vo_sdl.c

DawnLightPlayer,一个新的基于ffmpeg的全功能播放器

/**********************************************
 * Dawn Light Player
 *
 *   vo_sdl.c
 *
 * Created by kf701
 * 14:11:50 02/26/08 CST
 *
 * $Id: vo_sdl.c 171 2008-03-21 08:00:10Z kf701 $
 **********************************************/

#if ENABLE_VO_SDL

#include "avcodec.h"
#include "swscale.h"
#include "avoutput.h"
#include "avdecode.h"
#include "avinput.h"
#include "cmdutils.h"
#include "global.h"

#include <SDL/SDL.h>

static pthread_mutex_t vo_mutex;

static void vo_lock_init()
{
	pthread_mutex_init(&vo_mutex,NULL);
}

static void vo_lock_free()
{
	pthread_mutex_destroy(&vo_mutex);
}

static void vo_lock()
{
	pthread_mutex_lock(&vo_mutex);
}

static void vo_unlock()
{
	pthread_mutex_unlock(&vo_mutex);
}

static volatile int fullscreen = 0;
static void toggle_full_screen(void);

static SDL_Surface *screen = NULL;
static SDL_Overlay *overlay = NULL;

static int dx, dy, dw, dh, ww, wh;
static AVPicture *my_pic = NULL;

static int vo_sdl_init(void)
{
	int flags, ret;

	putenv("SDL_VIDEO_WINDOW_POS=center");
	putenv("SDL_VIDEO_CENTERED=1");

	flags = SDL_INIT_VIDEO | SDL_INIT_VIDEO | SDL_INIT_TIMER;
	if ( SDL_Init (flags) )
	{
		av_log(NULL, AV_LOG_ERROR, "initialize SDL: %s\n", SDL_GetError());
		return -1;
	}
	SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
	SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
	SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
	SDL_EventState(SDL_USEREVENT, SDL_IGNORE);

	dx = dy = 0;
	ww = dw = dlpctxp->pwidth;
	wh = dh = dlpctxp->pheight;

	flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL|SDL_RESIZABLE;
	screen = SDL_SetVideoMode(ww, wh, 0, flags);
	SDL_WM_SetCaption("Dawn Light Player", "Dawn Light Player");

	overlay = SDL_CreateYUVOverlay(dw, dh, SDL_YV12_OVERLAY, screen);

	my_pic = av_mallocz(sizeof(AVPicture));
	ret = avpicture_alloc(my_pic, dlpctxp->pixfmt, dw, dh);
	if ( -1 == ret )
	{
		av_log(NULL, AV_LOG_ERROR, "avpicture alloc error\n");
		return -1;
	}

	vo_lock_init();

	if ( dlpctxp->fs )
		toggle_full_screen();

	av_log(NULL, AV_LOG_INFO, "init vo sdl OK\n");

	return 0;
}

static int vo_sdl_uninit(void)
{
	vo_lock();

	SDL_FreeYUVOverlay(overlay);
	overlay = NULL;

	avpicture_free(my_pic);
	av_free(my_pic);
	my_pic = NULL;

	vo_lock_free();

	av_log(NULL, AV_LOG_INFO, "uninit vo sdl\n");
	return 0;
}

static void toggle_full_screen(void)
{
	SDL_Rect rect;
	int flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
	fullscreen = !fullscreen;

	if ( fullscreen )
	{
		int t1, t2, drate;
		int fs_screen_width = 0, fs_screen_height = 0;

#ifdef HAVE_SDL_VIDEO_SIZE
		const SDL_VideoInfo *vi = SDL_GetVideoInfo();
		fs_screen_width = vi->current_w;
		fs_screen_height = vi->current_h;
#endif
		ww = fs_screen_width ? fs_screen_width : 1024;
		wh = fs_screen_height ? fs_screen_height : 768;

		t1 = ww / (double)dlpctxp->pwidth;
		t2 = wh / (double)dlpctxp->pheight;

		drate = t1 > t2 ? t2 : t1 ;

		dw = dlpctxp->pwidth * drate;
		dh = dlpctxp->pheight * drate;

		/* make video center */
		dx = ( ww - dw ) / 2;
		dy = ( wh - dh ) / 2;

		flags |= SDL_FULLSCREEN;
	}
	else
	{
		dw = ww = dlpctxp->pwidth;
		dh = wh = dlpctxp->pheight;
		dx = dy = 0;

		flags |= SDL_RESIZABLE;
	}

	vo_lock();

	/* realloc resouce and reinit WM */
	SDL_FreeYUVOverlay(overlay);
	overlay = NULL;

	avpicture_free(my_pic);
	av_free(my_pic);
	my_pic = NULL;

	screen = SDL_SetVideoMode(ww, wh, 0, flags);
	overlay = SDL_CreateYUVOverlay(dw, dh, SDL_YV12_OVERLAY, screen);
	rect.x = dx;
	rect.y = dy;
	rect.w = dw;
	rect.h = dh;
	SDL_DisplayYUVOverlay(overlay, &rect);
	my_pic = av_mallocz(sizeof(AVPicture));
	avpicture_alloc(my_pic, dlpctxp->pixfmt, dw, dh);

	vo_unlock();
}

static int vo_sdl_sws(AVPicture *dst, AVPicture *src)
{
	static struct SwsContext *img_convert_ctx;

	img_convert_ctx = sws_getCachedContext(img_convert_ctx,
	                                       dlpctxp->pwidth, dlpctxp->pheight, dlpctxp->pixfmt,
	                                       dw, dh, dlpctxp->pixfmt, SWS_BICUBIC, NULL, NULL, NULL);

	sws_scale(img_convert_ctx, src->data, src->linesize,
	          0, dh, dst->data, dst->linesize);

	return 0;
}

static void vo_sdl_display(AVPicture *pict)
{
	SDL_Rect rect;
	int yuv_len =  0;
	int s1, s2, s3;

	vo_lock();

	vo_sdl_sws( my_pic, pict );

	yuv_len = avpicture_get_size(dlpctxp->pixfmt, dw, dh);
	s1 = dw * dh;
	s2 = s3 = (yuv_len - s1) / 2;

	SDL_LockYUVOverlay(overlay);
	memcpy(overlay->pixels[0], my_pic->data[0], s1);
	memcpy(overlay->pixels[2], my_pic->data[1], s2);
	memcpy(overlay->pixels[1], my_pic->data[2], s3);
	overlay->pitches[0] = my_pic->linesize[0];
	overlay->pitches[2] = my_pic->linesize[1];
	overlay->pitches[1] = my_pic->linesize[2];
	SDL_UnlockYUVOverlay(overlay);

	rect.x = dx;
	rect.y = dy;
	rect.w = dw;
	rect.h = dh;
	SDL_DisplayYUVOverlay(overlay, &rect);

	vo_unlock();
}

static void vo_sdl_event_loop(void)
{
	SDL_Event event;
	while (1)
	{
		SDL_WaitEvent(&event);
		switch (event.type)
		{
		case SDL_KEYDOWN:
			switch (event.key.keysym.sym)
			{
			case SDLK_h:
				show_ui_key();
				break;
			case SDLK_s:
				dlp_screen_shot();
				break;
			case SDLK_ESCAPE:
			case SDLK_q:
				dlp_exit(-2);
			case SDLK_9:
				dlp_sub_volume();
				break;
			case SDLK_0:
				dlp_add_volume();
				break;
			case SDLK_p:
			case SDLK_SPACE:
				dlp_pause_play();
				break;
			case SDLK_LEFT:
				dlp_seek(-10);
				break;
			case SDLK_RIGHT:
				dlp_seek(10);
				break;
			case SDLK_PAGEDOWN:
				dlp_seek(60);
				break;
			case SDLK_PAGEUP:
				dlp_seek(-60);
				break;
			case SDLK_f:
				toggle_full_screen();
				break;
			}
		}
	}
}

vo_t vo_sdl =
{
	VO_ID_SDL,
	"sdl",
	vo_sdl_init,
	vo_sdl_uninit,
	vo_sdl_display,
	vo_sdl_event_loop,
};

#endif /* ENABLE_VO_SDL */