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, 2012 VLC authors and VideoLAN
   5  *
   6  * Authors: KO Myung-Hun <komh@chollian.net>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * 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 )
  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     bool               is_on_top;
 108 };
 109
 110 struct picture_sys_t
 111 {
 112     int i_chroma_shift;
 113 };
 114
 115 /*****************************************************************************
 116  * Local prototypes
 117  *****************************************************************************/
 118 static picture_pool_t *Pool   (vout_display_t *, unsigned);
 119 static void            Display(vout_display_t *, picture_t *, subpicture_t * );
 120 static int             Control(vout_display_t *, int, va_list);
 121 static void            Manage (vout_display_t *);
 122
 123 static int  OpenDisplay ( vout_display_t *, video_format_t * );
 124 static void CloseDisplay( vout_display_t * );
 125
 126 static int  KVALock( picture_t * );
 127 static void KVAUnlock( picture_t * );
 128
 129 static void             MorphToPM     ( void );
 130 static int              ConvertKey    ( USHORT );
 131 static MRESULT EXPENTRY MyFrameWndProc( HWND, ULONG, MPARAM, MPARAM );
 132 static MRESULT EXPENTRY WndProc       ( HWND, ULONG, MPARAM, MPARAM );
 133
 134 #define WC_VLC_KVA "WC_VLC_KVA"
 135
 136 #define COLOR_KEY 0x0F0F0F
 137
 138 #define WM_VLC_MANAGE               ( WM_USER + 1 )
 139 #define WM_VLC_FULLSCREEN_CHANGE    ( WM_USER + 2 )
 140 #define WM_VLC_SIZE_CHANGE          ( WM_USER + 3 )
 141
 142 static const char *psz_video_mode[ 4 ] = {"DIVE", "WarpOverlay!", "SNAP",
 143                                           "VMAN"};
 144
 145 static void PMThread( void *arg )
 146 {
 147     vout_display_t *vd = ( vout_display_t * )arg;
 148     vout_display_sys_t * sys = vd->sys;
 149     ULONG i_frame_flags;
 150     QMSG qm;
 151     char *psz_mode;
 152     ULONG i_kva_mode;
 153
 154     /* */
 155     video_format_t fmt = vd->fmt;
 156
 157     /* */
 158     vout_display_info_t info = vd->info;
 159     info.is_slow = false;
 160     info.has_double_click = true;
 161     info.has_hide_mouse = false;
 162     info.has_pictures_invalid = false;
 163
 164     MorphToPM();
 165
 166     sys->hab = WinInitialize( 0 );
 167     sys->hmq = WinCreateMsgQueue( sys->hab, 0);
 168
 169     WinRegisterClass( sys->hab,
 170                       WC_VLC_KVA,
 171                       WndProc,
 172                       CS_SIZEREDRAW | CS_MOVENOTIFY,
 173                       sizeof( PVOID ));
 174
 175     sys->b_fixt23 = var_CreateGetBool( vd, "kva-fixt23");
 176
 177     if( !sys->b_fixt23 )
 178     {
 179         vout_window_cfg_t wnd_cfg;
 180
 181         wnd_cfg.is_standalone = false;
 182         wnd_cfg.type          = VOUT_WINDOW_TYPE_HWND;
 183         wnd_cfg.x             = var_InheritInteger(vd, "video-x");
 184         wnd_cfg.y             = var_InheritInteger(vd, "video-y");
 185         wnd_cfg.width         = vd->cfg->display.width;
 186         wnd_cfg.height        = vd->cfg->display.height;
 187
 188         /* If an external window was specified, we'll draw in it. */
 189         sys->parent_window =
 190             vout_display_NewWindow( vd, &wnd_cfg );
 191     }
 192
 193     if( sys->parent_window )
 194     {
 195         sys->parent = ( HWND )sys->parent_window->handle.hwnd;
 196
 197         ULONG i_style = WinQueryWindowULong( sys->parent, QWL_STYLE );
 198         WinSetWindowULong( sys->parent, QWL_STYLE,
 199                            i_style | WS_CLIPCHILDREN );
 200
 201         i_frame_flags = FCF_TITLEBAR;
 202     }
 203     else
 204     {
 205         sys->parent = HWND_DESKTOP;
 206
 207         i_frame_flags = FCF_SYSMENU    | FCF_TITLEBAR | FCF_MINMAX |
 208                         FCF_SIZEBORDER | FCF_TASKLIST;
 209     }
 210
 211     sys->frame =
 212         WinCreateStdWindow( sys->parent,      /* parent window handle */
 213                             WS_VISIBLE,       /* frame window style */
 214                             &i_frame_flags,   /* window style */
 215                             WC_VLC_KVA,       /* class name */
 216                             "",               /* window title */
 217                             0L,               /* default client style */
 218                             NULLHANDLE,       /* resource in exe file */
 219                             1,                /* frame window id */
 220                             &sys->client );   /* client window handle */
 221
 222     if( sys->frame == NULLHANDLE )
 223     {
 224         msg_Err( vd, "cannot create a frame window");
 225
 226         goto exit_frame;
 227     }
 228
 229     WinSetWindowPtr( sys->client, 0, vd );
 230
 231     if( !sys->parent_window )
 232     {
 233         WinSetWindowPtr( sys->frame, 0, vd );
 234         sys->p_old_frame = WinSubclassWindow( sys->frame, MyFrameWndProc );
 235     }
 236
 237     psz_mode = var_CreateGetString( vd, "kva-video-mode" );
 238
 239     i_kva_mode = KVAM_AUTO;
 240     if( strcmp( psz_mode, "snap" ) == 0 )
 241         i_kva_mode = KVAM_SNAP;
 242     else if( strcmp( psz_mode, "wo" ) == 0 )
 243         i_kva_mode = KVAM_WO;
 244     else if( strcmp( psz_mode, "vman" ) == 0 )
 245         i_kva_mode = KVAM_VMAN;
 246     else if( strcmp( psz_mode, "dive" ) == 0 )
 247         i_kva_mode = KVAM_DIVE;
 248
 249     free( psz_mode );
 250
 251     if( kvaInit( i_kva_mode, sys->client, COLOR_KEY ))
 252     {
 253         msg_Err( vd, "cannot initialize KVA");
 254
 255         goto exit_kva_init;
 256     }
 257
 258     kvaCaps( &sys->kvac );
 259
 260     msg_Dbg( vd, "selected video mode = %s",
 261              psz_video_mode[ sys->kvac.ulMode - 1 ]);
 262
 263     if( OpenDisplay( vd, &fmt ) )
 264     {
 265         msg_Err( vd, "cannot open display");
 266
 267         goto exit_open_display;
 268     }
 269
 270     if( vd->cfg->is_fullscreen )
 271     {
 272         if( sys->parent_window )
 273             vout_window_SetFullScreen(sys->parent_window, true);
 274         else
 275             WinPostMsg( sys->client, WM_VLC_FULLSCREEN_CHANGE,
 276                         MPFROMLONG( true ), 0 );
 277     }
 278
 279     kvaDisableScreenSaver();
 280
 281     /* Setup vout_display now that everything is fine */
 282     vd->fmt     = fmt;
 283     vd->info    = info;
 284
 285     vd->pool    = Pool;
 286     vd->prepare = NULL;
 287     vd->display = Display;
 288     vd->control = Control;
 289     vd->manage  = Manage;
 290
 291     /* Prevent SIG_FPE */
 292     _control87(MCW_EM, MCW_EM);
 293
 294     sys->i_result = VLC_SUCCESS;
 295     DosPostEventSem( sys->ack_event );
 296
 297     if( !sys->parent_window )
 298         WinSetVisibleRegionNotify( sys->frame, TRUE );
 299
 300     while( WinGetMsg( sys->hab, &qm, NULLHANDLE, 0, 0 ))
 301         WinDispatchMsg( sys->hab, &qm );
 302
 303     if( !sys->parent_window )
 304         WinSetVisibleRegionNotify( sys->frame, FALSE );
 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->parent_window )
 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( !sys->is_mouse_hidden &&
 441             WinWindowFromPoint( HWND_DESKTOP, &ptl, TRUE ) == sys->client )
 442         {
 443             WinShowPointer( HWND_DESKTOP, FALSE );
 444             sys->is_mouse_hidden = true;
 445         }
 446
 447         return VLC_SUCCESS;
 448     }
 449
 450     case VOUT_DISPLAY_CHANGE_FULLSCREEN:
 451     {
 452         vout_display_cfg_t cfg = *va_arg(args, const vout_display_cfg_t *);
 453
 454         if( sys->parent_window )
 455             vout_window_SetFullScreen(sys->parent_window, cfg.is_fullscreen);
 456         else
 457             WinPostMsg( sys->client, WM_VLC_FULLSCREEN_CHANGE,
 458                         MPFROMLONG( cfg.is_fullscreen ), 0 );
 459
 460         return VLC_SUCCESS;
 461     }
 462
 463     case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
 464     {
 465         const unsigned state = va_arg( args, unsigned );
 466         const bool is_on_top = (state & VOUT_WINDOW_STATE_ABOVE) != 0;
 467
 468         if( sys->parent_window )
 469         {
 470             if( vout_window_SetState( sys->parent_window, state ))
 471                 return VLC_EGENERIC;
 472         }
 473         else if( is_on_top )
 474             WinSetWindowPos( sys->frame, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER );
 475
 476         sys->is_on_top = is_on_top;
 477
 478         return VLC_SUCCESS;
 479     }
 480
 481     case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
 482     {
 483         const vout_display_cfg_t *cfg = va_arg(args, const vout_display_cfg_t *);
 484         bool  is_forced = va_arg(args, int);
 485
 486         if( is_forced )
 487         {
 488             if( sys->parent_window )
 489             {
 490                 vout_window_SetSize(sys->parent_window,
 491                                     cfg->display.width, cfg->display.height);
 492             }
 493             else
 494                 WinPostMsg( sys->client, WM_VLC_SIZE_CHANGE,
 495                             MPFROMLONG( cfg->display.width ),
 496                             MPFROMLONG( cfg->display.height ));
 497         }
 498
 499         return VLC_SUCCESS;
 500     }
 501
 502     case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
 503     case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
 504     {
 505         const video_format_t *source = va_arg(args, const video_format_t *);
 506
 507         if( query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT )
 508         {
 509             sys->kvas.ulAspectWidth  = ( int64_t )source->i_width *
 510                                        source->i_sar_num / source->i_sar_den;
 511             sys->kvas.ulAspectHeight = source->i_height;
 512         }
 513         else
 514         {
 515             sys->kvas.rclSrcRect.xLeft   = source->i_x_offset;
 516             sys->kvas.rclSrcRect.yTop    = source->i_y_offset;
 517             sys->kvas.rclSrcRect.xRight  = source->i_x_offset +
 518                                            source->i_visible_width;
 519             sys->kvas.rclSrcRect.yBottom = source->i_y_offset +
 520                                            source->i_visible_height;
 521         }
 522
 523         kvaSetup( &sys->kvas );
 524
 525         return VLC_SUCCESS;
 526     }
 527
 528     case VOUT_DISPLAY_RESET_PICTURES:
 529     case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
 530     case VOUT_DISPLAY_CHANGE_ZOOM:
 531     case VOUT_DISPLAY_GET_OPENGL:
 532         /* TODO */
 533         break;
 534     }
 535
 536     msg_Err(vd, "Unsupported query(=%d) in vout display KVA", query);
 537     return VLC_EGENERIC;
 538 }
 539
 540 /* following functions are local */
 541
 542 /*****************************************************************************
 543  * OpenDisplay: open and initialize KVA device
 544  *****************************************************************************
 545  * Open and initialize display according to preferences specified in the vout
 546  * thread fields.
 547  *****************************************************************************/
 548 static int OpenDisplay( vout_display_t *vd, video_format_t *fmt )
 549 {
 550     vout_display_sys_t * sys = vd->sys;
 551     const vlc_fourcc_t *fallback;
 552     bool b_hw_accel = 0;
 553     FOURCC i_kva_fourcc;
 554     int i_chroma_shift;
 555     char sz_title[ 256 ];
 556     RECTL rcl;
 557     int w, h;
 558
 559     msg_Dbg( vd, "render chroma = %4.4s", ( const char * )&fmt->i_chroma );
 560
 561     for( int pass = 0; pass < 2 && !b_hw_accel; pass++ )
 562     {
 563         fallback = ( pass == 0 ) ? vlc_fourcc_GetYUVFallback( fmt->i_chroma ) :
 564                                    vlc_fourcc_GetRGBFallback( fmt->i_chroma );
 565
 566         for( int i = 0; fallback[ i ]; i++ )
 567         {
 568             switch( fallback[ i ])
 569             {
 570                 case VLC_CODEC_YV12:
 571                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_YV12;
 572                     i_kva_fourcc = FOURCC_YV12;
 573                     i_chroma_shift = 1;
 574                     break;
 575
 576                 case VLC_CODEC_YUYV:
 577                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_YUY2;
 578                     i_kva_fourcc = FOURCC_Y422;
 579                     i_chroma_shift = 0;
 580                     break;
 581
 582                 case VLC_CODEC_YV9:
 583                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_YVU9;
 584                     i_kva_fourcc = FOURCC_YVU9;
 585                     i_chroma_shift = 2;
 586                     break;
 587
 588                 case VLC_CODEC_RGB32:
 589                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_BGR32;
 590                     i_kva_fourcc = FOURCC_BGR4;
 591                     i_chroma_shift = 0;
 592                     break;
 593
 594                 case VLC_CODEC_RGB24:
 595                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_BGR24;
 596                     i_kva_fourcc = FOURCC_BGR3;
 597                     i_chroma_shift = 0;
 598                     break;
 599
 600                 case VLC_CODEC_RGB16:
 601                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_BGR16;
 602                     i_kva_fourcc = FOURCC_R565;
 603                     i_chroma_shift = 0;
 604                     break;
 605
 606                 case VLC_CODEC_RGB15:
 607                     b_hw_accel = sys->kvac.ulInputFormatFlags & KVAF_BGR15;
 608                     i_kva_fourcc = FOURCC_R555;
 609                     i_chroma_shift = 0;
 610                     break;
 611             }
 612
 613             if( b_hw_accel )
 614             {
 615                 fmt->i_chroma = fallback[ i ];
 616                 break;
 617             }
 618         }
 619     }
 620
 621     if( !b_hw_accel )
 622     {
 623         msg_Err( vd, "Ooops. There is no fourcc supported by KVA at all.");
 624
 625         return VLC_EGENERIC;
 626     }
 627
 628     /* Set the RGB masks */
 629     fmt->i_rmask = sys->kvac.ulRMask;
 630     fmt->i_gmask = sys->kvac.ulGMask;
 631     fmt->i_bmask = sys->kvac.ulBMask;
 632
 633     msg_Dbg( vd, "output chroma = %4.4s", ( const char * )&fmt->i_chroma );
 634     msg_Dbg( vd, "KVA chroma = %4.4s", ( const char * )&i_kva_fourcc );
 635
 636     w = vd->source.i_width;
 637     h = vd->source.i_height;
 638
 639     sys->kvas.ulLength           = sizeof( KVASETUP );
 640     sys->kvas.szlSrcSize.cx      = w;
 641     sys->kvas.szlSrcSize.cy      = h;
 642     sys->kvas.rclSrcRect.xLeft   = 0;
 643     sys->kvas.rclSrcRect.yTop    = 0;
 644     sys->kvas.rclSrcRect.xRight  = w;
 645     sys->kvas.rclSrcRect.yBottom = h;
 646     sys->kvas.ulRatio            = KVAR_FORCEANY;
 647     sys->kvas.ulAspectWidth      = w;
 648     sys->kvas.ulAspectHeight     = h;
 649     sys->kvas.fccSrcColor        = i_kva_fourcc;
 650     sys->kvas.fDither            = TRUE;
 651
 652     if( kvaSetup( &sys->kvas ))
 653     {
 654         msg_Err( vd, "cannot set up KVA");
 655
 656         return VLC_EGENERIC;
 657     }
 658
 659     /* Create the associated picture */
 660     picture_resource_t *rsc = &sys->resource;
 661     rsc->p_sys = malloc( sizeof( *rsc->p_sys ));
 662     if( !rsc->p_sys )
 663         return VLC_EGENERIC;
 664
 665     rsc->p_sys->i_chroma_shift = i_chroma_shift;
 666
 667     for( int i = 0; i < PICTURE_PLANE_MAX; i++ )
 668     {
 669         rsc->p[ i ].p_pixels = NULL;
 670         rsc->p[ i ].i_pitch  = 0;
 671         rsc->p[ i ].i_lines  = 0;
 672     }
 673
 674     picture_t *picture = picture_NewFromResource( fmt, rsc );
 675     if( !picture )
 676         goto exit_picture;
 677
 678     /* Wrap it into a picture pool */
 679     picture_pool_configuration_t pool_cfg;
 680     memset( &pool_cfg, 0, sizeof( pool_cfg ));
 681     pool_cfg.picture_count = 1;
 682     pool_cfg.picture       = &picture;
 683     pool_cfg.lock          = KVALock;
 684     pool_cfg.unlock        = KVAUnlock;
 685
 686     sys->pool = picture_pool_NewExtended( &pool_cfg );
 687     if( !sys->pool )
 688     {
 689         picture_Release( picture );
 690
 691         goto exit_picture;
 692     }
 693
 694     if (vd->cfg->display.title)
 695         snprintf( sz_title, sizeof( sz_title ), "%s", vd->cfg->display.title );
 696     else
 697         snprintf( sz_title, sizeof( sz_title ),
 698                   "%s (%4.4s to %4.4s - %s mode KVA output)",
 699                   VOUT_TITLE,
 700                   ( char * )&vd->fmt.i_chroma,
 701                   ( char * )&sys->kvas.fccSrcColor,
 702                   psz_video_mode[ sys->kvac.ulMode - 1 ]);
 703     WinSetWindowText( sys->frame, sz_title );
 704
 705     sys->i_screen_width  = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN );
 706     sys->i_screen_height = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN );
 707
 708     if( sys->parent_window )
 709         WinQueryWindowRect( sys->parent, &sys->client_rect );
 710     else
 711     {
 712         sys->client_rect.xLeft   = ( sys->i_screen_width  - w ) / 2;
 713         sys->client_rect.yBottom = ( sys->i_screen_height - h ) / 2 ;
 714         sys->client_rect.xRight  = sys->client_rect.xLeft   + w;
 715         sys->client_rect.yTop    = sys->client_rect.yBottom + h;
 716     }
 717
 718     rcl = sys->client_rect;
 719
 720     WinCalcFrameRect( sys->frame, &rcl, FALSE);
 721
 722     WinSetWindowPos( sys->frame, HWND_TOP,
 723                      rcl.xLeft, rcl.yBottom,
 724                      rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
 725                      SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW |
 726                      SWP_ACTIVATE );
 727
 728     return VLC_SUCCESS;
 729
 730 exit_picture:
 731     free( rsc->p_sys );
 732
 733     return VLC_EGENERIC;
 734 }
 735
 736 /*****************************************************************************
 737  * CloseDisplay: close and reset KVA device
 738  *****************************************************************************
 739  * This function returns all resources allocated by OpenDisplay and restore
 740  * the original state of the device.
 741  *****************************************************************************/
 742 static void CloseDisplay( vout_display_t *vd )
 743 {
 744     VLC_UNUSED( vd );
 745 }
 746
 747 static int KVALock( picture_t *picture )
 748 {
 749     picture_sys_t *picsys = picture->p_sys;
 750     PVOID kva_buffer;
 751     ULONG kva_bpl;
 752
 753     if( kvaLockBuffer( &kva_buffer, &kva_bpl ))
 754         return VLC_EGENERIC;
 755
 756     /* Packed or Y plane */
 757     picture->p->p_pixels = ( uint8_t * )kva_buffer;
 758     picture->p->i_pitch  = kva_bpl;
 759     picture->p->i_lines  = picture->format.i_height;
 760
 761     /* Other planes */
 762     for( int n = 1; n < picture->i_planes; n++ )
 763     {
 764         const plane_t *o = &picture->p[n-1];
 765         plane_t *p = &picture->p[n];
 766
 767         p->p_pixels = o->p_pixels + o->i_lines * o->i_pitch;
 768         p->i_pitch  = kva_bpl >> picsys->i_chroma_shift;
 769         p->i_lines  = picture->format.i_height >> picsys->i_chroma_shift;
 770     }
 771
 772     return VLC_SUCCESS;
 773 }
 774
 775 static void KVAUnlock( picture_t *picture )
 776 {
 777     VLC_UNUSED( picture );
 778
 779     kvaUnlockBuffer();
 780 }
 781
 782 static void MorphToPM( void )
 783 {
 784     PPIB pib;
 785
 786     DosGetInfoBlocks(NULL, &pib);
 787
 788     /* Change flag from VIO to PM */
 789     if (pib->pib_ultype == 2)
 790         pib->pib_ultype = 3;
 791 }
 792
 793 /*****************************************************************************
 794  * Key events handling
 795  *****************************************************************************/
 796 static const struct
 797 {
 798     USHORT i_pmkey;
 799     int    i_vlckey;
 800 } pmkeys_to_vlckeys[] =
 801 {
 802     { VK_LEFT, KEY_LEFT },
 803     { VK_RIGHT, KEY_RIGHT },
 804     { VK_UP, KEY_UP },
 805     { VK_DOWN, KEY_DOWN },
 806     { VK_SPACE, ' ' },
 807     { VK_NEWLINE, KEY_ENTER },
 808     { VK_ENTER, KEY_ENTER },
 809     { VK_F1, KEY_F1 },
 810     { VK_F2, KEY_F2 },
 811     { VK_F3, KEY_F3 },
 812     { VK_F4, KEY_F4 },
 813     { VK_F5, KEY_F5 },
 814     { VK_F6, KEY_F6 },
 815     { VK_F7, KEY_F7 },
 816     { VK_F8, KEY_F8 },
 817     { VK_F9, KEY_F9 },
 818     { VK_F10, KEY_F10 },
 819     { VK_F11, KEY_F11 },
 820     { VK_F12, KEY_F12 },
 821     { VK_HOME, KEY_HOME },
 822     { VK_END, KEY_END },
 823     { VK_INSERT, KEY_INSERT },
 824     { VK_DELETE, KEY_DELETE },
 825 /*
 826     Not supported
 827     {, KEY_MENU },
 828 */
 829     { VK_ESC, KEY_ESC },
 830     { VK_PAGEUP, KEY_PAGEUP },
 831     { VK_PAGEDOWN, KEY_PAGEDOWN },
 832     { VK_TAB, KEY_TAB },
 833     { VK_BACKSPACE, KEY_BACKSPACE },
 834 /*
 835     Not supported
 836     {, KEY_MOUSEWHEELUP },
 837     {, KEY_MOUSEWHEELDOWN },
 838     {, KEY_MOUSEWHEELLEFT },
 839     {, KEY_MOUSEWHEELRIGHT },
 840
 841     {, KEY_BROWSER_BACK },
 842     {, KEY_BROWSER_FORWARD },
 843     {, KEY_BROWSER_REFRESH },
 844     {, KEY_BROWSER_STOP },
 845     {, KEY_BROWSER_SEARCH },
 846     {, KEY_BROWSER_FAVORITES },
 847     {, KEY_BROWSER_HOME },
 848     {, KEY_VOLUME_MUTE },
 849     {, KEY_VOLUME_DOWN },
 850     {, KEY_VOLUME_UP },
 851     {, KEY_MEDIA_NEXT_TRACK },
 852     {, KEY_MEDIA_PREV_TRACK },
 853     {, KEY_MEDIA_STOP },
 854     {, KEY_MEDIA_PLAY_PAUSE },
 855 */
 856
 857     { 0, 0 }
 858 };
 859
 860 static int ConvertKey( USHORT i_pmkey )
 861 {
 862     int i;
 863     for( i = 0; pmkeys_to_vlckeys[ i ].i_pmkey != 0; i++ )
 864     {
 865         if( pmkeys_to_vlckeys[ i ].i_pmkey == i_pmkey )
 866             return pmkeys_to_vlckeys[ i ].i_vlckey;
 867     }
 868     return 0;
 869 }
 870
 871 static MRESULT EXPENTRY MyFrameWndProc( HWND hwnd, ULONG msg, MPARAM mp1,
 872                                         MPARAM mp2 )
 873 {
 874     vout_display_t *vd = WinQueryWindowPtr( hwnd, 0 );
 875     vout_display_sys_t *sys = vd->sys;
 876
 877     switch( msg )
 878     {
 879         case WM_QUERYTRACKINFO :
 880         {
 881             MRESULT mr;
 882
 883             mr = sys->p_old_frame( hwnd, msg, mp1, mp2 );
 884             if( !sys->b_fixt23 )
 885                 return mr;
 886
 887             PTRACKINFO pti = ( PTRACKINFO )mp2;
 888             RECTL      rcl;
 889
 890             pti->rclBoundary.xLeft   = 0;
 891             pti->rclBoundary.yBottom = 0;
 892             pti->rclBoundary.xRight  = sys->i_screen_width;
 893             pti->rclBoundary.yTop    = sys->i_screen_height;
 894
 895             WinCalcFrameRect( hwnd, &pti->rclBoundary, FALSE );
 896
 897             pti->ptlMaxTrackSize.x = pti->rclBoundary.xRight -
 898                                      pti->rclBoundary.xLeft;
 899             pti->ptlMaxTrackSize.y = pti->rclBoundary.yTop -
 900                                      pti->rclBoundary.yBottom;
 901
 902             rcl.xLeft   = 0;
 903             rcl.yBottom = 0;
 904             rcl.xRight  = sys->kvas.szlSrcSize.cx + 1;
 905             rcl.yTop    = sys->kvas.szlSrcSize.cy + 1;
 906
 907             WinCalcFrameRect( hwnd, &rcl, FALSE );
 908
 909             pti->ptlMinTrackSize.x = rcl.xRight - rcl.xLeft;
 910             pti->ptlMinTrackSize.y = rcl.yTop - rcl.yBottom;
 911
 912             return MRFROMLONG( TRUE );
 913         }
 914
 915         case WM_ADJUSTWINDOWPOS :
 916         {
 917             if( !sys->b_fixt23 )
 918                 break;
 919
 920             PSWP  pswp = ( PSWP )mp1;
 921
 922             if( pswp->fl & SWP_SIZE )
 923             {
 924                 RECTL rcl;
 925
 926                 rcl.xLeft   = pswp->x;
 927                 rcl.yBottom = pswp->y;
 928                 rcl.xRight  = rcl.xLeft + pswp->cx;
 929                 rcl.yTop    = rcl.yBottom + pswp->cy;
 930
 931                 WinCalcFrameRect( hwnd, &rcl, TRUE );
 932
 933                 if( rcl.xRight - rcl.xLeft <= sys->kvas.szlSrcSize.cx )
 934                     rcl.xRight = rcl.xLeft + ( sys->kvas.szlSrcSize.cx + 1 );
 935
 936                 if( rcl.yTop - rcl.yBottom <= sys->kvas.szlSrcSize.cy )
 937                     rcl.yTop = rcl.yBottom + ( sys->kvas.szlSrcSize.cy + 1 );
 938
 939                 if( rcl.xRight - rcl.xLeft > sys->i_screen_width )
 940                 {
 941                     rcl.xLeft  = 0;
 942                     rcl.xRight = sys->i_screen_width;
 943                 }
 944
 945                 if( rcl.yTop - rcl.yBottom > sys->i_screen_height )
 946                 {
 947                     rcl.yBottom = 0;
 948                     rcl.yTop    = sys->i_screen_height;
 949                 }
 950
 951                 WinCalcFrameRect( hwnd, &rcl, FALSE );
 952
 953                 if( pswp->x != rcl.xLeft || pswp->y != rcl.yBottom )
 954                     pswp->fl |= SWP_MOVE;
 955
 956                 pswp->x = rcl.xLeft;
 957                 pswp->y = rcl.yBottom;
 958
 959                 pswp->cx = rcl.xRight - rcl.xLeft;
 960                 pswp->cy = rcl.yTop - rcl.yBottom;
 961             }
 962
 963             break;
 964         }
 965
 966         //case WM_VRNDISABLED :
 967         case WM_VRNENABLED :
 968             if( !vd->cfg->is_fullscreen && sys->is_on_top )
 969                 WinSetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER );
 970             break;
 971     }
 972
 973     return sys->p_old_frame( hwnd, msg, mp1, mp2 );
 974 }
 975
 976 static void MousePressed( vout_display_t *vd, HWND hwnd, unsigned button )
 977 {
 978     if( WinQueryFocus( HWND_DESKTOP ) != hwnd )
 979         WinSetFocus( HWND_DESKTOP, hwnd );
 980
 981     if( !vd->sys->button_pressed )
 982         WinSetCapture( HWND_DESKTOP, hwnd );
 983
 984     vd->sys->button_pressed |= 1 << button;
 985
 986     vout_display_SendEventMousePressed( vd, button );
 987 }
 988
 989 static void MouseReleased( vout_display_t *vd, unsigned button )
 990 {
 991     vd->sys->button_pressed &= ~(1 << button);
 992     if( !vd->sys->button_pressed )
 993         WinSetCapture( HWND_DESKTOP, NULLHANDLE );
 994
 995     vout_display_SendEventMouseReleased( vd, button );
 996 }
 997
 998 #define WM_MOUSELEAVE   0x41F
 999
1000 static MRESULT EXPENTRY WndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
1001 {
1002     vout_display_t * vd = WinQueryWindowPtr( hwnd, 0 );
1003     MRESULT result = ( MRESULT )TRUE;
1004
1005     if ( !vd )
1006         return WinDefWindowProc( hwnd, msg, mp1, mp2 );
1007
1008     vout_display_sys_t * sys = vd->sys;
1009     RECTL rcl;
1010     SWP   swp;
1011
1012     if ( sys->is_mouse_hidden &&
1013          ((msg >= WM_MOUSEFIRST    && msg <= WM_MOUSELAST) ||
1014           (msg >= WM_EXTMOUSEFIRST && msg <= WM_EXTMOUSELAST) ||
1015            msg == WM_MOUSELEAVE))
1016     {
1017         WinShowPointer(HWND_DESKTOP, TRUE);
1018         sys->is_mouse_hidden = false;
1019     }
1020
1021     switch( msg )
1022     {
1023         /* the user wants to close the window */
1024         case WM_CLOSE:
1025             vout_display_SendEventClose(vd);
1026             result = 0;
1027             break;
1028
1029         case WM_MOUSEMOVE :
1030         {
1031             SHORT i_mouse_x = SHORT1FROMMP( mp1 );
1032             SHORT i_mouse_y = SHORT2FROMMP( mp1 );
1033             RECTL movie_rect;
1034             int   i_movie_width, i_movie_height;
1035             int   i_src_width, i_src_height;
1036
1037             /* Get a current movie area */
1038             kvaAdjustDstRect( &sys->kvas.rclSrcRect, &movie_rect );
1039             i_movie_width = movie_rect.xRight - movie_rect.xLeft;
1040             i_movie_height = movie_rect.yTop - movie_rect.yBottom;
1041
1042             i_src_width =  sys->kvas.rclSrcRect.xRight -
1043                            sys->kvas.rclSrcRect.xLeft;
1044             i_src_height = sys->kvas.rclSrcRect.yBottom -
1045                            sys->kvas.rclSrcRect.yTop;
1046
1047             int x = ( i_mouse_x - movie_rect.xLeft ) *
1048                     i_src_width / i_movie_width +
1049                     sys->kvas.rclSrcRect.xLeft;
1050             int y = ( i_mouse_y - movie_rect.yBottom ) *
1051                     i_src_height / i_movie_height;
1052
1053             /* Invert Y coordinate and add y offset */
1054             y = ( i_src_height - y ) + sys->kvas.rclSrcRect.yTop;;
1055
1056             vout_display_SendEventMouseMoved(vd, x, y);
1057
1058             result = WinDefWindowProc( hwnd, msg, mp1,mp2 );
1059             break;
1060         }
1061
1062         case WM_BUTTON1DOWN :
1063             MousePressed( vd, hwnd, MOUSE_BUTTON_LEFT );
1064             break;
1065
1066         case WM_BUTTON2DOWN :
1067             MousePressed( vd, hwnd, MOUSE_BUTTON_RIGHT );
1068             break;
1069
1070         case WM_BUTTON3DOWN :
1071             MousePressed( vd, hwnd, MOUSE_BUTTON_CENTER );
1072             break;
1073
1074         case WM_BUTTON1UP :
1075             MouseReleased( vd, MOUSE_BUTTON_LEFT );
1076             break;
1077
1078         case WM_BUTTON2UP :
1079             MouseReleased( vd, MOUSE_BUTTON_RIGHT );
1080             break;
1081
1082         case WM_BUTTON3UP :
1083             MouseReleased( vd, MOUSE_BUTTON_CENTER );
1084             break;
1085
1086         case WM_BUTTON1DBLCLK :
1087             vout_display_SendEventMouseDoubleClick(vd);
1088             break;
1089
1090         case WM_TRANSLATEACCEL :
1091             /* We have no accelerator table at all */
1092             result = ( MRESULT )FALSE;
1093             break;
1094
1095         case WM_CHAR :
1096         {
1097             USHORT i_flags = SHORT1FROMMP( mp1 );
1098             USHORT i_ch    = SHORT1FROMMP( mp2 );
1099             USHORT i_vk    = SHORT2FROMMP( mp2 );
1100             int    i_key   = 0;
1101
1102             /* If embedded window, let the parent process keys */
1103             if( sys->parent_window )
1104             {
1105                 WinPostMsg( sys->parent, msg, mp1, mp2 );
1106                 break;
1107             }
1108
1109             if( !( i_flags & KC_KEYUP ))
1110             {
1111                 if( i_flags & KC_VIRTUALKEY )
1112                     /* convert the key if possible */
1113                     i_key = ConvertKey( i_vk );
1114                 else if(( i_flags & KC_CHAR ) && !HIBYTE( i_ch ))
1115                     i_key = tolower( i_ch );
1116
1117                 if( i_key )
1118                 {
1119                     if( i_flags & KC_SHIFT )
1120                        i_key |= KEY_MODIFIER_SHIFT;
1121
1122                     if( i_flags & KC_CTRL )
1123                         i_key |= KEY_MODIFIER_CTRL;
1124
1125                     if( i_flags & KC_ALT )
1126                         i_key |= KEY_MODIFIER_ALT;
1127
1128                     vout_display_SendEventKey(vd, i_key);
1129                 }
1130             }
1131             break;
1132         }
1133
1134         /* Process Manage() call */
1135         case WM_VLC_MANAGE :
1136             break;
1137
1138         /* Fullscreen change */
1139         case WM_VLC_FULLSCREEN_CHANGE :
1140             if( LONGFROMMP( mp1 ))
1141             {
1142                 WinQueryWindowPos( sys->frame, &swp );
1143                 sys->client_rect.xLeft   = swp.x;
1144                 sys->client_rect.yBottom = swp.y;
1145                 sys->client_rect.xRight  = sys->client_rect.xLeft   + swp.cx;
1146                 sys->client_rect.yTop    = sys->client_rect.yBottom + swp.cy;
1147                 WinCalcFrameRect( sys->frame, &sys->client_rect, TRUE );
1148
1149                 rcl.xLeft   = 0;
1150                 rcl.yBottom = 0;
1151                 rcl.xRight  = sys->i_screen_width;
1152                 rcl.yTop    = sys->i_screen_height;
1153             }
1154             else
1155                 rcl = sys->client_rect;
1156
1157             WinCalcFrameRect( sys->frame, &rcl, FALSE );
1158
1159             WinSetWindowPos( sys->frame, HWND_TOP,
1160                              rcl.xLeft, rcl.yBottom,
1161                              rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
1162                              SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW |
1163                              SWP_ACTIVATE );
1164             break;
1165
1166         /* Size change */
1167         case WM_VLC_SIZE_CHANGE :
1168             rcl.xLeft   = 0;
1169             rcl.yBottom = 0;
1170             rcl.xRight  = LONGFROMMP( mp1 );
1171             rcl.yTop    = LONGFROMMP( mp2 );
1172             WinCalcFrameRect( sys->frame, &rcl, FALSE );
1173
1174             WinSetWindowPos( sys->frame, NULLHANDLE,
1175                              0, 0,
1176                              rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
1177                              SWP_SIZE );
1178
1179             WinQueryWindowPos( sys->frame, &swp );
1180             sys->client_rect.xLeft   = swp.x;
1181             sys->client_rect.yBottom = swp.y;
1182             sys->client_rect.xRight  = sys->client_rect.xLeft   + swp.cx;
1183             sys->client_rect.yTop    = sys->client_rect.yBottom + swp.cy;
1184             WinCalcFrameRect( sys->frame, &sys->client_rect, TRUE );
1185             break;
1186
1187         default :
1188             return WinDefWindowProc( hwnd, msg, mp1, mp2 );
1189     }
1190
1191     /* If embedded window, we need to change our window size according to a
1192      * parent window size */
1193     if( sys->parent_window )
1194     {
1195         WinQueryWindowRect( sys->parent, &rcl );
1196
1197         if( rcl.xLeft   != sys->parent_rect.xLeft   ||
1198             rcl.yBottom != sys->parent_rect.yBottom ||
1199             rcl.xRight  != sys->parent_rect.xRight  ||
1200             rcl.yTop    != sys->parent_rect.yTop)
1201         {
1202             sys->parent_rect = rcl;
1203
1204             WinCalcFrameRect( sys->frame, &rcl, FALSE );
1205
1206             WinSetWindowPos( sys->frame, NULLHANDLE,
1207                              rcl.xLeft, rcl.yBottom,
1208                              rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
1209                              SWP_SIZE | SWP_MOVE );
1210         }
1211     }
1212
1213     return result;
1214 }