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

   1 /*****************************************************************************
   2  * direct3d.c: Windows Direct3D video output module
   3  *****************************************************************************
   4  * Copyright (C) 2006-2009 the VideoLAN team
   5  *$Id$
   6  *
   7  * Authors: Damien Fouilleul <damienf@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble:
  26  *
  27  * This plugin will use YUV surface if supported, using YUV will result in
  28  * the best video quality (hardware filering 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.
  34  *
  35  *****************************************************************************/
  36 #ifdef HAVE_CONFIG_H
  37 # include "config.h"
  38 #endif
  39
  40 #include <vlc_common.h>
  41 #include <vlc_plugin.h>
  42 #include <vlc_playlist.h>
  43 #include <vlc_vout_display.h>
  44
  45 #include <windows.h>
  46 #include <d3d9.h>
  47
  48 #include "common.h"
  49
  50 /*****************************************************************************
  51  * Module descriptor
  52  *****************************************************************************/
  53 static int  OpenVideoXP(vlc_object_t *);
  54 static int  OpenVideoVista(vlc_object_t *);
  55 static void Close(vlc_object_t *);
  56
  57 #define DESKTOP_TEXT N_("Enable desktop mode ")
  58 #define DESKTOP_LONGTEXT N_(\
  59     "The desktop mode allows you to display the video on the desktop.")
  60
  61 #define D3D_HELP N_("Recommended video output for Windows Vista and later versions")
  62
  63 vlc_module_begin ()
  64     set_shortname("Direct3D")
  65     set_description(N_("Direct3D video output"))
  66     set_help(D3D_HELP)
  67     set_category(CAT_VIDEO)
  68     set_subcategory(SUBCAT_VIDEO_VOUT)
  69
  70     add_bool("direct3d-desktop", false, NULL, DESKTOP_TEXT, DESKTOP_LONGTEXT, true)
  71
  72     set_capability("vout display", 70)
  73     add_shortcut("direct3d_xp")
  74     set_callbacks(OpenVideoXP, Close)
  75
  76     /* FIXME: Hack to avoid unregistering our window class */
  77     linked_with_a_crap_library_which_uses_atexit()
  78
  79     add_submodule()
  80         set_capability("vout display", 150)
  81         add_shortcut("direct3d_vista")
  82         set_callbacks(OpenVideoVista, Close)
  83 vlc_module_end ()
  84
  85 #if 0 /* FIXME */
  86     /* check if we registered a window class because we need to
  87      * unregister it */
  88     WNDCLASS wndclass;
  89     if (GetClassInfo(GetModuleHandle(NULL), "VLC DirectX", &wndclass))
  90         UnregisterClass("VLC DirectX", GetModuleHandle(NULL));
  91 #endif
  92
  93 /*****************************************************************************
  94  * Local prototypes.
  95  *****************************************************************************/
  96 struct picture_sys_t
  97 {
  98     LPDIRECT3DSURFACE9 surface;
  99 };
 100
 101 static int  Open(vlc_object_t *);
 102
 103 static picture_pool_t *Pool  (vout_display_t *, unsigned);
 104 static void           Prepare(vout_display_t *, picture_t *);
 105 static void           Display(vout_display_t *, picture_t *);
 106 static int            Control(vout_display_t *, int, va_list);
 107 static void           Manage (vout_display_t *);
 108
 109 static int  Direct3DCreate (vout_display_t *);
 110 static int  Direct3DReset  (vout_display_t *);
 111 static void Direct3DDestroy(vout_display_t *);
 112
 113 static int  Direct3DOpen (vout_display_t *, video_format_t *);
 114 static void Direct3DClose(vout_display_t *);
 115
 116 static void Direct3DRenderScene(vout_display_t *vd, LPDIRECT3DSURFACE9 surface);
 117
 118 /* */
 119 static int DesktopCallback(vlc_object_t *, char const *, vlc_value_t, vlc_value_t, void *);
 120
 121 /**
 122  * It creates a Direct3D vout display.
 123  */
 124 static int Open(vlc_object_t *object)
 125 {
 126     vout_display_t *vd = (vout_display_t *)object;
 127     vout_display_sys_t *sys;
 128
 129     /* Allocate structure */
 130     vd->sys = sys = calloc(1, sizeof(vout_display_sys_t));
 131     if (!sys)
 132         return VLC_ENOMEM;
 133
 134     if (Direct3DCreate(vd)) {
 135         msg_Err(vd, "Direct3D could not be initialized");
 136         Direct3DDestroy(vd);
 137         free(sys);
 138         return VLC_EGENERIC;
 139     }
 140
 141     sys->use_desktop = var_CreateGetBool(vd, "direct3d-desktop");
 142     sys->reset_device = false;
 143     sys->reset_device = false;
 144     sys->allow_hw_yuv = var_CreateGetBool(vd, "directx-hw-yuv");
 145     sys->desktop_save.is_fullscreen = vd->cfg->is_fullscreen;
 146     sys->desktop_save.is_on_top     = false;
 147     sys->desktop_save.win.left      = var_InheritInteger(vd, "video-x");
 148     sys->desktop_save.win.right     = vd->cfg->display.width;
 149     sys->desktop_save.win.top       = var_InheritInteger(vd, "video-y");
 150     sys->desktop_save.win.bottom    = vd->cfg->display.height;
 151
 152     if (CommonInit(vd))
 153         goto error;
 154
 155     /* */
 156     video_format_t fmt;
 157     if (Direct3DOpen(vd, &fmt)) {
 158         msg_Err(vd, "Direct3D could not be opened");
 159         goto error;
 160     }
 161
 162     /* */
 163     vout_display_info_t info = vd->info;
 164     info.is_slow = true;
 165     info.has_double_click = true;
 166     info.has_hide_mouse = true;
 167     info.has_pictures_invalid = true;
 168
 169     /* Interaction */
 170     vlc_mutex_init(&sys->lock);
 171     sys->ch_desktop = false;
 172     sys->desktop_requested = sys->use_desktop;
 173
 174     vlc_value_t val;
 175     val.psz_string = _("Desktop");
 176     var_Change(vd, "direct3d-desktop", VLC_VAR_SETTEXT, &val, NULL);
 177     var_AddCallback(vd, "direct3d-desktop", DesktopCallback, NULL);
 178
 179     /* Setup vout_display now that everything is fine */
 180     vd->fmt  = fmt;
 181     vd->info = info;
 182
 183     vd->pool    = Pool;
 184     vd->prepare = Prepare;
 185     vd->display = Display;
 186     vd->control = Control;
 187     vd->manage  = Manage;
 188
 189     /* Fix state in case of desktop mode */
 190     if (sys->use_desktop && vd->cfg->is_fullscreen)
 191         vout_display_SendEventFullscreen(vd, false);
 192
 193     return VLC_SUCCESS;
 194 error:
 195     Close(VLC_OBJECT(vd));
 196     return VLC_EGENERIC;
 197 }
 198
 199 static bool IsVistaOrAbove(void)
 200 {
 201     OSVERSIONINFO winVer;
 202     winVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 203     return GetVersionEx(&winVer) && winVer.dwMajorVersion > 5;
 204 }
 205
 206 static int OpenVideoXP(vlc_object_t *obj)
 207 {
 208     /* Windows XP or lower, make sure this module isn't the default */
 209     return IsVistaOrAbove() ? VLC_EGENERIC : Open(obj);
 210 }
 211
 212 static int OpenVideoVista(vlc_object_t *obj)
 213 {
 214     /* Windows Vista or above, make this module the default */
 215     return IsVistaOrAbove() ? Open(obj) : VLC_EGENERIC;
 216 }
 217
 218 /**
 219  * It destroyes a Direct3D vout display.
 220  */
 221 static void Close(vlc_object_t *object)
 222 {
 223     vout_display_t * vd = (vout_display_t *)object;
 224
 225     var_DelCallback(vd, "direct3d-desktop", DesktopCallback, NULL);
 226
 227     Direct3DClose(vd);
 228
 229     CommonClean(vd);
 230
 231     Direct3DDestroy(vd);
 232
 233     free(vd->sys);
 234 }
 235
 236 /* */
 237 static picture_pool_t *Pool(vout_display_t *vd, unsigned count)
 238 {
 239     VLC_UNUSED(count);
 240     return vd->sys->pool;
 241 }
 242
 243 static int  Direct3DLockSurface(picture_t *);
 244 static void Direct3DUnlockSurface(picture_t *);
 245
 246 static void Prepare(vout_display_t *vd, picture_t *picture)
 247 {
 248     LPDIRECT3DSURFACE9 surface = picture->p_sys->surface;
 249 #if 0
 250     picture_Release(picture);
 251     Direct3DRenderScene(vd, surface);
 252 #else
 253     /* FIXME it is a bit ugly, we need the surface to be unlocked for
 254      * rendering.
 255      *  The clean way would be to release the picture (and ensure that
 256      * the vout doesn't keep a reference). But because of the vout
 257      * wrapper, we can't */
 258
 259     Direct3DUnlockSurface(picture);
 260
 261     Direct3DRenderScene(vd, surface);
 262
 263     Direct3DLockSurface(picture);
 264 #endif
 265 }
 266
 267 static void Display(vout_display_t *vd, picture_t *picture)
 268 {
 269     vout_display_sys_t *sys = vd->sys;
 270     LPDIRECT3DDEVICE9 d3ddev = sys->d3ddev;
 271
 272     // Present the back buffer contents to the display
 273     // No stretching should happen here !
 274     const RECT src = sys->rect_dest_clipped;
 275     const RECT dst = sys->rect_dest_clipped;
 276     HRESULT hr = IDirect3DDevice9_Present(d3ddev, &src, &dst, NULL, NULL);
 277     if (FAILED(hr)) {
 278         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
 279     }
 280 #if 0
 281     VLC_UNUSED(picture);
 282 #else
 283     /* XXX See Prepare() */
 284     picture_Release(picture);
 285 #endif
 286
 287     CommonDisplay(vd);
 288 }
 289 static int ControlResetDevice(vout_display_t *vd)
 290 {
 291     return Direct3DReset(vd);
 292 }
 293 static int ControlReopenDevice(vout_display_t *vd)
 294 {
 295     vout_display_sys_t *sys = vd->sys;
 296
 297     if (!sys->use_desktop) {
 298         /* Save non-desktop state */
 299         sys->desktop_save.is_fullscreen = vd->cfg->is_fullscreen;
 300         sys->desktop_save.is_on_top     = sys->is_on_top;
 301
 302         WINDOWPLACEMENT wp = { .length = sizeof(wp), };
 303         GetWindowPlacement(sys->hparent ? sys->hparent : sys->hwnd, &wp);
 304         sys->desktop_save.win = wp.rcNormalPosition;
 305     }
 306
 307     /* */
 308     Direct3DClose(vd);
 309     EventThreadStop(sys->event);
 310
 311     /* */
 312     vlc_mutex_lock(&sys->lock);
 313     sys->use_desktop = sys->desktop_requested;
 314     sys->ch_desktop = false;
 315     vlc_mutex_unlock(&sys->lock);
 316
 317     /* */
 318     event_cfg_t cfg;
 319     memset(&cfg, 0, sizeof(cfg));
 320     cfg.use_desktop = sys->use_desktop;
 321     if (!sys->use_desktop) {
 322         cfg.win.type   = VOUT_WINDOW_TYPE_HWND;
 323         cfg.win.x      = sys->desktop_save.win.left;
 324         cfg.win.y      = sys->desktop_save.win.top;
 325         cfg.win.width  = sys->desktop_save.win.right  - sys->desktop_save.win.left;
 326         cfg.win.height = sys->desktop_save.win.bottom - sys->desktop_save.win.top;
 327     }
 328
 329     event_hwnd_t hwnd;
 330     if (EventThreadStart(sys->event, &hwnd, &cfg)) {
 331         msg_Err(vd, "Failed to restart event thread");
 332         return VLC_EGENERIC;
 333     }
 334     sys->parent_window = hwnd.parent_window;
 335     sys->hparent       = hwnd.hparent;
 336     sys->hwnd          = hwnd.hwnd;
 337     sys->hvideownd     = hwnd.hvideownd;
 338     sys->hfswnd        = hwnd.hfswnd;
 339     SetRectEmpty(&sys->rect_parent);
 340
 341     /* */
 342     video_format_t fmt;
 343     if (Direct3DOpen(vd, &fmt)) {
 344         CommonClean(vd);
 345         msg_Err(vd, "Failed to reopen device");
 346         return VLC_EGENERIC;
 347     }
 348     vd->fmt = fmt;
 349     sys->is_first_display = true;
 350
 351     if (sys->use_desktop) {
 352         /* Disable fullscreen/on_top while using desktop */
 353         if (sys->desktop_save.is_fullscreen)
 354             vout_display_SendEventFullscreen(vd, false);
 355         if (sys->desktop_save.is_on_top)
 356             vout_display_SendWindowState(vd, VOUT_WINDOW_STATE_NORMAL);
 357     } else {
 358         /* Restore fullscreen/on_top */
 359         if (sys->desktop_save.is_fullscreen)
 360             vout_display_SendEventFullscreen(vd, true);
 361         if (sys->desktop_save.is_on_top)
 362             vout_display_SendWindowState(vd, VOUT_WINDOW_STATE_ABOVE);
 363     }
 364     return VLC_SUCCESS;
 365 }
 366 static int Control(vout_display_t *vd, int query, va_list args)
 367 {
 368     vout_display_sys_t *sys = vd->sys;
 369
 370     switch (query) {
 371     case VOUT_DISPLAY_RESET_PICTURES:
 372         /* FIXME what to do here in case of failure */
 373         if (sys->reset_device) {
 374             if (ControlResetDevice(vd)) {
 375                 msg_Err(vd, "Failed to reset device");
 376                 return VLC_EGENERIC;
 377             }
 378             sys->reset_device = false;
 379         } else if(sys->reopen_device) {
 380             if (ControlReopenDevice(vd)) {
 381                 msg_Err(vd, "Failed to reopen device");
 382                 return VLC_EGENERIC;
 383             }
 384             sys->reopen_device = false;
 385         }
 386         return VLC_SUCCESS;
 387     default:
 388         return CommonControl(vd, query, args);
 389     }
 390 }
 391 static void Manage (vout_display_t *vd)
 392 {
 393     vout_display_sys_t *sys = vd->sys;
 394
 395     CommonManage(vd);
 396
 397     /* Desktop mode change */
 398     vlc_mutex_lock(&sys->lock);
 399     const bool ch_desktop = sys->ch_desktop;
 400     sys->ch_desktop = false;
 401     vlc_mutex_unlock(&sys->lock);
 402
 403     if (ch_desktop) {
 404         sys->reopen_device = true;
 405         vout_display_SendEventPicturesInvalid(vd);
 406     }
 407
 408 #if 0
 409     /*
 410      * Position Change
 411      */
 412     if (sys->changes & DX_POSITION_CHANGE) {
 413 #if 0 /* need that when bicubic filter is available */
 414         RECT rect;
 415         UINT width, height;
 416
 417         GetClientRect(p_sys->hvideownd, &rect);
 418         width  = rect.right-rect.left;
 419         height = rect.bottom-rect.top;
 420
 421         if (width != p_sys->d3dpp.BackBufferWidth || height != p_sys->d3dpp.BackBufferHeight)
 422         {
 423             msg_Dbg(vd, "resizing device back buffers to (%lux%lu)", width, height);
 424             // need to reset D3D device to resize back buffer
 425             if (VLC_SUCCESS != Direct3DResetDevice(vd, width, height))
 426                 return VLC_EGENERIC;
 427         }
 428 #endif
 429         sys->changes &= ~DX_POSITION_CHANGE;
 430     }
 431 #endif
 432 }
 433
 434 /**
 435  * It initializes an instance of Direct3D9
 436  */
 437 static int Direct3DCreate(vout_display_t *vd)
 438 {
 439     vout_display_sys_t *sys = vd->sys;
 440
 441     sys->hd3d9_dll = LoadLibrary(TEXT("D3D9.DLL"));
 442     if (!sys->hd3d9_dll) {
 443         msg_Warn(vd, "cannot load d3d9.dll, aborting");
 444         return VLC_EGENERIC;
 445     }
 446
 447     LPDIRECT3D9 (WINAPI *OurDirect3DCreate9)(UINT SDKVersion);
 448     OurDirect3DCreate9 =
 449         (void *)GetProcAddress(sys->hd3d9_dll, TEXT("Direct3DCreate9"));
 450     if (!OurDirect3DCreate9) {
 451         msg_Err(vd, "Cannot locate reference to Direct3DCreate9 ABI in DLL");
 452         return VLC_EGENERIC;
 453     }
 454
 455     /* Create the D3D object. */
 456     LPDIRECT3D9 d3dobj = OurDirect3DCreate9(D3D_SDK_VERSION);
 457     if (!d3dobj) {
 458        msg_Err(vd, "Could not create Direct3D9 instance.");
 459        return VLC_EGENERIC;
 460     }
 461     sys->d3dobj = d3dobj;
 462
 463     /*
 464     ** Get device capabilities
 465     */
 466     D3DCAPS9 d3dCaps;
 467     ZeroMemory(&d3dCaps, sizeof(d3dCaps));
 468     HRESULT hr = IDirect3D9_GetDeviceCaps(d3dobj, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dCaps);
 469     if (FAILED(hr)) {
 470        msg_Err(vd, "Could not read adapter capabilities. (hr=0x%lX)", hr);
 471        return VLC_EGENERIC;
 472     }
 473     /* TODO: need to test device capabilities and select the right render function */
 474
 475     return VLC_SUCCESS;
 476 }
 477
 478 /**
 479  * It releases an instance of Direct3D9
 480  */
 481 static void Direct3DDestroy(vout_display_t *vd)
 482 {
 483     vout_display_sys_t *sys = vd->sys;
 484
 485     if (sys->d3dobj)
 486        IDirect3D9_Release(sys->d3dobj);
 487     if (sys->hd3d9_dll)
 488         FreeLibrary(sys->hd3d9_dll);
 489
 490     sys->d3dobj = NULL;
 491     sys->hd3d9_dll = NULL;
 492 }
 493
 494
 495 /**
 496  * It setup vout_display_sys_t::d3dpp and vout_display_sys_t::rect_display
 497  * from the default adapter.
 498  */
 499 static int Direct3DFillPresentationParameters(vout_display_t *vd)
 500 {
 501     vout_display_sys_t *sys = vd->sys;
 502
 503     /*
 504     ** Get the current desktop display mode, so we can set up a back
 505     ** buffer of the same format
 506     */
 507     D3DDISPLAYMODE d3ddm;
 508     HRESULT hr = IDirect3D9_GetAdapterDisplayMode(sys->d3dobj,
 509                                                   D3DADAPTER_DEFAULT, &d3ddm);
 510     if (FAILED(hr)) {
 511        msg_Err(vd, "Could not read adapter display mode. (hr=0x%lX)", hr);
 512        return VLC_EGENERIC;
 513     }
 514
 515     /* Set up the structure used to create the D3DDevice. */
 516     D3DPRESENT_PARAMETERS *d3dpp = &vd->sys->d3dpp;
 517     ZeroMemory(d3dpp, sizeof(D3DPRESENT_PARAMETERS));
 518     d3dpp->Flags                  = D3DPRESENTFLAG_VIDEO;
 519     d3dpp->Windowed               = TRUE;
 520     d3dpp->hDeviceWindow          = vd->sys->hvideownd;
 521     d3dpp->BackBufferWidth        = __MAX(GetSystemMetrics(SM_CXVIRTUALSCREEN),
 522                                           d3ddm.Width);
 523     d3dpp->BackBufferHeight       = __MAX(GetSystemMetrics(SM_CYVIRTUALSCREEN),
 524                                           d3ddm.Height);
 525     d3dpp->SwapEffect             = D3DSWAPEFFECT_COPY;
 526     d3dpp->MultiSampleType        = D3DMULTISAMPLE_NONE;
 527     d3dpp->PresentationInterval   = D3DPRESENT_INTERVAL_DEFAULT;
 528     d3dpp->BackBufferFormat       = d3ddm.Format;
 529     d3dpp->BackBufferCount        = 1;
 530     d3dpp->EnableAutoDepthStencil = FALSE;
 531
 532     /* */
 533     RECT *display = &vd->sys->rect_display;
 534     display->left   = 0;
 535     display->top    = 0;
 536     display->right  = d3dpp->BackBufferWidth;
 537     display->bottom = d3dpp->BackBufferHeight;
 538
 539     return VLC_SUCCESS;
 540 }
 541
 542 /* */
 543 static int  Direct3DCreateResources (vout_display_t *, video_format_t *);
 544 static void Direct3DDestroyResources(vout_display_t *);
 545
 546 /**
 547  * It creates a Direct3D device and the associated resources.
 548  */
 549 static int Direct3DOpen(vout_display_t *vd, video_format_t *fmt)
 550 {
 551     vout_display_sys_t *sys = vd->sys;
 552     LPDIRECT3D9 d3dobj = sys->d3dobj;
 553
 554     if (Direct3DFillPresentationParameters(vd))
 555         return VLC_EGENERIC;
 556
 557     // Create the D3DDevice
 558     LPDIRECT3DDEVICE9 d3ddev;
 559     HRESULT hr = IDirect3D9_CreateDevice(d3dobj, D3DADAPTER_DEFAULT,
 560                                          D3DDEVTYPE_HAL, sys->hvideownd,
 561                                          D3DCREATE_SOFTWARE_VERTEXPROCESSING|
 562                                          D3DCREATE_MULTITHREADED,
 563                                          &sys->d3dpp, &d3ddev);
 564     if (FAILED(hr)) {
 565        msg_Err(vd, "Could not create the D3D device! (hr=0x%lX)", hr);
 566        return VLC_EGENERIC;
 567     }
 568     sys->d3ddev = d3ddev;
 569
 570     UpdateRects(vd, NULL, NULL, true);
 571
 572     if (Direct3DCreateResources(vd, fmt)) {
 573         msg_Err(vd, "Failed to allocate resources");
 574         return VLC_EGENERIC;
 575     }
 576
 577     /* Change the window title bar text */
 578     EventThreadUpdateTitle(sys->event, VOUT_TITLE " (Direct3D output)");
 579
 580     msg_Dbg(vd, "Direct3D device adapter successfully initialized");
 581     return VLC_SUCCESS;
 582 }
 583
 584 /**
 585  * It releases the Direct3D9 device and its resources.
 586  */
 587 static void Direct3DClose(vout_display_t *vd)
 588 {
 589     vout_display_sys_t *sys = vd->sys;
 590
 591     Direct3DDestroyResources(vd);
 592
 593     if (sys->d3ddev)
 594        IDirect3DDevice9_Release(sys->d3ddev);
 595
 596     sys->d3ddev = NULL;
 597 }
 598
 599 /**
 600  * It reset the Direct3D9 device and its resources.
 601  */
 602 static int Direct3DReset(vout_display_t *vd)
 603 {
 604     vout_display_sys_t *sys = vd->sys;
 605     LPDIRECT3DDEVICE9 d3ddev = sys->d3ddev;
 606
 607     if (Direct3DFillPresentationParameters(vd))
 608         return VLC_EGENERIC;
 609
 610     /* release all D3D objects */
 611     Direct3DDestroyResources(vd);
 612
 613     /* */
 614     HRESULT hr = IDirect3DDevice9_Reset(d3ddev, &sys->d3dpp);
 615     if (FAILED(hr)) {
 616         msg_Err(vd, "%s failed ! (hr=%08lX)", __FUNCTION__, hr);
 617         return VLC_EGENERIC;
 618     }
 619
 620     UpdateRects(vd, NULL, NULL, true);
 621
 622     /* re-create them */
 623     if (Direct3DCreateResources(vd, &vd->fmt)) {
 624         msg_Dbg(vd, "%s failed !", __FUNCTION__);
 625         return VLC_EGENERIC;
 626     }
 627     return VLC_SUCCESS;
 628 }
 629
 630 /* */
 631 static int  Direct3DCreatePool(vout_display_t *vd, video_format_t *fmt);
 632 static void Direct3DDestroyPool(vout_display_t *vd);
 633
 634 static int  Direct3DCreateScene(vout_display_t *vd);
 635 static void Direct3DDestroyScene(vout_display_t *vd);
 636
 637 /**
 638  * It creates the picture and scene resources.
 639  */
 640 static int Direct3DCreateResources(vout_display_t *vd, video_format_t *fmt)
 641 {
 642     if (Direct3DCreatePool(vd, fmt)) {
 643         msg_Err(vd, "Direct3D picture pool initialization failed");
 644         return VLC_EGENERIC;
 645     }
 646     if (Direct3DCreateScene(vd)) {
 647         msg_Err(vd, "Direct3D scene initialization failed !");
 648         return VLC_EGENERIC;
 649     }
 650     return VLC_SUCCESS;
 651 }
 652 /**
 653  * It destroys the picture and scene resources.
 654  */
 655 static void Direct3DDestroyResources(vout_display_t *vd)
 656 {
 657     Direct3DDestroyScene(vd);
 658     Direct3DDestroyPool(vd);
 659 }
 660
 661 /**
 662  * It tests if the conversion from src to dst is supported.
 663  */
 664 static int Direct3DCheckConversion(vout_display_t *vd,
 665                                    D3DFORMAT src, D3DFORMAT dst)
 666 {
 667     vout_display_sys_t *sys = vd->sys;
 668     LPDIRECT3D9 d3dobj = sys->d3dobj;
 669     HRESULT hr;
 670
 671     /* test whether device can create a surface of that format */
 672     hr = IDirect3D9_CheckDeviceFormat(d3dobj, D3DADAPTER_DEFAULT,
 673                                       D3DDEVTYPE_HAL, dst, 0,
 674                                       D3DRTYPE_SURFACE, src);
 675     if (SUCCEEDED(hr)) {
 676         /* test whether device can perform color-conversion
 677         ** from that format to target format
 678         */
 679         hr = IDirect3D9_CheckDeviceFormatConversion(d3dobj,
 680                                                     D3DADAPTER_DEFAULT,
 681                                                     D3DDEVTYPE_HAL,
 682                                                     src, dst);
 683     }
 684     if (!SUCCEEDED(hr)) {
 685         if (D3DERR_NOTAVAILABLE != hr)
 686             msg_Err(vd, "Could not query adapter supported formats. (hr=0x%lX)", hr);
 687         return VLC_EGENERIC;
 688     }
 689     return VLC_SUCCESS;
 690 }
 691
 692 typedef struct
 693 {
 694     const char   *name;
 695     D3DFORMAT    format;    /* D3D format */
 696     vlc_fourcc_t fourcc;    /* VLC fourcc */
 697     uint32_t     rmask;
 698     uint32_t     gmask;
 699     uint32_t     bmask;
 700 } d3d_format_t;
 701
 702 static const d3d_format_t d3d_formats[] = {
 703     /* YV12 is always used for planar 420, the planes are then swapped in Lock() */
 704     { "YV12",       MAKEFOURCC('Y','V','1','2'),    VLC_CODEC_YV12,  0,0,0 },
 705     { "YV12",       MAKEFOURCC('Y','V','1','2'),    VLC_CODEC_I420,  0,0,0 },
 706     { "YV12",       MAKEFOURCC('Y','V','1','2'),    VLC_CODEC_J420,  0,0,0 },
 707     { "UYVY",       D3DFMT_UYVY,    VLC_CODEC_UYVY,  0,0,0 },
 708     { "YUY2",       D3DFMT_YUY2,    VLC_CODEC_YUYV,  0,0,0 },
 709     { "X8R8G8B8",   D3DFMT_X8R8G8B8,VLC_CODEC_RGB32, 0xff0000, 0x00ff00, 0x0000ff },
 710     { "A8R8G8B8",   D3DFMT_A8R8G8B8,VLC_CODEC_RGB32, 0xff0000, 0x00ff00, 0x0000ff },
 711     { "8G8B8",      D3DFMT_R8G8B8,  VLC_CODEC_RGB24, 0xff0000, 0x00ff00, 0x0000ff },
 712     { "R5G6B5",     D3DFMT_R5G6B5,  VLC_CODEC_RGB16, 0x1f<<11, 0x3f<<5,  0x1f<<0 },
 713     { "X1R5G5B5",   D3DFMT_X1R5G5B5,VLC_CODEC_RGB15, 0x1f<<10, 0x1f<<5,  0x1f<<0 },
 714
 715     { NULL, 0, 0, 0,0,0}
 716 };
 717
 718 /**
 719  * It returns the format (closest to chroma) that can be converted to target */
 720 static const d3d_format_t *Direct3DFindFormat(vout_display_t *vd, vlc_fourcc_t chroma, D3DFORMAT target)
 721 {
 722     vout_display_sys_t *sys = vd->sys;
 723
 724     for (unsigned pass = 0; pass < 2; pass++) {
 725         const vlc_fourcc_t *list;
 726
 727         if (pass == 0 && sys->allow_hw_yuv && vlc_fourcc_IsYUV(chroma))
 728             list = vlc_fourcc_GetYUVFallback(chroma);
 729         else if (pass == 1)
 730             list = vlc_fourcc_GetRGBFallback(chroma);
 731         else
 732             continue;
 733
 734         for (unsigned i = 0; list[i] != 0; i++) {
 735             for (unsigned j = 0; d3d_formats[j].name; j++) {
 736                 const d3d_format_t *format = &d3d_formats[j];
 737
 738                 if (format->fourcc != list[i])
 739                     continue;
 740
 741                 msg_Warn(vd, "trying surface pixel format: %s",
 742                          format->name);
 743                 if (!Direct3DCheckConversion(vd, format->format, target)) {
 744                     msg_Dbg(vd, "selected surface pixel format is %s",
 745                             format->name);
 746                     return format;
 747                 }
 748             }
 749         }
 750     }
 751     return NULL;
 752 }
 753
 754 /**
 755  * It locks the surface associated to the picture and get the surface
 756  * descriptor which amongst other things has the pointer to the picture
 757  * data and its pitch.
 758  */
 759 static int Direct3DLockSurface(picture_t *picture)
 760 {
 761     /* Lock the surface to get a valid pointer to the picture buffer */
 762     D3DLOCKED_RECT d3drect;
 763     HRESULT hr = IDirect3DSurface9_LockRect(picture->p_sys->surface, &d3drect, NULL, 0);
 764     if (FAILED(hr)) {
 765         //msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
 766         return VLC_EGENERIC;
 767     }
 768
 769     /* fill in buffer info in first plane */
 770     picture->p->p_pixels = d3drect.pBits;
 771     picture->p->i_pitch  = d3drect.Pitch;
 772
 773     /*  Fill chroma planes for planar YUV */
 774     if (picture->format.i_chroma == VLC_CODEC_I420 ||
 775         picture->format.i_chroma == VLC_CODEC_J420 ||
 776         picture->format.i_chroma == VLC_CODEC_YV12) {
 777
 778         for (int n = 1; n < picture->i_planes; n++) {
 779             const plane_t *o = &picture->p[n-1];
 780             plane_t *p = &picture->p[n];
 781
 782             p->p_pixels = o->p_pixels + o->i_lines * o->i_pitch;
 783             p->i_pitch  = d3drect.Pitch / 2;
 784         }
 785         /* The d3d buffer is always allocated as YV12 */
 786         if (vlc_fourcc_AreUVPlanesSwapped(picture->format.i_chroma, VLC_CODEC_YV12)) {
 787             uint8_t *p_tmp = picture->p[1].p_pixels;
 788             picture->p[1].p_pixels = picture->p[2].p_pixels;
 789             picture->p[2].p_pixels = p_tmp;
 790         }
 791     }
 792     return VLC_SUCCESS;
 793 }
 794 /**
 795  * It unlocks the surface associated to the picture.
 796  */
 797 static void Direct3DUnlockSurface(picture_t *picture)
 798 {
 799     /* Unlock the Surface */
 800     HRESULT hr = IDirect3DSurface9_UnlockRect(picture->p_sys->surface);
 801     if (FAILED(hr)) {
 802         //msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
 803     }
 804 }
 805
 806 /**
 807  * It creates the pool of picture (only 1).
 808  *
 809  * Each picture has an associated offscreen surface in video memory
 810  * depending on hardware capabilities the picture chroma will be as close
 811  * as possible to the orginal render chroma to reduce CPU conversion overhead
 812  * and delegate this work to video card GPU
 813  */
 814 static int Direct3DCreatePool(vout_display_t *vd, video_format_t *fmt)
 815 {
 816     vout_display_sys_t *sys = vd->sys;
 817     LPDIRECT3DDEVICE9 d3ddev = sys->d3ddev;
 818
 819     /* */
 820     *fmt = vd->source;
 821
 822     /* Find the appropriate D3DFORMAT for the render chroma, the format will be the closest to
 823      * the requested chroma which is usable by the hardware in an offscreen surface, as they
 824      * typically support more formats than textures */
 825     const d3d_format_t *d3dfmt = Direct3DFindFormat(vd, fmt->i_chroma, sys->d3dpp.BackBufferFormat);
 826     if (!d3dfmt) {
 827         msg_Err(vd, "surface pixel format is not supported.");
 828         return VLC_EGENERIC;
 829     }
 830     fmt->i_chroma = d3dfmt->fourcc;
 831     fmt->i_rmask  = d3dfmt->rmask;
 832     fmt->i_gmask  = d3dfmt->gmask;
 833     fmt->i_bmask  = d3dfmt->bmask;
 834
 835     /* We create one picture.
 836      * It is useless to create more as we can't be used for direct rendering */
 837
 838     /* Create a surface */
 839     LPDIRECT3DSURFACE9 surface;
 840     HRESULT hr = IDirect3DDevice9_CreateOffscreenPlainSurface(d3ddev,
 841                                                               fmt->i_width,
 842                                                               fmt->i_height,
 843                                                               d3dfmt->format,
 844                                                               D3DPOOL_DEFAULT,
 845                                                               &surface,
 846                                                               NULL);
 847     if (FAILED(hr)) {
 848         msg_Err(vd, "Failed to create picture surface. (hr=0x%lx)", hr);
 849         return VLC_EGENERIC;
 850     }
 851     /* fill surface with black color */
 852     IDirect3DDevice9_ColorFill(d3ddev, surface, NULL, D3DCOLOR_ARGB(0xFF, 0, 0, 0));
 853
 854     /* Create the associated picture */
 855     picture_resource_t *rsc = &sys->resource;
 856     rsc->p_sys = malloc(sizeof(*rsc->p_sys));
 857     if (!rsc->p_sys) {
 858         IDirect3DSurface9_Release(surface);
 859         return VLC_ENOMEM;
 860     }
 861     rsc->p_sys->surface = surface;
 862     for (int i = 0; i < PICTURE_PLANE_MAX; i++) {
 863         rsc->p[i].p_pixels = NULL;
 864         rsc->p[i].i_pitch = 0;
 865         rsc->p[i].i_lines = fmt->i_height / (i > 0 ? 2 : 1);
 866     }
 867     picture_t *picture = picture_NewFromResource(fmt, rsc);
 868     if (!picture) {
 869         IDirect3DSurface9_Release(surface);
 870         free(rsc->p_sys);
 871         return VLC_ENOMEM;
 872     }
 873
 874     /* Wrap it into a picture pool */
 875     picture_pool_configuration_t pool_cfg;
 876     memset(&pool_cfg, 0, sizeof(pool_cfg));
 877     pool_cfg.picture_count = 1;
 878     pool_cfg.picture       = &picture;
 879     pool_cfg.lock          = Direct3DLockSurface;
 880     pool_cfg.unlock        = Direct3DUnlockSurface;
 881
 882     sys->pool = picture_pool_NewExtended(&pool_cfg);
 883     if (!sys->pool) {
 884         picture_Release(picture);
 885         IDirect3DSurface9_Release(surface);
 886         return VLC_ENOMEM;
 887     }
 888     return VLC_SUCCESS;
 889 }
 890 /**
 891  * It destroys the pool of picture and its resources.
 892  */
 893 static void Direct3DDestroyPool(vout_display_t *vd)
 894 {
 895     vout_display_sys_t *sys = vd->sys;
 896
 897     if (sys->pool) {
 898         picture_resource_t *rsc = &sys->resource;
 899         IDirect3DSurface9_Release(rsc->p_sys->surface);
 900
 901         picture_pool_Delete(sys->pool);
 902     }
 903     sys->pool = NULL;
 904 }
 905
 906 /* */
 907 typedef struct
 908 {
 909     FLOAT       x,y,z;      // vertex untransformed position
 910     FLOAT       rhw;        // eye distance
 911     D3DCOLOR    diffuse;    // diffuse color
 912     FLOAT       tu, tv;     // texture relative coordinates
 913 } CUSTOMVERTEX;
 914
 915 #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1)
 916
 917 /**
 918  * It allocates and initializes the resources needed to render the scene.
 919  */
 920 static int Direct3DCreateScene(vout_display_t *vd)
 921 {
 922     vout_display_sys_t *sys = vd->sys;
 923     LPDIRECT3DDEVICE9       d3ddev = sys->d3ddev;
 924     HRESULT hr;
 925
 926     /*
 927      * Create a texture for use when rendering a scene
 928      * for performance reason, texture format is identical to backbuffer
 929      * which would usually be a RGB format
 930      */
 931     LPDIRECT3DTEXTURE9 d3dtex;
 932     hr = IDirect3DDevice9_CreateTexture(d3ddev,
 933                                         sys->d3dpp.BackBufferWidth,
 934                                         sys->d3dpp.BackBufferHeight,
 935                                         1,
 936                                         D3DUSAGE_RENDERTARGET,
 937                                         sys->d3dpp.BackBufferFormat,
 938                                         D3DPOOL_DEFAULT,
 939                                         &d3dtex,
 940                                         NULL);
 941     if (FAILED(hr)) {
 942         msg_Err(vd, "Failed to create texture. (hr=0x%lx)", hr);
 943         return VLC_EGENERIC;
 944     }
 945
 946     /*
 947     ** Create a vertex buffer for use when rendering scene
 948     */
 949     LPDIRECT3DVERTEXBUFFER9 d3dvtc;
 950     hr = IDirect3DDevice9_CreateVertexBuffer(d3ddev,
 951                                              sizeof(CUSTOMVERTEX)*4,
 952                                              D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY,
 953                                              D3DFVF_CUSTOMVERTEX,
 954                                              D3DPOOL_DEFAULT,
 955                                              &d3dvtc,
 956                                              NULL);
 957     if (FAILED(hr)) {
 958         msg_Err(vd, "Failed to create vertex buffer. (hr=0x%lx)", hr);
 959         IDirect3DTexture9_Release(d3dtex);
 960         return VLC_EGENERIC;
 961     }
 962
 963     /* */
 964     sys->d3dtex = d3dtex;
 965     sys->d3dvtc = d3dvtc;
 966
 967     // Texture coordinates outside the range [0.0, 1.0] are set
 968     // to the texture color at 0.0 or 1.0, respectively.
 969     IDirect3DDevice9_SetSamplerState(d3ddev, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
 970     IDirect3DDevice9_SetSamplerState(d3ddev, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
 971
 972     // Set linear filtering quality
 973     IDirect3DDevice9_SetSamplerState(d3ddev, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
 974     IDirect3DDevice9_SetSamplerState(d3ddev, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
 975
 976     // set maximum ambient light
 977     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_AMBIENT, D3DCOLOR_XRGB(255,255,255));
 978
 979     // Turn off culling
 980     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_CULLMODE, D3DCULL_NONE);
 981
 982     // Turn off the zbuffer
 983     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ZENABLE, D3DZB_FALSE);
 984
 985     // Turn off lights
 986     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_LIGHTING, FALSE);
 987
 988     // Enable dithering
 989     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_DITHERENABLE, TRUE);
 990
 991     // disable stencil
 992     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_STENCILENABLE, FALSE);
 993
 994     // manage blending
 995     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ALPHABLENDENABLE, TRUE);
 996     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
 997     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
 998     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ALPHATESTENABLE,TRUE);
 999     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ALPHAREF, 0x10);
1000     IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ALPHAFUNC,D3DCMP_GREATER);
1001
1002     // Set texture states
1003     IDirect3DDevice9_SetTextureStageState(d3ddev, 0, D3DTSS_COLOROP,D3DTOP_MODULATE);
1004     IDirect3DDevice9_SetTextureStageState(d3ddev, 0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
1005     IDirect3DDevice9_SetTextureStageState(d3ddev, 0, D3DTSS_COLORARG2,D3DTA_DIFFUSE);
1006
1007     // turn off alpha operation
1008     IDirect3DDevice9_SetTextureStageState(d3ddev, 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
1009
1010     msg_Dbg(vd, "Direct3D scene created successfully");
1011
1012     return VLC_SUCCESS;
1013 }
1014
1015 /**
1016  * It releases the scene resources.
1017  */
1018 static void Direct3DDestroyScene(vout_display_t *vd)
1019 {
1020     vout_display_sys_t *sys = vd->sys;
1021
1022     LPDIRECT3DVERTEXBUFFER9 d3dvtc = sys->d3dvtc;
1023     if (d3dvtc)
1024         IDirect3DVertexBuffer9_Release(d3dvtc);
1025
1026     LPDIRECT3DTEXTURE9 d3dtex = sys->d3dtex;
1027     if (d3dtex)
1028         IDirect3DTexture9_Release(d3dtex);
1029
1030     sys->d3dvtc = NULL;
1031     sys->d3dtex = NULL;
1032     msg_Dbg(vd, "Direct3D scene released successfully");
1033 }
1034
1035 /**
1036  * It copies picture surface into a texture and renders into a scene.
1037  *
1038  * This function is intented for higher end 3D cards, with pixel shader support
1039  * and at least 64 MiB of video RAM.
1040  */
1041 static void Direct3DRenderScene(vout_display_t *vd, LPDIRECT3DSURFACE9 surface)
1042 {
1043     vout_display_sys_t *sys = vd->sys;
1044     LPDIRECT3DDEVICE9 d3ddev = sys->d3ddev;
1045     HRESULT hr;
1046
1047     // check if device is still available
1048     hr = IDirect3DDevice9_TestCooperativeLevel(d3ddev);
1049     if (FAILED(hr)) {
1050         if (hr == D3DERR_DEVICENOTRESET && !sys->reset_device) {
1051             vout_display_SendEventPicturesInvalid(vd);
1052             sys->reset_device = true;
1053         }
1054         return;
1055     }
1056     /* */
1057     LPDIRECT3DTEXTURE9      d3dtex  = sys->d3dtex;
1058     LPDIRECT3DVERTEXBUFFER9 d3dvtc  = sys->d3dvtc;
1059
1060     /* Clear the backbuffer and the zbuffer */
1061     hr = IDirect3DDevice9_Clear(d3ddev, 0, NULL, D3DCLEAR_TARGET,
1062                               D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
1063     if (FAILED(hr)) {
1064         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1065         return;
1066     }
1067     /*  retrieve picture surface */
1068     LPDIRECT3DSURFACE9 d3dsrc = surface;
1069     if (!d3dsrc) {
1070         msg_Dbg(vd, "no surface to render ?");
1071         return;
1072     }
1073
1074     /* retrieve texture top-level surface */
1075     LPDIRECT3DSURFACE9 d3ddest;
1076     hr = IDirect3DTexture9_GetSurfaceLevel(d3dtex, 0, &d3ddest);
1077     if (FAILED(hr)) {
1078         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1079         return;
1080     }
1081
1082     /* Copy picture surface into texture surface
1083      * color space conversion and scaling happen here */
1084     RECT src = vd->sys->rect_src_clipped;
1085     RECT dst = vd->sys->rect_dest_clipped;
1086
1087     hr = IDirect3DDevice9_StretchRect(d3ddev, d3dsrc, &src, d3ddest, &dst, D3DTEXF_LINEAR);
1088     IDirect3DSurface9_Release(d3ddest);
1089     if (FAILED(hr)) {
1090         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1091         return;
1092     }
1093
1094     /* Update the vertex buffer */
1095     CUSTOMVERTEX *vertices;
1096     hr = IDirect3DVertexBuffer9_Lock(d3dvtc, 0, 0, &vertices, D3DLOCK_DISCARD);
1097     if (FAILED(hr)) {
1098         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1099         return;
1100     }
1101
1102     /* Setup vertices */
1103     const float f_width  = vd->sys->d3dpp.BackBufferWidth;
1104     const float f_height = vd->sys->d3dpp.BackBufferHeight;
1105
1106     /* -0.5f is a "feature" of DirectX and it seems to apply to Direct3d also */
1107     /* http://www.sjbrown.co.uk/2003/05/01/fix-directx-rasterisation/ */
1108     vertices[0].x       = -0.5f;       // left
1109     vertices[0].y       = -0.5f;       // top
1110     vertices[0].z       = 0.0f;
1111     vertices[0].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
1112     vertices[0].rhw     = 1.0f;
1113     vertices[0].tu      = 0.0f;
1114     vertices[0].tv      = 0.0f;
1115
1116     vertices[1].x       = f_width - 0.5f;    // right
1117     vertices[1].y       = -0.5f;       // top
1118     vertices[1].z       = 0.0f;
1119     vertices[1].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
1120     vertices[1].rhw     = 1.0f;
1121     vertices[1].tu      = 1.0f;
1122     vertices[1].tv      = 0.0f;
1123
1124     vertices[2].x       = f_width - 0.5f;    // right
1125     vertices[2].y       = f_height - 0.5f;   // bottom
1126     vertices[2].z       = 0.0f;
1127     vertices[2].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
1128     vertices[2].rhw     = 1.0f;
1129     vertices[2].tu      = 1.0f;
1130     vertices[2].tv      = 1.0f;
1131
1132     vertices[3].x       = -0.5f;       // left
1133     vertices[3].y       = f_height - 0.5f;   // bottom
1134     vertices[3].z       = 0.0f;
1135     vertices[3].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
1136     vertices[3].rhw     = 1.0f;
1137     vertices[3].tu      = 0.0f;
1138     vertices[3].tv      = 1.0f;
1139
1140     hr= IDirect3DVertexBuffer9_Unlock(d3dvtc);
1141     if (FAILED(hr)) {
1142         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1143         return;
1144     }
1145
1146     // Begin the scene
1147     hr = IDirect3DDevice9_BeginScene(d3ddev);
1148     if (FAILED(hr)) {
1149         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1150         return;
1151     }
1152
1153     // Setup our texture. Using textures introduces the texture stage states,
1154     // which govern how textures get blended together (in the case of multiple
1155     // textures) and lighting information. In this case, we are modulating
1156     // (blending) our texture with the diffuse color of the vertices.
1157     hr = IDirect3DDevice9_SetTexture(d3ddev, 0, (LPDIRECT3DBASETEXTURE9)d3dtex);
1158     if (FAILED(hr)) {
1159         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1160         IDirect3DDevice9_EndScene(d3ddev);
1161         return;
1162     }
1163
1164     // Render the vertex buffer contents
1165     hr = IDirect3DDevice9_SetStreamSource(d3ddev, 0, d3dvtc, 0, sizeof(CUSTOMVERTEX));
1166     if (FAILED(hr)) {
1167         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1168         IDirect3DDevice9_EndScene(d3ddev);
1169         return;
1170     }
1171
1172     // we use FVF instead of vertex shader
1173     hr = IDirect3DDevice9_SetFVF(d3ddev, D3DFVF_CUSTOMVERTEX);
1174     if (FAILED(hr)) {
1175         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1176         IDirect3DDevice9_EndScene(d3ddev);
1177         return;
1178     }
1179
1180     // draw rectangle
1181     hr = IDirect3DDevice9_DrawPrimitive(d3ddev, D3DPT_TRIANGLEFAN, 0, 2);
1182     if (FAILED(hr)) {
1183         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1184         IDirect3DDevice9_EndScene(d3ddev);
1185         return;
1186     }
1187
1188     // End the scene
1189     hr = IDirect3DDevice9_EndScene(d3ddev);
1190     if (FAILED(hr)) {
1191         msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
1192         return;
1193     }
1194 }
1195
1196 /*****************************************************************************
1197  * DesktopCallback: desktop mode variable callback
1198  *****************************************************************************/
1199 static int DesktopCallback(vlc_object_t *object, char const *psz_cmd,
1200                             vlc_value_t oldval, vlc_value_t newval,
1201                             void *p_data)
1202 {
1203     vout_display_t *vd = (vout_display_t *)object;
1204     vout_display_sys_t *sys = vd->sys;
1205     VLC_UNUSED(psz_cmd);
1206     VLC_UNUSED(oldval);
1207     VLC_UNUSED(p_data);
1208
1209     vlc_mutex_lock(&sys->lock);
1210     const bool ch_desktop = !sys->desktop_requested != !newval.b_bool;
1211     sys->ch_desktop |= ch_desktop;
1212     sys->desktop_requested = newval.b_bool;
1213     vlc_mutex_unlock(&sys->lock);
1214
1215     /* FIXME we should have a way to export variable to be saved */
1216     if (ch_desktop) {
1217         playlist_t *p_playlist = pl_Get(vd);
1218         /* Modify playlist as well because the vout might have to be
1219          * restarted */
1220         var_Create(p_playlist, "direct3d-desktop", VLC_VAR_BOOL);
1221         var_SetBool(p_playlist, "direct3d-desktop", newval.b_bool);
1222     }
1223     return VLC_SUCCESS;
1224 }