#include "event.h"
+/* It must be present as long as a vout_display_t must be created using a dummy
+ * vout (as an opengl provider) */
+#define ALLOW_DUMMY_VOUT
+
static void SplitterClose(vout_display_t *vd);
/*****************************************************************************
vd->fmt.i_width == fmt->i_width &&
vd->fmt.i_height == fmt->i_height);
- return vout_display_Get(vd);
+ picture_pool_t *pool = vout_display_Pool(vd, 3);
+ if (!pool)
+ return NULL;
+ return picture_pool_Get(pool);
}
static void VideoBufferDelete(filter_t *filter, picture_t *picture)
{
static int FilterAllocationInit(filter_t *filter, void *vd)
{
- filter->pf_vout_buffer_new = VideoBufferNew;
- filter->pf_vout_buffer_del = VideoBufferDelete;
- filter->p_owner = vd;
+ filter->pf_video_buffer_new = VideoBufferNew;
+ filter->pf_video_buffer_del = VideoBufferDelete;
+ filter->p_owner = vd;
return VLC_SUCCESS;
}
static void FilterAllocationClean(filter_t *filter)
{
- filter->pf_vout_buffer_new = NULL;
- filter->pf_vout_buffer_del = NULL;
- filter->p_owner = NULL;
+ filter->pf_video_buffer_new = NULL;
+ filter->pf_video_buffer_del = NULL;
+ filter->p_owner = NULL;
}
/*****************************************************************************
/* Picture buffer does not have the concept of aspect ratio */
video_format_Copy(&vd->fmt, fmt);
- vd->fmt.i_aspect = 0;
vd->fmt.i_sar_num = 0;
vd->fmt.i_sar_den = 0;
vd->info.has_pictures_invalid = false;
vd->cfg = cfg;
- vd->get = NULL;
+ vd->pool = NULL;
vd->prepare = NULL;
vd->display = NULL;
vd->control = NULL;
if (load_module) {
vd->module = module_need(vd, "vout display", module, module && *module != '\0');
if (!vd->module) {
- vlc_object_detach(vd);
vlc_object_release(vd);
return NULL;
}
*/
static void vout_display_Delete(vout_display_t *vd)
{
- vlc_object_detach(vd);
-
if (vd->module)
module_unneed(vd, vd->module);
}
static void vout_display_Manage(vout_display_t *vd)
{
- vd->manage(vd);
+ if (vd->manage)
+ vd->manage(vd);
}
/* */
return;
/* */
- unsigned width;
- unsigned height;
unsigned display_width;
unsigned display_height;
if (cfg->is_display_filled) {
- width = source->i_visible_width;
- height = source->i_visible_height;
display_width = cfg->display.width;
display_height = cfg->display.height;
} else {
cfg_tmp.display.width = 0;
cfg_tmp.display.height = 0;
- vout_display_GetDefaultDisplaySize(&width, &height,
+ vout_display_GetDefaultDisplaySize(&display_width, &display_height,
source, &cfg_tmp);
- display_width = width;
- display_height = height;
if (do_clipping) {
display_width = __MIN(display_width, cfg->display.width);
display_height = __MIN(display_height, cfg->display.height);
}
}
+ const unsigned width = source->i_visible_width;
+ const unsigned height = source->i_visible_height;
/* Compute the height if we use the width to fill up display_width */
const int64_t scaled_height = (int64_t)height * display_width * cfg->display.sar.num * source->i_sar_den / width / source->i_sar_num / cfg->display.sar.den;
/* And the same but switching width/height */
/* */
vout_display_cfg_t cfg;
- bool is_on_top_initial;
+ unsigned wm_state_initial;
struct {
unsigned num;
unsigned den;
int den;
} zoom;
- bool ch_on_top;
- bool is_on_top;
+ bool ch_wm_state;
+ unsigned wm_state;
bool ch_sar;
struct {
int display_width;
int display_height;
bool display_is_fullscreen;
+ bool display_is_forced;
+
+#ifdef ALLOW_DUMMY_VOUT
+ vlc_mouse_t vout_mouse;
+#endif
};
+static void DummyVoutSendDisplayEventMouse(vout_thread_t *, vlc_mouse_t *fallback, const vlc_mouse_t *m);
+
static void VoutDisplayCreateRender(vout_display_t *vd)
{
vout_display_owner_sys_t *osys = vd->owner.sys;
osys->filters = NULL;
video_format_t v_src = vd->source;
- v_src.i_aspect = 0;
v_src.i_sar_num = 0;
v_src.i_sar_den = 0;
video_format_t v_dst = vd->fmt;
- v_dst.i_aspect = 0;
v_dst.i_sar_num = 0;
v_dst.i_sar_den = 0;
if (!convert)
return;
- msg_Err(vd, "A filter to adapt decoder to display is needed");
+ msg_Dbg(vd, "A filter to adapt decoder to display is needed");
osys->filters = filter_chain_New(vd, "video filter2", false,
FilterAllocationInit,
const int x = (int)va_arg(args, int);
const int y = (int)va_arg(args, int);
if (x != osys->mouse.state.i_x || y != osys->mouse.state.i_y) {
- msg_Dbg(vd, "VoutDisplayEvent 'mouse' @%d,%d", x, y);
+ //msg_Dbg(vd, "VoutDisplayEvent 'mouse' @%d,%d", x, y);
m.i_x = x;
m.i_y = y;
if (!vd->info.has_hide_mouse)
osys->mouse.last_moved = mdate();
- /* */
- vlc_mutex_unlock(&osys->lock);
-
/* */
vout_SendEventMouseVisible(osys->vout);
+#ifdef ALLOW_DUMMY_VOUT
+ DummyVoutSendDisplayEventMouse(osys->vout, &osys->vout_mouse, &m);
+#else
vout_SendDisplayEventMouse(osys->vout, &m);
+#endif
+ vlc_mutex_unlock(&osys->lock);
}
static void VoutDisplayEvent(vout_display_t *vd, int event, va_list args)
break;
}
+ case VOUT_DISPLAY_EVENT_WINDOW_STATE: {
+ const unsigned state = va_arg(args, unsigned);
+
+ msg_Dbg(vd, "VoutDisplayEvent 'window state' %u", state);
+
+ vlc_mutex_lock(&osys->lock);
+ if (state != osys->wm_state) {
+ osys->ch_wm_state = true;
+ osys->wm_state = state;
+ }
+ vlc_mutex_unlock(&osys->lock);
+ break;
+ }
+
case VOUT_DISPLAY_EVENT_DISPLAY_SIZE: {
const int width = (int)va_arg(args, int);
const int height = (int)va_arg(args, int);
osys->display_width = width;
osys->display_height = height;
osys->display_is_fullscreen = is_fullscreen;
+ osys->display_is_forced = false;
vlc_mutex_unlock(&osys->lock);
break;
vout_DeleteDisplayWindow(osys->vout, vd, window);
}
-void vout_ManageDisplay(vout_display_t *vd)
+void vout_ManageDisplay(vout_display_t *vd, bool allow_reset_pictures)
{
vout_display_owner_sys_t *osys = vd->owner.sys;
bool is_fullscreen = osys->is_fullscreen;
osys->ch_fullscreen = false;
+ bool ch_wm_state = osys->ch_wm_state;
+ unsigned wm_state = osys->wm_state;
+ osys->ch_wm_state = false;
+
bool ch_display_size = osys->ch_display_size;
int display_width = osys->display_width;
int display_height = osys->display_height;
bool display_is_fullscreen = osys->display_is_fullscreen;
+ bool display_is_forced = osys->display_is_forced;
osys->ch_display_size = false;
- bool reset_pictures = osys->reset_pictures;
- osys->reset_pictures = false;
+ bool reset_pictures;
+ if (allow_reset_pictures) {
+ reset_pictures = osys->reset_pictures;
+ osys->reset_pictures = false;
+ } else {
+ reset_pictures = false;
+ }
vlc_mutex_unlock(&osys->lock);
!reset_pictures &&
!osys->ch_display_filled &&
!osys->ch_zoom &&
- !osys->ch_on_top &&
+ !ch_wm_state &&
!osys->ch_sar &&
!osys->ch_crop)
break;
cfg.display.height = display_height;
if (!cfg.is_fullscreen != !display_is_fullscreen ||
- vout_display_Control(vd, VOUT_DISPLAY_CHANGE_DISPLAY_SIZE, &cfg)) {
+ vout_display_Control(vd, VOUT_DISPLAY_CHANGE_DISPLAY_SIZE, &cfg, display_is_forced)) {
if (!cfg.is_fullscreen == !display_is_fullscreen)
msg_Err(vd, "Failed to resize display");
const int display_width = (int64_t)vd->source.i_width * osys->zoom.num / osys->zoom.den;
const int display_height = (int64_t)vd->source.i_height * osys->zoom.num / osys->zoom.den;
- vout_display_SendEventDisplaySize(vd, display_width, display_height, osys->cfg.is_fullscreen);
+ vlc_mutex_lock(&osys->lock);
+
+ osys->ch_display_size = true;
+ osys->display_width = display_width;
+ osys->display_height = display_height;
+ osys->display_is_fullscreen = osys->cfg.is_fullscreen;
+ osys->display_is_forced = true;
+
+ vlc_mutex_unlock(&osys->lock);
}
osys->cfg.zoom.num = osys->zoom.num;
vout_SendEventZoom(osys->vout, osys->cfg.zoom.num, osys->cfg.zoom.den);
}
/* */
- if (osys->ch_on_top) {
- bool is_on_top = osys->is_on_top;
-
- if (vout_display_Control(vd, VOUT_DISPLAY_CHANGE_ON_TOP, is_on_top)) {
+ if (ch_wm_state) {
+ if (vout_display_Control(vd, VOUT_DISPLAY_CHANGE_WINDOW_STATE, wm_state)) {
msg_Err(vd, "Failed to set on top");
- is_on_top = osys->is_on_top_initial;
+ wm_state = osys->wm_state;
}
- osys->is_on_top_initial =
- osys->is_on_top = is_on_top;
- osys->ch_on_top = false;
+ osys->wm_state_initial = wm_state;
/* */
- vout_SendEventOnTop(osys->vout, osys->is_on_top_initial);
+ vout_SendEventOnTop(osys->vout, osys->wm_state_initial);
}
/* */
if (osys->ch_sar) {
{
vout_display_owner_sys_t *osys = vd->owner.sys;
- if (osys->zoom.num != num || osys->zoom.den != den) {
+ if (osys->is_display_filled ||
+ osys->zoom.num != num || osys->zoom.den != den) {
osys->ch_zoom = true;
osys->zoom.num = num;
osys->zoom.den = den;
}
}
-void vout_SetDisplayOnTop(vout_display_t *vd, bool is_on_top)
+
+void vout_SetWindowState(vout_display_t *vd, unsigned state)
{
vout_display_owner_sys_t *osys = vd->owner.sys;
- if (!osys->is_on_top != !is_on_top) {
- osys->ch_on_top = true;
- osys->is_on_top = is_on_top;
+ vlc_mutex_lock(&osys->lock);
+ if (osys->wm_state != state) {
+ osys->ch_wm_state = true;
+ osys->wm_state = state;
}
+ vlc_mutex_unlock(&osys->lock);
}
+
void vout_SetDisplayAspect(vout_display_t *vd, unsigned sar_num, unsigned sar_den)
{
vout_display_owner_sys_t *osys = vd->owner.sys;
osys->ch_crop = true;
}
}
-
+vout_opengl_t *vout_GetDisplayOpengl(vout_display_t *vd)
+{
+ vout_opengl_t *gl;
+ if (vout_display_Control(vd, VOUT_DISPLAY_GET_OPENGL, &gl))
+ return NULL;
+ return gl;
+}
static vout_display_t *DisplayNew(vout_thread_t *vout,
const video_format_t *source_org,
vout_display_cfg_t *cfg = &osys->cfg;
*cfg = state->cfg;
- osys->is_on_top_initial = state->is_on_top;;
+ osys->wm_state_initial = VOUT_WINDOW_STATE_NORMAL;
osys->sar_initial.num = state->sar.num;
osys->sar_initial.den = state->sar.den;
vout_display_GetDefaultDisplaySize(&cfg->display.width, &cfg->display.height,
osys->is_display_filled = cfg->is_display_filled;
osys->zoom.num = cfg->zoom.num;
osys->zoom.den = cfg->zoom.den;
+ osys->wm_state = state->is_on_top ? VOUT_WINDOW_STATE_ABOVE
+ : VOUT_WINDOW_STATE_NORMAL;
osys->source = *source_org;
osys->sar.num = osys->sar_initial.num ? osys->sar_initial.num : source.i_sar_num;
osys->sar.den = osys->sar_initial.den ? osys->sar_initial.den : source.i_sar_den;
+#ifdef ALLOW_DUMMY_VOUT
+ vlc_mouse_Init(&osys->vout_mouse);
+#endif
vout_display_owner_t owner;
if (owner_ptr) {
if (osys->sar.num != source_org->i_sar_num ||
osys->sar.den != source_org->i_sar_den)
osys->ch_sar = true;
- if (osys->is_on_top)
- osys->ch_on_top = true;
+ if (osys->wm_state != osys->wm_state_initial)
+ osys->ch_wm_state = true;
if (osys->crop.x != source_org->i_x_offset ||
osys->crop.y != source_org->i_y_offset ||
osys->crop.width != source_org->i_visible_width ||
if (state) {
if (!osys->is_wrapper )
state->cfg = osys->cfg;
- state->is_on_top = osys->is_on_top_initial;
+ state->is_on_top = (osys->wm_state & VOUT_WINDOW_STATE_ABOVE) != 0;
state->sar.num = osys->sar_initial.num;
state->sar.den = osys->sar_initial.den;
}
double_click_timeout, hide_timeout, NULL);
}
-static void SplitterClose(vout_display_t *vd)
-{
- VLC_UNUSED(vd);
- assert(0);
-}
-
-#if 0
/*****************************************************************************
*
*****************************************************************************/
struct vout_display_sys_t {
+ picture_pool_t *pool;
video_splitter_t *splitter;
/* */
}
static void SplitterEvent(vout_display_t *vd, int event, va_list args)
{
- vout_display_owner_sys_t *osys = vd->owner.sys;
+ //vout_display_owner_sys_t *osys = vd->owner.sys;
switch (event) {
#if 0
}
}
-static picture_t *SplitterGet(vout_display_t *vd)
+static picture_pool_t *SplitterPool(vout_display_t *vd, unsigned count)
{
- /* TODO pool ? */
- return picture_NewFromFormat(&vd->fmt);
+ vout_display_sys_t *sys = vd->sys;
+ if (!sys->pool)
+ sys->pool = picture_pool_NewFromFormat(&vd->fmt, count);
+ return sys->pool;
}
static void SplitterPrepare(vout_display_t *vd, picture_t *picture)
{
}
for (int i = 0; i < sys->count; i++) {
- /* */
- /* FIXME now vout_FilterDisplay already return a direct buffer FIXME */
- sys->picture[i] = vout_FilterDisplay(sys->display[i], sys->picture[i]);
- if (!sys->picture[i])
- continue;
-
- /* */
- picture_t *direct = vout_display_Get(sys->display[i]);
- if (!direct) {
- msg_Err(vd, "Failed to get a direct buffer");
- picture_Release(sys->picture[i]);
- sys->picture[i] = NULL;
- continue;
- }
-
- /* FIXME not always needed (easy when there is a osys->filters) */
- picture_Copy(direct, sys->picture[i]);
- picture_Release(sys->picture[i]);
- sys->picture[i] = direct;
-
- vout_display_Prepare(sys->display[i], sys->picture[i]);
+ if (vout_IsDisplayFiltered(sys->display[i]))
+ sys->picture[i] = vout_FilterDisplay(sys->display[i], sys->picture[i]);
+ if (sys->picture[i])
+ vout_display_Prepare(sys->display[i], sys->picture[i]);
}
}
static void SplitterDisplay(vout_display_t *vd, picture_t *picture)
vout_display_sys_t *sys = vd->sys;
for (int i = 0; i < sys->count; i++)
- vout_ManageDisplay(sys->display[i]);
+ vout_ManageDisplay(sys->display[i], true);
}
static int SplitterPictureNew(video_splitter_t *splitter, picture_t *picture[])
vout_display_sys_t *wsys = splitter->p_owner->wrapper->sys;
for (int i = 0; i < wsys->count; i++) {
- /* TODO pool ? */
- picture[i] = picture_NewFromFormat(&wsys->display[i]->source);
+ if (vout_IsDisplayFiltered(wsys->display[i])) {
+ /* TODO use a pool ? */
+ picture[i] = picture_NewFromFormat(&wsys->display[i]->source);
+ } else {
+ picture_pool_t *pool = vout_display_Pool(wsys->display[i], 1);
+ picture[i] = pool ? picture_pool_Get(pool) : NULL;
+ }
if (!picture[i]) {
for (int j = 0; j < i; j++)
picture_Release(picture[j]);
free(splitter->p_owner);
video_splitter_Delete(splitter);
+ if (sys->pool)
+ picture_pool_Delete(sys->pool);
+
/* */
for (int i = 0; i < sys->count; i++)
vout_DeleteDisplay(sys->display[i], NULL);
if (!sys->picture )
abort();
sys->splitter = splitter;
+ sys->pool = NULL;
- wrapper->get = SplitterGet;
+ wrapper->pool = SplitterPool;
wrapper->prepare = SplitterPrepare;
wrapper->display = SplitterDisplay;
wrapper->control = SplitterControl;
return wrapper;
}
-#endif
/*****************************************************************************
* TODO move out
#include "vout_internal.h"
void vout_SendDisplayEventMouse(vout_thread_t *vout, const vlc_mouse_t *m)
{
+ vlc_mouse_t tmp;
+
+ /* The check on p_spu is needed as long as ALLOW_DUMMY_VOUT is defined */
+ if (vout->p->p_spu && spu_ProcessMouse( vout->p->p_spu, m, &vout->p->display.vd->source))
+ return;
+
+ vlc_mutex_lock( &vout->p->vfilter_lock );
+ if (vout->p->p_vf2_chain) {
+ if (!filter_chain_MouseFilter(vout->p->p_vf2_chain, &tmp, m))
+ m = &tmp;
+ }
+ vlc_mutex_unlock( &vout->p->vfilter_lock );
+
if (vlc_mouse_HasMoved(&vout->p->mouse, m)) {
vout_SendEventMouseMoved(vout, m->i_x, m->i_y);
}
vout_SendEventMouseDoubleClick(vout);
vout->p->mouse = *m;
}
+#ifdef ALLOW_DUMMY_VOUT
+static void DummyVoutSendDisplayEventMouse(vout_thread_t *vout, vlc_mouse_t *fallback, const vlc_mouse_t *m)
+{
+ vout_thread_sys_t p;
+
+ if (!vout->p) {
+ p.mouse = *fallback;
+ vlc_mutex_init(&p.vfilter_lock);
+ p.p_vf2_chain = NULL;
+ p.p_spu = NULL;
+ vout->p = &p;
+ }
+ vout_SendDisplayEventMouse(vout, m);
+ if (vout->p == &p) {
+ vlc_mutex_destroy(&p.vfilter_lock);
+ *fallback = p.mouse;
+ vout->p = NULL;
+ }
+}
+#endif
vout_window_t * vout_NewDisplayWindow(vout_thread_t *vout, vout_display_t *vd, const vout_window_cfg_t *cfg)
{
VLC_UNUSED(vd);
vout_window_cfg_t cfg_override = *cfg;
- if( !config_GetInt( vout, "embedded-video" ) )
+ if( !var_InheritBool( vout, "embedded-video" ) )
cfg_override.is_standalone = true;
return vout_window_New(VLC_OBJECT(vout), NULL, &cfg_override);
projects / vlc / blobdiff