I’ve since updated the driver so that it treats the directional buttons on the big button controllers as the X and Y axes. This means that joydev.c will now detect the xbox360bb as a joystick driver, and so ordinary programs that use Linux’s joystick API can receive events from the controllers (and not just those that use evdev).

I also wrote a simple pygame version of Simon. This works whenever you have four joystick devices attached to your computer. You play by pressing any button on the controller. The colours match up to how the Big Button controllers are presented in xbox360bb. As soon as one person makes a mistake, the game ends. The loser is reported on the console.

Unfortunately, there’s no online “simulator” available, but that should be trivial for someone to write if they’re testing their program.

Because he didn’t implement it, and I got bored, I ended up writing “TrolledFS” as a FUSE filesystem module in Python.

The module requests two options, root, which is the directory that provides the structure of the filesystem (ie: it will appear to be a copy of this folder), and fakes, a folder containing replacement files. So if you requested example.avi, it would map it to the first file with the AVI extension in the fakes folder.

It is based on the Xmp.py (example) filesystem module from FUSE’s Python bindings, with all of the write calls filtered out. Instead, filesystem will say it is a read-only filesystem. If a file has no match in the fakes folder, the filesystem will say there was an I/O error.

Video demo (or you can watch it on YouTube):

You need to put this code inside your Gtk.Window.

public partial class MainWindow : Gtk.Window
{
	// viewport which we use to contain the label and handle the scrolling of the marquee.
	private Viewport vpMarquee = new Viewport();

	// marquee text should have some padding before and after the text, to avoid rendering errors, and
	// to allow the text to "flow in" when it is reset after reaching the end.
	private Label lblMarquee = new Label("                                                                                                 [lblMarquee] Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec metus quam, ullamcorper eu suscipit quis, rutrum sit amet massa.                                                                                                 ");//" Nunc dapibus accumsan metus, commodo placerat urna blandit non. Nullam turpis justo, dictum quis dignissim non, vehicula vel lorem. Fusce congue purus odio, lobortis pulvinar neque. Integer dui odio, venenatis sed tincidunt in, fringilla id urna. Maecenas faucibus massa eu orci tincidunt ac vulputate nibh aliquam. Aliquam ullamcorper erat nunc. Vestibulum hendrerit adipiscing neque quis interdum.");

	public MainWindow () : base(Gtk.WindowType.Toplevel)
	{
		// normally you'd be using Stetic, so you need to call it's build-constructor.
		Build ();

		// add the control to the window.  in this example, i'm adding it to a VBox control as the last element.
		vpMarquee.BorderWidth = 0;
		vpMarquee.Add (lblMarquee);
		this.vbox1.PackEnd (vpMarquee, false, false, 0);

		// update marquee every 33ms (~30fps)
		GLib.Timeout.Add (33, new GLib.TimeoutHandler (MarqueeUpdate));

		// add other code here for other things...
	}

	bool MarqueeUpdate ()
	{
		Application.Invoke (delegate {
			// calculate the total amount of space the marquee requires.  this only works because I've manually set the size of the window,
			// otherwise you need another way to get the width of the window instead of this.
			double n = vpMarquee.Hadjustment.Upper - this.WidthRequest;
			if (n < 1)
				// safety incase we don't have an actual width calculated width
				n = 1;

			//Console.WriteLine("{0} > {1} ?", vpMarquee.Hadjustment.Value, n);
			if (vpMarquee.Hadjustment.Value >= n) {
				// we've reached the end.  reset the marquee to the 0-position.
				vpMarquee.Hadjustment.Value = 0;
			} else {
				// scroll the marquee to the left by 3px
				vpMarquee.Hadjustment.Value += 3;
			}

			// tell gtk# we want it to take into account the updated value.
			vpMarquee.Hadjustment.ChangeValue ();
			vpMarquee.Hadjustment.Change ();

			// redraw the control and it's children (the label).
			vpMarquee.ShowAll ();
		});

		// tell Timeout we want to be called again.
		return true;
	}

	// ... add more stuff here for other functionality.
}

Changes:

• Mouse cursors now work correctly.
• You can now disable the “always shared” function of the VNC server and allow a client to take exclusive control with SDL_VNC_ALWAYS_SHARED="0".
• You can change the display number manually with SDL_VNC_DISPLAY.
• 8 bpp displays are now supported.
• pygame applications work at 16, 24 and 32 bpp display depths. 8 doesn’t work properly.
• This module now lies by default about the supported display depths reported by SDL_ListModes. It defaults to 16 bpp only, in order to make pygame work properly. You can change what it says this with SDL_VNC_DEPTH, or setting it to 0 to say all depths are supported. This doesn’t limit calls to SDL_SetVideoMode.
• You can tell the VNC server to ignore all client events by setting SDL_VNC_VIEW_ONLY="1".

There’s also a README.VNC included, which documents the functionality of the library and use of it’s environment variables.

I’ve spent the last couple of days writing a new SDL video output module, which acts as a VNC server using libvncserver. Here are the patches against SDL 1.2.14. To use VNC support, you need to run ./configure with --enable-video-vnc, and once built and installed, run the SDL application with the environment variable SDL_VIDEODRIVER="vnc".

What works:

• 16, 24 and 32-bit true-colour displays.
• Mouse events.
• Keyboard events.

What’s left to do:

• Fix mouse cursors so they display correctly.
• 8-bit (paletted) displays.
• Handle surface locking properly.
• Reduce/eliminate tearing on frequent screen updates.
• Run the libvncserver event loop inside SDL’s event loop system.
• Implement a password on the VNC server and some sort of simple access control.
• Implement a view-only mode.
• Allow setting the display number manually.
• pygame applications.
• Fix screen resolution change colour issues.

What will never work:

• OpenGL surfaces.
• CDROMs, Joysticks and Sound over VNC.
• YUV video output.

I’ve had a lot of success with using the Origyn web browser (a WebKit/SDL-based web browser) and cgterm (a SDL C64/C128 telnet client) with this output method. Any SDL application that doesn’t use OpenGL surfaces should be able to run with this output module.

Some pictures:

This time, this one will split up a single VNC server input into smaller pieces to form a 3×3 grid of smaller VNC server images. It’ll automatically resize it to 640×480. That stuff is configurable in the defines at the top of the file. It works best when the ratio between the source image and the destination image is a whole number, (ie: 4×4 of 640×480 images and an input of 1280×960 has a 2:1 ratio), because it uses a simple “nearest neighbour” scaling algorithm.

The idea of this client is that you take some input into this, run a whole bunch of thin clients or low end machines connecting to each of the pieces of the screen, and align some cheap CRT monitors in a grid, creating a much bigger screen. While there are pretty huge bezels with CRT monitors, it is a very low budget way to create a 107cm (42″) display from a 3×3 array of cheap 36cm (14″) monitors, for example.

Be aware that some VNC servers implement JPEG compression, which looks really horrible when you scale it up (for example, Vine). This program also requires that your VNC server has no password.

// 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;
}

./vnc-fifo vncserver:0 | ffmpeg -f rawvideo -pix_fmt argb -s 1024x768 -i - -vsync 1 -s 512x384 -f mpegts -vcodec mpeg4 -b 1000k -threads 2 udp://239.255.2.3:1234

In this example, I assume your VNC server is running on `vncserver:0`, and it is outputting 1024×768. Other output resolutions will result in corruption, so you’ll need to change the parameter appropriately. It’ll also resize the image to 512×384.

// vnc-fifo.c
#include <stdio.h>
#include <rfb/rfbclient.h>
#include <time.h>

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
	// in a format that ffmpeg will be pleased with (32bpp ARGB)
	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;
}

int main (int argc, char *argv[])
{
	fprintf(stderr, "vnc-fifo\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;

	// we don't care about keyboard LEDs and tightvnc chat protocol.
	client->HandleKeyboardLedState = 0;
	client->HandleTextChat = 0;

	// 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, 10);

		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;

		// pump out a frame only if it has been 1/10 sec since the last one.
		this_frame = clock();
		if (this_frame - last_frame >= (CLOCKS_PER_SEC / 100)) {
			// pump out a frame
			last_frame = this_frame;
			fwrite(client->frameBuffer, 1, client->width * client->height * (client->format.bitsPerPixel/8), stdout);
			fflush(stdout);
		}

	} while (1);
	return 0;
}

There is an issue with using ffmpeg in this fashion, because the framerate is variable, you essentially lie in your MPEG transport stream by saying you have a much higher framerate. The effect in ffplay is that it’ll buffer 10-45 seconds of video, play it all back to the end very fast, empty it’s buffer, then play normally. It’ll be “hanging on your every packet” for more video data.

Unfortunately, I couldn’t get VLC to act in the same fashion (as a reciever), even after telling it not to drop or skip frames, playback was jerky.

Oh well, an experiment to see if I could get out of writing a VLC or ffmpeg source module for VNC. Looks like if I want to go further with this, there’ll need to be a lot of changes to the code.

To get it, download the binaries and extract it to your Windows system32 folder (typically `C:\Windows\System32\`). Then open the screensaver settings, select `Vncscreensaver` and then configure it with your VNC server details. You can then use the screen saver!

Make sure the server you’re connecting to doesn’t require a password, otherwise this won’t work. The client runs in “view only” mode. It will quit when you either click the mouse or press a key, because hooking mouse movement seems to cause problems with the VNC client when it tries to reconnect.

If you’re interested, there’s also source code available for the program, licensed under the GPLv2 (the same license as VncSharp).

I’ve now got all the RetroLAN PCs running out of a copy-on-write image. This means I now have a single 4GB “base” image with an installation of Windows XP, instead of having 10 of them. It also means it is very trivial to reset the machine’s disk images, which I achieved with a bit of scripting.

First up, I needed to setup the copy-on-write images through `device-mapper`. This program is designed to let you setup software RAID, but it also allows snapshotting disks to provide a backup of a device at a point in time. Unfortunately, `dmsetup` doesn’t support accessing file images, only actual devices, so I need to create some loopback devices first.

# setup loop0 as the "master" image, and mark it as read-only so no changes ever get written back.
losetup -r /dev/loop0 /store/master.img
# we need to get the size of the image in sectors for use later on.
cow_size=`blockdev --getsize /dev/loop0`

The next step is to create a blank image file and loopback device to commit changes to. For my setup, I created 200MB images. Be aware of things like disk-based caches and automatic defragmentation will use up the allocated space very quickly, and when you run out of space in this file further writes will not be allowed, and Windows will soon crash with a blue screen of death. (More on dealing with this in a bit)

# remove any existing COW image
rm /store/pc-1.cow

# create a new 200MB image (it's actually comes out 5% more than stated, but it allows for overheads in the filesystem)
dd if=/dev/zero of=/store/pc-1.cow bs=1M count=200

# now hook it to a loopback device
losetup /dev/loop1 /store/pc-1.cow

Now we have two devices, `/dev/loop0` which contains the master image, and `/dev/loop1` which will contain any changes made to the disk. The next step is to use dmsetup to create a `device mapper` which will layer the COW image ontop of the original image.

# create the cow!
echo "0 ${cow_size} snapshot /dev/loop0 /dev/loop1 p 64" | dmsetup create pc1

This will create a device called `/dev/mapper/pc1`. You can use it in your iSCSI setup with something like this in your `/etc/ietd.conf`:

Target iqn.2010-01.lan.someplace.iscsihost:pc1
        Lun 0 Path=/dev/mapper/pc1,Type=fileio

You can then start `ietd`.

Now the next part is writing a script to let you reset the COW images. `ietd` does not like you changing things while it is running, so you’ll need to make sure your script suspends all disk activity before blanking out the COW image. Something like this:

# disconnect the COW image #1
ietadm --op delete --tid 1 --lun 0

# suspend dm activity
dmsetup suspend pc1

# clear the cow cache
dd if=/dev/zero of=/dev/loop1

# reload the cow table
master="/dev/loop0"
cow_size=`blockdev --getsize ${master}`
echo "0 ${cow_size} snapshot ${master} /dev/loop1 p 64" | dmsetup reload pc1

# resume dm activity
dmsetup resume pc1

# reconnect the COW image #1
ietadm --op new --tid 1 --lun 0 --params Path=/dev/mapper/pc1

You could change this script around so that it allows you to pass in a PC number as a command-line argument, and then hook in a CGI script that will call it to reset it remotely. In my setup, I’m using gPXE to boot from iSCSI, but it can also be used to access a URL via HTTP. So your CGI script reads in the request IP address, and if it is one of the resettable machines, it will reset it’s COW image. Then it sends back a gPXE script instructing it to run a DOS .com file that will reboot the computer. For this to work you need to have your CGI script execute the command as the superuser (root).

One of the things about the COWs is if you reset them or they become full while Windows is running, Windows will very soon crash, and refuse to boot up again. To better inform both yourself and users about the usage levels, you can read the information from `dmsetup`:

# dmsetup status pc8
0 8385930 snapshot 55296/409600

In this example, it is indicating that the full image is 8385930 sectors, and 55296 of 409600 sectors are used in the COW image. So I wrote a Python CGI script that reports this in a parsable fashion to clients:

#!/usr/bin/env python

print "Content-Type: text/plain\r\n\r"

from os import environ
from subprocess import Popen, PIPE

ip = environ['REMOTE_ADDR']
d = int(ip.split(".")[3])
if d >= 41 and d <= 54:
  machine = d - 40
  try:
    p = Popen(('/sbin/dmsetup', 'status', 'retrocow%d' % machine), stdout=PIPE, stderr=PIPE)
    stdout, stderr = p.communicate()
    use, total = stdout.split(' ')[3].split('/')
    use, total = long(use), long(total)
    print "OK %d %d" % (use, total)
  except:
    print "ERR Problem getting parsing information"
else:
  # return error
  print "ERR Not a RetroLAN Machine"

For me, the RetroLAN machines have IPs ending in 41 to 54. That corresponds to their PC number (retro-01 to retro-14). This script outputs the following text file when requested via CGI if successful:

OK 55296 409600

This isn’t very usable for the end user, so I wrote a .NET 2.0 app called `CowBell` that runs in the system tray showing the percentage of COW usage, and notifies them if they’re over 75% usage (which means they will crash soon). I’ve made source code available for download, which you’ll need to modify `frmMain.cs` line 37 to include the path to where you put the CGI script, and uncomment the line otherwise it will not compile. If you make modifications to this program I do ask that you share your improvements with me.

This is the message that constantly pops up when you’re over 75% usage:

The application refreshes it’s status every 10 seconds, and if you right-click the icon it shows the COW usage in sectors.