[sdl_omap.git] / test / testoverlay.c


/* Bring up a window and play with it */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define BENCHMARK_SDL

#define NOTICE(X)	printf("%s", X);

#define WINDOW_WIDTH  640
#define WINDOW_HEIGHT 480

#include "SDL.h"

SDL_Surface *screen, *pic;
SDL_Overlay *overlay;
int scale;
int monochrome;
int luminance;
int w, h;

/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
static void quit(int rc)
{
	SDL_Quit();
	exit(rc);
}

/* NOTE: These RGB conversion functions are not intended for speed,
         only as examples.
*/

void RGBtoYUV(Uint8 *rgb, int *yuv, int monochrome, int luminance)
{
    if (monochrome)
    {
#if 1 /* these are the two formulas that I found on the FourCC site... */
        yuv[0] = 0.299*rgb[0] + 0.587*rgb[1] + 0.114*rgb[2];
        yuv[1] = 128;
        yuv[2] = 128;
#else
        yuv[0] = (0.257 * rgb[0]) + (0.504 * rgb[1]) + (0.098 * rgb[2]) + 16;
        yuv[1] = 128;
        yuv[2] = 128;
#endif
    }
    else
    {
#if 1 /* these are the two formulas that I found on the FourCC site... */
        yuv[0] = 0.299*rgb[0] + 0.587*rgb[1] + 0.114*rgb[2];
        yuv[1] = (rgb[2]-yuv[0])*0.565 + 128;
        yuv[2] = (rgb[0]-yuv[0])*0.713 + 128;
#else
        yuv[0] = (0.257 * rgb[0]) + (0.504 * rgb[1]) + (0.098 * rgb[2]) + 16;
        yuv[1] = 128 - (0.148 * rgb[0]) - (0.291 * rgb[1]) + (0.439 * rgb[2]);
        yuv[2] = 128 + (0.439 * rgb[0]) - (0.368 * rgb[1]) - (0.071 * rgb[2]);
#endif
    }

    if (luminance!=100)
    {
        yuv[0]=yuv[0]*luminance/100;
        if (yuv[0]>255)
            yuv[0]=255;
    }

    /* clamp values...if you need to, we don't seem to have a need */
    /*
    for(i=0;i<3;i++)
    {
        if(yuv[i]<0)
            yuv[i]=0;
        if(yuv[i]>255)
            yuv[i]=255;
    }
    */
}

void ConvertRGBtoYV12(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance)
{
	int x,y;
	int yuv[3];
	Uint8 *p,*op[3];

	SDL_LockSurface(s);
	SDL_LockYUVOverlay(o);

	/* Black initialization */
	/*
	memset(o->pixels[0],0,o->pitches[0]*o->h);
	memset(o->pixels[1],128,o->pitches[1]*((o->h+1)/2));
	memset(o->pixels[2],128,o->pitches[2]*((o->h+1)/2));
	*/

	/* Convert */
	for(y=0; y<s->h && y<o->h; y++)
	{
		p=((Uint8 *) s->pixels)+s->pitch*y;
		op[0]=o->pixels[0]+o->pitches[0]*y;
		op[1]=o->pixels[1]+o->pitches[1]*(y/2);
		op[2]=o->pixels[2]+o->pitches[2]*(y/2);
		for(x=0; x<s->w && x<o->w; x++)
		{
			RGBtoYUV(p, yuv, monochrome, luminance);
			*(op[0]++)=yuv[0];
			if(x%2==0 && y%2==0)
			{
				*(op[1]++)=yuv[2];
				*(op[2]++)=yuv[1];
			}
			p+=s->format->BytesPerPixel;
		}
	}

	SDL_UnlockYUVOverlay(o);
	SDL_UnlockSurface(s);
}

void ConvertRGBtoIYUV(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance)
{
	int x,y;
	int yuv[3];
	Uint8 *p,*op[3];

	SDL_LockSurface(s);
	SDL_LockYUVOverlay(o);

	/* Black initialization */
	/*
	memset(o->pixels[0],0,o->pitches[0]*o->h);
	memset(o->pixels[1],128,o->pitches[1]*((o->h+1)/2));
	memset(o->pixels[2],128,o->pitches[2]*((o->h+1)/2));
	*/

	/* Convert */
	for(y=0; y<s->h && y<o->h; y++)
	{
		p=((Uint8 *) s->pixels)+s->pitch*y;
		op[0]=o->pixels[0]+o->pitches[0]*y;
		op[1]=o->pixels[1]+o->pitches[1]*(y/2);
		op[2]=o->pixels[2]+o->pitches[2]*(y/2);
		for(x=0; x<s->w && x<o->w; x++)
		{
			RGBtoYUV(p,yuv, monochrome, luminance);
			*(op[0]++)=yuv[0];
			if(x%2==0 && y%2==0)
			{
				*(op[1]++)=yuv[1];
				*(op[2]++)=yuv[2];
			}
			p+=s->format->BytesPerPixel;
		}
	}

	SDL_UnlockYUVOverlay(o);
	SDL_UnlockSurface(s);
}

void ConvertRGBtoUYVY(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance)
{
	int x,y;
	int yuv[3];
	Uint8 *p,*op;

	SDL_LockSurface(s);
	SDL_LockYUVOverlay(o);

	for(y=0; y<s->h && y<o->h; y++)
	{
		p=((Uint8 *) s->pixels)+s->pitch*y;
		op=o->pixels[0]+o->pitches[0]*y;
		for(x=0; x<s->w && x<o->w; x++)
		{
			RGBtoYUV(p, yuv, monochrome, luminance);
			if(x%2==0)
			{
				*(op++)=yuv[1];
				*(op++)=yuv[0];
				*(op++)=yuv[2];
			}
			else
				*(op++)=yuv[0];

			p+=s->format->BytesPerPixel;
		}
	}

	SDL_UnlockYUVOverlay(o);
	SDL_UnlockSurface(s);
}

void ConvertRGBtoYVYU(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance)
{
	int x,y;
	int yuv[3];
	Uint8 *p,*op;

	SDL_LockSurface(s);
	SDL_LockYUVOverlay(o);

	for(y=0; y<s->h && y<o->h; y++)
	{
		p=((Uint8 *) s->pixels)+s->pitch*y;
		op=o->pixels[0]+o->pitches[0]*y;
		for(x=0; x<s->w && x<o->w; x++)
		{
			RGBtoYUV(p,yuv, monochrome, luminance);
			if(x%2==0)
			{
				*(op++)=yuv[0];
				*(op++)=yuv[2];
				op[1]=yuv[1];
			}
			else
			{
				*op=yuv[0];
				op+=2;
			}

			p+=s->format->BytesPerPixel;
		}
	}

	SDL_UnlockYUVOverlay(o);
	SDL_UnlockSurface(s);
}

void ConvertRGBtoYUY2(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance)
{
	int x,y;
	int yuv[3];
	Uint8 *p,*op;

	SDL_LockSurface(s);
	SDL_LockYUVOverlay(o);

	for(y=0; y<s->h && y<o->h; y++)
	{
		p=((Uint8 *) s->pixels)+s->pitch*y;
		op=o->pixels[0]+o->pitches[0]*y;
		for(x=0; x<s->w && x<o->w; x++)
		{
			RGBtoYUV(p,yuv, monochrome, luminance);
			if(x%2==0)
			{
				*(op++)=yuv[0];
				*(op++)=yuv[1];
				op[1]=yuv[2];
			}
			else
			{
				*op=yuv[0];
				op+=2;
			}

			p+=s->format->BytesPerPixel;
		}
	}

	SDL_UnlockYUVOverlay(o);
	SDL_UnlockSurface(s);
}

void Draw()
{
	SDL_Rect rect;
	int i;
        int disp;

	if(!scale)
	{
		rect.w=overlay->w;
		rect.h=overlay->h;
		for(i=0; i<h-rect.h && i<w-rect.w; i++)
		{
			rect.x=i;
			rect.y=i;
			SDL_DisplayYUVOverlay(overlay,&rect);
		}
	}
	else
	{
		rect.w=overlay->w/2;
		rect.h=overlay->h/2;
		rect.x=(w-rect.w)/2;
		rect.y=(h-rect.h)/2;
                disp=rect.y-1;
		for(i=0; i<disp; i++)
		{
                        rect.w+=2;
                        rect.h+=2;
                        rect.x--;
                        rect.y--;
			SDL_DisplayYUVOverlay(overlay,&rect);
		}
	}
	printf("Displayed %d times.\n",i);
}

static void PrintUsage(char *argv0)
{
	fprintf(stderr, "Usage: %s [arg] [arg] [arg] ...\n", argv0);
	fprintf(stderr, "Where 'arg' is one of:\n");
	fprintf(stderr, "	-delay <seconds>\n");
	fprintf(stderr, "	-width <pixels>\n");
	fprintf(stderr, "	-height <pixels>\n");
	fprintf(stderr, "	-bpp <bits>\n");
	fprintf(stderr, "	-format <fmt> (one of the: YV12, IYUV, YUY2, UYVY, YVYU)\n");
	fprintf(stderr, "	-hw\n");
	fprintf(stderr, "	-flip\n");
	fprintf(stderr, "	-scale (test scaling features, from 50%% upto window size)\n");
	fprintf(stderr, "	-mono (use monochromatic RGB2YUV conversion)\n");
	fprintf(stderr, "	-lum <perc> (use luminance correction during RGB2YUV conversion,\n");
	fprintf(stderr, "	             from 0%% to unlimited, normal is 100%%)\n");
	fprintf(stderr, "	-help (shows this help)\n");
	fprintf(stderr, "	-fullscreen (test overlay in fullscreen mode)\n");
}

int main(int argc, char **argv)
{
	char *argv0 = argv[0];
	int flip;
	int delay;
	int desired_bpp;
	Uint32 video_flags, overlay_format;
	char *bmpfile;
#ifdef BENCHMARK_SDL
	Uint32 then, now;
#endif
	int i;

	/* Set default options and check command-line */
	flip = 0;
	scale=0;
        monochrome=0;
        luminance=100;
	delay = 1;
	w = WINDOW_WIDTH;
	h = WINDOW_HEIGHT;
	desired_bpp = 0;
	video_flags = 0;
	overlay_format = SDL_YV12_OVERLAY;

	while ( argc > 1 ) {
		if ( strcmp(argv[1], "-delay") == 0 ) {
			if ( argv[2] ) {
				delay = atoi(argv[2]);
				argv += 2;
				argc -= 2;
			} else {
				fprintf(stderr,
				"The -delay option requires an argument\n");
				return(1);
			}
		} else
		if ( strcmp(argv[1], "-width") == 0 ) {
			if ( argv[2] && ((w = atoi(argv[2])) > 0) ) {
				argv += 2;
				argc -= 2;
			} else {
				fprintf(stderr,
				"The -width option requires an argument\n");
				return(1);
			}
		} else
		if ( strcmp(argv[1], "-height") == 0 ) {
			if ( argv[2] && ((h = atoi(argv[2])) > 0) ) {
				argv += 2;
				argc -= 2;
			} else {
				fprintf(stderr,
				"The -height option requires an argument\n");
				return(1);
			}
		} else
		if ( strcmp(argv[1], "-bpp") == 0 ) {
			if ( argv[2] ) {
				desired_bpp = atoi(argv[2]);
				argv += 2;
				argc -= 2;
			} else {
				fprintf(stderr,
				"The -bpp option requires an argument\n");
				return(1);
			}
		} else
		if ( strcmp(argv[1], "-lum") == 0 ) {
			if ( argv[2] ) {
				luminance = atoi(argv[2]);
				argv += 2;
				argc -= 2;
			} else {
				fprintf(stderr,
				"The -lum option requires an argument\n");
				return(1);
			}
		} else
		if ( strcmp(argv[1], "-format") == 0 ) {
			if ( argv[2] ) {
				if(!strcmp(argv[2],"YV12"))
					overlay_format = SDL_YV12_OVERLAY;
				else if(!strcmp(argv[2],"IYUV"))
					overlay_format = SDL_IYUV_OVERLAY;
				else if(!strcmp(argv[2],"YUY2"))
					overlay_format = SDL_YUY2_OVERLAY;
				else if(!strcmp(argv[2],"UYVY"))
					overlay_format = SDL_UYVY_OVERLAY;
				else if(!strcmp(argv[2],"YVYU"))
					overlay_format = SDL_YVYU_OVERLAY;
				else
				{
					fprintf(stderr, "The -format option %s is not recognized\n",argv[2]);
					return(1);
				}
				argv += 2;
				argc -= 2;
			} else {
				fprintf(stderr,
				"The -format option requires an argument\n");
				return(1);
			}
		} else
		if ( strcmp(argv[1], "-hw") == 0 ) {
			video_flags |= SDL_HWSURFACE;
			argv += 1;
			argc -= 1;
		} else
		if ( strcmp(argv[1], "-flip") == 0 ) {
			video_flags |= SDL_DOUBLEBUF;
			argv += 1;
			argc -= 1;
		} else
		if ( strcmp(argv[1], "-scale") == 0 ) {
			scale = 1;
			argv += 1;
			argc -= 1;
		} else
		if ( strcmp(argv[1], "-mono") == 0 ) {
			monochrome = 1;
			argv += 1;
			argc -= 1;
		} else
		if (( strcmp(argv[1], "-help") == 0 ) || (strcmp(argv[1], "-h") == 0)) {
                        PrintUsage(argv0);
                        return(1);
		} else
		if ( strcmp(argv[1], "-fullscreen") == 0 ) {
			video_flags |= SDL_FULLSCREEN;
			argv += 1;
			argc -= 1;
		} else
			break;
	}
	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
		fprintf(stderr,
			"Couldn't initialize SDL: %s\n", SDL_GetError());
		return(1);
	}

	/* Initialize the display */
	screen = SDL_SetVideoMode(w, h, desired_bpp, video_flags);
	if ( screen == NULL ) {
		fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",
					w, h, desired_bpp, SDL_GetError());
		quit(1);
	}
	printf("Set%s %dx%dx%d mode\n",
			screen->flags & SDL_FULLSCREEN ? " fullscreen" : "",
			screen->w, screen->h, screen->format->BitsPerPixel);
	printf("(video surface located in %s memory)\n",
			(screen->flags&SDL_HWSURFACE) ? "video" : "system");
	if ( screen->flags & SDL_DOUBLEBUF ) {
		printf("Double-buffering enabled\n");
		flip = 1;
	}

	/* Set the window manager title bar */
	SDL_WM_SetCaption("SDL test overlay", "testoverlay");

	/* Load picture */
	bmpfile=(argv[1]?argv[1]:"sample.bmp");
	pic = SDL_LoadBMP(bmpfile);
	if ( pic == NULL ) {
		fprintf(stderr, "Couldn't load %s: %s\n", bmpfile,
							SDL_GetError());
		quit(1);
	}

	/* Convert the picture to 32bits, for easy conversion */
	{
		SDL_Surface *newsurf;
		SDL_PixelFormat format;

		format.palette=NULL;
		format.BitsPerPixel=32;
		format.BytesPerPixel=4;
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
		format.Rshift=0;
		format.Gshift=8;
		format.Bshift=16;
#else
		format.Rshift=24;
		format.Gshift=16;
		format.Bshift=8;
#endif
		format.Ashift=0;
		format.Rmask=0xff<<format.Rshift;
		format.Gmask=0xff<<format.Gshift;
		format.Bmask=0xff<<format.Bshift;
		format.Amask=0;
		format.Rloss=0;
		format.Gloss=0;
		format.Bloss=0;
		format.Aloss=8;
		format.colorkey=0;
		format.alpha=0;

		newsurf=SDL_ConvertSurface(pic, &format, SDL_SWSURFACE);
		if(!newsurf)
		{
			fprintf(stderr, "Couldn't convert picture to 32bits RGB: %s\n",
							SDL_GetError());
			quit(1);
		}
		SDL_FreeSurface(pic);
		pic=newsurf;
	}
	
	/* Create the overlay */
	overlay = SDL_CreateYUVOverlay(pic->w, pic->h, overlay_format, screen);
	if ( overlay == NULL ) {
		fprintf(stderr, "Couldn't create overlay: %s\n", SDL_GetError());
		quit(1);
	}
	printf("Created %dx%dx%d %s %s overlay\n",overlay->w,overlay->h,overlay->planes,
			overlay->hw_overlay?"hardware":"software",
			overlay->format==SDL_YV12_OVERLAY?"YV12":
			overlay->format==SDL_IYUV_OVERLAY?"IYUV":
			overlay->format==SDL_YUY2_OVERLAY?"YUY2":
			overlay->format==SDL_UYVY_OVERLAY?"UYVY":
			overlay->format==SDL_YVYU_OVERLAY?"YVYU":
			"Unknown");
	for(i=0; i<overlay->planes; i++)
	{
		printf("  plane %d: pitch=%d\n", i, overlay->pitches[i]);
	}
	
	/* Convert to YUV, and draw to the overlay */
#ifdef BENCHMARK_SDL
	then = SDL_GetTicks();
#endif
	switch(overlay->format)
	{
		case SDL_YV12_OVERLAY:
			ConvertRGBtoYV12(pic,overlay,monochrome,luminance);
			break;
		case SDL_UYVY_OVERLAY:
			ConvertRGBtoUYVY(pic,overlay,monochrome,luminance);
			break;
		case SDL_YVYU_OVERLAY:
			ConvertRGBtoYVYU(pic,overlay,monochrome,luminance);
			break;
		case SDL_YUY2_OVERLAY:
			ConvertRGBtoYUY2(pic,overlay,monochrome,luminance);
			break;
		case SDL_IYUV_OVERLAY:
			ConvertRGBtoIYUV(pic,overlay,monochrome,luminance);
			break;
		default:
			printf("cannot convert RGB picture to obtained YUV format!\n");
			quit(1);
			break;
	}
#ifdef BENCHMARK_SDL
	now = SDL_GetTicks();
	printf("Conversion Time: %d milliseconds\n", now-then);
#endif
	
	/* Do all the drawing work */
#ifdef BENCHMARK_SDL
	then = SDL_GetTicks();
#endif
	Draw();
#ifdef BENCHMARK_SDL
	now = SDL_GetTicks();
	printf("Time: %d milliseconds\n", now-then);
#endif
	SDL_Delay(delay*1000);
	SDL_Quit();
	return(0);
}
Commit	Line	Data
	1
	2	/* Bring up a window and play with it */
	3
	4	#include <stdlib.h>
	5	#include <stdio.h>
	6	#include <string.h>
	7
	8	#define BENCHMARK_SDL
	9
	10	#define NOTICE(X) printf("%s", X);
	11
	12	#define WINDOW_WIDTH 640
	13	#define WINDOW_HEIGHT 480
	14
	15	#include "SDL.h"
	16
	17	SDL_Surface screen, pic;
	18	SDL_Overlay *overlay;
	19	int scale;
	20	int monochrome;
	21	int luminance;
	22	int w, h;
	23
	24	/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
	25	static void quit(int rc)
	26	{
	27	SDL_Quit();
	28	exit(rc);
	29	}
	30
	31	/* NOTE: These RGB conversion functions are not intended for speed,
	32	only as examples.
	33	*/
	34
	35	void RGBtoYUV(Uint8 rgb, int yuv, int monochrome, int luminance)
	36	{
	37	if (monochrome)
	38	{
	39	#if 1 /* these are the two formulas that I found on the FourCC site... */
	40	yuv[0] = 0.299rgb[0] + 0.587rgb[1] + 0.114*rgb[2];
	41	yuv[1] = 128;
	42	yuv[2] = 128;
	43	#else
	44	yuv[0] = (0.257 * rgb[0]) + (0.504 * rgb[1]) + (0.098 * rgb[2]) + 16;
	45	yuv[1] = 128;
	46	yuv[2] = 128;
	47	#endif
	48	}
	49	else
	50	{
	51	#if 1 /* these are the two formulas that I found on the FourCC site... */
	52	yuv[0] = 0.299rgb[0] + 0.587rgb[1] + 0.114*rgb[2];
	53	yuv[1] = (rgb[2]-yuv[0])*0.565 + 128;
	54	yuv[2] = (rgb[0]-yuv[0])*0.713 + 128;
	55	#else
	56	yuv[0] = (0.257 * rgb[0]) + (0.504 * rgb[1]) + (0.098 * rgb[2]) + 16;
	57	yuv[1] = 128 - (0.148 * rgb[0]) - (0.291 * rgb[1]) + (0.439 * rgb[2]);
	58	yuv[2] = 128 + (0.439 * rgb[0]) - (0.368 * rgb[1]) - (0.071 * rgb[2]);
	59	#endif
	60	}
	61
	62	if (luminance!=100)
	63	{
	64	yuv[0]=yuv[0]*luminance/100;
	65	if (yuv[0]>255)
	66	yuv[0]=255;
	67	}
	68
	69	/* clamp values...if you need to, we don't seem to have a need */
	70	/*
	71	for(i=0;i<3;i++)
	72	{
	73	if(yuv[i]<0)
	74	yuv[i]=0;
	75	if(yuv[i]>255)
	76	yuv[i]=255;
	77	}
	78	*/
	79	}
	80
	81	void ConvertRGBtoYV12(SDL_Surface s, SDL_Overlay o, int monochrome, int luminance)
	82	{
	83	int x,y;
	84	int yuv[3];
	85	Uint8 p,op[3];
	86
	87	SDL_LockSurface(s);
	88	SDL_LockYUVOverlay(o);
	89
	90	/* Black initialization */
	91	/*
	92	memset(o->pixels[0],0,o->pitches[0]*o->h);
	93	memset(o->pixels[1],128,o->pitches[1]*((o->h+1)/2));
	94	memset(o->pixels[2],128,o->pitches[2]*((o->h+1)/2));
	95	*/
	96
	97	/* Convert */
	98	for(y=0; y<s->h && y<o->h; y++)
	99	{
	100	p=((Uint8 ) s->pixels)+s->pitchy;
	101	op[0]=o->pixels[0]+o->pitches[0]*y;
	102	op[1]=o->pixels[1]+o->pitches[1]*(y/2);
	103	op[2]=o->pixels[2]+o->pitches[2]*(y/2);
	104	for(x=0; x<s->w && x<o->w; x++)
	105	{
	106	RGBtoYUV(p, yuv, monochrome, luminance);
	107	*(op[0]++)=yuv[0];
	108	if(x%2==0 && y%2==0)
	109	{
	110	*(op[1]++)=yuv[2];
	111	*(op[2]++)=yuv[1];
	112	}
	113	p+=s->format->BytesPerPixel;
	114	}
	115	}
	116
	117	SDL_UnlockYUVOverlay(o);
	118	SDL_UnlockSurface(s);
	119	}
	120
	121	void ConvertRGBtoIYUV(SDL_Surface s, SDL_Overlay o, int monochrome, int luminance)
	122	{
	123	int x,y;
	124	int yuv[3];
	125	Uint8 p,op[3];
	126
	127	SDL_LockSurface(s);
	128	SDL_LockYUVOverlay(o);
	129
	130	/* Black initialization */
	131	/*
	132	memset(o->pixels[0],0,o->pitches[0]*o->h);
	133	memset(o->pixels[1],128,o->pitches[1]*((o->h+1)/2));
	134	memset(o->pixels[2],128,o->pitches[2]*((o->h+1)/2));
	135	*/
	136
	137	/* Convert */
	138	for(y=0; y<s->h && y<o->h; y++)
	139	{
	140	p=((Uint8 ) s->pixels)+s->pitchy;
	141	op[0]=o->pixels[0]+o->pitches[0]*y;
	142	op[1]=o->pixels[1]+o->pitches[1]*(y/2);
	143	op[2]=o->pixels[2]+o->pitches[2]*(y/2);
	144	for(x=0; x<s->w && x<o->w; x++)
	145	{
	146	RGBtoYUV(p,yuv, monochrome, luminance);
	147	*(op[0]++)=yuv[0];
	148	if(x%2==0 && y%2==0)
	149	{
	150	*(op[1]++)=yuv[1];
	151	*(op[2]++)=yuv[2];
	152	}
	153	p+=s->format->BytesPerPixel;
	154	}
	155	}
	156
	157	SDL_UnlockYUVOverlay(o);
	158	SDL_UnlockSurface(s);
	159	}
	160
	161	void ConvertRGBtoUYVY(SDL_Surface s, SDL_Overlay o, int monochrome, int luminance)
	162	{
	163	int x,y;
	164	int yuv[3];
	165	Uint8 p,op;
	166
	167	SDL_LockSurface(s);
	168	SDL_LockYUVOverlay(o);
	169
	170	for(y=0; y<s->h && y<o->h; y++)
	171	{
	172	p=((Uint8 ) s->pixels)+s->pitchy;
	173	op=o->pixels[0]+o->pitches[0]*y;
	174	for(x=0; x<s->w && x<o->w; x++)
	175	{
	176	RGBtoYUV(p, yuv, monochrome, luminance);
	177	if(x%2==0)
	178	{
	179	*(op++)=yuv[1];
	180	*(op++)=yuv[0];
	181	*(op++)=yuv[2];
	182	}
	183	else
	184	*(op++)=yuv[0];
	185
	186	p+=s->format->BytesPerPixel;
	187	}
	188	}
	189
	190	SDL_UnlockYUVOverlay(o);
	191	SDL_UnlockSurface(s);
	192	}
	193
	194	void ConvertRGBtoYVYU(SDL_Surface s, SDL_Overlay o, int monochrome, int luminance)
	195	{
	196	int x,y;
	197	int yuv[3];
	198	Uint8 p,op;
	199
	200	SDL_LockSurface(s);
	201	SDL_LockYUVOverlay(o);
	202
	203	for(y=0; y<s->h && y<o->h; y++)
	204	{
	205	p=((Uint8 ) s->pixels)+s->pitchy;
	206	op=o->pixels[0]+o->pitches[0]*y;
	207	for(x=0; x<s->w && x<o->w; x++)
	208	{
	209	RGBtoYUV(p,yuv, monochrome, luminance);
	210	if(x%2==0)
	211	{
	212	*(op++)=yuv[0];
	213	*(op++)=yuv[2];
	214	op[1]=yuv[1];
	215	}
	216	else
	217	{
	218	*op=yuv[0];
	219	op+=2;
	220	}
	221
	222	p+=s->format->BytesPerPixel;
	223	}
	224	}
	225
	226	SDL_UnlockYUVOverlay(o);
	227	SDL_UnlockSurface(s);
	228	}
	229
	230	void ConvertRGBtoYUY2(SDL_Surface s, SDL_Overlay o, int monochrome, int luminance)
	231	{
	232	int x,y;
	233	int yuv[3];
	234	Uint8 p,op;
	235
	236	SDL_LockSurface(s);
	237	SDL_LockYUVOverlay(o);
	238
	239	for(y=0; y<s->h && y<o->h; y++)
	240	{
	241	p=((Uint8 ) s->pixels)+s->pitchy;
	242	op=o->pixels[0]+o->pitches[0]*y;
	243	for(x=0; x<s->w && x<o->w; x++)
	244	{
	245	RGBtoYUV(p,yuv, monochrome, luminance);
	246	if(x%2==0)
	247	{
	248	*(op++)=yuv[0];
	249	*(op++)=yuv[1];
	250	op[1]=yuv[2];
	251	}
	252	else
	253	{
	254	*op=yuv[0];
	255	op+=2;
	256	}
	257
	258	p+=s->format->BytesPerPixel;
	259	}
	260	}
	261
	262	SDL_UnlockYUVOverlay(o);
	263	SDL_UnlockSurface(s);
	264	}
	265
	266	void Draw()
	267	{
	268	SDL_Rect rect;
	269	int i;
	270	int disp;
	271
	272	if(!scale)
	273	{
	274	rect.w=overlay->w;
	275	rect.h=overlay->h;
	276	for(i=0; i<h-rect.h && i<w-rect.w; i++)
	277	{
	278	rect.x=i;
	279	rect.y=i;
	280	SDL_DisplayYUVOverlay(overlay,&rect);
	281	}
	282	}
	283	else
	284	{
	285	rect.w=overlay->w/2;
	286	rect.h=overlay->h/2;
	287	rect.x=(w-rect.w)/2;
	288	rect.y=(h-rect.h)/2;
	289	disp=rect.y-1;
	290	for(i=0; i<disp; i++)
	291	{
	292	rect.w+=2;
	293	rect.h+=2;
	294	rect.x--;
	295	rect.y--;
	296	SDL_DisplayYUVOverlay(overlay,&rect);
	297	}
	298	}
	299	printf("Displayed %d times.\n",i);
	300	}
	301
	302	static void PrintUsage(char *argv0)
	303	{
	304	fprintf(stderr, "Usage: %s [arg] [arg] [arg] ...\n", argv0);
	305	fprintf(stderr, "Where 'arg' is one of:\n");
	306	fprintf(stderr, " -delay <seconds>\n");
	307	fprintf(stderr, " -width <pixels>\n");
	308	fprintf(stderr, " -height <pixels>\n");
	309	fprintf(stderr, " -bpp <bits>\n");
	310	fprintf(stderr, " -format <fmt> (one of the: YV12, IYUV, YUY2, UYVY, YVYU)\n");
	311	fprintf(stderr, " -hw\n");
	312	fprintf(stderr, " -flip\n");
	313	fprintf(stderr, " -scale (test scaling features, from 50%% upto window size)\n");
	314	fprintf(stderr, " -mono (use monochromatic RGB2YUV conversion)\n");
	315	fprintf(stderr, " -lum <perc> (use luminance correction during RGB2YUV conversion,\n");
	316	fprintf(stderr, " from 0%% to unlimited, normal is 100%%)\n");
	317	fprintf(stderr, " -help (shows this help)\n");
	318	fprintf(stderr, " -fullscreen (test overlay in fullscreen mode)\n");
	319	}
	320
	321	int main(int argc, char **argv)
	322	{
	323	char *argv0 = argv[0];
	324	int flip;
	325	int delay;
	326	int desired_bpp;
	327	Uint32 video_flags, overlay_format;
	328	char *bmpfile;
	329	#ifdef BENCHMARK_SDL
	330	Uint32 then, now;
	331	#endif
	332	int i;
	333
	334	/* Set default options and check command-line */
	335	flip = 0;
	336	scale=0;
	337	monochrome=0;
	338	luminance=100;
	339	delay = 1;
	340	w = WINDOW_WIDTH;
	341	h = WINDOW_HEIGHT;
	342	desired_bpp = 0;
	343	video_flags = 0;
	344	overlay_format = SDL_YV12_OVERLAY;
	345
	346	while ( argc > 1 ) {
	347	if ( strcmp(argv[1], "-delay") == 0 ) {
	348	if ( argv[2] ) {
	349	delay = atoi(argv[2]);
	350	argv += 2;
	351	argc -= 2;
	352	} else {
	353	fprintf(stderr,
	354	"The -delay option requires an argument\n");
	355	return(1);
	356	}
	357	} else
	358	if ( strcmp(argv[1], "-width") == 0 ) {
	359	if ( argv[2] && ((w = atoi(argv[2])) > 0) ) {
	360	argv += 2;
	361	argc -= 2;
	362	} else {
	363	fprintf(stderr,
	364	"The -width option requires an argument\n");
	365	return(1);
	366	}
	367	} else
	368	if ( strcmp(argv[1], "-height") == 0 ) {
	369	if ( argv[2] && ((h = atoi(argv[2])) > 0) ) {
	370	argv += 2;
	371	argc -= 2;
	372	} else {
	373	fprintf(stderr,
	374	"The -height option requires an argument\n");
	375	return(1);
	376	}
	377	} else
	378	if ( strcmp(argv[1], "-bpp") == 0 ) {
	379	if ( argv[2] ) {
	380	desired_bpp = atoi(argv[2]);
	381	argv += 2;
	382	argc -= 2;
	383	} else {
	384	fprintf(stderr,
	385	"The -bpp option requires an argument\n");
	386	return(1);
	387	}
	388	} else
	389	if ( strcmp(argv[1], "-lum") == 0 ) {
	390	if ( argv[2] ) {
	391	luminance = atoi(argv[2]);
	392	argv += 2;
	393	argc -= 2;
	394	} else {
	395	fprintf(stderr,
	396	"The -lum option requires an argument\n");
	397	return(1);
	398	}
	399	} else
	400	if ( strcmp(argv[1], "-format") == 0 ) {
	401	if ( argv[2] ) {
	402	if(!strcmp(argv[2],"YV12"))
	403	overlay_format = SDL_YV12_OVERLAY;
	404	else if(!strcmp(argv[2],"IYUV"))
	405	overlay_format = SDL_IYUV_OVERLAY;
	406	else if(!strcmp(argv[2],"YUY2"))
	407	overlay_format = SDL_YUY2_OVERLAY;
	408	else if(!strcmp(argv[2],"UYVY"))
	409	overlay_format = SDL_UYVY_OVERLAY;
	410	else if(!strcmp(argv[2],"YVYU"))
	411	overlay_format = SDL_YVYU_OVERLAY;
	412	else
	413	{
	414	fprintf(stderr, "The -format option %s is not recognized\n",argv[2]);
	415	return(1);
	416	}
	417	argv += 2;
	418	argc -= 2;
	419	} else {
	420	fprintf(stderr,
	421	"The -format option requires an argument\n");
	422	return(1);
	423	}
	424	} else
	425	if ( strcmp(argv[1], "-hw") == 0 ) {
	426	video_flags \|= SDL_HWSURFACE;
	427	argv += 1;
	428	argc -= 1;
	429	} else
	430	if ( strcmp(argv[1], "-flip") == 0 ) {
	431	video_flags \|= SDL_DOUBLEBUF;
	432	argv += 1;
	433	argc -= 1;
	434	} else
	435	if ( strcmp(argv[1], "-scale") == 0 ) {
	436	scale = 1;
	437	argv += 1;
	438	argc -= 1;
	439	} else
	440	if ( strcmp(argv[1], "-mono") == 0 ) {
	441	monochrome = 1;
	442	argv += 1;
	443	argc -= 1;
	444	} else
	445	if (( strcmp(argv[1], "-help") == 0 ) \|\| (strcmp(argv[1], "-h") == 0)) {
	446	PrintUsage(argv0);
	447	return(1);
	448	} else
	449	if ( strcmp(argv[1], "-fullscreen") == 0 ) {
	450	video_flags \|= SDL_FULLSCREEN;
	451	argv += 1;
	452	argc -= 1;
	453	} else
	454	break;
	455	}
	456	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
	457	fprintf(stderr,
	458	"Couldn't initialize SDL: %s\n", SDL_GetError());
	459	return(1);
	460	}
	461
	462	/* Initialize the display */
	463	screen = SDL_SetVideoMode(w, h, desired_bpp, video_flags);
	464	if ( screen == NULL ) {
	465	fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",
	466	w, h, desired_bpp, SDL_GetError());
	467	quit(1);
	468	}
	469	printf("Set%s %dx%dx%d mode\n",
	470	screen->flags & SDL_FULLSCREEN ? " fullscreen" : "",
	471	screen->w, screen->h, screen->format->BitsPerPixel);
	472	printf("(video surface located in %s memory)\n",
	473	(screen->flags&SDL_HWSURFACE) ? "video" : "system");
	474	if ( screen->flags & SDL_DOUBLEBUF ) {
	475	printf("Double-buffering enabled\n");
	476	flip = 1;
	477	}
	478
	479	/* Set the window manager title bar */
	480	SDL_WM_SetCaption("SDL test overlay", "testoverlay");
	481
	482	/* Load picture */
	483	bmpfile=(argv[1]?argv[1]:"sample.bmp");
	484	pic = SDL_LoadBMP(bmpfile);
	485	if ( pic == NULL ) {
	486	fprintf(stderr, "Couldn't load %s: %s\n", bmpfile,
	487	SDL_GetError());
	488	quit(1);
	489	}
	490
	491	/* Convert the picture to 32bits, for easy conversion */
	492	{
	493	SDL_Surface *newsurf;
	494	SDL_PixelFormat format;
	495
	496	format.palette=NULL;
	497	format.BitsPerPixel=32;
	498	format.BytesPerPixel=4;
	499	#if SDL_BYTEORDER == SDL_LIL_ENDIAN
	500	format.Rshift=0;
	501	format.Gshift=8;
	502	format.Bshift=16;
	503	#else
	504	format.Rshift=24;
	505	format.Gshift=16;
	506	format.Bshift=8;
	507	#endif
	508	format.Ashift=0;
	509	format.Rmask=0xff<<format.Rshift;
	510	format.Gmask=0xff<<format.Gshift;
	511	format.Bmask=0xff<<format.Bshift;
	512	format.Amask=0;
	513	format.Rloss=0;
	514	format.Gloss=0;
	515	format.Bloss=0;
	516	format.Aloss=8;
	517	format.colorkey=0;
	518	format.alpha=0;
	519
	520	newsurf=SDL_ConvertSurface(pic, &format, SDL_SWSURFACE);
	521	if(!newsurf)
	522	{
	523	fprintf(stderr, "Couldn't convert picture to 32bits RGB: %s\n",
	524	SDL_GetError());
	525	quit(1);
	526	}
	527	SDL_FreeSurface(pic);
	528	pic=newsurf;
	529	}
	530
	531	/* Create the overlay */
	532	overlay = SDL_CreateYUVOverlay(pic->w, pic->h, overlay_format, screen);
	533	if ( overlay == NULL ) {
	534	fprintf(stderr, "Couldn't create overlay: %s\n", SDL_GetError());
	535	quit(1);
	536	}
	537	printf("Created %dx%dx%d %s %s overlay\n",overlay->w,overlay->h,overlay->planes,
	538	overlay->hw_overlay?"hardware":"software",
	539	overlay->format==SDL_YV12_OVERLAY?"YV12":
	540	overlay->format==SDL_IYUV_OVERLAY?"IYUV":
	541	overlay->format==SDL_YUY2_OVERLAY?"YUY2":
	542	overlay->format==SDL_UYVY_OVERLAY?"UYVY":
	543	overlay->format==SDL_YVYU_OVERLAY?"YVYU":
	544	"Unknown");
	545	for(i=0; i<overlay->planes; i++)
	546	{
	547	printf(" plane %d: pitch=%d\n", i, overlay->pitches[i]);
	548	}
	549
	550	/* Convert to YUV, and draw to the overlay */
	551	#ifdef BENCHMARK_SDL
	552	then = SDL_GetTicks();
	553	#endif
	554	switch(overlay->format)
	555	{
	556	case SDL_YV12_OVERLAY:
	557	ConvertRGBtoYV12(pic,overlay,monochrome,luminance);
	558	break;
	559	case SDL_UYVY_OVERLAY:
	560	ConvertRGBtoUYVY(pic,overlay,monochrome,luminance);
	561	break;
	562	case SDL_YVYU_OVERLAY:
	563	ConvertRGBtoYVYU(pic,overlay,monochrome,luminance);
	564	break;
	565	case SDL_YUY2_OVERLAY:
	566	ConvertRGBtoYUY2(pic,overlay,monochrome,luminance);
	567	break;
	568	case SDL_IYUV_OVERLAY:
	569	ConvertRGBtoIYUV(pic,overlay,monochrome,luminance);
	570	break;
	571	default:
	572	printf("cannot convert RGB picture to obtained YUV format!\n");
	573	quit(1);
	574	break;
	575	}
	576	#ifdef BENCHMARK_SDL
	577	now = SDL_GetTicks();
	578	printf("Conversion Time: %d milliseconds\n", now-then);
	579	#endif
	580
	581	/* Do all the drawing work */
	582	#ifdef BENCHMARK_SDL
	583	then = SDL_GetTicks();
	584	#endif
	585	Draw();
	586	#ifdef BENCHMARK_SDL
	587	now = SDL_GetTicks();
	588	printf("Time: %d milliseconds\n", now-then);
	589	#endif
	590	SDL_Delay(delay*1000);
	591	SDL_Quit();
	592	return(0);
	593	}
	594