/**
* Control for vout display
*/
static int Control(vout_display_t *vd, int query, va_list args)
{
VLC_UNUSED(args);
vout_display_sys_t *sys = vd->sys;
switch (query) {
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
/* We have to ignore what is requested */
vout_display_SendEventPicturesInvalid(vd);
return VLC_SUCCESS;
case VOUT_DISPLAY_RESET_PICTURES:
if (sys->pool)
picture_pool_Release(sys->pool);
sys->pool = NULL;
vd->fmt.i_width = aa_imgwidth(sys->aa_context);
vd->fmt.i_height = aa_imgheight(sys->aa_context);
return VLC_SUCCESS;
case VOUT_DISPLAY_HIDE_MOUSE:
aa_hidemouse(sys->aa_context);
return VLC_SUCCESS;
default:
msg_Err(vd, "Unsupported query in vout display aalib");
return VLC_EGENERIC;
}
}
static void Close(vlc_object_t *p_this)
{
vout_display_t *vd = (vout_display_t *)p_this;
vout_display_sys_t *sys = vd->sys;
if (!sys)
return;
if (sys->pool)
picture_pool_Release(sys->pool);
if (sys->p_window)
AndroidWindow_Destroy(sys, sys->p_window);
if (sys->p_sub_pic)
picture_Release(sys->p_sub_pic);
if (sys->p_spu_blend)
filter_DeleteBlend(sys->p_spu_blend);
free(sys->p_sub_buffer_bounds);
if (sys->p_sub_window)
AndroidWindow_Destroy(sys, sys->p_sub_window);
if (sys->p_library)
dlclose(sys->p_library);
free(sys);
}
static void Close(vlc_object_t *p_this)
{
vout_display_t *vd = (vout_display_t *)p_this;
vout_display_sys_t *sys = vd->sys;
if (!sys)
return;
/* Check if SPU regions have been properly cleared, and clear them if they
* were not. */
if (sys->b_has_subpictures)
{
SubpicturePrepare(vd, NULL);
if (sys->b_sub_pic_locked)
AndroidWindow_UnlockPicture(sys, sys->p_sub_window, sys->p_sub_pic, true);
}
if (sys->pool)
picture_pool_Release(sys->pool);
if (sys->p_window)
AndroidWindow_Destroy(vd, sys->p_window);
if (sys->p_sub_pic)
picture_Release(sys->p_sub_pic);
if (sys->p_spu_blend)
filter_DeleteBlend(sys->p_spu_blend);
free(sys->p_sub_buffer_bounds);
if (sys->p_sub_window)
AndroidWindow_Destroy(vd, sys->p_sub_window);
if (sys->p_awh)
AWindowHandler_destroy(sys->p_awh);
free(sys);
}
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:
case VOUT_DISPLAY_CHANGE_FULLSCREEN:
return VLC_SUCCESS;
case VOUT_DISPLAY_RESET_PICTURES:
{
if (sys->p_window->b_opaque)
return VLC_EGENERIC;
msg_Dbg(vd, "resetting pictures");
if (sys->pool != NULL)
{
picture_pool_Release(sys->pool);
sys->pool = NULL;
}
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
{
if (query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT
|| query == VOUT_DISPLAY_CHANGE_SOURCE_CROP) {
const video_format_t *source;
msg_Dbg(vd, "change source crop/aspect");
source = va_arg(args, const video_format_t *);
if (query == VOUT_DISPLAY_CHANGE_SOURCE_CROP) {
video_format_CopyCrop(&sys->p_window->fmt, source);
AndroidWindow_UpdateCrop(sys, sys->p_window);
} else
CopySourceAspect(&sys->p_window->fmt, source);
UpdateWindowSize(&sys->p_window->fmt, sys->p_window->b_use_priv);
} else {
const vout_display_cfg_t *cfg;
cfg = va_arg(args, const vout_display_cfg_t *);
sys->i_display_width = cfg->display.width;
sys->i_display_height = cfg->display.height;
msg_Dbg(vd, "change display size: %dx%d", sys->i_display_width,
sys->i_display_height);
}
FixSubtitleFormat(sys);
return VLC_SUCCESS;
}
default:
msg_Warn(vd, "Unknown request in android_window");
case VOUT_DISPLAY_CHANGE_ZOOM:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
return VLC_EGENERIC;
}
static void Close(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
/* Check if SPU regions have been properly cleared, and clear them if they
* were not. */
if (sys->b_has_subpictures)
{
SubpicturePrepare(vd, NULL);
AndroidWindow_UnlockPicture(sys, sys->p_sub_window, sys->p_sub_pic);
}
if (sys->pool)
picture_pool_Release(sys->pool);
if (sys->p_window)
{
if (sys->b_displayed)
ClearSurface(vd);
AndroidWindow_Destroy(vd, sys->p_window);
}
if (sys->p_sub_pic)
picture_Release(sys->p_sub_pic);
if (sys->p_spu_blend)
filter_DeleteBlend(sys->p_spu_blend);
free(sys->p_sub_buffer_bounds);
if (sys->p_sub_window)
AndroidWindow_Destroy(vd, sys->p_sub_window);
if (sys->embed)
AWindowHandler_setVideoLayout(sys->p_awh, 0, 0, 0, 0, 0, 0);
free(sys);
}
static void
Close( vlc_object_t *p_this )
{
vout_display_t *vd = (vout_display_t *)p_this;
vout_display_sys_t *sys = vd->sys;
struct event *p_event;
if (!sys)
return;
EcoreMainLoopCallSync( vd, EvasDeinitMainloopCb );
BuffersClean( vd );
fifo_deinit( &sys->buffer_fifo );
if( sys->p_pool )
picture_pool_Release(sys->p_pool);
while( ( p_event = EVENT_FIFO_POP() ) )
free( p_event );
vlc_mutex_destroy( &sys->cb_lock );
vlc_cond_destroy( &sys->cb_wait );
free( sys );
}
static int
Control( vout_display_t *vd, int i_query, va_list ap )
{
vout_display_sys_t *sys = vd->sys;
switch( i_query )
{
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
{
const video_format_t *p_source;
vout_display_place_t place;
video_format_t fmt;
msg_Dbg( vd, "VOUT_DISPLAY_CHANGE_SOURCE_ASPECT" );
p_source = va_arg( ap, const video_format_t * );
video_format_ApplyRotation( &fmt, p_source );
vout_display_PlacePicture( &place, &fmt, vd->cfg, false );
if( place.width != (unsigned) sys->i_width
&& place.height != (unsigned) sys->i_height )
{
if( vd->info.has_pictures_invalid )
{
msg_Warn( vd, "ratio changed: invalidate pictures" );
vout_display_SendEventPicturesInvalid( vd );
}
else
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_FULLSCREEN:
return VLC_SUCCESS;
case VOUT_DISPLAY_RESET_PICTURES:
msg_Dbg( vd, "VOUT_DISPLAY_RESET_PICTURES" );
EcoreMainLoopCallSync( vd, EvasResetMainloopCb );
BuffersClean( vd );
if( sys->p_pool )
{
picture_pool_Release( sys->p_pool );
sys->p_pool = NULL;
}
return VLC_SUCCESS;
case VOUT_DISPLAY_CHANGE_ZOOM:
case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
case VOUT_DISPLAY_HIDE_MOUSE:
return VLC_EGENERIC;
default:
msg_Warn( vd, "Unknown request in evas_output" );
return VLC_EGENERIC;
}
}
static void Close(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys = vd->sys;
if (sys->pool)
picture_pool_Release(sys->pool);
free(sys);
}
static void Clean(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
if (sys->sys.pool)
picture_pool_Release(sys->sys.pool);
sys->sys.pool = NULL;
if (sys->off_dc)
DeleteDC(sys->off_dc);
if (sys->off_bitmap)
DeleteObject(sys->off_bitmap);
}
static void Close(vlc_object_t *p_this)
{
vout_display_t *vd = (vout_display_t *)p_this;
vout_display_sys_t *sys = vd->sys;
if (sys) {
if (sys->pool)
picture_pool_Release(sys->pool);
if (sys->p_library)
dlclose(sys->p_library);
free(sys);
}
}
static void ResetPictures (vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
if (!sys->pool)
return;
if (sys->seg_base != 0)
for (unsigned i = 0; i < MAX_PICTURES; i++)
xcb_shm_detach (sys->conn, sys->seg_base + i);
picture_pool_Release (sys->pool);
sys->pool = NULL;
}
static void Close(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys = vd->sys;
char response[20]; /* answer is hvs_update_fields=%1d */
unsigned i;
vc_tv_unregister_callback_full(tvservice_cb, vd);
if (sys->dmx_handle)
close_dmx(vd);
if (sys->component && sys->component->control->is_enabled)
mmal_port_disable(sys->component->control);
if (sys->input && sys->input->is_enabled)
mmal_port_disable(sys->input);
if (sys->component && sys->component->is_enabled)
mmal_component_disable(sys->component);
if (sys->pool)
mmal_pool_destroy(sys->pool);
if (sys->component)
mmal_component_release(sys->component);
if (sys->picture_pool)
picture_pool_Release(sys->picture_pool);
else
for (i = 0; i < sys->num_buffers; ++i)
if (sys->pictures[i])
picture_Release(sys->pictures[i]);
vlc_mutex_destroy(&sys->buffer_mutex);
vlc_cond_destroy(&sys->buffer_cond);
vlc_mutex_destroy(&sys->manage_mutex);
if (sys->native_interlaced) {
if (vc_gencmd(response, sizeof(response), "hvs_update_fields 0") < 0 ||
response[18] != '0')
msg_Warn(vd, "Could not reset hvs field mode");
}
free(sys->pictures);
free(sys);
bcm_host_deinit();
}
static void CloseVideo(vlc_object_t *p_this)
{
vout_display_t *vd = (vout_display_t *)p_this;
vout_display_sys_t *sys = vd->sys;
if (sys->pool)
picture_pool_Release(sys->pool);
if (sys->pic_nosignal)
picture_Release(sys->pic_nosignal);
free(sys);
ReleaseDLSys(p_this);
}
static void Close(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys = vd->sys;
if (sys->cleanup)
sys->cleanup(sys->opaque);
if (sys->pool)
{
picture_pool_Enum(sys->pool, Unlock, sys);
picture_pool_Release(sys->pool);
}
free(sys);
}
/*****************************************************************************
* Close: destroy KVA video thread output method
*****************************************************************************
* Terminate an output method created by Open
*****************************************************************************/
static void Close ( vlc_object_t *object )
{
vout_display_t * vd = (vout_display_t *)object;
vout_display_sys_t * sys = vd->sys;
WinPostQueueMsg( sys->hmq, WM_QUIT, 0, 0 );
DosWaitThread( &sys->tid, DCWW_WAIT );
if( sys->pool )
picture_pool_Release( sys->pool );
DosCloseEventSem( sys->ack_event );
free( sys );
}
static int DirectXCreatePool(vout_display_t *vd,
bool *use_overlay, video_format_t *fmt)
{
vout_display_sys_t *sys = vd->sys;
/* */
*fmt = vd->source;
if (DirectXCreatePictureResource(vd, use_overlay, fmt))
return VLC_EGENERIC;
/* Create the associated picture */
picture_resource_t resource = { .p_sys = sys->picsys };
picture_t *picture = picture_NewFromResource(fmt, &resource);
if (!picture) {
DirectXDestroyPictureResource(vd);
free(sys->picsys);
return VLC_ENOMEM;
}
/* Wrap it into a picture pool */
picture_pool_configuration_t cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.picture_count = 1;
cfg.picture = &picture;
cfg.lock = DirectXLock;
cfg.unlock = DirectXUnlock;
sys->pool = picture_pool_NewExtended(&cfg);
if (!sys->pool) {
picture_Release(picture);
DirectXDestroyPictureResource(vd);
return VLC_ENOMEM;
}
return VLC_SUCCESS;
}
static void DirectXDestroyPool(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
if (sys->pool) {
DirectXDestroyPictureResource(vd);
picture_pool_Release(sys->pool);
}
sys->pool = NULL;
}
/**
* Close a libcaca video output
*/
static void Close(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys = vd->sys;
if (sys->pool)
picture_pool_Release(sys->pool);
if (sys->dither)
cucul_free_dither(sys->dither);
caca_free_display(sys->dp);
cucul_free_canvas(sys->cv);
#if defined(_WIN32)
FreeConsole();
#endif
free(sys);
}
/**
* Close a SDL video output
*/
static void Close(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys = vd->sys;
if (sys->pool)
picture_pool_Release(sys->pool);
if (sys->overlay) {
SDL_LockYUVOverlay(sys->overlay);
SDL_FreeYUVOverlay(sys->overlay);
}
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);
}
static void Close(vlc_object_t *p_this)
{
vout_display_t *vd = (vout_display_t *)p_this;
vout_display_sys_t *p_sys = vd->sys;
if (p_sys->omx_handle) {
OMX_STATETYPE state;
OMX_GetState(p_sys->omx_handle, &state);
if (state == OMX_StateExecuting) {
OMX_SendCommand(p_sys->omx_handle, OMX_CommandStateSet, OMX_StateIdle, 0);
while (1) {
OMX_U32 cmd, state;
WaitForSpecificOmxEvent(&p_sys->event_queue, OMX_EventCmdComplete, &cmd, &state, 0);
if (cmd == OMX_CommandStateSet && state == OMX_StateIdle)
break;
}
}
OMX_GetState(p_sys->omx_handle, &state);
if (state == OMX_StateIdle) {
OMX_SendCommand(p_sys->omx_handle, OMX_CommandStateSet, OMX_StateLoaded, 0);
for (unsigned int i = 0; i < p_sys->port.i_buffers; i++) {
OMX_BUFFERHEADERTYPE *p_buffer;
OMX_FIFO_GET(&p_sys->port.fifo, p_buffer);
OMX_FreeBuffer(p_sys->omx_handle, p_sys->port.i_port_index, p_buffer);
}
WaitForSpecificOmxEvent(&p_sys->event_queue, OMX_EventCmdComplete, 0, 0, 0);
}
free(p_sys->port.pp_buffers);
pf_free_handle(p_sys->omx_handle);
DeinitOmxEventQueue(&p_sys->event_queue);
OMX_FIFO_DESTROY(&p_sys->port.fifo);
}
if (p_sys->pool)
picture_pool_Release(p_sys->pool);
free(p_sys);
DeinitOmxCore();
}
/**
* This function initializes libcaca vout method.
*/
static int Open(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys;
if (vout_display_IsWindowed(vd))
return VLC_EGENERIC;
#if !defined(__APPLE__) && !defined(_WIN32)
# ifndef X_DISPLAY_MISSING
if (!vlc_xlib_init(object))
return VLC_EGENERIC;
# endif
#endif
#if defined(_WIN32)
CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
SMALL_RECT rect;
COORD coord;
HANDLE hstdout;
if (!AllocConsole()) {
msg_Err(vd, "cannot create console");
return VLC_EGENERIC;
}
hstdout =
CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
if (!hstdout || hstdout == INVALID_HANDLE_VALUE) {
msg_Err(vd, "cannot create screen buffer");
FreeConsole();
return VLC_EGENERIC;
}
if (!SetConsoleActiveScreenBuffer(hstdout)) {
msg_Err(vd, "cannot set active screen buffer");
FreeConsole();
return VLC_EGENERIC;
}
coord = GetLargestConsoleWindowSize(hstdout);
msg_Dbg(vd, "SetConsoleWindowInfo: %ix%i", coord.X, coord.Y);
/* Force size for now */
coord.X = 100;
coord.Y = 40;
if (!SetConsoleScreenBufferSize(hstdout, coord))
msg_Warn(vd, "SetConsoleScreenBufferSize %i %i",
coord.X, coord.Y);
/* Get the current screen buffer size and window position. */
if (GetConsoleScreenBufferInfo(hstdout, &csbiInfo)) {
rect.Top = 0; rect.Left = 0;
rect.Right = csbiInfo.dwMaximumWindowSize.X - 1;
rect.Bottom = csbiInfo.dwMaximumWindowSize.Y - 1;
if (!SetConsoleWindowInfo(hstdout, TRUE, &rect))
msg_Dbg(vd, "SetConsoleWindowInfo failed: %ix%i",
rect.Right, rect.Bottom);
}
#endif
/* Allocate structure */
vd->sys = sys = calloc(1, sizeof(*sys));
if (!sys)
goto error;
sys->cv = cucul_create_canvas(0, 0);
if (!sys->cv) {
msg_Err(vd, "cannot initialize libcucul");
goto error;
}
const char *driver = NULL;
#ifdef __APPLE__
// Make sure we don't try to open a window.
driver = "ncurses";
#endif
sys->dp = caca_create_display_with_driver(sys->cv, driver);
if (!sys->dp) {
msg_Err(vd, "cannot initialize libcaca");
goto error;
}
if (vd->cfg->display.title)
caca_set_display_title(sys->dp,
vd->cfg->display.title);
else
caca_set_display_title(sys->dp,
VOUT_TITLE "(Colour AsCii Art)");
/* Fix format */
video_format_t fmt = vd->fmt;
if (fmt.i_chroma != VLC_CODEC_RGB32) {
fmt.i_chroma = VLC_CODEC_RGB32;
fmt.i_rmask = 0x00ff0000;
fmt.i_gmask = 0x0000ff00;
fmt.i_bmask = 0x000000ff;
}
/* TODO */
vout_display_info_t info = vd->info;
/* Setup vout_display now that everything is fine */
vd->fmt = fmt;
vd->info = info;
vd->pool = Pool;
vd->prepare = Prepare;
vd->display = PictureDisplay;
vd->control = Control;
vd->manage = Manage;
/* Fix initial state */
vout_display_SendEventFullscreen(vd, false);
Refresh(vd);
return VLC_SUCCESS;
error:
if (sys) {
if (sys->pool)
picture_pool_Release(sys->pool);
if (sys->dither)
cucul_free_dither(sys->dither);
if (sys->dp)
caca_free_display(sys->dp);
if (sys->cv)
cucul_free_canvas(sys->cv);
free(sys);
}
#if defined(_WIN32)
FreeConsole();
#endif
return VLC_EGENERIC;
}
