mplayer.hg: libvo/vo_sdl.c comparison

comparison libvo/vo_sdl.c @ 18234:a107276371a8

Part 5 and final of otvos attila's oattila AT chello-hu mp_msg changes, with lots of corrections

author	reynaldo
date	Mon, 24 Apr 2006 04:23:53 +0000
parents	3fe3b2b3a6ce
children	5766a9d21992

comparison

equal deleted inserted replaced

-:30fcc199bec7
+:a107276371a8
 #include <string.h>
 #include <inttypes.h>
 #include "mp_msg.h"
 #include "config.h"
+#include "mp_msg.h"
+#include "help_mp.h"
 #include "video_out.h"
 #include "video_out_internal.h"
 #include "fastmemcpy.h"
 #include "sub.h"
 #ifdef SDL_ENABLE_LOCKS
 #define	SDL_OVR_LOCK(x)        if (SDL_LockYUVOverlay (priv->overlay)) { \
 				if( mp_msg_test(MSGT_VO,MSGL_V) ) { \
-				  printf("SDL: Couldn't lock YUV overlay\n");} \
+				  mp_msg(MSGT_VO,MSGL_V, "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( mp_msg_test(MSGT_VO,MSGL_V) ) { \
-					  printf("SDL: Couldn't lock RGB surface\n"); } \
+					  mp_msg(MSGT_VO,MSGL_V, "SDL: Couldn't lock RGB surface\n"); } \
 					return x; \
 				} \
 			    }
 #define SDL_SRF_UNLOCK(srf) if(SDL_MUSTLOCK(srf)) \
 	/* other default values */
 	#ifdef SDL_NOHWSURFACE
 		if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SDL: using software-surface\n"); }
+			mp_msg(MSGT_VO,MSGL_V, "SDL: using software-surface\n"); }
 		priv->sdlflags = SDL_SWSURFACE|SDL_RESIZABLE|SDL_ANYFORMAT;
 		priv->sdlfullflags = SDL_SWSURFACE|SDL_FULLSCREEN|SDL_ANYFORMAT;
 		// XXX:FIXME: ASYNCBLIT should be enabled for SMP systems
 	#else
 		/*if((strcmp(priv->driver, "dga") == 0) && (priv->mode)) {
 			priv->sdlflags = SDL_SWSURFACE|SDL_FULLSCREEN|SDL_ASYNCBLIT|SDL_HWACCEL|SDL_ANYFORMAT;
 			priv->sdlfullflags = SDL_SWSURFACE|SDL_FULLSCREEN|SDL_ASYNCBLIT|SDL_HWACCEL|SDL_ANYFORMAT;
 		}
 		else {	*/
 			if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-				printf("SDL: using hardware-surface\n"); }
+	 			mp_msg(MSGT_VO,MSGL_V, "SDL: using hardware-surface\n"); }
 			priv->sdlflags = SDL_HWSURFACE|SDL_RESIZABLE/*|SDL_ANYFORMAT*/;
 			priv->sdlfullflags = SDL_HWSURFACE|SDL_FULLSCREEN/*|SDL_ANYFORMAT*/;
 			// XXX:FIXME: ASYNCBLIT should be enabled for SMP systems
 		//}
 	#endif
 		 * That's all we have. If this fails there's nothing left.
 		 * Theoretically there could be Fullscreenmodes left - we ignore this for now.
 		 */
 		priv->sdlflags &= ~SDL_HWSURFACE;
 		if ((!SDL_ListModes (vidInfo->vfmt, priv->sdlflags)) && (!priv->fullmodes)) {
-			printf("SDL: Couldn't get any acceptable SDL Mode for output.\n");
+			mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SDL_CouldntGetAnyAcceptableSDLModeForOutput);
 			return -1;
 		}
 	}
 */
 	priv->bpp = vidInfo->vfmt->BitsPerPixel;
 	if (priv->mode == YUV && priv->bpp < 16) {
 		if( mp_msg_test(MSGT_VO,MSGL_V) )
-printf("SDL: Your SDL display target wants to be at a color "
+		    mp_msg(MSGT_VO,MSGL_V, "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.\n",
 priv->bpp);
 #if 0
 static SDL_Rect aspect(int srcw, int srch, int dstw, int dsth) {
 	SDL_Rect newres;
 	if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-		printf("SDL Aspect: src: %ix%i dst: %ix%i\n", srcw, srch, dstw, dsth); }
+	 	mp_msg(MSGT_VO,MSGL_V, "SDL Aspect-Destinationres: %ix%i (x: %i, y: %i)\n", newres.w, newres.h, newres.x, newres.y); }
 	newres.h = ((float)dstw / (float)srcw * (float)srch) * ((float)dsth/((float)dstw/(MONITOR_ASPECT)));
 	if(newres.h > dsth) {
 		newres.w = ((float)dsth / (float)newres.h) * dstw;
 		newres.h = dsth;
 		newres.x = (dstw - newres.w) / 2;
 		newres.x = 0;
 		newres.y = (dsth - newres.h) / 2;
 	}
 	if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-		printf("SDL Aspect-Destinationres: %ix%i (x: %i, y: %i)\n", newres.w, newres.h, newres.x, newres.y); }
+		mp_msg(MSGT_VO,MSGL_V, "SDL Mode: %d:  %d x %d\n", i, priv->fullmodes[i]->w, priv->fullmodes[i]->h); }
 	return newres;
 }
 #endif
 priv->dstheight = height;
 setup_surfaces();
 }
 else
-printf("set_video_mode: SDL_SetVideoMode failed: %s\n", SDL_GetError());
+mp_msg(MSGT_VO,MSGL_WARN, "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;
 	}
 	else if (mode < 0) {
 int i,j,imax;
 		mode = 0; // Default to the biggest mode avaible
 		if ( mp_msg_test(MSGT_VO,MSGL_V) ) for(i=0;priv->fullmodes[i];++i)
-	           printf("SDL Mode: %d:  %d x %d\n", i, priv->fullmodes[i]->w, priv->fullmodes[i]->h);
+	           mp_msg(MSGT_VO,MSGL_V, "SDL Mode: %d:  %d x %d\n", i, priv->fullmodes[i]->w, priv->fullmodes[i]->h);
 		for(i = findArrayEnd(priv->fullmodes) - 1; i >=0; i--) {
 		  if( (priv->fullmodes[i]->w >= priv->dstwidth) &&
 		      (priv->fullmodes[i]->h >= priv->dstheight) ) {
 		      imax = i;
 		      for (j = findArrayEnd(priv->fullmodes) - 1; j >=0; j--) {
 		      mode = imax;
 		      break;
 		    }
 		  }
 		if ( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SET SDL Mode: %d:  %d x %d\n", mode, priv->fullmodes[mode]->w, priv->fullmodes[mode]->h); }
+			mp_msg(MSGT_VO,MSGL_V, "SET SDL Mode: %d:  %d x %d\n", mode, priv->fullmodes[mode]->w, priv->fullmodes[mode]->h); }
 		priv->fullmode = mode;
 screen_surface_h = priv->fullmodes[mode]->h;
 screen_surface_w = priv->fullmodes[mode]->w;
 	}
 else {
 SDL_FillRect(priv->surface, NULL, 0);
 SDL_SRF_UNLOCK(priv->surface)
 setup_surfaces();
 	}
 else
-printf("set_fullmode: SDL_SetVideoMode failed: %s\n", SDL_GetError());
+mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_SDL_SetVideoModeFailedFull, SDL_GetError());
 }
 /**
 * Initialize an SDL surface and an SDL YUV overlay.
 {
 	struct sdl_priv_s *priv = &sdl_priv;
 switch(format){
 case IMGFMT_I420:
-printf("SDL: Mapping I420 to IYUV\n");
+mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_SDL_MappingI420ToIYUV);
 format = SDL_IYUV_OVERLAY;
 		case IMGFMT_YV12:
 		case IMGFMT_IYUV:
 		case IMGFMT_YUY2:
 		case IMGFMT_UYVY:
 case IMGFMT_RGB24:
 		case IMGFMT_RGB32:
 			priv->mode = RGB;
 			break;
 		default:
-			printf("SDL: Unsupported image format (0x%X)\n",format);
+			mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SDL_UnsupportedImageFormat,format);
 			return -1;
 	}
 if ( vo_config_count ) sdl_close();
 if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-printf("SDL: Using 0x%X (%s) image format\n", format, vo_format_name(format)); }
+mp_msg(MSGT_VO,MSGL_V, "SDL: Using 0x%X (%s) image format\n", format, vo_format_name(format)); }
 if(priv->mode != YUV) {
 		priv->sdlflags |= SDL_ANYFORMAT;
 		priv->sdlfullflags |= SDL_ANYFORMAT;
 	}
 	 */
 //      printf("SDL: flags are set to: %i\n", flags);
 //	printf("SDL: Width: %i Height: %i D_Width %i D_Height: %i\n", width, height, d_width, d_height);
 	if(flags&VOFLAG_FLIPPING) {
 		if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SDL: using flipped video (only with RGB/BGR/packed YUV)\n"); }
+			mp_msg(MSGT_VO,MSGL_V, "SDL: using flipped video (only with RGB/BGR/packed YUV)\n"); }
 		priv->flip = 1;
 	}
 	if(flags&VOFLAG_FULLSCREEN) {
 	  	if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SDL: setting zoomed fullscreen without modeswitching\n"); }
+	  	    mp_msg(MSGT_VO,MSGL_V, "SDL: setting zoomed fullscreen without modeswitching\n");}
-		printf("SDL: Info - please use -vm or -zoom to switch to best resolution.\n");
+		    mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_SDL_InfoPleaseUseVmOrZoom);
 		priv->fulltype = VOFLAG_FULLSCREEN;
 		set_fullmode(priv->fullmode);
 	/*if((priv->surface = SDL_SetVideoMode (d_width, d_height, priv->bpp, priv->sdlfullflags)))
 			SDL_ShowCursor(0);*/
 	} else
 	if(flags&VOFLAG_MODESWITCHING) {
 	 	if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SDL: setting zoomed fullscreen with modeswitching\n"); }
+	 		mp_msg(MSGT_VO,MSGL_V, "SDL: setting zoomed fullscreen with modeswitching\n"); }
 		priv->fulltype = VOFLAG_MODESWITCHING;
 		set_fullmode(priv->fullmode);
 	/*if((priv->surface = SDL_SetVideoMode (d_width ? d_width : width, d_height ? d_height : height, priv->bpp, priv->sdlfullflags)))
 			SDL_ShowCursor(0);*/
 	} else
 	if(flags&VOFLAG_SWSCALE) {
 	 	if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SDL: setting zoomed fullscreen with modeswitching\n"); }
+			mp_msg(MSGT_VO,MSGL_V, "SDL: setting zoomed fullscreen with modeswitching\n"); }
 		priv->fulltype = VOFLAG_SWSCALE;
 		set_fullmode(priv->fullmode);
 	}
 else {
 		if((strcmp(priv->driver, "x11") == 0)
 		||(strcmp(priv->driver, "directx") == 0)
 		||(strcmp(priv->driver, "Quartz") == 0)
 		||(strcmp(priv->driver, "cgx") == 0)
 		||((strcmp(priv->driver, "aalib") == 0) && priv->X)){
 			if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-				printf("SDL: setting windowed mode\n"); }
+				mp_msg(MSGT_VO,MSGL_V, "SDL: setting windowed mode\n"); }
 set_video_mode(priv->dstwidth, priv->dstheight, priv->bpp, priv->sdlflags);
 		}
 		else {
 			if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-				printf("SDL: setting zoomed fullscreen with modeswitching\n"); }
+				mp_msg(MSGT_VO,MSGL_V, "SDL: setting zoomed fullscreen with modeswitching\n"); }
 			priv->fulltype = VOFLAG_SWSCALE;
 			set_fullmode(priv->fullmode);
 		}
 	}
 if(!priv->surface) { // cannot SetVideoMode
-		printf("SDL: failed to set video mode: %s\n", SDL_GetError());
+		mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SDL_FailedToSetVideoMode, SDL_GetError());
 		return -1;
 	}
 	return 0;
 }
 priv->rgbsurface = SDL_CreateRGBSurface (SDL_SRCCOLORKEY, surfwidth, surfheight, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0/*0xFF000000*/);
 	    break;
 	    default:
 		/* Initialize and create the YUV Overlay used for video out */
 		if (!(priv->overlay = SDL_CreateYUVOverlay (surfwidth, surfheight, priv->format, priv->surface))) {
-			printf ("SDL: Couldn't create a YUV overlay: %s\n", SDL_GetError());
+			mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SDL_CouldntCreateAYUVOverlay, SDL_GetError());
 			return -1;
 		}
 		priv->framePlaneY = priv->width * priv->height;
 		priv->framePlaneUV = (priv->width * priv->height) >> 2;
 		priv->framePlaneYUY = priv->width * priv->height * 2;
 		priv->stridePlaneYUY = priv->width * 2;
 	}
 if(priv->mode != YUV) {
 if(!priv->rgbsurface) {
-printf ("SDL: Couldn't create a RGB surface: %s\n", SDL_GetError());
+mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SDL_CouldntCreateARGBSurface, SDL_GetError());
 return -1;
 }
 priv->dblit = 0;
 if((priv->format&0xFF) != priv->bpp)
-printf("SDL: using depth/colorspace conversion, this will slow things"
+mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_SDL_UsingDepthColorspaceConversion, priv->format&0xFF, priv->bpp);
-"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;
 }
 dst = priv->overlay->pixels[2] + priv->overlay->pitches[2]*y + x;
 	memcpy_pic(dst, image[2], w, h, priv->overlay->pitches[2], stride[2]);
 break;
 default:
-	printf("SDL: unsupported image format in draw_slice, contact MPlayer developers!\n");
+	mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SDL_UnsupportedImageFormatInDrawslice);
 }
 	SDL_OVR_UNLOCK
 	return 0;
 			 	//if(!(priv->surface->flags & SDL_FULLSCREEN)) {
 				    priv->windowsize.w = priv->surface->w;
 				    priv->windowsize.h = priv->surface->h;
 				//}
 				if( mp_msg_test(MSGT_VO,MSGL_DBG3) ) {
-					printf("SDL: Window resize\n"); }
+					mp_msg(MSGT_VO,MSGL_DBG3, "SDL: Window resize\n"); }
 			break;
 			case SDL_MOUSEBUTTONDOWN:
 				if(vo_nomouse_input)
 				    break;
 #else
 			case SDL_KEYDOWN:
 #endif
 				keypressed = event.key.keysym.sym;
 				if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
-					printf("SDL: Key pressed: '%i'\n", keypressed); }
+					mp_msg(MSGT_VO,MSGL_DBG2, "SDL: Key pressed: '%i'\n", keypressed); }
 				/* c key pressed. c cycles through available fullscreenmodes, if we have some */
 				if ( ((keypressed == SDLK_c)) && (priv->fullmodes) ) {
 					/* select next fullscreen mode */
 					priv->fullmode++;
 					if (priv->fullmode > (findArrayEnd(priv->fullmodes) - 1)) priv->fullmode = 0;
 					set_fullmode(priv->fullmode);
 					if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
-						printf("SDL: Set next available fullscreen mode.\n"); }
+						mp_msg(MSGT_VO,MSGL_DBG2, "SDL: Set next available fullscreen mode.\n"); }
 				}
 				else if ( keypressed == SDLK_n ) {
 #ifdef HAVE_X11
 					aspect(&priv->dstwidth, &priv->dstheight,A_NOZOOM);
 					if (priv->surface->w != priv->dstwidth || priv->surface->h != priv->dstheight) {
 set_video_mode(priv->dstwidth, priv->dstheight, priv->bpp, priv->sdlflags);
 					    	priv->windowsize.w = priv->surface->w;
 						priv->windowsize.h = priv->surface->h;
 						if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
-							printf("SDL: Normal size\n"); }
+							mp_msg(MSGT_VO,MSGL_DBG2, "SDL: Normal size\n"); }
 					} else
 					if (priv->surface->w != priv->dstwidth * 2 || priv->surface->h != priv->dstheight * 2) {
 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( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
-							printf("SDL: Double size\n"); }
+							mp_msg(MSGT_VO,MSGL_DBG2, "SDL: Double size\n"); }
 					}
 				}
 else switch(keypressed){
 				case SDLK_RETURN: mplayer_put_key(KEY_ENTER);break;
 	    case IMGFMT_RGB32:
 	    case IMGFMT_BGR32:
 		if(!priv->dblit) {
 		  	/* blit to the RGB surface */
 			if(SDL_BlitSurface (priv->rgbsurface, NULL, priv->surface, NULL))
-				printf("SDL: Blit failed: %s\n", SDL_GetError());
+				mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SDL_BlitFailed, SDL_GetError());
 		}
 		/* update screen */
 		//SDL_UpdateRect(priv->surface, 0, 0, priv->surface->clip_rect.w, priv->surface->clip_rect.h);
 if(priv->osd_has_changed) {
 {
 #ifdef HAVE_X11
 struct sdl_priv_s *priv = &sdl_priv;
 if(priv->X) {
 		if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SDL: activating XScreensaver/DPMS\n"); }
+			mp_msg(MSGT_VO,MSGL_V, "SDL: activating XScreensaver/DPMS\n"); }
 		vo_x11_uninit();
 	}
 #endif
 	sdl_close();
 	/* Cleanup SDL */
 if(SDL_WasInit(SDL_INIT_VIDEO))
 SDL_QuitSubSystem(SDL_INIT_VIDEO);
 	if( mp_msg_test(MSGT_VO,MSGL_DBG3) ) {
-		printf("SDL: Closed Plugin\n"); }
+		mp_msg(MSGT_VO,MSGL_DBG3, "SDL: Closed Plugin\n"); }
 }
 static int preinit(const char *arg)
 {
 priv->rgbsurface = NULL;
 priv->overlay = NULL;
 priv->surface = NULL;
 if( mp_msg_test(MSGT_VO,MSGL_DBG3) ) {
-printf("SDL: Opening Plugin\n"); }
+mp_msg(MSGT_VO,MSGL_DBG3, "SDL: Opening Plugin\n"); }
 if(sdl_driver) {
 setenv("SDL_VIDEODRIVER", sdl_driver, 1);
 free(sdl_driver);
 }
 priv->bpp = 0;
 /* initialize the SDL Video system */
 if (!SDL_WasInit(SDL_INIT_VIDEO)) {
 if (SDL_Init (SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE)) {
-printf("SDL: Initializing of SDL failed: %s.\n", SDL_GetError());
+mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SDL_InitializingOfSDLFailed, SDL_GetError());
 return -1;
 }
 }
 SDL_VideoDriverName(priv->driver, 8);
-printf("SDL: Using driver: %s\n", priv->driver);
+mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_SDL_UsingDriver, priv->driver);
 priv->X = 0;
 #ifdef HAVE_X11
 if(vo_init()) {
 		if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SDL: deactivating XScreensaver/DPMS\n"); }
+			mp_msg(MSGT_VO,MSGL_V, "SDL: deactivating XScreensaver/DPMS\n"); }
 		priv->XWidth = vo_screenwidth;
 		priv->XHeight = vo_screenheight;
 		priv->X = 1;
 		if( mp_msg_test(MSGT_VO,MSGL_V) ) {
-			printf("SDL: X11 Resolution %ix%i\n", priv->XWidth, priv->XHeight); }
+			mp_msg(MSGT_VO,MSGL_V, "SDL: X11 Resolution %ix%i\n", priv->XWidth, priv->XHeight); }
 	}
 #endif
 return 0;
 }
 case VOCTRL_FULLSCREEN:
 if (priv->surface->flags & SDL_FULLSCREEN) {
 set_video_mode(priv->windowsize.w, priv->windowsize.h, priv->bpp, priv->sdlflags);
 SDL_ShowCursor(1);
 if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
-printf("SDL: Windowed mode\n"); }
+	mp_msg(MSGT_VO,MSGL_DBG2, "SDL: Windowed mode\n"); }
 } else if (priv->fullmodes) {
 set_fullmode(priv->fullmode);
 if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
-printf("SDL: Set fullscreen mode\n"); }
+	mp_msg(MSGT_VO,MSGL_DBG2, "SDL: Set fullscreen mode\n"); }
 }
 return VO_TRUE;
 }
 return VO_NOTIMPL;

Mercurial > mplayer.hg

comparison libvo/vo_sdl.c @ 18234:a107276371a8