/**
* Control for vout display
*/
static int Control(vout_display_t *vd, int query, va_list args)
{
vout_display_sys_t *sys = vd->sys;
switch (query)
{
case VOUT_DISPLAY_HIDE_MOUSE:
SDL_ShowCursor(0);
return VLC_SUCCESS;
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE: {
const vout_display_cfg_t *cfg = va_arg(args, const vout_display_cfg_t *);
/* */
sys->display = SDL_SetVideoMode(cfg->display.width,
cfg->display.height,
sys->display_bpp, sys->display_flags);
if (!sys->display) {
sys->display = SDL_SetVideoMode(vd->cfg->display.width,
vd->cfg->display.height,
sys->display_bpp, sys->display_flags);
return VLC_EGENERIC;
}
if (sys->overlay)
vout_display_PlacePicture(&sys->place, &vd->source, cfg, !sys->overlay);
else
vout_display_SendEventPicturesInvalid(vd);
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_FULLSCREEN: {
vout_display_cfg_t cfg = *va_arg(args, const vout_display_cfg_t *);
/* Fix flags */
sys->display_flags &= ~(SDL_FULLSCREEN | SDL_RESIZABLE);
sys->display_flags |= cfg.is_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
if (cfg.is_fullscreen) {
cfg.display.width = sys->desktop_width;
cfg.display.height = sys->desktop_height;
}
if (sys->overlay) {
sys->display = SDL_SetVideoMode(cfg.display.width, cfg.display.height,
sys->display_bpp, sys->display_flags);
vout_display_PlacePicture(&sys->place, &vd->source, &cfg, !sys->overlay);
}
vout_display_SendEventDisplaySize(vd, cfg.display.width, cfg.display.height, cfg.is_fullscreen);
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_ZOOM:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT: {
const vout_display_cfg_t *cfg;
const video_format_t *source;
if (query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT) {
source = va_arg(args, const video_format_t *);
cfg = vd->cfg;
} else {
source = &vd->source;
cfg = va_arg(args, const vout_display_cfg_t *);
}
if (sys->overlay) {
sys->display = SDL_SetVideoMode(cfg->display.width, cfg->display.height,
sys->display_bpp, sys->display_flags);
vout_display_PlacePicture(&sys->place, source, cfg, !sys->overlay);
} else {
vout_display_SendEventPicturesInvalid(vd);
}
return VLC_SUCCESS;
}
/**
* This function initializes SDL vout method.
*/
static int Open(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys;
#if !defined(_WIN32) && !defined(__OS2__)
if (!vlc_xlib_init (object))
return VLC_EGENERIC;
#endif
/* XXX: check for conflicts with the SDL audio output */
vlc_mutex_lock(&sdl_lock);
/* Check if SDL video module has been initialized */
if (SDL_WasInit(SDL_INIT_VIDEO) != 0) {
vlc_mutex_unlock(&sdl_lock);
return VLC_EGENERIC;
}
vd->sys = sys = calloc(1, sizeof(*sys));
if (!sys) {
vlc_mutex_unlock(&sdl_lock);
return VLC_ENOMEM;
}
/* */
int sdl_flags = SDL_INIT_VIDEO;
#ifndef _WIN32
/* Win32 SDL implementation doesn't support SDL_INIT_EVENTTHREAD yet*/
sdl_flags |= SDL_INIT_EVENTTHREAD;
#endif
/* In debug mode you may want vlc to dump a core instead of staying stuck */
sdl_flags |= SDL_INIT_NOPARACHUTE;
/* Initialize library */
if (SDL_Init(sdl_flags) < 0) {
vlc_mutex_unlock(&sdl_lock);
msg_Err(vd, "cannot initialize SDL (%s)", SDL_GetError());
free(sys);
return VLC_EGENERIC;
}
vlc_mutex_unlock(&sdl_lock);
/* Translate keys into unicode */
SDL_EnableUNICODE(1);
/* Get the desktop resolution */
/* FIXME: SDL has a problem with virtual desktop */
sys->desktop_width = SDL_GetVideoInfo()->current_w;
sys->desktop_height = SDL_GetVideoInfo()->current_h;
/* */
video_format_t fmt;
video_format_ApplyRotation(&fmt, &vd->fmt);
/* */
vout_display_info_t info = vd->info;
/* Set main window's size */
int display_width;
int display_height;
if (vd->cfg->is_fullscreen) {
display_width = sys->desktop_width;
display_height = sys->desktop_height;
} else {
display_width = vd->cfg->display.width;
display_height = vd->cfg->display.height;
}
/* Initialize flags and cursor */
sys->display_flags = SDL_ANYFORMAT | SDL_HWPALETTE | SDL_HWSURFACE | SDL_DOUBLEBUF;
sys->display_flags |= vd->cfg->is_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
sys->display_bpp = SDL_VideoModeOK(display_width, display_height,
16, sys->display_flags);
if (sys->display_bpp == 0) {
msg_Err(vd, "no video mode available");
goto error;
}
vout_display_DeleteWindow(vd, NULL);
sys->display = SDL_SetVideoMode(display_width, display_height,
sys->display_bpp, sys->display_flags);
if (!sys->display) {
msg_Err(vd, "cannot set video mode");
goto error;
}
/* We keep the surface locked forever */
SDL_LockSurface(sys->display);
/* */
vlc_fourcc_t forced_chroma = 0;
char *psz_chroma = var_InheritString(vd, "sdl-chroma");
if (psz_chroma) {
forced_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, psz_chroma);
if (forced_chroma)
msg_Dbg(vd, "Forcing chroma to 0x%.8x (%4.4s)",
forced_chroma, (const char*)&forced_chroma);
free(psz_chroma);
}
/* Try to open an overlay if requested */
sys->overlay = NULL;
const bool is_overlay = var_InheritBool(vd, "overlay");
if (is_overlay) {
static const struct
{
vlc_fourcc_t vlc;
uint32_t sdl;
} vlc_to_sdl[] = {
{ VLC_CODEC_YV12, SDL_YV12_OVERLAY },
{ VLC_CODEC_I420, SDL_IYUV_OVERLAY },
{ VLC_CODEC_YUYV, SDL_YUY2_OVERLAY },
{ VLC_CODEC_UYVY, SDL_UYVY_OVERLAY },
{ VLC_CODEC_YVYU, SDL_YVYU_OVERLAY },
{ 0, 0 }
};
const vlc_fourcc_t forced_chromas[] = {
forced_chroma, 0
};
const vlc_fourcc_t *fallback_chromas =
vlc_fourcc_GetYUVFallback(fmt.i_chroma);
const vlc_fourcc_t *chromas = forced_chroma ? forced_chromas : fallback_chromas;
for (int pass = forced_chroma ? 1 : 0; pass < 2 && !sys->overlay; pass++) {
for (int i = 0; chromas[i] != 0; i++) {
const vlc_fourcc_t vlc = chromas[i];
uint32_t sdl = 0;
for (int j = 0; vlc_to_sdl[j].vlc != 0 && !sdl; j++) {
if (vlc_to_sdl[j].vlc == vlc)
sdl = vlc_to_sdl[j].sdl;
}
if (!sdl)
continue;
sys->overlay = SDL_CreateYUVOverlay(fmt.i_width, fmt.i_height,
sdl, sys->display);
if (sys->overlay && !sys->overlay->hw_overlay && pass == 0) {
/* Ignore non hardware overlay surface in first pass */
SDL_FreeYUVOverlay(sys->overlay);
sys->overlay = NULL;
}
if (sys->overlay) {
/* We keep the surface locked forever */
SDL_LockYUVOverlay(sys->overlay);
fmt.i_chroma = vlc;
sys->is_uv_swapped = vlc_fourcc_AreUVPlanesSwapped(fmt.i_chroma,
vd->fmt.i_chroma);
if (sys->is_uv_swapped)
fmt.i_chroma = vd->fmt.i_chroma;
break;
}
}
}
} else {
msg_Warn(vd, "SDL overlay disabled by the user");
}
/* */
vout_display_cfg_t place_cfg = *vd->cfg;
place_cfg.display.width = display_width;
place_cfg.display.height = display_height;
vout_display_PlacePicture(&sys->place, &vd->source, &place_cfg, !sys->overlay);
/* If no overlay, fallback to software output */
if (!sys->overlay) {
/* */
switch (sys->display->format->BitsPerPixel) {
case 8:
fmt.i_chroma = VLC_CODEC_RGB8;
break;
case 15:
fmt.i_chroma = VLC_CODEC_RGB15;
break;
case 16:
fmt.i_chroma = VLC_CODEC_RGB16;
break;
case 24:
fmt.i_chroma = VLC_CODEC_RGB24;
break;
case 32:
fmt.i_chroma = VLC_CODEC_RGB32;
break;
default:
msg_Err(vd, "unknown screen depth %i",
sys->display->format->BitsPerPixel);
goto error;
}
/* All we have is an RGB image with square pixels */
fmt.i_width = display_width;
fmt.i_height = display_height;
fmt.i_rmask = sys->display->format->Rmask;
fmt.i_gmask = sys->display->format->Gmask;
fmt.i_bmask = sys->display->format->Bmask;
info.has_pictures_invalid = true;
}
if (vd->cfg->display.title)
SDL_WM_SetCaption(vd->cfg->display.title,
vd->cfg->display.title);
else if (!sys->overlay)
SDL_WM_SetCaption(VOUT_TITLE " (software RGB SDL output)",
VOUT_TITLE " (software RGB SDL output)");
else if (sys->overlay->hw_overlay)
SDL_WM_SetCaption(VOUT_TITLE " (hardware YUV SDL output)",
VOUT_TITLE " (hardware YUV SDL output)");
else
SDL_WM_SetCaption(VOUT_TITLE " (software YUV SDL output)",
VOUT_TITLE " (software YUV SDL output)");
/* Setup events */
SDL_EventState(SDL_KEYUP, SDL_IGNORE); /* ignore keys up */
/* Setup vout_display now that everything is fine */
vd->fmt = fmt;
vd->info = info;
vd->pool = Pool;
vd->prepare = NULL;
vd->display = PictureDisplay;
vd->control = Control;
vd->manage = Manage;
/* */
vout_display_SendEventDisplaySize(vd, display_width, display_height, vd->cfg->is_fullscreen);
return VLC_SUCCESS;
error:
msg_Err(vd, "cannot set up SDL (%s)", SDL_GetError());
if (sys->display) {
SDL_UnlockSurface(sys->display);
SDL_FreeSurface(sys->display);
}
vlc_mutex_lock(&sdl_lock);
SDL_QuitSubSystem(SDL_INIT_VIDEO);
vlc_mutex_unlock(&sdl_lock);
free(sys);
return VLC_EGENERIC;
}
/**
* Proccess pending event
*/
static void Manage(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
struct caca_event ev;
while (caca_get_event(sys->dp, CACA_EVENT_ANY, &ev, 0) > 0) {
switch (caca_get_event_type(&ev)) {
case CACA_EVENT_KEY_PRESS: {
const int caca = caca_get_event_key_ch(&ev);
for (int i = 0; keys[i].caca != -1; i++) {
if (keys[i].caca == caca) {
const int vlc = keys[i].vlc;
if (vlc >= 0)
vout_display_SendEventKey(vd, vlc);
return;
}
}
if (caca >= 0x20 && caca <= 0x7f) {
vout_display_SendEventKey(vd, caca);
return;
}
break;
}
case CACA_EVENT_RESIZE:
vout_display_SendEventDisplaySize(vd, caca_get_event_resize_width(&ev),
caca_get_event_resize_height(&ev), false);
break;
case CACA_EVENT_MOUSE_MOTION: {
vout_display_place_t place;
Place(vd, &place);
const unsigned x = vd->source.i_x_offset +
(int64_t)(caca_get_event_mouse_x(&ev) - place.x) *
vd->source.i_visible_width / place.width;
const unsigned y = vd->source.i_y_offset +
(int64_t)(caca_get_event_mouse_y(&ev) - place.y) *
vd->source.i_visible_height / place.height;
caca_set_mouse(sys->dp, 1);
vout_display_SendEventMouseMoved(vd, x, y);
break;
}
case CACA_EVENT_MOUSE_PRESS:
case CACA_EVENT_MOUSE_RELEASE: {
caca_set_mouse(sys->dp, 1);
const int caca = caca_get_event_mouse_button(&ev);
for (int i = 0; mouses[i].caca != -1; i++) {
if (mouses[i].caca == caca) {
if (caca_get_event_type(&ev) == CACA_EVENT_MOUSE_PRESS)
vout_display_SendEventMousePressed(vd, mouses[i].vlc);
else
vout_display_SendEventMouseReleased(vd, mouses[i].vlc);
return;
}
}
break;
}
case CACA_EVENT_QUIT:
vout_display_SendEventClose(vd);
break;
default:
break;
}
}
}
/**
* This function allocates and initializes a FB vout method.
*/
static int Open(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys;
/* Allocate instance and initialize some members */
vd->sys = sys = calloc(1, sizeof(*sys));
if (!sys)
return VLC_ENOMEM;
/* Does the framebuffer uses hw acceleration? */
sys->is_hw_accel = var_CreateGetBool(vd, "fb-hw-accel");
/* Set tty and fb devices */
sys->tty = 0; /* 0 == /dev/tty0 == current console */
sys->is_tty = var_CreateGetBool(vd, "fb-tty");
#if !defined(WIN32) && defined(HAVE_ISATTY)
/* Check that stdin is a TTY */
if (sys->is_tty && !isatty(0)) {
msg_Warn(vd, "fd 0 is not a TTY");
free(sys);
return VLC_EGENERIC;
}
msg_Warn(vd, "disabling tty handling, use with caution because "
"there is no way to return to the tty.");
#endif
const int mode = var_CreateGetInteger(vd, "fb-mode");
bool force_resolution = true;
switch (mode) {
case 0: /* QCIF */
sys->width = 176;
sys->height = 144;
break;
case 1: /* CIF */
sys->width = 352;
sys->height = 288;
break;
case 2: /* NTSC */
sys->width = 640;
sys->height = 480;
break;
case 3: /* PAL */
sys->width = 704;
sys->height = 576;
break;
case 4:
default:
force_resolution = false;
break;
}
/* tty handling */
if (sys->is_tty && TtyInit(vd)) {
free(sys);
return VLC_EGENERIC;
}
/* */
sys->video_ptr = MAP_FAILED;
sys->picture = NULL;
sys->pool = NULL;
if (OpenDisplay(vd, force_resolution)) {
Close(VLC_OBJECT(vd));
return VLC_EGENERIC;
}
/* */
video_format_t fmt = vd->fmt;
msg_Err(vd, "var_info.bits_per_pixel = %d", sys->var_info.bits_per_pixel);
switch (sys->var_info.bits_per_pixel) {
case 8: /* FIXME: set the palette */
fmt.i_chroma = VLC_CODEC_RGB8;
break;
case 15:
fmt.i_chroma = VLC_CODEC_RGB15;
break;
case 16:
fmt.i_chroma = VLC_CODEC_RGB16;
break;
case 24:
fmt.i_chroma = VLC_CODEC_RGB24;
break;
case 32:
fmt.i_chroma = VLC_CODEC_RGB32;
break;
default:
msg_Err(vd, "unknown screen depth %i",
sys->var_info.bits_per_pixel);
Close(VLC_OBJECT(vd));
return VLC_EGENERIC;
}
if (sys->var_info.bits_per_pixel != 8) {
fmt.i_rmask = ((1 << sys->var_info.red.length) - 1)
<< sys->var_info.red.offset;
fmt.i_gmask = ((1 << sys->var_info.green.length) - 1)
<< sys->var_info.green.offset;
fmt.i_bmask = ((1 << sys->var_info.blue.length) - 1)
<< sys->var_info.blue.offset;
}
fmt.i_width = sys->width;
fmt.i_height = sys->height;
/* */
vout_display_info_t info = vd->info;
info.has_hide_mouse = true;
/* */
vd->fmt = fmt;
vd->info = info;
vd->get = Get;
vd->prepare = NULL;
vd->display = Display;
vd->control = Control;
vd->manage = Manage;
/* */
vout_display_SendEventFullscreen(vd, true);
vout_display_SendEventDisplaySize(vd, fmt.i_width, fmt.i_height, true);
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: allocates video thread
*****************************************************************************
* This function allocates and initializes a vout method.
*****************************************************************************/
static int Open(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys = malloc(sizeof(*sys));
if (unlikely(!sys))
return VLC_ENOMEM;
/* Get the callbacks */
vlc_format_cb setup = var_InheritAddress(vd, "vmem-setup");
sys->lock = var_InheritAddress(vd, "vmem-lock");
if (sys->lock == NULL) {
msg_Err(vd, "missing lock callback");
free(sys);
return VLC_EGENERIC;
}
sys->unlock = var_InheritAddress(vd, "vmem-unlock");
sys->display = var_InheritAddress(vd, "vmem-display");
sys->cleanup = var_InheritAddress(vd, "vmem-cleanup");
sys->opaque = var_InheritAddress(vd, "vmem-data");
sys->pool = NULL;
/* Define the video format */
video_format_t fmt;
video_format_ApplyRotation(&fmt, &vd->fmt);
if (setup != NULL) {
char chroma[5];
memcpy(chroma, &fmt.i_chroma, 4);
chroma[4] = '\0';
memset(sys->pitches, 0, sizeof(sys->pitches));
memset(sys->lines, 0, sizeof(sys->lines));
sys->count = setup(&sys->opaque, chroma, &fmt.i_width, &fmt.i_height,
sys->pitches, sys->lines);
if (sys->count == 0) {
msg_Err(vd, "video format setup failure (no pictures)");
free(sys);
return VLC_EGENERIC;
}
fmt.i_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, chroma);
} else {
char *chroma = var_InheritString(vd, "vmem-chroma");
fmt.i_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, chroma);
free(chroma);
fmt.i_width = var_InheritInteger(vd, "vmem-width");
fmt.i_height = var_InheritInteger(vd, "vmem-height");
sys->pitches[0] = var_InheritInteger(vd, "vmem-pitch");
sys->lines[0] = fmt.i_height;
for (size_t i = 1; i < PICTURE_PLANE_MAX; i++)
{
sys->pitches[i] = sys->pitches[0];
sys->lines[i] = sys->lines[0];
}
sys->count = 1;
sys->cleanup = NULL;
}
fmt.i_x_offset = fmt.i_y_offset = 0;
fmt.i_visible_width = fmt.i_width;
fmt.i_visible_height = fmt.i_height;
if (!fmt.i_chroma) {
msg_Err(vd, "vmem-chroma should be 4 characters long");
free(sys);
return VLC_EGENERIC;
}
/* Define the bitmasks */
switch (fmt.i_chroma)
{
case VLC_CODEC_RGB15:
fmt.i_rmask = 0x001f;
fmt.i_gmask = 0x03e0;
fmt.i_bmask = 0x7c00;
break;
case VLC_CODEC_RGB16:
fmt.i_rmask = 0x001f;
fmt.i_gmask = 0x07e0;
fmt.i_bmask = 0xf800;
break;
case VLC_CODEC_RGB24:
case VLC_CODEC_RGB32:
fmt.i_rmask = 0xff0000;
fmt.i_gmask = 0x00ff00;
fmt.i_bmask = 0x0000ff;
break;
default:
fmt.i_rmask = 0;
fmt.i_gmask = 0;
fmt.i_bmask = 0;
break;
}
/* */
vout_display_info_t info = vd->info;
info.has_hide_mouse = true;
/* */
vd->sys = sys;
vd->fmt = fmt;
vd->info = info;
vd->pool = Pool;
vd->prepare = NULL;
vd->display = Display;
vd->control = Control;
vd->manage = NULL;
/* */
vout_display_SendEventFullscreen(vd, false);
vout_display_SendEventDisplaySize(vd, fmt.i_width, fmt.i_height, false);
return VLC_SUCCESS;
}
