Changeset 52136 in vbox
- Timestamp:
- Jul 22, 2014 7:36:45 PM (10 years ago)
- Location:
- trunk
- Files:
-
- 4 added
- 14 edited
-
. (modified) (1 prop)
-
src/VBox (modified) (1 prop)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk (modified) (1 diff)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPCommon.h (modified) (1 diff)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h (modified) (1 diff)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPVidModes.cpp (modified) (1 diff)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp (modified) (3 diffs)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h (modified) (1 diff)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h (modified) (2 diffs)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVModes.cpp (added)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVModes.h (added)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.cpp (modified) (10 diffs)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.h (modified) (4 diffs)
-
src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp (modified) (21 diffs)
-
src/VBox/Additions/WINNT/VBoxTray/VBoxDispIf.cpp (modified) (106 diffs)
-
src/VBox/Additions/WINNT/include/VBoxDisplay.h (modified) (2 diffs)
-
src/VBox/GuestHost/OpenGL/include/cr_sortarray.h (added)
-
src/VBox/GuestHost/OpenGL/util/sortarray.cpp (added)
Legend:
- Unmodified
- Added
- Removed
-
trunk
- Property svn:mergeinfo changed
/branches/VBox-4.3 merged: 95154,95164
- Property svn:mergeinfo changed
-
trunk/src/VBox
- Property svn:mergeinfo changed
/branches/VBox-4.3/src/VBox merged: 95154,95164
- Property svn:mergeinfo changed
-
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk
r50941 r52136 113 113 wddm/VBoxMPWddm.rc \ 114 114 wddm/VBoxMPRegistry.cpp \ 115 wddm/VBoxMPVModes.cpp \ 115 116 common/VBoxMPUtils.cpp \ 116 117 common/VBoxMPCommon.cpp \ 117 118 common/VBoxMPHGSMI.cpp \ 118 common/VBoxMPVidModes.cpp \119 119 $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp \ 120 120 $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/VBVABase.cpp \ 121 121 $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/Modesetting.cpp 122 123 VBoxVideoWddm_SOURCES += \ 124 $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/util/sortarray.cpp 122 125 123 126 if defined(VBOX_WITH_CROGL) -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPCommon.h
r50900 r52136 30 30 31 31 /* Video modes related */ 32 #ifdef VBOX_XPDM_MINIPORT 32 33 void VBoxMPCmnInitCustomVideoModes(PVBOXMP_DEVEXT pExt); 33 34 VIDEO_MODE_INFORMATION* VBoxMPCmnGetCustomVideoModeInfo(ULONG ulIndex); 34 35 #ifdef VBOX_XPDM_MINIPORT36 35 VIDEO_MODE_INFORMATION* VBoxMPCmnGetVideoModeInfo(PVBOXMP_DEVEXT pExt, ULONG ulIndex); 37 36 VIDEO_MODE_INFORMATION* VBoxMPXpdmCurrentVideoMode(PVBOXMP_DEVEXT pExt); 38 37 ULONG VBoxMPXpdmGetVideoModesCount(PVBOXMP_DEVEXT pExt); 39 38 void VBoxMPXpdmBuildVideoModesTable(PVBOXMP_DEVEXT pExt); 40 #endif41 42 #ifdef VBOX_WDDM_MINIPORT43 PVBOXWDDM_VIDEOMODES_INFO VBoxWddmUpdateVideoModesInfoByMask(PVBOXMP_DEVEXT pExt, uint8_t *pScreenIdMask);44 void VBoxWddmInitVideoModes(PVBOXMP_DEVEXT pExt);45 NTSTATUS VBoxWddmGetModesForResolution(VIDEO_MODE_INFORMATION *pAllModes, uint32_t cAllModes, int iSearchPreferredMode,46 const D3DKMDT_2DREGION *pResolution, VIDEO_MODE_INFORMATION * pModes,47 uint32_t cModes, uint32_t *pcModes, int32_t *piPreferrableMode);48 PVBOXWDDM_VIDEOMODES_INFO VBoxWddmGetAllVideoModesInfos(PVBOXMP_DEVEXT pExt);49 PVBOXWDDM_VIDEOMODES_INFO VBoxWddmGetVideoModesInfo(PVBOXMP_DEVEXT pExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId);50 bool VBoxWddmFillMode(VIDEO_MODE_INFORMATION *pInfo, D3DDDIFORMAT enmFormat, ULONG w, ULONG h);51 bool VBoxWddmFillMode(VIDEO_MODE_INFORMATION *pInfo, D3DDDIFORMAT enmFormat, ULONG w, ULONG h);52 void VBoxWddmAdjustMode(PVBOXMP_DEVEXT pExt, PVBOXWDDM_ADJUSTVIDEOMODE pMode);53 void VBoxWddmAdjustModes(PVBOXMP_DEVEXT pExt, uint32_t cModes, PVBOXWDDM_ADJUSTVIDEOMODE aModes);54 39 #endif 55 40 -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h
r51328 r52136 144 144 VBOXVTLIST VhwaCmdList; 145 145 #endif 146 BOOL bNotifyDxDpc; 146 BOOLEAN bNotifyDxDpc; 147 148 BOOLEAN fDisableTargetUpdate; 149 150 147 151 148 152 #ifdef VBOX_VDMA_WITH_WATCHDOG -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPVidModes.cpp
r51943 r52136 874 874 } 875 875 #endif /*VBOX_XPDM_MINIPORT*/ 876 877 #ifdef VBOX_WDDM_MINIPORT878 static VBOXWDDM_VIDEOMODES_INFO g_aVBoxVideoModeInfos[VBOX_VIDEO_MAX_SCREENS] = {0};879 static VBOXWDDM_VIDEOMODES_INFO g_VBoxVideoModeTmp;880 881 bool VBoxWddmFillMode(PVBOXMP_DEVEXT pExt, uint32_t iDisplay, VIDEO_MODE_INFORMATION *pInfo, D3DDDIFORMAT enmFormat, ULONG w, ULONG h)882 {883 switch (enmFormat)884 {885 case D3DDDIFMT_A8R8G8B8:886 if (!VBoxMPValidateVideoModeParamsGuest(pExt, iDisplay, w, h, 32))887 {888 WARN(("unsupported mode info for format(%d)", enmFormat));889 return false;890 }891 VBoxFillVidModeInfo(pInfo, w, h, 32, 0, 0);892 return true;893 case D3DDDIFMT_R8G8B8:894 if (!VBoxMPValidateVideoModeParamsGuest(pExt, iDisplay, w, h, 24))895 {896 WARN(("unsupported mode info for format(%d)", enmFormat));897 return false;898 }899 VBoxFillVidModeInfo(pInfo, w, h, 24, 0, 0);900 return true;901 case D3DDDIFMT_R5G6B5:902 if (!VBoxMPValidateVideoModeParamsGuest(pExt, iDisplay, w, h, 16))903 {904 WARN(("unsupported mode info for format(%d)", enmFormat));905 return false;906 }907 VBoxFillVidModeInfo(pInfo, w, h, 16, 0, 0);908 return true;909 case D3DDDIFMT_P8:910 if (!VBoxMPValidateVideoModeParamsGuest(pExt, iDisplay, w, h, 8))911 {912 WARN(("unsupported mode info for format(%d)", enmFormat));913 return false;914 }915 VBoxFillVidModeInfo(pInfo, w, h, 8, 0, 0);916 return true;917 default:918 WARN(("unsupported enmFormat(%d)", enmFormat));919 AssertBreakpoint();920 break;921 }922 923 return false;924 }925 926 static void927 VBoxWddmBuildResolutionTable(PVIDEO_MODE_INFORMATION pModesTable, size_t tableSize, int iPreferredMode,928 SIZE *pResolutions, uint32_t * pcResolutions, int *piPreferredResolution)929 {930 uint32_t cResolutionsArray = *pcResolutions;931 uint32_t cResolutions = 0;932 933 *piPreferredResolution = -1;934 *pcResolutions = 0;935 936 for (uint32_t i=0; i<tableSize; ++i)937 {938 PVIDEO_MODE_INFORMATION pMode = &pModesTable[i];939 int iResolution = -1;940 941 for (uint32_t j=0; j<cResolutions; ++j)942 {943 if (pResolutions[j].cx == pMode->VisScreenWidth944 && pResolutions[j].cy == pMode->VisScreenHeight)945 {946 iResolution = j;947 break;948 }949 }950 951 if (iResolution < 0)952 {953 if (cResolutions == cResolutionsArray)954 {955 WARN(("table overflow!"));956 break;957 }958 959 iResolution = cResolutions;960 pResolutions[cResolutions].cx = pMode->VisScreenWidth;961 pResolutions[cResolutions].cy = pMode->VisScreenHeight;962 ++cResolutions;963 }964 965 Assert(iResolution >= 0);966 if (i == iPreferredMode)967 {968 Assert(*piPreferredResolution == -1);969 *piPreferredResolution = iResolution;970 }971 }972 973 *pcResolutions = cResolutions;974 Assert(*piPreferredResolution >= 0);975 }976 977 static void VBoxWddmBuildResolutionTableForModes(PVBOXWDDM_VIDEOMODES_INFO pModes)978 {979 pModes->cResolutions = RT_ELEMENTS(pModes->aResolutions);980 VBoxWddmBuildResolutionTable(pModes->aModes, pModes->cModes, pModes->iPreferredMode,981 (SIZE*)((void*)pModes->aResolutions), &pModes->cResolutions, &pModes->iPreferredResolution);982 Assert(pModes->aResolutions[pModes->iPreferredResolution].cx == pModes->aModes[pModes->iPreferredMode].VisScreenWidth983 && pModes->aResolutions[pModes->iPreferredResolution].cy == pModes->aModes[pModes->iPreferredMode].VisScreenHeight);984 Assert(pModes->cModes >= pModes->cResolutions);985 }986 987 AssertCompile(sizeof (SIZE) == sizeof (D3DKMDT_2DREGION));988 AssertCompile(RT_OFFSETOF(SIZE, cx) == RT_OFFSETOF(D3DKMDT_2DREGION, cx));989 AssertCompile(RT_OFFSETOF(SIZE, cy) == RT_OFFSETOF(D3DKMDT_2DREGION, cy));990 static void991 VBoxWddmBuildVideoModesInfo(PVBOXMP_DEVEXT pExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId,992 PVBOXWDDM_VIDEOMODES_INFO pModes, VIDEO_MODE_INFORMATION *paAddlModes,993 UINT cAddlModes)994 {995 pModes->cResolutions = RT_ELEMENTS(pModes->aResolutions);996 997 /* Add default modes and ones read from registry. */998 pModes->cModes = VBoxMPFillModesTable(pExt, VidPnTargetId, pModes->aModes, RT_ELEMENTS(pModes->aModes), &pModes->iPreferredMode);999 Assert(pModes->cModes<=RT_ELEMENTS(pModes->aModes));1000 1001 if (!VBoxMPIsStartingUp(pExt, VidPnTargetId))1002 {1003 /* make sure we keep the current mode to avoid mode flickering */1004 PVBOXWDDM_ALLOC_DATA pAllocData = pExt->aSources[VidPnTargetId].pPrimaryAllocation ?1005 &pExt->aSources[VidPnTargetId].pPrimaryAllocation->AllocData1006 : &pExt->aSources[VidPnTargetId].AllocData;1007 if (pModes->cModes < RT_ELEMENTS(pModes->aModes))1008 {1009 /* VBox WDDM driver does not allow 24 modes since OS could choose the 24bit mode as default in that case,1010 * the pExt->aSources[iDisplay].AllocData.SurfDesc.bpp could be initially 24 though,1011 * i.e. when driver occurs the current mode on driver load via DxgkCbAcquirePostDisplayOwnership1012 * and until driver reports the supported modes1013 * This is true for Win8 Display-Only driver currently since DxgkCbAcquirePostDisplayOwnership is only used by it1014 *1015 * This is why we check the bpp to be supported here and add the current mode to the list only in that case */1016 if (VBoxMPIsSupportedBpp(pAllocData->SurfDesc.bpp))1017 {1018 int foundIdx;1019 VBoxFillVidModeInfo(&pModes->aModes[pModes->cModes], pAllocData->SurfDesc.width, pAllocData->SurfDesc.height, pAllocData->SurfDesc.bpp, 1/*index*/, 0);1020 if ((foundIdx=VBoxMPFindVideoMode(pModes->aModes, pModes->cModes, &pModes->aModes[pModes->cModes]))>=0)1021 {1022 pModes->iPreferredMode = foundIdx;1023 }1024 else1025 {1026 pModes->iPreferredMode = pModes->cModes;1027 ++pModes->cModes;1028 }1029 1030 #ifdef VBOX_WITH_8BPP_MODES1031 int bytesPerPixel=1;1032 #else1033 int bytesPerPixel=2;1034 #endif1035 for (; bytesPerPixel<=4; bytesPerPixel++)1036 {1037 int bpp = 8*bytesPerPixel;1038 1039 if (bpp == pAllocData->SurfDesc.bpp)1040 continue;1041 1042 if (!VBoxMPValidateVideoModeParamsGuest(pExt, VidPnTargetId,1043 pAllocData->SurfDesc.width, pAllocData->SurfDesc.height,1044 bpp))1045 continue;1046 1047 if (pModes->cModes >= RT_ELEMENTS(pModes->aModes))1048 {1049 WARN(("ran out of video modes 2"));1050 break;1051 }1052 1053 VBoxFillVidModeInfo(&pModes->aModes[pModes->cModes],1054 pAllocData->SurfDesc.width, pAllocData->SurfDesc.height,1055 bpp, pModes->cModes, 0);1056 if (VBoxMPFindVideoMode(pModes->aModes, pModes->cModes, &pModes->aModes[pModes->cModes]) < 0)1057 {1058 ++pModes->cModes;1059 }1060 }1061 }1062 }1063 else1064 {1065 WARN(("ran out of video modes 1"));1066 }1067 }1068 1069 /* Check if there's a pending display change request for this adapter */1070 VIDEO_MODE_INFORMATION specialMode;1071 if (VBoxMPCheckPendingVideoMode(pExt, &specialMode) && (specialMode.ModeIndex==VidPnTargetId))1072 {1073 /*Minor hack, ModeIndex!=0 Means this mode has been validated already and not just read from registry */1074 specialMode.ModeIndex = 1;1075 memcpy(&g_CustomVideoModes[VidPnTargetId], &specialMode, sizeof(VIDEO_MODE_INFORMATION));1076 1077 /* Save mode to registry */1078 VBoxMPRegSaveModeInfo(pExt, VidPnTargetId, &specialMode);1079 }1080 1081 /* Validate the mode which has been read from registry */1082 if (!g_CustomVideoModes[VidPnTargetId].ModeIndex)1083 {1084 uint32_t xres, yres, bpp;1085 1086 xres = g_CustomVideoModes[VidPnTargetId].VisScreenWidth;1087 yres = g_CustomVideoModes[VidPnTargetId].VisScreenHeight;1088 bpp = g_CustomVideoModes[VidPnTargetId].BitsPerPlane;1089 1090 if (VBoxMPValidateVideoModeParams(pExt, VidPnTargetId, xres, yres, bpp))1091 {1092 VBoxFillVidModeInfo(&g_CustomVideoModes[VidPnTargetId], xres, yres, bpp, 1/*index*/, 0);1093 Assert(g_CustomVideoModes[VidPnTargetId].ModeIndex == 1);1094 }1095 }1096 1097 /* Add custom mode to the table */1098 if (g_CustomVideoModes[VidPnTargetId].ModeIndex)1099 {1100 if (RT_ELEMENTS(pModes->aModes) > pModes->cModes)1101 {1102 g_CustomVideoModes[VidPnTargetId].ModeIndex = pModes->cModes;1103 pModes->aModes[pModes->cModes] = g_CustomVideoModes[VidPnTargetId];1104 1105 /* Check if we already have this mode in the table */1106 int foundIdx;1107 if ((foundIdx=VBoxMPFindVideoMode(pModes->aModes, pModes->cModes, &pModes->aModes[pModes->cModes]))>=0)1108 {1109 pModes->iPreferredMode = foundIdx;1110 }1111 else1112 {1113 pModes->iPreferredMode = pModes->cModes;1114 ++pModes->cModes;1115 }1116 1117 /* Add other bpp modes for this custom resolution */1118 #ifdef VBOX_WITH_8BPP_MODES1119 UINT bpp=8;1120 #else1121 UINT bpp=16;1122 #endif1123 for (; bpp<=32; bpp+=8)1124 {1125 if (RT_ELEMENTS(pModes->aModes) == pModes->cModes)1126 {1127 WARN(("table full, can't add other bpp for specail mode!"));1128 #ifdef DEBUG_misha1129 /* this is definitely something we do not expect */1130 AssertFailed();1131 #endif1132 break;1133 }1134 1135 AssertRelease(RT_ELEMENTS(pModes->aModes) > pModes->cModes); /* if not - the driver state is screwed up, @todo: better do KeBugCheckEx here */1136 1137 if (pModes->aModes[pModes->iPreferredMode].BitsPerPlane == bpp)1138 continue;1139 1140 if (!VBoxMPValidateVideoModeParamsGuest(pExt, VidPnTargetId,1141 pModes->aModes[pModes->iPreferredMode].VisScreenWidth,1142 pModes->aModes[pModes->iPreferredMode].VisScreenHeight,1143 bpp))1144 continue;1145 1146 VBoxFillVidModeInfo(&pModes->aModes[pModes->cModes],1147 pModes->aModes[pModes->iPreferredMode].VisScreenWidth,1148 pModes->aModes[pModes->iPreferredMode].VisScreenHeight,1149 bpp, pModes->cModes, 0);1150 if (VBoxMPFindVideoMode(pModes->aModes, pModes->cModes, &pModes->aModes[pModes->cModes]) < 0)1151 {1152 ++pModes->cModes;1153 }1154 }1155 }1156 else1157 {1158 AssertRelease(RT_ELEMENTS(pModes->aModes) == pModes->cModes); /* if not - the driver state is screwed up, @todo: better do KeBugCheckEx here */1159 WARN(("table full, can't add video mode for a host request!"));1160 #ifdef DEBUG_misha1161 /* this is definitely something we do not expect */1162 AssertFailed();1163 #endif1164 }1165 }1166 1167 /* Check and Add additional modes passed in paAddlModes */1168 for (UINT i=0; i<cAddlModes; ++i)1169 {1170 if (RT_ELEMENTS(pModes->aModes) == pModes->cModes)1171 {1172 WARN(("table full, can't add addl modes!"));1173 #ifdef DEBUG_misha1174 /* this is definitely something we do not expect */1175 AssertFailed();1176 #endif1177 break;1178 }1179 1180 AssertRelease(RT_ELEMENTS(pModes->aModes) > pModes->cModes); /* if not - the driver state is screwed up, @todo: better do KeBugCheckEx here */1181 1182 if (!VBoxCommonFromDeviceExt(pExt)->fAnyX)1183 {1184 paAddlModes[i].VisScreenWidth &= 0xFFF8;1185 }1186 1187 if (VBoxLikesVideoMode(VidPnTargetId, paAddlModes[i].VisScreenWidth, paAddlModes[i].VisScreenHeight, paAddlModes[i].BitsPerPlane))1188 {1189 int foundIdx;1190 if ((foundIdx=VBoxMPFindVideoMode(pModes->aModes, pModes->cModes, &paAddlModes[i]))>=0)1191 {1192 pModes->iPreferredMode = foundIdx;1193 }1194 else1195 {1196 memcpy(&pModes->aModes[pModes->cModes], &paAddlModes[i], sizeof(VIDEO_MODE_INFORMATION));1197 pModes->aModes[pModes->cModes].ModeIndex = pModes->cModes;1198 ++pModes->cModes;1199 }1200 }1201 }1202 1203 /* Build resolution table */1204 VBoxWddmBuildResolutionTableForModes(pModes);1205 }1206 1207 static void VBoxWddmInitVideoMode(PVBOXMP_DEVEXT pExt, int i)1208 {1209 VBoxWddmBuildVideoModesInfo(pExt, (D3DDDI_VIDEO_PRESENT_TARGET_ID)i, &g_aVBoxVideoModeInfos[i], NULL, 0);1210 }1211 1212 void VBoxWddmInitVideoModes(PVBOXMP_DEVEXT pExt)1213 {1214 for (int i = 0; i < VBoxCommonFromDeviceExt(pExt)->cDisplays; ++i)1215 {1216 VBoxWddmInitVideoMode(pExt, i);1217 }1218 }1219 1220 static NTSTATUS vboxWddmChildStatusReportPerform(PVBOXMP_DEVEXT pDevExt, PVBOXVDMA_CHILD_STATUS pChildStatus, D3DDDI_VIDEO_PRESENT_TARGET_ID iChild)1221 {1222 DXGK_CHILD_STATUS DdiChildStatus;1223 1224 Assert(iChild < UINT32_MAX/2);1225 Assert(iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);1226 1227 PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[iChild];1228 1229 if ((pChildStatus->fFlags & VBOXVDMA_CHILD_STATUS_F_DISCONNECTED)1230 && pTarget->fConnected)1231 {1232 /* report disconnected */1233 memset(&DdiChildStatus, 0, sizeof (DdiChildStatus));1234 DdiChildStatus.Type = StatusConnection;1235 DdiChildStatus.ChildUid = iChild;1236 DdiChildStatus.HotPlug.Connected = FALSE;1237 1238 LOG(("Reporting DISCONNECT to child %d", DdiChildStatus.ChildUid));1239 1240 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbIndicateChildStatus(pDevExt->u.primary.DxgkInterface.DeviceHandle, &DdiChildStatus);1241 if (!NT_SUCCESS(Status))1242 {1243 WARN(("DxgkCbIndicateChildStatus failed with Status (0x%x)", Status));1244 return Status;1245 }1246 pTarget->fConnected = FALSE;1247 }1248 1249 if ((pChildStatus->fFlags & VBOXVDMA_CHILD_STATUS_F_CONNECTED)1250 && !pTarget->fConnected)1251 {1252 /* report disconnected */1253 memset(&DdiChildStatus, 0, sizeof (DdiChildStatus));1254 DdiChildStatus.Type = StatusConnection;1255 DdiChildStatus.ChildUid = iChild;1256 DdiChildStatus.HotPlug.Connected = TRUE;1257 1258 LOG(("Reporting CONNECT to child %d", DdiChildStatus.ChildUid));1259 1260 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbIndicateChildStatus(pDevExt->u.primary.DxgkInterface.DeviceHandle, &DdiChildStatus);1261 if (!NT_SUCCESS(Status))1262 {1263 WARN(("DxgkCbIndicateChildStatus failed with Status (0x%x)", Status));1264 return Status;1265 }1266 pTarget->fConnected = TRUE;1267 }1268 1269 if (pChildStatus->fFlags & VBOXVDMA_CHILD_STATUS_F_ROTATED)1270 {1271 /* report disconnected */1272 memset(&DdiChildStatus, 0, sizeof (DdiChildStatus));1273 DdiChildStatus.Type = StatusRotation;1274 DdiChildStatus.ChildUid = iChild;1275 DdiChildStatus.Rotation.Angle = pChildStatus->u8RotationAngle;1276 1277 LOG(("Reporting ROTATED to child %d", DdiChildStatus.ChildUid));1278 1279 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbIndicateChildStatus(pDevExt->u.primary.DxgkInterface.DeviceHandle, &DdiChildStatus);1280 if (!NT_SUCCESS(Status))1281 {1282 WARN(("DxgkCbIndicateChildStatus failed with Status (0x%x)", Status));1283 return Status;1284 }1285 }1286 1287 return STATUS_SUCCESS;1288 }1289 1290 static NTSTATUS vboxWddmChildStatusHandleRequest(PVBOXMP_DEVEXT pDevExt, VBOXVDMACMD_CHILD_STATUS_IRQ *pBody)1291 {1292 NTSTATUS Status = STATUS_SUCCESS;1293 1294 for (UINT i = 0; i < pBody->cInfos; ++i)1295 {1296 PVBOXVDMA_CHILD_STATUS pInfo = &pBody->aInfos[i];1297 if (pBody->fFlags & VBOXVDMACMD_CHILD_STATUS_IRQ_F_APPLY_TO_ALL)1298 {1299 for (D3DDDI_VIDEO_PRESENT_TARGET_ID iChild = 0; iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++iChild)1300 {1301 Status = vboxWddmChildStatusReportPerform(pDevExt, pInfo, iChild);1302 if (!NT_SUCCESS(Status))1303 {1304 WARN(("vboxWddmChildStatusReportPerform failed with Status (0x%x)", Status));1305 break;1306 }1307 }1308 }1309 else1310 {1311 Status = vboxWddmChildStatusReportPerform(pDevExt, pInfo, pInfo->iChild);1312 if (!NT_SUCCESS(Status))1313 {1314 WARN(("vboxWddmChildStatusReportPerform failed with Status (0x%x)", Status));1315 break;1316 }1317 }1318 }1319 1320 return Status;1321 }1322 1323 #ifdef VBOX_WDDM_MONITOR_REPLUG_IRQ1324 typedef struct VBOXWDDMCHILDSTATUSCB1325 {1326 PVBOXVDMACBUF_DR pDr;1327 PKEVENT pEvent;1328 } VBOXWDDMCHILDSTATUSCB, *PVBOXWDDMCHILDSTATUSCB;1329 1330 static DECLCALLBACK(VOID) vboxWddmChildStatusReportCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)1331 {1332 /* we should be called from our DPC routine */1333 Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);1334 1335 PVBOXWDDMCHILDSTATUSCB pCtx = (PVBOXWDDMCHILDSTATUSCB)pvContext;1336 PVBOXVDMACBUF_DR pDr = pCtx->pDr;1337 PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);1338 VBOXVDMACMD_CHILD_STATUS_IRQ *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHILD_STATUS_IRQ);1339 1340 vboxWddmChildStatusHandleRequest(pDevExt, pBody);1341 1342 vboxVdmaCBufDrFree(&pDevExt->u.primary.Vdma, pDr);1343 1344 if (pCtx->pEvent)1345 {1346 KeSetEvent(pCtx->pEvent, 0, FALSE);1347 }1348 }1349 #endif1350 1351 static NTSTATUS vboxWddmChildStatusReportReconnected(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID idTarget)1352 {1353 #ifdef VBOX_WDDM_MONITOR_REPLUG_IRQ1354 NTSTATUS Status = STATUS_UNSUCCESSFUL;1355 UINT cbCmd = VBOXVDMACMD_SIZE_FROMBODYSIZE(sizeof (VBOXVDMACMD_CHILD_STATUS_IRQ));1356 1357 PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);1358 if (pDr)1359 {1360 // vboxVdmaCBufDrCreate zero initializes the pDr1361 /* the command data follows the descriptor */1362 pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;1363 pDr->cbBuf = cbCmd;1364 pDr->rc = VERR_NOT_IMPLEMENTED;1365 1366 PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);1367 pHdr->enmType = VBOXVDMACMD_TYPE_CHILD_STATUS_IRQ;1368 pHdr->u32CmdSpecific = 0;1369 PVBOXVDMACMD_CHILD_STATUS_IRQ pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHILD_STATUS_IRQ);1370 pBody->cInfos = 1;1371 if (idTarget == D3DDDI_ID_ALL)1372 {1373 pBody->fFlags |= VBOXVDMACMD_CHILD_STATUS_IRQ_F_APPLY_TO_ALL;1374 }1375 pBody->aInfos[0].iChild = idTarget;1376 pBody->aInfos[0].fFlags = VBOXVDMA_CHILD_STATUS_F_DISCONNECTED | VBOXVDMA_CHILD_STATUS_F_CONNECTED;1377 /* we're going to KeWaitForSingleObject */1378 Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);1379 1380 PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);1381 VBOXWDDMCHILDSTATUSCB Ctx;1382 KEVENT Event;1383 KeInitializeEvent(&Event, NotificationEvent, FALSE);1384 Ctx.pDr = pDr;1385 Ctx.pEvent = &Event;1386 vboxVdmaDdiCmdInit(pDdiCmd, 0, 0, vboxWddmChildStatusReportCompletion, &Ctx);1387 /* mark command as submitted & invisible for the dx runtime since dx did not originate it */1388 vboxVdmaDdiCmdSubmittedNotDx(pDdiCmd);1389 int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);1390 Assert(rc == VINF_SUCCESS);1391 if (RT_SUCCESS(rc))1392 {1393 Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);1394 Assert(Status == STATUS_SUCCESS);1395 return STATUS_SUCCESS;1396 }1397 1398 Status = STATUS_UNSUCCESSFUL;1399 1400 vboxVdmaCBufDrFree(&pDevExt->u.primary.Vdma, pDr);1401 }1402 else1403 {1404 /* @todo: try flushing.. */1405 WARN(("vboxVdmaCBufDrCreate returned NULL"));1406 Status = STATUS_INSUFFICIENT_RESOURCES;1407 }1408 1409 return Status;1410 #else1411 VBOXVDMACMD_CHILD_STATUS_IRQ Body = {0};1412 Body.cInfos = 1;1413 if (idTarget == D3DDDI_ID_ALL)1414 {1415 Body.fFlags |= VBOXVDMACMD_CHILD_STATUS_IRQ_F_APPLY_TO_ALL;1416 }1417 Body.aInfos[0].iChild = idTarget;1418 Body.aInfos[0].fFlags = VBOXVDMA_CHILD_STATUS_F_DISCONNECTED | VBOXVDMA_CHILD_STATUS_F_CONNECTED;1419 Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);1420 return vboxWddmChildStatusHandleRequest(pDevExt, &Body);1421 #endif1422 }1423 1424 NTSTATUS vboxWddmChildStatusConnect(PVBOXMP_DEVEXT pDevExt, uint32_t iChild, BOOLEAN fConnect)1425 {1426 #ifdef VBOX_WDDM_MONITOR_REPLUG_IRQ1427 # error "port me!"1428 #else1429 Assert(iChild < (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);1430 NTSTATUS Status = STATUS_SUCCESS;1431 VBOXVDMACMD_CHILD_STATUS_IRQ Body = {0};1432 Body.cInfos = 1;1433 Body.aInfos[0].iChild = iChild;1434 Body.aInfos[0].fFlags = fConnect ? VBOXVDMA_CHILD_STATUS_F_CONNECTED : VBOXVDMA_CHILD_STATUS_F_DISCONNECTED;1435 Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);1436 Status = vboxWddmChildStatusHandleRequest(pDevExt, &Body);1437 if (!NT_SUCCESS(Status))1438 WARN(("vboxWddmChildStatusHandleRequest failed Status 0x%x", Status));1439 1440 return Status;1441 #endif1442 }1443 1444 void VBoxWddmUpdateVideoMode(PVBOXMP_DEVEXT pExt, int i)1445 {1446 g_VBoxVideoModeTmp = g_aVBoxVideoModeInfos[i];1447 1448 Assert(g_aVBoxVideoModeInfos[i].cModes);1449 1450 VBoxWddmInitVideoMode(pExt, i);1451 1452 if (!memcmp(&g_VBoxVideoModeTmp, &g_aVBoxVideoModeInfos[i], sizeof (g_VBoxVideoModeTmp)))1453 return;1454 1455 #ifdef DEBUG_misha1456 LOGREL(("modes changed for target %d", i));1457 #else1458 LOG(("modes changed for target %d", i));1459 #endif1460 vboxWddmChildStatusReportReconnected(pExt, (D3DDDI_VIDEO_PRESENT_TARGET_ID)i);1461 }1462 1463 PVBOXWDDM_VIDEOMODES_INFO VBoxWddmUpdateVideoModesInfoByMask(PVBOXMP_DEVEXT pExt, uint8_t *pScreenIdMask)1464 {1465 for (int i = 0; i < VBoxCommonFromDeviceExt(pExt)->cDisplays; ++i)1466 {1467 if (!pScreenIdMask || ASMBitTest(pScreenIdMask, i))1468 {1469 VBoxWddmUpdateVideoMode(pExt, i);1470 }1471 }1472 1473 return g_aVBoxVideoModeInfos;1474 }1475 1476 void VBoxWddmAdjustMode(PVBOXMP_DEVEXT pExt, PVBOXWDDM_ADJUSTVIDEOMODE pMode)1477 {1478 pMode->fFlags = 0;1479 1480 if (pMode->Mode.Id >= (UINT)VBoxCommonFromDeviceExt(pExt)->cDisplays)1481 {1482 WARN(("invalid screen id (%d)", pMode->Mode.Id));1483 pMode->fFlags = VBOXWDDM_ADJUSTVIDEOMODE_F_INVALISCREENID;1484 return;1485 }1486 1487 /* @todo: this info should go from the target actually */1488 PVBOXWDDM_SOURCE pSource = &pExt->aSources[pMode->Mode.Id];1489 1490 UINT newWidth = pMode->Mode.Width;1491 UINT newHeight = pMode->Mode.Height;1492 UINT newBpp = pMode->Mode.BitsPerPixel;1493 1494 if (!VBoxMPValidateVideoModeParams(pExt, pMode->Mode.Id, newWidth, newHeight, newBpp))1495 {1496 PVBOXWDDM_SOURCE pSource = &pExt->aSources[pMode->Mode.Id];1497 pMode->fFlags |= VBOXWDDM_ADJUSTVIDEOMODE_F_UNSUPPORTED;1498 }1499 1500 if (pMode->Mode.Width != newWidth1501 || pMode->Mode.Height != newHeight1502 || pMode->Mode.BitsPerPixel != newBpp)1503 {1504 pMode->fFlags |= VBOXWDDM_ADJUSTVIDEOMODE_F_ADJUSTED;1505 pMode->Mode.Width = newWidth;1506 pMode->Mode.Height = newHeight;1507 pMode->Mode.BitsPerPixel = newBpp;1508 }1509 1510 if (pSource->cTargets /* <- active */1511 && pSource->AllocData.SurfDesc.width == pMode->Mode.Width1512 && pSource->AllocData.SurfDesc.height == pMode->Mode.Height1513 && pSource->AllocData.SurfDesc.bpp == pMode->Mode.BitsPerPixel)1514 {1515 pMode->fFlags |= VBOXWDDM_ADJUSTVIDEOMODE_F_CURRENT;1516 if (pMode->fFlags & VBOXWDDM_ADJUSTVIDEOMODE_F_UNSUPPORTED)1517 {1518 WARN(("current mode is reported as unsupported"));1519 }1520 }1521 }1522 1523 void VBoxWddmAdjustModes(PVBOXMP_DEVEXT pExt, uint32_t cModes, PVBOXWDDM_ADJUSTVIDEOMODE aModes)1524 {1525 for (UINT i = 0; i < cModes; ++i)1526 {1527 PVBOXWDDM_ADJUSTVIDEOMODE pMode = &aModes[i];1528 VBoxWddmAdjustMode(pExt, pMode);1529 }1530 }1531 1532 NTSTATUS VBoxWddmGetModesForResolution(VIDEO_MODE_INFORMATION *pAllModes, uint32_t cAllModes, int iSearchPreferredMode,1533 const D3DKMDT_2DREGION *pResolution, VIDEO_MODE_INFORMATION * pModes, uint32_t cModes, uint32_t *pcModes, int32_t *piPreferrableMode)1534 {1535 NTSTATUS Status = STATUS_SUCCESS;1536 uint32_t cFound = 0;1537 int iFoundPreferrableMode = -1;1538 for (uint32_t i = 0; i < cAllModes; ++i)1539 {1540 VIDEO_MODE_INFORMATION *pCur = &pAllModes[i];1541 if (pResolution->cx == pCur->VisScreenWidth1542 && pResolution->cy == pCur->VisScreenHeight)1543 {1544 if (pModes && cModes > cFound)1545 memcpy(&pModes[cFound], pCur, sizeof(VIDEO_MODE_INFORMATION));1546 else1547 Status = STATUS_BUFFER_TOO_SMALL;1548 1549 if (i == iSearchPreferredMode)1550 iFoundPreferrableMode = cFound;1551 1552 ++cFound;1553 }1554 }1555 1556 Assert(iFoundPreferrableMode < 0 || cFound > (uint32_t)iFoundPreferrableMode);1557 1558 *pcModes = cFound;1559 if (piPreferrableMode)1560 *piPreferrableMode = iFoundPreferrableMode;1561 1562 return Status;1563 }1564 1565 PVBOXWDDM_VIDEOMODES_INFO VBoxWddmGetAllVideoModesInfos(PVBOXMP_DEVEXT pExt)1566 {1567 return g_aVBoxVideoModeInfos;1568 }1569 1570 PVBOXWDDM_VIDEOMODES_INFO VBoxWddmGetVideoModesInfo(PVBOXMP_DEVEXT pExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)1571 {1572 return &VBoxWddmGetAllVideoModesInfos(pExt)[VidPnTargetId];1573 }1574 1575 #endif /*VBOX_WDDM_MINIPORT*/ -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp
r51943 r52136 707 707 708 708 Status = vboxWddmRegOpenKey(&hKey, VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY, GENERIC_READ); 709 Assert(Status == STATUS_SUCCESS);709 //Assert(Status == STATUS_SUCCESS); 710 710 if (Status == STATUS_SUCCESS) 711 711 { … … 734 734 memcpy(pSubBuf, VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY_SUBKEY, sizeof (VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY_SUBKEY)); 735 735 Status = vboxWddmRegOpenKey(&hSubKey, KeyBuf, GENERIC_READ); 736 Assert(Status == STATUS_SUCCESS);736 //Assert(Status == STATUS_SUCCESS); 737 737 if (Status == STATUS_SUCCESS) 738 738 { … … 856 856 HANDLE hKey; 857 857 NTSTATUS Status = vboxWddmRegOpenDisplaySettingsKey(pDeviceExtension, VidPnSourceId, &hKey); 858 Assert(Status == STATUS_SUCCESS);858 //Assert(Status == STATUS_SUCCESS); 859 859 if (Status == STATUS_SUCCESS) 860 860 { -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h
r51943 r52136 188 188 #endif 189 189 190 NTSTATUS vboxWddmChildStatusConnect(PVBOXMP_DEVEXT pDevExt, uint32_t iChild, BOOLEAN fConnect);191 192 190 #endif /* #ifndef ___VBoxMPMisc_h__ */ -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h
r51260 r52136 34 34 #include "VBoxMPVbva.h" 35 35 #include "VBoxMPCr.h" 36 #include "VBoxMPVModes.h" 36 37 37 38 #ifdef VBOX_WITH_CROGL 38 39 #include <cr_vreg.h> 39 40 #endif 41 42 #include <cr_sortarray.h> 40 43 41 44 #if 0 … … 336 339 } VBOXWDDM_OPENALLOCATION, *PVBOXWDDM_OPENALLOCATION; 337 340 338 #define VBOXWDDM_MAX_VIDEOMODES 128 339 typedef struct VBOXWDDM_VIDEOMODES_INFO 340 { 341 int32_t iPreferredMode; 342 uint32_t cModes; 343 VIDEO_MODE_INFORMATION aModes[VBOXWDDM_MAX_VIDEOMODES]; 344 int32_t iPreferredResolution; 345 uint32_t cResolutions; 346 D3DKMDT_2DREGION aResolutions[VBOXWDDM_MAX_VIDEOMODES]; 347 } VBOXWDDM_VIDEOMODES_INFO, *PVBOXWDDM_VIDEOMODES_INFO; 341 #define VBOX_VMODES_MAX_COUNT 128 342 343 typedef struct VBOX_VMODES 344 { 345 uint32_t cTargets; 346 CR_SORTARRAY aTargets[VBOX_VIDEO_MAX_SCREENS]; 347 } VBOX_VMODES; 348 349 typedef struct VBOXWDDM_VMODES 350 { 351 VBOX_VMODES Modes; 352 /* note that we not use array indices to indentify modes, because indices may change due to element removal */ 353 uint64_t aTransientResolutions[VBOX_VIDEO_MAX_SCREENS]; 354 uint64_t aPendingRemoveCurResolutions[VBOX_VIDEO_MAX_SCREENS]; 355 } VBOXWDDM_VMODES; 348 356 349 357 #endif /* #ifndef ___VBoxMPTypes_h___ */ -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.cpp
r51960 r52136 119 119 } 120 120 121 NTSTATUS vboxVidPnCheckSourceModeInfo(const D3DKMDT_HVIDPN hDesiredVidPn, 122 const D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo, 123 BOOLEAN *pbSupported) 124 { 125 BOOLEAN bSupported = TRUE; 126 /* we support both GRAPHICS and TEXT modes */ 127 switch (pNewVidPnSourceModeInfo->Type) 128 { 129 case D3DKMDT_RMT_GRAPHICS: 130 /* any primary surface size actually 131 pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx 132 pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy 133 */ 134 if (pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cx != pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx 135 || pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cy != pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy) 136 { 137 LOG(("VisibleRegionSize(%d, %d) != PrimSurfSize(%d, %d)", 138 pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cx, 139 pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cy, 140 pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx, 141 pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy)); 142 AssertBreakpoint(); 143 bSupported = FALSE; 144 break; 145 } 146 147 /* 148 pNewVidPnSourceModeInfo->Format.Graphics.Stride 149 pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat 150 pNewVidPnSourceModeInfo->Format.Graphics.ColorBasis 151 pNewVidPnSourceModeInfo->Format.Graphics.PixelValueAccessMode 152 */ 153 154 break; 155 case D3DKMDT_RMT_TEXT: 156 break; 157 default: 158 AssertBreakpoint(); 159 LOG(("Warning: Unknown Src mode Type (%d)", pNewVidPnSourceModeInfo->Type)); 160 break; 161 } 162 163 *pbSupported = bSupported; 164 return STATUS_SUCCESS; 165 } 166 167 NTSTATUS vboxVidPnCheckSourceModeSet(const D3DKMDT_HVIDPN hDesiredVidPn, 168 D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface, 169 BOOLEAN *pbSupported) 170 { 171 const D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo; 172 NTSTATUS Status = pVidPnSourceModeSetInterface->pfnAcquireFirstModeInfo(hNewVidPnSourceModeSet, &pNewVidPnSourceModeInfo); 173 BOOLEAN bSupported = TRUE; 174 if (Status == STATUS_SUCCESS) 175 { 176 while (1) 177 { 178 Status = vboxVidPnCheckSourceModeInfo(hDesiredVidPn, pNewVidPnSourceModeInfo, &bSupported); 179 if (Status == STATUS_SUCCESS && bSupported) 180 { 181 const D3DKMDT_VIDPN_SOURCE_MODE *pNextVidPnSourceModeInfo; 182 Status = pVidPnSourceModeSetInterface->pfnAcquireNextModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo, &pNextVidPnSourceModeInfo); 183 pVidPnSourceModeSetInterface->pfnReleaseModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo); 184 if (Status == STATUS_SUCCESS) 185 { 186 pNewVidPnSourceModeInfo = pNextVidPnSourceModeInfo; 187 } 188 else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET) 189 { 190 Status = STATUS_SUCCESS; 191 break; 192 } 193 else 194 { 195 LOGREL(("pfnAcquireNextModeInfo Failed Status(0x%x)", Status)); 196 break; 197 } 198 } 199 else 200 { 201 pVidPnSourceModeSetInterface->pfnReleaseModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo); 202 break; 203 } 204 } 205 } 206 else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY) 207 Status = STATUS_SUCCESS; 208 else 209 LOGREL(("pfnAcquireFirstModeInfo failed Status(0x%x)", Status)); 210 211 *pbSupported = bSupported; 212 return Status; 213 } 214 215 NTSTATUS vboxVidPnPopulateVideoSignalInfo(D3DKMDT_VIDEO_SIGNAL_INFO *pVsi, 216 D3DKMDT_2DREGION *pResolution, 121 static NTSTATUS vboxVidPnPopulateVideoSignalInfo(D3DKMDT_VIDEO_SIGNAL_INFO *pVsi, 122 const RTRECTSIZE *pResolution, 217 123 ULONG VSync) 218 124 { … … 220 126 221 127 pVsi->VideoStandard = D3DKMDT_VSS_OTHER; 222 pVsi->ActiveSize = *pResolution; 128 pVsi->ActiveSize.cx = pResolution->cx; 129 pVsi->ActiveSize.cy = pResolution->cy; 223 130 pVsi->VSyncFreq.Numerator = VSync * 1000; 224 131 pVsi->VSyncFreq.Denominator = 1000; … … 261 168 } 262 169 263 NTSTATUS vboxVidPnCheckTargetModeInfo(const D3DKMDT_HVIDPN hDesiredVidPn, 264 const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, 265 BOOLEAN *pbSupported) 266 { 267 BOOLEAN bSupported = TRUE; 268 D3DKMDT_VIDEO_SIGNAL_INFO CmpVsi; 269 D3DKMDT_2DREGION CmpRes; 270 CmpRes.cx = pNewVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cx; 271 CmpRes.cy = pNewVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy; 272 NTSTATUS Status = vboxVidPnPopulateVideoSignalInfo(&CmpVsi, 273 &CmpRes, 274 pNewVidPnTargetModeInfo->VideoSignalInfo.VSyncFreq.Numerator/pNewVidPnTargetModeInfo->VideoSignalInfo.VSyncFreq.Denominator); 275 Assert(Status == STATUS_SUCCESS); 276 if (Status != STATUS_SUCCESS) 277 { 278 LOGREL(("vboxVidPnPopulateVideoSignalInfo error Status (0x%x)", Status)); 279 return Status; 280 } 281 282 if (!vboxVidPnMatchVideoSignal(&CmpVsi, &pNewVidPnTargetModeInfo->VideoSignalInfo)) 283 { 284 WARN(("VideoSignalInfos do not match!!!")); 285 AssertBreakpoint(); 286 bSupported = FALSE; 287 } 288 289 *pbSupported = bSupported; 290 return STATUS_SUCCESS; 291 } 292 293 NTSTATUS vboxVidPnCheckTargetModeSet(const D3DKMDT_HVIDPN hDesiredVidPn, 294 D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface, 295 BOOLEAN *pbSupported) 296 { 297 const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo; 298 NTSTATUS Status = pVidPnTargetModeSetInterface->pfnAcquireFirstModeInfo(hNewVidPnTargetModeSet, &pNewVidPnTargetModeInfo); 299 BOOLEAN bSupported = TRUE; 300 if (Status == STATUS_SUCCESS) 301 { 302 Assert(pNewVidPnTargetModeInfo); 303 while (1) 304 { 305 Status = vboxVidPnCheckTargetModeInfo(hDesiredVidPn, pNewVidPnTargetModeInfo, &bSupported); 306 if (Status == STATUS_SUCCESS && bSupported) 307 { 308 const D3DKMDT_VIDPN_TARGET_MODE *pNextVidPnTargetModeInfo; 309 Status = pVidPnTargetModeSetInterface->pfnAcquireNextModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo, &pNextVidPnTargetModeInfo); 310 pVidPnTargetModeSetInterface->pfnReleaseModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo); 311 if (Status == STATUS_SUCCESS) 312 { 313 pNewVidPnTargetModeInfo = pNextVidPnTargetModeInfo; 314 } 315 else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET) 316 { 317 Status = STATUS_SUCCESS; 318 break; 319 } 320 else 321 { 322 LOGREL(("pfnAcquireNextModeInfo Failed Status(0x%x)", Status)); 323 break; 324 } 325 } 326 else 327 { 328 pVidPnTargetModeSetInterface->pfnReleaseModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo); 329 break; 330 } 331 } 332 } 333 else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY) 334 Status = STATUS_SUCCESS; 170 static void vboxVidPnPopulateSourceModeInfo(D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo, 171 const RTRECTSIZE *pSize) 172 { 173 NTSTATUS Status = STATUS_SUCCESS; 174 /* this is a graphics mode */ 175 pNewVidPnSourceModeInfo->Type = D3DKMDT_RMT_GRAPHICS; 176 pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx = pSize->cx; 177 pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy = pSize->cy; 178 pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize = pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize; 179 pNewVidPnSourceModeInfo->Format.Graphics.Stride = pSize->cx * 4; 180 pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat = D3DDDIFMT_A8R8G8B8; 181 Assert(pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat != D3DDDIFMT_UNKNOWN); 182 pNewVidPnSourceModeInfo->Format.Graphics.ColorBasis = D3DKMDT_CB_SRGB; 183 if (pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat == D3DDDIFMT_P8) 184 pNewVidPnSourceModeInfo->Format.Graphics.PixelValueAccessMode = D3DKMDT_PVAM_SETTABLEPALETTE; 335 185 else 336 LOGREL(("pfnAcquireFirstModeInfo failed Status(0x%x)", Status)); 337 338 *pbSupported = bSupported; 339 return Status; 340 } 341 342 NTSTATUS vboxVidPnPopulateSourceModeInfoFromLegacy(D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo, 343 VIDEO_MODE_INFORMATION *pMode) 344 { 345 NTSTATUS Status = STATUS_SUCCESS; 346 if (pMode->AttributeFlags & VIDEO_MODE_GRAPHICS) 347 { 348 /* this is a graphics mode */ 349 pNewVidPnSourceModeInfo->Type = D3DKMDT_RMT_GRAPHICS; 350 pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx = pMode->VisScreenWidth; 351 pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy = pMode->VisScreenHeight; 352 pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize = pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize; 353 pNewVidPnSourceModeInfo->Format.Graphics.Stride = pMode->ScreenStride; 354 pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat = vboxWddmCalcPixelFormat(pMode); 355 Assert(pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat != D3DDDIFMT_UNKNOWN); 356 if (pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat != D3DDDIFMT_UNKNOWN) 357 { 358 pNewVidPnSourceModeInfo->Format.Graphics.ColorBasis = D3DKMDT_CB_SRGB; 359 if (pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat == D3DDDIFMT_P8) 360 pNewVidPnSourceModeInfo->Format.Graphics.PixelValueAccessMode = D3DKMDT_PVAM_SETTABLEPALETTE; 361 else 362 pNewVidPnSourceModeInfo->Format.Graphics.PixelValueAccessMode = D3DKMDT_PVAM_DIRECT; 363 } 364 else 365 { 366 LOGREL(("vboxWddmCalcPixelFormat failed")); 367 Status = STATUS_INVALID_PARAMETER; 368 } 369 } 370 else 371 { 372 /* @todo: XPDM driver does not seem to return text modes, should we? */ 373 LOGREL(("text mode not supported currently")); 374 AssertBreakpoint(); 375 Status = STATUS_INVALID_PARAMETER; 376 } 377 378 return Status; 379 } 380 381 NTSTATUS vboxVidPnPopulateMonitorSourceModeInfoFromLegacy(PVBOXMP_DEVEXT pDevExt, 382 D3DKMDT_MONITOR_SOURCE_MODE *pMonitorSourceMode, 383 D3DKMDT_2DREGION *pResolution, 384 D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin, 385 BOOLEAN bPreferred) 386 { 387 NTSTATUS Status = vboxVidPnPopulateVideoSignalInfo(&pMonitorSourceMode->VideoSignalInfo, pResolution, 60 /* ULONG VSync */); 388 Assert(Status == STATUS_SUCCESS); 389 if (Status == STATUS_SUCCESS) 390 { 391 pMonitorSourceMode->ColorBasis = D3DKMDT_CB_SRGB; 392 pMonitorSourceMode->ColorCoeffDynamicRanges.FirstChannel = 8; 393 pMonitorSourceMode->ColorCoeffDynamicRanges.SecondChannel = 8; 394 pMonitorSourceMode->ColorCoeffDynamicRanges.ThirdChannel = 8; 395 pMonitorSourceMode->ColorCoeffDynamicRanges.FourthChannel = 0; 396 pMonitorSourceMode->Origin = enmOrigin; 397 pMonitorSourceMode->Preference = bPreferred ? D3DKMDT_MP_PREFERRED : D3DKMDT_MP_NOTPREFERRED; 398 } 399 400 return Status; 401 } 402 403 NTSTATUS vboxVidPnCreatePopulateMonitorSourceModeInfoFromLegacy(PVBOXMP_DEVEXT pDevExt, 404 CONST D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS, 405 CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf, 406 D3DKMDT_2DREGION *pResolution, 407 D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin, 408 BOOLEAN bPreferred) 409 { 410 D3DKMDT_MONITOR_SOURCE_MODE * pMonitorSMI; 411 NTSTATUS Status = pMonitorSMSIf->pfnCreateNewModeInfo(hMonitorSMS, &pMonitorSMI); 412 Assert(Status == STATUS_SUCCESS); 413 if (Status == STATUS_SUCCESS) 414 { 415 do 416 { 417 Status = vboxVidPnPopulateMonitorSourceModeInfoFromLegacy(pDevExt, 418 pMonitorSMI, 419 pResolution, 420 enmOrigin, 421 bPreferred); 422 Assert(Status == STATUS_SUCCESS); 423 if (Status == STATUS_SUCCESS) 424 { 425 Status = pMonitorSMSIf->pfnAddMode(hMonitorSMS, pMonitorSMI); 426 Assert(Status == STATUS_SUCCESS/* || Status == STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET*/); 427 if (Status == STATUS_SUCCESS) 428 break; 429 LOGREL(("pfnAddMode failed, Status(0x%x)", Status)); 430 } 431 else 432 LOGREL(("vboxVidPnPopulateMonitorSourceModeInfoFromLegacy failed, Status(0x%x)", Status)); 433 434 Assert (Status != STATUS_SUCCESS); 435 /* we're here because of a failure */ 436 NTSTATUS tmpStatus = pMonitorSMSIf->pfnReleaseModeInfo(hMonitorSMS, pMonitorSMI); 437 Assert(tmpStatus == STATUS_SUCCESS); 438 if (tmpStatus != STATUS_SUCCESS) 439 LOGREL(("pfnReleaseModeInfo failed tmpStatus(0x%x)", tmpStatus)); 440 441 if (Status == STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET) 442 Status = STATUS_SUCCESS; 443 } while (0); 444 } 445 else 446 LOGREL(("pfnCreateNewModeInfo failed, Status(0x%x)", Status)); 447 448 return Status; 449 } 450 451 NTSTATUS vboxVidPnPopulateTargetModeInfoFromLegacy(D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, D3DKMDT_2DREGION *pResolution, BOOLEAN fPreferred) 452 { 453 pNewVidPnTargetModeInfo->Preference = fPreferred ? D3DKMDT_MP_PREFERRED : D3DKMDT_MP_NOTPREFERRED; 186 pNewVidPnSourceModeInfo->Format.Graphics.PixelValueAccessMode = D3DKMDT_PVAM_DIRECT; 187 } 188 189 static void vboxVidPnPopulateMonitorModeInfo(D3DKMDT_MONITOR_SOURCE_MODE *pMonitorSourceMode, 190 const RTRECTSIZE *pResolution) 191 { 192 vboxVidPnPopulateVideoSignalInfo(&pMonitorSourceMode->VideoSignalInfo, pResolution, 60 /* ULONG VSync */); 193 pMonitorSourceMode->ColorBasis = D3DKMDT_CB_SRGB; 194 pMonitorSourceMode->ColorCoeffDynamicRanges.FirstChannel = 8; 195 pMonitorSourceMode->ColorCoeffDynamicRanges.SecondChannel = 8; 196 pMonitorSourceMode->ColorCoeffDynamicRanges.ThirdChannel = 8; 197 pMonitorSourceMode->ColorCoeffDynamicRanges.FourthChannel = 0; 198 pMonitorSourceMode->Origin = D3DKMDT_MCO_DRIVER; 199 pMonitorSourceMode->Preference = D3DKMDT_MP_NOTPREFERRED; 200 } 201 202 static NTSTATUS vboxVidPnPopulateTargetModeInfo(D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, const RTRECTSIZE *pResolution) 203 { 204 pNewVidPnTargetModeInfo->Preference = D3DKMDT_MP_NOTPREFERRED; 454 205 return vboxVidPnPopulateVideoSignalInfo(&pNewVidPnTargetModeInfo->VideoSignalInfo, pResolution, 60 /* ULONG VSync */); 455 206 } … … 598 349 } 599 350 600 typedef struct VBOXVIDPNCHECKADDMONITORMODES 601 { 351 352 static D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE vboxVidPnCofuncModalityCurrentPathPivot(D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmPivot, 353 const DXGK_ENUM_PIVOT *pPivot, 354 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 355 { 356 switch (enmPivot) 357 { 358 case D3DKMDT_EPT_VIDPNSOURCE: 359 if (pPivot->VidPnSourceId == VidPnSourceId) 360 return D3DKMDT_EPT_VIDPNSOURCE; 361 if (pPivot->VidPnSourceId == D3DDDI_ID_ALL) 362 { 363 #ifdef DEBUG_misha 364 AssertFailed(); 365 #endif 366 return D3DKMDT_EPT_VIDPNSOURCE; 367 } 368 return D3DKMDT_EPT_NOPIVOT; 369 case D3DKMDT_EPT_VIDPNTARGET: 370 if (pPivot->VidPnTargetId == VidPnTargetId) 371 return D3DKMDT_EPT_VIDPNTARGET; 372 if (pPivot->VidPnTargetId == D3DDDI_ID_ALL) 373 { 374 #ifdef DEBUG_misha 375 AssertFailed(); 376 #endif 377 return D3DKMDT_EPT_VIDPNTARGET; 378 } 379 return D3DKMDT_EPT_NOPIVOT; 380 case D3DKMDT_EPT_SCALING: 381 case D3DKMDT_EPT_ROTATION: 382 case D3DKMDT_EPT_NOPIVOT: 383 return D3DKMDT_EPT_NOPIVOT; 384 default: 385 WARN(("unexpected pivot")); 386 return D3DKMDT_EPT_NOPIVOT; 387 } 388 } 389 390 NTSTATUS vboxVidPnQueryPinnedTargetMode(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 391 D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, RTRECTSIZE *pSize) 392 { 393 D3DKMDT_HVIDPNTARGETMODESET hCurVidPnTargetModeSet; 394 const DXGK_VIDPNTARGETMODESET_INTERFACE *pCurVidPnTargetModeSetInterface; 395 pSize->cx = 0; 396 pSize->cy = 0; 397 NTSTATUS Status = pVidPnInterface->pfnAcquireTargetModeSet(hVidPn, 398 VidPnTargetId, 399 &hCurVidPnTargetModeSet, 400 &pCurVidPnTargetModeSetInterface); 401 if (!NT_SUCCESS(Status)) 402 { 403 WARN(("pfnAcquireTargetModeSet failed Status(0x%x)", Status)); 404 return Status; 405 } 406 407 CONST D3DKMDT_VIDPN_TARGET_MODE* pPinnedVidPnTargetModeInfo; 408 Status = pCurVidPnTargetModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnTargetModeSet, &pPinnedVidPnTargetModeInfo); 409 if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED) 410 { 411 pPinnedVidPnTargetModeInfo = NULL; 412 Status = STATUS_SUCCESS; 413 } 414 else if (!NT_SUCCESS(Status)) 415 { 416 WARN(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status)); 417 } 418 else 419 { 420 Assert(pPinnedVidPnTargetModeInfo); 421 pSize->cx = pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cx; 422 pSize->cy = pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy; 423 NTSTATUS tmpStatus = pCurVidPnTargetModeSetInterface->pfnReleaseModeInfo(hCurVidPnTargetModeSet, pPinnedVidPnTargetModeInfo); 424 Assert(NT_SUCCESS(tmpStatus)); 425 } 426 427 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hCurVidPnTargetModeSet); 428 Assert(tmpStatus == STATUS_SUCCESS); 429 430 return Status; 431 } 432 433 NTSTATUS vboxVidPnQueryPinnedSourceMode(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 434 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RTRECTSIZE *pSize) 435 { 436 D3DKMDT_HVIDPNSOURCEMODESET hCurVidPnSourceModeSet; 437 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pCurVidPnSourceModeSetInterface; 438 pSize->cx = 0; 439 pSize->cy = 0; 440 NTSTATUS Status = pVidPnInterface->pfnAcquireSourceModeSet(hVidPn, 441 VidPnSourceId, 442 &hCurVidPnSourceModeSet, 443 &pCurVidPnSourceModeSetInterface); 444 if (!NT_SUCCESS(Status)) 445 { 446 WARN(("pfnAcquireSourceModeSet failed Status(0x%x)", Status)); 447 return Status; 448 } 449 450 CONST D3DKMDT_VIDPN_SOURCE_MODE* pPinnedVidPnSourceModeInfo; 451 Status = pCurVidPnSourceModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnSourceModeSet, &pPinnedVidPnSourceModeInfo); 452 if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED) 453 { 454 pPinnedVidPnSourceModeInfo = NULL; 455 Status = STATUS_SUCCESS; 456 } 457 else if (!NT_SUCCESS(Status)) 458 { 459 WARN(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status)); 460 } 461 else 462 { 463 Assert(pPinnedVidPnSourceModeInfo); 464 pSize->cx = pPinnedVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cx; 465 pSize->cy = pPinnedVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cy; 466 NTSTATUS tmpStatus = pCurVidPnSourceModeSetInterface->pfnReleaseModeInfo(hCurVidPnSourceModeSet, pPinnedVidPnSourceModeInfo); 467 Assert(NT_SUCCESS(tmpStatus)); 468 } 469 470 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hCurVidPnSourceModeSet); 471 Assert(tmpStatus == STATUS_SUCCESS); 472 473 return Status; 474 } 475 476 static NTSTATUS vboxVidPnSourceModeSetToArray(D3DKMDT_HVIDPNSOURCEMODESET hVidPnModeSet, 477 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnModeSetInterface, 478 CR_SORTARRAY *pArray) 479 { 480 VBOXVIDPN_SOURCEMODE_ITER Iter; 481 const D3DKMDT_VIDPN_SOURCE_MODE *pVidPnModeInfo; 482 483 VBoxVidPnSourceModeIterInit(&Iter, hVidPnModeSet, pVidPnModeSetInterface); 484 485 while ((pVidPnModeInfo = VBoxVidPnSourceModeIterNext(&Iter)) != NULL) 486 { 487 RTRECTSIZE size; 488 size.cx = pVidPnModeInfo->Format.Graphics.VisibleRegionSize.cx; 489 size.cy = pVidPnModeInfo->Format.Graphics.VisibleRegionSize.cy; 490 int rc = CrSaAdd(pArray, CR_RSIZE2U64(size)); 491 if (RT_FAILURE(rc)) 492 { 493 WARN(("CrSaAdd failed %d", rc)); 494 VBoxVidPnSourceModeIterTerm(&Iter); 495 return STATUS_UNSUCCESSFUL; 496 } 497 } 498 499 VBoxVidPnSourceModeIterTerm(&Iter); 500 501 return VBoxVidPnSourceModeIterStatus(&Iter); 502 } 503 504 static NTSTATUS vboxVidPnSourceModeSetFromArray(D3DKMDT_HVIDPNSOURCEMODESET hVidPnModeSet, 505 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnModeSetInterface, 506 const CR_SORTARRAY *pArray) 507 { 508 for (uint32_t i = 0; i < CrSaGetSize(pArray); ++i) 509 { 510 RTRECTSIZE size = CR_U642RSIZE(CrSaGetVal(pArray, i)); 511 512 D3DKMDT_VIDPN_SOURCE_MODE *pVidPnModeInfo; 513 NTSTATUS Status = pVidPnModeSetInterface->pfnCreateNewModeInfo(hVidPnModeSet, &pVidPnModeInfo); 514 if (!NT_SUCCESS(Status)) 515 { 516 WARN(("pfnCreateNewModeInfo failed, Status 0x%x", Status)); 517 return Status; 518 } 519 520 vboxVidPnPopulateSourceModeInfo(pVidPnModeInfo, &size); 521 522 Status = pVidPnModeSetInterface->pfnAddMode(hVidPnModeSet, pVidPnModeInfo); 523 if (!NT_SUCCESS(Status)) 524 { 525 WARN(("pfnAddMode failed, Status 0x%x", Status)); 526 NTSTATUS tmpStatus = pVidPnModeSetInterface->pfnReleaseModeInfo(hVidPnModeSet, pVidPnModeInfo); 527 Assert(tmpStatus == STATUS_SUCCESS); 528 return Status; 529 } 530 } 531 532 return STATUS_SUCCESS; 533 } 534 535 static NTSTATUS vboxVidPnTargetModeSetToArray(D3DKMDT_HVIDPNTARGETMODESET hVidPnModeSet, 536 const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnModeSetInterface, 537 CR_SORTARRAY *pArray) 538 { 539 VBOXVIDPN_TARGETMODE_ITER Iter; 540 const D3DKMDT_VIDPN_TARGET_MODE *pVidPnModeInfo; 541 542 VBoxVidPnTargetModeIterInit(&Iter, hVidPnModeSet, pVidPnModeSetInterface); 543 544 while ((pVidPnModeInfo = VBoxVidPnTargetModeIterNext(&Iter)) != NULL) 545 { 546 RTRECTSIZE size; 547 size.cx = pVidPnModeInfo->VideoSignalInfo.ActiveSize.cx; 548 size.cy = pVidPnModeInfo->VideoSignalInfo.ActiveSize.cy; 549 int rc = CrSaAdd(pArray, CR_RSIZE2U64(size)); 550 if (RT_FAILURE(rc)) 551 { 552 WARN(("CrSaAdd failed %d", rc)); 553 VBoxVidPnTargetModeIterTerm(&Iter); 554 return STATUS_UNSUCCESSFUL; 555 } 556 } 557 558 VBoxVidPnTargetModeIterTerm(&Iter); 559 560 return VBoxVidPnTargetModeIterStatus(&Iter); 561 } 562 563 static NTSTATUS vboxVidPnTargetModeSetFromArray(D3DKMDT_HVIDPNTARGETMODESET hVidPnModeSet, 564 const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnModeSetInterface, 565 const CR_SORTARRAY *pArray) 566 { 567 for (uint32_t i = 0; i < CrSaGetSize(pArray); ++i) 568 { 569 RTRECTSIZE size = CR_U642RSIZE(CrSaGetVal(pArray, i)); 570 571 D3DKMDT_VIDPN_TARGET_MODE *pVidPnModeInfo; 572 NTSTATUS Status = pVidPnModeSetInterface->pfnCreateNewModeInfo(hVidPnModeSet, &pVidPnModeInfo); 573 if (!NT_SUCCESS(Status)) 574 { 575 WARN(("pfnCreateNewModeInfo failed, Status 0x%x", Status)); 576 return Status; 577 } 578 579 vboxVidPnPopulateTargetModeInfo(pVidPnModeInfo, &size); 580 581 Status = pVidPnModeSetInterface->pfnAddMode(hVidPnModeSet, pVidPnModeInfo); 582 if (!NT_SUCCESS(Status)) 583 { 584 WARN(("pfnAddMode failed, Status 0x%x", Status)); 585 NTSTATUS tmpStatus = pVidPnModeSetInterface->pfnReleaseModeInfo(hVidPnModeSet, pVidPnModeInfo); 586 Assert(tmpStatus == STATUS_SUCCESS); 587 return Status; 588 } 589 } 590 591 return STATUS_SUCCESS; 592 } 593 594 static NTSTATUS vboxVidPnMonitorModeSetToArray(D3DKMDT_HMONITORSOURCEMODESET hVidPnModeSet, 595 const DXGK_MONITORSOURCEMODESET_INTERFACE *pVidPnModeSetInterface, 596 CR_SORTARRAY *pArray) 597 { 598 VBOXVIDPN_MONITORMODE_ITER Iter; 599 const D3DKMDT_MONITOR_SOURCE_MODE *pVidPnModeInfo; 600 601 VBoxVidPnMonitorModeIterInit(&Iter, hVidPnModeSet, pVidPnModeSetInterface); 602 603 while ((pVidPnModeInfo = VBoxVidPnMonitorModeIterNext(&Iter)) != NULL) 604 { 605 RTRECTSIZE size; 606 size.cx = pVidPnModeInfo->VideoSignalInfo.ActiveSize.cx; 607 size.cy = pVidPnModeInfo->VideoSignalInfo.ActiveSize.cy; 608 int rc = CrSaAdd(pArray, CR_RSIZE2U64(size)); 609 if (RT_FAILURE(rc)) 610 { 611 WARN(("CrSaAdd failed %d", rc)); 612 VBoxVidPnMonitorModeIterTerm(&Iter); 613 return STATUS_UNSUCCESSFUL; 614 } 615 } 616 617 VBoxVidPnMonitorModeIterTerm(&Iter); 618 619 return VBoxVidPnMonitorModeIterStatus(&Iter); 620 } 621 622 static NTSTATUS vboxVidPnMonitorModeSetFromArray(D3DKMDT_HMONITORSOURCEMODESET hVidPnModeSet, 623 const DXGK_MONITORSOURCEMODESET_INTERFACE *pVidPnModeSetInterface, 624 const CR_SORTARRAY *pArray) 625 { 626 for (uint32_t i = 0; i < CrSaGetSize(pArray); ++i) 627 { 628 RTRECTSIZE size = CR_U642RSIZE(CrSaGetVal(pArray, i)); 629 630 D3DKMDT_MONITOR_SOURCE_MODE *pVidPnModeInfo; 631 NTSTATUS Status = pVidPnModeSetInterface->pfnCreateNewModeInfo(hVidPnModeSet, &pVidPnModeInfo); 632 if (!NT_SUCCESS(Status)) 633 { 634 WARN(("pfnCreateNewModeInfo failed, Status 0x%x", Status)); 635 return Status; 636 } 637 638 vboxVidPnPopulateMonitorModeInfo(pVidPnModeInfo, &size); 639 640 Status = pVidPnModeSetInterface->pfnAddMode(hVidPnModeSet, pVidPnModeInfo); 641 if (!NT_SUCCESS(Status)) 642 { 643 WARN(("pfnAddMode failed, Status 0x%x", Status)); 644 NTSTATUS tmpStatus = pVidPnModeSetInterface->pfnReleaseModeInfo(hVidPnModeSet, pVidPnModeInfo); 645 Assert(tmpStatus == STATUS_SUCCESS); 646 return Status; 647 } 648 } 649 650 return STATUS_SUCCESS; 651 } 652 653 654 static NTSTATUS vboxVidPnCollectInfoForPathTarget(PVBOXMP_DEVEXT pDevExt, 655 D3DKMDT_HVIDPN hVidPn, 656 const DXGK_VIDPN_INTERFACE* pVidPnInterface, 657 D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmCurPivot, 658 uint32_t *aAdjustedModeMap, 659 CR_SORTARRAY *aModes, 660 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 661 { 662 const CR_SORTARRAY* pSupportedModes = VBoxWddmVModesGet(pDevExt, VidPnTargetId); 602 663 NTSTATUS Status; 603 D3DKMDT_2DREGION *pResolutions; 604 uint32_t cResolutions; 605 } VBOXVIDPNCHECKADDMONITORMODES, *PVBOXVIDPNCHECKADDMONITORMODES; 606 607 static DECLCALLBACK(BOOLEAN) vboxVidPnCheckAddMonitorModesEnum(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS, CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf, 608 CONST D3DKMDT_MONITOR_SOURCE_MODE *pMonitorSMI, PVOID pContext) 609 { 610 PVBOXVIDPNCHECKADDMONITORMODES pData = (PVBOXVIDPNCHECKADDMONITORMODES)pContext; 611 NTSTATUS Status = STATUS_SUCCESS; 612 613 for (uint32_t i = 0; i < pData->cResolutions; ++i) 614 { 615 D3DKMDT_VIDPN_TARGET_MODE dummyMode = {0}; 616 Status = vboxVidPnPopulateTargetModeInfoFromLegacy(&dummyMode, &pData->pResolutions[i], FALSE /* preference does not matter for now */); 617 Assert(Status == STATUS_SUCCESS); 618 if (Status == STATUS_SUCCESS) 619 { 620 if (vboxVidPnMatchVideoSignal(&dummyMode.VideoSignalInfo, &pMonitorSMI->VideoSignalInfo)) 621 { 622 /* mark it as unneeded */ 623 pData->pResolutions[i].cx = 0; 624 break; 625 } 664 if (enmCurPivot == D3DKMDT_EPT_VIDPNTARGET) 665 { 666 D3DKMDT_HVIDPNTARGETMODESET hVidPnModeSet; 667 const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnModeSetInterface; 668 Status = pVidPnInterface->pfnAcquireTargetModeSet(hVidPn, 669 VidPnTargetId, 670 &hVidPnModeSet, 671 &pVidPnModeSetInterface); 672 if (!NT_SUCCESS(Status)) 673 { 674 WARN(("pfnAcquireTargetModeSet failed %#x", Status)); 675 return Status; 676 } 677 678 /* intersect modes from target */ 679 if (!ASMBitTest(aAdjustedModeMap, VidPnTargetId)) 680 { 681 Status = vboxVidPnTargetModeSetToArray(hVidPnModeSet, pVidPnModeSetInterface, &aModes[VidPnTargetId]); 682 ASMBitSet(aAdjustedModeMap, VidPnTargetId); 626 683 } 627 684 else 628 685 { 629 LOGREL(("vboxVidPnPopulateTargetModeInfoFromLegacy failed Status(0x%x)", Status)); 630 break; 631 } 632 } 633 634 pMonitorSMSIf->pfnReleaseModeInfo(hMonitorSMS, pMonitorSMI); 635 636 pData->Status = Status; 637 638 return Status == STATUS_SUCCESS; 639 } 640 641 typedef struct VBOXVIDPNCHECKMONMODESENUM 642 { 643 D3DKMDT_2DREGION Region; 644 const D3DKMDT_MONITOR_SOURCE_MODE * pMonitorSMI; 645 } VBOXVIDPNCHECKMONMODESENUM, *PVBOXVIDPNCHECKMONMODESENUM; 646 647 static DECLCALLBACK(BOOLEAN) vboxFidPnCheckMonitorModesEnum(D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS, CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf, 648 CONST D3DKMDT_MONITOR_SOURCE_MODE *pMonitorSMI, PVOID pContext) 649 { 650 PVBOXVIDPNCHECKMONMODESENUM pInfo = (PVBOXVIDPNCHECKMONMODESENUM)pContext; 651 if (pMonitorSMI->VideoSignalInfo.ActiveSize.cx == pInfo->Region.cx 652 && pMonitorSMI->VideoSignalInfo.ActiveSize.cy == pInfo->Region.cy) 653 { 654 Assert(!pInfo->pMonitorSMI); 655 if (pInfo->pMonitorSMI) 656 { 657 pMonitorSMSIf->pfnReleaseModeInfo(hMonitorSMS, pInfo->pMonitorSMI); 658 } 659 pInfo->pMonitorSMI = pMonitorSMI; 686 CR_SORTARRAY Arr; 687 CrSaInit(&Arr, 0); 688 Status = vboxVidPnTargetModeSetToArray(hVidPnModeSet, pVidPnModeSetInterface, &aModes[VidPnTargetId]); 689 CrSaIntersect(&aModes[VidPnTargetId], &Arr); 690 CrSaCleanup(&Arr); 691 } 692 693 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hVidPnModeSet); 694 Assert(tmpStatus == STATUS_SUCCESS); 695 696 if (!NT_SUCCESS(Status)) 697 { 698 WARN(("vboxVidPnTargetModeSetToArray failed %#x", Status)); 699 return Status; 700 } 701 702 return STATUS_SUCCESS; 703 } 704 705 RTRECTSIZE pinnedSize = {0}; 706 Status = vboxVidPnQueryPinnedTargetMode(hVidPn, pVidPnInterface, VidPnTargetId, &pinnedSize); 707 if (!NT_SUCCESS(Status)) 708 { 709 WARN(("vboxVidPnQueryPinnedTargetMode failed %#x", Status)); 710 return Status; 711 } 712 713 if (pinnedSize.cx) 714 { 715 Assert(CrSaContains(pSupportedModes, CR_RSIZE2U64(pinnedSize))); 716 717 if (!ASMBitTest(aAdjustedModeMap, VidPnTargetId)) 718 { 719 Assert(CrSaGetSize(&aModes[VidPnTargetId]) == 0); 720 int rc = CrSaAdd(&aModes[VidPnTargetId], CR_RSIZE2U64(pinnedSize)); 721 if (!RT_SUCCESS(rc)) 722 { 723 WARN(("CrSaAdd failed %d", rc)); 724 return STATUS_UNSUCCESSFUL; 725 } 726 ASMBitSet(aAdjustedModeMap, VidPnTargetId); 727 } 728 else 729 { 730 CrSaClear(&aModes[VidPnTargetId]); 731 int rc = CrSaAdd(&aModes[VidPnTargetId], CR_RSIZE2U64(pinnedSize)); 732 if (!RT_SUCCESS(rc)) 733 { 734 WARN(("CrSaAdd failed %d", rc)); 735 return STATUS_UNSUCCESSFUL; 736 } 737 } 738 739 return STATUS_SUCCESS; 740 } 741 742 743 Status = vboxVidPnQueryPinnedSourceMode(hVidPn, pVidPnInterface, VidPnSourceId, &pinnedSize); 744 if (!NT_SUCCESS(Status)) 745 { 746 WARN(("vboxVidPnQueryPinnedSourceMode failed %#x", Status)); 747 return Status; 748 } 749 750 if (pinnedSize.cx) 751 { 752 if (!ASMBitTest(aAdjustedModeMap, VidPnTargetId)) 753 { 754 Assert(CrSaGetSize(&aModes[VidPnTargetId]) == 0); 755 if (CrSaContains(pSupportedModes, CR_RSIZE2U64(pinnedSize))) 756 { 757 int rc = CrSaAdd(&aModes[VidPnTargetId], CR_RSIZE2U64(pinnedSize)); 758 if (!RT_SUCCESS(rc)) 759 { 760 WARN(("CrSaAdd failed %d", rc)); 761 return STATUS_UNSUCCESSFUL; 762 } 763 } 764 ASMBitSet(aAdjustedModeMap, VidPnTargetId); 765 } 766 else 767 { 768 CrSaClear(&aModes[VidPnTargetId]); 769 if (CrSaContains(pSupportedModes, CR_RSIZE2U64(pinnedSize))) 770 { 771 int rc = CrSaAdd(&aModes[VidPnTargetId], CR_RSIZE2U64(pinnedSize)); 772 if (!RT_SUCCESS(rc)) 773 { 774 WARN(("CrSaAdd failed %d", rc)); 775 return STATUS_UNSUCCESSFUL; 776 } 777 } 778 } 779 780 return STATUS_SUCCESS; 781 } 782 783 /* now we are here because no pinned info is specified, we need to populate it based on the supported info 784 * and modes already configured, 785 * this is pretty simple actually */ 786 787 if (!ASMBitTest(aAdjustedModeMap, VidPnTargetId)) 788 { 789 Assert(CrSaGetSize(&aModes[VidPnTargetId]) == 0); 790 int rc = CrSaClone(pSupportedModes, &aModes[VidPnTargetId]); 791 if (!RT_SUCCESS(rc)) 792 { 793 WARN(("CrSaClone failed %d", rc)); 794 return STATUS_UNSUCCESSFUL; 795 } 796 ASMBitSet(aAdjustedModeMap, VidPnTargetId); 660 797 } 661 798 else 662 799 { 663 pMonitorSMSIf->pfnReleaseModeInfo(hMonitorSMS, pMonitorSMI); 664 } 665 return TRUE; 666 } 667 668 typedef struct VBOXVIDPNMATCHMONMODESENUM 669 { 670 D3DKMDT_2DREGION *paResolutions; 671 uint32_t cResolutions; 672 BOOLEAN fMatched; 673 } VBOXVIDPNMATCHMONMODESENUM, *PVBOXVIDPNMATCHMONMODESENUM; 674 675 static DECLCALLBACK(BOOLEAN) vboxFidPnMatchMonitorModesEnum(D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS, CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf, 676 CONST D3DKMDT_MONITOR_SOURCE_MODE *pMonitorSMI, PVOID pContext) 677 { 678 PVBOXVIDPNMATCHMONMODESENUM pInfo = (PVBOXVIDPNMATCHMONMODESENUM)pContext; 679 680 Assert(pInfo->fMatched); 681 682 BOOLEAN fFound = FALSE; 683 684 for (UINT i = 0; i < pInfo->cResolutions; ++i) 685 { 686 D3DKMDT_2DREGION *pResolution = &pInfo->paResolutions[i]; 687 if (pMonitorSMI->VideoSignalInfo.ActiveSize.cx == pResolution->cx 688 && pMonitorSMI->VideoSignalInfo.ActiveSize.cy == pResolution->cy) 689 { 690 fFound = TRUE; 691 break; 692 } 693 } 694 695 if (!fFound) 696 pInfo->fMatched = FALSE; 697 698 if (!pInfo->fMatched) 699 LOG(("Found non-matching mode (%d X %d)", 700 pMonitorSMI->VideoSignalInfo.ActiveSize.cx, pMonitorSMI->VideoSignalInfo.ActiveSize.cy)); 701 702 pMonitorSMSIf->pfnReleaseModeInfo(hMonitorSMS, pMonitorSMI); 703 704 return pInfo->fMatched; 705 } 706 707 /* matches the monitor mode set for the given target id with the resolution set, and sets the pfMatch to true if they match, otherwise sets it to false */ 708 NTSTATUS vboxVidPnMatchMonitorModes(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID targetId, 709 D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions, BOOLEAN *pfMatch) 710 { 711 *pfMatch = FALSE; 712 CONST DXGK_MONITOR_INTERFACE *pMonitorInterface; 713 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryMonitorInterface(pDevExt->u.primary.DxgkInterface.DeviceHandle, DXGK_MONITOR_INTERFACE_VERSION_V1, &pMonitorInterface); 714 if (!NT_SUCCESS(Status)) 715 { 716 WARN(("DxgkCbQueryMonitorInterface failed, Status (0x%x)", Status)); 800 CrSaIntersect(&aModes[VidPnTargetId], pSupportedModes); 801 } 802 803 /* we are done */ 804 return STATUS_SUCCESS; 805 } 806 807 static NTSTATUS vboxVidPnApplyInfoForPathTarget(PVBOXMP_DEVEXT pDevExt, 808 D3DKMDT_HVIDPN hVidPn, 809 const DXGK_VIDPN_INTERFACE* pVidPnInterface, 810 D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmCurPivot, 811 uint32_t *aAdjustedModeMap, 812 const CR_SORTARRAY *aModes, 813 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 814 { 815 Assert(ASMBitTest(aAdjustedModeMap, VidPnTargetId)); 816 817 if (enmCurPivot == D3DKMDT_EPT_VIDPNTARGET) 818 return STATUS_SUCCESS; 819 820 RTRECTSIZE pinnedSize = {0}; 821 NTSTATUS Status = vboxVidPnQueryPinnedTargetMode(hVidPn, pVidPnInterface, VidPnTargetId, &pinnedSize); 822 if (!NT_SUCCESS(Status)) 823 { 824 WARN(("vboxVidPnQueryPinnedTargetMode failed %#x", Status)); 717 825 return Status; 718 826 } 719 827 720 D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS; 721 CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf; 722 Status = pMonitorInterface->pfnAcquireMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle, 723 targetId, 724 &hMonitorSMS, 725 &pMonitorSMSIf); 726 if (!NT_SUCCESS(Status)) 727 { 728 WARN(("pfnAcquireMonitorSourceModeSet failed, Status (0x%x)", Status)); 729 if (Status == STATUS_GRAPHICS_MONITOR_NOT_CONNECTED) 730 { 731 /* this is ok in case we replug the monitor to pick up the monitor modes properly, 732 * so pretend success */ 733 *pfMatch = TRUE; 734 Status = STATUS_SUCCESS; 735 } 828 if (pinnedSize.cx) 829 return STATUS_SUCCESS; 830 831 /* now just create the new source mode set and apply it */ 832 D3DKMDT_HVIDPNTARGETMODESET hVidPnModeSet; 833 const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnModeSetInterface; 834 Status = pVidPnInterface->pfnCreateNewTargetModeSet(hVidPn, 835 VidPnTargetId, 836 &hVidPnModeSet, 837 &pVidPnModeSetInterface); 838 if (!NT_SUCCESS(Status)) 839 { 840 WARN(("pfnCreateNewTargetModeSet failed Status(0x%x)", Status)); 736 841 return Status; 737 842 } 738 843 739 /* we care only about monitor modes covering all needed resolutions, 740 * we do NOT care if resolutions do not cover some monitor modes */ 741 SIZE_T cModes = 0; 742 Status = pMonitorSMSIf->pfnGetNumModes(hMonitorSMS, &cModes); 743 if (NT_SUCCESS(Status)) 744 { 745 if (cModes < cResolutions) 746 { 747 *pfMatch = FALSE; 748 LOG(("num modes(%d) and resolutions(%d) do not match, treat as not matched..", cModes, cResolutions)); 844 Status = vboxVidPnTargetModeSetFromArray(hVidPnModeSet, 845 pVidPnModeSetInterface, 846 &aModes[VidPnTargetId]); 847 if (!NT_SUCCESS(Status)) 848 { 849 WARN(("vboxVidPnTargetModeSetFromArray failed Status(0x%x)", Status)); 850 return Status; 851 } 852 853 Status = pVidPnInterface->pfnAssignTargetModeSet(hVidPn, VidPnTargetId, hVidPnModeSet); 854 if (!NT_SUCCESS(Status)) 855 { 856 WARN(("\n\n!!!!!!!\n\n pfnAssignTargetModeSet failed, Status(0x%x)", Status)); 857 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hVidPnModeSet); 858 Assert(tmpStatus == STATUS_SUCCESS); 859 return Status; 860 } 861 862 return STATUS_SUCCESS; 863 } 864 865 static NTSTATUS vboxVidPnApplyInfoForPathSource(PVBOXMP_DEVEXT pDevExt, 866 D3DKMDT_HVIDPN hVidPn, 867 const DXGK_VIDPN_INTERFACE* pVidPnInterface, 868 D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmCurPivot, 869 uint32_t *aAdjustedModeMap, 870 const CR_SORTARRAY *aModes, 871 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 872 { 873 Assert(ASMBitTest(aAdjustedModeMap, VidPnTargetId)); 874 875 if (enmCurPivot == D3DKMDT_EPT_VIDPNSOURCE) 876 return STATUS_SUCCESS; 877 878 RTRECTSIZE pinnedSize = {0}; 879 NTSTATUS Status = vboxVidPnQueryPinnedSourceMode(hVidPn, pVidPnInterface, VidPnSourceId, &pinnedSize); 880 if (!NT_SUCCESS(Status)) 881 { 882 WARN(("vboxVidPnQueryPinnedSourceMode failed %#x", Status)); 883 return Status; 884 } 885 886 if (pinnedSize.cx) 887 return STATUS_SUCCESS; 888 889 /* now just create the new source mode set and apply it */ 890 D3DKMDT_HVIDPNSOURCEMODESET hVidPnModeSet; 891 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnModeSetInterface; 892 Status = pVidPnInterface->pfnCreateNewSourceModeSet(hVidPn, 893 VidPnSourceId, 894 &hVidPnModeSet, 895 &pVidPnModeSetInterface); 896 if (!NT_SUCCESS(Status)) 897 { 898 WARN(("pfnCreateNewSourceModeSet failed Status(0x%x)", Status)); 899 return Status; 900 } 901 902 Status = vboxVidPnSourceModeSetFromArray(hVidPnModeSet, 903 pVidPnModeSetInterface, 904 &aModes[VidPnTargetId]); /* <- target modes always! */ 905 if (!NT_SUCCESS(Status)) 906 { 907 WARN(("vboxVidPnSourceModeSetFromArray failed Status(0x%x)", Status)); 908 return Status; 909 } 910 911 Status = pVidPnInterface->pfnAssignSourceModeSet(hVidPn, VidPnSourceId, hVidPnModeSet); 912 if (!NT_SUCCESS(Status)) 913 { 914 WARN(("\n\n!!!!!!!\n\n pfnAssignSourceModeSet failed, Status(0x%x)", Status)); 915 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hVidPnModeSet); 916 Assert(tmpStatus == STATUS_SUCCESS); 917 return Status; 918 } 919 920 return STATUS_SUCCESS; 921 } 922 923 static NTSTATUS vboxVidPnCollectInfoForPathSource(PVBOXMP_DEVEXT pDevExt, 924 D3DKMDT_HVIDPN hVidPn, 925 const DXGK_VIDPN_INTERFACE* pVidPnInterface, 926 D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmCurPivot, 927 uint32_t *aAdjustedModeMap, 928 CR_SORTARRAY *aModes, 929 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 930 { 931 const CR_SORTARRAY* pSupportedModes = VBoxWddmVModesGet(pDevExt, VidPnTargetId); /* <- yes, modes are target-determined always */ 932 NTSTATUS Status; 933 934 if (enmCurPivot == D3DKMDT_EPT_VIDPNSOURCE) 935 { 936 D3DKMDT_HVIDPNSOURCEMODESET hVidPnModeSet; 937 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnModeSetInterface; 938 Status = pVidPnInterface->pfnAcquireSourceModeSet(hVidPn, 939 VidPnSourceId, 940 &hVidPnModeSet, 941 &pVidPnModeSetInterface); 942 if (!NT_SUCCESS(Status)) 943 { 944 WARN(("pfnAcquireSourceModeSet failed %#x", Status)); 945 return Status; 946 } 947 948 /* intersect modes from target */ 949 if (!ASMBitTest(aAdjustedModeMap, VidPnTargetId)) 950 { 951 Status = vboxVidPnSourceModeSetToArray(hVidPnModeSet, pVidPnModeSetInterface, &aModes[VidPnTargetId]); 952 ASMBitSet(aAdjustedModeMap, VidPnTargetId); 749 953 } 750 954 else 751 955 { 752 VBOXVIDPNMATCHMONMODESENUM Info; 753 Info.paResolutions = pResolutions; 754 Info.cResolutions = cResolutions; 755 Info.fMatched = TRUE; 756 757 Status = vboxVidPnEnumMonitorSourceModes(hMonitorSMS, pMonitorSMSIf, vboxFidPnMatchMonitorModesEnum, &Info); 758 if (NT_SUCCESS(Status)) 759 { 760 *pfMatch = Info.fMatched; 761 LOG(("modes %smatched", Info.fMatched ? "" : "NOT ")); 762 } 763 else 764 WARN(("vboxVidPnEnumMonitorSourceModes failed, Status 0x%x", Status)); 765 } 956 CR_SORTARRAY Arr; 957 CrSaInit(&Arr, 0); 958 Status = vboxVidPnSourceModeSetToArray(hVidPnModeSet, pVidPnModeSetInterface, &aModes[VidPnTargetId]); 959 CrSaIntersect(&aModes[VidPnTargetId], &Arr); 960 CrSaCleanup(&Arr); 961 } 962 963 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hVidPnModeSet); 964 Assert(tmpStatus == STATUS_SUCCESS); 965 966 if (!NT_SUCCESS(Status)) 967 { 968 WARN(("pfnReleaseSourceModeSet failed %#x", Status)); 969 return Status; 970 } 971 972 /* intersect it with supported target modes, just in case */ 973 CrSaIntersect(&aModes[VidPnTargetId], pSupportedModes); 974 975 return STATUS_SUCCESS; 976 } 977 978 RTRECTSIZE pinnedSize = {0}; 979 Status = vboxVidPnQueryPinnedSourceMode(hVidPn, pVidPnInterface, VidPnSourceId, &pinnedSize); 980 if (!NT_SUCCESS(Status)) 981 { 982 WARN(("vboxVidPnQueryPinnedSourceMode failed %#x", Status)); 983 return Status; 984 } 985 986 if (pinnedSize.cx) 987 { 988 Assert(CrSaContains(pSupportedModes, CR_RSIZE2U64(pinnedSize))); 989 990 if (!ASMBitTest(aAdjustedModeMap, VidPnTargetId)) 991 { 992 Assert(CrSaGetSize(&aModes[VidPnTargetId]) == 0); 993 994 if (CrSaContains(pSupportedModes, CR_RSIZE2U64(pinnedSize))) 995 { 996 int rc = CrSaAdd(&aModes[VidPnTargetId], CR_RSIZE2U64(pinnedSize)); 997 if (!RT_SUCCESS(rc)) 998 { 999 WARN(("CrSaAdd failed %d", rc)); 1000 return STATUS_UNSUCCESSFUL; 1001 } 1002 } 1003 ASMBitSet(aAdjustedModeMap, VidPnTargetId); 1004 } 1005 else 1006 { 1007 CrSaClear(&aModes[VidPnTargetId]); 1008 if (CrSaContains(pSupportedModes, CR_RSIZE2U64(pinnedSize))) 1009 { 1010 int rc = CrSaAdd(&aModes[VidPnTargetId], CR_RSIZE2U64(pinnedSize)); 1011 if (!RT_SUCCESS(rc)) 1012 { 1013 WARN(("CrSaAdd failed %d", rc)); 1014 return STATUS_UNSUCCESSFUL; 1015 } 1016 } 1017 } 1018 1019 return STATUS_SUCCESS; 1020 } 1021 1022 1023 Status = vboxVidPnQueryPinnedTargetMode(hVidPn, pVidPnInterface, VidPnTargetId, &pinnedSize); 1024 if (!NT_SUCCESS(Status)) 1025 { 1026 WARN(("vboxVidPnQueryPinnedTargetMode failed %#x", Status)); 1027 return Status; 1028 } 1029 1030 if (pinnedSize.cx) 1031 { 1032 Assert(CrSaContains(pSupportedModes, CR_RSIZE2U64(pinnedSize))); 1033 1034 if (!ASMBitTest(aAdjustedModeMap, VidPnTargetId)) 1035 { 1036 Assert(CrSaGetSize(&aModes[VidPnTargetId]) == 0); 1037 int rc = CrSaAdd(&aModes[VidPnTargetId], CR_RSIZE2U64(pinnedSize)); 1038 if (!RT_SUCCESS(rc)) 1039 { 1040 WARN(("CrSaAdd failed %d", rc)); 1041 return STATUS_UNSUCCESSFUL; 1042 } 1043 ASMBitSet(aAdjustedModeMap, VidPnTargetId); 1044 } 1045 else 1046 { 1047 CrSaClear(&aModes[VidPnTargetId]); 1048 int rc = CrSaAdd(&aModes[VidPnTargetId], CR_RSIZE2U64(pinnedSize)); 1049 if (!RT_SUCCESS(rc)) 1050 { 1051 WARN(("CrSaAdd failed %d", rc)); 1052 return STATUS_UNSUCCESSFUL; 1053 } 1054 } 1055 1056 return STATUS_SUCCESS; 1057 } 1058 1059 /* now we are here because no pinned info is specified, we need to populate it based on the supported info 1060 * and modes already configured, 1061 * this is pretty simple actually */ 1062 1063 if (!ASMBitTest(aAdjustedModeMap, VidPnTargetId)) 1064 { 1065 Assert(CrSaGetSize(&aModes[VidPnTargetId]) == 0); 1066 int rc = CrSaClone(pSupportedModes, &aModes[VidPnTargetId]); 1067 if (!RT_SUCCESS(rc)) 1068 { 1069 WARN(("CrSaClone failed %d", rc)); 1070 return STATUS_UNSUCCESSFUL; 1071 } 1072 ASMBitSet(aAdjustedModeMap, VidPnTargetId); 766 1073 } 767 1074 else 768 WARN(("pfnGetNumModes failed, Status 0x%x", Status)); 769 770 NTSTATUS tmpStatus = pMonitorInterface->pfnReleaseMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle, hMonitorSMS); 771 if (!NT_SUCCESS(tmpStatus)) 772 WARN(("pfnReleaseMonitorSourceModeSet failed tmpStatus(0x%x)", tmpStatus)); 773 774 return Status; 775 } 776 777 NTSTATUS vboxVidPnCheckAddMonitorModes(PVBOXMP_DEVEXT pDevExt, 778 D3DDDI_VIDEO_PRESENT_TARGET_ID targetId, D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin, 779 D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions, int iPreferred) 1075 { 1076 CrSaIntersect(&aModes[VidPnTargetId], pSupportedModes); 1077 } 1078 1079 /* we are done */ 1080 return STATUS_SUCCESS; 1081 } 1082 1083 static NTSTATUS vboxVidPnCheckMonitorModes(PVBOXMP_DEVEXT pDevExt, uint32_t u32Target) 780 1084 { 781 1085 NTSTATUS Status; … … 788 1092 } 789 1093 790 D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS; 791 CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf; 1094 D3DKMDT_HMONITORSOURCEMODESET hVidPnModeSet; 1095 CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pVidPnModeSetInterface; 1096 1097 const CR_SORTARRAY *pSupportedModes = VBoxWddmVModesGet(pDevExt, u32Target); 1098 CR_SORTARRAY DiffModes; 1099 int rc = CrSaInit(&DiffModes, CrSaGetSize(pSupportedModes)); 1100 if (!RT_SUCCESS(rc)) 1101 { 1102 WARN(("CrSaInit failed")); 1103 return STATUS_NO_MEMORY; 1104 } 1105 792 1106 793 1107 Status = pMonitorInterface->pfnAcquireMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle, 794 targetId,795 &h MonitorSMS,796 &p MonitorSMSIf);1108 u32Target, 1109 &hVidPnModeSet, 1110 &pVidPnModeSetInterface); 797 1111 if (!NT_SUCCESS(Status)) 798 1112 { 799 1113 WARN(("DxgkCbQueryMonitorInterface failed, Status()0x%x", Status)); 800 if (Status == STATUS_GRAPHICS_MONITOR_NOT_CONNECTED) 801 { 802 /* this is ok in case we replug the monitor to pick up the monitor modes properly, 803 * so pretend success */ 804 Status = STATUS_SUCCESS; 805 } 1114 // if (Status == STATUS_GRAPHICS_MONITOR_NOT_CONNECTED) 1115 CrSaCleanup(&DiffModes); 806 1116 return Status; 807 1117 } 808 1118 809 for (uint32_t i = 0; i < cResolutions; ++i) 810 { 811 D3DKMDT_2DREGION *pRes = &pResolutions[i]; 812 813 Status = vboxVidPnCreatePopulateMonitorSourceModeInfoFromLegacy(pDevExt, 814 hMonitorSMS, 815 pMonitorSMSIf, 816 pRes, 817 enmOrigin, 818 iPreferred == i 819 ); 820 Assert(Status == STATUS_SUCCESS); 821 if (Status != STATUS_SUCCESS) 822 { 823 LOGREL(("vboxVidPnCreatePopulateMonitorSourceModeInfoFromLegacy failed Status(0x%x)", Status)); 824 break; 825 } 826 } 827 828 NTSTATUS tmpStatus = pMonitorInterface->pfnReleaseMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle, hMonitorSMS); 1119 VBOXVIDPN_MONITORMODE_ITER Iter; 1120 const D3DKMDT_MONITOR_SOURCE_MODE *pVidPnModeInfo; 1121 1122 rc = CrSaClone(pSupportedModes, &DiffModes); 1123 if (!RT_SUCCESS(rc)) 1124 { 1125 WARN(("CrSaClone failed")); 1126 Status = STATUS_NO_MEMORY; 1127 goto done; 1128 } 1129 1130 VBoxVidPnMonitorModeIterInit(&Iter, hVidPnModeSet, pVidPnModeSetInterface); 1131 1132 while ((pVidPnModeInfo = VBoxVidPnMonitorModeIterNext(&Iter)) != NULL) 1133 { 1134 RTRECTSIZE size; 1135 size.cx = pVidPnModeInfo->VideoSignalInfo.ActiveSize.cx; 1136 size.cy = pVidPnModeInfo->VideoSignalInfo.ActiveSize.cy; 1137 CrSaRemove(&DiffModes, CR_RSIZE2U64(size)); 1138 } 1139 1140 VBoxVidPnMonitorModeIterTerm(&Iter); 1141 1142 Status = VBoxVidPnMonitorModeIterStatus(&Iter); 1143 if (!NT_SUCCESS(Status)) 1144 { 1145 WARN(("iter status failed %#x", Status)); 1146 goto done; 1147 } 1148 1149 Status = vboxVidPnMonitorModeSetFromArray(hVidPnModeSet, pVidPnModeSetInterface, &DiffModes); 1150 if (!NT_SUCCESS(Status)) 1151 { 1152 WARN(("vboxVidPnMonitorModeSetFromArray failed %#x", Status)); 1153 goto done; 1154 } 1155 1156 done: 1157 NTSTATUS tmpStatus = pMonitorInterface->pfnReleaseMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle, hVidPnModeSet); 829 1158 if (!NT_SUCCESS(tmpStatus)) 830 {831 1159 WARN(("pfnReleaseMonitorSourceModeSet failed tmpStatus(0x%x)", tmpStatus)); 832 } 1160 1161 CrSaCleanup(&DiffModes); 833 1162 834 1163 return Status; 835 1164 } 836 1165 837 NTSTATUS vboxVidPnPathAdd(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 838 const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 1166 static NTSTATUS vboxVidPnPathAdd(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 1167 const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, 1168 D3DKMDT_VIDPN_PRESENT_PATH_IMPORTANCE enmImportance) 839 1169 { 840 1170 D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology; … … 857 1187 pNewVidPnPresentPathInfo->VidPnSourceId = VidPnSourceId; 858 1188 pNewVidPnPresentPathInfo->VidPnTargetId = VidPnTargetId; 859 pNewVidPnPresentPathInfo->ImportanceOrdinal = D3DKMDT_VPPI_PRIMARY;1189 pNewVidPnPresentPathInfo->ImportanceOrdinal = enmImportance; 860 1190 pNewVidPnPresentPathInfo->ContentTransformation.Scaling = D3DKMDT_VPPS_IDENTITY; 861 1191 memset(&pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport, … … 895 1225 } 896 1226 1227 LOG(("Recommended Path (%d->%d)", VidPnSourceId, VidPnTargetId)); 1228 897 1229 return Status; 898 1230 } 899 1231 900 static NTSTATUS vboxVidPnCreatePopulateSourceModeInfoFromLegacy(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 901 const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, 902 VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iModeToPin, 903 D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID *pModeIdToPin, 904 BOOLEAN fDoPin 905 ) 906 { 907 D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet; 908 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pNewVidPnSourceModeSetInterface; 909 910 if (pModeIdToPin) 911 *pModeIdToPin = D3DDDI_ID_UNINITIALIZED; 912 913 NTSTATUS Status = pVidPnInterface->pfnCreateNewSourceModeSet(hVidPn, 914 VidPnSourceId, 915 &hNewVidPnSourceModeSet, 916 &pNewVidPnSourceModeSetInterface); 917 if (!NT_SUCCESS(Status)) 918 { 919 AssertFailed(); 1232 NTSTATUS VBoxVidPnRecommendMonitorModes(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VideoPresentTargetId, 1233 D3DKMDT_HMONITORSOURCEMODESET hVidPnModeSet, const DXGK_MONITORSOURCEMODESET_INTERFACE *pVidPnModeSetInterface) 1234 { 1235 const CR_SORTARRAY *pSupportedModes = VBoxWddmVModesGet(pDevExt, VideoPresentTargetId); 1236 1237 NTSTATUS Status = vboxVidPnMonitorModeSetFromArray(hVidPnModeSet, pVidPnModeSetInterface, pSupportedModes); 1238 if (!NT_SUCCESS(Status)) 1239 { 1240 WARN(("vboxVidPnMonitorModeSetFromArray failed %d", Status)); 920 1241 return Status; 921 1242 } 922 1243 923 D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID sourceModeId = D3DDDI_ID_UNINITIALIZED; 924 925 for (uint32_t i = 0; i < cModes; ++i) 926 { 927 VIDEO_MODE_INFORMATION *pMode = &pModes[i]; 928 D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo; 929 Status = pNewVidPnSourceModeSetInterface->pfnCreateNewModeInfo(hNewVidPnSourceModeSet, &pNewVidPnSourceModeInfo); 1244 return STATUS_SUCCESS; 1245 } 1246 1247 NTSTATUS VBoxVidPnUpdateModes(PVBOXMP_DEVEXT pDevExt, uint32_t u32TargetId, const RTRECTSIZE *pSize) 1248 { 1249 if (u32TargetId >= (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays) 1250 { 1251 WARN(("invalid target id")); 1252 return STATUS_INVALID_PARAMETER; 1253 } 1254 1255 int rc = VBoxWddmVModesAdd(pDevExt, u32TargetId, pSize, TRUE); 1256 if (RT_FAILURE(rc)) 1257 { 1258 WARN(("VBoxWddmVModesAdd failed %d", rc)); 1259 return STATUS_UNSUCCESSFUL; 1260 } 1261 1262 if (rc == VINF_ALREADY_INITIALIZED) 1263 { 1264 /* mode was already in list, just return */ 1265 Assert(CrSaContains(VBoxWddmVModesGet(pDevExt, u32TargetId), CR_RSIZE2U64(*pSize))); 1266 return STATUS_SUCCESS; 1267 } 1268 1269 /* modes have changed, need to replug */ 1270 NTSTATUS Status = VBoxWddmChildStatusReportReconnected(pDevExt, u32TargetId); 1271 if (!NT_SUCCESS(Status)) 1272 { 1273 WARN(("VBoxWddmChildStatusReportReconnected failed Status(%#x)", Status)); 1274 return Status; 1275 } 1276 1277 return STATUS_SUCCESS; 1278 } 1279 1280 NTSTATUS VBoxVidPnRecommendFunctional(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, const VBOXWDDM_RECOMMENDVIDPN *pData) 1281 { 1282 const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL; 1283 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(hVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface); 1284 if (!NT_SUCCESS(Status)) 1285 { 1286 WARN(("DxgkCbQueryVidPnInterface failed Status(%#x)", Status)); 1287 return Status; 1288 } 1289 1290 VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aVisitedSourceMap); 1291 1292 memset(aVisitedSourceMap, 0, sizeof (aVisitedSourceMap)); 1293 1294 uint32_t Importance = (uint32_t)D3DKMDT_VPPI_PRIMARY; 1295 1296 for (uint32_t i = 0; i < (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) 1297 { 1298 int32_t iSource = pData->aTargets[i].iSource; 1299 if (iSource < 0) 1300 continue; 1301 1302 if (iSource >= VBoxCommonFromDeviceExt(pDevExt)->cDisplays) 1303 { 1304 WARN(("invalid iSource")); 1305 return STATUS_INVALID_PARAMETER; 1306 } 1307 1308 if (!pDevExt->fComplexTopologiesEnabled && iSource != i) 1309 { 1310 WARN(("complex topologies not supported!")); 1311 return STATUS_INVALID_PARAMETER; 1312 } 1313 1314 bool fNewSource = false; 1315 1316 if (!ASMBitTest(aVisitedSourceMap, iSource)) 1317 { 1318 int rc = VBoxWddmVModesAdd(pDevExt, i, &pData->aSources[iSource].Size, TRUE); 1319 if (RT_FAILURE(rc)) 1320 { 1321 WARN(("VBoxWddmVModesAdd failed %d", rc)); 1322 return STATUS_UNSUCCESSFUL; 1323 } 1324 1325 Assert(CrSaContains(VBoxWddmVModesGet(pDevExt, i), CR_RSIZE2U64(pData->aSources[iSource].Size))); 1326 1327 Status = vboxVidPnCheckMonitorModes(pDevExt, i); 1328 if (!NT_SUCCESS(Status)) 1329 { 1330 WARN(("vboxVidPnCheckMonitorModes failed %#x", Status)); 1331 return Status; 1332 } 1333 1334 ASMBitSet(aVisitedSourceMap, iSource); 1335 fNewSource = true; 1336 } 1337 1338 Status = vboxVidPnPathAdd(hVidPn, pVidPnInterface, 1339 (const D3DDDI_VIDEO_PRESENT_SOURCE_ID)iSource, (const D3DDDI_VIDEO_PRESENT_TARGET_ID)i, 1340 (D3DKMDT_VIDPN_PRESENT_PATH_IMPORTANCE)Importance); 930 1341 if (!NT_SUCCESS(Status)) 931 1342 { 932 AssertFailed(); 933 break; 934 } 935 936 Status = vboxVidPnPopulateSourceModeInfoFromLegacy(pNewVidPnSourceModeInfo, pMode); 937 if (NT_SUCCESS(Status)) 938 { 939 if (i == iModeToPin) 940 { 941 sourceModeId = pNewVidPnSourceModeInfo->Id; 942 } 943 Status = pNewVidPnSourceModeSetInterface->pfnAddMode(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo); 1343 WARN(("vboxVidPnPathAdd failed Status()0x%x\n", Status)); 1344 return Status; 1345 } 1346 1347 Importance++; 1348 1349 do { 1350 D3DKMDT_HVIDPNTARGETMODESET hVidPnModeSet; 1351 const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnModeSetInterface; 1352 1353 Status = pVidPnInterface->pfnCreateNewTargetModeSet(hVidPn, 1354 i, 1355 &hVidPnModeSet, 1356 &pVidPnModeSetInterface); 944 1357 if (NT_SUCCESS(Status)) 945 1358 { 946 /* success */ 947 continue; 948 } 949 AssertFailed(); 950 } 951 else 952 { 953 AssertFailed(); 954 } 955 956 NTSTATUS tmpStatus = pNewVidPnSourceModeSetInterface->pfnReleaseModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo); 957 Assert(tmpStatus == STATUS_SUCCESS); 958 959 /* we're here because of an error */ 960 Assert(!NT_SUCCESS(Status)); 961 break; 962 } 963 964 if (!NT_SUCCESS(Status)) 965 { 966 AssertFailed(); 967 return Status; 968 } 969 970 if (sourceModeId != D3DDDI_ID_UNINITIALIZED) 971 { 972 if (pModeIdToPin) 973 { 974 *pModeIdToPin = sourceModeId; 975 } 976 Assert(iModeToPin >= 0); 977 if (fDoPin) 978 { 979 Status = pNewVidPnSourceModeSetInterface->pfnPinMode(hNewVidPnSourceModeSet, sourceModeId); 980 if (!NT_SUCCESS(Status)) 981 { 982 AssertFailed(); 983 return Status; 984 } 985 } 986 } 987 else 988 { 989 Assert(iModeToPin < 0); 990 } 991 992 Status = pVidPnInterface->pfnAssignSourceModeSet(hVidPn, VidPnSourceId, hNewVidPnSourceModeSet); 993 if (!NT_SUCCESS(Status)) 994 { 995 AssertFailed(); 996 return Status; 997 } 998 999 return Status; 1000 } 1001 1002 static NTSTATUS vboxVidPnCreatePopulateTargetModeInfoFromLegacy(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 1003 const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, 1004 D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions, 1005 VIDEO_MODE_INFORMATION *pModeToPin, 1006 D3DKMDT_VIDEO_PRESENT_TARGET_MODE_ID *pModeIdToPin, 1007 BOOLEAN fSetPreferred, 1008 BOOLEAN fDoPin 1009 ) 1010 { 1011 D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet; 1012 const DXGK_VIDPNTARGETMODESET_INTERFACE *pNewVidPnTargetModeSetInterface; 1013 1014 if (pModeIdToPin) 1015 *pModeIdToPin = D3DDDI_ID_UNINITIALIZED; 1016 1017 NTSTATUS Status = pVidPnInterface->pfnCreateNewTargetModeSet(hVidPn, 1018 VidPnTargetId, 1019 &hNewVidPnTargetModeSet, 1020 &pNewVidPnTargetModeSetInterface); 1021 if (!NT_SUCCESS(Status)) 1022 { 1023 AssertFailed(); 1024 return Status; 1025 } 1026 1027 D3DKMDT_VIDEO_PRESENT_TARGET_MODE_ID targetModeId = D3DDDI_ID_UNINITIALIZED; 1028 1029 for (uint32_t i = 0; i < cResolutions; ++i) 1030 { 1031 D3DKMDT_2DREGION *pResolution = &pResolutions[i]; 1032 D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo; 1033 Status = pNewVidPnTargetModeSetInterface->pfnCreateNewModeInfo(hNewVidPnTargetModeSet, &pNewVidPnTargetModeInfo); 1034 if (!NT_SUCCESS(Status)) 1035 { 1036 AssertFailed(); 1037 break; 1038 } 1039 1040 BOOLEAN fIsPinMode = pModeToPin && pModeToPin->VisScreenWidth == pResolution->cx 1041 && pModeToPin->VisScreenHeight == pResolution->cy; 1042 1043 Status = vboxVidPnPopulateTargetModeInfoFromLegacy(pNewVidPnTargetModeInfo, pResolution, fIsPinMode && fSetPreferred); 1044 if (NT_SUCCESS(Status)) 1045 { 1046 if (fIsPinMode) 1047 { 1048 targetModeId = pNewVidPnTargetModeInfo->Id; 1049 } 1050 Status = pNewVidPnTargetModeSetInterface->pfnAddMode(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo); 1051 if (NT_SUCCESS(Status)) 1052 { 1053 1054 /* success */ 1055 continue; 1056 } 1057 AssertFailed(); 1058 } 1059 else 1060 { 1061 AssertFailed(); 1062 } 1063 1064 NTSTATUS tmpStatus = pNewVidPnTargetModeSetInterface->pfnReleaseModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo); 1065 Assert(tmpStatus == STATUS_SUCCESS); 1066 1067 /* we're here because of an error */ 1068 Assert(!NT_SUCCESS(Status)); 1069 break; 1070 } 1071 1072 if (!NT_SUCCESS(Status)) 1073 { 1074 AssertFailed(); 1075 return Status; 1076 } 1077 1078 if (targetModeId != D3DDDI_ID_UNINITIALIZED) 1079 { 1080 Assert(pModeToPin); 1081 1082 if (pModeIdToPin) 1083 { 1084 *pModeIdToPin = targetModeId; 1085 } 1086 1087 if (fDoPin) 1088 { 1089 Status = pNewVidPnTargetModeSetInterface->pfnPinMode(hNewVidPnTargetModeSet, targetModeId); 1090 if (!NT_SUCCESS(Status)) 1091 { 1092 AssertFailed(); 1093 return Status; 1094 } 1095 } 1096 } 1097 else 1098 { 1099 Assert(!pModeToPin); 1100 } 1101 1102 Status = pVidPnInterface->pfnAssignTargetModeSet(hVidPn, VidPnTargetId, hNewVidPnTargetModeSet); 1103 if (!NT_SUCCESS(Status)) 1104 { 1105 AssertFailed(); 1106 return Status; 1107 } 1108 1109 return Status; 1110 } 1111 1112 NTSTATUS vboxVidPnCreatePopulateVidPnPathFromLegacy(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 1113 VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iModeToPin, 1114 D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions, 1115 const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 1116 { 1117 NTSTATUS Status; 1118 1119 #if 0 1120 Status = vboxVidPnPathAdd(hVidPn, pVidPnInterface, VidPnSourceId, VidPnTargetId); 1121 if (!NT_SUCCESS(Status)) 1122 { 1123 AssertFailed(); 1124 return Status; 1125 } 1126 #endif 1127 1128 VIDEO_MODE_INFORMATION *pModeToPin = iModeToPin >= 0 ? &pModes[iModeToPin] : NULL; 1129 Status = vboxVidPnCreatePopulateTargetModeInfoFromLegacy(hVidPn, pVidPnInterface, VidPnTargetId, pResolutions, cResolutions, pModeToPin, NULL, TRUE, TRUE); 1130 if (!NT_SUCCESS(Status)) 1131 { 1132 AssertFailed(); 1133 return Status; 1134 } 1135 1136 Status = vboxVidPnCreatePopulateSourceModeInfoFromLegacy(hVidPn, pVidPnInterface, VidPnSourceId, pModes, cModes, iModeToPin, NULL, TRUE); 1137 if (!NT_SUCCESS(Status)) 1138 { 1139 AssertFailed(); 1140 return Status; 1141 } 1142 1143 return Status; 1144 } 1145 1146 typedef struct VBOXVIDPNPOPRESOLUTIONENUM 1147 { 1148 NTSTATUS Status; 1149 D3DKMDT_2DREGION *pResolutions; 1150 int cResolutions; 1151 int cResultResolutions; 1152 }VBOXVIDPNPOPRESOLUTIONENUM, *PVBOXVIDPNPOPRESOLUTIONENUM; 1153 1154 static DECLCALLBACK(BOOLEAN) vboxVidPnPopulateResolutionsFromSourceModeSetEnum(D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface, 1155 const D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo, PVOID pContext) 1156 { 1157 NTSTATUS Status = STATUS_SUCCESS; 1158 PVBOXVIDPNPOPRESOLUTIONENUM pInfo = (PVBOXVIDPNPOPRESOLUTIONENUM)pContext; 1159 Assert(pInfo->cResolutions >= pInfo->cResultResolutions); 1160 Assert(pInfo->Status == STATUS_SUCCESS); 1161 if (vboxWddmResolutionFind(pInfo->pResolutions, pInfo->cResultResolutions, &pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize) < 0) 1162 { 1163 if (pInfo->cResultResolutions < pInfo->cResolutions) 1164 { 1165 pInfo->pResolutions[pInfo->cResultResolutions] = pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize; 1166 ++pInfo->cResultResolutions; 1167 } 1168 else 1169 { 1170 Status = STATUS_BUFFER_OVERFLOW; 1171 } 1172 } 1173 1174 pInfo->Status = Status; 1175 1176 return Status == STATUS_SUCCESS; 1177 } 1178 1179 static DECLCALLBACK(BOOLEAN) vboxVidPnPopulateResolutionsFromTargetModeSetEnum(D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface, 1180 const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, PVOID pContext) 1181 { 1182 NTSTATUS Status = STATUS_SUCCESS; 1183 PVBOXVIDPNPOPRESOLUTIONENUM pInfo = (PVBOXVIDPNPOPRESOLUTIONENUM)pContext; 1184 Assert(pInfo->cResolutions >= pInfo->cResultResolutions); 1185 Assert(pInfo->Status == STATUS_SUCCESS); 1186 if (vboxWddmResolutionFind(pInfo->pResolutions, pInfo->cResultResolutions, &pNewVidPnTargetModeInfo->VideoSignalInfo.ActiveSize) < 0) 1187 { 1188 if (pInfo->cResultResolutions < pInfo->cResolutions) 1189 { 1190 pInfo->pResolutions[pInfo->cResultResolutions] = pNewVidPnTargetModeInfo->VideoSignalInfo.ActiveSize; 1191 ++pInfo->cResultResolutions; 1192 } 1193 else 1194 { 1195 Status = STATUS_BUFFER_OVERFLOW; 1196 } 1197 } 1198 1199 pInfo->Status = Status; 1200 1201 return Status == STATUS_SUCCESS; 1202 } 1203 1204 typedef struct VBOXVIDPNPOPMODEENUM 1205 { 1206 NTSTATUS Status; 1207 VIDEO_MODE_INFORMATION *pModes; 1208 int cModes; 1209 int cResultModes; 1210 }VBOXVIDPNPOPMODEENUM, *PVBOXVIDPNPOPMODEENUM; 1211 1212 static DECLCALLBACK(BOOLEAN) vboxVidPnPopulateModesFromSourceModeSetEnum(D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface, 1213 const D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo, PVOID pContext) 1214 { 1215 NTSTATUS Status = STATUS_SUCCESS; 1216 PVBOXVIDPNPOPMODEENUM pInfo = (PVBOXVIDPNPOPMODEENUM)pContext; 1217 VIDEO_MODE_INFORMATION Mode; 1218 Assert(pInfo->cModes >= pInfo->cResultModes); 1219 Assert(pInfo->Status == STATUS_SUCCESS); 1220 if (VBoxWddmFillMode(&Mode, pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat, 1221 pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cx, 1222 pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cy)) 1223 { 1224 if (vboxWddmVideoModeFind(pInfo->pModes, pInfo->cModes, &Mode) < 0) 1225 { 1226 if (pInfo->cResultModes < pInfo->cModes) 1227 { 1228 pInfo->pModes[pInfo->cResultModes] = Mode; 1229 ++pInfo->cResultModes; 1359 D3DKMDT_VIDPN_TARGET_MODE *pVidPnModeInfo; 1360 Status = pVidPnModeSetInterface->pfnCreateNewModeInfo(hVidPnModeSet, &pVidPnModeInfo); 1361 if (NT_SUCCESS(Status)) 1362 { 1363 vboxVidPnPopulateTargetModeInfo(pVidPnModeInfo, &pData->aSources[iSource].Size); 1364 1365 IN_CONST_D3DKMDT_VIDEO_PRESENT_TARGET_MODE_ID idMode = pVidPnModeInfo->Id; 1366 1367 Status = pVidPnModeSetInterface->pfnAddMode(hVidPnModeSet, pVidPnModeInfo); 1368 if (NT_SUCCESS(Status)) 1369 { 1370 pVidPnModeInfo = NULL; 1371 1372 Status = pVidPnModeSetInterface->pfnPinMode(hVidPnModeSet, idMode); 1373 if (NT_SUCCESS(Status)) 1374 { 1375 Status = pVidPnInterface->pfnAssignTargetModeSet(hVidPn, i, hVidPnModeSet); 1376 if (NT_SUCCESS(Status)) 1377 { 1378 LOG(("Recommended Target[%d] (%dx%d)", i, pData->aSources[iSource].Size.cx, pData->aSources[iSource].Size.cy)); 1379 break; 1380 } 1381 else 1382 WARN(("pfnAssignTargetModeSet failed %#x", Status)); 1383 } 1384 else 1385 WARN(("pfnPinMode failed %#x", Status)); 1386 1387 } 1388 else 1389 WARN(("pfnAddMode failed %#x", Status)); 1390 1391 if (pVidPnModeInfo) 1392 { 1393 NTSTATUS tmpStatus = pVidPnModeSetInterface->pfnReleaseModeInfo(hVidPnModeSet, pVidPnModeInfo); 1394 Assert(tmpStatus == STATUS_SUCCESS); 1395 } 1396 } 1397 else 1398 WARN(("pfnCreateNewTargetModeSet failed %#x", Status)); 1399 1400 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hVidPnModeSet); 1401 Assert(tmpStatus == STATUS_SUCCESS); 1230 1402 } 1231 1403 else 1232 { 1233 Status = STATUS_BUFFER_OVERFLOW; 1234 } 1235 } 1236 } 1237 else 1238 { 1239 Assert(0); 1240 Status = STATUS_INVALID_PARAMETER; 1241 } 1242 1243 pInfo->Status = Status; 1244 1245 return Status == STATUS_SUCCESS; 1246 } 1247 1248 typedef struct VBOXVIDPNPOPMODETARGETENUM 1249 { 1250 VBOXVIDPNPOPMODEENUM Base; 1251 VIDEO_MODE_INFORMATION *pSuperset; 1252 int cSuperset; 1253 }VBOXVIDPNPOPMODETARGETENUM, *PVBOXVIDPNPOPMODETARGETENUM; 1254 1255 static DECLCALLBACK(BOOLEAN) vboxVidPnPopulateModesFromTargetModeSetEnum(D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface, 1256 const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, PVOID pContext) 1257 { 1258 NTSTATUS Status = STATUS_SUCCESS; 1259 PVBOXVIDPNPOPMODETARGETENUM pInfo = (PVBOXVIDPNPOPMODETARGETENUM)pContext; 1260 Assert(pInfo->Base.cModes >= pInfo->Base.cResultModes); 1261 Assert(pInfo->Base.Status == STATUS_SUCCESS); 1262 uint32_t cResult; 1263 Status = VBoxWddmGetModesForResolution(pInfo->pSuperset, pInfo->cSuperset, -1, &pNewVidPnTargetModeInfo->VideoSignalInfo.ActiveSize, 1264 pInfo->Base.pModes + pInfo->Base.cResultModes, pInfo->Base.cModes - pInfo->Base.cResultModes, &cResult, NULL); 1265 Assert(Status == STATUS_SUCCESS); 1266 if (Status == STATUS_SUCCESS) 1267 { 1268 pInfo->Base.cResultModes += cResult; 1269 } 1270 1271 pInfo->Base.Status = Status; 1272 1273 return Status == STATUS_SUCCESS; 1274 } 1275 1276 static D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE vboxVidPnCofuncModalityCurrentPathPivot(CONST DXGKARG_ENUMVIDPNCOFUNCMODALITY* pEnumCofuncModalityArg, 1277 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 1278 { 1279 switch (pEnumCofuncModalityArg->EnumPivotType) 1280 { 1281 case D3DKMDT_EPT_VIDPNSOURCE: 1282 if (pEnumCofuncModalityArg->EnumPivot.VidPnSourceId == VidPnSourceId) 1283 return D3DKMDT_EPT_VIDPNSOURCE; 1284 if (pEnumCofuncModalityArg->EnumPivot.VidPnSourceId == D3DDDI_ID_ALL) 1285 { 1286 #ifdef DEBUG_misha 1287 AssertFailed(); 1288 #endif 1289 return D3DKMDT_EPT_VIDPNSOURCE; 1290 } 1291 return D3DKMDT_EPT_NOPIVOT; 1292 case D3DKMDT_EPT_VIDPNTARGET: 1293 if (pEnumCofuncModalityArg->EnumPivot.VidPnTargetId == VidPnTargetId) 1294 return D3DKMDT_EPT_VIDPNTARGET; 1295 if (pEnumCofuncModalityArg->EnumPivot.VidPnTargetId == D3DDDI_ID_ALL) 1296 { 1297 #ifdef DEBUG_misha 1298 AssertFailed(); 1299 #endif 1300 return D3DKMDT_EPT_VIDPNTARGET; 1301 } 1302 return D3DKMDT_EPT_NOPIVOT; 1303 case D3DKMDT_EPT_SCALING: 1304 case D3DKMDT_EPT_ROTATION: 1305 case D3DKMDT_EPT_NOPIVOT: 1306 return D3DKMDT_EPT_NOPIVOT; 1307 default: 1308 AssertFailed(); 1309 return D3DKMDT_EPT_NOPIVOT; 1310 } 1311 } 1312 1313 NTSTATUS vboxVidPnHasPinnedTargetMode(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 1314 D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, BOOLEAN *pfHas) 1315 { 1316 D3DKMDT_HVIDPNTARGETMODESET hCurVidPnTargetModeSet; 1317 const DXGK_VIDPNTARGETMODESET_INTERFACE *pCurVidPnTargetModeSetInterface; 1318 *pfHas = FALSE; 1319 NTSTATUS Status = pVidPnInterface->pfnAcquireTargetModeSet(hVidPn, 1320 VidPnTargetId, 1321 &hCurVidPnTargetModeSet, 1322 &pCurVidPnTargetModeSetInterface); 1323 if (!NT_SUCCESS(Status)) 1324 { 1325 AssertFailed(); 1326 return Status; 1327 } 1328 1329 CONST D3DKMDT_VIDPN_TARGET_MODE* pPinnedVidPnTargetModeInfo; 1330 Status = pCurVidPnTargetModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnTargetModeSet, &pPinnedVidPnTargetModeInfo); 1331 if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED) 1332 { 1333 pPinnedVidPnTargetModeInfo = NULL; 1334 Status = STATUS_SUCCESS; 1335 } 1336 else if (!NT_SUCCESS(Status)) 1337 { 1338 LOGREL(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status)); 1339 AssertFailed(); 1340 } 1341 else 1342 { 1343 Assert(pPinnedVidPnTargetModeInfo); 1344 NTSTATUS tmpStatus = pCurVidPnTargetModeSetInterface->pfnReleaseModeInfo(hCurVidPnTargetModeSet, pPinnedVidPnTargetModeInfo); 1345 Assert(NT_SUCCESS(tmpStatus)); 1346 *pfHas = TRUE; 1347 } 1348 1349 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hCurVidPnTargetModeSet); 1350 Assert(tmpStatus == STATUS_SUCCESS); 1351 1352 return Status; 1353 } 1354 1355 NTSTATUS vboxVidPnHasPinnedSourceMode(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 1356 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, BOOLEAN *pfHas) 1357 { 1358 D3DKMDT_HVIDPNSOURCEMODESET hCurVidPnSourceModeSet; 1359 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pCurVidPnSourceModeSetInterface; 1360 *pfHas = FALSE; 1361 NTSTATUS Status = pVidPnInterface->pfnAcquireSourceModeSet(hVidPn, 1362 VidPnSourceId, 1363 &hCurVidPnSourceModeSet, 1364 &pCurVidPnSourceModeSetInterface); 1365 if (!NT_SUCCESS(Status)) 1366 { 1367 AssertFailed(); 1368 return Status; 1369 } 1370 1371 CONST D3DKMDT_VIDPN_SOURCE_MODE* pPinnedVidPnSourceModeInfo; 1372 Status = pCurVidPnSourceModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnSourceModeSet, &pPinnedVidPnSourceModeInfo); 1373 if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED) 1374 { 1375 pPinnedVidPnSourceModeInfo = NULL; 1376 Status = STATUS_SUCCESS; 1377 } 1378 else if (!NT_SUCCESS(Status)) 1379 { 1380 LOGREL(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status)); 1381 AssertFailed(); 1382 } 1383 else 1384 { 1385 Assert(pPinnedVidPnSourceModeInfo); 1386 NTSTATUS tmpStatus = pCurVidPnSourceModeSetInterface->pfnReleaseModeInfo(hCurVidPnSourceModeSet, pPinnedVidPnSourceModeInfo); 1387 Assert(NT_SUCCESS(tmpStatus)); 1388 *pfHas = TRUE; 1389 } 1390 1391 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hCurVidPnSourceModeSet); 1392 Assert(tmpStatus == STATUS_SUCCESS); 1393 1394 return Status; 1395 } 1396 1397 static NTSTATUS vboxVidPnCofuncModalityForPathTarget(PVBOXVIDPNCOFUNCMODALITY pCbContext, 1398 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 1399 { 1400 PVBOXMP_DEVEXT pDevExt = pCbContext->pDevExt; 1401 D3DKMDT_HVIDPN hVidPn = pCbContext->pEnumCofuncModalityArg->hConstrainingVidPn; 1402 const DXGK_VIDPN_INTERFACE* pVidPnInterface = pCbContext->pVidPnInterface; 1403 PVBOXWDDM_VIDEOMODES_INFO pInfo = &pCbContext->pInfos[VidPnTargetId]; 1404 1405 D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet = NULL; 1406 const DXGK_VIDPNTARGETMODESET_INTERFACE *pNewVidPnTargetModeSetInterface; 1407 1408 Assert(pDevExt->fComplexTopologiesEnabled || VidPnSourceId == VidPnTargetId); 1409 1410 D3DKMDT_HVIDPNSOURCEMODESET hCurVidPnSourceModeSet; 1411 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pCurVidPnSourceModeSetInterface; 1412 NTSTATUS Status = pVidPnInterface->pfnAcquireSourceModeSet(hVidPn, 1413 VidPnSourceId, 1414 &hCurVidPnSourceModeSet, 1415 &pCurVidPnSourceModeSetInterface); 1416 if (!NT_SUCCESS(Status)) 1417 { 1418 AssertFailed(); 1419 return Status; 1420 } 1421 1422 CONST D3DKMDT_VIDPN_SOURCE_MODE* pPinnedVidPnSourceModeInfo; 1423 Status = pCurVidPnSourceModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnSourceModeSet, &pPinnedVidPnSourceModeInfo); 1424 if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED) 1425 { 1426 pPinnedVidPnSourceModeInfo = NULL; 1427 Status = STATUS_SUCCESS; 1428 } 1429 else if (!NT_SUCCESS(Status)) 1430 { 1431 LOGREL(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status)); 1432 AssertFailed(); 1433 } 1434 else 1435 { 1436 Assert(pPinnedVidPnSourceModeInfo); 1437 } 1438 1439 if (NT_SUCCESS(Status)) 1440 { 1441 Status = pVidPnInterface->pfnCreateNewTargetModeSet(hVidPn, 1442 VidPnTargetId, 1443 &hNewVidPnTargetModeSet, 1444 &pNewVidPnTargetModeSetInterface); 1445 if (NT_SUCCESS(Status)) 1446 { 1447 Assert(hNewVidPnTargetModeSet); 1448 Assert(pDevExt->fComplexTopologiesEnabled || VidPnSourceId == VidPnTargetId); 1449 // if (VidPnSourceId == VidPnTargetId && pCbContext->apPathInfos[VidPnTargetId].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT) 1450 { 1451 for (uint32_t i = 0; i < pInfo->cResolutions; ++i) 1404 WARN(("pfnCreateNewTargetModeSet failed %#x", Status)); 1405 1406 Assert(!NT_SUCCESS(Status)); 1407 1408 return Status; 1409 } while (0); 1410 1411 if (fNewSource) 1412 { 1413 do { 1414 D3DKMDT_HVIDPNSOURCEMODESET hVidPnModeSet; 1415 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnModeSetInterface; 1416 1417 Status = pVidPnInterface->pfnCreateNewSourceModeSet(hVidPn, 1418 iSource, 1419 &hVidPnModeSet, 1420 &pVidPnModeSetInterface); 1421 if (NT_SUCCESS(Status)) 1452 1422 { 1453 D3DKMDT_2DREGION *pResolution = &pInfo->aResolutions[i]; 1454 if (pPinnedVidPnSourceModeInfo) 1423 D3DKMDT_VIDPN_SOURCE_MODE *pVidPnModeInfo; 1424 Status = pVidPnModeSetInterface->pfnCreateNewModeInfo(hVidPnModeSet, &pVidPnModeInfo); 1425 if (NT_SUCCESS(Status)) 1455 1426 { 1456 if (pPinnedVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx != pResolution->cx 1457 || pPinnedVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy != pResolution->cy) 1427 vboxVidPnPopulateSourceModeInfo(pVidPnModeInfo, &pData->aSources[iSource].Size); 1428 1429 IN_CONST_D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID idMode = pVidPnModeInfo->Id; 1430 1431 Status = pVidPnModeSetInterface->pfnAddMode(hVidPnModeSet, pVidPnModeInfo); 1432 if (NT_SUCCESS(Status)) 1458 1433 { 1459 continue; 1434 pVidPnModeInfo = NULL; 1435 1436 Status = pVidPnModeSetInterface->pfnPinMode(hVidPnModeSet, idMode); 1437 if (NT_SUCCESS(Status)) 1438 { 1439 Status = pVidPnInterface->pfnAssignSourceModeSet(hVidPn, iSource, hVidPnModeSet); 1440 if (NT_SUCCESS(Status)) 1441 { 1442 LOG(("Recommended Source[%d] (%dx%d)", iSource, pData->aSources[iSource].Size.cx, pData->aSources[iSource].Size.cy)); 1443 break; 1444 } 1445 else 1446 WARN(("pfnAssignSourceModeSet failed %#x", Status)); 1447 } 1448 else 1449 WARN(("pfnPinMode failed %#x", Status)); 1450 1451 } 1452 else 1453 WARN(("pfnAddMode failed %#x", Status)); 1454 1455 if (pVidPnModeInfo) 1456 { 1457 NTSTATUS tmpStatus = pVidPnModeSetInterface->pfnReleaseModeInfo(hVidPnModeSet, pVidPnModeInfo); 1458 Assert(tmpStatus == STATUS_SUCCESS); 1460 1459 } 1461 1460 } 1462 1463 D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo; 1464 Status = pNewVidPnTargetModeSetInterface->pfnCreateNewModeInfo(hNewVidPnTargetModeSet, &pNewVidPnTargetModeInfo); 1465 Assert(Status == STATUS_SUCCESS); 1466 if (NT_SUCCESS(Status)) 1467 { 1468 Status = vboxVidPnPopulateTargetModeInfoFromLegacy(pNewVidPnTargetModeInfo, pResolution, i == pInfo->iPreferredResolution); 1469 if (NT_SUCCESS(Status)) 1470 { 1471 Status = pNewVidPnTargetModeSetInterface->pfnAddMode(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo); 1472 if (NT_SUCCESS(Status)) 1473 { 1474 /* success */ 1475 continue; 1476 } 1477 else 1478 WARN(("pfnAddMode failed, Status 0x%x", Status)); 1479 } 1480 else 1481 WARN(("vboxVidPnPopulateTargetModeInfoFromLegacy failed, Status 0x%x", Status)); 1482 1483 NTSTATUS tmpStatus = pNewVidPnTargetModeSetInterface->pfnReleaseModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo); 1484 Assert(tmpStatus == STATUS_SUCCESS); 1485 } 1486 1487 /* we're here because of an error */ 1488 Assert(!NT_SUCCESS(Status)); 1489 /* ignore mode addition failure */ 1490 Status = STATUS_SUCCESS; 1491 continue; 1461 else 1462 WARN(("pfnCreateNewSourceModeSet failed %#x", Status)); 1463 1464 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hVidPnModeSet); 1465 Assert(tmpStatus == STATUS_SUCCESS); 1492 1466 } 1493 } 1494 } 1495 else 1496 { 1497 AssertFailed(); 1498 } 1499 } 1500 else 1501 { 1502 AssertFailed(); 1503 } 1504 1505 if (pPinnedVidPnSourceModeInfo) 1506 { 1507 NTSTATUS tmpStatus = pCurVidPnSourceModeSetInterface->pfnReleaseModeInfo(hCurVidPnSourceModeSet, pPinnedVidPnSourceModeInfo); 1508 Assert(tmpStatus == STATUS_SUCCESS); 1509 } 1510 1511 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hCurVidPnSourceModeSet); 1512 Assert(tmpStatus == STATUS_SUCCESS); 1513 1514 if (NT_SUCCESS(Status)) 1515 { 1516 Assert(hNewVidPnTargetModeSet); 1517 Status = pVidPnInterface->pfnAssignTargetModeSet(hVidPn, VidPnTargetId, hNewVidPnTargetModeSet); 1518 if (!NT_SUCCESS(Status)) 1519 { 1520 WARN(("\n\n!!!!!!!\n\n pfnAssignTargetModeSet failed, Status(0x%x)", Status)); 1521 tmpStatus = pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hNewVidPnTargetModeSet); 1522 Assert(tmpStatus == STATUS_SUCCESS); 1523 } 1524 } 1525 1526 return Status; 1527 } 1528 1529 static NTSTATUS vboxVidPnCofuncModalityForPathSource(PVBOXVIDPNCOFUNCMODALITY pCbContext, 1530 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 1531 { 1532 PVBOXMP_DEVEXT pDevExt = pCbContext->pDevExt; 1533 D3DKMDT_HVIDPN hVidPn = pCbContext->pEnumCofuncModalityArg->hConstrainingVidPn; 1534 const DXGK_VIDPN_INTERFACE* pVidPnInterface = pCbContext->pVidPnInterface; 1535 PVBOXWDDM_VIDEOMODES_INFO pInfo = &pCbContext->pInfos[VidPnTargetId]; 1536 D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet = NULL; 1537 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pNewVidPnSourceModeSetInterface; 1538 1539 Assert(pDevExt->fComplexTopologiesEnabled || VidPnSourceId == VidPnTargetId); 1540 1541 D3DKMDT_HVIDPNTARGETMODESET hCurVidPnTargetModeSet; 1542 const DXGK_VIDPNTARGETMODESET_INTERFACE *pCurVidPnTargetModeSetInterface; 1543 NTSTATUS Status = pVidPnInterface->pfnAcquireTargetModeSet(hVidPn, 1544 VidPnTargetId, 1545 &hCurVidPnTargetModeSet, 1546 &pCurVidPnTargetModeSetInterface); 1547 if (!NT_SUCCESS(Status)) 1548 { 1549 AssertFailed(); 1550 return Status; 1551 } 1552 1553 CONST D3DKMDT_VIDPN_TARGET_MODE* pPinnedVidPnTargetModeInfo; 1554 Status = pCurVidPnTargetModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnTargetModeSet, &pPinnedVidPnTargetModeInfo); 1555 if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED) 1556 { 1557 pPinnedVidPnTargetModeInfo = NULL; 1558 Status = STATUS_SUCCESS; 1559 } 1560 else if (!NT_SUCCESS(Status)) 1561 { 1562 LOGREL(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status)); 1563 AssertFailed(); 1564 } 1565 else 1566 { 1567 Assert(pPinnedVidPnTargetModeInfo); 1568 } 1569 1570 if (NT_SUCCESS(Status)) 1571 { 1572 NTSTATUS Status = pVidPnInterface->pfnCreateNewSourceModeSet(hVidPn, 1573 VidPnSourceId, 1574 &hNewVidPnSourceModeSet, 1575 &pNewVidPnSourceModeSetInterface); 1576 if (NT_SUCCESS(Status)) 1577 { 1578 Assert(hNewVidPnSourceModeSet); 1579 Assert(pDevExt->fComplexTopologiesEnabled || VidPnSourceId == VidPnTargetId); 1580 // if (VidPnSourceId == VidPnTargetId && pCbContext->apPathInfos[VidPnSourceId].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT) 1581 { 1582 for (uint32_t i = 0; i < pInfo->cModes; ++i) 1583 { 1584 VIDEO_MODE_INFORMATION *pMode = &pInfo->aModes[i]; 1585 if (pPinnedVidPnTargetModeInfo) 1586 { 1587 if (pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cx != pMode->VisScreenWidth 1588 || pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy != pMode->VisScreenHeight) 1589 { 1590 continue; 1591 } 1592 } 1593 1594 D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo; 1595 Status = pNewVidPnSourceModeSetInterface->pfnCreateNewModeInfo(hNewVidPnSourceModeSet, &pNewVidPnSourceModeInfo); 1596 if (NT_SUCCESS(Status)) 1597 { 1598 Status = vboxVidPnPopulateSourceModeInfoFromLegacy(pNewVidPnSourceModeInfo, pMode); 1599 Assert(Status == STATUS_SUCCESS); 1600 if (NT_SUCCESS(Status)) 1601 { 1602 Status = pNewVidPnSourceModeSetInterface->pfnAddMode(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo); 1603 if (NT_SUCCESS(Status)) 1604 { 1605 /* success */ 1606 continue; 1607 } 1608 else 1609 WARN(("pfnAddMode failed, Status 0x%x", Status)); 1610 } 1611 1612 NTSTATUS tmpStatus = pNewVidPnSourceModeSetInterface->pfnReleaseModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo); 1613 Assert(tmpStatus == STATUS_SUCCESS); 1614 } 1615 else 1616 WARN(("pfnCreateNewModeInfo failed, Status 0x%x", Status)); 1617 /* we're here because of an error */ 1618 Assert(!NT_SUCCESS(Status)); 1619 /* ignore mode addition failure */ 1620 Status = STATUS_SUCCESS; 1621 continue; 1622 } 1623 } 1624 } 1625 else 1626 { 1627 AssertFailed(); 1628 } 1629 } 1630 else 1631 { 1632 AssertFailed(); 1633 } 1634 1635 if (pPinnedVidPnTargetModeInfo) 1636 { 1637 NTSTATUS tmpStatus = pCurVidPnTargetModeSetInterface->pfnReleaseModeInfo(hCurVidPnTargetModeSet, pPinnedVidPnTargetModeInfo); 1638 Assert(tmpStatus == STATUS_SUCCESS); 1639 } 1640 1641 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hCurVidPnTargetModeSet); 1642 Assert(tmpStatus == STATUS_SUCCESS); 1643 1644 if (NT_SUCCESS(Status)) 1645 { 1646 Assert(hNewVidPnSourceModeSet); 1647 Status = pVidPnInterface->pfnAssignSourceModeSet(hVidPn, VidPnSourceId, hNewVidPnSourceModeSet); 1648 if (!NT_SUCCESS(Status)) 1649 { 1650 WARN(("\n\n!!!!!!!\n\n pfnAssignSourceModeSet failed, Status(0x%x)", Status)); 1651 tmpStatus = pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hNewVidPnSourceModeSet); 1652 Assert(tmpStatus == STATUS_SUCCESS); 1653 } 1654 } 1655 1656 return Status; 1657 } 1658 1659 NTSTATUS vboxVidPnCofuncModalityForPath(PVBOXVIDPNCOFUNCMODALITY pCbContext, 1660 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) 1661 { 1662 PVBOXMP_DEVEXT pDevExt = pCbContext->pDevExt; 1663 D3DKMDT_HVIDPN hVidPn = pCbContext->pEnumCofuncModalityArg->hConstrainingVidPn; 1664 const DXGK_VIDPN_INTERFACE* pVidPnInterface = pCbContext->pVidPnInterface; 1665 NTSTATUS Status = STATUS_SUCCESS; 1666 pCbContext->Status = STATUS_SUCCESS; 1667 PVBOXWDDM_VIDEOMODES_INFO pInfo = &pCbContext->pInfos[VidPnTargetId]; 1668 1669 D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmPivot = vboxVidPnCofuncModalityCurrentPathPivot(pCbContext->pEnumCofuncModalityArg, VidPnSourceId, VidPnTargetId); 1670 BOOLEAN fHasPinnedMode = FALSE; 1671 Status = vboxVidPnHasPinnedTargetMode(hVidPn, pVidPnInterface, VidPnTargetId, &fHasPinnedMode); 1672 if (!NT_SUCCESS(Status)) 1673 { 1674 AssertFailed(); 1675 return Status; 1676 } 1677 1678 BOOLEAN fNeedUpdate = enmPivot != D3DKMDT_EPT_VIDPNTARGET && !fHasPinnedMode; 1679 if (fNeedUpdate) 1680 { 1681 Status = vboxVidPnCofuncModalityForPathTarget(pCbContext, VidPnSourceId, VidPnTargetId); 1682 } 1683 1684 if (NT_SUCCESS(Status)) 1685 { 1686 fHasPinnedMode = FALSE; 1687 Status = vboxVidPnHasPinnedSourceMode(hVidPn, pVidPnInterface, VidPnSourceId, &fHasPinnedMode); 1688 if (!NT_SUCCESS(Status)) 1689 { 1690 AssertFailed(); 1691 return Status; 1692 } 1693 1694 fNeedUpdate = enmPivot != D3DKMDT_EPT_VIDPNSOURCE && !fHasPinnedMode; 1695 if (fNeedUpdate) 1696 { 1697 Status = vboxVidPnCofuncModalityForPathSource(pCbContext, VidPnSourceId, VidPnTargetId); 1698 } 1699 } 1700 1701 return Status; 1702 } 1703 1704 DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalityPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, 1705 const D3DKMDT_VIDPN_PRESENT_PATH *pNewVidPnPresentPathInfo, PVOID pContext) 1706 { 1707 PVBOXVIDPNCOFUNCMODALITY pCbContext = (PVBOXVIDPNCOFUNCMODALITY)pContext; 1708 D3DKMDT_VIDPN_PRESENT_PATH AdjustedPath = {0}; 1709 NTSTATUS Status = STATUS_SUCCESS; 1710 bool bUpdatePath = false; 1711 AdjustedPath.VidPnSourceId = pNewVidPnPresentPathInfo->VidPnSourceId; 1712 AdjustedPath.VidPnTargetId = pNewVidPnPresentPathInfo->VidPnTargetId; 1713 AdjustedPath.ContentTransformation = pNewVidPnPresentPathInfo->ContentTransformation; 1714 AdjustedPath.CopyProtection = pNewVidPnPresentPathInfo->CopyProtection; 1715 1716 if (pNewVidPnPresentPathInfo->ContentTransformation.Scaling == D3DKMDT_VPPS_UNPINNED) 1717 { 1718 AdjustedPath.ContentTransformation.ScalingSupport.Identity = TRUE; 1719 bUpdatePath = true; 1720 } 1721 1722 if (pNewVidPnPresentPathInfo->ContentTransformation.Rotation == D3DKMDT_VPPR_UNPINNED) 1723 { 1724 AdjustedPath.ContentTransformation.RotationSupport.Identity = TRUE; 1725 bUpdatePath = true; 1726 } 1727 1728 if (bUpdatePath) 1729 { 1730 Status = pVidPnTopologyInterface->pfnUpdatePathSupportInfo(hVidPnTopology, &AdjustedPath); 1731 Assert(Status == STATUS_SUCCESS); 1732 } 1733 1734 Status = vboxVidPnCofuncModalityForPath(pCbContext, pNewVidPnPresentPathInfo->VidPnSourceId, pNewVidPnPresentPathInfo->VidPnTargetId); 1735 1736 pVidPnTopologyInterface->pfnReleasePathInfo(hVidPnTopology, pNewVidPnPresentPathInfo); 1737 1738 pCbContext->Status = Status; 1739 Assert(Status == STATUS_SUCCESS); 1740 return Status == STATUS_SUCCESS; 1467 else 1468 WARN(("pfnCreateNewSourceModeSet failed %#x", Status)); 1469 1470 Assert(!NT_SUCCESS(Status)); 1471 1472 return Status; 1473 } while (0); 1474 } 1475 } 1476 1477 Assert(NT_SUCCESS(Status)); 1478 return STATUS_SUCCESS; 1741 1479 } 1742 1480 … … 1864 1602 } 1865 1603 1866 typedef struct VBOXVIDPNGETPATHSINFO 1867 { 1868 PVBOXMP_DEVEXT pDevExt; 1869 NTSTATUS Status; 1870 BOOLEAN fBreakOnDisabled; 1871 BOOLEAN fDisabledFound; 1872 } VBOXVIDPNGETPATHSINFO, *PVBOXVIDPNGETPATHSINFO; 1873 1874 static DECLCALLBACK(BOOLEAN) vboxVidPnCheckTopologyEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, 1875 const D3DKMDT_VIDPN_PRESENT_PATH *pNewVidPnPresentPathInfo, PVOID pContext) 1876 { 1877 PVBOXVIDPNGETPATHSINFO pCbContext = (PVBOXVIDPNGETPATHSINFO)pContext; 1878 NTSTATUS Status = STATUS_SUCCESS; 1879 CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId = pNewVidPnPresentPathInfo->VidPnSourceId; 1880 CONST D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId = pNewVidPnPresentPathInfo->VidPnTargetId; 1881 BOOLEAN fDisabledFound = !vboxVidPnIsPathSupported(pCbContext->pDevExt, pNewVidPnPresentPathInfo); 1882 1883 pCbContext->fDisabledFound |= fDisabledFound; 1884 pCbContext->Status = Status; 1885 if (!NT_SUCCESS(Status)) 1886 return FALSE; /* do not continue on failure */ 1887 1888 return !fDisabledFound || !pCbContext->fBreakOnDisabled; 1889 } 1890 1891 /* we currently support only 0 -> 0, 1 -> 1, 2 -> 2 paths, AND 0 -> 0 must be present 1892 * this routine disables all paths unsupported */ 1893 NTSTATUS VBoxVidPnCheckTopology(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, BOOLEAN *pfSupported) 1894 { 1895 VBOXVIDPNGETPATHSINFO CbContext = {0}; 1896 CbContext.pDevExt = pDevExt; 1897 CbContext.Status = STATUS_SUCCESS; 1898 CbContext.fBreakOnDisabled = FALSE; 1899 CbContext.fDisabledFound = FALSE; 1900 NTSTATUS Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface, vboxVidPnCheckTopologyEnum, &CbContext); 1901 if (!NT_SUCCESS(Status)) 1902 { 1903 WARN(("vboxVidPnEnumPaths failed Status()0x%x\n", Status)); 1604 NTSTATUS VBoxVidPnIsSupported(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, BOOLEAN *pfSupported) 1605 { 1606 *pfSupported = FALSE; 1607 1608 const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL; 1609 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(hVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface); 1610 if (!NT_SUCCESS(Status)) 1611 { 1612 WARN(("DxgkCbQueryVidPnInterface failed Status()0x%x\n", Status)); 1904 1613 return Status; 1905 1614 } 1906 1615 1907 Status = CbContext.Status; 1908 if (!NT_SUCCESS(Status)) 1909 { 1910 WARN(("vboxVidPnCheckTopologyEnum returned failed Status()0x%x\n", Status)); 1616 #ifdef VBOXWDDM_DEBUG_VIDPN 1617 vboxVidPnDumpVidPn(">>>>IsSupported VidPN (IN) : >>>>\n", pDevExt, hVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n"); 1618 #endif 1619 1620 D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology; 1621 const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface; 1622 Status = pVidPnInterface->pfnGetTopology(hVidPn, &hVidPnTopology, &pVidPnTopologyInterface); 1623 if (!NT_SUCCESS(Status)) 1624 { 1625 WARN(("pfnGetTopology failed Status()0x%x\n", Status)); 1911 1626 return Status; 1912 1627 } 1913 1628 1914 BOOLEAN fSupported = !CbContext.fDisabledFound; 1915 1916 /* now check if 0->0 path is present and enabled, and if not, disable everything */ 1917 // if (cItems && aItems[0].enmState != VBOXVIDPNPATHITEM_STATE_PRESENT) 1918 // { 1919 // LOG(("path 0 not set to present\n")); 1920 //// for (i = 0; i < cItems; ++i) 1921 //// { 1922 //// if (aItems[i].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT) 1923 //// aItems[i].enmState = VBOXVIDPNPATHITEM_STATE_DISABLED; 1924 //// } 1925 // fSupported = FALSE; 1926 // } 1927 1928 if (pfSupported) 1929 *pfSupported = fSupported; 1629 VBOXVIDPN_PATH_ITER PathIter; 1630 const D3DKMDT_VIDPN_PRESENT_PATH * pPath; 1631 VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aVisitedTargetMap); 1632 VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aModeMap); 1633 CR_SORTARRAY aModes[VBOX_VIDEO_MAX_SCREENS]; 1634 1635 memset(aVisitedTargetMap, 0, sizeof (aVisitedTargetMap)); 1636 memset(aModeMap, 0, sizeof (aModeMap)); 1637 memset(aModes, 0, sizeof (aModes)); 1638 1639 CR_SORTARRAY TargetMode = {0}; 1640 1641 BOOLEAN fSupported = TRUE; 1642 /* collect info first */ 1643 VBoxVidPnPathIterInit(&PathIter, hVidPnTopology, pVidPnTopologyInterface); 1644 while ((pPath = VBoxVidPnPathIterNext(&PathIter)) != NULL) 1645 { 1646 CrSaClear(&TargetMode); 1647 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId = pPath->VidPnSourceId; 1648 D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId = pPath->VidPnTargetId; 1649 /* actually vidpn topology should contain only one target info, right? */ 1650 Assert(!ASMBitTest(aVisitedTargetMap, VidPnTargetId)); 1651 ASMBitSet(aVisitedTargetMap, VidPnTargetId); 1652 1653 if (!vboxVidPnIsPathSupported(pDevExt, pPath)) 1654 { 1655 fSupported = FALSE; 1656 break; 1657 } 1658 1659 RTRECTSIZE TargetSize; 1660 RTRECTSIZE SourceSize; 1661 Status = vboxVidPnQueryPinnedTargetMode(hVidPn, pVidPnInterface, VidPnTargetId, &TargetSize); 1662 if (!NT_SUCCESS(Status)) 1663 { 1664 WARN(("vboxVidPnQueryPinnedTargetMode failed %#x", Status)); 1665 break; 1666 } 1667 1668 Status = vboxVidPnQueryPinnedSourceMode(hVidPn, pVidPnInterface, VidPnSourceId, &SourceSize); 1669 if (!NT_SUCCESS(Status)) 1670 { 1671 WARN(("vboxVidPnQueryPinnedSourceMode failed %#x", Status)); 1672 break; 1673 } 1674 1675 if (memcmp(&TargetSize, &SourceSize, sizeof (TargetSize)) && TargetSize.cx) 1676 { 1677 if (!SourceSize.cx) 1678 WARN(("not expected?")); 1679 1680 fSupported = FALSE; 1681 break; 1682 } 1683 1684 { 1685 D3DKMDT_HVIDPNTARGETMODESET hVidPnModeSet; 1686 const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnModeSetInterface; 1687 Status = pVidPnInterface->pfnAcquireTargetModeSet(hVidPn, 1688 VidPnTargetId, 1689 &hVidPnModeSet, 1690 &pVidPnModeSetInterface); 1691 if (!NT_SUCCESS(Status)) 1692 { 1693 WARN(("pfnAcquireTargetModeSet failed %#x", Status)); 1694 break; 1695 } 1696 1697 Status = vboxVidPnTargetModeSetToArray(hVidPnModeSet, pVidPnModeSetInterface, &TargetMode); 1698 if (!NT_SUCCESS(Status)) 1699 { 1700 WARN(("vboxVidPnTargetModeSetToArray failed %#x", Status)); 1701 break; 1702 } 1703 1704 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hVidPnModeSet); 1705 Assert(tmpStatus == STATUS_SUCCESS); 1706 } 1707 1708 if (!ASMBitTest(aModeMap, VidPnSourceId)) 1709 { 1710 D3DKMDT_HVIDPNSOURCEMODESET hVidPnModeSet; 1711 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnModeSetInterface; 1712 Status = pVidPnInterface->pfnAcquireSourceModeSet(hVidPn, 1713 VidPnSourceId, 1714 &hVidPnModeSet, 1715 &pVidPnModeSetInterface); 1716 if (!NT_SUCCESS(Status)) 1717 { 1718 WARN(("pfnAcquireSourceModeSet failed %#x", Status)); 1719 break; 1720 } 1721 1722 Status = vboxVidPnSourceModeSetToArray(hVidPnModeSet, pVidPnModeSetInterface, &aModes[VidPnSourceId]); 1723 if (!NT_SUCCESS(Status)) 1724 { 1725 WARN(("vboxVidPnSourceModeSetToArray failed %#x", Status)); 1726 break; 1727 } 1728 1729 NTSTATUS tmpStatus = pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hVidPnModeSet); 1730 Assert(tmpStatus == STATUS_SUCCESS); 1731 1732 ASMBitSet(aModeMap, VidPnSourceId); 1733 } 1734 1735 if (CrSaCmp(&aModes[VidPnSourceId], &TargetMode)) 1736 { 1737 WARN(("not expected 2?")); 1738 fSupported = FALSE; 1739 break; 1740 } 1741 1742 #if 0 1743 const CR_SORTARRAY *pSupportedModes = VBoxWddmVModesGet(pDevExt, VidPnTargetId); 1744 if (!CrSaCovers(pSupportedModes, &TargetMode)) 1745 { 1746 WARN(("not expected 3?")); 1747 fSupported = FALSE; 1748 break; 1749 } 1750 #endif 1751 } 1752 1753 VBoxVidPnPathIterTerm(&PathIter); 1754 1755 if (!NT_SUCCESS(Status)) 1756 goto done; 1757 1758 Status = VBoxVidPnPathIterStatus(&PathIter); 1759 if (!NT_SUCCESS(Status)) 1760 { 1761 WARN(("PathIter failed Status()0x%x\n", Status)); 1762 goto done; 1763 } 1764 1765 *pfSupported = fSupported; 1766 done: 1767 1768 CrSaCleanup(&TargetMode); 1769 1770 for (uint32_t i = 0; i < (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) 1771 { 1772 CrSaCleanup(&aModes[i]); 1773 } 1774 1775 1776 return Status; 1777 } 1778 1779 NTSTATUS VBoxVidPnCofuncModality(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmPivot, const DXGK_ENUM_PIVOT *pPivot) 1780 { 1781 const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL; 1782 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(hVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface); 1783 if (!NT_SUCCESS(Status)) 1784 { 1785 WARN(("DxgkCbQueryVidPnInterface failed Status()0x%x\n", Status)); 1786 return Status; 1787 } 1788 1789 #ifdef VBOXWDDM_DEBUG_VIDPN 1790 vboxVidPnDumpCofuncModalityArg(">>>>MODALITY Args: ", pEnumCofuncModalityArg, "\n"); 1791 vboxVidPnDumpVidPn(">>>>MODALITY VidPN (IN) : >>>>\n", pDevExt, pEnumCofuncModalityArg->hConstrainingVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n"); 1792 #endif 1793 1794 D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology; 1795 const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface; 1796 Status = pVidPnInterface->pfnGetTopology(hVidPn, &hVidPnTopology, &pVidPnTopologyInterface); 1797 if (!NT_SUCCESS(Status)) 1798 { 1799 WARN(("pfnGetTopology failed Status()0x%x\n", Status)); 1800 return Status; 1801 } 1802 1803 VBOXVIDPN_PATH_ITER PathIter; 1804 const D3DKMDT_VIDPN_PRESENT_PATH * pPath; 1805 VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aVisitedTargetMap); 1806 VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aAdjustedModeMap); 1807 CR_SORTARRAY aModes[VBOX_VIDEO_MAX_SCREENS]; 1808 1809 memset(aVisitedTargetMap, 0, sizeof (aVisitedTargetMap)); 1810 memset(aAdjustedModeMap, 0, sizeof (aAdjustedModeMap)); 1811 memset(aModes, 0, sizeof (aModes)); 1812 1813 /* collect info first */ 1814 VBoxVidPnPathIterInit(&PathIter, hVidPnTopology, pVidPnTopologyInterface); 1815 while ((pPath = VBoxVidPnPathIterNext(&PathIter)) != NULL) 1816 { 1817 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId = pPath->VidPnSourceId; 1818 D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId = pPath->VidPnTargetId; 1819 /* actually vidpn topology should contain only one target info, right? */ 1820 Assert(!ASMBitTest(aVisitedTargetMap, VidPnTargetId)); 1821 ASMBitSet(aVisitedTargetMap, VidPnTargetId); 1822 1823 D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmCurPivot = vboxVidPnCofuncModalityCurrentPathPivot(enmPivot, pPivot, VidPnSourceId, VidPnTargetId); 1824 1825 Status = vboxVidPnCollectInfoForPathTarget(pDevExt, 1826 hVidPn, 1827 pVidPnInterface, 1828 enmCurPivot, 1829 aAdjustedModeMap, 1830 aModes, 1831 VidPnSourceId, VidPnTargetId); 1832 if (!NT_SUCCESS(Status)) 1833 { 1834 WARN(("vboxVidPnCollectInfoForPathTarget failed Status(0x%x\n", Status)); 1835 break; 1836 } 1837 1838 Assert(CrSaCovers(VBoxWddmVModesGet(pDevExt, VidPnTargetId), &aModes[VidPnTargetId])); 1839 1840 Status = vboxVidPnCollectInfoForPathSource(pDevExt, 1841 hVidPn, 1842 pVidPnInterface, 1843 enmCurPivot, 1844 aAdjustedModeMap, 1845 aModes, 1846 VidPnSourceId, VidPnTargetId); 1847 if (!NT_SUCCESS(Status)) 1848 { 1849 WARN(("vboxVidPnCollectInfoForPathSource failed Status(0x%x\n", Status)); 1850 break; 1851 } 1852 1853 Assert(CrSaCovers(VBoxWddmVModesGet(pDevExt, VidPnTargetId), &aModes[VidPnTargetId])); 1854 } 1855 1856 VBoxVidPnPathIterTerm(&PathIter); 1857 1858 if (!NT_SUCCESS(Status)) 1859 goto done; 1860 1861 Status = VBoxVidPnPathIterStatus(&PathIter); 1862 if (!NT_SUCCESS(Status)) 1863 { 1864 WARN(("PathIter failed Status()0x%x\n", Status)); 1865 goto done; 1866 } 1867 1868 /* now we have collected all the necessary info, 1869 * go ahead and apply it */ 1870 memset(aVisitedTargetMap, 0, sizeof (aVisitedTargetMap)); 1871 VBoxVidPnPathIterInit(&PathIter, hVidPnTopology, pVidPnTopologyInterface); 1872 while ((pPath = VBoxVidPnPathIterNext(&PathIter)) != NULL) 1873 { 1874 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId = pPath->VidPnSourceId; 1875 D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId = pPath->VidPnTargetId; 1876 /* actually vidpn topology should contain only one target info, right? */ 1877 Assert(!ASMBitTest(aVisitedTargetMap, VidPnTargetId)); 1878 ASMBitSet(aVisitedTargetMap, VidPnTargetId); 1879 1880 D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmCurPivot = vboxVidPnCofuncModalityCurrentPathPivot(enmPivot, pPivot, VidPnSourceId, VidPnTargetId); 1881 1882 bool bUpdatePath = false; 1883 D3DKMDT_VIDPN_PRESENT_PATH AdjustedPath = {0}; 1884 AdjustedPath.VidPnSourceId = pPath->VidPnSourceId; 1885 AdjustedPath.VidPnTargetId = pPath->VidPnTargetId; 1886 AdjustedPath.ContentTransformation = pPath->ContentTransformation; 1887 AdjustedPath.CopyProtection = pPath->CopyProtection; 1888 1889 if (pPath->ContentTransformation.Scaling == D3DKMDT_VPPS_UNPINNED) 1890 { 1891 AdjustedPath.ContentTransformation.ScalingSupport.Identity = TRUE; 1892 bUpdatePath = true; 1893 } 1894 1895 if (pPath->ContentTransformation.Rotation == D3DKMDT_VPPR_UNPINNED) 1896 { 1897 AdjustedPath.ContentTransformation.RotationSupport.Identity = TRUE; 1898 bUpdatePath = true; 1899 } 1900 1901 if (bUpdatePath) 1902 { 1903 Status = pVidPnTopologyInterface->pfnUpdatePathSupportInfo(hVidPnTopology, &AdjustedPath); 1904 if (!NT_SUCCESS(Status)) 1905 { 1906 WARN(("pfnUpdatePathSupportInfo failed Status()0x%x\n", Status)); 1907 goto done; 1908 } 1909 } 1910 1911 Assert(CrSaCovers(VBoxWddmVModesGet(pDevExt, VidPnTargetId), &aModes[VidPnTargetId])); 1912 1913 Status = vboxVidPnApplyInfoForPathTarget(pDevExt, 1914 hVidPn, 1915 pVidPnInterface, 1916 enmCurPivot, 1917 aAdjustedModeMap, 1918 aModes, 1919 VidPnSourceId, VidPnTargetId); 1920 if (!NT_SUCCESS(Status)) 1921 { 1922 WARN(("vboxVidPnApplyInfoForPathTarget failed Status(0x%x\n", Status)); 1923 break; 1924 } 1925 1926 Status = vboxVidPnApplyInfoForPathSource(pDevExt, 1927 hVidPn, 1928 pVidPnInterface, 1929 enmCurPivot, 1930 aAdjustedModeMap, 1931 aModes, 1932 VidPnSourceId, VidPnTargetId); 1933 if (!NT_SUCCESS(Status)) 1934 { 1935 WARN(("vboxVidPnApplyInfoForPathSource failed Status(0x%x\n", Status)); 1936 break; 1937 } 1938 } 1939 1940 VBoxVidPnPathIterTerm(&PathIter); 1941 1942 if (!NT_SUCCESS(Status)) 1943 goto done; 1944 1945 Status = VBoxVidPnPathIterStatus(&PathIter); 1946 if (!NT_SUCCESS(Status)) 1947 { 1948 WARN(("PathIter failed Status()0x%x\n", Status)); 1949 goto done; 1950 } 1951 1952 done: 1953 1954 for (uint32_t i = 0; i < (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) 1955 { 1956 CrSaCleanup(&aModes[i]); 1957 } 1930 1958 1931 1959 return Status; … … 2399 2427 } 2400 2428 2401 typedef struct VBOXVIDPNCOMMIT2402 {2403 NTSTATUS Status;2404 PVBOXMP_DEVEXT pDevExt;2405 D3DKMDT_HVIDPN hVidPn;2406 const DXGK_VIDPN_INTERFACE* pVidPnInterface;2407 PVBOXWDDM_ALLOCATION pAllocation;2408 VBOXWDDM_SOURCE *paSources;2409 VBOXWDDM_TARGET *paTargets;2410 } VBOXVIDPNCOMMIT, *PVBOXVIDPNCOMMIT;2411 2412 DECLCALLBACK(BOOLEAN) vboxVidPnCommitPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,2413 const D3DKMDT_VIDPN_PRESENT_PATH *pVidPnPresentPathInfo, PVOID pContext)2414 {2415 NTSTATUS Status = STATUS_SUCCESS;2416 PVBOXVIDPNCOMMIT pCommitInfo = (PVBOXVIDPNCOMMIT)pContext;2417 PVBOXMP_DEVEXT pDevExt = pCommitInfo->pDevExt;2418 const D3DKMDT_HVIDPN hDesiredVidPn = pCommitInfo->hVidPn;2419 const DXGK_VIDPN_INTERFACE* pVidPnInterface = pCommitInfo->pVidPnInterface;2420 2421 Status = VBoxVidPnCommitSourceModeForSrcId(pDevExt, hDesiredVidPn, pVidPnInterface, pCommitInfo->pAllocation,2422 pVidPnPresentPathInfo->VidPnSourceId, pCommitInfo->paSources, pCommitInfo->paTargets);2423 if (Status != STATUS_SUCCESS)2424 WARN(("VBoxVidPnCommitSourceModeForSrcId failed Status(0x%x)", Status));2425 2426 pCommitInfo->Status = Status;2427 pVidPnTopologyInterface->pfnReleasePathInfo(hVidPnTopology, pVidPnPresentPathInfo);2428 return Status == STATUS_SUCCESS;2429 }2430 2431 2429 NTSTATUS VBoxVidPnCommitAll(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 2432 2430 PVBOXWDDM_ALLOCATION pAllocation, … … 2461 2459 VBoxVidPnStCleanup(paSources, paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays); 2462 2460 2463 VBOXVIDPNCOMMIT CbContext; 2464 memset(&CbContext, 0, sizeof (CbContext)); 2465 CbContext.pDevExt = pDevExt; 2466 CbContext.hVidPn = hDesiredVidPn; 2467 CbContext.pVidPnInterface = pVidPnInterface; 2468 CbContext.pAllocation = pAllocation; 2469 CbContext.paSources = paSources; 2470 CbContext.paTargets = paTargets; 2471 Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface, 2472 vboxVidPnCommitPathEnum, &CbContext); 2473 if (!NT_SUCCESS(Status)) 2474 { 2475 WARN(("vboxVidPnEnumPaths failed Status 0x%x", Status)); 2461 VBOXVIDPN_PATH_ITER PathIter; 2462 const D3DKMDT_VIDPN_PRESENT_PATH *pPath; 2463 VBoxVidPnPathIterInit(&PathIter, hVidPnTopology, pVidPnTopologyInterface); 2464 while ((pPath = VBoxVidPnPathIterNext(&PathIter)) != NULL) 2465 { 2466 Status = VBoxVidPnCommitSourceModeForSrcId(pDevExt, hDesiredVidPn, pVidPnInterface, pAllocation, 2467 pPath->VidPnSourceId, paSources, paTargets); 2468 if (Status != STATUS_SUCCESS) 2469 { 2470 WARN(("VBoxVidPnCommitSourceModeForSrcId failed Status(0x%x)", Status)); 2471 break; 2472 } 2473 } 2474 2475 VBoxVidPnPathIterTerm(&PathIter); 2476 2477 if (!NT_SUCCESS(Status)) 2478 { 2479 WARN(("")); 2476 2480 return Status; 2477 2481 } 2478 2482 2479 Status = CbContext.Status;2480 if (!NT_SUCCESS(Status)) 2481 { 2482 WARN((" vboxVidPnCommitPathEnumfailed Status 0x%x", Status));2483 Status = VBoxVidPnPathIterStatus(&PathIter); 2484 if (!NT_SUCCESS(Status)) 2485 { 2486 WARN(("VBoxVidPnPathIterStatus failed Status 0x%x", Status)); 2483 2487 return Status; 2484 2488 } 2485 2489 2486 return S tatus;2490 return STATUS_SUCCESS; 2487 2491 } 2488 2492 -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.h
r51269 r52136 48 48 PVBOXWDDM_TARGET VBoxVidPnStTIterNext(VBOXWDDM_TARGET_ITER *pIter); 49 49 50 NTSTATUS vboxVidPnCheckSourceModeInfo(const D3DKMDT_HVIDPN hDesiredVidPn,51 const D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo,52 BOOLEAN *pbSupported);53 54 NTSTATUS vboxVidPnCheckSourceModeSet(const D3DKMDT_HVIDPN hDesiredVidPn,55 D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,56 BOOLEAN *pbSupported);57 58 NTSTATUS vboxVidPnCheckTargetModeInfo(const D3DKMDT_HVIDPN hDesiredVidPn,59 const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo,60 BOOLEAN *pbSupported);61 62 NTSTATUS vboxVidPnCheckTargetModeSet(const D3DKMDT_HVIDPN hDesiredVidPn,63 D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface,64 BOOLEAN *pbSupported);65 66 typedef enum67 {68 VBOXVIDPNPATHITEM_STATE_NOT_EXISTS = 0,69 VBOXVIDPNPATHITEM_STATE_PRESENT,70 VBOXVIDPNPATHITEM_STATE_DISABLED71 } VBOXVIDPNPATHITEM_STATE;72 73 typedef struct VBOXVIDPNPATHITEM74 {75 VBOXVIDPNPATHITEM_STATE enmState;76 } VBOXVIDPNPATHITEM, *PVBOXVIDPNPATHITEM;77 78 typedef struct VBOXVIDPNCOFUNCMODALITY79 {80 NTSTATUS Status;81 PVBOXMP_DEVEXT pDevExt;82 const DXGK_VIDPN_INTERFACE* pVidPnInterface;83 CONST DXGKARG_ENUMVIDPNCOFUNCMODALITY* pEnumCofuncModalityArg;84 PVBOXWDDM_VIDEOMODES_INFO pInfos;85 // UINT cPathInfos;86 // PVBOXVIDPNPATHITEM apPathInfos;87 } VBOXVIDPNCOFUNCMODALITY, *PVBOXVIDPNCOFUNCMODALITY;88 89 50 /* !!!NOTE: The callback is responsible for releasing the path */ 90 51 typedef DECLCALLBACK(BOOLEAN) FNVBOXVIDPNENUMPATHS(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, … … 111 72 typedef FNVBOXVIDPNENUMTARGETSFORSOURCE *PFNVBOXVIDPNENUMTARGETSFORSOURCE; 112 73 113 DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalityPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,114 const D3DKMDT_VIDPN_PRESENT_PATH *pNewVidPnPresentPathInfo, PVOID pContext);115 116 DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalitySourceModeEnum(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,117 D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,118 const D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo, PVOID pContext);119 120 DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalityTargetModeEnum(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,121 D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface,122 const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, PVOID pContext);123 124 74 NTSTATUS VBoxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, 125 75 PVBOXWDDM_ALLOCATION pAllocation, … … 145 95 CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, 146 96 PFNVBOXVIDPNENUMTARGETSFORSOURCE pfnCallback, PVOID pContext); 147 148 NTSTATUS vboxVidPnPopulateMonitorSourceModeInfoFromLegacy(PVBOXMP_DEVEXT pDevExt,149 D3DKMDT_MONITOR_SOURCE_MODE *pMonitorSourceMode,150 D3DKMDT_2DREGION *pResolution,151 D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin,152 BOOLEAN bPreferred);153 154 NTSTATUS vboxVidPnCreatePopulateVidPnPathFromLegacy(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,155 VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iPreferredMode,156 D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions,157 const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId);158 159 NTSTATUS vboxVidPnCheckAddMonitorModes(PVBOXMP_DEVEXT pDevExt,160 D3DDDI_VIDEO_PRESENT_TARGET_ID targetId, D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin,161 D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions, int iPreferred);162 163 NTSTATUS vboxVidPnMatchMonitorModes(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID targetId,164 D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions, BOOLEAN *pfMatch);165 166 NTSTATUS vboxVidPnCofuncModalityForPath(PVBOXVIDPNCOFUNCMODALITY pCbContext, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId);167 168 NTSTATUS VBoxVidPnCheckTopology(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, BOOLEAN *pfSupported);169 170 NTSTATUS vboxVidPnPathAdd(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,171 const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId);172 97 173 98 void vboxVidPnDumpVidPn(const char * pPrefix, PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, const char * pSuffix); … … 178 103 const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, PVOID pContext); 179 104 105 106 typedef struct VBOXVIDPN_SOURCEMODE_ITER 107 { 108 D3DKMDT_HVIDPNSOURCEMODESET hVidPnModeSet; 109 const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnModeSetInterface; 110 const D3DKMDT_VIDPN_SOURCE_MODE *pCurVidPnModeInfo; 111 NTSTATUS Status; 112 } VBOXVIDPN_SOURCEMODE_ITER; 113 114 DECLINLINE(void) VBoxVidPnSourceModeIterInit(VBOXVIDPN_SOURCEMODE_ITER *pIter, D3DKMDT_HVIDPNSOURCEMODESET hVidPnModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnModeSetInterface) 115 { 116 pIter->hVidPnModeSet = hVidPnModeSet; 117 pIter->pVidPnModeSetInterface = pVidPnModeSetInterface; 118 pIter->pCurVidPnModeInfo = NULL; 119 pIter->Status = STATUS_SUCCESS; 120 } 121 122 DECLINLINE(void) VBoxVidPnSourceModeIterTerm(VBOXVIDPN_SOURCEMODE_ITER *pIter) 123 { 124 if (pIter->pCurVidPnModeInfo) 125 { 126 pIter->pVidPnModeSetInterface->pfnReleaseModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo); 127 pIter->pCurVidPnModeInfo = NULL; 128 } 129 } 130 131 DECLINLINE(const D3DKMDT_VIDPN_SOURCE_MODE *) VBoxVidPnSourceModeIterNext(VBOXVIDPN_SOURCEMODE_ITER *pIter) 132 { 133 NTSTATUS Status; 134 const D3DKMDT_VIDPN_SOURCE_MODE *pCurVidPnModeInfo; 135 136 if (!pIter->pCurVidPnModeInfo) 137 Status = pIter->pVidPnModeSetInterface->pfnAcquireFirstModeInfo(pIter->hVidPnModeSet, &pCurVidPnModeInfo); 138 else 139 Status = pIter->pVidPnModeSetInterface->pfnAcquireNextModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo, &pCurVidPnModeInfo); 140 141 if (Status == STATUS_SUCCESS) 142 { 143 Assert(pCurVidPnModeInfo); 144 145 if (pIter->pCurVidPnModeInfo) 146 pIter->pVidPnModeSetInterface->pfnReleaseModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo); 147 148 pIter->pCurVidPnModeInfo = pCurVidPnModeInfo; 149 return pCurVidPnModeInfo; 150 } 151 152 if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET 153 || Status == STATUS_GRAPHICS_DATASET_IS_EMPTY) 154 return NULL; 155 156 WARN(("getting Source info failed %#x", Status)); 157 158 pIter->Status = Status; 159 return NULL; 160 } 161 162 DECLINLINE(NTSTATUS) VBoxVidPnSourceModeIterStatus(VBOXVIDPN_SOURCEMODE_ITER *pIter) 163 { 164 return pIter->Status; 165 } 166 167 typedef struct VBOXVIDPN_TARGETMODE_ITER 168 { 169 D3DKMDT_HVIDPNTARGETMODESET hVidPnModeSet; 170 const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnModeSetInterface; 171 const D3DKMDT_VIDPN_TARGET_MODE *pCurVidPnModeInfo; 172 NTSTATUS Status; 173 } VBOXVIDPN_TARGETMODE_ITER; 174 175 DECLINLINE(void) VBoxVidPnTargetModeIterInit(VBOXVIDPN_TARGETMODE_ITER *pIter,D3DKMDT_HVIDPNTARGETMODESET hVidPnModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnModeSetInterface) 176 { 177 pIter->hVidPnModeSet = hVidPnModeSet; 178 pIter->pVidPnModeSetInterface = pVidPnModeSetInterface; 179 pIter->pCurVidPnModeInfo = NULL; 180 pIter->Status = STATUS_SUCCESS; 181 } 182 183 DECLINLINE(void) VBoxVidPnTargetModeIterTerm(VBOXVIDPN_TARGETMODE_ITER *pIter) 184 { 185 if (pIter->pCurVidPnModeInfo) 186 { 187 pIter->pVidPnModeSetInterface->pfnReleaseModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo); 188 pIter->pCurVidPnModeInfo = NULL; 189 } 190 } 191 192 DECLINLINE(const D3DKMDT_VIDPN_TARGET_MODE *) VBoxVidPnTargetModeIterNext(VBOXVIDPN_TARGETMODE_ITER *pIter) 193 { 194 NTSTATUS Status; 195 const D3DKMDT_VIDPN_TARGET_MODE *pCurVidPnModeInfo; 196 197 if (!pIter->pCurVidPnModeInfo) 198 Status = pIter->pVidPnModeSetInterface->pfnAcquireFirstModeInfo(pIter->hVidPnModeSet, &pCurVidPnModeInfo); 199 else 200 Status = pIter->pVidPnModeSetInterface->pfnAcquireNextModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo, &pCurVidPnModeInfo); 201 202 if (Status == STATUS_SUCCESS) 203 { 204 Assert(pCurVidPnModeInfo); 205 206 if (pIter->pCurVidPnModeInfo) 207 pIter->pVidPnModeSetInterface->pfnReleaseModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo); 208 209 pIter->pCurVidPnModeInfo = pCurVidPnModeInfo; 210 return pCurVidPnModeInfo; 211 } 212 213 if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET 214 || Status == STATUS_GRAPHICS_DATASET_IS_EMPTY) 215 return NULL; 216 217 WARN(("getting Target info failed %#x", Status)); 218 219 pIter->Status = Status; 220 return NULL; 221 } 222 223 DECLINLINE(NTSTATUS) VBoxVidPnTargetModeIterStatus(VBOXVIDPN_TARGETMODE_ITER *pIter) 224 { 225 return pIter->Status; 226 } 227 228 229 typedef struct VBOXVIDPN_MONITORMODE_ITER 230 { 231 D3DKMDT_HMONITORSOURCEMODESET hVidPnModeSet; 232 const DXGK_MONITORSOURCEMODESET_INTERFACE *pVidPnModeSetInterface; 233 const D3DKMDT_MONITOR_SOURCE_MODE *pCurVidPnModeInfo; 234 NTSTATUS Status; 235 } VBOXVIDPN_MONITORMODE_ITER; 236 237 238 DECLINLINE(void) VBoxVidPnMonitorModeIterInit(VBOXVIDPN_MONITORMODE_ITER *pIter, D3DKMDT_HMONITORSOURCEMODESET hVidPnModeSet, const DXGK_MONITORSOURCEMODESET_INTERFACE *pVidPnModeSetInterface) 239 { 240 pIter->hVidPnModeSet = hVidPnModeSet; 241 pIter->pVidPnModeSetInterface = pVidPnModeSetInterface; 242 pIter->pCurVidPnModeInfo = NULL; 243 pIter->Status = STATUS_SUCCESS; 244 } 245 246 DECLINLINE(void) VBoxVidPnMonitorModeIterTerm(VBOXVIDPN_MONITORMODE_ITER *pIter) 247 { 248 if (pIter->pCurVidPnModeInfo) 249 { 250 pIter->pVidPnModeSetInterface->pfnReleaseModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo); 251 pIter->pCurVidPnModeInfo = NULL; 252 } 253 } 254 255 DECLINLINE(const D3DKMDT_MONITOR_SOURCE_MODE *) VBoxVidPnMonitorModeIterNext(VBOXVIDPN_MONITORMODE_ITER *pIter) 256 { 257 NTSTATUS Status; 258 const D3DKMDT_MONITOR_SOURCE_MODE *pCurVidPnModeInfo; 259 260 if (!pIter->pCurVidPnModeInfo) 261 Status = pIter->pVidPnModeSetInterface->pfnAcquireFirstModeInfo(pIter->hVidPnModeSet, &pCurVidPnModeInfo); 262 else 263 Status = pIter->pVidPnModeSetInterface->pfnAcquireNextModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo, &pCurVidPnModeInfo); 264 265 if (Status == STATUS_SUCCESS) 266 { 267 Assert(pCurVidPnModeInfo); 268 269 if (pIter->pCurVidPnModeInfo) 270 pIter->pVidPnModeSetInterface->pfnReleaseModeInfo(pIter->hVidPnModeSet, pIter->pCurVidPnModeInfo); 271 272 pIter->pCurVidPnModeInfo = pCurVidPnModeInfo; 273 return pCurVidPnModeInfo; 274 } 275 276 if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET 277 || Status == STATUS_GRAPHICS_DATASET_IS_EMPTY) 278 return NULL; 279 280 WARN(("getting Monitor info failed %#x", Status)); 281 282 pIter->Status = Status; 283 return NULL; 284 } 285 286 DECLINLINE(NTSTATUS) VBoxVidPnMonitorModeIterStatus(VBOXVIDPN_MONITORMODE_ITER *pIter) 287 { 288 return pIter->Status; 289 } 290 291 292 293 typedef struct VBOXVIDPN_PATH_ITER 294 { 295 D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology; 296 const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface; 297 const D3DKMDT_VIDPN_PRESENT_PATH *pCurVidPnPathInfo; 298 NTSTATUS Status; 299 } VBOXVIDPN_PATH_ITER; 300 301 302 DECLINLINE(void) VBoxVidPnPathIterInit(VBOXVIDPN_PATH_ITER *pIter, D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface) 303 { 304 pIter->hVidPnTopology = hVidPnTopology; 305 pIter->pVidPnTopologyInterface = pVidPnTopologyInterface; 306 pIter->pCurVidPnPathInfo = NULL; 307 pIter->Status = STATUS_SUCCESS; 308 } 309 310 DECLINLINE(void) VBoxVidPnPathIterTerm(VBOXVIDPN_PATH_ITER *pIter) 311 { 312 if (pIter->pCurVidPnPathInfo) 313 { 314 pIter->pVidPnTopologyInterface->pfnReleasePathInfo(pIter->hVidPnTopology, pIter->pCurVidPnPathInfo); 315 pIter->pCurVidPnPathInfo = NULL; 316 } 317 } 318 319 DECLINLINE(const D3DKMDT_VIDPN_PRESENT_PATH *) VBoxVidPnPathIterNext(VBOXVIDPN_PATH_ITER *pIter) 320 { 321 NTSTATUS Status; 322 const D3DKMDT_VIDPN_PRESENT_PATH *pCurVidPnPathInfo; 323 324 if (!pIter->pCurVidPnPathInfo) 325 Status = pIter->pVidPnTopologyInterface->pfnAcquireFirstPathInfo(pIter->hVidPnTopology, &pCurVidPnPathInfo); 326 else 327 Status = pIter->pVidPnTopologyInterface->pfnAcquireNextPathInfo(pIter->hVidPnTopology, pIter->pCurVidPnPathInfo, &pCurVidPnPathInfo); 328 329 if (Status == STATUS_SUCCESS) 330 { 331 Assert(pCurVidPnPathInfo); 332 333 if (pIter->pCurVidPnPathInfo) 334 pIter->pVidPnTopologyInterface->pfnReleasePathInfo(pIter->hVidPnTopology, pIter->pCurVidPnPathInfo); 335 336 pIter->pCurVidPnPathInfo = pCurVidPnPathInfo; 337 return pCurVidPnPathInfo; 338 } 339 340 if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET 341 || Status == STATUS_GRAPHICS_DATASET_IS_EMPTY) 342 return NULL; 343 344 WARN(("getting Path info failed %#x", Status)); 345 346 pIter->Status = Status; 347 return NULL; 348 } 349 350 DECLINLINE(NTSTATUS) VBoxVidPnPathIterStatus(VBOXVIDPN_PATH_ITER *pIter) 351 { 352 return pIter->Status; 353 } 354 355 NTSTATUS VBoxVidPnRecommendMonitorModes(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VideoPresentTargetId, 356 D3DKMDT_HMONITORSOURCEMODESET hVidPnModeSet, const DXGK_MONITORSOURCEMODESET_INTERFACE *pVidPnModeSetInterface); 357 358 NTSTATUS VBoxVidPnRecommendFunctional(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, const VBOXWDDM_RECOMMENDVIDPN *pData); 359 360 NTSTATUS VBoxVidPnCofuncModality(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE enmPivot, const DXGK_ENUM_PIVOT *pPivot); 361 362 NTSTATUS VBoxVidPnIsSupported(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPN hVidPn, BOOLEAN *pfSupported); 363 364 NTSTATUS VBoxVidPnUpdateModes(PVBOXMP_DEVEXT pDevExt, uint32_t u32TargetId, const RTRECTSIZE *pSize); 365 180 366 #endif /* #ifndef ___VBoxMPVidPn_h___ */ -
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp
r51920 r52136 532 532 bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource) 533 533 { 534 bool fReportTargets = !pDevExt-> cContextsDispIfResize;534 bool fReportTargets = !pDevExt->fDisableTargetUpdate; 535 535 return vboxWddmGhDisplayCheckSetInfoFromSourceEx(pDevExt, pSource, fReportTargets); 536 536 } … … 629 629 void vboxWddmGhDisplayCheckSetInfoForDisabledTargetsCheck(PVBOXMP_DEVEXT pDevExt) 630 630 { 631 bool fReportTargets = !pDevExt-> cContextsDispIfResize;631 bool fReportTargets = !pDevExt->fDisableTargetUpdate; 632 632 633 633 if (fReportTargets) … … 649 649 void vboxWddmGhDisplayCheckSetInfo(PVBOXMP_DEVEXT pDevExt) 650 650 { 651 bool fReportTargets = !pDevExt-> cContextsDispIfResize;651 bool fReportTargets = !pDevExt->fDisableTargetUpdate; 652 652 vboxWddmGhDisplayCheckSetInfoEx(pDevExt, fReportTargets); 653 653 } … … 1154 1154 pDevExt->cContextsDispIfResize = 0; 1155 1155 pDevExt->cUnlockedVBVADisabled = 0; 1156 pDevExt->fDisableTargetUpdate = 0; 1156 1157 VBOXWDDM_CTXLOCK_INIT(pDevExt); 1157 1158 KeInitializeSpinLock(&pDevExt->SynchLock); 1158 1159 VBoxMPCmnInitCustomVideoModes(pDevExt);1160 1159 1161 1160 VBoxCommonFromDeviceExt(pDevExt)->fAnyX = VBoxVideoAnyWidthAllowed(); … … 1278 1277 #endif 1279 1278 1280 VBoxWddm InitVideoModes(pDevExt);1279 VBoxWddmVModesInit(pDevExt); 1281 1280 } 1282 1281 else … … 1965 1964 PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext; 1966 1965 1966 if (ChildStatus->ChildUid >= (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays) 1967 { 1968 WARN(("Invalid child id %d", ChildStatus->ChildUid)); 1969 return STATUS_INVALID_PARAMETER; 1970 } 1971 1967 1972 NTSTATUS Status = STATUS_SUCCESS; 1968 1973 switch (ChildStatus->Type) … … 1972 1977 LOGF(("StatusConnection")); 1973 1978 VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[ChildStatus->ChildUid]; 1979 BOOLEAN Connected = !!pTarget->fConnected; 1980 if (!Connected) 1981 LOGREL(("Tgt[%d] DISCONNECTED!!", ChildStatus->ChildUid)); 1974 1982 ChildStatus->HotPlug.Connected = !!pTarget->fConnected; 1975 1983 break; … … 4586 4594 } 4587 4595 #endif 4588 case VBOXESC_REINITVIDEOMODES: 4589 { 4596 case VBOXESC_CONFIGURETARGETS: 4597 { 4598 LOG(("=> VBOXESC_CONFIGURETARGETS")); 4599 4590 4600 if (!pEscape->Flags.HardwareAccess) 4591 4601 { 4592 WARN(("VBOXESC_ REINITVIDEOMODESBYMASKcalled without HardwareAccess flag set, failing"));4602 WARN(("VBOXESC_CONFIGURETARGETS called without HardwareAccess flag set, failing")); 4593 4603 Status = STATUS_INVALID_PARAMETER; 4594 4604 break; … … 4600 4610 if (!pContext) 4601 4611 { 4602 WARN(("VBOXESC_REINITVIDEOMODES no context supplied!"));4603 Status = STATUS_INVALID_PARAMETER;4604 break;4605 }4606 4607 if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE)4608 {4609 WARN(("VBOXESC_REINITVIDEOMODES invalid context supplied %d!", pContext->enmType));4610 Status = STATUS_INVALID_PARAMETER;4611 break;4612 }4613 #endif4614 4615 WARN(("VBOXESC_REINITVIDEOMODESBYMASK should be called instead"));4616 VBoxWddmUpdateVideoModesInfoByMask(pDevExt, NULL);4617 Status = STATUS_SUCCESS;4618 break;4619 }4620 case VBOXESC_REINITVIDEOMODESBYMASK:4621 {4622 if (!pEscape->Flags.HardwareAccess)4623 {4624 WARN(("VBOXESC_REINITVIDEOMODESBYMASK called without HardwareAccess flag set, failing"));4625 Status = STATUS_INVALID_PARAMETER;4626 break;4627 }4628 4629 #ifdef VBOX_DISPIF_WITH_OPCONTEXT4630 /* win8.1 does not allow context-based escapes for display-only mode */4631 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;4632 if (!pContext)4633 {4634 WARN(("VBOXESC_REINITVIDEOMODESBYMASK no context supplied!"));4635 Status = STATUS_INVALID_PARAMETER;4636 break;4637 }4638 4639 if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE)4640 {4641 WARN(("VBOXESC_REINITVIDEOMODESBYMASK invalid context supplied %d!", pContext->enmType));4642 Status = STATUS_INVALID_PARAMETER;4643 break;4644 }4645 #endif4646 4647 if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK))4648 {4649 WARN(("invalid private driver size %d", pEscape->PrivateDriverDataSize));4650 Status = STATUS_INVALID_PARAMETER;4651 break;4652 }4653 LOG(("=> VBOXESC_REINITVIDEOMODESBYMASK"));4654 PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK pData = (PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK)pEscapeHdr;4655 VBoxWddmUpdateVideoModesInfoByMask(pDevExt, pData->ScreenMask);4656 Status = STATUS_SUCCESS;4657 LOG(("<= VBOXESC_REINITVIDEOMODESBYMASK"));4658 break;4659 }4660 case VBOXESC_CONFIGURETARGETS:4661 {4662 LOG(("=> VBOXESC_CONFIGURETARGETS"));4663 4664 if (!pEscape->Flags.HardwareAccess)4665 {4666 WARN(("VBOXESC_CONFIGURETARGETS called without HardwareAccess flag set, failing"));4667 Status = STATUS_INVALID_PARAMETER;4668 break;4669 }4670 4671 #ifdef VBOX_DISPIF_WITH_OPCONTEXT4672 /* win8.1 does not allow context-based escapes for display-only mode */4673 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;4674 if (!pContext)4675 {4676 4612 WARN(("VBOXESC_CONFIGURETARGETS no context supplied!")); 4677 4613 Status = STATUS_INVALID_PARAMETER; … … 4715 4651 if (!pTarget->fConnected) 4716 4652 { 4717 Status = vboxWddmChildStatusConnect(pDevExt, (uint32_t)i, TRUE);4653 Status = VBoxWddmChildStatusConnect(pDevExt, (uint32_t)i, TRUE); 4718 4654 if (NT_SUCCESS(Status)) 4719 4655 ++cAdjusted; … … 4755 4691 break; 4756 4692 } 4757 case VBOXESC_ADJUSTVIDEOMODES:4758 {4759 if (!pEscape->Flags.HardwareAccess)4760 {4761 WARN(("VBOXESC_ADJUSTVIDEOMODES called without HardwareAccess flag set, failing"));4762 Status = STATUS_INVALID_PARAMETER;4763 break;4764 }4765 4766 uint32_t cModes = pEscapeHdr->u32CmdSpecific;4767 if (cModes > VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXDISPIFESCAPE_ADJUSTVIDEOMODES, aScreenInfos)4768 || pEscape->PrivateDriverDataSize != RT_OFFSETOF(VBOXDISPIFESCAPE_ADJUSTVIDEOMODES, aScreenInfos[cModes]))4769 {4770 WARN(("invalid modes count passed"));4771 Status = STATUS_INVALID_PARAMETER;4772 break;4773 }4774 4775 PVBOXDISPIFESCAPE_ADJUSTVIDEOMODES pPodesInfo = (PVBOXDISPIFESCAPE_ADJUSTVIDEOMODES)pEscapeHdr;4776 VBoxWddmAdjustModes(pDevExt, cModes, pPodesInfo->aScreenInfos);4777 Status = STATUS_SUCCESS;4778 break;4779 }4780 4693 case VBOXESC_SETALLOCHOSTID: 4781 4694 { … … 4916 4829 pIsAnyX->u32IsAnyX = VBoxCommonFromDeviceExt(pDevExt)->fAnyX; 4917 4830 Status = STATUS_SUCCESS; 4831 break; 4832 } 4833 case VBOXESC_UPDATEMODES: 4834 { 4835 LOG(("=> VBOXESC_UPDATEMODES")); 4836 4837 if (!pEscape->Flags.HardwareAccess) 4838 { 4839 WARN(("VBOXESC_UPDATEMODES called without HardwareAccess flag set, failing")); 4840 Status = STATUS_INVALID_PARAMETER; 4841 break; 4842 } 4843 4844 #ifdef VBOX_DISPIF_WITH_OPCONTEXT 4845 /* win8.1 does not allow context-based escapes for display-only mode */ 4846 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext; 4847 if (!pContext) 4848 { 4849 WARN(("VBOXESC_UPDATEMODES no context supplied!")); 4850 Status = STATUS_INVALID_PARAMETER; 4851 break; 4852 } 4853 4854 if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE) 4855 { 4856 WARN(("VBOXESC_UPDATEMODES invalid context supplied %d!", pContext->enmType)); 4857 Status = STATUS_INVALID_PARAMETER; 4858 break; 4859 } 4860 #endif 4861 4862 if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_UPDATEMODES)) 4863 { 4864 WARN(("VBOXESC_UPDATEMODES invalid private driver size %d", pEscape->PrivateDriverDataSize)); 4865 Status = STATUS_INVALID_PARAMETER; 4866 break; 4867 } 4868 4869 VBOXDISPIFESCAPE_UPDATEMODES *pData = (VBOXDISPIFESCAPE_UPDATEMODES*)pEscapeHdr; 4870 Status = VBoxVidPnUpdateModes(pDevExt, pData->u32TargetId, &pData->Size); 4871 if (!NT_SUCCESS(Status)) 4872 { 4873 WARN(("VBoxVidPnUpdateModes failed Status(%#x)\n", Status)); 4874 return Status; 4875 } 4876 4918 4877 break; 4919 4878 } … … 5087 5046 vboxVDbgBreakFv(); 5088 5047 5089 NTSTATUS Status = STATUS_SUCCESS;5090 5091 5048 PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter; 5092 const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL; 5093 Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pIsSupportedVidPnArg->hDesiredVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface); 5049 NTSTATUS Status = VBoxVidPnIsSupported(pDevExt, pIsSupportedVidPnArg->hDesiredVidPn, &pIsSupportedVidPnArg->IsVidPnSupported); 5094 5050 if (!NT_SUCCESS(Status)) 5095 5051 { 5096 WARN((" DxgkCbQueryVidPnInterface failed Status()0x%x\n", Status));5052 WARN(("VBoxVidPnIsSupported failed Status(%#x)\n", Status)); 5097 5053 return Status; 5098 5054 } 5099 5055 5100 #ifdef VBOXWDDM_DEBUG_VIDPN5101 vboxVidPnDumpVidPn("\n>>>>IS SUPPORTED VidPN : >>>>", pDevExt, pIsSupportedVidPnArg->hDesiredVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<");5102 #endif5103 5104 D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology;5105 const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;5106 Status = pVidPnInterface->pfnGetTopology(pIsSupportedVidPnArg->hDesiredVidPn, &hVidPnTopology, &pVidPnTopologyInterface);5107 if (!NT_SUCCESS(Status))5108 {5109 WARN(("pfnGetTopology failed Status()0x%x\n", Status));5110 return Status;5111 }5112 5113 BOOLEAN fSupported = FALSE;5114 Status = VBoxVidPnCheckTopology(pDevExt, hVidPnTopology, pVidPnTopologyInterface, &fSupported);5115 if (!NT_SUCCESS(Status))5116 {5117 WARN(("VBoxVidPnCheckTopology failed Status()0x%x\n", Status));5118 return Status;5119 }5120 5121 if (!fSupported)5122 LOG(("found unsupported path"));5123 5124 pIsSupportedVidPnArg->IsVidPnSupported = fSupported;5125 5126 #ifdef VBOXWDDM_DEBUG_VIDPN5127 LOGREL(("The Given VidPn is %ssupported\n", pIsSupportedVidPnArg->IsVidPnSupported ? "" : "!!NOT!! "));5128 #endif5129 5130 5056 LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter)); 5131 5057 5132 return S tatus;5058 return STATUS_SUCCESS; 5133 5059 } 5134 5060 … … 5147 5073 vboxVDbgBreakFv(); 5148 5074 5149 #ifdef DEBUG_misha5150 Assert(0);5151 #endif5152 5153 5075 PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter; 5154 NTSTATUS Status; 5155 PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo = pRecommendFunctionalVidPnArg->PrivateDriverDataSize >= sizeof (VBOXWDDM_RECOMMENDVIDPN) ? 5156 (PVBOXWDDM_RECOMMENDVIDPN)pRecommendFunctionalVidPnArg->pPrivateDriverData : NULL; 5157 PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmGetAllVideoModesInfos(pDevExt); 5158 int i; 5159 5160 for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) 5161 { 5162 /* @todo: check that we actually need the current source->target */ 5163 PVBOXWDDM_VIDEOMODES_INFO pInfo = &pInfos[i]; 5164 VIDEO_MODE_INFORMATION *pModeInfo = &pInfo->aModes[pInfo->iPreferredMode]; 5165 #if 0 5166 D3DKMDT_2DREGION Resolution; 5167 Resolution.cx = pModeInfo->VisScreenWidth; 5168 Resolution.cy = pModeInfo->VisScreenHeight; 5169 Status = vboxVidPnCheckAddMonitorModes(pDevExt, i, D3DKMDT_MCO_DRIVER, &Resolution, 1, 0); 5170 #else 5171 Status = vboxVidPnCheckAddMonitorModes(pDevExt, i, D3DKMDT_MCO_DRIVER, pInfo->aResolutions, pInfo->cResolutions, pInfo->iPreferredResolution); 5172 #endif 5173 if (Status != STATUS_SUCCESS) 5174 { 5175 WARN(("vboxVidPnCheckAddMonitorModes failed Status(0x%x)", Status)); 5176 break; 5177 } 5178 } 5179 5180 const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL; 5181 Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface); 5076 5077 if (pRecommendFunctionalVidPnArg->PrivateDriverDataSize != sizeof (VBOXWDDM_RECOMMENDVIDPN)) 5078 { 5079 WARN(("invalid size")); 5080 return STATUS_INVALID_PARAMETER; 5081 } 5082 5083 VBOXWDDM_RECOMMENDVIDPN *pData = (VBOXWDDM_RECOMMENDVIDPN*)pRecommendFunctionalVidPnArg->pPrivateDriverData; 5084 Assert(pData); 5085 5086 NTSTATUS Status = VBoxVidPnRecommendFunctional(pDevExt, pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pData); 5182 5087 if (!NT_SUCCESS(Status)) 5183 5088 { 5184 WARN((" DxgkCbQueryVidPnInterface failed Status(0x%x)", Status));5089 WARN(("VBoxVidPnRecommendFunctional failed %#x", Status)); 5185 5090 return Status; 5186 5091 } 5187 5092 5188 for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)5189 {5190 Status = vboxVidPnPathAdd(pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pVidPnInterface, i, i);5191 if (!NT_SUCCESS(Status))5192 {5193 WARN(("vboxVidPnPathAdd failed Status(0x%x)", Status));5194 return Status;5195 }5196 }5197 5198 VIDEO_MODE_INFORMATION *pResModes = NULL;5199 uint32_t cResModes = 0;5200 5201 for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)5202 {5203 D3DKMDT_2DREGION Resolution;5204 PVBOXWDDM_VIDEOMODES_INFO pInfo = &pInfos[i];5205 VIDEO_MODE_INFORMATION *pModeInfo = &pInfo->aModes[pInfo->iPreferredMode];5206 Resolution.cx = pModeInfo->VisScreenWidth;5207 Resolution.cy = pModeInfo->VisScreenHeight;5208 int32_t iPreferableResMode;5209 uint32_t cActualResModes;5210 5211 Status = VBoxWddmGetModesForResolution(pInfo->aModes, pInfo->cModes, pInfo->iPreferredMode, &Resolution,5212 pResModes, cResModes, &cActualResModes, &iPreferableResMode);5213 Assert(Status == STATUS_SUCCESS || Status == STATUS_BUFFER_TOO_SMALL);5214 if (Status == STATUS_BUFFER_TOO_SMALL)5215 {5216 Assert(cResModes < cActualResModes);5217 if (pResModes)5218 {5219 vboxWddmMemFree(pResModes);5220 }5221 pResModes = (VIDEO_MODE_INFORMATION*)vboxWddmMemAllocZero(sizeof (*pResModes) * cActualResModes);5222 Assert(pResModes);5223 if (!pResModes)5224 {5225 Status = STATUS_NO_MEMORY;5226 break;5227 }5228 cResModes = cActualResModes;5229 Status = VBoxWddmGetModesForResolution(pInfo->aModes, pInfo->cModes, pInfo->iPreferredMode, &Resolution,5230 pResModes, cResModes, &cActualResModes, &iPreferableResMode);5231 Assert(Status == STATUS_SUCCESS);5232 if (Status != STATUS_SUCCESS)5233 break;5234 }5235 else if (Status != STATUS_SUCCESS)5236 break;5237 5238 Assert(iPreferableResMode >= 0);5239 Assert(cActualResModes);5240 5241 Status = vboxVidPnCreatePopulateVidPnPathFromLegacy(pDevExt, pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pVidPnInterface,5242 pResModes, cActualResModes, iPreferableResMode,5243 &Resolution, 1 /* cResolutions */,5244 i, i); /* srcId, tgtId */5245 Assert(Status == STATUS_SUCCESS);5246 if (Status != STATUS_SUCCESS)5247 {5248 LOGREL(("vboxVidPnCreatePopulateVidPnFromLegacy failed Status(0x%x)", Status));5249 break;5250 }5251 }5252 5253 if(pResModes)5254 vboxWddmMemFree(pResModes);5255 5256 #ifdef VBOXWDDM_DEBUG_VIDPN5257 vboxVidPnDumpVidPn("\n>>>>Recommended VidPN: >>>>", pDevExt, pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n");5258 #endif5259 5260 5093 LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter)); 5261 5094 5262 return S tatus;5095 return STATUS_SUCCESS; 5263 5096 } 5264 5097 … … 5278 5111 5279 5112 PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter; 5280 const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL; 5281 NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pEnumCofuncModalityArg->hConstrainingVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);5113 5114 NTSTATUS Status = VBoxVidPnCofuncModality(pDevExt, pEnumCofuncModalityArg->hConstrainingVidPn, pEnumCofuncModalityArg->EnumPivotType, &pEnumCofuncModalityArg->EnumPivot); 5282 5115 if (!NT_SUCCESS(Status)) 5283 5116 { 5284 WARN((" DxgkCbQueryVidPnInterface failed Status()0x%x\n", Status));5117 WARN(("VBoxVidPnCofuncModality failed Status(%#x)\n", Status)); 5285 5118 return Status; 5286 5119 } 5287 #ifdef VBOXWDDM_DEBUG_VIDPN5288 vboxVidPnDumpCofuncModalityArg(">>>>MODALITY Args: ", pEnumCofuncModalityArg, "\n");5289 vboxVidPnDumpVidPn(">>>>MODALITY VidPN (IN) : >>>>\n", pDevExt, pEnumCofuncModalityArg->hConstrainingVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n");5290 #endif5291 5292 D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology;5293 const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;5294 Status = pVidPnInterface->pfnGetTopology(pEnumCofuncModalityArg->hConstrainingVidPn, &hVidPnTopology, &pVidPnTopologyInterface);5295 Assert(Status == STATUS_SUCCESS);5296 if (!NT_SUCCESS(Status))5297 {5298 WARN(("pfnGetTopology failed Status()0x%x\n", Status));5299 return Status;5300 }5301 5302 #ifdef DEBUG_misha5303 {5304 BOOLEAN fSupported = FALSE;5305 Status = VBoxVidPnCheckTopology(pDevExt, hVidPnTopology, pVidPnTopologyInterface, &fSupported);5306 if (!NT_SUCCESS(Status))5307 WARN(("VBoxVidPnCheckTopology failed Status()0x%x\n", Status));5308 5309 Assert(fSupported);5310 }5311 #endif5312 VBOXVIDPNCOFUNCMODALITY CbContext = {0};5313 CbContext.pDevExt = pDevExt;5314 CbContext.pVidPnInterface = pVidPnInterface;5315 CbContext.pEnumCofuncModalityArg = pEnumCofuncModalityArg;5316 CbContext.pInfos = VBoxWddmGetAllVideoModesInfos(pDevExt);5317 5318 Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface,5319 vboxVidPnCofuncModalityPathEnum, &CbContext);5320 if (!NT_SUCCESS(Status))5321 {5322 WARN(("vboxVidPnEnumPaths failed Status()0x%x\n", Status));5323 return Status;5324 }5325 5326 Status = CbContext.Status;5327 if (!NT_SUCCESS(Status))5328 {5329 WARN(("vboxVidPnCofuncModalityPathEnum failed Status()0x%x\n", Status));5330 return Status;5331 }5332 5333 #ifdef VBOXWDDM_DEBUG_VIDPN5334 vboxVidPnDumpVidPn("\n>>>>MODALITY VidPN (OUT) : >>>>\n", pDevExt, pEnumCofuncModalityArg->hConstrainingVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n\n");5335 #endif5336 5120 5337 5121 LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter)); 5338 5122 5339 return S tatus;5123 return STATUS_SUCCESS; 5340 5124 } 5341 5125 … … 5361 5145 POINT Pos; 5362 5146 Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &Pos); 5363 Assert(Status == STATUS_SUCCESS);5147 //Assert(Status == STATUS_SUCCESS); 5364 5148 if (NT_SUCCESS(Status)) 5365 5149 { … … 5445 5229 POINT Pos; 5446 5230 Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &Pos); 5447 Assert(Status == STATUS_SUCCESS);5231 //Assert(Status == STATUS_SUCCESS); 5448 5232 if (NT_SUCCESS(Status)) 5449 5233 { … … 5602 5386 5603 5387 PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter; 5604 NTSTATUS Status; 5605 PVBOXWDDM_VIDEOMODES_INFO pInfo = VBoxWddmGetVideoModesInfo(pDevExt, pRecommendMonitorModesArg->VideoPresentTargetId); 5606 PVIDEO_MODE_INFORMATION pPreferredMode = &pInfo->aModes[pInfo->iPreferredMode]; 5607 5608 5609 for (uint32_t i = 0; i < pInfo->cResolutions; i++) 5610 { 5611 D3DKMDT_MONITOR_SOURCE_MODE * pNewMonitorSourceModeInfo; 5612 Status = pRecommendMonitorModesArg->pMonitorSourceModeSetInterface->pfnCreateNewModeInfo( 5613 pRecommendMonitorModesArg->hMonitorSourceModeSet, &pNewMonitorSourceModeInfo); 5614 Assert(Status == STATUS_SUCCESS); 5615 if (Status == STATUS_SUCCESS) 5616 { 5617 Status = vboxVidPnPopulateMonitorSourceModeInfoFromLegacy(pDevExt, 5618 pNewMonitorSourceModeInfo, 5619 &pInfo->aResolutions[i], 5620 D3DKMDT_MCO_DRIVER, 5621 pPreferredMode->VisScreenWidth == pInfo->aResolutions[i].cx 5622 && pPreferredMode->VisScreenHeight == pInfo->aResolutions[i].cy); 5623 Assert(Status == STATUS_SUCCESS); 5624 if (Status == STATUS_SUCCESS) 5625 { 5626 Status = pRecommendMonitorModesArg->pMonitorSourceModeSetInterface->pfnAddMode( 5627 pRecommendMonitorModesArg->hMonitorSourceModeSet, pNewMonitorSourceModeInfo); 5628 Assert(Status == STATUS_SUCCESS); 5629 if (Status == STATUS_SUCCESS) 5630 continue; 5631 } 5632 5633 /* error has occurred, release & break */ 5634 pRecommendMonitorModesArg->pMonitorSourceModeSetInterface->pfnReleaseModeInfo( 5635 pRecommendMonitorModesArg->hMonitorSourceModeSet, pNewMonitorSourceModeInfo); 5636 break; 5637 } 5388 5389 NTSTATUS Status = VBoxVidPnRecommendMonitorModes(pDevExt, pRecommendMonitorModesArg->VideoPresentTargetId, 5390 pRecommendMonitorModesArg->hMonitorSourceModeSet, pRecommendMonitorModesArg->pMonitorSourceModeSetInterface); 5391 if (!NT_SUCCESS(Status)) 5392 { 5393 WARN(("VBoxVidPnRecommendMonitorModes failed %#x", Status)); 5394 return Status; 5638 5395 } 5639 5396 5640 5397 LOGF(("LEAVE, hAdapter(0x%x)", hAdapter)); 5641 5398 5642 return S tatus;5399 return STATUS_SUCCESS; 5643 5400 } 5644 5401 … … 5670 5427 5671 5428 #ifdef DEBUG_misha 5672 RT_BREAKPOINT();5429 // RT_BREAKPOINT(); 5673 5430 #endif 5674 5431 … … 6991 6748 pDevExt->aSources[i].u8SyncState = 0; 6992 6749 NTSTATUS tmpStatus= vboxWddmDisplaySettingsQueryPos(pDevExt, i, &pDevExt->aSources[i].VScreenPos); 6993 Assert(tmpStatus == STATUS_SUCCESS);6750 //Assert(tmpStatus == STATUS_SUCCESS); 6994 6751 } 6995 6752 #ifdef VBOX_WITH_CROGL … … 7207 6964 Assert(cContexts < UINT32_MAX/2); 7208 6965 if (!cContexts) 7209 vboxWddmGhDisplayCheckSetInfoEx(pDevExt, true); 6966 { 6967 if (pDevExt->fDisableTargetUpdate) 6968 { 6969 pDevExt->fDisableTargetUpdate = FALSE; 6970 vboxWddmGhDisplayCheckSetInfoEx(pDevExt, true); 6971 } 6972 } 7210 6973 break; 7211 6974 } -
trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDispIf.cpp
r51469 r52136 1 1 /** @file 2 * VBox DispIf.cpp - Display Settings Interface abstraction for XPDM & WDDM.2 * VBoxTray - Display Settings Interface abstraction for XPDM & WDDM 3 3 */ 4 4 5 5 /* 6 * Copyright (C) 2006-201 4Oracle Corporation6 * Copyright (C) 2006-2012 Oracle Corporation 7 7 * 8 8 * This file is part of VirtualBox Open Source Edition (OSE), as … … 14 14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. 15 15 */ 16 16 17 #include "VBoxTray.h" 17 #include "VBoxDisplay.h"18 19 #include <malloc.h>20 18 #define _WIN32_WINNT 0x0601 21 22 19 #include <iprt/log.h> 23 20 #include <iprt/err.h> 24 21 #include <iprt/assert.h> 25 22 23 #include <malloc.h> 24 26 25 #ifdef VBOX_WITH_WDDM 27 26 #include <iprt/asm.h> 28 27 #endif 29 28 30 29 #include "VBoxDisplay.h" 31 30 32 31 #ifndef NT_SUCCESS … … 85 84 if (winEr != ERROR_SUCCESS) 86 85 { 87 LogFlowFunc(("Failed calling GetDisplayConfigBufferSizes, dwErr=%ld\n", winEr));86 WARN(("VBoxTray: (WDDM) Failed GetDisplayConfigBufferSizes\n")); 88 87 return winEr; 89 88 } 90 89 91 /** @todo r=andy Why using malloc() instead of RTMemAlloc*? */92 90 pPathInfoArray = (DISPLAYCONFIG_PATH_INFO *)malloc(cPathInfoArray * sizeof(DISPLAYCONFIG_PATH_INFO)); 93 91 if (!pPathInfoArray) 94 92 { 95 LogFlowFunc(("Allocating pPathInfoArray failed\n"));93 WARN(("VBoxTray: (WDDM) malloc failed!\n")); 96 94 return ERROR_OUTOFMEMORY; 97 95 } … … 99 97 if (!pModeInfoArray) 100 98 { 101 LogFlowFunc(("Allocating pModeInfoArray failed\n"));99 WARN(("VBoxTray: (WDDM) malloc failed!\n")); 102 100 free(pPathInfoArray); 103 101 return ERROR_OUTOFMEMORY; … … 107 105 if (winEr != ERROR_SUCCESS) 108 106 { 109 LogFlowFunc(("Failed calling QueryDisplayConfig, dwErr=%ld\n", winEr));107 WARN(("VBoxTray: (WDDM) Failed QueryDisplayConfig\n")); 110 108 free(pPathInfoArray); 111 109 free(pModeInfoArray); … … 124 122 memset(pCfgDst, 0, sizeof (*pCfgDst)); 125 123 126 /** @todo r=andy Why using malloc() instead of RTMemAlloc*? */127 124 if (pCfg->cPathInfoArray) 128 125 { … … 130 127 if (!pCfgDst->pPathInfoArray) 131 128 { 132 LogFlowFunc(("malloc failed!\n"));129 WARN(("VBoxTray: (WDDM) malloc failed!\n")); 133 130 return ERROR_OUTOFMEMORY; 134 131 } … … 144 141 if (!pCfgDst->pModeInfoArray) 145 142 { 146 LogFlowFunc(("malloc failed!\n"));143 WARN(("VBoxTray: (WDDM) malloc failed!\n")); 147 144 if (pCfgDst->pPathInfoArray) 148 145 { … … 182 179 if (winEr != ERROR_SUCCESS) 183 180 { 184 LogFlowFunc(("vboxDispIfWddmDcCreate failed winEr %ld\n", winEr));181 WARN(("VBoxTray:(WDDM) vboxDispIfWddmDcCreate Failed winEr %d\n", winEr)); 185 182 return winEr; 186 183 } … … 258 255 if (!pModeInfoArray) 259 256 { 260 LogFlowFunc(("malloc failed!\n"));257 WARN(("VBoxTray: (WDDM) malloc failed!\n")); 261 258 return ERROR_OUTOFMEMORY; 262 259 } … … 283 280 { 284 281 285 LogFlowFunc(("no source mode index specified"));282 WARN(("VBoxTray: (WDDM) no source mode index specified")); 286 283 DWORD winEr = vboxDispIfWddmDcSettingsModeAdd(pCfg, &iSrcMode); 287 284 if (winEr != ERROR_SUCCESS) 288 285 { 289 LogFlowFunc(("vboxDispIfWddmDcSettingsModeAdd Failed winEr %d\n", winEr));286 WARN(("VBoxTray:(WDDM) vboxDispIfWddmDcSettingsModeAdd Failed winEr %d\n", winEr)); 290 287 return winEr; 291 288 } … … 301 298 { 302 299 /* this is something we're not expecting/supporting */ 303 LogFlowFunc(("multiple paths have the same mode index"));300 WARN(("VBoxTray: (WDDM) multiple paths have the same mode index")); 304 301 return ERROR_NOT_SUPPORTED; 305 302 } … … 332 329 break; 333 330 default: 334 LogRel((" invalid bpp %d, using 32\n", pDeviceMode->dmBitsPerPel));331 LogRel(("VBoxTray: (WDDM) invalid bpp %d, using 32\n", pDeviceMode->dmBitsPerPel)); 335 332 pCfg->pModeInfoArray[iSrcMode].sourceMode.pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP; 336 333 break; … … 353 350 DWORD winEr = gCtx.pfnSetDisplayConfig(pCfg->cPathInfoArray, pCfg->pPathInfoArray, pCfg->cModeInfoArray, pCfg->pModeInfoArray, fFlags); 354 351 if (winEr != ERROR_SUCCESS) 355 Log FlowFunc(("pfnSetDisplayConfig Failed for Flags 0x%x\n", fFlags));352 Log(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed for Flags 0x%x\n", fFlags)); 356 353 return winEr; 357 354 } … … 397 394 if (winEr != ERROR_SUCCESS) 398 395 { 399 LogFlowFunc(("vboxDispIfWddmDcQueryNumDisplays Failed winEr %d\n", winEr));396 WARN(("VBoxTray:(WDDM) vboxDispIfWddmDcQueryNumDisplays Failed winEr %d\n", winEr)); 400 397 return winEr; 401 398 } … … 404 401 if (!pPathInfoArray) 405 402 { 406 LogFlowFunc(("malloc failed\n"));403 WARN(("malloc failed\n")); 407 404 return ERROR_OUTOFMEMORY; 408 405 } … … 416 413 if (idx >= 0) 417 414 { 418 LogFlowFunc(("different source and target paare enabled, this is something we would not expect\n"));415 WARN(("VBoxTray:(WDDM) different source and target paare enabled, this is something we would not expect\n")); 419 416 } 420 417 } … … 429 426 if (winEr != ERROR_SUCCESS) 430 427 { 431 LogFlowFunc(("vboxDispIfWddmDcCreate Failed winEr %d\n", winEr));428 WARN(("VBoxTray:(WDDM) vboxDispIfWddmDcCreate Failed winEr %d\n", winEr)); 432 429 free(pPathInfoArray); 433 430 return winEr; … … 439 436 if (idx < 0) 440 437 { 441 LogFlowFunc(("%d %d path not supported\n", i, i));438 WARN(("VBoxTray:(WDDM) %d %d path not supported\n", i, i)); 442 439 idx = vboxDispIfWddmDcSearchPath(pCfg, -1, i); 443 440 if (idx < 0) 444 441 { 445 LogFlowFunc(("%d %d path not supported\n", -1, i));442 WARN(("VBoxTray:(WDDM) %d %d path not supported\n", -1, i)); 446 443 } 447 444 } … … 453 450 if (pPathInfoArray[i].flags & DISPLAYCONFIG_PATH_ACTIVE) 454 451 { 455 LogFlowFunc(("disabled path %d %d is marked active\n",452 WARN(("VBoxTray:(WDDM) disabled path %d %d is marked active\n", 456 453 pPathInfoArray[i].sourceInfo.id, pPathInfoArray[i].targetInfo.id)); 457 454 pPathInfoArray[i].flags &= ~DISPLAYCONFIG_PATH_ACTIVE; … … 521 518 return ERROR_SUCCESS; 522 519 else 523 LogFlowFunc(("vboxDispKmtCreateContext failed hr 0x%x", hr));520 WARN(("VBoxTray: vboxDispKmtCreateContext failed hr 0x%x", hr)); 524 521 525 522 vboxDispKmtDestroyDevice(&pOp->Device); 526 523 } 527 524 else 528 LogFlowFunc(("vboxDispKmtCreateDevice failed hr 0x%x", hr));525 WARN(("VBoxTray: vboxDispKmtCreateDevice failed hr 0x%x", hr)); 529 526 530 527 vboxDispKmtCloseAdapter(&pOp->Adapter); … … 600 597 if (OSinfo.dwMajorVersion >= 6) 601 598 { 602 Log FlowFunc(("this is vista and up\n"));599 Log((__FUNCTION__": this is vista and up\n")); 603 600 HMODULE hUser = GetModuleHandle("user32.dll"); 604 601 if (hUser) 605 602 { 606 603 *(uintptr_t *)&pIf->modeData.wddm.pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA"); 607 Log FlowFunc(("pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.wddm.pfnChangeDisplaySettingsEx));604 Log((__FUNCTION__": VBoxDisplayInit: pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.wddm.pfnChangeDisplaySettingsEx)); 608 605 bSupported &= !!(pIf->modeData.wddm.pfnChangeDisplaySettingsEx); 609 606 610 607 *(uintptr_t *)&pIf->modeData.wddm.pfnEnumDisplayDevices = (uintptr_t)GetProcAddress(hUser, "EnumDisplayDevicesA"); 611 Log FlowFunc(("pfnEnumDisplayDevices = %p\n", pIf->modeData.wddm.pfnEnumDisplayDevices));608 Log((__FUNCTION__": VBoxDisplayInit: pfnEnumDisplayDevices = %p\n", pIf->modeData.wddm.pfnEnumDisplayDevices)); 612 609 bSupported &= !!(pIf->modeData.wddm.pfnEnumDisplayDevices); 613 610 /* for win 7 and above */ … … 615 612 { 616 613 *(uintptr_t *)&gCtx.pfnSetDisplayConfig = (uintptr_t)GetProcAddress(hUser, "SetDisplayConfig"); 617 Log FlowFunc(("pfnSetDisplayConfig = %p\n", gCtx.pfnSetDisplayConfig));614 Log((__FUNCTION__": VBoxDisplayInit: pfnSetDisplayConfig = %p\n", gCtx.pfnSetDisplayConfig)); 618 615 bSupported &= !!(gCtx.pfnSetDisplayConfig); 619 616 620 617 *(uintptr_t *)&gCtx.pfnQueryDisplayConfig = (uintptr_t)GetProcAddress(hUser, "QueryDisplayConfig"); 621 Log FlowFunc(("pfnQueryDisplayConfig = %p\n", gCtx.pfnQueryDisplayConfig));618 Log((__FUNCTION__": VBoxDisplayInit: pfnQueryDisplayConfig = %p\n", gCtx.pfnQueryDisplayConfig)); 622 619 bSupported &= !!(gCtx.pfnQueryDisplayConfig); 623 620 624 621 *(uintptr_t *)&gCtx.pfnGetDisplayConfigBufferSizes = (uintptr_t)GetProcAddress(hUser, "GetDisplayConfigBufferSizes"); 625 Log FlowFunc(("pfnGetDisplayConfigBufferSizes = %p\n", gCtx.pfnGetDisplayConfigBufferSizes));622 Log((__FUNCTION__": VBoxDisplayInit: pfnGetDisplayConfigBufferSizes = %p\n", gCtx.pfnGetDisplayConfigBufferSizes)); 626 623 bSupported &= !!(gCtx.pfnGetDisplayConfigBufferSizes); 627 624 } … … 631 628 if (FAILED(hr)) 632 629 { 633 LogFlowFunc(("vboxDispKmtCallbacksInit failed hr 0x%x\n", hr));630 WARN(("VBoxTray: vboxDispKmtCallbacksInit failed hr 0x%x\n", hr)); 634 631 err = hr; 635 632 } … … 637 634 else 638 635 { 639 LogFlowFunc(("GetModuleHandle(USER32) failed, err(%d)\n", GetLastError()));636 WARN((__FUNCTION__": GetModuleHandle(USER32) failed, err(%d)\n", GetLastError())); 640 637 err = ERROR_NOT_SUPPORTED; 641 638 } … … 643 640 else 644 641 { 645 LogFlowFunc(("Couldnot switch to VBOXDISPIF_MODE_WDDM, because os is not Vista or upper\n"));642 WARN((__FUNCTION__": can not switch to VBOXDISPIF_MODE_WDDM, because os is not Vista or upper\n")); 646 643 err = ERROR_NOT_SUPPORTED; 647 644 } … … 682 679 { 683 680 winEr = GetLastError(); 684 LogFlowFunc(("CreateDC failed %d", winEr));681 WARN(("CreateDC failed %d", winEr)); 685 682 break; 686 683 } 687 684 } 688 Log FlowFunc(("display data no match display(%d): i(%d), flags(%d)", iDisplay, i, pDev->StateFlags));685 Log(("display data no match display(%d): i(%d), flags(%d)", iDisplay, i, pDev->StateFlags)); 689 686 } 690 687 else 691 688 { 692 689 winEr = GetLastError(); 693 LogFlowFunc(("EnumDisplayDevices failed %d", winEr));690 WARN(("EnumDisplayDevices failed %d", winEr)); 694 691 break; 695 692 } 696 693 } 697 694 698 LogFlowFunc(("vboxDispIfWDDMAdpHdcCreate failure branch %d", winEr));695 WARN(("vboxDispIfWDDMAdpHdcCreate failure branch %d", winEr)); 699 696 return winEr; 700 697 } … … 707 704 if (!SUCCEEDED(hr)) 708 705 { 709 LogFlowFunc(("vboxDispKmtOpenAdapter failed hr 0x%x\n", hr));706 WARN(("VBoxTray: vboxDispKmtOpenAdapter failed hr 0x%x\n", hr)); 710 707 return hr; 711 708 } … … 726 723 else 727 724 { 728 LogFlowFunc(("pfnD3DKMTEscape failed Status 0x%x\n", Status));725 WARN(("VBoxTray: pfnD3DKMTEscape failed Status 0x%x\n", Status)); 729 726 winEr = ERROR_GEN_FAILURE; 730 727 } … … 749 746 #endif 750 747 default: 751 Log FlowFunc(("unknown mode (%d)\n", pIf->enmMode));748 Log((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode)); 752 749 return ERROR_INVALID_PARAMETER; 753 750 } … … 767 764 #endif 768 765 default: 769 Log FlowFunc(("unknown mode (%d)\n", pIf->enmMode));766 Log((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode)); 770 767 return ERROR_INVALID_PARAMETER; 771 768 } … … 851 848 pMon->fExtDispSup = fExtDispSup; 852 849 853 /** @todo r=andy Why using malloc() instead of RTMemAlloc*? */854 850 if (cDevModes) 855 851 { … … 858 854 if (!pMon->paDisplayDevices) 859 855 { 860 Log FlowFunc(("malloc failed"));856 Log(("malloc failed!")); 861 857 vboxRrRetryStopLocked(); 862 858 LeaveCriticalSection(&pMon->CritSect); … … 869 865 if (!pMon->paDeviceModes) 870 866 { 871 Log FlowFunc(("malloc failed"));867 Log(("malloc failed!")); 872 868 vboxRrRetryStopLocked(); 873 869 LeaveCriticalSection(&pMon->CritSect); … … 882 878 if (!pMon->idTimer) 883 879 { 884 LogFlowFunc(("SetTimer failed, err %ld\n", GetLastError()));880 WARN(("VBoxTray: SetTimer failed!, err %d\n", GetLastError())); 885 881 vboxRrRetryStopLocked(); 886 882 } … … 914 910 case WM_DISPLAYCHANGE: 915 911 { 916 Log FlowFunc(("WM_DISPLAYCHANGE\n"));912 Log(("VBoxTray: WM_DISPLAYCHANGE\n")); 917 913 VBoxRrRetryStop(); 918 914 return 0; … … 922 918 if (wParam == VBOXRR_TIMER_ID) 923 919 { 924 Log FlowFunc(("VBOXRR_TIMER_ID\n"));920 Log(("VBoxTray: VBOXRR_TIMER_ID\n")); 925 921 vboxRrRetryPerform(); 926 922 return 0; … … 929 925 } 930 926 case WM_CLOSE: 931 Log FlowFunc(("got WM_CLOSE for hwnd(0x%x)", hwnd));927 Log((__FUNCTION__": got WM_CLOSE for hwnd(0x%x)", hwnd)); 932 928 return 0; 933 929 case WM_DESTROY: 934 Log FlowFunc(("got WM_DESTROY for hwnd(0x%x)", hwnd));930 Log((__FUNCTION__": got WM_DESTROY for hwnd(0x%x)", hwnd)); 935 931 return 0; 936 932 case WM_NCHITTEST: 937 Log FlowFunc(("got WM_NCHITTEST for hwnd(0x%x)\n", hwnd));933 Log((__FUNCTION__": got WM_NCHITTEST for hwnd(0x%x)\n", hwnd)); 938 934 return HTNOWHERE; 939 935 default: … … 967 963 { 968 964 DWORD winErr = GetLastError(); 969 LogFlowFunc(("RegisterClass failed, winErr(%d)\n", winErr));965 WARN((__FUNCTION__": RegisterClass failed, winErr(%d)\n", winErr)); 970 966 hr = E_FAIL; 971 967 } … … 991 987 { 992 988 DWORD winErr = GetLastError(); 993 LogFlowFunc(("CreateWindowEx failed, winErr(%d)\n", winErr));989 WARN((__FUNCTION__": CreateWindowEx failed, winErr(%d)\n", winErr)); 994 990 hr = E_FAIL; 995 991 } … … 1006 1002 1007 1003 DWORD winErr = GetLastError(); 1008 LogFlowFunc(("DestroyWindow failed, winErr(%d) for hWnd(0x%x)\n", winErr, hWnd));1004 WARN((__FUNCTION__": DestroyWindow failed, winErr(%d) for hWnd(0x%x)\n", winErr, hWnd)); 1009 1005 1010 1006 return HRESULT_FROM_WIN32(winErr); … … 1055 1051 { 1056 1052 hr = S_FALSE; 1057 Log FlowFunc(("GetMessage returned FALSE\n"));1053 Log(("VBoxTray: GetMessage returned FALSE\n")); 1058 1054 VBoxRrRetryStop(); 1059 1055 break; … … 1069 1065 if (hr == S_OK || hr == S_FALSE) 1070 1066 hr = E_FAIL; 1071 LogFlowFunc(("GetMessage returned -1, err %d\n", winEr));1067 WARN(("VBoxTray: GetMessage returned -1, err %d\n", winEr)); 1072 1068 VBoxRrRetryStop(); 1073 1069 break; … … 1079 1075 case WM_CLOSE: 1080 1076 { 1081 Log FlowFunc(("closing Rr %d\n", Msg.message));1077 Log(("VBoxTray: closing Rr %d\n", Msg.message)); 1082 1078 VBoxRrRetryStop(); 1083 1079 PostQuitMessage(0); … … 1101 1097 { 1102 1098 DWORD winErr = GetLastError(); 1103 LogFlowFunc(("SetEvent failed, winErr = (%d)", winErr));1099 WARN((__FUNCTION__": SetEvent failed, winErr = (%d)", winErr)); 1104 1100 HRESULT tmpHr = HRESULT_FROM_WIN32(winErr); 1105 1101 Assert(tmpHr != S_OK); … … 1147 1143 else 1148 1144 { 1149 Log FlowFunc(("WaitForSingleObject failed"));1145 Log(("WaitForSingleObject failed!")); 1150 1146 hr = E_FAIL; 1151 1147 } … … 1154 1150 { 1155 1151 DWORD winErr = GetLastError(); 1156 LogFlowFunc(("CreateThread failed, winErr = (%d)", winErr));1152 WARN((__FUNCTION__": CreateThread failed, winErr = (%d)", winErr)); 1157 1153 hr = HRESULT_FROM_WIN32(winErr); 1158 1154 Assert(hr != S_OK); … … 1163 1159 { 1164 1160 DWORD winErr = GetLastError(); 1165 LogFlowFunc(("CreateEvent failed, winErr = (%d)", winErr));1161 WARN((__FUNCTION__": CreateEvent failed, winErr = (%d)", winErr)); 1166 1162 hr = HRESULT_FROM_WIN32(winErr); 1167 1163 Assert(hr != S_OK); … … 1216 1212 return ERROR_SUCCESS; 1217 1213 } 1218 LogFlowFunc(("VBoxRrInit failed hr 0x%x\n", hr));1214 WARN(("VBoxTray: VBoxRrInit failed hr 0x%x\n", hr)); 1219 1215 return hr; 1220 1216 } … … 1240 1236 if (winEr != ERROR_SUCCESS) 1241 1237 { 1242 LogFlowFunc(("Failed vboxDispIfWddmDcCreate winEr %d\n", winEr));1238 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate winEr %d\n", winEr)); 1243 1239 return winEr; 1244 1240 } … … 1252 1248 } 1253 1249 1254 static DWORD vboxDispIfWaitDisplayDataInited(VBOXDISPIF_OP *pOp , const uint8_t *pu8DisplayMask)1250 static DWORD vboxDispIfWaitDisplayDataInited(VBOXDISPIF_OP *pOp) 1255 1251 { 1256 1252 DWORD winEr = ERROR_SUCCESS; … … 1265 1261 if (Status != 0) 1266 1262 { 1267 Log FlowFunc(("pfnD3DKMTPollDisplayChildren failed, Status (0x%x)\n", Status));1263 Log(("VBoxTray: (WDDM) pfnD3DKMTPollDisplayChildren failed, Status (0x%x)\n", Status)); 1268 1264 continue; 1269 1265 } … … 1280 1276 if (winEr != ERROR_SUCCESS) 1281 1277 { 1282 LogFlowFunc(("Failed vboxDispIfQueryDisplayConnection winEr %d\n", winEr));1278 WARN(("VBoxTray: (WDDM) Failed vboxDispIfQueryDisplayConnection winEr %d\n", winEr)); 1283 1279 return winEr; 1284 1280 } … … 1286 1282 if (!fConnected) 1287 1283 { 1288 LogFlowFunc(("Display %d not connected, not expected\n", i));1284 WARN(("VBoxTray: (WDDM) Display %d not connected, not expected\n", i)); 1289 1285 fFound = TRUE; 1290 1286 break; … … 1299 1295 } 1300 1296 1301 static DWORD vboxDispIf ReninitModesWDDM(VBOXDISPIF_OP *pOp, const uint8_t *pScreenIdMask)1297 static DWORD vboxDispIfUpdateModesWDDM(VBOXDISPIF_OP *pOp, uint32_t u32TargetId, const RTRECTSIZE *pSize) 1302 1298 { 1303 1299 DWORD winEr = ERROR_SUCCESS; 1304 VBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK EscData = {0}; 1305 EscData.EscapeHdr.escapeCode = VBOXESC_REINITVIDEOMODESBYMASK; 1306 memcpy(EscData.ScreenMask, pScreenIdMask, sizeof (EscData.ScreenMask)); 1300 VBOXDISPIFESCAPE_UPDATEMODES EscData = {0}; 1301 EscData.EscapeHdr.escapeCode = VBOXESC_UPDATEMODES; 1302 EscData.u32TargetId = u32TargetId; 1303 EscData.Size = *pSize; 1307 1304 1308 1305 D3DKMT_ESCAPE EscapeData = {0}; … … 1323 1320 else 1324 1321 { 1325 LogFlowFunc(("pfnD3DKMTEscape VBOXESC_REINITVIDEOMODESBYMASKfailed Status 0x%x\n", Status));1322 WARN(("VBoxTray: pfnD3DKMTEscape VBOXESC_UPDATEMODES failed Status 0x%x\n", Status)); 1326 1323 winEr = ERROR_GEN_FAILURE; 1327 1324 } 1328 1325 1329 winEr = vboxDispIfWaitDisplayDataInited(pOp , pScreenIdMask);1326 winEr = vboxDispIfWaitDisplayDataInited(pOp); 1330 1327 if (winEr != NO_ERROR) 1331 LogFlowFunc(("Failed vboxDispIfWaitDisplayDataInited winEr %d\n", winEr));1328 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWaitDisplayDataInited winEr %d\n", winEr)); 1332 1329 1333 1330 return winEr; … … 1336 1333 DWORD vboxDispIfCancelPendingResizeWDDM(PCVBOXDISPIF const pIf) 1337 1334 { 1338 Log FlowFunc(("cancelling pending resize\n"));1335 Log(("VBoxTray: cancelling pending resize\n")); 1339 1336 VBoxRrRetryStop(); 1340 1337 return NO_ERROR; … … 1352 1349 tempDevMode.dmSize = sizeof(DEVMODE); 1353 1350 EnumDisplaySettings((LPSTR)paDisplayDevices[i].DeviceName, 0xffffff, &tempDevMode); 1354 Log FlowFunc(("ResizeDisplayDevice: EnumDisplaySettings last error %d\n", GetLastError ()));1351 Log(("VBoxTray: ResizeDisplayDevice: EnumDisplaySettings last error %d\n", GetLastError ())); 1355 1352 } 1356 1353 … … 1358 1355 paDeviceModes[iChangedMode].dmBitsPerPel, paDeviceModes[iChangedMode].dmPosition.x, paDeviceModes[iChangedMode].dmPosition.y, fEnable, fExtDispSup); 1359 1356 if (winEr != NO_ERROR) 1360 LogFlowFunc(("Failed EnableAndResizeDispDev winEr %d\n", winEr));1357 WARN(("VBoxTray: (WDDM) Failed EnableAndResizeDispDev winEr %d\n", winEr)); 1361 1358 1362 1359 return winEr; … … 1370 1367 winEr = vboxDispIfWddmResizeDisplay(pIf, iChangedMode, fEnable, paDisplayDevices, paDeviceModes, cDevModes); 1371 1368 if (winEr != NO_ERROR) 1372 LogFlowFunc(("Failed vboxDispIfWddmResizeDisplay winEr %d\n", winEr));1369 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmResizeDisplay winEr %d\n", winEr)); 1373 1370 } 1374 1371 else … … 1376 1373 winEr = vboxDispIfWddmResizeDisplayVista(paDeviceModes, paDisplayDevices, cDevModes, iChangedMode, fEnable, fExtDispSup); 1377 1374 if (winEr != NO_ERROR) 1378 LogFlowFunc(("Failed vboxDispIfWddmResizeDisplayVista winEr %d\n", winEr));1375 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmResizeDisplayVista winEr %d\n", winEr)); 1379 1376 } 1380 1377 return winEr; … … 1383 1380 DWORD vboxDispIfResizeModesWDDM(PCVBOXDISPIF const pIf, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes) 1384 1381 { 1385 UINT cbVidPnInfo = VBOXWDDM_RECOMMENDVIDPN_SIZE(cDevModes);1386 PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo = (PVBOXWDDM_RECOMMENDVIDPN)alloca(cbVidPnInfo);1387 pVidPnInfo->cScreenInfos = cDevModes;1388 D3DKMT_HANDLE hAdapter = NULL;1389 1382 DWORD winEr = NO_ERROR; 1390 UINT i = 0; 1391 1392 LogFlowFunc(("vboxDispIfResizeModesWDDM\n")); 1383 1384 Log(("VBoxTray: vboxDispIfResizeModesWDDM\n")); 1393 1385 VBoxRrRetryStop(); 1394 1386 … … 1398 1390 if (winEr != NO_ERROR) 1399 1391 { 1400 LogFlowFunc(("vboxDispIfOpBegin failed winEr 0x%x", winEr));1392 WARN(("VBoxTray: vboxDispIfOpBegin failed winEr 0x%x", winEr)); 1401 1393 return winEr; 1402 1394 } 1403 1395 1404 1405 // if (fEnable) 1406 { 1407 1408 uint8_t ScreenMask[VBOXWDDM_SCREENMASK_SIZE] = {0}; 1409 ASMBitSet(ScreenMask, iChangedMode); 1410 vboxDispIfReninitModesWDDM(&Op, ScreenMask); 1411 } 1412 1413 winEr = vboxDispIfResizePerform(pIf, iChangedMode, fEnable, fExtDispSup, paDisplayDevices, paDeviceModes, cDevModes); 1414 1415 if (winEr == ERROR_RETRY) 1416 { 1417 VBoxRrRetrySchedule(pIf, iChangedMode, fEnable, fExtDispSup, paDisplayDevices, paDeviceModes, cDevModes); 1418 /* just pretend everything is fine so far */ 1396 VBOXWDDM_RECOMMENDVIDPN VidPnData; 1397 1398 memset(&VidPnData, 0, sizeof (VidPnData)); 1399 1400 uint32_t cElements = 0; 1401 1402 for (uint32_t i = 0; i < cDevModes; ++i) 1403 { 1404 if ((i == iChangedMode) ? fEnable : (paDisplayDevices[i].StateFlags & DISPLAY_DEVICE_ACTIVE)) 1405 { 1406 VidPnData.aSources[cElements].Size.cx = paDeviceModes[i].dmPelsWidth; 1407 VidPnData.aSources[cElements].Size.cy = paDeviceModes[i].dmPelsHeight; 1408 VidPnData.aTargets[cElements].iSource = cElements; 1409 ++cElements; 1410 } 1411 else 1412 VidPnData.aTargets[cElements].iSource = -1; 1413 } 1414 1415 D3DKMT_INVALIDATEACTIVEVIDPN DdiData = {0}; 1416 1417 DdiData.hAdapter = Op.Adapter.hAdapter; 1418 DdiData.pPrivateDriverData = &VidPnData; 1419 DdiData.PrivateDriverDataSize = sizeof (VidPnData); 1420 1421 NTSTATUS Status = Op.pIf->modeData.wddm.KmtCallbacks.pfnD3DKMTInvalidateActiveVidPn(&DdiData); 1422 if (NT_SUCCESS(Status)) 1419 1423 winEr = NO_ERROR; 1424 else 1425 { 1426 winEr = NO_ERROR; 1427 1428 if (fEnable) 1429 { 1430 RTRECTSIZE Size; 1431 Size.cx = paDeviceModes[iChangedMode].dmPelsWidth; 1432 Size.cy = paDeviceModes[iChangedMode].dmPelsHeight; 1433 winEr = vboxDispIfUpdateModesWDDM(&Op, iChangedMode, &Size); 1434 if (winEr != NO_ERROR) 1435 WARN(("vboxDispIfUpdateModesWDDM failed %d\n", winEr)); 1436 } 1437 1438 if (winEr == NO_ERROR) 1439 { 1440 winEr = vboxDispIfResizePerform(pIf, iChangedMode, fEnable, fExtDispSup, paDisplayDevices, paDeviceModes, cDevModes); 1441 1442 if (winEr == ERROR_RETRY) 1443 { 1444 VBoxRrRetrySchedule(pIf, iChangedMode, fEnable, fExtDispSup, paDisplayDevices, paDeviceModes, cDevModes); 1445 /* just pretend everything is fine so far */ 1446 winEr = NO_ERROR; 1447 } 1448 } 1420 1449 } 1421 1450 … … 1435 1464 if (winEr != ERROR_SUCCESS) 1436 1465 { 1437 LogFlowFunc(("Failed vboxDispIfWddmDcCreate winEr %d\n", winEr));1466 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate winEr %d\n", winEr)); 1438 1467 return winEr; 1439 1468 } … … 1443 1472 if (!pChangeIds) 1444 1473 { 1445 LogFlowFunc(("Failed to alloc change ids\n"));1474 WARN(("VBoxTray: (WDDM) Failed to alloc change ids\n")); 1446 1475 winEr = ERROR_OUTOFMEMORY; 1447 1476 goto done; … … 1475 1504 if (cChangeIds == 0) 1476 1505 { 1477 Log FlowFunc(("vboxDispIfWddmEnableDisplay: settings are up to date\n"));1506 Log(("VBoxTray: (WDDM) vboxDispIfWddmEnableDisplay: settings are up to date\n")); 1478 1507 winEr = ERROR_SUCCESS; 1479 1508 goto done; … … 1484 1513 if (winEr != ERROR_SUCCESS) 1485 1514 { 1486 LogFlowFunc(("Failed vboxDispIfWddmDcSettingsIncludeAllTargets winEr %d\n", winEr));1515 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcSettingsIncludeAllTargets winEr %d\n", winEr)); 1487 1516 return winEr; 1488 1517 } … … 1498 1527 if (iPath < 0) 1499 1528 { 1500 LogFlowFunc(("path index not found while it should"));1529 WARN(("VBoxTray: (WDDM) path index not found while it should")); 1501 1530 winEr = ERROR_GEN_FAILURE; 1502 1531 goto done; … … 1506 1535 if (winEr != ERROR_SUCCESS) 1507 1536 { 1508 LogFlowFunc(("Failed vboxDispIfWddmDcSettingsUpdate winEr %d\n", winEr));1537 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcSettingsUpdate winEr %d\n", winEr)); 1509 1538 goto done; 1510 1539 } … … 1519 1548 if (iPath < 0) 1520 1549 { 1521 LogFlowFunc(("path index not found while it should"));1550 WARN(("VBoxTray: (WDDM) path index not found while it should")); 1522 1551 winEr = ERROR_GEN_FAILURE; 1523 1552 goto done; … … 1527 1556 if (winEr != ERROR_SUCCESS) 1528 1557 { 1529 LogFlowFunc(("Failed vboxDispIfWddmDcSettingsUpdate winEr %d\n", winEr));1558 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcSettingsUpdate winEr %d\n", winEr)); 1530 1559 goto done; 1531 1560 } … … 1538 1567 if (!fSetTopology) 1539 1568 { 1540 LogFlowFunc(("vboxDispIfWddmDcSet validation failed winEr, trying with changes %d\n", winEr));1569 WARN(("VBoxTray: (WDDM) vboxDispIfWddmDcSet validation failed winEr, trying with changes %d\n", winEr)); 1541 1570 fSetFlags |= SDC_ALLOW_CHANGES; 1542 1571 } 1543 1572 else 1544 1573 { 1545 Log FlowFunc(("vboxDispIfWddmDcSet topology validation failed winEr %d\n", winEr));1574 Log(("VBoxTray: (WDDM) vboxDispIfWddmDcSet topology validation failed winEr %d\n", winEr)); 1546 1575 goto done; 1547 1576 } … … 1553 1582 winEr = vboxDispIfWddmDcSet(&DispCfg, fSetFlags | SDC_APPLY); 1554 1583 if (winEr != ERROR_SUCCESS) 1555 LogFlowFunc(("vboxDispIfWddmDcSet apply failed winEr %d\n", winEr));1584 WARN(("VBoxTray: (WDDM) vboxDispIfWddmDcSet apply failed winEr %d\n", winEr)); 1556 1585 1557 1586 done: … … 1567 1596 { 1568 1597 if (fEnable) 1569 LogFlowFunc(("Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr));1598 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr)); 1570 1599 else 1571 Log FlowFunc(("Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr));1600 Log(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr)); 1572 1601 winEr = vboxDispIfWddmEnableDisplays(pIf, cIds, pIds, fEnable, TRUE, NULL); 1573 1602 if (winEr != ERROR_SUCCESS) 1574 LogFlowFunc(("Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr));1603 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplay mode winEr %d\n", winEr)); 1575 1604 } 1576 1605 … … 1587 1616 if (winEr != ERROR_SUCCESS) 1588 1617 { 1589 LogFlowFunc(("Failed vboxDispIfWddmDcCreate\n"));1618 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate\n")); 1590 1619 return winEr; 1591 1620 } … … 1606 1635 if (winEr != ERROR_SUCCESS) 1607 1636 { 1608 LogFlowFunc(("Failed vboxDispIfWddmEnableDisplaysTryingTopology winEr %d\n", winEr));1637 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplaysTryingTopology winEr %d\n", winEr)); 1609 1638 return winEr; 1610 1639 } … … 1613 1642 if (winEr != ERROR_SUCCESS) 1614 1643 { 1615 LogFlowFunc(("Failed vboxDispIfWddmDcCreate winEr %d\n", winEr));1644 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcCreate winEr %d\n", winEr)); 1616 1645 return winEr; 1617 1646 } … … 1620 1649 if (iPath < 0) 1621 1650 { 1622 LogFlowFunc(("path (%d) is still disabled, going to retry winEr %d\n", winEr));1651 WARN(("VBoxTray: (WDDM) path (%d) is still disabled, going to retry winEr %d\n", winEr)); 1623 1652 vboxDispIfWddmDcTerm(&DispCfg); 1624 1653 return ERROR_RETRY; … … 1636 1665 if (winEr != ERROR_SUCCESS) 1637 1666 { 1638 LogFlowFunc(("Failed vboxDispIfWddmEnableDisplaysTryingTopology winEr %d\n", winEr));1667 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmEnableDisplaysTryingTopology winEr %d\n", winEr)); 1639 1668 return winEr; 1640 1669 } … … 1648 1677 if (winEr != ERROR_SUCCESS) 1649 1678 { 1650 LogFlowFunc(("Failed vboxDispIfWddmDcSettingsUpdate\n"));1679 WARN(("VBoxTray: (WDDM) Failed vboxDispIfWddmDcSettingsUpdate\n")); 1651 1680 vboxDispIfWddmDcTerm(&DispCfg); 1652 1681 return winEr; … … 1657 1686 if (winEr != ERROR_SUCCESS) 1658 1687 { 1659 LogFlowFunc(("pfnSetDisplayConfig Failed to validate winEr %d.\n", winEr));1688 WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to validate winEr %d.\n", winEr)); 1660 1689 fSetFlags |= SDC_ALLOW_CHANGES; 1661 1690 } … … 1664 1693 if (winEr != ERROR_SUCCESS) 1665 1694 { 1666 LogFlowFunc(("pfnSetDisplayConfig Failed to validate winEr %d.\n", winEr));1695 WARN(("VBoxTray:(WDDM) pfnSetDisplayConfig Failed to validate winEr %d.\n", winEr)); 1667 1696 } 1668 1697 … … 1688 1717 #endif 1689 1718 default: 1690 LogFlowFunc(("unknown mode (%d)\n", pIf->enmMode));1719 WARN((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode)); 1691 1720 return ERROR_INVALID_PARAMETER; 1692 1721 } … … 1707 1736 #endif 1708 1737 default: 1709 LogFlowFunc(("unknown mode (%d)\n", pIf->enmMode));1738 WARN((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode)); 1710 1739 return ERROR_INVALID_PARAMETER; 1711 1740 } … … 1737 1766 return NO_ERROR; 1738 1767 } 1739 LogFlowFunc(("pfnD3DKMTEscape VBOXESC_CONFIGURETARGETS failed Status 0x%x\n", Status));1768 WARN(("VBoxTray: pfnD3DKMTEscape VBOXESC_CONFIGURETARGETS failed Status 0x%x\n", Status)); 1740 1769 return Status; 1741 1770 } … … 1746 1775 if (NumDevices == 0) 1747 1776 { 1748 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: Zero devices found\n"));1777 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: Zero devices found\n")); 1749 1778 return ERROR_GEN_FAILURE; 1750 1779 } … … 1758 1787 if (winEr != NO_ERROR) 1759 1788 { 1760 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: VBoxGetDisplayConfig failed, %d\n", winEr));1789 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: VBoxGetDisplayConfig failed, %d\n", winEr)); 1761 1790 return winEr; 1762 1791 } 1763 1792 1764 1793 if (NumDevices != DevNum) 1765 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: NumDevices(%d) != DevNum(%d)\n", NumDevices, DevNum));1794 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: NumDevices(%d) != DevNum(%d)\n", NumDevices, DevNum)); 1766 1795 1767 1796 … … 1770 1799 if (winEr != NO_ERROR) 1771 1800 { 1772 LogFlowFunc(("vboxDispIfConfigureTargetsWDDM failed winEr 0x%x\n", winEr));1801 WARN(("VBoxTray: vboxDispIfConfigureTargetsWDDM failed winEr 0x%x\n", winEr)); 1773 1802 return winEr; 1774 1803 } … … 1776 1805 if (!cConnected) 1777 1806 { 1778 Log FlowFunc(("all targets already connected, nothing to do\n"));1807 Log(("VBoxTray: all targets already connected, nothing to do\n")); 1779 1808 return NO_ERROR; 1780 1809 } 1781 1810 1782 winEr = vboxDispIfWaitDisplayDataInited(pOp , NULL);1811 winEr = vboxDispIfWaitDisplayDataInited(pOp); 1783 1812 if (winEr != NO_ERROR) 1784 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: vboxDispIfWaitDisplayDataInited failed winEr 0x%x\n", winEr));1813 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: vboxDispIfWaitDisplayDataInited failed winEr 0x%x\n", winEr)); 1785 1814 1786 1815 DWORD NewNumDevices = VBoxGetDisplayConfigCount(); 1787 1816 if (NewNumDevices == 0) 1788 1817 { 1789 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: Zero devices found\n"));1818 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: Zero devices found\n")); 1790 1819 return ERROR_GEN_FAILURE; 1791 1820 } 1792 1821 1793 1822 if (NewNumDevices != NumDevices) 1794 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: NumDevices(%d) != NewNumDevices(%d)\n", NumDevices, NewNumDevices));1823 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: NumDevices(%d) != NewNumDevices(%d)\n", NumDevices, NewNumDevices)); 1795 1824 1796 1825 DISPLAY_DEVICE *paNewDisplayDevices = (DISPLAY_DEVICE *)alloca (sizeof (DISPLAY_DEVICE) * NewNumDevices); … … 1802 1831 if (winEr != NO_ERROR) 1803 1832 { 1804 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: VBoxGetDisplayConfig failed for new devices, %d\n", winEr));1833 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: VBoxGetDisplayConfig failed for new devices, %d\n", winEr)); 1805 1834 return winEr; 1806 1835 } 1807 1836 1808 1837 if (NewNumDevices != NewDevNum) 1809 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: NewNumDevices(%d) != NewDevNum(%d)\n", NewNumDevices, NewDevNum));1838 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: NewNumDevices(%d) != NewDevNum(%d)\n", NewNumDevices, NewDevNum)); 1810 1839 1811 1840 DWORD minDevNum = RT_MIN(DevNum, NewDevNum); … … 1825 1854 { 1826 1855 /* this is something we would not regularly expect */ 1827 LogFlowFunc(("all targets already have proper config, nothing to do\n"));1856 WARN(("VBoxTray: all targets already have proper config, nothing to do\n")); 1828 1857 return NO_ERROR; 1829 1858 } … … 1833 1862 winEr = vboxDispIfWddmEnableDisplaysTryingTopology(pOp->pIf, cIds, pIds, FALSE); 1834 1863 if (winEr != NO_ERROR) 1835 LogFlowFunc(("vboxDispIfWddmEnableDisplaysTryingTopology failed to record current settings, %d, ignoring\n", winEr));1864 WARN(("VBoxTray: vboxDispIfWddmEnableDisplaysTryingTopology failed to record current settings, %d, ignoring\n", winEr)); 1836 1865 } 1837 1866 else … … 1841 1870 winEr = vboxDispIfWddmResizeDisplayVista(paNewDeviceModes, paNewDisplayDevices, NewDevNum, i, FALSE, TRUE); 1842 1871 if (winEr != NO_ERROR) 1843 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp: vboxDispIfWddmResizeDisplayVista failed winEr 0x%x\n", winEr));1872 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: vboxDispIfWddmResizeDisplayVista failed winEr 0x%x\n", winEr)); 1844 1873 } 1845 1874 } … … 1856 1885 if (winEr != NO_ERROR) 1857 1886 { 1858 LogFlowFunc(("vboxDispIfOpBegin failed winEr 0x%x\n", winEr));1887 WARN(("VBoxTray: vboxDispIfOpBegin failed winEr 0x%x\n", winEr)); 1859 1888 return winEr; 1860 1889 } … … 1863 1892 if (winEr != NO_ERROR) 1864 1893 { 1865 LogFlowFunc(("vboxDispIfResizeStartedWDDMOp failed winEr 0x%x\n", winEr));1894 WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp failed winEr 0x%x\n", winEr)); 1866 1895 } 1867 1896 … … 1885 1914 #endif 1886 1915 default: 1887 LogFlowFunc(("unknown mode (%d)\n", pIf->enmMode));1916 WARN((__FUNCTION__": unknown mode (%d)\n", pIf->enmMode)); 1888 1917 return ERROR_INVALID_PARAMETER; 1889 1918 } … … 1909 1938 bool bSupported = true; 1910 1939 *(uintptr_t *)&pIf->modeData.xpdm.pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA"); 1911 Log FlowFunc(("pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.xpdm.pfnChangeDisplaySettingsEx));1940 Log((__FUNCTION__": pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.xpdm.pfnChangeDisplaySettingsEx)); 1912 1941 bSupported &= !!(pIf->modeData.xpdm.pfnChangeDisplaySettingsEx); 1913 1942 1914 1943 if (!bSupported) 1915 1944 { 1916 LogFlowFunc(("pfnChangeDisplaySettingsEx function pointer failed to initialize\n"));1945 WARN((__FUNCTION__": pfnChangeDisplaySettingsEx function pointer failed to initialize\n")); 1917 1946 err = ERROR_NOT_SUPPORTED; 1918 1947 } … … 1920 1949 else 1921 1950 { 1922 LogFlowFunc(("failed to get USER32 handle, err (%d)\n", GetLastError()));1951 WARN((__FUNCTION__": failed to get USER32 handle, err (%d)\n", GetLastError())); 1923 1952 err = ERROR_NOT_SUPPORTED; 1924 1953 } … … 1926 1955 else 1927 1956 { 1928 LogFlowFunc(("can not switch to VBOXDISPIF_MODE_XPDM, because os is not >= w2k\n"));1957 WARN((__FUNCTION__": can not switch to VBOXDISPIF_MODE_XPDM, because os is not >= w2k\n")); 1929 1958 err = ERROR_NOT_SUPPORTED; 1930 1959 } … … 1956 1985 { 1957 1986 case VBOXDISPIF_MODE_XPDM_NT4: 1958 Log FlowFunc(("request to switch to VBOXDISPIF_MODE_XPDM_NT4\n"));1987 Log((__FUNCTION__": request to switch to VBOXDISPIF_MODE_XPDM_NT4\n")); 1959 1988 err = vboxDispIfSwitchToXPDM_NT4(pIf); 1960 1989 if (err == NO_ERROR) 1961 1990 { 1962 Log FlowFunc(("successfully switched to XPDM_NT4 mode\n"));1991 Log((__FUNCTION__": successfully switched to XPDM_NT4 mode\n")); 1963 1992 pIf->enmMode = VBOXDISPIF_MODE_XPDM_NT4; 1964 1993 } 1965 1994 else 1966 LogFlowFunc(("failed to switch to XPDM_NT4 mode, err (%d)\n", err));1995 WARN((__FUNCTION__": failed to switch to XPDM_NT4 mode, err (%d)\n", err)); 1967 1996 break; 1968 1997 case VBOXDISPIF_MODE_XPDM: 1969 Log FlowFunc(("request to switch to VBOXDISPIF_MODE_XPDM\n"));1998 Log((__FUNCTION__": request to switch to VBOXDISPIF_MODE_XPDM\n")); 1970 1999 err = vboxDispIfSwitchToXPDM(pIf); 1971 2000 if (err == NO_ERROR) 1972 2001 { 1973 Log FlowFunc(("successfully switched to XPDM mode\n"));2002 Log((__FUNCTION__": successfully switched to XPDM mode\n")); 1974 2003 pIf->enmMode = VBOXDISPIF_MODE_XPDM; 1975 2004 } 1976 2005 else 1977 LogFlowFunc(("failed to switch to XPDM mode, err (%d)\n", err));2006 WARN((__FUNCTION__": failed to switch to XPDM mode, err (%d)\n", err)); 1978 2007 break; 1979 2008 #ifdef VBOX_WITH_WDDM 1980 2009 case VBOXDISPIF_MODE_WDDM: 1981 2010 { 1982 Log FlowFunc(("request to switch to VBOXDISPIF_MODE_WDDM\n"));2011 Log((__FUNCTION__": request to switch to VBOXDISPIF_MODE_WDDM\n")); 1983 2012 err = vboxDispIfSwitchToWDDM(pIf); 1984 2013 if (err == NO_ERROR) 1985 2014 { 1986 Log FlowFunc(("successfully switched to WDDM mode\n"));2015 Log((__FUNCTION__": successfully switched to WDDM mode\n")); 1987 2016 pIf->enmMode = VBOXDISPIF_MODE_WDDM; 1988 2017 } 1989 2018 else 1990 LogFlowFunc(("failed to switch to WDDM mode, err (%d)\n", err));2019 WARN((__FUNCTION__": failed to switch to WDDM mode, err (%d)\n", err)); 1991 2020 break; 1992 2021 } 1993 2022 case VBOXDISPIF_MODE_WDDM_W7: 1994 2023 { 1995 Log FlowFunc(("request to switch to VBOXDISPIF_MODE_WDDM_W7\n"));2024 Log((__FUNCTION__": request to switch to VBOXDISPIF_MODE_WDDM_W7\n")); 1996 2025 err = vboxDispIfSwitchToWDDM_W7(pIf); 1997 2026 if (err == NO_ERROR) 1998 2027 { 1999 Log FlowFunc(("successfully switched to WDDM mode\n"));2028 Log((__FUNCTION__": successfully switched to WDDM mode\n")); 2000 2029 pIf->enmMode = VBOXDISPIF_MODE_WDDM_W7; 2001 2030 } 2002 2031 else 2003 LogFlowFunc(("failed to switch to WDDM mode, err (%d)\n", err));2032 WARN((__FUNCTION__": failed to switch to WDDM mode, err (%d)\n", err)); 2004 2033 break; 2005 2034 } … … 2028 2057 #ifdef VBOX_DISPIF_WITH_OPCONTEXT 2029 2058 else 2030 LogFlowFunc(("vboxDispKmtCreateContext failed hr 0x%x", hr));2059 WARN(("VBoxTray: vboxDispKmtCreateContext failed hr 0x%x", hr)); 2031 2060 2032 2061 vboxDispKmtDestroyDevice(&pSeamless->modeData.wddm.Device); 2033 2062 } 2034 2063 else 2035 LogFlowFunc(("vboxDispKmtCreateDevice failed hr 0x%x", hr));2064 WARN(("VBoxTray: vboxDispKmtCreateDevice failed hr 0x%x", hr)); 2036 2065 2037 2066 vboxDispKmtCloseAdapter(&pSeamless->modeData.wddm.Adapter); … … 2070 2099 return ERROR_SUCCESS; 2071 2100 2072 LogFlowFunc(("pfnD3DKMTEscape Seamless failed Status 0x%x\n", Status));2101 WARN(("VBoxTray: pfnD3DKMTEscape Seamless failed Status 0x%x\n", Status)); 2073 2102 return Status; 2074 2103 } … … 2090 2119 #endif 2091 2120 default: 2092 LogFlowFunc(("VBoxDispIfSeamlesCreate: invalid mode %d\n", pIf->enmMode));2121 WARN(("VBoxTray: VBoxDispIfSeamlesCreate: invalid mode %d\n", pIf->enmMode)); 2093 2122 return ERROR_INVALID_PARAMETER; 2094 2123 } … … 2112 2141 #endif 2113 2142 default: 2114 LogFlowFunc(("VBoxDispIfSeamlesTerm: invalid mode %d\n", pIf->enmMode));2143 WARN(("VBoxTray: VBoxDispIfSeamlesTerm: invalid mode %d\n", pIf->enmMode)); 2115 2144 winEr = ERROR_INVALID_PARAMETER; 2116 2145 break; … … 2129 2158 if (pData->escapeCode != VBOXESC_SETVISIBLEREGION) 2130 2159 { 2131 LogFlowFunc(("invalid escape code for Seamless submit %d\n", pData->escapeCode));2160 WARN(("VBoxTray: invalid escape code for Seamless submit %d\n", pData->escapeCode)); 2132 2161 return ERROR_INVALID_PARAMETER; 2133 2162 } … … 2144 2173 #endif 2145 2174 default: 2146 LogFlowFunc(("VBoxDispIfSeamlesSubmit: invalid mode %d\n", pIf->enmMode));2175 WARN(("VBoxTray: VBoxDispIfSeamlesSubmit: invalid mode %d\n", pIf->enmMode)); 2147 2176 return ERROR_INVALID_PARAMETER; 2148 2177 } -
trunk/src/VBox/Additions/WINNT/include/VBoxDisplay.h
r50984 r52136 41 41 # define VBOXESC_SETALLOCHOSTID 0xABCD9014 42 42 # define VBOXESC_CRHGSMICTLCON_GETHOSTCAPS 0xABCD9015 43 # define VBOXESC_UPDATEMODES 0xABCD9016 43 44 #endif /* #ifdef VBOX_WITH_WDDM */ 44 45 … … 76 77 #include <VBox/Hardware/VBoxVideoVBE.h> 77 78 78 typedef struct 79 typedef struct VBOXWDDM_RECOMMENDVIDPN_SOURCE 79 80 { 80 DWORD Id;81 DWORD Width;82 DWORD Height; 83 DWORD BitsPerPixel; 84 DWORD PosX; 85 DWORD PosY;86 } VBOXWDDM_RECOMMENDVIDPN_ SCREEN_INFO, *PVBOXWDDM_RECOMMENDVIDPN_SCREEN_INFO;81 RTRECTSIZE Size; 82 } VBOXWDDM_RECOMMENDVIDPN_SOURCE; 83 84 typedef struct VBOXWDDM_RECOMMENDVIDPN_TARGET 85 { 86 int32_t iSource; 87 } VBOXWDDM_RECOMMENDVIDPN_TARGET; 87 88 88 89 typedef struct 89 90 { 90 uint32_t cScreenInfos;91 VBOXWDDM_RECOMMENDVIDPN_ SCREEN_INFO aScreenInfos[1];91 VBOXWDDM_RECOMMENDVIDPN_SOURCE aSources[VBOX_VIDEO_MAX_SCREENS]; 92 VBOXWDDM_RECOMMENDVIDPN_TARGET aTargets[VBOX_VIDEO_MAX_SCREENS]; 92 93 } VBOXWDDM_RECOMMENDVIDPN, *PVBOXWDDM_RECOMMENDVIDPN; 93 94 #define VBOXWDDM_RECOMMENDVIDPN_SIZE(_c) (RT_OFFSETOF(VBOXWDDM_RECOMMENDVIDPN, aScreenInfos[_c]))95 96 /* the mode was adjusted */97 #define VBOXWDDM_ADJUSTVIDEOMODE_F_ADJUSTED 0x0000000198 /* the mode is the currently active one */99 #define VBOXWDDM_ADJUSTVIDEOMODE_F_CURRENT 0x00000002100 /* the mode is unsupported */101 #define VBOXWDDM_ADJUSTVIDEOMODE_F_UNSUPPORTED 0x00000004102 /* invalid screen id */103 #define VBOXWDDM_ADJUSTVIDEOMODE_F_INVALISCREENID 0x00000008104 105 typedef struct VBOXWDDM_ADJUSTVIDEOMODE106 {107 uint32_t fFlags;108 VBOXWDDM_RECOMMENDVIDPN_SCREEN_INFO Mode;109 } VBOXWDDM_ADJUSTVIDEOMODE, *PVBOXWDDM_ADJUSTVIDEOMODE;110 111 typedef struct VBOXDISPIFESCAPE_ADJUSTVIDEOMODES112 {113 VBOXDISPIFESCAPE EscapeHdr;114 VBOXWDDM_ADJUSTVIDEOMODE aScreenInfos[1];115 } VBOXDISPIFESCAPE_ADJUSTVIDEOMODES, *PVBOXDISPIFESCAPE_ADJUSTVIDEOMODES;116 117 #define VBOXWDDM_REINITVIDEOMODESBYMASK_F_RECONNECT_DISPLAYS_ON_CHANGE 0x00000001118 94 119 95 #define VBOXWDDM_SCREENMASK_SIZE ((VBOX_VIDEO_MAX_SCREENS + 7) >> 3) 120 96 121 typedef struct VBOXDISPIFESCAPE_ REINITVIDEOMODESBYMASK97 typedef struct VBOXDISPIFESCAPE_UPDATEMODES 122 98 { 123 99 VBOXDISPIFESCAPE EscapeHdr; 124 uint8_t ScreenMask[VBOXWDDM_SCREENMASK_SIZE]; 125 } VBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK, *PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK; 100 uint32_t u32TargetId; 101 RTRECTSIZE Size; 102 } VBOXDISPIFESCAPE_UPDATEMODES; 126 103 127 104 #endif /* VBOX_WITH_WDDM */
Note:
See TracChangeset
for help on using the changeset viewer.

