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