VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp

Last change on this file was 98103, checked in by vboxsync, 16 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 14.6 KB
Line 
1/* $Id: VBoxD3DIf.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2/** @file
3 * VBoxVideo Display D3D User mode dll
4 */
5
6/*
7 * Copyright (C) 2012-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28#include "VBoxDispD3DCmn.h"
29
30/* DDI2D3D */
31
32D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format)
33{
34 /** @todo check they are all equal */
35 return (D3DFORMAT)format;
36}
37
38D3DMULTISAMPLE_TYPE vboxDDI2D3DMultiSampleType(D3DDDIMULTISAMPLE_TYPE enmType)
39{
40 /** @todo check they are all equal */
41 return (D3DMULTISAMPLE_TYPE)enmType;
42}
43
44D3DPOOL vboxDDI2D3DPool(D3DDDI_POOL enmPool)
45{
46 /** @todo check they are all equal */
47 switch (enmPool)
48 {
49 case D3DDDIPOOL_SYSTEMMEM:
50 return D3DPOOL_SYSTEMMEM;
51 case D3DDDIPOOL_VIDEOMEMORY:
52 case D3DDDIPOOL_LOCALVIDMEM:
53 case D3DDDIPOOL_NONLOCALVIDMEM:
54 /** @todo what would be proper here? */
55 return D3DPOOL_DEFAULT;
56 default:
57 Assert(0);
58 }
59 return D3DPOOL_DEFAULT;
60}
61
62D3DRENDERSTATETYPE vboxDDI2D3DRenderStateType(D3DDDIRENDERSTATETYPE enmType)
63{
64 /** @todo not entirely correct, need to check */
65 return (D3DRENDERSTATETYPE)enmType;
66}
67
68VBOXWDDMDISP_TSS_LOOKUP vboxDDI2D3DTestureStageStateType(D3DDDITEXTURESTAGESTATETYPE enmType)
69{
70 static const VBOXWDDMDISP_TSS_LOOKUP lookup[] =
71 {
72 {FALSE, D3DTSS_FORCE_DWORD}, /* 0, D3DDDITSS_TEXTUREMAP */
73 {FALSE, D3DTSS_COLOROP}, /* 1, D3DDDITSS_COLOROP */
74 {FALSE, D3DTSS_COLORARG1}, /* 2, D3DDDITSS_COLORARG1 */
75 {FALSE, D3DTSS_COLORARG2}, /* 3, D3DDDITSS_COLORARG2 */
76 {FALSE, D3DTSS_ALPHAOP}, /* 4, D3DDDITSS_ALPHAOP */
77 {FALSE, D3DTSS_ALPHAARG1}, /* 5, D3DDDITSS_ALPHAARG1 */
78 {FALSE, D3DTSS_ALPHAARG2}, /* 6, D3DDDITSS_ALPHAARG2 */
79 {FALSE, D3DTSS_BUMPENVMAT00}, /* 7, D3DDDITSS_BUMPENVMAT00 */
80 {FALSE, D3DTSS_BUMPENVMAT01}, /* 8, D3DDDITSS_BUMPENVMAT01 */
81 {FALSE, D3DTSS_BUMPENVMAT10}, /* 9, D3DDDITSS_BUMPENVMAT10 */
82 {FALSE, D3DTSS_BUMPENVMAT11}, /* 10, D3DDDITSS_BUMPENVMAT11 */
83 {FALSE, D3DTSS_TEXCOORDINDEX}, /* 11, D3DDDITSS_TEXCOORDINDEX */
84 {FALSE, D3DTSS_FORCE_DWORD}, /* 12, unused */
85 {TRUE, D3DSAMP_ADDRESSU}, /* 13, D3DDDITSS_ADDRESSU */
86 {TRUE, D3DSAMP_ADDRESSV}, /* 14, D3DDDITSS_ADDRESSV */
87 {TRUE, D3DSAMP_BORDERCOLOR}, /* 15, D3DDDITSS_BORDERCOLOR */
88 {TRUE, D3DSAMP_MAGFILTER}, /* 16, D3DDDITSS_MAGFILTER */
89 {TRUE, D3DSAMP_MINFILTER}, /* 17, D3DDDITSS_MINFILTER */
90 {TRUE, D3DSAMP_MIPFILTER}, /* 18, D3DDDITSS_MIPFILTER */
91 {TRUE, D3DSAMP_MIPMAPLODBIAS}, /* 19, D3DDDITSS_MIPMAPLODBIAS */
92 {TRUE, D3DSAMP_MAXMIPLEVEL}, /* 20, D3DDDITSS_MAXMIPLEVEL */
93 {TRUE, D3DSAMP_MAXANISOTROPY}, /* 21, D3DDDITSS_MAXANISOTROPY */
94 {FALSE, D3DTSS_BUMPENVLSCALE}, /* 22, D3DDDITSS_BUMPENVLSCALE */
95 {FALSE, D3DTSS_BUMPENVLOFFSET}, /* 23, D3DDDITSS_BUMPENVLOFFSET */
96 {FALSE, D3DTSS_TEXTURETRANSFORMFLAGS}, /* 24, D3DDDITSS_TEXTURETRANSFORMFLAGS */
97 {TRUE, D3DSAMP_ADDRESSW}, /* 25, D3DDDITSS_ADDRESSW */
98 {FALSE, D3DTSS_COLORARG0}, /* 26, D3DDDITSS_COLORARG0 */
99 {FALSE, D3DTSS_ALPHAARG0}, /* 27, D3DDDITSS_ALPHAARG0 */
100 {FALSE, D3DTSS_RESULTARG}, /* 28, D3DDDITSS_RESULTARG */
101 {TRUE, D3DSAMP_SRGBTEXTURE}, /* 29, D3DDDITSS_SRGBTEXTURE */
102 {TRUE, D3DSAMP_ELEMENTINDEX}, /* 30, D3DDDITSS_ELEMENTINDEX */
103 {TRUE, D3DSAMP_DMAPOFFSET}, /* 31, D3DDDITSS_DMAPOFFSET */
104 {FALSE, D3DTSS_CONSTANT}, /* 32, D3DDDITSS_CONSTANT */
105 {FALSE, D3DTSS_FORCE_DWORD}, /* 33, D3DDDITSS_DISABLETEXTURECOLORKEY */
106 {FALSE, D3DTSS_FORCE_DWORD}, /* 34, D3DDDITSS_TEXTURECOLORKEYVAL */
107 };
108
109 Assert(enmType > 0);
110 Assert(enmType < RT_ELEMENTS(lookup));
111 Assert(lookup[enmType].dType != D3DTSS_FORCE_DWORD);
112
113 return lookup[enmType];
114}
115
116DWORD vboxDDI2D3DUsage(D3DDDI_RESOURCEFLAGS fFlags)
117{
118 DWORD fUsage = 0;
119 if (fFlags.Dynamic)
120 fUsage |= D3DUSAGE_DYNAMIC;
121 if (fFlags.AutogenMipmap)
122 fUsage |= D3DUSAGE_AUTOGENMIPMAP;
123 if (fFlags.DMap)
124 fUsage |= D3DUSAGE_DMAP;
125 if (fFlags.WriteOnly)
126 fUsage |= D3DUSAGE_WRITEONLY;
127 if (fFlags.NPatches)
128 fUsage |= D3DUSAGE_NPATCHES;
129 if (fFlags.Points)
130 fUsage |= D3DUSAGE_POINTS;
131 if (fFlags.RenderTarget)
132 fUsage |= D3DUSAGE_RENDERTARGET;
133 if (fFlags.RtPatches)
134 fUsage |= D3DUSAGE_RTPATCHES;
135 if (fFlags.TextApi)
136 fUsage |= D3DUSAGE_TEXTAPI;
137 if (fFlags.WriteOnly)
138 fUsage |= D3DUSAGE_WRITEONLY;
139 //below are wddm 1.1-specific
140// if (fFlags.RestrictedContent)
141// fUsage |= D3DUSAGE_RESTRICTED_CONTENT;
142// if (fFlags.RestrictSharedAccess)
143// fUsage |= D3DUSAGE_RESTRICT_SHARED_RESOURCE;
144 return fUsage;
145}
146
147DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags)
148{
149 DWORD fFlags = 0;
150 if (fLockFlags.Discard)
151 fFlags |= D3DLOCK_DISCARD;
152 if (fLockFlags.NoOverwrite)
153 fFlags |= D3DLOCK_NOOVERWRITE;
154 if (fLockFlags.ReadOnly)
155 fFlags |= D3DLOCK_READONLY;
156 if (fLockFlags.DoNotWait)
157 fFlags |= D3DLOCK_DONOTWAIT;
158 return fFlags;
159}
160
161D3DTEXTUREFILTERTYPE vboxDDI2D3DBltFlags(D3DDDI_BLTFLAGS fFlags)
162{
163 if (fFlags.Point)
164 {
165 /* no flags other than [Begin|Continue|End]PresentToDwm are set */
166 Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 1);
167 return D3DTEXF_POINT;
168 }
169 if (fFlags.Linear)
170 {
171 /* no flags other than [Begin|Continue|End]PresentToDwm are set */
172 Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 2);
173 return D3DTEXF_LINEAR;
174 }
175 /* no flags other than [Begin|Continue|End]PresentToDwm are set */
176 Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 0);
177 return D3DTEXF_NONE;
178}
179
180D3DQUERYTYPE vboxDDI2D3DQueryType(D3DDDIQUERYTYPE enmType)
181{
182 return (D3DQUERYTYPE)enmType;
183}
184
185DWORD vboxDDI2D3DIssueQueryFlags(D3DDDI_ISSUEQUERYFLAGS Flags)
186{
187 DWORD fFlags = 0;
188 if (Flags.Begin)
189 fFlags |= D3DISSUE_BEGIN;
190 if (Flags.End)
191 fFlags |= D3DISSUE_END;
192 return fFlags;
193}
194
195void VBoxD3DIfLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo)
196{
197 Assert(pAlloc->SurfDesc.pitch);
198 Assert(pAlloc->pvMem);
199
200 if (!pRect)
201 {
202 if (pAlloc->SurfDesc.pitch == (UINT)pLockInfo->Pitch)
203 {
204 Assert(pAlloc->SurfDesc.cbSize);
205 if (bToLockInfo)
206 memcpy(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.cbSize);
207 else
208 memcpy(pAlloc->pvMem, pLockInfo->pBits, pAlloc->SurfDesc.cbSize);
209 }
210 else
211 {
212 uint8_t *pvSrc, *pvDst;
213 uint32_t srcPitch, dstPitch;
214 if (bToLockInfo)
215 {
216 pvSrc = (uint8_t *)pAlloc->pvMem;
217 pvDst = (uint8_t *)pLockInfo->pBits;
218 srcPitch = pAlloc->SurfDesc.pitch;
219 dstPitch = pLockInfo->Pitch;
220 }
221 else
222 {
223 pvDst = (uint8_t *)pAlloc->pvMem;
224 pvSrc = (uint8_t *)pLockInfo->pBits;
225 dstPitch = pAlloc->SurfDesc.pitch;
226 srcPitch = (uint32_t)pLockInfo->Pitch;
227 }
228
229 uint32_t cRows = vboxWddmCalcNumRows(0, pAlloc->SurfDesc.height, pAlloc->SurfDesc.format);
230 uint32_t pitch = RT_MIN(srcPitch, dstPitch);
231 Assert(pitch);
232 for (UINT j = 0; j < cRows; ++j)
233 {
234 memcpy(pvDst, pvSrc, pitch);
235 pvSrc += srcPitch;
236 pvDst += dstPitch;
237 }
238 }
239 }
240 else
241 {
242 uint8_t *pvSrc, *pvDst;
243 uint32_t srcPitch, dstPitch;
244 uint8_t * pvAllocMemStart = (uint8_t *)pAlloc->pvMem;
245 uint32_t offAllocMemStart = vboxWddmCalcOffXYrd(pRect->left, pRect->top, pAlloc->SurfDesc.pitch, pAlloc->SurfDesc.format);
246 pvAllocMemStart += offAllocMemStart;
247
248 if (bToLockInfo)
249 {
250 pvSrc = (uint8_t *)pvAllocMemStart;
251 pvDst = (uint8_t *)pLockInfo->pBits;
252 srcPitch = pAlloc->SurfDesc.pitch;
253 dstPitch = pLockInfo->Pitch;
254 }
255 else
256 {
257 pvDst = (uint8_t *)pvAllocMemStart;
258 pvSrc = (uint8_t *)pLockInfo->pBits;
259 dstPitch = pAlloc->SurfDesc.pitch;
260 srcPitch = (uint32_t)pLockInfo->Pitch;
261 }
262
263 if (pRect->right - pRect->left == (LONG)pAlloc->SurfDesc.width && srcPitch == dstPitch)
264 {
265 uint32_t cbSize = vboxWddmCalcSize(pAlloc->SurfDesc.pitch, pRect->bottom - pRect->top, pAlloc->SurfDesc.format);
266 memcpy(pvDst, pvSrc, cbSize);
267 }
268 else
269 {
270 uint32_t pitch = RT_MIN(srcPitch, dstPitch);
271 uint32_t cbCopyLine = vboxWddmCalcRowSize(pRect->left, pRect->right, pAlloc->SurfDesc.format);
272 Assert(pitch); NOREF(pitch);
273 uint32_t cRows = vboxWddmCalcNumRows(pRect->top, pRect->bottom, pAlloc->SurfDesc.format);
274 for (UINT j = 0; j < cRows; ++j)
275 {
276 memcpy(pvDst, pvSrc, cbCopyLine);
277 pvSrc += srcPitch;
278 pvDst += dstPitch;
279 }
280 }
281 }
282}
283
284HRESULT VBoxD3DIfLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,
285 D3DLOCKED_RECT * pLockedRect,
286 CONST RECT *pRect,
287 DWORD fLockFlags)
288{
289 HRESULT hr = E_FAIL;
290 Assert(!pRc->aAllocations[iAlloc].LockInfo.cLocks);
291 Assert(pRc->cAllocations > iAlloc);
292 switch (pRc->aAllocations[0].enmD3DIfType)
293 {
294 case VBOXDISP_D3DIFTYPE_SURFACE:
295 {
296 IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
297 Assert(pD3DIfSurf);
298 hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags);
299 Assert(hr == S_OK);
300 break;
301 }
302 case VBOXDISP_D3DIFTYPE_TEXTURE:
303 {
304 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
305 Assert(pD3DIfTex);
306 hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags);
307 Assert(hr == S_OK);
308 break;
309 }
310 case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
311 {
312 IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;
313 Assert(pD3DIfCubeTex);
314 hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc),
315 VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), pLockedRect, pRect, fLockFlags);
316 Assert(hr == S_OK);
317 break;
318 }
319 case VBOXDISP_D3DIFTYPE_VERTEXBUFFER:
320 {
321 IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;
322 Assert(pD3D9VBuf);
323 hr = pD3D9VBuf->Lock(pRect ? pRect->left : 0/* offset */,
324 pRect ? pRect->right : 0 /* size 2 lock - 0 means all */,
325 &pLockedRect->pBits, fLockFlags);
326 Assert(hr == S_OK);
327 pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch;
328 break;
329 }
330 case VBOXDISP_D3DIFTYPE_INDEXBUFFER:
331 {
332 IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;
333 Assert(pD3D9IBuf);
334 hr = pD3D9IBuf->Lock(pRect ? pRect->left : 0/* offset */,
335 pRect ? pRect->right : 0 /* size 2 lock - 0 means all */,
336 &pLockedRect->pBits, fLockFlags);
337 Assert(hr == S_OK);
338 pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch;
339 break;
340 }
341 default:
342 WARN(("uknown if type %d", pRc->aAllocations[0].enmD3DIfType));
343 break;
344 }
345 return hr;
346}
347
348HRESULT VBoxD3DIfUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc)
349{
350 HRESULT hr = S_OK;
351 Assert(pRc->cAllocations > iAlloc);
352 switch (pRc->aAllocations[0].enmD3DIfType)
353 {
354 case VBOXDISP_D3DIFTYPE_SURFACE:
355 {
356 IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
357 Assert(pD3DIfSurf);
358 hr = pD3DIfSurf->UnlockRect();
359 Assert(hr == S_OK);
360 break;
361 }
362 case VBOXDISP_D3DIFTYPE_TEXTURE:
363 {
364 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
365 Assert(pD3DIfTex);
366 hr = pD3DIfTex->UnlockRect(iAlloc);
367 Assert(hr == S_OK);
368 break;
369 }
370 case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
371 {
372 IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;
373 Assert(pD3DIfCubeTex);
374 hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc),
375 VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc));
376 Assert(hr == S_OK);
377 break;
378 }
379 case VBOXDISP_D3DIFTYPE_VERTEXBUFFER:
380 {
381 IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;
382 Assert(pD3D9VBuf);
383 hr = pD3D9VBuf->Unlock();
384 Assert(hr == S_OK);
385 break;
386 }
387 case VBOXDISP_D3DIFTYPE_INDEXBUFFER:
388 {
389 IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;
390 Assert(pD3D9IBuf);
391 hr = pD3D9IBuf->Unlock();
392 Assert(hr == S_OK);
393 break;
394 }
395 default:
396 WARN(("uknown if type %d", pRc->aAllocations[0].enmD3DIfType));
397 hr = E_FAIL;
398 break;
399 }
400 return hr;
401}
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use