# HG changeset patch # User atmosfear # Date 988231425 0 # Node ID b9735f811d7d838dff656fa7ab5dc578453c6945 # Parent 12d884de4ea186a7f6dcb90982c2c6b073dff1f0 15,16,24,32Bit rgb/bgr support added, aalib fixed, performance optimizations, code cleanup and so much more... diff -r 12d884de4ea1 -r b9735f811d7d libvo/vo_sdl.c --- a/libvo/vo_sdl.c Wed Apr 25 19:31:06 2001 +0000 +++ b/libvo/vo_sdl.c Wed Apr 25 20:43:45 2001 +0000 @@ -5,6 +5,10 @@ * * Copyright (C) Ryan C. Gordon - April 22, 2000. * + * Copyright (C) Felix Buenemann - 2001 + * + * (for extensive code enhancements) + * * Current maintainer for MPlayer project (report bugs to that address): * Felix Buenemann * @@ -86,15 +90,11 @@ * to update this all the time (CVS info on http://mplayer.sourceforge.net) * * KNOWN BUGS: - * - Crashes with aalib (not resolved yet) + * - Crashes with aalib (fixed, but have to find cause!) */ -/* define if you want to force Xv SDL output? */ -#undef SDL_FORCEXV /* define to force software-surface (video surface stored in system memory)*/ #undef SDL_NOHWSURFACE -/* define to disable usage of the xvideo extension */ -#undef SDL_NOXV #include #include @@ -110,16 +110,16 @@ LIBVO_EXTERN(sdl) -//#include "log.h" -//#define LOG if(0)printf - extern int verbose; +char *sdl_driver; +int sdl_noxv; +int sdl_forcexv; static vo_info_t vo_info = { - "SDL YUV overlay (SDL v1.1.7+ only!)", + "SDL YUV/RGB/BGR renderer (SDL v1.1.7+ only!)", "sdl", - "Ryan C. Gordon ", + "Ryan C. Gordon , Felix Buenemann ", "" }; @@ -129,10 +129,20 @@ static struct sdl_priv_s { - /* SDL YUV surface & overlay */ + /* output driver used by sdl */ + char driver[8]; + + /* SDL display surface */ SDL_Surface *surface; + + /* SDL RGB surface */ + SDL_Surface *rgbsurface; + + /* SDL YUV overlay */ SDL_Overlay *overlay; -// SDL_Overlay *current_frame; + + /* x,y video position for centering */ + SDL_Rect vidpos; /* available fullscreen modes */ SDL_Rect **fullmodes; @@ -146,12 +156,22 @@ /* Bits per Pixel */ Uint8 bpp; + /* RGB or YUV? */ + Uint8 mode; + #define YUV 0 + #define RGB 1 + #define BGR 2 + /* current fullscreen mode, 0 = highest available fullscreen mode */ int fullmode; /* YUV ints */ int framePlaneY, framePlaneUV; int stridePlaneY, stridePlaneUV; + + /* RGB ints */ + int framePlaneRGB; + int width,height; int format; } sdl_priv; @@ -166,7 +186,6 @@ static void draw_alpha(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){ struct sdl_priv_s *priv = &sdl_priv; - int x,y; switch(priv->format) { case IMGFMT_YV12: @@ -180,7 +199,23 @@ break; case IMGFMT_UYVY: vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) *(priv->overlay->pixels))+2*(priv->width*y0+x0)+1,2*priv->width); - break; + break; + case IMGFMT_RGB15: + case IMGFMT_BGR15: + vo_draw_alpha_rgb15(w,h,src,srca,stride,((uint8_t *) priv->rgbsurface->pixels)+2*(y0*priv->width+x0),2*priv->width); + break; + case IMGFMT_RGB16: + case IMGFMT_BGR16: + vo_draw_alpha_rgb16(w,h,src,srca,stride,((uint8_t *) priv->rgbsurface->pixels)+2*(y0*priv->width+x0),2*priv->width); + break; + case IMGFMT_RGB24: + case IMGFMT_BGR24: + vo_draw_alpha_rgb24(w,h,src,srca,stride,((uint8_t *) priv->rgbsurface->pixels)+3*(y0*priv->width+x0),3*priv->width); + break; + case IMGFMT_RGB32: + case IMGFMT_BGR32: + vo_draw_alpha_rgb32(w,h,src,srca,stride,((uint8_t *) priv->rgbsurface->pixels)+4*(y0*priv->width+x0),4*priv->width); + break; } } @@ -220,41 +255,54 @@ return 0; opened = 1; -// LOG (LOG_DEBUG, "SDL video out: Opened Plugin"); + if(verbose > 2) printf("SDL: Opening Plugin\n"); + + if(sdl_driver) setenv("SDL_VIDEODRIVER", sdl_driver, 1); /* does the user want SDL to try and force Xv */ - #ifdef SDL_FORCEXV - setenv("SDL_VIDEO_X11_NODIRECTCOLOR", "1", 1); - #endif - #ifdef SDL_NOXV - setenv("SDL_VIDEO_YUV_HWACCEL", "0", 1); - #endif + if(sdl_forcexv) setenv("SDL_VIDEO_X11_NODIRECTCOLOR", "1", 1); + + /* does the user want to disable Xv and use software scaling instead */ + if(sdl_noxv) setenv("SDL_VIDEO_YUV_HWACCEL", "0", 1); + /* default to no fullscreen mode, we'll set this as soon we have the avail. modes */ priv->fullmode = -2; + + priv->surface = NULL; + priv->rgbsurface = NULL; + priv->overlay = NULL; + priv->fullmodes = NULL; + priv->bpp = 0; + + /* initialize the SDL Video system */ + if (SDL_Init (SDL_INIT_VIDEO/*|SDL_INIT_NOPARACHUTE*/)) { + if(verbose > 2) printf("SDL: Initializing of SDL failed: %s.\n", SDL_GetError()); + return -1; + } + + SDL_VideoDriverName(priv->driver, 8); + if(verbose) printf("SDL: Using driver: %s\n", priv->driver); /* other default values */ #ifdef SDL_NOHWSURFACE if(verbose) printf("SDL: using software-surface\n"); priv->sdlflags = SDL_SWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT; priv->sdlfullflags = SDL_SWSURFACE|SDL_FULLSCREEN|SDL_DOUBLEBUF|SDL_ASYNCBLIT; #else - if(verbose) printf("SDL: using hardware-surface\n"); - priv->sdlflags = SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT; //SDL_HWACCEL - priv->sdlfullflags = SDL_HWSURFACE|SDL_FULLSCREEN|SDL_DOUBLEBUF|SDL_ASYNCBLIT; //SDL_HWACCEL + if((strcmp(priv->driver, "dga") == 0) && (priv->mode)) { + if(verbose) printf("SDL: using software-surface\n"); + priv->sdlflags = SDL_SWSURFACE|SDL_FULLSCREEN|SDL_ASYNCBLIT|SDL_HWACCEL; + priv->sdlfullflags = SDL_SWSURFACE|SDL_FULLSCREEN|SDL_ASYNCBLIT|SDL_HWACCEL; + } + else { + if(verbose) printf("SDL: using hardware-surface\n"); + priv->sdlflags = SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL; + priv->sdlfullflags = SDL_HWSURFACE|SDL_FULLSCREEN|SDL_DOUBLEBUF|SDL_ASYNCBLIT|SDL_HWACCEL; + } #endif - priv->surface = NULL; - priv->overlay = NULL; - priv->fullmodes = NULL; - priv->bpp = 0; //added atmos - - /* initialize the SDL Video system */ - if (SDL_Init (SDL_INIT_VIDEO)) { -// LOG (LOG_ERROR, "SDL video out: Initializing of SDL failed (SDL_Init). Please use the latest version of SDL."); - return -1; - } - /* No Keyrepeats! */ - SDL_EnableKeyRepeat(0,0); + /* Setup Keyrepeats */ + SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); /* get information about the graphics adapter */ vidInfo = SDL_GetVideoInfo (); @@ -276,36 +324,42 @@ */ priv->sdlflags &= ~SDL_HWSURFACE; if ((!SDL_ListModes (vidInfo->vfmt, priv->sdlflags)) && (!priv->fullmodes)) { -// LOG (LOG_ERROR, "SDL video out: Couldn't get any acceptable SDL Mode for output. (SDL_ListModes failed)"); + printf("SDL: Couldn't get any acceptable SDL Mode for output.\n"); return -1; } } - + /* YUV overlays need at least 16-bit color depth, but the * display might less. The SDL AAlib target says it can only do * 8-bits, for example. So, if the display is less than 16-bits, * we'll force the BPP to 16, and pray that SDL can emulate for us. - */ + */ + //commented out for RGB test reasons priv->bpp = vidInfo->vfmt->BitsPerPixel; - if (priv->bpp < 16) { -/* - LOG (LOG_WARNING, "SDL video out: Your SDL display target wants to be at a color depth of (%d), but we need it to be at\ + //FIXME: DO NOT ADD ANY CODE BELOW THIS OR SDL WILL CRASH WITH AALIB! + if (!priv->mode && priv->bpp < 16) { + + if(verbose) printf("SDL: Your SDL display target wants to be at a color depth of (%d), but we need it to be at\ least 16 bits, so we need to emulate 16-bit color. This is going to slow things down; you might want to\ -increase your display's color depth, if possible", priv->bpp); -*/ +increase your display's color depth, if possible.\n", priv->bpp); + priv->bpp = 16; } - /* We dont want those in out event queue */ - SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE); + /* We don't want those in our event queue. + * We use SDL_KEYUP cause SDL_KEYDOWN seems to cause problems + * with keys need to be pressed twice, to be recognized. + */ + /*SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE); SDL_EventState(SDL_KEYDOWN, SDL_IGNORE); SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONDOWN, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONUP, SDL_IGNORE); SDL_EventState(SDL_QUIT, SDL_IGNORE); SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE); - SDL_EventState(SDL_USEREVENT, SDL_IGNORE); + SDL_EventState(SDL_USEREVENT, SDL_IGNORE);*/ + /* Success! */ return 0; @@ -327,6 +381,10 @@ if (priv->overlay) SDL_FreeYUVOverlay(priv->overlay); + /* Free RGB Surface */ + if (priv->rgbsurface) + SDL_FreeSurface(priv->rgbsurface); + /* Free our blitting surface */ if (priv->surface) SDL_FreeSurface(priv->surface); @@ -334,10 +392,12 @@ /* DONT attempt to free the fullscreen modes array. SDL_Quit* does this for us */ /* Cleanup SDL */ - SDL_Quit(); /* might have to be changed to quitsubsystem only, if plugins become - changeable on the fly */ + SDL_Quit(); + //SDL_QuitSubSystem(SDL_INIT_VIDEO); + /* might have to be changed to quitsubsystem only, if plugins become + * changeable on the fly */ -// LOG (LOG_DEBUG, "SDL video out: Closed Plugin"); + if(verbose > 2) printf("SDL: Closed Plugin\n"); return 0; } @@ -378,6 +438,9 @@ priv->surface = newsurface; SDL_ShowCursor(0); } + //TODO: check if this produces memhole! (no surface freeing) + priv->vidpos.x = (priv->surface->w - priv->width) / 2; + priv->vidpos.y = (priv->surface->h - priv->height) / 2; } @@ -414,7 +477,39 @@ if(verbose) printf("SDL: Using 0x%X (I420) image format\n", format); printf("SDL: Mapping I420 to IYUV\n"); sdl_format = SDL_IYUV_OVERLAY; - break; + break; + case IMGFMT_BGR15: + if(verbose) printf("SDL: Using 0x%X (BGR15) image format\n", format); + priv->mode = BGR; + break; + case IMGFMT_RGB15: + if(verbose) printf("SDL: Using 0x%X (RGB15) image format\n", format); + priv->mode = RGB; + break; + case IMGFMT_BGR16: + if(verbose) printf("SDL: Using 0x%X (BGR16) image format\n", format); + priv->mode = BGR; + break; + case IMGFMT_RGB16: + if(verbose) printf("SDL: Using 0x%X (RGB16) image format\n", format); + priv->mode = RGB; + break; + case IMGFMT_BGR24: + if(verbose) printf("SDL: Using 0x%X (BGR24) image format\n", format); + priv->mode = BGR; + break; + case IMGFMT_RGB24: + if(verbose) printf("SDL: Using 0x%X (RGB24) image format\n", format); + priv->mode = RGB; + break; + case IMGFMT_BGR32: + if(verbose) printf("SDL: Using 0x%X (BGR32) image format\n", format); + priv->mode = BGR; + break; + case IMGFMT_RGB32: + if(verbose) printf("SDL: Using 0x%X (RGB32) image format\n", format); + priv->mode = RGB; + break; default: printf("SDL: Unsupported image format (0x%X)\n",format); return -1; @@ -424,12 +519,15 @@ /* Set output window title */ SDL_WM_SetCaption (".: MPlayer : F = Fullscreen/Windowed : C = Cycle Fullscreen Resolutions :.", "SDL Video Out"); + //SDL_WM_SetCaption (title, title); /* Save the original Image size */ - priv->width = width; - priv->height = height; + priv->width = d_width ? d_width : width; + priv->height = d_height ? d_height : height; priv->format = format; + priv->windowsize.w = d_width ? d_width : width; + priv->windowsize.h = d_height ? d_height : height; /* bit 0 (0x01) means fullscreen (-fs) * bit 1 (0x02) means mode switching (-vm) @@ -440,52 +538,108 @@ switch(fullscreen){ case 0x01: case 0x05: + priv->width = width; + priv->height = height; if(verbose) printf("SDL: setting zoomed fullscreen without modeswitching\n"); - priv->windowsize.w = d_width; - priv->windowsize.h = d_height; + printf("SDL: Info - please use -vm (unscaled) or -zoom (scaled) for best fullscreen experience\n"); if((priv->surface = SDL_SetVideoMode (d_width, d_height, priv->bpp, priv->sdlfullflags))) SDL_ShowCursor(0); break; case 0x02: - case 0x03: - priv->windowsize.w = width; - priv->windowsize.h = height; -#ifdef SDL_NOXV if(verbose) printf("SDL: setting nonzoomed fullscreen with modeswitching\n"); - if(priv->surface = SDL_SetVideoMode (width, height, priv->bpp, priv->sdlfullflags)) + printf("SDL: Info - please use -zoom switch to scale video\n"); + if((priv->surface = SDL_SetVideoMode (d_width ? d_width : width, d_height ? d_height : height, priv->bpp, priv->sdlfullflags))) SDL_ShowCursor(0); -#else + break; + case 0x04: + case 0x06: if(verbose) printf("SDL: setting zoomed fullscreen with modeswitching\n"); - priv->surface=NULL; - set_fullmode(priv->fullmode); -#endif - break; - case 0x06: - case 0x07: - if(verbose) printf("SDL: setting zoomed fullscreen with modeswitching\n"); - priv->windowsize.w = width; - priv->windowsize.h = height; + printf("SDL: Info - please use -vm switch instead if you don't want scaled video\n"); priv->surface=NULL; set_fullmode(priv->fullmode); break; default: if(verbose) printf("SDL: setting windowed mode\n"); - priv->windowsize.w = d_width; - priv->windowsize.h = d_height; - priv->surface = SDL_SetVideoMode (d_width, d_height, priv->bpp, priv->sdlflags); + if((priv->surface = SDL_SetVideoMode (d_width, d_height, priv->bpp, priv->sdlflags)) + && (strcmp(priv->driver, "dga") == 0)) SDL_ShowCursor(0); //TODO: other sdl drivers that are fullscreen only? } - if(!priv->surface) return -1; // cannot SetVideoMode + if(!priv->surface) { // cannot SetVideoMode + printf("SDL: failed to set video mode: %s\n", SDL_GetError()); + return -1; + } - /* Initialize and create the YUV Overlay used for video out */ - if (!(priv->overlay = SDL_CreateYUVOverlay (width, height, sdl_format, priv->surface))) { - printf ("SDL video out: Couldn't create an SDL-based YUV overlay\n"); - return -1; + switch(format) { + /* Initialize and create the RGB Surface used for video out in BGR/RGB mode */ +//SDL_Surface *SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask); + // SDL_SWSURFACE,SDL_HWSURFACE,SDL_SRCCOLORKEY, priv->flags? guess: exchange Rmask and Bmask for BGR<->RGB + // 32 bit: a:ff000000 r:ff000 g:ff00 b:ff + // 24 bit: r:ff0000 g:ff00 b:ff + // 16 bit: r:1111100000000000b g:0000011111100000b b:0000000000011111b + // 15 bit: r:111110000000000b g:000001111100000b b:000000000011111b + // FIXME: colorkey detect based on bpp, FIXME static bpp value, FIXME alpha value correct? + case IMGFMT_RGB15: + if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, width, height, 15, 31, 992, 31744, 0))) { + printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError()); + return -1; + } + break; + case IMGFMT_BGR15: + if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, width, height, 15, 31744, 992, 31, 0))) { + printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError()); + return -1; + } + break; + case IMGFMT_RGB16: + if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, width, height, 16, 31, 2016, 63488, 0))) { + printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError()); + return -1; + } + break; + case IMGFMT_BGR16: + if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, width, height, 16, 63488, 2016, 31, 0))) { + printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError()); + return -1; + } + break; + case IMGFMT_RGB24: + if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, width, height, 24, 0x0000FF, 0x00FF00, 0xFF0000, 0))) { + printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError()); + return -1; + } + break; + case IMGFMT_BGR24: + if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, width, height, 24, 0xFF0000, 0x00FF00, 0x0000FF, 0))) { + printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError()); + return -1; + } + break; + case IMGFMT_RGB32: + if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, width, height, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000))) { + printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError()); + return -1; + } + break; + case IMGFMT_BGR32: + if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, width, height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000))) { + printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError()); + return -1; + } + break; + default: + /* Initialize and create the YUV Overlay used for video out */ + if (!(priv->overlay = SDL_CreateYUVOverlay (width, height, sdl_format, priv->surface))) { + printf ("SDL: Couldn't create a YUV overlay: %s\n", SDL_GetError()); + return -1; + } + priv->framePlaneY = width * height; + priv->framePlaneUV = (width * height) >> 2; + priv->stridePlaneY = width; + priv->stridePlaneUV = width/2; } - priv->framePlaneY = width * height; - priv->framePlaneUV = (width * height) >> 2; - priv->stridePlaneY = width; - priv->stridePlaneUV = width/2; - + + if(priv->mode) { + priv->framePlaneRGB = width * height * priv->rgbsurface->format->BytesPerPixel; + } return 0; } @@ -502,36 +656,58 @@ { struct sdl_priv_s *priv = &sdl_priv; uint8_t *dst; - -// priv->current_frame = (SDL_Overlay*) frame->private; -// SDL_UnlockYUVOverlay (priv->current_frame); - - if (SDL_LockYUVOverlay (priv->overlay)) { -// LOG (LOG_ERROR, "SDL video out: Couldn't lock SDL-based YUV overlay"); - return -1; - } - + switch(priv->format){ case IMGFMT_YV12: case IMGFMT_I420: case IMGFMT_IYUV: + /*if (SDL_LockYUVOverlay (priv->overlay)) { + if(verbose) printf("SDL: Couldn't lock YUV overlay\n"); + return -1; + }*/ dst = (uint8_t *) *(priv->overlay->pixels); memcpy (dst, src[0], priv->framePlaneY); dst += priv->framePlaneY; memcpy (dst, src[2], priv->framePlaneUV); dst += priv->framePlaneUV; memcpy (dst, src[1], priv->framePlaneUV); + /*SDL_UnlockYUVOverlay (priv->overlay);*/ break; case IMGFMT_YUY2: case IMGFMT_UYVY: case IMGFMT_YVYU: + /*if (SDL_LockYUVOverlay (priv->overlay)) { + if(verbose) printf("SDL: Couldn't lock YUV overlay\n"); + return -1; + }*/ dst = (uint8_t *) *(priv->overlay->pixels); memcpy (dst, src[0], priv->width*priv->height*2); + /*SDL_UnlockYUVOverlay (priv->overlay);*/ break; + + case IMGFMT_RGB15: + case IMGFMT_BGR15: + case IMGFMT_RGB16: + case IMGFMT_BGR16: + case IMGFMT_RGB24: + case IMGFMT_BGR24: + case IMGFMT_RGB32: + case IMGFMT_BGR32: + /*if(SDL_MUSTLOCK(priv->rgbsurface)) { + if (SDL_LockSurface (priv->rgbsurface)) { + if(verbose) printf("SDL: Couldn't lock RGB surface\n"); + return -1; + } + }*/ + dst = (uint8_t *) priv->rgbsurface->pixels; + memcpy (dst, src[0], priv->framePlaneRGB); + /*if(SDL_MUSTLOCK(priv->rgbsurface)) + SDL_UnlockSurface (priv->rgbsurface);*/ + break; + } - SDL_UnlockYUVOverlay (priv->overlay); return 0; } @@ -551,12 +727,10 @@ uint8_t *src; int i; - //priv->current_frame = priv->overlay; - - if (SDL_LockYUVOverlay (priv->overlay)) { -// LOG (LOG_ERROR, "SDL video out: Couldn't lock SDL-based YUV overlay"); + /*if (SDL_LockYUVOverlay (priv->overlay)) { + if(verbose) printf("SDL: Couldn't lock YUV overlay"); return -1; - } + }*/ dst = (uint8_t *) *(priv->overlay->pixels) + (priv->stridePlaneY * y + x); @@ -587,16 +761,7 @@ dst+=priv->stridePlaneUV; } -#if 0 - dst = (uint8_t *) *(priv->overlay->pixels) + (priv->slicePlaneY * slice_num); - memcpy (dst, src[0], priv->slicePlaneY); - dst = (uint8_t *) *(priv->overlay->pixels) + priv->framePlaneY + (priv->slicePlaneUV * slice_num); - memcpy (dst, src[2], priv->slicePlaneUV); - dst += priv->framePlaneUV; - memcpy (dst, src[1], priv->slicePlaneUV); -#endif - - SDL_UnlockYUVOverlay (priv->overlay); + /*SDL_UnlockYUVOverlay (priv->overlay);*/ return 0; } @@ -633,12 +798,20 @@ priv->windowsize.w = priv->surface->w; priv->windowsize.h = priv->surface->h; //} -// LOG (LOG_DEBUG, "SDL video out: Window resize"); + if(verbose > 2) printf("SDL: Window resize\n"); break; /* graphics mode selection shortcuts */ - case SDL_KEYUP: + case SDL_KEYDOWN: + switch(event.key.keysym.sym) { + case SDLK_UP: mplayer_put_key(KEY_UP);break; + case SDLK_DOWN: mplayer_put_key(KEY_DOWN);break; + case SDLK_LEFT: mplayer_put_key(KEY_LEFT);break; + case SDLK_RIGHT: mplayer_put_key(KEY_RIGHT);break; + } + break; + case SDL_KEYUP: keypressed = event.key.keysym.sym; /* c key pressed. c cycles through available fullscreenmodes, if we have some */ @@ -648,7 +821,7 @@ if (priv->fullmode > (findArrayEnd(priv->fullmodes) - 1)) priv->fullmode = 0; set_fullmode(priv->fullmode); -// LOG (LOG_DEBUG, "SDL video out: Set next available fullscreen mode."); + if(verbose > 1) printf("SDL: Set next available fullscreen mode.\n"); } /* f key pressed toggles/exits fullscreenmode */ @@ -656,17 +829,16 @@ if (priv->surface->flags & SDL_FULLSCREEN) { priv->surface = SDL_SetVideoMode(priv->windowsize.w, priv->windowsize.h, priv->bpp, priv->sdlflags); SDL_ShowCursor(1); -// LOG (LOG_DEBUG, "SDL video out: Windowed mode"); + if(verbose > 1) printf("SDL: Windowed mode\n"); } else if (priv->fullmodes){ set_fullmode(priv->fullmode); -// LOG (LOG_DEBUG, "SDL video out: Set fullscreen mode."); + if(verbose > 1) printf("SDL: Set fullscreen mode\n"); } } else switch(keypressed){ -// case SDLK_q: if(!(priv->surface->flags & SDL_FULLSCREEN))mplayer_put_key('q');break; case SDLK_RETURN: if (!firstcheck) { firstcheck = 1; break; } case SDLK_ESCAPE: @@ -677,10 +849,6 @@ /*case SDLK_o: mplayer_put_key('o');break; case SDLK_SPACE: mplayer_put_key(' ');break; case SDLK_p: mplayer_put_key('p');break;*/ - case SDLK_UP: mplayer_put_key(KEY_UP);break; - case SDLK_DOWN: mplayer_put_key(KEY_DOWN);break; - case SDLK_LEFT: mplayer_put_key(KEY_LEFT);break; - case SDLK_RIGHT: mplayer_put_key(KEY_RIGHT);break; case SDLK_PLUS: case SDLK_KP_PLUS: mplayer_put_key('+');break; case SDLK_MINUS: @@ -711,54 +879,57 @@ static void flip_page (void) { struct sdl_priv_s *priv = &sdl_priv; + SDL_Surface *blitconv; // temporary conversion surface - //vo_draw_alpha_yuy2(int w,int h, unsigned char* src, unsigned char *srca, int srcstride, unsigned char* dstbase,int dststride) + /* update osd/subtitles */ vo_draw_text(priv->width,priv->height,draw_alpha); /* check and react on keypresses and window resizes */ check_events(); - /* blit to the YUV overlay */ - SDL_DisplayYUVOverlay (priv->overlay, &priv->surface->clip_rect); - - /* check if we have a double buffered surface and flip() if we do. */ - if ( priv->surface->flags & SDL_DOUBLEBUF ) - SDL_Flip(priv->surface); - - SDL_LockYUVOverlay (priv->overlay); -} - -#if 0 -static frame_t* sdl_allocate_image_buffer(int width, int height) -{ - struct sdl_priv_s *priv = &sdl_priv; - frame_t *frame; - - if (!(frame = malloc (sizeof (frame_t)))) - return NULL; + switch(priv->format) { + case IMGFMT_RGB15: + case IMGFMT_BGR15: + case IMGFMT_RGB16: + case IMGFMT_BGR16: + case IMGFMT_RGB24: + case IMGFMT_BGR24: + case IMGFMT_RGB32: + case IMGFMT_BGR32: + /* blit to the RGB surface */ + blitconv = SDL_DisplayFormat(priv->rgbsurface); + if(SDL_BlitSurface (blitconv, NULL, priv->surface, &priv->vidpos)) + printf("SDL: Blit failed: %s\n", SDL_GetError()); + SDL_FreeSurface(blitconv); - if (!(frame->private = (void*) SDL_CreateYUVOverlay (width, height, - SDL_IYUV_OVERLAY, priv->surface))) - { -// LOG (LOG_ERROR, "SDL video out: Couldn't create an SDL-based YUV overlay"); - return NULL; - } - - frame->base[0] = (uint8_t*) ((SDL_Overlay*) (frame->private))->pixels[0]; - frame->base[1] = (uint8_t*) ((SDL_Overlay*) (frame->private))->pixels[1]; - frame->base[2] = (uint8_t*) ((SDL_Overlay*) (frame->private))->pixels[2]; - - SDL_LockYUVOverlay ((SDL_Overlay*) frame->private); - return frame; + /*if(SDL_MUSTLOCK(priv->surface)) { + if (SDL_LockSurface (priv->surface)) { + if(verbose) printf("SDL: Couldn't lock RGB surface\n"); + return; + } + }*/ + /* update screen */ + SDL_UpdateRect(priv->surface, priv->vidpos.x, priv->vidpos.y, priv->width, priv->height); + /*if(SDL_MUSTLOCK(priv->surface)) + SDL_UnlockSurface (priv->surface);*/ + + /* check if we have a double buffered surface and flip() if we do. */ + if ( priv->surface->flags & SDL_DOUBLEBUF ) + SDL_Flip(priv->surface); + + break; + default: + /* blit to the YUV overlay */ + SDL_DisplayYUVOverlay (priv->overlay, &priv->surface->clip_rect); + + /* check if we have a double buffered surface and flip() if we do. */ + if ( priv->surface->flags & SDL_DOUBLEBUF ) + SDL_Flip(priv->surface); + + //SDL_LockYUVOverlay (priv->overlay); // removed because unused!? + } } -static void sdl_free_image_buffer(frame_t* frame) -{ - SDL_FreeYUVOverlay((SDL_Overlay*) frame->private); - free(frame); -} -#endif - static uint32_t query_format(uint32_t format) { @@ -769,9 +940,16 @@ case IMGFMT_YUY2: case IMGFMT_UYVY: case IMGFMT_YVYU: -// case IMGFMT_RGB|24: -// case IMGFMT_BGR|24: - return 1; + return 0x6; // hw supported & osd + case IMGFMT_RGB15: + case IMGFMT_BGR15: + case IMGFMT_RGB16: + case IMGFMT_BGR16: + case IMGFMT_RGB24: + case IMGFMT_BGR24: + case IMGFMT_RGB32: + case IMGFMT_BGR32: + return 0x5; // hw supported w/conversion & osd } return 0; }