[55401] | 1 | /* $Id: VBoxDispIf.cpp 99828 2023-05-17 13:48:57Z vboxsync $ */
|
---|
[31145] | 2 | /** @file
|
---|
[52136] | 3 | * VBoxTray - Display Settings Interface abstraction for XPDM & WDDM
|
---|
[31145] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2006-2023 Oracle and/or its affiliates.
|
---|
[31145] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
| 11 | *
|
---|
| 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
| 25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[31145] | 26 | */
|
---|
[52136] | 27 |
|
---|
[78937] | 28 |
|
---|
| 29 | /*********************************************************************************************************************************
|
---|
| 30 | * Header Files *
|
---|
| 31 | *********************************************************************************************************************************/
|
---|
[92962] | 32 | #define _WIN32_WINNT 0x0601
|
---|
[51469] | 33 | #include "VBoxTray.h"
|
---|
[95961] | 34 | #include "VBoxTrayInternal.h"
|
---|
[95868] | 35 |
|
---|
| 36 | #include <iprt/alloca.h>
|
---|
| 37 | #include <iprt/assert.h>
|
---|
| 38 | #include <iprt/errcore.h>
|
---|
[31145] | 39 | #include <iprt/log.h>
|
---|
[95868] | 40 | #include <iprt/mem.h>
|
---|
[78937] | 41 | #include <iprt/system.h>
|
---|
[31145] | 42 |
|
---|
[52136] | 43 |
|
---|
[63099] | 44 | /*********************************************************************************************************************************
|
---|
| 45 | * Defined Constants And Macros *
|
---|
| 46 | *********************************************************************************************************************************/
|
---|
[84325] | 47 | #ifdef DEBUG
|
---|
[63099] | 48 | # define WARN(_m) do { \
|
---|
[84325] | 49 | AssertFailed(); \
|
---|
| 50 | LogRelFunc(_m); \
|
---|
[52143] | 51 | } while (0)
|
---|
| 52 | #else
|
---|
[63099] | 53 | # define WARN(_m) do { \
|
---|
[84325] | 54 | LogRelFunc(_m); \
|
---|
[52143] | 55 | } while (0)
|
---|
| 56 | #endif
|
---|
| 57 |
|
---|
[42217] | 58 | #ifdef VBOX_WITH_WDDM
|
---|
| 59 | #include <iprt/asm.h>
|
---|
| 60 | #endif
|
---|
| 61 |
|
---|
[52136] | 62 | #include "VBoxDisplay.h"
|
---|
[48070] | 63 |
|
---|
| 64 | #ifndef NT_SUCCESS
|
---|
| 65 | # define NT_SUCCESS(_Status) ((_Status) >= 0)
|
---|
| 66 | #endif
|
---|
| 67 |
|
---|
[63099] | 68 |
|
---|
| 69 | /*********************************************************************************************************************************
|
---|
| 70 | * Structures and Typedefs *
|
---|
| 71 | *********************************************************************************************************************************/
|
---|
[48070] | 72 | typedef struct VBOXDISPIF_OP
|
---|
| 73 | {
|
---|
| 74 | PCVBOXDISPIF pIf;
|
---|
| 75 | VBOXDISPKMT_ADAPTER Adapter;
|
---|
| 76 | VBOXDISPKMT_DEVICE Device;
|
---|
| 77 | VBOXDISPKMT_CONTEXT Context;
|
---|
| 78 | } VBOXDISPIF_OP;
|
---|
| 79 |
|
---|
[57741] | 80 | /*
|
---|
| 81 | * APIs specific to Win7 and above WDDM architecture. Not available for Vista WDDM.
|
---|
| 82 | * This is the reason they have not been put in the VBOXDISPIF struct in VBoxDispIf.h.
|
---|
[44557] | 83 | */
|
---|
| 84 | typedef struct _VBOXDISPLAYWDDMAPICONTEXT
|
---|
| 85 | {
|
---|
[85121] | 86 | DECLCALLBACKMEMBER_EX(LONG, WINAPI, pfnSetDisplayConfig,(UINT numPathArrayElements, DISPLAYCONFIG_PATH_INFO *pathArray,
|
---|
| 87 | UINT numModeInfoArrayElements,
|
---|
| 88 | DISPLAYCONFIG_MODE_INFO *modeInfoArray, UINT Flags));
|
---|
| 89 | DECLCALLBACKMEMBER_EX(LONG, WINAPI, pfnQueryDisplayConfig,(UINT Flags, UINT *pNumPathArrayElements,
|
---|
| 90 | DISPLAYCONFIG_PATH_INFO *pPathInfoArray,
|
---|
| 91 | UINT *pNumModeInfoArrayElements,
|
---|
| 92 | DISPLAYCONFIG_MODE_INFO *pModeInfoArray,
|
---|
| 93 | DISPLAYCONFIG_TOPOLOGY_ID *pCurrentTopologyId));
|
---|
| 94 | DECLCALLBACKMEMBER_EX(LONG, WINAPI, pfnGetDisplayConfigBufferSizes,(UINT Flags, UINT *pNumPathArrayElements,
|
---|
| 95 | UINT *pNumModeInfoArrayElements));
|
---|
[44557] | 96 | } _VBOXDISPLAYWDDMAPICONTEXT;
|
---|
| 97 |
|
---|
| 98 | static _VBOXDISPLAYWDDMAPICONTEXT gCtx = {0};
|
---|
| 99 |
|
---|
[48070] | 100 | typedef struct VBOXDISPIF_WDDM_DISPCFG
|
---|
| 101 | {
|
---|
| 102 | UINT32 cPathInfoArray;
|
---|
| 103 | DISPLAYCONFIG_PATH_INFO *pPathInfoArray;
|
---|
| 104 | UINT32 cModeInfoArray;
|
---|
| 105 | DISPLAYCONFIG_MODE_INFO *pModeInfoArray;
|
---|
| 106 | } VBOXDISPIF_WDDM_DISPCFG;
|
---|
| 107 |
|
---|
[63099] | 108 |
|
---|
| 109 | /*********************************************************************************************************************************
|
---|
| 110 | * Internal Functions *
|
---|
| 111 | *********************************************************************************************************************************/
|
---|
| 112 | static DWORD vboxDispIfWddmResizeDisplay(PCVBOXDISPIF const pIf, UINT Id, BOOL fEnable, DISPLAY_DEVICE * paDisplayDevices,
|
---|
| 113 | DEVMODE *paDeviceModes, UINT devModes);
|
---|
[72000] | 114 |
|
---|
| 115 | static DWORD vboxDispIfWddmResizeDisplay2(PCVBOXDISPIF const pIf, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT devModes);
|
---|
| 116 |
|
---|
[63099] | 117 | static DWORD vboxDispIfResizePerform(PCVBOXDISPIF const pIf, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup,
|
---|
| 118 | DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes);
|
---|
| 119 | static DWORD vboxDispIfWddmEnableDisplaysTryingTopology(PCVBOXDISPIF const pIf, UINT cIds, UINT *pIds, BOOL fEnable);
|
---|
| 120 | static DWORD vboxDispIfResizeStartedWDDMOp(VBOXDISPIF_OP *pOp);
|
---|
| 121 |
|
---|
[84382] | 122 | static void vboxDispIfWddmDcLogRel(VBOXDISPIF_WDDM_DISPCFG const *pCfg, UINT fFlags)
|
---|
| 123 | {
|
---|
| 124 | LogRel(("Display config: Flags = 0x%08X\n", fFlags));
|
---|
[63099] | 125 |
|
---|
[84382] | 126 | LogRel(("PATH_INFO[%d]:\n", pCfg->cPathInfoArray));
|
---|
| 127 | for (uint32_t i = 0; i < pCfg->cPathInfoArray; ++i)
|
---|
| 128 | {
|
---|
| 129 | DISPLAYCONFIG_PATH_INFO *p = &pCfg->pPathInfoArray[i];
|
---|
| 130 |
|
---|
| 131 | LogRel(("%d: flags 0x%08x\n", i, p->flags));
|
---|
| 132 |
|
---|
| 133 | LogRel((" sourceInfo: adapterId 0x%08x:%08x, id %u, modeIdx %d, statusFlags 0x%08x\n",
|
---|
| 134 | p->sourceInfo.adapterId.HighPart, p->sourceInfo.adapterId.LowPart,
|
---|
| 135 | p->sourceInfo.id, p->sourceInfo.modeInfoIdx, p->sourceInfo.statusFlags));
|
---|
| 136 |
|
---|
| 137 | LogRel((" targetInfo: adapterId 0x%08x:%08x, id %u, modeIdx %d,\n"
|
---|
| 138 | " ot %d, r %d, s %d, rr %d/%d, so %d, ta %d, statusFlags 0x%08x\n",
|
---|
| 139 | p->targetInfo.adapterId.HighPart, p->targetInfo.adapterId.LowPart,
|
---|
| 140 | p->targetInfo.id, p->targetInfo.modeInfoIdx,
|
---|
| 141 | p->targetInfo.outputTechnology,
|
---|
| 142 | p->targetInfo.rotation,
|
---|
| 143 | p->targetInfo.scaling,
|
---|
| 144 | p->targetInfo.refreshRate.Numerator, p->targetInfo.refreshRate.Denominator,
|
---|
| 145 | p->targetInfo.scanLineOrdering,
|
---|
| 146 | p->targetInfo.targetAvailable,
|
---|
| 147 | p->targetInfo.statusFlags
|
---|
| 148 | ));
|
---|
| 149 | }
|
---|
| 150 |
|
---|
| 151 | LogRel(("MODE_INFO[%d]:\n", pCfg->cModeInfoArray));
|
---|
| 152 | for (uint32_t i = 0; i < pCfg->cModeInfoArray; ++i)
|
---|
| 153 | {
|
---|
| 154 | DISPLAYCONFIG_MODE_INFO *p = &pCfg->pModeInfoArray[i];
|
---|
| 155 |
|
---|
| 156 | LogRel(("%d: adapterId 0x%08x:%08x, id %u\n",
|
---|
| 157 | i, p->adapterId.HighPart, p->adapterId.LowPart, p->id));
|
---|
| 158 |
|
---|
| 159 | if (p->infoType == DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE)
|
---|
| 160 | {
|
---|
| 161 | LogRel((" src %ux%u, fmt %d, @%dx%d\n",
|
---|
| 162 | p->sourceMode.width, p->sourceMode.height, p->sourceMode.pixelFormat,
|
---|
| 163 | p->sourceMode.position.x, p->sourceMode.position.y));
|
---|
| 164 | }
|
---|
| 165 | else if (p->infoType == DISPLAYCONFIG_MODE_INFO_TYPE_TARGET)
|
---|
| 166 | {
|
---|
| 167 | LogRel((" tgt pr 0x%RX64, hSyncFreq %d/%d, vSyncFreq %d/%d, active %ux%u, total %ux%u, std %d, so %d\n",
|
---|
| 168 | p->targetMode.targetVideoSignalInfo.pixelRate,
|
---|
| 169 | p->targetMode.targetVideoSignalInfo.hSyncFreq.Numerator, p->targetMode.targetVideoSignalInfo.hSyncFreq.Denominator,
|
---|
| 170 | p->targetMode.targetVideoSignalInfo.vSyncFreq.Numerator, p->targetMode.targetVideoSignalInfo.vSyncFreq.Denominator,
|
---|
| 171 | p->targetMode.targetVideoSignalInfo.activeSize.cx, p->targetMode.targetVideoSignalInfo.activeSize.cy,
|
---|
| 172 | p->targetMode.targetVideoSignalInfo.totalSize.cx, p->targetMode.targetVideoSignalInfo.totalSize.cy,
|
---|
| 173 | p->targetMode.targetVideoSignalInfo.videoStandard,
|
---|
| 174 | p->targetMode.targetVideoSignalInfo.scanLineOrdering));
|
---|
| 175 | }
|
---|
| 176 | else
|
---|
| 177 | {
|
---|
| 178 | LogRel((" Invalid infoType %u(0x%08x)\n", p->infoType, p->infoType));
|
---|
| 179 | }
|
---|
| 180 | }
|
---|
| 181 | }
|
---|
| 182 |
|
---|
[48070] | 183 | static DWORD vboxDispIfWddmDcCreate(VBOXDISPIF_WDDM_DISPCFG *pCfg, UINT32 fFlags)
|
---|
| 184 | {
|
---|
| 185 | UINT32 cPathInfoArray = 0;
|
---|
| 186 | UINT32 cModeInfoArray = 0;
|
---|
| 187 | DWORD winEr = gCtx.pfnGetDisplayConfigBufferSizes(fFlags, &cPathInfoArray, &cModeInfoArray);
|
---|
| 188 | if (winEr != ERROR_SUCCESS)
|
---|
| 189 | {
|
---|
[52136] | 190 | WARN(("VBoxTray: (WDDM) Failed GetDisplayConfigBufferSizes\n"));
|
---|
[48070] | 191 | return winEr;
|
---|
| 192 | }
|
---|
| 193 |
|
---|
[95868] | 194 | DISPLAYCONFIG_PATH_INFO *pPathInfoArray = (DISPLAYCONFIG_PATH_INFO *)RTMemAlloc( cPathInfoArray
|
---|
| 195 | * sizeof(DISPLAYCONFIG_PATH_INFO));
|
---|
[48070] | 196 | if (!pPathInfoArray)
|
---|
| 197 | {
|
---|
[95868] | 198 | WARN(("VBoxTray: (WDDM) RTMemAlloc failed!\n"));
|
---|
[48070] | 199 | return ERROR_OUTOFMEMORY;
|
---|
| 200 | }
|
---|
[95868] | 201 | DISPLAYCONFIG_MODE_INFO *pModeInfoArray = (DISPLAYCONFIG_MODE_INFO *)RTMemAlloc( cModeInfoArray
|
---|
| 202 | * sizeof(DISPLAYCONFIG_MODE_INFO));
|
---|
[48070] | 203 | if (!pModeInfoArray)
|
---|
| 204 | {
|
---|
[95868] | 205 | WARN(("VBoxTray: (WDDM) RTMemAlloc failed!\n"));
|
---|
| 206 | RTMemFree(pPathInfoArray);
|
---|
[48070] | 207 | return ERROR_OUTOFMEMORY;
|
---|
| 208 | }
|
---|
| 209 |
|
---|
| 210 | winEr = gCtx.pfnQueryDisplayConfig(fFlags, &cPathInfoArray, pPathInfoArray, &cModeInfoArray, pModeInfoArray, NULL);
|
---|
| 211 | if (winEr != ERROR_SUCCESS)
|
---|
| 212 | {
|
---|
[52136] | 213 | WARN(("VBoxTray: (WDDM) Failed QueryDisplayConfig\n"));
|
---|
[95868] | 214 | RTMemFree(pPathInfoArray);
|
---|
| 215 | RTMemFree(pModeInfoArray);
|
---|
[48070] | 216 | return winEr;
|
---|
| 217 | }
|
---|
| 218 |
|
---|
| 219 | pCfg->cPathInfoArray = cPathInfoArray;
|
---|
| 220 | pCfg->pPathInfoArray = pPathInfoArray;
|
---|
| 221 | pCfg->cModeInfoArray = cModeInfoArray;
|
---|
| 222 | pCfg->pModeInfoArray = pModeInfoArray;
|
---|
| 223 | return ERROR_SUCCESS;
|
---|
| 224 | }
|
---|
| 225 |
|
---|
| 226 | static DWORD vboxDispIfWddmDcClone(VBOXDISPIF_WDDM_DISPCFG *pCfg, VBOXDISPIF_WDDM_DISPCFG *pCfgDst)
|
---|
| 227 | {
|
---|
| 228 | memset(pCfgDst, 0, sizeof (*pCfgDst));
|
---|
| 229 |
|
---|
| 230 | if (pCfg->cPathInfoArray)
|
---|
| 231 | {
|
---|
[95868] | 232 | pCfgDst->pPathInfoArray = (DISPLAYCONFIG_PATH_INFO *)RTMemAlloc(pCfg->cPathInfoArray * sizeof (DISPLAYCONFIG_PATH_INFO));
|
---|
[48070] | 233 | if (!pCfgDst->pPathInfoArray)
|
---|
| 234 | {
|
---|
[95868] | 235 | WARN(("VBoxTray: (WDDM) RTMemAlloc failed!\n"));
|
---|
[48070] | 236 | return ERROR_OUTOFMEMORY;
|
---|
| 237 | }
|
---|
| 238 |
|
---|
| 239 | memcpy(pCfgDst->pPathInfoArray, pCfg->pPathInfoArray, pCfg->cPathInfoArray * sizeof (DISPLAYCONFIG_PATH_INFO));
|
---|
| 240 |
|
---|
| 241 | pCfgDst->cPathInfoArray = pCfg->cPathInfoArray;
|
---|
| 242 | }
|
---|
| 243 |
|
---|
| 244 | if (pCfg->cModeInfoArray)
|
---|
| 245 | {
|
---|
[95868] | 246 | pCfgDst->pModeInfoArray = (DISPLAYCONFIG_MODE_INFO *)RTMemAlloc(pCfg->cModeInfoArray * sizeof (DISPLAYCONFIG_MODE_INFO));
|
---|
[48070] | 247 | if (!pCfgDst->pModeInfoArray)
|
---|
| 248 | {
|
---|
[95868] | 249 | WARN(("VBoxTray: (WDDM) RTMemAlloc failed!\n"));
|
---|
[48070] | 250 | if (pCfgDst->pPathInfoArray)
|
---|
| 251 | {
|
---|
[95868] | 252 | RTMemFree(pCfgDst->pPathInfoArray);
|
---|
[48070] | 253 | pCfgDst->pPathInfoArray = NULL;
|
---|
| 254 | }
|
---|
| 255 | return ERROR_OUTOFMEMORY;
|
---|
| 256 | }
|
---|
| 257 |
|
---|
| 258 | memcpy(pCfgDst->pModeInfoArray, pCfg->pModeInfoArray, pCfg->cModeInfoArray * sizeof (DISPLAYCONFIG_MODE_INFO));
|
---|
| 259 |
|
---|
| 260 | pCfgDst->cModeInfoArray = pCfg->cModeInfoArray;
|
---|
| 261 | }
|
---|
| 262 |
|
---|
| 263 | return ERROR_SUCCESS;
|
---|
| 264 | }
|
---|
| 265 |
|
---|
| 266 |
|
---|
| 267 | static VOID vboxDispIfWddmDcTerm(VBOXDISPIF_WDDM_DISPCFG *pCfg)
|
---|
| 268 | {
|
---|
| 269 | if (pCfg->pPathInfoArray)
|
---|
[95868] | 270 | RTMemFree(pCfg->pPathInfoArray);
|
---|
[48070] | 271 | if (pCfg->pModeInfoArray)
|
---|
[95868] | 272 | RTMemFree(pCfg->pModeInfoArray);
|
---|
[48070] | 273 | /* sanity */
|
---|
| 274 | memset(pCfg, 0, sizeof (*pCfg));
|
---|
| 275 | }
|
---|
| 276 |
|
---|
| 277 | static UINT32 g_cVBoxDispIfWddmDisplays = 0;
|
---|
| 278 | static DWORD vboxDispIfWddmDcQueryNumDisplays(UINT32 *pcDisplays)
|
---|
| 279 | {
|
---|
| 280 | if (!g_cVBoxDispIfWddmDisplays)
|
---|
| 281 | {
|
---|
| 282 | VBOXDISPIF_WDDM_DISPCFG DispCfg;
|
---|
| 283 | *pcDisplays = 0;
|
---|
| 284 | DWORD winEr = vboxDispIfWddmDcCreate(&DispCfg, QDC_ALL_PATHS);
|
---|
| 285 | if (winEr != ERROR_SUCCESS)
|
---|
| 286 | {
|
---|
[52136] | 287 | WARN(("VBoxTray:(WDDM) vboxDispIfWddmDcCreate Failed winEr %d\n", winEr));
|
---|
[48070] | 288 | return winEr;
|
---|
| 289 | }
|
---|
| 290 |
|
---|
| 291 | int cDisplays = -1;
|
---|
| 292 |
|
---|
| 293 | for (UINT iter = 0; iter < DispCfg.cPathInfoArray; ++iter)
|
---|
| 294 | {
|
---|
| 295 | if (cDisplays < (int)(DispCfg.pPathInfoArray[iter].sourceInfo.id))
|
---|
| 296 | cDisplays = (int)(DispCfg.pPathInfoArray[iter].sourceInfo.id);
|
---|
| 297 | }
|
---|
| 298 |
|
---|
| 299 | cDisplays++;
|
---|
| 300 |
|
---|
| 301 | g_cVBoxDispIfWddmDisplays = cDisplays;
|
---|
| 302 | Assert(g_cVBoxDispIfWddmDisplays);
|
---|
| 303 |
|
---|
| 304 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 305 | }
|
---|
| 306 |
|
---|
| 307 | *pcDisplays = g_cVBoxDispIfWddmDisplays;
|
---|
| 308 | return ERROR_SUCCESS;
|
---|
| 309 | }
|
---|
| 310 |
|
---|
[63099] | 311 | #define VBOX_WDDM_DC_SEARCH_PATH_ANY (~(UINT)0)
|
---|
[48070] | 312 | static int vboxDispIfWddmDcSearchPath(VBOXDISPIF_WDDM_DISPCFG *pCfg, UINT srcId, UINT trgId)
|
---|
| 313 | {
|
---|
| 314 | for (UINT iter = 0; iter < pCfg->cPathInfoArray; ++iter)
|
---|
| 315 | {
|
---|
[63099] | 316 | if ( (srcId == VBOX_WDDM_DC_SEARCH_PATH_ANY || pCfg->pPathInfoArray[iter].sourceInfo.id == srcId)
|
---|
| 317 | && (trgId == VBOX_WDDM_DC_SEARCH_PATH_ANY || pCfg->pPathInfoArray[iter].targetInfo.id == trgId))
|
---|
[48070] | 318 | {
|
---|
| 319 | return (int)iter;
|
---|
| 320 | }
|
---|
| 321 | }
|
---|
| 322 | return -1;
|
---|
| 323 | }
|
---|
| 324 |
|
---|
[84452] | 325 | static int vboxDispIfWddmDcSearchActiveSourcePath(VBOXDISPIF_WDDM_DISPCFG *pCfg, UINT srcId)
|
---|
| 326 | {
|
---|
| 327 | for (UINT i = 0; i < pCfg->cPathInfoArray; ++i)
|
---|
| 328 | {
|
---|
| 329 | if ( pCfg->pPathInfoArray[i].sourceInfo.id == srcId
|
---|
| 330 | && RT_BOOL(pCfg->pPathInfoArray[i].flags & DISPLAYCONFIG_PATH_ACTIVE))
|
---|
| 331 | {
|
---|
| 332 | return (int)i;
|
---|
| 333 | }
|
---|
| 334 | }
|
---|
| 335 | return -1;
|
---|
| 336 | }
|
---|
| 337 |
|
---|
[48070] | 338 | static int vboxDispIfWddmDcSearchActivePath(VBOXDISPIF_WDDM_DISPCFG *pCfg, UINT srcId, UINT trgId)
|
---|
| 339 | {
|
---|
| 340 | int idx = vboxDispIfWddmDcSearchPath(pCfg, srcId, trgId);
|
---|
| 341 | if (idx < 0)
|
---|
| 342 | return idx;
|
---|
| 343 |
|
---|
| 344 | if (!(pCfg->pPathInfoArray[idx].flags & DISPLAYCONFIG_PATH_ACTIVE))
|
---|
| 345 | return -1;
|
---|
| 346 |
|
---|
| 347 | return idx;
|
---|
| 348 | }
|
---|
| 349 |
|
---|
| 350 | static VOID vboxDispIfWddmDcSettingsInvalidateModeIndex(VBOXDISPIF_WDDM_DISPCFG *pCfg, int idx)
|
---|
| 351 | {
|
---|
| 352 | pCfg->pPathInfoArray[idx].sourceInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 353 | pCfg->pPathInfoArray[idx].targetInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 354 | }
|
---|
| 355 |
|
---|
| 356 | static VOID vboxDispIfWddmDcSettingsInvalidateModeIndeces(VBOXDISPIF_WDDM_DISPCFG *pCfg)
|
---|
| 357 | {
|
---|
| 358 | for (UINT iter = 0; iter < pCfg->cPathInfoArray; ++iter)
|
---|
| 359 | {
|
---|
| 360 | vboxDispIfWddmDcSettingsInvalidateModeIndex(pCfg, (int)iter);
|
---|
| 361 | }
|
---|
| 362 |
|
---|
| 363 | if (pCfg->pModeInfoArray)
|
---|
| 364 | {
|
---|
[95868] | 365 | RTMemFree(pCfg->pModeInfoArray);
|
---|
[48070] | 366 | pCfg->pModeInfoArray = NULL;
|
---|
| 367 | }
|
---|
| 368 | pCfg->cModeInfoArray = 0;
|
---|
| 369 | }
|
---|
| 370 |
|
---|
| 371 | static DWORD vboxDispIfWddmDcSettingsModeAdd(VBOXDISPIF_WDDM_DISPCFG *pCfg, UINT *pIdx)
|
---|
| 372 | {
|
---|
| 373 | UINT32 cModeInfoArray = pCfg->cModeInfoArray + 1;
|
---|
[95868] | 374 | DISPLAYCONFIG_MODE_INFO *pModeInfoArray = (DISPLAYCONFIG_MODE_INFO *)RTMemAlloc( cModeInfoArray
|
---|
| 375 | * sizeof (DISPLAYCONFIG_MODE_INFO));
|
---|
[48070] | 376 | if (!pModeInfoArray)
|
---|
| 377 | {
|
---|
[95868] | 378 | WARN(("VBoxTray: (WDDM) RTMemAlloc failed!\n"));
|
---|
[48070] | 379 | return ERROR_OUTOFMEMORY;
|
---|
| 380 | }
|
---|
| 381 |
|
---|
| 382 | memcpy (pModeInfoArray, pCfg->pModeInfoArray, pCfg->cModeInfoArray * sizeof(DISPLAYCONFIG_MODE_INFO));
|
---|
| 383 | memset(&pModeInfoArray[cModeInfoArray-1], 0, sizeof (pModeInfoArray[0]));
|
---|
[95868] | 384 | RTMemFree(pCfg->pModeInfoArray);
|
---|
[48070] | 385 | *pIdx = cModeInfoArray-1;
|
---|
| 386 | pCfg->pModeInfoArray = pModeInfoArray;
|
---|
| 387 | pCfg->cModeInfoArray = cModeInfoArray;
|
---|
| 388 | return ERROR_SUCCESS;
|
---|
| 389 | }
|
---|
| 390 |
|
---|
| 391 | static DWORD vboxDispIfWddmDcSettingsUpdate(VBOXDISPIF_WDDM_DISPCFG *pCfg, int idx, DEVMODE *pDeviceMode, BOOL fInvalidateSrcMode, BOOL fEnable)
|
---|
| 392 | {
|
---|
| 393 | if (fInvalidateSrcMode)
|
---|
| 394 | pCfg->pPathInfoArray[idx].sourceInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 395 | else if (pDeviceMode)
|
---|
| 396 | {
|
---|
| 397 | UINT iSrcMode = pCfg->pPathInfoArray[idx].sourceInfo.modeInfoIdx;
|
---|
| 398 | if (iSrcMode == DISPLAYCONFIG_PATH_MODE_IDX_INVALID)
|
---|
| 399 | {
|
---|
| 400 |
|
---|
[52136] | 401 | WARN(("VBoxTray: (WDDM) no source mode index specified"));
|
---|
[48070] | 402 | DWORD winEr = vboxDispIfWddmDcSettingsModeAdd(pCfg, &iSrcMode);
|
---|
| 403 | if (winEr != ERROR_SUCCESS)
|
---|
| 404 | {
|
---|
[52136] | 405 | WARN(("VBoxTray:(WDDM) vboxDispIfWddmDcSettingsModeAdd Failed winEr %d\n", winEr));
|
---|
[48070] | 406 | return winEr;
|
---|
| 407 | }
|
---|
| 408 | pCfg->pPathInfoArray[idx].sourceInfo.modeInfoIdx = iSrcMode;
|
---|
| 409 | }
|
---|
| 410 |
|
---|
| 411 | for (int i = 0; i < (int)pCfg->cPathInfoArray; ++i)
|
---|
| 412 | {
|
---|
| 413 | if (i == idx)
|
---|
| 414 | continue;
|
---|
| 415 |
|
---|
| 416 | if (pCfg->pPathInfoArray[i].sourceInfo.modeInfoIdx == iSrcMode)
|
---|
| 417 | {
|
---|
| 418 | /* this is something we're not expecting/supporting */
|
---|
[52136] | 419 | WARN(("VBoxTray: (WDDM) multiple paths have the same mode index"));
|
---|
[48070] | 420 | return ERROR_NOT_SUPPORTED;
|
---|
| 421 | }
|
---|
| 422 | }
|
---|
| 423 |
|
---|
| 424 | if (pDeviceMode->dmFields & DM_PELSWIDTH)
|
---|
| 425 | pCfg->pModeInfoArray[iSrcMode].sourceMode.width = pDeviceMode->dmPelsWidth;
|
---|
| 426 | if (pDeviceMode->dmFields & DM_PELSHEIGHT)
|
---|
| 427 | pCfg->pModeInfoArray[iSrcMode].sourceMode.height = pDeviceMode->dmPelsHeight;
|
---|
| 428 | if (pDeviceMode->dmFields & DM_POSITION)
|
---|
| 429 | {
|
---|
[53313] | 430 | LogFlowFunc(("DM_POSITION %d,%d -> %d,%d\n",
|
---|
| 431 | pCfg->pModeInfoArray[iSrcMode].sourceMode.position.x,
|
---|
| 432 | pCfg->pModeInfoArray[iSrcMode].sourceMode.position.y,
|
---|
| 433 | pDeviceMode->dmPosition.x, pDeviceMode->dmPosition.y));
|
---|
[48070] | 434 | pCfg->pModeInfoArray[iSrcMode].sourceMode.position.x = pDeviceMode->dmPosition.x;
|
---|
| 435 | pCfg->pModeInfoArray[iSrcMode].sourceMode.position.y = pDeviceMode->dmPosition.y;
|
---|
| 436 | }
|
---|
| 437 | if (pDeviceMode->dmFields & DM_BITSPERPEL)
|
---|
| 438 | {
|
---|
| 439 | switch (pDeviceMode->dmBitsPerPel)
|
---|
| 440 | {
|
---|
| 441 | case 32:
|
---|
| 442 | pCfg->pModeInfoArray[iSrcMode].sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 443 | break;
|
---|
| 444 | case 24:
|
---|
| 445 | pCfg->pModeInfoArray[iSrcMode].sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_24BPP;
|
---|
| 446 | break;
|
---|
| 447 | case 16:
|
---|
| 448 | pCfg->pModeInfoArray[iSrcMode].sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_16BPP;
|
---|
| 449 | break;
|
---|
| 450 | case 8:
|
---|
| 451 | pCfg->pModeInfoArray[iSrcMode].sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_8BPP;
|
---|
| 452 | break;
|
---|
| 453 | default:
|
---|
[52136] | 454 | LogRel(("VBoxTray: (WDDM) invalid bpp %d, using 32\n", pDeviceMode->dmBitsPerPel));
|
---|
[48070] | 455 | pCfg->pModeInfoArray[iSrcMode].sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 456 | break;
|
---|
| 457 | }
|
---|
| 458 | }
|
---|
| 459 | }
|
---|
| 460 |
|
---|
| 461 | pCfg->pPathInfoArray[idx].targetInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 462 |
|
---|
[62415] | 463 | /* "A refresh rate with both the numerator and denominator set to zero indicates that
|
---|
| 464 | * the caller does not specify a refresh rate and the operating system should use
|
---|
| 465 | * the most optimal refresh rate available. For this case, in a call to the SetDisplayConfig
|
---|
| 466 | * function, the caller must set the scanLineOrdering member to the
|
---|
| 467 | * DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED value; otherwise, SetDisplayConfig fails."
|
---|
| 468 | *
|
---|
| 469 | * If a refresh rate is set to a value, then the resize will fail if miniport driver
|
---|
| 470 | * does not support VSync, i.e. with display-only driver on Win8+ (@bugref{8440}).
|
---|
| 471 | */
|
---|
| 472 | pCfg->pPathInfoArray[idx].targetInfo.refreshRate.Numerator = 0;
|
---|
| 473 | pCfg->pPathInfoArray[idx].targetInfo.refreshRate.Denominator = 0;
|
---|
| 474 | pCfg->pPathInfoArray[idx].targetInfo.scanLineOrdering = DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED;
|
---|
| 475 |
|
---|
| 476 | /* Make sure that "The output can be forced on this target even if a monitor is not detected." */
|
---|
| 477 | pCfg->pPathInfoArray[idx].targetInfo.targetAvailable = TRUE;
|
---|
| 478 | pCfg->pPathInfoArray[idx].targetInfo.statusFlags |= DISPLAYCONFIG_TARGET_FORCIBLE;
|
---|
| 479 |
|
---|
[48070] | 480 | if (fEnable)
|
---|
| 481 | pCfg->pPathInfoArray[idx].flags |= DISPLAYCONFIG_PATH_ACTIVE;
|
---|
| 482 | else
|
---|
| 483 | pCfg->pPathInfoArray[idx].flags &= ~DISPLAYCONFIG_PATH_ACTIVE;
|
---|
| 484 |
|
---|
| 485 | return ERROR_SUCCESS;
|
---|
| 486 | }
|
---|
| 487 |
|
---|
| 488 | static DWORD vboxDispIfWddmDcSet(VBOXDISPIF_WDDM_DISPCFG *pCfg, UINT fFlags)
|
---|
| 489 | {
|
---|
| 490 | DWORD winEr = gCtx.pfnSetDisplayConfig(pCfg->cPathInfoArray, pCfg->pPathInfoArray, pCfg->cModeInfoArray, pCfg->pModeInfoArray, fFlags);
|
---|
| 491 | if (winEr != ERROR_SUCCESS)
|
---|
[52136] | 492 | Log(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed for Flags 0x%x\n", fFlags));
|
---|
[48070] | 493 | return winEr;
|
---|
| 494 | }
|
---|
| 495 |
|
---|
| 496 | static BOOL vboxDispIfWddmDcSettingsAdjustSupportedPaths(VBOXDISPIF_WDDM_DISPCFG *pCfg)
|
---|
| 497 | {
|
---|
| 498 | BOOL fAdjusted = FALSE;
|
---|
| 499 | for (UINT iter = 0; iter < pCfg->cPathInfoArray; ++iter)
|
---|
| 500 | {
|
---|
| 501 | if (pCfg->pPathInfoArray[iter].sourceInfo.id == pCfg->pPathInfoArray[iter].targetInfo.id)
|
---|
| 502 | continue;
|
---|
| 503 |
|
---|
| 504 | if (!(pCfg->pPathInfoArray[iter].flags & DISPLAYCONFIG_PATH_ACTIVE))
|
---|
| 505 | continue;
|
---|
| 506 |
|
---|
| 507 | pCfg->pPathInfoArray[iter].flags &= ~DISPLAYCONFIG_PATH_ACTIVE;
|
---|
| 508 | fAdjusted = TRUE;
|
---|
| 509 | }
|
---|
| 510 |
|
---|
| 511 | return fAdjusted;
|
---|
| 512 | }
|
---|
| 513 |
|
---|
| 514 | static void vboxDispIfWddmDcSettingsAttachDisbledToPrimary(VBOXDISPIF_WDDM_DISPCFG *pCfg)
|
---|
| 515 | {
|
---|
| 516 | for (UINT iter = 0; iter < pCfg->cPathInfoArray; ++iter)
|
---|
| 517 | {
|
---|
| 518 | if ((pCfg->pPathInfoArray[iter].flags & DISPLAYCONFIG_PATH_ACTIVE))
|
---|
| 519 | continue;
|
---|
| 520 |
|
---|
| 521 | pCfg->pPathInfoArray[iter].sourceInfo.id = 0;
|
---|
| 522 | pCfg->pPathInfoArray[iter].sourceInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 523 | pCfg->pPathInfoArray[iter].targetInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 524 | }
|
---|
| 525 | }
|
---|
| 526 |
|
---|
| 527 | static DWORD vboxDispIfWddmDcSettingsIncludeAllTargets(VBOXDISPIF_WDDM_DISPCFG *pCfg)
|
---|
| 528 | {
|
---|
| 529 | UINT32 cDisplays = 0;
|
---|
| 530 | VBOXDISPIF_WDDM_DISPCFG AllCfg;
|
---|
| 531 | BOOL fAllCfgInited = FALSE;
|
---|
| 532 |
|
---|
| 533 | DWORD winEr = vboxDispIfWddmDcQueryNumDisplays(&cDisplays);
|
---|
| 534 | if (winEr != ERROR_SUCCESS)
|
---|
| 535 | {
|
---|
[52136] | 536 | WARN(("VBoxTray:(WDDM) vboxDispIfWddmDcQueryNumDisplays Failed winEr %d\n", winEr));
|
---|
[48070] | 537 | return winEr;
|
---|
| 538 | }
|
---|
| 539 |
|
---|
[95868] | 540 | DISPLAYCONFIG_PATH_INFO *pPathInfoArray = (DISPLAYCONFIG_PATH_INFO *)RTMemAlloc(cDisplays * sizeof(DISPLAYCONFIG_PATH_INFO));
|
---|
[48070] | 541 | if (!pPathInfoArray)
|
---|
| 542 | {
|
---|
[95868] | 543 | WARN(("RTMemAlloc failed\n"));
|
---|
[48070] | 544 | return ERROR_OUTOFMEMORY;
|
---|
| 545 | }
|
---|
| 546 |
|
---|
| 547 | for (UINT i = 0; i < cDisplays; ++i)
|
---|
| 548 | {
|
---|
| 549 | int idx = vboxDispIfWddmDcSearchPath(pCfg, i, i);
|
---|
| 550 | if (idx < 0)
|
---|
| 551 | {
|
---|
[63099] | 552 | idx = vboxDispIfWddmDcSearchPath(pCfg, VBOX_WDDM_DC_SEARCH_PATH_ANY, i);
|
---|
[48070] | 553 | if (idx >= 0)
|
---|
| 554 | {
|
---|
[52136] | 555 | WARN(("VBoxTray:(WDDM) different source and target paare enabled, this is something we would not expect\n"));
|
---|
[48070] | 556 | }
|
---|
| 557 | }
|
---|
| 558 |
|
---|
| 559 | if (idx >= 0)
|
---|
| 560 | pPathInfoArray[i] = pCfg->pPathInfoArray[idx];
|
---|
| 561 | else
|
---|
| 562 | {
|
---|
| 563 | if (!fAllCfgInited)
|
---|
| 564 | {
|
---|
| 565 | winEr = vboxDispIfWddmDcCreate(&AllCfg, QDC_ALL_PATHS);
|
---|
| 566 | if (winEr != ERROR_SUCCESS)
|
---|
| 567 | {
|
---|
[52136] | 568 | WARN(("VBoxTray:(WDDM) vboxDispIfWddmDcCreate Failed winEr %d\n", winEr));
|
---|
[95868] | 569 | RTMemFree(pPathInfoArray);
|
---|
[48070] | 570 | return winEr;
|
---|
| 571 | }
|
---|
| 572 | fAllCfgInited = TRUE;
|
---|
| 573 | }
|
---|
| 574 |
|
---|
| 575 | idx = vboxDispIfWddmDcSearchPath(&AllCfg, i, i);
|
---|
| 576 | if (idx < 0)
|
---|
| 577 | {
|
---|
[52136] | 578 | WARN(("VBoxTray:(WDDM) %d %d path not supported\n", i, i));
|
---|
[63099] | 579 | idx = vboxDispIfWddmDcSearchPath(pCfg, VBOX_WDDM_DC_SEARCH_PATH_ANY, i);
|
---|
[48070] | 580 | if (idx < 0)
|
---|
| 581 | {
|
---|
[52136] | 582 | WARN(("VBoxTray:(WDDM) %d %d path not supported\n", -1, i));
|
---|
[48070] | 583 | }
|
---|
| 584 | }
|
---|
| 585 |
|
---|
| 586 | if (idx >= 0)
|
---|
| 587 | {
|
---|
| 588 | pPathInfoArray[i] = AllCfg.pPathInfoArray[idx];
|
---|
| 589 |
|
---|
| 590 | if (pPathInfoArray[i].flags & DISPLAYCONFIG_PATH_ACTIVE)
|
---|
| 591 | {
|
---|
[52136] | 592 | WARN(("VBoxTray:(WDDM) disabled path %d %d is marked active\n",
|
---|
[48070] | 593 | pPathInfoArray[i].sourceInfo.id, pPathInfoArray[i].targetInfo.id));
|
---|
| 594 | pPathInfoArray[i].flags &= ~DISPLAYCONFIG_PATH_ACTIVE;
|
---|
| 595 | }
|
---|
| 596 |
|
---|
| 597 | Assert(pPathInfoArray[i].sourceInfo.modeInfoIdx == DISPLAYCONFIG_PATH_MODE_IDX_INVALID);
|
---|
| 598 | Assert(pPathInfoArray[i].sourceInfo.statusFlags == 0);
|
---|
| 599 |
|
---|
| 600 | Assert(pPathInfoArray[i].targetInfo.modeInfoIdx == DISPLAYCONFIG_PATH_MODE_IDX_INVALID);
|
---|
| 601 | Assert(pPathInfoArray[i].targetInfo.outputTechnology == DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15);
|
---|
| 602 | Assert(pPathInfoArray[i].targetInfo.rotation == DISPLAYCONFIG_ROTATION_IDENTITY);
|
---|
| 603 | Assert(pPathInfoArray[i].targetInfo.scaling == DISPLAYCONFIG_SCALING_PREFERRED);
|
---|
| 604 | Assert(pPathInfoArray[i].targetInfo.refreshRate.Numerator == 0);
|
---|
| 605 | Assert(pPathInfoArray[i].targetInfo.refreshRate.Denominator == 0);
|
---|
| 606 | Assert(pPathInfoArray[i].targetInfo.scanLineOrdering == DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED);
|
---|
| 607 | Assert(pPathInfoArray[i].targetInfo.targetAvailable == TRUE);
|
---|
| 608 | Assert(pPathInfoArray[i].targetInfo.statusFlags == DISPLAYCONFIG_TARGET_FORCIBLE);
|
---|
| 609 |
|
---|
| 610 | Assert(pPathInfoArray[i].flags == 0);
|
---|
| 611 | }
|
---|
| 612 | else
|
---|
| 613 | {
|
---|
| 614 | pPathInfoArray[i].sourceInfo.adapterId = pCfg->pPathInfoArray[0].sourceInfo.adapterId;
|
---|
| 615 | pPathInfoArray[i].sourceInfo.id = i;
|
---|
| 616 | pPathInfoArray[i].sourceInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 617 | pPathInfoArray[i].sourceInfo.statusFlags = 0;
|
---|
| 618 |
|
---|
| 619 | pPathInfoArray[i].targetInfo.adapterId = pPathInfoArray[i].sourceInfo.adapterId;
|
---|
| 620 | pPathInfoArray[i].targetInfo.id = i;
|
---|
| 621 | pPathInfoArray[i].targetInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 622 | pPathInfoArray[i].targetInfo.outputTechnology = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15;
|
---|
| 623 | pPathInfoArray[i].targetInfo.rotation = DISPLAYCONFIG_ROTATION_IDENTITY;
|
---|
| 624 | pPathInfoArray[i].targetInfo.scaling = DISPLAYCONFIG_SCALING_PREFERRED;
|
---|
| 625 | pPathInfoArray[i].targetInfo.refreshRate.Numerator = 0;
|
---|
| 626 | pPathInfoArray[i].targetInfo.refreshRate.Denominator = 0;
|
---|
| 627 | pPathInfoArray[i].targetInfo.scanLineOrdering = DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED;
|
---|
| 628 | pPathInfoArray[i].targetInfo.targetAvailable = TRUE;
|
---|
| 629 | pPathInfoArray[i].targetInfo.statusFlags = DISPLAYCONFIG_TARGET_FORCIBLE;
|
---|
| 630 |
|
---|
| 631 | pPathInfoArray[i].flags = 0;
|
---|
| 632 | }
|
---|
| 633 | }
|
---|
| 634 | }
|
---|
| 635 |
|
---|
[95868] | 636 | RTMemFree(pCfg->pPathInfoArray);
|
---|
[48070] | 637 | pCfg->pPathInfoArray = pPathInfoArray;
|
---|
| 638 | pCfg->cPathInfoArray = cDisplays;
|
---|
| 639 | if (fAllCfgInited)
|
---|
| 640 | vboxDispIfWddmDcTerm(&AllCfg);
|
---|
| 641 |
|
---|
| 642 | return ERROR_SUCCESS;
|
---|
| 643 | }
|
---|
| 644 |
|
---|
| 645 | static DWORD vboxDispIfOpBegin(PCVBOXDISPIF pIf, VBOXDISPIF_OP *pOp)
|
---|
| 646 | {
|
---|
| 647 | pOp->pIf = pIf;
|
---|
| 648 |
|
---|
| 649 | HRESULT hr = vboxDispKmtOpenAdapter(&pIf->modeData.wddm.KmtCallbacks, &pOp->Adapter);
|
---|
| 650 | if (SUCCEEDED(hr))
|
---|
| 651 | {
|
---|
| 652 | hr = vboxDispKmtCreateDevice(&pOp->Adapter, &pOp->Device);
|
---|
| 653 | if (SUCCEEDED(hr))
|
---|
| 654 | {
|
---|
| 655 | hr = vboxDispKmtCreateContext(&pOp->Device, &pOp->Context, VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE,
|
---|
[80425] | 656 | NULL, 0ULL);
|
---|
[48070] | 657 | if (SUCCEEDED(hr))
|
---|
| 658 | return ERROR_SUCCESS;
|
---|
| 659 | else
|
---|
[52136] | 660 | WARN(("VBoxTray: vboxDispKmtCreateContext failed hr 0x%x", hr));
|
---|
[48070] | 661 |
|
---|
| 662 | vboxDispKmtDestroyDevice(&pOp->Device);
|
---|
| 663 | }
|
---|
| 664 | else
|
---|
[52136] | 665 | WARN(("VBoxTray: vboxDispKmtCreateDevice failed hr 0x%x", hr));
|
---|
[48070] | 666 |
|
---|
| 667 | vboxDispKmtCloseAdapter(&pOp->Adapter);
|
---|
| 668 | }
|
---|
| 669 |
|
---|
[84325] | 670 | return ERROR_NOT_SUPPORTED;
|
---|
[48070] | 671 | }
|
---|
| 672 |
|
---|
| 673 | static VOID vboxDispIfOpEnd(VBOXDISPIF_OP *pOp)
|
---|
| 674 | {
|
---|
| 675 | vboxDispKmtDestroyContext(&pOp->Context);
|
---|
| 676 | vboxDispKmtDestroyDevice(&pOp->Device);
|
---|
| 677 | vboxDispKmtCloseAdapter(&pOp->Adapter);
|
---|
| 678 | }
|
---|
| 679 |
|
---|
[31145] | 680 | /* display driver interface abstraction for XPDM & WDDM
|
---|
| 681 | * with WDDM we can not use ExtEscape to communicate with our driver
|
---|
| 682 | * because we do not have XPDM display driver any more, i.e. escape requests are handled by cdd
|
---|
| 683 | * that knows nothing about us */
|
---|
[68367] | 684 | DWORD VBoxDispIfInit(PVBOXDISPIF pDispIf)
|
---|
[31145] | 685 | {
|
---|
[95049] | 686 | /* Note: NT4 is handled implicitly by VBoxDispIfSwitchMode(). */
|
---|
[68367] | 687 | VBoxDispIfSwitchMode(pDispIf, VBOXDISPIF_MODE_XPDM, NULL);
|
---|
| 688 |
|
---|
[31145] | 689 | return NO_ERROR;
|
---|
| 690 | }
|
---|
| 691 |
|
---|
[42217] | 692 | #ifdef VBOX_WITH_WDDM
|
---|
| 693 | static void vboxDispIfWddmTerm(PCVBOXDISPIF pIf);
|
---|
| 694 | static DWORD vboxDispIfWddmInit(PCVBOXDISPIF pIf);
|
---|
| 695 | #endif
|
---|
| 696 |
|
---|
[31145] | 697 | DWORD VBoxDispIfTerm(PVBOXDISPIF pIf)
|
---|
| 698 | {
|
---|
[42217] | 699 | #ifdef VBOX_WITH_WDDM
|
---|
[48070] | 700 | if (pIf->enmMode >= VBOXDISPIF_MODE_WDDM)
|
---|
[42217] | 701 | {
|
---|
| 702 | vboxDispIfWddmTerm(pIf);
|
---|
[48070] | 703 |
|
---|
| 704 | vboxDispKmtCallbacksTerm(&pIf->modeData.wddm.KmtCallbacks);
|
---|
[42217] | 705 | }
|
---|
| 706 | #endif
|
---|
| 707 |
|
---|
[31145] | 708 | pIf->enmMode = VBOXDISPIF_MODE_UNKNOWN;
|
---|
| 709 | return NO_ERROR;
|
---|
| 710 | }
|
---|
| 711 |
|
---|
[42232] | 712 | static DWORD vboxDispIfEscapeXPDM(PCVBOXDISPIF pIf, PVBOXDISPIFESCAPE pEscape, int cbData, int iDirection)
|
---|
[31145] | 713 | {
|
---|
[63099] | 714 | RT_NOREF(pIf);
|
---|
[31145] | 715 | HDC hdc = GetDC(HWND_DESKTOP);
|
---|
| 716 | VOID *pvData = cbData ? VBOXDISPIFESCAPE_DATA(pEscape, VOID) : NULL;
|
---|
[42232] | 717 | int iRet = ExtEscape(hdc, pEscape->escapeCode,
|
---|
| 718 | iDirection >= 0 ? cbData : 0,
|
---|
| 719 | iDirection >= 0 ? (LPSTR)pvData : NULL,
|
---|
| 720 | iDirection <= 0 ? cbData : 0,
|
---|
| 721 | iDirection <= 0 ? (LPSTR)pvData : NULL);
|
---|
[31145] | 722 | ReleaseDC(HWND_DESKTOP, hdc);
|
---|
| 723 | if (iRet > 0)
|
---|
| 724 | return VINF_SUCCESS;
|
---|
[63099] | 725 | if (iRet == 0)
|
---|
[31145] | 726 | return ERROR_NOT_SUPPORTED;
|
---|
| 727 | /* else */
|
---|
| 728 | return ERROR_GEN_FAILURE;
|
---|
| 729 | }
|
---|
| 730 |
|
---|
[32622] | 731 | #ifdef VBOX_WITH_WDDM
|
---|
[31145] | 732 | static DWORD vboxDispIfSwitchToWDDM(PVBOXDISPIF pIf)
|
---|
| 733 | {
|
---|
| 734 | DWORD err = NO_ERROR;
|
---|
[34130] | 735 |
|
---|
[78937] | 736 | bool fSupported = true;
|
---|
| 737 |
|
---|
| 738 | uint64_t const uNtVersion = RTSystemGetNtVersion();
|
---|
| 739 | if (uNtVersion >= RTSYSTEM_MAKE_NT_VERSION(6, 0, 0))
|
---|
[31145] | 740 | {
|
---|
[60274] | 741 | LogFunc(("this is vista and up\n"));
|
---|
[46625] | 742 | HMODULE hUser = GetModuleHandle("user32.dll");
|
---|
[34130] | 743 | if (hUser)
|
---|
[31145] | 744 | {
|
---|
[34130] | 745 | *(uintptr_t *)&pIf->modeData.wddm.pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
|
---|
[60274] | 746 | LogFunc(("VBoxDisplayInit: pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.wddm.pfnChangeDisplaySettingsEx));
|
---|
[78937] | 747 | fSupported &= !!(pIf->modeData.wddm.pfnChangeDisplaySettingsEx);
|
---|
[31145] | 748 |
|
---|
[34130] | 749 | *(uintptr_t *)&pIf->modeData.wddm.pfnEnumDisplayDevices = (uintptr_t)GetProcAddress(hUser, "EnumDisplayDevicesA");
|
---|
[60274] | 750 | LogFunc(("VBoxDisplayInit: pfnEnumDisplayDevices = %p\n", pIf->modeData.wddm.pfnEnumDisplayDevices));
|
---|
[78937] | 751 | fSupported &= !!(pIf->modeData.wddm.pfnEnumDisplayDevices);
|
---|
| 752 |
|
---|
[44557] | 753 | /* for win 7 and above */
|
---|
[78937] | 754 | if (uNtVersion >= RTSYSTEM_MAKE_NT_VERSION(6, 1, 0))
|
---|
[44557] | 755 | {
|
---|
| 756 | *(uintptr_t *)&gCtx.pfnSetDisplayConfig = (uintptr_t)GetProcAddress(hUser, "SetDisplayConfig");
|
---|
[60274] | 757 | LogFunc(("VBoxDisplayInit: pfnSetDisplayConfig = %p\n", gCtx.pfnSetDisplayConfig));
|
---|
[78937] | 758 | fSupported &= !!(gCtx.pfnSetDisplayConfig);
|
---|
[31145] | 759 |
|
---|
[44557] | 760 | *(uintptr_t *)&gCtx.pfnQueryDisplayConfig = (uintptr_t)GetProcAddress(hUser, "QueryDisplayConfig");
|
---|
[60274] | 761 | LogFunc(("VBoxDisplayInit: pfnQueryDisplayConfig = %p\n", gCtx.pfnQueryDisplayConfig));
|
---|
[78937] | 762 | fSupported &= !!(gCtx.pfnQueryDisplayConfig);
|
---|
[44557] | 763 |
|
---|
| 764 | *(uintptr_t *)&gCtx.pfnGetDisplayConfigBufferSizes = (uintptr_t)GetProcAddress(hUser, "GetDisplayConfigBufferSizes");
|
---|
[60274] | 765 | LogFunc(("VBoxDisplayInit: pfnGetDisplayConfigBufferSizes = %p\n", gCtx.pfnGetDisplayConfigBufferSizes));
|
---|
[78937] | 766 | fSupported &= !!(gCtx.pfnGetDisplayConfigBufferSizes);
|
---|
[44557] | 767 | }
|
---|
| 768 |
|
---|
[34130] | 769 | /* this is vista and up */
|
---|
[48070] | 770 | HRESULT hr = vboxDispKmtCallbacksInit(&pIf->modeData.wddm.KmtCallbacks);
|
---|
| 771 | if (FAILED(hr))
|
---|
[34130] | 772 | {
|
---|
[52136] | 773 | WARN(("VBoxTray: vboxDispKmtCallbacksInit failed hr 0x%x\n", hr));
|
---|
[48070] | 774 | err = hr;
|
---|
[34130] | 775 | }
|
---|
[31145] | 776 | }
|
---|
| 777 | else
|
---|
| 778 | {
|
---|
[84325] | 779 | WARN(("GetModuleHandle(USER32) failed, err(%d)\n", GetLastError()));
|
---|
[31145] | 780 | err = ERROR_NOT_SUPPORTED;
|
---|
| 781 | }
|
---|
| 782 | }
|
---|
| 783 | else
|
---|
| 784 | {
|
---|
[84325] | 785 | WARN(("can not switch to VBOXDISPIF_MODE_WDDM, because os is not Vista or upper\n"));
|
---|
[31145] | 786 | err = ERROR_NOT_SUPPORTED;
|
---|
| 787 | }
|
---|
| 788 |
|
---|
[42217] | 789 | if (err == ERROR_SUCCESS)
|
---|
| 790 | {
|
---|
| 791 | err = vboxDispIfWddmInit(pIf);
|
---|
| 792 | }
|
---|
| 793 |
|
---|
[31145] | 794 | return err;
|
---|
| 795 | }
|
---|
| 796 |
|
---|
[48070] | 797 | static DWORD vboxDispIfSwitchToWDDM_W7(PVBOXDISPIF pIf)
|
---|
| 798 | {
|
---|
| 799 | return vboxDispIfSwitchToWDDM(pIf);
|
---|
| 800 | }
|
---|
| 801 |
|
---|
[33931] | 802 | static DWORD vboxDispIfWDDMAdpHdcCreate(int iDisplay, HDC *phDc, DISPLAY_DEVICE *pDev)
|
---|
[31145] | 803 | {
|
---|
[33931] | 804 | DWORD winEr = ERROR_INVALID_STATE;
|
---|
| 805 | memset(pDev, 0, sizeof (*pDev));
|
---|
| 806 | pDev->cb = sizeof (*pDev);
|
---|
| 807 |
|
---|
| 808 | for (int i = 0; ; ++i)
|
---|
[31145] | 809 | {
|
---|
[33931] | 810 | if (EnumDisplayDevices(NULL, /* LPCTSTR lpDevice */ i, /* DWORD iDevNum */
|
---|
| 811 | pDev, 0 /* DWORD dwFlags*/))
|
---|
[31145] | 812 | {
|
---|
[33931] | 813 | if (i == iDisplay || (iDisplay < 0 && pDev->StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE))
|
---|
[31145] | 814 | {
|
---|
[33931] | 815 | HDC hDc = CreateDC(NULL, pDev->DeviceName, NULL, NULL);
|
---|
| 816 | if (hDc)
|
---|
| 817 | {
|
---|
| 818 | *phDc = hDc;
|
---|
| 819 | return NO_ERROR;
|
---|
| 820 | }
|
---|
| 821 | else
|
---|
| 822 | {
|
---|
| 823 | winEr = GetLastError();
|
---|
[52136] | 824 | WARN(("CreateDC failed %d", winEr));
|
---|
[33931] | 825 | break;
|
---|
| 826 | }
|
---|
[31145] | 827 | }
|
---|
[52136] | 828 | Log(("display data no match display(%d): i(%d), flags(%d)", iDisplay, i, pDev->StateFlags));
|
---|
[31145] | 829 | }
|
---|
[33931] | 830 | else
|
---|
| 831 | {
|
---|
| 832 | winEr = GetLastError();
|
---|
[52136] | 833 | WARN(("EnumDisplayDevices failed %d", winEr));
|
---|
[33931] | 834 | break;
|
---|
| 835 | }
|
---|
[31145] | 836 | }
|
---|
[33931] | 837 |
|
---|
[52136] | 838 | WARN(("vboxDispIfWDDMAdpHdcCreate failure branch %d", winEr));
|
---|
[33931] | 839 | return winEr;
|
---|
| 840 | }
|
---|
| 841 |
|
---|
[48070] | 842 | static DWORD vboxDispIfEscapeWDDM(PCVBOXDISPIF pIf, PVBOXDISPIFESCAPE pEscape, int cbData, BOOL fHwAccess)
|
---|
[33931] | 843 | {
|
---|
[48070] | 844 | DWORD winEr = ERROR_SUCCESS;
|
---|
| 845 | VBOXDISPKMT_ADAPTER Adapter;
|
---|
| 846 | HRESULT hr = vboxDispKmtOpenAdapter(&pIf->modeData.wddm.KmtCallbacks, &Adapter);
|
---|
| 847 | if (!SUCCEEDED(hr))
|
---|
[31687] | 848 | {
|
---|
[52136] | 849 | WARN(("VBoxTray: vboxDispKmtOpenAdapter failed hr 0x%x\n", hr));
|
---|
[48070] | 850 | return hr;
|
---|
[31687] | 851 | }
|
---|
[31145] | 852 |
|
---|
| 853 | D3DKMT_ESCAPE EscapeData = {0};
|
---|
[48070] | 854 | EscapeData.hAdapter = Adapter.hAdapter;
|
---|
[31145] | 855 | //EscapeData.hDevice = NULL;
|
---|
| 856 | EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
|
---|
[48070] | 857 | if (fHwAccess)
|
---|
| 858 | EscapeData.Flags.HardwareAccess = 1;
|
---|
| 859 | EscapeData.pPrivateDriverData = pEscape;
|
---|
| 860 | EscapeData.PrivateDriverDataSize = VBOXDISPIFESCAPE_SIZE(cbData);
|
---|
[31145] | 861 | //EscapeData.hContext = NULL;
|
---|
| 862 |
|
---|
[48070] | 863 | NTSTATUS Status = pIf->modeData.wddm.KmtCallbacks.pfnD3DKMTEscape(&EscapeData);
|
---|
| 864 | if (NT_SUCCESS(Status))
|
---|
| 865 | winEr = ERROR_SUCCESS;
|
---|
[31145] | 866 | else
|
---|
| 867 | {
|
---|
[84325] | 868 | WARN(("VBoxTray: pfnD3DKMTEscape(0x%08X) failed Status 0x%x\n", pEscape->escapeCode, Status));
|
---|
[48070] | 869 | winEr = ERROR_GEN_FAILURE;
|
---|
[31145] | 870 | }
|
---|
| 871 |
|
---|
[48070] | 872 | vboxDispKmtCloseAdapter(&Adapter);
|
---|
[31145] | 873 |
|
---|
[48070] | 874 | return winEr;
|
---|
[31145] | 875 | }
|
---|
| 876 | #endif
|
---|
| 877 |
|
---|
| 878 | DWORD VBoxDispIfEscape(PCVBOXDISPIF pIf, PVBOXDISPIFESCAPE pEscape, int cbData)
|
---|
| 879 | {
|
---|
| 880 | switch (pIf->enmMode)
|
---|
| 881 | {
|
---|
| 882 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
| 883 | case VBOXDISPIF_MODE_XPDM:
|
---|
[42232] | 884 | return vboxDispIfEscapeXPDM(pIf, pEscape, cbData, 1);
|
---|
[32622] | 885 | #ifdef VBOX_WITH_WDDM
|
---|
[31145] | 886 | case VBOXDISPIF_MODE_WDDM:
|
---|
[48070] | 887 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
[42098] | 888 | return vboxDispIfEscapeWDDM(pIf, pEscape, cbData, TRUE /* BOOL fHwAccess */);
|
---|
[31145] | 889 | #endif
|
---|
| 890 | default:
|
---|
[60274] | 891 | LogFunc(("unknown mode (%d)\n", pIf->enmMode));
|
---|
[31145] | 892 | return ERROR_INVALID_PARAMETER;
|
---|
| 893 | }
|
---|
| 894 | }
|
---|
| 895 |
|
---|
[42232] | 896 | DWORD VBoxDispIfEscapeInOut(PCVBOXDISPIF const pIf, PVBOXDISPIFESCAPE pEscape, int cbData)
|
---|
| 897 | {
|
---|
| 898 | switch (pIf->enmMode)
|
---|
| 899 | {
|
---|
| 900 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
| 901 | case VBOXDISPIF_MODE_XPDM:
|
---|
| 902 | return vboxDispIfEscapeXPDM(pIf, pEscape, cbData, 0);
|
---|
| 903 | #ifdef VBOX_WITH_WDDM
|
---|
| 904 | case VBOXDISPIF_MODE_WDDM:
|
---|
[48070] | 905 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
[42232] | 906 | return vboxDispIfEscapeWDDM(pIf, pEscape, cbData, TRUE /* BOOL fHwAccess */);
|
---|
| 907 | #endif
|
---|
| 908 | default:
|
---|
[60274] | 909 | LogFunc(("unknown mode (%d)\n", pIf->enmMode));
|
---|
[42232] | 910 | return ERROR_INVALID_PARAMETER;
|
---|
| 911 | }
|
---|
| 912 | }
|
---|
| 913 |
|
---|
[32622] | 914 | #ifdef VBOX_WITH_WDDM
|
---|
[31145] | 915 |
|
---|
[44550] | 916 | #define VBOXRR_TIMER_ID 1234
|
---|
| 917 |
|
---|
| 918 | typedef struct VBOXRR
|
---|
| 919 | {
|
---|
| 920 | HANDLE hThread;
|
---|
| 921 | DWORD idThread;
|
---|
| 922 | HANDLE hEvent;
|
---|
| 923 | HWND hWnd;
|
---|
| 924 | CRITICAL_SECTION CritSect;
|
---|
| 925 | UINT_PTR idTimer;
|
---|
| 926 | PCVBOXDISPIF pIf;
|
---|
[48070] | 927 | UINT iChangedMode;
|
---|
| 928 | BOOL fEnable;
|
---|
| 929 | BOOL fExtDispSup;
|
---|
[44550] | 930 | DISPLAY_DEVICE *paDisplayDevices;
|
---|
| 931 | DEVMODE *paDeviceModes;
|
---|
| 932 | UINT cDevModes;
|
---|
| 933 | } VBOXRR, *PVBOXRR;
|
---|
| 934 |
|
---|
| 935 | static VBOXRR g_VBoxRr = {0};
|
---|
| 936 |
|
---|
| 937 | #define VBOX_E_INSUFFICIENT_BUFFER HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)
|
---|
| 938 | #define VBOX_E_NOT_SUPPORTED HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED)
|
---|
| 939 |
|
---|
| 940 | static void vboxRrRetryStopLocked()
|
---|
| 941 | {
|
---|
| 942 | PVBOXRR pMon = &g_VBoxRr;
|
---|
| 943 | if (pMon->pIf)
|
---|
| 944 | {
|
---|
| 945 | if (pMon->paDisplayDevices)
|
---|
| 946 | {
|
---|
[95868] | 947 | RTMemFree(pMon->paDisplayDevices);
|
---|
[44550] | 948 | pMon->paDisplayDevices = NULL;
|
---|
| 949 | }
|
---|
| 950 |
|
---|
| 951 | if (pMon->paDeviceModes)
|
---|
| 952 | {
|
---|
[95868] | 953 | RTMemFree(pMon->paDeviceModes);
|
---|
[44550] | 954 | pMon->paDeviceModes = NULL;
|
---|
| 955 | }
|
---|
| 956 |
|
---|
| 957 | if (pMon->idTimer)
|
---|
| 958 | {
|
---|
| 959 | KillTimer(pMon->hWnd, pMon->idTimer);
|
---|
| 960 | pMon->idTimer = 0;
|
---|
| 961 | }
|
---|
| 962 |
|
---|
| 963 | pMon->cDevModes = 0;
|
---|
| 964 | pMon->pIf = NULL;
|
---|
| 965 | }
|
---|
| 966 | }
|
---|
| 967 |
|
---|
| 968 | static void VBoxRrRetryStop()
|
---|
| 969 | {
|
---|
| 970 | PVBOXRR pMon = &g_VBoxRr;
|
---|
| 971 | EnterCriticalSection(&pMon->CritSect);
|
---|
| 972 | vboxRrRetryStopLocked();
|
---|
| 973 | LeaveCriticalSection(&pMon->CritSect);
|
---|
| 974 | }
|
---|
| 975 |
|
---|
[48070] | 976 | //static DWORD vboxDispIfWddmValidateFixResize(PCVBOXDISPIF const pIf, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes);
|
---|
[44550] | 977 |
|
---|
| 978 | static void vboxRrRetryReschedule()
|
---|
| 979 | {
|
---|
| 980 | }
|
---|
| 981 |
|
---|
[48070] | 982 | static void VBoxRrRetrySchedule(PCVBOXDISPIF const pIf, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes)
|
---|
[44550] | 983 | {
|
---|
| 984 | PVBOXRR pMon = &g_VBoxRr;
|
---|
| 985 | EnterCriticalSection(&pMon->CritSect);
|
---|
| 986 | vboxRrRetryStopLocked();
|
---|
| 987 |
|
---|
| 988 | pMon->pIf = pIf;
|
---|
[48070] | 989 | pMon->iChangedMode = iChangedMode;
|
---|
| 990 | pMon->fEnable = fEnable;
|
---|
| 991 | pMon->fExtDispSup = fExtDispSup;
|
---|
| 992 |
|
---|
[44550] | 993 | if (cDevModes)
|
---|
| 994 | {
|
---|
[95868] | 995 | pMon->paDisplayDevices = (DISPLAY_DEVICE*)RTMemAlloc(sizeof (*paDisplayDevices) * cDevModes);
|
---|
[44550] | 996 | Assert(pMon->paDisplayDevices);
|
---|
| 997 | if (!pMon->paDisplayDevices)
|
---|
| 998 | {
|
---|
[95868] | 999 | Log(("RTMemAlloc failed!"));
|
---|
[44550] | 1000 | vboxRrRetryStopLocked();
|
---|
| 1001 | LeaveCriticalSection(&pMon->CritSect);
|
---|
| 1002 | return;
|
---|
| 1003 | }
|
---|
| 1004 | memcpy(pMon->paDisplayDevices, paDisplayDevices, sizeof (*paDisplayDevices) * cDevModes);
|
---|
| 1005 |
|
---|
[95868] | 1006 | pMon->paDeviceModes = (DEVMODE*)RTMemAlloc(sizeof (*paDeviceModes) * cDevModes);
|
---|
[44550] | 1007 | Assert(pMon->paDeviceModes);
|
---|
| 1008 | if (!pMon->paDeviceModes)
|
---|
| 1009 | {
|
---|
[95868] | 1010 | Log(("RTMemAlloc failed!"));
|
---|
[44550] | 1011 | vboxRrRetryStopLocked();
|
---|
| 1012 | LeaveCriticalSection(&pMon->CritSect);
|
---|
| 1013 | return;
|
---|
| 1014 | }
|
---|
| 1015 | memcpy(pMon->paDeviceModes, paDeviceModes, sizeof (*paDeviceModes) * cDevModes);
|
---|
| 1016 | }
|
---|
| 1017 | pMon->cDevModes = cDevModes;
|
---|
| 1018 |
|
---|
| 1019 | pMon->idTimer = SetTimer(pMon->hWnd, VBOXRR_TIMER_ID, 1000, (TIMERPROC)NULL);
|
---|
| 1020 | Assert(pMon->idTimer);
|
---|
| 1021 | if (!pMon->idTimer)
|
---|
| 1022 | {
|
---|
[52136] | 1023 | WARN(("VBoxTray: SetTimer failed!, err %d\n", GetLastError()));
|
---|
[44550] | 1024 | vboxRrRetryStopLocked();
|
---|
| 1025 | }
|
---|
| 1026 |
|
---|
| 1027 | LeaveCriticalSection(&pMon->CritSect);
|
---|
| 1028 | }
|
---|
| 1029 |
|
---|
| 1030 | static void vboxRrRetryPerform()
|
---|
| 1031 | {
|
---|
| 1032 | PVBOXRR pMon = &g_VBoxRr;
|
---|
| 1033 | EnterCriticalSection(&pMon->CritSect);
|
---|
| 1034 | if (pMon->pIf)
|
---|
| 1035 | {
|
---|
[48070] | 1036 | DWORD dwErr = vboxDispIfResizePerform(pMon->pIf, pMon->iChangedMode, pMon->fEnable, pMon->fExtDispSup, pMon->paDisplayDevices, pMon->paDeviceModes, pMon->cDevModes);
|
---|
[44550] | 1037 | if (ERROR_RETRY != dwErr)
|
---|
| 1038 | VBoxRrRetryStop();
|
---|
| 1039 | else
|
---|
| 1040 | vboxRrRetryReschedule();
|
---|
| 1041 | }
|
---|
| 1042 | LeaveCriticalSection(&pMon->CritSect);
|
---|
| 1043 | }
|
---|
| 1044 |
|
---|
| 1045 | static LRESULT CALLBACK vboxRrWndProc(HWND hwnd,
|
---|
| 1046 | UINT uMsg,
|
---|
| 1047 | WPARAM wParam,
|
---|
| 1048 | LPARAM lParam
|
---|
| 1049 | )
|
---|
| 1050 | {
|
---|
| 1051 | switch(uMsg)
|
---|
| 1052 | {
|
---|
| 1053 | case WM_DISPLAYCHANGE:
|
---|
| 1054 | {
|
---|
[52136] | 1055 | Log(("VBoxTray: WM_DISPLAYCHANGE\n"));
|
---|
[44550] | 1056 | VBoxRrRetryStop();
|
---|
| 1057 | return 0;
|
---|
| 1058 | }
|
---|
| 1059 | case WM_TIMER:
|
---|
| 1060 | {
|
---|
| 1061 | if (wParam == VBOXRR_TIMER_ID)
|
---|
| 1062 | {
|
---|
[52136] | 1063 | Log(("VBoxTray: VBOXRR_TIMER_ID\n"));
|
---|
[44550] | 1064 | vboxRrRetryPerform();
|
---|
| 1065 | return 0;
|
---|
| 1066 | }
|
---|
| 1067 | break;
|
---|
| 1068 | }
|
---|
| 1069 | case WM_NCHITTEST:
|
---|
[60274] | 1070 | LogFunc(("got WM_NCHITTEST for hwnd(0x%x)\n", hwnd));
|
---|
[44550] | 1071 | return HTNOWHERE;
|
---|
| 1072 | default:
|
---|
| 1073 | break;
|
---|
| 1074 | }
|
---|
| 1075 |
|
---|
| 1076 | return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
---|
| 1077 | }
|
---|
| 1078 |
|
---|
| 1079 | #define VBOXRRWND_NAME "VBoxRrWnd"
|
---|
| 1080 |
|
---|
| 1081 | static HRESULT vboxRrWndCreate(HWND *phWnd)
|
---|
| 1082 | {
|
---|
| 1083 | HRESULT hr = S_OK;
|
---|
[57741] | 1084 |
|
---|
| 1085 | /** @todo r=andy Use VBOXSERVICEENV::hInstance. */
|
---|
[44550] | 1086 | HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
|
---|
[57741] | 1087 |
|
---|
[44550] | 1088 | /* Register the Window Class. */
|
---|
[57741] | 1089 | WNDCLASSEX wc = { 0 };
|
---|
| 1090 | wc.cbSize = sizeof(WNDCLASSEX);
|
---|
| 1091 |
|
---|
| 1092 | if (!GetClassInfoEx(hInstance, VBOXRRWND_NAME, &wc))
|
---|
[44550] | 1093 | {
|
---|
[57741] | 1094 | wc.lpfnWndProc = vboxRrWndProc;
|
---|
| 1095 | wc.hInstance = hInstance;
|
---|
[44550] | 1096 | wc.lpszClassName = VBOXRRWND_NAME;
|
---|
[57741] | 1097 |
|
---|
| 1098 | if (!RegisterClassEx(&wc))
|
---|
[44550] | 1099 | {
|
---|
[84325] | 1100 | WARN(("RegisterClass failed, winErr(%d)\n", GetLastError()));
|
---|
[44550] | 1101 | hr = E_FAIL;
|
---|
| 1102 | }
|
---|
| 1103 | }
|
---|
| 1104 |
|
---|
| 1105 | if (hr == S_OK)
|
---|
| 1106 | {
|
---|
| 1107 | HWND hWnd = CreateWindowEx (WS_EX_TOOLWINDOW,
|
---|
| 1108 | VBOXRRWND_NAME, VBOXRRWND_NAME,
|
---|
| 1109 | WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED,
|
---|
| 1110 | -100, -100,
|
---|
| 1111 | 10, 10,
|
---|
| 1112 | NULL, //GetDesktopWindow() /* hWndParent */,
|
---|
| 1113 | NULL /* hMenu */,
|
---|
| 1114 | hInstance,
|
---|
| 1115 | NULL /* lpParam */);
|
---|
| 1116 | Assert(hWnd);
|
---|
| 1117 | if (hWnd)
|
---|
| 1118 | {
|
---|
| 1119 | *phWnd = hWnd;
|
---|
| 1120 | }
|
---|
| 1121 | else
|
---|
| 1122 | {
|
---|
[84325] | 1123 | WARN(("CreateWindowEx failed, winErr(%d)\n", GetLastError()));
|
---|
[44550] | 1124 | hr = E_FAIL;
|
---|
| 1125 | }
|
---|
| 1126 | }
|
---|
| 1127 |
|
---|
| 1128 | return hr;
|
---|
| 1129 | }
|
---|
| 1130 |
|
---|
| 1131 | static HRESULT vboxRrWndDestroy(HWND hWnd)
|
---|
| 1132 | {
|
---|
| 1133 | BOOL bResult = DestroyWindow(hWnd);
|
---|
| 1134 | if (bResult)
|
---|
| 1135 | return S_OK;
|
---|
| 1136 |
|
---|
| 1137 | DWORD winErr = GetLastError();
|
---|
[84325] | 1138 | WARN(("DestroyWindow failed, winErr(%d) for hWnd(0x%x)\n", winErr, hWnd));
|
---|
[44550] | 1139 |
|
---|
| 1140 | return HRESULT_FROM_WIN32(winErr);
|
---|
| 1141 | }
|
---|
| 1142 |
|
---|
| 1143 | static HRESULT vboxRrWndInit()
|
---|
| 1144 | {
|
---|
| 1145 | PVBOXRR pMon = &g_VBoxRr;
|
---|
| 1146 | return vboxRrWndCreate(&pMon->hWnd);
|
---|
| 1147 | }
|
---|
| 1148 |
|
---|
| 1149 | HRESULT vboxRrWndTerm()
|
---|
| 1150 | {
|
---|
| 1151 | PVBOXRR pMon = &g_VBoxRr;
|
---|
[63099] | 1152 | HRESULT hrTmp = vboxRrWndDestroy(pMon->hWnd);
|
---|
| 1153 | Assert(hrTmp == S_OK); NOREF(hrTmp);
|
---|
[44550] | 1154 |
|
---|
| 1155 | HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
|
---|
| 1156 | UnregisterClass(VBOXRRWND_NAME, hInstance);
|
---|
| 1157 |
|
---|
| 1158 | return S_OK;
|
---|
| 1159 | }
|
---|
| 1160 |
|
---|
| 1161 | #define WM_VBOXRR_INIT_QUIT (WM_APP+2)
|
---|
| 1162 |
|
---|
| 1163 | HRESULT vboxRrRun()
|
---|
| 1164 | {
|
---|
| 1165 | PVBOXRR pMon = &g_VBoxRr;
|
---|
| 1166 | MSG Msg;
|
---|
| 1167 |
|
---|
| 1168 | HRESULT hr = S_FALSE;
|
---|
| 1169 |
|
---|
[61943] | 1170 | /* Create the thread message queue*/
|
---|
[44550] | 1171 | PeekMessage(&Msg,
|
---|
| 1172 | NULL /* HWND hWnd */,
|
---|
| 1173 | WM_USER /* UINT wMsgFilterMin */,
|
---|
| 1174 | WM_USER /* UINT wMsgFilterMax */,
|
---|
| 1175 | PM_NOREMOVE);
|
---|
[62470] | 1176 |
|
---|
| 1177 | /*
|
---|
[61943] | 1178 | * Send signal that message queue is ready.
|
---|
| 1179 | * From this moment only the thread is ready to receive messages.
|
---|
| 1180 | */
|
---|
| 1181 | BOOL bRc = SetEvent(pMon->hEvent);
|
---|
| 1182 | if (!bRc)
|
---|
| 1183 | {
|
---|
| 1184 | DWORD winErr = GetLastError();
|
---|
[84325] | 1185 | WARN(("SetEvent failed, winErr = (%d)", winErr));
|
---|
[63099] | 1186 | HRESULT hrTmp = HRESULT_FROM_WIN32(winErr);
|
---|
| 1187 | Assert(hrTmp != S_OK); NOREF(hrTmp);
|
---|
[61943] | 1188 | }
|
---|
[44550] | 1189 |
|
---|
| 1190 | do
|
---|
| 1191 | {
|
---|
| 1192 | BOOL bResult = GetMessage(&Msg,
|
---|
| 1193 | 0 /*HWND hWnd*/,
|
---|
| 1194 | 0 /*UINT wMsgFilterMin*/,
|
---|
| 1195 | 0 /*UINT wMsgFilterMax*/
|
---|
| 1196 | );
|
---|
| 1197 |
|
---|
[61943] | 1198 | if (bResult == -1) /* error occurred */
|
---|
[44550] | 1199 | {
|
---|
| 1200 | DWORD winEr = GetLastError();
|
---|
| 1201 | hr = HRESULT_FROM_WIN32(winEr);
|
---|
| 1202 | /* just ensure we never return success in this case */
|
---|
| 1203 | Assert(hr != S_OK);
|
---|
| 1204 | Assert(hr != S_FALSE);
|
---|
| 1205 | if (hr == S_OK || hr == S_FALSE)
|
---|
| 1206 | hr = E_FAIL;
|
---|
[52136] | 1207 | WARN(("VBoxTray: GetMessage returned -1, err %d\n", winEr));
|
---|
[44550] | 1208 | VBoxRrRetryStop();
|
---|
| 1209 | break;
|
---|
| 1210 | }
|
---|
| 1211 |
|
---|
[61943] | 1212 | if(!bResult) /* WM_QUIT was posted */
|
---|
| 1213 | {
|
---|
| 1214 | hr = S_FALSE;
|
---|
| 1215 | Log(("VBoxTray: GetMessage returned FALSE\n"));
|
---|
| 1216 | VBoxRrRetryStop();
|
---|
| 1217 | break;
|
---|
| 1218 | }
|
---|
[62470] | 1219 |
|
---|
[44550] | 1220 | switch (Msg.message)
|
---|
| 1221 | {
|
---|
| 1222 | case WM_VBOXRR_INIT_QUIT:
|
---|
| 1223 | case WM_CLOSE:
|
---|
| 1224 | {
|
---|
[52136] | 1225 | Log(("VBoxTray: closing Rr %d\n", Msg.message));
|
---|
[44550] | 1226 | VBoxRrRetryStop();
|
---|
| 1227 | PostQuitMessage(0);
|
---|
| 1228 | break;
|
---|
| 1229 | }
|
---|
| 1230 | default:
|
---|
| 1231 | TranslateMessage(&Msg);
|
---|
| 1232 | DispatchMessage(&Msg);
|
---|
| 1233 | break;
|
---|
| 1234 | }
|
---|
| 1235 | } while (1);
|
---|
| 1236 | return 0;
|
---|
| 1237 | }
|
---|
| 1238 |
|
---|
[85121] | 1239 | /** @todo r=bird: Only the CRT uses CreateThread for creating threading!! */
|
---|
| 1240 | static DWORD WINAPI vboxRrRunnerThread(void *pvUser) RT_NOTHROW_DEF
|
---|
[44550] | 1241 | {
|
---|
[63099] | 1242 | RT_NOREF(pvUser);
|
---|
[44550] | 1243 | HRESULT hr = vboxRrWndInit();
|
---|
| 1244 | Assert(hr == S_OK);
|
---|
| 1245 | if (hr == S_OK)
|
---|
| 1246 | {
|
---|
| 1247 | hr = vboxRrRun();
|
---|
| 1248 | Assert(hr == S_OK);
|
---|
| 1249 |
|
---|
| 1250 | vboxRrWndTerm();
|
---|
| 1251 | }
|
---|
| 1252 |
|
---|
| 1253 | return 0;
|
---|
| 1254 | }
|
---|
| 1255 |
|
---|
| 1256 | HRESULT VBoxRrInit()
|
---|
| 1257 | {
|
---|
| 1258 | HRESULT hr = E_FAIL;
|
---|
| 1259 | PVBOXRR pMon = &g_VBoxRr;
|
---|
| 1260 | memset(pMon, 0, sizeof (*pMon));
|
---|
| 1261 |
|
---|
| 1262 | InitializeCriticalSection(&pMon->CritSect);
|
---|
| 1263 |
|
---|
| 1264 | pMon->hEvent = CreateEvent(NULL, /* LPSECURITY_ATTRIBUTES lpEventAttributes*/
|
---|
| 1265 | TRUE, /* BOOL bManualReset*/
|
---|
| 1266 | FALSE, /* BOOL bInitialState */
|
---|
| 1267 | NULL /* LPCTSTR lpName */
|
---|
| 1268 | );
|
---|
| 1269 | if (pMon->hEvent)
|
---|
| 1270 | {
|
---|
[85121] | 1271 | /** @todo r=bird: What kind of stupid nonsense is this?!?
|
---|
| 1272 | * Only the CRT uses CreateThread for creating threading!!
|
---|
| 1273 | */
|
---|
[44550] | 1274 | pMon->hThread = CreateThread(NULL /* LPSECURITY_ATTRIBUTES lpThreadAttributes */,
|
---|
| 1275 | 0 /* SIZE_T dwStackSize */,
|
---|
[85121] | 1276 | vboxRrRunnerThread,
|
---|
| 1277 | pMon,
|
---|
| 1278 | 0 /* DWORD dwCreationFlags */,
|
---|
| 1279 | &pMon->idThread);
|
---|
[44550] | 1280 | if (pMon->hThread)
|
---|
| 1281 | {
|
---|
| 1282 | DWORD dwResult = WaitForSingleObject(pMon->hEvent, INFINITE);
|
---|
| 1283 | if (dwResult == WAIT_OBJECT_0)
|
---|
| 1284 | return S_OK;
|
---|
[85121] | 1285 | Log(("WaitForSingleObject failed!"));
|
---|
| 1286 | hr = E_FAIL;
|
---|
[44550] | 1287 | }
|
---|
| 1288 | else
|
---|
| 1289 | {
|
---|
| 1290 | DWORD winErr = GetLastError();
|
---|
[84325] | 1291 | WARN(("CreateThread failed, winErr = (%d)", winErr));
|
---|
[44550] | 1292 | hr = HRESULT_FROM_WIN32(winErr);
|
---|
| 1293 | Assert(hr != S_OK);
|
---|
| 1294 | }
|
---|
| 1295 | CloseHandle(pMon->hEvent);
|
---|
| 1296 | }
|
---|
| 1297 | else
|
---|
| 1298 | {
|
---|
| 1299 | DWORD winErr = GetLastError();
|
---|
[84325] | 1300 | WARN(("CreateEvent failed, winErr = (%d)", winErr));
|
---|
[44550] | 1301 | hr = HRESULT_FROM_WIN32(winErr);
|
---|
| 1302 | Assert(hr != S_OK);
|
---|
| 1303 | }
|
---|
| 1304 |
|
---|
| 1305 | DeleteCriticalSection(&pMon->CritSect);
|
---|
| 1306 |
|
---|
| 1307 | return hr;
|
---|
| 1308 | }
|
---|
| 1309 |
|
---|
| 1310 | VOID VBoxRrTerm()
|
---|
| 1311 | {
|
---|
| 1312 | HRESULT hr;
|
---|
| 1313 | PVBOXRR pMon = &g_VBoxRr;
|
---|
| 1314 | if (!pMon->hThread)
|
---|
| 1315 | return;
|
---|
| 1316 |
|
---|
| 1317 | BOOL bResult = PostThreadMessage(pMon->idThread, WM_VBOXRR_INIT_QUIT, 0, 0);
|
---|
| 1318 | DWORD winErr;
|
---|
| 1319 | if (bResult
|
---|
| 1320 | || (winErr = GetLastError()) == ERROR_INVALID_THREAD_ID) /* <- could be that the thread is terminated */
|
---|
| 1321 | {
|
---|
| 1322 | DWORD dwErr = WaitForSingleObject(pMon->hThread, INFINITE);
|
---|
| 1323 | if (dwErr == WAIT_OBJECT_0)
|
---|
| 1324 | {
|
---|
| 1325 | hr = S_OK;
|
---|
| 1326 | }
|
---|
| 1327 | else
|
---|
| 1328 | {
|
---|
| 1329 | winErr = GetLastError();
|
---|
| 1330 | hr = HRESULT_FROM_WIN32(winErr);
|
---|
| 1331 | }
|
---|
| 1332 | }
|
---|
| 1333 | else
|
---|
| 1334 | {
|
---|
| 1335 | hr = HRESULT_FROM_WIN32(winErr);
|
---|
| 1336 | }
|
---|
| 1337 |
|
---|
| 1338 | DeleteCriticalSection(&pMon->CritSect);
|
---|
| 1339 |
|
---|
| 1340 | CloseHandle(pMon->hThread);
|
---|
| 1341 | pMon->hThread = 0;
|
---|
| 1342 | CloseHandle(pMon->hEvent);
|
---|
| 1343 | pMon->hThread = 0;
|
---|
| 1344 | }
|
---|
| 1345 |
|
---|
[48070] | 1346 | static DWORD vboxDispIfWddmInit(PCVBOXDISPIF pIf)
|
---|
| 1347 | {
|
---|
[63099] | 1348 | RT_NOREF(pIf);
|
---|
[48070] | 1349 | HRESULT hr = VBoxRrInit();
|
---|
| 1350 | if (SUCCEEDED(hr))
|
---|
| 1351 | return ERROR_SUCCESS;
|
---|
[52136] | 1352 | WARN(("VBoxTray: VBoxRrInit failed hr 0x%x\n", hr));
|
---|
[48070] | 1353 | return hr;
|
---|
| 1354 | }
|
---|
[44931] | 1355 |
|
---|
[48070] | 1356 | static void vboxDispIfWddmTerm(PCVBOXDISPIF pIf)
|
---|
[42217] | 1357 | {
|
---|
[63099] | 1358 | RT_NOREF(pIf);
|
---|
[48070] | 1359 | VBoxRrTerm();
|
---|
| 1360 | }
|
---|
[42217] | 1361 |
|
---|
[48070] | 1362 | static DWORD vboxDispIfQueryDisplayConnection(VBOXDISPIF_OP *pOp, UINT32 iDisplay, BOOL *pfConnected)
|
---|
[42217] | 1363 | {
|
---|
[48070] | 1364 | if (pOp->pIf->enmMode == VBOXDISPIF_MODE_WDDM)
|
---|
[34130] | 1365 | {
|
---|
[63566] | 1366 | /** @todo do we need ti impl it? */
|
---|
[48070] | 1367 | *pfConnected = TRUE;
|
---|
| 1368 | return ERROR_SUCCESS;
|
---|
| 1369 | }
|
---|
[34130] | 1370 |
|
---|
[48070] | 1371 | *pfConnected = FALSE;
|
---|
[34130] | 1372 |
|
---|
[48070] | 1373 | VBOXDISPIF_WDDM_DISPCFG DispCfg;
|
---|
| 1374 | DWORD winEr = vboxDispIfWddmDcCreate(&DispCfg, QDC_ALL_PATHS);
|
---|
| 1375 | if (winEr != ERROR_SUCCESS)
|
---|
| 1376 | {
|
---|
[52136] | 1377 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate winEr %d\n", winEr));
|
---|
[48070] | 1378 | return winEr;
|
---|
| 1379 | }
|
---|
[34130] | 1380 |
|
---|
[48070] | 1381 | int idx = vboxDispIfWddmDcSearchPath(&DispCfg, iDisplay, iDisplay);
|
---|
| 1382 | *pfConnected = (idx >= 0);
|
---|
[34130] | 1383 |
|
---|
[48070] | 1384 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 1385 |
|
---|
| 1386 | return ERROR_SUCCESS;
|
---|
| 1387 | }
|
---|
| 1388 |
|
---|
[52136] | 1389 | static DWORD vboxDispIfWaitDisplayDataInited(VBOXDISPIF_OP *pOp)
|
---|
[48070] | 1390 | {
|
---|
| 1391 | DWORD winEr = ERROR_SUCCESS;
|
---|
| 1392 | do
|
---|
| 1393 | {
|
---|
| 1394 | Sleep(100);
|
---|
| 1395 |
|
---|
| 1396 | D3DKMT_POLLDISPLAYCHILDREN PollData = {0};
|
---|
| 1397 | PollData.hAdapter = pOp->Adapter.hAdapter;
|
---|
| 1398 | PollData.NonDestructiveOnly = 1;
|
---|
| 1399 | NTSTATUS Status = pOp->pIf->modeData.wddm.KmtCallbacks.pfnD3DKMTPollDisplayChildren(&PollData);
|
---|
| 1400 | if (Status != 0)
|
---|
[34130] | 1401 | {
|
---|
[52136] | 1402 | Log(("VBoxTray: (WDDM) pfnD3DKMTPollDisplayChildren failed, Status (0x%x)\n", Status));
|
---|
[48070] | 1403 | continue;
|
---|
[34130] | 1404 | }
|
---|
| 1405 |
|
---|
[48070] | 1406 | BOOL fFound = FALSE;
|
---|
| 1407 | #if 0
|
---|
| 1408 | for (UINT i = 0; i < VBOXWDDM_SCREENMASK_SIZE; ++i)
|
---|
[34130] | 1409 | {
|
---|
[48070] | 1410 | if (pu8DisplayMask && !ASMBitTest(pu8DisplayMask, i))
|
---|
| 1411 | continue;
|
---|
[34130] | 1412 |
|
---|
[48070] | 1413 | BOOL fConnected = FALSE;
|
---|
| 1414 | winEr = vboxDispIfQueryDisplayConnection(pOp, i, &fConnected);
|
---|
| 1415 | if (winEr != ERROR_SUCCESS)
|
---|
[34130] | 1416 | {
|
---|
[52136] | 1417 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfQueryDisplayConnection winEr %d\n", winEr));
|
---|
[48070] | 1418 | return winEr;
|
---|
[34130] | 1419 | }
|
---|
| 1420 |
|
---|
[48070] | 1421 | if (!fConnected)
|
---|
[34130] | 1422 | {
|
---|
[52136] | 1423 | WARN(("VBoxTray: (WDDM) Display %d not connected, not expected\n", i));
|
---|
[48070] | 1424 | fFound = TRUE;
|
---|
| 1425 | break;
|
---|
[44136] | 1426 | }
|
---|
[34130] | 1427 | }
|
---|
[48070] | 1428 | #endif
|
---|
| 1429 | if (!fFound)
|
---|
| 1430 | break;
|
---|
| 1431 | } while (1);
|
---|
[34130] | 1432 |
|
---|
[48070] | 1433 | return winEr;
|
---|
[34130] | 1434 | }
|
---|
| 1435 |
|
---|
[52136] | 1436 | static DWORD vboxDispIfUpdateModesWDDM(VBOXDISPIF_OP *pOp, uint32_t u32TargetId, const RTRECTSIZE *pSize)
|
---|
[42098] | 1437 | {
|
---|
[48070] | 1438 | DWORD winEr = ERROR_SUCCESS;
|
---|
[93299] | 1439 | VBOXDISPIFESCAPE_UPDATEMODES EscData = {{0}};
|
---|
[52136] | 1440 | EscData.EscapeHdr.escapeCode = VBOXESC_UPDATEMODES;
|
---|
| 1441 | EscData.u32TargetId = u32TargetId;
|
---|
| 1442 | EscData.Size = *pSize;
|
---|
[42217] | 1443 |
|
---|
[48070] | 1444 | D3DKMT_ESCAPE EscapeData = {0};
|
---|
| 1445 | EscapeData.hAdapter = pOp->Adapter.hAdapter;
|
---|
[48732] | 1446 | #ifdef VBOX_DISPIF_WITH_OPCONTEXT
|
---|
[48146] | 1447 | /* win8.1 does not allow context-based escapes for display-only mode */
|
---|
[48070] | 1448 | EscapeData.hDevice = pOp->Device.hDevice;
|
---|
| 1449 | EscapeData.hContext = pOp->Context.hContext;
|
---|
[48145] | 1450 | #endif
|
---|
[48070] | 1451 | EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
|
---|
| 1452 | EscapeData.Flags.HardwareAccess = 1;
|
---|
| 1453 | EscapeData.pPrivateDriverData = &EscData;
|
---|
| 1454 | EscapeData.PrivateDriverDataSize = sizeof (EscData);
|
---|
[42217] | 1455 |
|
---|
[48070] | 1456 | NTSTATUS Status = pOp->pIf->modeData.wddm.KmtCallbacks.pfnD3DKMTEscape(&EscapeData);
|
---|
| 1457 | if (NT_SUCCESS(Status))
|
---|
| 1458 | winEr = ERROR_SUCCESS;
|
---|
| 1459 | else
|
---|
[42217] | 1460 | {
|
---|
[52136] | 1461 | WARN(("VBoxTray: pfnD3DKMTEscape VBOXESC_UPDATEMODES failed Status 0x%x\n", Status));
|
---|
[48070] | 1462 | winEr = ERROR_GEN_FAILURE;
|
---|
| 1463 | }
|
---|
[42217] | 1464 |
|
---|
[64878] | 1465 | #ifdef VBOX_WDDM_REPLUG_ON_MODE_CHANGE
|
---|
| 1466 | /* The code was disabled because VBOXESC_UPDATEMODES should not cause (un)plugging virtual displays. */
|
---|
[52136] | 1467 | winEr = vboxDispIfWaitDisplayDataInited(pOp);
|
---|
[48070] | 1468 | if (winEr != NO_ERROR)
|
---|
[52136] | 1469 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWaitDisplayDataInited winEr %d\n", winEr));
|
---|
[64878] | 1470 | #endif
|
---|
| 1471 |
|
---|
[48070] | 1472 | return winEr;
|
---|
| 1473 | }
|
---|
[42217] | 1474 |
|
---|
[64878] | 1475 | static DWORD vboxDispIfTargetConnectivityWDDM(VBOXDISPIF_OP *pOp, uint32_t u32TargetId, uint32_t fu32Connect)
|
---|
| 1476 | {
|
---|
| 1477 | VBOXDISPIFESCAPE_TARGETCONNECTIVITY PrivateData;
|
---|
| 1478 | RT_ZERO(PrivateData);
|
---|
| 1479 | PrivateData.EscapeHdr.escapeCode = VBOXESC_TARGET_CONNECTIVITY;
|
---|
| 1480 | PrivateData.u32TargetId = u32TargetId;
|
---|
| 1481 | PrivateData.fu32Connect = fu32Connect;
|
---|
| 1482 |
|
---|
| 1483 | D3DKMT_ESCAPE EscapeData;
|
---|
| 1484 | RT_ZERO(EscapeData);
|
---|
| 1485 | EscapeData.hAdapter = pOp->Adapter.hAdapter;
|
---|
| 1486 | EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
|
---|
| 1487 | EscapeData.Flags.HardwareAccess = 1;
|
---|
| 1488 | EscapeData.pPrivateDriverData = &PrivateData;
|
---|
| 1489 | EscapeData.PrivateDriverDataSize = sizeof(PrivateData);
|
---|
| 1490 |
|
---|
| 1491 | NTSTATUS Status = pOp->pIf->modeData.wddm.KmtCallbacks.pfnD3DKMTEscape(&EscapeData);
|
---|
| 1492 | if (NT_SUCCESS(Status))
|
---|
| 1493 | return ERROR_SUCCESS;
|
---|
| 1494 |
|
---|
| 1495 | WARN(("VBoxTray: pfnD3DKMTEscape VBOXESC_TARGETCONNECTIVITY failed Status 0x%x\n", Status));
|
---|
| 1496 | return ERROR_GEN_FAILURE;
|
---|
| 1497 | }
|
---|
| 1498 |
|
---|
[48070] | 1499 | DWORD vboxDispIfCancelPendingResizeWDDM(PCVBOXDISPIF const pIf)
|
---|
| 1500 | {
|
---|
[63099] | 1501 | RT_NOREF(pIf);
|
---|
[52136] | 1502 | Log(("VBoxTray: cancelling pending resize\n"));
|
---|
[48070] | 1503 | VBoxRrRetryStop();
|
---|
| 1504 | return NO_ERROR;
|
---|
| 1505 | }
|
---|
[42217] | 1506 |
|
---|
[48979] | 1507 | static DWORD vboxDispIfWddmResizeDisplayVista(DEVMODE *paDeviceModes, DISPLAY_DEVICE *paDisplayDevices, DWORD cDevModes, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup)
|
---|
| 1508 | {
|
---|
| 1509 | /* Without this, Windows will not ask the miniport for its
|
---|
| 1510 | * mode table but uses an internal cache instead.
|
---|
| 1511 | */
|
---|
| 1512 | for (DWORD i = 0; i < cDevModes; i++)
|
---|
| 1513 | {
|
---|
| 1514 | DEVMODE tempDevMode;
|
---|
| 1515 | ZeroMemory (&tempDevMode, sizeof (tempDevMode));
|
---|
| 1516 | tempDevMode.dmSize = sizeof(DEVMODE);
|
---|
| 1517 | EnumDisplaySettings((LPSTR)paDisplayDevices[i].DeviceName, 0xffffff, &tempDevMode);
|
---|
[52136] | 1518 | Log(("VBoxTray: ResizeDisplayDevice: EnumDisplaySettings last error %d\n", GetLastError ()));
|
---|
[48979] | 1519 | }
|
---|
| 1520 |
|
---|
| 1521 | DWORD winEr = EnableAndResizeDispDev(paDeviceModes, paDisplayDevices, cDevModes, iChangedMode, paDeviceModes[iChangedMode].dmPelsWidth, paDeviceModes[iChangedMode].dmPelsHeight,
|
---|
| 1522 | paDeviceModes[iChangedMode].dmBitsPerPel, paDeviceModes[iChangedMode].dmPosition.x, paDeviceModes[iChangedMode].dmPosition.y, fEnable, fExtDispSup);
|
---|
| 1523 | if (winEr != NO_ERROR)
|
---|
[52136] | 1524 | WARN(("VBoxTray: (WDDM) Failed EnableAndResizeDispDev winEr %d\n", winEr));
|
---|
[48979] | 1525 |
|
---|
| 1526 | return winEr;
|
---|
| 1527 | }
|
---|
| 1528 |
|
---|
[48070] | 1529 | static DWORD vboxDispIfResizePerform(PCVBOXDISPIF const pIf, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes)
|
---|
| 1530 | {
|
---|
[61548] | 1531 | LogFunc((" ENTER"));
|
---|
[48070] | 1532 | DWORD winEr;
|
---|
[61548] | 1533 |
|
---|
[48070] | 1534 | if (pIf->enmMode > VBOXDISPIF_MODE_WDDM)
|
---|
[42217] | 1535 | {
|
---|
[72000] | 1536 | if (fEnable)
|
---|
| 1537 | paDisplayDevices[iChangedMode].StateFlags |= DISPLAY_DEVICE_ACTIVE;
|
---|
| 1538 | else
|
---|
| 1539 | paDisplayDevices[iChangedMode].StateFlags &= ~DISPLAY_DEVICE_ACTIVE;
|
---|
| 1540 |
|
---|
| 1541 | winEr = vboxDispIfWddmResizeDisplay2(pIf, paDisplayDevices, paDeviceModes, cDevModes);
|
---|
| 1542 |
|
---|
[48070] | 1543 | if (winEr != NO_ERROR)
|
---|
[52136] | 1544 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmResizeDisplay winEr %d\n", winEr));
|
---|
[42217] | 1545 | }
|
---|
[44550] | 1546 | else
|
---|
| 1547 | {
|
---|
[48979] | 1548 | winEr = vboxDispIfWddmResizeDisplayVista(paDeviceModes, paDisplayDevices, cDevModes, iChangedMode, fEnable, fExtDispSup);
|
---|
[48070] | 1549 | if (winEr != NO_ERROR)
|
---|
[52136] | 1550 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmResizeDisplayVista winEr %d\n", winEr));
|
---|
[44550] | 1551 | }
|
---|
[61548] | 1552 |
|
---|
| 1553 | LogFunc((" LEAVE"));
|
---|
[48070] | 1554 | return winEr;
|
---|
| 1555 | }
|
---|
[42217] | 1556 |
|
---|
[48070] | 1557 | DWORD vboxDispIfResizeModesWDDM(PCVBOXDISPIF const pIf, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes)
|
---|
| 1558 | {
|
---|
| 1559 | DWORD winEr = NO_ERROR;
|
---|
[44576] | 1560 |
|
---|
[61548] | 1561 | Log(("VBoxTray: vboxDispIfResizeModesWDDM iChanged %d cDevModes %d fEnable %d fExtDispSup %d\n", iChangedMode, cDevModes, fEnable, fExtDispSup));
|
---|
[48070] | 1562 | VBoxRrRetryStop();
|
---|
[44576] | 1563 |
|
---|
[48070] | 1564 | VBOXDISPIF_OP Op;
|
---|
[42217] | 1565 |
|
---|
[48070] | 1566 | winEr = vboxDispIfOpBegin(pIf, &Op);
|
---|
| 1567 | if (winEr != NO_ERROR)
|
---|
[44550] | 1568 | {
|
---|
[52136] | 1569 | WARN(("VBoxTray: vboxDispIfOpBegin failed winEr 0x%x", winEr));
|
---|
[48070] | 1570 | return winEr;
|
---|
[44550] | 1571 | }
|
---|
[42217] | 1572 |
|
---|
[69201] | 1573 | /* The pfnD3DKMTInvalidateActiveVidPn was deprecated since Win7 and causes deadlocks since Win10 TH2.
|
---|
| 1574 | Instead, the VidPn Manager can replace an old VidPn as soon as SetDisplayConfig or ChangeDisplaySettingsEx will try to set a new display mode.
|
---|
| 1575 | On Vista D3DKMTInvalidateActiveVidPn is still required. TBD: Get rid of it. */
|
---|
| 1576 | if (Op.pIf->enmMode < VBOXDISPIF_MODE_WDDM_W7)
|
---|
| 1577 | {
|
---|
| 1578 | D3DKMT_INVALIDATEACTIVEVIDPN ddiArgInvalidateVidPN;
|
---|
| 1579 | VBOXWDDM_RECOMMENDVIDPN vboxRecommendVidPN;
|
---|
[42217] | 1580 |
|
---|
[69201] | 1581 | memset(&ddiArgInvalidateVidPN, 0, sizeof(ddiArgInvalidateVidPN));
|
---|
| 1582 | memset(&vboxRecommendVidPN, 0, sizeof(vboxRecommendVidPN));
|
---|
[52136] | 1583 |
|
---|
[69201] | 1584 | uint32_t cElements = 0;
|
---|
[52136] | 1585 |
|
---|
[69201] | 1586 | for (uint32_t i = 0; i < cDevModes; ++i)
|
---|
[52136] | 1587 | {
|
---|
[69201] | 1588 | if ((i == iChangedMode) ? fEnable : (paDisplayDevices[i].StateFlags & DISPLAY_DEVICE_ACTIVE))
|
---|
| 1589 | {
|
---|
| 1590 | vboxRecommendVidPN.aSources[cElements].Size.cx = paDeviceModes[i].dmPelsWidth;
|
---|
| 1591 | vboxRecommendVidPN.aSources[cElements].Size.cy = paDeviceModes[i].dmPelsHeight;
|
---|
| 1592 | vboxRecommendVidPN.aTargets[cElements].iSource = cElements;
|
---|
| 1593 | ++cElements;
|
---|
| 1594 | }
|
---|
| 1595 | else
|
---|
| 1596 | vboxRecommendVidPN.aTargets[cElements].iSource = -1;
|
---|
[52136] | 1597 | }
|
---|
[44149] | 1598 |
|
---|
[69201] | 1599 | ddiArgInvalidateVidPN.hAdapter = Op.Adapter.hAdapter;
|
---|
| 1600 | ddiArgInvalidateVidPN.pPrivateDriverData = &vboxRecommendVidPN;
|
---|
| 1601 | ddiArgInvalidateVidPN.PrivateDriverDataSize = sizeof (vboxRecommendVidPN);
|
---|
[48070] | 1602 |
|
---|
[61548] | 1603 | NTSTATUS Status;
|
---|
[69201] | 1604 | Status = Op.pIf->modeData.wddm.KmtCallbacks.pfnD3DKMTInvalidateActiveVidPn(&ddiArgInvalidateVidPN);
|
---|
[61548] | 1605 | LogFunc(("D3DKMTInvalidateActiveVidPn returned %d)\n", Status));
|
---|
| 1606 | }
|
---|
[53315] | 1607 |
|
---|
[64878] | 1608 | vboxDispIfTargetConnectivityWDDM(&Op, iChangedMode, fEnable? 1: 0);
|
---|
[71103] | 1609 |
|
---|
[71085] | 1610 | /* Whether the current display is already or should be enabled. */
|
---|
| 1611 | BOOL fChangedEnable = fEnable || RT_BOOL(paDisplayDevices[iChangedMode].StateFlags & DISPLAY_DEVICE_ACTIVE);
|
---|
[64878] | 1612 |
|
---|
[71086] | 1613 | if (fChangedEnable)
|
---|
[71070] | 1614 | {
|
---|
| 1615 | RTRECTSIZE Size;
|
---|
| 1616 |
|
---|
| 1617 | Size.cx = paDeviceModes[iChangedMode].dmPelsWidth;
|
---|
| 1618 | Size.cy = paDeviceModes[iChangedMode].dmPelsHeight;
|
---|
| 1619 |
|
---|
| 1620 | LogFunc(("Calling vboxDispIfUpdateModesWDDM to change target %d mode to (%d x %d)\n", iChangedMode, Size.cx, Size.cy));
|
---|
| 1621 | winEr = vboxDispIfUpdateModesWDDM(&Op, iChangedMode, &Size);
|
---|
| 1622 | }
|
---|
| 1623 |
|
---|
[71860] | 1624 | winEr = vboxDispIfResizePerform(pIf, iChangedMode, fEnable, fExtDispSup, paDisplayDevices, paDeviceModes, cDevModes);
|
---|
[71085] | 1625 |
|
---|
| 1626 | if (winEr == ERROR_RETRY)
|
---|
[44149] | 1627 | {
|
---|
[71860] | 1628 | VBoxRrRetrySchedule(pIf, iChangedMode, fEnable, fExtDispSup, paDisplayDevices, paDeviceModes, cDevModes);
|
---|
[71085] | 1629 |
|
---|
[48070] | 1630 | winEr = NO_ERROR;
|
---|
[44149] | 1631 | }
|
---|
| 1632 |
|
---|
[48070] | 1633 | vboxDispIfOpEnd(&Op);
|
---|
[42217] | 1634 |
|
---|
[48070] | 1635 | return winEr;
|
---|
[42098] | 1636 | }
|
---|
| 1637 |
|
---|
[48070] | 1638 | static DWORD vboxDispIfWddmEnableDisplays(PCVBOXDISPIF const pIf, UINT cIds, UINT *pIds, BOOL fEnabled, BOOL fSetTopology, DEVMODE *pDeviceMode)
|
---|
[44550] | 1639 | {
|
---|
[63099] | 1640 | RT_NOREF(pIf);
|
---|
[48070] | 1641 | VBOXDISPIF_WDDM_DISPCFG DispCfg;
|
---|
[44550] | 1642 |
|
---|
[48070] | 1643 | DWORD winEr;
|
---|
| 1644 | int iPath;
|
---|
[99828] | 1645 | UINT fSetFlags = 0; /* /permissive- hack */
|
---|
[48070] | 1646 |
|
---|
| 1647 | winEr = vboxDispIfWddmDcCreate(&DispCfg, QDC_ONLY_ACTIVE_PATHS);
|
---|
| 1648 | if (winEr != ERROR_SUCCESS)
|
---|
[42108] | 1649 | {
|
---|
[52136] | 1650 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate winEr %d\n", winEr));
|
---|
[48070] | 1651 | return winEr;
|
---|
| 1652 | }
|
---|
[42108] | 1653 |
|
---|
[48070] | 1654 | UINT cChangeIds = 0;
|
---|
| 1655 | UINT *pChangeIds = (UINT*)alloca(cIds * sizeof (*pChangeIds));
|
---|
| 1656 | if (!pChangeIds)
|
---|
| 1657 | {
|
---|
[52136] | 1658 | WARN(("VBoxTray: (WDDM) Failed to alloc change ids\n"));
|
---|
[48070] | 1659 | winEr = ERROR_OUTOFMEMORY;
|
---|
| 1660 | goto done;
|
---|
| 1661 | }
|
---|
[42108] | 1662 |
|
---|
[48070] | 1663 | for (UINT i = 0; i < cIds; ++i)
|
---|
| 1664 | {
|
---|
| 1665 | UINT Id = pIds[i];
|
---|
| 1666 | bool fIsDup = false;
|
---|
| 1667 | for (UINT j = 0; j < cChangeIds; ++j)
|
---|
[42108] | 1668 | {
|
---|
[48070] | 1669 | if (pChangeIds[j] == Id)
|
---|
| 1670 | {
|
---|
| 1671 | fIsDup = true;
|
---|
| 1672 | break;
|
---|
| 1673 | }
|
---|
[42108] | 1674 | }
|
---|
| 1675 |
|
---|
[48070] | 1676 | if (fIsDup)
|
---|
| 1677 | continue;
|
---|
[42108] | 1678 |
|
---|
[48070] | 1679 | iPath = vboxDispIfWddmDcSearchPath(&DispCfg, Id, Id);
|
---|
[42108] | 1680 |
|
---|
[48070] | 1681 | if (!((iPath >= 0) && (DispCfg.pPathInfoArray[iPath].flags & DISPLAYCONFIG_PATH_ACTIVE)) != !fEnabled)
|
---|
[42108] | 1682 | {
|
---|
[48070] | 1683 | pChangeIds[cChangeIds] = Id;
|
---|
| 1684 | ++cChangeIds;
|
---|
[42108] | 1685 | }
|
---|
| 1686 | }
|
---|
| 1687 |
|
---|
[48070] | 1688 | if (cChangeIds == 0)
|
---|
[42108] | 1689 | {
|
---|
[52136] | 1690 | Log(("VBoxTray: (WDDM) vboxDispIfWddmEnableDisplay: settings are up to date\n"));
|
---|
[48070] | 1691 | winEr = ERROR_SUCCESS;
|
---|
| 1692 | goto done;
|
---|
[42108] | 1693 | }
|
---|
| 1694 |
|
---|
[48070] | 1695 | /* we want to set primary for every disabled for non-topoly mode only */
|
---|
| 1696 | winEr = vboxDispIfWddmDcSettingsIncludeAllTargets(&DispCfg);
|
---|
| 1697 | if (winEr != ERROR_SUCCESS)
|
---|
[42217] | 1698 | {
|
---|
[52136] | 1699 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcSettingsIncludeAllTargets winEr %d\n", winEr));
|
---|
[48070] | 1700 | return winEr;
|
---|
[42217] | 1701 | }
|
---|
| 1702 |
|
---|
[48070] | 1703 | if (fSetTopology)
|
---|
| 1704 | vboxDispIfWddmDcSettingsInvalidateModeIndeces(&DispCfg);
|
---|
[34130] | 1705 |
|
---|
[48070] | 1706 | for (UINT i = 0; i < cChangeIds; ++i)
|
---|
[34130] | 1707 | {
|
---|
[48070] | 1708 | UINT Id = pChangeIds[i];
|
---|
| 1709 | /* re-query paths */
|
---|
[63099] | 1710 | iPath = vboxDispIfWddmDcSearchPath(&DispCfg, VBOX_WDDM_DC_SEARCH_PATH_ANY, Id);
|
---|
[48070] | 1711 | if (iPath < 0)
|
---|
[34130] | 1712 | {
|
---|
[52136] | 1713 | WARN(("VBoxTray: (WDDM) path index not found while it should"));
|
---|
[34130] | 1714 | winEr = ERROR_GEN_FAILURE;
|
---|
[48070] | 1715 | goto done;
|
---|
[34130] | 1716 | }
|
---|
| 1717 |
|
---|
[48070] | 1718 | winEr = vboxDispIfWddmDcSettingsUpdate(&DispCfg, iPath, pDeviceMode, !fEnabled || fSetTopology, fEnabled);
|
---|
| 1719 | if (winEr != ERROR_SUCCESS)
|
---|
[44557] | 1720 | {
|
---|
[52136] | 1721 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcSettingsUpdate winEr %d\n", winEr));
|
---|
[48070] | 1722 | goto done;
|
---|
[44557] | 1723 | }
|
---|
[34130] | 1724 | }
|
---|
| 1725 |
|
---|
[48070] | 1726 | if (!fSetTopology)
|
---|
| 1727 | vboxDispIfWddmDcSettingsAttachDisbledToPrimary(&DispCfg);
|
---|
[42098] | 1728 |
|
---|
[48070] | 1729 | #if 0
|
---|
| 1730 | /* ensure the zero-index (primary) screen is enabled */
|
---|
| 1731 | iPath = vboxDispIfWddmDcSearchPath(&DispCfg, 0, 0);
|
---|
| 1732 | if (iPath < 0)
|
---|
[34130] | 1733 | {
|
---|
[52136] | 1734 | WARN(("VBoxTray: (WDDM) path index not found while it should"));
|
---|
[48070] | 1735 | winEr = ERROR_GEN_FAILURE;
|
---|
| 1736 | goto done;
|
---|
| 1737 | }
|
---|
[34130] | 1738 |
|
---|
[48070] | 1739 | winEr = vboxDispIfWddmDcSettingsUpdate(&DispCfg, iPath, /* just re-use device node here*/ pDeviceMode, fSetTopology, TRUE);
|
---|
| 1740 | if (winEr != ERROR_SUCCESS)
|
---|
| 1741 | {
|
---|
[52136] | 1742 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcSettingsUpdate winEr %d\n", winEr));
|
---|
[48070] | 1743 | goto done;
|
---|
| 1744 | }
|
---|
| 1745 | #endif
|
---|
[34130] | 1746 |
|
---|
[99828] | 1747 | fSetFlags = !fSetTopology ? (SDC_USE_SUPPLIED_DISPLAY_CONFIG) : (SDC_ALLOW_PATH_ORDER_CHANGES | SDC_TOPOLOGY_SUPPLIED);
|
---|
[48070] | 1748 | winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_VALIDATE);
|
---|
| 1749 | if (winEr != ERROR_SUCCESS)
|
---|
| 1750 | {
|
---|
| 1751 | if (!fSetTopology)
|
---|
[34130] | 1752 | {
|
---|
[52136] | 1753 | WARN(("VBoxTray: (WDDM) vboxDispIfWddmDcSet validation failed winEr, trying with changes %d\n", winEr));
|
---|
[48070] | 1754 | fSetFlags |= SDC_ALLOW_CHANGES;
|
---|
[34130] | 1755 | }
|
---|
[42098] | 1756 | else
|
---|
| 1757 | {
|
---|
[52136] | 1758 | Log(("VBoxTray: (WDDM) vboxDispIfWddmDcSet topology validation failed winEr %d\n", winEr));
|
---|
[48070] | 1759 | goto done;
|
---|
[42098] | 1760 | }
|
---|
[34130] | 1761 | }
|
---|
| 1762 |
|
---|
[48070] | 1763 | if (!fSetTopology)
|
---|
| 1764 | fSetFlags |= SDC_SAVE_TO_DATABASE;
|
---|
[34130] | 1765 |
|
---|
[48070] | 1766 | winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_APPLY);
|
---|
| 1767 | if (winEr != ERROR_SUCCESS)
|
---|
[52136] | 1768 | WARN(("VBoxTray: (WDDM) vboxDispIfWddmDcSet apply failed winEr %d\n", winEr));
|
---|
[42217] | 1769 |
|
---|
[48070] | 1770 | done:
|
---|
| 1771 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
[44729] | 1772 |
|
---|
[48070] | 1773 | return winEr;
|
---|
| 1774 | }
|
---|
| 1775 |
|
---|
| 1776 | static DWORD vboxDispIfWddmEnableDisplaysTryingTopology(PCVBOXDISPIF const pIf, UINT cIds, UINT *pIds, BOOL fEnable)
|
---|
| 1777 | {
|
---|
| 1778 | DWORD winEr = vboxDispIfWddmEnableDisplays(pIf, cIds, pIds, fEnable, FALSE, NULL);
|
---|
| 1779 | if (winEr != ERROR_SUCCESS)
|
---|
[42217] | 1780 | {
|
---|
[48070] | 1781 | if (fEnable)
|
---|
[52136] | 1782 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr));
|
---|
[44931] | 1783 | else
|
---|
[52136] | 1784 | Log(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr));
|
---|
[48070] | 1785 | winEr = vboxDispIfWddmEnableDisplays(pIf, cIds, pIds, fEnable, TRUE, NULL);
|
---|
| 1786 | if (winEr != ERROR_SUCCESS)
|
---|
[52136] | 1787 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr));
|
---|
[34130] | 1788 | }
|
---|
| 1789 |
|
---|
| 1790 | return winEr;
|
---|
| 1791 | }
|
---|
[44557] | 1792 |
|
---|
[72611] | 1793 | BOOL VBoxDispIfResizeDisplayWin7(PCVBOXDISPIF const pIf, uint32_t cDispDef, const VMMDevDisplayDef *paDispDef)
|
---|
[72351] | 1794 | {
|
---|
[84728] | 1795 | const VMMDevDisplayDef *pDispDef;
|
---|
[73724] | 1796 | uint32_t i;
|
---|
[72351] | 1797 |
|
---|
[91763] | 1798 | /* SetDisplayConfig assumes the top-left corner of a primary display at (0, 0) position */
|
---|
[91764] | 1799 | const VMMDevDisplayDef* pDispDefPrimary = NULL;
|
---|
[91763] | 1800 |
|
---|
| 1801 | for (i = 0; i < cDispDef; ++i)
|
---|
| 1802 | {
|
---|
| 1803 | pDispDef = &paDispDef[i];
|
---|
| 1804 |
|
---|
[91764] | 1805 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_PRIMARY)
|
---|
[91763] | 1806 | {
|
---|
[91764] | 1807 | pDispDefPrimary = pDispDef;
|
---|
[91763] | 1808 | break;
|
---|
| 1809 | }
|
---|
| 1810 | }
|
---|
| 1811 |
|
---|
[84325] | 1812 | VBOXDISPIF_OP Op;
|
---|
| 1813 | DWORD winEr = vboxDispIfOpBegin(pIf, &Op);
|
---|
| 1814 | if (winEr != ERROR_SUCCESS)
|
---|
| 1815 | {
|
---|
| 1816 | WARN(("VBoxTray: vboxDispIfOpBegin failed winEr 0x%x", winEr));
|
---|
| 1817 | return (winEr == ERROR_SUCCESS);
|
---|
| 1818 | }
|
---|
[72351] | 1819 |
|
---|
[73724] | 1820 | for (i = 0; i < cDispDef; ++i)
|
---|
[72351] | 1821 | {
|
---|
[73724] | 1822 | pDispDef = &paDispDef[i];
|
---|
[72351] | 1823 |
|
---|
[84325] | 1824 | if (RT_BOOL(pDispDef->fDisplayFlags & VMMDEV_DISPLAY_DISABLED))
|
---|
| 1825 | continue;
|
---|
| 1826 |
|
---|
| 1827 | if ( RT_BOOL(pDispDef->fDisplayFlags & VMMDEV_DISPLAY_CX)
|
---|
| 1828 | && RT_BOOL(pDispDef->fDisplayFlags & VMMDEV_DISPLAY_CY))
|
---|
[72351] | 1829 | {
|
---|
| 1830 | RTRECTSIZE Size;
|
---|
[72366] | 1831 | Size.cx = pDispDef->cx;
|
---|
| 1832 | Size.cy = pDispDef->cy;
|
---|
[72351] | 1833 |
|
---|
[84728] | 1834 | winEr = vboxDispIfUpdateModesWDDM(&Op, pDispDef->idDisplay, &Size);
|
---|
| 1835 | if (winEr != ERROR_SUCCESS)
|
---|
| 1836 | break;
|
---|
[72351] | 1837 | }
|
---|
| 1838 | }
|
---|
| 1839 |
|
---|
| 1840 | vboxDispIfOpEnd(&Op);
|
---|
| 1841 |
|
---|
[84728] | 1842 | if (winEr != ERROR_SUCCESS)
|
---|
| 1843 | return (winEr == ERROR_SUCCESS);
|
---|
| 1844 |
|
---|
[72351] | 1845 | VBOXDISPIF_WDDM_DISPCFG DispCfg;
|
---|
[84325] | 1846 | winEr = vboxDispIfWddmDcCreate(&DispCfg, QDC_ALL_PATHS);
|
---|
| 1847 | if (winEr != ERROR_SUCCESS)
|
---|
| 1848 | {
|
---|
| 1849 | WARN(("VBoxTray: vboxDispIfWddmDcCreate failed winEr 0x%x", winEr));
|
---|
| 1850 | return (winEr == ERROR_SUCCESS);
|
---|
| 1851 | }
|
---|
[72351] | 1852 |
|
---|
[73724] | 1853 | for (i = 0; i < cDispDef; ++i)
|
---|
[72351] | 1854 | {
|
---|
[73724] | 1855 | pDispDef = &paDispDef[i];
|
---|
[72351] | 1856 |
|
---|
[84452] | 1857 | /* Modify the path which the same source and target ids. */
|
---|
| 1858 | int const iPath = vboxDispIfWddmDcSearchPath(&DispCfg, pDispDef->idDisplay, pDispDef->idDisplay);
|
---|
[72351] | 1859 | if (iPath < 0)
|
---|
| 1860 | {
|
---|
[73724] | 1861 | WARN(("VBoxTray:(WDDM) Unexpected iPath(%d) between src(%d) and tgt(%d)\n", iPath, pDispDef->idDisplay, pDispDef->idDisplay));
|
---|
[72351] | 1862 | continue;
|
---|
| 1863 | }
|
---|
| 1864 |
|
---|
[84452] | 1865 | /* If the source is used by another active path, then deactivate the path. */
|
---|
| 1866 | int const iActiveSrcPath = vboxDispIfWddmDcSearchActiveSourcePath(&DispCfg, pDispDef->idDisplay);
|
---|
| 1867 | if (iActiveSrcPath >= 0 && iActiveSrcPath != iPath)
|
---|
| 1868 | DispCfg.pPathInfoArray[iActiveSrcPath].flags &= ~DISPLAYCONFIG_PATH_ACTIVE;
|
---|
| 1869 |
|
---|
| 1870 | DISPLAYCONFIG_PATH_INFO *pPathInfo = &DispCfg.pPathInfoArray[iPath];
|
---|
| 1871 |
|
---|
[72366] | 1872 | if (!(pDispDef->fDisplayFlags & VMMDEV_DISPLAY_DISABLED))
|
---|
[72351] | 1873 | {
|
---|
| 1874 | DISPLAYCONFIG_SOURCE_MODE *pSrcMode;
|
---|
| 1875 | DISPLAYCONFIG_TARGET_MODE *pTgtMode;
|
---|
| 1876 |
|
---|
| 1877 | if (pPathInfo->flags & DISPLAYCONFIG_PATH_ACTIVE)
|
---|
| 1878 | {
|
---|
[84452] | 1879 | UINT iSrcMode = pPathInfo->sourceInfo.modeInfoIdx;
|
---|
| 1880 | UINT iTgtMode = pPathInfo->targetInfo.modeInfoIdx;
|
---|
[72351] | 1881 |
|
---|
| 1882 | if (iSrcMode >= DispCfg.cModeInfoArray || iTgtMode >= DispCfg.cModeInfoArray)
|
---|
| 1883 | {
|
---|
| 1884 | WARN(("VBoxTray:(WDDM) Unexpected iSrcMode(%d) and/or iTgtMode(%d)\n", iSrcMode, iTgtMode));
|
---|
| 1885 | continue;
|
---|
| 1886 | }
|
---|
| 1887 |
|
---|
| 1888 | pSrcMode = &DispCfg.pModeInfoArray[iSrcMode].sourceMode;
|
---|
| 1889 | pTgtMode = &DispCfg.pModeInfoArray[iTgtMode].targetMode;
|
---|
| 1890 |
|
---|
[72611] | 1891 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_CX)
|
---|
| 1892 | {
|
---|
| 1893 | pSrcMode->width =
|
---|
[84452] | 1894 | pTgtMode->targetVideoSignalInfo.activeSize.cx =
|
---|
| 1895 | pTgtMode->targetVideoSignalInfo.totalSize.cx = pDispDef->cx;
|
---|
[72611] | 1896 | }
|
---|
[72351] | 1897 |
|
---|
[72611] | 1898 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_CY)
|
---|
| 1899 | {
|
---|
| 1900 | pSrcMode->height =
|
---|
[84452] | 1901 | pTgtMode->targetVideoSignalInfo.activeSize.cy =
|
---|
| 1902 | pTgtMode->targetVideoSignalInfo.totalSize.cy = pDispDef->cy;
|
---|
[72611] | 1903 | }
|
---|
[72351] | 1904 |
|
---|
[72611] | 1905 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_ORIGIN)
|
---|
| 1906 | {
|
---|
[91764] | 1907 | pSrcMode->position.x = pDispDef->xOrigin - (pDispDefPrimary ? pDispDefPrimary->xOrigin : 0);
|
---|
| 1908 | pSrcMode->position.y = pDispDef->yOrigin - (pDispDefPrimary ? pDispDefPrimary->yOrigin : 0);
|
---|
[72611] | 1909 | }
|
---|
[72351] | 1910 |
|
---|
[72611] | 1911 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_BPP)
|
---|
[72351] | 1912 | {
|
---|
[72611] | 1913 | switch (pDispDef->cBitsPerPixel)
|
---|
| 1914 | {
|
---|
| 1915 | case 32:
|
---|
| 1916 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 1917 | break;
|
---|
| 1918 | case 24:
|
---|
| 1919 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_24BPP;
|
---|
| 1920 | break;
|
---|
| 1921 | case 16:
|
---|
| 1922 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_16BPP;
|
---|
| 1923 | break;
|
---|
| 1924 | case 8:
|
---|
| 1925 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_8BPP;
|
---|
| 1926 | break;
|
---|
| 1927 | default:
|
---|
[84452] | 1928 | WARN(("VBoxTray: (WDDM) invalid bpp %d, using 32bpp instead\n", pDispDef->cBitsPerPixel));
|
---|
[72611] | 1929 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 1930 | break;
|
---|
| 1931 | }
|
---|
[72351] | 1932 | }
|
---|
| 1933 | }
|
---|
| 1934 | else
|
---|
| 1935 | {
|
---|
[84452] | 1936 | /* "The source and target modes for each source and target identifiers can only appear
|
---|
| 1937 | * in the modeInfoArray array once."
|
---|
| 1938 | * Try to find the source mode.
|
---|
| 1939 | */
|
---|
| 1940 | DISPLAYCONFIG_MODE_INFO *pSrcModeInfo = NULL;
|
---|
| 1941 | int iSrcModeInfo = -1;
|
---|
| 1942 | for (UINT j = 0; j < DispCfg.cModeInfoArray; ++j)
|
---|
| 1943 | {
|
---|
| 1944 | if ( DispCfg.pModeInfoArray[j].infoType == DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE
|
---|
| 1945 | && DispCfg.pModeInfoArray[j].id == pDispDef->idDisplay)
|
---|
| 1946 | {
|
---|
| 1947 | pSrcModeInfo = &DispCfg.pModeInfoArray[j];
|
---|
| 1948 | iSrcModeInfo = (int)j;
|
---|
| 1949 | break;
|
---|
| 1950 | }
|
---|
| 1951 | }
|
---|
[72351] | 1952 |
|
---|
[84452] | 1953 | if (pSrcModeInfo == NULL)
|
---|
| 1954 | {
|
---|
| 1955 | /* No mode yet. Add the new mode to the ModeInfo array. */
|
---|
[95868] | 1956 | DISPLAYCONFIG_MODE_INFO *paModeInfo = (DISPLAYCONFIG_MODE_INFO *)RTMemRealloc(DispCfg.pModeInfoArray,
|
---|
| 1957 | (DispCfg.cModeInfoArray + 1)
|
---|
| 1958 | * sizeof(paModeInfo[0]));
|
---|
[84452] | 1959 | if (!paModeInfo)
|
---|
| 1960 | {
|
---|
| 1961 | WARN(("VBoxTray:(WDDM) Unable to re-allocate DispCfg.pModeInfoArray\n"));
|
---|
| 1962 | continue;
|
---|
| 1963 | }
|
---|
[72351] | 1964 |
|
---|
[84452] | 1965 | DispCfg.pModeInfoArray = paModeInfo;
|
---|
| 1966 | DispCfg.cModeInfoArray += 1;
|
---|
| 1967 |
|
---|
| 1968 | iSrcModeInfo = DispCfg.cModeInfoArray - 1;
|
---|
| 1969 | pSrcModeInfo = &DispCfg.pModeInfoArray[iSrcModeInfo];
|
---|
| 1970 | RT_ZERO(*pSrcModeInfo);
|
---|
| 1971 |
|
---|
| 1972 | pSrcModeInfo->infoType = DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE;
|
---|
| 1973 | pSrcModeInfo->id = pDispDef->idDisplay;
|
---|
| 1974 | pSrcModeInfo->adapterId = DispCfg.pModeInfoArray[0].adapterId;
|
---|
| 1975 | }
|
---|
| 1976 |
|
---|
| 1977 | /* Update the source mode information. */
|
---|
| 1978 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_CX)
|
---|
[72351] | 1979 | {
|
---|
[84452] | 1980 | pSrcModeInfo->sourceMode.width = pDispDef->cx;
|
---|
[72351] | 1981 | }
|
---|
| 1982 |
|
---|
[84452] | 1983 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_CY)
|
---|
| 1984 | {
|
---|
| 1985 | pSrcModeInfo->sourceMode.height = pDispDef->cy;
|
---|
| 1986 | }
|
---|
[72351] | 1987 |
|
---|
[84452] | 1988 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_BPP)
|
---|
| 1989 | {
|
---|
| 1990 | switch (pDispDef->cBitsPerPixel)
|
---|
| 1991 | {
|
---|
| 1992 | case 32:
|
---|
| 1993 | pSrcModeInfo->sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 1994 | break;
|
---|
| 1995 | case 24:
|
---|
| 1996 | pSrcModeInfo->sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_24BPP;
|
---|
| 1997 | break;
|
---|
| 1998 | case 16:
|
---|
| 1999 | pSrcModeInfo->sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_16BPP;
|
---|
| 2000 | break;
|
---|
| 2001 | case 8:
|
---|
| 2002 | pSrcModeInfo->sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_8BPP;
|
---|
| 2003 | break;
|
---|
| 2004 | default:
|
---|
| 2005 | WARN(("VBoxTray: (WDDM) invalid bpp %d, using 32bpp instead\n", pDispDef->cBitsPerPixel));
|
---|
| 2006 | pSrcModeInfo->sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 2007 | break;
|
---|
| 2008 | }
|
---|
| 2009 | }
|
---|
[72351] | 2010 |
|
---|
[84452] | 2011 | if (pDispDef->fDisplayFlags & VMMDEV_DISPLAY_ORIGIN)
|
---|
| 2012 | {
|
---|
[91764] | 2013 | pSrcModeInfo->sourceMode.position.x = pDispDef->xOrigin - (pDispDefPrimary ? pDispDefPrimary->xOrigin : 0);
|
---|
| 2014 | pSrcModeInfo->sourceMode.position.y = pDispDef->yOrigin - (pDispDefPrimary ? pDispDefPrimary->yOrigin : 0);
|
---|
[84452] | 2015 | }
|
---|
[72351] | 2016 |
|
---|
[84452] | 2017 | /* Configure the path information. */
|
---|
| 2018 | Assert(pPathInfo->sourceInfo.id == pDispDef->idDisplay);
|
---|
| 2019 | pPathInfo->sourceInfo.modeInfoIdx = iSrcModeInfo;
|
---|
[72351] | 2020 |
|
---|
[84452] | 2021 | Assert(pPathInfo->targetInfo.id == pDispDef->idDisplay);
|
---|
| 2022 | /* "If the index value is DISPLAYCONFIG_PATH_MODE_IDX_INVALID ..., this indicates
|
---|
| 2023 | * the mode information is not being specified. It is valid for the path plus source mode ...
|
---|
| 2024 | * information to be specified for a given path."
|
---|
| 2025 | */
|
---|
| 2026 | pPathInfo->targetInfo.modeInfoIdx = DISPLAYCONFIG_PATH_MODE_IDX_INVALID;
|
---|
| 2027 | pPathInfo->targetInfo.outputTechnology = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15;
|
---|
| 2028 | pPathInfo->targetInfo.rotation = DISPLAYCONFIG_ROTATION_IDENTITY;
|
---|
| 2029 | pPathInfo->targetInfo.scaling = DISPLAYCONFIG_SCALING_PREFERRED;
|
---|
| 2030 | /* "A refresh rate with both the numerator and denominator set to zero indicates that
|
---|
| 2031 | * the caller does not specify a refresh rate and the operating system should use
|
---|
| 2032 | * the most optimal refresh rate available. For this case, in a call to the SetDisplayConfig
|
---|
| 2033 | * function, the caller must set the scanLineOrdering member to the
|
---|
| 2034 | * DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED value; otherwise, SetDisplayConfig fails."
|
---|
| 2035 | *
|
---|
| 2036 | * If a refresh rate is set to a value, then the resize will fail if miniport driver
|
---|
| 2037 | * does not support VSync, i.e. with display-only driver on Win8+ (@bugref{8440}).
|
---|
| 2038 | */
|
---|
| 2039 | pPathInfo->targetInfo.refreshRate.Numerator = 0;
|
---|
| 2040 | pPathInfo->targetInfo.refreshRate.Denominator = 0;
|
---|
| 2041 | pPathInfo->targetInfo.scanLineOrdering = DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED;
|
---|
| 2042 | /* Make sure that "The output can be forced on this target even if a monitor is not detected." */
|
---|
| 2043 | pPathInfo->targetInfo.targetAvailable = TRUE;
|
---|
| 2044 | pPathInfo->targetInfo.statusFlags = DISPLAYCONFIG_TARGET_FORCIBLE;
|
---|
[72351] | 2045 | }
|
---|
[84452] | 2046 |
|
---|
| 2047 | pPathInfo->flags |= DISPLAYCONFIG_PATH_ACTIVE;
|
---|
[72351] | 2048 | }
|
---|
| 2049 | else
|
---|
| 2050 | {
|
---|
[84452] | 2051 | pPathInfo->flags &= ~DISPLAYCONFIG_PATH_ACTIVE;
|
---|
[72351] | 2052 | }
|
---|
| 2053 | }
|
---|
| 2054 |
|
---|
| 2055 | UINT fSetFlags = SDC_USE_SUPPLIED_DISPLAY_CONFIG;
|
---|
| 2056 | winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_VALIDATE);
|
---|
| 2057 | if (winEr != ERROR_SUCCESS)
|
---|
| 2058 | {
|
---|
[72611] | 2059 | WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to VALIDATE winEr %d.\n", winEr));
|
---|
[84382] | 2060 | vboxDispIfWddmDcLogRel(&DispCfg, fSetFlags);
|
---|
[72351] | 2061 | fSetFlags |= SDC_ALLOW_CHANGES;
|
---|
| 2062 | }
|
---|
| 2063 |
|
---|
| 2064 | winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_SAVE_TO_DATABASE | SDC_APPLY);
|
---|
| 2065 | if (winEr != ERROR_SUCCESS)
|
---|
| 2066 | {
|
---|
[72611] | 2067 | WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to SET, winEr %d.\n", winEr));
|
---|
| 2068 |
|
---|
| 2069 | vboxDispIfWddmDcSettingsInvalidateModeIndeces(&DispCfg);
|
---|
| 2070 | winEr = vboxDispIfWddmDcSet(&DispCfg, SDC_TOPOLOGY_SUPPLIED | SDC_ALLOW_PATH_ORDER_CHANGES | SDC_APPLY);
|
---|
| 2071 | if (winEr != ERROR_SUCCESS)
|
---|
| 2072 | {
|
---|
| 2073 | WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to APPLY TOPOLOGY ONLY, winEr %d.\n", winEr));
|
---|
| 2074 | winEr = vboxDispIfWddmDcSet(&DispCfg, SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_APPLY);
|
---|
| 2075 | if (winEr != ERROR_SUCCESS)
|
---|
| 2076 | {
|
---|
| 2077 | WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to APPLY ANY TOPOLOGY, winEr %d.\n", winEr));
|
---|
| 2078 | }
|
---|
| 2079 | }
|
---|
[72351] | 2080 | }
|
---|
| 2081 |
|
---|
| 2082 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 2083 |
|
---|
| 2084 | return (winEr == ERROR_SUCCESS);
|
---|
| 2085 | }
|
---|
| 2086 |
|
---|
[72000] | 2087 | static DWORD vboxDispIfWddmResizeDisplay2(PCVBOXDISPIF const pIf, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT devModes)
|
---|
| 2088 | {
|
---|
| 2089 | RT_NOREF(pIf, paDeviceModes);
|
---|
| 2090 | VBOXDISPIF_WDDM_DISPCFG DispCfg;
|
---|
| 2091 | DWORD winEr = ERROR_SUCCESS;
|
---|
| 2092 | UINT idx;
|
---|
| 2093 | int iPath;
|
---|
| 2094 |
|
---|
| 2095 | winEr = vboxDispIfWddmDcCreate(&DispCfg, QDC_ALL_PATHS);
|
---|
| 2096 |
|
---|
| 2097 | if (winEr != ERROR_SUCCESS)
|
---|
[72003] | 2098 | {
|
---|
[72000] | 2099 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate\n"));
|
---|
| 2100 | return winEr;
|
---|
| 2101 | }
|
---|
| 2102 |
|
---|
| 2103 | for (idx = 0; idx < devModes; idx++)
|
---|
| 2104 | {
|
---|
| 2105 | DEVMODE *pDeviceMode = &paDeviceModes[idx];
|
---|
| 2106 |
|
---|
| 2107 | if (paDisplayDevices[idx].StateFlags & DISPLAY_DEVICE_ACTIVE)
|
---|
| 2108 | {
|
---|
| 2109 | DISPLAYCONFIG_PATH_INFO *pPathInfo;
|
---|
| 2110 |
|
---|
| 2111 | iPath = vboxDispIfWddmDcSearchPath(&DispCfg, idx, idx);
|
---|
| 2112 |
|
---|
| 2113 | if (iPath < 0)
|
---|
| 2114 | {
|
---|
| 2115 | WARN(("VBoxTray:(WDDM) Unexpected iPath(%d) between src(%d) and tgt(%d)\n", iPath, idx, idx));
|
---|
| 2116 | continue;
|
---|
| 2117 | }
|
---|
| 2118 |
|
---|
| 2119 | pPathInfo = &DispCfg.pPathInfoArray[iPath];
|
---|
| 2120 |
|
---|
| 2121 | if (pPathInfo->flags & DISPLAYCONFIG_PATH_ACTIVE)
|
---|
| 2122 | {
|
---|
| 2123 | UINT iSrcMode, iTgtMode;
|
---|
| 2124 | DISPLAYCONFIG_SOURCE_MODE *pSrcMode;
|
---|
| 2125 | DISPLAYCONFIG_TARGET_MODE *pTgtMode;
|
---|
| 2126 |
|
---|
| 2127 | iSrcMode = pPathInfo->sourceInfo.modeInfoIdx;
|
---|
| 2128 | iTgtMode = pPathInfo->targetInfo.modeInfoIdx;
|
---|
| 2129 |
|
---|
| 2130 | if (iSrcMode >= DispCfg.cModeInfoArray || iTgtMode >= DispCfg.cModeInfoArray)
|
---|
| 2131 | {
|
---|
| 2132 | WARN(("VBoxTray:(WDDM) Unexpected iSrcMode(%d) and/or iTgtMode(%d)\n", iSrcMode, iTgtMode));
|
---|
| 2133 | continue;
|
---|
| 2134 | }
|
---|
| 2135 |
|
---|
| 2136 | pSrcMode = &DispCfg.pModeInfoArray[iSrcMode].sourceMode;
|
---|
| 2137 | pTgtMode = &DispCfg.pModeInfoArray[iTgtMode].targetMode;
|
---|
| 2138 |
|
---|
| 2139 | if (pDeviceMode->dmFields & DM_PELSWIDTH)
|
---|
| 2140 | {
|
---|
| 2141 | pSrcMode->width = pDeviceMode->dmPelsWidth;
|
---|
| 2142 | pTgtMode->targetVideoSignalInfo.activeSize.cx = pDeviceMode->dmPelsWidth;
|
---|
| 2143 | pTgtMode->targetVideoSignalInfo.totalSize.cx = pDeviceMode->dmPelsWidth;
|
---|
| 2144 | }
|
---|
| 2145 |
|
---|
| 2146 | if (pDeviceMode->dmFields & DM_PELSHEIGHT)
|
---|
| 2147 | {
|
---|
| 2148 | pSrcMode->height = pDeviceMode->dmPelsHeight;
|
---|
| 2149 | pTgtMode->targetVideoSignalInfo.activeSize.cy = pDeviceMode->dmPelsHeight;
|
---|
| 2150 | pTgtMode->targetVideoSignalInfo.totalSize.cy = pDeviceMode->dmPelsHeight;
|
---|
| 2151 | }
|
---|
| 2152 |
|
---|
| 2153 | if (pDeviceMode->dmFields & DM_POSITION)
|
---|
| 2154 | {
|
---|
| 2155 | pSrcMode->position.x = pDeviceMode->dmPosition.x;
|
---|
| 2156 | pSrcMode->position.y = pDeviceMode->dmPosition.y;
|
---|
| 2157 | }
|
---|
| 2158 |
|
---|
| 2159 | if (pDeviceMode->dmFields & DM_BITSPERPEL)
|
---|
| 2160 | {
|
---|
| 2161 | switch (pDeviceMode->dmBitsPerPel)
|
---|
| 2162 | {
|
---|
| 2163 | case 32:
|
---|
| 2164 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 2165 | break;
|
---|
| 2166 | case 24:
|
---|
| 2167 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_24BPP;
|
---|
| 2168 | break;
|
---|
| 2169 | case 16:
|
---|
| 2170 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_16BPP;
|
---|
| 2171 | break;
|
---|
| 2172 | case 8:
|
---|
| 2173 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_8BPP;
|
---|
| 2174 | break;
|
---|
| 2175 | default:
|
---|
| 2176 | LogRel(("VBoxTray: (WDDM) invalid bpp %d, using 32bpp instead\n", pDeviceMode->dmBitsPerPel));
|
---|
| 2177 | pSrcMode->pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 2178 | break;
|
---|
| 2179 | }
|
---|
| 2180 | }
|
---|
| 2181 | }
|
---|
| 2182 | else
|
---|
| 2183 | {
|
---|
[95868] | 2184 | DISPLAYCONFIG_MODE_INFO *pModeInfo = (DISPLAYCONFIG_MODE_INFO *)RTMemRealloc(DispCfg.pModeInfoArray,
|
---|
| 2185 | (DispCfg.cModeInfoArray + 2)
|
---|
| 2186 | * sizeof(pModeInfo[0]));
|
---|
[72000] | 2187 | if (!pModeInfo)
|
---|
| 2188 | {
|
---|
| 2189 | WARN(("VBoxTray:(WDDM) Unable to re-allocate DispCfg.pModeInfoArray\n"));
|
---|
| 2190 | continue;
|
---|
| 2191 | }
|
---|
| 2192 |
|
---|
| 2193 | DispCfg.pModeInfoArray = pModeInfo;
|
---|
| 2194 |
|
---|
| 2195 | *pPathInfo = DispCfg.pPathInfoArray[0];
|
---|
| 2196 | pPathInfo->sourceInfo.id = idx;
|
---|
| 2197 | pPathInfo->targetInfo.id = idx;
|
---|
| 2198 |
|
---|
[95868] | 2199 | DISPLAYCONFIG_MODE_INFO *pModeInfoNew = &pModeInfo[DispCfg.cModeInfoArray];
|
---|
[72000] | 2200 |
|
---|
| 2201 | pModeInfoNew->infoType = DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE;
|
---|
| 2202 | pModeInfoNew->id = idx;
|
---|
| 2203 | pModeInfoNew->adapterId = pModeInfo[0].adapterId;
|
---|
| 2204 | pModeInfoNew->sourceMode.width = pDeviceMode->dmPelsWidth;
|
---|
| 2205 | pModeInfoNew->sourceMode.height = pDeviceMode->dmPelsHeight;
|
---|
| 2206 | pModeInfoNew->sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP;
|
---|
| 2207 | pModeInfoNew->sourceMode.position.x = pDeviceMode->dmPosition.x;
|
---|
| 2208 | pModeInfoNew->sourceMode.position.y = pDeviceMode->dmPosition.y;
|
---|
| 2209 | pPathInfo->sourceInfo.modeInfoIdx = DispCfg.cModeInfoArray;
|
---|
| 2210 |
|
---|
| 2211 | pModeInfoNew++;
|
---|
| 2212 | pModeInfoNew->infoType = DISPLAYCONFIG_MODE_INFO_TYPE_TARGET;
|
---|
| 2213 | pModeInfoNew->id = idx;
|
---|
| 2214 | pModeInfoNew->adapterId = pModeInfo[0].adapterId;
|
---|
| 2215 | pModeInfoNew->targetMode = pModeInfo[0].targetMode;
|
---|
| 2216 | pModeInfoNew->targetMode.targetVideoSignalInfo.activeSize.cx = pDeviceMode->dmPelsWidth;
|
---|
| 2217 | pModeInfoNew->targetMode.targetVideoSignalInfo.totalSize.cx = pDeviceMode->dmPelsWidth;
|
---|
| 2218 | pModeInfoNew->targetMode.targetVideoSignalInfo.activeSize.cy = pDeviceMode->dmPelsHeight;
|
---|
| 2219 | pModeInfoNew->targetMode.targetVideoSignalInfo.totalSize.cy = pDeviceMode->dmPelsHeight;
|
---|
| 2220 | pPathInfo->targetInfo.modeInfoIdx = DispCfg.cModeInfoArray + 1;
|
---|
| 2221 |
|
---|
| 2222 | DispCfg.cModeInfoArray += 2;
|
---|
| 2223 | }
|
---|
| 2224 | }
|
---|
| 2225 | else
|
---|
| 2226 | {
|
---|
| 2227 | iPath = vboxDispIfWddmDcSearchActivePath(&DispCfg, idx, idx);
|
---|
| 2228 |
|
---|
| 2229 | if (iPath >= 0)
|
---|
| 2230 | {
|
---|
| 2231 | DispCfg.pPathInfoArray[idx].flags &= ~DISPLAYCONFIG_PATH_ACTIVE;
|
---|
| 2232 | }
|
---|
| 2233 | }
|
---|
| 2234 | }
|
---|
| 2235 |
|
---|
| 2236 | UINT fSetFlags = SDC_USE_SUPPLIED_DISPLAY_CONFIG;
|
---|
| 2237 | winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_VALIDATE);
|
---|
| 2238 | if (winEr != ERROR_SUCCESS)
|
---|
| 2239 | {
|
---|
| 2240 | WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to validate winEr %d.\n", winEr));
|
---|
| 2241 | fSetFlags |= SDC_ALLOW_CHANGES;
|
---|
| 2242 | }
|
---|
| 2243 |
|
---|
| 2244 | winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_SAVE_TO_DATABASE | SDC_APPLY);
|
---|
| 2245 | if (winEr != ERROR_SUCCESS)
|
---|
| 2246 | {
|
---|
| 2247 | WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to validate winEr %d.\n", winEr));
|
---|
| 2248 | }
|
---|
| 2249 |
|
---|
| 2250 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 2251 |
|
---|
| 2252 | return winEr;
|
---|
| 2253 | }
|
---|
| 2254 |
|
---|
[63099] | 2255 | static DWORD vboxDispIfWddmResizeDisplay(PCVBOXDISPIF const pIf, UINT Id, BOOL fEnable, DISPLAY_DEVICE *paDisplayDevices,
|
---|
| 2256 | DEVMODE *paDeviceModes, UINT devModes)
|
---|
[44557] | 2257 | {
|
---|
[63099] | 2258 | RT_NOREF(paDisplayDevices, devModes);
|
---|
[48070] | 2259 | VBOXDISPIF_WDDM_DISPCFG DispCfg;
|
---|
| 2260 | DWORD winEr;
|
---|
| 2261 | int iPath;
|
---|
[44557] | 2262 |
|
---|
[48070] | 2263 | winEr = vboxDispIfWddmDcCreate(&DispCfg, QDC_ONLY_ACTIVE_PATHS);
|
---|
| 2264 | if (winEr != ERROR_SUCCESS)
|
---|
[44557] | 2265 | {
|
---|
[52136] | 2266 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate\n"));
|
---|
[48070] | 2267 | return winEr;
|
---|
[44557] | 2268 | }
|
---|
[48070] | 2269 |
|
---|
| 2270 | iPath = vboxDispIfWddmDcSearchActivePath(&DispCfg, Id, Id);
|
---|
| 2271 |
|
---|
| 2272 | if (iPath < 0)
|
---|
[44732] | 2273 | {
|
---|
[48070] | 2274 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 2275 |
|
---|
| 2276 | if (!fEnable)
|
---|
[44735] | 2277 | {
|
---|
[48070] | 2278 | /* nothing to be done here, just leave */
|
---|
| 2279 | return ERROR_SUCCESS;
|
---|
[44735] | 2280 | }
|
---|
[48070] | 2281 |
|
---|
| 2282 | winEr = vboxDispIfWddmEnableDisplaysTryingTopology(pIf, 1, &Id, fEnable);
|
---|
| 2283 | if (winEr != ERROR_SUCCESS)
|
---|
[44557] | 2284 | {
|
---|
[52136] | 2285 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplaysTryingTopology winEr %d\n", winEr));
|
---|
[48070] | 2286 | return winEr;
|
---|
[44557] | 2287 | }
|
---|
[48070] | 2288 |
|
---|
| 2289 | winEr = vboxDispIfWddmDcCreate(&DispCfg, QDC_ONLY_ACTIVE_PATHS);
|
---|
| 2290 | if (winEr != ERROR_SUCCESS)
|
---|
| 2291 | {
|
---|
[52136] | 2292 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate winEr %d\n", winEr));
|
---|
[48070] | 2293 | return winEr;
|
---|
| 2294 | }
|
---|
| 2295 |
|
---|
| 2296 | iPath = vboxDispIfWddmDcSearchPath(&DispCfg, Id, Id);
|
---|
| 2297 | if (iPath < 0)
|
---|
| 2298 | {
|
---|
[52136] | 2299 | WARN(("VBoxTray: (WDDM) path (%d) is still disabled, going to retry winEr %d\n", winEr));
|
---|
[48070] | 2300 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 2301 | return ERROR_RETRY;
|
---|
| 2302 | }
|
---|
[44557] | 2303 | }
|
---|
[44729] | 2304 |
|
---|
[48070] | 2305 | Assert(iPath >= 0);
|
---|
[44729] | 2306 |
|
---|
[48070] | 2307 | if (!fEnable)
|
---|
[44729] | 2308 | {
|
---|
[48070] | 2309 | /* need to disable it, and we are done */
|
---|
| 2310 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 2311 |
|
---|
| 2312 | winEr = vboxDispIfWddmEnableDisplaysTryingTopology(pIf, 1, &Id, fEnable);
|
---|
| 2313 | if (winEr != ERROR_SUCCESS)
|
---|
[44735] | 2314 | {
|
---|
[52136] | 2315 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplaysTryingTopology winEr %d\n", winEr));
|
---|
[48070] | 2316 | return winEr;
|
---|
[44735] | 2317 | }
|
---|
[48070] | 2318 |
|
---|
| 2319 | return winEr;
|
---|
[44732] | 2320 | }
|
---|
[48070] | 2321 |
|
---|
| 2322 | Assert(fEnable);
|
---|
| 2323 |
|
---|
[63099] | 2324 | winEr = vboxDispIfWddmDcSettingsUpdate(&DispCfg, iPath, &paDeviceModes[Id], FALSE, fEnable);
|
---|
[48070] | 2325 | if (winEr != ERROR_SUCCESS)
|
---|
[44729] | 2326 | {
|
---|
[52136] | 2327 | WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcSettingsUpdate\n"));
|
---|
[48070] | 2328 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 2329 | return winEr;
|
---|
[44931] | 2330 | }
|
---|
[48070] | 2331 |
|
---|
| 2332 | UINT fSetFlags = SDC_USE_SUPPLIED_DISPLAY_CONFIG;
|
---|
| 2333 | winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_VALIDATE);
|
---|
| 2334 | if (winEr != ERROR_SUCCESS)
|
---|
[44729] | 2335 | {
|
---|
[52136] | 2336 | WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to validate winEr %d.\n", winEr));
|
---|
[48070] | 2337 | fSetFlags |= SDC_ALLOW_CHANGES;
|
---|
[44729] | 2338 | }
|
---|
[48070] | 2339 |
|
---|
| 2340 | winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_SAVE_TO_DATABASE | SDC_APPLY);
|
---|
| 2341 | if (winEr != ERROR_SUCCESS)
|
---|
[44735] | 2342 | {
|
---|
[52136] | 2343 | WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to validate winEr %d.\n", winEr));
|
---|
[48070] | 2344 | }
|
---|
[46194] | 2345 |
|
---|
[48070] | 2346 | vboxDispIfWddmDcTerm(&DispCfg);
|
---|
| 2347 |
|
---|
| 2348 | return winEr;
|
---|
[44557] | 2349 | }
|
---|
| 2350 |
|
---|
[34780] | 2351 | #endif /* VBOX_WITH_WDDM */
|
---|
[34130] | 2352 |
|
---|
[48070] | 2353 | DWORD VBoxDispIfResizeModes(PCVBOXDISPIF const pIf, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes)
|
---|
[34130] | 2354 | {
|
---|
| 2355 | switch (pIf->enmMode)
|
---|
| 2356 | {
|
---|
| 2357 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
| 2358 | return ERROR_NOT_SUPPORTED;
|
---|
| 2359 | case VBOXDISPIF_MODE_XPDM:
|
---|
| 2360 | return ERROR_NOT_SUPPORTED;
|
---|
| 2361 | #ifdef VBOX_WITH_WDDM
|
---|
| 2362 | case VBOXDISPIF_MODE_WDDM:
|
---|
[48070] | 2363 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
| 2364 | return vboxDispIfResizeModesWDDM(pIf, iChangedMode, fEnable, fExtDispSup, paDisplayDevices, paDeviceModes, cDevModes);
|
---|
[34130] | 2365 | #endif
|
---|
| 2366 | default:
|
---|
[84325] | 2367 | WARN(("unknown mode (%d)\n", pIf->enmMode));
|
---|
[34130] | 2368 | return ERROR_INVALID_PARAMETER;
|
---|
| 2369 | }
|
---|
| 2370 | }
|
---|
| 2371 |
|
---|
[44550] | 2372 | DWORD VBoxDispIfCancelPendingResize(PCVBOXDISPIF const pIf)
|
---|
| 2373 | {
|
---|
| 2374 | switch (pIf->enmMode)
|
---|
| 2375 | {
|
---|
| 2376 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
| 2377 | return NO_ERROR;
|
---|
| 2378 | case VBOXDISPIF_MODE_XPDM:
|
---|
| 2379 | return NO_ERROR;
|
---|
| 2380 | #ifdef VBOX_WITH_WDDM
|
---|
| 2381 | case VBOXDISPIF_MODE_WDDM:
|
---|
[48070] | 2382 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
[44550] | 2383 | return vboxDispIfCancelPendingResizeWDDM(pIf);
|
---|
| 2384 | #endif
|
---|
| 2385 | default:
|
---|
[84325] | 2386 | WARN(("unknown mode (%d)\n", pIf->enmMode));
|
---|
[44550] | 2387 | return ERROR_INVALID_PARAMETER;
|
---|
| 2388 | }
|
---|
| 2389 | }
|
---|
| 2390 |
|
---|
[48070] | 2391 | static DWORD vboxDispIfConfigureTargetsWDDM(VBOXDISPIF_OP *pOp, uint32_t *pcConnected)
|
---|
[42217] | 2392 | {
|
---|
[48070] | 2393 | VBOXDISPIFESCAPE EscapeHdr = {0};
|
---|
| 2394 | EscapeHdr.escapeCode = VBOXESC_CONFIGURETARGETS;
|
---|
| 2395 | EscapeHdr.u32CmdSpecific = 0;
|
---|
| 2396 |
|
---|
| 2397 | D3DKMT_ESCAPE EscapeData = {0};
|
---|
| 2398 | EscapeData.hAdapter = pOp->Adapter.hAdapter;
|
---|
[48732] | 2399 | #ifdef VBOX_DISPIF_WITH_OPCONTEXT
|
---|
[48146] | 2400 | /* win8.1 does not allow context-based escapes for display-only mode */
|
---|
[48070] | 2401 | EscapeData.hDevice = pOp->Device.hDevice;
|
---|
| 2402 | EscapeData.hContext = pOp->Context.hContext;
|
---|
[48145] | 2403 | #endif
|
---|
[48070] | 2404 | EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
|
---|
| 2405 | EscapeData.Flags.HardwareAccess = 1;
|
---|
| 2406 | EscapeData.pPrivateDriverData = &EscapeHdr;
|
---|
| 2407 | EscapeData.PrivateDriverDataSize = sizeof (EscapeHdr);
|
---|
| 2408 |
|
---|
| 2409 | NTSTATUS Status = pOp->pIf->modeData.wddm.KmtCallbacks.pfnD3DKMTEscape(&EscapeData);
|
---|
| 2410 | if (NT_SUCCESS(Status))
|
---|
| 2411 | {
|
---|
| 2412 | if (pcConnected)
|
---|
| 2413 | *pcConnected = EscapeHdr.u32CmdSpecific;
|
---|
| 2414 | return NO_ERROR;
|
---|
| 2415 | }
|
---|
[52136] | 2416 | WARN(("VBoxTray: pfnD3DKMTEscape VBOXESC_CONFIGURETARGETS failed Status 0x%x\n", Status));
|
---|
[48070] | 2417 | return Status;
|
---|
| 2418 | }
|
---|
| 2419 |
|
---|
| 2420 | static DWORD vboxDispIfResizeStartedWDDMOp(VBOXDISPIF_OP *pOp)
|
---|
| 2421 | {
|
---|
[57741] | 2422 | DWORD NumDevices = VBoxDisplayGetCount();
|
---|
[48070] | 2423 | if (NumDevices == 0)
|
---|
| 2424 | {
|
---|
[52136] | 2425 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: Zero devices found\n"));
|
---|
[48070] | 2426 | return ERROR_GEN_FAILURE;
|
---|
| 2427 | }
|
---|
| 2428 |
|
---|
| 2429 | DISPLAY_DEVICE *paDisplayDevices = (DISPLAY_DEVICE *)alloca (sizeof (DISPLAY_DEVICE) * NumDevices);
|
---|
| 2430 | DEVMODE *paDeviceModes = (DEVMODE *)alloca (sizeof (DEVMODE) * NumDevices);
|
---|
| 2431 | DWORD DevNum = 0;
|
---|
| 2432 | DWORD DevPrimaryNum = 0;
|
---|
| 2433 |
|
---|
[57741] | 2434 | DWORD winEr = VBoxDisplayGetConfig(NumDevices, &DevPrimaryNum, &DevNum, paDisplayDevices, paDeviceModes);
|
---|
[48070] | 2435 | if (winEr != NO_ERROR)
|
---|
| 2436 | {
|
---|
[52136] | 2437 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: VBoxGetDisplayConfig failed, %d\n", winEr));
|
---|
[48070] | 2438 | return winEr;
|
---|
| 2439 | }
|
---|
| 2440 |
|
---|
| 2441 | if (NumDevices != DevNum)
|
---|
[52136] | 2442 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: NumDevices(%d) != DevNum(%d)\n", NumDevices, DevNum));
|
---|
[48070] | 2443 |
|
---|
| 2444 |
|
---|
| 2445 | uint32_t cConnected = 0;
|
---|
| 2446 | winEr = vboxDispIfConfigureTargetsWDDM(pOp, &cConnected);
|
---|
| 2447 | if (winEr != NO_ERROR)
|
---|
| 2448 | {
|
---|
[52136] | 2449 | WARN(("VBoxTray: vboxDispIfConfigureTargetsWDDM failed winEr 0x%x\n", winEr));
|
---|
[48070] | 2450 | return winEr;
|
---|
| 2451 | }
|
---|
| 2452 |
|
---|
| 2453 | if (!cConnected)
|
---|
| 2454 | {
|
---|
[52136] | 2455 | Log(("VBoxTray: all targets already connected, nothing to do\n"));
|
---|
[48070] | 2456 | return NO_ERROR;
|
---|
| 2457 | }
|
---|
| 2458 |
|
---|
[52136] | 2459 | winEr = vboxDispIfWaitDisplayDataInited(pOp);
|
---|
[48070] | 2460 | if (winEr != NO_ERROR)
|
---|
[52136] | 2461 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: vboxDispIfWaitDisplayDataInited failed winEr 0x%x\n", winEr));
|
---|
[48070] | 2462 |
|
---|
[57741] | 2463 | DWORD NewNumDevices = VBoxDisplayGetCount();
|
---|
[48070] | 2464 | if (NewNumDevices == 0)
|
---|
| 2465 | {
|
---|
[52136] | 2466 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: Zero devices found\n"));
|
---|
[48070] | 2467 | return ERROR_GEN_FAILURE;
|
---|
| 2468 | }
|
---|
| 2469 |
|
---|
| 2470 | if (NewNumDevices != NumDevices)
|
---|
[52136] | 2471 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: NumDevices(%d) != NewNumDevices(%d)\n", NumDevices, NewNumDevices));
|
---|
[48070] | 2472 |
|
---|
| 2473 | DISPLAY_DEVICE *paNewDisplayDevices = (DISPLAY_DEVICE *)alloca (sizeof (DISPLAY_DEVICE) * NewNumDevices);
|
---|
| 2474 | DEVMODE *paNewDeviceModes = (DEVMODE *)alloca (sizeof (DEVMODE) * NewNumDevices);
|
---|
| 2475 | DWORD NewDevNum = 0;
|
---|
| 2476 | DWORD NewDevPrimaryNum = 0;
|
---|
| 2477 |
|
---|
[57741] | 2478 | winEr = VBoxDisplayGetConfig(NewNumDevices, &NewDevPrimaryNum, &NewDevNum, paNewDisplayDevices, paNewDeviceModes);
|
---|
[48070] | 2479 | if (winEr != NO_ERROR)
|
---|
| 2480 | {
|
---|
[52136] | 2481 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: VBoxGetDisplayConfig failed for new devices, %d\n", winEr));
|
---|
[48070] | 2482 | return winEr;
|
---|
| 2483 | }
|
---|
| 2484 |
|
---|
| 2485 | if (NewNumDevices != NewDevNum)
|
---|
[52136] | 2486 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: NewNumDevices(%d) != NewDevNum(%d)\n", NewNumDevices, NewDevNum));
|
---|
[48070] | 2487 |
|
---|
| 2488 | DWORD minDevNum = RT_MIN(DevNum, NewDevNum);
|
---|
| 2489 | UINT *pIds = (UINT*)alloca (sizeof (UINT) * minDevNum);
|
---|
| 2490 | UINT cIds = 0;
|
---|
| 2491 | for (DWORD i = 0; i < minDevNum; ++i)
|
---|
| 2492 | {
|
---|
| 2493 | if ((paNewDisplayDevices[i].StateFlags & DISPLAY_DEVICE_ACTIVE)
|
---|
| 2494 | && !(paDisplayDevices[i].StateFlags & DISPLAY_DEVICE_ACTIVE))
|
---|
| 2495 | {
|
---|
| 2496 | pIds[cIds] = i;
|
---|
| 2497 | ++cIds;
|
---|
| 2498 | }
|
---|
| 2499 | }
|
---|
| 2500 |
|
---|
| 2501 | if (!cIds)
|
---|
| 2502 | {
|
---|
| 2503 | /* this is something we would not regularly expect */
|
---|
[52136] | 2504 | WARN(("VBoxTray: all targets already have proper config, nothing to do\n"));
|
---|
[48070] | 2505 | return NO_ERROR;
|
---|
| 2506 | }
|
---|
| 2507 |
|
---|
| 2508 | if (pOp->pIf->enmMode > VBOXDISPIF_MODE_WDDM)
|
---|
| 2509 | {
|
---|
| 2510 | winEr = vboxDispIfWddmEnableDisplaysTryingTopology(pOp->pIf, cIds, pIds, FALSE);
|
---|
| 2511 | if (winEr != NO_ERROR)
|
---|
[52136] | 2512 | WARN(("VBoxTray: vboxDispIfWddmEnableDisplaysTryingTopology failed to record current settings, %d, ignoring\n", winEr));
|
---|
[48070] | 2513 | }
|
---|
| 2514 | else
|
---|
| 2515 | {
|
---|
| 2516 | for (DWORD i = 0; i < cIds; ++i)
|
---|
| 2517 | {
|
---|
[48979] | 2518 | winEr = vboxDispIfWddmResizeDisplayVista(paNewDeviceModes, paNewDisplayDevices, NewDevNum, i, FALSE, TRUE);
|
---|
[48070] | 2519 | if (winEr != NO_ERROR)
|
---|
[52136] | 2520 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: vboxDispIfWddmResizeDisplayVista failed winEr 0x%x\n", winEr));
|
---|
[48070] | 2521 | }
|
---|
| 2522 | }
|
---|
| 2523 |
|
---|
| 2524 | return winEr;
|
---|
| 2525 | }
|
---|
| 2526 |
|
---|
| 2527 |
|
---|
| 2528 | static DWORD vboxDispIfResizeStartedWDDM(PCVBOXDISPIF const pIf)
|
---|
| 2529 | {
|
---|
| 2530 | VBOXDISPIF_OP Op;
|
---|
| 2531 |
|
---|
| 2532 | DWORD winEr = vboxDispIfOpBegin(pIf, &Op);
|
---|
| 2533 | if (winEr != NO_ERROR)
|
---|
| 2534 | {
|
---|
[52136] | 2535 | WARN(("VBoxTray: vboxDispIfOpBegin failed winEr 0x%x\n", winEr));
|
---|
[48070] | 2536 | return winEr;
|
---|
| 2537 | }
|
---|
| 2538 |
|
---|
| 2539 | winEr = vboxDispIfResizeStartedWDDMOp(&Op);
|
---|
| 2540 | if (winEr != NO_ERROR)
|
---|
| 2541 | {
|
---|
[52136] | 2542 | WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp failed winEr 0x%x\n", winEr));
|
---|
[48070] | 2543 | }
|
---|
| 2544 |
|
---|
| 2545 | vboxDispIfOpEnd(&Op);
|
---|
| 2546 |
|
---|
| 2547 | return winEr;
|
---|
| 2548 | }
|
---|
| 2549 |
|
---|
| 2550 | DWORD VBoxDispIfResizeStarted(PCVBOXDISPIF const pIf)
|
---|
| 2551 | {
|
---|
[42217] | 2552 | switch (pIf->enmMode)
|
---|
| 2553 | {
|
---|
| 2554 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
[48070] | 2555 | return NO_ERROR;
|
---|
[42217] | 2556 | case VBOXDISPIF_MODE_XPDM:
|
---|
[48070] | 2557 | return NO_ERROR;
|
---|
[42217] | 2558 | #ifdef VBOX_WITH_WDDM
|
---|
| 2559 | case VBOXDISPIF_MODE_WDDM:
|
---|
[48070] | 2560 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
| 2561 | return vboxDispIfResizeStartedWDDM(pIf);
|
---|
[42217] | 2562 | #endif
|
---|
| 2563 | default:
|
---|
[84325] | 2564 | WARN(("unknown mode (%d)\n", pIf->enmMode));
|
---|
[42217] | 2565 | return ERROR_INVALID_PARAMETER;
|
---|
| 2566 | }
|
---|
| 2567 | }
|
---|
| 2568 |
|
---|
[31145] | 2569 | static DWORD vboxDispIfSwitchToXPDM_NT4(PVBOXDISPIF pIf)
|
---|
| 2570 | {
|
---|
[63099] | 2571 | RT_NOREF(pIf);
|
---|
[31145] | 2572 | return NO_ERROR;
|
---|
| 2573 | }
|
---|
| 2574 |
|
---|
| 2575 | static DWORD vboxDispIfSwitchToXPDM(PVBOXDISPIF pIf)
|
---|
| 2576 | {
|
---|
| 2577 | DWORD err = NO_ERROR;
|
---|
[57741] | 2578 |
|
---|
[78937] | 2579 | uint64_t const uNtVersion = RTSystemGetNtVersion();
|
---|
| 2580 | if (uNtVersion >= RTSYSTEM_MAKE_NT_VERSION(5, 0, 0))
|
---|
[31145] | 2581 | {
|
---|
[46625] | 2582 | HMODULE hUser = GetModuleHandle("user32.dll");
|
---|
[31145] | 2583 | if (NULL != hUser)
|
---|
| 2584 | {
|
---|
| 2585 | *(uintptr_t *)&pIf->modeData.xpdm.pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
|
---|
[60274] | 2586 | LogFunc(("pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.xpdm.pfnChangeDisplaySettingsEx));
|
---|
[78937] | 2587 | bool const fSupported = RT_BOOL(pIf->modeData.xpdm.pfnChangeDisplaySettingsEx);
|
---|
| 2588 | if (!fSupported)
|
---|
[31145] | 2589 | {
|
---|
[84325] | 2590 | WARN(("pfnChangeDisplaySettingsEx function pointer failed to initialize\n"));
|
---|
[31145] | 2591 | err = ERROR_NOT_SUPPORTED;
|
---|
| 2592 | }
|
---|
| 2593 | }
|
---|
| 2594 | else
|
---|
| 2595 | {
|
---|
[84325] | 2596 | WARN(("failed to get USER32 handle, err (%d)\n", GetLastError()));
|
---|
[31145] | 2597 | err = ERROR_NOT_SUPPORTED;
|
---|
| 2598 | }
|
---|
| 2599 | }
|
---|
| 2600 | else
|
---|
| 2601 | {
|
---|
[84325] | 2602 | WARN(("can not switch to VBOXDISPIF_MODE_XPDM, because os is not >= w2k\n"));
|
---|
[31145] | 2603 | err = ERROR_NOT_SUPPORTED;
|
---|
| 2604 | }
|
---|
| 2605 |
|
---|
| 2606 | return err;
|
---|
| 2607 | }
|
---|
| 2608 |
|
---|
| 2609 | DWORD VBoxDispIfSwitchMode(PVBOXDISPIF pIf, VBOXDISPIF_MODE enmMode, VBOXDISPIF_MODE *penmOldMode)
|
---|
| 2610 | {
|
---|
[63566] | 2611 | /** @todo may need to addd synchronization in case we want to change modes dynamically
|
---|
[31145] | 2612 | * i.e. currently the mode is supposed to be initialized once on service initialization */
|
---|
| 2613 | if (penmOldMode)
|
---|
| 2614 | *penmOldMode = pIf->enmMode;
|
---|
| 2615 |
|
---|
| 2616 | if (enmMode == pIf->enmMode)
|
---|
[42217] | 2617 | return NO_ERROR;
|
---|
[31145] | 2618 |
|
---|
[95049] | 2619 | /* Make sure that we never try to run anything else but VBOXDISPIF_MODE_XPDM_NT4 on NT4 guests.
|
---|
| 2620 | * Anything else will get us into serious trouble. */
|
---|
| 2621 | if (RTSystemGetNtVersion() < RTSYSTEM_MAKE_NT_VERSION(5, 0, 0))
|
---|
| 2622 | enmMode = VBOXDISPIF_MODE_XPDM_NT4;
|
---|
| 2623 |
|
---|
[42217] | 2624 | #ifdef VBOX_WITH_WDDM
|
---|
[48070] | 2625 | if (pIf->enmMode >= VBOXDISPIF_MODE_WDDM)
|
---|
[42217] | 2626 | {
|
---|
| 2627 | vboxDispIfWddmTerm(pIf);
|
---|
[48070] | 2628 |
|
---|
| 2629 | vboxDispKmtCallbacksTerm(&pIf->modeData.wddm.KmtCallbacks);
|
---|
[42217] | 2630 | }
|
---|
| 2631 | #endif
|
---|
| 2632 |
|
---|
[31145] | 2633 | DWORD err = NO_ERROR;
|
---|
| 2634 | switch (enmMode)
|
---|
| 2635 | {
|
---|
| 2636 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
[60274] | 2637 | LogFunc(("request to switch to VBOXDISPIF_MODE_XPDM_NT4\n"));
|
---|
[31145] | 2638 | err = vboxDispIfSwitchToXPDM_NT4(pIf);
|
---|
| 2639 | if (err == NO_ERROR)
|
---|
| 2640 | {
|
---|
[60274] | 2641 | LogFunc(("successfully switched to XPDM_NT4 mode\n"));
|
---|
[31145] | 2642 | pIf->enmMode = VBOXDISPIF_MODE_XPDM_NT4;
|
---|
| 2643 | }
|
---|
| 2644 | else
|
---|
[84325] | 2645 | WARN(("failed to switch to XPDM_NT4 mode, err (%d)\n", err));
|
---|
[31145] | 2646 | break;
|
---|
| 2647 | case VBOXDISPIF_MODE_XPDM:
|
---|
[60274] | 2648 | LogFunc(("request to switch to VBOXDISPIF_MODE_XPDM\n"));
|
---|
[31145] | 2649 | err = vboxDispIfSwitchToXPDM(pIf);
|
---|
| 2650 | if (err == NO_ERROR)
|
---|
| 2651 | {
|
---|
[60274] | 2652 | LogFunc(("successfully switched to XPDM mode\n"));
|
---|
[31145] | 2653 | pIf->enmMode = VBOXDISPIF_MODE_XPDM;
|
---|
| 2654 | }
|
---|
| 2655 | else
|
---|
[84325] | 2656 | WARN(("failed to switch to XPDM mode, err (%d)\n", err));
|
---|
[31145] | 2657 | break;
|
---|
[32622] | 2658 | #ifdef VBOX_WITH_WDDM
|
---|
[31145] | 2659 | case VBOXDISPIF_MODE_WDDM:
|
---|
| 2660 | {
|
---|
[60274] | 2661 | LogFunc(("request to switch to VBOXDISPIF_MODE_WDDM\n"));
|
---|
[31145] | 2662 | err = vboxDispIfSwitchToWDDM(pIf);
|
---|
| 2663 | if (err == NO_ERROR)
|
---|
| 2664 | {
|
---|
[60274] | 2665 | LogFunc(("successfully switched to WDDM mode\n"));
|
---|
[31145] | 2666 | pIf->enmMode = VBOXDISPIF_MODE_WDDM;
|
---|
| 2667 | }
|
---|
| 2668 | else
|
---|
[84325] | 2669 | WARN(("failed to switch to WDDM mode, err (%d)\n", err));
|
---|
[31145] | 2670 | break;
|
---|
| 2671 | }
|
---|
[48070] | 2672 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
| 2673 | {
|
---|
[60274] | 2674 | LogFunc(("request to switch to VBOXDISPIF_MODE_WDDM_W7\n"));
|
---|
[48070] | 2675 | err = vboxDispIfSwitchToWDDM_W7(pIf);
|
---|
| 2676 | if (err == NO_ERROR)
|
---|
| 2677 | {
|
---|
[60274] | 2678 | LogFunc(("successfully switched to WDDM mode\n"));
|
---|
[48070] | 2679 | pIf->enmMode = VBOXDISPIF_MODE_WDDM_W7;
|
---|
| 2680 | }
|
---|
| 2681 | else
|
---|
[84325] | 2682 | WARN(("failed to switch to WDDM mode, err (%d)\n", err));
|
---|
[48070] | 2683 | break;
|
---|
| 2684 | }
|
---|
[31145] | 2685 | #endif
|
---|
| 2686 | default:
|
---|
| 2687 | err = ERROR_INVALID_PARAMETER;
|
---|
| 2688 | break;
|
---|
| 2689 | }
|
---|
| 2690 | return err;
|
---|
| 2691 | }
|
---|
[48070] | 2692 |
|
---|
[57741] | 2693 | static DWORD vboxDispIfSeamlessCreateWDDM(PCVBOXDISPIF const pIf, VBOXDISPIF_SEAMLESS *pSeamless, HANDLE hEvent)
|
---|
[48070] | 2694 | {
|
---|
[63099] | 2695 | RT_NOREF(hEvent);
|
---|
[48070] | 2696 | HRESULT hr = vboxDispKmtOpenAdapter(&pIf->modeData.wddm.KmtCallbacks, &pSeamless->modeData.wddm.Adapter);
|
---|
| 2697 | if (SUCCEEDED(hr))
|
---|
| 2698 | {
|
---|
[63099] | 2699 | #ifndef VBOX_DISPIF_WITH_OPCONTEXT
|
---|
| 2700 | return ERROR_SUCCESS;
|
---|
| 2701 | #else
|
---|
[48070] | 2702 | hr = vboxDispKmtCreateDevice(&pSeamless->modeData.wddm.Adapter, &pSeamless->modeData.wddm.Device);
|
---|
| 2703 | if (SUCCEEDED(hr))
|
---|
| 2704 | {
|
---|
| 2705 | hr = vboxDispKmtCreateContext(&pSeamless->modeData.wddm.Device, &pSeamless->modeData.wddm.Context, VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_SEAMLESS,
|
---|
[80425] | 2706 | hEvent, 0ULL);
|
---|
[48070] | 2707 | if (SUCCEEDED(hr))
|
---|
| 2708 | return ERROR_SUCCESS;
|
---|
[63099] | 2709 | WARN(("VBoxTray: vboxDispKmtCreateContext failed hr 0x%x", hr));
|
---|
[48070] | 2710 |
|
---|
| 2711 | vboxDispKmtDestroyDevice(&pSeamless->modeData.wddm.Device);
|
---|
| 2712 | }
|
---|
| 2713 | else
|
---|
[52136] | 2714 | WARN(("VBoxTray: vboxDispKmtCreateDevice failed hr 0x%x", hr));
|
---|
[48070] | 2715 |
|
---|
| 2716 | vboxDispKmtCloseAdapter(&pSeamless->modeData.wddm.Adapter);
|
---|
[63099] | 2717 | #endif /* VBOX_DISPIF_WITH_OPCONTEXT */
|
---|
[48070] | 2718 | }
|
---|
| 2719 |
|
---|
| 2720 | return hr;
|
---|
| 2721 | }
|
---|
| 2722 |
|
---|
[57741] | 2723 | static DWORD vboxDispIfSeamlessTermWDDM(VBOXDISPIF_SEAMLESS *pSeamless)
|
---|
[48070] | 2724 | {
|
---|
[48732] | 2725 | #ifdef VBOX_DISPIF_WITH_OPCONTEXT
|
---|
[48070] | 2726 | vboxDispKmtDestroyContext(&pSeamless->modeData.wddm.Context);
|
---|
| 2727 | vboxDispKmtDestroyDevice(&pSeamless->modeData.wddm.Device);
|
---|
[48732] | 2728 | #endif
|
---|
[48070] | 2729 | vboxDispKmtCloseAdapter(&pSeamless->modeData.wddm.Adapter);
|
---|
| 2730 |
|
---|
| 2731 | return NO_ERROR;
|
---|
| 2732 | }
|
---|
| 2733 |
|
---|
[57741] | 2734 | static DWORD vboxDispIfSeamlessSubmitWDDM(VBOXDISPIF_SEAMLESS *pSeamless, VBOXDISPIFESCAPE *pData, int cbData)
|
---|
[48070] | 2735 | {
|
---|
| 2736 | D3DKMT_ESCAPE EscapeData = {0};
|
---|
| 2737 | EscapeData.hAdapter = pSeamless->modeData.wddm.Adapter.hAdapter;
|
---|
[48732] | 2738 | #ifdef VBOX_DISPIF_WITH_OPCONTEXT
|
---|
[48070] | 2739 | EscapeData.hDevice = pSeamless->modeData.wddm.Device.hDevice;
|
---|
| 2740 | EscapeData.hContext = pSeamless->modeData.wddm.Context.hContext;
|
---|
[48732] | 2741 | #endif
|
---|
[48070] | 2742 | EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
|
---|
[48815] | 2743 | /*EscapeData.Flags.HardwareAccess = 1;*/
|
---|
[48070] | 2744 | EscapeData.pPrivateDriverData = pData;
|
---|
| 2745 | EscapeData.PrivateDriverDataSize = VBOXDISPIFESCAPE_SIZE(cbData);
|
---|
| 2746 |
|
---|
| 2747 | NTSTATUS Status = pSeamless->pIf->modeData.wddm.KmtCallbacks.pfnD3DKMTEscape(&EscapeData);
|
---|
| 2748 | if (NT_SUCCESS(Status))
|
---|
| 2749 | return ERROR_SUCCESS;
|
---|
| 2750 |
|
---|
[52136] | 2751 | WARN(("VBoxTray: pfnD3DKMTEscape Seamless failed Status 0x%x\n", Status));
|
---|
[48070] | 2752 | return Status;
|
---|
| 2753 | }
|
---|
| 2754 |
|
---|
[57741] | 2755 | DWORD VBoxDispIfSeamlessCreate(PCVBOXDISPIF const pIf, VBOXDISPIF_SEAMLESS *pSeamless, HANDLE hEvent)
|
---|
[48070] | 2756 | {
|
---|
| 2757 | memset(pSeamless, 0, sizeof (*pSeamless));
|
---|
| 2758 | pSeamless->pIf = pIf;
|
---|
| 2759 |
|
---|
| 2760 | switch (pIf->enmMode)
|
---|
| 2761 | {
|
---|
| 2762 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
| 2763 | case VBOXDISPIF_MODE_XPDM:
|
---|
| 2764 | return NO_ERROR;
|
---|
| 2765 | #ifdef VBOX_WITH_WDDM
|
---|
| 2766 | case VBOXDISPIF_MODE_WDDM:
|
---|
| 2767 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
[57741] | 2768 | return vboxDispIfSeamlessCreateWDDM(pIf, pSeamless, hEvent);
|
---|
[48070] | 2769 | #endif
|
---|
| 2770 | default:
|
---|
[57741] | 2771 | break;
|
---|
[48070] | 2772 | }
|
---|
[57741] | 2773 |
|
---|
| 2774 | WARN(("VBoxTray: VBoxDispIfSeamlessCreate: invalid mode %d\n", pIf->enmMode));
|
---|
| 2775 | return ERROR_INVALID_PARAMETER;
|
---|
[48070] | 2776 | }
|
---|
| 2777 |
|
---|
[57741] | 2778 | DWORD VBoxDispIfSeamlessTerm(VBOXDISPIF_SEAMLESS *pSeamless)
|
---|
[48070] | 2779 | {
|
---|
| 2780 | PCVBOXDISPIF const pIf = pSeamless->pIf;
|
---|
| 2781 | DWORD winEr;
|
---|
| 2782 | switch (pIf->enmMode)
|
---|
| 2783 | {
|
---|
| 2784 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
| 2785 | case VBOXDISPIF_MODE_XPDM:
|
---|
| 2786 | winEr = NO_ERROR;
|
---|
| 2787 | break;
|
---|
| 2788 | #ifdef VBOX_WITH_WDDM
|
---|
| 2789 | case VBOXDISPIF_MODE_WDDM:
|
---|
| 2790 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
[57741] | 2791 | winEr = vboxDispIfSeamlessTermWDDM(pSeamless);
|
---|
[48070] | 2792 | break;
|
---|
| 2793 | #endif
|
---|
| 2794 | default:
|
---|
[57741] | 2795 | WARN(("VBoxTray: VBoxDispIfSeamlessTerm: invalid mode %d\n", pIf->enmMode));
|
---|
[48070] | 2796 | winEr = ERROR_INVALID_PARAMETER;
|
---|
| 2797 | break;
|
---|
| 2798 | }
|
---|
| 2799 |
|
---|
| 2800 | if (winEr == NO_ERROR)
|
---|
| 2801 | memset(pSeamless, 0, sizeof (*pSeamless));
|
---|
| 2802 |
|
---|
| 2803 | return winEr;
|
---|
| 2804 | }
|
---|
| 2805 |
|
---|
[57741] | 2806 | DWORD VBoxDispIfSeamlessSubmit(VBOXDISPIF_SEAMLESS *pSeamless, VBOXDISPIFESCAPE *pData, int cbData)
|
---|
[48070] | 2807 | {
|
---|
| 2808 | PCVBOXDISPIF const pIf = pSeamless->pIf;
|
---|
| 2809 |
|
---|
| 2810 | if (pData->escapeCode != VBOXESC_SETVISIBLEREGION)
|
---|
| 2811 | {
|
---|
[52136] | 2812 | WARN(("VBoxTray: invalid escape code for Seamless submit %d\n", pData->escapeCode));
|
---|
[48070] | 2813 | return ERROR_INVALID_PARAMETER;
|
---|
| 2814 | }
|
---|
| 2815 |
|
---|
| 2816 | switch (pIf->enmMode)
|
---|
| 2817 | {
|
---|
| 2818 | case VBOXDISPIF_MODE_XPDM_NT4:
|
---|
| 2819 | case VBOXDISPIF_MODE_XPDM:
|
---|
| 2820 | return VBoxDispIfEscape(pIf, pData, cbData);
|
---|
| 2821 | #ifdef VBOX_WITH_WDDM
|
---|
| 2822 | case VBOXDISPIF_MODE_WDDM:
|
---|
| 2823 | case VBOXDISPIF_MODE_WDDM_W7:
|
---|
[57741] | 2824 | return vboxDispIfSeamlessSubmitWDDM(pSeamless, pData, cbData);
|
---|
[48070] | 2825 | #endif
|
---|
| 2826 | default:
|
---|
[57741] | 2827 | WARN(("VBoxTray: VBoxDispIfSeamlessSubmit: invalid mode %d\n", pIf->enmMode));
|
---|
[48070] | 2828 | return ERROR_INVALID_PARAMETER;
|
---|
| 2829 | }
|
---|
| 2830 | }
|
---|
[57741] | 2831 |
|
---|