开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
directx.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：82k
源码类别：

midi

开发平台：

Unix_Linux

directx.c：源码内容
  1. /*****************************************************************************
  2.  * vout.c: Windows DirectX video output display method
  3.  *****************************************************************************
  4.  * Copyright (C) 2001-2009 the VideoLAN team
  5.  * $Id: cbb7eafca17135ba238cbd2fa744770c630eb6a0 $
  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.  *****************************************************************************/
  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 */
  39. #ifdef HAVE_CONFIG_H
  40. # include "config.h"
  41. #endif
  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>
  49. #include <windows.h>
  50. #include <tchar.h>
  51. #include <ddraw.h>
  52. #include <commctrl.h>
  54. #ifndef UNDER_CE
  55. #   include <multimon.h>
  56. #endif
  57. #undef GetSystemMetrics
  59. #ifndef MONITOR_DEFAULTTONEAREST
  60. #   define MONITOR_DEFAULTTONEAREST 2
  61. #endif
  63. #include "vout.h"
  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. };
  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 );
  89. /*****************************************************************************
  90.  * Local prototypes.
  91.  *****************************************************************************/
  92. static int  OpenVideo  ( vlc_object_t * );
  93. static void CloseVideo ( vlc_object_t * );
  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 * );
  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 );
  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 );
  119. static DWORD DirectXFindColorkey( vout_thread_t *p_vout, uint32_t *i_color );
  121. void SwitchWallpaperMode( vout_thread_t *, bool );
  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 * );
  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." )
  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." )
  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)." )
  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"." )
  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." )
  161. static const char *const ppsz_dev[] = { "" };
  162. static const char *const ppsz_dev_text[] = { N_("Default") };
  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 )
  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") )
  180.     add_bool( "directx-wallpaper", 0, NULL, WALLPAPER_TEXT, WALLPAPER_LONGTEXT,
  181.               true )
  183.     set_description( N_("DirectX video output") )
  184.     set_capability( "video output", 100 )
  185.     add_shortcut( "directx" )
  186.     set_callbacks( OpenVideo, CloseVideo )
  188.     /* FIXME: Hack to avoid unregistering our window class */
  189.     linked_with_a_crap_library_which_uses_atexit ()
  190. vlc_module_end ()
  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
  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;
  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;
  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;
  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 );
  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.     }
  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 );
  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;
  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;
  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 );
  293.     if( p_vout->p_sys->p_event->b_error )
  294.     {
  295.         msg_Err( p_vout, "Vout EventThread failed" );
  296.         goto error;
  297.     }
  299.     vlc_object_attach( p_vout->p_sys->p_event, p_vout );
  301.     msg_Dbg( p_vout, "Vout EventThread running" );
  303.     /* Initialise DirectDraw */
  304.     if( DirectXInitDDraw( p_vout ) )
  305.     {
  306.         msg_Err( p_vout, "cannot initialize DirectX DirectDraw" );
  307.         goto error;
  308.     }
  310.     /* Create the directx display */
  311.     if( DirectXCreateDisplay( p_vout ) )
  312.     {
  313.         msg_Err( p_vout, "cannot initialize DirectX DirectDraw" );
  314.         goto error;
  315.     }
  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" );
  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" );
  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.     }
  352.     return VLC_SUCCESS;
  354.  error:
  355.     CloseVideo( VLC_OBJECT(p_vout) );
  356.     return VLC_EGENERIC;
  357. }
  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;
  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" );
  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.     }
  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.     }
  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 );
  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 */
  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.     }
  427.     NewPictureVec( p_vout, p_vout->p_picture, MAX_DIRECTBUFFERS );
  429.     i_chroma_backup = p_vout->output.i_chroma;
  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.     }
  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.     }
  456.     /* Change the window title bar text */
  457.     PostMessage( p_vout->p_sys->hwnd, WM_VLC_CHANGE_TEXT, 0, 0 );
  459.     p_vout->fmt_out.i_chroma = p_vout->output.i_chroma;
  460.     return VLC_SUCCESS;
  461. }
  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 );
  473.     DirectXCloseDisplay( p_vout );
  474.     DirectXCloseDDraw( p_vout );
  476.     return;
  477. }
  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;
  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.     }
  496.     if( p_vout->p_sys->p_event )
  497.     {
  498.         vlc_object_detach( p_vout->p_sys->p_event );
  500.         /* Kill Vout EventThread */
  501.         vlc_object_kill( p_vout->p_sys->p_event );
  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.         }
  510.         vlc_thread_join( p_vout->p_sys->p_event );
  511.         vlc_object_release( p_vout->p_sys->p_event );
  512.     }
  514.     vlc_mutex_destroy( &p_vout->p_sys->lock );
  516.     /* Make sure the wallpaper is restored */
  517.     var_DelCallback( p_vout, "directx-wallpaper", WallpaperCallback, NULL );
  518.     SwitchWallpaperMode( p_vout, false );
  520.     /* restore screensaver system settings */
  521.     if( 0 != p_vout->p_sys->i_spi_lowpowertimeout ) {
  522.         SystemParametersInfo(SPI_SETLOWPOWERTIMEOUT,
  523.             p_vout->p_sys->i_spi_lowpowertimeout, NULL, 0);
  524.     }
  525.     if( 0 != p_vout->p_sys->i_spi_powerofftimeout ) {
  526.         SystemParametersInfo(SPI_SETPOWEROFFTIMEOUT,
  527.             p_vout->p_sys->i_spi_powerofftimeout, NULL, 0);
  528.     }
  529.     if( 0 != p_vout->p_sys->i_spi_screensavetimeout ) {
  530.         SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT,
  531.             p_vout->p_sys->i_spi_screensavetimeout, NULL, 0);
  532.     }
  534.     free( p_vout->p_sys );
  535.     p_vout->p_sys = NULL;
  536. }
  538. /*****************************************************************************
  539.  * Manage: handle Sys events
  540.  *****************************************************************************
  541.  * This function should be called regularly by the video output thread.
  542.  * It returns a non null value if an error occurred.
  543.  *****************************************************************************/
  544. static int Manage( vout_thread_t *p_vout )
  545. {
  546.     /* If we do not control our window, we check for geometry changes
  547.      * ourselves because the parent might not send us its events. */
  548.     vlc_mutex_lock( &p_vout->p_sys->lock );
  549.     if( p_vout->p_sys->hparent && !p_vout->b_fullscreen )
  550.     {
  551.         RECT rect_parent;
  552.         POINT point;
  554.         vlc_mutex_unlock( &p_vout->p_sys->lock );
  556.         GetClientRect( p_vout->p_sys->hparent, &rect_parent );
  557.         point.x = point.y = 0;
  558.         ClientToScreen( p_vout->p_sys->hparent, &point );
  559.         OffsetRect( &rect_parent, point.x, point.y );
  561.         if( !EqualRect( &rect_parent, &p_vout->p_sys->rect_parent ) )
  562.         {
  563.             p_vout->p_sys->rect_parent = rect_parent;
  565.             /* This one is to force the update even if only
  566.              * the position has changed */
  567.             SetWindowPos( p_vout->p_sys->hwnd, 0, 1, 1,
  568.                           rect_parent.right - rect_parent.left,
  569.                           rect_parent.bottom - rect_parent.top, 0 );
  571.             SetWindowPos( p_vout->p_sys->hwnd, 0, 0, 0,
  572.                           rect_parent.right - rect_parent.left,
  573.                           rect_parent.bottom - rect_parent.top, 0 );
  574.         }
  575.     }
  576.     else
  577.     {
  578.         vlc_mutex_unlock( &p_vout->p_sys->lock );
  579.     }
  581.     /*
  582.      * Position Change
  583.      */
  584.     if( p_vout->p_sys->i_changes & DX_POSITION_CHANGE )
  585.     {
  586.         p_vout->p_sys->i_changes &= ~DX_POSITION_CHANGE;
  588.         /* Check if we are still on the same monitor */
  589.         if( p_vout->p_sys->MonitorFromWindow &&
  590.             p_vout->p_sys->hmonitor !=
  591.                 p_vout->p_sys->MonitorFromWindow( p_vout->p_sys->hwnd,
  592.                                                   MONITOR_DEFAULTTONEAREST ) )
  593.         {
  594.             /* This will force the vout core to recreate the picture buffers */
  595.             p_vout->i_changes |= VOUT_PICTURE_BUFFERS_CHANGE;
  596.         }
  597.     }
  599.     /* autoscale toggle */
  600.     if( p_vout->i_changes & VOUT_SCALE_CHANGE )
  601.     {
  602.         p_vout->i_changes &= ~VOUT_SCALE_CHANGE;
  604.         p_vout->b_autoscale = var_GetBool( p_vout, "autoscale" );
  605.         p_vout->i_zoom = (int) ZOOM_FP_FACTOR;
  607.         UpdateRects( p_vout, true );
  608.     }
  610.     /* scaling factor */
  611.     if( p_vout->i_changes & VOUT_ZOOM_CHANGE )
  612.     {
  613.         p_vout->i_changes &= ~VOUT_ZOOM_CHANGE;
  615.         p_vout->b_autoscale = false;
  616.         p_vout->i_zoom =
  617.             (int)( ZOOM_FP_FACTOR * var_GetFloat( p_vout, "scale" ) );
  618.         UpdateRects( p_vout, true );
  619.     }
  621.     /* Check for cropping / aspect changes */
  622.     if( p_vout->i_changes & VOUT_CROP_CHANGE ||
  623.         p_vout->i_changes & VOUT_ASPECT_CHANGE )
  624.     {
  625.         p_vout->i_changes &= ~VOUT_CROP_CHANGE;
  626.         p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
  628.         p_vout->fmt_out.i_x_offset = p_vout->fmt_in.i_x_offset;
  629.         p_vout->fmt_out.i_y_offset = p_vout->fmt_in.i_y_offset;
  630.         p_vout->fmt_out.i_visible_width = p_vout->fmt_in.i_visible_width;
  631.         p_vout->fmt_out.i_visible_height = p_vout->fmt_in.i_visible_height;
  632.         p_vout->fmt_out.i_aspect = p_vout->fmt_in.i_aspect;
  633.         p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
  634.         p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
  635.         p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
  636.         UpdateRects( p_vout, true );
  637.     }
  639.     /* We used to call the Win32 PeekMessage function here to read the window
  640.      * messages. But since window can stay blocked into this function for a
  641.      * long time (for example when you move your window on the screen), I
  642.      * decided to isolate PeekMessage in another thread. */
  644.     if( p_vout->p_sys->i_changes & DX_WALLPAPER_CHANGE )
  645.     {
  646.         SwitchWallpaperMode( p_vout, !p_vout->p_sys->b_wallpaper );
  647.         p_vout->p_sys->i_changes &= ~DX_WALLPAPER_CHANGE;
  648.         DirectDrawUpdateOverlay( p_vout );
  649.     }
  651.     /*
  652.      * Fullscreen change
  653.      */
  654.     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE
  655.         || p_vout->p_sys->i_changes & VOUT_FULLSCREEN_CHANGE )
  656.     {
  657.         Win32ToggleFullscreen( p_vout );
  659.         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
  660.         p_vout->p_sys->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
  661.     }
  663.     /*
  664.      * Pointer change
  665.      */
  666.     if( p_vout->b_fullscreen && !p_vout->p_sys->b_cursor_hidden &&
  667.         (mdate() - p_vout->p_sys->i_lastmoved) >
  668.             p_vout->p_sys->i_mouse_hide_timeout )
  669.     {
  670.         POINT point;
  671.         HWND hwnd;
  673.         /* Hide the cursor only if it is inside our window */
  674.         GetCursorPos( &point );
  675.         hwnd = WindowFromPoint(point);
  676.         if( hwnd == p_vout->p_sys->hwnd || hwnd == p_vout->p_sys->hvideownd )
  677.         {
  678.             PostMessage( p_vout->p_sys->hwnd, WM_VLC_HIDE_MOUSE, 0, 0 );
  679.         }
  680.         else
  681.         {
  682.             p_vout->p_sys->i_lastmoved = mdate();
  683.         }
  684.     }
  686.     /*
  687.      * "Always on top" status change
  688.      */
  689.     if( p_vout->p_sys->b_on_top_change )
  690.     {
  691.         vlc_value_t val;
  692.         HMENU hMenu = GetSystemMenu( p_vout->p_sys->hwnd, FALSE );
  694.         var_Get( p_vout, "video-on-top", &val );
  696.         /* Set the window on top if necessary */
  697.         if( val.b_bool && !( GetWindowLong( p_vout->p_sys->hwnd, GWL_EXSTYLE )
  698.                            & WS_EX_TOPMOST ) )
  699.         {
  700.             CheckMenuItem( hMenu, IDM_TOGGLE_ON_TOP,
  701.                            MF_BYCOMMAND | MFS_CHECKED );
  702.             SetWindowPos( p_vout->p_sys->hwnd, HWND_TOPMOST, 0, 0, 0, 0,
  703.                           SWP_NOSIZE | SWP_NOMOVE );
  704.         }
  705.         else
  706.         /* The window shouldn't be on top */
  707.         if( !val.b_bool && ( GetWindowLong( p_vout->p_sys->hwnd, GWL_EXSTYLE )
  708.                            & WS_EX_TOPMOST ) )
  709.         {
  710.             CheckMenuItem( hMenu, IDM_TOGGLE_ON_TOP,
  711.                            MF_BYCOMMAND | MFS_UNCHECKED );
  712.             SetWindowPos( p_vout->p_sys->hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
  713.                           SWP_NOSIZE | SWP_NOMOVE );
  714.         }
  716.         p_vout->p_sys->b_on_top_change = false;
  717.     }
  719.     /* Check if the event thread is still running */
  720.     if( !vlc_object_alive (p_vout->p_sys->p_event) )
  721.     {
  722.         return VLC_EGENERIC; /* exit */
  723.     }
  725.     return VLC_SUCCESS;
  726. }
  728. /*****************************************************************************
  729.  * Display: displays previously rendered output
  730.  *****************************************************************************
  731.  * This function sends the currently rendered image to the display, wait until
  732.  * it is displayed and switch the two rendering buffers, preparing next frame.
  733.  *****************************************************************************/
  734. static void Display( vout_thread_t *p_vout, picture_t *p_pic )
  735. {
  736.     HRESULT dxresult;
  738.     if( (p_vout->p_sys->p_display == NULL) )
  739.     {
  740.         msg_Warn( p_vout, "no display!" );
  741.         return;
  742.     }
  744.     /* Our surface can be lost so be sure to check this
  745.      * and restore it if need be */
  746.     if( IDirectDrawSurface2_IsLost( p_vout->p_sys->p_display )
  747.         == DDERR_SURFACELOST )
  748.     {
  749.         if( IDirectDrawSurface2_Restore( p_vout->p_sys->p_display ) == DD_OK &&
  750.             p_vout->p_sys->b_using_overlay )
  751.             DirectDrawUpdateOverlay( p_vout );
  752.     }
  754.     if( !p_vout->p_sys->b_using_overlay )
  755.     {
  756.         DDBLTFX  ddbltfx;
  758.         /* We ask for the "NOTEARING" option */
  759.         memset( &ddbltfx, 0, sizeof(DDBLTFX) );
  760.         ddbltfx.dwSize = sizeof(DDBLTFX);
  761.         ddbltfx.dwDDFX = DDBLTFX_NOTEARING;
  763.         /* Blit video surface to display */
  764.         dxresult = IDirectDrawSurface2_Blt( p_vout->p_sys->p_display,
  765.                                             &p_vout->p_sys->rect_dest_clipped,
  766.                                             p_pic->p_sys->p_surface,
  767.                                             &p_vout->p_sys->rect_src_clipped,
  768.                                             DDBLT_ASYNC, &ddbltfx );
  769.         if( dxresult != DD_OK )
  770.         {
  771.             msg_Warn( p_vout, "could not blit surface (error %li)", dxresult );
  772.             return;
  773.         }
  774.     }
  775.     else /* using overlay */
  776.     {
  777.         /* Flip the overlay buffers if we are using back buffers */
  778.         if( p_pic->p_sys->p_front_surface == p_pic->p_sys->p_surface )
  779.         {
  780.             return;
  781.         }
  783.         dxresult = IDirectDrawSurface2_Flip( p_pic->p_sys->p_front_surface,
  784.                                              NULL, DDFLIP_WAIT );
  785.         if( dxresult != DD_OK )
  786.         {
  787.             msg_Warn( p_vout, "could not flip overlay (error %li)", dxresult );
  788.         }
  790.         /* set currently displayed pic */
  791.         p_vout->p_sys->p_current_surface = p_pic->p_sys->p_front_surface;
  793.         /* Lock surface to get all the required info */
  794.         if( DirectXLockSurface( p_vout, p_pic ) )
  795.         {
  796.             /* AAARRGG */
  797.             msg_Warn( p_vout, "cannot lock surface" );
  798.             return;
  799.         }
  800.         DirectXUnlockSurface( p_vout, p_pic );
  801.     }
  802. }
  804. /*
  805. ** this function is only used once when the first picture is received
  806. ** this function will show the video window once video is ready for
  807. ** display.
  808. */
  810. static void FirstDisplay( vout_thread_t *p_vout, picture_t *p_pic )
  811. {
  812.     /* get initial picture rendered on overlay surface */
  813.     Display(p_vout, p_pic);
  815.     IDirectDraw_WaitForVerticalBlank(p_vout->p_sys->p_ddobject,
  816.             DDWAITVB_BLOCKBEGIN, NULL);
  818.     if( p_vout->p_sys->b_using_overlay )
  819.     {
  820.         /* set the colorkey as the backgound brush for the video window */
  821.         SetClassLong( p_vout->p_sys->hvideownd, GCL_HBRBACKGROUND,
  822.                       (LONG)CreateSolidBrush( p_vout->p_sys->i_rgb_colorkey ) );
  823.     }
  824.     /*
  825.     ** Video window is initially hidden, show it now since we got a
  826.     ** picture to show.
  827.     */
  828.     SetWindowPos( p_vout->p_sys->hvideownd, NULL, 0, 0, 0, 0,
  829.         SWP_ASYNCWINDOWPOS|
  830.         SWP_FRAMECHANGED|
  831.         SWP_SHOWWINDOW|
  832.         SWP_NOMOVE|
  833.         SWP_NOSIZE|
  834.         SWP_NOZORDER );
  836.     /* use and restores proper display function for further pictures */
  837.     p_vout->pf_display = Display;
  838. }
  840. /* following functions are local */
  842. /*****************************************************************************
  843.  * DirectXEnumCallback: Device enumeration
  844.  *****************************************************************************
  845.  * This callback function is called by DirectDraw once for each
  846.  * available DirectDraw device.
  847.  *****************************************************************************/
  848. BOOL WINAPI DirectXEnumCallback( GUID* p_guid, LPTSTR psz_desc,
  849.                                  LPTSTR psz_drivername, VOID* p_context,
  850.                                  HMONITOR hmon )
  851. {
  852.     vout_thread_t *p_vout = (vout_thread_t *)p_context;
  853.     vlc_value_t device;
  855.     msg_Dbg( p_vout, "DirectXEnumCallback: %s, %s", psz_desc, psz_drivername );
  857.     if( hmon )
  858.     {
  859.         var_Get( p_vout, "directx-device", &device );
  861.         if( ( !device.psz_string || !*device.psz_string ) &&
  862.             hmon == p_vout->p_sys->hmonitor )
  863.         {
  864.             free( device.psz_string );
  865.         }
  866.         else if( strcmp( psz_drivername, device.psz_string ) == 0 )
  867.         {
  868.             MONITORINFO monitor_info;
  869.             monitor_info.cbSize = sizeof( MONITORINFO );
  871.             if( p_vout->p_sys->GetMonitorInfo( hmon, &monitor_info ) )
  872.             {
  873.                 RECT rect;
  875.                 /* Move window to the right screen */
  876.                 GetWindowRect( p_vout->p_sys->hwnd, &rect );
  877.                 if( !IntersectRect( &rect, &rect, &monitor_info.rcWork ) )
  878.                 {
  879.                     rect.left = monitor_info.rcWork.left;
  880.                     rect.top = monitor_info.rcWork.top;
  881.                     msg_Dbg( p_vout, "DirectXEnumCallback: setting window "
  882.                              "position to %ld,%ld", rect.left, rect.top );
  883.                     SetWindowPos( p_vout->p_sys->hwnd, NULL,
  884.                                   rect.left, rect.top, 0, 0,
  885.                                   SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
  886.                 }
  887.             }
  889.             p_vout->p_sys->hmonitor = hmon;
  890.             free( device.psz_string );
  891.         }
  892.         else
  893.         {
  894.             free( device.psz_string );
  895.             return TRUE; /* Keep enumerating */
  896.         }
  898.         msg_Dbg( p_vout, "selecting %s, %s", psz_desc, psz_drivername );
  899.         p_vout->p_sys->p_display_driver = malloc( sizeof(GUID) );
  900.         if( p_vout->p_sys->p_display_driver )
  901.             memcpy( p_vout->p_sys->p_display_driver, p_guid, sizeof(GUID) );
  902.     }
  904.     return TRUE; /* Keep enumerating */
  905. }
  907. /*****************************************************************************
  908.  * DirectXInitDDraw: Takes care of all the DirectDraw initialisations
  909.  *****************************************************************************
  910.  * This function initialise and allocate resources for DirectDraw.
  911.  *****************************************************************************/
  912. static int DirectXInitDDraw( vout_thread_t *p_vout )
  913. {
  914.     HRESULT dxresult;
  915.     HRESULT (WINAPI *OurDirectDrawCreate)(GUID *,LPDIRECTDRAW *,IUnknown *);
  916.     HRESULT (WINAPI *OurDirectDrawEnumerateEx)( LPDDENUMCALLBACKEXA, LPVOID,
  917.                                                 DWORD );
  918.     LPDIRECTDRAW p_ddobject;
  920.     msg_Dbg( p_vout, "DirectXInitDDraw" );
  922.     /* Load direct draw DLL */
  923.     p_vout->p_sys->hddraw_dll = LoadLibrary(_T("DDRAW.DLL"));
  924.     if( p_vout->p_sys->hddraw_dll == NULL )
  925.     {
  926.         msg_Warn( p_vout, "DirectXInitDDraw failed loading ddraw.dll" );
  927.         goto error;
  928.     }
  930.     OurDirectDrawCreate =
  931.       (void *)GetProcAddress( p_vout->p_sys->hddraw_dll,
  932.                               _T("DirectDrawCreate") );
  933.     if( OurDirectDrawCreate == NULL )
  934.     {
  935.         msg_Err( p_vout, "DirectXInitDDraw failed GetProcAddress" );
  936.         goto error;
  937.     }
  939.     OurDirectDrawEnumerateEx =
  940.       (void *)GetProcAddress( p_vout->p_sys->hddraw_dll,
  941. #ifndef UNICODE
  942.                               "DirectDrawEnumerateExA" );
  943. #else
  944.                               _T("DirectDrawEnumerateExW") );
  945. #endif
  947.     if( OurDirectDrawEnumerateEx && p_vout->p_sys->MonitorFromWindow )
  948.     {
  949.         vlc_value_t device;
  951.         var_Get( p_vout, "directx-device", &device );
  952.         if( device.psz_string )
  953.         {
  954.             msg_Dbg( p_vout, "directx-device: %s", device.psz_string );
  955.             free( device.psz_string );
  956.         }
  958.         p_vout->p_sys->hmonitor =
  959.             p_vout->p_sys->MonitorFromWindow( p_vout->p_sys->hwnd,
  960.                                               MONITOR_DEFAULTTONEAREST );
  962.         /* Enumerate displays */
  963.         OurDirectDrawEnumerateEx( DirectXEnumCallback, p_vout,
  964.                                   DDENUM_ATTACHEDSECONDARYDEVICES );
  965.     }
  967.     /* Initialize DirectDraw now */
  968.     dxresult = OurDirectDrawCreate( p_vout->p_sys->p_display_driver,
  969.                                     &p_ddobject, NULL );
  970.     if( dxresult != DD_OK )
  971.     {
  972.         msg_Err( p_vout, "DirectXInitDDraw cannot initialize DDraw" );
  973.         goto error;
  974.     }
  976.     /* Get the IDirectDraw2 interface */
  977.     dxresult = IDirectDraw_QueryInterface( p_ddobject, &IID_IDirectDraw2,
  978.                                         (LPVOID *)&p_vout->p_sys->p_ddobject );
  979.     /* Release the unused interface */
  980.     IDirectDraw_Release( p_ddobject );
  981.     if( dxresult != DD_OK )
  982.     {
  983.         msg_Err( p_vout, "cannot get IDirectDraw2 interface" );
  984.         goto error;
  985.     }
  987.     /* Set DirectDraw Cooperative level, ie what control we want over Windows
  988.      * display */
  989.     dxresult = IDirectDraw2_SetCooperativeLevel( p_vout->p_sys->p_ddobject,
  990.                                                  NULL, DDSCL_NORMAL );
  991.     if( dxresult != DD_OK )
  992.     {
  993.         msg_Err( p_vout, "cannot set direct draw cooperative level" );
  994.         goto error;
  995.     }
  997.     /* Get the size of the current display device */
  998.     if( p_vout->p_sys->hmonitor && p_vout->p_sys->GetMonitorInfo )
  999.     {
  1000.         MONITORINFO monitor_info;
  1001.         monitor_info.cbSize = sizeof( MONITORINFO );
  1002.         p_vout->p_sys->GetMonitorInfo( p_vout->p_sys->hmonitor,
  1003.                                        &monitor_info );
  1004.         p_vout->p_sys->rect_display = monitor_info.rcMonitor;
  1005.     }
  1006.     else
  1007.     {
  1008.         p_vout->p_sys->rect_display.left = 0;
  1009.         p_vout->p_sys->rect_display.top = 0;
  1010.         p_vout->p_sys->rect_display.right  = GetSystemMetrics(SM_CXSCREEN);
  1011.         p_vout->p_sys->rect_display.bottom = GetSystemMetrics(SM_CYSCREEN);
  1012.     }
  1014.     msg_Dbg( p_vout, "screen dimensions (%lix%li,%lix%li)",
  1015.              p_vout->p_sys->rect_display.left,
  1016.              p_vout->p_sys->rect_display.top,
  1017.              p_vout->p_sys->rect_display.right,
  1018.              p_vout->p_sys->rect_display.bottom );
  1020.     /* Probe the capabilities of the hardware */
  1021.     DirectXGetDDrawCaps( p_vout );
  1023.     msg_Dbg( p_vout, "End DirectXInitDDraw" );
  1024.     return VLC_SUCCESS;
  1026.  error:
  1027.     if( p_vout->p_sys->p_ddobject )
  1028.         IDirectDraw2_Release( p_vout->p_sys->p_ddobject );
  1029.     if( p_vout->p_sys->hddraw_dll )
  1030.         FreeLibrary( p_vout->p_sys->hddraw_dll );
  1031.     p_vout->p_sys->hddraw_dll = NULL;
  1032.     p_vout->p_sys->p_ddobject = NULL;
  1033.     return VLC_EGENERIC;
  1034. }
  1036. /*****************************************************************************
  1037.  * DirectXCreateDisplay: create the DirectDraw display.
  1038.  *****************************************************************************
  1039.  * Create and initialize display according to preferences specified in the vout
  1040.  * thread fields.
  1041.  *****************************************************************************/
  1042. static int DirectXCreateDisplay( vout_thread_t *p_vout )
  1043. {
  1044.     HRESULT              dxresult;
  1045.     DDSURFACEDESC        ddsd;
  1046.     LPDIRECTDRAWSURFACE  p_display;
  1048.     msg_Dbg( p_vout, "DirectXCreateDisplay" );
  1050.     /* Now get the primary surface. This surface is what you actually see
  1051.      * on your screen */
  1052.     memset( &ddsd, 0, sizeof( DDSURFACEDESC ));
  1053.     ddsd.dwSize = sizeof(DDSURFACEDESC);
  1054.     ddsd.dwFlags = DDSD_CAPS;
  1055.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  1057.     dxresult = IDirectDraw2_CreateSurface( p_vout->p_sys->p_ddobject,
  1058.                                            &ddsd, &p_display, NULL );
  1059.     if( dxresult != DD_OK )
  1060.     {
  1061.         msg_Err( p_vout, "cannot get primary surface (error %li)", dxresult );
  1062.         return VLC_EGENERIC;
  1063.     }
  1065.     dxresult = IDirectDrawSurface_QueryInterface( p_display,
  1066.                                          &IID_IDirectDrawSurface2,
  1067.                                          (LPVOID *)&p_vout->p_sys->p_display );
  1068.     /* Release the old interface */
  1069.     IDirectDrawSurface_Release( p_display );
  1070.     if ( dxresult != DD_OK )
  1071.     {
  1072.         msg_Err( p_vout, "cannot query IDirectDrawSurface2 interface "
  1073.                          "(error %li)", dxresult );
  1074.         return VLC_EGENERIC;
  1075.     }
  1077.     /* The clipper will be used only in non-overlay mode */
  1078.     DirectXCreateClipper( p_vout );
  1080.     /* Make sure the colorkey will be painted */
  1081.     p_vout->p_sys->i_colorkey = 1;
  1082.     p_vout->p_sys->i_rgb_colorkey =
  1083.         DirectXFindColorkey( p_vout, &p_vout->p_sys->i_colorkey );
  1085.     UpdateRects( p_vout, true );
  1087.     return VLC_SUCCESS;
  1088. }
  1090. /*****************************************************************************
  1091.  * DirectXCreateClipper: Create a clipper that will be used when blitting the
  1092.  *                       RGB surface to the main display.
  1093.  *****************************************************************************
  1094.  * This clipper prevents us to modify by mistake anything on the screen
  1095.  * which doesn't belong to our window. For example when a part of our video
  1096.  * window is hidden by another window.
  1097.  *****************************************************************************/
  1098. static int DirectXCreateClipper( vout_thread_t *p_vout )
  1099. {
  1100.     HRESULT dxresult;
  1102.     msg_Dbg( p_vout, "DirectXCreateClipper" );
  1104.     /* Create the clipper */
  1105.     dxresult = IDirectDraw2_CreateClipper( p_vout->p_sys->p_ddobject, 0,
  1106.                                            &p_vout->p_sys->p_clipper, NULL );
  1107.     if( dxresult != DD_OK )
  1108.     {
  1109.         msg_Warn( p_vout, "cannot create clipper (error %li)", dxresult );
  1110.         goto error;
  1111.     }
  1113.     /* Associate the clipper to the window */
  1114.     dxresult = IDirectDrawClipper_SetHWnd( p_vout->p_sys->p_clipper, 0,
  1115.                                            p_vout->p_sys->hvideownd );
  1116.     if( dxresult != DD_OK )
  1117.     {
  1118.         msg_Warn( p_vout, "cannot attach clipper to window (error %li)",
  1119.                           dxresult );
  1120.         goto error;
  1121.     }
  1123.     /* associate the clipper with the surface */
  1124.     dxresult = IDirectDrawSurface_SetClipper(p_vout->p_sys->p_display,
  1125.                                              p_vout->p_sys->p_clipper);
  1126.     if( dxresult != DD_OK )
  1127.     {
  1128.         msg_Warn( p_vout, "cannot attach clipper to surface (error %li)",
  1129.                           dxresult );
  1130.         goto error;
  1131.     }
  1133.     return VLC_SUCCESS;
  1135.  error:
  1136.     if( p_vout->p_sys->p_clipper )
  1137.     {
  1138.         IDirectDrawClipper_Release( p_vout->p_sys->p_clipper );
  1139.     }
  1140.     p_vout->p_sys->p_clipper = NULL;
  1141.     return VLC_EGENERIC;
  1142. }
  1144. /*****************************************************************************
  1145.  * DirectXCreateSurface: create an YUV overlay or RGB surface for the video.
  1146.  *****************************************************************************
  1147.  * The best method of display is with an YUV overlay because the YUV->RGB
  1148.  * conversion is done in hardware.
  1149.  * You can also create a plain RGB surface.
  1150.  * ( Maybe we could also try an RGB overlay surface, which could have hardware
  1151.  * scaling and which would also be faster in window mode because you don't
  1152.  * need to do any blitting to the main display...)
  1153.  *****************************************************************************/
  1154. static int DirectXCreateSurface( vout_thread_t *p_vout,
  1155.                                  LPDIRECTDRAWSURFACE2 *pp_surface_final,
  1156.                                  int i_chroma, int b_overlay,
  1157.                                  int i_backbuffers )
  1158. {
  1159.     HRESULT dxresult;
  1160.     LPDIRECTDRAWSURFACE p_surface;
  1161.     DDSURFACEDESC ddsd;
  1163.     /* Create the video surface */
  1164.     if( b_overlay )
  1165.     {
  1166.         /* Now try to create the YUV overlay surface.
  1167.          * This overlay will be displayed on top of the primary surface.
  1168.          * A color key is used to determine whether or not the overlay will be
  1169.          * displayed, ie the overlay will be displayed in place of the primary
  1170.          * surface wherever the primary surface will have this color.
  1171.          * The video window has been created with a background of this color so
  1172.          * the overlay will be only displayed on top of this window */
  1174.         memset( &ddsd, 0, sizeof( DDSURFACEDESC ));
  1175.         ddsd.dwSize = sizeof(DDSURFACEDESC);
  1176.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  1177.         ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
  1178.         ddsd.ddpfPixelFormat.dwFourCC = i_chroma;
  1179.         ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
  1180.         ddsd.dwFlags |= (i_backbuffers ? DDSD_BACKBUFFERCOUNT : 0);
  1181.         ddsd.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
  1182.         ddsd.ddsCaps.dwCaps |= (i_backbuffers ? DDSCAPS_COMPLEX | DDSCAPS_FLIP
  1183.                                 : 0 );
  1184.         ddsd.dwHeight = p_vout->render.i_height;
  1185.         ddsd.dwWidth = p_vout->render.i_width;
  1186.         ddsd.dwBackBufferCount = i_backbuffers;
  1188.         dxresult = IDirectDraw2_CreateSurface( p_vout->p_sys->p_ddobject,
  1189.                                                &ddsd, &p_surface, NULL );
  1190.         if( dxresult != DD_OK )
  1191.         {
  1192.             *pp_surface_final = NULL;
  1193.             return VLC_EGENERIC;
  1194.         }
  1195.     }
  1197.     if( !b_overlay )
  1198.     {
  1199.         bool b_rgb_surface =
  1200.             ( i_chroma == VLC_FOURCC('R','G','B','2') )
  1201.           || ( i_chroma == VLC_FOURCC('R','V','1','5') )
  1202.            || ( i_chroma == VLC_FOURCC('R','V','1','6') )
  1203.             || ( i_chroma == VLC_FOURCC('R','V','2','4') )
  1204.              || ( i_chroma == VLC_FOURCC('R','V','3','2') );
  1206.         memset( &ddsd, 0, sizeof( DDSURFACEDESC ) );
  1207.         ddsd.dwSize = sizeof(DDSURFACEDESC);
  1208.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  1209.         ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_CAPS;
  1210.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  1211.         ddsd.dwHeight = p_vout->render.i_height;
  1212.         ddsd.dwWidth = p_vout->render.i_width;
  1214.         if( p_vout->p_sys->b_use_sysmem )
  1215.             ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
  1216.         else
  1217.             ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
  1219.         if( !b_rgb_surface )
  1220.         {
  1221.             ddsd.dwFlags |= DDSD_PIXELFORMAT;
  1222.             ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
  1223.             ddsd.ddpfPixelFormat.dwFourCC = i_chroma;
  1224.         }
  1226.         dxresult = IDirectDraw2_CreateSurface( p_vout->p_sys->p_ddobject,
  1227.                                                &ddsd, &p_surface, NULL );
  1228.         if( dxresult != DD_OK )
  1229.         {
  1230.             *pp_surface_final = NULL;
  1231.             return VLC_EGENERIC;
  1232.         }
  1233.     }
  1235.     /* Now that the surface is created, try to get a newer DirectX interface */
  1236.     dxresult = IDirectDrawSurface_QueryInterface( p_surface,
  1237.                                      &IID_IDirectDrawSurface2,
  1238.                                      (LPVOID *)pp_surface_final );
  1239.     IDirectDrawSurface_Release( p_surface );    /* Release the old interface */
  1240.     if ( dxresult != DD_OK )
  1241.     {
  1242.         msg_Err( p_vout, "cannot query IDirectDrawSurface2 interface "
  1243.                          "(error %li)", dxresult );
  1244.         *pp_surface_final = NULL;
  1245.         return VLC_EGENERIC;
  1246.     }
  1248.     if( b_overlay )
  1249.     {
  1250.         /* Check the overlay is useable as some graphics cards allow creating
  1251.          * several overlays but only one can be used at one time. */
  1252.         p_vout->p_sys->p_current_surface = *pp_surface_final;
  1253.         if( DirectDrawUpdateOverlay( p_vout ) != VLC_SUCCESS )
  1254.         {
  1255.             IDirectDrawSurface2_Release( *pp_surface_final );
  1256.             *pp_surface_final = NULL;
  1257.             msg_Err( p_vout, "overlay unuseable (might already be in use)" );
  1258.             return VLC_EGENERIC;
  1259.         }
  1260.     }
  1262.     return VLC_SUCCESS;
  1263. }
  1265. /*****************************************************************************
  1266.  * DirectDrawUpdateOverlay: Move or resize overlay surface on video display.
  1267.  *****************************************************************************
  1268.  * This function is used to move or resize an overlay surface on the screen.
  1269.  * Ususally the overlay is moved by the user and thus, by a move or resize
  1270.  * event (in Manage).
  1271.  *****************************************************************************/
  1272. int DirectDrawUpdateOverlay( vout_thread_t *p_vout )
  1273. {
  1274.     DDOVERLAYFX     ddofx;
  1275.     DWORD           dwFlags;
  1276.     HRESULT         dxresult;
  1277.     RECT            rect_src = p_vout->p_sys->rect_src_clipped;
  1278.     RECT            rect_dest = p_vout->p_sys->rect_dest_clipped;
  1280.     if( !p_vout->p_sys->b_using_overlay ) return VLC_EGENERIC;
  1282.     if( p_vout->p_sys->b_wallpaper )
  1283.     {
  1284.         int i_x, i_y, i_width, i_height;
  1286.         rect_src.left = p_vout->fmt_out.i_x_offset;
  1287.         rect_src.top = p_vout->fmt_out.i_y_offset;
  1288.         rect_src.right = rect_src.left + p_vout->fmt_out.i_visible_width;
  1289.         rect_src.bottom = rect_src.top + p_vout->fmt_out.i_visible_height;
  1291.         rect_dest = p_vout->p_sys->rect_display;
  1292.         vout_PlacePicture( p_vout, rect_dest.right, rect_dest.bottom,
  1293.                            &i_x, &i_y, &i_width, &i_height );
  1295.         rect_dest.left += i_x;
  1296.         rect_dest.right = rect_dest.left + i_width;
  1297.         rect_dest.top += i_y;
  1298.         rect_dest.bottom = rect_dest.top + i_height;
  1299.     }
  1301.     vlc_mutex_lock( &p_vout->p_sys->lock );
  1302.     if( p_vout->p_sys->p_current_surface == NULL )
  1303.     {
  1304.         vlc_mutex_unlock( &p_vout->p_sys->lock );
  1305.         return VLC_EGENERIC;
  1306.     }
  1308.     /* The new window dimensions should already have been computed by the
  1309.      * caller of this function */
  1311.     /* Position and show the overlay */
  1312.     memset(&ddofx, 0, sizeof(DDOVERLAYFX));
  1313.     ddofx.dwSize = sizeof(DDOVERLAYFX);
  1314.     ddofx.dckDestColorkey.dwColorSpaceLowValue = p_vout->p_sys->i_colorkey;
  1315.     ddofx.dckDestColorkey.dwColorSpaceHighValue = p_vout->p_sys->i_colorkey;
  1317.     dwFlags = DDOVER_SHOW | DDOVER_KEYDESTOVERRIDE;
  1319.     dxresult = IDirectDrawSurface2_UpdateOverlay(
  1320.                    p_vout->p_sys->p_current_surface,
  1321.                    &rect_src, p_vout->p_sys->p_display, &rect_dest,
  1322.                    dwFlags, &ddofx );
  1324.     vlc_mutex_unlock( &p_vout->p_sys->lock );
  1326.     if(dxresult != DD_OK)
  1327.     {
  1328.         msg_Warn( p_vout, "DirectDrawUpdateOverlay cannot move/resize overlay" );
  1329.         return VLC_EGENERIC;
  1330.     }
  1332.     return VLC_SUCCESS;
  1333. }
  1335. /*****************************************************************************
  1336.  * DirectXCloseDDraw: Release the DDraw object allocated by DirectXInitDDraw
  1337.  *****************************************************************************
  1338.  * This function returns all resources allocated by DirectXInitDDraw.
  1339.  *****************************************************************************/
  1340. static void DirectXCloseDDraw( vout_thread_t *p_vout )
  1341. {
  1342.     msg_Dbg( p_vout, "DirectXCloseDDraw" );
  1343.     if( p_vout->p_sys->p_ddobject != NULL )
  1344.     {
  1345.         IDirectDraw2_Release(p_vout->p_sys->p_ddobject);
  1346.         p_vout->p_sys->p_ddobject = NULL;
  1347.     }
  1349.     if( p_vout->p_sys->hddraw_dll != NULL )
  1350.     {
  1351.         FreeLibrary( p_vout->p_sys->hddraw_dll );
  1352.         p_vout->p_sys->hddraw_dll = NULL;
  1353.     }
  1355.     free( p_vout->p_sys->p_display_driver );
  1356.     p_vout->p_sys->p_display_driver = NULL;
  1358.     p_vout->p_sys->hmonitor = NULL;
  1359. }
  1361. /*****************************************************************************
  1362.  * DirectXCloseDisplay: close and reset the DirectX display device
  1363.  *****************************************************************************
  1364.  * This function returns all resources allocated by DirectXCreateDisplay.
  1365.  *****************************************************************************/
  1366. static void DirectXCloseDisplay( vout_thread_t *p_vout )
  1367. {
  1368.     msg_Dbg( p_vout, "DirectXCloseDisplay" );
  1370.     if( p_vout->p_sys->p_clipper != NULL )
  1371.     {
  1372.         msg_Dbg( p_vout, "DirectXCloseDisplay clipper" );
  1373.         IDirectDrawClipper_Release( p_vout->p_sys->p_clipper );
  1374.         p_vout->p_sys->p_clipper = NULL;
  1375.     }
  1377.     if( p_vout->p_sys->p_display != NULL )
  1378.     {
  1379.         msg_Dbg( p_vout, "DirectXCloseDisplay display" );
  1380.         IDirectDrawSurface2_Release( p_vout->p_sys->p_display );
  1381.         p_vout->p_sys->p_display = NULL;
  1382.     }
  1383. }
  1385. /*****************************************************************************
  1386.  * DirectXCloseSurface: close the YUV overlay or RGB surface.
  1387.  *****************************************************************************
  1388.  * This function returns all resources allocated for the surface.
  1389.  *****************************************************************************/
  1390. static void DirectXCloseSurface( vout_thread_t *p_vout,
  1391.                                  LPDIRECTDRAWSURFACE2 p_surface )
  1392. {
  1393.     msg_Dbg( p_vout, "DirectXCloseSurface" );
  1394.     if( p_surface != NULL )
  1395.     {
  1396.         IDirectDrawSurface2_Release( p_surface );
  1397.     }
  1398. }
  1400. /*****************************************************************************
  1401.  * NewPictureVec: allocate a vector of identical pictures
  1402.  *****************************************************************************
  1403.  * Returns 0 on success, -1 otherwise
  1404.  *****************************************************************************/
  1405. static int NewPictureVec( vout_thread_t *p_vout, picture_t *p_pic,
  1406.                           int i_num_pics )
  1407. {
  1408.     int i;
  1409.     int i_ret = VLC_SUCCESS;
  1410.     LPDIRECTDRAWSURFACE2 p_surface;
  1412.     msg_Dbg( p_vout, "NewPictureVec overlay:%s chroma:%.4s",
  1413.              p_vout->p_sys->b_using_overlay ? "yes" : "no",
  1414.              (char *)&p_vout->output.i_chroma );
  1416.     I_OUTPUTPICTURES = 0;
  1418.     /* First we try to use an YUV overlay surface.
  1419.      * The overlay surface that we create won't be used to decode directly
  1420.      * into it because accessing video memory directly is way to slow (remember
  1421.      * that pictures are decoded macroblock per macroblock). Instead the video
  1422.      * will be decoded in picture buffers in system memory which will then be
  1423.      * memcpy() to the overlay surface. */
  1424.     if( p_vout->p_sys->b_using_overlay )
  1425.     {
  1426.         /* Triple buffering rocks! it doesn't have any processing overhead
  1427.          * (you don't have to wait for the vsync) and provides for a very nice
  1428.          * video quality (no tearing). */
  1429.         if( p_vout->p_sys->b_3buf_overlay )
  1430.             i_ret = DirectXCreateSurface( p_vout, &p_surface,
  1431.                                           p_vout->output.i_chroma,
  1432.                                           p_vout->p_sys->b_using_overlay,
  1433.                                           2 /* number of backbuffers */ );
  1435.         if( !p_vout->p_sys->b_3buf_overlay || i_ret != VLC_SUCCESS )
  1436.         {
  1437.             /* Try to reduce the number of backbuffers */
  1438.             i_ret = DirectXCreateSurface( p_vout, &p_surface,
  1439.                                           p_vout->output.i_chroma,
  1440.                                           p_vout->p_sys->b_using_overlay,
  1441.                                           0 /* number of backbuffers */ );
  1442.         }
  1444.         if( i_ret == VLC_SUCCESS )
  1445.         {
  1446.             DDSCAPS dds_caps;
  1447.             picture_t front_pic;
  1448.             picture_sys_t front_pic_sys;
  1449.             front_pic.p_sys = &front_pic_sys;
  1451.             /* Allocate internal structure */
  1452.             p_pic[0].p_sys = malloc( sizeof( picture_sys_t ) );
  1453.             if( p_pic[0].p_sys == NULL )
  1454.             {
  1455.                 DirectXCloseSurface( p_vout, p_surface );
  1456.                 return VLC_ENOMEM;
  1457.             }
  1459.             /* set front buffer */
  1460.             p_pic[0].p_sys->p_front_surface = p_surface;
  1462.             /* Get the back buffer */
  1463.             memset( &dds_caps, 0, sizeof( DDSCAPS ) );
  1464.             dds_caps.dwCaps = DDSCAPS_BACKBUFFER;
  1465.             if( DD_OK != IDirectDrawSurface2_GetAttachedSurface(
  1466.                                                 p_surface, &dds_caps,
  1467.                                                 &p_pic[0].p_sys->p_surface ) )
  1468.             {
  1469.                 msg_Warn( p_vout, "NewPictureVec could not get back buffer" );
  1470.                 /* front buffer is the same as back buffer */
  1471.                 p_pic[0].p_sys->p_surface = p_surface;
  1472.             }
  1475.             p_vout->p_sys->p_current_surface = front_pic.p_sys->p_surface =
  1476.                 p_pic[0].p_sys->p_front_surface;
  1478.             /* Reset the front buffer memory */
  1479.             if( DirectXLockSurface( p_vout, &front_pic ) == VLC_SUCCESS )
  1480.             {
  1481.                 int i,j;
  1482.                 for( i = 0; i < front_pic.i_planes; i++ )
  1483.                     for( j = 0; j < front_pic.p[i].i_visible_lines; j++)
  1484.                         memset( front_pic.p[i].p_pixels + j *
  1485.                                 front_pic.p[i].i_pitch, 127,
  1486.                                 front_pic.p[i].i_visible_pitch );
  1488.                 DirectXUnlockSurface( p_vout, &front_pic );
  1489.             }
  1491.             DirectDrawUpdateOverlay( p_vout );
  1492.             I_OUTPUTPICTURES = 1;
  1493.             msg_Dbg( p_vout, "YUV overlay created successfully" );
  1494.         }
  1495.     }
  1497.     /* As we can't have an overlay, we'll try to create a plain offscreen
  1498.      * surface. This surface will reside in video memory because there's a
  1499.      * better chance then that we'll be able to use some kind of hardware
  1500.      * acceleration like rescaling, blitting or YUV->RGB conversions.
  1501.      * We then only need to blit this surface onto the main display when we
  1502.      * want to display it */
  1503.     if( !p_vout->p_sys->b_using_overlay )
  1504.     {
  1505.         if( p_vout->p_sys->b_hw_yuv )
  1506.         {
  1507.             DWORD i_codes;
  1508.             DWORD *pi_codes;
  1509.             bool b_result = false;
  1511.             /* Check if the chroma is supported first. This is required
  1512.              * because a few buggy drivers don't mind creating the surface
  1513.              * even if they don't know about the chroma. */
  1514.             if( IDirectDraw2_GetFourCCCodes( p_vout->p_sys->p_ddobject,
  1515.                                              &i_codes, NULL ) == DD_OK )
  1516.             {
  1517.                 pi_codes = malloc( i_codes * sizeof(DWORD) );
  1518.                 if( pi_codes && IDirectDraw2_GetFourCCCodes(
  1519.                     p_vout->p_sys->p_ddobject, &i_codes, pi_codes ) == DD_OK )
  1520.                 {
  1521.                     for( i = 0; i < (int)i_codes; i++ )
  1522.                     {
  1523.                         if( p_vout->output.i_chroma == pi_codes[i] )
  1524.                         {
  1525.                             b_result = true;
  1526.                             break;
  1527.                         }
  1528.                     }
  1529.                 }
  1530.             }
  1532.             if( b_result )
  1533.                 i_ret = DirectXCreateSurface( p_vout, &p_surface,
  1534.                                               p_vout->output.i_chroma,
  1535.                                               0 /* no overlay */,
  1536.                                               0 /* no back buffers */ );
  1537.             else
  1538.                 p_vout->p_sys->b_hw_yuv = false;
  1539.         }
  1541.         if( i_ret || !p_vout->p_sys->b_hw_yuv )
  1542.         {
  1543.             /* Our last choice is to use a plain RGB surface */
  1544.             DDPIXELFORMAT ddpfPixelFormat;
  1546.             ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  1547.             IDirectDrawSurface2_GetPixelFormat( p_vout->p_sys->p_display,
  1548.                                                 &ddpfPixelFormat );
  1550.             if( ddpfPixelFormat.dwFlags & DDPF_RGB )
  1551.             {
  1552.                 switch( ddpfPixelFormat.dwRGBBitCount )
  1553.                 {
  1554.                 case 8:
  1555.                     p_vout->output.i_chroma = VLC_FOURCC('R','G','B','2');
  1556.                     p_vout->output.pf_setpalette = SetPalette;
  1557.                     break;
  1558.                 case 15:
  1559.                     p_vout->output.i_chroma = VLC_FOURCC('R','V','1','5');
  1560.                     break;
  1561.                 case 16:
  1562.                     p_vout->output.i_chroma = VLC_FOURCC('R','V','1','6');
  1563.                     break;
  1564.                 case 24:
  1565.                     p_vout->output.i_chroma = VLC_FOURCC('R','V','2','4');
  1566.                     break;
  1567.                 case 32:
  1568.                     p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
  1569.                     break;
  1570.                 default:
  1571.                     msg_Err( p_vout, "unknown screen depth" );
  1572.                     return VLC_EGENERIC;
  1573.                 }
  1574.                 p_vout->output.i_rmask = ddpfPixelFormat.dwRBitMask;
  1575.                 p_vout->output.i_gmask = ddpfPixelFormat.dwGBitMask;
  1576.                 p_vout->output.i_bmask = ddpfPixelFormat.dwBBitMask;
  1577.             }
  1579.             p_vout->p_sys->b_hw_yuv = 0;
  1581.             i_ret = DirectXCreateSurface( p_vout, &p_surface,
  1582.                                           p_vout->output.i_chroma,
  1583.                                           0 /* no overlay */,
  1584.                                           0 /* no back buffers */ );
  1586.             if( i_ret && !p_vout->p_sys->b_use_sysmem )
  1587.             {
  1588.                 /* Give it a last try with b_use_sysmem enabled */
  1589.                 p_vout->p_sys->b_use_sysmem = 1;
  1591.                 i_ret = DirectXCreateSurface( p_vout, &p_surface,
  1592.                                               p_vout->output.i_chroma,
  1593.                                               0 /* no overlay */,
  1594.                                               0 /* no back buffers */ );
  1595.             }
  1596.         }
  1598.         if( i_ret == VLC_SUCCESS )
  1599.         {
  1600.             /* Allocate internal structure */
  1601.             p_pic[0].p_sys = malloc( sizeof( picture_sys_t ) );
  1602.             if( p_pic[0].p_sys == NULL )
  1603.             {
  1604.                 DirectXCloseSurface( p_vout, p_surface );
  1605.                 return VLC_ENOMEM;
  1606.             }
  1608.             p_pic[0].p_sys->p_surface = p_pic[0].p_sys->p_front_surface
  1609.                 = p_surface;
  1611.             I_OUTPUTPICTURES = 1;
  1613.             msg_Dbg( p_vout, "created plain surface of chroma:%.4s",
  1614.                      (char *)&p_vout->output.i_chroma );
  1615.         }
  1616.     }
  1619.     /* Now that we've got all our direct-buffers, we can finish filling in the
  1620.      * picture_t structures */
  1621.     for( i = 0; i < I_OUTPUTPICTURES; i++ )
  1622.     {
  1623.         p_pic[i].i_status = DESTROYED_PICTURE;
  1624.         p_pic[i].i_type   = DIRECT_PICTURE;
  1625.         p_pic[i].b_slow   = true;
  1626.         p_pic[i].pf_lock  = DirectXLockSurface;
  1627.         p_pic[i].pf_unlock = DirectXUnlockSurface;
  1628.         PP_OUTPUTPICTURE[i] = &p_pic[i];
  1630.         if( DirectXLockSurface( p_vout, &p_pic[i] ) != VLC_SUCCESS )
  1631.         {
  1632.             /* AAARRGG */
  1633.             FreePictureVec( p_vout, p_pic, I_OUTPUTPICTURES );
  1634.             I_OUTPUTPICTURES = 0;
  1635.             msg_Err( p_vout, "cannot lock surface" );
  1636.             return VLC_EGENERIC;
  1637.         }
  1638.         DirectXUnlockSurface( p_vout, &p_pic[i] );
  1639.     }
  1641.     msg_Dbg( p_vout, "End NewPictureVec (%s)",
  1642.              I_OUTPUTPICTURES ? "succeeded" : "failed" );
  1644.     return VLC_SUCCESS;
  1645. }
  1647. /*****************************************************************************
  1648.  * FreePicture: destroy a picture vector allocated with NewPictureVec
  1649.  *****************************************************************************
  1650.  *
  1651.  *****************************************************************************/
  1652. static void FreePictureVec( vout_thread_t *p_vout, picture_t *p_pic,
  1653.                             int i_num_pics )
  1654. {
  1655.     int i;
  1657.     vlc_mutex_lock( &p_vout->p_sys->lock );
  1658.     p_vout->p_sys->p_current_surface = 0;
  1659.     vlc_mutex_unlock( &p_vout->p_sys->lock );
  1661.     for( i = 0; i < i_num_pics; i++ )
  1662.     {
  1663.         DirectXCloseSurface( p_vout, p_pic[i].p_sys->p_front_surface );
  1665.         for( i = 0; i < i_num_pics; i++ )
  1666.         {
  1667.             free( p_pic[i].p_sys );
  1668.         }
  1669.     }
  1670. }
  1672. /*****************************************************************************
  1673.  * UpdatePictureStruct: updates the internal data in the picture_t structure
  1674.  *****************************************************************************
  1675.  * This will setup stuff for use by the video_output thread
  1676.  *****************************************************************************/
  1677. static int UpdatePictureStruct( vout_thread_t *p_vout, picture_t *p_pic,
  1678.                                 int i_chroma )
  1679. {
  1680.     switch( p_vout->output.i_chroma )
  1681.     {
  1682.         case VLC_FOURCC('R','G','B','2'):
  1683.         case VLC_FOURCC('R','V','1','5'):
  1684.         case VLC_FOURCC('R','V','1','6'):
  1685.         case VLC_FOURCC('R','V','2','4'):
  1686.         case VLC_FOURCC('R','V','3','2'):
  1687.             p_pic->p->p_pixels = p_pic->p_sys->ddsd.lpSurface;
  1688.             p_pic->p->i_lines = p_vout->output.i_height;
  1689.             p_pic->p->i_visible_lines = p_vout->output.i_height;
  1690.             p_pic->p->i_pitch = p_pic->p_sys->ddsd.lPitch;
  1691.             switch( p_vout->output.i_chroma )
  1692.             {
  1693.                 case VLC_FOURCC('R','G','B','2'):
  1694.                     p_pic->p->i_pixel_pitch = 1;
  1695.                     break;
  1696.                 case VLC_FOURCC('R','V','1','5'):
  1697.                 case VLC_FOURCC('R','V','1','6'):
  1698.                     p_pic->p->i_pixel_pitch = 2;
  1699.                     break;
  1700.                 case VLC_FOURCC('R','V','2','4'):
  1701.                     p_pic->p->i_pixel_pitch = 3;
  1702.                     break;
  1703.                 case VLC_FOURCC('R','V','3','2'):
  1704.                     p_pic->p->i_pixel_pitch = 4;
  1705.                     break;
  1706.                 default:
  1707.                     return VLC_EGENERIC;
  1708.             }
  1709.             p_pic->p->i_visible_pitch = p_vout->output.i_width *
  1710.               p_pic->p->i_pixel_pitch;
  1711.             p_pic->i_planes = 1;
  1712.             break;
  1714.         case VLC_FOURCC('Y','V','1','2'):
  1715.         case VLC_FOURCC('I','4','2','0'):
  1717.             /* U and V inverted compared to I420
  1718.              * Fixme: this should be handled by the vout core */
  1719.             p_vout->output.i_chroma = VLC_FOURCC('I','4','2','0');
  1721.             p_pic->Y_PIXELS = p_pic->p_sys->ddsd.lpSurface;
  1722.             p_pic->p[Y_PLANE].i_lines = p_vout->output.i_height;
  1723.             p_pic->p[Y_PLANE].i_visible_lines = p_vout->output.i_height;
  1724.             p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->ddsd.lPitch;
  1725.             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
  1726.             p_pic->p[Y_PLANE].i_visible_pitch = p_vout->output.i_width *
  1727.               p_pic->p[Y_PLANE].i_pixel_pitch;
  1729.             p_pic->V_PIXELS =  p_pic->Y_PIXELS
  1730.               + p_pic->p[Y_PLANE].i_lines * p_pic->p[Y_PLANE].i_pitch;
  1731.             p_pic->p[V_PLANE].i_lines = p_vout->output.i_height / 2;
  1732.             p_pic->p[V_PLANE].i_visible_lines = p_vout->output.i_height / 2;
  1733.             p_pic->p[V_PLANE].i_pitch = p_pic->p[Y_PLANE].i_pitch / 2;
  1734.             p_pic->p[V_PLANE].i_pixel_pitch = 1;
  1735.             p_pic->p[V_PLANE].i_visible_pitch = p_vout->output.i_width / 2 *
  1736.               p_pic->p[V_PLANE].i_pixel_pitch;
  1738.             p_pic->U_PIXELS = p_pic->V_PIXELS
  1739.               + p_pic->p[V_PLANE].i_lines * p_pic->p[V_PLANE].i_pitch;
  1740.             p_pic->p[U_PLANE].i_lines = p_vout->output.i_height / 2;
  1741.             p_pic->p[U_PLANE].i_visible_lines = p_vout->output.i_height / 2;
  1742.             p_pic->p[U_PLANE].i_pitch = p_pic->p[Y_PLANE].i_pitch / 2;
  1743.             p_pic->p[U_PLANE].i_pixel_pitch = 1;
  1744.             p_pic->p[U_PLANE].i_visible_pitch = p_vout->output.i_width / 2 *
  1745.               p_pic->p[U_PLANE].i_pixel_pitch;
  1747.             p_pic->i_planes = 3;
  1748.             break;
  1750.         case VLC_FOURCC('I','Y','U','V'):
  1752.             p_pic->Y_PIXELS = p_pic->p_sys->ddsd.lpSurface;
  1753.             p_pic->p[Y_PLANE].i_lines = p_vout->output.i_height;
  1754.             p_pic->p[Y_PLANE].i_visible_lines = p_vout->output.i_height;
  1755.             p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->ddsd.lPitch;
  1756.             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
  1757.             p_pic->p[Y_PLANE].i_visible_pitch = p_vout->output.i_width *
  1758.               p_pic->p[Y_PLANE].i_pixel_pitch;
  1760.             p_pic->U_PIXELS = p_pic->Y_PIXELS
  1761.               + p_pic->p[Y_PLANE].i_lines * p_pic->p[Y_PLANE].i_pitch;
  1762.             p_pic->p[U_PLANE].i_lines = p_vout->output.i_height / 2;
  1763.             p_pic->p[U_PLANE].i_visible_lines = p_vout->output.i_height / 2;
  1764.             p_pic->p[U_PLANE].i_pitch = p_pic->p[Y_PLANE].i_pitch / 2;
  1765.             p_pic->p[U_PLANE].i_pixel_pitch = 1;
  1766.             p_pic->p[U_PLANE].i_visible_pitch = p_vout->output.i_width / 2 *
  1767.               p_pic->p[U_PLANE].i_pixel_pitch;
  1769.             p_pic->V_PIXELS =  p_pic->U_PIXELS
  1770.               + p_pic->p[U_PLANE].i_lines * p_pic->p[U_PLANE].i_pitch;
  1771.             p_pic->p[V_PLANE].i_lines = p_vout->output.i_height / 2;
  1772.             p_pic->p[V_PLANE].i_visible_lines = p_vout->output.i_height / 2;
  1773.             p_pic->p[V_PLANE].i_pitch = p_pic->p[Y_PLANE].i_pitch / 2;
  1774.             p_pic->p[V_PLANE].i_pixel_pitch = 1;
  1775.             p_pic->p[V_PLANE].i_visible_pitch = p_vout->output.i_width / 2 *
  1776.               p_pic->p[V_PLANE].i_pixel_pitch;
  1778.             p_pic->i_planes = 3;
  1779.             break;
  1781.         case VLC_FOURCC('U','Y','V','Y'):
  1782.         case VLC_FOURCC('Y','U','Y','2'):
  1784.             p_pic->p->p_pixels = p_pic->p_sys->ddsd.lpSurface;
  1785.             p_pic->p->i_lines = p_vout->output.i_height;
  1786.             p_pic->p->i_visible_lines = p_vout->output.i_height;
  1787.             p_pic->p->i_pitch = p_pic->p_sys->ddsd.lPitch;
  1788.             p_pic->p->i_pixel_pitch = 2;
  1789.             p_pic->p->i_visible_pitch = p_vout->output.i_width *
  1790.               p_pic->p->i_pixel_pitch;
  1792.             p_pic->i_planes = 1;
  1793.             break;
  1795.         default:
  1796.             /* Unknown chroma, tell the guy to get lost */
  1797.             msg_Err( p_vout, "never heard of chroma 0x%.8x (%4.4s)",
  1798.                      p_vout->output.i_chroma,
  1799.                      (char*)&p_vout->output.i_chroma );
  1800.             return VLC_EGENERIC;
  1801.     }
  1803.     return VLC_SUCCESS;
  1804. }
  1806. /*****************************************************************************
  1807.  * DirectXGetDDrawCaps: Probe the capabilities of the hardware
  1808.  *****************************************************************************
  1809.  * It is nice to know which features are supported by the hardware so we can
  1810.  * find ways to optimize our rendering.
  1811.  *****************************************************************************/
  1812. static void DirectXGetDDrawCaps( vout_thread_t *p_vout )
  1813. {
  1814.     DDCAPS ddcaps;
  1815.     HRESULT dxresult;
  1817.     /* This is just an indication of whether or not we'll support overlay,
  1818.      * but with this test we don't know if we support YUV overlay */
  1819.     memset( &ddcaps, 0, sizeof( DDCAPS ));
  1820.     ddcaps.dwSize = sizeof(DDCAPS);
  1821.     dxresult = IDirectDraw2_GetCaps( p_vout->p_sys->p_ddobject,
  1822.                                      &ddcaps, NULL );
  1823.     if(dxresult != DD_OK )
  1824.     {
  1825.         msg_Warn( p_vout, "cannot get caps" );
  1826.     }
  1827.     else
  1828.     {
  1829.         bool bHasOverlay, bHasOverlayFourCC, bCanDeinterlace,
  1830.              bHasColorKey, bCanStretch, bCanBltFourcc,
  1831.              bAlignBoundarySrc, bAlignBoundaryDest,
  1832.              bAlignSizeSrc, bAlignSizeDest;
  1834.         /* Determine if the hardware supports overlay surfaces */
  1835.         bHasOverlay = (ddcaps.dwCaps & DDCAPS_OVERLAY) ? 1 : 0;
  1836.         /* Determine if the hardware supports overlay surfaces */
  1837.         bHasOverlayFourCC = (ddcaps.dwCaps & DDCAPS_OVERLAYFOURCC) ? 1 : 0;
  1838.         /* Determine if the hardware supports overlay deinterlacing */
  1839.         bCanDeinterlace = (ddcaps.dwCaps & DDCAPS2_CANFLIPODDEVEN) ? 1 : 0;
  1840.         /* Determine if the hardware supports colorkeying */
  1841.         bHasColorKey = (ddcaps.dwCaps & DDCAPS_COLORKEY) ? 1 : 0;
  1842.         /* Determine if the hardware supports scaling of the overlay surface */
  1843.         bCanStretch = (ddcaps.dwCaps & DDCAPS_OVERLAYSTRETCH) ? 1 : 0;
  1844.         /* Determine if the hardware supports color conversion during a blit */
  1845.         bCanBltFourcc = (ddcaps.dwCaps & DDCAPS_BLTFOURCC) ? 1 : 0;
  1846.         /* Determine overlay source boundary alignment */
  1847.         bAlignBoundarySrc = (ddcaps.dwCaps & DDCAPS_ALIGNBOUNDARYSRC) ? 1 : 0;
  1848.         /* Determine overlay destination boundary alignment */
  1849.         bAlignBoundaryDest = (ddcaps.dwCaps & DDCAPS_ALIGNBOUNDARYDEST) ? 1:0;
  1850.         /* Determine overlay destination size alignment */
  1851.         bAlignSizeSrc = (ddcaps.dwCaps & DDCAPS_ALIGNSIZESRC) ? 1 : 0;
  1852.         /* Determine overlay destination size alignment */
  1853.         bAlignSizeDest = (ddcaps.dwCaps & DDCAPS_ALIGNSIZEDEST) ? 1 : 0;
  1854.  
  1855.         msg_Dbg( p_vout, "DirectDraw Capabilities: overlay=%i yuvoverlay=%i "
  1856.                          "can_deinterlace_overlay=%i colorkey=%i stretch=%i "
  1857.                          "bltfourcc=%i",
  1858.                          bHasOverlay, bHasOverlayFourCC, bCanDeinterlace,
  1859.                          bHasColorKey, bCanStretch, bCanBltFourcc );
  1861.         if( bAlignBoundarySrc || bAlignBoundaryDest ||
  1862.             bAlignSizeSrc || bAlignSizeDest )
  1863.         {
  1864.             if( bAlignBoundarySrc ) p_vout->p_sys->i_align_src_boundary =
  1865.                 ddcaps.dwAlignBoundarySrc;
  1866.             if( bAlignBoundaryDest ) p_vout->p_sys->i_align_dest_boundary =
  1867.                 ddcaps.dwAlignBoundaryDest;
  1868.             if( bAlignSizeDest ) p_vout->p_sys->i_align_src_size =
  1869.                 ddcaps.dwAlignSizeSrc;
  1870.             if( bAlignSizeDest ) p_vout->p_sys->i_align_dest_size =
  1871.                 ddcaps.dwAlignSizeDest;
  1873.             msg_Dbg( p_vout, "align_boundary_src=%i,%i "
  1874.                      "align_boundary_dest=%i,%i "
  1875.                      "align_size_src=%i,%i align_size_dest=%i,%i",
  1876.                      bAlignBoundarySrc, p_vout->p_sys->i_align_src_boundary,
  1877.                      bAlignBoundaryDest, p_vout->p_sys->i_align_dest_boundary,
  1878.                      bAlignSizeSrc, p_vout->p_sys->i_align_src_size,
  1879.                      bAlignSizeDest, p_vout->p_sys->i_align_dest_size );
  1880.         }
  1882.         /* Don't ask for troubles */
  1883.         if( !bCanBltFourcc ) p_vout->p_sys->b_hw_yuv = FALSE;
  1884.     }
  1885. }
  1887. /*****************************************************************************
  1888.  * DirectXLockSurface: Lock surface and get picture data pointer
  1889.  *****************************************************************************
  1890.  * This function locks a surface and get the surface descriptor which amongst
  1891.  * other things has the pointer to the picture data.
  1892.  *****************************************************************************/
  1893. static int DirectXLockSurface( vout_thread_t *p_vout, picture_t *p_pic )
  1894. {
  1895.     HRESULT dxresult;
  1897.     /* Lock the surface to get a valid pointer to the picture buffer */
  1898.     memset( &p_pic->p_sys->ddsd, 0, sizeof( DDSURFACEDESC ));
  1899.     p_pic->p_sys->ddsd.dwSize = sizeof(DDSURFACEDESC);
  1900.     dxresult = IDirectDrawSurface2_Lock( p_pic->p_sys->p_surface,
  1901.                                          NULL, &p_pic->p_sys->ddsd,
  1902.                                          DDLOCK_NOSYSLOCK | DDLOCK_WAIT,
  1903.                                          NULL );
  1904.     if( dxresult != DD_OK )
  1905.     {
  1906.         if( dxresult == DDERR_INVALIDPARAMS )
  1907.         {
  1908.             /* DirectX 3 doesn't support the DDLOCK_NOSYSLOCK flag, resulting
  1909.              * in an invalid params error */
  1910.             dxresult = IDirectDrawSurface2_Lock( p_pic->p_sys->p_surface, NULL,
  1911.                                              &p_pic->p_sys->ddsd,
  1912.                                              DDLOCK_WAIT, NULL);
  1913.         }
  1914.         if( dxresult == DDERR_SURFACELOST )
  1915.         {
  1916.             /* Your surface can be lost so be sure
  1917.              * to check this and restore it if needed */
  1919.             /* When using overlays with back-buffers, we need to restore
  1920.              * the front buffer so the back-buffers get restored as well. */
  1921.             if( p_vout->p_sys->b_using_overlay  )
  1922.                 IDirectDrawSurface2_Restore( p_pic->p_sys->p_front_surface );
  1923.             else
  1924.                 IDirectDrawSurface2_Restore( p_pic->p_sys->p_surface );
  1926.             dxresult = IDirectDrawSurface2_Lock( p_pic->p_sys->p_surface, NULL,
  1927.                                                  &p_pic->p_sys->ddsd,
  1928.                                                  DDLOCK_WAIT, NULL);
  1929. #if 0
  1930.             if( dxresult == DDERR_SURFACELOST )
  1931.                 msg_Dbg( p_vout, "DirectXLockSurface: DDERR_SURFACELOST" );
  1932. #endif
  1933.         }
  1934.         if( dxresult != DD_OK )
  1935.         {
  1936.             return VLC_EGENERIC;
  1937.         }
  1938.     }
  1940.     /* Now we have a pointer to the surface memory, we can update our picture
  1941.      * structure. */
  1942.     if( UpdatePictureStruct( p_vout, p_pic, p_vout->output.i_chroma )
  1943.         != VLC_SUCCESS )
  1944.     {
  1945.         DirectXUnlockSurface( p_vout, p_pic );
  1946.         return VLC_EGENERIC;
  1947.     }
  1948.     else
  1949.         return VLC_SUCCESS;
  1950. }
  1952. /*****************************************************************************
  1953.  * DirectXUnlockSurface: Unlock a surface locked by DirectXLockSurface().
  1954.  *****************************************************************************/
  1955. static int DirectXUnlockSurface( vout_thread_t *p_vout, picture_t *p_pic )
  1956. {
  1957.     /* Unlock the Surface */
  1958.     if( IDirectDrawSurface2_Unlock( p_pic->p_sys->p_surface, NULL ) == DD_OK )
  1959.         return VLC_SUCCESS;
  1960.     else
  1961.         return VLC_EGENERIC;
  1962. }
  1964. /*****************************************************************************
  1965.  * DirectXFindColorkey: Finds out the 32bits RGB pixel value of the colorkey
  1966.  *****************************************************************************/
  1967. static DWORD DirectXFindColorkey( vout_thread_t *p_vout, uint32_t *pi_color )
  1968. {
  1969.     DDSURFACEDESC ddsd;
  1970.     HRESULT dxresult;
  1971.     COLORREF i_rgb = 0;
  1972.     uint32_t i_pixel_backup;
  1973.     HDC hdc;
  1975.     ddsd.dwSize = sizeof(ddsd);
  1976.     dxresult = IDirectDrawSurface2_Lock( p_vout->p_sys->p_display, NULL,
  1977.                                          &ddsd, DDLOCK_WAIT, NULL );
  1978.     if( dxresult != DD_OK ) return 0;
  1980.     i_pixel_backup = *(uint32_t *)ddsd.lpSurface;
  1982.     switch( ddsd.ddpfPixelFormat.dwRGBBitCount )
  1983.     {
  1984.     case 4:
  1985.         *(uint8_t *)ddsd.lpSurface = *pi_color | (*pi_color << 4);
  1986.         break;
  1987.     case 8:
  1988.         *(uint8_t *)ddsd.lpSurface = *pi_color;
  1989.         break;
  1990.     case 15:
  1991.     case 16:
  1992.         *(uint16_t *)ddsd.lpSurface = *pi_color;
  1993.         break;
  1994.     case 24:
  1995.         /* Seems to be problematic so we'll just put black as the colorkey */
  1996.         *pi_color = 0;
  1997.     default:
  1998.         *(uint32_t *)ddsd.lpSurface = *pi_color;
  1999.         break;
  2000.     }
  2002.     IDirectDrawSurface2_Unlock( p_vout->p_sys->p_display, NULL );
  2004.     if( IDirectDrawSurface2_GetDC( p_vout->p_sys->p_display, &hdc ) == DD_OK )
  2005.     {
  2006.         i_rgb = GetPixel( hdc, 0, 0 );
  2007.         IDirectDrawSurface2_ReleaseDC( p_vout->p_sys->p_display, hdc );
  2008.     }
  2010.     ddsd.dwSize = sizeof(ddsd);
  2011.     dxresult = IDirectDrawSurface2_Lock( p_vout->p_sys->p_display, NULL,
  2012.                                          &ddsd, DDLOCK_WAIT, NULL );
  2013.     if( dxresult != DD_OK ) return i_rgb;
  2015.     *(uint32_t *)ddsd.lpSurface = i_pixel_backup;
  2017.     IDirectDrawSurface2_Unlock( p_vout->p_sys->p_display, NULL );
  2019.     return i_rgb;
  2020. }
  2022. /*****************************************************************************
  2023.  * A few toolbox functions
  2024.  *****************************************************************************/
  2025. void SwitchWallpaperMode( vout_thread_t *p_vout, bool b_on )
  2026. {
  2027.     HWND hwnd;
  2029.     if( p_vout->p_sys->b_wallpaper == b_on ) return; /* Nothing to do */
  2031.     hwnd = FindWindow( _T("Progman"), NULL );
  2032.     if( hwnd ) hwnd = FindWindowEx( hwnd, NULL, _T("SHELLDLL_DefView"), NULL );
  2033.     if( hwnd ) hwnd = FindWindowEx( hwnd, NULL, _T("SysListView32"), NULL );
  2034.     if( !hwnd )
  2035.     {
  2036.         msg_Warn( p_vout, "couldn't find "SysListView32" window, "
  2037.                   "wallpaper mode not supported" );
  2038.         return;
  2039.     }
  2041.     p_vout->p_sys->b_wallpaper = b_on;
  2043.     msg_Dbg( p_vout, "wallpaper mode %s", b_on ? "enabled" : "disabled" );
  2045.     if( p_vout->p_sys->b_wallpaper )
  2046.     {
  2047.         p_vout->p_sys->color_bkg = ListView_GetBkColor( hwnd );
  2048.         p_vout->p_sys->color_bkgtxt = ListView_GetTextBkColor( hwnd );
  2050.         ListView_SetBkColor( hwnd, p_vout->p_sys->i_rgb_colorkey );
  2051.         ListView_SetTextBkColor( hwnd, p_vout->p_sys->i_rgb_colorkey );
  2052.     }
  2053.     else if( hwnd )
  2054.     {
  2055.         ListView_SetBkColor( hwnd, p_vout->p_sys->color_bkg );
  2056.         ListView_SetTextBkColor( hwnd, p_vout->p_sys->color_bkgtxt );
  2057.     }
  2059.     /* Update desktop */
  2060.     InvalidateRect( hwnd, NULL, TRUE );
  2061.     UpdateWindow( hwnd );
  2062. }
  2064. /*****************************************************************************
  2065.  * config variable callback
  2066.  *****************************************************************************/
  2067. BOOL WINAPI DirectXEnumCallback2( GUID* p_guid, LPTSTR psz_desc,
  2068.                                   LPTSTR psz_drivername, VOID* p_context,
  2069.                                   HMONITOR hmon )
  2070. {
  2071.     module_config_t *p_item = (module_config_t *)p_context;
  2073.     p_item->ppsz_list =
  2074.         (char **)realloc( p_item->ppsz_list,
  2075.                           (p_item->i_list+2) * sizeof(char *) );
  2076.     p_item->ppsz_list_text =
  2077.         (char **)realloc( p_item->ppsz_list_text,
  2078.                           (p_item->i_list+2) * sizeof(char *) );
  2080.     p_item->ppsz_list[p_item->i_list] = strdup( psz_drivername );
  2081.     p_item->ppsz_list_text[p_item->i_list] = NULL;
  2082.     p_item->i_list++;
  2083.     p_item->ppsz_list[p_item->i_list] = NULL;
  2084.     p_item->ppsz_list_text[p_item->i_list] = NULL;
  2086.     return TRUE; /* Keep enumerating */
  2087. }
  2089. static int FindDevicesCallback( vlc_object_t *p_this, char const *psz_name,
  2090.                                vlc_value_t newval, vlc_value_t oldval, void *d)
  2091. {
  2092.     HRESULT (WINAPI *OurDirectDrawEnumerateEx)( LPDDENUMCALLBACKEXA, LPVOID,
  2093.                                                 DWORD );
  2094.     HINSTANCE hddraw_dll;
  2096.     module_config_t *p_item;
  2097.     int i;
  2099.     p_item = config_FindConfig( p_this, psz_name );
  2100.     if( !p_item ) return VLC_SUCCESS;
  2102.     /* Clear-up the current list */
  2103.     if( p_item->i_list )
  2104.     {
  2105.         /* Keep the first entry */
  2106.         for( i = 1; i < p_item->i_list; i++ )
  2107.         {
  2108.             free( p_item->ppsz_list[i] );
  2109.             free( p_item->ppsz_list_text[i] );
  2110.         }
  2111.         /* TODO: Remove when no more needed */
  2112.         p_item->ppsz_list[i] = NULL;
  2113.         p_item->ppsz_list_text[i] = NULL;
  2114.     }
  2115.     p_item->i_list = 1;
  2117.     /* Load direct draw DLL */
  2118.     hddraw_dll = LoadLibrary(_T("DDRAW.DLL"));
  2119.     if( hddraw_dll == NULL ) return VLC_SUCCESS;
  2121.     OurDirectDrawEnumerateEx =
  2122. #ifndef UNICODE
  2123.       (void *)GetProcAddress( hddraw_dll, "DirectDrawEnumerateExA" );
  2124. #else
  2125.       (void *)GetProcAddress( hddraw_dll, _T("DirectDrawEnumerateExW") );
  2126. #endif
  2128.     if( OurDirectDrawEnumerateEx )
  2129.     {
  2130.         /* Enumerate displays */
  2131.         OurDirectDrawEnumerateEx( DirectXEnumCallback2, p_item,
  2132.                                   DDENUM_ATTACHEDSECONDARYDEVICES );
  2133.     }
  2135.     FreeLibrary( hddraw_dll );
  2137.     /* Signal change to the interface */
  2138.     p_item->b_dirty = true;
  2140.     return VLC_SUCCESS;
  2141. }
  2143. static int WallpaperCallback( vlc_object_t *p_this, char const *psz_cmd,
  2144.                               vlc_value_t oldval, vlc_value_t newval,
  2145.                               void *p_data )
  2146. {
  2147.     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  2149.     if( (newval.b_bool && !p_vout->p_sys->b_wallpaper) ||
  2150.         (!newval.b_bool && p_vout->p_sys->b_wallpaper) )
  2151.     {
  2152.         playlist_t *p_playlist = pl_Hold( p_vout );
  2154.         if( p_playlist )
  2155.         {
  2156.             /* Modify playlist as well because the vout might have to be
  2157.              * restarted */
  2158.             var_Create( p_playlist, "directx-wallpaper", VLC_VAR_BOOL );
  2159.             var_Set( p_playlist, "directx-wallpaper", newval );
  2160.             pl_Release( p_vout );
  2161.         }
  2163.         p_vout->p_sys->i_changes |= DX_WALLPAPER_CHANGE;
  2164.     }
  2166.     return VLC_SUCCESS;
  2167. }
  2169. /*****************************************************************************
  2170.  * SetPalette: sets an 8 bpp palette
  2171.  *****************************************************************************/
  2172. static void SetPalette( vout_thread_t *p_vout,
  2173.                         uint16_t *red, uint16_t *green, uint16_t *blue )
  2174. {
  2175.     msg_Err( p_vout, "FIXME: SetPalette unimplemented" );
  2176. }