diff options
author | arpi_esp <arpi_esp@b3059339-0415-0410-9bf9-f77b7e298cf2> | 2001-02-24 20:28:24 +0000 |
---|---|---|
committer | arpi_esp <arpi_esp@b3059339-0415-0410-9bf9-f77b7e298cf2> | 2001-02-24 20:28:24 +0000 |
commit | d34041569e71fc9bd772354e94dc9d16061072a5 (patch) | |
tree | 8f481cae1c70f32d1756fbe5f39000577b73042d /libvo | |
parent | e95a95ece09bac96bdfd37322f96c6f57ef79ebc (diff) | |
download | mpv-d34041569e71fc9bd772354e94dc9d16061072a5.tar.bz2 mpv-d34041569e71fc9bd772354e94dc9d16061072a5.tar.xz |
Initial revision
git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@2 b3059339-0415-0410-9bf9-f77b7e298cf2
Diffstat (limited to 'libvo')
32 files changed, 9258 insertions, 0 deletions
diff --git a/libvo/Attic/SHIT/video_out_gl.c.V3-sux b/libvo/Attic/SHIT/video_out_gl.c.V3-sux new file mode 100644 index 0000000000..459995d9d4 --- /dev/null +++ b/libvo/Attic/SHIT/video_out_gl.c.V3-sux @@ -0,0 +1,538 @@ +#define DISP + +// this can be 3 or 4 (regarding 24bpp and 32bpp) +#define BYTES_PP 3 + +#define TEXTUREFORMAT_32BPP + +// Hmm. Enabling this makes about 20% speedup too! (Celeron2+G400+UtahGLX) +//#define TEXSUBIMAGE_BUG_WORKAROUND + +/* + * video_out_gl.c, X11/OpenGL interface + * based on video_out_x11 by Aaron Holtzman, + * and WS opengl window manager by Pontscho/Fresh! + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> + +#include "config.h" +#include "video_out.h" +#include "video_out_internal.h" + + +LIBVO_EXTERN(gl) + +#include <X11/Xlib.h> +#include <X11/Xutil.h> +//#include <X11/keysym.h> +#include <GL/glx.h> +#include <errno.h> +#include "yuv2rgb.h" + +#include <GL/gl.h> + +static vo_info_t vo_info = +{ + "X11 (OpenGL)", + "gl", + "Arpad Gereoffy <arpi@esp-team.scene.hu>", + "" +}; + +/* private prototypes */ +static void Display_Image (unsigned char *ImageData); + +/* local data */ +static unsigned char *ImageData=NULL; + +/* X11 related variables */ +static Display *mydisplay; +static Window mywindow; +//static GC mygc; +//static XImage *myximage; +//static int depth,mode; +static XWindowAttributes attribs; +static int X_already_started = 0; + +static int texture_id=1; + +static GLXContext wsGLXContext; +//XVisualInfo * wsVisualInfo; +int wsGLXAttrib[] = { GLX_RGBA, + GLX_RED_SIZE,1, + GLX_GREEN_SIZE,1, + GLX_BLUE_SIZE,1, +// GLX_DEPTH_SIZE,16, + GLX_DOUBLEBUFFER, + None }; + + +static uint32_t image_width; +static uint32_t image_height; +static uint32_t image_format; +static uint32_t image_bpp; +static uint32_t image_bytes; + +static uint32_t texture_width; +static uint32_t texture_height; + +static resize(int x,int y){ + printf("Resize: %dx%d\n",x,y); + glViewport( 0, 0, x, y ); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, image_width, image_height, 0, -1,1); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); +} + +/* connect to server, create and map window, + * allocate colors and (shared) memory + */ +static uint32_t +init(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t fullscreen, char *title, uint32_t format) +{ + int screen; + unsigned int fg, bg; + char *hello = (title == NULL) ? "OpenGL rulez" : title; + char *name = ":0.0"; + XSizeHints hint; + XVisualInfo *vinfo; + XEvent xev; + + XGCValues xgcv; + XSetWindowAttributes xswa; + unsigned long xswamask; + + image_height = height; + image_width = width; + image_format = format; + + if (X_already_started) return -1; + + if(getenv("DISPLAY")) name = getenv("DISPLAY"); + + mydisplay = XOpenDisplay(name); + + if (mydisplay == NULL) + { + fprintf(stderr,"Can not open display\n"); + return -1; + } + + screen = DefaultScreen(mydisplay); + + hint.x = 0; + hint.y = 0; + hint.width = d_width; + hint.height = d_height; + hint.flags = PPosition | PSize; + + /* Get some colors */ + + bg = WhitePixel(mydisplay, screen); + fg = BlackPixel(mydisplay, screen); + + /* Make the window */ + + XGetWindowAttributes(mydisplay, DefaultRootWindow(mydisplay), &attribs); + +#if 0 + /* + * + * depth in X11 terminology land is the number of bits used to + * actually represent the colour. + * + * bpp in X11 land means how many bits in the frame buffer per + * pixel. + * + * ex. 15 bit color is 15 bit depth and 16 bpp. Also 24 bit + * color is 24 bit depth, but can be 24 bpp or 32 bpp. + */ + + depth = attribs.depth; + + if (depth != 15 && depth != 16 && depth != 24 && depth != 32) + { + /* The root window may be 8bit but there might still be + * visuals with other bit depths. For example this is the + * case on Sun/Solaris machines. + */ + depth = 24; + } + //BEGIN HACK + //mywindow = XCreateSimpleWindow(mydisplay, DefaultRootWindow(mydisplay), + //hint.x, hint.y, hint.width, hint.height, 4, fg, bg); + // +#endif + +// XMatchVisualInfo(mydisplay, screen, depth, TrueColor, &vinfo); + vinfo=glXChooseVisual( mydisplay,screen,wsGLXAttrib ); + + xswa.background_pixel = 0; + xswa.border_pixel = 1; +// xswa.colormap = XCreateColormap(mydisplay, RootWindow(mydisplay,screen), vinfo.visual, AllocNone); + xswa.colormap = XCreateColormap(mydisplay, RootWindow(mydisplay,screen), vinfo->visual, AllocNone); + xswamask = CWBackPixel | CWBorderPixel | CWColormap; +// xswamask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask | CWCursor | CWOverrideRedirect | CWSaveUnder | CWX | CWY | CWWidth | CWHeight; + + mywindow = XCreateWindow(mydisplay, RootWindow(mydisplay,screen), + hint.x, hint.y, hint.width, hint.height, 4, vinfo->depth,CopyFromParent,vinfo->visual,xswamask,&xswa); + + wsGLXContext=glXCreateContext( mydisplay,vinfo,NULL,True ); +// XStoreName( wsDisplay,wsMyWin,wsSysName ); + + printf("GLXcontect ok\n"); + + XSelectInput(mydisplay, mywindow, StructureNotifyMask); + + /* Tell other applications about this window */ + + XSetStandardProperties(mydisplay, mywindow, hello, hello, None, NULL, 0, &hint); + + /* Map window. */ + + XMapWindow(mydisplay, mywindow); + + /* Wait for map. */ + do + { + XNextEvent(mydisplay, &xev); + } + while (xev.type != MapNotify || xev.xmap.event != mywindow); + + XSelectInput(mydisplay, mywindow, NoEventMask); + + glXMakeCurrent( mydisplay,mywindow,wsGLXContext ); + + XFlush(mydisplay); + XSync(mydisplay, False); + +// mygc = XCreateGC(mydisplay, mywindow, 0L, &xgcv); + +// myximage = XGetImage(mydisplay, mywindow, 0, 0, +// width, image_height, AllPlanes, ZPixmap); +// ImageData = myximage->data; +// bpp = myximage->bits_per_pixel; + + XSelectInput(mydisplay, mywindow, StructureNotifyMask); // !!!! + + printf("Window setup ok\n"); + +#if 0 + // If we have blue in the lowest bit then obviously RGB + mode = ((myximage->blue_mask & 0x01) != 0) ? MODE_RGB : MODE_BGR; +#ifdef WORDS_BIGENDIAN + if (myximage->byte_order != MSBFirst) +#else + if (myximage->byte_order != LSBFirst) +#endif + { + fprintf( stderr, "No support fon non-native XImage byte order!\n" ); + return -1; + } + + printf("DEPTH=%d BPP=%d\n",depth,bpp); +#endif + + /* + * If depth is 24 then it may either be a 3 or 4 byte per pixel + * format. We can't use bpp because then we would lose the + * distinction between 15/16bit depth (2 byte formate assumed). + * + * FIXME - change yuv2rgb_init to take both depth and bpp + * parameters + */ + + texture_width=32; + while(texture_width<image_width) texture_width*=2; + while(texture_width<image_height) texture_width*=2; + if(texture_width>256)texture_width=256; // voodoo3 hack + texture_height=texture_width; + + if(format==IMGFMT_YV12){ + yuv2rgb_init(8*BYTES_PP, MODE_RGB); + printf("YUV init OK!\n"); + image_bpp=8*BYTES_PP; + image_bytes=BYTES_PP; + } else { + image_bpp=format&0xFF; + image_bytes=(image_bpp+7)/8; + } + + ImageData=malloc(texture_width*texture_height*image_bytes); + memset(ImageData,128,texture_width*texture_height*image_bytes); + + glDisable(GL_BLEND); + glDisable(GL_DEPTH_TEST); + glDepthMask(GL_FALSE); + glDisable(GL_CULL_FACE); + + printf("Creating %dx%d texture...\n",texture_width,texture_height); + +#if 1 +// glBindTexture(GL_TEXTURE_2D, texture_id); + glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR); +#ifdef TEXTUREFORMAT_32BPP + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, texture_width, texture_height, 0, +#else + glTexImage2D(GL_TEXTURE_2D, 0, BYTES_PP, texture_width, texture_height, 0, +#endif + (image_bytes==4)?GL_RGBA:GL_BGR, GL_UNSIGNED_BYTE, ImageData); +#endif + + resize(d_width,d_height); + + glClearColor( 1.0f,1.0f,1.0f,0.0f ); + glClear( GL_COLOR_BUFFER_BIT ); + + printf("OpenGL setup OK!\n"); + + X_already_started++; + return 0; +} + +static const vo_info_t* +get_info(void) +{ + return &vo_info; +} + +static void +Terminate_Display_Process(void) +{ + getchar(); /* wait for enter to remove window */ + XDestroyWindow(mydisplay, mywindow); + XCloseDisplay(mydisplay); + X_already_started = 0; +} + +static void +FlipImage() +{ +// XPutImage(mydisplay, mywindow, mygc, myximage, 0, 0, 0, 0, myximage->width, myximage->height); +// XFlush(mydisplay); +int i; +XEvent wsEvent; +XEvent xev; + + while ( XPending( mydisplay ) ) { + XNextEvent( mydisplay,&wsEvent ); + switch( wsEvent.type ) { +// case Expose: if ( wsReDraw ) wsReDraw( wsDisplay,wsEvent.xany.window ); break; + case ConfigureNotify: //wsWindowWidth=wsEvent.xconfigure.width; + //wsWindowHeight=wsEvent.xconfigure.height; +#if 0 + XUnmapWindow( mydisplay,mywindow ); + XMapWindow( mydisplay,mywindow ); + /* Wait for map. */ + do { XNextEvent(mydisplay, &xev);} + while (xev.type != MapNotify || xev.xmap.event != mywindow); +#endif + resize( wsEvent.xconfigure.width, wsEvent.xconfigure.height ); + break; + } + } + + glEnable(GL_TEXTURE_2D); +// glBindTexture(GL_TEXTURE_2D, texture_id); + + glColor3f(1,1,1); + glBegin(GL_QUADS); + glTexCoord2f(0,0);glVertex2i(0,0); + glTexCoord2f(0,1);glVertex2i(0,texture_height); + glTexCoord2f(1,1);glVertex2i(texture_width,texture_height); + glTexCoord2f(1,0);glVertex2i(texture_width,0); + glEnd(); + +// glFlush(); + glFinish(); + glXSwapBuffers( mydisplay,mywindow ); + +} + +static inline void +flip_page_x11(void) +{ +// Display_Image(myximage, ImageData); +// Display_Image(ImageData); + FlipImage(); +} + + +static void +flip_page(void) +{ + return flip_page_x11(); +} + +static inline uint32_t +draw_slice_x11(uint8_t *src[], uint32_t slice_num) +{ + uint8_t *dst; + int i; + + dst = ImageData;// + image_width * 16 * BYTES_PP * slice_num; + + yuv2rgb(dst , src[0], src[1], src[2], + image_width, 16, + image_width*BYTES_PP, image_width, image_width/2 ); + +// emms (); + +#ifdef TEXSUBIMAGE_BUG_WORKAROUND + for(i=0;i<16;i++){ + glTexSubImage2D( GL_TEXTURE_2D, // target + 0, // level + 0, // x offset + 16*slice_num+i, // y offset + image_width, // width + 1, // height + (BYTES_PP==4)?GL_RGBA:GL_RGB, // format + GL_UNSIGNED_BYTE, // type + ImageData+i*BYTES_PP*image_width ); // *pixels + } +#else +//printf("uploading slice \n"); + glTexSubImage2D( GL_TEXTURE_2D, // target + 0, // level + 0, // x offset + 16*slice_num, // y offset + image_width, // width + 16, // height + (BYTES_PP==4)?GL_RGBA:GL_RGB, // format + GL_UNSIGNED_BYTE, // type + ImageData ); // *pixels +#endif + + return 0; +} + +static uint32_t +draw_slice(uint8_t *src[], uint32_t slice_num) +{ + return draw_slice_x11(src,slice_num); +} + +#define MIN(a,b) (((a)<(b))?(a):(b)) + +static inline uint32_t +draw_frame_x11_yv12(uint8_t *src[]) +{ +int i; +// printf("Converting YUV->RGB...\n"); + yuv2rgb(ImageData, src[0], src[1], src[2], + image_width, image_height, + image_width*BYTES_PP, image_width, image_width/2 ); +// printf("Ready!\n"); + +// emms (); + +// for(i=0;i<image_height;i++){ + for(i=0;i<MIN(image_height,texture_height);i++){ + glTexSubImage2D( GL_TEXTURE_2D, // target + 0, // level + 0, // x offset + i, // y offset +// image_width, // width + MIN(image_width,texture_width), // width + 1, // height + (BYTES_PP==4)?GL_RGBA:GL_RGB, // format + GL_UNSIGNED_BYTE, // type + ImageData+i*BYTES_PP*image_width ); // *pixels + } + +// Display_Image(ImageData); +// FlipImage(); + return 0; +} + + +static inline uint32_t +draw_frame_x11_bgr(uint8_t *src[]) +{ +int i; +uint8_t *s=src[0]; +uint8_t *de=&ImageData[3*image_width]; + + for(i=0;i<image_height;i++){ + int j; + uint8_t *d=ImageData; + while(d<de){ + d[0]=s[2]; + d[1]=s[1]; + d[2]=s[0]; + s+=3;d+=3; + } + glTexSubImage2D( GL_TEXTURE_2D, // target + 0, // level + 0, // x offset + image_height-1-i, // y offset + image_width<texture_width?image_width:texture_width, // width +// image_width, // width + 1, // height + (image_bytes==4)?GL_RGBA:GL_RGB, // format + GL_UNSIGNED_BYTE, // type + ImageData); // *pixels + } + +// Display_Image(ImageData); + FlipImage(); + return 0; +} + +static inline uint32_t +draw_frame_x11_rgb(uint8_t *src[]) +{ +int i; +uint8_t *ImageData=src[0]; + + for(i=0;i<image_height;i++){ + glTexSubImage2D( GL_TEXTURE_2D, // target + 0, // level + 0, // x offset + image_height-1-i, // y offset +// image_width, // width + image_width<texture_width?image_width:texture_width, // width + 1, // height + (image_bytes==4)?GL_RGBA:GL_RGB, // format + GL_UNSIGNED_BYTE, // type + ImageData+i*image_bytes*image_width ); // *pixels + } + +// Display_Image(ImageData); + FlipImage(); + return 0; +} + + +static uint32_t +draw_frame(uint8_t *src[]) +{ + if(image_format==IMGFMT_YV12) + return draw_frame_x11_yv12(src); + else + if((image_format&IMGFMT_RGB_MASK)==IMGFMT_RGB) + return draw_frame_x11_rgb(src); + else + return draw_frame_x11_bgr(src); +} + +static uint32_t +query_format(uint32_t format) +{ + switch(format){ + case IMGFMT_YV12: + case IMGFMT_RGB|24: + case IMGFMT_BGR|24: + return 1; + } + return 0; +} diff --git a/libvo/Attic/SHIT/video_out_gl.c.diff b/libvo/Attic/SHIT/video_out_gl.c.diff new file mode 100644 index 0000000000..dece59b7fd --- /dev/null +++ b/libvo/Attic/SHIT/video_out_gl.c.diff @@ -0,0 +1,64 @@ +8,10d7 +< // Hmm. Enabling this makes about 20% speedup too! (Celeron2+G400+UtahGLX) +< //#define TEXSUBIMAGE_BUG_WORKAROUND +< +369,370c366,367 +< static inline uint32_t +< draw_slice_x11(uint8_t *src[], uint32_t slice_num) +--- +> //static inline uint32_t draw_slice_x11(uint8_t *src[], uint32_t slice_num) +> static uint32_t draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y) +372,375c369,372 +< uint8_t *dst; +< int i; +< +< dst = ImageData;// + image_width * 16 * BYTES_PP * slice_num; +--- +> int i; +> int dstride=w*BYTES_PP; +> +> dstride=(dstride+15)&(~15); +377,379c374,375 +< yuv2rgb(dst , src[0], src[1], src[2], +< image_width, 16, +< image_width*BYTES_PP, image_width, image_width/2 ); +--- +> yuv2rgb(ImageData, src[0], src[1], src[2], +> w,h, dstride, stride[0],stride[1]); +383,384c379 +< #ifdef TEXSUBIMAGE_BUG_WORKAROUND +< for(i=0;i<16;i++){ +--- +> for(i=0;i<h;i++){ +387,389c382,384 +< 0, // x offset +< 16*slice_num+i, // y offset +< image_width, // width +--- +> x, // x offset +> y+i, // y offset +> w, // width +393c388 +< ImageData+i*BYTES_PP*image_width ); // *pixels +--- +> ImageData+i*dstride ); // *pixels +395,406d389 +< #else +< //printf("uploading slice \n"); +< glTexSubImage2D( GL_TEXTURE_2D, // target +< 0, // level +< 0, // x offset +< 16*slice_num, // y offset +< image_width, // width +< 16, // height +< (BYTES_PP==4)?GL_RGBA:GL_RGB, // format +< GL_UNSIGNED_BYTE, // type +< ImageData ); // *pixels +< #endif +409,414d391 +< } +< +< static uint32_t +< draw_slice(uint8_t *src[], uint32_t slice_num) +< { +< return draw_slice_x11(src,slice_num); diff --git a/libvo/Attic/SHIT/video_out_odivx.c.OLD b/libvo/Attic/SHIT/video_out_odivx.c.OLD new file mode 100644 index 0000000000..83f3fe2e61 --- /dev/null +++ b/libvo/Attic/SHIT/video_out_odivx.c.OLD @@ -0,0 +1,183 @@ +/* + * OpenDivX AVI file writer + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "config.h" +#include "video_out.h" +#include "video_out_internal.h" + +LIBVO_EXTERN(odivx) + +#include <sys/ioctl.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/mman.h> + +#include "../encore/encore.h" + +static vo_info_t vo_info = +{ + "OpenDivX AVI File writer", + "odivx", + "Arpad Gereoffy <arpi@esp-team.scene.hu>", + "" +}; + +static uint8_t *image=NULL; +static int image_width=0; +static int image_height=0; +static char *buffer=NULL; +static int frameno=0; + +extern char* encode_name; +extern char* encode_index_name; + +static uint32_t +draw_slice(uint8_t *src[], uint32_t slice_num) +{ + uint8_t *d; + + // copy Y + d=image; + memcpy(d+(slice_num<<4)*image_width,src[0],image_width*16); + // copy U + d+=image_width*image_height; + memcpy(d+(slice_num<<2)*image_width,src[1],image_width*4); + // copy V + d+=image_width*image_height/4; + memcpy(d+(slice_num<<2)*image_width,src[2],image_width*4); + + return 0; +} + +static uint32_t +draw_frame(uint8_t *src[]) +{ + uint8_t *d; + + // copy Y + d=image; + memcpy(d,src[0],image_width*image_height); + // copy U + d+=image_width*image_height; + memcpy(d,src[1],image_width*image_height/4); + // copy V + d+=image_width*image_height/4; + memcpy(d,src[2],image_width*image_height/4); + + return 0; +} + +typedef unsigned int DWORD; + +typedef struct +{ + DWORD ckid; + DWORD dwFlags; + DWORD dwChunkOffset; // Position of chunk + DWORD dwChunkLength; // Length of chunk +} AVIINDEXENTRY; + +static void +flip_page(void) +{ + +// we are rady to encode this frame +ENC_FRAME enc_frame; +ENC_RESULT enc_result; + +if(++frameno<10) return; + +enc_frame.bmp=image; +enc_frame.bitstream=buffer; +enc_frame.length=0; +encore(0x123,0,&enc_frame,&enc_result); + +printf("coded length: %d \n",enc_frame.length); + +if(encode_name){ + AVIINDEXENTRY i; + FILE *file; + i.ckid=('c'<<24)|('d'<<16)|('0'<<8)|'0'; // "00dc" + i.dwFlags=enc_result.isKeyFrame?0x10:0; + i.dwChunkLength=enc_frame.length; + // Write AVI chunk: + if((file=fopen(encode_name,"ab"))){ + unsigned char zerobyte=0; + i.dwChunkOffset=ftell(file); + fwrite(&i.ckid,4,1,file); + fwrite(&enc_frame.length,4,1,file); + fwrite(buffer,enc_frame.length,1,file); + if(enc_frame.length&1) fwrite(&zerobyte,1,1,file); // padding + fclose(file); + } + // Write AVI index: + if(encode_index_name && (file=fopen(encode_index_name,"ab"))){ + fwrite(&i,sizeof(i),1,file); + fclose(file); + } +} + + +} + +static uint32_t +query_format(uint32_t format) +{ + switch(format){ + case IMGFMT_YV12: +// case IMGFMT_YUY2: +// case IMGFMT_RGB|24: +// case IMGFMT_BGR|24: + return 1; + } + return 0; +} + +static uint32_t +init(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t fullscreen, char *title, uint32_t format) +{ + uint32_t frame_size; + ENC_PARAM enc_param; + + buffer=malloc(0x100000); + if(!buffer) return -1; + +// file = fopen("encoded.odvx","wb"); +// if(!file) return -1; + + frame_size=width*height+width*height/2; + image_width=width; + image_height=height; + image=malloc(frame_size); + + //clear the buffer + memset(image,0x80,frame_size); + +// encoding parameters: +enc_param.framerate=25.0; +enc_param.bitrate=400000; //780000; +enc_param.rc_period=300; +enc_param.max_quantizer=15; +enc_param.min_quantizer=1; +enc_param.search_range=128; + +// init codec: +enc_param.x_dim=width; +enc_param.y_dim=height; +enc_param.flip=2; // 0=RGB 1=flippedRGB 2=planarYUV format +encore(0x123,ENC_OPT_INIT,&enc_param,NULL); + + return 0; +} + +static const vo_info_t* +get_info(void) +{ + return &vo_info; +} + diff --git a/libvo/Attic/SHIT/video_out_sdl.c-1.1.4 b/libvo/Attic/SHIT/video_out_sdl.c-1.1.4 new file mode 100644 index 0000000000..a0f307beba --- /dev/null +++ b/libvo/Attic/SHIT/video_out_sdl.c-1.1.4 @@ -0,0 +1,574 @@ +/* + * video_out_sdl.c + * + * Copyright (C) Ryan C. Gordon <icculus@lokigames.com> - April 22, 2000. + * + * A mpeg2dec display driver that does output through the + * Simple DirectMedia Layer (SDL) library. This effectively gives us all + * sorts of output options: X11, SVGAlib, fbcon, AAlib, GGI. Win32, MacOS + * and BeOS support, too. Yay. SDL info, source, and binaries can be found + * at http://slouken.devolution.com/SDL/ + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * + * mpeg2dec is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * mpeg2dec is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Make; see the file COPYING. If not, write to + * the Free Software Foundation, + * + * Changes: + * Dominik Schnitzer <dominik@schnitzer.at> - November 08, 2000. + * - Added resizing support, fullscreen: chnaged the sdlmodes selection + * routine. + * - SDL bugfixes: removed the atexit(SLD_Quit), SDL_Quit now resides in + * the plugin_exit routine. + * - Commented the source :) + * - Shortcuts: for switching between Fullscreen/Windowed mode and for + * cycling between the different Fullscreen modes. + * - Small bugfixes: proper width/height of movie + * Dominik Schnitzer <dominik@schnitzer.at> - November 11, 2000. + * - Cleanup code, more comments + * - Better error handling + * Bruno Barreyra <barreyra@ufl.edu> - December 10, 2000. + * - Eliminated memcpy's for entire frames + * Arpad Gereoffy <arpi@esp-team.scene.hu> - Jan 13, 2001. + * - Ported to MPlayer + * - small changes about keys and fullscreen mode + * Jeffrey Boser <verin@lvcm.com> - Jan 16, 2001. + * - type casting fixes, clip rect fix + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <inttypes.h> + +#include "config.h" +#include "video_out.h" +#include "video_out_internal.h" + +LIBVO_EXTERN(sdl) + +//#include "log.h" +//#define LOG if(0)printf + +static vo_info_t vo_info = +{ + "SDL YUV overlay", + "sdl", + "Ryan C. Gordon <icculus@lokigames.com>", + "" +}; + +#include <SDL/SDL.h> + +/** Private SDL Data structure **/ + +static struct sdl_priv_s { + + /* SDL YUV surface & overlay */ + SDL_Surface *s |