TDE
/
libtdevnc
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/libtdevnc
0
0
Fork 0
Code Issues Releases Wiki Activity

fix cursor bug; missing keysym; fix align problem on SGI; clean up cursor.c

Browse Source 
clean up rfb.h a bit; endian issues
pull/1/head
dscho 23 years ago
parent cb3b9c7700
commit 94f04a8631
10 changed files with 1868 additions and 260 deletions
Show Stats Download Patch File Download Diff File

2
Makefile
Unescape View File

@ -28,6 +28,8 @@ OBJS=main.o rfbserver.o miregion.o auth.o sockets.o xalloc.o \
all: example pnmshow storepasswd
$(OBJS): rfb.h
install_OSX: OSXvnc-server
cp OSXvnc-server storepasswd ../OSXvnc/build/OSXvnc.app/Contents/MacOS

18
TODO
Unescape View File

@ -1,13 +1,27 @@
fix bug with odd width
immediate:
----------
fix bug with odd width (depends on client depth: width has to be multiple of server.bytesPerPixel/client.bytesPerPixel). only raw!!
fix bug in http (java) client with big endian server: byte swapping is broken
in the works:
-------------
adapt rdp2vnc (rdesktop)
dont draw rich cursors as xcursors
optionally dont draw rich cursors as xcursors
later:
------
udp
rfbCloseClient, rfbConnect, ConnectToTcpAddr
CORBA
translate.c: warning about non 8-bit colourmaps
set colourmap
documentation
done:
-----
.cursors
.cutpaste

99
cursor.c
Unescape View File

@ -22,53 +22,8 @@
* USA.
*/
#include <stdio.h>
#include "rfb.h"
/*
#include "mipointer.h"
#include "sprite.h"
#include "cursorstr.h"
#include "servermd.h"
*/
/* Copied from Xvnc/lib/font/util/utilbitmap.c */
static unsigned char _reverse_byte[0x100] = {
0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
};
/*
* Send cursor shape either in X-style format or in client pixel format.
*/
@ -98,12 +53,6 @@ rfbSendCursorShape(cl)
rect.encoding = Swap32IfLE(rfbEncodingXCursor);
}
/*{
rfbScreenInfoPtr s=cl->screen;
SetXCutTextProcPtr sx=cl->screen->setXCutText;
GetCursorProcPtr g=cl->screen->getCursorPtr;
}*/
/* If there is no cursor, send update with empty cursor data. */
if ( pCursor->width == 1 &&
@ -228,7 +177,43 @@ rfbSendCursorShape(cl)
return TRUE;
}
/* if you have a cursor in LSB order you have to convert it */
/* conversion routine for predefined cursors in LSB order */
static unsigned char _reverse_byte[0x100] = {
/* copied from Xvnc/lib/font/util/utilbitmap.c */
0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
};
void rfbConvertLSBCursorBitmapOrMask(int width,int height,unsigned char* bitmap)
{
int i,t=(width+7)/8*height;
@ -236,6 +221,8 @@ void rfbConvertLSBCursorBitmapOrMask(int width,int height,unsigned char* bitmap)
bitmap[i]=_reverse_byte[(int)bitmap[i]];
}
/* Cursor creation. You "paint" a cursor and let these routines do the work */
rfbCursorPtr rfbMakeXCursor(int width,int height,char* cursorString,char* maskString)
{
int i,j,w=(width+7)/8;
@ -347,6 +334,8 @@ void MakeRichCursorFromXCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor)
else memcpy(cp,back,bpp);
}
/* functions to draw/hide cursor directly in the frame buffer */
void rfbUndrawCursor(rfbClientPtr cl)
{
rfbScreenInfoPtr s=cl->screen;
@ -396,12 +385,12 @@ void rfbDrawCursor(rfbClientPtr cl)
x2=x1+c->width;
if(x1<0) { i1=-x1; x1=0; }
if(x2>=s->width) x2=s->width-1;
x2-=x1;
x2-=x1; if(x2<=0) return; /* nothing to do */
y1=s->cursorY-c->yhot;
y2=y1+c->height;
if(y1<0) { j1=-y1; y1=0; }
if(y2>=s->height) y2=s->height-1;
y2-=y1;
y2-=y1; if(y2<=0) return; /* nothing to do */
for(j=0;j<y2;j++)
memcpy(s->underCursorBuffer+j*x2*bpp,
s->frameBuffer+(y1+j)*rowstride+x1*bpp,
@ -421,6 +410,8 @@ void rfbDrawCursor(rfbClientPtr cl)
s->cursorIsDrawn = TRUE;
}
/* for debugging */
void rfbPrintXCursor(rfbCursorPtr cursor)
{
int i,i1,j,w=(cursor->width+7)/8;

110
example.c
Unescape View File

@ -30,7 +30,7 @@
#include "rfb.h"
#include "keysym.h"
const int maxx=640, maxy=480, bpp=4;
const int maxx=641, maxy=480, bpp=4;
/* TODO: odd maxx doesn't work */
/* This initializes a nice (?) background */
@ -40,9 +40,9 @@ void initBuffer(unsigned char* buffer)
int i,j;
for(i=0;i<maxx;++i)
for(j=0;j<maxy;++j) {
buffer[(j*maxx+i)*bpp+1]=(i+j)*128/(maxx+maxy); /* red */
buffer[(j*maxx+i)*bpp+2]=i*128/maxx; /* green */
buffer[(j*maxx+i)*bpp+3]=j*256/maxy; /* blue */
buffer[(j*maxx+i)*bpp+0]=(i+j)*128/(maxx+maxy); /* red */
buffer[(j*maxx+i)*bpp+1]=i*128/maxx; /* green */
buffer[(j*maxx+i)*bpp+2]=j*256/maxy; /* blue */
}
}
@ -65,6 +65,7 @@ void newclient(rfbClientPtr cl)
}
/* aux function to draw a line */
void drawline(unsigned char* buffer,int rowstride,int bpp,int x1,int y1,int x2,int y2)
{
int i,j;
@ -194,15 +195,15 @@ void dokey(Bool down,KeySym key,rfbClientPtr cl)
if(key==XK_Escape)
rfbCloseClient(cl);
else if(key==XK_Page_Up) {
//if(cl->screen->cursorIsDrawn)
//rfbUndrawCursor(cl);
if(cl->screen->cursorIsDrawn)
rfbUndrawCursor(cl);
initBuffer(cl->screen->frameBuffer);
rfbMarkRectAsModified(cl->screen,0,0,maxx,maxy);
} else if(key>=' ' && key<0x100) {
ClientData* cd=cl->clientData;
int x1=cd->oldx,y1=cd->oldy,x2,y2;
//if(cl->screen->cursorIsDrawn)
//rfbUndrawCursor(cl);
if(cl->screen->cursorIsDrawn)
rfbUndrawCursor(cl);
cd->oldx+=drawchar(cl->screen->frameBuffer,
cl->screen->paddedWidthInBytes,bpp,cd->oldx,cd->oldy,
key);
@ -212,10 +213,10 @@ void dokey(Bool down,KeySym key,rfbClientPtr cl)
}
}
/*
extern void rfbPrintXCursor(rfbCursorPtr cursor);
int exampleCursorWidth=9,exampleCursorHeight=7;
char exampleCursor[]=
/* Example for an XCursor (foreground/background only) */
int exampleXCursorWidth=9,exampleXCursorHeight=7;
char exampleXCursor[]=
" "
" xx xx "
" xx xx "
@ -223,12 +224,59 @@ char exampleCursor[]=
" xx xx "
" xx xx "
" ";
rfbCursorPtr exampleCurse;
rfbCursorPtr exampleGetCursor(rfbClientPtr cl)
/* Example for a rich cursor (full-colour) */
void MakeRichCursor(rfbScreenInfoPtr rfbScreen)
{
return(exampleCurse);
int i,j,w=32,h=32;
rfbCursorPtr c = rfbScreen->cursor;
char bitmap[]=
" "
" xxxxxx "
" xxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxx "
" xxxxxxxxxxxx "
" xxxxxxxxxxxx "
" xx xxxxxxxxxxx "
" xxx xxxxxxxxxxx "
" xxxx xxxxxxxxxxx "
" xxxxxx xxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxxxxxxxx "
" xxxxxxxxxxxxxxxx "
" ";
c=rfbScreen->cursor = rfbMakeXCursor(w,h,bitmap,0);
c->xhot = 2; c->yhot = 10;
c->richSource = malloc(w*h*bpp);
for(j=0;j<h;j++) {
for(i=0;i<w;i++) {
c->richSource[j*w*bpp+i*bpp+0]=0; //i*0xff/w;
c->richSource[j*w*bpp+i*bpp+1]=0;
c->richSource[j*w*bpp+i*bpp+2]=j*0xff/h;
c->richSource[j*w*bpp+i*bpp+3]=0;
}
}
}
*/
/* Initialization */
@ -247,30 +295,12 @@ int main(int argc,char** argv)
initBuffer(rfbScreen->frameBuffer);
drawstring(rfbScreen->frameBuffer,maxx*bpp,bpp,20,100,"Hello, World!");
//exampleCurse = rfbMakeXCursor(exampleCursorWidth,exampleCursorHeight,exampleCursor,0);
{
int i,j,w=32,h=32;
rfbCursorPtr c = rfbScreen->cursor;
char x[32*32],mask[32*32/8];
c=rfbScreen->cursor = rfbMakeXCursor(w,h,x,mask);
c->xhot = 2; c->yhot = 10;
c->mask[0]=0xff; c->mask[1]=0x0;
memset(c->mask,255,h*w/8);
c->richSource = malloc(w*h*bpp);
for(j=0;j<h;j++) {
for(i=0;i<w;i++) {
c->richSource[j*w*bpp+i*bpp+0]=0;
c->richSource[j*w*bpp+i*bpp+1]=0;
c->richSource[j*w*bpp+i*bpp+2]=j*0xff/h;
c->richSource[j*w*bpp+i*bpp+3]=0;
}
c->richSource[j*w*bpp+(w-1)*bpp+0]=0xff;
c->richSource[j*w*bpp+(w-1)*bpp+1]=0xff;
c->richSource[j*w*bpp+(w-1)*bpp+2]=0xff;
c->richSource[j*w*bpp+(w-1)*bpp+3]=0xff;
}
//memset(c->richSource,0xff,w*h*bpp);
}
/* This call creates a mask and then a cursor: */
/* rfbScreen->defaultCursor =
rfbMakeXCursor(exampleCursorWidth,exampleCursorHeight,exampleCursor,0);
*/
MakeRichCursor(rfbScreen);
/* this is the blocking event loop, i.e. it never returns */
/* 40000 are the microseconds, i.e. 0.04 seconds */

1631
keysym.h
View File

File diff suppressed because it is too large Load Diff

104
main.c
Unescape View File

@ -1,22 +1,13 @@
/*
* OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
* Original Xvnc code Copyright (C) 1999 AT&T Laboratories Cambridge.
* All Rights Reserved.
*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
* This file is called main.c, because it contains most of the new functions
* for use with LibVNCServer.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* LibVNCServer (C) 2001 Johannes E. Schindelin <Johannes.Schindelin@gmx.de>
* Original OSXvnc (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
* Original Xvnc (C) 1999 AT&T Laboratories Cambridge.
* All Rights Reserved.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
* USA.
* see GPL (latest version) for full details
*/
#include <stdio.h>
@ -273,9 +264,6 @@ processArguments(rfbScreenInfoPtr rfbScreen,int argc, char *argv[])
} else if (strcmp(argv[i], "-rfbauth") == 0) { /* -rfbauth passwd-file */
if (i + 1 >= argc) usage();
rfbScreen->rfbAuthPasswdFile = argv[++i];
} else if (strcmp(argv[i], "-deferupdate") == 0) { /* -deferupdate ms */
if (i + 1 >= argc) usage();
rfbScreen->rfbDeferUpdateTime = atoi(argv[++i]);
} else if (strcmp(argv[i], "-desktop") == 0) { /* -desktop desktop-name */
if (i + 1 >= argc) usage();
rfbScreen->desktopName = argv[++i];
@ -314,6 +302,8 @@ void defaultSetXCutText(char* text, int len, rfbClientPtr cl)
{
}
/* TODO: add a nice VNC or RFB cursor */
static rfbCursor myCursor =
{
//width: 8, height: 7, xhot: 3, yhot: 3,
@ -353,6 +343,8 @@ void doNothingWithClient(rfbClientPtr cl)
rfbScreenInfoPtr rfbDefaultScreenInit(int argc,char** argv,int width,int height,int bitsPerSample,int samplesPerPixel,int bytesPerPixel)
{
rfbScreenInfoPtr rfbScreen=malloc(sizeof(rfbScreenInfo));
rfbPixelFormat* format=&rfbScreen->rfbServerFormat;
rfbScreen->rfbPort=5900;
rfbScreen->socketInitDone=FALSE;
rfbScreen->inetdSock=-1;
@ -379,56 +371,44 @@ rfbScreenInfoPtr rfbDefaultScreenInit(int argc,char** argv,int width,int height,
rfbScreen->bitsPerPixel = rfbScreen->depth = 8*bytesPerPixel;
gethostname(rfbScreen->rfbThisHost, 255);
rfbScreen->paddedWidthInBytes = width*bytesPerPixel;
rfbScreen->rfbServerFormat.bitsPerPixel = rfbScreen->bitsPerPixel;
rfbScreen->rfbServerFormat.depth = rfbScreen->depth;
rfbScreen->rfbServerFormat.bigEndian = !(*(char *)&rfbEndianTest);
rfbScreen->rfbServerFormat.trueColour = TRUE;
/* Why? (TODO)
if (samplesPerPixel != 3) {
rfbLog("screen format not supported. exiting.\n");
exit(1);
/* format */
format->bitsPerPixel = rfbScreen->bitsPerPixel;
format->depth = rfbScreen->depth;
format->bigEndian = rfbEndianTest?FALSE:TRUE;
format->trueColour = TRUE;
if(bytesPerPixel == 8) {
format->redMax = 7;
format->greenMax = 7;
format->blueMax = 3;
format->redShift = 0;
format->greenShift = 3;
format->blueShift = 6;
} else {
format->redMax = (1 << bitsPerSample) - 1;
format->greenMax = (1 << bitsPerSample) - 1;
format->blueMax = (1 << bitsPerSample) - 1;
if(rfbEndianTest) {
format->redShift = 0;
format->greenShift = bitsPerSample;
format->blueShift = bitsPerSample * 2;
} else {
format->redShift = bitsPerSample*3;
format->greenShift = bitsPerSample*2;
format->blueShift = bitsPerSample;
}
}
*/
/* This works for 16 and 32-bit, but not for 8-bit.
What should it be for 8-bit? (Shouldn't 8-bit use a colormap?) */
rfbScreen->rfbServerFormat.redMax = (1 << bitsPerSample) - 1;
rfbScreen->rfbServerFormat.greenMax = (1 << bitsPerSample) - 1;
rfbScreen->rfbServerFormat.blueMax = (1 << bitsPerSample) - 1;
rfbScreen->rfbServerFormat.redShift = bitsPerSample * 2;
rfbScreen->rfbServerFormat.greenShift = bitsPerSample;
rfbScreen->rfbServerFormat.blueShift = 0;
/* cursor */
rfbScreen->cursorIsDrawn = FALSE;
rfbScreen->dontSendFramebufferUpdate = FALSE;
rfbScreen->cursorX=rfbScreen->cursorY=rfbScreen->underCursorBufferLen=0;
rfbScreen->underCursorBuffer=NULL;
/* We want to use the X11 REGION_* macros without having an actual
X11 ScreenPtr, so we do this. Pretty ugly, but at least it lets us
avoid hacking up regionstr.h, or changing every call to REGION_*
(which actually I should probably do eventually). */
/*
rfbScreen->screen.RegionCreate = miRegionCreate;
rfbScreen->screen.RegionInit = miRegionInit;
rfbScreen->screen.RegionCopy = miRegionCopy;
rfbScreen->screen.RegionDestroy = miRegionDestroy;
rfbScreen->screen.RegionUninit = miRegionUninit;
rfbScreen->screen.Intersect = miIntersect;
rfbScreen->screen.Union = miUnion;
rfbScreen->screen.Subtract = miSubtract;
rfbScreen->screen.Inverse = miInverse;
rfbScreen->screen.RegionReset = miRegionReset;
rfbScreen->screen.TranslateRegion = miTranslateRegion;
rfbScreen->screen.RectIn = miRectIn;
rfbScreen->screen.PointInRegion = miPointInRegion;
rfbScreen->screen.RegionNotEmpty = miRegionNotEmpty;
rfbScreen->screen.RegionEmpty = miRegionEmpty;
rfbScreen->screen.RegionExtents = miRegionExtents;
rfbScreen->screen.RegionAppend = miRegionAppend;
rfbScreen->screen.RegionValidate = miRegionValidate;
*/
/* proc's and hook's */
rfbScreen->kbdAddEvent = defaultKbdAddEvent;
rfbScreen->kbdReleaseAllKeys = doNothingWithClient;

14
pnmshow.c
Unescape View File

@ -48,6 +48,9 @@ int main(int argc,char** argv)
rfbScreen->rfbAlwaysShared = TRUE;
rfbScreen->kbdAddEvent = HandleKey;
/* enable http */
rfbScreen->httpDir = "./classes";
/* allocate picture and read it */
rfbScreen->frameBuffer = (char*)malloc(width*height*4);
fread(rfbScreen->frameBuffer,width*3,height,in);
@ -55,16 +58,9 @@ int main(int argc,char** argv)
/* correct the format to 4 bytes instead of 3 */
for(i=width*height-1;i>=0;i--) {
rfbScreen->frameBuffer[i*4+2]=rfbScreen->frameBuffer[i*3+0];
rfbScreen->frameBuffer[i*4+2]=rfbScreen->frameBuffer[i*3+2];
rfbScreen->frameBuffer[i*4+1]=rfbScreen->frameBuffer[i*3+1];
rfbScreen->frameBuffer[i*4+0]=rfbScreen->frameBuffer[i*3+2];
}
for(i=0;i<200;i++) {
rfbScreen->frameBuffer[i*4+i*width*4]=0;
rfbScreen->frameBuffer[i*4+i*width*4+1]=0;
rfbScreen->frameBuffer[i*4+i*width*4+2]=0;
rfbScreen->frameBuffer[i*4+i*width*4+3]=0;
rfbScreen->frameBuffer[i*4+0]=rfbScreen->frameBuffer[i*3+0];
}
/* run event loop */

71
region.h
Unescape View File

@ -1,43 +1,14 @@
/*#define KeySym ___KeySym
#define Bool ___Bool
#define _Box ___Box
#define BoxRec ___BoxRec
#define _RegData ___RegData
#define RegDataRec ___RegDataRec
#define RegDataPtr ___RegDataPtr
#define _Region ___Region
#define RegionRec ___RegionRec
#define RegionPtr ___RegionPtr
#define CARD8 ___CARD8
#define CARD16 ___CARD16
#define CARD32 ___CARD32
#include "X11/Xalloca.h"
#include "Xserver/regionstr.h"
#undef KeySym
#undef Bool
#undef _Box
#undef BoxRec
#undef _RegData
#undef RegDataRec
#undef RegDataPtr
#undef _Region
#undef RegionRec
#undef RegionPtr
#undef CARD8
#undef CARD16
#undef CARD32
#ifndef REGION_H
#define REGION_H
#undef REGION_INTERSECT
#undef REGION_UNION
#undef REGION_SUBTRACT
#undef REGION_TRANSLATE
#undef REGION_INIT
#undef REGION_UNINIT
#undef REGION_EMPTY
#undef REGION_NOTEMPTY
#undef FALSE
#undef TRUE
*/
#define NullRegion ((RegionPtr)0)
#define NullBox ((BoxPtr)0)
typedef struct RegDataRec {
long size;
long numRects;
/* BoxRec rects[size]; in memory but not explicitly declared */
} RegDataRec;
extern void miRegionInit(RegionPtr,BoxPtr,int);
extern void miRegionUninit(RegionPtr);
@ -47,3 +18,25 @@ extern Bool miIntersect(RegionPtr,RegionPtr,RegionPtr);
extern Bool miSubtract(RegionPtr,RegionPtr,RegionPtr);
extern Bool miUnion(RegionPtr,RegionPtr,RegionPtr);
extern void miTranslateRegion(RegionPtr,int,int);
#define REGION_NIL(reg) ((reg)->data && !(reg)->data->numRects)
#define REGION_NUM_RECTS(reg) ((reg)->data ? (reg)->data->numRects : 1)
#define REGION_SIZE(reg) ((reg)->data ? (reg)->data->size : 0)
#define REGION_RECTS(reg) ((reg)->data ? (BoxPtr)((reg)->data + 1) \
: &(reg)->extents)
#define REGION_BOXPTR(reg) ((BoxPtr)((reg)->data + 1))
#define REGION_BOX(reg,i) (&REGION_BOXPTR(reg)[i])
#define REGION_TOP(reg) REGION_BOX(reg, (reg)->data->numRects)
#define REGION_END(reg) REGION_BOX(reg, (reg)->data->numRects - 1)
#define REGION_SZOF(n) (sizeof(RegDataRec) + ((n) * sizeof(BoxRec)))
#define REGION_INIT(s,pReg,rect,size) miRegionInit(pReg,rect,size)
#define REGION_EMPTY(s,pReg) miRegionEmpty(pReg)
#define REGION_UNINIT(s,pReg) miRegionUninit(pReg)
#define REGION_NOTEMPTY(s,pReg) miRegionNotEmpty(pReg)
#define REGION_INTERSECT(s,newReg,reg1,reg2) miIntersect(newReg,reg1,reg2)
#define REGION_SUBTRACT(s,newReg,reg1,reg2) miSubtract(newReg,reg1,reg2)
#define REGION_UNION(s,newReg,reg1,reg2) miUnion(newReg,reg1,reg2)
#define REGION_TRANSLATE(s,pReg,x,y) miTranslateRegion(pReg,x,y)
#endif

69
rfb.h
Unescape View File

@ -23,64 +23,22 @@
* USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include "scrnintstr.h"
#include "keysym.h"
/* trying to replace the above with some more minimal set of includes */
//#include "misc.h"
//#include "Xmd.h"
/* TODO: this stuff has to go into autoconf */
typedef unsigned char CARD8;
typedef unsigned short CARD16;
typedef unsigned int CARD32;
typedef CARD32 Pixel;
typedef CARD32 KeySym;
typedef signed char Bool;
/* for some strange reason, "typedef signed char Bool;" yields a four byte
signed int on an SGI, but only for rfbserver.o!!! */
#define Bool signed char
#define FALSE 0
#define TRUE -1
#include "keysym.h"
/* region stuff */
#define NullRegion ((RegionPtr)0)
#define NullBox ((BoxPtr)0)
typedef struct _Box {
short x1, y1, x2, y2;
} BoxRec, *BoxPtr;
typedef struct _RegData {
long size;
long numRects;
/* BoxRec rects[size]; in memory but not explicitly declared */
} RegDataRec, *RegDataPtr;
typedef struct _Region {
BoxRec extents;
RegDataPtr data;
} RegionRec, *RegionPtr;
#define REGION_NIL(reg) ((reg)->data && !(reg)->data->numRects)
#define REGION_NUM_RECTS(reg) ((reg)->data ? (reg)->data->numRects : 1)
#define REGION_SIZE(reg) ((reg)->data ? (reg)->data->size : 0)
#define REGION_RECTS(reg) ((reg)->data ? (BoxPtr)((reg)->data + 1) \
: &(reg)->extents)
#define REGION_BOXPTR(reg) ((BoxPtr)((reg)->data + 1))
#define REGION_BOX(reg,i) (&REGION_BOXPTR(reg)[i])
#define REGION_TOP(reg) REGION_BOX(reg, (reg)->data->numRects)
#define REGION_END(reg) REGION_BOX(reg, (reg)->data->numRects - 1)
#define REGION_SZOF(n) (sizeof(RegDataRec) + ((n) * sizeof(BoxRec)))
#define REGION_INIT(s,pReg,rect,size) miRegionInit(pReg,rect,size)
#define REGION_EMPTY(s,pReg) miRegionEmpty(pReg)
#define REGION_UNINIT(s,pReg) miRegionUninit(pReg)
#define REGION_NOTEMPTY(s,pReg) miRegionNotEmpty(pReg)
#define REGION_INTERSECT(s,newReg,reg1,reg2) miIntersect(newReg,reg1,reg2)
#define REGION_SUBTRACT(s,newReg,reg1,reg2) miSubtract(newReg,reg1,reg2)
#define REGION_UNION(s,newReg,reg1,reg2) miUnion(newReg,reg1,reg2)
#define REGION_TRANSLATE(s,pReg,x,y) miTranslateRegion(pReg,x,y)
//#include "regionstr.h"
#define xalloc malloc
#define xrealloc realloc
@ -266,6 +224,19 @@ typedef void (*rfbTranslateFnType)(char *table, rfbPixelFormat *in,
int width, int height);
/* region stuff */
typedef struct BoxRec {
short x1, y1, x2, y2;
} BoxRec, *BoxPtr;
typedef struct RegDataRec* RegDataPtr;
typedef struct RegionRec {
BoxRec extents;
RegDataPtr data;
} RegionRec, *RegionPtr;
/*
* Per-client structure.
*/
@ -457,9 +428,9 @@ typedef struct rfbClientRec {
static const int rfbEndianTest = (_BYTE_ORDER == _LITTLE_ENDIAN);
#define Swap16IfLE(s) (*(const char *)&rfbEndianTest ? Swap16(s) : (s))
#define Swap16IfLE(s) (rfbEndianTest ? Swap16(s) : (s))
#define Swap32IfLE(l) (*(const char *)&rfbEndianTest ? Swap32(l) : (l))
#define Swap32IfLE(l) (rfbEndianTest ? Swap32(l) : (l))
/* main.c */

10
rfbserver.c
Unescape View File

@ -25,6 +25,8 @@
#include <stdio.h>
#include <stdlib.h>
#include "rfb.h"
#include "region.h"
#include <unistd.h>
#include <pwd.h>
#include <sys/types.h>
@ -34,8 +36,6 @@
#ifdef HAVE_PTHREADS
#include <pthread.h>
#endif
#include "rfb.h"
#include "region.h"
rfbClientPtr pointerClient = NULL; /* Mutex for pointer events */
@ -273,7 +273,7 @@ rfbClientConnectionGone(cl)
free(cl->host);
/* Release the compression state structures if any. */
if ( cl->compStreamInited == TRUE ) {
if ( cl->compStreamInited ) {
deflateEnd( &(cl->compStream) );
}
@ -523,8 +523,8 @@ rfbProcessClientNormalMessage(cl)
cl->format.bitsPerPixel = msg.spf.format.bitsPerPixel;
cl->format.depth = msg.spf.format.depth;
cl->format.bigEndian = (msg.spf.format.bigEndian ? 1 : 0);
cl->format.trueColour = (msg.spf.format.trueColour ? 1 : 0);
cl->format.bigEndian = (msg.spf.format.bigEndian ? TRUE : FALSE);
cl->format.trueColour = (msg.spf.format.trueColour ? TRUE : FALSE);
cl->format.redMax = Swap16IfLE(msg.spf.format.redMax);
cl->format.greenMax = Swap16IfLE(msg.spf.format.greenMax);
cl->format.blueMax = Swap16IfLE(msg.spf.format.blueMax);

Write Preview
Loading…
Cancel
Save