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