/**
* Attaches a window to a display. Window events will be dispatched to the
* display until they are detached.
*/
void vout_display_window_Attach(vout_window_t *window, vout_display_t *vd)
{
vout_display_window_t *state = window->owner.sys;
vout_window_SetSize(window,
vd->cfg->display.width, vd->cfg->display.height);
vlc_mutex_lock(&state->lock);
state->vd = vd;
vout_display_SendEventDisplaySize(vd, state->width, state->height);
vlc_mutex_unlock(&state->lock);
}
int CommonControl(vout_display_t *vd, int query, va_list args)
{
vout_display_sys_t *sys = vd->sys;
switch (query) {
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE: /* const vout_display_cfg_t *p_cfg, int is_forced */
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED: /* const vout_display_cfg_t *p_cfg */
case VOUT_DISPLAY_CHANGE_ZOOM: /* const vout_display_cfg_t *p_cfg */
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT: /* const video_format_t *p_source */
case VOUT_DISPLAY_CHANGE_SOURCE_CROP: { /* const video_format_t *p_source */
const vout_display_cfg_t *cfg;
const video_format_t *source;
bool is_forced = true;
if (query == VOUT_DISPLAY_CHANGE_SOURCE_CROP ||
query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT) {
cfg = vd->cfg;
source = va_arg(args, const video_format_t *);
} else {
cfg = va_arg(args, const vout_display_cfg_t *);
source = &vd->source;
if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE)
is_forced = va_arg(args, int);
}
if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE && is_forced) {
/* Update dimensions */
if (sys->parent_window) {
vout_window_SetSize(sys->parent_window, cfg->display.width, cfg->display.height);
} else {
RECT rect_window;
rect_window.top = 0;
rect_window.left = 0;
rect_window.right = cfg->display.width;
rect_window.bottom = cfg->display.height;
AdjustWindowRect(&rect_window, EventThreadGetWindowStyle(sys->event), 0);
SetWindowPos(sys->hwnd, 0, 0, 0,
rect_window.right - rect_window.left,
rect_window.bottom - rect_window.top, SWP_NOMOVE);
}
return VLC_EGENERIC;
}
UpdateRects(vd, cfg, source, is_forced);
return VLC_SUCCESS;
}
/* Internal wrapper to call vout_ControlWindow for hparent */
static int vaControlParentWindow( vout_thread_t *p_vout, int i_query,
va_list args )
{
switch( i_query )
{
case VOUT_SET_SIZE:
{
const unsigned i_width = va_arg(args, unsigned);
const unsigned i_height = va_arg(args, unsigned);
return vout_window_SetSize( p_vout->p_sys->parent_window, i_width, i_height );
}
case VOUT_SET_STAY_ON_TOP:
{
const bool is_on_top = va_arg(args, int);
return vout_window_SetOnTop( p_vout->p_sys->parent_window, is_on_top );
}
default:
return VLC_EGENERIC;
}
}
/*****************************************************************************
* Control: control facility for the vout
*****************************************************************************/
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:
{
POINTL ptl;
WinQueryPointerPos( HWND_DESKTOP, &ptl );
if( WinWindowFromPoint( HWND_DESKTOP, &ptl, TRUE ) == sys->client )
{
WinShowPointer( HWND_DESKTOP, FALSE );
sys->is_mouse_hidden = true;
}
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_FULLSCREEN:
{
vout_display_cfg_t cfg = *va_arg(args, const vout_display_cfg_t *);
if( sys->parent_window )
vout_window_SetFullScreen(sys->parent_window, cfg.is_fullscreen);
else
WinPostMsg( sys->client, WM_VLC_FULLSCREEN_CHANGE,
MPFROMLONG( cfg.is_fullscreen ), 0 );
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
{
const vout_display_cfg_t *cfg = va_arg(args, const vout_display_cfg_t *);
bool is_forced = va_arg(args, int);
if( is_forced )
{
if( sys->parent_window )
{
vout_window_SetSize(sys->parent_window,
cfg->display.width, cfg->display.height);
/* Workaround :
* If changing aspect ratio after resizing a main window,
* an embedded window is misplaced. So reposition it, here.
*/
WinSetWindowPos( WinQueryWindow( sys->parent, QW_PARENT ),
HWND_TOP, 0, 1, 0, 0, SWP_MOVE );
WinSetWindowPos( WinQueryWindow( sys->parent, QW_PARENT ),
HWND_TOP, 0, 0, 0, 0, SWP_MOVE );
}
else
WinPostMsg( sys->client, WM_VLC_SIZE_CHANGE,
MPFROMLONG( cfg->display.width ),
MPFROMLONG( cfg->display.height ));
}
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
{
const video_format_t *source = va_arg(args, const video_format_t *);
if( query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT )
{
sys->kvas.ulAspectWidth = ( int64_t )source->i_width *
source->i_sar_num / source->i_sar_den;
sys->kvas.ulAspectHeight = source->i_height;
}
else
{
sys->kvas.rclSrcRect.xLeft = source->i_x_offset;
sys->kvas.rclSrcRect.yTop = source->i_y_offset;
sys->kvas.rclSrcRect.xRight = source->i_x_offset +
source->i_visible_width;
sys->kvas.rclSrcRect.yBottom = source->i_y_offset +
source->i_visible_height;
}
kvaSetup( &sys->kvas );
return VLC_SUCCESS;
}
case VOUT_DISPLAY_RESET_PICTURES:
case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
case VOUT_DISPLAY_CHANGE_ZOOM:
case VOUT_DISPLAY_GET_OPENGL:
/* TODO */
break;
}
msg_Err(vd, "Unsupported query(=%d) in vout display KVA", query);
return VLC_EGENERIC;
}
static int Control (vout_display_t *vd, int query, va_list ap)
{
vout_display_sys_t *sys = vd->sys;
switch (query)
{
case VOUT_DISPLAY_CHANGE_FULLSCREEN:
{
const vout_display_cfg_t *c = va_arg (ap, const vout_display_cfg_t *);
return vout_window_SetFullScreen (sys->embed, c->is_fullscreen);
}
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
{
const vout_display_cfg_t *p_cfg =
(const vout_display_cfg_t*)va_arg (ap, const vout_display_cfg_t *);
const bool is_forced = (bool)va_arg (ap, int);
if (is_forced)
{ /* Changing the dimensions of the parent window takes place
* asynchronously (in the X server). Also it might fail or result
* in different dimensions than requested. Request the size change
* and return a failure since the size is not (yet) changed.
* If the change eventually succeeds, HandleParentStructure()
* will trigger a non-forced display size change later. */
vout_window_SetSize (sys->embed, p_cfg->display.width,
p_cfg->display.height);
return VLC_EGENERIC;
}
vout_display_place_t place;
vout_display_PlacePicture (&place, &vd->source, p_cfg, false);
if (place.width != vd->fmt.i_visible_width ||
place.height != vd->fmt.i_visible_height)
{
vout_display_SendEventPicturesInvalid (vd);
return VLC_SUCCESS;
}
/* Move the picture within the window */
const uint32_t values[] = { place.x, place.y };
xcb_configure_window (sys->conn, sys->window,
XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y,
values);
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
{
unsigned state = va_arg (ap, unsigned);
return vout_window_SetState (sys->embed, state);
}
case VOUT_DISPLAY_CHANGE_ZOOM:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
/* I am not sure it is always necessary, but it is way simpler ... */
vout_display_SendEventPicturesInvalid (vd);
return VLC_SUCCESS;
case VOUT_DISPLAY_RESET_PICTURES:
{
ResetPictures (vd);
vout_display_place_t place;
vout_display_PlacePicture (&place, &vd->source, vd->cfg, false);
vd->fmt.i_width = vd->source.i_width * place.width / vd->source.i_visible_width;
vd->fmt.i_height = vd->source.i_height * place.height / vd->source.i_visible_height;
vd->fmt.i_visible_width = place.width;
vd->fmt.i_visible_height = place.height;
vd->fmt.i_x_offset = vd->source.i_x_offset * place.width / vd->source.i_visible_width;
vd->fmt.i_y_offset = vd->source.i_y_offset * place.height / vd->source.i_visible_height;
return VLC_SUCCESS;
}
/* Hide the mouse. It will be send when
* vout_display_t::info.b_hide_mouse is false */
case VOUT_DISPLAY_HIDE_MOUSE:
xcb_change_window_attributes (sys->conn, sys->embed->handle.xid,
XCB_CW_CURSOR, &(uint32_t){ sys->cursor });
xcb_flush (sys->conn);
return VLC_SUCCESS;
default:
msg_Err (vd, "Unknown request in XCB vout display");
return VLC_EGENERIC;
}
}
static int Control (vout_display_t *vd, int query, va_list ap)
{
vout_display_sys_t *sys = vd->sys;
switch (query)
{
case VOUT_DISPLAY_HIDE_MOUSE: /* FIXME TODO */
break;
#ifndef NDEBUG
case VOUT_DISPLAY_RESET_PICTURES: // not needed
assert(0);
#endif
case VOUT_DISPLAY_CHANGE_FULLSCREEN:
{
const vout_display_cfg_t *cfg =
va_arg (ap, const vout_display_cfg_t *);
return vout_window_SetFullScreen (sys->window, cfg->is_fullscreen);
}
case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
{
unsigned state = va_arg (ap, unsigned);
return vout_window_SetState (sys->window, state);
}
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
case VOUT_DISPLAY_CHANGE_ZOOM:
{
const vout_display_cfg_t *cfg = va_arg (ap, const vout_display_cfg_t *);
const video_format_t *src = &vd->source;
if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE)
{
bool force = false;
force = va_arg (ap, int);
if (force
&& (cfg->display.width != vd->cfg->display.width
|| cfg->display.height != vd->cfg->display.height)
&& vout_window_SetSize (sys->window,
cfg->display.width, cfg->display.height))
return VLC_EGENERIC;
}
vout_display_place_t place;
vout_display_PlacePicture (&place, src, cfg, false);
glViewport (0, 0, place.width, place.height);
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
{
const vout_display_cfg_t *cfg = vd->cfg;
const video_format_t *src = va_arg (ap, const video_format_t *);
vout_display_place_t place;
vout_display_PlacePicture (&place, src, cfg, false);
glViewport (0, 0, place.width, place.height);
return VLC_SUCCESS;
}
case VOUT_DISPLAY_GET_OPENGL:
{
vlc_gl_t **pgl = va_arg (ap, vlc_gl_t **);
*pgl = sys->gl;
return VLC_SUCCESS;
}
default:
msg_Err (vd, "Unknown request %d", query);
}
static int Control (vout_display_t *vd, int query, va_list ap)
{
vout_display_sys_t *p_sys = vd->sys;
switch (query)
{
case VOUT_DISPLAY_CHANGE_FULLSCREEN:
{
const vout_display_cfg_t *c = va_arg (ap, const vout_display_cfg_t *);
return vout_window_SetFullScreen (p_sys->embed, c->is_fullscreen);
}
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
{
const vout_display_cfg_t *p_cfg =
(const vout_display_cfg_t*)va_arg (ap, const vout_display_cfg_t *);
const bool is_forced = (bool)va_arg (ap, int);
if (is_forced
&& vout_window_SetSize (p_sys->embed,
p_cfg->display.width,
p_cfg->display.height))
return VLC_EGENERIC;
vout_display_place_t place;
vout_display_PlacePicture (&place, &vd->source, p_cfg, false);
if (place.width != vd->fmt.i_visible_width ||
place.height != vd->fmt.i_visible_height)
{
vout_display_SendEventPicturesInvalid (vd);
return VLC_SUCCESS;
}
/* Move the picture within the window */
const uint32_t values[] = { place.x, place.y };
xcb_configure_window (p_sys->conn, p_sys->window,
XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y,
values);
return VLC_SUCCESS;
}
case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
{
unsigned state = va_arg (ap, unsigned);
return vout_window_SetState (p_sys->embed, state);
}
case VOUT_DISPLAY_CHANGE_ZOOM:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
/* I am not sure it is always necessary, but it is way simpler ... */
vout_display_SendEventPicturesInvalid (vd);
return VLC_SUCCESS;
case VOUT_DISPLAY_RESET_PICTURES:
{
ResetPictures (vd);
vout_display_place_t place;
vout_display_PlacePicture (&place, &vd->source, vd->cfg, false);
vd->fmt.i_width = vd->source.i_width * place.width / vd->source.i_visible_width;
vd->fmt.i_height = vd->source.i_height * place.height / vd->source.i_visible_height;
vd->fmt.i_visible_width = place.width;
vd->fmt.i_visible_height = place.height;
vd->fmt.i_x_offset = vd->source.i_x_offset * place.width / vd->source.i_visible_width;
vd->fmt.i_y_offset = vd->source.i_y_offset * place.height / vd->source.i_visible_height;
return VLC_SUCCESS;
}
/* Hide the mouse. It will be send when
* vout_display_t::info.b_hide_mouse is false */
case VOUT_DISPLAY_HIDE_MOUSE:
xcb_change_window_attributes (p_sys->conn, p_sys->embed->handle.xid,
XCB_CW_CURSOR, &(uint32_t){ p_sys->cursor });
xcb_flush (p_sys->conn);
return VLC_SUCCESS;
default:
msg_Err (vd, "Unknown request in XCB vout display");
return VLC_EGENERIC;
}
}
