dlls/dxva2/main.c

   1 /*
   2  * Copyright 2014 Michael Müller for Pipelight
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22 #include <limits.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "d3d9.h"
  26 #include "physicalmonitorenumerationapi.h"
  27 #include "lowlevelmonitorconfigurationapi.h"
  28 #include "highlevelmonitorconfigurationapi.h"
  29 #include "initguid.h"
  30 #include "dxva2api.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/heap.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(dxva2);
  36
  37 enum device_handle_flags
  38 {
  39     HANDLE_FLAG_OPEN = 0x1,
  40     HANDLE_FLAG_INVALID = 0x2,
  41 };
  42
  43 struct device_handle
  44 {
  45     unsigned int flags;
  46     IDirect3DStateBlock9 *state_block;
  47 };
  48
  49 struct device_manager
  50 {
  51     IDirect3DDeviceManager9 IDirect3DDeviceManager9_iface;
  52     IDirectXVideoProcessorService IDirectXVideoProcessorService_iface;
  53     LONG refcount;
  54
  55     IDirect3DDevice9 *device;
  56     UINT token;
  57
  58     struct device_handle *handles;
  59     size_t count;
  60     size_t capacity;
  61
  62     HANDLE locking_handle;
  63
  64     CRITICAL_SECTION cs;
  65     CONDITION_VARIABLE lock;
  66 };
  67
  68 struct video_processor
  69 {
  70     IDirectXVideoProcessor IDirectXVideoProcessor_iface;
  71     LONG refcount;
  72
  73     IDirectXVideoProcessorService *service;
  74 };
  75
  76 static BOOL dxva_array_reserve(void **elements, size_t *capacity, size_t count, size_t size)
  77 {
  78     size_t new_capacity, max_capacity;
  79     void *new_elements;
  80
  81     if (count <= *capacity)
  82         return TRUE;
  83
  84     max_capacity = ~(SIZE_T)0 / size;
  85     if (count > max_capacity)
  86         return FALSE;
  87
  88     new_capacity = max(4, *capacity);
  89     while (new_capacity < count && new_capacity <= max_capacity / 2)
  90         new_capacity *= 2;
  91     if (new_capacity < count)
  92         new_capacity = max_capacity;
  93
  94     if (!(new_elements = heap_realloc(*elements, new_capacity * size)))
  95         return FALSE;
  96
  97     *elements = new_elements;
  98     *capacity = new_capacity;
  99
 100     return TRUE;
 101 }
 102
 103 static struct device_manager *impl_from_IDirect3DDeviceManager9(IDirect3DDeviceManager9 *iface)
 104 {
 105     return CONTAINING_RECORD(iface, struct device_manager, IDirect3DDeviceManager9_iface);
 106 }
 107
 108 static struct device_manager *impl_from_IDirectXVideoProcessorService(IDirectXVideoProcessorService *iface)
 109 {
 110     return CONTAINING_RECORD(iface, struct device_manager, IDirectXVideoProcessorService_iface);
 111 }
 112
 113 static struct video_processor *impl_from_IDirectXVideoProcessor(IDirectXVideoProcessor *iface)
 114 {
 115     return CONTAINING_RECORD(iface, struct video_processor, IDirectXVideoProcessor_iface);
 116 }
 117
 118 static HRESULT WINAPI video_processor_QueryInterface(IDirectXVideoProcessor *iface, REFIID riid, void **obj)
 119 {
 120     if (IsEqualIID(riid, &IID_IDirectXVideoProcessor) ||
 121             IsEqualIID(riid, &IID_IUnknown))
 122     {
 123         *obj = iface;
 124         IDirectXVideoProcessor_AddRef(iface);
 125         return S_OK;
 126     }
 127
 128     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 129     *obj = NULL;
 130     return E_NOINTERFACE;
 131 }
 132
 133 static ULONG WINAPI video_processor_AddRef(IDirectXVideoProcessor *iface)
 134 {
 135     struct video_processor *processor = impl_from_IDirectXVideoProcessor(iface);
 136     ULONG refcount = InterlockedIncrement(&processor->refcount);
 137
 138     TRACE("%p, refcount %u.\n", iface, refcount);
 139
 140     return refcount;
 141 }
 142
 143 static ULONG WINAPI video_processor_Release(IDirectXVideoProcessor *iface)
 144 {
 145     struct video_processor *processor = impl_from_IDirectXVideoProcessor(iface);
 146     ULONG refcount = InterlockedDecrement(&processor->refcount);
 147
 148     TRACE("%p, refcount %u.\n", iface, refcount);
 149
 150     if (!refcount)
 151     {
 152         IDirectXVideoProcessorService_Release(processor->service);
 153         heap_free(processor);
 154     }
 155
 156     return refcount;
 157 }
 158
 159 static HRESULT WINAPI video_processor_GetVideoProcessorService(IDirectXVideoProcessor *iface,
 160         IDirectXVideoProcessorService **service)
 161 {
 162     struct video_processor *processor = impl_from_IDirectXVideoProcessor(iface);
 163
 164     TRACE("%p, %p.\n", iface, service);
 165
 166     *service = processor->service;
 167     IDirectXVideoProcessorService_AddRef(*service);
 168
 169     return S_OK;
 170 }
 171
 172 static HRESULT WINAPI video_processor_GetCreationParameters(IDirectXVideoProcessor *iface,
 173         GUID *device, DXVA2_VideoDesc *video_desc, D3DFORMAT *rt_format, UINT *maxstreams)
 174 {
 175     FIXME("%p, %p, %p, %p, %p.\n", iface, device, video_desc, rt_format, maxstreams);
 176
 177     if (!device && !video_desc && !rt_format && !maxstreams)
 178         return E_INVALIDARG;
 179
 180     return E_NOTIMPL;
 181 }
 182
 183 static HRESULT WINAPI video_processor_GetVideoProcessorCaps(IDirectXVideoProcessor *iface,
 184         DXVA2_VideoProcessorCaps *caps)
 185 {
 186     FIXME("%p, %p.\n", iface, caps);
 187
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI video_processor_GetProcAmpRange(IDirectXVideoProcessor *iface, UINT cap, DXVA2_ValueRange *range)
 192 {
 193     FIXME("%p, %u, %p.\n", iface, cap, range);
 194
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI video_processor_GetFilterPropertyRange(IDirectXVideoProcessor *iface, UINT setting,
 199         DXVA2_ValueRange *range)
 200 {
 201     FIXME("%p, %u, %p.\n", iface, setting, range);
 202
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI video_processor_VideoProcessBlt(IDirectXVideoProcessor *iface, IDirect3DSurface9 *rt,
 207         const DXVA2_VideoProcessBltParams *params, const DXVA2_VideoSample *samples, UINT sample_count,
 208         HANDLE *complete_handle)
 209 {
 210     FIXME("%p, %p, %p, %p, %u, %p.\n", iface, rt, params, samples, sample_count, complete_handle);
 211
 212     return E_NOTIMPL;
 213 }
 214
 215 static const IDirectXVideoProcessorVtbl video_processor_vtbl =
 216 {
 217     video_processor_QueryInterface,
 218     video_processor_AddRef,
 219     video_processor_Release,
 220     video_processor_GetVideoProcessorService,
 221     video_processor_GetCreationParameters,
 222     video_processor_GetVideoProcessorCaps,
 223     video_processor_GetProcAmpRange,
 224     video_processor_GetFilterPropertyRange,
 225     video_processor_VideoProcessBlt,
 226 };
 227
 228 static HRESULT WINAPI device_manager_processor_service_QueryInterface(IDirectXVideoProcessorService *iface,
 229         REFIID riid, void **obj)
 230 {
 231     if (IsEqualIID(riid, &IID_IDirectXVideoProcessorService) ||
 232             IsEqualIID(riid, &IID_IDirectXVideoAccelerationService) ||
 233             IsEqualIID(riid, &IID_IUnknown))
 234     {
 235         *obj = iface;
 236         IDirectXVideoProcessorService_AddRef(iface);
 237         return S_OK;
 238     }
 239
 240     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 241     *obj = NULL;
 242     return E_NOINTERFACE;
 243 }
 244
 245 static ULONG WINAPI device_manager_processor_service_AddRef(IDirectXVideoProcessorService *iface)
 246 {
 247     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 248     return IDirect3DDeviceManager9_AddRef(&manager->IDirect3DDeviceManager9_iface);
 249 }
 250
 251 static ULONG WINAPI device_manager_processor_service_Release(IDirectXVideoProcessorService *iface)
 252 {
 253     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 254     return IDirect3DDeviceManager9_Release(&manager->IDirect3DDeviceManager9_iface);
 255 }
 256
 257 static HRESULT WINAPI device_manager_processor_service_CreateSurface(IDirectXVideoProcessorService *iface,
 258         UINT width, UINT height, UINT backbuffers, D3DFORMAT format, D3DPOOL pool, DWORD usage, DWORD dxvaType,
 259         IDirect3DSurface9 **surfaces, HANDLE *shared_handle)
 260 {
 261     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 262     unsigned int i, j;
 263     HRESULT hr;
 264
 265     TRACE("%p, %u, %u, %u, %u, %u, %u, %u, %p, %p.\n", iface, width, height, backbuffers, format, pool, usage, dxvaType,
 266             surfaces, shared_handle);
 267
 268     if (backbuffers >= UINT_MAX)
 269         return E_INVALIDARG;
 270
 271     memset(surfaces, 0, (backbuffers + 1) * sizeof(*surfaces));
 272
 273     for (i = 0; i < backbuffers + 1; ++i)
 274     {
 275         if (FAILED(hr = IDirect3DDevice9_CreateOffscreenPlainSurface(manager->device, width, height, format,
 276                 pool, &surfaces[i], NULL)))
 277             break;
 278     }
 279
 280     if (FAILED(hr))
 281     {
 282         for (j = 0; j < i; ++j)
 283         {
 284             if (surfaces[j])
 285             {
 286                 IDirect3DSurface9_Release(surfaces[j]);
 287                 surfaces[j] = NULL;
 288             }
 289         }
 290     }
 291
 292     return hr;
 293 }
 294
 295 static HRESULT WINAPI device_manager_processor_service_RegisterVideoProcessorSoftwareDevice(
 296         IDirectXVideoProcessorService *iface, void *callbacks)
 297 {
 298     FIXME("%p, %p.\n", iface, callbacks);
 299
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorDeviceGuids(
 304         IDirectXVideoProcessorService *iface, const DXVA2_VideoDesc *video_desc, UINT *count, GUID **guids)
 305 {
 306     FIXME("%p, %p, %p, %p semi-stub.\n", iface, video_desc, count, guids);
 307
 308     if (!(*guids = CoTaskMemAlloc(sizeof(**guids))))
 309         return E_OUTOFMEMORY;
 310
 311     memcpy(*guids, &DXVA2_VideoProcSoftwareDevice, sizeof(**guids));
 312     *count = 1;
 313
 314     return S_OK;
 315 }
 316
 317 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorRenderTargets(
 318         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc, UINT *count,
 319         D3DFORMAT **formats)
 320 {
 321     TRACE("%p, %s, %p, %p, %p.\n", iface, debugstr_guid(deviceguid), video_desc, count, formats);
 322
 323     if (IsEqualGUID(deviceguid, &DXVA2_VideoProcSoftwareDevice))
 324     {
 325         /* FIXME: filter some input formats */
 326
 327         if (!(*formats = CoTaskMemAlloc(2 * sizeof(**formats))))
 328             return E_OUTOFMEMORY;
 329
 330         *count = 2;
 331         (*formats)[0] = D3DFMT_X8R8G8B8;
 332         (*formats)[1] = D3DFMT_A8R8G8B8;
 333
 334         return S_OK;
 335     }
 336     else
 337         FIXME("Unsupported device %s.\n", debugstr_guid(deviceguid));
 338
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorSubStreamFormats(
 343         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 344         D3DFORMAT rt_format, UINT *count, D3DFORMAT **formats)
 345 {
 346     FIXME("%p, %s, %p, %u, %p, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, count, formats);
 347
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorCaps(
 352         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 353         D3DFORMAT rt_format, DXVA2_VideoProcessorCaps *caps)
 354 {
 355     FIXME("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, caps);
 356
 357     return E_NOTIMPL;
 358 }
 359
 360 static HRESULT WINAPI device_manager_processor_service_GetProcAmpRange(
 361         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 362         D3DFORMAT rt_format, UINT ProcAmpCap, DXVA2_ValueRange *range)
 363 {
 364     FIXME("%p, %s, %p, %u, %u, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, ProcAmpCap, range);
 365
 366     return E_NOTIMPL;
 367 }
 368
 369 static HRESULT WINAPI device_manager_processor_service_GetFilterPropertyRange(
 370         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 371         D3DFORMAT rt_format, UINT filter_setting, DXVA2_ValueRange *range)
 372 {
 373     FIXME("%p, %s, %p, %d, %d, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, filter_setting, range);
 374
 375     return E_NOTIMPL;
 376 }
 377
 378 static HRESULT WINAPI device_manager_processor_service_CreateVideoProcessor(IDirectXVideoProcessorService *iface,
 379         REFGUID deviceguid, const DXVA2_VideoDesc *video_desc, D3DFORMAT rt_format, UINT max_substreams,
 380         IDirectXVideoProcessor **processor)
 381 {
 382     struct video_processor *object;
 383
 384     FIXME("%p, %s, %p, %d, %u, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, max_substreams,
 385             processor);
 386
 387     /* FIXME: validate render target format */
 388
 389     if (!(object = heap_alloc_zero(sizeof(*object))))
 390         return E_OUTOFMEMORY;
 391
 392     object->IDirectXVideoProcessor_iface.lpVtbl = &video_processor_vtbl;
 393     object->refcount = 1;
 394     object->service = iface;
 395     IDirectXVideoProcessorService_AddRef(object->service);
 396
 397     *processor = &object->IDirectXVideoProcessor_iface;
 398
 399     return S_OK;
 400 }
 401
 402 static const IDirectXVideoProcessorServiceVtbl device_manager_processor_service_vtbl =
 403 {
 404     device_manager_processor_service_QueryInterface,
 405     device_manager_processor_service_AddRef,
 406     device_manager_processor_service_Release,
 407     device_manager_processor_service_CreateSurface,
 408     device_manager_processor_service_RegisterVideoProcessorSoftwareDevice,
 409     device_manager_processor_service_GetVideoProcessorDeviceGuids,
 410     device_manager_processor_service_GetVideoProcessorRenderTargets,
 411     device_manager_processor_service_GetVideoProcessorSubStreamFormats,
 412     device_manager_processor_service_GetVideoProcessorCaps,
 413     device_manager_processor_service_GetProcAmpRange,
 414     device_manager_processor_service_GetFilterPropertyRange,
 415     device_manager_processor_service_CreateVideoProcessor,
 416 };
 417
 418 static HRESULT WINAPI device_manager_QueryInterface(IDirect3DDeviceManager9 *iface, REFIID riid, void **obj)
 419 {
 420     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 421
 422     if (IsEqualIID(&IID_IDirect3DDeviceManager9, riid) ||
 423             IsEqualIID(&IID_IUnknown, riid))
 424     {
 425         *obj = iface;
 426         IDirect3DDeviceManager9_AddRef(iface);
 427         return S_OK;
 428     }
 429
 430     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 431     *obj = NULL;
 432     return E_NOINTERFACE;
 433 }
 434
 435 static ULONG WINAPI device_manager_AddRef(IDirect3DDeviceManager9 *iface)
 436 {
 437     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 438     ULONG refcount = InterlockedIncrement(&manager->refcount);
 439
 440     TRACE("%p, refcount %u.\n", iface, refcount);
 441
 442     return refcount;
 443 }
 444
 445 static ULONG WINAPI device_manager_Release(IDirect3DDeviceManager9 *iface)
 446 {
 447     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 448     ULONG refcount = InterlockedDecrement(&manager->refcount);
 449     size_t i;
 450
 451     TRACE("%p, refcount %u.\n", iface, refcount);
 452
 453     if (!refcount)
 454     {
 455         if (manager->device)
 456             IDirect3DDevice9_Release(manager->device);
 457         DeleteCriticalSection(&manager->cs);
 458         for (i = 0; i < manager->count; ++i)
 459         {
 460             if (manager->handles[i].state_block)
 461                 IDirect3DStateBlock9_Release(manager->handles[i].state_block);
 462         }
 463         heap_free(manager->handles);
 464         heap_free(manager);
 465     }
 466
 467     return refcount;
 468 }
 469
 470 static HRESULT WINAPI device_manager_ResetDevice(IDirect3DDeviceManager9 *iface, IDirect3DDevice9 *device,
 471         UINT token)
 472 {
 473     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 474     size_t i;
 475
 476     TRACE("%p, %p, %#x.\n", iface, device, token);
 477
 478     if (token != manager->token)
 479         return E_INVALIDARG;
 480
 481     EnterCriticalSection(&manager->cs);
 482     if (manager->device)
 483     {
 484         for (i = 0; i < manager->count; ++i)
 485         {
 486             if (manager->handles[i].state_block)
 487                 IDirect3DStateBlock9_Release(manager->handles[i].state_block);
 488             manager->handles[i].state_block = NULL;
 489             manager->handles[i].flags |= HANDLE_FLAG_INVALID;
 490         }
 491         manager->locking_handle = NULL;
 492         IDirect3DDevice9_Release(manager->device);
 493     }
 494     manager->device = device;
 495     IDirect3DDevice9_AddRef(manager->device);
 496     LeaveCriticalSection(&manager->cs);
 497
 498     WakeAllConditionVariable(&manager->lock);
 499
 500     return S_OK;
 501 }
 502
 503 static HRESULT WINAPI device_manager_OpenDeviceHandle(IDirect3DDeviceManager9 *iface, HANDLE *hdevice)
 504 {
 505     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 506     HRESULT hr = S_OK;
 507     size_t i;
 508
 509     TRACE("%p, %p.\n", iface, hdevice);
 510
 511     *hdevice = NULL;
 512
 513     EnterCriticalSection(&manager->cs);
 514     if (!manager->device)
 515         hr = DXVA2_E_NOT_INITIALIZED;
 516     else
 517     {
 518         for (i = 0; i < manager->count; ++i)
 519         {
 520             if (!(manager->handles[i].flags & HANDLE_FLAG_OPEN))
 521             {
 522                 manager->handles[i].flags |= HANDLE_FLAG_OPEN;
 523                 *hdevice = ULongToHandle(i + 1);
 524                 break;
 525             }
 526         }
 527
 528         if (dxva_array_reserve((void **)&manager->handles, &manager->capacity, manager->count + 1,
 529                 sizeof(*manager->handles)))
 530         {
 531             *hdevice = ULongToHandle(manager->count + 1);
 532             manager->handles[manager->count].flags = HANDLE_FLAG_OPEN;
 533             manager->handles[manager->count].state_block = NULL;
 534             manager->count++;
 535         }
 536         else
 537             hr = E_OUTOFMEMORY;
 538     }
 539     LeaveCriticalSection(&manager->cs);
 540
 541     return hr;
 542 }
 543
 544 static HRESULT device_manager_get_handle_index(struct device_manager *manager, HANDLE hdevice, size_t *idx)
 545 {
 546     if (hdevice > ULongToHandle(manager->count))
 547         return E_HANDLE;
 548     *idx = (ULONG_PTR)hdevice - 1;
 549     return S_OK;
 550 }
 551
 552 static HRESULT WINAPI device_manager_CloseDeviceHandle(IDirect3DDeviceManager9 *iface, HANDLE hdevice)
 553 {
 554     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 555     HRESULT hr;
 556     size_t idx;
 557
 558     TRACE("%p, %p.\n", iface, hdevice);
 559
 560     EnterCriticalSection(&manager->cs);
 561     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 562     {
 563         if (manager->handles[idx].flags & HANDLE_FLAG_OPEN)
 564         {
 565             if (manager->locking_handle == hdevice)
 566                 manager->locking_handle = NULL;
 567             manager->handles[idx].flags = 0;
 568             if (idx == manager->count - 1)
 569                 manager->count--;
 570             if (manager->handles[idx].state_block)
 571                 IDirect3DStateBlock9_Release(manager->handles[idx].state_block);
 572             manager->handles[idx].state_block = NULL;
 573         }
 574         else
 575             hr = E_HANDLE;
 576     }
 577     LeaveCriticalSection(&manager->cs);
 578
 579     WakeAllConditionVariable(&manager->lock);
 580
 581     return hr;
 582 }
 583
 584 static HRESULT WINAPI device_manager_TestDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice)
 585 {
 586     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 587     HRESULT hr;
 588     size_t idx;
 589
 590     TRACE("%p, %p.\n", iface, hdevice);
 591
 592     EnterCriticalSection(&manager->cs);
 593     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 594     {
 595         unsigned int flags = manager->handles[idx].flags;
 596
 597         if (flags & HANDLE_FLAG_INVALID)
 598             hr = DXVA2_E_NEW_VIDEO_DEVICE;
 599         else if (!(flags & HANDLE_FLAG_OPEN))
 600             hr = E_HANDLE;
 601     }
 602     LeaveCriticalSection(&manager->cs);
 603
 604     return hr;
 605 }
 606
 607 static HRESULT WINAPI device_manager_LockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice,
 608         IDirect3DDevice9 **device, BOOL block)
 609 {
 610     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 611     HRESULT hr;
 612     size_t idx;
 613
 614     TRACE("%p, %p, %p, %d.\n", iface, hdevice, device, block);
 615
 616     EnterCriticalSection(&manager->cs);
 617     if (!manager->device)
 618         hr = DXVA2_E_NOT_INITIALIZED;
 619     else if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 620     {
 621         if (manager->locking_handle && !block)
 622             hr = DXVA2_E_VIDEO_DEVICE_LOCKED;
 623         else
 624         {
 625             while (manager->locking_handle && block)
 626             {
 627                 SleepConditionVariableCS(&manager->lock, &manager->cs, INFINITE);
 628             }
 629
 630             if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 631             {
 632                 if (manager->handles[idx].flags & HANDLE_FLAG_INVALID)
 633                     hr = DXVA2_E_NEW_VIDEO_DEVICE;
 634                 else
 635                 {
 636                     if (manager->handles[idx].state_block)
 637                     {
 638                         if (FAILED(IDirect3DStateBlock9_Apply(manager->handles[idx].state_block)))
 639                             WARN("Failed to apply state.\n");
 640                         IDirect3DStateBlock9_Release(manager->handles[idx].state_block);
 641                         manager->handles[idx].state_block = NULL;
 642                     }
 643                     *device = manager->device;
 644                     IDirect3DDevice9_AddRef(*device);
 645                     manager->locking_handle = hdevice;
 646                 }
 647             }
 648         }
 649     }
 650     LeaveCriticalSection(&manager->cs);
 651
 652     return hr;
 653 }
 654
 655 static HRESULT WINAPI device_manager_UnlockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice, BOOL savestate)
 656 {
 657     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 658     HRESULT hr;
 659     size_t idx;
 660
 661     TRACE("%p, %p, %d.\n", iface, hdevice, savestate);
 662
 663     EnterCriticalSection(&manager->cs);
 664
 665     if (hdevice != manager->locking_handle)
 666         hr = E_INVALIDARG;
 667     else if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 668     {
 669         manager->locking_handle = NULL;
 670         if (savestate)
 671             IDirect3DDevice9_CreateStateBlock(manager->device, D3DSBT_ALL, &manager->handles[idx].state_block);
 672     }
 673
 674     LeaveCriticalSection(&manager->cs);
 675
 676     WakeAllConditionVariable(&manager->lock);
 677
 678     return hr;
 679 }
 680
 681 static HRESULT WINAPI device_manager_GetVideoService(IDirect3DDeviceManager9 *iface, HANDLE hdevice, REFIID riid,
 682         void **obj)
 683 {
 684     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 685     HRESULT hr;
 686     size_t idx;
 687
 688     TRACE("%p, %p, %s, %p.\n", iface, hdevice, debugstr_guid(riid), obj);
 689
 690     EnterCriticalSection(&manager->cs);
 691     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 692     {
 693         unsigned int flags = manager->handles[idx].flags;
 694
 695         if (flags & HANDLE_FLAG_INVALID)
 696             hr = DXVA2_E_NEW_VIDEO_DEVICE;
 697         else if (!(flags & HANDLE_FLAG_OPEN))
 698             hr = E_HANDLE;
 699         else
 700             hr = IDirectXVideoProcessorService_QueryInterface(&manager->IDirectXVideoProcessorService_iface,
 701                     riid, obj);
 702     }
 703     LeaveCriticalSection(&manager->cs);
 704
 705     return hr;
 706 }
 707
 708 static const IDirect3DDeviceManager9Vtbl device_manager_vtbl =
 709 {
 710     device_manager_QueryInterface,
 711     device_manager_AddRef,
 712     device_manager_Release,
 713     device_manager_ResetDevice,
 714     device_manager_OpenDeviceHandle,
 715     device_manager_CloseDeviceHandle,
 716     device_manager_TestDevice,
 717     device_manager_LockDevice,
 718     device_manager_UnlockDevice,
 719     device_manager_GetVideoService,
 720 };
 721
 722 BOOL WINAPI CapabilitiesRequestAndCapabilitiesReply( HMONITOR monitor, LPSTR buffer, DWORD length )
 723 {
 724     FIXME("(%p, %p, %d): stub\n", monitor, buffer, length);
 725
 726     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 727     return FALSE;
 728 }
 729
 730 HRESULT WINAPI DXVA2CreateDirect3DDeviceManager9(UINT *token, IDirect3DDeviceManager9 **manager)
 731 {
 732     struct device_manager *object;
 733
 734     TRACE("%p, %p.\n", token, manager);
 735
 736     *manager = NULL;
 737
 738     if (!(object = heap_alloc_zero(sizeof(*object))))
 739         return E_OUTOFMEMORY;
 740
 741     object->IDirect3DDeviceManager9_iface.lpVtbl = &device_manager_vtbl;
 742     object->IDirectXVideoProcessorService_iface.lpVtbl = &device_manager_processor_service_vtbl;
 743     object->refcount = 1;
 744     object->token = GetTickCount();
 745     InitializeCriticalSection(&object->cs);
 746     InitializeConditionVariable(&object->lock);
 747
 748     *token = object->token;
 749     *manager = &object->IDirect3DDeviceManager9_iface;
 750
 751     return S_OK;
 752 }
 753
 754 HRESULT WINAPI DXVA2CreateVideoService(IDirect3DDevice9 *device, REFIID riid, void **obj)
 755 {
 756     IDirect3DDeviceManager9 *manager;
 757     HANDLE handle;
 758     HRESULT hr;
 759     UINT token;
 760
 761     TRACE("%p, %s, %p.\n", device, debugstr_guid(riid), obj);
 762
 763     if (FAILED(hr = DXVA2CreateDirect3DDeviceManager9(&token, &manager)))
 764         return hr;
 765
 766     if (FAILED(hr = IDirect3DDeviceManager9_ResetDevice(manager, device, token)))
 767         goto done;
 768
 769     if (FAILED(hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle)))
 770         goto done;
 771
 772     hr = IDirect3DDeviceManager9_GetVideoService(manager, handle, riid, obj);
 773     IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle);
 774
 775 done:
 776     IDirect3DDeviceManager9_Release(manager);
 777
 778     return hr;
 779 }
 780
 781 BOOL WINAPI DegaussMonitor( HMONITOR monitor )
 782 {
 783     FIXME("(%p): stub\n", monitor);
 784
 785     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 786     return FALSE;
 787 }
 788
 789 BOOL WINAPI DestroyPhysicalMonitor( HMONITOR monitor )
 790 {
 791     FIXME("(%p): stub\n", monitor);
 792
 793     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 794     return FALSE;
 795 }
 796
 797 BOOL WINAPI DestroyPhysicalMonitors( DWORD arraySize, LPPHYSICAL_MONITOR array )
 798 {
 799     FIXME("(0x%x, %p): stub\n", arraySize, array);
 800
 801     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 802     return FALSE;
 803 }
 804
 805 BOOL WINAPI GetCapabilitiesStringLength( HMONITOR monitor, LPDWORD length )
 806 {
 807     FIXME("(%p, %p): stub\n", monitor, length);
 808
 809     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 810     return FALSE;
 811 }
 812
 813 BOOL WINAPI GetMonitorBrightness( HMONITOR monitor, LPDWORD minimum, LPDWORD current, LPDWORD maximum )
 814 {
 815     FIXME("(%p, %p, %p, %p): stub\n", monitor, minimum, current, maximum);
 816
 817     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 818     return FALSE;
 819 }
 820
 821 BOOL WINAPI GetMonitorCapabilities( HMONITOR monitor, LPDWORD capabilities, LPDWORD temperatures )
 822 {
 823     FIXME("(%p, %p, %p): stub\n", monitor, capabilities, temperatures);
 824
 825     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 826     return FALSE;
 827 }
 828
 829
 830 BOOL WINAPI GetMonitorColorTemperature( HMONITOR monitor, LPMC_COLOR_TEMPERATURE temperature )
 831 {
 832     FIXME("(%p, %p): stub\n", monitor, temperature);
 833
 834     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 835     return FALSE;
 836 }
 837
 838 BOOL WINAPI GetMonitorContrast( HMONITOR monitor, LPDWORD minimum, LPDWORD current, LPDWORD maximum )
 839 {
 840     FIXME("(%p, %p, %p, %p): stub\n", monitor, minimum, current, maximum);
 841
 842     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 843     return FALSE;
 844 }
 845
 846 BOOL WINAPI GetMonitorDisplayAreaPosition( HMONITOR monitor, MC_POSITION_TYPE type, LPDWORD minimum,
 847                                            LPDWORD current, LPDWORD maximum )
 848 {
 849     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
 850
 851     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 852     return FALSE;
 853 }
 854
 855 BOOL WINAPI GetMonitorDisplayAreaSize( HMONITOR monitor, MC_SIZE_TYPE type, LPDWORD minimum,
 856                                        LPDWORD current, LPDWORD maximum )
 857 {
 858     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
 859
 860     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 861     return FALSE;
 862 }
 863
 864 BOOL WINAPI GetMonitorRedGreenOrBlueDrive( HMONITOR monitor, MC_DRIVE_TYPE type, LPDWORD minimum,
 865                                            LPDWORD current, LPDWORD maximum )
 866 {
 867     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
 868
 869     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 870     return FALSE;
 871 }
 872
 873 BOOL WINAPI GetMonitorRedGreenOrBlueGain( HMONITOR monitor, MC_GAIN_TYPE type, LPDWORD minimum,
 874                                           LPDWORD current, LPDWORD maximum )
 875 {
 876     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
 877
 878     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 879     return FALSE;
 880 }
 881
 882 BOOL WINAPI GetMonitorTechnologyType( HMONITOR monitor, LPMC_DISPLAY_TECHNOLOGY_TYPE type )
 883 {
 884     FIXME("(%p, %p): stub\n", monitor, type);
 885
 886     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 887     return FALSE;
 888 }
 889
 890 BOOL WINAPI GetNumberOfPhysicalMonitorsFromHMONITOR( HMONITOR monitor, LPDWORD number )
 891 {
 892     FIXME("(%p, %p): stub\n", monitor, number);
 893
 894     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 895     return FALSE;
 896 }
 897
 898 HRESULT WINAPI GetNumberOfPhysicalMonitorsFromIDirect3DDevice9( IDirect3DDevice9 *device, LPDWORD number )
 899 {
 900     FIXME("(%p, %p): stub\n", device, number);
 901
 902     return E_NOTIMPL;
 903 }
 904
 905 BOOL WINAPI GetPhysicalMonitorsFromHMONITOR( HMONITOR monitor, DWORD arraySize, LPPHYSICAL_MONITOR array )
 906 {
 907     FIXME("(%p, 0x%x, %p): stub\n", monitor, arraySize, array);
 908
 909     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 910     return FALSE;
 911 }
 912
 913 HRESULT WINAPI GetPhysicalMonitorsFromIDirect3DDevice9( IDirect3DDevice9 *device, DWORD arraySize, LPPHYSICAL_MONITOR array )
 914 {
 915     FIXME("(%p, 0x%x, %p): stub\n", device, arraySize, array);
 916
 917     return E_NOTIMPL;
 918 }
 919
 920 BOOL WINAPI GetTimingReport( HMONITOR monitor, LPMC_TIMING_REPORT timingReport )
 921 {
 922     FIXME("(%p, %p): stub\n", monitor, timingReport);
 923
 924     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 925     return FALSE;
 926 }
 927
 928 BOOL WINAPI GetVCPFeatureAndVCPFeatureReply( HMONITOR monitor, BYTE vcpCode, LPMC_VCP_CODE_TYPE pvct,
 929                                              LPDWORD current, LPDWORD maximum )
 930 {
 931     FIXME("(%p, 0x%02x, %p, %p, %p): stub\n", monitor, vcpCode, pvct, current, maximum);
 932
 933     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 934     return FALSE;
 935 }
 936
 937 HRESULT WINAPI OPMGetVideoOutputsFromHMONITOR( HMONITOR monitor, /* OPM_VIDEO_OUTPUT_SEMANTICS */ int vos,
 938                                                ULONG *numVideoOutputs, /* IOPMVideoOutput */ void ***videoOutputs )
 939 {
 940     FIXME("(%p, 0x%x, %p, %p): stub\n", monitor, vos, numVideoOutputs, videoOutputs);
 941
 942     return E_NOTIMPL;
 943 }
 944
 945 HRESULT WINAPI OPMGetVideoOutputsFromIDirect3DDevice9Object( IDirect3DDevice9 *device, /* OPM_VIDEO_OUTPUT_SEMANTICS */ int vos,
 946                                                              ULONG *numVideoOutputs,  /* IOPMVideoOutput */ void ***videoOutputs )
 947 {
 948     FIXME("(%p, 0x%x, %p, %p): stub\n", device, vos, numVideoOutputs, videoOutputs);
 949
 950     return E_NOTIMPL;
 951 }
 952
 953 BOOL WINAPI RestoreMonitorFactoryColorDefaults( HMONITOR monitor )
 954 {
 955     FIXME("(%p): stub\n", monitor);
 956
 957     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 958     return FALSE;
 959 }
 960
 961 BOOL WINAPI RestoreMonitorFactoryDefaults( HMONITOR monitor )
 962 {
 963     FIXME("(%p): stub\n", monitor);
 964
 965     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 966     return FALSE;
 967 }
 968
 969 BOOL WINAPI SaveCurrentMonitorSettings( HMONITOR monitor )
 970 {
 971     FIXME("(%p): stub\n", monitor);
 972
 973     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 974     return FALSE;
 975 }
 976
 977 BOOL WINAPI SaveCurrentSettings( HMONITOR monitor )
 978 {
 979     FIXME("(%p): stub\n", monitor);
 980
 981     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 982     return FALSE;
 983 }
 984
 985 BOOL WINAPI SetMonitorBrightness( HMONITOR monitor, DWORD brightness )
 986 {
 987     FIXME("(%p, 0x%x): stub\n", monitor, brightness);
 988
 989     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 990     return FALSE;
 991 }
 992
 993 BOOL WINAPI SetMonitorColorTemperature( HMONITOR monitor, MC_COLOR_TEMPERATURE temperature )
 994 {
 995     FIXME("(%p, 0x%x): stub\n", monitor, temperature);
 996
 997     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 998     return FALSE;
 999 }
1000
1001 BOOL WINAPI SetMonitorContrast( HMONITOR monitor, DWORD contrast )
1002 {
1003     FIXME("(%p, 0x%x): stub\n", monitor, contrast);
1004
1005     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1006     return FALSE;
1007 }
1008
1009 BOOL WINAPI SetMonitorDisplayAreaPosition( HMONITOR monitor, MC_POSITION_TYPE type, DWORD position )
1010 {
1011     FIXME("(%p, 0x%x, 0x%x): stub\n", monitor, type, position);
1012
1013     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1014     return FALSE;
1015 }
1016
1017 BOOL WINAPI SetMonitorDisplayAreaSize( HMONITOR monitor, MC_SIZE_TYPE type, DWORD size )
1018 {
1019     FIXME("(%p, 0x%x, 0x%x): stub\n", monitor, type, size);
1020
1021     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1022     return FALSE;
1023 }
1024
1025 BOOL WINAPI SetMonitorRedGreenOrBlueDrive( HMONITOR monitor, MC_DRIVE_TYPE type, DWORD drive )
1026 {
1027     FIXME("(%p, 0x%x, 0x%x): stub\n", monitor, type, drive);
1028
1029     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1030     return FALSE;
1031 }
1032
1033 BOOL WINAPI SetMonitorRedGreenOrBlueGain( HMONITOR monitor, MC_GAIN_TYPE type, DWORD gain )
1034 {
1035     FIXME("(%p, 0x%x, 0x%x): stub\n", monitor, type, gain);
1036
1037     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1038     return FALSE;
1039 }
1040
1041 BOOL WINAPI SetVCPFeature( HMONITOR monitor, BYTE vcpCode, DWORD value )
1042 {
1043     FIXME("(%p, 0x%02x, 0x%x): stub\n", monitor, vcpCode, value);
1044
1045     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1046     return FALSE;
1047 }
1048
1049 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1050 {
1051     TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
1052
1053     switch (fdwReason) {
1054         case DLL_WINE_PREATTACH:
1055             return FALSE;  /* prefer native version */
1056         case DLL_PROCESS_ATTACH:
1057             DisableThreadLibraryCalls(hinstDLL);
1058             break;
1059     }
1060
1061     return TRUE;
1062 }