[Mplayer-cvslog] CVS: main/libvo sub.c,1.42,1.43 sub.h,1.10,1.11 vo_sdl.c,1.69,1.70
Atmosfear
atmos4 at mplayer.dev.hu
Fri Feb 22 16:25:14 CET 2002
- Previous message: [Mplayer-cvslog] CVS: main find_sub.c,1.5,1.6 mplayer.c,1.402,1.403
- Next message: [Mplayer-cvslog] CVS: main/libvo sub.c,1.42,1.43 sub.h,1.10,1.11 vo_sdl.c,1.69,1.70
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Update of /cvsroot/mplayer/main/libvo
In directory mplayer:/var/tmp.root/cvs-serv5364/libvo
Modified Files:
sub.c sub.h vo_sdl.c
Log Message:
osd outside movie support for vo_sdl, patch by Fredrik Kuivinen
Index: sub.c
===================================================================
RCS file: /cvsroot/mplayer/main/libvo/sub.c,v
retrieving revision 1.42
retrieving revision 1.43
diff -u -r1.42 -r1.43
--- sub.c 20 Feb 2002 22:43:34 -0000 1.42
+++ sub.c 22 Feb 2002 15:25:11 -0000 1.43
@@ -320,3 +320,11 @@
}
+static int vo_osd_changed_status = 0;
+
+int vo_osd_changed(int new_value)
+{
+ int ret = vo_osd_changed_status;
+ vo_osd_changed_status = new_value;
+ return ret;
+}
Index: sub.h
===================================================================
RCS file: /cvsroot/mplayer/main/libvo/sub.h,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -r1.10 -r1.11
--- sub.h 10 Jan 2002 17:20:27 -0000 1.10
+++ sub.h 22 Feb 2002 15:25:11 -0000 1.11
@@ -50,5 +50,7 @@
//extern void vo_draw_text_sub(int dxs,int dys,void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
extern void vo_draw_text(int dxs,int dys,void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
+int vo_osd_changed(int new_value);
+
#endif
#endif
Index: vo_sdl.c
===================================================================
RCS file: /cvsroot/mplayer/main/libvo/vo_sdl.c,v
retrieving revision 1.69
retrieving revision 1.70
diff -u -r1.69 -r1.70
--- vo_sdl.c 21 Feb 2002 16:17:15 -0000 1.69
+++ vo_sdl.c 22 Feb 2002 15:25:11 -0000 1.70
@@ -164,6 +164,29 @@
#define ZOOM 0x04
#define FLIP 0x08
+#ifdef SDL_ENABLE_LOCKS
+#define SDL_OVR_LOCK(x) if (SDL_LockYUVOverlay (priv->overlay)) { \
+ if(verbose) printf("SDL: Couldn't lock YUV overlay\n"); \
+ return x; \
+ }
+#define SDL_OVR_UNLOCK SDL_UnlockYUVOverlay (priv->overlay);
+
+#define SDL_SRF_LOCK(srf, x) if(SDL_MUSTLOCK(srf)) { \
+ if(SDL_LockSurface (srf)) { \
+ if(verbose) printf("SDL: Couldn't lock RGB surface\n"); \
+ return x; \
+ } \
+ }
+
+#define SDL_SRF_UNLOCK(srf) if(SDL_MUSTLOCK(srf)) \
+ SDL_UnlockSurface (srf);
+#else
+#define SDL_OVR_LOCK(x)
+#define SDL_OVR_UNLOCK
+#define SDL_SRF_LOCK(srf, x)
+#define SDL_SRF_UNLOCK(srf)
+#endif
+
/** Private SDL Data structure **/
static struct sdl_priv_s {
@@ -221,10 +244,8 @@
/* is X running (0/1) */
int X;
-#ifdef HAVE_X11
/* X11 Resolution */
int XWidth, XHeight;
-#endif
/* original image dimensions */
int width, height;
@@ -232,10 +253,53 @@
/* destination dimensions */
int dstwidth, dstheight;
+ /* Draw image at coordinate y on the SDL surfaces */
+ int y;
+
+ /* The image is displayed between those y coordinates in priv->surface */
+ int y_screen_top, y_screen_bottom;
+
+ /* 1 if the OSD has changed otherwise 0 */
+ int osd_has_changed;
+
/* source image format (YUV/RGB/...) */
int format;
+
+ /* dirty_off_frame[0] contains a bounding box around the osd contents drawn above the image
+ dirty_off_frame[1] is the corresponding thing for OSD contents drawn below the image
+ */
+ SDL_Rect dirty_off_frame[2];
} sdl_priv;
+static void erase_area_4(int x_start, int width, int height, int pitch, uint32_t color, uint8_t* pixels);
+static void erase_area_1(int x_start, int width, int height, int pitch, uint8_t color, uint8_t* pixels);
+static int setup_surfaces(void);
+static void set_video_mode(int width, int height, int bpp, uint32_t sdlflags);
+static void erase_rectangle(int x, int y, int w, int h);
+
+/* Expand 'rect' to contain the rectangle specified by x, y, w and h */
+static void expand_rect(SDL_Rect* rect, int x, int y, int w, int h)
+{
+ if(rect->x < 0 || rect->y < 0) {
+ rect->x = x;
+ rect->y = y;
+ rect->w = w;
+ rect->h = h;
+ return;
+ }
+
+ if(rect->x > x)
+ rect->x = x;
+
+ if(rect->y > y)
+ rect->y = y;
+
+ if(rect->x + rect->w < x + w)
+ rect->w = x + w - rect->x;
+
+ if(rect->y + rect->h < y + h)
+ rect->h = y + h - rect->y;
+}
/** libvo Plugin functions **/
@@ -247,11 +311,45 @@
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;
+ if(priv->osd_has_changed) {
+ /* OSD did change. Store a bounding box of everything drawn into the OSD */
+ if(priv->y >= y0) {
+ /* Make sure we don't mark part of the frame area dirty */
+ if(h + y0 > priv->y)
+ expand_rect(&priv->dirty_off_frame[0], x0, y0, w, priv->y - y0);
+ else
+ expand_rect(&priv->dirty_off_frame[0], x0, y0, w, h);
+ }
+ else if(priv->y + priv->height <= y0 + h) {
+ /* Make sure we don't mark part of the frame area dirty */
+ if(y0 < priv->y + priv->height)
+ expand_rect(&priv->dirty_off_frame[1], x0,
+ priv->y + priv->height,
+ w, h - ((priv->y + priv->height) - y0));
+ else
+ expand_rect(&priv->dirty_off_frame[1], x0, y0, w, h);
+ }
+ }
+ else { /* OSD contents didn't change only draw parts that was erased by the frame */
+ if(priv->y >= y0) {
+ src = src + (priv->y - y0) * stride;
+ srca = srca + (priv->y - y0) * stride;
+ h -= priv->y - y0;
+ y0 = priv->y;
+ }
+
+ if(priv->y + priv->height <= y0 + h)
+ h = priv->y + priv->height - y0;
+
+ if(h <= 0)
+ return;
+ }
+
switch(priv->format) {
case IMGFMT_YV12:
case IMGFMT_I420:
case IMGFMT_IYUV:
- vo_draw_alpha_yv12(w,h,src,srca,stride,((uint8_t *) *(priv->overlay->pixels))+priv->width*y0+x0,priv->width);
+ vo_draw_alpha_yv12(w,h,src,srca,stride,((uint8_t *) *(priv->overlay->pixels))+priv->overlay->pitches[0]*y0+x0,priv->width);
break;
case IMGFMT_YUY2:
case IMGFMT_YVYU:
@@ -260,6 +358,7 @@
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;
+
default:
if(priv->dblit)
switch(priv->format) {
@@ -419,7 +518,7 @@
* we'll force the BPP to 16, and pray that SDL can emulate for us.
*/
priv->bpp = vidInfo->vfmt->BitsPerPixel;
- if (!priv->mode && priv->bpp < 16) {
+ if (priv->mode == YUV && 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\
@@ -556,40 +655,73 @@
}
#endif
+/* Set video mode. Not fullscreen */
+static void set_video_mode(int width, int height, int bpp, uint32_t sdlflags)
+{
+ struct sdl_priv_s *priv = &sdl_priv;
+ SDL_Surface* newsurface;
+
+ newsurface = SDL_SetVideoMode(width, height, bpp, sdlflags);
+
+ if(newsurface) {
+
+ /* priv->surface will be NULL the first time this function is called. */
+ if(priv->surface)
+ SDL_FreeSurface(priv->surface);
+
+ priv->surface = newsurface;
+ priv->dstwidth = width;
+ priv->dstheight = height;
+
+ setup_surfaces();
+ }
+ else
+ printf("set_video_mode: SDL_SetVideoMode failed: %s\n", SDL_GetError());
+}
+
static void set_fullmode (int mode) {
struct sdl_priv_s *priv = &sdl_priv;
SDL_Surface *newsurface = NULL;
+ int screen_surface_w, screen_surface_h;
/* if we haven't set a fullmode yet, default to the lowest res fullmode first */
/* But select a mode where the full video enter */
- if (mode < 0) {
- int i = 0;
+ if(priv->X && priv->fulltype & FS) {
+ screen_surface_w = priv->XWidth;
+ screen_surface_h = priv->XHeight;
+ }
+ else if (mode < 0) {
+ int i;
mode = 0; // Default to the biggest mode avaible
for(i = findArrayEnd(priv->fullmodes) - 1; i >=0; i--) {
- if( (priv->fullmodes[i]->w >= priv->width) &&
- (priv->fullmodes[i]->h >= priv->height) ) {
+ if( (priv->fullmodes[i]->w >= priv->dstwidth) &&
+ (priv->fullmodes[i]->h >= priv->dstheight) ) {
mode = i;
break;
}
}
priv->fullmode = mode;
+ screen_surface_h = priv->fullmodes[mode]->h;
+ screen_surface_w = priv->fullmodes[mode]->w;
+ }
+ else {
+ screen_surface_h = priv->fullmodes[mode]->h;
+ screen_surface_w = priv->fullmodes[mode]->w;
}
- aspect_save_screenres(priv->fullmodes[mode]->w, priv->fullmodes[mode]->h);
+ aspect_save_screenres(screen_surface_w, screen_surface_h);
/* calculate new video size/aspect */
- if(!priv->mode) {
- if(priv->fulltype&FS) {
-#ifdef HAVE_X11
+ if(priv->mode == YUV) {
+ if(priv->fulltype&FS)
aspect_save_screenres(priv->XWidth, priv->XHeight);
-#endif
- }
- aspect(&priv->dstwidth, &priv->dstheight, A_ZOOM);
+ aspect(&priv->dstwidth, &priv->dstheight, A_ZOOM);
}
/* try to change to given fullscreenmode */
- newsurface = SDL_SetVideoMode(priv->dstwidth, priv->dstheight, priv->bpp, priv->sdlfullflags);
+ newsurface = SDL_SetVideoMode(priv->dstwidth, screen_surface_h, priv->bpp,
+ priv->sdlfullflags);
/* if creation of new surface was successfull, save it and hide mouse cursor */
if(newsurface) {
@@ -597,7 +729,13 @@
SDL_FreeSurface(priv->surface);
priv->surface = newsurface;
SDL_ShowCursor(0);
+ SDL_SRF_LOCK(priv->surface, -1)
+ SDL_FillRect(priv->surface, NULL, 0);
+ SDL_SRF_UNLOCK(priv->surface)
+ setup_surfaces();
}
+ else
+ printf("set_fullmode: SDL_SetVideoMode failed: %s\n", SDL_GetError());
}
@@ -621,8 +759,6 @@
static Display *XDisplay;
static int XScreen;
#endif
- aspect_save_orig(width,height);
- aspect_save_prescale(d_width,d_height);
sdl_format = format;
switch(format){
@@ -640,6 +776,7 @@
if(verbose) printf("SDL: Using 0x%X (I420) image format\n", format);
printf("SDL: Mapping I420 to IYUV\n");
sdl_format = SDL_IYUV_OVERLAY;
+ priv->mode = YUV;
break;
case IMGFMT_BGR15:
if(verbose) printf("SDL: Using 0x%X (BGR15) image format\n", format);
@@ -682,6 +819,28 @@
priv->sdlfullflags |= SDL_ANYFORMAT;
}
+ /* SDL can only scale YUV data */
+ if(priv->mode == RGB || priv->mode == BGR) {
+ d_width = width;
+ d_height = height;
+ }
+
+ aspect_save_orig(width,height);
+ aspect_save_prescale(d_width ? d_width : width, d_height ? d_height : height);
+
+ /* Save the original Image size */
+ priv->X = 0;
+ priv->width = width;
+ priv->height = height;
+ priv->dstwidth = d_width ? d_width : width;
+ priv->dstheight = d_height ? d_height : height;
+
+ priv->rgbsurface = NULL;
+ priv->overlay = NULL;
+ priv->surface = NULL;
+
+ priv->format = sdl_format;
+
#ifdef HAVE_X11
if(getenv("DISPLAY")) {
if(verbose) printf("SDL: deactivating XScreensaver/DPMS\n");
@@ -702,20 +861,11 @@
SDL_WM_SetCaption (".: MPlayer : F = Fullscreen/Windowed : C = Cycle Fullscreen Resolutions :.", title);
//SDL_WM_SetCaption (title, title);
- /* Save the original Image size */
-
- priv->width = width;
- priv->height = height;
- priv->dstwidth = d_width ? d_width : width;
- priv->dstheight = d_height ? d_height : height;
-
- /*priv->width = res.w;
- priv->height = res.h;*/
- priv->format = format;
-#ifdef HAVE_X11
+ if(priv->X) {
aspect_save_screenres(priv->XWidth,priv->XHeight);
aspect(&priv->dstwidth,&priv->dstheight,A_NOZOOM);
-#endif
+ }
+
priv->windowsize.w = priv->dstwidth;
priv->windowsize.h = priv->dstheight;
@@ -753,7 +903,7 @@
else {
if((strcmp(priv->driver, "x11") == 0) || ((strcmp(priv->driver, "aalib") == 0) && priv->X)) {
if(verbose) printf("SDL: setting windowed mode\n");
- priv->surface = SDL_SetVideoMode (priv->dstwidth, priv->dstheight, priv->bpp, priv->sdlflags);
+ set_video_mode(priv->dstwidth, priv->dstheight, priv->bpp, priv->sdlflags);
}
else {
if(verbose) printf("SDL: setting zoomed fullscreen with modeswitching\n");
@@ -767,7 +917,60 @@
return -1;
}
- switch(format) {
+ return 0;
+}
+
+/* Free priv->rgbsurface or priv->overlay if they are != NULL.
+ * Setup priv->rgbsurface or priv->overlay depending on source format.
+ * The size of the created surface or overlay depends on the size of
+ * priv->surface, priv->width, priv->height, priv->dstwidth and priv->dstheight.
+ */
+static int setup_surfaces(void)
+{
+ struct sdl_priv_s *priv = &sdl_priv;
+ float h_scale = ((float) priv->dstwidth) / priv->width;
+ float v_scale = ((float) priv->dstheight) / priv->height;
+ int surfwidth, surfheight;
+
+ surfwidth = priv->width + (priv->surface->w - priv->dstwidth) / h_scale;
+ surfheight = priv->height + (priv->surface->h - priv->dstheight) / v_scale;
+
+ /* Place the image in the middle of the screen */
+ priv->y = (surfheight - priv->height) / 2;
+ priv->y_screen_top = priv->y * v_scale;
+ priv->y_screen_bottom = (priv->y + priv->dstheight) * v_scale;
+
+ priv->dirty_off_frame[0].x = -1;
+ priv->dirty_off_frame[0].y = -1;
+ priv->dirty_off_frame[1].x = -1;
+ priv->dirty_off_frame[1].y = -1;
+
+ /* Make sure the entire screen is updated */
+ vo_osd_changed(1);
+
+ if(priv->rgbsurface)
+ SDL_FreeSurface(priv->rgbsurface);
+ else if(priv->overlay)
+ SDL_FreeYUVOverlay(priv->overlay);
+
+ if(priv->mode != YUV) {
+ if((priv->format&0xFF) != priv->bpp) {
+ priv->dblit = 0;
+ printf("SDL: using depth/colorspace conversion, this will slow things"
+ "down (%ibpp -> %ibpp).\n", priv->format&0xFF, priv->bpp);
+ priv->framePlaneRGB = priv->width * priv->height * priv->rgbsurface->format->BytesPerPixel;
+ priv->stridePlaneRGB = priv->width * priv->rgbsurface->format->BytesPerPixel;
+ }
+ else if(strcmp(priv->driver, "x11") == 0) {
+ priv->dblit = 1;
+ priv->framePlaneRGB = priv->width * priv->height * priv->surface->format->BytesPerPixel;
+ priv->stridePlaneRGB = priv->width * priv->surface->format->BytesPerPixel;
+ erase_rectangle(0, 0, priv->surface->w, priv->surface->h);
+ return 0;
+ }
+ }
+
+ switch(priv->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
@@ -777,98 +980,72 @@
// 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))) {
+ if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 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))) {
+ if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 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))) {
+ if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 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))) {
+ if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 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))) {
+ if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 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))) {
+ if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 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, 0/*0xFF000000*/))) {
+ if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0/*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, 0/*0xFF000000*/))) {
+ if (!(priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0/*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))) {
+ if (!(priv->overlay = SDL_CreateYUVOverlay (surfwidth, surfheight, priv->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->framePlaneYUY = width * height * 2;
- priv->stridePlaneY = width;
- priv->stridePlaneUV = width/2;
- priv->stridePlaneYUY = width * 2;
+ priv->framePlaneY = priv->width * priv->height;
+ priv->framePlaneUV = (priv->width * priv->height) >> 2;
+ priv->framePlaneYUY = priv->width * priv->height * 2;
+ priv->stridePlaneY = priv->width;
+ priv->stridePlaneUV = priv->width/2;
+ priv->stridePlaneYUY = priv->width * 2;
}
- if(priv->mode) {
- if((priv->format&0xFF) != priv->bpp) { priv->dblit = 0; printf("SDL: using depth/colorspace conversion, this will slow things down (%ibpp -> %ibpp).\n", priv->format&0xFF, priv->bpp); }
- else if(strcmp(priv->driver, "x11") == 0) priv->dblit = 1;
- priv->framePlaneRGB = width * height * priv->rgbsurface->format->BytesPerPixel;
- priv->stridePlaneRGB = width * priv->rgbsurface->format->BytesPerPixel;
- }
+ erase_rectangle(0, 0, surfwidth, surfheight);
+
return 0;
}
-#ifdef SDL_ENABLE_LOCKS
-#define SDL_OVR_LOCK if (SDL_LockYUVOverlay (priv->overlay)) { \
- if(verbose) printf("SDL: Couldn't lock YUV overlay\n"); \
- return -1; \
- }
-#define SDL_OVR_UNLOCK SDL_UnlockYUVOverlay (priv->overlay);
-
-#define SDL_SRF_LOCK(srf) if(SDL_MUSTLOCK(srf)) { \
- if(SDL_LockSurface (srf)) { \
- if(verbose) printf("SDL: Couldn't lock RGB surface\n"); \
- return -1; \
- } \
- }
-
-#define SDL_SRF_UNLOCK(srf) if(SDL_MUSTLOCK(srf)) \
- SDL_UnlockSurface (srf);
-#else
-#define SDL_OVR_LOCK
-#define SDL_OVR_UNLOCK
-#define SDL_SRF_LOCK(srf)
-#define SDL_SRF_UNLOCK(srf)
-#endif
/**
* Draw a frame to the SDL YUV overlay.
@@ -889,27 +1066,29 @@
case IMGFMT_YV12:
case IMGFMT_I420:
case IMGFMT_IYUV:
- SDL_OVR_LOCK
- 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_OVR_LOCK(-1)
+
+ dst = priv->overlay->pixels[0] + priv->y*priv->overlay->pitches[0];
+ memcpy(dst, src[0], priv->overlay->pitches[0]*priv->overlay->h);
+ dst = priv->overlay->pixels[1] + priv->y*priv->overlay->pitches[1]/2;
+ memcpy(dst, src[1], priv->overlay->pitches[1]*priv->overlay->h/2);
+ dst = priv->overlay->pixels[2] + priv->y*priv->overlay->pitches[2]/2;
+ memcpy(dst, src[2], priv->overlay->pitches[2]*priv->overlay->h/2);
+
SDL_OVR_UNLOCK
break;
case IMGFMT_YUY2:
case IMGFMT_UYVY:
case IMGFMT_YVYU:
- SDL_OVR_LOCK
- dst = (uint8_t *) *(priv->overlay->pixels);
+ SDL_OVR_LOCK(-1)
+ dst = (uint8_t *) *(priv->overlay->pixels) + priv->overlay->pitches[0]*priv->y;
if(priv->flip) {
mysrc+=priv->framePlaneYUY;
for(i = 0; i < priv->height; i++) {
mysrc-=priv->stridePlaneYUY;
memcpy (dst, mysrc, priv->stridePlaneYUY);
- dst+=priv->stridePlaneYUY;
+ dst+=priv->overlay->pitches[0];
}
}
else memcpy (dst, src[0], priv->framePlaneYUY);
@@ -925,27 +1104,28 @@
case IMGFMT_RGB32:
case IMGFMT_BGR32:
if(priv->dblit) {
- SDL_SRF_LOCK(priv->surface)
- dst = (uint8_t *) priv->surface->pixels;
+ SDL_SRF_LOCK(priv->surface, -1)
+ dst = (uint8_t *) priv->surface->pixels + priv->y*priv->surface->pitch;
+
if(priv->flip) {
mysrc+=priv->framePlaneRGB;
for(i = 0; i < priv->height; i++) {
mysrc-=priv->stridePlaneRGB;
memcpy (dst, mysrc, priv->stridePlaneRGB);
- dst+=priv->stridePlaneRGB;
+ dst += priv->surface->pitch;
}
}
else memcpy (dst, src[0], priv->framePlaneRGB);
SDL_SRF_UNLOCK(priv->surface)
} else {
- SDL_SRF_LOCK(priv->rgbsurface)
- dst = (uint8_t *) priv->rgbsurface->pixels;
+ SDL_SRF_LOCK(priv->rgbsurface, -1)
+ dst = (uint8_t *) priv->rgbsurface->pixels + priv->y*priv->rgbsurface->pitch;
if(priv->flip) {
mysrc+=priv->framePlaneRGB;
for(i = 0; i < priv->height; i++) {
mysrc-=priv->stridePlaneRGB;
memcpy (dst, mysrc, priv->stridePlaneRGB);
- dst+=priv->stridePlaneRGB;
+ dst += priv->rgbsurface->pitch;
}
}
else memcpy (dst, src[0], priv->framePlaneRGB);
@@ -974,35 +1154,35 @@
uint8_t *src;
int i;
- SDL_OVR_LOCK
+ SDL_OVR_LOCK(-1)
+
+ y += priv->y;
+
+ dst = priv->overlay->pixels[0] + priv->overlay->pitches[0]*y + x;
- dst = (uint8_t *) *(priv->overlay->pixels)
- + (priv->stridePlaneY * y + x);
src = image[0];
for(i=0;i<h;i++){
memcpy(dst,src,w);
src+=stride[0];
- dst+=priv->stridePlaneY;
+ dst += priv->overlay->pitches[0];
}
x/=2;y/=2;w/=2;h/=2;
- dst = (uint8_t *) *(priv->overlay->pixels) + priv->framePlaneY
- + (priv->stridePlaneUV * y + x);
- src = image[2];
+ dst = priv->overlay->pixels[2] + priv->overlay->pitches[2]*y + x;
+ src = image[1];
for(i=0;i<h;i++){
memcpy(dst,src,w);
src+=stride[2];
- dst+=priv->stridePlaneUV;
+ dst += priv->overlay->pitches[2];
}
- dst = (uint8_t *) *(priv->overlay->pixels) + priv->framePlaneY
- + priv->framePlaneUV + (priv->stridePlaneUV * y + x);
- src = image[1];
+ dst = priv->overlay->pixels[1] + priv->overlay->pitches[1]*y + x;
+ src = image[2];
for(i=0;i<h;i++){
memcpy(dst,src,w);
src+=stride[1];
- dst+=priv->stridePlaneUV;
+ dst += priv->overlay->pitches[1];
}
SDL_OVR_UNLOCK
@@ -1036,7 +1216,8 @@
/* capture window resize events */
case SDL_VIDEORESIZE:
- if(!priv->dblit) priv->surface = SDL_SetVideoMode(event.resize.w, event.resize.h, priv->bpp, priv->sdlflags);
+ if(!priv->dblit)
+ set_video_mode(event.resize.w, event.resize.h, priv->bpp, priv->sdlflags);
/* save video extents, to restore them after going fullscreen */
//if(!(priv->surface->flags & SDL_FULLSCREEN)) {
@@ -1134,13 +1315,13 @@
aspect(&priv->dstwidth, &priv->dstheight,A_NOZOOM);
#endif
if (priv->surface->w != priv->dstwidth || priv->surface->h != priv->dstheight) {
- priv->surface = SDL_SetVideoMode(priv->dstwidth, priv->dstheight, priv->bpp, priv->sdlflags);
+ set_video_mode(priv->dstwidth, priv->dstheight, priv->bpp, priv->sdlflags);
priv->windowsize.w = priv->surface->w;
priv->windowsize.h = priv->surface->h;
if(verbose > 1) printf("SDL: Normal size\n");
} else
if (priv->surface->w != priv->dstwidth * 2 || priv->surface->h != priv->dstheight * 2) {
- priv->surface = SDL_SetVideoMode(priv->dstwidth * 2, priv->dstheight * 2, priv->bpp, priv->sdlflags);
+ set_video_mode(priv->dstwidth * 2, priv->dstheight * 2, priv->bpp, priv->sdlflags);
priv->windowsize.w = priv->surface->w;
priv->windowsize.h = priv->surface->h;
if(verbose > 1) printf("SDL: Double size\n");
@@ -1207,11 +1388,163 @@
}
#undef shift_key
+/* Erase (paint it black) the rectangle specified by x, y, w and h in the surface
+ or overlay which is used for OSD
+*/
+static void erase_rectangle(int x, int y, int w, int h)
+{
+ struct sdl_priv_s *priv = &sdl_priv;
+
+ switch(priv->format) {
+ case IMGFMT_YV12:
+ case IMGFMT_I420:
+ case IMGFMT_IYUV:
+ {
+ SDL_OVR_LOCK((void) 0)
+
+ /* Erase Y plane */
+ erase_area_1(x, w, h,
+ priv->overlay->pitches[0], 0,
+ priv->overlay->pixels[0] +
+ priv->overlay->pitches[0]*y);
+
+ /* Erase U and V planes */
+ w /= 2;
+ x /= 2;
+ h /= 2;
+ y /= 2;
+
+ erase_area_1(x, w, h,
+ priv->overlay->pitches[1], 128,
+ priv->overlay->pixels[1] +
+ priv->overlay->pitches[1]*y);
+
+ erase_area_1(x, w, h,
+ priv->overlay->pitches[2], 128,
+ priv->overlay->pixels[2] +
+ priv->overlay->pitches[2]*y);
+ SDL_OVR_UNLOCK
+ break;
+ }
+
+ case IMGFMT_YUY2:
+ case IMGFMT_YVYU:
+ {
+ /* yuy2 and yvyu represent black the same way */
+ uint8_t yuy2_black[] = {0, 128, 0, 128};
+
+ SDL_OVR_LOCK((void) 0)
+ erase_area_4(x*2, w*2, h,
+ priv->overlay->pitches[0],
+ *((uint32_t*) yuy2_black),
+ priv->overlay->pixels[0] +
+ priv->overlay->pitches[0]*y);
+ SDL_OVR_UNLOCK
+ break;
+ }
+
+ case IMGFMT_UYVY:
+ {
+ uint8_t uyvy_black[] = {128, 0, 128, 0};
+
+ SDL_OVR_LOCK((void) 0)
+ erase_area_4(x*2, w*2, h,
+ priv->overlay->pitches[0],
+ *((uint32_t*) uyvy_black),
+ priv->overlay->pixels[0] +
+ priv->overlay->pitches[0]*y);
+ SDL_OVR_UNLOCK
+ 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:
+ {
+ SDL_Rect rect;
+ rect.w = w; rect.h = h;
+ rect.x = x; rect.y = y;
+
+ if(priv->dblit) {
+ SDL_SRF_LOCK(priv->surface, (void) 0)
+ SDL_FillRect(priv->surface, &rect, 0);
+ SDL_SRF_UNLOCK(priv->surface)
+ }
+ else {
+ SDL_SRF_LOCK(priv->rgbsurface, (void) 0)
+ SDL_FillRect(priv->rgbsurface, &rect, 0);
+ SDL_SRF_UNLOCK(priv->rgbsurface)
+ }
+ break;
+ }
+ }
+}
+
static void draw_osd(void)
{ struct sdl_priv_s *priv = &sdl_priv;
+ priv->osd_has_changed = vo_osd_changed(0);
+
+ if(priv->osd_has_changed)
+ {
+ int i;
+
+ for(i = 0; i < 2; i++) {
+ if(priv->dirty_off_frame[i].x < 0 || priv->dirty_off_frame[i].y < 0)
+ continue;
+
+ erase_rectangle(priv->dirty_off_frame[i].x, priv->dirty_off_frame[i].y,
+ priv->dirty_off_frame[i].w, priv->dirty_off_frame[i].h);
+
+ priv->dirty_off_frame[i].x = -1;
+ priv->dirty_off_frame[i].y = -1;
+ }
+ }
+
/* update osd/subtitles */
- vo_draw_text(priv->width,priv->height,draw_alpha);
+ if(priv->mode == YUV)
+ vo_draw_text(priv->overlay->w, priv->overlay->h, draw_alpha);
+ else {
+ if(priv->dblit)
+ vo_draw_text(priv->surface->w, priv->surface->h, draw_alpha);
+ else
+ vo_draw_text(priv->rgbsurface->w, priv->rgbsurface->h, draw_alpha);
+ }
+}
+
+/* Fill area beginning at 'pixels' with 'color'. 'x_start', 'width' and 'pitch'
+ * are given in bytes. 4 bytes at a time.
+ */
+static void erase_area_4(int x_start, int width, int height, int pitch, uint32_t color, uint8_t* pixels)
+{
+ int x_end = x_start/4 + width/4;
+ int x, y;
+ uint32_t* data = (uint32_t*) pixels;
+
+ x_start /= 4;
+ pitch /= 4;
+
+ for(y = 0; y < height; y++) {
+ for(x = x_start; x < x_end; x++)
+ data[y*pitch + x] = color;
+ }
+}
+
+/* Fill area beginning at 'pixels' with 'color'. 'x_start', 'width' and 'pitch'
+ * are given in bytes. 1 byte at a time.
+ */
+static void erase_area_1(int x_start, int width, int height, int pitch, uint8_t color, uint8_t* pixels)
+{
+ int y;
+
+ for(y = 0; y < height; y++) {
+ memset(&pixels[y*pitch + x_start], color, width);
+ }
}
/**
@@ -1242,7 +1575,13 @@
/* update screen */
//SDL_UpdateRect(priv->surface, 0, 0, priv->surface->clip_rect.w, priv->surface->clip_rect.h);
+ if(priv->osd_has_changed) {
+ priv->osd_has_changed = 0;
SDL_UpdateRects(priv->surface, 1, &priv->surface->clip_rect);
+ }
+ else
+ SDL_UpdateRect(priv->surface, 0, priv->y_screen_top,
+ priv->surface->clip_rect.w, priv->y_screen_bottom);
/* check if we have a double buffered surface and flip() if we do. */
if ( priv->surface->flags & SDL_DOUBLEBUF )
@@ -1320,7 +1659,7 @@
return query_format(*((uint32_t*)data));
case VOCTRL_FULLSCREEN:
if (priv->surface->flags & SDL_FULLSCREEN) {
- priv->surface = SDL_SetVideoMode(priv->windowsize.w, priv->windowsize.h, priv->bpp, priv->sdlflags);
+ set_video_mode(priv->windowsize.w, priv->windowsize.h, priv->bpp, priv->sdlflags);
SDL_ShowCursor(1);
if(verbose > 1) printf("SDL: Windowed mode\n");
} else if (priv->fullmodes) {
- Previous message: [Mplayer-cvslog] CVS: main find_sub.c,1.5,1.6 mplayer.c,1.402,1.403
- Next message: [Mplayer-cvslog] CVS: main/libvo sub.c,1.42,1.43 sub.h,1.10,1.11 vo_sdl.c,1.69,1.70
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the MPlayer-cvslog
mailing list