micolous.id.au

// vnc-splitter
// Copyright 2010 Michael Farrell <http://micolous.id.au>
// build with: gcc -o vnc-splitter vnc-splitter.c -lvncserver -lvncclient
#include <stdio.h>
#include <rfb/rfb.h>
#include <rfb/rfbclient.h>
 
// the height and width of the screens
// this should match the aspect ratio of the input
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
 
// the amount of screens is this number squared
#define SCREEN_SQUARE_SIZE 3
 
// where to start displays counting from.
// the first screen number is this, and subsequent screens are other positions.
#define DISPLAY_START 30
 
// output buffers for child vnc server processes
rfbScreenInfoPtr output_screens[SCREEN_SQUARE_SIZE * SCREEN_SQUARE_SIZE];
 
static rfbBool resizeImage(rfbClient* client)
{  
	int width=client->width;
	int height=client->height;
	int depth=client->format.bitsPerPixel;
	fprintf(stderr, "ResizeImage fired: %ix%i %ibpp\n", width, height, depth);
 
	// change the screen resolution
	// deallocate any existing framebuffer	
	if (client->frameBuffer != NULL)
		free (client->frameBuffer);
 
	client->frameBuffer = malloc(width * height * (depth / 8));
 
	if (client->frameBuffer == NULL) {
		fprintf(stderr, "Cannot allocate memory for framebuffer!");
		exit(1);
	}
 
	// we also need to tell libvncclient how it should put pixel data in there
	client->format.redShift   = 8;
	client->format.greenShift = 16;
	client->format.blueShift  = 24;
	client->format.redMax     = 0xFF;
	client->format.greenMax   = 0xFF;
	client->format.blueMax    = 0xFF;
 
	// now we set the format and encoding method information back to libvncclient so it updates it's information.
	SetFormatAndEncodings(client);
 
	// report success to libvncclient
	return TRUE;
}
 
static void updateImage(rfbClient* client,int u_x,int u_y,int u_w,int u_h)
{
	unsigned int x, y, src_x, src_y;
	unsigned int *dest;
	unsigned int *src;
 
	unsigned int max_x = SCREEN_SQUARE_SIZE * SCREEN_WIDTH;
	unsigned int max_y = SCREEN_SQUARE_SIZE * SCREEN_HEIGHT;
 
	// precalculate the region we actually need to update.
	unsigned int u_min_x = ((double)(u_x) / (double)(client->width)) * max_x;
	unsigned int u_min_y = ((double)(u_y) / (double)(client->height)) * max_y;
 
	unsigned int u_max_x = ((double)(u_x + u_w) / (double)(client->width)) * max_x;
	unsigned int u_max_y = ((double)(u_y + u_h) / (double)(client->height)) * max_y;
 
	unsigned char updated[SCREEN_SQUARE_SIZE * SCREEN_SQUARE_SIZE];
	memset(updated, 0, SCREEN_SQUARE_SIZE * SCREEN_SQUARE_SIZE);
 
	// This scaling algorithm really sucks.  It's a "nearest neighbour" scaling format.
	// It's really easy to implement, really fast, but looks absolutely terrible.
	// Try and end up with the image being blown up so that 1x1 on the original maps to 2x2
	// on the destination.  If it maps to a fraction of pixels things look really bad.
	for (y=u_min_y; y<u_max_y; y++) {
		for (x=u_min_x; x<u_max_x; x++) {
			// now find out where that maps to on the original framebuffer.
			src_x = (unsigned int)(((double)x / (double)max_x) * (double)client->width);
			src_y = (unsigned int)(((double)y / (double)max_y) * (double)client->height);
 
			// figure out where this pixel is
			unsigned int d = ((y / SCREEN_HEIGHT) * SCREEN_SQUARE_SIZE) + (x / SCREEN_WIDTH);
 
			// now create a pointer to where that pixel is stored
			dest = (unsigned int*)&output_screens[d]->frameBuffer[(((y % SCREEN_HEIGHT) * SCREEN_WIDTH) + (x % SCREEN_WIDTH)) * 4];
 
			// and fix a pointer to that
			src = (unsigned int*)&client->frameBuffer[((src_y * client->width) + src_x) * 4];
 
			// and copy the pixel
			*dest = *src;
 
			// mark that screen as updated
			updated[d] = 1;
		}
	}
 
	for (x=0; x<SCREEN_SQUARE_SIZE * SCREEN_SQUARE_SIZE; x++)
		if (updated[x])
			// mark the entire screen as updated for now.  this could really
			// use some proper optimisations.
			rfbMarkRectAsModified(output_screens[x], 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
}
 
int main (int argc, char *argv[])
{
	fprintf(stderr, "vnc-splitter\n");
	fprintf(stderr, "Copyright 2010 Michael Farrell <http://micolous.id.au>\n");
	// create a 32-bpp "client".
	rfbClient* client = rfbGetClient(8,3,4);
 
	// tell the library we can handle being resized.
	client->canHandleNewFBSize = TRUE;
	client->MallocFrameBuffer = resizeImage;
 
	// handle framebuffer updates
	client->GotFrameBufferUpdate = updateImage;
 
	// we don't care about keyboard LEDs and tightvnc chat protocol.
	client->HandleKeyboardLedState = 0;
	client->HandleTextChat = 0;
 
	// make a blank cursor
	rfbCursorPtr cursor = rfbMakeXCursor(0, 0, "\0", "\0");
 
	// create the vnc servers
	unsigned int id;
 
	for (id=0; id<SCREEN_SQUARE_SIZE * SCREEN_SQUARE_SIZE; id++) {
		output_screens[id] = rfbGetScreen(0, NULL, SCREEN_WIDTH, SCREEN_HEIGHT, 8, 3, 4);
		output_screens[id]->frameBuffer = malloc(SCREEN_WIDTH * SCREEN_HEIGHT * 4);
 
		output_screens[id]->serverFormat.redShift   = 8;
		output_screens[id]->serverFormat.greenShift = 16;
		output_screens[id]->serverFormat.blueShift  = 24;
		output_screens[id]->serverFormat.redMax     = 0xFF;
		output_screens[id]->serverFormat.greenMax   = 0xFF;
		output_screens[id]->serverFormat.blueMax    = 0xFF;
 
		output_screens[id]->autoPort = FALSE;
		output_screens[id]->port = SERVER_PORT_OFFSET + DISPLAY_START + id;
		output_screens[id]->alwaysShared = TRUE;
		rfbSetCursor(output_screens[id], cursor);
 
		// create the server in another thread
		rfbInitServer(output_screens[id]);
		rfbRunEventLoop(output_screens[id],-1,TRUE);
	}
 
	// connect to the server
	fprintf(stderr, "Connecting to server...\n");
 
	// rfbInitClient also allows us to use vncviewer-style commandline options.
	if(!rfbInitClient(client,&argc,argv))
		return 1;
 
	// start pumping the loop.
	fprintf(stderr, "Pumping...\n");
 
	clock_t last_frame = clock();
	clock_t this_frame = last_frame;
	do {
		int i = WaitForMessage(client, 100);
 
		if (i < 0)
			// there was an issue getting the message, probably our socket was closed.
			return 0;
 
		if (i)
			// handle message
			if (!HandleRFBServerMessage(client))
				// error handling message, die.
				return 0;
	} while (1);
	return 0;
}