--- a/src/video/ps2gs/SDL_gsyuv.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/video/ps2gs/SDL_gsyuv.c	Mon Jul 10 21:04:37 2006 +0000
@@ -27,435 +27,445 @@
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
-#include <asm/page.h>		/* For definition of PAGE_SIZE */
+#include <asm/page.h>           /* For definition of PAGE_SIZE */
 
 #include "SDL_video.h"
 #include "SDL_gsyuv_c.h"
 #include "../SDL_yuvfuncs.h"
 
 /* The maximum number of 16x16 pixel block converted at once */
-#define MAX_MACROBLOCKS	1024	/* 2^10 macroblocks at once */
+#define MAX_MACROBLOCKS	1024    /* 2^10 macroblocks at once */
 
 /* The functions used to manipulate video overlays */
 static struct private_yuvhwfuncs gs_yuvfuncs = {
-	GS_LockYUVOverlay,
-	GS_UnlockYUVOverlay,
-	GS_DisplayYUVOverlay,
-	GS_FreeYUVOverlay
+    GS_LockYUVOverlay,
+    GS_UnlockYUVOverlay,
+    GS_DisplayYUVOverlay,
+    GS_FreeYUVOverlay
 };
 
-struct private_yuvhwdata {
-	int ipu_fd;
-	Uint8 *pixels;
-	int macroblocks;
-	int dma_len;
-	caddr_t dma_mem;
-	caddr_t ipu_imem;
-	caddr_t ipu_omem;
-	caddr_t dma_tags;
-	unsigned long long *stretch_x1y1;
-	unsigned long long *stretch_x2y2;
-	struct ps2_plist plist;
+struct private_yuvhwdata
+{
+    int ipu_fd;
+    Uint8 *pixels;
+    int macroblocks;
+    int dma_len;
+    caddr_t dma_mem;
+    caddr_t ipu_imem;
+    caddr_t ipu_omem;
+    caddr_t dma_tags;
+    unsigned long long *stretch_x1y1;
+    unsigned long long *stretch_x2y2;
+    struct ps2_plist plist;
 
-	/* These are just so we don't have to allocate them separately */
-	Uint16 pitches[3];
-	Uint8 *planes[3];
+    /* These are just so we don't have to allocate them separately */
+    Uint16 pitches[3];
+    Uint8 *planes[3];
 };
 
-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);
 }
 
-SDL_Overlay *GS_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, SDL_Surface *display)
+SDL_Overlay *
+GS_CreateYUVOverlay(_THIS, int width, int height, Uint32 format,
+                    SDL_Surface * display)
 {
-	SDL_Overlay *overlay;
-	struct private_yuvhwdata *hwdata;
-	int map_offset;
-	unsigned long long *tags;
-	caddr_t base;
-	int bpp;
-	int fbp, fbw, psm;
-	int x, y, w, h;
-	int pnum;
-	struct ps2_packet *packet;
-	struct ps2_packet tex_packet;
-
-	/* We can only decode blocks of 16x16 pixels */
-	if ( (width & 15) || (height & 15) ) {
-		SDL_SetError("Overlay width/height must be multiples of 16");
-		return(NULL);
-	}
-	/* Make sure the image isn't too large for a single DMA transfer */
-	if ( ((width/16) * (height/16)) > MAX_MACROBLOCKS ) {
-		SDL_SetError("Overlay too large (maximum size: %d pixels)",
-		             MAX_MACROBLOCKS * 16 * 16);
-		return(NULL);
-	}
+    SDL_Overlay *overlay;
+    struct private_yuvhwdata *hwdata;
+    int map_offset;
+    unsigned long long *tags;
+    caddr_t base;
+    int bpp;
+    int fbp, fbw, psm;
+    int x, y, w, h;
+    int pnum;
+    struct ps2_packet *packet;
+    struct ps2_packet tex_packet;
 
-	/* Double-check the requested format.  For simplicity, we'll only
-	   support planar YUV formats.
-	 */
-	switch (format) {
-	    case SDL_YV12_OVERLAY:
-	    case SDL_IYUV_OVERLAY:
-		/* Supported planar YUV format */
-		break;
-	    default:
-		SDL_SetError("Unsupported YUV format");
-		return(NULL);
-	}
+    /* We can only decode blocks of 16x16 pixels */
+    if ((width & 15) || (height & 15)) {
+        SDL_SetError("Overlay width/height must be multiples of 16");
+        return (NULL);
+    }
+    /* Make sure the image isn't too large for a single DMA transfer */
+    if (((width / 16) * (height / 16)) > MAX_MACROBLOCKS) {
+        SDL_SetError("Overlay too large (maximum size: %d pixels)",
+                     MAX_MACROBLOCKS * 16 * 16);
+        return (NULL);
+    }
 
-	/* Create the overlay structure */
-	overlay = (SDL_Overlay *)SDL_malloc(sizeof *overlay);
-	if ( overlay == NULL ) {
-		SDL_OutOfMemory();
-		return(NULL);
-	}
-	SDL_memset(overlay, 0, (sizeof *overlay));
+    /* Double-check the requested format.  For simplicity, we'll only
+       support planar YUV formats.
+     */
+    switch (format) {
+    case SDL_YV12_OVERLAY:
+    case SDL_IYUV_OVERLAY:
+        /* Supported planar YUV format */
+        break;
+    default:
+        SDL_SetError("Unsupported YUV format");
+        return (NULL);
+    }
 
-	/* Fill in the basic members */
-	overlay->format = format;
-	overlay->w = width;
-	overlay->h = height;
+    /* Create the overlay structure */
+    overlay = (SDL_Overlay *) SDL_malloc(sizeof *overlay);
+    if (overlay == NULL) {
+        SDL_OutOfMemory();
+        return (NULL);
+    }
+    SDL_memset(overlay, 0, (sizeof *overlay));
+
+    /* Fill in the basic members */
+    overlay->format = format;
+    overlay->w = width;
+    overlay->h = height;
 
-	/* Set up the YUV surface function structure */
-	overlay->hwfuncs = &gs_yuvfuncs;
-	overlay->hw_overlay = 1;
+    /* Set up the YUV surface function structure */
+    overlay->hwfuncs = &gs_yuvfuncs;
+    overlay->hw_overlay = 1;
 
-	/* Create the pixel data */
-	hwdata = (struct private_yuvhwdata *)SDL_malloc(sizeof *hwdata);
-	overlay->hwdata = hwdata;
-	if ( hwdata == NULL ) {
-		SDL_FreeYUVOverlay(overlay);
-		SDL_OutOfMemory();
-		return(NULL);
-	}
-	hwdata->ipu_fd = -1;
-	hwdata->pixels = (Uint8 *)SDL_malloc(width*height*2);
-	if ( hwdata->pixels == NULL ) {
-		SDL_FreeYUVOverlay(overlay);
-		SDL_OutOfMemory();
-		return(NULL);
-	}
-	hwdata->macroblocks = (width/16) * (height/16);
+    /* Create the pixel data */
+    hwdata = (struct private_yuvhwdata *) SDL_malloc(sizeof *hwdata);
+    overlay->hwdata = hwdata;
+    if (hwdata == NULL) {
+        SDL_FreeYUVOverlay(overlay);
+        SDL_OutOfMemory();
+        return (NULL);
+    }
+    hwdata->ipu_fd = -1;
+    hwdata->pixels = (Uint8 *) SDL_malloc(width * height * 2);
+    if (hwdata->pixels == NULL) {
+        SDL_FreeYUVOverlay(overlay);
+        SDL_OutOfMemory();
+        return (NULL);
+    }
+    hwdata->macroblocks = (width / 16) * (height / 16);
 
-	/* Find the pitch and offset values for the overlay */
-	overlay->pitches = hwdata->pitches;
-	overlay->pixels = hwdata->planes;
-	switch (format) {
-	    case SDL_YV12_OVERLAY:
-	    case SDL_IYUV_OVERLAY:
-		overlay->pitches[0] = overlay->w;
-		overlay->pitches[1] = overlay->pitches[0] / 2;
-		overlay->pitches[2] = overlay->pitches[0] / 2;
-	        overlay->pixels[0] = hwdata->pixels;
-	        overlay->pixels[1] = overlay->pixels[0] +
-		                     overlay->pitches[0] * overlay->h;
-	        overlay->pixels[2] = overlay->pixels[1] +
-		                     overlay->pitches[1] * overlay->h / 2;
-		overlay->planes = 3;
-		break;
-	    default:
-		/* We should never get here (caught above) */
-		break;
-	}
+    /* Find the pitch and offset values for the overlay */
+    overlay->pitches = hwdata->pitches;
+    overlay->pixels = hwdata->planes;
+    switch (format) {
+    case SDL_YV12_OVERLAY:
+    case SDL_IYUV_OVERLAY:
+        overlay->pitches[0] = overlay->w;
+        overlay->pitches[1] = overlay->pitches[0] / 2;
+        overlay->pitches[2] = overlay->pitches[0] / 2;
+        overlay->pixels[0] = hwdata->pixels;
+        overlay->pixels[1] = overlay->pixels[0] +
+            overlay->pitches[0] * overlay->h;
+        overlay->pixels[2] = overlay->pixels[1] +
+            overlay->pitches[1] * overlay->h / 2;
+        overlay->planes = 3;
+        break;
+    default:
+        /* We should never get here (caught above) */
+        break;
+    }
 
-	/* Theoretically we could support several concurrent decode
-	   streams queueing up on the same file descriptor, but for
-	   simplicity we'll support only one.  Opening the IPU more
-	   than once will fail with EBUSY.
-	*/
-	hwdata->ipu_fd = open("/dev/ps2ipu", O_RDWR);
-	if ( hwdata->ipu_fd < 0 ) {
-		SDL_FreeYUVOverlay(overlay);
-		SDL_SetError("Playstation 2 IPU busy");
-		return(NULL);
-	}
+    /* Theoretically we could support several concurrent decode
+       streams queueing up on the same file descriptor, but for
+       simplicity we'll support only one.  Opening the IPU more
+       than once will fail with EBUSY.
+     */
+    hwdata->ipu_fd = open("/dev/ps2ipu", O_RDWR);
+    if (hwdata->ipu_fd < 0) {
+        SDL_FreeYUVOverlay(overlay);
+        SDL_SetError("Playstation 2 IPU busy");
+        return (NULL);
+    }
 
-	/* Allocate a DMA area for pixel conversion */
-	bpp = this->screen->format->BytesPerPixel;
-	map_offset = (mapped_len + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-	hwdata->dma_len = hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8) +
-	                  width * height * bpp +
-	                  hwdata->macroblocks * (16 * sizeof(long long)) +
-	                  12 * sizeof(long long);
-	hwdata->dma_mem = mmap(0, hwdata->dma_len, PROT_READ|PROT_WRITE,
-	                       MAP_SHARED, memory_fd, map_offset);
-	if ( hwdata->dma_mem == MAP_FAILED ) {
-		hwdata->ipu_imem = (caddr_t)0;
-		SDL_FreeYUVOverlay(overlay);
-		SDL_SetError("Unable to map %d bytes for DMA", hwdata->dma_len);
-		return(NULL);
-	}
-	hwdata->ipu_imem = hwdata->dma_mem;
-	hwdata->ipu_omem = hwdata->ipu_imem +
-	                   hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8);
-	hwdata->dma_tags = hwdata->ipu_omem + width * height * bpp;
+    /* Allocate a DMA area for pixel conversion */
+    bpp = this->screen->format->BytesPerPixel;
+    map_offset = (mapped_len + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
+    hwdata->dma_len = hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8) +
+        width * height * bpp +
+        hwdata->macroblocks * (16 * sizeof(long long)) +
+        12 * sizeof(long long);
+    hwdata->dma_mem = mmap(0, hwdata->dma_len, PROT_READ | PROT_WRITE,
+                           MAP_SHARED, memory_fd, map_offset);
+    if (hwdata->dma_mem == MAP_FAILED) {
+        hwdata->ipu_imem = (caddr_t) 0;
+        SDL_FreeYUVOverlay(overlay);
+        SDL_SetError("Unable to map %d bytes for DMA", hwdata->dma_len);
+        return (NULL);
+    }
+    hwdata->ipu_imem = hwdata->dma_mem;
+    hwdata->ipu_omem = hwdata->ipu_imem +
+        hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8);
+    hwdata->dma_tags = hwdata->ipu_omem + width * height * bpp;
 
-	/* Allocate memory for the DMA packets */
-	hwdata->plist.num = hwdata->macroblocks * 4 + 1;
-	hwdata->plist.packet = (struct ps2_packet *)SDL_malloc(
-	                       hwdata->plist.num*sizeof(struct ps2_packet));
-	if ( ! hwdata->plist.packet ) {
-		SDL_FreeYUVOverlay(overlay);
-		SDL_OutOfMemory();
-		return(NULL);
-	}
-	pnum = 0;
-	packet = hwdata->plist.packet;
+    /* Allocate memory for the DMA packets */
+    hwdata->plist.num = hwdata->macroblocks * 4 + 1;
+    hwdata->plist.packet =
+        (struct ps2_packet *) SDL_malloc(hwdata->plist.num *
+                                         sizeof(struct ps2_packet));
+    if (!hwdata->plist.packet) {
+        SDL_FreeYUVOverlay(overlay);
+        SDL_OutOfMemory();
+        return (NULL);
+    }
+    pnum = 0;
+    packet = hwdata->plist.packet;
 
-	/* Set up the tags to send the image to the screen */
-	tags = (unsigned long long *)hwdata->dma_tags;
-	base = hwdata->ipu_omem;
-	fbp = screen_image.fbp;
-	fbw = screen_image.fbw;
-	psm = screen_image.psm;
-	y = screen_image.y + screen_image.h;	/* Offscreen video memory */
-	for ( h=height/16; h; --h ) {
-		x = 0;			/* Visible video memory */
-		for ( w=width/16; w; --w ) {
-			/* The head tag */
-			packet[pnum].ptr = &tags[0];
-			packet[pnum].len = 10 * sizeof(*tags);
-			++pnum;
-			tags[0] = 4 | (1LL << 60);	/* GIFtag */
-			tags[1] = 0x0e;			/* A+D */
-			tags[2] = ((unsigned long long)fbp << 32) |
-			          ((unsigned long long)fbw << 48) |
-			          ((unsigned long long)psm << 56);
-			tags[3] = PS2_GS_BITBLTBUF;
-			tags[4] = ((unsigned long long)x << 32) |
-			          ((unsigned long long)y << 48);
-			tags[5] = PS2_GS_TRXPOS;
-			tags[6] = (unsigned long long)16 |
-			          ((unsigned long long)16 << 32);
-			tags[7] = PS2_GS_TRXREG;
-			tags[8] = 0;
-			tags[9] = PS2_GS_TRXDIR;
-			/* Now the actual image data */
-			packet[pnum].ptr = &tags[10];
-			packet[pnum].len = 2 * sizeof(*tags);
-			++pnum;
-			tags[10] = ((16*16*bpp) >> 4) | (2LL << 58);
-			tags[11] = 0;
-			packet[pnum].ptr = (void *)base;
-			packet[pnum].len = 16 * 16 * bpp;
-			++pnum;
-			packet[pnum].ptr = &tags[12];
-			packet[pnum].len = 2 * sizeof(*tags);
-			++pnum;
-			tags[12] = (0 >> 4) | (1 << 15) | (2LL << 58);
-			tags[13] = 0;
+    /* Set up the tags to send the image to the screen */
+    tags = (unsigned long long *) hwdata->dma_tags;
+    base = hwdata->ipu_omem;
+    fbp = screen_image.fbp;
+    fbw = screen_image.fbw;
+    psm = screen_image.psm;
+    y = screen_image.y + screen_image.h;        /* Offscreen video memory */
+    for (h = height / 16; h; --h) {
+        x = 0;                  /* Visible video memory */
+        for (w = width / 16; w; --w) {
+            /* The head tag */
+            packet[pnum].ptr = &tags[0];
+            packet[pnum].len = 10 * sizeof(*tags);
+            ++pnum;
+            tags[0] = 4 | (1LL << 60);  /* GIFtag */
+            tags[1] = 0x0e;     /* A+D */
+            tags[2] = ((unsigned long long) fbp << 32) |
+                ((unsigned long long) fbw << 48) |
+                ((unsigned long long) psm << 56);
+            tags[3] = PS2_GS_BITBLTBUF;
+            tags[4] = ((unsigned long long) x << 32) |
+                ((unsigned long long) y << 48);
+            tags[5] = PS2_GS_TRXPOS;
+            tags[6] = (unsigned long long) 16 |
+                ((unsigned long long) 16 << 32);
+            tags[7] = PS2_GS_TRXREG;
+            tags[8] = 0;
+            tags[9] = PS2_GS_TRXDIR;
+            /* Now the actual image data */
+            packet[pnum].ptr = &tags[10];
+            packet[pnum].len = 2 * sizeof(*tags);
+            ++pnum;
+            tags[10] = ((16 * 16 * bpp) >> 4) | (2LL << 58);
+            tags[11] = 0;
+            packet[pnum].ptr = (void *) base;
+            packet[pnum].len = 16 * 16 * bpp;
+            ++pnum;
+            packet[pnum].ptr = &tags[12];
+            packet[pnum].len = 2 * sizeof(*tags);
+            ++pnum;
+            tags[12] = (0 >> 4) | (1 << 15) | (2LL << 58);
+            tags[13] = 0;
 
-			tags += 16;
-			base += 16 * 16 * bpp;
+            tags += 16;
+            base += 16 * 16 * bpp;
 
-			x += 16;
-		}
-		y += 16;
-	}
+            x += 16;
+        }
+        y += 16;
+    }
 
-	/* Set up the texture memory area for the video */
-	tex_packet.ptr = tags;
-	tex_packet.len = 8 * sizeof(*tags);
-	tags[0] = 3 | (1LL << 60);	/* GIFtag */
-	tags[1] = 0x0e;			/* A+D */
-	tags[2] = ((screen_image.y + screen_image.h) * screen_image.w) / 64 +
-	          ((unsigned long long)fbw << 14) +
-	          ((unsigned long long)psm << 20) +
-	          ((unsigned long long)power_of_2(width) << 26) +
-	          ((unsigned long long)power_of_2(height) << 30) +
-	          ((unsigned long long)1 << 34) +
-	          ((unsigned long long)1 << 35);
-	tags[3] = PS2_GS_TEX0_1;
-	tags[4] = (1 << 5) + (1 << 6);
-	tags[5] = PS2_GS_TEX1_1;
-	tags[6] = 0;
-	tags[7] = PS2_GS_TEXFLUSH;
-	ioctl(console_fd, PS2IOC_SEND, &tex_packet);
+    /* Set up the texture memory area for the video */
+    tex_packet.ptr = tags;
+    tex_packet.len = 8 * sizeof(*tags);
+    tags[0] = 3 | (1LL << 60);  /* GIFtag */
+    tags[1] = 0x0e;             /* A+D */
+    tags[2] = ((screen_image.y + screen_image.h) * screen_image.w) / 64 +
+        ((unsigned long long) fbw << 14) +
+        ((unsigned long long) psm << 20) +
+        ((unsigned long long) power_of_2(width) << 26) +
+        ((unsigned long long) power_of_2(height) << 30) +
+        ((unsigned long long) 1 << 34) + ((unsigned long long) 1 << 35);
+    tags[3] = PS2_GS_TEX0_1;
+    tags[4] = (1 << 5) + (1 << 6);
+    tags[5] = PS2_GS_TEX1_1;
+    tags[6] = 0;
+    tags[7] = PS2_GS_TEXFLUSH;
+    ioctl(console_fd, PS2IOC_SEND, &tex_packet);
 
-	/* Set up the tags for scaling the image */
-	packet[pnum].ptr = tags;
-	packet[pnum].len = 12 * sizeof(*tags);
-	++pnum;
-	tags[0] = 5 | (1LL << 60);	/* GIFtag */
-	tags[1] = 0x0e;			/* A+D */
-	tags[2] = 6 + (1 << 4) + (1 << 8);
-	tags[3] = PS2_GS_PRIM;
-	tags[4] = ((unsigned long long)0 * 16) +
-	           (((unsigned long long)0 * 16) << 16);
-	tags[5] = PS2_GS_UV;
-	tags[6] = 0; /* X1, Y1 */
-	tags[7] = PS2_GS_XYZ2;
-	hwdata->stretch_x1y1 = &tags[6];
-	tags[8] = ((unsigned long long)overlay->w * 16) +
-	           (((unsigned long long)overlay->h * 16) << 16);
-	tags[9] = PS2_GS_UV;
-	tags[10] = 0; /* X2, Y2 */
-	tags[11] = PS2_GS_XYZ2;
-	hwdata->stretch_x2y2 = &tags[10];
+    /* Set up the tags for scaling the image */
+    packet[pnum].ptr = tags;
+    packet[pnum].len = 12 * sizeof(*tags);
+    ++pnum;
+    tags[0] = 5 | (1LL << 60);  /* GIFtag */
+    tags[1] = 0x0e;             /* A+D */
+    tags[2] = 6 + (1 << 4) + (1 << 8);
+    tags[3] = PS2_GS_PRIM;
+    tags[4] = ((unsigned long long) 0 * 16) +
+        (((unsigned long long) 0 * 16) << 16);
+    tags[5] = PS2_GS_UV;
+    tags[6] = 0;                /* X1, Y1 */
+    tags[7] = PS2_GS_XYZ2;
+    hwdata->stretch_x1y1 = &tags[6];
+    tags[8] = ((unsigned long long) overlay->w * 16) +
+        (((unsigned long long) overlay->h * 16) << 16);
+    tags[9] = PS2_GS_UV;
+    tags[10] = 0;               /* X2, Y2 */
+    tags[11] = PS2_GS_XYZ2;
+    hwdata->stretch_x2y2 = &tags[10];
 
-	/* We're all done.. */
-	return(overlay);
+    /* We're all done.. */
+    return (overlay);
 }
 
-int GS_LockYUVOverlay(_THIS, SDL_Overlay *overlay)
+int
+GS_LockYUVOverlay(_THIS, SDL_Overlay * overlay)
 {
-	return(0);
+    return (0);
 }
 
-void GS_UnlockYUVOverlay(_THIS, SDL_Overlay *overlay)
+void
+GS_UnlockYUVOverlay(_THIS, SDL_Overlay * overlay)
 {
-	return;
+    return;
 }
 
-int GS_DisplayYUVOverlay(_THIS, SDL_Overlay *overlay, SDL_Rect *src, SDL_Rect *dst)
+int
+GS_DisplayYUVOverlay(_THIS, SDL_Overlay * overlay, SDL_Rect * src,
+                     SDL_Rect * dst)
 {
-	struct private_yuvhwdata *hwdata;
-	__u32 cmd;
-	struct ps2_packet packet;
-	int h, w, i;
-	Uint32 *lum, *Cr, *Cb;
-	int lum_pitch;
-	int crb_pitch;
-	Uint32 *lum_src, *Cr_src, *Cb_src;
-	Uint32 *srcp, *dstp;
-	unsigned int x, y;
-	SDL_Surface *screen;
+    struct private_yuvhwdata *hwdata;
+    __u32 cmd;
+    struct ps2_packet packet;
+    int h, w, i;
+    Uint32 *lum, *Cr, *Cb;
+    int lum_pitch;
+    int crb_pitch;
+    Uint32 *lum_src, *Cr_src, *Cb_src;
+    Uint32 *srcp, *dstp;
+    unsigned int x, y;
+    SDL_Surface *screen;
 
-	/* Find out where the various portions of the image are */
-	hwdata = overlay->hwdata;
-	switch (overlay->format) {
-	    case SDL_YV12_OVERLAY:
-		lum = (Uint32 *)overlay->pixels[0];
-		Cr =  (Uint32 *)overlay->pixels[1];
-		Cb =  (Uint32 *)overlay->pixels[2];
-		break;
-	    case SDL_IYUV_OVERLAY:
-		lum = (Uint32 *)overlay->pixels[0];
-		Cr =  (Uint32 *)overlay->pixels[2];
-		Cb =  (Uint32 *)overlay->pixels[1];
-	    default:
-		SDL_SetError("Unsupported YUV format in blit (?)");
-		return(-1);
-	}
-	dstp = (Uint32 *)hwdata->ipu_imem;
-	lum_pitch = overlay->w/4;
-	crb_pitch = (overlay->w/2)/4;
+    /* Find out where the various portions of the image are */
+    hwdata = overlay->hwdata;
+    switch (overlay->format) {
+    case SDL_YV12_OVERLAY:
+        lum = (Uint32 *) overlay->pixels[0];
+        Cr = (Uint32 *) overlay->pixels[1];
+        Cb = (Uint32 *) overlay->pixels[2];
+        break;
+    case SDL_IYUV_OVERLAY:
+        lum = (Uint32 *) overlay->pixels[0];
+        Cr = (Uint32 *) overlay->pixels[2];
+        Cb = (Uint32 *) overlay->pixels[1];
+    default:
+        SDL_SetError("Unsupported YUV format in blit (?)");
+        return (-1);
+    }
+    dstp = (Uint32 *) hwdata->ipu_imem;
+    lum_pitch = overlay->w / 4;
+    crb_pitch = (overlay->w / 2) / 4;
 
-	/* Copy blocks of 16x16 pixels to the DMA area */
-	for ( h=overlay->h/16; h; --h ) {
-		lum_src = lum;
-		Cr_src = Cr;
-		Cb_src = Cb;
-		for ( w=overlay->w/16; w; --w ) {
-			srcp = lum_src;
-			for ( i=0; i<16; ++i ) {
-				dstp[0] = srcp[0];
-				dstp[1] = srcp[1];
-				dstp[2] = srcp[2];
-				dstp[3] = srcp[3];
-				srcp += lum_pitch;
-				dstp += 4;
-			}
-			srcp = Cb_src;
-			for ( i=0; i<8; ++i ) {
-				dstp[0] = srcp[0];
-				dstp[1] = srcp[1];
-				srcp += crb_pitch;
-				dstp += 2;
-			}
-			srcp = Cr_src;
-			for ( i=0; i<8; ++i ) {
-				dstp[0] = srcp[0];
-				dstp[1] = srcp[1];
-				srcp += crb_pitch;
-				dstp += 2;
-			}
-			lum_src += 16 / 4;
-			Cb_src += 8 / 4;
-			Cr_src += 8 / 4;
-		}
-		lum += lum_pitch * 16;
-		Cr += crb_pitch * 8;
-		Cb += crb_pitch * 8;
-	}
+    /* Copy blocks of 16x16 pixels to the DMA area */
+    for (h = overlay->h / 16; h; --h) {
+        lum_src = lum;
+        Cr_src = Cr;
+        Cb_src = Cb;
+        for (w = overlay->w / 16; w; --w) {
+            srcp = lum_src;
+            for (i = 0; i < 16; ++i) {
+                dstp[0] = srcp[0];
+                dstp[1] = srcp[1];
+                dstp[2] = srcp[2];
+                dstp[3] = srcp[3];
+                srcp += lum_pitch;
+                dstp += 4;
+            }
+            srcp = Cb_src;
+            for (i = 0; i < 8; ++i) {
+                dstp[0] = srcp[0];
+                dstp[1] = srcp[1];
+                srcp += crb_pitch;
+                dstp += 2;
+            }
+            srcp = Cr_src;
+            for (i = 0; i < 8; ++i) {
+                dstp[0] = srcp[0];
+                dstp[1] = srcp[1];
+                srcp += crb_pitch;
+                dstp += 2;
+            }
+            lum_src += 16 / 4;
+            Cb_src += 8 / 4;
+            Cr_src += 8 / 4;
+        }
+        lum += lum_pitch * 16;
+        Cr += crb_pitch * 8;
+        Cb += crb_pitch * 8;
+    }
 
-	/* Send the macroblock data to the IPU */
+    /* Send the macroblock data to the IPU */
 #ifdef DEBUG_YUV
-	fprintf(stderr, "Sending data to IPU..\n");
+    fprintf(stderr, "Sending data to IPU..\n");
 #endif
-	packet.ptr = hwdata->ipu_imem;
-	packet.len = hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8);
-	ioctl(hwdata->ipu_fd, PS2IOC_SENDA, &packet);
+    packet.ptr = hwdata->ipu_imem;
+    packet.len = hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8);
+    ioctl(hwdata->ipu_fd, PS2IOC_SENDA, &packet);
 
-	/* Trigger the DMA to the IPU for conversion */
+    /* Trigger the DMA to the IPU for conversion */
 #ifdef DEBUG_YUV
-	fprintf(stderr, "Trigging conversion command\n");
+    fprintf(stderr, "Trigging conversion command\n");
 #endif
-	cmd = (7 << 28) + hwdata->macroblocks;
-	if ( screen_image.psm == PS2_GS_PSMCT16 ) {
-		cmd += (1 << 27) +	/* Output RGB 555 */
-		       (1 << 26);	/* Dither output */
-	}
-	ioctl(hwdata->ipu_fd, PS2IOC_SIPUCMD, &cmd);
+    cmd = (7 << 28) + hwdata->macroblocks;
+    if (screen_image.psm == PS2_GS_PSMCT16) {
+        cmd += (1 << 27) +      /* Output RGB 555 */
+            (1 << 26);          /* Dither output */
+    }
+    ioctl(hwdata->ipu_fd, PS2IOC_SIPUCMD, &cmd);
 
-	/* Retrieve the converted image from the IPU */
+    /* Retrieve the converted image from the IPU */
 #ifdef DEBUG_YUV
-	fprintf(stderr, "Retrieving data from IPU..\n");
+    fprintf(stderr, "Retrieving data from IPU..\n");
 #endif
-	packet.ptr = hwdata->ipu_omem;
-	packet.len = overlay->w * overlay->h *
-	             this->screen->format->BytesPerPixel;
-	ioctl(hwdata->ipu_fd, PS2IOC_RECV, &packet);
+    packet.ptr = hwdata->ipu_omem;
+    packet.len = overlay->w * overlay->h *
+        this->screen->format->BytesPerPixel;
+    ioctl(hwdata->ipu_fd, PS2IOC_RECV, &packet);
 
 #ifdef DEBUG_YUV
-	fprintf(stderr, "Copying image to screen..\n");
+    fprintf(stderr, "Copying image to screen..\n");
 #endif
-	/* Wait for previous DMA to complete */
-	ioctl(console_fd, PS2IOC_SENDQCT, 1);
+    /* Wait for previous DMA to complete */
+    ioctl(console_fd, PS2IOC_SENDQCT, 1);
 
-	/* Send the current image to the screen and scale it */
-	screen = this->screen;
-	x = (unsigned int)dst->x;
-	y = (unsigned int)dst->y;
-	if ( screen->offset ) {
-		x += (screen->offset % screen->pitch) /
-		     screen->format->BytesPerPixel;
-		y += (screen->offset / screen->pitch);
-	}
-	y += screen_image.y;
-	*hwdata->stretch_x1y1 = (x * 16) + ((y * 16) << 16);
-	x += (unsigned int)dst->w;
-	y += (unsigned int)dst->h;
-	*hwdata->stretch_x2y2 = (x * 16) + ((y * 16) << 16);
-	return ioctl(console_fd, PS2IOC_SENDL, &hwdata->plist);
+    /* Send the current image to the screen and scale it */
+    screen = this->screen;
+    x = (unsigned int) dst->x;
+    y = (unsigned int) dst->y;
+    if (screen->offset) {
+        x += (screen->offset % screen->pitch) / screen->format->BytesPerPixel;
+        y += (screen->offset / screen->pitch);
+    }
+    y += screen_image.y;
+    *hwdata->stretch_x1y1 = (x * 16) + ((y * 16) << 16);
+    x += (unsigned int) dst->w;
+    y += (unsigned int) dst->h;
+    *hwdata->stretch_x2y2 = (x * 16) + ((y * 16) << 16);
+    return ioctl(console_fd, PS2IOC_SENDL, &hwdata->plist);
 }
 
-void GS_FreeYUVOverlay(_THIS, SDL_Overlay *overlay)
+void
+GS_FreeYUVOverlay(_THIS, SDL_Overlay * overlay)
 {
-	struct private_yuvhwdata *hwdata;
+    struct private_yuvhwdata *hwdata;
 
-	hwdata = overlay->hwdata;
-	if ( hwdata ) {
-		if ( hwdata->ipu_fd >= 0 ) {
-			close(hwdata->ipu_fd);
-		}
-		if ( hwdata->dma_mem ) {
-			munmap(hwdata->dma_mem, hwdata->dma_len);
-		}
-		if ( hwdata->plist.packet ) {
-			SDL_free(hwdata->plist.packet);
-		}
-		if ( hwdata->pixels ) {
-			SDL_free(hwdata->pixels);
-		}
-		SDL_free(hwdata);
-	}
+    hwdata = overlay->hwdata;
+    if (hwdata) {
+        if (hwdata->ipu_fd >= 0) {
+            close(hwdata->ipu_fd);
+        }
+        if (hwdata->dma_mem) {
+            munmap(hwdata->dma_mem, hwdata->dma_len);
+        }
+        if (hwdata->plist.packet) {
+            SDL_free(hwdata->plist.packet);
+        }
+        if (hwdata->pixels) {
+            SDL_free(hwdata->pixels);
+        }
+        SDL_free(hwdata);
+    }
 }
+
+/* vi: set ts=4 sw=4 expandtab: */