git.sesse.net Git - vlc/blob - src/video_output/display.c

   1 /*****************************************************************************
   2  * display.c: "vout display" managment
   3  *****************************************************************************
   4  * Copyright (C) 2009 Laurent Aimar
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30 #include <assert.h>
  31
  32 #include <vlc_common.h>
  33 #include <vlc_video_splitter.h>
  34 #include <vlc_vout_display.h>
  35 #include <vlc_vout.h>
  36
  37 #include <libvlc.h>
  38
  39 #include "display.h"
  40
  41 #include "event.h"
  42
  43 static void SplitterClose(vout_display_t *vd);
  44
  45 /*****************************************************************************
  46  * FIXME/TODO see how to have direct rendering here (interact with vout.c)
  47  *****************************************************************************/
  48 static picture_t *VideoBufferNew(filter_t *filter)
  49 {
  50     vout_display_t *vd = (vout_display_t*)filter->p_owner;
  51     const video_format_t *fmt = &filter->fmt_out.video;
  52
  53     assert(vd->fmt.i_chroma == fmt->i_chroma &&
  54            vd->fmt.i_width  == fmt->i_width  &&
  55            vd->fmt.i_height == fmt->i_height);
  56
  57     return vout_display_Get(vd);
  58 }
  59 static void VideoBufferDelete(filter_t *filter, picture_t *picture)
  60 {
  61     VLC_UNUSED(filter);
  62     picture_Release(picture);
  63 }
  64
  65 static int  FilterAllocationInit(filter_t *filter, void *vd)
  66 {
  67     filter->pf_vout_buffer_new = VideoBufferNew;
  68     filter->pf_vout_buffer_del = VideoBufferDelete;
  69     filter->p_owner            = vd;
  70
  71     return VLC_SUCCESS;
  72 }
  73 static void FilterAllocationClean(filter_t *filter)
  74 {
  75     filter->pf_vout_buffer_new = NULL;
  76     filter->pf_vout_buffer_del = NULL;
  77     filter->p_owner            = NULL;
  78 }
  79
  80 /*****************************************************************************
  81  *
  82  *****************************************************************************/
  83
  84 /**
  85  * It creates a new vout_display_t using the given configuration.
  86  */
  87 static vout_display_t *vout_display_New(vlc_object_t *obj,
  88                                         const char *module, bool load_module,
  89                                         const video_format_t *fmt,
  90                                         const vout_display_cfg_t *cfg,
  91                                         vout_display_owner_t *owner)
  92 {
  93     /* */
  94     vout_display_t *vd = vlc_object_create(obj, sizeof(*vd));
  95
  96     /* */
  97     video_format_Copy(&vd->source, fmt);
  98
  99     /* Picture buffer does not have the concept of aspect ratio */
 100     video_format_Copy(&vd->fmt, fmt);
 101     vd->fmt.i_aspect = 0;
 102     vd->fmt.i_sar_num = 0;
 103     vd->fmt.i_sar_den = 0;
 104
 105     vd->info.is_slow = false;
 106     vd->info.has_double_click = false;
 107     vd->info.has_hide_mouse = false;
 108     vd->info.has_pictures_invalid = false;
 109
 110     vd->cfg = cfg;
 111     vd->get = NULL;
 112     vd->prepare = NULL;
 113     vd->display = NULL;
 114     vd->control = NULL;
 115     vd->manage = NULL;
 116     vd->sys = NULL;
 117
 118     vd->owner = *owner;
 119
 120     vlc_object_attach(vd, obj);
 121
 122     if (load_module) {
 123         vd->module = module_need(vd, "vout display", module, module && *module != '\0');
 124         if (!vd->module) {
 125             vlc_object_detach(vd);
 126             vlc_object_release(vd);
 127             return NULL;
 128         }
 129     } else {
 130         vd->module = NULL;
 131     }
 132     return vd;
 133 }
 134
 135 /**
 136  * It deletes a vout_display_t
 137  */
 138 static void vout_display_Delete(vout_display_t *vd)
 139 {
 140     vlc_object_detach(vd);
 141
 142     if (vd->module)
 143         module_unneed(vd, vd->module);
 144
 145     vlc_object_release(vd);
 146 }
 147
 148 /**
 149  * It controls a vout_display_t
 150  */
 151 static int vout_display_Control(vout_display_t *vd, int query, ...)
 152 {
 153     va_list args;
 154     int result;
 155
 156     va_start(args, query);
 157     result = vd->control(vd, query, args);
 158     va_end(args);
 159
 160     return result;
 161 }
 162 static void vout_display_Manage(vout_display_t *vd)
 163 {
 164     vd->manage(vd);
 165 }
 166
 167 /* */
 168 void vout_display_GetDefaultDisplaySize(unsigned *width, unsigned *height,
 169                                         const video_format_t *source,
 170                                         const vout_display_cfg_t *cfg)
 171 {
 172     if (cfg->display.width > 0 && cfg->display.height > 0) {
 173         *width  = cfg->display.width;
 174         *height = cfg->display.height;
 175     } else if (cfg->display.width > 0) {
 176         *width  = cfg->display.width;
 177         *height = (int64_t)source->i_visible_height * source->i_sar_den * cfg->display.width * cfg->display.sar.num /
 178             source->i_visible_width / source->i_sar_num / cfg->display.sar.den;
 179     } else if (cfg->display.height > 0) {
 180         *width  = (int64_t)source->i_visible_width * source->i_sar_num * cfg->display.height * cfg->display.sar.den /
 181             source->i_visible_height / source->i_sar_den / cfg->display.sar.num;
 182         *height = cfg->display.height;
 183     } else if (source->i_sar_num >= source->i_sar_den) {
 184         *width  = (int64_t)source->i_visible_width * source->i_sar_num * cfg->display.sar.den / source->i_sar_den / cfg->display.sar.num;
 185         *height = source->i_visible_height;
 186     } else {
 187         *width  = source->i_visible_width;
 188         *height = (int64_t)source->i_visible_height * source->i_sar_den * cfg->display.sar.num / source->i_sar_num / cfg->display.sar.den;
 189     }
 190
 191     *width  = *width  * cfg->zoom.num / cfg->zoom.den;
 192     *height = *height * cfg->zoom.num / cfg->zoom.den;
 193 }
 194
 195 /* */
 196 void vout_display_PlacePicture(vout_display_place_t *place,
 197                                const video_format_t *source,
 198                                const vout_display_cfg_t *cfg,
 199                                bool do_clipping)
 200 {
 201     /* */
 202     memset(place, 0, sizeof(*place));
 203     if (cfg->display.width <= 0 || cfg->display.height <= 0)
 204         return;
 205
 206     /* */
 207     unsigned width;
 208     unsigned height;
 209     unsigned display_width;
 210     unsigned display_height;
 211
 212     if (cfg->is_display_filled) {
 213         width  = source->i_visible_width;
 214         height = source->i_visible_height;
 215         display_width  = cfg->display.width;
 216         display_height = cfg->display.height;
 217     } else {
 218         vout_display_cfg_t cfg_tmp = *cfg;
 219
 220         cfg_tmp.display.width  = 0;
 221         cfg_tmp.display.height = 0;
 222         vout_display_GetDefaultDisplaySize(&width, &height,
 223                                            source, &cfg_tmp);
 224
 225         display_width  = width;
 226         display_height = height;
 227         if (do_clipping) {
 228             display_width  = __MIN(display_width,  cfg->display.width);
 229             display_height = __MIN(display_height, cfg->display.height);
 230         }
 231     }
 232
 233     /* Compute the height if we use the width to fill up display_width */
 234     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;
 235     /* And the same but switching width/height */
 236     const int64_t scaled_width  = (int64_t)width  * display_height * cfg->display.sar.den * source->i_sar_num / height / source->i_sar_den / cfg->display.sar.num;
 237
 238     /* We keep the solution that avoid filling outside the display */
 239     if (scaled_width <= cfg->display.width) {
 240         place->width  = scaled_width;
 241         place->height = display_height;
 242     } else {
 243         place->width  = display_width;
 244         place->height = scaled_height;
 245     }
 246
 247     /*  Compute position */
 248     switch (cfg->align.horizontal) {
 249     case VOUT_DISPLAY_ALIGN_LEFT:
 250         place->x = 0;
 251         break;
 252     case VOUT_DISPLAY_ALIGN_RIGHT:
 253         place->x = cfg->display.width - place->width;
 254         break;
 255     default:
 256         place->x = (cfg->display.width - place->width) / 2;
 257         break;
 258     }
 259
 260     switch (cfg->align.vertical) {
 261     case VOUT_DISPLAY_ALIGN_TOP:
 262         place->y = 0;
 263         break;
 264     case VOUT_DISPLAY_ALIGN_BOTTOM:
 265         place->y = cfg->display.height - place->height;
 266         break;
 267     default:
 268         place->y = (cfg->display.height - place->height) / 2;
 269         break;
 270     }
 271 }
 272
 273 struct vout_display_owner_sys_t {
 274     vout_thread_t   *vout;
 275     bool            is_wrapper;  /* Is the current display a wrapper */
 276     vout_display_t  *wrapper; /* Vout display wrapper */
 277
 278     /* */
 279     vout_display_cfg_t cfg;
 280     bool     is_on_top_initial;
 281     struct {
 282         unsigned num;
 283         unsigned den;
 284     } sar_initial;
 285
 286     /* */
 287     int  width_saved;
 288     int  height_saved;
 289
 290     struct {
 291         unsigned num;
 292         unsigned den;
 293     } crop_saved;
 294
 295     /* */
 296     bool ch_display_filled;
 297     bool is_display_filled;
 298
 299     bool ch_zoom;
 300     struct {
 301         int  num;
 302         int  den;
 303     } zoom;
 304
 305     bool ch_on_top;
 306     bool is_on_top;
 307
 308     bool ch_sar;
 309     struct {
 310         unsigned num;
 311         unsigned den;
 312     } sar;
 313
 314     bool ch_crop;
 315     struct {
 316         unsigned x;
 317         unsigned y;
 318         unsigned width;
 319         unsigned height;
 320         unsigned num;
 321         unsigned den;
 322     } crop;
 323
 324     /* */
 325     video_format_t source;
 326     filter_chain_t *filters;
 327
 328     /* Lock protecting the variables used by
 329      * VoutDisplayEvent(ie vout_display_SendEvent) */
 330     vlc_mutex_t lock;
 331
 332     /* mouse state */
 333     struct {
 334         vlc_mouse_t state;
 335
 336         mtime_t last_pressed;
 337         mtime_t last_moved;
 338         bool    is_hidden;
 339         bool    ch_activity;
 340
 341         /* */
 342         mtime_t double_click_timeout;
 343         mtime_t hide_timeout;
 344     } mouse;
 345
 346     bool reset_pictures;
 347
 348     bool ch_fullscreen;
 349     bool is_fullscreen;
 350
 351     bool ch_display_size;
 352     int  display_width;
 353     int  display_height;
 354     bool display_is_fullscreen;
 355 };
 356
 357 static void VoutDisplayCreateRender(vout_display_t *vd)
 358 {
 359     vout_display_owner_sys_t *osys = vd->owner.sys;
 360
 361     osys->filters = NULL;
 362
 363     video_format_t v_src = vd->source;
 364     v_src.i_aspect  = 0;
 365     v_src.i_sar_num = 0;
 366     v_src.i_sar_den = 0;
 367
 368     video_format_t v_dst = vd->fmt;
 369     v_dst.i_aspect  = 0;
 370     v_dst.i_sar_num = 0;
 371     v_dst.i_sar_den = 0;
 372
 373     video_format_t v_dst_cmp = v_dst;
 374     if ((v_src.i_chroma == VLC_CODEC_J420 && v_dst.i_chroma == VLC_CODEC_I420) ||
 375         (v_src.i_chroma == VLC_CODEC_J422 && v_dst.i_chroma == VLC_CODEC_I422) ||
 376         (v_src.i_chroma == VLC_CODEC_J440 && v_dst.i_chroma == VLC_CODEC_I440) ||
 377         (v_src.i_chroma == VLC_CODEC_J444 && v_dst.i_chroma == VLC_CODEC_I444))
 378         v_dst_cmp.i_chroma = v_src.i_chroma;
 379
 380     const bool convert = memcmp(&v_src, &v_dst_cmp, sizeof(v_src)) != 0;
 381     if (!convert)
 382         return;
 383
 384     msg_Err(vd, "A filter to adapt decoder to display is needed");
 385
 386     osys->filters = filter_chain_New(vd, "video filter2", false,
 387                                      FilterAllocationInit,
 388                                      FilterAllocationClean, vd);
 389     assert(osys->filters); /* TODO critical */
 390
 391     /* */
 392     es_format_t src;
 393     es_format_InitFromVideo(&src, &v_src);
 394
 395     /* */
 396     es_format_t dst;
 397
 398     filter_t *filter;
 399     for (int i = 0; i < 1 + (v_dst_cmp.i_chroma != v_dst.i_chroma); i++) {
 400
 401         es_format_InitFromVideo(&dst, i == 0 ? &v_dst : &v_dst_cmp);
 402
 403         filter_chain_Reset(osys->filters, &src, &dst);
 404         filter = filter_chain_AppendFilter(osys->filters,
 405                                            NULL, NULL, &src, &dst);
 406         if (filter)
 407             break;
 408     }
 409     if (!filter)
 410     {
 411         msg_Err(vd, "VoutDisplayCreateRender FAILED");
 412         /* TODO */
 413         assert(0);
 414     }
 415 }
 416
 417 static void VoutDisplayDestroyRender(vout_display_t *vd)
 418 {
 419     vout_display_owner_sys_t *osys = vd->owner.sys;
 420
 421     if (osys->filters)
 422         filter_chain_Delete(osys->filters);
 423 }
 424
 425 static void VoutDisplayResetRender(vout_display_t *vd)
 426 {
 427     VoutDisplayDestroyRender(vd);
 428     VoutDisplayCreateRender(vd);
 429 }
 430 static void VoutDisplayEventMouse(vout_display_t *vd, int event, va_list args)
 431 {
 432     vout_display_owner_sys_t *osys = vd->owner.sys;
 433
 434     vlc_mutex_lock(&osys->lock);
 435
 436     /* */
 437     vlc_mouse_t m = osys->mouse.state;
 438     bool is_ignored = false;
 439
 440     switch (event) {
 441     case VOUT_DISPLAY_EVENT_MOUSE_STATE: {
 442         const int x = (int)va_arg(args, int);
 443         const int y = (int)va_arg(args, int);
 444         const int button_mask = (int)va_arg(args, int);
 445
 446         vlc_mouse_Init(&m);
 447         m.i_x = x;
 448         m.i_y = y;
 449         m.i_pressed = button_mask;
 450         break;
 451     }
 452     case VOUT_DISPLAY_EVENT_MOUSE_MOVED: {
 453         const int x = (int)va_arg(args, int);
 454         const int y = (int)va_arg(args, int);
 455         if (x != osys->mouse.state.i_x || y != osys->mouse.state.i_y) {
 456             msg_Dbg(vd, "VoutDisplayEvent 'mouse' @%d,%d", x, y);
 457
 458             m.i_x = x;
 459             m.i_y = y;
 460             m.b_double_click = false;
 461         } else {
 462             is_ignored = true;
 463         }
 464         break;
 465     }
 466     case VOUT_DISPLAY_EVENT_MOUSE_PRESSED:
 467     case VOUT_DISPLAY_EVENT_MOUSE_RELEASED: {
 468         const int button = (int)va_arg(args, int);
 469         const int button_mask = 1 << button;
 470
 471         /* Ignore inconsistent event */
 472         if ((event == VOUT_DISPLAY_EVENT_MOUSE_PRESSED  &&  (osys->mouse.state.i_pressed & button_mask)) ||
 473             (event == VOUT_DISPLAY_EVENT_MOUSE_RELEASED && !(osys->mouse.state.i_pressed & button_mask))) {
 474             is_ignored = true;
 475             break;
 476         }
 477
 478         /* */
 479         msg_Dbg(vd, "VoutDisplayEvent 'mouse button' %d t=%d", button, event);
 480
 481         m.b_double_click = false;
 482         if (event == VOUT_DISPLAY_EVENT_MOUSE_PRESSED)
 483             m.i_pressed |= button_mask;
 484         else
 485             m.i_pressed &= ~button_mask;
 486         break;
 487     }
 488     case VOUT_DISPLAY_EVENT_MOUSE_DOUBLE_CLICK:
 489         msg_Dbg(vd, "VoutDisplayEvent 'double click'");
 490
 491         m.b_double_click = true;
 492         break;
 493     default:
 494         assert(0);
 495     }
 496
 497     if (is_ignored) {
 498         vlc_mutex_unlock(&osys->lock);
 499         return;
 500     }
 501
 502     /* Emulate double-click if needed */
 503     if (!vd->info.has_double_click &&
 504         vlc_mouse_HasPressed(&osys->mouse.state, &m, MOUSE_BUTTON_LEFT)) {
 505         const mtime_t i_date = mdate();
 506
 507         if (i_date - osys->mouse.last_pressed < osys->mouse.double_click_timeout ) {
 508             m.b_double_click = true;
 509             osys->mouse.last_pressed = 0;
 510         } else {
 511             osys->mouse.last_pressed = mdate();
 512         }
 513     }
 514
 515     /* */
 516     osys->mouse.state = m;
 517
 518     /* */
 519     osys->mouse.ch_activity = true;
 520     if (!vd->info.has_hide_mouse)
 521         osys->mouse.last_moved = mdate();
 522
 523     /* */
 524     vlc_mutex_unlock(&osys->lock);
 525
 526     /* */
 527     vout_SendEventMouseVisible(osys->vout);
 528     vout_SendDisplayEventMouse(osys->vout, &m);
 529 }
 530
 531 static void VoutDisplayEvent(vout_display_t *vd, int event, va_list args)
 532 {
 533     vout_display_owner_sys_t *osys = vd->owner.sys;
 534
 535     switch (event) {
 536     case VOUT_DISPLAY_EVENT_CLOSE: {
 537         msg_Dbg(vd, "VoutDisplayEvent 'close'");
 538         vout_SendEventClose(osys->vout);
 539         break;
 540     }
 541     case VOUT_DISPLAY_EVENT_KEY: {
 542         const int key = (int)va_arg(args, int);
 543         msg_Dbg(vd, "VoutDisplayEvent 'key' 0x%2.2x", key);
 544         vout_SendEventKey(osys->vout, key);
 545         break;
 546     }
 547     case VOUT_DISPLAY_EVENT_MOUSE_STATE:
 548     case VOUT_DISPLAY_EVENT_MOUSE_MOVED:
 549     case VOUT_DISPLAY_EVENT_MOUSE_PRESSED:
 550     case VOUT_DISPLAY_EVENT_MOUSE_RELEASED:
 551     case VOUT_DISPLAY_EVENT_MOUSE_DOUBLE_CLICK:
 552         VoutDisplayEventMouse(vd, event, args);
 553         break;
 554
 555     case VOUT_DISPLAY_EVENT_FULLSCREEN: {
 556         const int is_fullscreen = (int)va_arg(args, int);
 557
 558         msg_Dbg(vd, "VoutDisplayEvent 'fullscreen' %d", is_fullscreen);
 559
 560         vlc_mutex_lock(&osys->lock);
 561         if (!is_fullscreen != !osys->is_fullscreen) {
 562             osys->ch_fullscreen = true;
 563             osys->is_fullscreen = is_fullscreen;
 564         }
 565         vlc_mutex_unlock(&osys->lock);
 566         break;
 567     }
 568
 569     case VOUT_DISPLAY_EVENT_DISPLAY_SIZE: {
 570         const int width  = (int)va_arg(args, int);
 571         const int height = (int)va_arg(args, int);
 572         const bool is_fullscreen = (bool)va_arg(args, int);
 573         msg_Dbg(vd, "VoutDisplayEvent 'resize' %dx%d %s",
 574                 width, height, is_fullscreen ? "fullscreen" : "window");
 575
 576         /* */
 577         vlc_mutex_lock(&osys->lock);
 578
 579         osys->ch_display_size       = true;
 580         osys->display_width         = width;
 581         osys->display_height        = height;
 582         osys->display_is_fullscreen = is_fullscreen;
 583
 584         vlc_mutex_unlock(&osys->lock);
 585         break;
 586     }
 587
 588     case VOUT_DISPLAY_EVENT_PICTURES_INVALID: {
 589         msg_Warn(vd, "VoutDisplayEvent 'pictures invalid'");
 590
 591         /* */
 592         assert(vd->info.has_pictures_invalid);
 593
 594         vlc_mutex_lock(&osys->lock);
 595         osys->reset_pictures = true;
 596         vlc_mutex_unlock(&osys->lock);
 597         break;
 598     }
 599     default:
 600         msg_Err(vd, "VoutDisplayEvent received event %d", event);
 601         /* TODO add an assert when all event are handled */
 602         break;
 603     }
 604 }
 605
 606 static vout_window_t *VoutDisplayNewWindow(vout_display_t *vd, const vout_window_cfg_t *cfg)
 607 {
 608     vout_display_owner_sys_t *osys = vd->owner.sys;
 609
 610     return vout_NewDisplayWindow(osys->vout, vd, cfg);
 611 }
 612 static void VoutDisplayDelWindow(vout_display_t *vd, vout_window_t *window)
 613 {
 614     vout_display_owner_sys_t *osys = vd->owner.sys;
 615
 616     vout_DeleteDisplayWindow(osys->vout, vd, window);
 617 }
 618
 619 void vout_ManageDisplay(vout_display_t *vd)
 620 {
 621     vout_display_owner_sys_t *osys = vd->owner.sys;
 622
 623     vout_display_Manage(vd);
 624
 625     /* Handle mouse timeout */
 626     const mtime_t date = mdate();
 627     bool  hide_mouse = false;
 628
 629     vlc_mutex_lock(&osys->lock);
 630
 631     if (!osys->mouse.is_hidden &&
 632         osys->mouse.last_moved + osys->mouse.hide_timeout < date) {
 633         osys->mouse.is_hidden = hide_mouse = true;
 634     } else if (osys->mouse.ch_activity) {
 635         osys->mouse.is_hidden = false;
 636     }
 637     osys->mouse.ch_activity = false;
 638     vlc_mutex_unlock(&osys->lock);
 639
 640     if (hide_mouse) {
 641         if (!vd->info.has_hide_mouse) {
 642             msg_Dbg(vd, "auto hidding mouse");
 643             vout_display_Control(vd, VOUT_DISPLAY_HIDE_MOUSE);
 644         }
 645         vout_SendEventMouseHidden(osys->vout);
 646     }
 647
 648     bool reset_render = false;
 649     for (;;) {
 650
 651         vlc_mutex_lock(&osys->lock);
 652
 653         bool ch_fullscreen  = osys->ch_fullscreen;
 654         bool is_fullscreen  = osys->is_fullscreen;
 655         osys->ch_fullscreen = false;
 656
 657         bool ch_display_size       = osys->ch_display_size;
 658         int  display_width         = osys->display_width;
 659         int  display_height        = osys->display_height;
 660         bool display_is_fullscreen = osys->display_is_fullscreen;
 661         osys->ch_display_size = false;
 662
 663         bool reset_pictures = osys->reset_pictures;
 664         osys->reset_pictures = false;
 665
 666         vlc_mutex_unlock(&osys->lock);
 667
 668         if (!ch_fullscreen &&
 669             !ch_display_size &&
 670             !reset_pictures &&
 671             !osys->ch_display_filled &&
 672             !osys->ch_zoom &&
 673             !osys->ch_on_top &&
 674             !osys->ch_sar &&
 675             !osys->ch_crop)
 676             break;
 677
 678         /* */
 679         if (ch_fullscreen) {
 680             vout_display_cfg_t cfg = osys->cfg;
 681
 682             cfg.is_fullscreen  = is_fullscreen;
 683             cfg.display.width  = cfg.is_fullscreen ? 0 : osys->width_saved;
 684             cfg.display.height = cfg.is_fullscreen ? 0 : osys->height_saved;
 685
 686             if (vout_display_Control(vd, VOUT_DISPLAY_CHANGE_FULLSCREEN, &cfg)) {
 687                 msg_Err(vd, "Failed to set fullscreen");
 688                 is_fullscreen = osys->cfg.is_fullscreen;
 689             }
 690             osys->cfg.is_fullscreen = is_fullscreen;
 691
 692             /* */
 693             vout_SendEventFullscreen(osys->vout, osys->cfg.is_fullscreen);
 694         }
 695
 696         /* */
 697         if (ch_display_size) {
 698             vout_display_cfg_t cfg = osys->cfg;
 699             cfg.display.width  = display_width;
 700             cfg.display.height = display_height;
 701
 702             if (!cfg.is_fullscreen != !display_is_fullscreen ||
 703                 vout_display_Control(vd, VOUT_DISPLAY_CHANGE_DISPLAY_SIZE, &cfg)) {
 704                 if (!cfg.is_fullscreen == !display_is_fullscreen)
 705                     msg_Err(vd, "Failed to resize display");
 706
 707                 /* We ignore the resized */
 708                 display_width  = osys->cfg.display.width;
 709                 display_height = osys->cfg.display.height;
 710             }
 711             osys->cfg.display.width  = display_width;
 712             osys->cfg.display.height = display_height;
 713
 714             if (!display_is_fullscreen) {
 715                 osys->width_saved  = display_width;
 716                 osys->height_saved = display_height;
 717             }
 718         }
 719         /* */
 720         if (osys->ch_display_filled) {
 721             vout_display_cfg_t cfg = osys->cfg;
 722
 723             cfg.is_display_filled = osys->is_display_filled;
 724
 725             if (vout_display_Control(vd, VOUT_DISPLAY_CHANGE_DISPLAY_FILLED, &cfg)) {
 726                 msg_Err(vd, "Failed to change display filled state");
 727                 osys->is_display_filled = osys->cfg.is_display_filled;
 728             }
 729             osys->cfg.is_display_filled = osys->is_display_filled;
 730             osys->ch_display_filled = false;
 731
 732             vout_SendEventDisplayFilled(osys->vout, osys->cfg.is_display_filled);
 733         }
 734         /* */
 735         if (osys->ch_zoom) {
 736             vout_display_cfg_t cfg = osys->cfg;
 737
 738             cfg.zoom.num = osys->zoom.num;
 739             cfg.zoom.den = osys->zoom.den;
 740
 741             if (10 * cfg.zoom.num <= cfg.zoom.den) {
 742                 cfg.zoom.num = 1;
 743                 cfg.zoom.den = 10;
 744             } else if (cfg.zoom.num >= 10 * cfg.zoom.den) {
 745                 cfg.zoom.num = 10;
 746                 cfg.zoom.den = 1;
 747             }
 748
 749             if (vout_display_Control(vd, VOUT_DISPLAY_CHANGE_ZOOM, &cfg)) {
 750                 msg_Err(vd, "Failed to change zoom");
 751                 osys->zoom.num = osys->cfg.zoom.num;
 752                 osys->zoom.den = osys->cfg.zoom.den;
 753             } else if (cfg.is_display_filled) {
 754                 const int display_width  = (int64_t)vd->source.i_width  * osys->zoom.num / osys->zoom.den;
 755                 const int display_height = (int64_t)vd->source.i_height * osys->zoom.num / osys->zoom.den;
 756
 757                 vout_display_SendEventDisplaySize(vd, display_width, display_height, osys->cfg.is_fullscreen);
 758             }
 759
 760             osys->cfg.zoom.num = osys->zoom.num;
 761             osys->cfg.zoom.den = osys->zoom.den;
 762             osys->ch_zoom = false;
 763
 764             vout_SendEventZoom(osys->vout, osys->cfg.zoom.num, osys->cfg.zoom.den);
 765         }
 766         /* */
 767         if (osys->ch_on_top) {
 768             bool is_on_top = osys->is_on_top;
 769
 770             if (vout_display_Control(vd, VOUT_DISPLAY_CHANGE_ON_TOP, is_on_top)) {
 771                 msg_Err(vd, "Failed to set on top");
 772                 is_on_top = osys->is_on_top_initial;
 773             }
 774             osys->is_on_top_initial =
 775             osys->is_on_top         = is_on_top;
 776             osys->ch_on_top = false;
 777
 778             /* */
 779             vout_SendEventOnTop(osys->vout, osys->is_on_top_initial);
 780         }
 781         /* */
 782         if (osys->ch_sar) {
 783             video_format_t source = vd->source;
 784
 785             if (osys->sar.num > 0 && osys->sar.den > 0) {
 786                 source.i_sar_num = osys->sar.num;
 787                 source.i_sar_den = osys->sar.den;
 788             } else {
 789                 source.i_sar_num = osys->source.i_sar_num;
 790                 source.i_sar_den = osys->source.i_sar_den;
 791             }
 792
 793             if (vout_display_Control(vd, VOUT_DISPLAY_CHANGE_SOURCE_ASPECT, &source)) {
 794                 /* There nothing much we can do. The only reason a vout display
 795                  * does not support it is because it need the core to add black border
 796                  * to the video for it.
 797                  * TODO add black borders ?
 798                  */
 799                 msg_Err(vd, "Failed to change source AR");
 800                 source = vd->source;
 801             }
 802             vd->source = source;
 803             osys->sar.num = source.i_sar_num;
 804             osys->sar.den = source.i_sar_den;
 805             osys->ch_sar  = false;
 806
 807             /* */
 808             if (osys->sar.num == osys->source.i_sar_num &&
 809                 osys->sar.den == osys->source.i_sar_den)
 810             {
 811                 vout_SendEventSourceAspect(osys->vout, 0, 0);
 812             }
 813             else
 814             {
 815                 unsigned dar_num, dar_den;
 816                 vlc_ureduce( &dar_num, &dar_den,
 817                              osys->sar.num * vd->source.i_visible_width,
 818                              osys->sar.den * vd->source.i_visible_height,
 819                              65536);
 820                 vout_SendEventSourceAspect(osys->vout, dar_num, dar_den);
 821             }
 822         }
 823         /* */
 824         if (osys->ch_crop) {
 825             video_format_t source = vd->source;
 826             unsigned crop_num = osys->crop.num;
 827             unsigned crop_den = osys->crop.den;
 828
 829             source.i_x_offset       = osys->crop.x;
 830             source.i_y_offset       = osys->crop.y;
 831             source.i_visible_width  = osys->crop.width;
 832             source.i_visible_height = osys->crop.height;
 833
 834             /* */
 835             const bool is_valid = source.i_x_offset < source.i_width &&
 836                                   source.i_y_offset < source.i_height &&
 837                                   source.i_x_offset + source.i_visible_width  <= source.i_width &&
 838                                   source.i_y_offset + source.i_visible_height <= source.i_height &&
 839                                   source.i_visible_width > 0 && source.i_visible_height > 0;
 840
 841             if (!is_valid || vout_display_Control(vd, VOUT_DISPLAY_CHANGE_SOURCE_CROP, &source)) {
 842                 if (is_valid)
 843                     msg_Err(vd, "Failed to change source crop TODO implement crop at core");
 844                 else
 845                     msg_Err(vd, "Invalid crop requested");
 846
 847                 source = vd->source;
 848                 crop_num = osys->crop_saved.num;
 849                 crop_den = osys->crop_saved.den;
 850                 /* FIXME implement cropping in the core if not supported by the
 851                  * vout module (easy)
 852                  */
 853             }
 854             vd->source = source;
 855             osys->crop.x      = source.i_x_offset;
 856             osys->crop.y      = source.i_y_offset;
 857             osys->crop.width  = source.i_visible_width;
 858             osys->crop.height = source.i_visible_height;
 859             osys->crop.num    = crop_num;
 860             osys->crop.den    = crop_den;
 861             osys->ch_crop = false;
 862
 863             /* TODO fix when a ratio is used (complicated). */
 864             const unsigned left   = osys->crop.x - osys->source.i_x_offset;
 865             const unsigned top    = osys->crop.y - osys->source.i_y_offset;
 866             const unsigned right  = osys->source.i_visible_width  - (osys->crop.width  + osys->crop.x);
 867             const unsigned bottom = osys->source.i_visible_height - (osys->crop.height + osys->crop.y);
 868             vout_SendEventSourceCrop(osys->vout,
 869                                      osys->crop.num, osys->crop.den,
 870                                      left, top, right, bottom);
 871         }
 872
 873         /* */
 874         if (reset_pictures) {
 875             if (vout_display_Control(vd, VOUT_DISPLAY_RESET_PICTURES)) {
 876                 /* FIXME what to do here ? */
 877                 msg_Err(vd, "Failed to reset pictures (probably fatal)");
 878             }
 879             reset_render = true;
 880         }
 881     }
 882     if (reset_render)
 883         VoutDisplayResetRender(vd);
 884 }
 885
 886 bool vout_AreDisplayPicturesInvalid(vout_display_t *vd)
 887 {
 888     vout_display_owner_sys_t *osys = vd->owner.sys;
 889
 890     vlc_mutex_lock(&osys->lock);
 891     const bool reset_pictures = osys->reset_pictures;
 892     vlc_mutex_unlock(&osys->lock);
 893
 894     return reset_pictures;
 895 }
 896
 897 bool vout_IsDisplayFiltered(vout_display_t *vd)
 898 {
 899     vout_display_owner_sys_t *osys = vd->owner.sys;
 900
 901     return osys->filters != NULL;
 902 }
 903
 904 picture_t *vout_FilterDisplay(vout_display_t *vd, picture_t *picture)
 905 {
 906     vout_display_owner_sys_t *osys = vd->owner.sys;
 907
 908     assert(osys->filters);
 909     return filter_chain_VideoFilter(osys->filters, picture);
 910 }
 911
 912 void vout_SetDisplayFullscreen(vout_display_t *vd, bool is_fullscreen)
 913 {
 914     vout_display_owner_sys_t *osys = vd->owner.sys;
 915
 916     vlc_mutex_lock(&osys->lock);
 917     if (!osys->is_fullscreen != !is_fullscreen) {
 918         osys->ch_fullscreen = true;
 919         osys->is_fullscreen = is_fullscreen;
 920     }
 921     vlc_mutex_unlock(&osys->lock);
 922 }
 923
 924 void vout_SetDisplayFilled(vout_display_t *vd, bool is_filled)
 925 {
 926     vout_display_owner_sys_t *osys = vd->owner.sys;
 927
 928     if (!osys->is_display_filled != !is_filled) {
 929         osys->ch_display_filled = true;
 930         osys->is_display_filled = is_filled;
 931     }
 932 }
 933
 934 void vout_SetDisplayZoom(vout_display_t *vd, int num, int den)
 935 {
 936     vout_display_owner_sys_t *osys = vd->owner.sys;
 937
 938     if (osys->zoom.num != num || osys->zoom.den != den) {
 939         osys->ch_zoom = true;
 940         osys->zoom.num = num;
 941         osys->zoom.den = den;
 942     }
 943 }
 944 void vout_SetDisplayOnTop(vout_display_t *vd, bool is_on_top)
 945 {
 946     vout_display_owner_sys_t *osys = vd->owner.sys;
 947
 948     if (!osys->is_on_top != !is_on_top) {
 949         osys->ch_on_top = true;
 950         osys->is_on_top = is_on_top;
 951     }
 952 }
 953 void vout_SetDisplayAspect(vout_display_t *vd, unsigned sar_num, unsigned sar_den)
 954 {
 955     vout_display_owner_sys_t *osys = vd->owner.sys;
 956
 957     if (osys->sar.num != sar_num || osys->sar.den != sar_den) {
 958         osys->ch_sar = true;
 959         osys->sar.num = sar_num;
 960         osys->sar.den = sar_den;
 961     }
 962 }
 963 void vout_SetDisplayCrop(vout_display_t *vd,
 964                          unsigned crop_num, unsigned crop_den,
 965                          unsigned x, unsigned y, unsigned width, unsigned height)
 966 {
 967     vout_display_owner_sys_t *osys = vd->owner.sys;
 968
 969     if (osys->crop.x != x || osys->crop.y != y ||
 970         osys->crop.width  != width || osys->crop.height != height) {
 971
 972         osys->crop.x      = x;
 973         osys->crop.y      = y;
 974         osys->crop.width  = width;
 975         osys->crop.height = height;
 976         osys->crop.num    = crop_num;
 977         osys->crop.den    = crop_den;
 978
 979         osys->ch_crop = true;
 980     }
 981 }
 982
 983
 984 static vout_display_t *DisplayNew(vout_thread_t *vout,
 985                                   const video_format_t *source_org,
 986                                   const vout_display_state_t *state,
 987                                   const char *module,
 988                                   bool is_wrapper, vout_display_t *wrapper,
 989                                   mtime_t double_click_timeout,
 990                                   mtime_t hide_timeout,
 991                                   const vout_display_owner_t *owner_ptr)
 992 {
 993     /* */
 994     vout_display_owner_sys_t *osys = calloc(1, sizeof(*osys));
 995     vout_display_cfg_t *cfg = &osys->cfg;
 996
 997     *cfg = state->cfg;
 998     osys->is_on_top_initial = state->is_on_top;;
 999     osys->sar_initial.num = state->sar.num;
1000     osys->sar_initial.den = state->sar.den;
1001     vout_display_GetDefaultDisplaySize(&cfg->display.width, &cfg->display.height,
1002                                        source_org, cfg);
1003
1004     osys->vout = vout;
1005     osys->is_wrapper = is_wrapper;
1006     osys->wrapper = wrapper;
1007
1008     vlc_mutex_init(&osys->lock);
1009
1010     vlc_mouse_Init(&osys->mouse.state);
1011     osys->mouse.last_moved = mdate();
1012     osys->mouse.double_click_timeout = double_click_timeout;
1013     osys->mouse.hide_timeout = hide_timeout;
1014     osys->is_fullscreen  = cfg->is_fullscreen;
1015     osys->width_saved    =
1016     osys->display_width  = cfg->display.width;
1017     osys->height_saved   =
1018     osys->display_height = cfg->display.height;
1019     osys->is_display_filled = cfg->is_display_filled;
1020     osys->zoom.num = cfg->zoom.num;
1021     osys->zoom.den = cfg->zoom.den;
1022
1023     osys->source = *source_org;
1024
1025     video_format_t source = *source_org;
1026
1027     source.i_x_offset =
1028     osys->crop.x  = 0;
1029     source.i_y_offset =
1030     osys->crop.y  = 0;
1031     source.i_visible_width  =
1032     osys->crop.width    = source.i_width;
1033     source.i_visible_height =
1034     osys->crop.height   = source.i_height;
1035     osys->crop_saved.num = 0;
1036     osys->crop_saved.den = 0;
1037     osys->crop.num = 0;
1038     osys->crop.den = 0;
1039
1040     osys->sar.num = osys->sar_initial.num ? osys->sar_initial.num : source.i_sar_num;
1041     osys->sar.den = osys->sar_initial.den ? osys->sar_initial.den : source.i_sar_den;
1042
1043     vout_display_owner_t owner;
1044     if (owner_ptr) {
1045         owner = *owner_ptr;
1046     } else {
1047         owner.event      = VoutDisplayEvent;
1048         owner.window_new = VoutDisplayNewWindow;
1049         owner.window_del = VoutDisplayDelWindow;
1050     }
1051     owner.sys = osys;
1052
1053     /* */
1054     vout_display_t *p_display = vout_display_New(VLC_OBJECT(vout),
1055                                                  module, !is_wrapper,
1056                                                  &source, cfg, &owner);
1057     if (!p_display) {
1058         free(osys);
1059         return NULL;
1060     }
1061
1062     VoutDisplayCreateRender(p_display);
1063
1064     /* Setup delayed request */
1065     if (osys->sar.num != source_org->i_sar_num ||
1066         osys->sar.den != source_org->i_sar_den)
1067         osys->ch_sar = true;
1068     if (osys->is_on_top)
1069         osys->ch_on_top = true;
1070     if (osys->crop.x      != source_org->i_x_offset ||
1071         osys->crop.y      != source_org->i_y_offset ||
1072         osys->crop.width  != source_org->i_visible_width ||
1073         osys->crop.height != source_org->i_visible_height)
1074         osys->ch_crop = true;
1075
1076     return p_display;
1077 }
1078
1079 void vout_DeleteDisplay(vout_display_t *vd, vout_display_state_t *state)
1080 {
1081     vout_display_owner_sys_t *osys = vd->owner.sys;
1082
1083     if (state) {
1084         if (!osys->is_wrapper )
1085             state->cfg = osys->cfg;
1086         state->is_on_top = osys->is_on_top_initial;
1087         state->sar.num   = osys->sar_initial.num;
1088         state->sar.den   = osys->sar_initial.den;
1089     }
1090
1091     VoutDisplayDestroyRender(vd);
1092     if (osys->is_wrapper)
1093         SplitterClose(vd);
1094     vout_display_Delete(vd);
1095     vlc_mutex_destroy(&osys->lock);
1096     free(osys);
1097 }
1098
1099 /*****************************************************************************
1100  *
1101  *****************************************************************************/
1102 vout_display_t *vout_NewDisplay(vout_thread_t *vout,
1103                                 const video_format_t *source,
1104                                 const vout_display_state_t *state,
1105                                 const char *module,
1106                                 mtime_t double_click_timeout,
1107                                 mtime_t hide_timeout)
1108 {
1109     return DisplayNew(vout, source, state, module, false, NULL,
1110                       double_click_timeout, hide_timeout, NULL);
1111 }
1112
1113 static void SplitterClose(vout_display_t *vd)
1114 {
1115     VLC_UNUSED(vd);
1116     assert(0);
1117 }
1118
1119 #if 0
1120 /*****************************************************************************
1121  *
1122  *****************************************************************************/
1123 struct vout_display_sys_t {
1124     video_splitter_t *splitter;
1125
1126     /* */
1127     int            count;
1128     picture_t      **picture;
1129     vout_display_t **display;
1130 };
1131 struct video_splitter_owner_t {
1132     vout_display_t *wrapper;
1133 };
1134
1135 static vout_window_t *SplitterNewWindow(vout_display_t *vd, const vout_window_cfg_t *cfg_ptr)
1136 {
1137     vout_display_owner_sys_t *osys = vd->owner.sys;
1138
1139     vout_window_cfg_t cfg = *cfg_ptr;
1140     cfg.is_standalone = true;
1141     cfg.x += 0;//output->window.i_x; FIXME
1142     cfg.y += 0;//output->window.i_y;
1143
1144     return vout_NewDisplayWindow(osys->vout, vd, &cfg);
1145 }
1146 static void SplitterDelWindow(vout_display_t *vd, vout_window_t *window)
1147 {
1148     vout_display_owner_sys_t *osys = vd->owner.sys;
1149
1150     vout_DeleteDisplayWindow(osys->vout, vd, window);
1151 }
1152 static void SplitterEvent(vout_display_t *vd, int event, va_list args)
1153 {
1154     vout_display_owner_sys_t *osys = vd->owner.sys;
1155
1156     switch (event) {
1157 #if 0
1158     case VOUT_DISPLAY_EVENT_MOUSE_STATE:
1159     case VOUT_DISPLAY_EVENT_MOUSE_MOVED:
1160     case VOUT_DISPLAY_EVENT_MOUSE_PRESSED:
1161     case VOUT_DISPLAY_EVENT_MOUSE_RELEASED:
1162         /* TODO */
1163         break;
1164 #endif
1165     case VOUT_DISPLAY_EVENT_MOUSE_DOUBLE_CLICK:
1166     case VOUT_DISPLAY_EVENT_KEY:
1167     case VOUT_DISPLAY_EVENT_CLOSE:
1168     case VOUT_DISPLAY_EVENT_FULLSCREEN:
1169     case VOUT_DISPLAY_EVENT_DISPLAY_SIZE:
1170     case VOUT_DISPLAY_EVENT_PICTURES_INVALID:
1171         VoutDisplayEvent(vd, event, args);
1172         break;
1173
1174     default:
1175         msg_Err(vd, "SplitterEvent TODO");
1176         break;
1177     }
1178 }
1179
1180 static picture_t *SplitterGet(vout_display_t *vd)
1181 {
1182     /* TODO pool ? */
1183     return picture_NewFromFormat(&vd->fmt);
1184 }
1185 static void SplitterPrepare(vout_display_t *vd, picture_t *picture)
1186 {
1187     vout_display_sys_t *sys = vd->sys;
1188
1189     picture_Hold(picture);
1190
1191     if (video_splitter_Filter(sys->splitter, sys->picture, picture)) {
1192         for (int i = 0; i < sys->count; i++)
1193             sys->picture[i] = NULL;
1194         picture_Release(picture);
1195         return;
1196     }
1197
1198     for (int i = 0; i < sys->count; i++) {
1199         /* */
1200         /* FIXME now vout_FilterDisplay already return a direct buffer FIXME */
1201         sys->picture[i] = vout_FilterDisplay(sys->display[i], sys->picture[i]);
1202         if (!sys->picture[i])
1203             continue;
1204
1205         /* */
1206         picture_t *direct = vout_display_Get(sys->display[i]);
1207         if (!direct) {
1208             msg_Err(vd, "Failed to get a direct buffer");
1209             picture_Release(sys->picture[i]);
1210             sys->picture[i] = NULL;
1211             continue;
1212         }
1213
1214         /* FIXME not always needed (easy when there is a osys->filters) */
1215         picture_Copy(direct, sys->picture[i]);
1216         picture_Release(sys->picture[i]);
1217         sys->picture[i] = direct;
1218
1219         vout_display_Prepare(sys->display[i], sys->picture[i]);
1220     }
1221 }
1222 static void SplitterDisplay(vout_display_t *vd, picture_t *picture)
1223 {
1224     vout_display_sys_t *sys = vd->sys;
1225
1226     for (int i = 0; i < sys->count; i++) {
1227         if (sys->picture[i])
1228             vout_display_Display(sys->display[i], sys->picture[i]);
1229     }
1230     picture_Release(picture);
1231 }
1232 static int SplitterControl(vout_display_t *vd, int query, va_list args)
1233 {
1234     return VLC_EGENERIC;
1235 }
1236 static void SplitterManage(vout_display_t *vd)
1237 {
1238     vout_display_sys_t *sys = vd->sys;
1239
1240     for (int i = 0; i < sys->count; i++)
1241         vout_ManageDisplay(sys->display[i]);
1242 }
1243
1244 static int SplitterPictureNew(video_splitter_t *splitter, picture_t *picture[])
1245 {
1246     vout_display_sys_t *wsys = splitter->p_owner->wrapper->sys;
1247
1248     for (int i = 0; i < wsys->count; i++) {
1249         /* TODO pool ? */
1250         picture[i] = picture_NewFromFormat(&wsys->display[i]->source);
1251         if (!picture[i]) {
1252             for (int j = 0; j < i; j++)
1253                 picture_Release(picture[j]);
1254             return VLC_EGENERIC;
1255         }
1256     }
1257     return VLC_SUCCESS;
1258 }
1259 static void SplitterPictureDel(video_splitter_t *splitter, picture_t *picture[])
1260 {
1261     vout_display_sys_t *wsys = splitter->p_owner->wrapper->sys;
1262
1263     for (int i = 0; i < wsys->count; i++)
1264         picture_Release(picture[i]);
1265 }
1266 static void SplitterClose(vout_display_t *vd)
1267 {
1268     vout_display_sys_t *sys = vd->sys;
1269
1270     /* */
1271     video_splitter_t *splitter = sys->splitter;
1272     free(splitter->p_owner);
1273     video_splitter_Delete(splitter);
1274
1275     /* */
1276     for (int i = 0; i < sys->count; i++)
1277         vout_DeleteDisplay(sys->display[i], NULL);
1278     TAB_CLEAN(sys->count, sys->display);
1279     free(sys->picture);
1280
1281     free(sys);
1282 }
1283
1284 vout_display_t *vout_NewSplitter(vout_thread_t *vout,
1285                                  const video_format_t *source,
1286                                  const vout_display_state_t *state,
1287                                  const char *module,
1288                                  const char *splitter_module,
1289                                  mtime_t double_click_timeout,
1290                                  mtime_t hide_timeout)
1291 {
1292     video_splitter_t *splitter =
1293         video_splitter_New(VLC_OBJECT(vout), splitter_module, source);
1294     if (!splitter)
1295         return NULL;
1296
1297     /* */
1298     vout_display_t *wrapper =
1299         DisplayNew(vout, source, state, module, true, NULL,
1300                     double_click_timeout, hide_timeout, NULL);
1301     if (!wrapper) {
1302         video_splitter_Delete(splitter);
1303         return NULL;
1304     }
1305     vout_display_sys_t *sys = malloc(sizeof(*sys));
1306     if (!sys)
1307         abort();
1308     sys->picture = calloc(splitter->i_output, sizeof(*sys->picture));
1309     if (!sys->picture )
1310         abort();
1311     sys->splitter = splitter;
1312
1313     wrapper->get     = SplitterGet;
1314     wrapper->prepare = SplitterPrepare;
1315     wrapper->display = SplitterDisplay;
1316     wrapper->control = SplitterControl;
1317     wrapper->manage  = SplitterManage;
1318     wrapper->sys     = sys;
1319
1320     /* */
1321     video_splitter_owner_t *owner = malloc(sizeof(*owner));
1322     if (!owner)
1323         abort();
1324     owner->wrapper = wrapper;
1325     splitter->p_owner = owner;
1326     splitter->pf_picture_new = SplitterPictureNew;
1327     splitter->pf_picture_del = SplitterPictureDel;
1328
1329     /* */
1330     TAB_INIT(sys->count, sys->display);
1331     for (int i = 0; i < splitter->i_output; i++) {
1332         vout_display_owner_t owner;
1333
1334         owner.event      = SplitterEvent;
1335         owner.window_new = SplitterNewWindow;
1336         owner.window_del = SplitterDelWindow;
1337
1338         const video_splitter_output_t *output = &splitter->p_output[i];
1339         vout_display_state_t ostate;
1340
1341         memset(&ostate, 0, sizeof(ostate));
1342         ostate.cfg.is_fullscreen = false;
1343         ostate.cfg.display = state->cfg.display;
1344         ostate.cfg.align.horizontal = 0; /* TODO */
1345         ostate.cfg.align.vertical = 0; /* TODO */
1346         ostate.cfg.is_display_filled = true;
1347         ostate.cfg.zoom.num = 1;
1348         ostate.cfg.zoom.den = 1;
1349
1350         vout_display_t *vd = DisplayNew(vout, &output->fmt, &ostate,
1351                                            output->psz_module ? output->psz_module : module,
1352                                            false, wrapper,
1353                                            double_click_timeout, hide_timeout, &owner);
1354         if (!vd) {
1355             vout_DeleteDisplay(wrapper, NULL);
1356             return NULL;
1357         }
1358         TAB_APPEND(sys->count, sys->display, vd);
1359     }
1360
1361     return wrapper;
1362 }
1363 #endif
1364
1365 /*****************************************************************************
1366  * TODO move out
1367  *****************************************************************************/
1368 #include "vout_internal.h"
1369 void vout_SendDisplayEventMouse(vout_thread_t *vout, const vlc_mouse_t *m)
1370 {
1371     if (vlc_mouse_HasMoved(&vout->p->mouse, m)) {
1372         vout_SendEventMouseMoved(vout, m->i_x, m->i_y);
1373     }
1374     if (vlc_mouse_HasButton(&vout->p->mouse, m)) {
1375         static const int buttons[] = {
1376             MOUSE_BUTTON_LEFT,
1377             MOUSE_BUTTON_CENTER,
1378             MOUSE_BUTTON_RIGHT,
1379             MOUSE_BUTTON_WHEEL_UP,
1380             MOUSE_BUTTON_WHEEL_DOWN,
1381             -1
1382         };
1383         for (int i = 0; buttons[i] >= 0; i++) {
1384             const int button = buttons[i];
1385             if (vlc_mouse_HasPressed(&vout->p->mouse, m, button))
1386                 vout_SendEventMousePressed(vout, button);
1387             else if (vlc_mouse_HasReleased(&vout->p->mouse, m, button))
1388                 vout_SendEventMouseReleased(vout, button);
1389         }
1390     }
1391     if (m->b_double_click)
1392         vout_SendEventMouseDoubleClick(vout);
1393     vout->p->mouse = *m;
1394 }
1395 vout_window_t * vout_NewDisplayWindow(vout_thread_t *vout, vout_display_t *vd, const vout_window_cfg_t *cfg)
1396 {
1397     VLC_UNUSED(vd);
1398     vout_window_cfg_t cfg_override = *cfg;
1399
1400     if( !config_GetInt( vout, "embedded-video" ) )
1401         cfg_override.is_standalone = true;
1402
1403     return vout_window_New(VLC_OBJECT(vout), NULL, &cfg_override);
1404 }
1405 void vout_DeleteDisplayWindow(vout_thread_t *vout, vout_display_t *vd, vout_window_t *window)
1406 {
1407     VLC_UNUSED(vout);
1408     VLC_UNUSED(vd);
1409     vout_window_Delete(window);
1410 }
1411