VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDispIf.cpp@ 44149

Last change on this file since 44149 was 44149, checked in by vboxsync, 12 years ago

wddm/display-only: fix auto-resize
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 44.6 KB
Line 
1/** @file
2 * VBoxTray - Display Settings Interface abstraction for XPDM & WDDM
3 */
4
5/*
6 * Copyright (C) 2006-2010 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 */
16
17#include "VBoxTray.h"
18
19#include <iprt/log.h>
20#include <iprt/err.h>
21#include <iprt/assert.h>
22
23#include <malloc.h>
24
25#ifdef VBOX_WITH_WDDM
26#include <iprt/asm.h>
27#endif
28
29/* display driver interface abstraction for XPDM & WDDM
30 * with WDDM we can not use ExtEscape to communicate with our driver
31 * because we do not have XPDM display driver any more, i.e. escape requests are handled by cdd
32 * that knows nothing about us */
33DWORD VBoxDispIfInit(PVBOXDISPIF pIf)
34{
35 pIf->enmMode = VBOXDISPIF_MODE_XPDM;
36 return NO_ERROR;
37}
38
39#ifdef VBOX_WITH_WDDM
40static void vboxDispIfWddmTerm(PCVBOXDISPIF pIf);
41static DWORD vboxDispIfWddmInit(PCVBOXDISPIF pIf);
42#endif
43
44DWORD VBoxDispIfTerm(PVBOXDISPIF pIf)
45{
46#ifdef VBOX_WITH_WDDM
47 if (pIf->enmMode == VBOXDISPIF_MODE_WDDM)
48 {
49 vboxDispIfWddmTerm(pIf);
50 }
51#endif
52
53 pIf->enmMode = VBOXDISPIF_MODE_UNKNOWN;
54 return NO_ERROR;
55}
56
57static DWORD vboxDispIfEscapeXPDM(PCVBOXDISPIF pIf, PVBOXDISPIFESCAPE pEscape, int cbData, int iDirection)
58{
59 HDC hdc = GetDC(HWND_DESKTOP);
60 VOID *pvData = cbData ? VBOXDISPIFESCAPE_DATA(pEscape, VOID) : NULL;
61 int iRet = ExtEscape(hdc, pEscape->escapeCode,
62 iDirection >= 0 ? cbData : 0,
63 iDirection >= 0 ? (LPSTR)pvData : NULL,
64 iDirection <= 0 ? cbData : 0,
65 iDirection <= 0 ? (LPSTR)pvData : NULL);
66 ReleaseDC(HWND_DESKTOP, hdc);
67 if (iRet > 0)
68 return VINF_SUCCESS;
69 else if (iRet == 0)
70 return ERROR_NOT_SUPPORTED;
71 /* else */
72 return ERROR_GEN_FAILURE;
73}
74
75#ifdef VBOX_WITH_WDDM
76static DWORD vboxDispIfSwitchToWDDM(PVBOXDISPIF pIf)
77{
78 DWORD err = NO_ERROR;
79 OSVERSIONINFO OSinfo;
80 OSinfo.dwOSVersionInfoSize = sizeof (OSinfo);
81 GetVersionEx (&OSinfo);
82 bool bSupported = true;
83
84 if (OSinfo.dwMajorVersion >= 6)
85 {
86 Log((__FUNCTION__": this is vista and up\n"));
87 HMODULE hUser = GetModuleHandle("USER32");
88 if (hUser)
89 {
90 *(uintptr_t *)&pIf->modeData.wddm.pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
91 Log((__FUNCTION__": VBoxDisplayInit: pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.wddm.pfnChangeDisplaySettingsEx));
92 bSupported &= !!(pIf->modeData.wddm.pfnChangeDisplaySettingsEx);
93
94 *(uintptr_t *)&pIf->modeData.wddm.pfnEnumDisplayDevices = (uintptr_t)GetProcAddress(hUser, "EnumDisplayDevicesA");
95 Log((__FUNCTION__": VBoxDisplayInit: pfnEnumDisplayDevices = %p\n", pIf->modeData.wddm.pfnEnumDisplayDevices));
96 bSupported &= !!(pIf->modeData.wddm.pfnEnumDisplayDevices);
97
98 /* this is vista and up */
99 HMODULE hGdi32 = GetModuleHandle("gdi32");
100 if (hGdi32 != NULL)
101 {
102 pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromHdc = (PFND3DKMT_OPENADAPTERFROMHDC)GetProcAddress(hGdi32, "D3DKMTOpenAdapterFromHdc");
103 Log((__FUNCTION__"pfnD3DKMTOpenAdapterFromHdc = %p\n", pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromHdc));
104 bSupported &= !!(pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromHdc);
105
106 pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromGdiDisplayName = (PFND3DKMT_OPENADAPTERFROMGDIDISPLAYNAME)GetProcAddress(hGdi32, "D3DKMTOpenAdapterFromGdiDisplayName");
107 Log((__FUNCTION__": pfnD3DKMTOpenAdapterFromGdiDisplayName = %p\n", pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromGdiDisplayName));
108 bSupported &= !!(pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromGdiDisplayName);
109
110 pIf->modeData.wddm.pfnD3DKMTCloseAdapter = (PFND3DKMT_CLOSEADAPTER)GetProcAddress(hGdi32, "D3DKMTCloseAdapter");
111 Log((__FUNCTION__": pfnD3DKMTCloseAdapter = %p\n", pIf->modeData.wddm.pfnD3DKMTCloseAdapter));
112 bSupported &= !!(pIf->modeData.wddm.pfnD3DKMTCloseAdapter);
113
114 pIf->modeData.wddm.pfnD3DKMTEscape = (PFND3DKMT_ESCAPE)GetProcAddress(hGdi32, "D3DKMTEscape");
115 Log((__FUNCTION__": pfnD3DKMTEscape = %p\n", pIf->modeData.wddm.pfnD3DKMTEscape));
116 bSupported &= !!(pIf->modeData.wddm.pfnD3DKMTCloseAdapter);
117
118 pIf->modeData.wddm.pfnD3DKMTInvalidateActiveVidPn = (PFND3DKMT_INVALIDATEACTIVEVIDPN)GetProcAddress(hGdi32, "D3DKMTInvalidateActiveVidPn");
119 Log((__FUNCTION__": pfnD3DKMTInvalidateActiveVidPn = %p\n", pIf->modeData.wddm.pfnD3DKMTInvalidateActiveVidPn));
120 bSupported &= !!(pIf->modeData.wddm.pfnD3DKMTInvalidateActiveVidPn);
121
122 pIf->modeData.wddm.pfnD3DKMTPollDisplayChildren = (PFND3DKMT_POLLDISPLAYCHILDREN)GetProcAddress(hGdi32, "D3DKMTPollDisplayChildren");
123 Log((__FUNCTION__": pfnD3DKMTPollDisplayChildren = %p\n", pIf->modeData.wddm.pfnD3DKMTPollDisplayChildren));
124 bSupported &= !!(pIf->modeData.wddm.pfnD3DKMTPollDisplayChildren);
125
126 if (!bSupported)
127 {
128 Log((__FUNCTION__": one of pfnD3DKMT function pointers failed to initialize\n"));
129 err = ERROR_NOT_SUPPORTED;
130 }
131 }
132 else
133 {
134 Log((__FUNCTION__": GetModuleHandle(gdi32) failed, err(%d)\n", GetLastError()));
135 err = ERROR_NOT_SUPPORTED;
136 }
137
138 }
139 else
140 {
141 Log((__FUNCTION__": GetModuleHandle(USER32) failed, err(%d)\n", GetLastError()));
142 err = ERROR_NOT_SUPPORTED;
143 }
144 }
145 else
146 {
147 Log((__FUNCTION__": can not switch to VBOXDISPIF_MODE_WDDM, because os is not Vista or upper\n"));
148 err = ERROR_NOT_SUPPORTED;
149 }
150
151 if (err == ERROR_SUCCESS)
152 {
153 err = vboxDispIfWddmInit(pIf);
154 }
155
156 return err;
157}
158
159static DWORD vboxDispIfWDDMAdpHdcCreate(int iDisplay, HDC *phDc, DISPLAY_DEVICE *pDev)
160{
161 DWORD winEr = ERROR_INVALID_STATE;
162 memset(pDev, 0, sizeof (*pDev));
163 pDev->cb = sizeof (*pDev);
164
165 for (int i = 0; ; ++i)
166 {
167 if (EnumDisplayDevices(NULL, /* LPCTSTR lpDevice */ i, /* DWORD iDevNum */
168 pDev, 0 /* DWORD dwFlags*/))
169 {
170 if (i == iDisplay || (iDisplay < 0 && pDev->StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE))
171 {
172 HDC hDc = CreateDC(NULL, pDev->DeviceName, NULL, NULL);
173 if (hDc)
174 {
175 *phDc = hDc;
176 return NO_ERROR;
177 }
178 else
179 {
180 winEr = GetLastError();
181 Log(("CreateDC failed %d", winEr));
182 break;
183 }
184 }
185 Log(("display data no match display(%d): i(%d), flags(%d)", iDisplay, i, pDev->StateFlags));
186 }
187 else
188 {
189 winEr = GetLastError();
190 Log(("EnumDisplayDevices failed %d", winEr));
191 break;
192 }
193 }
194
195 Log(("vboxDispIfWDDMAdpHdcCreate failure branch %d", winEr));
196 return winEr;
197}
198
199
200typedef DECLCALLBACK(BOOLEAN) FNVBOXDISPIFWDDM_ADAPTEROP(PCVBOXDISPIF pIf, D3DKMT_HANDLE hAdapter, DISPLAY_DEVICE *pDev, PVOID pContext);
201typedef FNVBOXDISPIFWDDM_ADAPTEROP *PFNVBOXDISPIFWDDM_ADAPTEROP;
202static DWORD vboxDispIfWDDMAdapterOp(PCVBOXDISPIF pIf, int iDisplay, PFNVBOXDISPIFWDDM_ADAPTEROP pfnOp, PVOID pContext)
203{
204 D3DKMT_OPENADAPTERFROMHDC OpenAdapterData = {0};
205 DISPLAY_DEVICE DDev;
206 DWORD err = vboxDispIfWDDMAdpHdcCreate(iDisplay, &OpenAdapterData.hDc, &DDev);
207 Assert(err == NO_ERROR);
208 if (err == NO_ERROR)
209 {
210 NTSTATUS Status = pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromHdc(&OpenAdapterData);
211 Assert(!Status);
212 if (!Status)
213 {
214 BOOLEAN bCloseAdapter = pfnOp(pIf, OpenAdapterData.hAdapter, &DDev, pContext);
215
216 if (bCloseAdapter)
217 {
218 D3DKMT_CLOSEADAPTER ClosaAdapterData = {0};
219 ClosaAdapterData.hAdapter = OpenAdapterData.hAdapter;
220 Status = pIf->modeData.wddm.pfnD3DKMTCloseAdapter(&ClosaAdapterData);
221 if (Status)
222 {
223 Log((__FUNCTION__": pfnD3DKMTCloseAdapter failed, Status (0x%x)\n", Status));
224 }
225 }
226 }
227 else
228 {
229 Log((__FUNCTION__": pfnD3DKMTOpenAdapterFromGdiDisplayName failed, Status (0x%x)\n", Status));
230 err = ERROR_GEN_FAILURE;
231 }
232
233 DeleteDC(OpenAdapterData.hDc);
234 }
235 else
236 Log((__FUNCTION__": vboxDispIfWDDMAdpHdcCreate failed, winEr (%d)\n", err));
237
238 return err;
239}
240
241typedef struct
242{
243 NTSTATUS Status;
244 PVBOXDISPIFESCAPE pEscape;
245 int cbData;
246 D3DDDI_ESCAPEFLAGS EscapeFlags;
247} VBOXDISPIFWDDM_ESCAPEOP_CONTEXT, *PVBOXDISPIFWDDM_ESCAPEOP_CONTEXT;
248
249DECLCALLBACK(BOOLEAN) vboxDispIfEscapeWDDMOp(PCVBOXDISPIF pIf, D3DKMT_HANDLE hAdapter, DISPLAY_DEVICE *pDev, PVOID pContext)
250{
251 PVBOXDISPIFWDDM_ESCAPEOP_CONTEXT pCtx = (PVBOXDISPIFWDDM_ESCAPEOP_CONTEXT)pContext;
252
253 D3DKMT_ESCAPE EscapeData = {0};
254 EscapeData.hAdapter = hAdapter;
255 //EscapeData.hDevice = NULL;
256 EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
257 EscapeData.Flags = pCtx->EscapeFlags;
258 EscapeData.pPrivateDriverData = pCtx->pEscape;
259 EscapeData.PrivateDriverDataSize = VBOXDISPIFESCAPE_SIZE(pCtx->cbData);
260 //EscapeData.hContext = NULL;
261
262 pCtx->Status = pIf->modeData.wddm.pfnD3DKMTEscape(&EscapeData);
263
264 return TRUE;
265}
266
267static DWORD vboxDispIfEscapeWDDM(PCVBOXDISPIF pIf, PVBOXDISPIFESCAPE pEscape, int cbData, BOOL fHwAccess)
268{
269 VBOXDISPIFWDDM_ESCAPEOP_CONTEXT Ctx = {0};
270 Ctx.pEscape = pEscape;
271 Ctx.cbData = cbData;
272 if (fHwAccess)
273 Ctx.EscapeFlags.HardwareAccess = 1;
274 DWORD err = vboxDispIfWDDMAdapterOp(pIf, -1 /* iDisplay, -1 means primary */, vboxDispIfEscapeWDDMOp, &Ctx);
275 if (err == NO_ERROR)
276 {
277 if (!Ctx.Status)
278 err = NO_ERROR;
279 else
280 {
281 if (Ctx.Status == 0xC00000BBL) /* not supported */
282 err = ERROR_NOT_SUPPORTED;
283 else
284 err = ERROR_GEN_FAILURE;
285 Log((__FUNCTION__": pfnD3DKMTEscape failed, Status (0x%x)\n", Ctx.Status));
286 }
287 }
288 else
289 Log((__FUNCTION__": vboxDispIfWDDMAdapterOp failed, err (%d)\n", err));
290
291 return err;
292}
293
294typedef struct
295{
296 NTSTATUS Status;
297 VBOXWDDM_RECOMMENDVIDPN_SCREEN_INFO Info;
298} VBOXDISPIFWDDM_RESIZEOP_CONTEXT, *PVBOXDISPIFWDDM_RESIZEOP_CONTEXT;
299
300DECLCALLBACK(BOOLEAN) vboxDispIfResizeWDDMOp(PCVBOXDISPIF pIf, D3DKMT_HANDLE hAdapter, DISPLAY_DEVICE *pDev, PVOID pContext)
301{
302 PVBOXDISPIFWDDM_RESIZEOP_CONTEXT pCtx = (PVBOXDISPIFWDDM_RESIZEOP_CONTEXT)pContext;
303 D3DKMT_INVALIDATEACTIVEVIDPN IAVidPnData = {0};
304 uint32_t cbData = VBOXWDDM_RECOMMENDVIDPN_SIZE(1);
305 PVBOXWDDM_RECOMMENDVIDPN pData = (PVBOXWDDM_RECOMMENDVIDPN)malloc(cbData);
306 if (pData)
307 {
308 memset(pData, 0, cbData);
309 pData->cScreenInfos = 1;
310 memcpy(&pData->aScreenInfos[0], &pCtx->Info, sizeof (VBOXWDDM_RECOMMENDVIDPN_SCREEN_INFO));
311
312 IAVidPnData.hAdapter = hAdapter;
313 IAVidPnData.pPrivateDriverData = pData;
314 IAVidPnData.PrivateDriverDataSize = cbData;
315
316 pCtx->Status = pIf->modeData.wddm.pfnD3DKMTInvalidateActiveVidPn(&IAVidPnData);
317 Assert(!pCtx->Status);
318 if (pCtx->Status)
319 Log((__FUNCTION__": pfnD3DKMTInvalidateActiveVidPn failed, Status (0x%x)\n", pCtx->Status));
320
321 free(pData);
322 }
323 else
324 {
325 Log((__FUNCTION__": malloc failed\n"));
326 pCtx->Status = -1;
327 }
328
329 return TRUE;
330}
331
332static DWORD vboxDispIfResizeWDDM(PCVBOXDISPIF const pIf, ULONG Id, DWORD Width, DWORD Height, DWORD BitsPerPixel)
333{
334 VBOXDISPIFWDDM_RESIZEOP_CONTEXT Ctx = {0};
335 Ctx.Info.Id = Id;
336 Ctx.Info.Width = Width;
337 Ctx.Info.Height = Height;
338 Ctx.Info.BitsPerPixel = BitsPerPixel;
339 DWORD err = vboxDispIfWDDMAdapterOp(pIf, -1, /* (int)Id - always say -1 to use primary display since the display does not really matter here */
340 vboxDispIfResizeWDDMOp, &Ctx);
341 if (err == NO_ERROR)
342 {
343 if (!Ctx.Status)
344 err = NO_ERROR;
345 else
346 {
347 if (Ctx.Status == 0xC00000BBL) /* not supported */
348 err = ERROR_NOT_SUPPORTED;
349 else
350 err = ERROR_GEN_FAILURE;
351 Log((__FUNCTION__": vboxDispIfResizeWDDMOp failed, Status (0x%x)\n", Ctx.Status));
352 }
353 }
354 else
355 Log((__FUNCTION__": vboxDispIfWDDMAdapterOp failed, err (%d)\n", err));
356
357 return err;
358}
359#endif
360
361DWORD VBoxDispIfEscape(PCVBOXDISPIF pIf, PVBOXDISPIFESCAPE pEscape, int cbData)
362{
363 switch (pIf->enmMode)
364 {
365 case VBOXDISPIF_MODE_XPDM_NT4:
366 case VBOXDISPIF_MODE_XPDM:
367 return vboxDispIfEscapeXPDM(pIf, pEscape, cbData, 1);
368#ifdef VBOX_WITH_WDDM
369 case VBOXDISPIF_MODE_WDDM:
370 return vboxDispIfEscapeWDDM(pIf, pEscape, cbData, TRUE /* BOOL fHwAccess */);
371#endif
372 default:
373 Log((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode));
374 return ERROR_INVALID_PARAMETER;
375 }
376}
377
378DWORD VBoxDispIfEscapeInOut(PCVBOXDISPIF const pIf, PVBOXDISPIFESCAPE pEscape, int cbData)
379{
380 switch (pIf->enmMode)
381 {
382 case VBOXDISPIF_MODE_XPDM_NT4:
383 case VBOXDISPIF_MODE_XPDM:
384 return vboxDispIfEscapeXPDM(pIf, pEscape, cbData, 0);
385#ifdef VBOX_WITH_WDDM
386 case VBOXDISPIF_MODE_WDDM:
387 return vboxDispIfEscapeWDDM(pIf, pEscape, cbData, TRUE /* BOOL fHwAccess */);
388#endif
389 default:
390 Log((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode));
391 return ERROR_INVALID_PARAMETER;
392 }
393}
394
395static DWORD vboxDispIfResizeXPDM(PCVBOXDISPIF const pIf, ULONG Id, DWORD Width, DWORD Height, DWORD BitsPerPixel)
396{
397 return ERROR_NOT_SUPPORTED;
398}
399
400DWORD VBoxDispIfResize(PCVBOXDISPIF const pIf, ULONG Id, DWORD Width, DWORD Height, DWORD BitsPerPixel)
401{
402 switch (pIf->enmMode)
403 {
404 case VBOXDISPIF_MODE_XPDM_NT4:
405 return ERROR_NOT_SUPPORTED;
406 case VBOXDISPIF_MODE_XPDM:
407 return vboxDispIfResizeXPDM(pIf, Id, Width, Height, BitsPerPixel);
408#ifdef VBOX_WITH_WDDM
409 case VBOXDISPIF_MODE_WDDM:
410 return vboxDispIfResizeWDDM(pIf, Id, Width, Height, BitsPerPixel);
411#endif
412 default:
413 Log((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode));
414 return ERROR_INVALID_PARAMETER;
415 }
416}
417
418
419#ifdef VBOX_WITH_WDDM
420/**/
421typedef DECLCALLBACK(VOID) FNVBOXSCREENMONRUNNER_CB(void *pvCb);
422typedef FNVBOXSCREENMONRUNNER_CB *PFNVBOXSCREENMONRUNNER_CB;
423
424typedef struct VBOXSCREENMON
425{
426 HANDLE hThread;
427 DWORD idThread;
428 HANDLE hEvent;
429 HWND hWnd;
430 PFNVBOXSCREENMONRUNNER_CB pfnCb;
431 void *pvCb;
432} VBOXSCREENMON, *PVBOXSCREENMON;
433
434
435static VBOXSCREENMON g_VBoxScreenMon;
436
437
438#define VBOX_E_INSUFFICIENT_BUFFER HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)
439#define VBOX_E_NOT_SUPPORTED HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED)
440
441
442static void vboxScreenMonOnChange()
443{
444 PVBOXSCREENMON pMon = &g_VBoxScreenMon;
445 pMon->pfnCb(pMon->pvCb);
446}
447
448static LRESULT CALLBACK vboxScreenMonWndProc(HWND hwnd,
449 UINT uMsg,
450 WPARAM wParam,
451 LPARAM lParam
452)
453{
454 switch(uMsg)
455 {
456 case WM_DISPLAYCHANGE:
457 {
458 vboxScreenMonOnChange();
459 }
460 case WM_CLOSE:
461 Log((__FUNCTION__": got WM_CLOSE for hwnd(0x%x)", hwnd));
462 return 0;
463 case WM_DESTROY:
464 Log((__FUNCTION__": got WM_DESTROY for hwnd(0x%x)", hwnd));
465 return 0;
466 case WM_NCHITTEST:
467 Log((__FUNCTION__": got WM_NCHITTEST for hwnd(0x%x)\n", hwnd));
468 return HTNOWHERE;
469 }
470
471 return DefWindowProc(hwnd, uMsg, wParam, lParam);
472}
473
474#define VBOXSCREENMONWND_NAME "VboxScreenMonWnd"
475
476static HRESULT vboxScreenMonWndCreate(HWND *phWnd)
477{
478 HRESULT hr = S_OK;
479 HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
480 /* Register the Window Class. */
481 WNDCLASS wc;
482 if (!GetClassInfo(hInstance, VBOXSCREENMONWND_NAME, &wc))
483 {
484 wc.style = 0;//CS_OWNDC;
485 wc.lpfnWndProc = vboxScreenMonWndProc;
486 wc.cbClsExtra = 0;
487 wc.cbWndExtra = 0;
488 wc.hInstance = hInstance;
489 wc.hIcon = NULL;
490 wc.hCursor = NULL;
491 wc.hbrBackground = NULL;
492 wc.lpszMenuName = NULL;
493 wc.lpszClassName = VBOXSCREENMONWND_NAME;
494 if (!RegisterClass(&wc))
495 {
496 DWORD winErr = GetLastError();
497 Log((__FUNCTION__": RegisterClass failed, winErr(%d)\n", winErr));
498 hr = E_FAIL;
499 }
500 }
501
502 if (hr == S_OK)
503 {
504 HWND hWnd = CreateWindowEx (WS_EX_TOOLWINDOW,
505 VBOXSCREENMONWND_NAME, VBOXSCREENMONWND_NAME,
506 WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED,
507 -100, -100,
508 10, 10,
509 NULL, //GetDesktopWindow() /* hWndParent */,
510 NULL /* hMenu */,
511 hInstance,
512 NULL /* lpParam */);
513 Assert(hWnd);
514 if (hWnd)
515 {
516 *phWnd = hWnd;
517 }
518 else
519 {
520 DWORD winErr = GetLastError();
521 Log((__FUNCTION__": CreateWindowEx failed, winErr(%d)\n", winErr));
522 hr = E_FAIL;
523 }
524 }
525
526 return hr;
527}
528
529static HRESULT vboxScreenMonWndDestroy(HWND hWnd)
530{
531 BOOL bResult = DestroyWindow(hWnd);
532 if (bResult)
533 return S_OK;
534
535 DWORD winErr = GetLastError();
536 Log((__FUNCTION__": DestroyWindow failed, winErr(%d) for hWnd(0x%x)\n", winErr, hWnd));
537 Assert(0);
538
539 return HRESULT_FROM_WIN32(winErr);
540}
541
542static HRESULT vboxScreenMonWndInit()
543{
544 PVBOXSCREENMON pMon = &g_VBoxScreenMon;
545 return vboxScreenMonWndCreate(&pMon->hWnd);
546}
547
548HRESULT vboxScreenMonWndTerm()
549{
550 PVBOXSCREENMON pMon = &g_VBoxScreenMon;
551 HRESULT tmpHr = vboxScreenMonWndDestroy(pMon->hWnd);
552 Assert(tmpHr == S_OK);
553
554 HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
555 UnregisterClass(VBOXSCREENMONWND_NAME, hInstance);
556
557 return S_OK;
558}
559
560#define WM_VBOXSCREENMON_INIT_QUIT (WM_APP+2)
561
562HRESULT vboxScreenMonRun()
563{
564 PVBOXSCREENMON pMon = &g_VBoxScreenMon;
565 MSG Msg;
566
567 HRESULT hr = S_FALSE;
568
569 PeekMessage(&Msg,
570 NULL /* HWND hWnd */,
571 WM_USER /* UINT wMsgFilterMin */,
572 WM_USER /* UINT wMsgFilterMax */,
573 PM_NOREMOVE);
574
575 BOOL bCheck = TRUE;
576
577 do
578 {
579 if (bCheck)
580 {
581 vboxScreenMonOnChange();
582
583 bCheck = FALSE;
584 }
585
586 BOOL bResult = GetMessage(&Msg,
587 0 /*HWND hWnd*/,
588 0 /*UINT wMsgFilterMin*/,
589 0 /*UINT wMsgFilterMax*/
590 );
591
592 if(!bResult) /* WM_QUIT was posted */
593 {
594 hr = S_FALSE;
595 break;
596 }
597
598 if(bResult == -1) /* error occurred */
599 {
600 DWORD winEr = GetLastError();
601 hr = HRESULT_FROM_WIN32(winEr);
602 Assert(0);
603 /* just ensure we never return success in this case */
604 Assert(hr != S_OK);
605 Assert(hr != S_FALSE);
606 if (hr == S_OK || hr == S_FALSE)
607 hr = E_FAIL;
608 break;
609 }
610
611 switch (Msg.message)
612 {
613 case WM_VBOXSCREENMON_INIT_QUIT:
614 case WM_CLOSE:
615 {
616 PostQuitMessage(0);
617 break;
618 }
619 case WM_DISPLAYCHANGE:
620 bCheck = TRUE;
621 default:
622 TranslateMessage(&Msg);
623 DispatchMessage(&Msg);
624 break;
625 }
626 } while (1);
627 return 0;
628}
629
630static DWORD WINAPI vboxScreenMonRunnerThread(void *pvUser)
631{
632 PVBOXSCREENMON pMon = &g_VBoxScreenMon;
633
634 BOOL bRc = SetEvent(pMon->hEvent);
635 if (!bRc)
636 {
637 DWORD winErr = GetLastError();
638 Log((__FUNCTION__": SetEvent failed, winErr = (%d)", winErr));
639 HRESULT tmpHr = HRESULT_FROM_WIN32(winErr);
640 Assert(0);
641 Assert(tmpHr != S_OK);
642 }
643
644 HRESULT hr = vboxScreenMonWndInit();
645 Assert(hr == S_OK);
646 if (hr == S_OK)
647 {
648 hr = vboxScreenMonRun();
649 Assert(hr == S_OK);
650
651 vboxScreenMonWndTerm();
652 }
653
654 return 0;
655}
656
657HRESULT VBoxScreenMonInit(PFNVBOXSCREENMONRUNNER_CB pfnCb, void *pvCb)
658{
659 HRESULT hr = E_FAIL;
660 PVBOXSCREENMON pMon = &g_VBoxScreenMon;
661 memset(pMon, 0, sizeof (*pMon));
662
663 pMon->pfnCb = pfnCb;
664 pMon->pvCb = pvCb;
665
666 pMon->hEvent = CreateEvent(NULL, /* LPSECURITY_ATTRIBUTES lpEventAttributes*/
667 TRUE, /* BOOL bManualReset*/
668 FALSE, /* BOOL bInitialState */
669 NULL /* LPCTSTR lpName */
670 );
671 if (pMon->hEvent)
672 {
673 pMon->hThread = CreateThread(NULL /* LPSECURITY_ATTRIBUTES lpThreadAttributes */,
674 0 /* SIZE_T dwStackSize */,
675 vboxScreenMonRunnerThread,
676 pMon,
677 0 /* DWORD dwCreationFlags */,
678 &pMon->idThread);
679 if (pMon->hThread)
680 {
681 DWORD dwResult = WaitForSingleObject(pMon->hEvent, INFINITE);
682 if (dwResult == WAIT_OBJECT_0)
683 return S_OK;
684 else
685 {
686 Log(("WaitForSingleObject failed!"));
687 hr = E_FAIL;
688 }
689 }
690 else
691 {
692 DWORD winErr = GetLastError();
693 Log((__FUNCTION__": CreateThread failed, winErr = (%d)", winErr));
694 hr = HRESULT_FROM_WIN32(winErr);
695 Assert(0);
696 Assert(hr != S_OK);
697 }
698 CloseHandle(pMon->hEvent);
699 }
700 else
701 {
702 DWORD winErr = GetLastError();
703 Log((__FUNCTION__": CreateEvent failed, winErr = (%d)", winErr));
704 hr = HRESULT_FROM_WIN32(winErr);
705 Assert(0);
706 Assert(hr != S_OK);
707 }
708
709 return hr;
710}
711
712VOID VBoxScreenMonTerm()
713{
714 HRESULT hr;
715 PVBOXSCREENMON pMon = &g_VBoxScreenMon;
716 if (!pMon->hThread)
717 return;
718
719 BOOL bResult = PostThreadMessage(pMon->idThread, WM_VBOXSCREENMON_INIT_QUIT, 0, 0);
720 DWORD winErr;
721 if (bResult
722 || (winErr = GetLastError()) == ERROR_INVALID_THREAD_ID) /* <- could be that the thread is terminated */
723 {
724 DWORD dwErr = WaitForSingleObject(pMon->hThread, INFINITE);
725 if (dwErr == WAIT_OBJECT_0)
726 {
727 hr = S_OK;
728 }
729 else
730 {
731 winErr = GetLastError();
732 hr = HRESULT_FROM_WIN32(winErr);
733 Assert(0);
734 }
735 }
736 else
737 {
738 hr = HRESULT_FROM_WIN32(winErr);
739 Assert(0);
740 }
741
742 CloseHandle(pMon->hThread);
743 pMon->hThread = 0;
744 CloseHandle(pMon->hEvent);
745 pMon->hThread = 0;
746}
747/**/
748
749typedef struct VBOXDISPIF_WDDM_INTERNAL
750{
751 PCVBOXDISPIF pIf;
752
753 HANDLE hResizeEvent;
754} VBOXDISPIF_WDDM_INTERNAL, *PVBOXDISPIF_WDDM_INTERNAL;
755
756static VBOXDISPIF_WDDM_INTERNAL g_VBoxDispIfWddm;
757
758static BOOL vboxDispIfWddmValidateResize(DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes)
759{
760 DISPLAY_DEVICE DisplayDevice;
761 int i = 0;
762 UINT cMatched = 0;
763 DEVMODE CurDevMode, RegDevMode;
764 for (int i = 0; ; ++i)
765 {
766 ZeroMemory(&DisplayDevice, sizeof(DISPLAY_DEVICE));
767 DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
768
769 if (!EnumDisplayDevices (NULL, i, &DisplayDevice, 0))
770 break;
771
772 Log(("VBoxTray: vboxDispIfValidateResize: [%d(%d)] %s\n", i, cMatched, DisplayDevice.DeviceName));
773
774 BOOL bFetchDevice = FALSE;
775
776 if (DisplayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
777 {
778 Log(("VBoxTray: vboxDispIfValidateResize: Found primary device. err %d\n", GetLastError ()));
779 bFetchDevice = TRUE;
780 }
781 else if (!(DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
782 {
783
784 Log(("VBoxTray: vboxDispIfValidateResize: Found secondary device. err %d\n", GetLastError ()));
785 bFetchDevice = TRUE;
786 }
787
788 if (bFetchDevice)
789 {
790 if (cMatched >= cDevModes)
791 {
792 Log(("VBoxTray: vboxDispIfValidateResize: %d >= %d\n", cDevModes, cMatched));
793 return FALSE;
794 }
795
796 /* First try to get the video mode stored in registry (ENUM_REGISTRY_SETTINGS).
797 * A secondary display could be not active at the moment and would not have
798 * a current video mode (ENUM_CURRENT_SETTINGS).
799 */
800 ZeroMemory(&RegDevMode, sizeof(RegDevMode));
801 RegDevMode.dmSize = sizeof(DEVMODE);
802 if (!EnumDisplaySettings((LPSTR)DisplayDevice.DeviceName,
803 ENUM_REGISTRY_SETTINGS, &RegDevMode))
804 {
805 Log(("VBoxTray: vboxDispIfValidateResize: EnumDisplaySettings error %d\n", GetLastError ()));
806 return FALSE;
807 }
808
809 /* with Win8 WDDM Display-only driver, it seems like sometimes we get an auto-resize setting being stored in registry, although current settings do not match */
810 ZeroMemory(&CurDevMode, sizeof(CurDevMode));
811 CurDevMode.dmSize = sizeof(CurDevMode);
812 if (!EnumDisplaySettings((LPSTR)DisplayDevice.DeviceName,
813 ENUM_CURRENT_SETTINGS, &CurDevMode))
814 {
815 /* ENUM_CURRENT_SETTINGS returns FALSE when the display is not active:
816 * for example a disabled secondary display */
817 Log(("VBoxTray: vboxDispIfValidateResize: EnumDisplaySettings(ENUM_CURRENT_SETTINGS) error %d\n", GetLastError ()));
818 return FALSE;
819 }
820
821 /* No ENUM_REGISTRY_SETTINGS yet. Seen on Vista after installation.
822 * Get the current video mode then.
823 */
824 if ( RegDevMode.dmPelsWidth != 0
825 && RegDevMode.dmPelsHeight == 0)
826 {
827 if (CurDevMode.dmBitsPerPel != RegDevMode.dmBitsPerPel
828 || CurDevMode.dmPelsWidth != RegDevMode.dmPelsWidth
829 || CurDevMode.dmPelsHeight != RegDevMode.dmPelsHeight
830 || CurDevMode.dmPosition.x != RegDevMode.dmPosition.x
831 || CurDevMode.dmPosition.y != RegDevMode.dmPosition.y)
832 {
833 Log(("VBoxTray: vboxDispIfValidateResize: current settings do not match registry settings, trating as no-match"));
834 return FALSE;
835 }
836 }
837
838 UINT j = 0;
839 for (; j < cDevModes; ++j)
840 {
841 if (!strncmp(DisplayDevice.DeviceName, paDisplayDevices[j].DeviceName, RT_ELEMENTS(CurDevMode.dmDeviceName)))
842 {
843 if (paDeviceModes[j].dmBitsPerPel != CurDevMode.dmBitsPerPel
844 || (paDeviceModes[j].dmPelsWidth & 0xfff8) != (CurDevMode.dmPelsWidth & 0xfff8)
845 || (paDeviceModes[j].dmPelsHeight & 0xfff8) != (CurDevMode.dmPelsHeight & 0xfff8)
846 || (paDeviceModes[j].dmPosition.x & 0xfff8) != (CurDevMode.dmPosition.x & 0xfff8)
847 || (paDeviceModes[j].dmPosition.y & 0xfff8) != (CurDevMode.dmPosition.y & 0xfff8)
848 || (paDisplayDevices[j].StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) != (DisplayDevice.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP))
849 {
850 return FALSE;
851 }
852 break;
853 }
854 }
855
856 if (j == cDevModes)
857 return FALSE;
858
859 ++cMatched;
860 }
861 }
862
863 return cMatched == cDevModes;
864}
865
866static DWORD vboxDispIfWddmValidateFixResize(PCVBOXDISPIF const pIf, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes)
867{
868 if (vboxDispIfWddmValidateResize(paDisplayDevices, paDeviceModes, cDevModes))
869 return NO_ERROR;
870
871 DWORD winEr;
872 LONG status = DISP_CHANGE_SUCCESSFUL;
873
874 /* now try to resize in a "regular" way */
875 /* Assign the new rectangles to displays. */
876 for (UINT i = 0; i < cDevModes; i++)
877 {
878 /* On Vista one must specify DM_BITSPERPEL.
879 * Note that the current mode dmBitsPerPel is already in the DEVMODE structure.
880 */
881 paDeviceModes[i].dmFields = DM_POSITION | DM_PELSHEIGHT | DM_PELSWIDTH | DM_BITSPERPEL;
882
883 Log(("VBoxTray: ResizeDisplayDevice: pfnChangeDisplaySettingsEx %x: %dx%dx%d at %d,%d\n",
884 pIf->modeData.wddm.pfnChangeDisplaySettingsEx,
885 paDeviceModes[i].dmPelsWidth,
886 paDeviceModes[i].dmPelsHeight,
887 paDeviceModes[i].dmBitsPerPel,
888 paDeviceModes[i].dmPosition.x,
889 paDeviceModes[i].dmPosition.y));
890
891 /* the miniport might have been adjusted the display mode stuff,
892 * adjust the paDeviceModes[i] by picking the closest available one */
893// DEVMODE AdjustedMode = paDeviceModes[i];
894// vboxDispIfAdjustMode(&paDisplayDevices[i], &AdjustedMode);
895
896 LONG tmpStatus = pIf->modeData.wddm.pfnChangeDisplaySettingsEx((LPSTR)paDisplayDevices[i].DeviceName,
897 &paDeviceModes[i], NULL, CDS_NORESET | CDS_UPDATEREGISTRY, NULL);
898 Log(("VBoxTray: ResizeDisplayDevice: ChangeDisplaySettingsEx position status %d, err %d\n", tmpStatus, GetLastError ()));
899
900 if (tmpStatus != DISP_CHANGE_SUCCESSFUL)
901 {
902 status = tmpStatus;
903 }
904 }
905
906 /* A second call to ChangeDisplaySettings updates the monitor. */
907 LONG tmpStatus = pIf->modeData.wddm.pfnChangeDisplaySettingsEx(NULL, NULL, NULL, 0, NULL);
908 Log(("VBoxTray: ResizeDisplayDevice: ChangeDisplaySettings update status %d\n", status));
909 if (tmpStatus == DISP_CHANGE_SUCCESSFUL)
910 {
911 if (status == DISP_CHANGE_SUCCESSFUL)
912 {
913 return NO_ERROR;
914 }
915 tmpStatus = status;
916 }
917
918 winEr = ERROR_GEN_FAILURE;
919 return winEr;
920}
921
922static DECLCALLBACK(VOID) vboxDispIfWddmScreenMonCb(void *pvCb)
923{
924 PVBOXDISPIF_WDDM_INTERNAL pData = (PVBOXDISPIF_WDDM_INTERNAL)pvCb;
925
926 SetEvent(pData->hResizeEvent);
927}
928
929static DWORD vboxDispIfWddmInit(PCVBOXDISPIF pIf)
930{
931 memset(&g_VBoxDispIfWddm, 0, sizeof (g_VBoxDispIfWddm));
932 g_VBoxDispIfWddm.pIf = pIf;
933 g_VBoxDispIfWddm.hResizeEvent = CreateEvent(NULL,
934 FALSE, /* BOOL bManualReset */
935 FALSE, /* BOOL bInitialState */
936 NULL /* LPCTSTR lpName */
937 );
938 if (g_VBoxDispIfWddm.hResizeEvent)
939 {
940 HRESULT hr = VBoxScreenMonInit(vboxDispIfWddmScreenMonCb, &g_VBoxDispIfWddm);
941 if (SUCCEEDED(hr))
942 {
943 /* ensure event is reset */
944 WaitForSingleObject(g_VBoxDispIfWddm.hResizeEvent, 0);
945 return ERROR_SUCCESS;
946 }
947 CloseHandle(g_VBoxDispIfWddm.hResizeEvent);
948 }
949 return ERROR_GEN_FAILURE;
950}
951
952static void vboxDispIfWddmTerm(PCVBOXDISPIF pIf)
953{
954 VBoxScreenMonTerm();
955 CloseHandle(g_VBoxDispIfWddm.hResizeEvent);
956 memset(&g_VBoxDispIfWddm, 0, sizeof (g_VBoxDispIfWddm));
957}
958
959typedef struct VBOXDISPIF_REINITMODES_OP
960{
961 VBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK EscData;
962} VBOXDISPIF_REINITMODES_OP, *PVBOXDISPIF_REINITMODES_OP;
963
964static DECLCALLBACK(BOOLEAN) vboxDispIfReninitModesWDDMOp(PCVBOXDISPIF pIf, D3DKMT_HANDLE hAdapter, DISPLAY_DEVICE *pDev, PVOID pContext)
965{
966 PVBOXDISPIF_REINITMODES_OP pData = (PVBOXDISPIF_REINITMODES_OP)pContext;
967 VBOXDISPIFWDDM_ESCAPEOP_CONTEXT Ctx = {0};
968 Ctx.pEscape = &pData->EscData.EscapeHdr;
969 Ctx.cbData = sizeof (pData->EscData) - sizeof (pData->EscData.EscapeHdr);
970// Ctx.EscapeFlags.HardwareAccess = 0;
971 DWORD err = vboxDispIfWDDMAdapterOp(pIf, -1 /* iDisplay, -1 means primary */, vboxDispIfEscapeWDDMOp, &Ctx);
972 if (err == NO_ERROR)
973 {
974 if (!Ctx.Status)
975 err = NO_ERROR;
976 else
977 {
978 if (Ctx.Status == 0xC00000BBL) /* not supported */
979 err = ERROR_NOT_SUPPORTED;
980 else
981 err = ERROR_GEN_FAILURE;
982 Log((__FUNCTION__": pfnD3DKMTEscape failed, Status (0x%x)\n", Ctx.Status));
983 }
984 }
985 else
986 Log((__FUNCTION__": vboxDispIfWDDMAdapterOp failed, err (%d)\n", err));
987
988 D3DKMT_POLLDISPLAYCHILDREN PollData = {0};
989 PollData.hAdapter = hAdapter;
990 PollData.NonDestructiveOnly = 1;
991 NTSTATUS Status = pIf->modeData.wddm.pfnD3DKMTPollDisplayChildren(&PollData);
992 if (Status != 0)
993 {
994 Log((__FUNCTION__": pfnD3DKMTPollDisplayChildren failed, Status (0x%x)\n", Status));
995 }
996 return TRUE;
997}
998
999static DWORD vboxDispIfReninitModesWDDM(PCVBOXDISPIF const pIf, uint8_t *pScreenIdMask, BOOL fReconnectDisplaysOnChange)
1000{
1001 VBOXDISPIF_REINITMODES_OP OpData = {0};
1002 OpData.EscData.EscapeHdr.escapeCode = VBOXESC_REINITVIDEOMODESBYMASK;
1003 if (fReconnectDisplaysOnChange)
1004 OpData.EscData.EscapeHdr.u32CmdSpecific = VBOXWDDM_REINITVIDEOMODESBYMASK_F_RECONNECT_DISPLAYS_ON_CHANGE;
1005
1006 memcpy(OpData.EscData.ScreenMask, pScreenIdMask, sizeof (OpData.EscData.ScreenMask));
1007
1008 DWORD err = vboxDispIfWDDMAdapterOp(pIf, -1 /* iDisplay, -1 means primary */, vboxDispIfReninitModesWDDMOp, &OpData);
1009 return err;
1010}
1011
1012static DWORD vboxDispIfAdjustMode(DISPLAY_DEVICE *pDisplayDevice, DEVMODE *pDeviceMode)
1013{
1014 DEVMODE CurMode;
1015 DEVMODE BestMatchMode;
1016 DWORD i = 0;
1017 int64_t diffWH = INT64_MAX;
1018 int diffBpp = INT32_MAX;
1019 for (; ; ++i)
1020 {
1021 CurMode.dmSize = sizeof (CurMode);
1022 CurMode.dmDriverExtra = 0;
1023
1024 if (!EnumDisplaySettings(pDisplayDevice->DeviceName, i, &CurMode))
1025 break;
1026
1027 if (CurMode.dmPelsWidth == pDeviceMode->dmPelsWidth
1028 && CurMode.dmPelsHeight == pDeviceMode->dmPelsHeight
1029 && CurMode.dmBitsPerPel == pDeviceMode->dmBitsPerPel)
1030 {
1031 Log(("Exact match found"));
1032 *pDeviceMode = CurMode;
1033 return NO_ERROR;
1034 }
1035
1036 int diffCurrW = RT_ABS((int)(CurMode.dmPelsWidth - pDeviceMode->dmPelsWidth));
1037 int diffCurrH = RT_ABS((int)(CurMode.dmPelsHeight - pDeviceMode->dmPelsHeight));
1038 int diffCurrBpp = RT_ABS((int)(CurMode.dmBitsPerPel - pDeviceMode->dmBitsPerPel)
1039 - 1 /* <- to make higher bpp take precedence over lower ones */
1040 );
1041
1042 int64_t diffCurrHW = (int64_t)diffCurrW*diffCurrW + (int64_t)diffCurrH*diffCurrH;
1043
1044 if (i == 0
1045 || diffCurrHW < diffWH
1046 || (diffCurrHW == diffWH && diffCurrBpp < diffBpp))
1047 {
1048 /* first run */
1049 BestMatchMode = CurMode;
1050 diffWH = diffCurrHW;
1051 diffBpp = diffCurrBpp;
1052 continue;
1053 }
1054 }
1055
1056 if (i == 0)
1057 {
1058 Log(("No modes found!"));
1059 return NO_ERROR;
1060 }
1061
1062 *pDeviceMode = BestMatchMode;
1063 return NO_ERROR;
1064}
1065
1066static DWORD vboxDispIfAdjustModeValues(PCVBOXDISPIF const pIf, DISPLAY_DEVICE *pDisplayDevice, DEVMODE *pDeviceMode)
1067{
1068 VBOXDISPIFESCAPE_ADJUSTVIDEOMODES Data = {0};
1069 Data.EscapeHdr.escapeCode = VBOXESC_REINITVIDEOMODESBYMASK;
1070 Data.EscapeHdr.u32CmdSpecific = 1;
1071 Data.aScreenInfos[0].Mode.Id =
1072 Data.aScreenInfos[0].Mode.Width = pDeviceMode->dmPelsWidth;
1073 Data.aScreenInfos[0].Mode.Height = pDeviceMode->dmPelsHeight;
1074 Data.aScreenInfos[0].Mode.BitsPerPixel = pDeviceMode->dmBitsPerPel;
1075 DWORD err = vboxDispIfEscapeWDDM(pIf, &Data.EscapeHdr, sizeof (Data) - sizeof (Data.EscapeHdr), TRUE);
1076 if (err != NO_ERROR)
1077 {
1078 Log((__FUNCTION__": VBoxDispIfEscape failed with err (%d)\n", err));
1079 }
1080 return err;
1081}
1082
1083DWORD vboxDispIfResizeModesWDDM(PCVBOXDISPIF const pIf, UINT iChangedMode, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes)
1084{
1085 UINT cbVidPnInfo = VBOXWDDM_RECOMMENDVIDPN_SIZE(cDevModes);
1086 PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo = (PVBOXWDDM_RECOMMENDVIDPN)alloca(cbVidPnInfo);
1087 pVidPnInfo->cScreenInfos = cDevModes;
1088 D3DKMT_HANDLE hAdapter = NULL;
1089 NTSTATUS Status;
1090 DWORD winEr = NO_ERROR;
1091 UINT i = 0;
1092
1093 for (; i < cDevModes; i++)
1094 {
1095 PVBOXWDDM_RECOMMENDVIDPN_SCREEN_INFO pInfo = &pVidPnInfo->aScreenInfos[i];
1096 D3DKMT_OPENADAPTERFROMHDC OpenAdapterData = {0};
1097 OpenAdapterData.hDc = CreateDC(NULL, paDisplayDevices[i].DeviceName, NULL, NULL);
1098 if (!OpenAdapterData.hDc)
1099 {
1100 winEr = GetLastError();
1101 Log(("WARNING: Failed to get dc for display device %s, winEr %d\n", paDisplayDevices[i].DeviceName, winEr));
1102 break;
1103 }
1104
1105 Status = pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromHdc(&OpenAdapterData);
1106 Assert(!Status);
1107 if (Status)
1108 {
1109 winEr = ERROR_GEN_FAILURE;
1110 Log(("WARNING: Failed to open adapter from dc, Status 0x%x\n", Status));
1111 break;
1112 }
1113
1114 pInfo->Id = OpenAdapterData.VidPnSourceId;
1115 pInfo->Width = paDeviceModes[i].dmPelsWidth;
1116 pInfo->Height = paDeviceModes[i].dmPelsHeight;
1117 pInfo->BitsPerPixel = paDeviceModes[i].dmBitsPerPel;
1118
1119 if (!hAdapter)
1120 {
1121 hAdapter = OpenAdapterData.hAdapter;
1122 }
1123 else
1124 {
1125 D3DKMT_CLOSEADAPTER ClosaAdapterData = {0};
1126 ClosaAdapterData.hAdapter = OpenAdapterData.hAdapter;
1127 Status = pIf->modeData.wddm.pfnD3DKMTCloseAdapter(&ClosaAdapterData);
1128 if (Status)
1129 Log(("WARNING: Failed to close adapter, Status 0x%x\n", Status));
1130 }
1131 }
1132
1133 BOOL fAbleToInvalidateVidPn = FALSE;
1134
1135 if (winEr == NO_ERROR)
1136 {
1137 Assert(hAdapter);
1138
1139 D3DKMT_INVALIDATEACTIVEVIDPN IAVidPnData = {0};
1140 IAVidPnData.hAdapter = hAdapter;
1141 IAVidPnData.pPrivateDriverData = pVidPnInfo;
1142 IAVidPnData.PrivateDriverDataSize = cbVidPnInfo;
1143
1144 DWORD winEr = NO_ERROR;
1145 Status = pIf->modeData.wddm.pfnD3DKMTInvalidateActiveVidPn(&IAVidPnData);
1146 Assert(!Status);
1147 if (Status)
1148 {
1149 Log((__FUNCTION__": pfnD3DKMTInvalidateActiveVidPn failed, Status (0x%x)\n", Status));
1150 winEr = ERROR_GEN_FAILURE;
1151 }
1152 else
1153 {
1154 fAbleToInvalidateVidPn = TRUE;
1155 }
1156 }
1157
1158 if (hAdapter)
1159 {
1160 D3DKMT_CLOSEADAPTER ClosaAdapterData = {0};
1161 ClosaAdapterData.hAdapter = hAdapter;
1162 Status = pIf->modeData.wddm.pfnD3DKMTCloseAdapter(&ClosaAdapterData);
1163 if (Status)
1164 Log(("WARNING: Failed to close adapter[2], Status 0x%x\n", Status));
1165 }
1166
1167// for (i = 0; i < cDevModes; i++)
1168// {
1169// vboxDispIfAdjustMode(&paDisplayDevices[i], &paDeviceModes[i]);
1170// }
1171
1172 if (fAbleToInvalidateVidPn)
1173 {
1174 Log(("Invalidating VidPn Worked!\n"));
1175 winEr = vboxDispIfWddmValidateFixResize(pIf, paDisplayDevices, paDeviceModes, cDevModes);
1176 }
1177 else
1178 {
1179 Log(("Falling back to monitor mode reinit\n"));
1180 /* fallback impl needed for display-only driver
1181 * since D3DKMTInvalidateActiveVidPn is not available for WDDM > 1.0:
1182 * make the driver invalidate VidPn,
1183 * which is done by emulating a monitor re-plug currently */
1184 /* ensure event is reset */
1185 WaitForSingleObject(g_VBoxDispIfWddm.hResizeEvent, 0);
1186
1187 uint8_t ScreenMask[VBOXWDDM_SCREENMASK_SIZE] = {0};
1188 ASMBitSet(ScreenMask, iChangedMode);
1189 vboxDispIfReninitModesWDDM(pIf, ScreenMask, TRUE);
1190
1191 winEr = vboxDispIfWddmValidateFixResize(pIf, paDisplayDevices, paDeviceModes, cDevModes);
1192
1193// for (UINT i = 0; i < 4; ++i)
1194// {
1195// WaitForSingleObject(g_VBoxDispIfWddm.hResizeEvent, 500);
1196// winEr = vboxDispIfWddmValidateFixResize(pIf, paDisplayDevices, paDeviceModes, cDevModes);
1197// if (winEr == NO_ERROR)
1198// break;
1199// }
1200
1201 Assert(winEr == NO_ERROR);
1202 }
1203
1204 return winEr;
1205}
1206#endif /* VBOX_WITH_WDDM */
1207
1208DWORD VBoxDispIfResizeModes(PCVBOXDISPIF const pIf, UINT iChangedMode, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes)
1209{
1210 switch (pIf->enmMode)
1211 {
1212 case VBOXDISPIF_MODE_XPDM_NT4:
1213 return ERROR_NOT_SUPPORTED;
1214 case VBOXDISPIF_MODE_XPDM:
1215 return ERROR_NOT_SUPPORTED;
1216#ifdef VBOX_WITH_WDDM
1217 case VBOXDISPIF_MODE_WDDM:
1218 return vboxDispIfResizeModesWDDM(pIf, iChangedMode, paDisplayDevices, paDeviceModes, cDevModes);
1219#endif
1220 default:
1221 Log((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode));
1222 return ERROR_INVALID_PARAMETER;
1223 }
1224}
1225
1226DWORD VBoxDispIfReninitModes(PCVBOXDISPIF const pIf, uint8_t *pScreenIdMask, BOOL fReconnectDisplaysOnChange)
1227{
1228 switch (pIf->enmMode)
1229 {
1230 case VBOXDISPIF_MODE_XPDM_NT4:
1231 return ERROR_NOT_SUPPORTED;
1232 case VBOXDISPIF_MODE_XPDM:
1233 return ERROR_NOT_SUPPORTED;
1234#ifdef VBOX_WITH_WDDM
1235 case VBOXDISPIF_MODE_WDDM:
1236 return vboxDispIfReninitModesWDDM(pIf, pScreenIdMask, fReconnectDisplaysOnChange);
1237#endif
1238 default:
1239 Log((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode));
1240 return ERROR_INVALID_PARAMETER;
1241 }
1242}
1243
1244static DWORD vboxDispIfSwitchToXPDM_NT4(PVBOXDISPIF pIf)
1245{
1246 return NO_ERROR;
1247}
1248
1249static DWORD vboxDispIfSwitchToXPDM(PVBOXDISPIF pIf)
1250{
1251 DWORD err = NO_ERROR;
1252 AssertBreakpoint();
1253 OSVERSIONINFO OSinfo;
1254 OSinfo.dwOSVersionInfoSize = sizeof (OSinfo);
1255 GetVersionEx (&OSinfo);
1256 if (OSinfo.dwMajorVersion >= 5)
1257 {
1258 HMODULE hUser = GetModuleHandle("USER32");
1259 if (NULL != hUser)
1260 {
1261 bool bSupported = true;
1262 *(uintptr_t *)&pIf->modeData.xpdm.pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
1263 Log((__FUNCTION__": pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.xpdm.pfnChangeDisplaySettingsEx));
1264 bSupported &= !!(pIf->modeData.xpdm.pfnChangeDisplaySettingsEx);
1265
1266 if (!bSupported)
1267 {
1268 Log((__FUNCTION__": pfnChangeDisplaySettingsEx function pointer failed to initialize\n"));
1269 err = ERROR_NOT_SUPPORTED;
1270 }
1271 }
1272 else
1273 {
1274 Log((__FUNCTION__": failed to get USER32 handle, err (%d)\n", GetLastError()));
1275 err = ERROR_NOT_SUPPORTED;
1276 }
1277 }
1278 else
1279 {
1280 Log((__FUNCTION__": can not switch to VBOXDISPIF_MODE_XPDM, because os is not >= w2k\n"));
1281 err = ERROR_NOT_SUPPORTED;
1282 }
1283
1284 return err;
1285}
1286
1287DWORD VBoxDispIfSwitchMode(PVBOXDISPIF pIf, VBOXDISPIF_MODE enmMode, VBOXDISPIF_MODE *penmOldMode)
1288{
1289 /* @todo: may need to addd synchronization in case we want to change modes dynamically
1290 * i.e. currently the mode is supposed to be initialized once on service initialization */
1291 if (penmOldMode)
1292 *penmOldMode = pIf->enmMode;
1293
1294 if (enmMode == pIf->enmMode)
1295 return NO_ERROR;
1296
1297#ifdef VBOX_WITH_WDDM
1298 if (pIf->enmMode == VBOXDISPIF_MODE_WDDM)
1299 {
1300 vboxDispIfWddmTerm(pIf);
1301 }
1302#endif
1303
1304 DWORD err = NO_ERROR;
1305 switch (enmMode)
1306 {
1307 case VBOXDISPIF_MODE_XPDM_NT4:
1308 Log((__FUNCTION__": request to switch to VBOXDISPIF_MODE_XPDM_NT4\n"));
1309 err = vboxDispIfSwitchToXPDM_NT4(pIf);
1310 if (err == NO_ERROR)
1311 {
1312 Log((__FUNCTION__": successfully switched to XPDM_NT4 mode\n"));
1313 pIf->enmMode = VBOXDISPIF_MODE_XPDM_NT4;
1314 }
1315 else
1316 Log((__FUNCTION__": failed to switch to XPDM_NT4 mode, err (%d)\n", err));
1317 break;
1318 case VBOXDISPIF_MODE_XPDM:
1319 Log((__FUNCTION__": request to switch to VBOXDISPIF_MODE_XPDM\n"));
1320 err = vboxDispIfSwitchToXPDM(pIf);
1321 if (err == NO_ERROR)
1322 {
1323 Log((__FUNCTION__": successfully switched to XPDM mode\n"));
1324 pIf->enmMode = VBOXDISPIF_MODE_XPDM;
1325 }
1326 else
1327 Log((__FUNCTION__": failed to switch to XPDM mode, err (%d)\n", err));
1328 break;
1329#ifdef VBOX_WITH_WDDM
1330 case VBOXDISPIF_MODE_WDDM:
1331 {
1332 Log((__FUNCTION__": request to switch to VBOXDISPIF_MODE_WDDM\n"));
1333 err = vboxDispIfSwitchToWDDM(pIf);
1334 if (err == NO_ERROR)
1335 {
1336 Log((__FUNCTION__": successfully switched to WDDM mode\n"));
1337 pIf->enmMode = VBOXDISPIF_MODE_WDDM;
1338 }
1339 else
1340 Log((__FUNCTION__": failed to switch to WDDM mode, err (%d)\n", err));
1341 break;
1342 }
1343#endif
1344 default:
1345 err = ERROR_INVALID_PARAMETER;
1346 break;
1347 }
1348 return err;
1349}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette