git.sesse.net Git - vlc/blob - modules/video_output/kva.c

   1 /*****************************************************************************
   2  * kva.c: KVA video output plugin for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2010, 2011 the VideoLAN team
   5  *
   6  * Authors: KO Myung-Hun <komh@chollian.net>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <vlc_common.h>
  31 #include <vlc_plugin.h>
  32 #include <vlc_vout_display.h>
  33 #include <vlc_picture_pool.h>
  34
  35 #include <ctype.h>
  36 #include <float.h>
  37 #include <assert.h>
  38
  39 #include <fourcc.h>
  40
  41 #include <kva.h>
  42
  43 /*****************************************************************************
  44  * Module descriptor
  45  *****************************************************************************/
  46 static int  Open ( vlc_object_t * );
  47 static void Close( vlc_object_t * );
  48
  49 #define KVA_FIXT23_TEXT N_( \
  50     "Enable a workaround for T23" )
  51 #define KVA_FIXT23_LONGTEXT N_( \
  52     "Enable this option if the diagonal stripes are displayed " \
  53     "when the window size is equal to or smaller than the movie size." )
  54 #define KVA_VIDEO_MODE_TEXT N_( \
  55     "Video mode" )
  56 #define KVA_VIDEO_MODE_LONGTEXT N_( \
  57     "Select a proper video mode to be used by KVA." )
  58
  59 static const char *const ppsz_kva_video_mode[] = {
  60     "auto", "snap", "wo", "vman", "dive" };
  61 static const char *const ppsz_kva_video_mode_text[] = {
  62     N_("Auto"), N_("SNAP"), N_("WarpOverlay!"), N_("VMAN"), N_("DIVE") };
  63
  64 vlc_module_begin ()
  65     set_shortname( "KVA" )
  66     set_category( CAT_VIDEO )
  67     set_subcategory( SUBCAT_VIDEO_VOUT )
  68     add_string( "kva-video-mode", ppsz_kva_video_mode[0], KVA_VIDEO_MODE_TEXT,
  69                 KVA_VIDEO_MODE_LONGTEXT, false )
  70         change_string_list( ppsz_kva_video_mode, ppsz_kva_video_mode_text, 0 )
  71     add_bool( "kva-fixt23", false, KVA_FIXT23_TEXT, KVA_FIXT23_LONGTEXT, true );
  72     set_description( N_("K Video Acceleration video output") )
  73     set_capability( "vout display", 100 )
  74     add_shortcut( "kva" )
  75     set_callbacks( Open, Close )
  76 vlc_module_end ()
  77
  78 /*****************************************************************************
  79  * vout_display_sys_t: video output method descriptor
  80  *****************************************************************************
  81  * This structure is part of the video output thread descriptor.
  82  * It describes the module specific properties of an output thread.
  83  *****************************************************************************/
  84 struct vout_display_sys_t
  85 {
  86     TID                tid;
  87     HEV                ack_event;
  88     int                i_result;
  89     HAB                hab;
  90     HMQ                hmq;
  91     HWND               frame;
  92     HWND               client;
  93     KVASETUP           kvas;
  94     KVACAPS            kvac;
  95     LONG               i_screen_width;
  96     LONG               i_screen_height;
  97     bool               b_fixt23;
  98     PFNWP              p_old_frame;
  99     RECTL              client_rect;
 100     vout_window_t     *parent_window;
 101     HWND               parent;
 102     RECTL              parent_rect;
 103     picture_pool_t    *pool;
 104     picture_resource_t resource;
 105     unsigned           button_pressed;
 106     bool               is_mouse_hidden;
 107 };
 108
 109 struct picture_sys_t
 110 {
 111     int i_chroma_shift;
 112 };
 113
 114 /*****************************************************************************
 115  * Local prototypes
 116  *****************************************************************************/
 117 static picture_pool_t *Pool   (vout_display_t *, unsigned);
 118 static void            Display(vout_display_t *, picture_t *, subpicture_t * );
 119 static int             Control(vout_display_t *, int, va_list);
 120 static void            Manage (vout_display_t *);
 121
 122 static int  OpenDisplay ( vout_display_t *, video_format_t * );
 123 static void CloseDisplay( vout_display_t * );
 124
 125 static int  KVALock( picture_t * );
 126 static void KVAUnlock( picture_t * );
 127
 128 static void             MorphToPM     ( void );
 129 static int              ConvertKey    ( USHORT );
 130 static MRESULT EXPENTRY MyFrameWndProc( HWND, ULONG, MPARAM, MPARAM );
 131 static MRESULT EXPENTRY WndProc       ( HWND, ULONG, MPARAM, MPARAM );
 132
 133 #define WC_VLC_KVA "WC_VLC_KVA"
 134
 135 #define COLOR_KEY 0x0F0F0F
 136
 137 #define WM_VLC_MANAGE               ( WM_USER + 1 )
 138 #define WM_VLC_FULLSCREEN_CHANGE    ( WM_USER + 2 )
 139 #define WM_VLC_SIZE_CHANGE          ( WM_USER + 3 )
 140
 141 static const char *psz_video_mode[ 4 ] = {"DIVE", "WarpOverlay!", "SNAP",
 142                                           "VMAN"};
 143
 144 static void PMThread( void *arg )
 145 {
 146     vout_display_t *vd = ( vout_display_t * )arg;
 147     vout_display_sys_t * sys = vd->sys;
 148     ULONG i_frame_flags;
 149     QMSG qm;
 150     char *psz_mode;
 151     ULONG i_kva_mode;
 152
 153     /* */
 154     video_format_t fmt = vd->fmt;
 155
 156     /* */
 157     vout_display_info_t info = vd->info;
 158     info.is_slow = false;
 159     info.has_double_click = true;
 160     info.has_hide_mouse = false;
 161     info.has_pictures_invalid = false;
 162
 163     MorphToPM();
 164
 165     sys->hab = WinInitialize( 0 );
 166     sys->hmq = WinCreateMsgQueue( sys->hab, 0);
 167
 168     WinRegisterClass( sys->hab,
 169                       WC_VLC_KVA,
 170                       WndProc,
 171                       CS_SIZEREDRAW | CS_MOVENOTIFY,
 172                       sizeof( PVOID ));
 173
 174     sys->b_fixt23 = var_CreateGetBool( vd, "kva-fixt23");
 175
 176     if( !sys->b_fixt23 )
 177     {
 178         vout_window_cfg_t wnd_cfg;
 179
 180         wnd_cfg.is_standalone = false;
 181         wnd_cfg.type          = VOUT_WINDOW_TYPE_HWND;
 182         wnd_cfg.x             = var_InheritInteger(vd, "video-x");
 183         wnd_cfg.y             = var_InheritInteger(vd, "video-y");
 184         wnd_cfg.width         = vd->cfg->display.width;
 185         wnd_cfg.height        = vd->cfg->display.height;
 186
 187         /* If an external window was specified, we'll draw in it. */
 188         sys->parent_window =
 189             vout_display_NewWindow( vd, &wnd_cfg );
 190     }
 191
 192     if( sys->parent_window )
 193     {
 194         sys->parent = ( HWND )sys->parent_window->handle.hwnd;
 195
 196         /* Workaround :
 197          * When an embedded window opened first, it is not positioned
 198          * correctly. So reposition it here, again.
 199          */
 200         WinSetWindowPos( WinQueryWindow( sys->parent, QW_PARENT ),
 201                          HWND_TOP, 0, 0, 0, 0, SWP_MOVE );
 202
 203         ULONG i_style = WinQueryWindowULong( sys->parent, QWL_STYLE );
 204         WinSetWindowULong( sys->parent, QWL_STYLE,
 205                            i_style | WS_CLIPCHILDREN );
 206
 207         i_frame_flags = FCF_TITLEBAR;
 208     }
 209     else
 210     {
 211         sys->parent = HWND_DESKTOP;
 212
 213         i_frame_flags = FCF_SYSMENU    | FCF_TITLEBAR | FCF_MINMAX |
 214                         FCF_SIZEBORDER | FCF_TASKLIST;
 215     }
 216
 217     sys->frame =
 218         WinCreateStdWindow( sys->parent,      /* parent window handle */
 219                             WS_VISIBLE,       /* frame window style */
 220                             &i_frame_flags,   /* window style */
 221                             WC_VLC_KVA,       /* class name */
 222                             "",               /* window title */
 223                             0L,               /* default client style */
 224                             NULLHANDLE,       /* resource in exe file */
 225                             1,                /* frame window id */
 226                             &sys->client );   /* client window handle */
 227
 228     if( sys->frame == NULLHANDLE )
 229     {
 230         msg_Err( vd, "cannot create a frame window");
 231
 232         goto exit_frame;
 233     }
 234
 235     WinSetWindowPtr( sys->client, 0, vd );
 236
 237     if( sys->b_fixt23 )
 238     {
 239         WinSetWindowPtr( sys->frame, 0, vd );
 240         sys->p_old_frame = WinSubclassWindow( sys->frame, MyFrameWndProc );
 241     }
 242
 243     psz_mode = var_CreateGetString( vd, "kva-video-mode" );
 244
 245     i_kva_mode = KVAM_AUTO;
 246     if( strcmp( psz_mode, "snap" ) == 0 )
 247         i_kva_mode = KVAM_SNAP;
 248     else if( strcmp( psz_mode, "wo" ) == 0 )
 249         i_kva_mode = KVAM_WO;
 250     else if( strcmp( psz_mode, "vman" ) == 0 )
 251         i_kva_mode = KVAM_VMAN;
 252     else if( strcmp( psz_mode, "dive" ) == 0 )
 253         i_kva_mode = KVAM_DIVE;
 254
 255     free( psz_mode );
 256
 257     if( kvaInit( i_kva_mode, sys->client, COLOR_KEY ))
 258     {
 259         msg_Err( vd, "cannot initialize KVA");
 260
 261         goto exit_kva_init;
 262     }
 263
 264     kvaCaps( &sys->kvac );
 265
 266     msg_Dbg( vd, "selected video mode = %s",
 267              psz_video_mode[ sys->kvac.ulMode - 1 ]);
 268
 269     if( OpenDisplay( vd, &fmt ) )
 270     {
 271         msg_Err( vd, "cannot open display");
 272
 273         goto exit_open_display;
 274     }
 275
 276     if( vd->cfg->is_fullscreen )
 277     {
 278         if( sys->parent_window )
 279             vout_window_SetFullScreen(sys->parent_window, true);
 280         else
 281             WinPostMsg( sys->client, WM_VLC_FULLSCREEN_CHANGE,
 282                         MPFROMLONG( true ), 0 );
 283     }
 284
 285     kvaDisableScreenSaver();
 286
 287     /* Setup vout_display now that everything is fine */
 288     vd->fmt     = fmt;
 289     vd->info    = info;
 290
 291     vd->pool    = Pool;
 292     vd->prepare = NULL;
 293     vd->display = Display;
 294     vd->control = Control;
 295     vd->manage  = Manage;
 296
 297     /* Prevent SIG_FPE */
 298     _control87(MCW_EM, MCW_EM);
 299
 300     sys->i_result = VLC_SUCCESS;
 301     DosPostEventSem( sys->ack_event );
 302
 303     while( WinGetMsg( sys->hab, &qm, NULLHANDLE, 0, 0 ))
 304         WinDispatchMsg( sys->hab, &qm );
 305
 306     kvaEnableScreenSaver();
 307
 308     CloseDisplay( vd );
 309
 310     /* fall through */
 311
 312 exit_open_display :
 313     kvaDone();
 314
 315 exit_kva_init :
 316     if( sys->b_fixt23 )
 317         WinSubclassWindow( sys->frame, sys->p_old_frame );
 318
 319     WinDestroyWindow( sys->frame );
 320
 321 exit_frame :
 322     vout_display_DeleteWindow( vd, sys->parent_window );
 323
 324     if( sys->is_mouse_hidden )
 325         WinShowPointer( HWND_DESKTOP, TRUE );
 326
 327     WinDestroyMsgQueue( sys->hmq );
 328     WinTerminate( sys->hab );
 329
 330     sys->i_result = VLC_EGENERIC;
 331     DosPostEventSem( sys->ack_event );
 332 }
 333
 334 /**
 335  * This function initializes KVA vout method.
 336  */
 337 static int Open ( vlc_object_t *object )
 338 {
 339     vout_display_t *vd = (vout_display_t *)object;
 340     vout_display_sys_t *sys;
 341
 342     vd->sys = sys = calloc( 1, sizeof( *sys ));
 343     if( !sys )
 344         return VLC_ENOMEM;
 345
 346     DosCreateEventSem( NULL, &sys->ack_event, 0, FALSE );
 347
 348     sys->tid = _beginthread( PMThread, NULL, 1024 * 1024, vd );
 349     DosWaitEventSem( sys->ack_event, SEM_INDEFINITE_WAIT );
 350
 351     if( sys->i_result != VLC_SUCCESS )
 352     {
 353         DosCloseEventSem( sys->ack_event );
 354
 355         free( sys );
 356
 357         return VLC_EGENERIC;
 358     }
 359
 360     return VLC_SUCCESS;
 361 }
 362
 363 /*****************************************************************************
 364  * Close: destroy KVA video thread output method
 365  *****************************************************************************
 366  * Terminate an output method created by Open
 367  *****************************************************************************/
 368 static void Close ( vlc_object_t *object )
 369 {
 370     vout_display_t * vd = (vout_display_t *)object;
 371     vout_display_sys_t * sys = vd->sys;
 372
 373     WinPostQueueMsg( sys->hmq, WM_QUIT, 0, 0 );
 374
 375     DosWaitThread( &sys->tid, DCWW_WAIT );
 376
 377     if( sys->pool )
 378         picture_pool_Delete( sys->pool );
 379
 380     DosCloseEventSem( sys->ack_event );
 381
 382     free( sys );
 383 }
 384
 385 /**
 386  * Return a pool of direct buffers
 387  */
 388 static picture_pool_t *Pool(vout_display_t *vd, unsigned count)
 389 {
 390     vout_display_sys_t *sys = vd->sys;
 391     VLC_UNUSED(count);
 392
 393     return sys->pool;
 394 }
 395
 396 /*****************************************************************************
 397  * Display: displays previously rendered output
 398  *****************************************************************************
 399  * This function sends the currently rendered image to the display.
 400  *****************************************************************************/
 401 static void Display( vout_display_t *vd, picture_t *picture,
 402                      subpicture_t *subpicture )
 403 {
 404     VLC_UNUSED( vd );
 405     VLC_UNUSED( subpicture );
 406
 407     picture_Release( picture );
 408 }
 409
 410 /*****************************************************************************
 411  * Manage: handle Sys events
 412  *****************************************************************************
 413  * This function should be called regularly by video output thread. It returns
 414  * a non null value if an error occurred.
 415  *****************************************************************************/
 416 static void Manage( vout_display_t *vd )
 417 {
 418     vout_display_sys_t * sys = vd->sys;
 419
 420     /* Let a window procedure manage instead because if resizing a frame window
 421      * here, WM_SIZE is not sent to its child window.
 422      * Maybe, is this due to the different threads ? */
 423     WinPostMsg( sys->client, WM_VLC_MANAGE, 0, 0 );
 424 }
 425
 426 /*****************************************************************************
 427  * Control: control facility for the vout
 428  *****************************************************************************/
 429 static int Control( vout_display_t *vd, int query, va_list args )
 430 {
 431     vout_display_sys_t *sys = vd->sys;
 432
 433     switch (query)
 434     {
 435     case VOUT_DISPLAY_HIDE_MOUSE:
 436     {
 437         POINTL ptl;
 438
 439         WinQueryPointerPos( HWND_DESKTOP, &ptl );
 440         if( WinWindowFromPoint( HWND_DESKTOP, &ptl, TRUE ) == sys->client )
 441         {
 442             WinShowPointer( HWND_DESKTOP, FALSE );
 443             sys->is_mouse_hidden = true;
 444         }
 445
 446         return VLC_SUCCESS;
 447     }
 448
 449     case VOUT_DISPLAY_CHANGE_FULLSCREEN:
 450     {
 451         vout_display_cfg_t cfg = *va_arg(args, const vout_display_cfg_t *);
 452
 453         if( sys->parent_window )
 454             vout_window_SetFullScreen(sys->parent_window, cfg.is_fullscreen);
 455         else
 456             WinPostMsg( sys->client, WM_VLC_FULLSCREEN_CHANGE,
 457                         MPFROMLONG( cfg.is_fullscreen ), 0 );
 458
 459         return VLC_SUCCESS;
 460     }
 461
 462     case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
 463     {
 464         const vout_display_cfg_t *cfg = va_arg(args, const vout_display_cfg_t *);
 465         bool  is_forced = va_arg(args, int);
 466
 467         if( is_forced )
 468         {
 469             if( sys->parent_window )
 470             {
 471                 vout_window_SetSize(sys->parent_window,
 472                                     cfg->display.width, cfg->display.height);
 473
 474                 /* Workaround :
 475                  * If changing aspect ratio after resizing a main window,
 476                  * an embedded window is misplaced. So reposition it, here.
 477                  */
 478                 WinSetWindowPos( WinQueryWindow( sys->parent, QW_PARENT ),
 479                                  HWND_TOP, 0, 1, 0, 0, SWP_MOVE );
 480                 WinSetWindowPos( WinQueryWindow( sys->parent, QW_PARENT ),
 481                                  HWND_TOP, 0, 0, 0, 0, SWP_MOVE );
 482             }
 483             else
 484                 WinPostMsg( sys->client, WM_VLC_SIZE_CHANGE,
 485                             MPFROMLONG( cfg->display.width ),
 486                             MPFROMLONG( cfg->display.height ));
 487         }
 488
 489         return VLC_SUCCESS;
 490     }
 491
 492     case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
 493     case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
 494     {
 495         const video_format_t *source = va_arg(args, const video_format_t *);
 496
 497         if( query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT )
 498         {
 499             sys->kvas.ulAspectWidth  = ( int64_t )source->i_width *
 500                                        source->i_sar_num / source->i_sar_den;
 501             sys->kvas.ulAspectHeight = source->i_height;
 502         }
 503         else
 504         {
 505             sys->kvas.rclSrcRect.xLeft   = source->i_x_offset;
 506             sys->kvas.rclSrcRect.yTop    = source->i_y_offset;
 507             sys->kvas.rclSrcRect.xRight  = source->i_x_offset +
 508                                            source->i_visible_width;
 509             sys->kvas.rclSrcRect.yBottom = source->i_y_offset +
 510                                            source->i_visible_height;
 511         }
 512
 513         kvaSetup( &sys->kvas );
 514
 515         return VLC_SUCCESS;
 516     }
 517
 518     case VOUT_DISPLAY_RESET_PICTURES:
 519     case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
 520     case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
 521     case VOUT_DISPLAY_CHANGE_ZOOM:
 522     case VOUT_DISPLAY_GET_OPENGL:
 523         /* TODO */
 524         break;
 525     }
 526
 527     msg_Err(vd, "Unsupported query(=%d) in vout display KVA", query);
 528     return VLC_EGENERIC;
 529 }
 530
 531 /* following functions are local */
 532
 533 /*****************************************************************************
 534  * OpenDisplay: open and initialize KVA device
 535  *****************************************************************************
 536  * Open and initialize display according to preferences specified in the vout
 537  * thread fields.
 538  *****************************************************************************/
 539 static int OpenDisplay( vout_display_t *vd, video_format_t *fmt )
 540 {
 541     vout_display_sys_t * sys = vd->sys;
 542     const vlc_fourcc_t *fallback;
 543     bool b_hw_accel = 0;
 544     FOURCC i_kva_fourcc;
 545     int i_chroma_shift;
 546     char sz_title[ 256 ];
 547     RECTL rcl;
 548     int w, h;
 549
 550     msg_Dbg( vd, "render chroma = %4.4s", ( const char * )&fmt->i_chroma );
 551
 552     for( int pass = 0; pass < 2 && !b_hw_accel; pass++ )
 553     {
 554         fallback = ( pass == 0 ) ? vlc_fourcc_GetYUVFallback( fmt->i_chroma ) :
 555                                    vlc_fourcc_GetRGBFallback( fmt->i_chroma );
 556
 557         for( int i = 0; fallback[ i ]; i++ )
 558         {
 559             switch( fallback[ i ])
 560             {
 561                 case VLC_CODEC_YV12:
 562                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_YV12;
 563                     i_kva_fourcc = FOURCC_YV12;
 564                     i_chroma_shift = 1;
 565                     break;
 566
 567                 case VLC_CODEC_YUYV:
 568                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_YUY2;
 569                     i_kva_fourcc = FOURCC_Y422;
 570                     i_chroma_shift = 0;
 571                     break;
 572
 573                 case VLC_CODEC_YV9:
 574                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_YVU9;
 575                     i_kva_fourcc = FOURCC_YVU9;
 576                     i_chroma_shift = 2;
 577                     break;
 578
 579                 case VLC_CODEC_RGB32:
 580                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_BGR32;
 581                     i_kva_fourcc = FOURCC_BGR4;
 582                     i_chroma_shift = 0;
 583                     break;
 584
 585                 case VLC_CODEC_RGB24:
 586                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_BGR24;
 587                     i_kva_fourcc = FOURCC_BGR3;
 588                     i_chroma_shift = 0;
 589                     break;
 590
 591                 case VLC_CODEC_RGB16:
 592                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_BGR16;
 593                     i_kva_fourcc = FOURCC_R565;
 594                     i_chroma_shift = 0;
 595                     break;
 596
 597                 case VLC_CODEC_RGB15:
 598                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_BGR15;
 599                     i_kva_fourcc = FOURCC_R555;
 600                     i_chroma_shift = 0;
 601                     break;
 602             }
 603
 604             if( b_hw_accel )
 605             {
 606                 fmt->i_chroma = fallback[ i ];
 607                 break;
 608             }
 609         }
 610     }
 611
 612     if( !b_hw_accel )
 613     {
 614         msg_Err( vd, "Ooops. There is no fourcc supported by KVA at all.");
 615
 616         return VLC_EGENERIC;
 617     }
 618
 619     /* Set the RGB masks */
 620     fmt->i_rmask = sys->kvac.ulRMask;
 621     fmt->i_gmask = sys->kvac.ulGMask;
 622     fmt->i_bmask = sys->kvac.ulBMask;
 623
 624     msg_Dbg( vd, "output chroma = %4.4s", ( const char * )&fmt->i_chroma );
 625     msg_Dbg( vd, "KVA chroma = %4.4s", ( const char * )&i_kva_fourcc );
 626
 627     w = vd->source.i_width;
 628     h = vd->source.i_height;
 629
 630     sys->kvas.ulLength           = sizeof( KVASETUP );
 631     sys->kvas.szlSrcSize.cx      = w;
 632     sys->kvas.szlSrcSize.cy      = h;
 633     sys->kvas.rclSrcRect.xLeft   = 0;
 634     sys->kvas.rclSrcRect.yTop    = 0;
 635     sys->kvas.rclSrcRect.xRight  = w;
 636     sys->kvas.rclSrcRect.yBottom = h;
 637     sys->kvas.ulRatio            = KVAR_FORCEANY;
 638     sys->kvas.ulAspectWidth      = w;
 639     sys->kvas.ulAspectHeight     = h;
 640     sys->kvas.fccSrcColor        = i_kva_fourcc;
 641     sys->kvas.fDither            = TRUE;
 642
 643     if( kvaSetup( &sys->kvas ))
 644     {
 645         msg_Err( vd, "cannot set up KVA");
 646
 647         return VLC_EGENERIC;
 648     }
 649
 650     /* Create the associated picture */
 651     picture_resource_t *rsc = &sys->resource;
 652     rsc->p_sys = malloc( sizeof( *rsc->p_sys ));
 653     if( !rsc->p_sys )
 654         return VLC_EGENERIC;
 655
 656     rsc->p_sys->i_chroma_shift = i_chroma_shift;
 657
 658     for( int i = 0; i < PICTURE_PLANE_MAX; i++ )
 659     {
 660         rsc->p[ i ].p_pixels = NULL;
 661         rsc->p[ i ].i_pitch  = 0;
 662         rsc->p[ i ].i_lines  = 0;
 663     }
 664
 665     picture_t *picture = picture_NewFromResource( fmt, rsc );
 666     if( !picture )
 667         goto exit_picture;
 668
 669     /* Wrap it into a picture pool */
 670     picture_pool_configuration_t pool_cfg;
 671     memset( &pool_cfg, 0, sizeof( pool_cfg ));
 672     pool_cfg.picture_count = 1;
 673     pool_cfg.picture       = &picture;
 674     pool_cfg.lock          = KVALock;
 675     pool_cfg.unlock        = KVAUnlock;
 676
 677     sys->pool = picture_pool_NewExtended( &pool_cfg );
 678     if( !sys->pool )
 679     {
 680         picture_Release( picture );
 681
 682         goto exit_picture;
 683     }
 684
 685     if (vd->cfg->display.title)
 686         snprintf( sz_title, sizeof( sz_title ), "%s", vd->cfg->display.title );
 687     else
 688         snprintf( sz_title, sizeof( sz_title ),
 689                   "%s (%4.4s to %4.4s - %s mode KVA output)",
 690                   VOUT_TITLE,
 691                   ( char * )&vd->fmt.i_chroma,
 692                   ( char * )&sys->kvas.fccSrcColor,
 693                   psz_video_mode[ sys->kvac.ulMode - 1 ]);
 694     WinSetWindowText( sys->frame, sz_title );
 695
 696     sys->i_screen_width  = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN );
 697     sys->i_screen_height = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN );
 698
 699     if( sys->parent_window )
 700         WinQueryWindowRect( sys->parent, &sys->client_rect );
 701     else
 702     {
 703         sys->client_rect.xLeft   = ( sys->i_screen_width  - w ) / 2;
 704         sys->client_rect.yBottom = ( sys->i_screen_height - h ) / 2 ;
 705         sys->client_rect.xRight  = sys->client_rect.xLeft   + w;
 706         sys->client_rect.yTop    = sys->client_rect.yBottom + h;
 707     }
 708
 709     rcl = sys->client_rect;
 710
 711     WinCalcFrameRect( sys->frame, &rcl, FALSE);
 712
 713     WinSetWindowPos( sys->frame, HWND_TOP,
 714                      rcl.xLeft, rcl.yBottom,
 715                      rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
 716                      SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW |
 717                      SWP_ACTIVATE );
 718
 719     return VLC_SUCCESS;
 720
 721 exit_picture:
 722     free( rsc->p_sys );
 723
 724     return VLC_EGENERIC;
 725 }
 726
 727 /*****************************************************************************
 728  * CloseDisplay: close and reset KVA device
 729  *****************************************************************************
 730  * This function returns all resources allocated by OpenDisplay and restore
 731  * the original state of the device.
 732  *****************************************************************************/
 733 static void CloseDisplay( vout_display_t *vd )
 734 {
 735     VLC_UNUSED( vd );
 736 }
 737
 738 static int KVALock( picture_t *picture )
 739 {
 740     picture_sys_t *picsys = picture->p_sys;
 741     PVOID kva_buffer;
 742     ULONG kva_bpl;
 743
 744     if( kvaLockBuffer( &kva_buffer, &kva_bpl ))
 745         return VLC_EGENERIC;
 746
 747     /* Packed or Y plane */
 748     picture->p->p_pixels = ( uint8_t * )kva_buffer;
 749     picture->p->i_pitch  = kva_bpl;
 750     picture->p->i_lines  = picture->format.i_height;
 751
 752     /* Other planes */
 753     for( int n = 1; n < picture->i_planes; n++ )
 754     {
 755         const plane_t *o = &picture->p[n-1];
 756         plane_t *p = &picture->p[n];
 757
 758         p->p_pixels = o->p_pixels + o->i_lines * o->i_pitch;
 759         p->i_pitch  = kva_bpl >> picsys->i_chroma_shift;
 760         p->i_lines  = picture->format.i_height >> picsys->i_chroma_shift;
 761     }
 762
 763     return VLC_SUCCESS;
 764 }
 765
 766 static void KVAUnlock( picture_t *picture )
 767 {
 768     VLC_UNUSED( picture );
 769
 770     kvaUnlockBuffer();
 771 }
 772
 773 static void MorphToPM( void )
 774 {
 775     PPIB pib;
 776
 777     DosGetInfoBlocks(NULL, &pib);
 778
 779     /* Change flag from VIO to PM */
 780     if (pib->pib_ultype == 2)
 781         pib->pib_ultype = 3;
 782 }
 783
 784 /*****************************************************************************
 785  * Key events handling
 786  *****************************************************************************/
 787 static const struct
 788 {
 789     USHORT i_pmkey;
 790     int    i_vlckey;
 791 } pmkeys_to_vlckeys[] =
 792 {
 793     { VK_LEFT, KEY_LEFT },
 794     { VK_RIGHT, KEY_RIGHT },
 795     { VK_UP, KEY_UP },
 796     { VK_DOWN, KEY_DOWN },
 797     { VK_SPACE, ' ' },
 798     { VK_NEWLINE, KEY_ENTER },
 799     { VK_ENTER, KEY_ENTER },
 800     { VK_F1, KEY_F1 },
 801     { VK_F2, KEY_F2 },
 802     { VK_F3, KEY_F3 },
 803     { VK_F4, KEY_F4 },
 804     { VK_F5, KEY_F5 },
 805     { VK_F6, KEY_F6 },
 806     { VK_F7, KEY_F7 },
 807     { VK_F8, KEY_F8 },
 808     { VK_F9, KEY_F9 },
 809     { VK_F10, KEY_F10 },
 810     { VK_F11, KEY_F11 },
 811     { VK_F12, KEY_F12 },
 812     { VK_HOME, KEY_HOME },
 813     { VK_END, KEY_END },
 814     { VK_INSERT, KEY_INSERT },
 815     { VK_DELETE, KEY_DELETE },
 816 /*
 817     Not supported
 818     {, KEY_MENU },
 819 */
 820     { VK_ESC, KEY_ESC },
 821     { VK_PAGEUP, KEY_PAGEUP },
 822     { VK_PAGEDOWN, KEY_PAGEDOWN },
 823     { VK_TAB, KEY_TAB },
 824     { VK_BACKSPACE, KEY_BACKSPACE },
 825 /*
 826     Not supported
 827     {, KEY_MOUSEWHEELUP },
 828     {, KEY_MOUSEWHEELDOWN },
 829     {, KEY_MOUSEWHEELLEFT },
 830     {, KEY_MOUSEWHEELRIGHT },
 831
 832     {, KEY_BROWSER_BACK },
 833     {, KEY_BROWSER_FORWARD },
 834     {, KEY_BROWSER_REFRESH },
 835     {, KEY_BROWSER_STOP },
 836     {, KEY_BROWSER_SEARCH },
 837     {, KEY_BROWSER_FAVORITES },
 838     {, KEY_BROWSER_HOME },
 839     {, KEY_VOLUME_MUTE },
 840     {, KEY_VOLUME_DOWN },
 841     {, KEY_VOLUME_UP },
 842     {, KEY_MEDIA_NEXT_TRACK },
 843     {, KEY_MEDIA_PREV_TRACK },
 844     {, KEY_MEDIA_STOP },
 845     {, KEY_MEDIA_PLAY_PAUSE },
 846 */
 847
 848     { 0, 0 }
 849 };
 850
 851 static int ConvertKey( USHORT i_pmkey )
 852 {
 853     int i;
 854     for( i = 0; pmkeys_to_vlckeys[ i ].i_pmkey != 0; i++ )
 855     {
 856         if( pmkeys_to_vlckeys[ i ].i_pmkey == i_pmkey )
 857             return pmkeys_to_vlckeys[ i ].i_vlckey;
 858     }
 859     return 0;
 860 }
 861
 862 static MRESULT EXPENTRY MyFrameWndProc( HWND hwnd, ULONG msg, MPARAM mp1,
 863                                         MPARAM mp2 )
 864 {
 865     vout_display_t *vd = WinQueryWindowPtr( hwnd, 0 );
 866     vout_display_sys_t *sys = vd->sys;
 867
 868     switch( msg )
 869     {
 870         case WM_QUERYTRACKINFO :
 871         {
 872             PTRACKINFO pti = ( PTRACKINFO )mp2;
 873             RECTL      rcl;
 874
 875             sys->p_old_frame( hwnd, msg, mp1, mp2 );
 876
 877             pti->rclBoundary.xLeft   = 0;
 878             pti->rclBoundary.yBottom = 0;
 879             pti->rclBoundary.xRight  = sys->i_screen_width;
 880             pti->rclBoundary.yTop    = sys->i_screen_height;
 881
 882             WinCalcFrameRect( hwnd, &pti->rclBoundary, FALSE );
 883
 884             pti->ptlMaxTrackSize.x = pti->rclBoundary.xRight -
 885                                      pti->rclBoundary.xLeft;
 886             pti->ptlMaxTrackSize.y = pti->rclBoundary.yTop -
 887                                      pti->rclBoundary.yBottom;
 888
 889             rcl.xLeft   = 0;
 890             rcl.yBottom = 0;
 891             rcl.xRight  = sys->kvas.szlSrcSize.cx + 1;
 892             rcl.yTop    = sys->kvas.szlSrcSize.cy + 1;
 893
 894             WinCalcFrameRect( hwnd, &rcl, FALSE );
 895
 896             pti->ptlMinTrackSize.x = rcl.xRight - rcl.xLeft;
 897             pti->ptlMinTrackSize.y = rcl.yTop - rcl.yBottom;
 898
 899             return MRFROMLONG( TRUE );
 900         }
 901
 902         case WM_ADJUSTWINDOWPOS :
 903         {
 904             PSWP  pswp = ( PSWP )mp1;
 905             RECTL rcl;
 906
 907             if( pswp->fl & SWP_SIZE )
 908             {
 909                 rcl.xLeft   = pswp->x;
 910                 rcl.yBottom = pswp->y;
 911                 rcl.xRight  = rcl.xLeft + pswp->cx;
 912                 rcl.yTop    = rcl.yBottom + pswp->cy;
 913
 914                 WinCalcFrameRect( hwnd, &rcl, TRUE );
 915
 916                 if( rcl.xRight - rcl.xLeft <= sys->kvas.szlSrcSize.cx )
 917                     rcl.xRight = rcl.xLeft + ( sys->kvas.szlSrcSize.cx + 1 );
 918
 919                 if( rcl.yTop - rcl.yBottom <= sys->kvas.szlSrcSize.cy )
 920                     rcl.yTop = rcl.yBottom + ( sys->kvas.szlSrcSize.cy + 1 );
 921
 922                 if( rcl.xRight - rcl.xLeft > sys->i_screen_width )
 923                 {
 924                     rcl.xLeft  = 0;
 925                     rcl.xRight = sys->i_screen_width;
 926                 }
 927
 928                 if( rcl.yTop - rcl.yBottom > sys->i_screen_height )
 929                 {
 930                     rcl.yBottom = 0;
 931                     rcl.yTop    = sys->i_screen_height;
 932                 }
 933
 934                 WinCalcFrameRect( hwnd, &rcl, FALSE );
 935
 936                 if( pswp->x != rcl.xLeft || pswp->y != rcl.yBottom )
 937                     pswp->fl |= SWP_MOVE;
 938
 939                 pswp->x = rcl.xLeft;
 940                 pswp->y = rcl.yBottom;
 941
 942                 pswp->cx = rcl.xRight - rcl.xLeft;
 943                 pswp->cy = rcl.yTop - rcl.yBottom;
 944             }
 945
 946             break;
 947         }
 948     }
 949
 950     return sys->p_old_frame( hwnd, msg, mp1, mp2 );
 951 }
 952
 953 static void MousePressed( vout_display_t *vd, HWND hwnd, unsigned button )
 954 {
 955     if( WinQueryFocus( HWND_DESKTOP ) != hwnd )
 956         WinSetFocus( HWND_DESKTOP, hwnd );
 957
 958     if( !vd->sys->button_pressed )
 959         WinSetCapture( HWND_DESKTOP, hwnd );
 960
 961     vd->sys->button_pressed |= 1 << button;
 962
 963     vout_display_SendEventMousePressed( vd, button );
 964 }
 965
 966 static void MouseReleased( vout_display_t *vd, unsigned button )
 967 {
 968     vd->sys->button_pressed &= ~(1 << button);
 969     if( !vd->sys->button_pressed )
 970         WinSetCapture( HWND_DESKTOP, NULLHANDLE );
 971
 972     vout_display_SendEventMouseReleased( vd, button );
 973 }
 974
 975 #define WM_MOUSELEAVE   0x41F
 976
 977 static MRESULT EXPENTRY WndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
 978 {
 979     vout_display_t * vd = WinQueryWindowPtr( hwnd, 0 );
 980     MRESULT result = ( MRESULT )TRUE;
 981
 982     if ( !vd )
 983         return WinDefWindowProc( hwnd, msg, mp1, mp2 );
 984
 985     vout_display_sys_t * sys = vd->sys;
 986     RECTL rcl;
 987     SWP   swp;
 988
 989     if ( sys->is_mouse_hidden &&
 990          ((msg >= WM_MOUSEFIRST    && msg <= WM_MOUSELAST) ||
 991           (msg >= WM_EXTMOUSEFIRST && msg <= WM_EXTMOUSELAST) ||
 992            msg == WM_MOUSELEAVE))
 993     {
 994         WinShowPointer(HWND_DESKTOP, TRUE);
 995         sys->is_mouse_hidden = false;
 996     }
 997
 998     switch( msg )
 999     {
1000         /* the user wants to close the window */
1001         case WM_CLOSE:
1002             vout_display_SendEventClose(vd);
1003             result = 0;
1004             break;
1005
1006         case WM_MOUSEMOVE :
1007         {
1008             SHORT i_mouse_x = SHORT1FROMMP( mp1 );
1009             SHORT i_mouse_y = SHORT2FROMMP( mp1 );
1010             RECTL movie_rect;
1011             int   i_movie_width, i_movie_height;
1012             int   i_src_width, i_src_height;
1013
1014             /* Get a current movie area */
1015             kvaAdjustDstRect( &sys->kvas.rclSrcRect, &movie_rect );
1016             i_movie_width = movie_rect.xRight - movie_rect.xLeft;
1017             i_movie_height = movie_rect.yTop - movie_rect.yBottom;
1018
1019             i_src_width =  sys->kvas.rclSrcRect.xRight -
1020                            sys->kvas.rclSrcRect.xLeft;
1021             i_src_height = sys->kvas.rclSrcRect.yBottom -
1022                            sys->kvas.rclSrcRect.yTop;
1023
1024             int x = ( i_mouse_x - movie_rect.xLeft ) *
1025                     i_src_width / i_movie_width +
1026                     sys->kvas.rclSrcRect.xLeft;
1027             int y = ( i_mouse_y - movie_rect.yBottom ) *
1028                     i_src_height / i_movie_height;
1029
1030             /* Invert Y coordinate and add y offset */
1031             y = ( i_src_height - y ) + sys->kvas.rclSrcRect.yTop;;
1032
1033             vout_display_SendEventMouseMoved(vd, x, y);
1034
1035             result = WinDefWindowProc( hwnd, msg, mp1,mp2 );
1036             break;
1037         }
1038
1039         case WM_BUTTON1DOWN :
1040             MousePressed( vd, hwnd, MOUSE_BUTTON_LEFT );
1041             break;
1042
1043         case WM_BUTTON2DOWN :
1044             MousePressed( vd, hwnd, MOUSE_BUTTON_RIGHT );
1045             break;
1046
1047         case WM_BUTTON3DOWN :
1048             MousePressed( vd, hwnd, MOUSE_BUTTON_CENTER );
1049             break;
1050
1051         case WM_BUTTON1UP :
1052             MouseReleased( vd, MOUSE_BUTTON_LEFT );
1053             break;
1054
1055         case WM_BUTTON2UP :
1056             MouseReleased( vd, MOUSE_BUTTON_RIGHT );
1057             break;
1058
1059         case WM_BUTTON3UP :
1060             MouseReleased( vd, MOUSE_BUTTON_CENTER );
1061             break;
1062
1063         case WM_BUTTON1DBLCLK :
1064             vout_display_SendEventMouseDoubleClick(vd);
1065             break;
1066
1067         case WM_TRANSLATEACCEL :
1068             /* We have no accelerator table at all */
1069             result = ( MRESULT )FALSE;
1070             break;
1071
1072         case WM_CHAR :
1073         {
1074             USHORT i_flags = SHORT1FROMMP( mp1 );
1075             USHORT i_ch    = SHORT1FROMMP( mp2 );
1076             USHORT i_vk    = SHORT2FROMMP( mp2 );
1077             int    i_key   = 0;
1078
1079             /* If embedded window, let the parent process keys */
1080             if( sys->parent_window )
1081             {
1082                 WinPostMsg( sys->parent, msg, mp1, mp2 );
1083                 break;
1084             }
1085
1086             if( !( i_flags & KC_KEYUP ))
1087             {
1088                 if( i_flags & KC_VIRTUALKEY )
1089                     /* convert the key if possible */
1090                     i_key = ConvertKey( i_vk );
1091                 else if(( i_flags & KC_CHAR ) && !HIBYTE( i_ch ))
1092                     i_key = tolower( i_ch );
1093
1094                 if( i_key )
1095                 {
1096                     if( i_flags & KC_SHIFT )
1097                        i_key |= KEY_MODIFIER_SHIFT;
1098
1099                     if( i_flags & KC_CTRL )
1100                         i_key |= KEY_MODIFIER_CTRL;
1101
1102                     if( i_flags & KC_ALT )
1103                         i_key |= KEY_MODIFIER_ALT;
1104
1105                     vout_display_SendEventKey(vd, i_key);
1106                 }
1107             }
1108             break;
1109         }
1110
1111         /* Process Manage() call */
1112         case WM_VLC_MANAGE :
1113             break;
1114
1115         /* Fullscreen change */
1116         case WM_VLC_FULLSCREEN_CHANGE :
1117             if( LONGFROMMP( mp1 ))
1118             {
1119                 WinQueryWindowPos( sys->frame, &swp );
1120                 sys->client_rect.xLeft   = swp.x;
1121                 sys->client_rect.yBottom = swp.y;
1122                 sys->client_rect.xRight  = sys->client_rect.xLeft   + swp.cx;
1123                 sys->client_rect.yTop    = sys->client_rect.yBottom + swp.cy;
1124                 WinCalcFrameRect( sys->frame, &sys->client_rect, TRUE );
1125
1126                 rcl.xLeft   = 0;
1127                 rcl.yBottom = 0;
1128                 rcl.xRight  = sys->i_screen_width;
1129                 rcl.yTop    = sys->i_screen_height;
1130             }
1131             else
1132                 rcl = sys->client_rect;
1133
1134             WinCalcFrameRect( sys->frame, &rcl, FALSE );
1135
1136             WinSetWindowPos( sys->frame, HWND_TOP,
1137                              rcl.xLeft, rcl.yBottom,
1138                              rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
1139                              SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW |
1140                              SWP_ACTIVATE );
1141             break;
1142
1143         /* Size change */
1144         case WM_VLC_SIZE_CHANGE :
1145             rcl.xLeft   = 0;
1146             rcl.yBottom = 0;
1147             rcl.xRight  = LONGFROMMP( mp1 );
1148             rcl.yTop    = LONGFROMMP( mp2 );
1149             WinCalcFrameRect( sys->frame, &rcl, FALSE );
1150
1151             WinSetWindowPos( sys->frame, NULLHANDLE,
1152                              0, 0,
1153                              rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
1154                              SWP_SIZE );
1155
1156             WinQueryWindowPos( sys->frame, &swp );
1157             sys->client_rect.xLeft   = swp.x;
1158             sys->client_rect.yBottom = swp.y;
1159             sys->client_rect.xRight  = sys->client_rect.xLeft   + swp.cx;
1160             sys->client_rect.yTop    = sys->client_rect.yBottom + swp.cy;
1161             WinCalcFrameRect( sys->frame, &sys->client_rect, TRUE );
1162             break;
1163
1164         default :
1165             return WinDefWindowProc( hwnd, msg, mp1, mp2 );
1166     }
1167
1168     /* If embedded window, we need to change our window size according to a
1169      * parent window size */
1170     if( sys->parent_window )
1171     {
1172         WinQueryWindowRect( sys->parent, &rcl );
1173
1174         if( rcl.xLeft   != sys->parent_rect.xLeft   ||
1175             rcl.yBottom != sys->parent_rect.yBottom ||
1176             rcl.xRight  != sys->parent_rect.xRight  ||
1177             rcl.yTop    != sys->parent_rect.yTop)
1178         {
1179             sys->parent_rect = rcl;
1180
1181             WinCalcFrameRect( sys->frame, &rcl, FALSE );
1182
1183             WinSetWindowPos( sys->frame, NULLHANDLE,
1184                              rcl.xLeft, rcl.yBottom,
1185                              rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
1186                              SWP_SIZE | SWP_MOVE );
1187         }
1188     }
1189
1190     return result;
1191 }