int main(int argc, char **argv)
{
if(argc > 1)
{
int i=1;
while(i < argc)
{
if(*argv[i] == '-')
{
switch(*(argv[i] + 1))
{
case 'h':
print_usage(argv);
exit(0);
break;
case 'k':
i++;
strcpy(KBD_DEVICE, argv[i]);
break;
case 't':
i++;
strcpy(TOUCH_DEVICE, argv[i]);
break;
}
}
i++;
}
}
printf("Initializing framebuffer device " FB_DEVICE "...\n");
init_fb();
/* printf("Initializing keyboard device %s ...\n", KBD_DEVICE);
init_kbd();
printf("Initializing touch device %s ...\n", TOUCH_DEVICE);
init_touch();
*/
printf("Initializing VNC server:\n");
printf(" width: %d\n", (int)scrinfo.xres);
printf(" height: %d\n", (int)scrinfo.yres);
printf(" bpp: %d\n", (int)scrinfo.bits_per_pixel);
printf(" port: %d\n", (int)VNC_PORT);
init_fb_server(argc, argv);
/* Implement our own event loop to detect changes in the framebuffer. */
while (1)
{
while (vncscr->clientHead == NULL)
rfbProcessEvents(vncscr, 100000);
rfbProcessEvents(vncscr, 100000);
update_screen();
}
printf("Cleaning up...\n");
cleanup_fb();
/* cleanup_kdb();
cleanup_touch();*/
}
int main(int argc,char** argv)
{
rfbFontDataPtr font;
rfbScreenInfoPtr s=rfbGetScreen(&argc,argv,640,480,8,3,3);
int i,j;
s->frameBuffer=(char*)malloc(640*480*3);
rfbInitServer(s);
for(j=0;j<480;j++)
for(i=0;i<640;i++) {
s->frameBuffer[(j*640+i)*3+0]=j*256/480;
s->frameBuffer[(j*640+i)*3+1]=i*256/640;
s->frameBuffer[(j*640+i)*3+2]=(i+j)*256/(480+640);
}
rfbScreen = s;
font=rfbLoadConsoleFont(DEFAULTFONT);
if(!font) {
rfbErr("Couldn't find %s\n",DEFAULTFONT);
exit(1);
}
for(j=0;j<0 && rfbIsActive(s);j++)
rfbProcessEvents(s,900000);
i = rfbSelectBox(s,font,fontlist,10,20,200,300,0xffdfdf,0x602040,2,showFont);
rfbLog("Selection: %d: %s\n",i,(i>=0)?fontlist[i]:"cancelled");
rfbFreeFont(font);
free(s->frameBuffer);
rfbScreenCleanup(s);
return(0);
}
int main(int argc,char** argv)
{
int width=400,height=300,w=20,x,y;
double r,phi=0;
rfbScreenInfoPtr server=rfbGetScreen(&argc,argv,width,height,8,3,4);
server->frameBuffer=(char*)malloc(width*height*4);
initBackground(server);
server->deferUpdateTime=0;
rfbInitServer(server);
r=0;
while(1) {
if(r<=0) {
initBackground(server);
rfbMarkRectAsModified(server,0,0,width,height);
r=0.43;
phi=0;
} else {
r-=0.0001;
phi+=0.02;
if(phi>2*M_PI)
phi-=2*M_PI;
}
x=width*(0.5+cos(phi)*r);
y=height*(0.5+sin(phi)*r);
if(x>=0 && y>=0 && x+w<=width && y+w<=height) {
unsigned int dx=width*0.5*(1-cos(phi)*r)-x,
dy=height*0.5*(1-sin(phi)*r)-y;
rfbDoCopyRect(server,x,y,x+w,y+w,-dx,-dy);
}
rfbProcessEvents(server,50000);
}
return(0);
}
bool PresentationServer::run() {
const long RFB_PROCESS_EVENTS_TIMEOUT_USEC = 20000;
//Server tot oder kein Client mehr da?
if (!_server || _server->clientHead == 0)
return false;
//Server runtergefahren?
if (!rfbIsActive(_server))
return false;
if (_capture) {
//5 Bilder / Sekunde machen
if (std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - _tick).count() > (1000 / _fps)) {
_capture->capture(_server);
_tick = std::chrono::high_resolution_clock::now();
}
}
rfbProcessEvents(_server, RFB_PROCESS_EVENTS_TIMEOUT_USEC);
// Soll die Präsentation
if (_useTimeOfDeath) {
if (std::chrono::system_clock::now() > _timeOfDeath)
return false;
}
return true; //Weitermachen
}
void LibVNCServer::processEvents()
{
//TODO: Find a good timeout
rfbProcessEvents( m_screenInfo, 1 );
QWSServer::instance()->enablePainting( isConnected() );
}
/*
* Single-threaded application that interleaves client servicing with taking
* pictures from the camera. This way, we do not update the framebuffer
* while an encoding is working on it too (banding, and image artifacts).
*/
int main(int argc,char** argv)
{
long usec;
rfbScreenInfoPtr server=rfbGetScreen(&argc,argv,WIDTH,HEIGHT,8,3,BPP);
if(!server)
return 0;
server->desktopName = "Live Video Feed Example";
server->frameBuffer=(char*)malloc(WIDTH*HEIGHT*BPP);
server->alwaysShared=(1==1);
/* Initialize the server */
rfbInitServer(server);
/* Loop, processing clients and taking pictures */
while (rfbIsActive(server)) {
if (TimeToTakePicture())
if (TakePicture((unsigned char *)server->frameBuffer))
rfbMarkRectAsModified(server,0,0,WIDTH,HEIGHT);
usec = server->deferUpdateTime*1000;
rfbProcessEvents(server,usec);
}
return(0);
}
int main(int argc,char** argv)
{
rfbScreenInfoPtr rfbScreen =
rfbGetScreen(&argc,argv,maxx,maxy,8,3,bpp);
rfbScreen->desktopName = "LibVNCServer Example";
rfbScreen->frameBuffer = (char*)malloc(maxx*maxy*bpp);
rfbScreen->alwaysShared = TRUE;
rfbScreen->ptrAddEvent = doptr;
rfbScreen->kbdAddEvent = dokey;
rfbScreen->newClientHook = newclient;
rfbScreen->httpDir = "../classes";
rfbScreen->httpEnableProxyConnect = TRUE;
initBuffer((unsigned char*)rfbScreen->frameBuffer);
rfbDrawString(rfbScreen,&radonFont,20,100,"Hello, World!",0xffffff);
/* This call creates a mask and then a cursor: */
/* rfbScreen->defaultCursor =
rfbMakeXCursor(exampleCursorWidth,exampleCursorHeight,exampleCursor,0);
*/
MakeRichCursor(rfbScreen);
/* initialize the server */
rfbInitServer(rfbScreen);
#ifndef BACKGROUND_LOOP_TEST
#ifdef USE_OWN_LOOP
{
int i;
for(i=0;rfbIsActive(rfbScreen);i++) {
fprintf(stderr,"%d\r",i);
rfbProcessEvents(rfbScreen,100000);
}
}
#else
/* this is the blocking event loop, i.e. it never returns */
/* 40000 are the microseconds to wait on select(), i.e. 0.04 seconds */
rfbRunEventLoop(rfbScreen,40000,FALSE);
#endif /* OWN LOOP */
#else
#if !defined(LIBVNCSERVER_HAVE_LIBPTHREAD)
#error "I need pthreads for that."
#endif
/* this is the non-blocking event loop; a background thread is started */
rfbRunEventLoop(rfbScreen,-1,TRUE);
/* now we could do some cool things like rendering in idle time */
while(1) sleep(5); /* render(); */
#endif /* BACKGROUND_LOOP */
free(rfbScreen->frameBuffer);
rfbScreenCleanup(rfbScreen);
return(0);
}
/*
* utility wrapper to call rfbProcessEvents
* checks that we are not in threaded mode.
*/
#define USEC_MAX 999999 /* libvncsever assumes < 1 second */
void rfbPE(long usec) {
if (! screen) {
return;
}
if (usec > USEC_MAX) {
usec = USEC_MAX;
}
if (! use_threads) {
rfbProcessEvents(screen, usec);
}
}
void rfbRunEventLoop(rfbScreenInfoPtr rfbScreen, long usec, rfbBool runInBackground)
{
if(runInBackground) {
rfbErr("Can't run in background, because I don't have PThreads!\n");
return;
}
if(usec<0)
usec=rfbScreen->rfbDeferUpdateTime*1000;
while(1)
rfbProcessEvents(rfbScreen,usec);
}
void vncserver::thread_func()
{
uint8_t color = 0;
ready = true;
std::cout << "Starting VNC thread..." << std::endl;
while(ready)
{
rfbProcessEvents(rfbScreen, 0);
usleep(100000);
}
}
/*
* utility wrapper to call rfbProcessEvents
* checks that we are not in threaded mode.
*/
#define USEC_MAX 999999 /* libvncsever assumes < 1 second */
void rfbPE(long usec) {
int uip0 = unixpw_in_progress;
static int check_rate = -1;
if (! screen) {
return;
}
if (unixpw && unixpw_in_progress && !unixpw_in_rfbPE) {
rfbLog("unixpw_in_rfbPE: skipping rfbPE\n");
return;
}
if (debug_tiles > 2) {
double tm = dnow();
fprintf(stderr, "rfbPE(%d) t: %.4f\n",
(int) usec, tm - x11vnc_start);
}
if (usec > USEC_MAX) {
usec = USEC_MAX;
}
if (! use_threads) {
rfbProcessEvents(screen, usec);
}
if (unixpw && unixpw_in_progress && !uip0) {
if (!unixpw_in_rfbPE) {
rfbLog("rfbPE: got new client in non-rfbPE\n");
; /* this is new unixpw client */
}
}
if (check_rate != 0) {
if (check_rate < 0) {
if (getenv("CHECK_RATE")) {
check_rate = 1;
} else {
check_rate = 0;
}
}
if (check_rate && !all_input && x11vnc_current < last_client + 45) {
check_allinput_rate();
}
}
if (all_input) {
do_allinput(usec);
}
}
int main()
{
int rfbargc = 0;
char **rfbargv = 0;
int bpp = 4;
rfbScreenInfoPtr server = rfbGetScreen(&rfbargc, rfbargv, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT, 8, 3, bpp);
fb = new unsigned char[FRAMEBUFFER_WIDTH * FRAMEBUFFER_HEIGHT * bpp];
server->frameBuffer = (char *)fb;
server->kbdAddEvent = handleKey;
server->ptrAddEvent = handlePointer;
rfbInitServer(server);
touchscreen_init();
while(!quit) {
int x, y;
float z;
TouchscreenEvent e;
while((e = touchscreen_read(&x, &y, &z)) != TOUCHSCREEN_IDLE) {
switch(e) {
case TOUCHSCREEN_START:
printf("start %d %d %f\n", x, y, z);
draw_new_circle(server, x, y, z / 16.0);
break;
case TOUCHSCREEN_DRAG:
printf("drag %d %d %f\n", x, y, z);
draw_new_circle(server, x, y, z / 16.0);
break;
case TOUCHSCREEN_STOP:
printf("stop\n");
break;
case TOUCHSCREEN_IDLE:
default:
break;
}
}
// usleep(100000);
rfbProcessEvents(server, 10000);
}
}
static void* vnc_thread(void* args)
{
int i = 0;
int argc = 1;
int width = g_vnc_context.width;
int height = g_vnc_context.height;
char* argv[5] = {"FTKVNC", NULL};
rfbScreenInfoPtr rfbScreen = NULL;
ftk_logd("%s: vnc thread start.\n", __func__);
rfbScreen = rfbGetScreen(&argc, argv, width, height, 8, 4, 4);
rfbScreen->desktopName = "FTK VNC";
rfbScreen->alwaysShared = 0;
rfbScreen->frameBuffer = g_vnc_context.vnc_buffer;
rfbScreen->ptrAddEvent = on_pointer_event;
rfbScreen->kbdAddEvent = on_key_event;
rfbScreen->newClientHook = on_new_client;
rfbScreen->deferUpdateTime = 100;
rfbInitServer(rfbScreen);
g_vnc_context.rfbScreen = rfbScreen;
for(i=0; !g_vnc_context.quit && rfbIsActive(rfbScreen); i++)
{
if(g_vnc_context.client_nr > 0 && g_vnc_context.active)
{
if((i % 10) == 0)
{
rfbMarkRectAsModified(g_vnc_context.rfbScreen, 0, 0, width, height);
}
}
else
{
sleep(1);
}
rfbProcessEvents(rfbScreen, 200000);
}
ftk_logd("%s: vnc thread quit.\n", __func__);
rfbScreenCleanup(rfbScreen);
return NULL;
}
int main(int argc,char **argv)
{
rfbScreenInfoPtr s;
double t1, t2;
double timeout;
int nread;
if (argc == 2)
v4l2str = argv[1];
printf("Using dev %s\n", v4l2str);
if (argc == 3)
v4l2fps = atoi(argv[2]);
printf("Using fps %d\n", v4l2fps);
if (open_v4l2() != 0)
exit(EXIT_FAILURE);
if (init_v4l2() != 0)
exit(EXIT_FAILURE);
if (alloc_mem() != 0)
exit(EXIT_FAILURE);
s = rfbGetScreen(&argc, argv, v4l2width, v4l2height, 8, 3, v4l2Bpp);
s->desktopName = "v4l2tovnc";
s->frameBuffer = (char *) v4l2buf;
s->serverFormat.blueShift = 0;
s->serverFormat.greenShift = 8;
s->serverFormat.redShift = 16;
timeout = 1.0 / v4l2fps;
rfbInitServer(s);
t1 = timestamp();
while (rfbIsActive(s)) {
t2 = timestamp();
if ((t2 - t1) >= timeout) {
nread = read_frame();
if (nread < 0)
break;
rfbMarkRectAsModified(s, 0, 0, v4l2width, v4l2height);
t1 = timestamp();
}
rfbProcessEvents(s, -1);
}
close_v4l2();
return 0;
}
int main(int argc,char** argv)
{
rfbScreenInfoPtr s=rfbGetScreen(&argc,argv,width,height,8,1,1);
s->colourMap.is16=FALSE;
s->colourMap.count=2;
s->colourMap.data.bytes=(unsigned char*)"\xd0\xd0\xd0\x30\x01\xe0";
s->serverFormat.trueColour=FALSE;
s->frameBuffer=f;
s->kbdAddEvent=dokey;
s->ptrAddEvent=doptr;
s->newClientHook=newclient;
memset(f,0,width*height);
read_keys();
rfbInitServer(s);
while(1) {
rfbProcessEvents(s,999999);
}
}
void rfbRunEventLoop(rfbScreenInfoPtr rfbScreen, long usec, Bool runInBackground)
{
if(runInBackground) {
#ifdef HAVE_PTHREADS
rfbScreen->backgroundLoop = TRUE;
pthread_create(&rfbScreen->listener_thread, NULL, listenerRun, rfbScreen);
return;
#else
fprintf(stderr,"Can't run in background, because I don't have PThreads!\n");
exit(-1);
#endif
}
if(usec<0)
usec=rfbScreen->rfbDeferUpdateTime*1000;
while(1)
rfbProcessEvents(rfbScreen,usec);
}
void rfbRunEventLoop(rfbScreenInfoPtr screen, long usec, rfbBool runInBackground)
{
if(runInBackground) {
#ifdef LIBVNCSERVER_HAVE_LIBPTHREAD
pthread_t listener_thread;
screen->backgroundLoop = TRUE;
pthread_create(&listener_thread, NULL, listenerRun, screen);
return;
#else
rfbErr("Can't run in background, because I don't have PThreads!\n");
return;
#endif
}
if(usec<0)
usec=screen->deferUpdateTime*1000;
while(rfbIsActive(screen))
rfbProcessEvents(screen,usec);
}
/*
* utility wrapper to call rfbProcessEvents
* checks that we are not in threaded mode.
*/
#define USEC_MAX 999999 /* libvncsever assumes < 1 second */
void rfbPE(long usec) {
int uip0 = unixpw_in_progress;
if (! screen) {
return;
}
if (unixpw && unixpw_in_progress && !unixpw_in_rfbPE) {
rfbLog("unixpw_in_rfbPE: skipping rfbPE\n");
return;
}
if (usec > USEC_MAX) {
usec = USEC_MAX;
}
if (! use_threads) {
rfbProcessEvents(screen, usec);
}
if (unixpw && unixpw_in_progress && !uip0) {
if (!unixpw_in_rfbPE) {
rfbLog("rfbPE: got new client in non-rfbPE\n");
; /* this is new unixpw client */
}
}
}
int main(int argc, char **argv)
{
//pipe signals
signal(SIGINT, close_app);
signal(SIGKILL, close_app);
signal(SIGILL, close_app);
long usec;
if(argc > 1) {
int i=1;
int r;
while(i < argc) {
if(*argv[i] == '-') {
switch(*(argv[i] + 1)) {
case 'h':
printUsage(argv);
exit(0);
break;
case 'p':
i++;
strcpy(VNC_PASSWORD,argv[i]);
break;
case 'f':
i++;
FB_setDevice(argv[i]);
break;
case 'z':
i++;
display_rotate_180=1;
break;
case 'P':
i++;
VNC_PORT=atoi(argv[i]);
break;
case 'r':
i++;
r = atoi(argv[i]);
if (r==0 || r==90 || r==180 || r==270)
rotation = r;
L("rotating to %d degrees\n",rotation);
break;
case 's':
i++;
r=atoi(argv[i]);
if (r >= 1 && r <= 150)
scaling = r;
else
scaling = 100;
L("scaling to %d%%\n",scaling);
break;
case 'R':
i++;
extractReverseHostPort(argv[i]);
break;
case 'm':
i++;
if (!strcmp(argv[i],"adb")){
method = ADB;
L("ADB display grabber selected\n");
} else if (!strcmp(argv[i],"fb")) {
method = FRAMEBUFFER;
L("Framebuffer display grabber selected\n");
} else if (!strcmp(argv[i],"gralloc")) {
method = GRALLOC;
L("Gralloc display grabber selected\n");
} else if (!strcmp(argv[i],"flinger")) {
method = FLINGER;
L("Flinger display grabber selected\n");
} else {
L("Grab method \"%s\" not found, sticking with auto-detection.\n",argv[i]);
}
break;
}
}
i++;
}
}
L("Initializing grabber method...\n");
initGrabberMethod();
L("Initializing virtual keyboard and touch device...\n");
initInput();
L("Initializing VNC server:\n");
L(" width: %d\n", (int)screenformat.width);
L(" height: %d\n", (int)screenformat.height);
L(" bpp: %d\n", (int)screenformat.bitsPerPixel);
L(" port: %d\n", (int)VNC_PORT);
L("Colourmap_rgba=%d:%d:%d:%d lenght=%d:%d:%d:%d\n", screenformat.redShift, screenformat.greenShift, screenformat.blueShift,screenformat.alphaShift,
screenformat.redMax,screenformat.greenMax,screenformat.blueMax,screenformat.alphaMax);
initVncServer(argc, argv);
bindIPCserver();
sendServerStarted();
if (rhost) {
rfbClientPtr cl;
cl = rfbReverseConnection(vncscr, rhost, rport);
if (cl == NULL) {
char *str=malloc(255*sizeof(char));
sprintf(str,"~SHOW|Couldn't connect to remote host:\n%s\n",rhost);
L("Couldn't connect to remote host: %s\n",rhost);
sendMsgToGui(str);
free(str);
} else {
cl->onHold = FALSE;
rfbStartOnHoldClient(cl);
}
}
while (1) {
usec=(vncscr->deferUpdateTime+standby)*1000;
//clock_t start = clock();
rfbProcessEvents(vncscr,usec);
if (idle)
standby+=2;
else
standby=2;
if (vncscr->clientHead == NULL)
{
idle=1;
standby=50;
continue;
}
update_screen();
//printf ( "%f\n", ( (double)clock() - start )*1000 / CLOCKS_PER_SEC );
}
close_app();
}
int main()
{
int rfbargc = 0;
char **rfbargv = 0;
int bpp = 4;
rfbScreenInfoPtr server = rfbGetScreen(&rfbargc, rfbargv, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT, 8, 3, bpp);
fb = new unsigned char[FRAMEBUFFER_WIDTH * FRAMEBUFFER_HEIGHT * bpp];
server->frameBuffer = (char *)fb;
server->kbdAddEvent = handleKey;
server->ptrAddEvent = handlePointer;
rfbInitServer(server);
int file;
file = open(devname, O_RDWR);
if (file < 0) {
perror("open");
exit(EXIT_FAILURE);
}
int addr = ADXL345_ADDRESS; /* The I2C address */
if (ioctl(file, I2C_SLAVE, addr) < 0) {
perror("ioctl");
exit(EXIT_FAILURE);
}
uint16_t id = read_u16(file, 0x00);
printf("id is 0x%04X\n", id);
ADXL345_init(file);
int tilt_was_valid = false;
while(1) {
int16_t xdata = read_u16_le(file, ADXL345_DATAX0);
int16_t ydata = read_u16_le(file, ADXL345_DATAY0);
int16_t zdata = read_u16_le(file, ADXL345_DATAZ0);
float xg = xdata / 256.0;
float yg = ydata / 256.0;
float zg = zdata / 256.0;
float theta_y = -atan2(yg, zg);
float theta_x = atan2(xg, zg);
float y_angle_center = 40.0 / 180.0 * M_PI;
float y_angle_range = 25.0 / 180.0 * M_PI;
float x_angle_center = 0.0 / 180.0 * M_PI;
float x_angle_range = 25.0 / 180.0 * M_PI;
int tilt_is_valid =
(theta_y > y_angle_center - y_angle_range) &&
(theta_y < y_angle_center + y_angle_range) &&
(theta_x > x_angle_center - x_angle_range) &&
(theta_x < x_angle_center + x_angle_range);
if(tilt_is_valid != tilt_was_valid) {
if(tilt_is_valid)
printf("TILT_VALID\n");
else
printf("TILT_INVALID\n");
tilt_was_valid = tilt_is_valid;
}
if(tilt_is_valid) {
float tilt_x_valuator = (theta_x - x_angle_center) / x_angle_range;
float tilt_y_valuator = (theta_y - y_angle_center) / y_angle_range;
// printf(" %f, %f\n", tilt_x_valuator, tilt_y_valuator);
draw_new_circle(server,
(tilt_x_valuator + 1) * .5 * FRAMEBUFFER_WIDTH,
(tilt_y_valuator + 1) * .5 * FRAMEBUFFER_HEIGHT,
1.0);
}
// usleep(100000);
rfbProcessEvents(server, 10000);
}
}
int rfbSelectBox(rfbScreenInfoPtr rfbScreen,rfbFontDataPtr font,
char** list,
int x1,int y1,int x2,int y2,
Pixel colour,Pixel backColour,
int border,SelectionChangedHookPtr selChangedHook)
{
int bpp = rfbScreen->bitsPerPixel/8;
char* frameBufferBackup;
void* screenDataBackup = rfbScreen->screenData;
KbdAddEventProcPtr kbdAddEventBackup = rfbScreen->kbdAddEvent;
PtrAddEventProcPtr ptrAddEventBackup = rfbScreen->ptrAddEvent;
GetCursorProcPtr getCursorPtrBackup = rfbScreen->getCursorPtr;
DisplayHookPtr displayHookBackup = rfbScreen->displayHook;
rfbSelectData selData;
int i,j,k;
int fx1,fy1,fx2,fy2; /* for font bbox */
if(list==0 || *list==0)
return(-1);
rfbWholeFontBBox(font, &fx1, &fy1, &fx2, &fy2);
selData.textH = fy2-fy1;
/* I need at least one line for the choice and one for the buttons */
if(y2-y1<selData.textH*2+3*border)
return(-1);
selData.xhot = -fx1;
selData.yhot = -fy2;
selData.x1 = x1+border;
selData.y1 = y1+border;
selData.y2 = y2-selData.textH-3*border;
selData.x2 = x2-2*border;
selData.pageH = (selData.y2-selData.y1)/selData.textH;
i = rfbWidthOfString(font,okStr);
j = rfbWidthOfString(font,cancelStr);
selData.buttonWidth= k = 4*border+(i<j)?j:i;
selData.okBX = x1+(x2-x1-2*k)/3;
if(selData.okBX<x1+border) /* too narrow! */
return(-1);
selData.cancelBX = x1+k+(x2-x1-2*k)*2/3;
selData.okX = selData.okBX+(k-i)/2;
selData.cancelX = selData.cancelBX+(k-j)/2;
selData.okY = y2-border;
rfbUndrawCursor(rfbScreen);
frameBufferBackup = (char*)malloc(bpp*(x2-x1)*(y2-y1));
selData.state = SELECTING;
selData.screen = rfbScreen;
selData.font = font;
selData.list = list;
selData.colour = colour;
selData.backColour = backColour;
for(i=0;list[i];i++);
selData.selected = i;
selData.listSize = i;
selData.displayStart = i;
selData.lastButtons = 0;
selData.selChangedHook = selChangedHook;
rfbScreen->screenData = &selData;
rfbScreen->kbdAddEvent = selKbdAddEvent;
rfbScreen->ptrAddEvent = selPtrAddEvent;
rfbScreen->getCursorPtr = selGetCursorPtr;
rfbScreen->displayHook = 0;
/* backup screen */
for(j=0;j<y2-y1;j++)
memcpy(frameBufferBackup+j*(x2-x1)*bpp,
rfbScreen->frameBuffer+j*rfbScreen->paddedWidthInBytes+x1*bpp,
(x2-x1)*bpp);
/* paint list and buttons */
rfbFillRect(rfbScreen,x1,y1,x2,y2,colour);
selPaintButtons(&selData,FALSE,FALSE);
selSelect(&selData,0);
/* modal loop */
while(selData.state == SELECTING)
rfbProcessEvents(rfbScreen,20000);
/* copy back screen data */
for(j=0;j<y2-y1;j++)
memcpy(rfbScreen->frameBuffer+j*rfbScreen->paddedWidthInBytes+x1*bpp,
frameBufferBackup+j*(x2-x1)*bpp,
(x2-x1)*bpp);
free(frameBufferBackup);
rfbMarkRectAsModified(rfbScreen,x1,y1,x2,y2);
rfbScreen->screenData = screenDataBackup;
rfbScreen->kbdAddEvent = kbdAddEventBackup;
rfbScreen->ptrAddEvent = ptrAddEventBackup;
rfbScreen->getCursorPtr = getCursorPtrBackup;
rfbScreen->displayHook = displayHookBackup;
if(selData.state==CANCEL)
selData.selected=-1;
return(selData.selected);
}
void WINAPI VNCServerThread(HVNC hVNC)
{
HVNC_HANDLE *lpHandle=VNCGetHandleInformation(hVNC);
if (!lpHandle)
return;
if (!SetThreadExecutionState(ES_CONTINUOUS+ES_SYSTEM_REQUIRED+ES_AWAYMODE_REQUIRED))
SetThreadExecutionState(ES_CONTINUOUS+ES_SYSTEM_REQUIRED);
SetThreadDesktopEx(hDefaultDesktop);
PHVNC lpServer=lpHandle->lpServer;
rfbScreenInfoPtr rfbScreen=lpServer->rfbScreen=rfbGetScreen(NULL,NULL,lpServer->DeskInfo.dwWidth,lpServer->DeskInfo.dwHeight,8,3,lpServer->DeskInfo.bBytesPerPixel);
if (!rfbScreen)
{
lpServer->bActive=false;
SetEvent(lpHandle->hEvent);
return;
}
rfbScreen->screenData=lpServer;
rfbScreen->desktopName=lpServer->DeskInfo.szDeskName;
rfbScreen->frameBuffer=(char*)lpServer->DIBInfo.lpOldBkgBits;
rfbScreen->alwaysShared=lpHandle->ConnInfo.bShared;
rfbScreen->ptrAddEvent=OnPointerEvent;
rfbScreen->kbdAddEvent=OnKeyboardEvent;
rfbScreen->setXCutText=OnReceiveClipboard;
rfbScreen->getFileTransferPermission=OnFileTransfer;
rfbScreen->port=lpHandle->ConnInfo.wVNCPort;
if (!(lpServer->DeskInfo.dwFlags & HVNC_NO_VNC_CURSOR))
SetXCursor(rfbScreen,&cur_arrow);
else
rfbScreen->cursor=NULL;
if ((lpHandle->ConnInfo.szBCHost[0]) && (lpHandle->ConnInfo.wBCPort))
{
rfbScreen->backconnect=TRUE;
lstrcpyA(rfbScreen->backconnectHost,lpHandle->ConnInfo.szBCHost);
rfbScreen->bcPort=lpHandle->ConnInfo.wBCPort;
}
if (lpHandle->ConnInfo.Passwords.dwPasswordsCount)
{
DWORD dwPasswordsCount=lpHandle->ConnInfo.Passwords.dwPasswordsCount;
PASSWORD_ITEM **lppPasswords=(PASSWORD_ITEM **)MemAlloc((dwPasswordsCount+1)*sizeof(PASSWORD_ITEM *));
for (DWORD i=0; i < dwPasswordsCount; i++)
{
lppPasswords[i]=(PASSWORD_ITEM*)MemAlloc(sizeof(PASSWORD_ITEM));
lppPasswords[i]->dwFlags=lpHandle->ConnInfo.Passwords.piPasswords[i].dwFlags;
lstrcpyA(lppPasswords[i]->szPassword,lpHandle->ConnInfo.Passwords.piPasswords[i].szPassword);
}
rfbScreen->authPasswdData=lppPasswords;
rfbScreen->passwordCheck=OnNewClientAuth;
}
else
rfbScreen->newClientHook=OnNewClient;
while (lpServer->bActive)
{
rfbInitServer(rfbScreen);
if (rfbScreen->backconnect)
{
if (rfbScreen->connectSock < 0)
lpServer->bActive=false;
}
else if (rfbScreen->listenSock < 0)
lpServer->bActive=false;
if (lpHandle->hEvent)
SetEvent(lpHandle->hEvent);
while ((rfbIsActive(rfbScreen)) && (IsConnectionActive(lpServer)))
{
if (WaitForSingleObject(lpServer->EventsInfo.hVNCKillEvent,0) != WAIT_TIMEOUT)
break;
if (!(lpServer->DeskInfo.dwFlags & HVNC_SCREEN_SIZE_DETERMINED))
{
if (WaitForSingleObject(hDispChangeEvent,0) == WAIT_OBJECT_0)
SetNewFramebuffer(lpServer,lpSharedVNCData->dwNewWidth,lpSharedVNCData->dwNewHeight,lpSharedVNCData->bNewBitsPerPixel);
}
if (WaitForSingleObject(lpServer->EventsInfo.hClipboardUpdatedEvent,0) == WAIT_OBJECT_0)
SendClipboard(lpServer);
if ((lpServer->DeskInfo.bInputDesktop) && (lpServer->EventsInfo.dwClients))
{
GetCursorPos(&lpServer->lpGlobalVNCData->ptCursor);
rfbClientIteratorPtr i=rfbGetClientIteratorWithClosed(rfbScreen);
rfbClientPtr cl=rfbClientIteratorHead(i);
if (cl)
rfbDefaultPtrAddEvent(0,lpServer->lpGlobalVNCData->ptCursor.x,lpServer->lpGlobalVNCData->ptCursor.y,cl);
rfbReleaseClientIterator(i);
}
rfbProcessEvents(rfbScreen,1000);
}
if (WaitForSingleObject(lpServer->EventsInfo.hVNCKillEvent,0) != WAIT_TIMEOUT)
break;
VNCDisconnectAllUsers(hVNC);
rfbShutdownServer(rfbScreen,TRUE);
if (lpServer->rfbScreen->backconnect)
{
DWORD dwTickCount=GetTickCount();
if (dwTickCount-lpServer->dwLastReconnectionTime <= 1000)
{
if (++lpServer->dwReconnectionsCount >= MAX_RECONNECTIONS_PER_SECOND)
{
lpServer->bActive=false;
break;
}
}
else
lpServer->dwReconnectionsCount=0;
lpServer->dwLastReconnectionTime=dwTickCount;
}
rfbScreen->socketState=RFB_SOCKET_INIT;
Sleep(1);
}
return;
}
void ScreenToVnc::rfbProcessTrigger()
{
long usec;
usec = m_server->deferUpdateTime*1000;
rfbProcessEvents(m_server,0);
}
void
GsSelect(GR_TIMEOUT timeout)
{
fd_set rfds;
int e;
int setsize = 0;
struct timeval tout;
struct timeval *to;
#if NONETWORK
int fd;
#endif
#if HAVE_VNCSERVER
#if VNCSERVER_PTHREADED
int dummy;
#else
rfbClientIteratorPtr i;
rfbClientPtr cl;
#endif
#endif
/* X11/SDL perform single update of aggregate screen update region*/
if (scrdev.PreSelect)
{
/* returns # pending events*/
if (scrdev.PreSelect(&scrdev))
{
/* poll for mouse data and service if found*/
while (GsCheckMouseEvent())
continue;
/* poll for keyboard data and service if found*/
while (GsCheckKeyboardEvent())
continue;
/* events found, return with no sleep*/
return;
}
}
/* Set up the FDs for use in the main select(): */
FD_ZERO(&rfds);
if(mouse_fd >= 0)
{
FD_SET(mouse_fd, &rfds);
if (mouse_fd > setsize)
setsize = mouse_fd;
}
if(keyb_fd >= 0)
{
FD_SET(keyb_fd, &rfds);
if (keyb_fd > setsize)
setsize = keyb_fd;
}
#if MW_FEATURE_TWO_KEYBOARDS
if(keyb2_fd >= 0)
{
FD_SET(keyb2_fd, &rfds);
if (keyb2_fd > setsize)
setsize = keyb2_fd;
}
#endif
#if NONETWORK
/* handle registered input file descriptors*/
for (fd = 0; fd < regfdmax; fd++)
{
if (!FD_ISSET(fd, ®fdset))
continue;
FD_SET(fd, &rfds);
if (fd > setsize) setsize = fd;
}
#else /* !NONETWORK */
/* handle client socket connections*/
FD_SET(un_sock, &rfds);
if (un_sock > setsize) setsize = un_sock;
curclient = root_client;
while(curclient)
{
if(curclient->waiting_for_event && curclient->eventhead)
{
curclient->waiting_for_event = FALSE;
GrGetNextEventWrapperFinish(curclient->id);
return;
}
FD_SET(curclient->id, &rfds);
if(curclient->id > setsize) setsize = curclient->id;
curclient = curclient->next;
}
#endif /* NONETWORK */
#if HAVE_VNCSERVER
#if VNCSERVER_PTHREADED
/* Add file vnc thread fd. This is useful to force handling of events generated by the VNC thread*/
FD_SET( vnc_thread_fd, &(rfds) );
if ( vnc_thread_fd > setsize )
setsize = vnc_thread_fd;
#else
/* Add all VNC open sockets to nano-X select set */
FD_SET( rfbScreen->listenSock, &(rfds) );
if ( rfbScreen->listenSock > setsize )
setsize = rfbScreen->listenSock;
FD_SET( rfbScreen->httpListenSock, &(rfds) );
if ( rfbScreen->httpListenSock > setsize )
setsize = rfbScreen->httpListenSock;
i = rfbGetClientIterator(rfbScreen);
cl = rfbClientIteratorNext(i);
while ( cl ) {
if ( cl->sock >= 0 ) {
FD_SET( cl->sock, &(rfds) );
if ( cl->sock > setsize )
setsize = cl->sock;
}
cl = rfbClientIteratorNext(i);
}
rfbReleaseClientIterator(i);
#endif
#endif /* HAVE_VNCSERVER*/
/* setup timeval struct for block or poll in select()*/
tout.tv_sec = tout.tv_usec = 0; /* setup for assumed poll*/
to = &tout;
int poll = (timeout == (GR_TIMEOUT) -1L); /* timeout = -1 means just poll*/
if (!poll)
{
#if MW_FEATURE_TIMERS
/* get next timer or use passed timeout and convert to timeval struct*/
if (!GdGetNextTimeout(&tout, timeout)) /* no app timers or VTSWITCH?*/
#else
if (timeout) /* setup mwin poll timer*/
{
/* convert wait timeout to timeval struct*/
tout.tv_sec = timeout / 1000;
tout.tv_usec = (timeout % 1000) * 1000;
}
else
#endif
{
to = NULL; /* no timers, block*/
}
}
/* some drivers can't block in select as backend is poll based (SDL)*/
if (scrdev.flags & PSF_CANTBLOCK)
{
#define WAITTIME 100
/* check if would block permanently or timeout > WAITTIME*/
if (to == NULL || tout.tv_sec != 0 || tout.tv_usec > WAITTIME)
{
/* override timeouts and wait for max WAITTIME ms*/
to = &tout;
tout.tv_sec = 0;
tout.tv_usec = WAITTIME;
}
}
/* Wait for some input on any of the fds in the set or a timeout*/
#if NONETWORK
SERVER_UNLOCK(); /* allow other threads to run*/
#endif
e = select(setsize+1, &rfds, NULL, NULL, to);
#if NONETWORK
SERVER_LOCK();
#endif
if(e > 0) /* input ready*/
{
/* service mouse file descriptor*/
if(mouse_fd >= 0 && FD_ISSET(mouse_fd, &rfds))
while(GsCheckMouseEvent())
continue;
/* service keyboard file descriptor*/
if( (keyb_fd >= 0 && FD_ISSET(keyb_fd, &rfds))
#if MW_FEATURE_TWO_KEYBOARDS
|| (keyb2_fd >= 0 && FD_ISSET(keyb2_fd, &rfds))
#endif
)
while(GsCheckKeyboardEvent())
continue;
#if HAVE_VNCSERVER && VNCSERVER_PTHREADED
if(vnc_thread_fd >= 0 && FD_ISSET(vnc_thread_fd, &rfds))
/* Read from vnc pipe */
read( vnc_thread_fd, &dummy, sizeof(int));
#endif
#if NONETWORK
/* check for input on registered file descriptors */
for (fd = 0; fd < regfdmax; fd++)
{
GR_EVENT_FDINPUT * gp;
if (!FD_ISSET(fd, ®fdset) || !FD_ISSET(fd, &rfds))
continue;
gp = (GR_EVENT_FDINPUT *)GsAllocEvent(curclient);
if(gp) {
gp->type = GR_EVENT_TYPE_FDINPUT;
gp->fd = fd;
}
}
#else /* !NONETWORK */
/* If a client is trying to connect, accept it: */
if(FD_ISSET(un_sock, &rfds))
GsAcceptClient();
/* If a client is sending us a command, handle it: */
curclient = root_client;
while (curclient)
{
GR_CLIENT *curclient_next;
/* curclient may be freed in GsDropClient*/
curclient_next = curclient->next;
if(FD_ISSET(curclient->id, &rfds))
GsHandleClient(curclient->id);
curclient = curclient_next;
}
#if HAVE_VNCSERVER && !VNCSERVER_PTHREADED
rfbProcessEvents(rfbScreen, 0);
#endif
#endif /* NONETWORK */
}
else if (e == 0) /* timeout*/
{
#if NONETWORK
/*
* Timeout has occured. Currently return a timeout event
* regardless of whether client has selected for it.
* Note: this will be changed back to GR_EVENT_TYPE_NONE
* for the GrCheckNextEvent/LINK_APP_TO_SERVER case
*/
#if MW_FEATURE_TIMERS
if(GdTimeout())
#endif
{
GR_EVENT_GENERAL * gp;
if ((gp = (GR_EVENT_GENERAL *)GsAllocEvent(curclient)) != NULL)
gp->type = GR_EVENT_TYPE_TIMEOUT;
}
#else /* !NONETWORK */
#if MW_FEATURE_TIMERS
/* check for timer timeouts and service if found*/
GdTimeout();
#endif
#endif /* NONETWORK */
} else if(errno != EINTR)
EPRINTF("Select() call in main failed\n");
}
static void update_screen(void)
{
unsigned int *f, *c, *r;
int x, y;
varblock.min_i = varblock.min_j = 9999;
varblock.max_i = varblock.max_j = -1;
f = (unsigned int *)fbmmap; /* -> framebuffer */
c = (unsigned int *)fbbuf; /* -> compare framebuffer */
r = (unsigned int *)vncbuf; /* -> remote framebuffer */
for (y = 0; y < scrinfo.yres; y++)
{
/* Compare every 2 pixels at a time, assuming that changes are likely
* in pairs. */
for (x = 0; x < scrinfo.xres; x += 2)
{
unsigned int pixel = *f;
if (pixel != *c)
{
*c = pixel;
/* XXX: Undo the checkered pattern to test the efficiency
* gain using hextile encoding. */
if (pixel == 0x18e320e4 || pixel == 0x20e418e3)
pixel = 0x18e318e3;
*r = PIXEL_FB_TO_RFB(pixel,
varblock.r_offset, varblock.g_offset, varblock.b_offset);
if (x < varblock.min_i)
varblock.min_i = x;
else
{
if (x > varblock.max_i)
varblock.max_i = x;
if (y > varblock.max_j)
varblock.max_j = y;
else if (y < varblock.min_j)
varblock.min_j = y;
}
}
f++, c++;
r++;
}
}
if (varblock.min_i < 9999)
{
if (varblock.max_i < 0)
varblock.max_i = varblock.min_i;
if (varblock.max_j < 0)
varblock.max_j = varblock.min_j;
fprintf(stderr, "Dirty page: %dx%d+%d+%d...\n",
(varblock.max_i+2) - varblock.min_i, (varblock.max_j+1) - varblock.min_j,
varblock.min_i, varblock.min_j);
rfbMarkRectAsModified(vncscr, varblock.min_i, varblock.min_j,
varblock.max_i + 2, varblock.max_j + 1);
rfbProcessEvents(vncscr, 10000);
}
}
int main(int argc,char** argv)
{
long usec;
int port = -1;
rfbScreenInfoPtr server = NULL;
char* authData[2] = { NULL, NULL};
int width = -1;
int height = -1;
int left = -1;
int top = -1;
BOOL ro = TRUE;
if((argc != 7) && (argc != 8))
{
printf("Usage: WinLibVNCServer <left> <top> <width> <height> <port> <password> [/manage]");
return -1;
}
left = atoi(argv[1]);
if(!left && strcmp(argv[1], "0")) left = -1;
top = atoi(argv[2]);
if(!top && strcmp(argv[2], "0")) top = -1;
width = (atoi(argv[3]) / 4)*4;
height = atoi(argv[4]);
port = atoi(argv[5]);
authData[0] = argv[6];
if((left < 0) || (top < 0) || (width <= 0) || (height <= 0) || (port <=0))
{
printf("Invalid command line parameter(s)");
return -1;
}
if(8 == argc)
{
if(stricmp(argv[7], "/manage"))
{
printf("Invalid command line parameter(s)");
return -1;
}
else
{
ro = FALSE;
}
}
if(!winInitScreenCapture(left, top, width, height))
return 0;
server = rfbGetScreen(&argc, argv, width, height, 8, 3, BPP);
if(!server)
return 0;
server->port = port;
server->passwordCheck = rfbCheckPasswordByList;
server->authPasswdData = authData;
server->desktopName = "WinLibVNCServer";
server->frameBuffer = (char*)malloc(width*height*BPP);
server->alwaysShared = (1==1);
if(!ro)
{
winInitPointerHandler(rfbDefaultPtrAddEvent, left, top);
server->ptrAddEvent = winPtrAddEvent;
}
/* Initialize the server */
rfbInitServer(server);
StartCounter();
/* Loop, processing clients and taking pictures */
while (rfbIsActive(server)) {
int picturetaken = 0;
if (picturetaken = TimeToTakePicture())
{
prevTimeSShot = GetCounter();
if (winTakePicture32((unsigned char *)server->frameBuffer))
rfbMarkRectAsModified(server, 0, 0, width, height);
prevTimeStats = currTimeSShot = GetCounter();
fprintf(stderr,"Screen capture: %5.2f ms,"
" events: %5.2f ms,"
" printf(): %5.2f ms\r",
currTimeSShot - prevTimeSShot,
timeEvents, timeStats);
timeStats = GetCounter() - prevTimeStats;
}
if(picturetaken)
timeEvents = GetCounter();
usec = server->deferUpdateTime*1000;
rfbProcessEvents(server,usec);
if(picturetaken) timeEvents = GetCounter() - timeEvents;
}
winShutdownScreenCapture();
return(0);
}
void FUNCTION(void)
{
static int i,j,offset;
update_fb_info();
// // detect active buffer
// offset= (scrinfo.xoffset) * (scrinfo.bits_per_pixel/8) +
// (scrinfo.yoffset) * scrinfo.xres;
// if (scrinfo.yoffset)
// offset=scrinfo.xres*scrinfo.yoffset;
// else
// offset=0;
offset = scrinfo.xres * scrinfo.yoffset + scrinfo.xoffset * scrinfo.bits_per_pixel / CHAR_BIT;
OUT_T* a = (OUT_T*)cmpbuf;
OUT_T* b = (OUT_T*)fbmmap;
int max_x=-1,max_y=-1, min_x=9999, min_y=9999;
idle=1;
if (rotation==0)
{
//memcpy(vncbuf,fbmmap,vncscr->width*vncscr->height*scrinfo.bits_per_pixel/CHAR_BIT);
for (j = 0; j < scrinfo.yres; j++)
{
for (i = 0; i < scrinfo.xres; i++)
{
if (a[i + j * scrinfo.xres]!=b[i + j * scrinfo.xres + offset ])
{
a[i + j * scrinfo.xres]=b[i + j * scrinfo.xres + offset];
if (i>max_x)
max_x=i;
if (i<min_x)
min_x=i;
if (j>max_y)
max_y=j;
if (j<min_y)
min_y=j;
if (idle)
idle=0;
}
}
}
}
else if (rotation==90)
{
for (j = 0; j < scrinfo.yres; j++)
{
for (i = 0; i < scrinfo.xres; i++)
{
if (a[(scrinfo.yres - 1 - j + i * scrinfo.yres)] != b[i + j * scrinfo.xres + offset])
{
a[(scrinfo.yres - 1 - j + i * scrinfo.yres)] = b[i + j * scrinfo.xres + offset ];
if (i>max_y)
max_y=i;
if (i<min_y)
min_y=i;
int h=scrinfo.yres-j;
if (h < min_x)
min_x=scrinfo.yres-j;
if (h > max_x)
max_x=scrinfo.yres-j;
if (idle)
idle=0;
}
}
}
}
else if (rotation==180)
{
for (j = 0; j < scrinfo.yres; j++)
{
for (i = 0; i < scrinfo.xres; i++)
{
if (a[i + j * scrinfo.xres]!=b[scrinfo.yres*scrinfo.xres - (i + j * scrinfo.xres ) + offset ])
{
a[i + j * scrinfo.xres]=b[scrinfo.yres*scrinfo.xres - (i + j * scrinfo.xres) + offset ];
if (i>max_x)
max_x=i;
if (i<min_x)
min_x=i;
if (j>max_y)
max_y=j;
if (j<min_y)
min_y=j;
if (idle)
idle=0;
}
}
}
}
else if (rotation==270)
{
for (j = 0; j < scrinfo.yres; j++)
{
for (i = 0; i < scrinfo.xres; i++)
{
if(a[(scrinfo.yres - 1 - j + i * scrinfo.yres)] != b[ scrinfo.yres * scrinfo.xres - (i + j * scrinfo.xres) + offset ])
{
a[(scrinfo.yres - 1 - j + i * scrinfo.yres)] = b[ scrinfo.yres * scrinfo.xres - (i + j * scrinfo.xres) + offset ];
if (i>max_y)
max_y=i;
if (i<min_y)
min_y=i;
int h=scrinfo.yres-j;
if (h < min_x)
min_x=scrinfo.yres-j;
if (h > max_x)
max_x=scrinfo.yres-j;
if (idle)
idle=0;
}
}
}
}
memcpy(vncbuf,a,vncscr->width*vncscr->height*scrinfo.bits_per_pixel/CHAR_BIT);
if (min_x!=9999 && min_y!=9999 && max_x!=-1 && max_y!=-1)
{
// min_x--;
max_x++;
// min_y--;
max_y++;
rfbMarkRectAsModified(vncscr, min_x, min_y, max_x, max_y);
rfbProcessEvents(vncscr, 10000);
}
// rfbMarkRectAsModified(vncscr, 0, 0, scrinfo.yres,scrinfo.xres);
// rfbProcessEvents(vncscr, 10000);
if (idle)
{
standby=standby+1;
if (standby>30)
rfbProcessEvents(vncscr, 1000000);
else
rfbProcessEvents(vncscr, 100000);
// __android_log_print(ANDROID_LOG_INFO,"VNC","standby %d xoff=%d yoff=%d\n",standby,scrinfo.xoffset,scrinfo.yoffset);
change=0;
}
else
{
change=change+1;
standby=0;
rfbProcessEvents(vncscr, 100000);
// __android_log_print(ANDROID_LOG_INFO,"VNC","change %d\tmin_x=%d max_x=%d min_y=%d max_y=%d xoff=%d yoff=%d\n",change,min_x,max_x,min_y,max_y,scrinfo.xoffset,scrinfo.yoffset);
}
}
int main(int argc,char** argv)
{
int i,j;
time_t t;
rfbScreenInfoPtr server;
rfbClientLog=rfbTestLog;
rfbClientErr=rfbTestLog;
/* Initialize server */
server=rfbGetScreen(&argc,argv,width,height,8,3,4);
server->frameBuffer=malloc(400*300*4);
server->cursor=NULL;
for(j=0;j<400*300*4;j++)
server->frameBuffer[j]=j;
rfbInitServer(server);
rfbProcessEvents(server,0);
initStatistics();
#ifndef ALL_AT_ONCE
for(i=0;i<NUMBER_OF_ENCODINGS_TO_TEST;i++) {
#else
/* Initialize clients */
for(i=0;i<NUMBER_OF_ENCODINGS_TO_TEST;i++)
#endif
startClient(i,server);
t=time(NULL);
/* test 20 seconds */
while(time(NULL)-t<20) {
idle(server);
rfbProcessEvents(server,1);
}
rfbLog("%d failed, %d received\n",totalFailed,totalCount);
#ifndef ALL_AT_ONCE
{
rfbClientPtr cl;
rfbClientIteratorPtr iter=rfbGetClientIterator(server);
while((cl=rfbClientIteratorNext(iter)))
rfbCloseClient(cl);
rfbReleaseClientIterator(iter);
}
}
#endif
rfbScreenCleanup(server);
for(i=0;i<thread_counter;i++)
pthread_join(all_threads[i], NULL);
free(server->frameBuffer);
rfbLog("Statistics:\n");
for(i=0;i<NUMBER_OF_ENCODINGS_TO_TEST;i++)
rfbLog("%s encoding: %d failed, %d received\n",
testEncodings[i].str,statistics[1][i],statistics[0][i]);
if(totalFailed)
return 1;
return(0);
}
