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
  34 WINE_DEFAULT_DEBUG_CHANNEL(dxva2);
  35
  36 #define D3DFMT_NV12 MAKEFOURCC('N','V','1','2')
  37
  38 enum device_handle_flags
  39 {
  40     HANDLE_FLAG_OPEN = 0x1,
  41     HANDLE_FLAG_INVALID = 0x2,
  42 };
  43
  44 struct device_handle
  45 {
  46     unsigned int flags;
  47     IDirect3DStateBlock9 *state_block;
  48 };
  49
  50 struct device_manager
  51 {
  52     IDirect3DDeviceManager9 IDirect3DDeviceManager9_iface;
  53     IDirectXVideoProcessorService IDirectXVideoProcessorService_iface;
  54     IDirectXVideoDecoderService IDirectXVideoDecoderService_iface;
  55     LONG refcount;
  56
  57     IDirect3DDevice9 *device;
  58     UINT token;
  59
  60     struct device_handle *handles;
  61     size_t count;
  62     size_t capacity;
  63
  64     HANDLE locking_handle;
  65
  66     CRITICAL_SECTION cs;
  67     CONDITION_VARIABLE lock;
  68 };
  69
  70 struct video_processor
  71 {
  72     IDirectXVideoProcessor IDirectXVideoProcessor_iface;
  73     LONG refcount;
  74
  75     IDirectXVideoProcessorService *service;
  76     GUID device;
  77     DXVA2_VideoDesc video_desc;
  78     D3DFORMAT rt_format;
  79     unsigned int max_substreams;
  80 };
  81
  82 static BOOL dxva_array_reserve(void **elements, size_t *capacity, size_t count, size_t size)
  83 {
  84     size_t new_capacity, max_capacity;
  85     void *new_elements;
  86
  87     if (count <= *capacity)
  88         return TRUE;
  89
  90     max_capacity = ~(SIZE_T)0 / size;
  91     if (count > max_capacity)
  92         return FALSE;
  93
  94     new_capacity = max(4, *capacity);
  95     while (new_capacity < count && new_capacity <= max_capacity / 2)
  96         new_capacity *= 2;
  97     if (new_capacity < count)
  98         new_capacity = max_capacity;
  99
 100     if (!(new_elements = realloc(*elements, new_capacity * size)))
 101         return FALSE;
 102
 103     *elements = new_elements;
 104     *capacity = new_capacity;
 105
 106     return TRUE;
 107 }
 108
 109 static struct device_manager *impl_from_IDirect3DDeviceManager9(IDirect3DDeviceManager9 *iface)
 110 {
 111     return CONTAINING_RECORD(iface, struct device_manager, IDirect3DDeviceManager9_iface);
 112 }
 113
 114 static struct device_manager *impl_from_IDirectXVideoProcessorService(IDirectXVideoProcessorService *iface)
 115 {
 116     return CONTAINING_RECORD(iface, struct device_manager, IDirectXVideoProcessorService_iface);
 117 }
 118
 119 static struct device_manager *impl_from_IDirectXVideoDecoderService(IDirectXVideoDecoderService *iface)
 120 {
 121     return CONTAINING_RECORD(iface, struct device_manager, IDirectXVideoDecoderService_iface);
 122 }
 123
 124 static struct video_processor *impl_from_IDirectXVideoProcessor(IDirectXVideoProcessor *iface)
 125 {
 126     return CONTAINING_RECORD(iface, struct video_processor, IDirectXVideoProcessor_iface);
 127 }
 128
 129 static const DXVA2_VideoProcessorCaps software_processor_caps =
 130 {
 131     .DeviceCaps = DXVA2_VPDev_SoftwareDevice,
 132     .InputPool = D3DPOOL_SYSTEMMEM,
 133     .VideoProcessorOperations = DXVA2_VideoProcess_PlanarAlpha | DXVA2_VideoProcess_YUV2RGB |
 134             DXVA2_VideoProcess_StretchX | DXVA2_VideoProcess_StretchY | DXVA2_VideoProcess_SubRects |
 135             DXVA2_VideoProcess_SubStreams | DXVA2_VideoProcess_SubStreamsExtended | DXVA2_VideoProcess_YUV2RGBExtended,
 136 };
 137
 138 static const DXVA2_VideoProcessorCaps progressive_processor_caps =
 139 {
 140     .DeviceCaps = DXVA2_VPDev_HardwareDevice,
 141     .InputPool = D3DPOOL_DEFAULT,
 142     .VideoProcessorOperations = DXVA2_VideoProcess_YUV2RGB | DXVA2_VideoProcess_StretchX | DXVA2_VideoProcess_StretchY,
 143 };
 144
 145 static HRESULT WINAPI video_processor_QueryInterface(IDirectXVideoProcessor *iface, REFIID riid, void **obj)
 146 {
 147     if (IsEqualIID(riid, &IID_IDirectXVideoProcessor) ||
 148             IsEqualIID(riid, &IID_IUnknown))
 149     {
 150         *obj = iface;
 151         IDirectXVideoProcessor_AddRef(iface);
 152         return S_OK;
 153     }
 154
 155     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 156     *obj = NULL;
 157     return E_NOINTERFACE;
 158 }
 159
 160 static ULONG WINAPI video_processor_AddRef(IDirectXVideoProcessor *iface)
 161 {
 162     struct video_processor *processor = impl_from_IDirectXVideoProcessor(iface);
 163     ULONG refcount = InterlockedIncrement(&processor->refcount);
 164
 165     TRACE("%p, refcount %lu.\n", iface, refcount);
 166
 167     return refcount;
 168 }
 169
 170 static ULONG WINAPI video_processor_Release(IDirectXVideoProcessor *iface)
 171 {
 172     struct video_processor *processor = impl_from_IDirectXVideoProcessor(iface);
 173     ULONG refcount = InterlockedDecrement(&processor->refcount);
 174
 175     TRACE("%p, refcount %lu.\n", iface, refcount);
 176
 177     if (!refcount)
 178     {
 179         IDirectXVideoProcessorService_Release(processor->service);
 180         free(processor);
 181     }
 182
 183     return refcount;
 184 }
 185
 186 static HRESULT WINAPI video_processor_GetVideoProcessorService(IDirectXVideoProcessor *iface,
 187         IDirectXVideoProcessorService **service)
 188 {
 189     struct video_processor *processor = impl_from_IDirectXVideoProcessor(iface);
 190
 191     TRACE("%p, %p.\n", iface, service);
 192
 193     *service = processor->service;
 194     IDirectXVideoProcessorService_AddRef(*service);
 195
 196     return S_OK;
 197 }
 198
 199 static HRESULT WINAPI video_processor_GetCreationParameters(IDirectXVideoProcessor *iface,
 200         GUID *device, DXVA2_VideoDesc *video_desc, D3DFORMAT *rt_format, UINT *max_substreams)
 201 {
 202     struct video_processor *processor = impl_from_IDirectXVideoProcessor(iface);
 203
 204     TRACE("%p, %p, %p, %p, %p.\n", iface, device, video_desc, rt_format, max_substreams);
 205
 206     if (!device && !video_desc && !rt_format && !max_substreams)
 207         return E_INVALIDARG;
 208
 209     if (device)
 210         *device = processor->device;
 211     if (video_desc)
 212         *video_desc = processor->video_desc;
 213     if (rt_format)
 214         *rt_format = processor->rt_format;
 215     if (max_substreams)
 216         *max_substreams = processor->max_substreams;
 217
 218     return S_OK;
 219 }
 220
 221 static HRESULT WINAPI video_processor_GetVideoProcessorCaps(IDirectXVideoProcessor *iface,
 222         DXVA2_VideoProcessorCaps *caps)
 223 {
 224     struct video_processor *processor = impl_from_IDirectXVideoProcessor(iface);
 225
 226     TRACE("%p, %p.\n", iface, caps);
 227
 228     if (IsEqualGUID(&processor->device, &DXVA2_VideoProcSoftwareDevice))
 229     {
 230         *caps = software_processor_caps;
 231     }
 232     else if (IsEqualGUID(&processor->device, &DXVA2_VideoProcProgressiveDevice))
 233     {
 234         *caps = progressive_processor_caps;
 235     }
 236     else
 237     {
 238         FIXME("Unsupported device %s.\n", debugstr_guid(&processor->device));
 239         return E_FAIL;
 240     }
 241
 242     return S_OK;
 243 }
 244
 245 static HRESULT WINAPI video_processor_GetProcAmpRange(IDirectXVideoProcessor *iface, UINT cap, DXVA2_ValueRange *range)
 246 {
 247     FIXME("%p, %u, %p.\n", iface, cap, range);
 248
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI video_processor_GetFilterPropertyRange(IDirectXVideoProcessor *iface, UINT setting,
 253         DXVA2_ValueRange *range)
 254 {
 255     FIXME("%p, %u, %p.\n", iface, setting, range);
 256
 257     return E_NOTIMPL;
 258 }
 259
 260 static BOOL intersect_rect(RECT *dest, const RECT *src1, const RECT *src2)
 261 {
 262     if (IsRectEmpty(src1) || IsRectEmpty(src2) ||
 263         (src1->left >= src2->right) || (src2->left >= src1->right) ||
 264         (src1->top >= src2->bottom) || (src2->top >= src1->bottom))
 265     {
 266         SetRectEmpty(dest);
 267         return FALSE;
 268     }
 269     dest->left   = max(src1->left, src2->left);
 270     dest->right  = min(src1->right, src2->right);
 271     dest->top    = max(src1->top, src2->top);
 272     dest->bottom = min(src1->bottom, src2->bottom);
 273
 274     return TRUE;
 275 }
 276
 277 static D3DCOLOR video_processor_get_background_color(const DXVA2_AYUVSample16 *ayuv)
 278 {
 279     float y, cb, cr;
 280     BYTE r, g, b;
 281
 282     y = (ayuv->Y >> 8) - 16;
 283     cb = (ayuv->Cb >> 8) - 128;
 284     cr = (ayuv->Cr >> 8) - 128;
 285
 286     y = 255.0f * y / 219.0f;
 287     cb = 255.0f * cb / 224.0f;
 288     cr = 255.0f * cr / 224.0f;
 289
 290     r = y + 1.402 * cr;
 291     g = y - 0.344 * cb - 0.714 * cr;
 292     b = y + 1.772 * cb;
 293
 294     return D3DCOLOR_XRGB(r, g, b);
 295 }
 296
 297 static HRESULT WINAPI video_processor_VideoProcessBlt(IDirectXVideoProcessor *iface, IDirect3DSurface9 *rt,
 298         const DXVA2_VideoProcessBltParams *params, const DXVA2_VideoSample *samples, UINT sample_count,
 299         HANDLE *complete_handle)
 300 {
 301     IDirect3DDevice9 *device;
 302     unsigned int i;
 303     RECT dst_rect;
 304     HRESULT hr;
 305
 306     TRACE("%p, %p, %p, %p, %u, %p.\n", iface, rt, params, samples, sample_count, complete_handle);
 307
 308     if (params->BackgroundColor.Alpha != 0xffff)
 309     {
 310         WARN("Unexpected background alpha %#x.\n", params->BackgroundColor.Alpha);
 311         return E_INVALIDARG;
 312     }
 313
 314     if (FAILED(hr = IDirect3DSurface9_GetDevice(rt, &device)))
 315     {
 316         WARN("Failed to get surface device, hr %#lx.\n", hr);
 317         return hr;
 318     }
 319
 320     IDirect3DDevice9_ColorFill(device, rt, &params->TargetRect, video_processor_get_background_color(&params->BackgroundColor));
 321
 322     for (i = 0; i < sample_count; ++i)
 323     {
 324         dst_rect = params->TargetRect;
 325
 326         if (!intersect_rect(&dst_rect, &dst_rect, &samples[i].DstRect))
 327             continue;
 328
 329         if (FAILED(hr = IDirect3DDevice9_StretchRect(device, samples[i].SrcSurface, &samples[i].SrcRect,
 330                 rt, &dst_rect, D3DTEXF_POINT)))
 331         {
 332             WARN("Failed to copy sample %u, hr %#lx.\n", i, hr);
 333         }
 334     }
 335
 336     IDirect3DDevice9_Release(device);
 337
 338     return S_OK;
 339 }
 340
 341 static const IDirectXVideoProcessorVtbl video_processor_vtbl =
 342 {
 343     video_processor_QueryInterface,
 344     video_processor_AddRef,
 345     video_processor_Release,
 346     video_processor_GetVideoProcessorService,
 347     video_processor_GetCreationParameters,
 348     video_processor_GetVideoProcessorCaps,
 349     video_processor_GetProcAmpRange,
 350     video_processor_GetFilterPropertyRange,
 351     video_processor_VideoProcessBlt,
 352 };
 353
 354 static HRESULT WINAPI device_manager_processor_service_QueryInterface(IDirectXVideoProcessorService *iface,
 355         REFIID riid, void **obj)
 356 {
 357     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 358
 359     if (IsEqualIID(riid, &IID_IDirectXVideoProcessorService) ||
 360             IsEqualIID(riid, &IID_IDirectXVideoAccelerationService) ||
 361             IsEqualIID(riid, &IID_IUnknown))
 362     {
 363         *obj = iface;
 364     }
 365     else if (IsEqualIID(riid, &IID_IDirectXVideoDecoderService))
 366     {
 367         *obj = &manager->IDirectXVideoDecoderService_iface;
 368     }
 369     else
 370     {
 371         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 372         *obj = NULL;
 373         return E_NOINTERFACE;
 374     }
 375
 376     IUnknown_AddRef((IUnknown *)*obj);
 377     return S_OK;
 378 }
 379
 380 static ULONG WINAPI device_manager_processor_service_AddRef(IDirectXVideoProcessorService *iface)
 381 {
 382     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 383     return IDirect3DDeviceManager9_AddRef(&manager->IDirect3DDeviceManager9_iface);
 384 }
 385
 386 static ULONG WINAPI device_manager_processor_service_Release(IDirectXVideoProcessorService *iface)
 387 {
 388     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 389     return IDirect3DDeviceManager9_Release(&manager->IDirect3DDeviceManager9_iface);
 390 }
 391
 392 static HRESULT WINAPI device_manager_processor_service_CreateSurface(IDirectXVideoProcessorService *iface,
 393         UINT width, UINT height, UINT backbuffers, D3DFORMAT format, D3DPOOL pool, DWORD usage, DWORD dxvaType,
 394         IDirect3DSurface9 **surfaces, HANDLE *shared_handle)
 395 {
 396     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 397     unsigned int i, j;
 398     HRESULT hr;
 399
 400     TRACE("%p, %u, %u, %u, %u, %u, %lu, %lu, %p, %p.\n", iface, width, height, backbuffers, format, pool, usage, dxvaType,
 401             surfaces, shared_handle);
 402
 403     if (backbuffers >= UINT_MAX)
 404         return E_INVALIDARG;
 405
 406     memset(surfaces, 0, (backbuffers + 1) * sizeof(*surfaces));
 407
 408     for (i = 0; i < backbuffers + 1; ++i)
 409     {
 410         if (FAILED(hr = IDirect3DDevice9_CreateOffscreenPlainSurface(manager->device, width, height, format,
 411                 pool, &surfaces[i], NULL)))
 412             break;
 413     }
 414
 415     if (FAILED(hr))
 416     {
 417         for (j = 0; j < i; ++j)
 418         {
 419             if (surfaces[j])
 420             {
 421                 IDirect3DSurface9_Release(surfaces[j]);
 422                 surfaces[j] = NULL;
 423             }
 424         }
 425     }
 426
 427     return hr;
 428 }
 429
 430 static HRESULT WINAPI device_manager_processor_service_RegisterVideoProcessorSoftwareDevice(
 431         IDirectXVideoProcessorService *iface, void *callbacks)
 432 {
 433     FIXME("%p, %p.\n", iface, callbacks);
 434
 435     return E_NOTIMPL;
 436 }
 437
 438 struct dxva_processor_device_desc
 439 {
 440     const GUID *guid;
 441     const D3DFORMAT *input_formats;
 442 };
 443
 444 static const D3DFORMAT software_processor_input_formats[] =
 445 {
 446     D3DFMT_A8R8G8B8, D3DFMT_X8R8G8B8, D3DFMT_YUY2, 0
 447 };
 448
 449 static const D3DFORMAT progressive_processor_input_formats[] =
 450 {
 451     D3DFMT_A8R8G8B8, D3DFMT_X8R8G8B8, D3DFMT_YUY2, D3DFMT_NV12, 0
 452 };
 453
 454 static const struct dxva_processor_device_desc processor_devices[] =
 455 {
 456     { &DXVA2_VideoProcProgressiveDevice, progressive_processor_input_formats },
 457     { &DXVA2_VideoProcSoftwareDevice, software_processor_input_formats },
 458 };
 459
 460 static BOOL dxva_is_supported_stream_format(const DXVA2_VideoDesc *video_desc, const D3DFORMAT *formats)
 461 {
 462     while (*formats)
 463     {
 464         if (*formats == video_desc->Format) return TRUE;
 465         formats++;
 466     }
 467
 468     return FALSE;
 469 }
 470
 471 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorDeviceGuids(
 472         IDirectXVideoProcessorService *iface, const DXVA2_VideoDesc *video_desc, UINT *count, GUID **guids)
 473 {
 474     unsigned int i;
 475
 476     FIXME("%p, %p, %p, %p semi-stub.\n", iface, video_desc, count, guids);
 477
 478     *count = 0;
 479
 480     if (!(*guids = CoTaskMemAlloc(ARRAY_SIZE(processor_devices) * sizeof(**guids))))
 481         return E_OUTOFMEMORY;
 482
 483     for (i = 0; i < ARRAY_SIZE(processor_devices); ++i)
 484     {
 485         if (dxva_is_supported_stream_format(video_desc, processor_devices[i].input_formats))
 486         {
 487             (*guids)[*count] = *processor_devices[i].guid;
 488             *count += 1;
 489         }
 490     }
 491
 492     if (!*count)
 493     {
 494         CoTaskMemFree(*guids);
 495         *guids = NULL;
 496         return E_FAIL;
 497     }
 498
 499     return S_OK;
 500 }
 501
 502 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorRenderTargets(
 503         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc, UINT *count,
 504         D3DFORMAT **formats)
 505 {
 506     TRACE("%p, %s, %p, %p, %p.\n", iface, debugstr_guid(deviceguid), video_desc, count, formats);
 507
 508     if (IsEqualGUID(deviceguid, &DXVA2_VideoProcSoftwareDevice))
 509     {
 510         if (!dxva_is_supported_stream_format(video_desc, software_processor_input_formats))
 511         {
 512             WARN("Unsupported content format %#x.\n", video_desc->Format);
 513             return E_FAIL;
 514         }
 515
 516         if (!(*formats = CoTaskMemAlloc(2 * sizeof(**formats))))
 517             return E_OUTOFMEMORY;
 518
 519         *count = 2;
 520         (*formats)[0] = D3DFMT_X8R8G8B8;
 521         (*formats)[1] = D3DFMT_A8R8G8B8;
 522
 523         return S_OK;
 524     }
 525     else if (IsEqualGUID(deviceguid, &DXVA2_VideoProcProgressiveDevice))
 526     {
 527         if (!dxva_is_supported_stream_format(video_desc, progressive_processor_input_formats))
 528         {
 529             WARN("Unsupported content format %#x.\n", video_desc->Format);
 530             return E_FAIL;
 531         }
 532
 533         if (!(*formats = CoTaskMemAlloc(2 * sizeof(**formats))))
 534             return E_OUTOFMEMORY;
 535
 536         *count = 2;
 537         (*formats)[0] = D3DFMT_X8R8G8B8;
 538         (*formats)[1] = D3DFMT_NV12;
 539
 540         return S_OK;
 541     }
 542     else
 543         FIXME("Unsupported device %s.\n", debugstr_guid(deviceguid));
 544
 545     return E_NOTIMPL;
 546 }
 547
 548 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorSubStreamFormats(
 549         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 550         D3DFORMAT rt_format, UINT *count, D3DFORMAT **formats)
 551 {
 552     FIXME("%p, %s, %p, %u, %p, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, count, formats);
 553
 554     return E_NOTIMPL;
 555 }
 556
 557 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorCaps(
 558         IDirectXVideoProcessorService *iface, REFGUID device, const DXVA2_VideoDesc *video_desc,
 559         D3DFORMAT rt_format, DXVA2_VideoProcessorCaps *caps)
 560 {
 561     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(device), video_desc, rt_format, caps);
 562
 563     if (IsEqualGUID(device, &DXVA2_VideoProcSoftwareDevice))
 564     {
 565         *caps = software_processor_caps;
 566     }
 567     else if (IsEqualGUID(device, &DXVA2_VideoProcProgressiveDevice))
 568     {
 569         *caps = progressive_processor_caps;
 570     }
 571     else
 572     {
 573         FIXME("Unrecognized device %s.\n", debugstr_guid(device));
 574         return E_NOTIMPL;
 575     }
 576
 577     return S_OK;
 578 }
 579
 580 static HRESULT WINAPI device_manager_processor_service_GetProcAmpRange(
 581         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 582         D3DFORMAT rt_format, UINT ProcAmpCap, DXVA2_ValueRange *range)
 583 {
 584     FIXME("%p, %s, %p, %u, %u, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, ProcAmpCap, range);
 585
 586     return E_NOTIMPL;
 587 }
 588
 589 static HRESULT WINAPI device_manager_processor_service_GetFilterPropertyRange(
 590         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 591         D3DFORMAT rt_format, UINT filter_setting, DXVA2_ValueRange *range)
 592 {
 593     FIXME("%p, %s, %p, %d, %d, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, filter_setting, range);
 594
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI device_manager_processor_service_CreateVideoProcessor(IDirectXVideoProcessorService *iface,
 599         REFGUID device, const DXVA2_VideoDesc *video_desc, D3DFORMAT rt_format, UINT max_substreams,
 600         IDirectXVideoProcessor **processor)
 601 {
 602     struct video_processor *object;
 603
 604     FIXME("%p, %s, %p, %d, %u, %p.\n", iface, debugstr_guid(device), video_desc, rt_format, max_substreams,
 605             processor);
 606
 607     /* FIXME: validate render target format */
 608
 609     if (max_substreams >= 16)
 610     {
 611         WARN("Invalid substreams count %u.\n", max_substreams);
 612         return E_INVALIDARG;
 613     }
 614
 615     if (!(object = calloc(1, sizeof(*object))))
 616         return E_OUTOFMEMORY;
 617
 618     object->IDirectXVideoProcessor_iface.lpVtbl = &video_processor_vtbl;
 619     object->refcount = 1;
 620     object->service = iface;
 621     IDirectXVideoProcessorService_AddRef(object->service);
 622     object->device = *device;
 623     object->video_desc = *video_desc;
 624     object->rt_format = rt_format;
 625     object->max_substreams = max_substreams;
 626
 627     *processor = &object->IDirectXVideoProcessor_iface;
 628
 629     return S_OK;
 630 }
 631
 632 static const IDirectXVideoProcessorServiceVtbl device_manager_processor_service_vtbl =
 633 {
 634     device_manager_processor_service_QueryInterface,
 635     device_manager_processor_service_AddRef,
 636     device_manager_processor_service_Release,
 637     device_manager_processor_service_CreateSurface,
 638     device_manager_processor_service_RegisterVideoProcessorSoftwareDevice,
 639     device_manager_processor_service_GetVideoProcessorDeviceGuids,
 640     device_manager_processor_service_GetVideoProcessorRenderTargets,
 641     device_manager_processor_service_GetVideoProcessorSubStreamFormats,
 642     device_manager_processor_service_GetVideoProcessorCaps,
 643     device_manager_processor_service_GetProcAmpRange,
 644     device_manager_processor_service_GetFilterPropertyRange,
 645     device_manager_processor_service_CreateVideoProcessor,
 646 };
 647
 648 static HRESULT WINAPI device_manager_decoder_service_QueryInterface(IDirectXVideoDecoderService *iface,
 649         REFIID riid, void **obj)
 650 {
 651     if (IsEqualIID(riid, &IID_IDirectXVideoDecoderService) ||
 652             IsEqualIID(riid, &IID_IDirectXVideoAccelerationService) ||
 653             IsEqualIID(riid, &IID_IUnknown))
 654     {
 655         *obj = iface;
 656         IDirectXVideoDecoderService_AddRef(iface);
 657         return S_OK;
 658     }
 659
 660     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 661     *obj = NULL;
 662     return E_NOINTERFACE;
 663 }
 664
 665 static ULONG WINAPI device_manager_decoder_service_AddRef(IDirectXVideoDecoderService *iface)
 666 {
 667     struct device_manager *manager = impl_from_IDirectXVideoDecoderService(iface);
 668     return IDirect3DDeviceManager9_AddRef(&manager->IDirect3DDeviceManager9_iface);
 669 }
 670
 671 static ULONG WINAPI device_manager_decoder_service_Release(IDirectXVideoDecoderService *iface)
 672 {
 673     struct device_manager *manager = impl_from_IDirectXVideoDecoderService(iface);
 674     return IDirect3DDeviceManager9_Release(&manager->IDirect3DDeviceManager9_iface);
 675 }
 676
 677 static HRESULT WINAPI device_manager_decoder_service_CreateSurface(IDirectXVideoDecoderService *iface,
 678         UINT width, UINT height, UINT backbuffers, D3DFORMAT format, D3DPOOL pool, DWORD usage, DWORD dxvaType,
 679         IDirect3DSurface9 **surfaces, HANDLE *shared_handle)
 680 {
 681     FIXME("%p, %u, %u, %u, %#x, %d, %ld, %ld, %p, %p.\n", iface, width, height, backbuffers, format, pool, usage,
 682             dxvaType, surfaces, shared_handle);
 683
 684     return E_NOTIMPL;
 685 }
 686
 687 static HRESULT WINAPI device_manager_decoder_service_GetDecoderDeviceGuids(IDirectXVideoDecoderService *iface,
 688         UINT *count, GUID **guids)
 689 {
 690     FIXME("%p, %p, %p.\n", iface, count, guids);
 691
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI device_manager_decoder_service_GetDecoderRenderTargets(IDirectXVideoDecoderService *iface,
 696         REFGUID guid, UINT *count, D3DFORMAT **formats)
 697 {
 698     FIXME("%p, %s, %p, %p.\n", iface, debugstr_guid(guid), count, formats);
 699
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI device_manager_decoder_service_GetDecoderConfigurations(IDirectXVideoDecoderService *iface,
 704         REFGUID guid, const DXVA2_VideoDesc *video_desc, IUnknown *reserved, UINT *count, DXVA2_ConfigPictureDecode **configs)
 705 {
 706     FIXME("%p, %s, %p, %p, %p, %p.\n", iface, debugstr_guid(guid), video_desc, reserved, count, configs);
 707
 708     return E_NOTIMPL;
 709 }
 710
 711 static HRESULT WINAPI device_manager_decoder_service_CreateVideoDecoder(IDirectXVideoDecoderService *iface,
 712         REFGUID guid, const DXVA2_VideoDesc *video_desc, DXVA2_ConfigPictureDecode *config, IDirect3DSurface9 **rts,
 713         UINT num_surfaces, IDirectXVideoDecoder **decoder)
 714 {
 715     FIXME("%p, %s, %p, %p, %p, %u, %p.\n", iface, debugstr_guid(guid), video_desc, config, rts, num_surfaces,
 716             decoder);
 717
 718     return E_NOTIMPL;
 719 }
 720
 721 static const IDirectXVideoDecoderServiceVtbl device_manager_decoder_service_vtbl =
 722 {
 723     device_manager_decoder_service_QueryInterface,
 724     device_manager_decoder_service_AddRef,
 725     device_manager_decoder_service_Release,
 726     device_manager_decoder_service_CreateSurface,
 727     device_manager_decoder_service_GetDecoderDeviceGuids,
 728     device_manager_decoder_service_GetDecoderRenderTargets,
 729     device_manager_decoder_service_GetDecoderConfigurations,
 730     device_manager_decoder_service_CreateVideoDecoder,
 731 };
 732
 733 static HRESULT WINAPI device_manager_QueryInterface(IDirect3DDeviceManager9 *iface, REFIID riid, void **obj)
 734 {
 735     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 736
 737     if (IsEqualIID(&IID_IDirect3DDeviceManager9, riid) ||
 738             IsEqualIID(&IID_IUnknown, riid))
 739     {
 740         *obj = iface;
 741         IDirect3DDeviceManager9_AddRef(iface);
 742         return S_OK;
 743     }
 744
 745     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 746     *obj = NULL;
 747     return E_NOINTERFACE;
 748 }
 749
 750 static ULONG WINAPI device_manager_AddRef(IDirect3DDeviceManager9 *iface)
 751 {
 752     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 753     ULONG refcount = InterlockedIncrement(&manager->refcount);
 754
 755     TRACE("%p, refcount %lu.\n", iface, refcount);
 756
 757     return refcount;
 758 }
 759
 760 static ULONG WINAPI device_manager_Release(IDirect3DDeviceManager9 *iface)
 761 {
 762     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 763     ULONG refcount = InterlockedDecrement(&manager->refcount);
 764     size_t i;
 765
 766     TRACE("%p, refcount %lu.\n", iface, refcount);
 767
 768     if (!refcount)
 769     {
 770         if (manager->device)
 771             IDirect3DDevice9_Release(manager->device);
 772         DeleteCriticalSection(&manager->cs);
 773         for (i = 0; i < manager->count; ++i)
 774         {
 775             if (manager->handles[i].state_block)
 776                 IDirect3DStateBlock9_Release(manager->handles[i].state_block);
 777         }
 778         free(manager->handles);
 779         free(manager);
 780     }
 781
 782     return refcount;
 783 }
 784
 785 static HRESULT WINAPI device_manager_ResetDevice(IDirect3DDeviceManager9 *iface, IDirect3DDevice9 *device,
 786         UINT token)
 787 {
 788     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 789     size_t i;
 790
 791     TRACE("%p, %p, %#x.\n", iface, device, token);
 792
 793     if (token != manager->token)
 794         return E_INVALIDARG;
 795
 796     EnterCriticalSection(&manager->cs);
 797     if (manager->device)
 798     {
 799         for (i = 0; i < manager->count; ++i)
 800         {
 801             if (manager->handles[i].state_block)
 802                 IDirect3DStateBlock9_Release(manager->handles[i].state_block);
 803             manager->handles[i].state_block = NULL;
 804             manager->handles[i].flags |= HANDLE_FLAG_INVALID;
 805         }
 806         manager->locking_handle = NULL;
 807         IDirect3DDevice9_Release(manager->device);
 808     }
 809     manager->device = device;
 810     IDirect3DDevice9_AddRef(manager->device);
 811     LeaveCriticalSection(&manager->cs);
 812
 813     WakeAllConditionVariable(&manager->lock);
 814
 815     return S_OK;
 816 }
 817
 818 static HRESULT WINAPI device_manager_OpenDeviceHandle(IDirect3DDeviceManager9 *iface, HANDLE *hdevice)
 819 {
 820     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 821     HRESULT hr = S_OK;
 822     size_t i;
 823
 824     TRACE("%p, %p.\n", iface, hdevice);
 825
 826     *hdevice = NULL;
 827
 828     EnterCriticalSection(&manager->cs);
 829     if (!manager->device)
 830         hr = DXVA2_E_NOT_INITIALIZED;
 831     else
 832     {
 833         for (i = 0; i < manager->count; ++i)
 834         {
 835             if (!(manager->handles[i].flags & HANDLE_FLAG_OPEN))
 836             {
 837                 manager->handles[i].flags |= HANDLE_FLAG_OPEN;
 838                 *hdevice = ULongToHandle(i + 1);
 839                 break;
 840             }
 841         }
 842
 843         if (dxva_array_reserve((void **)&manager->handles, &manager->capacity, manager->count + 1,
 844                 sizeof(*manager->handles)))
 845         {
 846             *hdevice = ULongToHandle(manager->count + 1);
 847             manager->handles[manager->count].flags = HANDLE_FLAG_OPEN;
 848             manager->handles[manager->count].state_block = NULL;
 849             manager->count++;
 850         }
 851         else
 852             hr = E_OUTOFMEMORY;
 853     }
 854     LeaveCriticalSection(&manager->cs);
 855
 856     return hr;
 857 }
 858
 859 static HRESULT device_manager_get_handle_index(struct device_manager *manager, HANDLE hdevice, size_t *idx)
 860 {
 861     if (!hdevice || hdevice > ULongToHandle(manager->count))
 862         return E_HANDLE;
 863     *idx = (ULONG_PTR)hdevice - 1;
 864     return S_OK;
 865 }
 866
 867 static HRESULT WINAPI device_manager_CloseDeviceHandle(IDirect3DDeviceManager9 *iface, HANDLE hdevice)
 868 {
 869     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 870     HRESULT hr;
 871     size_t idx;
 872
 873     TRACE("%p, %p.\n", iface, hdevice);
 874
 875     EnterCriticalSection(&manager->cs);
 876     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 877     {
 878         if (manager->handles[idx].flags & HANDLE_FLAG_OPEN)
 879         {
 880             if (manager->locking_handle == hdevice)
 881                 manager->locking_handle = NULL;
 882             manager->handles[idx].flags = 0;
 883             if (idx == manager->count - 1)
 884                 manager->count--;
 885             if (manager->handles[idx].state_block)
 886                 IDirect3DStateBlock9_Release(manager->handles[idx].state_block);
 887             manager->handles[idx].state_block = NULL;
 888         }
 889         else
 890             hr = E_HANDLE;
 891     }
 892     LeaveCriticalSection(&manager->cs);
 893
 894     WakeAllConditionVariable(&manager->lock);
 895
 896     return hr;
 897 }
 898
 899 static HRESULT WINAPI device_manager_TestDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice)
 900 {
 901     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 902     HRESULT hr;
 903     size_t idx;
 904
 905     TRACE("%p, %p.\n", iface, hdevice);
 906
 907     EnterCriticalSection(&manager->cs);
 908     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 909     {
 910         unsigned int flags = manager->handles[idx].flags;
 911
 912         if (flags & HANDLE_FLAG_INVALID)
 913             hr = DXVA2_E_NEW_VIDEO_DEVICE;
 914         else if (!(flags & HANDLE_FLAG_OPEN))
 915             hr = E_HANDLE;
 916     }
 917     LeaveCriticalSection(&manager->cs);
 918
 919     return hr;
 920 }
 921
 922 static HRESULT WINAPI device_manager_LockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice,
 923         IDirect3DDevice9 **device, BOOL block)
 924 {
 925     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 926     HRESULT hr;
 927     size_t idx;
 928
 929     TRACE("%p, %p, %p, %d.\n", iface, hdevice, device, block);
 930
 931     EnterCriticalSection(&manager->cs);
 932     if (!manager->device)
 933         hr = DXVA2_E_NOT_INITIALIZED;
 934     else if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 935     {
 936         if (manager->locking_handle && !block)
 937             hr = DXVA2_E_VIDEO_DEVICE_LOCKED;
 938         else
 939         {
 940             while (manager->locking_handle && block)
 941             {
 942                 SleepConditionVariableCS(&manager->lock, &manager->cs, INFINITE);
 943             }
 944
 945             if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 946             {
 947                 if (manager->handles[idx].flags & HANDLE_FLAG_INVALID)
 948                     hr = DXVA2_E_NEW_VIDEO_DEVICE;
 949                 else
 950                 {
 951                     if (manager->handles[idx].state_block)
 952                     {
 953                         if (FAILED(IDirect3DStateBlock9_Apply(manager->handles[idx].state_block)))
 954                             WARN("Failed to apply state.\n");
 955                         IDirect3DStateBlock9_Release(manager->handles[idx].state_block);
 956                         manager->handles[idx].state_block = NULL;
 957                     }
 958                     *device = manager->device;
 959                     IDirect3DDevice9_AddRef(*device);
 960                     manager->locking_handle = hdevice;
 961                 }
 962             }
 963         }
 964     }
 965     LeaveCriticalSection(&manager->cs);
 966
 967     return hr;
 968 }
 969
 970 static HRESULT WINAPI device_manager_UnlockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice, BOOL savestate)
 971 {
 972     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 973     HRESULT hr;
 974     size_t idx;
 975
 976     TRACE("%p, %p, %d.\n", iface, hdevice, savestate);
 977
 978     EnterCriticalSection(&manager->cs);
 979
 980     if (hdevice != manager->locking_handle)
 981         hr = E_INVALIDARG;
 982     else if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 983     {
 984         manager->locking_handle = NULL;
 985         if (savestate)
 986             IDirect3DDevice9_CreateStateBlock(manager->device, D3DSBT_ALL, &manager->handles[idx].state_block);
 987     }
 988
 989     LeaveCriticalSection(&manager->cs);
 990
 991     WakeAllConditionVariable(&manager->lock);
 992
 993     return hr;
 994 }
 995
 996 static HRESULT WINAPI device_manager_GetVideoService(IDirect3DDeviceManager9 *iface, HANDLE hdevice, REFIID riid,
 997         void **obj)
 998 {
 999     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
1000     HRESULT hr;
1001     size_t idx;
1002
1003     TRACE("%p, %p, %s, %p.\n", iface, hdevice, debugstr_guid(riid), obj);
1004
1005     EnterCriticalSection(&manager->cs);
1006     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
1007     {
1008         unsigned int flags = manager->handles[idx].flags;
1009
1010         if (flags & HANDLE_FLAG_INVALID)
1011             hr = DXVA2_E_NEW_VIDEO_DEVICE;
1012         else if (!(flags & HANDLE_FLAG_OPEN))
1013             hr = E_HANDLE;
1014         else
1015             hr = IDirectXVideoProcessorService_QueryInterface(&manager->IDirectXVideoProcessorService_iface,
1016                     riid, obj);
1017     }
1018     LeaveCriticalSection(&manager->cs);
1019
1020     return hr;
1021 }
1022
1023 static const IDirect3DDeviceManager9Vtbl device_manager_vtbl =
1024 {
1025     device_manager_QueryInterface,
1026     device_manager_AddRef,
1027     device_manager_Release,
1028     device_manager_ResetDevice,
1029     device_manager_OpenDeviceHandle,
1030     device_manager_CloseDeviceHandle,
1031     device_manager_TestDevice,
1032     device_manager_LockDevice,
1033     device_manager_UnlockDevice,
1034     device_manager_GetVideoService,
1035 };
1036
1037 BOOL WINAPI CapabilitiesRequestAndCapabilitiesReply( HMONITOR monitor, LPSTR buffer, DWORD length )
1038 {
1039     FIXME("%p, %p, %ld: stub.\n", monitor, buffer, length);
1040
1041     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1042     return FALSE;
1043 }
1044
1045 HRESULT WINAPI DXVA2CreateDirect3DDeviceManager9(UINT *token, IDirect3DDeviceManager9 **manager)
1046 {
1047     struct device_manager *object;
1048
1049     TRACE("%p, %p.\n", token, manager);
1050
1051     *manager = NULL;
1052
1053     if (!(object = calloc(1, sizeof(*object))))
1054         return E_OUTOFMEMORY;
1055
1056     object->IDirect3DDeviceManager9_iface.lpVtbl = &device_manager_vtbl;
1057     object->IDirectXVideoProcessorService_iface.lpVtbl = &device_manager_processor_service_vtbl;
1058     object->IDirectXVideoDecoderService_iface.lpVtbl = &device_manager_decoder_service_vtbl;
1059     object->refcount = 1;
1060     object->token = GetTickCount();
1061     InitializeCriticalSection(&object->cs);
1062     InitializeConditionVariable(&object->lock);
1063
1064     *token = object->token;
1065     *manager = &object->IDirect3DDeviceManager9_iface;
1066
1067     return S_OK;
1068 }
1069
1070 HRESULT WINAPI DXVA2CreateVideoService(IDirect3DDevice9 *device, REFIID riid, void **obj)
1071 {
1072     IDirect3DDeviceManager9 *manager;
1073     HANDLE handle;
1074     HRESULT hr;
1075     UINT token;
1076
1077     TRACE("%p, %s, %p.\n", device, debugstr_guid(riid), obj);
1078
1079     if (FAILED(hr = DXVA2CreateDirect3DDeviceManager9(&token, &manager)))
1080         return hr;
1081
1082     if (FAILED(hr = IDirect3DDeviceManager9_ResetDevice(manager, device, token)))
1083         goto done;
1084
1085     if (FAILED(hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle)))
1086         goto done;
1087
1088     hr = IDirect3DDeviceManager9_GetVideoService(manager, handle, riid, obj);
1089     IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle);
1090
1091 done:
1092     IDirect3DDeviceManager9_Release(manager);
1093
1094     return hr;
1095 }
1096
1097 BOOL WINAPI DegaussMonitor( HMONITOR monitor )
1098 {
1099     FIXME("(%p): stub\n", monitor);
1100
1101     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1102     return FALSE;
1103 }
1104
1105 BOOL WINAPI DestroyPhysicalMonitor( HMONITOR monitor )
1106 {
1107     FIXME("(%p): stub\n", monitor);
1108
1109     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1110     return FALSE;
1111 }
1112
1113 BOOL WINAPI DestroyPhysicalMonitors( DWORD arraySize, LPPHYSICAL_MONITOR array )
1114 {
1115     FIXME("%lu, %p: stub.\n", arraySize, array);
1116
1117     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1118     return FALSE;
1119 }
1120
1121 BOOL WINAPI GetCapabilitiesStringLength( HMONITOR monitor, LPDWORD length )
1122 {
1123     FIXME("(%p, %p): stub\n", monitor, length);
1124
1125     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1126     return FALSE;
1127 }
1128
1129 BOOL WINAPI GetMonitorBrightness( HMONITOR monitor, LPDWORD minimum, LPDWORD current, LPDWORD maximum )
1130 {
1131     FIXME("(%p, %p, %p, %p): stub\n", monitor, minimum, current, maximum);
1132
1133     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1134     return FALSE;
1135 }
1136
1137 BOOL WINAPI GetMonitorCapabilities( HMONITOR monitor, LPDWORD capabilities, LPDWORD temperatures )
1138 {
1139     FIXME("(%p, %p, %p): stub\n", monitor, capabilities, temperatures);
1140
1141     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1142     return FALSE;
1143 }
1144
1145
1146 BOOL WINAPI GetMonitorColorTemperature( HMONITOR monitor, LPMC_COLOR_TEMPERATURE temperature )
1147 {
1148     FIXME("(%p, %p): stub\n", monitor, temperature);
1149
1150     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1151     return FALSE;
1152 }
1153
1154 BOOL WINAPI GetMonitorContrast( HMONITOR monitor, LPDWORD minimum, LPDWORD current, LPDWORD maximum )
1155 {
1156     FIXME("(%p, %p, %p, %p): stub\n", monitor, minimum, current, maximum);
1157
1158     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1159     return FALSE;
1160 }
1161
1162 BOOL WINAPI GetMonitorDisplayAreaPosition( HMONITOR monitor, MC_POSITION_TYPE type, LPDWORD minimum,
1163                                            LPDWORD current, LPDWORD maximum )
1164 {
1165     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
1166
1167     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1168     return FALSE;
1169 }
1170
1171 BOOL WINAPI GetMonitorDisplayAreaSize( HMONITOR monitor, MC_SIZE_TYPE type, LPDWORD minimum,
1172                                        LPDWORD current, LPDWORD maximum )
1173 {
1174     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
1175
1176     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1177     return FALSE;
1178 }
1179
1180 BOOL WINAPI GetMonitorRedGreenOrBlueDrive( HMONITOR monitor, MC_DRIVE_TYPE type, LPDWORD minimum,
1181                                            LPDWORD current, LPDWORD maximum )
1182 {
1183     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
1184
1185     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1186     return FALSE;
1187 }
1188
1189 BOOL WINAPI GetMonitorRedGreenOrBlueGain( HMONITOR monitor, MC_GAIN_TYPE type, LPDWORD minimum,
1190                                           LPDWORD current, LPDWORD maximum )
1191 {
1192     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
1193
1194     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1195     return FALSE;
1196 }
1197
1198 BOOL WINAPI GetMonitorTechnologyType( HMONITOR monitor, LPMC_DISPLAY_TECHNOLOGY_TYPE type )
1199 {
1200     FIXME("(%p, %p): stub\n", monitor, type);
1201
1202     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1203     return FALSE;
1204 }
1205
1206 BOOL WINAPI GetNumberOfPhysicalMonitorsFromHMONITOR( HMONITOR monitor, LPDWORD number )
1207 {
1208     FIXME("(%p, %p): stub\n", monitor, number);
1209
1210     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1211     return FALSE;
1212 }
1213
1214 HRESULT WINAPI GetNumberOfPhysicalMonitorsFromIDirect3DDevice9( IDirect3DDevice9 *device, LPDWORD number )
1215 {
1216     FIXME("(%p, %p): stub\n", device, number);
1217
1218     return E_NOTIMPL;
1219 }
1220
1221 BOOL WINAPI GetPhysicalMonitorsFromHMONITOR( HMONITOR monitor, DWORD arraySize, LPPHYSICAL_MONITOR array )
1222 {
1223     FIXME("%p, %lu, %p: stub.\n", monitor, arraySize, array);
1224
1225     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1226     return FALSE;
1227 }
1228
1229 HRESULT WINAPI GetPhysicalMonitorsFromIDirect3DDevice9( IDirect3DDevice9 *device, DWORD arraySize, LPPHYSICAL_MONITOR array )
1230 {
1231     FIXME("%p, %lu, %p: stub.\n", device, arraySize, array);
1232
1233     return E_NOTIMPL;
1234 }
1235
1236 BOOL WINAPI GetTimingReport( HMONITOR monitor, LPMC_TIMING_REPORT timingReport )
1237 {
1238     FIXME("(%p, %p): stub\n", monitor, timingReport);
1239
1240     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1241     return FALSE;
1242 }
1243
1244 BOOL WINAPI GetVCPFeatureAndVCPFeatureReply( HMONITOR monitor, BYTE vcpCode, LPMC_VCP_CODE_TYPE pvct,
1245                                              LPDWORD current, LPDWORD maximum )
1246 {
1247     FIXME("(%p, 0x%02x, %p, %p, %p): stub\n", monitor, vcpCode, pvct, current, maximum);
1248
1249     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1250     return FALSE;
1251 }
1252
1253 HRESULT WINAPI OPMGetVideoOutputsFromHMONITOR( HMONITOR monitor, /* OPM_VIDEO_OUTPUT_SEMANTICS */ int vos,
1254                                                ULONG *numVideoOutputs, /* IOPMVideoOutput */ void ***videoOutputs )
1255 {
1256     FIXME("(%p, 0x%x, %p, %p): stub\n", monitor, vos, numVideoOutputs, videoOutputs);
1257
1258     return E_NOTIMPL;
1259 }
1260
1261 HRESULT WINAPI OPMGetVideoOutputsFromIDirect3DDevice9Object( IDirect3DDevice9 *device, /* OPM_VIDEO_OUTPUT_SEMANTICS */ int vos,
1262                                                              ULONG *numVideoOutputs,  /* IOPMVideoOutput */ void ***videoOutputs )
1263 {
1264     FIXME("(%p, 0x%x, %p, %p): stub\n", device, vos, numVideoOutputs, videoOutputs);
1265
1266     return E_NOTIMPL;
1267 }
1268
1269 BOOL WINAPI RestoreMonitorFactoryColorDefaults( HMONITOR monitor )
1270 {
1271     FIXME("(%p): stub\n", monitor);
1272
1273     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1274     return FALSE;
1275 }
1276
1277 BOOL WINAPI RestoreMonitorFactoryDefaults( HMONITOR monitor )
1278 {
1279     FIXME("(%p): stub\n", monitor);
1280
1281     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1282     return FALSE;
1283 }
1284
1285 BOOL WINAPI SaveCurrentMonitorSettings( HMONITOR monitor )
1286 {
1287     FIXME("(%p): stub\n", monitor);
1288
1289     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1290     return FALSE;
1291 }
1292
1293 BOOL WINAPI SaveCurrentSettings( HMONITOR monitor )
1294 {
1295     FIXME("(%p): stub\n", monitor);
1296
1297     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1298     return FALSE;
1299 }
1300
1301 BOOL WINAPI SetMonitorBrightness( HMONITOR monitor, DWORD brightness )
1302 {
1303     FIXME("%p, %#lx: stub.\n", monitor, brightness);
1304
1305     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1306     return FALSE;
1307 }
1308
1309 BOOL WINAPI SetMonitorColorTemperature( HMONITOR monitor, MC_COLOR_TEMPERATURE temperature )
1310 {
1311     FIXME("(%p, 0x%x): stub\n", monitor, temperature);
1312
1313     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1314     return FALSE;
1315 }
1316
1317 BOOL WINAPI SetMonitorContrast( HMONITOR monitor, DWORD contrast )
1318 {
1319     FIXME("%p, %#lx: stub.\n", monitor, contrast);
1320
1321     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1322     return FALSE;
1323 }
1324
1325 BOOL WINAPI SetMonitorDisplayAreaPosition( HMONITOR monitor, MC_POSITION_TYPE type, DWORD position )
1326 {
1327     FIXME("%p, 0x%x, %#lx: stub.\n", monitor, type, position);
1328
1329     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1330     return FALSE;
1331 }
1332
1333 BOOL WINAPI SetMonitorDisplayAreaSize( HMONITOR monitor, MC_SIZE_TYPE type, DWORD size )
1334 {
1335     FIXME("%p, 0x%x, %#lx: stub.\n", monitor, type, size);
1336
1337     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1338     return FALSE;
1339 }
1340
1341 BOOL WINAPI SetMonitorRedGreenOrBlueDrive( HMONITOR monitor, MC_DRIVE_TYPE type, DWORD drive )
1342 {
1343     FIXME("%p, 0x%x, %#lx: stub.\n", monitor, type, drive);
1344
1345     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1346     return FALSE;
1347 }
1348
1349 BOOL WINAPI SetMonitorRedGreenOrBlueGain( HMONITOR monitor, MC_GAIN_TYPE type, DWORD gain )
1350 {
1351     FIXME("%p, 0x%x, %#lx: stub.\n", monitor, type, gain);
1352
1353     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1354     return FALSE;
1355 }
1356
1357 BOOL WINAPI SetVCPFeature( HMONITOR monitor, BYTE vcpCode, DWORD value )
1358 {
1359     FIXME("%p, 0x%02x, %#lx: stub.\n", monitor, vcpCode, value);
1360
1361     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1362     return FALSE;
1363 }