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