--- a/src/video/ps2gs/SDL_gsvideo.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/video/ps2gs/SDL_gsvideo.c	Mon Jul 10 21:04:37 2006 +0000
@@ -42,648 +42,648 @@
 
 
 /* Initialization/Query functions */
-static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat);
-static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
-static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
-static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
+static int GS_VideoInit(_THIS, SDL_PixelFormat * vformat);
+static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags);
+static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface * current, int width,
+                                    int height, int bpp, Uint32 flags);
+static int GS_SetColors(_THIS, int firstcolor, int ncolors,
+                        SDL_Color * colors);
 static void GS_VideoQuit(_THIS);
 
 /* Hardware surface functions */
-static int GS_AllocHWSurface(_THIS, SDL_Surface *surface);
-static int GS_LockHWSurface(_THIS, SDL_Surface *surface);
-static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface);
-static void GS_FreeHWSurface(_THIS, SDL_Surface *surface);
+static int GS_AllocHWSurface(_THIS, SDL_Surface * surface);
+static int GS_LockHWSurface(_THIS, SDL_Surface * surface);
+static void GS_UnlockHWSurface(_THIS, SDL_Surface * surface);
+static void GS_FreeHWSurface(_THIS, SDL_Surface * surface);
 
 /* GS driver bootstrap functions */
 
-static int GS_Available(void)
+static int
+GS_Available(void)
 {
-	int console, memory;
+    int console, memory;
 
-	console = open(PS2_DEV_GS, O_RDWR, 0);
-	if ( console >= 0 ) {
-		close(console);
-	}
-	memory = open(PS2_DEV_MEM, O_RDWR, 0);
-	if ( memory >= 0 ) {
-		close(memory);
-	}
-	return((console >= 0) && (memory >= 0));
+    console = open(PS2_DEV_GS, O_RDWR, 0);
+    if (console >= 0) {
+        close(console);
+    }
+    memory = open(PS2_DEV_MEM, O_RDWR, 0);
+    if (memory >= 0) {
+        close(memory);
+    }
+    return ((console >= 0) && (memory >= 0));
 }
 
-static void GS_DeleteDevice(SDL_VideoDevice *device)
+static void
+GS_DeleteDevice(SDL_VideoDevice * device)
 {
-	SDL_free(device->hidden);
-	SDL_free(device);
+    SDL_free(device->hidden);
+    SDL_free(device);
 }
 
-static SDL_VideoDevice *GS_CreateDevice(int devindex)
+static SDL_VideoDevice *
+GS_CreateDevice(int devindex)
 {
-	SDL_VideoDevice *this;
+    SDL_VideoDevice *this;
 
-	/* Initialize all variables that we clean on shutdown */
-	this = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
-	if ( this ) {
-		SDL_memset(this, 0, (sizeof *this));
-		this->hidden = (struct SDL_PrivateVideoData *)
-				SDL_malloc((sizeof *this->hidden));
-	}
-	if ( (this == NULL) || (this->hidden == NULL) ) {
-		SDL_OutOfMemory();
-		if ( this ) {
-			SDL_free(this);
-		}
-		return(0);
-	}
-	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
-	mouse_fd = -1;
-	keyboard_fd = -1;
+    /* Initialize all variables that we clean on shutdown */
+    this = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
+    if (this) {
+        SDL_memset(this, 0, (sizeof *this));
+        this->hidden = (struct SDL_PrivateVideoData *)
+            SDL_malloc((sizeof *this->hidden));
+    }
+    if ((this == NULL) || (this->hidden == NULL)) {
+        SDL_OutOfMemory();
+        if (this) {
+            SDL_free(this);
+        }
+        return (0);
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+    mouse_fd = -1;
+    keyboard_fd = -1;
 
-	/* Set the function pointers */
-	this->VideoInit = GS_VideoInit;
-	this->ListModes = GS_ListModes;
-	this->SetVideoMode = GS_SetVideoMode;
-	this->CreateYUVOverlay = GS_CreateYUVOverlay;
-	this->SetColors = GS_SetColors;
-	this->UpdateRects = NULL;
-	this->VideoQuit = GS_VideoQuit;
-	this->AllocHWSurface = GS_AllocHWSurface;
-	this->CheckHWBlit = NULL;
-	this->FillHWRect = NULL;
-	this->SetHWColorKey = NULL;
-	this->SetHWAlpha = NULL;
-	this->LockHWSurface = GS_LockHWSurface;
-	this->UnlockHWSurface = GS_UnlockHWSurface;
-	this->FlipHWSurface = NULL;
-	this->FreeHWSurface = GS_FreeHWSurface;
-	this->SetIcon = NULL;
-	this->SetCaption = NULL;
-	this->GetWMInfo = NULL;
-	this->FreeWMCursor = GS_FreeWMCursor;
-	this->CreateWMCursor = GS_CreateWMCursor;
-	this->ShowWMCursor = GS_ShowWMCursor;
-	this->MoveWMCursor = GS_MoveWMCursor;
-	this->InitOSKeymap = GS_InitOSKeymap;
-	this->PumpEvents = GS_PumpEvents;
+    /* Set the function pointers */
+    this->VideoInit = GS_VideoInit;
+    this->ListModes = GS_ListModes;
+    this->SetVideoMode = GS_SetVideoMode;
+    this->CreateYUVOverlay = GS_CreateYUVOverlay;
+    this->SetColors = GS_SetColors;
+    this->UpdateRects = NULL;
+    this->VideoQuit = GS_VideoQuit;
+    this->AllocHWSurface = GS_AllocHWSurface;
+    this->CheckHWBlit = NULL;
+    this->FillHWRect = NULL;
+    this->SetHWColorKey = NULL;
+    this->SetHWAlpha = NULL;
+    this->LockHWSurface = GS_LockHWSurface;
+    this->UnlockHWSurface = GS_UnlockHWSurface;
+    this->FlipHWSurface = NULL;
+    this->FreeHWSurface = GS_FreeHWSurface;
+    this->SetIcon = NULL;
+    this->SetCaption = NULL;
+    this->GetWMInfo = NULL;
+    this->FreeWMCursor = GS_FreeWMCursor;
+    this->CreateWMCursor = GS_CreateWMCursor;
+    this->ShowWMCursor = GS_ShowWMCursor;
+    this->MoveWMCursor = GS_MoveWMCursor;
+    this->InitOSKeymap = GS_InitOSKeymap;
+    this->PumpEvents = GS_PumpEvents;
 
-	this->free = GS_DeleteDevice;
+    this->free = GS_DeleteDevice;
 
-	return this;
+    return this;
 }
 
 VideoBootStrap PS2GS_bootstrap = {
-	"ps2gs", "PlayStation 2 Graphics Synthesizer",
-	GS_Available, GS_CreateDevice
+    "ps2gs", "PlayStation 2 Graphics Synthesizer",
+    GS_Available, GS_CreateDevice
 };
 
 /* These are the pixel formats for the 32, 24, and 16 bit video modes */
-static struct {
-	int bpp;
-	Uint32 r;
-	Uint32 g;
-	Uint32 b;
+static struct
+{
+    int bpp;
+    Uint32 r;
+    Uint32 g;
+    Uint32 b;
 } GS_pixelmasks[] = {
-	{ 32, 0x000000FF,	/* RGB little-endian */
-	      0x0000FF00,
-	      0x00FF0000 },
-	{ 24, 0x000000FF,	/* RGB little-endian */
-	      0x0000FF00,
-	      0x00FF0000 },
-	{ 16, 0x0000001f,	/* RGB little-endian */
-	      0x000003e0,
-	      0x00007c00 },
-};
+    {
+        32, 0x000000FF,         /* RGB little-endian */
+    0x0000FF00, 0x00FF0000}, {
+        24, 0x000000FF,         /* RGB little-endian */
+    0x0000FF00, 0x00FF0000}, {
+        16, 0x0000001f,         /* RGB little-endian */
+0x000003e0, 0x00007c00},};
+
 /* This is a mapping from SDL bytes-per-pixel to GS pixel format */
 static int GS_formatmap[] = {
-	-1,		/* 0 bpp, not a legal value */
-	-1,		/* 8 bpp, not supported (yet?) */
-	PS2_GS_PSMCT16,	/* 16 bpp */
-	PS2_GS_PSMCT24,	/* 24 bpp */
-	PS2_GS_PSMCT32	/* 32 bpp */
+    -1,                         /* 0 bpp, not a legal value */
+    -1,                         /* 8 bpp, not supported (yet?) */
+    PS2_GS_PSMCT16,             /* 16 bpp */
+    PS2_GS_PSMCT24,             /* 24 bpp */
+    PS2_GS_PSMCT32              /* 32 bpp */
 };
 
-static unsigned long long head_tags[] __attribute__((aligned(16))) = {
-	4 | (1LL << 60),	/* GIFtag */
-	0x0e,			/* A+D */
-	0,			/* 2 */
-	PS2_GS_BITBLTBUF,
-	0,			/* 4 */
-	PS2_GS_TRXPOS,
-	0,			/* 6 */
-	PS2_GS_TRXREG,
-	0,			/* 8 */
-	PS2_GS_TRXDIR
-};
+static unsigned long long head_tags[] __attribute__ ((aligned(16))) = {
+    4 | (1LL << 60),            /* GIFtag */
+        0x0e,                   /* A+D */
+        0,                      /* 2 */
+        PS2_GS_BITBLTBUF, 0,    /* 4 */
+        PS2_GS_TRXPOS, 0,       /* 6 */
+        PS2_GS_TRXREG, 0,       /* 8 */
+PS2_GS_TRXDIR};
 
 #define MAXIMG		(32767 * 16)
 #define MAXTAGS		8
 
-static inline int loadimage_nonblock(int fd, struct ps2_image *image, int size,
-                                     unsigned long long *hm,
-                                     unsigned long long *im)
+static inline int
+loadimage_nonblock(int fd, struct ps2_image *image, int size,
+                   unsigned long long *hm, unsigned long long *im)
 {
-	struct ps2_plist plist;
-	struct ps2_packet packet[1 + MAXTAGS * 2];
-	int isize;
-	int pnum, it, eop;
-	char *data;
+    struct ps2_plist plist;
+    struct ps2_packet packet[1 + MAXTAGS * 2];
+    int isize;
+    int pnum, it, eop;
+    char *data;
 
-	/* initialize the variables */
-	data = (char *)image->ptr;
-	pnum = it = eop = 0;
-	plist.packet = packet;
+    /* initialize the variables */
+    data = (char *) image->ptr;
+    pnum = it = eop = 0;
+    plist.packet = packet;
 
-	/* make BITBLT packet */
-	packet[pnum].ptr = hm;
-	packet[pnum].len = sizeof(head_tags);
-	pnum++;
-	hm[2] = ((unsigned long long)image->fbp << 32) |
-	        ((unsigned long long)image->fbw << 48) |
-	        ((unsigned long long)image->psm << 56);
-	hm[4] = ((unsigned long long)image->x << 32) |
-	        ((unsigned long long)image->y << 48);
-	hm[6] = (unsigned long long)image->w |
-	        ((unsigned long long)image->h << 32);
+    /* make BITBLT packet */
+    packet[pnum].ptr = hm;
+    packet[pnum].len = sizeof(head_tags);
+    pnum++;
+    hm[2] = ((unsigned long long) image->fbp << 32) |
+        ((unsigned long long) image->fbw << 48) |
+        ((unsigned long long) image->psm << 56);
+    hm[4] = ((unsigned long long) image->x << 32) |
+        ((unsigned long long) image->y << 48);
+    hm[6] = (unsigned long long) image->w |
+        ((unsigned long long) image->h << 32);
 
-	/* make image mode tags */
-	while (!eop) {
-		isize = size > MAXIMG ? MAXIMG : size;
-		size -= isize;
-		eop = (size == 0);
+    /* make image mode tags */
+    while (!eop) {
+        isize = size > MAXIMG ? MAXIMG : size;
+        size -= isize;
+        eop = (size == 0);
 
-		packet[pnum].ptr = &im[it];
-		packet[pnum].len = sizeof(unsigned long long) * 2;
-		pnum++;
-		im[it++] = (isize >> 4) | (eop ? (1 << 15) : 0) | (2LL << 58);
-		im[it++] = 0;
+        packet[pnum].ptr = &im[it];
+        packet[pnum].len = sizeof(unsigned long long) * 2;
+        pnum++;
+        im[it++] = (isize >> 4) | (eop ? (1 << 15) : 0) | (2LL << 58);
+        im[it++] = 0;
 
-		packet[pnum].ptr = (void *)data;
-		packet[pnum].len = isize;
-		pnum++;
-		data += isize;
-	}
-	plist.num = pnum;
+        packet[pnum].ptr = (void *) data;
+        packet[pnum].len = isize;
+        pnum++;
+        data += isize;
+    }
+    plist.num = pnum;
 
-	return ioctl(fd, PS2IOC_SENDL, &plist);
+    return ioctl(fd, PS2IOC_SENDL, &plist);
 }
 
-static unsigned long long tex_tags[] __attribute__((aligned(16))) = {
-	3 | (1LL << 60),	/* GIFtag */
-	0x0e,			/* A+D */
-	0,			/* 2 */
-	PS2_GS_TEX0_1,
-	(1 << 5) + (1 << 6),
-	PS2_GS_TEX1_1,
-	0,
-	PS2_GS_TEXFLUSH
-};
-static unsigned long long scale_tags[] __attribute__((aligned(16))) = {
-	5 | (1LL << 60),	/* GIFtag */
-	0x0e,			/* A+D */
-	6 + (1 << 4) + (1 << 8),
-	PS2_GS_PRIM,
-	((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
-	PS2_GS_UV,
-	((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
-	PS2_GS_XYZ2,
-	0,			/* 8 */
-	PS2_GS_UV,
-	0,			/* 10 */
-	PS2_GS_XYZ2
-};
+static unsigned long long tex_tags[] __attribute__ ((aligned(16))) = {
+    3 | (1LL << 60),            /* GIFtag */
+        0x0e,                   /* A+D */
+        0,                      /* 2 */
+PS2_GS_TEX0_1, (1 << 5) + (1 << 6), PS2_GS_TEX1_1, 0, PS2_GS_TEXFLUSH};
+static unsigned long long scale_tags[] __attribute__ ((aligned(16))) = {
+    5 | (1LL << 60),            /* GIFtag */
+        0x0e,                   /* A+D */
+        6 + (1 << 4) + (1 << 8), PS2_GS_PRIM, ((unsigned long long) 0 * 16) + (((unsigned long long) 0 * 16) << 16), PS2_GS_UV, ((unsigned long long) 0 * 16) + (((unsigned long long) 0 * 16) << 16), PS2_GS_XYZ2, 0,  /* 8 */
+        PS2_GS_UV, 0,           /* 10 */
+PS2_GS_XYZ2};
 
 
-int scaleimage_nonblock(int fd, unsigned long long *tm, unsigned long long *sm)
+int
+scaleimage_nonblock(int fd, unsigned long long *tm, unsigned long long *sm)
 {
-	struct ps2_plist plist;
-	struct ps2_packet packet[2];
+    struct ps2_plist plist;
+    struct ps2_packet packet[2];
 
-	/* initialize the variables */
-	plist.num = 2;
-	plist.packet = packet;
+    /* initialize the variables */
+    plist.num = 2;
+    plist.packet = packet;
 
-	packet[0].ptr = tm;
-	packet[0].len = sizeof(tex_tags);
-	packet[1].ptr = sm;
-	packet[1].len = sizeof(scale_tags);
+    packet[0].ptr = tm;
+    packet[0].len = sizeof(tex_tags);
+    packet[1].ptr = sm;
+    packet[1].len = sizeof(scale_tags);
 
-	return ioctl(fd, PS2IOC_SENDL, &plist);
+    return ioctl(fd, PS2IOC_SENDL, &plist);
 }
 
-static int power_of_2(int value)
+static int
+power_of_2(int value)
 {
-	int shift;
+    int shift;
 
-	for ( shift = 0; (1<<shift) < value; ++shift ) {
-		/* Keep looking */ ;
-	}
-	return(shift);
+    for (shift = 0; (1 << shift) < value; ++shift) {
+        /* Keep looking */ ;
+    }
+    return (shift);
 }
 
-static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat)
+static int
+GS_VideoInit(_THIS, SDL_PixelFormat * vformat)
 {
-	struct ps2_screeninfo vinfo;
+    struct ps2_screeninfo vinfo;
 
-	/* Initialize the library */
-	console_fd = open(PS2_DEV_GS, O_RDWR, 0);
-	if ( console_fd < 0 ) {
-		SDL_SetError("Unable to open %s", PS2_DEV_GS);
-		return(-1);
-	}
-	memory_fd = open(PS2_DEV_MEM, O_RDWR, 0);
-	if ( memory_fd < 0 ) {
-		close(console_fd);
-		console_fd = -1;
-		SDL_SetError("Unable to open %s", PS2_DEV_MEM);
-		return(-1);
-	}
+    /* Initialize the library */
+    console_fd = open(PS2_DEV_GS, O_RDWR, 0);
+    if (console_fd < 0) {
+        SDL_SetError("Unable to open %s", PS2_DEV_GS);
+        return (-1);
+    }
+    memory_fd = open(PS2_DEV_MEM, O_RDWR, 0);
+    if (memory_fd < 0) {
+        close(console_fd);
+        console_fd = -1;
+        SDL_SetError("Unable to open %s", PS2_DEV_MEM);
+        return (-1);
+    }
 
-	if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
-		close(memory_fd);
-		close(console_fd);
-		console_fd = -1;
-		SDL_SetError("Couldn't get console pixel format");
-		return(-1);
-	}
+    if (ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0) {
+        close(memory_fd);
+        close(console_fd);
+        console_fd = -1;
+        SDL_SetError("Couldn't get console pixel format");
+        return (-1);
+    }
 
-	/* Determine the current screen size */
-	this->info.current_w = vinfo.w;
-	this->info.current_h = vinfo.h;
+    /* Determine the current screen size */
+    this->info.current_w = vinfo.w;
+    this->info.current_h = vinfo.h;
 
-	/* Determine the current screen depth */
-	switch (vinfo.psm) {
-	    /* Supported pixel formats */
-	    case PS2_GS_PSMCT32:
-	    case PS2_GS_PSMCT24:
-	    case PS2_GS_PSMCT16:
-		break;
-	    default:
-		GS_VideoQuit(this);
-		SDL_SetError("Unknown console pixel format: %d", vinfo.psm);
-		return(-1);
-	}
-	vformat->BitsPerPixel = GS_pixelmasks[vinfo.psm].bpp;
-	vformat->Rmask = GS_pixelmasks[vinfo.psm].r;
-	vformat->Gmask = GS_pixelmasks[vinfo.psm].g;
-	vformat->Bmask = GS_pixelmasks[vinfo.psm].b;
-	saved_vinfo = vinfo;
+    /* Determine the current screen depth */
+    switch (vinfo.psm) {
+        /* Supported pixel formats */
+    case PS2_GS_PSMCT32:
+    case PS2_GS_PSMCT24:
+    case PS2_GS_PSMCT16:
+        break;
+    default:
+        GS_VideoQuit(this);
+        SDL_SetError("Unknown console pixel format: %d", vinfo.psm);
+        return (-1);
+    }
+    vformat->BitsPerPixel = GS_pixelmasks[vinfo.psm].bpp;
+    vformat->Rmask = GS_pixelmasks[vinfo.psm].r;
+    vformat->Gmask = GS_pixelmasks[vinfo.psm].g;
+    vformat->Bmask = GS_pixelmasks[vinfo.psm].b;
+    saved_vinfo = vinfo;
 
-	/* Enable mouse and keyboard support */
-	if ( GS_OpenKeyboard(this) < 0 ) {
-		GS_VideoQuit(this);
-		SDL_SetError("Unable to open keyboard");
-		return(-1);
-	}
-	if ( GS_OpenMouse(this) < 0 ) {
-		const char *sdl_nomouse;
+    /* Enable mouse and keyboard support */
+    if (GS_OpenKeyboard(this) < 0) {
+        GS_VideoQuit(this);
+        SDL_SetError("Unable to open keyboard");
+        return (-1);
+    }
+    if (GS_OpenMouse(this) < 0) {
+        const char *sdl_nomouse;
 
-		sdl_nomouse = SDL_getenv("SDL_NOMOUSE");
-		if ( ! sdl_nomouse ) {
-			GS_VideoQuit(this);
-			SDL_SetError("Unable to open mouse");
-			return(-1);
-		}
-	}
+        sdl_nomouse = SDL_getenv("SDL_NOMOUSE");
+        if (!sdl_nomouse) {
+            GS_VideoQuit(this);
+            SDL_SetError("Unable to open mouse");
+            return (-1);
+        }
+    }
 
-	/* We're done! */
-	return(0);
+    /* We're done! */
+    return (0);
 }
 
-static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
+static SDL_Rect **
+GS_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
 {
-	static SDL_Rect GS_vesa_mode_list[] = {
-		{ 0, 0, 1280, 1024 },
-		{ 0, 0, 1024, 768 },
-		{ 0, 0, 800, 600 },
-		{ 0, 0, 640, 480 }
-	};
-	static SDL_Rect *GS_vesa_modes[] = {
-		&GS_vesa_mode_list[0],
-		&GS_vesa_mode_list[1],
-		&GS_vesa_mode_list[2],
-		&GS_vesa_mode_list[3],
-		NULL
-	};
-	static SDL_Rect GS_tvout_stretch;
-	static SDL_Rect GS_tvout_mode;
-	static SDL_Rect *GS_tvout_modes[3];
-	SDL_Rect **modes = NULL;
+    static SDL_Rect GS_vesa_mode_list[] = {
+        {0, 0, 1280, 1024},
+        {0, 0, 1024, 768},
+        {0, 0, 800, 600},
+        {0, 0, 640, 480}
+    };
+    static SDL_Rect *GS_vesa_modes[] = {
+        &GS_vesa_mode_list[0],
+        &GS_vesa_mode_list[1],
+        &GS_vesa_mode_list[2],
+        &GS_vesa_mode_list[3],
+        NULL
+    };
+    static SDL_Rect GS_tvout_stretch;
+    static SDL_Rect GS_tvout_mode;
+    static SDL_Rect *GS_tvout_modes[3];
+    SDL_Rect **modes = NULL;
 
-	switch (format->BitsPerPixel) {
-	    case 16:
-	    case 24:
-	    case 32:
-		if ( saved_vinfo.mode == PS2_GS_VESA ) {
-			modes = GS_vesa_modes;
-		} else {
-			int i, j = 0;
+    switch (format->BitsPerPixel) {
+    case 16:
+    case 24:
+    case 32:
+        if (saved_vinfo.mode == PS2_GS_VESA) {
+            modes = GS_vesa_modes;
+        } else {
+            int i, j = 0;
 
 // FIXME - what's wrong with the stretch code at 16 bpp?
-if ( format->BitsPerPixel != 32 ) break;
-			/* Add a mode that we could possibly stretch to */
-			for ( i=0; GS_vesa_modes[i]; ++i ) {
-				if ( (GS_vesa_modes[i]->w == saved_vinfo.w) &&
-				     (GS_vesa_modes[i]->h != saved_vinfo.h) ) {
-					GS_tvout_stretch.w=GS_vesa_modes[i]->w;
-					GS_tvout_stretch.h=GS_vesa_modes[i]->h;
-					GS_tvout_modes[j++] = &GS_tvout_stretch;
-					break;
-				}
-			}
-			/* Add the current TV video mode */
-			GS_tvout_mode.w = saved_vinfo.w;
-			GS_tvout_mode.h = saved_vinfo.h;
-			GS_tvout_modes[j++] = &GS_tvout_mode;
-			GS_tvout_modes[j++] = NULL;
+            if (format->BitsPerPixel != 32)
+                break;
+            /* Add a mode that we could possibly stretch to */
+            for (i = 0; GS_vesa_modes[i]; ++i) {
+                if ((GS_vesa_modes[i]->w == saved_vinfo.w) &&
+                    (GS_vesa_modes[i]->h != saved_vinfo.h)) {
+                    GS_tvout_stretch.w = GS_vesa_modes[i]->w;
+                    GS_tvout_stretch.h = GS_vesa_modes[i]->h;
+                    GS_tvout_modes[j++] = &GS_tvout_stretch;
+                    break;
+                }
+            }
+            /* Add the current TV video mode */
+            GS_tvout_mode.w = saved_vinfo.w;
+            GS_tvout_mode.h = saved_vinfo.h;
+            GS_tvout_modes[j++] = &GS_tvout_mode;
+            GS_tvout_modes[j++] = NULL;
 
-			/* Return the created list of modes */
-			modes = GS_tvout_modes;
-		}
-		break;
-	    default:
-		break;
-	}
-	return(modes);
+            /* Return the created list of modes */
+            modes = GS_tvout_modes;
+        }
+        break;
+    default:
+        break;
+    }
+    return (modes);
 }
 
 /* Various screen update functions available */
-static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects);
+static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect * rects);
 
-static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current,
-				int width, int height, int bpp, Uint32 flags)
+static SDL_Surface *
+GS_SetVideoMode(_THIS, SDL_Surface * current,
+                int width, int height, int bpp, Uint32 flags)
 {
-	struct ps2_screeninfo vinfo;
+    struct ps2_screeninfo vinfo;
 
-	/* Set the terminal into graphics mode */
-	if ( GS_EnterGraphicsMode(this) < 0 ) {
-		return(NULL);
-	}
+    /* Set the terminal into graphics mode */
+    if (GS_EnterGraphicsMode(this) < 0) {
+        return (NULL);
+    }
 
-	/* Set the video mode and get the final screen format */
-	if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
-		SDL_SetError("Couldn't get console screen info");
-		return(NULL);
-	}
-	if ( (vinfo.w != width) || (vinfo.h != height) ||
-	     (GS_pixelmasks[vinfo.psm].bpp != bpp) ) {
-		/* If we're not in VESA mode, we have to scale resolution */
-		if ( saved_vinfo.mode == PS2_GS_VESA ) {
-			switch (width) {
-			    case 640:
-				vinfo.res = PS2_GS_640x480;
-				break;
-			    case 800:
-				vinfo.res = PS2_GS_800x600;
-				break;
-			    case 1024:
-				vinfo.res = PS2_GS_1024x768;
-				break;
-			    case 1280:
-				vinfo.res = PS2_GS_1280x1024;
-				break;
-			    default:
-				SDL_SetError("Unsupported resolution: %dx%d\n",
-					     width, height);
-				return(NULL);
-			}
-			vinfo.res |= (PS2_GS_75Hz << 8);
-			vinfo.w = width;
-			vinfo.h = height;
-		}
-		vinfo.fbp = 0;
-		vinfo.psm = GS_formatmap[bpp/8];
-		if ( vinfo.psm < 0 ) {
-			SDL_SetError("Unsupported depth: %d bpp\n", bpp);
-			return(NULL);
-		}
-		if ( ioctl(console_fd, PS2IOC_SSCREENINFO, &vinfo) < 0 ) {
-			SDL_SetError("Couldn't set console screen info");
-			return(NULL);
-		}
+    /* Set the video mode and get the final screen format */
+    if (ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0) {
+        SDL_SetError("Couldn't get console screen info");
+        return (NULL);
+    }
+    if ((vinfo.w != width) || (vinfo.h != height) ||
+        (GS_pixelmasks[vinfo.psm].bpp != bpp)) {
+        /* If we're not in VESA mode, we have to scale resolution */
+        if (saved_vinfo.mode == PS2_GS_VESA) {
+            switch (width) {
+            case 640:
+                vinfo.res = PS2_GS_640x480;
+                break;
+            case 800:
+                vinfo.res = PS2_GS_800x600;
+                break;
+            case 1024:
+                vinfo.res = PS2_GS_1024x768;
+                break;
+            case 1280:
+                vinfo.res = PS2_GS_1280x1024;
+                break;
+            default:
+                SDL_SetError("Unsupported resolution: %dx%d\n",
+                             width, height);
+                return (NULL);
+            }
+            vinfo.res |= (PS2_GS_75Hz << 8);
+            vinfo.w = width;
+            vinfo.h = height;
+        }
+        vinfo.fbp = 0;
+        vinfo.psm = GS_formatmap[bpp / 8];
+        if (vinfo.psm < 0) {
+            SDL_SetError("Unsupported depth: %d bpp\n", bpp);
+            return (NULL);
+        }
+        if (ioctl(console_fd, PS2IOC_SSCREENINFO, &vinfo) < 0) {
+            SDL_SetError("Couldn't set console screen info");
+            return (NULL);
+        }
 
-		/* Unmap the previous DMA buffer */
-		if ( mapped_mem ) {
-			munmap(mapped_mem, mapped_len);
-			mapped_mem = NULL;
-		}
-	}
-	if ( ! SDL_ReallocFormat(current, GS_pixelmasks[vinfo.psm].bpp,
-	                                  GS_pixelmasks[vinfo.psm].r,
-	                                  GS_pixelmasks[vinfo.psm].g,
-	                                  GS_pixelmasks[vinfo.psm].b, 0) ) {
-		return(NULL);
-	}
+        /* Unmap the previous DMA buffer */
+        if (mapped_mem) {
+            munmap(mapped_mem, mapped_len);
+            mapped_mem = NULL;
+        }
+    }
+    if (!SDL_ReallocFormat(current, GS_pixelmasks[vinfo.psm].bpp,
+                           GS_pixelmasks[vinfo.psm].r,
+                           GS_pixelmasks[vinfo.psm].g,
+                           GS_pixelmasks[vinfo.psm].b, 0)) {
+        return (NULL);
+    }
 
-	/* Set up the new mode framebuffer */
-	current->flags = SDL_FULLSCREEN;
-	current->w = width;
-	current->h = height;
-	current->pitch = SDL_CalculatePitch(current);
+    /* Set up the new mode framebuffer */
+    current->flags = SDL_FULLSCREEN;
+    current->w = width;
+    current->h = height;
+    current->pitch = SDL_CalculatePitch(current);
 
-	/* Memory map the DMA area for block memory transfer */
-	if ( ! mapped_mem ) {
-		pixels_len = height * current->pitch;
-		mapped_len = pixels_len +
-		             /* Screen update DMA command area */
-		             sizeof(head_tags) + ((2 * MAXTAGS) * 16);
-		if ( saved_vinfo.mode != PS2_GS_VESA ) {
-			mapped_len += sizeof(tex_tags) + sizeof(scale_tags);
-		}
-		mapped_mem = mmap(0, mapped_len, PROT_READ|PROT_WRITE,
-		                  MAP_SHARED, memory_fd, 0);
-		if ( mapped_mem == MAP_FAILED ) {
-			SDL_SetError("Unable to map %d bytes for DMA",
-			             mapped_len);
-			mapped_mem = NULL;
-			return(NULL);
-		}
+    /* Memory map the DMA area for block memory transfer */
+    if (!mapped_mem) {
+        pixels_len = height * current->pitch;
+        mapped_len = pixels_len +
+            /* Screen update DMA command area */
+            sizeof(head_tags) + ((2 * MAXTAGS) * 16);
+        if (saved_vinfo.mode != PS2_GS_VESA) {
+            mapped_len += sizeof(tex_tags) + sizeof(scale_tags);
+        }
+        mapped_mem = mmap(0, mapped_len, PROT_READ | PROT_WRITE,
+                          MAP_SHARED, memory_fd, 0);
+        if (mapped_mem == MAP_FAILED) {
+            SDL_SetError("Unable to map %d bytes for DMA", mapped_len);
+            mapped_mem = NULL;
+            return (NULL);
+        }
 
-		/* Set up the entire screen for DMA transfer */
-		screen_image.ptr = mapped_mem;
-		screen_image.fbp = 0;
-		screen_image.fbw = (vinfo.w + 63) / 64;
-		screen_image.psm = vinfo.psm;
-		screen_image.x = 0;
-		if ( vinfo.h == height ) {
-			screen_image.y = 0;
-		} else {
-			/* Put image offscreen and scale to screen height */
-			screen_image.y = vinfo.h;
-		}
-		screen_image.w = current->w;
-		screen_image.h = current->h;
+        /* Set up the entire screen for DMA transfer */
+        screen_image.ptr = mapped_mem;
+        screen_image.fbp = 0;
+        screen_image.fbw = (vinfo.w + 63) / 64;
+        screen_image.psm = vinfo.psm;
+        screen_image.x = 0;
+        if (vinfo.h == height) {
+            screen_image.y = 0;
+        } else {
+            /* Put image offscreen and scale to screen height */
+            screen_image.y = vinfo.h;
+        }
+        screen_image.w = current->w;
+        screen_image.h = current->h;
 
-		/* get screen image data size (qword aligned) */
-		screen_image_size = (screen_image.w * screen_image.h);
-		switch (screen_image.psm) {
-		    case PS2_GS_PSMCT32:
-			screen_image_size *= 4;
-			break;
-		    case PS2_GS_PSMCT24:
-			screen_image_size *= 3;
-			break;
-		    case PS2_GS_PSMCT16:
-			screen_image_size *= 2;
-			break;
-		}
-		screen_image_size = (screen_image_size + 15) & ~15;
+        /* get screen image data size (qword aligned) */
+        screen_image_size = (screen_image.w * screen_image.h);
+        switch (screen_image.psm) {
+        case PS2_GS_PSMCT32:
+            screen_image_size *= 4;
+            break;
+        case PS2_GS_PSMCT24:
+            screen_image_size *= 3;
+            break;
+        case PS2_GS_PSMCT16:
+            screen_image_size *= 2;
+            break;
+        }
+        screen_image_size = (screen_image_size + 15) & ~15;
 
-		/* Set up the memory for screen update DMA commands */
-		head_tags_mem = (unsigned long long *)
-		                (mapped_mem + pixels_len);
-		image_tags_mem = (unsigned long long *)
-		                 ((caddr_t)head_tags_mem + sizeof(head_tags));
-		SDL_memcpy(head_tags_mem, head_tags, sizeof(head_tags));
-		if ( saved_vinfo.mode != PS2_GS_VESA ) {
-			tex_tags_mem = (unsigned long long *)
-		                 ((caddr_t)image_tags_mem + ((2*MAXTAGS)*16));
-			scale_tags_mem = (unsigned long long *)
-		                 ((caddr_t)tex_tags_mem + sizeof(tex_tags));
-			SDL_memcpy(tex_tags_mem, tex_tags, sizeof(tex_tags));
-			tex_tags_mem[2] = 
-				(vinfo.h * vinfo.w) / 64 +
-	          		((unsigned long long)screen_image.fbw << 14) +
-	          		((unsigned long long)screen_image.psm << 20) +
-	          		((unsigned long long)power_of_2(screen_image.w) << 26) +
-	          		((unsigned long long)power_of_2(screen_image.h) << 30) +
-	          		((unsigned long long)1 << 34) +
-	          		((unsigned long long)1 << 35);
-			SDL_memcpy(scale_tags_mem, scale_tags, sizeof(scale_tags));
-			scale_tags_mem[8] =
-				((unsigned long long)screen_image.w * 16) +
-			         (((unsigned long long)screen_image.h * 16) << 16);
-			scale_tags_mem[10] =
-				((unsigned long long)vinfo.w * 16) +
-			         (((unsigned long long)vinfo.h * 16) << 16);
-		}
-	}
-	current->pixels = NULL;
-	if ( SDL_getenv("SDL_FULLSCREEN_UPDATE") ) {
-		/* Correct semantics */
-		current->flags |= SDL_ASYNCBLIT;
-	} else {
-		/* We lie here - the screen memory isn't really the visible
-		   display memory and still requires an update, but this
-		   has the desired effect for most applications.
-		 */
-		current->flags |= SDL_HWSURFACE;
-	}
+        /* Set up the memory for screen update DMA commands */
+        head_tags_mem = (unsigned long long *) (mapped_mem + pixels_len);
+        image_tags_mem = (unsigned long long *)
+            ((caddr_t) head_tags_mem + sizeof(head_tags));
+        SDL_memcpy(head_tags_mem, head_tags, sizeof(head_tags));
+        if (saved_vinfo.mode != PS2_GS_VESA) {
+            tex_tags_mem = (unsigned long long *)
+                ((caddr_t) image_tags_mem + ((2 * MAXTAGS) * 16));
+            scale_tags_mem = (unsigned long long *)
+                ((caddr_t) tex_tags_mem + sizeof(tex_tags));
+            SDL_memcpy(tex_tags_mem, tex_tags, sizeof(tex_tags));
+            tex_tags_mem[2] =
+                (vinfo.h * vinfo.w) / 64 +
+                ((unsigned long long) screen_image.fbw << 14) +
+                ((unsigned long long) screen_image.psm << 20) +
+                ((unsigned long long) power_of_2(screen_image.w) << 26) +
+                ((unsigned long long) power_of_2(screen_image.h) << 30) +
+                ((unsigned long long) 1 << 34) +
+                ((unsigned long long) 1 << 35);
+            SDL_memcpy(scale_tags_mem, scale_tags, sizeof(scale_tags));
+            scale_tags_mem[8] =
+                ((unsigned long long) screen_image.w * 16) +
+                (((unsigned long long) screen_image.h * 16) << 16);
+            scale_tags_mem[10] =
+                ((unsigned long long) vinfo.w * 16) +
+                (((unsigned long long) vinfo.h * 16) << 16);
+        }
+    }
+    current->pixels = NULL;
+    if (SDL_getenv("SDL_FULLSCREEN_UPDATE")) {
+        /* Correct semantics */
+        current->flags |= SDL_ASYNCBLIT;
+    } else {
+        /* We lie here - the screen memory isn't really the visible
+           display memory and still requires an update, but this
+           has the desired effect for most applications.
+         */
+        current->flags |= SDL_HWSURFACE;
+    }
 
-	/* Set the update rectangle function */
-	this->UpdateRects = GS_DMAFullUpdate;
+    /* Set the update rectangle function */
+    this->UpdateRects = GS_DMAFullUpdate;
 
-	/* We're done */
-	return(current);
+    /* We're done */
+    return (current);
 }
 
 /* We don't support hardware surfaces yet */
-static int GS_AllocHWSurface(_THIS, SDL_Surface *surface)
+static int
+GS_AllocHWSurface(_THIS, SDL_Surface * surface)
 {
-	return(-1);
+    return (-1);
 }
-static void GS_FreeHWSurface(_THIS, SDL_Surface *surface)
-{
-	return;
-}
-static int GS_LockHWSurface(_THIS, SDL_Surface *surface)
+static void
+GS_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
-	if ( surface == this->screen ) {
-		/* Since mouse motion affects 'pixels', lock it */
-		SDL_LockCursor();
+    return;
+}
+static int
+GS_LockHWSurface(_THIS, SDL_Surface * surface)
+{
+    if (surface == this->screen) {
+        /* Since mouse motion affects 'pixels', lock it */
+        SDL_LockCursor();
 
-		/* Make sure any pending DMA has completed */
-		if ( dma_pending ) {
-			ioctl(console_fd, PS2IOC_SENDQCT, 1);
-			dma_pending = 0;
-		}
+        /* Make sure any pending DMA has completed */
+        if (dma_pending) {
+            ioctl(console_fd, PS2IOC_SENDQCT, 1);
+            dma_pending = 0;
+        }
 
-		/* If the cursor is drawn on the DMA area, remove it */
-		if ( cursor_drawn ) {
-			surface->pixels = mapped_mem + surface->offset;
-			SDL_EraseCursorNoLock(this->screen);
-			cursor_drawn = 0;
-		}
+        /* If the cursor is drawn on the DMA area, remove it */
+        if (cursor_drawn) {
+            surface->pixels = mapped_mem + surface->offset;
+            SDL_EraseCursorNoLock(this->screen);
+            cursor_drawn = 0;
+        }
 
-		/* Set the surface pixels to the base of the DMA area */
-		surface->pixels = mapped_mem;
+        /* Set the surface pixels to the base of the DMA area */
+        surface->pixels = mapped_mem;
 
-		/* We're finished! */
-		SDL_UnlockCursor();
-	}
-	return(0);
+        /* We're finished! */
+        SDL_UnlockCursor();
+    }
+    return (0);
 }
-static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface)
+static void
+GS_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
-	if ( surface == this->screen ) {
-		/* Since mouse motion affects 'pixels', lock it */
-		SDL_LockCursor();
-		surface->pixels = NULL;
-		SDL_UnlockCursor();
-	}
+    if (surface == this->screen) {
+        /* Since mouse motion affects 'pixels', lock it */
+        SDL_LockCursor();
+        surface->pixels = NULL;
+        SDL_UnlockCursor();
+    }
 }
 
-static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects)
+static void
+GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
-	/* Lock so we aren't interrupted by a mouse update */
-	SDL_LockCursor();
+    /* Lock so we aren't interrupted by a mouse update */
+    SDL_LockCursor();
 
-	/* Make sure any pending DMA has completed */
-	if ( dma_pending ) {
-		ioctl(console_fd, PS2IOC_SENDQCT, 1);
-		dma_pending = 0;
-	}
+    /* Make sure any pending DMA has completed */
+    if (dma_pending) {
+        ioctl(console_fd, PS2IOC_SENDQCT, 1);
+        dma_pending = 0;
+    }
 
-	/* If the mouse is visible, draw it on the DMA area */
-	if ( (SDL_cursorstate & CURSOR_VISIBLE) && !cursor_drawn ) {
-		this->screen->pixels = mapped_mem + this->screen->offset;
-		SDL_DrawCursorNoLock(this->screen);
-		this->screen->pixels = NULL;
-		cursor_drawn = 1;
-	}
+    /* If the mouse is visible, draw it on the DMA area */
+    if ((SDL_cursorstate & CURSOR_VISIBLE) && !cursor_drawn) {
+        this->screen->pixels = mapped_mem + this->screen->offset;
+        SDL_DrawCursorNoLock(this->screen);
+        this->screen->pixels = NULL;
+        cursor_drawn = 1;
+    }
 
-	/* Put the image onto the screen */
-	loadimage_nonblock(console_fd,
-	                   &screen_image, screen_image_size,
-	                   head_tags_mem, image_tags_mem);
-	if ( screen_image.y > 0 ) {
-		/* Need to scale offscreen image to TV output */
-		ioctl(console_fd, PS2IOC_SENDQCT, 1);
-		dma_pending = 0;
-		scaleimage_nonblock(console_fd, tex_tags_mem, scale_tags_mem);
-	} else {
-		dma_pending = 1;
-	}
+    /* Put the image onto the screen */
+    loadimage_nonblock(console_fd,
+                       &screen_image, screen_image_size,
+                       head_tags_mem, image_tags_mem);
+    if (screen_image.y > 0) {
+        /* Need to scale offscreen image to TV output */
+        ioctl(console_fd, PS2IOC_SENDQCT, 1);
+        dma_pending = 0;
+        scaleimage_nonblock(console_fd, tex_tags_mem, scale_tags_mem);
+    } else {
+        dma_pending = 1;
+    }
 
-	/* We're finished! */
-	SDL_UnlockCursor();
+    /* We're finished! */
+    SDL_UnlockCursor();
 }
 
-static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+static int
+GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
 {
-	return(0);
+    return (0);
 }
 
-static void GS_VideoQuit(_THIS)
+static void
+GS_VideoQuit(_THIS)
 {
-	/* Close console and input file descriptors */
-	if ( console_fd > 0 ) {
-		/* Unmap the video framebuffer */
-		if ( mapped_mem ) {
-			/* Unmap the video framebuffer */
-			munmap(mapped_mem, mapped_len);
-			mapped_mem = NULL;
-		}
-		close(memory_fd);
+    /* Close console and input file descriptors */
+    if (console_fd > 0) {
+        /* Unmap the video framebuffer */
+        if (mapped_mem) {
+            /* Unmap the video framebuffer */
+            munmap(mapped_mem, mapped_len);
+            mapped_mem = NULL;
+        }
+        close(memory_fd);
 
-		/* Restore the original video mode */
-		if ( GS_InGraphicsMode(this) ) {
-			ioctl(console_fd, PS2IOC_SSCREENINFO, &saved_vinfo);
-		}
+        /* Restore the original video mode */
+        if (GS_InGraphicsMode(this)) {
+            ioctl(console_fd, PS2IOC_SSCREENINFO, &saved_vinfo);
+        }
 
-		/* We're all done with the graphics device */
-		close(console_fd);
-		console_fd = -1;
-	}
-	GS_CloseMouse(this);
-	GS_CloseKeyboard(this);
+        /* We're all done with the graphics device */
+        close(console_fd);
+        console_fd = -1;
+    }
+    GS_CloseMouse(this);
+    GS_CloseKeyboard(this);
 }
+
+/* vi: set ts=4 sw=4 expandtab: */