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 "windef.h"
  23 #include "winbase.h"
  24 #include "d3d9.h"
  25 #include "physicalmonitorenumerationapi.h"
  26 #include "lowlevelmonitorconfigurationapi.h"
  27 #include "highlevelmonitorconfigurationapi.h"
  28 #include "initguid.h"
  29 #include "dxva2api.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/heap.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(dxva2);
  35
  36 enum device_handle_flags
  37 {
  38     HANDLE_FLAG_OPEN = 0x1,
  39     HANDLE_FLAG_INVALID = 0x2,
  40 };
  41
  42 struct device_handle
  43 {
  44     unsigned int flags;
  45 };
  46
  47 struct device_manager
  48 {
  49     IDirect3DDeviceManager9 IDirect3DDeviceManager9_iface;
  50     IDirectXVideoProcessorService IDirectXVideoProcessorService_iface;
  51     LONG refcount;
  52
  53     IDirect3DDevice9 *device;
  54     UINT token;
  55
  56     struct device_handle *handles;
  57     size_t count;
  58     size_t capacity;
  59
  60     CRITICAL_SECTION cs;
  61 };
  62
  63 static BOOL dxva_array_reserve(void **elements, size_t *capacity, size_t count, size_t size)
  64 {
  65     size_t new_capacity, max_capacity;
  66     void *new_elements;
  67
  68     if (count <= *capacity)
  69         return TRUE;
  70
  71     max_capacity = ~(SIZE_T)0 / size;
  72     if (count > max_capacity)
  73         return FALSE;
  74
  75     new_capacity = max(4, *capacity);
  76     while (new_capacity < count && new_capacity <= max_capacity / 2)
  77         new_capacity *= 2;
  78     if (new_capacity < count)
  79         new_capacity = max_capacity;
  80
  81     if (!(new_elements = heap_realloc(*elements, new_capacity * size)))
  82         return FALSE;
  83
  84     *elements = new_elements;
  85     *capacity = new_capacity;
  86
  87     return TRUE;
  88 }
  89
  90 static struct device_manager *impl_from_IDirect3DDeviceManager9(IDirect3DDeviceManager9 *iface)
  91 {
  92     return CONTAINING_RECORD(iface, struct device_manager, IDirect3DDeviceManager9_iface);
  93 }
  94
  95 static struct device_manager *impl_from_IDirectXVideoProcessorService(IDirectXVideoProcessorService *iface)
  96 {
  97     return CONTAINING_RECORD(iface, struct device_manager, IDirectXVideoProcessorService_iface);
  98 }
  99
 100 static HRESULT WINAPI device_manager_processor_service_QueryInterface(IDirectXVideoProcessorService *iface,
 101         REFIID riid, void **obj)
 102 {
 103     if (IsEqualIID(riid, &IID_IDirectXVideoProcessorService) ||
 104             IsEqualIID(riid, &IID_IDirectXVideoAccelerationService) ||
 105             IsEqualIID(riid, &IID_IUnknown))
 106     {
 107         *obj = iface;
 108         IDirectXVideoProcessorService_AddRef(iface);
 109         return S_OK;
 110     }
 111
 112     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 113     *obj = NULL;
 114     return E_NOINTERFACE;
 115 }
 116
 117 static ULONG WINAPI device_manager_processor_service_AddRef(IDirectXVideoProcessorService *iface)
 118 {
 119     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 120     return IDirect3DDeviceManager9_AddRef(&manager->IDirect3DDeviceManager9_iface);
 121 }
 122
 123 static ULONG WINAPI device_manager_processor_service_Release(IDirectXVideoProcessorService *iface)
 124 {
 125     struct device_manager *manager = impl_from_IDirectXVideoProcessorService(iface);
 126     return IDirect3DDeviceManager9_Release(&manager->IDirect3DDeviceManager9_iface);
 127 }
 128
 129 static HRESULT WINAPI device_manager_processor_service_CreateSurface(IDirectXVideoProcessorService *iface,
 130         UINT width, UINT height, UINT backbuffers, D3DFORMAT format, D3DPOOL pool, DWORD usage, DWORD dxvaType,
 131         IDirect3DSurface9 **surface, HANDLE *shared_handle)
 132 {
 133     FIXME("%p, %u, %u, %u, %u, %u, %u, %u, %p, %p.\n", iface, width, height, backbuffers, format, pool, usage, dxvaType,
 134             surface, shared_handle);
 135
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI device_manager_processor_service_RegisterVideoProcessorSoftwareDevice(
 140         IDirectXVideoProcessorService *iface, void *callbacks)
 141 {
 142     FIXME("%p, %p.\n", iface, callbacks);
 143
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorDeviceGuids(
 148         IDirectXVideoProcessorService *iface, const DXVA2_VideoDesc *video_desc, UINT *count, GUID **guids)
 149 {
 150     FIXME("%p, %p, %p, %p.\n", iface, video_desc, count, guids);
 151
 152     return E_NOTIMPL;
 153 }
 154
 155 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorRenderTargets(
 156         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc, UINT *count,
 157         D3DFORMAT **formats)
 158 {
 159     FIXME("%p, %s, %p, %p, %p.\n", iface, debugstr_guid(deviceguid), video_desc, count, formats);
 160
 161     return E_NOTIMPL;
 162 }
 163
 164 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorSubStreamFormats(
 165         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 166         D3DFORMAT rt_format, UINT *count, D3DFORMAT **formats)
 167 {
 168     FIXME("%p, %s, %p, %u, %p, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, count, formats);
 169
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI device_manager_processor_service_GetVideoProcessorCaps(
 174         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 175         D3DFORMAT rt_format, DXVA2_VideoProcessorCaps *caps)
 176 {
 177     FIXME("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, caps);
 178
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI device_manager_processor_service_GetProcAmpRange(
 183         IDirectXVideoProcessorService *iface, REFGUID deviceguid, const DXVA2_VideoDesc *video_desc,
 184         D3DFORMAT rt_format, UINT ProcAmpCap, DXVA2_ValueRange *range)
 185 {
 186     FIXME("%p, %s, %p, %u, %u, %p.\n", iface, debugstr_guid(deviceguid), video_desc, rt_format, ProcAmpCap, range);
 187
 188     return E_NOTIMPL;
 189 }
 190
 191 static const IDirectXVideoProcessorServiceVtbl device_manager_processor_service_vtbl =
 192 {
 193     device_manager_processor_service_QueryInterface,
 194     device_manager_processor_service_AddRef,
 195     device_manager_processor_service_Release,
 196     device_manager_processor_service_CreateSurface,
 197     device_manager_processor_service_RegisterVideoProcessorSoftwareDevice,
 198     device_manager_processor_service_GetVideoProcessorDeviceGuids,
 199     device_manager_processor_service_GetVideoProcessorRenderTargets,
 200     device_manager_processor_service_GetVideoProcessorSubStreamFormats,
 201     device_manager_processor_service_GetVideoProcessorCaps,
 202     device_manager_processor_service_GetProcAmpRange,
 203 };
 204
 205 static HRESULT WINAPI device_manager_QueryInterface(IDirect3DDeviceManager9 *iface, REFIID riid, void **obj)
 206 {
 207     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 208
 209     if (IsEqualIID(&IID_IDirect3DDeviceManager9, riid) ||
 210             IsEqualIID(&IID_IUnknown, riid))
 211     {
 212         *obj = iface;
 213         IDirect3DDeviceManager9_AddRef(iface);
 214         return S_OK;
 215     }
 216
 217     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 218     *obj = NULL;
 219     return E_NOINTERFACE;
 220 }
 221
 222 static ULONG WINAPI device_manager_AddRef(IDirect3DDeviceManager9 *iface)
 223 {
 224     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 225     ULONG refcount = InterlockedIncrement(&manager->refcount);
 226
 227     TRACE("%p, refcount %u.\n", iface, refcount);
 228
 229     return refcount;
 230 }
 231
 232 static ULONG WINAPI device_manager_Release(IDirect3DDeviceManager9 *iface)
 233 {
 234     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 235     ULONG refcount = InterlockedDecrement(&manager->refcount);
 236
 237     TRACE("%p, refcount %u.\n", iface, refcount);
 238
 239     if (!refcount)
 240     {
 241         if (manager->device)
 242             IDirect3DDevice9_Release(manager->device);
 243         DeleteCriticalSection(&manager->cs);
 244         heap_free(manager->handles);
 245         heap_free(manager);
 246     }
 247
 248     return refcount;
 249 }
 250
 251 static HRESULT WINAPI device_manager_ResetDevice(IDirect3DDeviceManager9 *iface, IDirect3DDevice9 *device,
 252         UINT token)
 253 {
 254     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 255     size_t i;
 256
 257     TRACE("%p, %p, %#x.\n", iface, device, token);
 258
 259     if (token != manager->token)
 260         return E_INVALIDARG;
 261
 262     EnterCriticalSection(&manager->cs);
 263     if (manager->device)
 264     {
 265         for (i = 0; i < manager->count; ++i)
 266             manager->handles[i].flags |= HANDLE_FLAG_INVALID;
 267         IDirect3DDevice9_Release(manager->device);
 268     }
 269     manager->device = device;
 270     IDirect3DDevice9_AddRef(manager->device);
 271     LeaveCriticalSection(&manager->cs);
 272
 273     return S_OK;
 274 }
 275
 276 static HRESULT WINAPI device_manager_OpenDeviceHandle(IDirect3DDeviceManager9 *iface, HANDLE *hdevice)
 277 {
 278     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 279     HRESULT hr = S_OK;
 280     size_t i;
 281
 282     TRACE("%p, %p.\n", iface, hdevice);
 283
 284     *hdevice = NULL;
 285
 286     EnterCriticalSection(&manager->cs);
 287     if (!manager->device)
 288         hr = DXVA2_E_NOT_INITIALIZED;
 289     else
 290     {
 291         for (i = 0; i < manager->count; ++i)
 292         {
 293             if (!(manager->handles[i].flags & HANDLE_FLAG_OPEN))
 294             {
 295                 manager->handles[i].flags |= HANDLE_FLAG_OPEN;
 296                 *hdevice = ULongToHandle(i + 1);
 297                 break;
 298             }
 299         }
 300
 301         if (dxva_array_reserve((void **)&manager->handles, &manager->capacity, manager->count + 1,
 302                 sizeof(*manager->handles)))
 303         {
 304             *hdevice = ULongToHandle(manager->count + 1);
 305             manager->handles[manager->count].flags |= HANDLE_FLAG_OPEN;
 306             manager->count++;
 307         }
 308         else
 309             hr = E_OUTOFMEMORY;
 310     }
 311     LeaveCriticalSection(&manager->cs);
 312
 313     return hr;
 314 }
 315
 316 static HRESULT device_manager_get_handle_index(struct device_manager *manager, HANDLE hdevice, size_t *idx)
 317 {
 318     if (hdevice > ULongToHandle(manager->count))
 319         return E_HANDLE;
 320     *idx = (ULONG_PTR)hdevice - 1;
 321     return S_OK;
 322 }
 323
 324 static HRESULT WINAPI device_manager_CloseDeviceHandle(IDirect3DDeviceManager9 *iface, HANDLE hdevice)
 325 {
 326     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 327     HRESULT hr;
 328     size_t idx;
 329
 330     TRACE("%p, %p.\n", iface, hdevice);
 331
 332     EnterCriticalSection(&manager->cs);
 333     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 334     {
 335         if (manager->handles[idx].flags & HANDLE_FLAG_OPEN)
 336         {
 337             manager->handles[idx].flags = 0;
 338             if (idx == manager->count - 1)
 339                 manager->count--;
 340         }
 341         else
 342             hr = E_HANDLE;
 343     }
 344     LeaveCriticalSection(&manager->cs);
 345
 346     return hr;
 347 }
 348
 349 static HRESULT WINAPI device_manager_TestDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice)
 350 {
 351     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 352     HRESULT hr;
 353     size_t idx;
 354
 355     TRACE("%p, %p.\n", iface, hdevice);
 356
 357     EnterCriticalSection(&manager->cs);
 358     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 359     {
 360         unsigned int flags = manager->handles[idx].flags;
 361
 362         if (flags & HANDLE_FLAG_INVALID)
 363             hr = DXVA2_E_NEW_VIDEO_DEVICE;
 364         else if (!(flags & HANDLE_FLAG_OPEN))
 365             hr = E_HANDLE;
 366     }
 367     LeaveCriticalSection(&manager->cs);
 368
 369     return hr;
 370 }
 371
 372 static HRESULT WINAPI device_manager_LockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice,
 373         IDirect3DDevice9 **device, BOOL block)
 374 {
 375     FIXME("%p, %p, %p, %d.\n", iface, hdevice, device, block);
 376
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT WINAPI device_manager_UnlockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice, BOOL savestate)
 381 {
 382     FIXME("%p, %p, %d.\n", iface, hdevice, savestate);
 383
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT WINAPI device_manager_GetVideoService(IDirect3DDeviceManager9 *iface, HANDLE hdevice, REFIID riid,
 388         void **obj)
 389 {
 390     struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface);
 391     HRESULT hr;
 392     size_t idx;
 393
 394     TRACE("%p, %p, %s, %p.\n", iface, hdevice, debugstr_guid(riid), obj);
 395
 396     EnterCriticalSection(&manager->cs);
 397     if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx)))
 398     {
 399         unsigned int flags = manager->handles[idx].flags;
 400
 401         if (flags & HANDLE_FLAG_INVALID)
 402             hr = DXVA2_E_NEW_VIDEO_DEVICE;
 403         else if (!(flags & HANDLE_FLAG_OPEN))
 404             hr = E_HANDLE;
 405         else
 406             hr = IDirectXVideoProcessorService_QueryInterface(&manager->IDirectXVideoProcessorService_iface,
 407                     riid, obj);
 408     }
 409     LeaveCriticalSection(&manager->cs);
 410
 411     return hr;
 412 }
 413
 414 static const IDirect3DDeviceManager9Vtbl device_manager_vtbl =
 415 {
 416     device_manager_QueryInterface,
 417     device_manager_AddRef,
 418     device_manager_Release,
 419     device_manager_ResetDevice,
 420     device_manager_OpenDeviceHandle,
 421     device_manager_CloseDeviceHandle,
 422     device_manager_TestDevice,
 423     device_manager_LockDevice,
 424     device_manager_UnlockDevice,
 425     device_manager_GetVideoService,
 426 };
 427
 428 BOOL WINAPI CapabilitiesRequestAndCapabilitiesReply( HMONITOR monitor, LPSTR buffer, DWORD length )
 429 {
 430     FIXME("(%p, %p, %d): stub\n", monitor, buffer, length);
 431
 432     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 433     return FALSE;
 434 }
 435
 436 HRESULT WINAPI DXVA2CreateDirect3DDeviceManager9(UINT *token, IDirect3DDeviceManager9 **manager)
 437 {
 438     struct device_manager *object;
 439
 440     TRACE("%p, %p.\n", token, manager);
 441
 442     *manager = NULL;
 443
 444     if (!(object = heap_alloc_zero(sizeof(*object))))
 445         return E_OUTOFMEMORY;
 446
 447     object->IDirect3DDeviceManager9_iface.lpVtbl = &device_manager_vtbl;
 448     object->IDirectXVideoProcessorService_iface.lpVtbl = &device_manager_processor_service_vtbl;
 449     object->refcount = 1;
 450     object->token = GetTickCount();
 451     InitializeCriticalSection(&object->cs);
 452
 453     *token = object->token;
 454     *manager = &object->IDirect3DDeviceManager9_iface;
 455
 456     return S_OK;
 457 }
 458
 459 HRESULT WINAPI DXVA2CreateVideoService(IDirect3DDevice9 *device, REFIID riid, void **obj)
 460 {
 461     IDirect3DDeviceManager9 *manager;
 462     HANDLE handle;
 463     HRESULT hr;
 464     UINT token;
 465
 466     TRACE("%p, %s, %p.\n", device, debugstr_guid(riid), obj);
 467
 468     if (FAILED(hr = DXVA2CreateDirect3DDeviceManager9(&token, &manager)))
 469         return hr;
 470
 471     if (FAILED(hr = IDirect3DDeviceManager9_ResetDevice(manager, device, token)))
 472         goto done;
 473
 474     if (FAILED(hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle)))
 475         goto done;
 476
 477     hr = IDirect3DDeviceManager9_GetVideoService(manager, handle, riid, obj);
 478     IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle);
 479
 480 done:
 481     IDirect3DDeviceManager9_Release(manager);
 482
 483     return hr;
 484 }
 485
 486 BOOL WINAPI DegaussMonitor( HMONITOR monitor )
 487 {
 488     FIXME("(%p): stub\n", monitor);
 489
 490     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 491     return FALSE;
 492 }
 493
 494 BOOL WINAPI DestroyPhysicalMonitor( HMONITOR monitor )
 495 {
 496     FIXME("(%p): stub\n", monitor);
 497
 498     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 499     return FALSE;
 500 }
 501
 502 BOOL WINAPI DestroyPhysicalMonitors( DWORD arraySize, LPPHYSICAL_MONITOR array )
 503 {
 504     FIXME("(0x%x, %p): stub\n", arraySize, array);
 505
 506     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 507     return FALSE;
 508 }
 509
 510 BOOL WINAPI GetCapabilitiesStringLength( HMONITOR monitor, LPDWORD length )
 511 {
 512     FIXME("(%p, %p): stub\n", monitor, length);
 513
 514     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 515     return FALSE;
 516 }
 517
 518 BOOL WINAPI GetMonitorBrightness( HMONITOR monitor, LPDWORD minimum, LPDWORD current, LPDWORD maximum )
 519 {
 520     FIXME("(%p, %p, %p, %p): stub\n", monitor, minimum, current, maximum);
 521
 522     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 523     return FALSE;
 524 }
 525
 526 BOOL WINAPI GetMonitorCapabilities( HMONITOR monitor, LPDWORD capabilities, LPDWORD temperatures )
 527 {
 528     FIXME("(%p, %p, %p): stub\n", monitor, capabilities, temperatures);
 529
 530     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 531     return FALSE;
 532 }
 533
 534
 535 BOOL WINAPI GetMonitorColorTemperature( HMONITOR monitor, LPMC_COLOR_TEMPERATURE temperature )
 536 {
 537     FIXME("(%p, %p): stub\n", monitor, temperature);
 538
 539     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 540     return FALSE;
 541 }
 542
 543 BOOL WINAPI GetMonitorContrast( HMONITOR monitor, LPDWORD minimum, LPDWORD current, LPDWORD maximum )
 544 {
 545     FIXME("(%p, %p, %p, %p): stub\n", monitor, minimum, current, maximum);
 546
 547     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 548     return FALSE;
 549 }
 550
 551 BOOL WINAPI GetMonitorDisplayAreaPosition( HMONITOR monitor, MC_POSITION_TYPE type, LPDWORD minimum,
 552                                            LPDWORD current, LPDWORD maximum )
 553 {
 554     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
 555
 556     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 557     return FALSE;
 558 }
 559
 560 BOOL WINAPI GetMonitorDisplayAreaSize( HMONITOR monitor, MC_SIZE_TYPE type, LPDWORD minimum,
 561                                        LPDWORD current, LPDWORD maximum )
 562 {
 563     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
 564
 565     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 566     return FALSE;
 567 }
 568
 569 BOOL WINAPI GetMonitorRedGreenOrBlueDrive( HMONITOR monitor, MC_DRIVE_TYPE type, LPDWORD minimum,
 570                                            LPDWORD current, LPDWORD maximum )
 571 {
 572     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
 573
 574     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 575     return FALSE;
 576 }
 577
 578 BOOL WINAPI GetMonitorRedGreenOrBlueGain( HMONITOR monitor, MC_GAIN_TYPE type, LPDWORD minimum,
 579                                           LPDWORD current, LPDWORD maximum )
 580 {
 581     FIXME("(%p, 0x%x, %p, %p, %p): stub\n", monitor, type, minimum, current, maximum);
 582
 583     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 584     return FALSE;
 585 }
 586
 587 BOOL WINAPI GetMonitorTechnologyType( HMONITOR monitor, LPMC_DISPLAY_TECHNOLOGY_TYPE type )
 588 {
 589     FIXME("(%p, %p): stub\n", monitor, type);
 590
 591     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 592     return FALSE;
 593 }
 594
 595 BOOL WINAPI GetNumberOfPhysicalMonitorsFromHMONITOR( HMONITOR monitor, LPDWORD number )
 596 {
 597     FIXME("(%p, %p): stub\n", monitor, number);
 598
 599     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 600     return FALSE;
 601 }
 602
 603 HRESULT WINAPI GetNumberOfPhysicalMonitorsFromIDirect3DDevice9( IDirect3DDevice9 *device, LPDWORD number )
 604 {
 605     FIXME("(%p, %p): stub\n", device, number);
 606
 607     return E_NOTIMPL;
 608 }
 609
 610 BOOL WINAPI GetPhysicalMonitorsFromHMONITOR( HMONITOR monitor, DWORD arraySize, LPPHYSICAL_MONITOR array )
 611 {
 612     FIXME("(%p, 0x%x, %p): stub\n", monitor, arraySize, array);
 613
 614     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 615     return FALSE;
 616 }
 617
 618 HRESULT WINAPI GetPhysicalMonitorsFromIDirect3DDevice9( IDirect3DDevice9 *device, DWORD arraySize, LPPHYSICAL_MONITOR array )
 619 {
 620     FIXME("(%p, 0x%x, %p): stub\n", device, arraySize, array);
 621
 622     return E_NOTIMPL;
 623 }
 624
 625 BOOL WINAPI GetTimingReport( HMONITOR monitor, LPMC_TIMING_REPORT timingReport )
 626 {
 627     FIXME("(%p, %p): stub\n", monitor, timingReport);
 628
 629     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 630     return FALSE;
 631 }
 632
 633 BOOL WINAPI GetVCPFeatureAndVCPFeatureReply( HMONITOR monitor, BYTE vcpCode, LPMC_VCP_CODE_TYPE pvct,
 634                                              LPDWORD current, LPDWORD maximum )
 635 {
 636     FIXME("(%p, 0x%02x, %p, %p, %p): stub\n", monitor, vcpCode, pvct, current, maximum);
 637
 638     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 639     return FALSE;
 640 }
 641
 642 HRESULT WINAPI OPMGetVideoOutputsFromHMONITOR( HMONITOR monitor, /* OPM_VIDEO_OUTPUT_SEMANTICS */ int vos,
 643                                                ULONG *numVideoOutputs, /* IOPMVideoOutput */ void ***videoOutputs )
 644 {
 645     FIXME("(%p, 0x%x, %p, %p): stub\n", monitor, vos, numVideoOutputs, videoOutputs);
 646
 647     return E_NOTIMPL;
 648 }
 649
 650 HRESULT WINAPI OPMGetVideoOutputsFromIDirect3DDevice9Object( IDirect3DDevice9 *device, /* OPM_VIDEO_OUTPUT_SEMANTICS */ int vos,
 651                                                              ULONG *numVideoOutputs,  /* IOPMVideoOutput */ void ***videoOutputs )
 652 {
 653     FIXME("(%p, 0x%x, %p, %p): stub\n", device, vos, numVideoOutputs, videoOutputs);
 654
 655     return E_NOTIMPL;
 656 }
 657
 658 BOOL WINAPI RestoreMonitorFactoryColorDefaults( HMONITOR monitor )
 659 {
 660     FIXME("(%p): stub\n", monitor);
 661
 662     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 663     return FALSE;
 664 }
 665
 666 BOOL WINAPI RestoreMonitorFactoryDefaults( HMONITOR monitor )
 667 {
 668     FIXME("(%p): stub\n", monitor);
 669
 670     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 671     return FALSE;
 672 }
 673
 674 BOOL WINAPI SaveCurrentMonitorSettings( HMONITOR monitor )
 675 {
 676     FIXME("(%p): stub\n", monitor);
 677
 678     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 679     return FALSE;
 680 }
 681
 682 BOOL WINAPI SaveCurrentSettings( HMONITOR monitor )
 683 {
 684     FIXME("(%p): stub\n", monitor);
 685
 686     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 687     return FALSE;
 688 }
 689
 690 BOOL WINAPI SetMonitorBrightness( HMONITOR monitor, DWORD brightness )
 691 {
 692     FIXME("(%p, 0x%x): stub\n", monitor, brightness);
 693
 694     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 695     return FALSE;
 696 }
 697
 698 BOOL WINAPI SetMonitorColorTemperature( HMONITOR monitor, MC_COLOR_TEMPERATURE temperature )
 699 {
 700     FIXME("(%p, 0x%x): stub\n", monitor, temperature);
 701
 702     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 703     return FALSE;
 704 }
 705
 706 BOOL WINAPI SetMonitorContrast( HMONITOR monitor, DWORD contrast )
 707 {
 708     FIXME("(%p, 0x%x): stub\n", monitor, contrast);
 709
 710     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 711     return FALSE;
 712 }
 713
 714 BOOL WINAPI SetMonitorDisplayAreaPosition( HMONITOR monitor, MC_POSITION_TYPE type, DWORD position )
 715 {
 716     FIXME("(%p, 0x%x, 0x%x): stub\n", monitor, type, position);
 717
 718     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 719     return FALSE;
 720 }
 721
 722 BOOL WINAPI SetMonitorDisplayAreaSize( HMONITOR monitor, MC_SIZE_TYPE type, DWORD size )
 723 {
 724     FIXME("(%p, 0x%x, 0x%x): stub\n", monitor, type, size);
 725
 726     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 727     return FALSE;
 728 }
 729
 730 BOOL WINAPI SetMonitorRedGreenOrBlueDrive( HMONITOR monitor, MC_DRIVE_TYPE type, DWORD drive )
 731 {
 732     FIXME("(%p, 0x%x, 0x%x): stub\n", monitor, type, drive);
 733
 734     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 735     return FALSE;
 736 }
 737
 738 BOOL WINAPI SetMonitorRedGreenOrBlueGain( HMONITOR monitor, MC_GAIN_TYPE type, DWORD gain )
 739 {
 740     FIXME("(%p, 0x%x, 0x%x): stub\n", monitor, type, gain);
 741
 742     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 743     return FALSE;
 744 }
 745
 746 BOOL WINAPI SetVCPFeature( HMONITOR monitor, BYTE vcpCode, DWORD value )
 747 {
 748     FIXME("(%p, 0x%02x, 0x%x): stub\n", monitor, vcpCode, value);
 749
 750     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 751     return FALSE;
 752 }
 753
 754 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 755 {
 756     TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
 757
 758     switch (fdwReason) {
 759         case DLL_WINE_PREATTACH:
 760             return FALSE;  /* prefer native version */
 761         case DLL_PROCESS_ATTACH:
 762             DisableThreadLibraryCalls(hinstDLL);
 763             break;
 764     }
 765
 766     return TRUE;
 767 }