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

   1 /*****************************************************************************
   2  * vout.c: Windows DirectX video output display method
   3  *****************************************************************************
   4  * Copyright (C) 2001-2009 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble:
  26  *
  27  * This plugin will use YUV overlay if supported, using overlay will result in
  28  * the best video quality (hardware interpolation when rescaling the picture)
  29  * and the fastest display as it requires less processing.
  30  *
  31  * If YUV overlay is not supported this plugin will use RGB offscreen video
  32  * surfaces that will be blitted onto the primary surface (display) to
  33  * effectively display the pictures. This fallback method also enables us to
  34  * display video in window mode.
  35  *
  36  *****************************************************************************/
  37 #include <errno.h>                                                 /* ENOMEM */
  38
  39 #ifdef HAVE_CONFIG_H
  40 # include "config.h"
  41 #endif
  42
  43 #include <vlc_common.h>
  44 #include <vlc_plugin.h>
  45 #include <vlc_interface.h>
  46 #include <vlc_playlist.h>
  47 #include <vlc_vout.h>
  48
  49 #include <windows.h>
  50 #include <tchar.h>
  51 #include <ddraw.h>
  52 #include <commctrl.h>
  53
  54 #ifndef UNDER_CE
  55 #   include <multimon.h>
  56 #endif
  57 #undef GetSystemMetrics
  58
  59 #ifndef MONITOR_DEFAULTTONEAREST
  60 #   define MONITOR_DEFAULTTONEAREST 2
  61 #endif
  62
  63 #include "vout.h"
  64
  65 /*****************************************************************************
  66  * picture_sys_t: direct buffer method descriptor
  67  *****************************************************************************
  68  * This structure is part of the picture descriptor, it describes the
  69  * DirectX specific properties of a direct buffer.
  70  *****************************************************************************/
  71 struct picture_sys_t
  72 {
  73     LPDIRECTDRAWSURFACE2 p_surface;
  74     LPDIRECTDRAWSURFACE2 p_front_surface;
  75     DDSURFACEDESC        ddsd;
  76 };
  77
  78 /*****************************************************************************
  79  * DirectDraw GUIDs.
  80  * Defining them here allows us to get rid of the dxguid library during
  81  * the linking stage.
  82  *****************************************************************************/
  83 #include <initguid.h>
  84 #undef GUID_EXT
  85 #define GUID_EXT
  86 DEFINE_GUID( IID_IDirectDraw2, 0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 );
  87 DEFINE_GUID( IID_IDirectDrawSurface2, 0x57805885,0x6eec,0x11cf,0x94,0x41,0xa8,0x23,0x03,0xc1,0x0e,0x27 );
  88
  89 /*****************************************************************************
  90  * Local prototypes.
  91  *****************************************************************************/
  92 static int  OpenVideo  ( vlc_object_t * );
  93 static void CloseVideo ( vlc_object_t * );
  94
  95 static int  Init      ( vout_thread_t * );
  96 static void End       ( vout_thread_t * );
  97 static int  Manage    ( vout_thread_t * );
  98 static void Display   ( vout_thread_t *, picture_t * );
  99 static void FirstDisplay( vout_thread_t *, picture_t * );
 100 static void SetPalette( vout_thread_t *, uint16_t *, uint16_t *, uint16_t * );
 101
 102 static int  NewPictureVec  ( vout_thread_t *, picture_t *, int );
 103 static void FreePictureVec ( vout_thread_t *, picture_t *, int );
 104 static int  UpdatePictureStruct( vout_thread_t *, picture_t *, int );
 105
 106 static int  DirectXInitDDraw      ( vout_thread_t *p_vout );
 107 static void DirectXCloseDDraw     ( vout_thread_t *p_vout );
 108 static int  DirectXCreateDisplay  ( vout_thread_t *p_vout );
 109 static void DirectXCloseDisplay   ( vout_thread_t *p_vout );
 110 static int  DirectXCreateSurface  ( vout_thread_t *p_vout,
 111                                     LPDIRECTDRAWSURFACE2 *, int, int, int );
 112 static void DirectXCloseSurface   ( vout_thread_t *p_vout,
 113                                     LPDIRECTDRAWSURFACE2 );
 114 static int  DirectXCreateClipper  ( vout_thread_t *p_vout );
 115 static void DirectXGetDDrawCaps   ( vout_thread_t *p_vout );
 116 static int  DirectXLockSurface    ( vout_thread_t *p_vout, picture_t *p_pic );
 117 static int  DirectXUnlockSurface  ( vout_thread_t *p_vout, picture_t *p_pic );
 118
 119 static DWORD DirectXFindColorkey( vout_thread_t *p_vout, uint32_t *i_color );
 120
 121 void SwitchWallpaperMode( vout_thread_t *, bool );
 122
 123 /* Object variables callbacks */
 124 static int FindDevicesCallback( vlc_object_t *, char const *,
 125                                 vlc_value_t, vlc_value_t, void * );
 126 static int WallpaperCallback( vlc_object_t *, char const *,
 127                               vlc_value_t, vlc_value_t, void * );
 128
 129 /*****************************************************************************
 130  * Module descriptor
 131  *****************************************************************************/
 132 #define HW_YUV_TEXT N_("Use hardware YUV->RGB conversions")
 133 #define HW_YUV_LONGTEXT N_( \
 134     "Try to use hardware acceleration for YUV->RGB conversions. " \
 135     "This option doesn't have any effect when using overlays." )
 136
 137 #define SYSMEM_TEXT N_("Use video buffers in system memory")
 138 #define SYSMEM_LONGTEXT N_( \
 139     "Create video buffers in system memory instead of video memory. This " \
 140     "isn't recommended as usually using video memory allows to benefit from " \
 141     "more hardware acceleration (like rescaling or YUV->RGB conversions). " \
 142     "This option doesn't have any effect when using overlays." )
 143
 144 #define TRIPLEBUF_TEXT N_("Use triple buffering for overlays")
 145 #define TRIPLEBUF_LONGTEXT N_( \
 146     "Try to use triple buffering when using YUV overlays. That results in " \
 147     "much better video quality (no flickering)." )
 148
 149 #define DEVICE_TEXT N_("Name of desired display device")
 150 #define DEVICE_LONGTEXT N_("In a multiple monitor configuration, you can " \
 151     "specify the Windows device name of the display that you want the video " \
 152     "window to open on. For example, \"\\\\.\\DISPLAY1\" or " \
 153     "\"\\\\.\\DISPLAY2\"." )
 154
 155 #define WALLPAPER_TEXT N_("Enable wallpaper mode ")
 156 #define WALLPAPER_LONGTEXT N_( \
 157     "The wallpaper mode allows you to display the video as the desktop " \
 158     "background. Note that this feature only works in overlay mode and " \
 159     "the desktop must not already have a wallpaper." )
 160
 161 static const char *const ppsz_dev[] = { "" };
 162 static const char *const ppsz_dev_text[] = { N_("Default") };
 163
 164 vlc_module_begin ()
 165     set_shortname( "DirectX" )
 166     set_category( CAT_VIDEO )
 167     set_subcategory( SUBCAT_VIDEO_VOUT )
 168     add_bool( "directx-hw-yuv", 1, NULL, HW_YUV_TEXT, HW_YUV_LONGTEXT,
 169               true )
 170     add_bool( "directx-use-sysmem", 0, NULL, SYSMEM_TEXT, SYSMEM_LONGTEXT,
 171               true )
 172     add_bool( "directx-3buffering", 1, NULL, TRIPLEBUF_TEXT,
 173               TRIPLEBUF_LONGTEXT, true )
 174
 175     add_string( "directx-device", "", NULL, DEVICE_TEXT, DEVICE_LONGTEXT,
 176                 true )
 177         change_string_list( ppsz_dev, ppsz_dev_text, FindDevicesCallback )
 178         change_action_add( FindDevicesCallback, N_("Refresh list") )
 179
 180     add_bool( "directx-wallpaper", 0, NULL, WALLPAPER_TEXT, WALLPAPER_LONGTEXT,
 181               true )
 182
 183     set_description( N_("DirectX video output") )
 184     set_capability( "video output", 100 )
 185     add_shortcut( "directx" )
 186     set_callbacks( OpenVideo, CloseVideo )
 187
 188     /* FIXME: Hack to avoid unregistering our window class */
 189     linked_with_a_crap_library_which_uses_atexit ()
 190 vlc_module_end ()
 191
 192 #if 0 /* FIXME */
 193     /* check if we registered a window class because we need to
 194      * unregister it */
 195     WNDCLASS wndclass;
 196     if( GetClassInfo( GetModuleHandle(NULL), "VLC DirectX", &wndclass ) )
 197         UnregisterClass( "VLC DirectX", GetModuleHandle(NULL) );
 198 #endif
 199
 200 /*****************************************************************************
 201  * OpenVideo: allocate DirectX video thread output method
 202  *****************************************************************************
 203  * This function allocates and initialize the DirectX vout method.
 204  *****************************************************************************/
 205 static int OpenVideo( vlc_object_t *p_this )
 206 {
 207     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 208     vlc_value_t val;
 209     HMODULE huser32;
 210
 211     /* Allocate structure */
 212     p_vout->p_sys = calloc( 1, sizeof( vout_sys_t ) );
 213     if( p_vout->p_sys == NULL )
 214         return VLC_ENOMEM;
 215
 216     /* Initialisations */
 217     p_vout->pf_init = Init;
 218     p_vout->pf_end = End;
 219     p_vout->pf_manage = Manage;
 220     p_vout->pf_render = NULL;
 221     p_vout->pf_display = FirstDisplay;
 222
 223     p_vout->p_sys->p_ddobject = NULL;
 224     p_vout->p_sys->p_display = NULL;
 225     p_vout->p_sys->p_current_surface = NULL;
 226     p_vout->p_sys->p_clipper = NULL;
 227     p_vout->p_sys->hwnd = p_vout->p_sys->hvideownd = NULL;
 228     p_vout->p_sys->hparent = p_vout->p_sys->hfswnd = NULL;
 229     p_vout->p_sys->i_changes = 0;
 230     p_vout->p_sys->b_wallpaper = 0;
 231     vlc_mutex_init( &p_vout->p_sys->lock );
 232     SetRectEmpty( &p_vout->p_sys->rect_display );
 233     SetRectEmpty( &p_vout->p_sys->rect_parent );
 234
 235     /* Multimonitor stuff */
 236     p_vout->p_sys->hmonitor = NULL;
 237     p_vout->p_sys->p_display_driver = NULL;
 238     p_vout->p_sys->MonitorFromWindow = NULL;
 239     p_vout->p_sys->GetMonitorInfo = NULL;
 240     if( (huser32 = GetModuleHandle( _T("USER32") ) ) )
 241     {
 242         p_vout->p_sys->MonitorFromWindow = (HMONITOR (WINAPI *)( HWND, DWORD ))
 243             GetProcAddress( huser32, _T("MonitorFromWindow") );
 244         p_vout->p_sys->GetMonitorInfo =
 245 #ifndef UNICODE
 246             GetProcAddress( huser32, "GetMonitorInfoA" );
 247 #else
 248             GetProcAddress( huser32, _T("GetMonitorInfoW") );
 249 #endif
 250     }
 251
 252     var_Create( p_vout, "overlay", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 253     var_Create( p_vout, "directx-use-sysmem", VLC_VAR_BOOL|VLC_VAR_DOINHERIT );
 254     var_Create( p_vout, "directx-hw-yuv", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 255     var_Create( p_vout, "directx-3buffering", VLC_VAR_BOOL|VLC_VAR_DOINHERIT );
 256     var_Create( p_vout, "directx-device", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 257     var_Create( p_vout, "video-title", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 258     var_Create( p_vout, "disable-screensaver", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 259
 260     p_vout->p_sys->b_cursor_hidden = 0;
 261     p_vout->p_sys->i_lastmoved = mdate();
 262     p_vout->p_sys->i_mouse_hide_timeout =
 263         var_GetInteger(p_vout, "mouse-hide-timeout") * 1000;
 264
 265     /* Set main window's size */
 266     p_vout->p_sys->i_window_width = p_vout->i_window_width;
 267     p_vout->p_sys->i_window_height = p_vout->i_window_height;
 268
 269     /* Create the Vout EventThread, this thread is created by us to isolate
 270      * the Win32 PeekMessage function calls. We want to do this because
 271      * Windows can stay blocked inside this call for a long time, and when
 272      * this happens it thus blocks vlc's video_output thread.
 273      * DirectXEventThread will take care of the creation of the video
 274      * window (because PeekMessage has to be called from the same thread which
 275      * created the window). */
 276     msg_Dbg( p_vout, "creating DirectXEventThread" );
 277     p_vout->p_sys->p_event =
 278         vlc_object_create( p_vout, sizeof(event_thread_t) );
 279     p_vout->p_sys->p_event->p_vout = p_vout;
 280     p_vout->p_sys->p_event->window_ready = CreateEvent( NULL, TRUE, FALSE, NULL );
 281     if( vlc_thread_create( p_vout->p_sys->p_event, "Vout Events Thread",
 282                            EventThread, 0 ) )
 283     {
 284         msg_Err( p_vout, "cannot create Vout EventThread" );
 285         CloseHandle( p_vout->p_sys->p_event->window_ready );
 286         vlc_object_release( p_vout->p_sys->p_event );
 287         p_vout->p_sys->p_event = NULL;
 288         goto error;
 289     }
 290     WaitForSingleObject( p_vout->p_sys->p_event->window_ready, INFINITE );
 291     CloseHandle( p_vout->p_sys->p_event->window_ready );
 292
 293     if( p_vout->p_sys->p_event->b_error )
 294     {
 295         msg_Err( p_vout, "Vout EventThread failed" );
 296         goto error;
 297     }
 298
 299     vlc_object_attach( p_vout->p_sys->p_event, p_vout );
 300
 301     msg_Dbg( p_vout, "Vout EventThread running" );
 302
 303     /* Initialise DirectDraw */
 304     if( DirectXInitDDraw( p_vout ) )
 305     {
 306         msg_Err( p_vout, "cannot initialize DirectX DirectDraw" );
 307         goto error;
 308     }
 309
 310     /* Create the directx display */
 311     if( DirectXCreateDisplay( p_vout ) )
 312     {
 313         msg_Err( p_vout, "cannot initialize DirectX DirectDraw" );
 314         goto error;
 315     }
 316
 317     /* Variable to indicate if the window should be on top of others */
 318     /* Trigger a callback right now */
 319     var_TriggerCallback( p_vout, "video-on-top" );
 320
 321     /* Variable to indicate if the window should be on top of others */
 322     /* Trigger a callback right now */
 323     var_Create( p_vout, "directx-wallpaper", VLC_VAR_BOOL|VLC_VAR_DOINHERIT );
 324     val.psz_string = _("Wallpaper");
 325     var_Change( p_vout, "directx-wallpaper", VLC_VAR_SETTEXT, &val, NULL );
 326     var_AddCallback( p_vout, "directx-wallpaper", WallpaperCallback, NULL );
 327     var_TriggerCallback( p_vout, "directx-wallpaper" );
 328
 329     /* disable screensaver by temporarily changing system settings */
 330     p_vout->p_sys->i_spi_lowpowertimeout = 0;
 331     p_vout->p_sys->i_spi_powerofftimeout = 0;
 332     p_vout->p_sys->i_spi_screensavetimeout = 0;
 333     if( var_GetBool( p_vout, "disable-screensaver" ) ) {
 334         msg_Dbg(p_vout, "disabling screen saver");
 335         SystemParametersInfo(SPI_GETLOWPOWERTIMEOUT,
 336             0, &(p_vout->p_sys->i_spi_lowpowertimeout), 0);
 337         if( 0 != p_vout->p_sys->i_spi_lowpowertimeout ) {
 338             SystemParametersInfo(SPI_SETLOWPOWERTIMEOUT, 0, NULL, 0);
 339         }
 340         SystemParametersInfo(SPI_GETPOWEROFFTIMEOUT, 0,
 341             &(p_vout->p_sys->i_spi_powerofftimeout), 0);
 342         if( 0 != p_vout->p_sys->i_spi_powerofftimeout ) {
 343             SystemParametersInfo(SPI_SETPOWEROFFTIMEOUT, 0, NULL, 0);
 344         }
 345         SystemParametersInfo(SPI_GETSCREENSAVETIMEOUT, 0,
 346             &(p_vout->p_sys->i_spi_screensavetimeout), 0);
 347         if( 0 != p_vout->p_sys->i_spi_screensavetimeout ) {
 348             SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT, 0, NULL, 0);
 349         }
 350     }
 351
 352     return VLC_SUCCESS;
 353
 354  error:
 355     CloseVideo( VLC_OBJECT(p_vout) );
 356     return VLC_EGENERIC;
 357 }
 358
 359 /*****************************************************************************
 360  * Init: initialize DirectX video thread output method
 361  *****************************************************************************
 362  * This function create the directx surfaces needed by the output thread.
 363  * It is called at the beginning of the thread.
 364  *****************************************************************************/
 365 static int Init( vout_thread_t *p_vout )
 366 {
 367     int i_chroma_backup;
 368
 369     /* Get a few default parameters */
 370     p_vout->p_sys->b_using_overlay = var_GetBool( p_vout, "overlay" );
 371     p_vout->p_sys->b_use_sysmem = var_GetBool( p_vout, "directx-use-sysmem" );
 372     p_vout->p_sys->b_hw_yuv = var_GetBool( p_vout, "directx-hw-yuv" );
 373     p_vout->p_sys->b_3buf_overlay = var_GetBool( p_vout, "directx-3buffering" );
 374
 375     /* Initialise DirectDraw if not already done.
 376      * We do this here because on multi-monitor systems we may have to
 377      * re-create the directdraw surfaces. */
 378     if( !p_vout->p_sys->p_ddobject &&
 379         DirectXInitDDraw( p_vout ) != VLC_SUCCESS )
 380     {
 381         msg_Err( p_vout, "cannot initialize DirectDraw" );
 382         return VLC_EGENERIC;
 383     }
 384
 385     /* Create the directx display */
 386     if( !p_vout->p_sys->p_display &&
 387         DirectXCreateDisplay( p_vout ) != VLC_SUCCESS )
 388     {
 389         msg_Err( p_vout, "cannot initialize DirectDraw" );
 390         return VLC_EGENERIC;
 391     }
 392
 393     /* Initialize the output structure.
 394      * Since DirectDraw can do rescaling for us, stick to the default
 395      * coordinates and aspect. */
 396     p_vout->output.i_width  = p_vout->render.i_width;
 397     p_vout->output.i_height = p_vout->render.i_height;
 398     p_vout->output.i_aspect = p_vout->render.i_aspect;
 399     p_vout->fmt_out = p_vout->fmt_in;
 400     UpdateRects( p_vout, true );
 401
 402 #define MAX_DIRECTBUFFERS 1
 403     /* Right now we use only 1 directbuffer because we don't want the
 404      * video decoder to decode directly into direct buffers as they are
 405      * created into video memory and video memory is _really_ slow */
 406
 407     /* Choose the chroma we will try first. */
 408     switch( p_vout->render.i_chroma )
 409     {
 410         case VLC_FOURCC('Y','U','Y','2'):
 411         case VLC_FOURCC('Y','U','N','V'):
 412             p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
 413             break;
 414         case VLC_FOURCC('U','Y','V','Y'):
 415         case VLC_FOURCC('U','Y','N','V'):
 416         case VLC_FOURCC('Y','4','2','2'):
 417             p_vout->output.i_chroma = VLC_FOURCC('U','Y','V','Y');
 418             break;
 419         case VLC_FOURCC('Y','V','Y','U'):
 420             p_vout->output.i_chroma = VLC_FOURCC('Y','V','Y','U');
 421             break;
 422         default:
 423             p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
 424             break;
 425     }
 426
 427     NewPictureVec( p_vout, p_vout->p_picture, MAX_DIRECTBUFFERS );
 428
 429     i_chroma_backup = p_vout->output.i_chroma;
 430
 431     if( !I_OUTPUTPICTURES )
 432     {
 433         /* hmmm, it didn't work! Let's try commonly supported chromas */
 434         if( p_vout->output.i_chroma != VLC_FOURCC('I','4','2','0') )
 435         {
 436             p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
 437             NewPictureVec( p_vout, p_vout->p_picture, MAX_DIRECTBUFFERS );
 438         }
 439         if( !I_OUTPUTPICTURES )
 440         {
 441             /* hmmm, it still didn't work! Let's try another one */
 442             p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
 443             NewPictureVec( p_vout, p_vout->p_picture, MAX_DIRECTBUFFERS );
 444         }
 445     }
 446
 447     if( !I_OUTPUTPICTURES )
 448     {
 449         /* If it still didn't work then don't try to use an overlay */
 450         p_vout->output.i_chroma = i_chroma_backup;
 451         p_vout->p_sys->b_using_overlay = 0;
 452         msg_Warn( p_vout, "Could not initialize directx overlay" ) ;
 453         NewPictureVec( p_vout, p_vout->p_picture, MAX_DIRECTBUFFERS );
 454     }
 455
 456     /* Change the window title bar text */
 457     PostMessage( p_vout->p_sys->hwnd, WM_VLC_CHANGE_TEXT, 0, 0 );
 458
 459     p_vout->fmt_out.i_chroma = p_vout->output.i_chroma;
 460     return VLC_SUCCESS;
 461 }
 462
 463 /*****************************************************************************
 464  * End: terminate Sys video thread output method
 465  *****************************************************************************
 466  * Terminate an output method created by Create.
 467  * It is called at the end of the thread.
 468  *****************************************************************************/
 469 static void End( vout_thread_t *p_vout )
 470 {
 471     FreePictureVec( p_vout, p_vout->p_picture, I_OUTPUTPICTURES );
 472
 473     DirectXCloseDisplay( p_vout );
 474     DirectXCloseDDraw( p_vout );
 475
 476     return;
 477 }
 478
 479 /*****************************************************************************
 480  * CloseVideo: destroy Sys video thread output method
 481  *****************************************************************************
 482  * Terminate an output method created by Create
 483  *****************************************************************************/
 484 static void CloseVideo( vlc_object_t *p_this )
 485 {
 486     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 487
 488     if( p_vout->b_fullscreen )
 489     {
 490         msg_Dbg( p_vout, "Quitting fullscreen" );
 491         Win32ToggleFullscreen( p_vout );
 492         /* Force fullscreen in the core for the next video */
 493         var_SetBool( p_vout, "fullscreen", true );
 494     }
 495
 496     if( p_vout->p_sys->p_event )
 497     {
 498         vlc_object_detach( p_vout->p_sys->p_event );
 499
 500         /* Kill Vout EventThread */
 501         vlc_object_kill( p_vout->p_sys->p_event );
 502
 503         /* we need to be sure Vout EventThread won't stay stuck in
 504          * GetMessage, so we send a fake message */
 505         if( p_vout->p_sys->hwnd )
 506         {
 507             PostMessage( p_vout->p_sys->hwnd, WM_NULL, 0, 0);
 508         }
 509
 510         vlc_thread_join( p_vout->p_sys->p_event );
 511         vlc_object_release( p_vout->p_sys->p_event );
 512     }
 513
 514     vlc_mutex_destroy( &p_vout->p_sys->lock );
 515
 516     /* Make sure the wallpaper is restored */
 517     SwitchWallpaperMode( p_vout, false );
 518
 519     /* restore screensaver system settings */
 520     if( 0 != p_vout->p_sys->i_spi_lowpowertimeout ) {
 521         SystemParametersInfo(SPI_SETLOWPOWERTIMEOUT,
 522             p_vout->p_sys->i_spi_lowpowertimeout, NULL, 0);
 523     }
 524     if( 0 != p_vout->p_sys->i_spi_powerofftimeout ) {
 525         SystemParametersInfo(SPI_SETPOWEROFFTIMEOUT,
 526             p_vout->p_sys->i_spi_powerofftimeout, NULL, 0);
 527     }
 528     if( 0 != p_vout->p_sys->i_spi_screensavetimeout ) {
 529         SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT,
 530             p_vout->p_sys->i_spi_screensavetimeout, NULL, 0);
 531     }
 532
 533     free( p_vout->p_sys );
 534     p_vout->p_sys = NULL;
 535 }
 536
 537 /*****************************************************************************
 538  * Manage: handle Sys events
 539  *****************************************************************************
 540  * This function should be called regularly by the video output thread.
 541  * It returns a non null value if an error occurred.
 542  *****************************************************************************/
 543 static int Manage( vout_thread_t *p_vout )
 544 {
 545     /* If we do not control our window, we check for geometry changes
 546      * ourselves because the parent might not send us its events. */
 547     vlc_mutex_lock( &p_vout->p_sys->lock );
 548     if( p_vout->p_sys->hparent && !p_vout->b_fullscreen )
 549     {
 550         RECT rect_parent;
 551         POINT point;
 552
 553         vlc_mutex_unlock( &p_vout->p_sys->lock );
 554
 555         GetClientRect( p_vout->p_sys->hparent, &rect_parent );
 556         point.x = point.y = 0;
 557         ClientToScreen( p_vout->p_sys->hparent, &point );
 558         OffsetRect( &rect_parent, point.x, point.y );
 559
 560         if( !EqualRect( &rect_parent, &p_vout->p_sys->rect_parent ) )
 561         {
 562             p_vout->p_sys->rect_parent = rect_parent;
 563
 564             /* This one is to force the update even if only
 565              * the position has changed */
 566             SetWindowPos( p_vout->p_sys->hwnd, 0, 1, 1,
 567                           rect_parent.right - rect_parent.left,
 568                           rect_parent.bottom - rect_parent.top, 0 );
 569
 570             SetWindowPos( p_vout->p_sys->hwnd, 0, 0, 0,
 571                           rect_parent.right - rect_parent.left,
 572                           rect_parent.bottom - rect_parent.top, 0 );
 573         }
 574     }
 575     else
 576     {
 577         vlc_mutex_unlock( &p_vout->p_sys->lock );
 578     }
 579
 580     /*
 581      * Position Change
 582      */
 583     if( p_vout->p_sys->i_changes & DX_POSITION_CHANGE )
 584     {
 585         p_vout->p_sys->i_changes &= ~DX_POSITION_CHANGE;
 586
 587         /* Check if we are still on the same monitor */
 588         if( p_vout->p_sys->MonitorFromWindow &&
 589             p_vout->p_sys->hmonitor !=
 590                 p_vout->p_sys->MonitorFromWindow( p_vout->p_sys->hwnd,
 591                                                   MONITOR_DEFAULTTONEAREST ) )
 592         {
 593             /* This will force the vout core to recreate the picture buffers */
 594             p_vout->i_changes |= VOUT_PICTURE_BUFFERS_CHANGE;
 595         }
 596     }
 597
 598     /* autoscale toggle */
 599     if( p_vout->i_changes & VOUT_SCALE_CHANGE )
 600     {
 601         p_vout->i_changes &= ~VOUT_SCALE_CHANGE;
 602
 603         p_vout->b_autoscale = var_GetBool( p_vout, "autoscale" );
 604         p_vout->i_zoom = (int) ZOOM_FP_FACTOR;
 605
 606         UpdateRects( p_vout, true );
 607     }
 608
 609     /* scaling factor */
 610     if( p_vout->i_changes & VOUT_ZOOM_CHANGE )
 611     {
 612         p_vout->i_changes &= ~VOUT_ZOOM_CHANGE;
 613
 614         p_vout->b_autoscale = false;
 615         p_vout->i_zoom =
 616             (int)( ZOOM_FP_FACTOR * var_GetFloat( p_vout, "scale" ) );
 617         UpdateRects( p_vout, true );
 618     }
 619
 620     /* Check for cropping / aspect changes */
 621     if( p_vout->i_changes & VOUT_CROP_CHANGE ||
 622         p_vout->i_changes & VOUT_ASPECT_CHANGE )
 623     {
 624         p_vout->i_changes &= ~VOUT_CROP_CHANGE;
 625         p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
 626
 627         p_vout->fmt_out.i_x_offset = p_vout->fmt_in.i_x_offset;
 628         p_vout->fmt_out.i_y_offset = p_vout->fmt_in.i_y_offset;
 629         p_vout->fmt_out.i_visible_width = p_vout->fmt_in.i_visible_width;
 630         p_vout->fmt_out.i_visible_height = p_vout->fmt_in.i_visible_height;
 631         p_vout->fmt_out.i_aspect = p_vout->fmt_in.i_aspect;
 632         p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
 633         p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
 634         p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
 635         UpdateRects( p_vout, true );
 636     }
 637
 638     /* We used to call the Win32 PeekMessage function here to read the window
 639      * messages. But since window can stay blocked into this function for a
 640      * long time (for example when you move your window on the screen), I
 641      * decided to isolate PeekMessage in another thread. */
 642
 643     if( p_vout->p_sys->i_changes & DX_WALLPAPER_CHANGE )
 644     {
 645         SwitchWallpaperMode( p_vout, !p_vout->p_sys->b_wallpaper );
 646         p_vout->p_sys->i_changes &= ~DX_WALLPAPER_CHANGE;
 647         DirectDrawUpdateOverlay( p_vout );
 648     }
 649
 650     /*
 651      * Fullscreen change
 652      */
 653     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE
 654         || p_vout->p_sys->i_changes & VOUT_FULLSCREEN_CHANGE )
 655     {
 656         Win32ToggleFullscreen( p_vout );
 657
 658         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
 659         p_vout->p_sys->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
 660     }
 661
 662     /*
 663      * Pointer change
 664      */
 665     if( p_vout->b_fullscreen && !p_vout->p_sys->b_cursor_hidden &&
 666         (mdate() - p_vout->p_sys->i_lastmoved) >
 667             p_vout->p_sys->i_mouse_hide_timeout )
 668     {
 669         POINT point;
 670         HWND hwnd;
 671
 672         /* Hide the cursor only if it is inside our window */
 673         GetCursorPos( &point );
 674         hwnd = WindowFromPoint(point);
 675         if( hwnd == p_vout->p_sys->hwnd || hwnd == p_vout->p_sys->hvideownd )
 676         {
 677             PostMessage( p_vout->p_sys->hwnd, WM_VLC_HIDE_MOUSE, 0, 0 );
 678         }
 679         else
 680         {
 681             p_vout->p_sys->i_lastmoved = mdate();
 682         }
 683     }
 684
 685     /*
 686      * "Always on top" status change
 687      */
 688     if( p_vout->p_sys->b_on_top_change )
 689     {
 690         vlc_value_t val;
 691         HMENU hMenu = GetSystemMenu( p_vout->p_sys->hwnd, FALSE );
 692
 693         var_Get( p_vout, "video-on-top", &val );
 694
 695         /* Set the window on top if necessary */
 696         if( val.b_bool && !( GetWindowLong( p_vout->p_sys->hwnd, GWL_EXSTYLE )
 697                            & WS_EX_TOPMOST ) )
 698         {
 699             CheckMenuItem( hMenu, IDM_TOGGLE_ON_TOP,
 700                            MF_BYCOMMAND | MFS_CHECKED );
 701             SetWindowPos( p_vout->p_sys->hwnd, HWND_TOPMOST, 0, 0, 0, 0,
 702                           SWP_NOSIZE | SWP_NOMOVE );
 703         }
 704         else
 705         /* The window shouldn't be on top */
 706         if( !val.b_bool && ( GetWindowLong( p_vout->p_sys->hwnd, GWL_EXSTYLE )
 707                            & WS_EX_TOPMOST ) )
 708         {
 709             CheckMenuItem( hMenu, IDM_TOGGLE_ON_TOP,
 710                            MF_BYCOMMAND | MFS_UNCHECKED );
 711             SetWindowPos( p_vout->p_sys->hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
 712                           SWP_NOSIZE | SWP_NOMOVE );
 713         }
 714
 715         p_vout->p_sys->b_on_top_change = false;
 716     }
 717
 718     /* Check if the event thread is still running */
 719     if( !vlc_object_alive (p_vout->p_sys->p_event) )
 720     {
 721         return VLC_EGENERIC; /* exit */
 722     }
 723
 724     return VLC_SUCCESS;
 725 }
 726
 727 /*****************************************************************************
 728  * Display: displays previously rendered output
 729  *****************************************************************************
 730  * This function sends the currently rendered image to the display, wait until
 731  * it is displayed and switch the two rendering buffers, preparing next frame.
 732  *****************************************************************************/
 733 static void Display( vout_thread_t *p_vout, picture_t *p_pic )
 734 {
 735     HRESULT dxresult;
 736
 737     if( (p_vout->p_sys->p_display == NULL) )
 738     {
 739         msg_Warn( p_vout, "no display!" );
 740         return;
 741     }
 742
 743     /* Our surface can be lost so be sure to check this
 744      * and restore it if need be */
 745     if( IDirectDrawSurface2_IsLost( p_vout->p_sys->p_display )
 746         == DDERR_SURFACELOST )
 747     {
 748         if( IDirectDrawSurface2_Restore( p_vout->p_sys->p_display ) == DD_OK &&
 749             p_vout->p_sys->b_using_overlay )
 750             DirectDrawUpdateOverlay( p_vout );
 751     }
 752
 753     if( !p_vout->p_sys->b_using_overlay )
 754     {
 755         DDBLTFX  ddbltfx;
 756
 757         /* We ask for the "NOTEARING" option */
 758         memset( &ddbltfx, 0, sizeof(DDBLTFX) );
 759         ddbltfx.dwSize = sizeof(DDBLTFX);
 760         ddbltfx.dwDDFX = DDBLTFX_NOTEARING;
 761
 762         /* Blit video surface to display */
 763         dxresult = IDirectDrawSurface2_Blt( p_vout->p_sys->p_display,
 764                                             &p_vout->p_sys->rect_dest_clipped,
 765                                             p_pic->p_sys->p_surface,
 766                                             &p_vout->p_sys->rect_src_clipped,
 767                                             DDBLT_ASYNC, &ddbltfx );
 768         if( dxresult != DD_OK )
 769         {
 770             msg_Warn( p_vout, "could not blit surface (error %li)", dxresult );
 771             return;
 772         }
 773     }
 774     else /* using overlay */
 775     {
 776         /* Flip the overlay buffers if we are using back buffers */
 777         if( p_pic->p_sys->p_front_surface == p_pic->p_sys->p_surface )
 778         {
 779             return;
 780         }
 781
 782         dxresult = IDirectDrawSurface2_Flip( p_pic->p_sys->p_front_surface,
 783                                              NULL, DDFLIP_WAIT );
 784         if( dxresult != DD_OK )
 785         {
 786             msg_Warn( p_vout, "could not flip overlay (error %li)", dxresult );
 787         }
 788
 789         /* set currently displayed pic */
 790         p_vout->p_sys->p_current_surface = p_pic->p_sys->p_front_surface;
 791
 792         /* Lock surface to get all the required info */
 793         if( DirectXLockSurface( p_vout, p_pic ) )
 794         {
 795             /* AAARRGG */
 796             msg_Warn( p_vout, "cannot lock surface" );
 797             return;
 798         }
 799         DirectXUnlockSurface( p_vout, p_pic );
 800     }
 801 }
 802
 803 /*
 804 ** this function is only used once when the first picture is received
 805 ** this function will show the video window once video is ready for
 806 ** display.
 807 */
 808
 809 static void FirstDisplay( vout_thread_t *p_vout, picture_t *p_pic )
 810 {
 811     /* get initial picture rendered on overlay surface */
 812     Display(p_vout, p_pic);
 813
 814     IDirectDraw_WaitForVerticalBlank(p_vout->p_sys->p_ddobject,
 815             DDWAITVB_BLOCKBEGIN, NULL);
 816
 817     if( p_vout->p_sys->b_using_overlay )
 818     {
 819         /* set the colorkey as the backgound brush for the video window */
 820         SetClassLong( p_vout->p_sys->hvideownd, GCL_HBRBACKGROUND,
 821                       (LONG)CreateSolidBrush( p_vout->p_sys->i_rgb_colorkey ) );
 822     }
 823     /*
 824     ** Video window is initially hidden, show it now since we got a
 825     ** picture to show.
 826     */
 827     SetWindowPos( p_vout->p_sys->hvideownd, NULL, 0, 0, 0, 0,
 828         SWP_ASYNCWINDOWPOS|
 829         SWP_FRAMECHANGED|
 830         SWP_SHOWWINDOW|
 831         SWP_NOMOVE|
 832         SWP_NOSIZE|
 833         SWP_NOZORDER );
 834
 835     /* use and restores proper display function for further pictures */
 836     p_vout->pf_display = Display;
 837 }
 838
 839 /* following functions are local */
 840
 841 /*****************************************************************************
 842  * DirectXEnumCallback: Device enumeration
 843  *****************************************************************************
 844  * This callback function is called by DirectDraw once for each
 845  * available DirectDraw device.
 846  *****************************************************************************/
 847 BOOL WINAPI DirectXEnumCallback( GUID* p_guid, LPTSTR psz_desc,
 848                                  LPTSTR psz_drivername, VOID* p_context,
 849                                  HMONITOR hmon )
 850 {
 851     vout_thread_t *p_vout = (vout_thread_t *)p_context;
 852     vlc_value_t device;
 853
 854     msg_Dbg( p_vout, "DirectXEnumCallback: %s, %s", psz_desc, psz_drivername );
 855
 856     if( hmon )
 857     {
 858         var_Get( p_vout, "directx-device", &device );
 859
 860         if( ( !device.psz_string || !*device.psz_string ) &&
 861             hmon == p_vout->p_sys->hmonitor )
 862         {
 863             free( device.psz_string );
 864         }
 865         else if( strcmp( psz_drivername, device.psz_string ) == 0 )
 866         {
 867             MONITORINFO monitor_info;
 868             monitor_info.cbSize = sizeof( MONITORINFO );
 869
 870             if( p_vout->p_sys->GetMonitorInfo( hmon, &monitor_info ) )
 871             {
 872                 RECT rect;
 873
 874                 /* Move window to the right screen */
 875                 GetWindowRect( p_vout->p_sys->hwnd, &rect );
 876                 if( !IntersectRect( &rect, &rect, &monitor_info.rcWork ) )
 877                 {
 878                     rect.left = monitor_info.rcWork.left;
 879                     rect.top = monitor_info.rcWork.top;
 880                     msg_Dbg( p_vout, "DirectXEnumCallback: setting window "
 881                              "position to %ld,%ld", rect.left, rect.top );
 882                     SetWindowPos( p_vout->p_sys->hwnd, NULL,
 883                                   rect.left, rect.top, 0, 0,
 884                                   SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
 885                 }
 886             }
 887
 888             p_vout->p_sys->hmonitor = hmon;
 889             free( device.psz_string );
 890         }
 891         else
 892         {
 893             free( device.psz_string );
 894             return TRUE; /* Keep enumerating */
 895         }
 896
 897         msg_Dbg( p_vout, "selecting %s, %s", psz_desc, psz_drivername );
 898         p_vout->p_sys->p_display_driver = malloc( sizeof(GUID) );
 899         if( p_vout->p_sys->p_display_driver )
 900             memcpy( p_vout->p_sys->p_display_driver, p_guid, sizeof(GUID) );
 901     }
 902
 903     return TRUE; /* Keep enumerating */
 904 }
 905
 906 /*****************************************************************************
 907  * DirectXInitDDraw: Takes care of all the DirectDraw initialisations
 908  *****************************************************************************
 909  * This function initialise and allocate resources for DirectDraw.
 910  *****************************************************************************/
 911 static int DirectXInitDDraw( vout_thread_t *p_vout )
 912 {
 913     HRESULT dxresult;
 914     HRESULT (WINAPI *OurDirectDrawCreate)(GUID *,LPDIRECTDRAW *,IUnknown *);
 915     HRESULT (WINAPI *OurDirectDrawEnumerateEx)( LPDDENUMCALLBACKEXA, LPVOID,
 916                                                 DWORD );
 917     LPDIRECTDRAW p_ddobject;
 918
 919     msg_Dbg( p_vout, "DirectXInitDDraw" );
 920
 921     /* Load direct draw DLL */
 922     p_vout->p_sys->hddraw_dll = LoadLibrary(_T("DDRAW.DLL"));
 923     if( p_vout->p_sys->hddraw_dll == NULL )
 924     {
 925         msg_Warn( p_vout, "DirectXInitDDraw failed loading ddraw.dll" );
 926         goto error;
 927     }
 928
 929     OurDirectDrawCreate =
 930       (void *)GetProcAddress( p_vout->p_sys->hddraw_dll,
 931                               _T("DirectDrawCreate") );
 932     if( OurDirectDrawCreate == NULL )
 933     {
 934         msg_Err( p_vout, "DirectXInitDDraw failed GetProcAddress" );
 935         goto error;
 936     }
 937
 938     OurDirectDrawEnumerateEx =
 939       (void *)GetProcAddress( p_vout->p_sys->hddraw_dll,
 940 #ifndef UNICODE
 941                               "DirectDrawEnumerateExA" );
 942 #else
 943                               _T("DirectDrawEnumerateExW") );
 944 #endif
 945
 946     if( OurDirectDrawEnumerateEx && p_vout->p_sys->MonitorFromWindow )
 947     {
 948         vlc_value_t device;
 949
 950         var_Get( p_vout, "directx-device", &device );
 951         if( device.psz_string )
 952         {
 953             msg_Dbg( p_vout, "directx-device: %s", device.psz_string );
 954             free( device.psz_string );
 955         }
 956
 957         p_vout->p_sys->hmonitor =
 958             p_vout->p_sys->MonitorFromWindow( p_vout->p_sys->hwnd,
 959                                               MONITOR_DEFAULTTONEAREST );
 960
 961         /* Enumerate displays */
 962         OurDirectDrawEnumerateEx( DirectXEnumCallback, p_vout,
 963                                   DDENUM_ATTACHEDSECONDARYDEVICES );
 964     }
 965
 966     /* Initialize DirectDraw now */
 967     dxresult = OurDirectDrawCreate( p_vout->p_sys->p_display_driver,
 968                                     &p_ddobject, NULL );
 969     if( dxresult != DD_OK )
 970     {
 971         msg_Err( p_vout, "DirectXInitDDraw cannot initialize DDraw" );
 972         goto error;
 973     }
 974
 975     /* Get the IDirectDraw2 interface */
 976     dxresult = IDirectDraw_QueryInterface( p_ddobject, &IID_IDirectDraw2,
 977                                         (LPVOID *)&p_vout->p_sys->p_ddobject );
 978     /* Release the unused interface */
 979     IDirectDraw_Release( p_ddobject );
 980     if( dxresult != DD_OK )
 981     {
 982         msg_Err( p_vout, "cannot get IDirectDraw2 interface" );
 983         goto error;
 984     }
 985
 986     /* Set DirectDraw Cooperative level, ie what control we want over Windows
 987      * display */
 988     dxresult = IDirectDraw2_SetCooperativeLevel( p_vout->p_sys->p_ddobject,
 989                                                  NULL, DDSCL_NORMAL );
 990     if( dxresult != DD_OK )
 991     {
 992         msg_Err( p_vout, "cannot set direct draw cooperative level" );
 993         goto error;
 994     }
 995
 996     /* Get the size of the current display device */
 997     if( p_vout->p_sys->hmonitor && p_vout->p_sys->GetMonitorInfo )
 998     {
 999         MONITORINFO monitor_info;
1000         monitor_info.cbSize = sizeof( MONITORINFO );
1001         p_vout->p_sys->GetMonitorInfo( p_vout->p_sys->hmonitor,
1002                                        &monitor_info );
1003         p_vout->p_sys->rect_display = monitor_info.rcMonitor;
1004     }
1005     else
1006     {
1007         p_vout->p_sys->rect_display.left = 0;
1008         p_vout->p_sys->rect_display.top = 0;
1009         p_vout->p_sys->rect_display.right  = GetSystemMetrics(SM_CXSCREEN);
1010         p_vout->p_sys->rect_display.bottom = GetSystemMetrics(SM_CYSCREEN);
1011     }
1012
1013     msg_Dbg( p_vout, "screen dimensions (%lix%li,%lix%li)",
1014              p_vout->p_sys->rect_display.left,
1015              p_vout->p_sys->rect_display.top,
1016              p_vout->p_sys->rect_display.right,
1017              p_vout->p_sys->rect_display.bottom );
1018
1019     /* Probe the capabilities of the hardware */
1020     DirectXGetDDrawCaps( p_vout );
1021
1022     msg_Dbg( p_vout, "End DirectXInitDDraw" );
1023     return VLC_SUCCESS;
1024
1025  error:
1026     if( p_vout->p_sys->p_ddobject )
1027         IDirectDraw2_Release( p_vout->p_sys->p_ddobject );
1028     if( p_vout->p_sys->hddraw_dll )
1029         FreeLibrary( p_vout->p_sys->hddraw_dll );
1030     p_vout->p_sys->hddraw_dll = NULL;
1031     p_vout->p_sys->p_ddobject = NULL;
1032     return VLC_EGENERIC;
1033 }
1034
1035 /*****************************************************************************
1036  * DirectXCreateDisplay: create the DirectDraw display.
1037  *****************************************************************************
1038  * Create and initialize display according to preferences specified in the vout
1039  * thread fields.
1040  *****************************************************************************/
1041 static int DirectXCreateDisplay( vout_thread_t *p_vout )
1042 {
1043     HRESULT              dxresult;
1044     DDSURFACEDESC        ddsd;
1045     LPDIRECTDRAWSURFACE  p_display;
1046
1047     msg_Dbg( p_vout, "DirectXCreateDisplay" );
1048
1049     /* Now get the primary surface. This surface is what you actually see
1050      * on your screen */
1051     memset( &ddsd, 0, sizeof( DDSURFACEDESC ));
1052     ddsd.dwSize = sizeof(DDSURFACEDESC);
1053     ddsd.dwFlags = DDSD_CAPS;
1054     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
1055
1056     dxresult = IDirectDraw2_CreateSurface( p_vout->p_sys->p_ddobject,
1057                                            &ddsd, &p_display, NULL );
1058     if( dxresult != DD_OK )
1059     {
1060         msg_Err( p_vout, "cannot get primary surface (error %li)", dxresult );
1061         return VLC_EGENERIC;
1062     }
1063
1064     dxresult = IDirectDrawSurface_QueryInterface( p_display,
1065                                          &IID_IDirectDrawSurface2,
1066                                          (LPVOID *)&p_vout->p_sys->p_display );
1067     /* Release the old interface */
1068     IDirectDrawSurface_Release( p_display );
1069     if ( dxresult != DD_OK )
1070     {
1071         msg_Err( p_vout, "cannot query IDirectDrawSurface2 interface "
1072                          "(error %li)", dxresult );
1073         return VLC_EGENERIC;
1074     }
1075
1076     /* The clipper will be used only in non-overlay mode */
1077     DirectXCreateClipper( p_vout );
1078
1079     /* Make sure the colorkey will be painted */
1080     p_vout->p_sys->i_colorkey = 1;
1081     p_vout->p_sys->i_rgb_colorkey =
1082         DirectXFindColorkey( p_vout, &p_vout->p_sys->i_colorkey );
1083
1084     UpdateRects( p_vout, true );
1085
1086     return VLC_SUCCESS;
1087 }
1088
1089 /*****************************************************************************
1090  * DirectXCreateClipper: Create a clipper that will be used when blitting the
1091  *                       RGB surface to the main display.
1092  *****************************************************************************
1093  * This clipper prevents us to modify by mistake anything on the screen
1094  * which doesn't belong to our window. For example when a part of our video
1095  * window is hidden by another window.
1096  *****************************************************************************/
1097 static int DirectXCreateClipper( vout_thread_t *p_vout )
1098 {
1099     HRESULT dxresult;
1100
1101     msg_Dbg( p_vout, "DirectXCreateClipper" );
1102
1103     /* Create the clipper */
1104     dxresult = IDirectDraw2_CreateClipper( p_vout->p_sys->p_ddobject, 0,
1105                                            &p_vout->p_sys->p_clipper, NULL );
1106     if( dxresult != DD_OK )
1107     {
1108         msg_Warn( p_vout, "cannot create clipper (error %li)", dxresult );
1109         goto error;
1110     }
1111
1112     /* Associate the clipper to the window */
1113     dxresult = IDirectDrawClipper_SetHWnd( p_vout->p_sys->p_clipper, 0,
1114                                            p_vout->p_sys->hvideownd );
1115     if( dxresult != DD_OK )
1116     {
1117         msg_Warn( p_vout, "cannot attach clipper to window (error %li)",
1118                           dxresult );
1119         goto error;
1120     }
1121
1122     /* associate the clipper with the surface */
1123     dxresult = IDirectDrawSurface_SetClipper(p_vout->p_sys->p_display,
1124                                              p_vout->p_sys->p_clipper);
1125     if( dxresult != DD_OK )
1126     {
1127         msg_Warn( p_vout, "cannot attach clipper to surface (error %li)",
1128                           dxresult );
1129         goto error;
1130     }
1131
1132     return VLC_SUCCESS;
1133
1134  error:
1135     if( p_vout->p_sys->p_clipper )
1136     {
1137         IDirectDrawClipper_Release( p_vout->p_sys->p_clipper );
1138     }
1139     p_vout->p_sys->p_clipper = NULL;
1140     return VLC_EGENERIC;
1141 }
1142
1143 /*****************************************************************************
1144  * DirectXCreateSurface: create an YUV overlay or RGB surface for the video.
1145  *****************************************************************************
1146  * The best method of display is with an YUV overlay because the YUV->RGB
1147  * conversion is done in hardware.
1148  * You can also create a plain RGB surface.
1149  * ( Maybe we could also try an RGB overlay surface, which could have hardware
1150  * scaling and which would also be faster in window mode because you don't
1151  * need to do any blitting to the main display...)
1152  *****************************************************************************/
1153 static int DirectXCreateSurface( vout_thread_t *p_vout,
1154                                  LPDIRECTDRAWSURFACE2 *pp_surface_final,
1155                                  int i_chroma, int b_overlay,
1156                                  int i_backbuffers )
1157 {
1158     HRESULT dxresult;
1159     LPDIRECTDRAWSURFACE p_surface;
1160     DDSURFACEDESC ddsd;
1161
1162     /* Create the video surface */
1163     if( b_overlay )
1164     {
1165         /* Now try to create the YUV overlay surface.
1166          * This overlay will be displayed on top of the primary surface.
1167          * A color key is used to determine whether or not the overlay will be
1168          * displayed, ie the overlay will be displayed in place of the primary
1169          * surface wherever the primary surface will have this color.
1170          * The video window has been created with a background of this color so
1171          * the overlay will be only displayed on top of this window */
1172
1173         memset( &ddsd, 0, sizeof( DDSURFACEDESC ));
1174         ddsd.dwSize = sizeof(DDSURFACEDESC);
1175         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1176         ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
1177         ddsd.ddpfPixelFormat.dwFourCC = i_chroma;
1178         ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
1179         ddsd.dwFlags |= (i_backbuffers ? DDSD_BACKBUFFERCOUNT : 0);
1180         ddsd.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
1181         ddsd.ddsCaps.dwCaps |= (i_backbuffers ? DDSCAPS_COMPLEX | DDSCAPS_FLIP
1182                                 : 0 );
1183         ddsd.dwHeight = p_vout->render.i_height;
1184         ddsd.dwWidth = p_vout->render.i_width;
1185         ddsd.dwBackBufferCount = i_backbuffers;
1186
1187         dxresult = IDirectDraw2_CreateSurface( p_vout->p_sys->p_ddobject,
1188                                                &ddsd, &p_surface, NULL );
1189         if( dxresult != DD_OK )
1190         {
1191             *pp_surface_final = NULL;
1192             return VLC_EGENERIC;
1193         }
1194     }
1195
1196     if( !b_overlay )
1197     {
1198         bool b_rgb_surface =
1199             ( i_chroma == VLC_FOURCC('R','G','B','2') )
1200           || ( i_chroma == VLC_FOURCC('R','V','1','5') )
1201            || ( i_chroma == VLC_FOURCC('R','V','1','6') )
1202             || ( i_chroma == VLC_FOURCC('R','V','2','4') )
1203              || ( i_chroma == VLC_FOURCC('R','V','3','2') );
1204
1205         memset( &ddsd, 0, sizeof( DDSURFACEDESC ) );
1206         ddsd.dwSize = sizeof(DDSURFACEDESC);
1207         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1208         ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_CAPS;
1209         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
1210         ddsd.dwHeight = p_vout->render.i_height;
1211         ddsd.dwWidth = p_vout->render.i_width;
1212
1213         if( p_vout->p_sys->b_use_sysmem )
1214             ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
1215         else
1216             ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
1217
1218         if( !b_rgb_surface )
1219         {
1220             ddsd.dwFlags |= DDSD_PIXELFORMAT;
1221             ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
1222             ddsd.ddpfPixelFormat.dwFourCC = i_chroma;
1223         }
1224
1225         dxresult = IDirectDraw2_CreateSurface( p_vout->p_sys->p_ddobject,
1226                                                &ddsd, &p_surface, NULL );
1227         if( dxresult != DD_OK )
1228         {
1229             *pp_surface_final = NULL;
1230             return VLC_EGENERIC;
1231         }
1232     }
1233
1234     /* Now that the surface is created, try to get a newer DirectX interface */
1235     dxresult = IDirectDrawSurface_QueryInterface( p_surface,
1236                                      &IID_IDirectDrawSurface2,
1237                                      (LPVOID *)pp_surface_final );
1238     IDirectDrawSurface_Release( p_surface );    /* Release the old interface */
1239     if ( dxresult != DD_OK )
1240     {
1241         msg_Err( p_vout, "cannot query IDirectDrawSurface2 interface "
1242                          "(error %li)", dxresult );
1243         *pp_surface_final = NULL;
1244         return VLC_EGENERIC;
1245     }
1246
1247     if( b_overlay )
1248     {
1249         /* Check the overlay is useable as some graphics cards allow creating
1250          * several overlays but only one can be used at one time. */
1251         p_vout->p_sys->p_current_surface = *pp_surface_final;
1252         if( DirectDrawUpdateOverlay( p_vout ) != VLC_SUCCESS )
1253         {
1254             IDirectDrawSurface2_Release( *pp_surface_final );
1255             *pp_surface_final = NULL;
1256             msg_Err( p_vout, "overlay unuseable (might already be in use)" );
1257             return VLC_EGENERIC;
1258         }
1259     }
1260
1261     return VLC_SUCCESS;
1262 }
1263
1264 /*****************************************************************************
1265  * DirectDrawUpdateOverlay: Move or resize overlay surface on video display.
1266  *****************************************************************************
1267  * This function is used to move or resize an overlay surface on the screen.
1268  * Ususally the overlay is moved by the user and thus, by a move or resize
1269  * event (in Manage).
1270  *****************************************************************************/
1271 int DirectDrawUpdateOverlay( vout_thread_t *p_vout )
1272 {
1273     DDOVERLAYFX     ddofx;
1274     DWORD           dwFlags;
1275     HRESULT         dxresult;
1276     RECT            rect_src = p_vout->p_sys->rect_src_clipped;
1277     RECT            rect_dest = p_vout->p_sys->rect_dest_clipped;
1278
1279     if( !p_vout->p_sys->b_using_overlay ) return VLC_EGENERIC;
1280
1281     if( p_vout->p_sys->b_wallpaper )
1282     {
1283         int i_x, i_y, i_width, i_height;
1284
1285         rect_src.left = p_vout->fmt_out.i_x_offset;
1286         rect_src.top = p_vout->fmt_out.i_y_offset;
1287         rect_src.right = rect_src.left + p_vout->fmt_out.i_visible_width;
1288         rect_src.bottom = rect_src.top + p_vout->fmt_out.i_visible_height;
1289
1290         rect_dest = p_vout->p_sys->rect_display;
1291         vout_PlacePicture( p_vout, rect_dest.right, rect_dest.bottom,
1292                            &i_x, &i_y, &i_width, &i_height );
1293
1294         rect_dest.left += i_x;
1295         rect_dest.right = rect_dest.left + i_width;
1296         rect_dest.top += i_y;
1297         rect_dest.bottom = rect_dest.top + i_height;
1298     }
1299
1300     vlc_mutex_lock( &p_vout->p_sys->lock );
1301     if( p_vout->p_sys->p_current_surface == NULL )
1302     {
1303         vlc_mutex_unlock( &p_vout->p_sys->lock );
1304         return VLC_EGENERIC;
1305     }
1306
1307     /* The new window dimensions should already have been computed by the
1308      * caller of this function */
1309
1310     /* Position and show the overlay */
1311     memset(&ddofx, 0, sizeof(DDOVERLAYFX));
1312     ddofx.dwSize = sizeof(DDOVERLAYFX);
1313     ddofx.dckDestColorkey.dwColorSpaceLowValue = p_vout->p_sys->i_colorkey;
1314     ddofx.dckDestColorkey.dwColorSpaceHighValue = p_vout->p_sys->i_colorkey;
1315
1316     dwFlags = DDOVER_SHOW | DDOVER_KEYDESTOVERRIDE;
1317
1318     dxresult = IDirectDrawSurface2_UpdateOverlay(
1319                    p_vout->p_sys->p_current_surface,
1320                    &rect_src, p_vout->p_sys->p_display, &rect_dest,
1321                    dwFlags, &ddofx );
1322
1323     vlc_mutex_unlock( &p_vout->p_sys->lock );
1324
1325     if(dxresult != DD_OK)
1326     {
1327         msg_Warn( p_vout, "DirectDrawUpdateOverlay cannot move/resize overlay" );
1328         return VLC_EGENERIC;
1329     }
1330
1331     return VLC_SUCCESS;
1332 }
1333
1334 /*****************************************************************************
1335  * DirectXCloseDDraw: Release the DDraw object allocated by DirectXInitDDraw
1336  *****************************************************************************
1337  * This function returns all resources allocated by DirectXInitDDraw.
1338  *****************************************************************************/
1339 static void DirectXCloseDDraw( vout_thread_t *p_vout )
1340 {
1341     msg_Dbg( p_vout, "DirectXCloseDDraw" );
1342     if( p_vout->p_sys->p_ddobject != NULL )
1343     {
1344         IDirectDraw2_Release(p_vout->p_sys->p_ddobject);
1345         p_vout->p_sys->p_ddobject = NULL;
1346     }
1347
1348     if( p_vout->p_sys->hddraw_dll != NULL )
1349     {
1350         FreeLibrary( p_vout->p_sys->hddraw_dll );
1351         p_vout->p_sys->hddraw_dll = NULL;
1352     }
1353
1354     free( p_vout->p_sys->p_display_driver );
1355     p_vout->p_sys->p_display_driver = NULL;
1356
1357     p_vout->p_sys->hmonitor = NULL;
1358 }
1359
1360 /*****************************************************************************
1361  * DirectXCloseDisplay: close and reset the DirectX display device
1362  *****************************************************************************
1363  * This function returns all resources allocated by DirectXCreateDisplay.
1364  *****************************************************************************/
1365 static void DirectXCloseDisplay( vout_thread_t *p_vout )
1366 {
1367     msg_Dbg( p_vout, "DirectXCloseDisplay" );
1368
1369     if( p_vout->p_sys->p_clipper != NULL )
1370     {
1371         msg_Dbg( p_vout, "DirectXCloseDisplay clipper" );
1372         IDirectDrawClipper_Release( p_vout->p_sys->p_clipper );
1373         p_vout->p_sys->p_clipper = NULL;
1374     }
1375
1376     if( p_vout->p_sys->p_display != NULL )
1377     {
1378         msg_Dbg( p_vout, "DirectXCloseDisplay display" );
1379         IDirectDrawSurface2_Release( p_vout->p_sys->p_display );
1380         p_vout->p_sys->p_display = NULL;
1381     }
1382 }
1383
1384 /*****************************************************************************
1385  * DirectXCloseSurface: close the YUV overlay or RGB surface.
1386  *****************************************************************************
1387  * This function returns all resources allocated for the surface.
1388  *****************************************************************************/
1389 static void DirectXCloseSurface( vout_thread_t *p_vout,
1390                                  LPDIRECTDRAWSURFACE2 p_surface )
1391 {
1392     msg_Dbg( p_vout, "DirectXCloseSurface" );
1393     if( p_surface != NULL )
1394     {
1395         IDirectDrawSurface2_Release( p_surface );
1396     }
1397 }
1398
1399 /*****************************************************************************
1400  * NewPictureVec: allocate a vector of identical pictures
1401  *****************************************************************************
1402  * Returns 0 on success, -1 otherwise
1403  *****************************************************************************/
1404 static int NewPictureVec( vout_thread_t *p_vout, picture_t *p_pic,
1405                           int i_num_pics )
1406 {
1407     int i;
1408     int i_ret = VLC_SUCCESS;
1409     LPDIRECTDRAWSURFACE2 p_surface;
1410
1411     msg_Dbg( p_vout, "NewPictureVec overlay:%s chroma:%.4s",
1412              p_vout->p_sys->b_using_overlay ? "yes" : "no",
1413              (char *)&p_vout->output.i_chroma );
1414
1415     I_OUTPUTPICTURES = 0;
1416
1417     /* First we try to use an YUV overlay surface.
1418      * The overlay surface that we create won't be used to decode directly
1419      * into it because accessing video memory directly is way to slow (remember
1420      * that pictures are decoded macroblock per macroblock). Instead the video
1421      * will be decoded in picture buffers in system memory which will then be
1422      * memcpy() to the overlay surface. */
1423     if( p_vout->p_sys->b_using_overlay )
1424     {
1425         /* Triple buffering rocks! it doesn't have any processing overhead
1426          * (you don't have to wait for the vsync) and provides for a very nice
1427          * video quality (no tearing). */
1428         if( p_vout->p_sys->b_3buf_overlay )
1429             i_ret = DirectXCreateSurface( p_vout, &p_surface,
1430                                           p_vout->output.i_chroma,
1431                                           p_vout->p_sys->b_using_overlay,
1432                                           2 /* number of backbuffers */ );
1433
1434         if( !p_vout->p_sys->b_3buf_overlay || i_ret != VLC_SUCCESS )
1435         {
1436             /* Try to reduce the number of backbuffers */
1437             i_ret = DirectXCreateSurface( p_vout, &p_surface,
1438                                           p_vout->output.i_chroma,
1439                                           p_vout->p_sys->b_using_overlay,
1440                                           0 /* number of backbuffers */ );
1441         }
1442
1443         if( i_ret == VLC_SUCCESS )
1444         {
1445             DDSCAPS dds_caps;
1446             picture_t front_pic;
1447             picture_sys_t front_pic_sys;
1448             front_pic.p_sys = &front_pic_sys;
1449
1450             /* Allocate internal structure */
1451             p_pic[0].p_sys = malloc( sizeof( picture_sys_t ) );
1452             if( p_pic[0].p_sys == NULL )
1453             {
1454                 DirectXCloseSurface( p_vout, p_surface );
1455                 return VLC_ENOMEM;
1456             }
1457
1458             /* set front buffer */
1459             p_pic[0].p_sys->p_front_surface = p_surface;
1460
1461             /* Get the back buffer */
1462             memset( &dds_caps, 0, sizeof( DDSCAPS ) );
1463             dds_caps.dwCaps = DDSCAPS_BACKBUFFER;
1464             if( DD_OK != IDirectDrawSurface2_GetAttachedSurface(
1465                                                 p_surface, &dds_caps,
1466                                                 &p_pic[0].p_sys->p_surface ) )
1467             {
1468                 msg_Warn( p_vout, "NewPictureVec could not get back buffer" );
1469                 /* front buffer is the same as back buffer */
1470                 p_pic[0].p_sys->p_surface = p_surface;
1471             }
1472
1473
1474             p_vout->p_sys->p_current_surface = front_pic.p_sys->p_surface =
1475                 p_pic[0].p_sys->p_front_surface;
1476
1477             /* Reset the front buffer memory */
1478             if( DirectXLockSurface( p_vout, &front_pic ) == VLC_SUCCESS )
1479             {
1480                 int i,j;
1481                 for( i = 0; i < front_pic.i_planes; i++ )
1482                     for( j = 0; j < front_pic.p[i].i_visible_lines; j++)
1483                         memset( front_pic.p[i].p_pixels + j *
1484                                 front_pic.p[i].i_pitch, 127,
1485                                 front_pic.p[i].i_visible_pitch );
1486
1487                 DirectXUnlockSurface( p_vout, &front_pic );
1488             }
1489
1490             DirectDrawUpdateOverlay( p_vout );
1491             I_OUTPUTPICTURES = 1;
1492             msg_Dbg( p_vout, "YUV overlay created successfully" );
1493         }
1494     }
1495
1496     /* As we can't have an overlay, we'll try to create a plain offscreen
1497      * surface. This surface will reside in video memory because there's a
1498      * better chance then that we'll be able to use some kind of hardware
1499      * acceleration like rescaling, blitting or YUV->RGB conversions.
1500      * We then only need to blit this surface onto the main display when we
1501      * want to display it */
1502     if( !p_vout->p_sys->b_using_overlay )
1503     {
1504         if( p_vout->p_sys->b_hw_yuv )
1505         {
1506             DWORD i_codes;
1507             DWORD *pi_codes;
1508             bool b_result = false;
1509
1510             /* Check if the chroma is supported first. This is required
1511              * because a few buggy drivers don't mind creating the surface
1512              * even if they don't know about the chroma. */
1513             if( IDirectDraw2_GetFourCCCodes( p_vout->p_sys->p_ddobject,
1514                                              &i_codes, NULL ) == DD_OK )
1515             {
1516                 pi_codes = malloc( i_codes * sizeof(DWORD) );
1517                 if( pi_codes && IDirectDraw2_GetFourCCCodes(
1518                     p_vout->p_sys->p_ddobject, &i_codes, pi_codes ) == DD_OK )
1519                 {
1520                     for( i = 0; i < (int)i_codes; i++ )
1521                     {
1522                         if( p_vout->output.i_chroma == pi_codes[i] )
1523                         {
1524                             b_result = true;
1525                             break;
1526                         }
1527                     }
1528                 }
1529             }
1530
1531             if( b_result )
1532                 i_ret = DirectXCreateSurface( p_vout, &p_surface,
1533                                               p_vout->output.i_chroma,
1534                                               0 /* no overlay */,
1535                                               0 /* no back buffers */ );
1536             else
1537                 p_vout->p_sys->b_hw_yuv = false;
1538         }
1539
1540         if( i_ret || !p_vout->p_sys->b_hw_yuv )
1541         {
1542             /* Our last choice is to use a plain RGB surface */
1543             DDPIXELFORMAT ddpfPixelFormat;
1544
1545             ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1546             IDirectDrawSurface2_GetPixelFormat( p_vout->p_sys->p_display,
1547                                                 &ddpfPixelFormat );
1548
1549             if( ddpfPixelFormat.dwFlags & DDPF_RGB )
1550             {
1551                 switch( ddpfPixelFormat.dwRGBBitCount )
1552                 {
1553                 case 8:
1554                     p_vout->output.i_chroma = VLC_FOURCC('R','G','B','2');
1555                     p_vout->output.pf_setpalette = SetPalette;
1556                     break;
1557                 case 15:
1558                     p_vout->output.i_chroma = VLC_FOURCC('R','V','1','5');
1559                     break;
1560                 case 16:
1561                     p_vout->output.i_chroma = VLC_FOURCC('R','V','1','6');
1562                     break;
1563                 case 24:
1564                     p_vout->output.i_chroma = VLC_FOURCC('R','V','2','4');
1565                     break;
1566                 case 32:
1567                     p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
1568                     break;
1569                 default:
1570                     msg_Err( p_vout, "unknown screen depth" );
1571                     return VLC_EGENERIC;
1572                 }
1573                 p_vout->output.i_rmask = ddpfPixelFormat.dwRBitMask;
1574                 p_vout->output.i_gmask = ddpfPixelFormat.dwGBitMask;
1575                 p_vout->output.i_bmask = ddpfPixelFormat.dwBBitMask;
1576             }
1577
1578             p_vout->p_sys->b_hw_yuv = 0;
1579
1580             i_ret = DirectXCreateSurface( p_vout, &p_surface,
1581                                           p_vout->output.i_chroma,
1582                                           0 /* no overlay */,
1583                                           0 /* no back buffers */ );
1584
1585             if( i_ret && !p_vout->p_sys->b_use_sysmem )
1586             {
1587                 /* Give it a last try with b_use_sysmem enabled */
1588                 p_vout->p_sys->b_use_sysmem = 1;
1589
1590                 i_ret = DirectXCreateSurface( p_vout, &p_surface,
1591                                               p_vout->output.i_chroma,
1592                                               0 /* no overlay */,
1593                                               0 /* no back buffers */ );
1594             }
1595         }
1596
1597         if( i_ret == VLC_SUCCESS )
1598         {
1599             /* Allocate internal structure */
1600             p_pic[0].p_sys = malloc( sizeof( picture_sys_t ) );
1601             if( p_pic[0].p_sys == NULL )
1602             {
1603                 DirectXCloseSurface( p_vout, p_surface );
1604                 return VLC_ENOMEM;
1605             }
1606
1607             p_pic[0].p_sys->p_surface = p_pic[0].p_sys->p_front_surface
1608                 = p_surface;
1609
1610             I_OUTPUTPICTURES = 1;
1611
1612             msg_Dbg( p_vout, "created plain surface of chroma:%.4s",
1613                      (char *)&p_vout->output.i_chroma );
1614         }
1615     }
1616
1617
1618     /* Now that we've got all our direct-buffers, we can finish filling in the
1619      * picture_t structures */
1620     for( i = 0; i < I_OUTPUTPICTURES; i++ )
1621     {
1622         p_pic[i].i_status = DESTROYED_PICTURE;
1623         p_pic[i].i_type   = DIRECT_PICTURE;
1624         p_pic[i].b_slow   = true;
1625         p_pic[i].pf_lock  = DirectXLockSurface;
1626         p_pic[i].pf_unlock = DirectXUnlockSurface;
1627         PP_OUTPUTPICTURE[i] = &p_pic[i];
1628
1629         if( DirectXLockSurface( p_vout, &p_pic[i] ) != VLC_SUCCESS )
1630         {
1631             /* AAARRGG */
1632             FreePictureVec( p_vout, p_pic, I_OUTPUTPICTURES );
1633             I_OUTPUTPICTURES = 0;
1634             msg_Err( p_vout, "cannot lock surface" );
1635             return VLC_EGENERIC;
1636         }
1637         DirectXUnlockSurface( p_vout, &p_pic[i] );
1638     }
1639
1640     msg_Dbg( p_vout, "End NewPictureVec (%s)",
1641              I_OUTPUTPICTURES ? "succeeded" : "failed" );
1642
1643     return VLC_SUCCESS;
1644 }
1645
1646 /*****************************************************************************
1647  * FreePicture: destroy a picture vector allocated with NewPictureVec
1648  *****************************************************************************
1649  *
1650  *****************************************************************************/
1651 static void FreePictureVec( vout_thread_t *p_vout, picture_t *p_pic,
1652                             int i_num_pics )
1653 {
1654     int i;
1655
1656     vlc_mutex_lock( &p_vout->p_sys->lock );
1657     p_vout->p_sys->p_current_surface = 0;
1658     vlc_mutex_unlock( &p_vout->p_sys->lock );
1659
1660     for( i = 0; i < i_num_pics; i++ )
1661     {
1662         DirectXCloseSurface( p_vout, p_pic[i].p_sys->p_front_surface );
1663
1664         for( i = 0; i < i_num_pics; i++ )
1665         {
1666             free( p_pic[i].p_sys );
1667         }
1668     }
1669 }
1670
1671 /*****************************************************************************
1672  * UpdatePictureStruct: updates the internal data in the picture_t structure
1673  *****************************************************************************
1674  * This will setup stuff for use by the video_output thread
1675  *****************************************************************************/
1676 static int UpdatePictureStruct( vout_thread_t *p_vout, picture_t *p_pic,
1677                                 int i_chroma )
1678 {
1679     switch( p_vout->output.i_chroma )
1680     {
1681         case VLC_FOURCC('R','G','B','2'):
1682         case VLC_FOURCC('R','V','1','5'):
1683         case VLC_FOURCC('R','V','1','6'):
1684         case VLC_FOURCC('R','V','2','4'):
1685         case VLC_FOURCC('R','V','3','2'):
1686             p_pic->p->p_pixels = p_pic->p_sys->ddsd.lpSurface;
1687             p_pic->p->i_lines = p_vout->output.i_height;
1688             p_pic->p->i_visible_lines = p_vout->output.i_height;
1689             p_pic->p->i_pitch = p_pic->p_sys->ddsd.lPitch;
1690             switch( p_vout->output.i_chroma )
1691             {
1692                 case VLC_FOURCC('R','G','B','2'):
1693                     p_pic->p->i_pixel_pitch = 1;
1694                     break;
1695                 case VLC_FOURCC('R','V','1','5'):
1696                 case VLC_FOURCC('R','V','1','6'):
1697                     p_pic->p->i_pixel_pitch = 2;
1698                     break;
1699                 case VLC_FOURCC('R','V','2','4'):
1700                     p_pic->p->i_pixel_pitch = 3;
1701                     break;
1702                 case VLC_FOURCC('R','V','3','2'):
1703                     p_pic->p->i_pixel_pitch = 4;
1704                     break;
1705                 default:
1706                     return VLC_EGENERIC;
1707             }
1708             p_pic->p->i_visible_pitch = p_vout->output.i_width *
1709               p_pic->p->i_pixel_pitch;
1710             p_pic->i_planes = 1;
1711             break;
1712
1713         case VLC_FOURCC('Y','V','1','2'):
1714         case VLC_FOURCC('I','4','2','0'):
1715
1716             /* U and V inverted compared to I420
1717              * Fixme: this should be handled by the vout core */
1718             p_vout->output.i_chroma = VLC_FOURCC('I','4','2','0');
1719
1720             p_pic->Y_PIXELS = p_pic->p_sys->ddsd.lpSurface;
1721             p_pic->p[Y_PLANE].i_lines = p_vout->output.i_height;
1722             p_pic->p[Y_PLANE].i_visible_lines = p_vout->output.i_height;
1723             p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->ddsd.lPitch;
1724             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
1725             p_pic->p[Y_PLANE].i_visible_pitch = p_vout->output.i_width *
1726               p_pic->p[Y_PLANE].i_pixel_pitch;
1727
1728             p_pic->V_PIXELS =  p_pic->Y_PIXELS
1729               + p_pic->p[Y_PLANE].i_lines * p_pic->p[Y_PLANE].i_pitch;
1730             p_pic->p[V_PLANE].i_lines = p_vout->output.i_height / 2;
1731             p_pic->p[V_PLANE].i_visible_lines = p_vout->output.i_height / 2;
1732             p_pic->p[V_PLANE].i_pitch = p_pic->p[Y_PLANE].i_pitch / 2;
1733             p_pic->p[V_PLANE].i_pixel_pitch = 1;
1734             p_pic->p[V_PLANE].i_visible_pitch = p_vout->output.i_width / 2 *
1735               p_pic->p[V_PLANE].i_pixel_pitch;
1736
1737             p_pic->U_PIXELS = p_pic->V_PIXELS
1738               + p_pic->p[V_PLANE].i_lines * p_pic->p[V_PLANE].i_pitch;
1739             p_pic->p[U_PLANE].i_lines = p_vout->output.i_height / 2;
1740             p_pic->p[U_PLANE].i_visible_lines = p_vout->output.i_height / 2;
1741             p_pic->p[U_PLANE].i_pitch = p_pic->p[Y_PLANE].i_pitch / 2;
1742             p_pic->p[U_PLANE].i_pixel_pitch = 1;
1743             p_pic->p[U_PLANE].i_visible_pitch = p_vout->output.i_width / 2 *
1744               p_pic->p[U_PLANE].i_pixel_pitch;
1745
1746             p_pic->i_planes = 3;
1747             break;
1748
1749         case VLC_FOURCC('I','Y','U','V'):
1750
1751             p_pic->Y_PIXELS = p_pic->p_sys->ddsd.lpSurface;
1752             p_pic->p[Y_PLANE].i_lines = p_vout->output.i_height;
1753             p_pic->p[Y_PLANE].i_visible_lines = p_vout->output.i_height;
1754             p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->ddsd.lPitch;
1755             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
1756             p_pic->p[Y_PLANE].i_visible_pitch = p_vout->output.i_width *
1757               p_pic->p[Y_PLANE].i_pixel_pitch;
1758
1759             p_pic->U_PIXELS = p_pic->Y_PIXELS
1760               + p_pic->p[Y_PLANE].i_lines * p_pic->p[Y_PLANE].i_pitch;
1761             p_pic->p[U_PLANE].i_lines = p_vout->output.i_height / 2;
1762             p_pic->p[U_PLANE].i_visible_lines = p_vout->output.i_height / 2;
1763             p_pic->p[U_PLANE].i_pitch = p_pic->p[Y_PLANE].i_pitch / 2;
1764             p_pic->p[U_PLANE].i_pixel_pitch = 1;
1765             p_pic->p[U_PLANE].i_visible_pitch = p_vout->output.i_width / 2 *
1766               p_pic->p[U_PLANE].i_pixel_pitch;
1767
1768             p_pic->V_PIXELS =  p_pic->U_PIXELS
1769               + p_pic->p[U_PLANE].i_lines * p_pic->p[U_PLANE].i_pitch;
1770             p_pic->p[V_PLANE].i_lines = p_vout->output.i_height / 2;
1771             p_pic->p[V_PLANE].i_visible_lines = p_vout->output.i_height / 2;
1772             p_pic->p[V_PLANE].i_pitch = p_pic->p[Y_PLANE].i_pitch / 2;
1773             p_pic->p[V_PLANE].i_pixel_pitch = 1;
1774             p_pic->p[V_PLANE].i_visible_pitch = p_vout->output.i_width / 2 *
1775               p_pic->p[V_PLANE].i_pixel_pitch;
1776
1777             p_pic->i_planes = 3;
1778             break;
1779
1780         case VLC_FOURCC('U','Y','V','Y'):
1781         case VLC_FOURCC('Y','U','Y','2'):
1782
1783             p_pic->p->p_pixels = p_pic->p_sys->ddsd.lpSurface;
1784             p_pic->p->i_lines = p_vout->output.i_height;
1785             p_pic->p->i_visible_lines = p_vout->output.i_height;
1786             p_pic->p->i_pitch = p_pic->p_sys->ddsd.lPitch;
1787             p_pic->p->i_pixel_pitch = 2;
1788             p_pic->p->i_visible_pitch = p_vout->output.i_width *
1789               p_pic->p->i_pixel_pitch;
1790
1791             p_pic->i_planes = 1;
1792             break;
1793
1794         default:
1795             /* Unknown chroma, tell the guy to get lost */
1796             msg_Err( p_vout, "never heard of chroma 0x%.8x (%4.4s)",
1797                      p_vout->output.i_chroma,
1798                      (char*)&p_vout->output.i_chroma );
1799             return VLC_EGENERIC;
1800     }
1801
1802     return VLC_SUCCESS;
1803 }
1804
1805 /*****************************************************************************
1806  * DirectXGetDDrawCaps: Probe the capabilities of the hardware
1807  *****************************************************************************
1808  * It is nice to know which features are supported by the hardware so we can
1809  * find ways to optimize our rendering.
1810  *****************************************************************************/
1811 static void DirectXGetDDrawCaps( vout_thread_t *p_vout )
1812 {
1813     DDCAPS ddcaps;
1814     HRESULT dxresult;
1815
1816     /* This is just an indication of whether or not we'll support overlay,
1817      * but with this test we don't know if we support YUV overlay */
1818     memset( &ddcaps, 0, sizeof( DDCAPS ));
1819     ddcaps.dwSize = sizeof(DDCAPS);
1820     dxresult = IDirectDraw2_GetCaps( p_vout->p_sys->p_ddobject,
1821                                      &ddcaps, NULL );
1822     if(dxresult != DD_OK )
1823     {
1824         msg_Warn( p_vout, "cannot get caps" );
1825     }
1826     else
1827     {
1828         bool bHasOverlay, bHasOverlayFourCC, bCanDeinterlace,
1829              bHasColorKey, bCanStretch, bCanBltFourcc,
1830              bAlignBoundarySrc, bAlignBoundaryDest,
1831              bAlignSizeSrc, bAlignSizeDest;
1832
1833         /* Determine if the hardware supports overlay surfaces */
1834         bHasOverlay = (ddcaps.dwCaps & DDCAPS_OVERLAY) ? 1 : 0;
1835         /* Determine if the hardware supports overlay surfaces */
1836         bHasOverlayFourCC = (ddcaps.dwCaps & DDCAPS_OVERLAYFOURCC) ? 1 : 0;
1837         /* Determine if the hardware supports overlay deinterlacing */
1838         bCanDeinterlace = (ddcaps.dwCaps & DDCAPS2_CANFLIPODDEVEN) ? 1 : 0;
1839         /* Determine if the hardware supports colorkeying */
1840         bHasColorKey = (ddcaps.dwCaps & DDCAPS_COLORKEY) ? 1 : 0;
1841         /* Determine if the hardware supports scaling of the overlay surface */
1842         bCanStretch = (ddcaps.dwCaps & DDCAPS_OVERLAYSTRETCH) ? 1 : 0;
1843         /* Determine if the hardware supports color conversion during a blit */
1844         bCanBltFourcc = (ddcaps.dwCaps & DDCAPS_BLTFOURCC) ? 1 : 0;
1845         /* Determine overlay source boundary alignment */
1846         bAlignBoundarySrc = (ddcaps.dwCaps & DDCAPS_ALIGNBOUNDARYSRC) ? 1 : 0;
1847         /* Determine overlay destination boundary alignment */
1848         bAlignBoundaryDest = (ddcaps.dwCaps & DDCAPS_ALIGNBOUNDARYDEST) ? 1:0;
1849         /* Determine overlay destination size alignment */
1850         bAlignSizeSrc = (ddcaps.dwCaps & DDCAPS_ALIGNSIZESRC) ? 1 : 0;
1851         /* Determine overlay destination size alignment */
1852         bAlignSizeDest = (ddcaps.dwCaps & DDCAPS_ALIGNSIZEDEST) ? 1 : 0;
1853
1854         msg_Dbg( p_vout, "DirectDraw Capabilities: overlay=%i yuvoverlay=%i "
1855                          "can_deinterlace_overlay=%i colorkey=%i stretch=%i "
1856                          "bltfourcc=%i",
1857                          bHasOverlay, bHasOverlayFourCC, bCanDeinterlace,
1858                          bHasColorKey, bCanStretch, bCanBltFourcc );
1859
1860         if( bAlignBoundarySrc || bAlignBoundaryDest ||
1861             bAlignSizeSrc || bAlignSizeDest )
1862         {
1863             if( bAlignBoundarySrc ) p_vout->p_sys->i_align_src_boundary =
1864                 ddcaps.dwAlignBoundarySrc;
1865             if( bAlignBoundaryDest ) p_vout->p_sys->i_align_dest_boundary =
1866                 ddcaps.dwAlignBoundaryDest;
1867             if( bAlignSizeDest ) p_vout->p_sys->i_align_src_size =
1868                 ddcaps.dwAlignSizeSrc;
1869             if( bAlignSizeDest ) p_vout->p_sys->i_align_dest_size =
1870                 ddcaps.dwAlignSizeDest;
1871
1872             msg_Dbg( p_vout, "align_boundary_src=%i,%i "
1873                      "align_boundary_dest=%i,%i "
1874                      "align_size_src=%i,%i align_size_dest=%i,%i",
1875                      bAlignBoundarySrc, p_vout->p_sys->i_align_src_boundary,
1876                      bAlignBoundaryDest, p_vout->p_sys->i_align_dest_boundary,
1877                      bAlignSizeSrc, p_vout->p_sys->i_align_src_size,
1878                      bAlignSizeDest, p_vout->p_sys->i_align_dest_size );
1879         }
1880
1881         /* Don't ask for troubles */
1882         if( !bCanBltFourcc ) p_vout->p_sys->b_hw_yuv = FALSE;
1883     }
1884 }
1885
1886 /*****************************************************************************
1887  * DirectXLockSurface: Lock surface and get picture data pointer
1888  *****************************************************************************
1889  * This function locks a surface and get the surface descriptor which amongst
1890  * other things has the pointer to the picture data.
1891  *****************************************************************************/
1892 static int DirectXLockSurface( vout_thread_t *p_vout, picture_t *p_pic )
1893 {
1894     HRESULT dxresult;
1895
1896     /* Lock the surface to get a valid pointer to the picture buffer */
1897     memset( &p_pic->p_sys->ddsd, 0, sizeof( DDSURFACEDESC ));
1898     p_pic->p_sys->ddsd.dwSize = sizeof(DDSURFACEDESC);
1899     dxresult = IDirectDrawSurface2_Lock( p_pic->p_sys->p_surface,
1900                                          NULL, &p_pic->p_sys->ddsd,
1901                                          DDLOCK_NOSYSLOCK | DDLOCK_WAIT,
1902                                          NULL );
1903     if( dxresult != DD_OK )
1904     {
1905         if( dxresult == DDERR_INVALIDPARAMS )
1906         {
1907             /* DirectX 3 doesn't support the DDLOCK_NOSYSLOCK flag, resulting
1908              * in an invalid params error */
1909             dxresult = IDirectDrawSurface2_Lock( p_pic->p_sys->p_surface, NULL,
1910                                              &p_pic->p_sys->ddsd,
1911                                              DDLOCK_WAIT, NULL);
1912         }
1913         if( dxresult == DDERR_SURFACELOST )
1914         {
1915             /* Your surface can be lost so be sure
1916              * to check this and restore it if needed */
1917
1918             /* When using overlays with back-buffers, we need to restore
1919              * the front buffer so the back-buffers get restored as well. */
1920             if( p_vout->p_sys->b_using_overlay  )
1921                 IDirectDrawSurface2_Restore( p_pic->p_sys->p_front_surface );
1922             else
1923                 IDirectDrawSurface2_Restore( p_pic->p_sys->p_surface );
1924
1925             dxresult = IDirectDrawSurface2_Lock( p_pic->p_sys->p_surface, NULL,
1926                                                  &p_pic->p_sys->ddsd,
1927                                                  DDLOCK_WAIT, NULL);
1928 #if 0
1929             if( dxresult == DDERR_SURFACELOST )
1930                 msg_Dbg( p_vout, "DirectXLockSurface: DDERR_SURFACELOST" );
1931 #endif
1932         }
1933         if( dxresult != DD_OK )
1934         {
1935             return VLC_EGENERIC;
1936         }
1937     }
1938
1939     /* Now we have a pointer to the surface memory, we can update our picture
1940      * structure. */
1941     if( UpdatePictureStruct( p_vout, p_pic, p_vout->output.i_chroma )
1942         != VLC_SUCCESS )
1943     {
1944         DirectXUnlockSurface( p_vout, p_pic );
1945         return VLC_EGENERIC;
1946     }
1947     else
1948         return VLC_SUCCESS;
1949 }
1950
1951 /*****************************************************************************
1952  * DirectXUnlockSurface: Unlock a surface locked by DirectXLockSurface().
1953  *****************************************************************************/
1954 static int DirectXUnlockSurface( vout_thread_t *p_vout, picture_t *p_pic )
1955 {
1956     /* Unlock the Surface */
1957     if( IDirectDrawSurface2_Unlock( p_pic->p_sys->p_surface, NULL ) == DD_OK )
1958         return VLC_SUCCESS;
1959     else
1960         return VLC_EGENERIC;
1961 }
1962
1963 /*****************************************************************************
1964  * DirectXFindColorkey: Finds out the 32bits RGB pixel value of the colorkey
1965  *****************************************************************************/
1966 static DWORD DirectXFindColorkey( vout_thread_t *p_vout, uint32_t *pi_color )
1967 {
1968     DDSURFACEDESC ddsd;
1969     HRESULT dxresult;
1970     COLORREF i_rgb = 0;
1971     uint32_t i_pixel_backup;
1972     HDC hdc;
1973
1974     ddsd.dwSize = sizeof(ddsd);
1975     dxresult = IDirectDrawSurface2_Lock( p_vout->p_sys->p_display, NULL,
1976                                          &ddsd, DDLOCK_WAIT, NULL );
1977     if( dxresult != DD_OK ) return 0;
1978
1979     i_pixel_backup = *(uint32_t *)ddsd.lpSurface;
1980
1981     switch( ddsd.ddpfPixelFormat.dwRGBBitCount )
1982     {
1983     case 4:
1984         *(uint8_t *)ddsd.lpSurface = *pi_color | (*pi_color << 4);
1985         break;
1986     case 8:
1987         *(uint8_t *)ddsd.lpSurface = *pi_color;
1988         break;
1989     case 15:
1990     case 16:
1991         *(uint16_t *)ddsd.lpSurface = *pi_color;
1992         break;
1993     case 24:
1994         /* Seems to be problematic so we'll just put black as the colorkey */
1995         *pi_color = 0;
1996     default:
1997         *(uint32_t *)ddsd.lpSurface = *pi_color;
1998         break;
1999     }
2000
2001     IDirectDrawSurface2_Unlock( p_vout->p_sys->p_display, NULL );
2002
2003     if( IDirectDrawSurface2_GetDC( p_vout->p_sys->p_display, &hdc ) == DD_OK )
2004     {
2005         i_rgb = GetPixel( hdc, 0, 0 );
2006         IDirectDrawSurface2_ReleaseDC( p_vout->p_sys->p_display, hdc );
2007     }
2008
2009     ddsd.dwSize = sizeof(ddsd);
2010     dxresult = IDirectDrawSurface2_Lock( p_vout->p_sys->p_display, NULL,
2011                                          &ddsd, DDLOCK_WAIT, NULL );
2012     if( dxresult != DD_OK ) return i_rgb;
2013
2014     *(uint32_t *)ddsd.lpSurface = i_pixel_backup;
2015
2016     IDirectDrawSurface2_Unlock( p_vout->p_sys->p_display, NULL );
2017
2018     return i_rgb;
2019 }
2020
2021 /*****************************************************************************
2022  * A few toolbox functions
2023  *****************************************************************************/
2024 void SwitchWallpaperMode( vout_thread_t *p_vout, bool b_on )
2025 {
2026     HWND hwnd;
2027
2028     if( p_vout->p_sys->b_wallpaper == b_on ) return; /* Nothing to do */
2029
2030     hwnd = FindWindow( _T("Progman"), NULL );
2031     if( hwnd ) hwnd = FindWindowEx( hwnd, NULL, _T("SHELLDLL_DefView"), NULL );
2032     if( hwnd ) hwnd = FindWindowEx( hwnd, NULL, _T("SysListView32"), NULL );
2033     if( !hwnd )
2034     {
2035         msg_Warn( p_vout, "couldn't find \"SysListView32\" window, "
2036                   "wallpaper mode not supported" );
2037         return;
2038     }
2039
2040     p_vout->p_sys->b_wallpaper = b_on;
2041
2042     msg_Dbg( p_vout, "wallpaper mode %s", b_on ? "enabled" : "disabled" );
2043
2044     if( p_vout->p_sys->b_wallpaper )
2045     {
2046         p_vout->p_sys->color_bkg = ListView_GetBkColor( hwnd );
2047         p_vout->p_sys->color_bkgtxt = ListView_GetTextBkColor( hwnd );
2048
2049         ListView_SetBkColor( hwnd, p_vout->p_sys->i_rgb_colorkey );
2050         ListView_SetTextBkColor( hwnd, p_vout->p_sys->i_rgb_colorkey );
2051     }
2052     else if( hwnd )
2053     {
2054         ListView_SetBkColor( hwnd, p_vout->p_sys->color_bkg );
2055         ListView_SetTextBkColor( hwnd, p_vout->p_sys->color_bkgtxt );
2056     }
2057
2058     /* Update desktop */
2059     InvalidateRect( hwnd, NULL, TRUE );
2060     UpdateWindow( hwnd );
2061 }
2062
2063 /*****************************************************************************
2064  * config variable callback
2065  *****************************************************************************/
2066 BOOL WINAPI DirectXEnumCallback2( GUID* p_guid, LPTSTR psz_desc,
2067                                   LPTSTR psz_drivername, VOID* p_context,
2068                                   HMONITOR hmon )
2069 {
2070     module_config_t *p_item = (module_config_t *)p_context;
2071
2072     p_item->ppsz_list =
2073         (char **)realloc( p_item->ppsz_list,
2074                           (p_item->i_list+2) * sizeof(char *) );
2075     p_item->ppsz_list_text =
2076         (char **)realloc( p_item->ppsz_list_text,
2077                           (p_item->i_list+2) * sizeof(char *) );
2078
2079     p_item->ppsz_list[p_item->i_list] = strdup( psz_drivername );
2080     p_item->ppsz_list_text[p_item->i_list] = NULL;
2081     p_item->i_list++;
2082     p_item->ppsz_list[p_item->i_list] = NULL;
2083     p_item->ppsz_list_text[p_item->i_list] = NULL;
2084
2085     return TRUE; /* Keep enumerating */
2086 }
2087
2088 static int FindDevicesCallback( vlc_object_t *p_this, char const *psz_name,
2089                                vlc_value_t newval, vlc_value_t oldval, void *d)
2090 {
2091     HRESULT (WINAPI *OurDirectDrawEnumerateEx)( LPDDENUMCALLBACKEXA, LPVOID,
2092                                                 DWORD );
2093     HINSTANCE hddraw_dll;
2094
2095     module_config_t *p_item;
2096     int i;
2097
2098     p_item = config_FindConfig( p_this, psz_name );
2099     if( !p_item ) return VLC_SUCCESS;
2100
2101     /* Clear-up the current list */
2102     if( p_item->i_list )
2103     {
2104         /* Keep the first entry */
2105         for( i = 1; i < p_item->i_list; i++ )
2106         {
2107             free( p_item->ppsz_list[i] );
2108             free( p_item->ppsz_list_text[i] );
2109         }
2110         /* TODO: Remove when no more needed */
2111         p_item->ppsz_list[i] = NULL;
2112         p_item->ppsz_list_text[i] = NULL;
2113     }
2114     p_item->i_list = 1;
2115
2116     /* Load direct draw DLL */
2117     hddraw_dll = LoadLibrary(_T("DDRAW.DLL"));
2118     if( hddraw_dll == NULL ) return VLC_SUCCESS;
2119
2120     OurDirectDrawEnumerateEx =
2121 #ifndef UNICODE
2122       (void *)GetProcAddress( hddraw_dll, "DirectDrawEnumerateExA" );
2123 #else
2124       (void *)GetProcAddress( hddraw_dll, _T("DirectDrawEnumerateExW") );
2125 #endif
2126
2127     if( OurDirectDrawEnumerateEx )
2128     {
2129         /* Enumerate displays */
2130         OurDirectDrawEnumerateEx( DirectXEnumCallback2, p_item,
2131                                   DDENUM_ATTACHEDSECONDARYDEVICES );
2132     }
2133
2134     FreeLibrary( hddraw_dll );
2135
2136     /* Signal change to the interface */
2137     p_item->b_dirty = true;
2138
2139     return VLC_SUCCESS;
2140 }
2141
2142 static int WallpaperCallback( vlc_object_t *p_this, char const *psz_cmd,
2143                               vlc_value_t oldval, vlc_value_t newval,
2144                               void *p_data )
2145 {
2146     vout_thread_t *p_vout = (vout_thread_t *)p_this;
2147
2148     if( (newval.b_bool && !p_vout->p_sys->b_wallpaper) ||
2149         (!newval.b_bool && p_vout->p_sys->b_wallpaper) )
2150     {
2151         playlist_t *p_playlist = pl_Hold( p_vout );
2152
2153         if( p_playlist )
2154         {
2155             /* Modify playlist as well because the vout might have to be
2156              * restarted */
2157             var_Create( p_playlist, "directx-wallpaper", VLC_VAR_BOOL );
2158             var_Set( p_playlist, "directx-wallpaper", newval );
2159             pl_Release( p_vout );
2160         }
2161
2162         p_vout->p_sys->i_changes |= DX_WALLPAPER_CHANGE;
2163     }
2164
2165     return VLC_SUCCESS;
2166 }
2167
2168 /*****************************************************************************
2169  * SetPalette: sets an 8 bpp palette
2170  *****************************************************************************/
2171 static void SetPalette( vout_thread_t *p_vout,
2172                         uint16_t *red, uint16_t *green, uint16_t *blue )
2173 {
2174     msg_Err( p_vout, "FIXME: SetPalette unimplemented" );
2175 }