VirtualBox

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

Last change on this file was 102505, checked in by vboxsync, 6 months ago

WDDM: user mode driver update: bugref:10529
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 46.7 KB
Line 
1/* $Id: VBoxDXVideo.cpp 102505 2023-12-06 14:48:31Z vboxsync $ */
2/** @file
3 * VirtualBox D3D user mode driver.
4 */
5
6/*
7 * Copyright (C) 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 <iprt/alloc.h>
29#include <iprt/errcore.h>
30#include <iprt/thread.h>
31#include <VBox/log.h>
32
33#include <iprt/win/windows.h>
34#include <iprt/win/d3dkmthk.h>
35
36#include <d3d10umddi.h>
37
38#include "VBoxDX.h"
39#include "VBoxDXCmd.h"
40
41
42static void vboxDXDestroyVideoDeviceAllocation(PVBOXDX_DEVICE pDevice)
43{
44 if (pDevice->VideoDevice.hAllocation)
45 {
46 D3DDDICB_DEALLOCATE ddiDeallocate;
47 RT_ZERO(ddiDeallocate);
48 ddiDeallocate.NumAllocations = 1;
49 ddiDeallocate.HandleList = &pDevice->VideoDevice.hAllocation;
50
51 HRESULT hr = pDevice->pRTCallbacks->pfnDeallocateCb(pDevice->hRTDevice.handle, &ddiDeallocate);
52 LogFlowFunc(("pfnDeallocateCb returned %d", hr));
53 AssertStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
54
55 pDevice->VideoDevice.hAllocation = 0;
56 pDevice->VideoDevice.cbAllocation = 0;
57 }
58}
59
60
61static bool vboxDXCreateVideoDeviceAllocation(PVBOXDX_DEVICE pDevice, uint32_t cbAllocation)
62{
63 VBOXDXALLOCATIONDESC desc;
64 RT_ZERO(desc);
65 desc.enmAllocationType = VBOXDXALLOCATIONTYPE_CO; /* Context Object allocation. */
66 desc.cbAllocation = cbAllocation;
67
68 D3DDDI_ALLOCATIONINFO2 ddiAllocationInfo;
69 RT_ZERO(ddiAllocationInfo);
70 ddiAllocationInfo.pPrivateDriverData = &desc;
71 ddiAllocationInfo.PrivateDriverDataSize = sizeof(desc);
72
73 D3DDDICB_ALLOCATE ddiAllocate;
74 RT_ZERO(ddiAllocate);
75 ddiAllocate.NumAllocations = 1;
76 ddiAllocate.pAllocationInfo2 = &ddiAllocationInfo;
77
78 HRESULT hr = pDevice->pRTCallbacks->pfnAllocateCb(pDevice->hRTDevice.handle, &ddiAllocate);
79 LogFlowFunc(("pfnAllocateCb returned %d, hKMResource 0x%X, hAllocation 0x%X", hr, ddiAllocate.hKMResource, ddiAllocationInfo.hAllocation));
80 AssertReturnStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr), false);
81
82 pDevice->VideoDevice.hAllocation = ddiAllocationInfo.hAllocation;
83 pDevice->VideoDevice.cbAllocation = cbAllocation;
84
85 D3DDDICB_LOCK ddiLock;
86 RT_ZERO(ddiLock);
87 ddiLock.hAllocation = ddiAllocationInfo.hAllocation;
88 ddiLock.Flags.WriteOnly = 1;
89 hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
90 if (SUCCEEDED(hr))
91 {
92 memset(ddiLock.pData, 0, cbAllocation);
93
94 D3DDDICB_UNLOCK ddiUnlock;
95 ddiUnlock.NumAllocations = 1;
96 ddiUnlock.phAllocations = &ddiAllocationInfo.hAllocation;
97 hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
98 }
99 AssertReturnStmt(SUCCEEDED(hr),
100 vboxDXDestroyVideoDeviceAllocation(pDevice); vboxDXDeviceSetError(pDevice, hr), false);
101 return true;
102}
103
104
105static bool vboxDXEnsureVideoDeviceAllocation(PVBOXDX_DEVICE pDevice)
106{
107 if (!pDevice->VideoDevice.hAllocation)
108 return vboxDXCreateVideoDeviceAllocation(pDevice, _64K);
109 return true;
110}
111
112
113static void vboxDXQueryVideoCapability(PVBOXDX_DEVICE pDevice, VBSVGA3dVideoCapability cap,
114 void const *pvDataIn, uint32_t cbDataIn,
115 void **ppvDataOut, uint32_t *pcbDataOut)
116{
117 bool fSuccess = vboxDXEnsureVideoDeviceAllocation(pDevice);
118 if (!fSuccess)
119 return;
120
121 uint32 const offsetInBytes = 0;
122 uint32 const sizeInBytes = pDevice->VideoDevice.cbAllocation - offsetInBytes;
123 AssertReturnVoid(cbDataIn <= sizeInBytes - RT_UOFFSETOF(VBSVGA3dVideoCapabilityMobLayout, data));
124
125 if (cbDataIn)
126 {
127 D3DDDICB_LOCK ddiLock;
128 RT_ZERO(ddiLock);
129 ddiLock.hAllocation = pDevice->VideoDevice.hAllocation;
130 ddiLock.Flags.ReadOnly = 1;
131 HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
132 if (SUCCEEDED(hr))
133 {
134 VBSVGA3dVideoCapabilityMobLayout *pCap = (VBSVGA3dVideoCapabilityMobLayout *)ddiLock.pData;
135 memcpy(&pCap->data, pvDataIn, cbDataIn);
136
137 D3DDDICB_UNLOCK ddiUnlock;
138 ddiUnlock.NumAllocations = 1;
139 ddiUnlock.phAllocations = &pDevice->VideoDevice.hAllocation;
140 hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
141 }
142 AssertReturnVoidStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
143 }
144
145 uint64_t const fenceValue = ASMAtomicIncU64(&pDevice->VideoDevice.u64MobFenceValue);
146 vgpu10GetVideoCapability(pDevice, cap, pDevice->VideoDevice.hAllocation, offsetInBytes, sizeInBytes, fenceValue);
147 vboxDXDeviceFlushCommands(pDevice);
148
149 /** @todo Time limit? */
150 bool fDone = false;
151 for (;;)
152 {
153 RTThreadYield();
154
155 D3DDDICB_LOCK ddiLock;
156 RT_ZERO(ddiLock);
157 ddiLock.hAllocation = pDevice->VideoDevice.hAllocation;
158 ddiLock.Flags.ReadOnly = 1;
159 HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
160 if (SUCCEEDED(hr))
161 {
162 VBSVGA3dVideoCapabilityMobLayout const *pCap = (VBSVGA3dVideoCapabilityMobLayout *)ddiLock.pData;
163 if (pCap->fenceValue >= fenceValue)
164 {
165 if (pCap->cbDataOut > 0)
166 {
167 void *pvData = RTMemAlloc(pCap->cbDataOut);
168 if (pvData)
169 {
170 memcpy(pvData, &pCap->data, pCap->cbDataOut);
171 *ppvDataOut = pvData;
172 *pcbDataOut = pCap->cbDataOut;
173 }
174 else
175 vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY);
176 }
177
178 fDone = true;
179 }
180
181 D3DDDICB_UNLOCK ddiUnlock;
182 ddiUnlock.NumAllocations = 1;
183 ddiUnlock.phAllocations = &pDevice->VideoDevice.hAllocation;
184 hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
185 }
186 AssertReturnVoidStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
187
188 if (fDone)
189 break;
190 }
191}
192
193
194static void vboxDXQueryVideoDecodeProfiles(PVBOXDX_DEVICE pDevice)
195{
196 RTMemFree(pDevice->VideoDevice.paDecodeProfile);
197 pDevice->VideoDevice.cDecodeProfile = 0;
198
199 /* On failure the pDevice->VideoDevice.cDecodeProfile value is 0, i.e. no decoding. */
200 pDevice->VideoDevice.fDecodeProfilesQueried = true;
201
202 void *pvDataOut = 0;
203 uint32_t cbDataOut = 0;
204 vboxDXQueryVideoCapability(pDevice, VBSVGA3D_VIDEO_CAPABILITY_DECODE_PROFILE,
205 NULL, 0, &pvDataOut, &cbDataOut);
206 if (pvDataOut)
207 {
208 pDevice->VideoDevice.cDecodeProfile = cbDataOut / sizeof(VBSVGA3dDecodeProfileInfo);
209 pDevice->VideoDevice.paDecodeProfile = (VBSVGA3dDecodeProfileInfo *)pvDataOut;
210 }
211}
212
213
214static void vboxDXQueryVideoDecodeConfig(PVBOXDX_DEVICE pDevice, VBSVGA3dVideoDecoderDesc const &desc)
215{
216 RTMemFree(pDevice->VideoDevice.config.pConfigInfo);
217 pDevice->VideoDevice.config.cConfig = 0;
218
219 void *pvDataOut = 0;
220 uint32_t cbDataOut = 0;
221 vboxDXQueryVideoCapability(pDevice, VBSVGA3D_VIDEO_CAPABILITY_DECODE_CONFIG,
222 &desc, sizeof(desc), &pvDataOut, &cbDataOut);
223 if (pvDataOut)
224 {
225 AssertReturnVoidStmt(cbDataOut >= sizeof(desc), RTMemFree(pvDataOut));
226
227 VBSVGA3dDecodeConfigInfo *pConfigInfo = (VBSVGA3dDecodeConfigInfo *)pvDataOut;
228 pDevice->VideoDevice.config.pConfigInfo = pConfigInfo;
229 pDevice->VideoDevice.config.cConfig = (cbDataOut - sizeof(pConfigInfo->desc)) / sizeof(pConfigInfo->aConfig[0]);
230 }
231}
232
233
234static void vboxDXQueryVideoProcessorEnumInfo(PVBOXDX_DEVICE pDevice, VBSVGA3dVideoProcessorDesc const &desc)
235{
236 void *pvDataOut = 0;
237 uint32_t cbDataOut = 0;
238 vboxDXQueryVideoCapability(pDevice, VBSVGA3D_VIDEO_CAPABILITY_PROCESSOR_ENUM,
239 &desc, sizeof(desc), &pvDataOut, &cbDataOut);
240 if (pvDataOut)
241 {
242 AssertReturnVoidStmt(cbDataOut >= sizeof(VBSVGA3dProcessorEnumInfo), RTMemFree(pvDataOut));
243
244 VBSVGA3dProcessorEnumInfo *pInfo = (VBSVGA3dProcessorEnumInfo *)pvDataOut;
245 pDevice->VideoDevice.videoProcessorEnum.desc = desc;
246 pDevice->VideoDevice.videoProcessorEnum.info = pInfo->info;
247
248 RTMemFree(pvDataOut);
249 }
250}
251
252
253void vboxDXGetVideoDecoderProfileCount(PVBOXDX_DEVICE pDevice, UINT *pDecodeProfileCount)
254{
255 if (!pDevice->VideoDevice.fDecodeProfilesQueried)
256 vboxDXQueryVideoDecodeProfiles(pDevice);
257
258 *pDecodeProfileCount = pDevice->VideoDevice.cDecodeProfile;
259}
260
261
262void vboxDXGetVideoDecoderProfile(PVBOXDX_DEVICE pDevice, UINT Index, GUID *pGuid)
263{
264 if (!pDevice->VideoDevice.fDecodeProfilesQueried)
265 vboxDXQueryVideoDecodeProfiles(pDevice);
266
267 *pGuid = *(GUID *)&pDevice->VideoDevice.paDecodeProfile[Index].DecodeProfile;
268}
269
270
271void vboxDXCheckVideoDecoderFormat(PVBOXDX_DEVICE pDevice, GUID const *pDecodeProfile, DXGI_FORMAT Format, BOOL *pSupported)
272{
273 if (!pDevice->VideoDevice.fDecodeProfilesQueried)
274 vboxDXQueryVideoDecodeProfiles(pDevice);
275
276 for (unsigned i = 0; i < pDevice->VideoDevice.cDecodeProfile; ++i)
277 {
278 VBSVGA3dDecodeProfileInfo const *s = &pDevice->VideoDevice.paDecodeProfile[i];
279 if (memcmp(&s->DecodeProfile, pDecodeProfile, sizeof(s->DecodeProfile)) == 0)
280 {
281 switch (Format)
282 {
283 case DXGI_FORMAT_AYUV: *pSupported = RT_BOOL(s->fAYUV); break;
284 case DXGI_FORMAT_NV12: *pSupported = RT_BOOL(s->fNV12); break;
285 case DXGI_FORMAT_420_OPAQUE: *pSupported = RT_BOOL(s->fNV12); break;
286 case DXGI_FORMAT_YUY2: *pSupported = RT_BOOL(s->fYUY2); break;
287 default: *pSupported = false;
288 }
289 break;
290 }
291 }
292}
293
294
295static void vboxDXVideoDecoderDescToSvga(VBSVGA3dVideoDecoderDesc *pSvgaDecoderDesc, D3D11_1DDI_VIDEO_DECODER_DESC const &Desc)
296{
297 memcpy(&pSvgaDecoderDesc->DecodeProfile, &Desc.Guid, sizeof(VBSVGA3dGuid));
298 pSvgaDecoderDesc->SampleWidth = Desc.SampleWidth;
299 pSvgaDecoderDesc->SampleHeight = Desc.SampleHeight;
300 pSvgaDecoderDesc->OutputFormat = vboxDXDxgiToSvgaFormat(Desc.OutputFormat);
301}
302
303
304void vboxDXGetVideoDecoderConfigCount(PVBOXDX_DEVICE pDevice, D3D11_1DDI_VIDEO_DECODER_DESC const *pDecodeDesc, UINT *pConfigCount)
305{
306 VBSVGA3dVideoDecoderDesc svgaDesc;
307 vboxDXVideoDecoderDescToSvga(&svgaDesc, *pDecodeDesc);
308
309 if ( !pDevice->VideoDevice.config.pConfigInfo
310 || memcmp(&svgaDesc, &pDevice->VideoDevice.config.pConfigInfo->desc, sizeof(VBSVGA3dVideoDecoderDesc)) != 0)
311 vboxDXQueryVideoDecodeConfig(pDevice, svgaDesc);
312
313 *pConfigCount = pDevice->VideoDevice.config.cConfig;
314}
315
316
317void vboxDXGetVideoDecoderConfig(PVBOXDX_DEVICE pDevice, D3D11_1DDI_VIDEO_DECODER_DESC const *pDecodeDesc, UINT Index,
318 D3D11_1DDI_VIDEO_DECODER_CONFIG *pConfig)
319{
320 VBSVGA3dVideoDecoderDesc svgaDesc;
321 vboxDXVideoDecoderDescToSvga(&svgaDesc, *pDecodeDesc);
322
323 if ( !pDevice->VideoDevice.config.pConfigInfo
324 || memcmp(&svgaDesc, &pDevice->VideoDevice.config.pConfigInfo->desc, sizeof(VBSVGA3dVideoDecoderDesc)) != 0)
325 vboxDXQueryVideoDecodeConfig(pDevice, svgaDesc);
326
327 AssertReturnVoidStmt(Index <= pDevice->VideoDevice.config.cConfig, vboxDXDeviceSetError(pDevice, E_INVALIDARG));
328
329 VBSVGA3dVideoDecoderConfig const *s = &pDevice->VideoDevice.config.pConfigInfo->aConfig[Index];
330 memcpy(&pConfig->guidConfigBitstreamEncryption, &s->guidConfigBitstreamEncryption, sizeof(GUID));
331 memcpy(&pConfig->guidConfigMBcontrolEncryption, &s->guidConfigMBcontrolEncryption, sizeof(GUID));
332 memcpy(&pConfig->guidConfigResidDiffEncryption, &s->guidConfigResidDiffEncryption, sizeof(GUID));
333 pConfig->ConfigBitstreamRaw = s->ConfigBitstreamRaw;
334 pConfig->ConfigMBcontrolRasterOrder = s->ConfigMBcontrolRasterOrder;
335 pConfig->ConfigResidDiffHost = s->ConfigResidDiffHost;
336 pConfig->ConfigSpatialResid8 = s->ConfigSpatialResid8;
337 pConfig->ConfigResid8Subtraction = s->ConfigResid8Subtraction;
338 pConfig->ConfigSpatialHost8or9Clipping = s->ConfigSpatialHost8or9Clipping;
339 pConfig->ConfigSpatialResidInterleaved = s->ConfigSpatialResidInterleaved;
340 pConfig->ConfigIntraResidUnsigned = s->ConfigIntraResidUnsigned;
341 pConfig->ConfigResidDiffAccelerator = s->ConfigResidDiffAccelerator;
342 pConfig->ConfigHostInverseScan = s->ConfigHostInverseScan;
343 pConfig->ConfigSpecificIDCT = s->ConfigSpecificIDCT;
344 pConfig->Config4GroupedCoefs = s->Config4GroupedCoefs;
345 pConfig->ConfigMinRenderTargetBuffCount = s->ConfigMinRenderTargetBuffCount;
346 pConfig->ConfigDecoderSpecific = s->ConfigDecoderSpecific;
347}
348
349
350HRESULT vboxDXCreateVideoProcessorEnum(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum,
351 D3D11_1DDI_VIDEO_PROCESSOR_CONTENT_DESC const *pDesc)
352{
353 RT_NOREF(pDevice);
354
355 pVideoProcessorEnum->svga.desc.InputFrameFormat = pDesc->InputFrameFormat;
356 pVideoProcessorEnum->svga.desc.InputFrameRate.numerator = pDesc->InputFrameRate.Numerator;
357 pVideoProcessorEnum->svga.desc.InputFrameRate.denominator = pDesc->InputFrameRate.Denominator;
358 pVideoProcessorEnum->svga.desc.InputWidth = pDesc->InputWidth;
359 pVideoProcessorEnum->svga.desc.InputHeight = pDesc->InputHeight;
360 pVideoProcessorEnum->svga.desc.OutputFrameRate.numerator = pDesc->OutputFrameRate.Numerator;
361 pVideoProcessorEnum->svga.desc.OutputFrameRate.denominator = pDesc->OutputFrameRate.Denominator;
362 pVideoProcessorEnum->svga.desc.OutputWidth = pDesc->OutputWidth;
363 pVideoProcessorEnum->svga.desc.OutputHeight = pDesc->OutputHeight;
364 pVideoProcessorEnum->svga.desc.Usage = pDesc->Usage;
365 return S_OK;
366}
367
368
369void vboxDXCheckVideoProcessorFormat(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum,
370 DXGI_FORMAT Format, UINT *pSupported)
371{
372 if (memcmp(&pVideoProcessorEnum->svga.desc,
373 &pDevice->VideoDevice.videoProcessorEnum.desc, sizeof(pVideoProcessorEnum->svga.desc)) != 0)
374 vboxDXQueryVideoProcessorEnumInfo(pDevice, pVideoProcessorEnum->svga.desc);
375
376 AssertCompile(D3D11_1DDI_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT == VBSVGA3D_VP_FORMAT_SUPPORT_INPUT);
377 AssertCompile(D3D11_1DDI_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT == VBSVGA3D_VP_FORMAT_SUPPORT_OUTPUT);
378 VBSVGA3dVideoProcessorEnumInfo const *pInfo = &pDevice->VideoDevice.videoProcessorEnum.info;
379 switch (Format)
380 {
381 case DXGI_FORMAT_R8_UNORM: *pSupported = pInfo->fR8_UNORM; break;
382 case DXGI_FORMAT_R16_UNORM: *pSupported = pInfo->fR16_UNORM; break;
383 case DXGI_FORMAT_NV12: *pSupported = pInfo->fNV12; break;
384 case DXGI_FORMAT_YUY2: *pSupported = pInfo->fYUY2; break;
385 case DXGI_FORMAT_R16G16B16A16_FLOAT: *pSupported = pInfo->fR16G16B16A16_FLOAT; break;
386 case DXGI_FORMAT_B8G8R8X8_UNORM: *pSupported = pInfo->fB8G8R8X8_UNORM; break;
387 case DXGI_FORMAT_B8G8R8A8_UNORM: *pSupported = pInfo->fB8G8R8A8_UNORM; break;
388 case DXGI_FORMAT_R8G8B8A8_UNORM: *pSupported = pInfo->fR8G8B8A8_UNORM; break;
389 case DXGI_FORMAT_R10G10B10A2_UNORM: *pSupported = pInfo->fR10G10B10A2_UNORM; break;
390 case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM: *pSupported = pInfo->fR10G10B10_XR_BIAS_A2_UNORM; break;
391 case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: *pSupported = pInfo->fR8G8B8A8_UNORM_SRGB; break;
392 case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: *pSupported = pInfo->fB8G8R8A8_UNORM_SRGB; break;
393 default: *pSupported = 0;
394 }
395}
396
397
398void vboxDXGetVideoProcessorCaps(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum,
399 D3D11_1DDI_VIDEO_PROCESSOR_CAPS *pCaps)
400{
401 if (memcmp(&pVideoProcessorEnum->svga.desc,
402 &pDevice->VideoDevice.videoProcessorEnum.desc, sizeof(pVideoProcessorEnum->svga.desc)) != 0)
403 vboxDXQueryVideoProcessorEnumInfo(pDevice, pVideoProcessorEnum->svga.desc);
404
405 VBSVGA3dVideoProcessorEnumInfo const *pInfo = &pDevice->VideoDevice.videoProcessorEnum.info;
406 pCaps->DeviceCaps = pInfo->Caps.DeviceCaps;
407 pCaps->FeatureCaps = pInfo->Caps.FeatureCaps;
408 pCaps->FilterCaps = pInfo->Caps.FilterCaps;
409 pCaps->InputFormatCaps = pInfo->Caps.InputFormatCaps;
410 pCaps->AutoStreamCaps = pInfo->Caps.AutoStreamCaps;
411 pCaps->StereoCaps = pInfo->Caps.StereoCaps;
412 pCaps->RateConversionCapsCount = RT_MIN(pInfo->Caps.RateConversionCapsCount, VBSVGA3D_MAX_VIDEO_RATE_CONVERSION_CAPS);
413 pCaps->MaxInputStreams = RT_MIN(pInfo->Caps.MaxInputStreams, VBSVGA3D_MAX_VIDEO_STREAMS);
414 pCaps->MaxStreamStates = RT_MIN(pInfo->Caps.MaxStreamStates, VBSVGA3D_MAX_VIDEO_STREAMS);
415}
416
417
418void vboxDXGetVideoProcessorRateConversionCaps(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum,
419 D3D11_1DDI_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps)
420{
421 if (memcmp(&pVideoProcessorEnum->svga.desc,
422 &pDevice->VideoDevice.videoProcessorEnum.desc, sizeof(pVideoProcessorEnum->svga.desc)) != 0)
423 vboxDXQueryVideoProcessorEnumInfo(pDevice, pVideoProcessorEnum->svga.desc);
424
425 VBSVGA3dVideoProcessorEnumInfo const *pInfo = &pDevice->VideoDevice.videoProcessorEnum.info;
426 pCaps->PastFrames = pInfo->RateCaps.PastFrames;
427 pCaps->FutureFrames = pInfo->RateCaps.FutureFrames;
428 pCaps->ConversionCaps = pInfo->RateCaps.ProcessorCaps;
429 pCaps->ITelecineCaps = pInfo->RateCaps.ITelecineCaps;
430 pCaps->CustomRateCount = RT_MIN(pInfo->RateCaps.CustomRateCount, VBSVGA3D_MAX_VIDEO_CUSTOM_RATE_CAPS);;
431}
432
433
434void vboxDXGetVideoProcessorCustomRate(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum,
435 UINT CustomRateIndex, D3D11_1DDI_VIDEO_PROCESSOR_CUSTOM_RATE *pRate)
436{
437 if (memcmp(&pVideoProcessorEnum->svga.desc,
438 &pDevice->VideoDevice.videoProcessorEnum.desc, sizeof(pVideoProcessorEnum->svga.desc)) != 0)
439 vboxDXQueryVideoProcessorEnumInfo(pDevice, pVideoProcessorEnum->svga.desc);
440
441 VBSVGA3dVideoProcessorEnumInfo const *pInfo = &pDevice->VideoDevice.videoProcessorEnum.info;
442 VBSVGA3dVideoProcessorCustomRateCaps const *pCustomRateCaps = &pInfo->aCustomRateCaps[CustomRateIndex];
443 pRate->CustomRate.Numerator = pCustomRateCaps->CustomRate.numerator;
444 pRate->CustomRate.Denominator = pCustomRateCaps->CustomRate.denominator;
445 pRate->OutputFrames = pCustomRateCaps->OutputFrames;
446 pRate->InputInterlaced = RT_BOOL(pCustomRateCaps->InputInterlaced);
447 pRate->InputFramesOrFields = pCustomRateCaps->InputFramesOrFields;
448}
449
450
451void vboxDXGetVideoProcessorFilterRange(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum,
452 D3D11_1DDI_VIDEO_PROCESSOR_FILTER Filter, D3D11_1DDI_VIDEO_PROCESSOR_FILTER_RANGE *pFilterRange)
453{
454 if (memcmp(&pVideoProcessorEnum->svga.desc,
455 &pDevice->VideoDevice.videoProcessorEnum.desc, sizeof(pVideoProcessorEnum->svga.desc)) != 0)
456 vboxDXQueryVideoProcessorEnumInfo(pDevice, pVideoProcessorEnum->svga.desc);
457
458 VBSVGA3dVideoProcessorEnumInfo const *pInfo = &pDevice->VideoDevice.videoProcessorEnum.info;
459 pFilterRange->Minimum = pInfo->aFilterRange[Filter].Minimum;
460 pFilterRange->Maximum = pInfo->aFilterRange[Filter].Maximum;
461 pFilterRange->Default = pInfo->aFilterRange[Filter].Default;
462 pFilterRange->Multiplier = pInfo->aFilterRange[Filter].Multiplier;
463}
464
465
466HRESULT vboxDXCreateVideoProcessor(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor,
467 PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum, UINT RateConversionCapsIndex)
468{
469 AssertReturnStmt(RateConversionCapsIndex < VBSVGA3D_MAX_VIDEO_RATE_CONVERSION_CAPS, vboxDXDeviceSetError(pDevice, E_INVALIDARG), E_INVALIDARG);
470
471 int rc = RTHandleTableAlloc(pDevice->hHTVideoProcessor, pVideoProcessor, &pVideoProcessor->uVideoProcessorId);
472 AssertRCReturnStmt(rc, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), E_OUTOFMEMORY);
473
474 pVideoProcessor->svga.desc = pVideoProcessorEnum->svga.desc;
475
476 vgpu10DefineVideoProcessor(pDevice, pVideoProcessor->uVideoProcessorId,
477 pVideoProcessor->svga.desc);
478 return S_OK;
479}
480
481
482HRESULT vboxDXCreateVideoDecoderOutputView(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEODECODEROUTPUTVIEW pVideoDecoderOutputView, PVBOXDX_RESOURCE pResource,
483 GUID const &DecodeProfile, UINT MipSlice, UINT FirstArraySlice, UINT ArraySize)
484{
485 /* The host API does not have these parameters. */
486 RT_NOREF(MipSlice, ArraySize);
487 Assert(MipSlice == 0 && ArraySize == 1);
488
489 int rc = RTHandleTableAlloc(pDevice->hHTVideoDecoderOutputView, pVideoDecoderOutputView, &pVideoDecoderOutputView->uVideoDecoderOutputViewId);
490 AssertRCReturnStmt(rc, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), E_OUTOFMEMORY);
491
492 pVideoDecoderOutputView->pResource = pResource;
493
494 VBSVGA3dVDOVDesc *pDesc = &pVideoDecoderOutputView->svga.desc;
495 memcpy(&pDesc->DecodeProfile, &DecodeProfile, sizeof(pDesc->DecodeProfile));
496 pDesc->ViewDimension = VBSVGA3D_VDOV_DIMENSION_TEXTURE2D;
497 pDesc->Texture2D.ArraySlice = FirstArraySlice;
498
499 vgpu10DefineVideoDecoderOutputView(pDevice, pVideoDecoderOutputView->uVideoDecoderOutputViewId,
500 vboxDXGetAllocation(pVideoDecoderOutputView->pResource),
501 pVideoDecoderOutputView->svga.desc);
502
503 pVideoDecoderOutputView->fDefined = true;
504 RTListAppend(&pVideoDecoderOutputView->pResource->listVDOV, &pVideoDecoderOutputView->nodeView);
505 return S_OK;
506}
507
508
509HRESULT vboxDXCreateVideoDecoder(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEODECODER pVideoDecoder,
510 D3D11_1DDI_VIDEO_DECODER_DESC const &Desc,
511 D3D11_1DDI_VIDEO_DECODER_CONFIG const &Config)
512{
513 int rc = RTHandleTableAlloc(pDevice->hHTVideoDecoder, pVideoDecoder, &pVideoDecoder->uVideoDecoderId);
514 AssertRCReturnStmt(rc, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), E_OUTOFMEMORY);
515
516 vboxDXVideoDecoderDescToSvga(&pVideoDecoder->svga.Desc, Desc);
517
518 memcpy(&pVideoDecoder->svga.Config.guidConfigBitstreamEncryption, &Config.guidConfigBitstreamEncryption, sizeof(VBSVGA3dGuid));
519 memcpy(&pVideoDecoder->svga.Config.guidConfigMBcontrolEncryption, &Config.guidConfigMBcontrolEncryption, sizeof(VBSVGA3dGuid));
520 memcpy(&pVideoDecoder->svga.Config.guidConfigResidDiffEncryption, &Config.guidConfigResidDiffEncryption, sizeof(VBSVGA3dGuid));
521 pVideoDecoder->svga.Config.ConfigBitstreamRaw = Config.ConfigBitstreamRaw;
522 pVideoDecoder->svga.Config.ConfigMBcontrolRasterOrder = Config.ConfigMBcontrolRasterOrder;
523 pVideoDecoder->svga.Config.ConfigResidDiffHost = Config.ConfigResidDiffHost;
524 pVideoDecoder->svga.Config.ConfigSpatialResid8 = Config.ConfigSpatialResid8;
525 pVideoDecoder->svga.Config.ConfigResid8Subtraction = Config.ConfigResid8Subtraction;
526 pVideoDecoder->svga.Config.ConfigSpatialHost8or9Clipping = Config.ConfigSpatialHost8or9Clipping;
527 pVideoDecoder->svga.Config.ConfigSpatialResidInterleaved = Config.ConfigSpatialResidInterleaved;
528 pVideoDecoder->svga.Config.ConfigIntraResidUnsigned = Config.ConfigIntraResidUnsigned;
529 pVideoDecoder->svga.Config.ConfigResidDiffAccelerator = Config.ConfigResidDiffAccelerator;
530 pVideoDecoder->svga.Config.ConfigHostInverseScan = Config.ConfigHostInverseScan;
531 pVideoDecoder->svga.Config.ConfigSpecificIDCT = Config.ConfigSpecificIDCT;
532 pVideoDecoder->svga.Config.Config4GroupedCoefs = Config.Config4GroupedCoefs;
533 pVideoDecoder->svga.Config.ConfigMinRenderTargetBuffCount = Config.ConfigMinRenderTargetBuffCount;
534 pVideoDecoder->svga.Config.ConfigDecoderSpecific = Config.ConfigDecoderSpecific;
535
536 vgpu10DefineVideoDecoder(pDevice, pVideoDecoder->uVideoDecoderId,
537 pVideoDecoder->svga.Desc, pVideoDecoder->svga.Config);
538 return S_OK;
539}
540
541
542HRESULT vboxDXVideoDecoderBeginFrame(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEODECODER pVideoDecoder,
543 PVBOXDXVIDEODECODEROUTPUTVIEW pVideoDecoderOutputView,
544 void const *pContentKey, UINT ContentKeySize)
545{
546 RT_NOREF(pContentKey, ContentKeySize); /** @todo vgpu10VideoDecoderBeginFrame2 */
547
548 vgpu10VideoDecoderBeginFrame(pDevice, pVideoDecoder->uVideoDecoderId,
549 pVideoDecoderOutputView->uVideoDecoderOutputViewId);
550 return S_OK;
551}
552
553
554HRESULT vboxDXVideoDecoderSubmitBuffers(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEODECODER pVideoDecoder,
555 UINT BufferCount, D3D11_1DDI_VIDEO_DECODER_BUFFER_DESC const *pBufferDesc)
556{
557 void *pvTmpBuffer = RTMemTmpAlloc(BufferCount * (sizeof(D3DKMT_HANDLE) + sizeof(VBSVGA3dVideoDecoderBufferDesc)));
558 if (!pvTmpBuffer)
559 return E_OUTOFMEMORY;
560
561 D3DKMT_HANDLE *pahAllocation = (D3DKMT_HANDLE *)pvTmpBuffer;
562 VBSVGA3dVideoDecoderBufferDesc *paBD = (VBSVGA3dVideoDecoderBufferDesc *)((uint8_t *)pvTmpBuffer + BufferCount * sizeof(D3DKMT_HANDLE));
563
564 for (UINT i = 0; i < BufferCount; ++i)
565 {
566 D3D11_1DDI_VIDEO_DECODER_BUFFER_DESC const *s = &pBufferDesc[i];
567
568 PVBOXDX_RESOURCE pBuffer = (PVBOXDX_RESOURCE)s->hResource.pDrvPrivate;
569 pahAllocation[i] = vboxDXGetAllocation(pBuffer);
570
571 VBSVGA3dVideoDecoderBufferDesc *d = &paBD[i];
572 d->sidBuffer = SVGA3D_INVALID_ID;
573 switch(s->BufferType)
574 {
575 default:
576 case D3D11_1DDI_VIDEO_DECODER_BUFFER_UNKNOWN:
577 AssertFailedReturnStmt(RTMemTmpFree(pvTmpBuffer), E_INVALIDARG);
578 case D3D11_1DDI_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS:
579 d->bufferType = VBSVGA3D_VD_BUFFER_PICTURE_PARAMETERS; break;
580 case D3D11_1DDI_VIDEO_DECODER_BUFFER_MACROBLOCK_CONTROL:
581 d->bufferType = VBSVGA3D_VD_BUFFER_MACROBLOCK_CONTROL; break;
582 case D3D11_1DDI_VIDEO_DECODER_BUFFER_RESIDUAL_DIFFERENCE:
583 d->bufferType = VBSVGA3D_VD_BUFFER_RESIDUAL_DIFFERENCE; break;
584 case D3D11_1DDI_VIDEO_DECODER_BUFFER_DEBLOCKING_CONTROL:
585 d->bufferType = VBSVGA3D_VD_BUFFER_DEBLOCKING_CONTROL; break;
586 case D3D11_1DDI_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX:
587 d->bufferType = VBSVGA3D_VD_BUFFER_INVERSE_QUANTIZATION_MATRIX; break;
588 case D3D11_1DDI_VIDEO_DECODER_BUFFER_SLICE_CONTROL:
589 d->bufferType = VBSVGA3D_VD_BUFFER_SLICE_CONTROL; break;
590 case D3D11_1DDI_VIDEO_DECODER_BUFFER_BITSTREAM:
591 d->bufferType = VBSVGA3D_VD_BUFFER_BITSTREAM; break;
592 case D3D11_1DDI_VIDEO_DECODER_BUFFER_MOTION_VECTOR:
593 d->bufferType = VBSVGA3D_VD_BUFFER_MOTION_VECTOR; break;
594 case D3D11_1DDI_VIDEO_DECODER_BUFFER_FILM_GRAIN:
595 d->bufferType = VBSVGA3D_VD_BUFFER_FILM_GRAIN; break;
596 }
597 d->dataOffset = s->DataOffset;
598 d->dataSize = s->DataSize;
599 d->firstMBaddress = s->FirstMBaddress;
600 d->numMBsInBuffer = s->NumMBsInBuffer;
601 }
602
603 vgpu10VideoDecoderSubmitBuffers(pDevice, pVideoDecoder->uVideoDecoderId, BufferCount, pahAllocation, paBD);
604 RTMemTmpFree(pvTmpBuffer);
605 return S_OK;
606}
607
608
609HRESULT vboxDXVideoDecoderEndFrame(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEODECODER pVideoDecoder)
610{
611 vgpu10VideoDecoderEndFrame(pDevice, pVideoDecoder->uVideoDecoderId);
612 return S_OK;
613}
614
615
616HRESULT vboxDXCreateVideoProcessorInputView(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSORINPUTVIEW pVideoProcessorInputView,
617 PVBOXDX_RESOURCE pResource, PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum,
618 UINT FourCC, UINT MipSlice, UINT FirstArraySlice, UINT ArraySize)
619{
620 RT_NOREF(ArraySize);
621 Assert(ArraySize == 1); /** @todo D3D11 API does use this. */
622
623 int rc = RTHandleTableAlloc(pDevice->hHTVideoProcessorInputView, pVideoProcessorInputView, &pVideoProcessorInputView->uVideoProcessorInputViewId);
624 AssertRCReturnStmt(rc, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), E_OUTOFMEMORY);
625
626 pVideoProcessorInputView->pResource = pResource;
627 pVideoProcessorInputView->svga.ContentDesc = pVideoProcessorEnum->svga.desc;
628
629 VBSVGA3dVPIVDesc *pDesc= &pVideoProcessorInputView->svga.VPIVDesc;
630 RT_ZERO(*pDesc);
631 pDesc->FourCC = FourCC;
632 pDesc->ViewDimension = VBSVGA3D_VPIV_DIMENSION_TEXTURE2D;
633 pDesc->Texture2D.MipSlice = MipSlice;
634 pDesc->Texture2D.ArraySlice = FirstArraySlice;
635
636 vgpu10DefineVideoProcessorInputView(pDevice, pVideoProcessorInputView->uVideoProcessorInputViewId,
637 vboxDXGetAllocation(pVideoProcessorInputView->pResource),
638 pVideoProcessorInputView->svga.ContentDesc, *pDesc);
639
640 pVideoProcessorInputView->fDefined = true;
641 RTListAppend(&pVideoProcessorInputView->pResource->listVPIV, &pVideoProcessorInputView->nodeView);
642 return S_OK;
643}
644
645
646HRESULT vboxDXCreateVideoProcessorOutputView(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOROUTPUTVIEW pVideoProcessorOutputView,
647 PVBOXDX_RESOURCE pResource, PVBOXDXVIDEOPROCESSORENUM pVideoProcessorEnum,
648 UINT MipSlice, UINT FirstArraySlice, UINT ArraySize)
649{
650 int rc = RTHandleTableAlloc(pDevice->hHTVideoProcessorOutputView, pVideoProcessorOutputView, &pVideoProcessorOutputView->uVideoProcessorOutputViewId);
651 AssertRCReturnStmt(rc, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), E_OUTOFMEMORY);
652
653 pVideoProcessorOutputView->pResource = pResource;
654 pVideoProcessorOutputView->svga.ContentDesc = pVideoProcessorEnum->svga.desc;
655
656 VBSVGA3dVPOVDesc *pDesc= &pVideoProcessorOutputView->svga.VPOVDesc;
657 RT_ZERO(*pDesc);
658 if (ArraySize <= 1) /** @todo Or from pResource? */
659 {
660 pDesc->ViewDimension = VBSVGA3D_VPOV_DIMENSION_TEXTURE2D;
661 pDesc->Texture2D.MipSlice = MipSlice;
662 }
663 else
664 {
665 pDesc->ViewDimension = VBSVGA3D_VPOV_DIMENSION_TEXTURE2DARRAY;
666 pDesc->Texture2DArray.MipSlice = MipSlice;
667 pDesc->Texture2DArray.FirstArraySlice = FirstArraySlice;
668 pDesc->Texture2DArray.ArraySize = ArraySize;
669 }
670
671 vgpu10DefineVideoProcessorOutputView(pDevice, pVideoProcessorOutputView->uVideoProcessorOutputViewId,
672 vboxDXGetAllocation(pVideoProcessorOutputView->pResource),
673 pVideoProcessorOutputView->svga.ContentDesc, *pDesc);
674
675 pVideoProcessorOutputView->fDefined = true;
676 RTListAppend(&pVideoProcessorOutputView->pResource->listVPOV, &pVideoProcessorOutputView->nodeView);
677 return S_OK;
678}
679
680
681HRESULT vboxDXVideoProcessorBlt(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, PVBOXDXVIDEOPROCESSOROUTPUTVIEW pVideoProcessorOutputView,
682 UINT OutputFrame, UINT StreamCount, D3D11_1DDI_VIDEO_PROCESSOR_STREAM const *paStream)
683{
684 uint32_t cbVideoProcessorStreams = StreamCount * sizeof(VBSVGA3dVideoProcessorStream);
685 for (UINT i = 0; i < StreamCount; ++i)
686 {
687 D3D11_1DDI_VIDEO_PROCESSOR_STREAM const *s = &paStream[i];
688 uint32_t cbIds = (s->PastFrames + 1 + s->FutureFrames) * sizeof(VBSVGA3dVideoProcessorInputViewId);
689 if (pVideoProcessor->aStreams[i].FrameFormat == D3D11_1DDI_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE)
690 cbIds *= 2;
691 cbVideoProcessorStreams += cbIds;
692 }
693
694 void *pvTmpBuffer = RTMemTmpAlloc(cbVideoProcessorStreams);
695 if (!pvTmpBuffer)
696 return E_OUTOFMEMORY;
697
698 VBSVGA3dVideoProcessorStream *paVideoProcessorStreams = (VBSVGA3dVideoProcessorStream *)pvTmpBuffer;
699 for (UINT i = 0; i < StreamCount; ++i)
700 {
701 D3D11_1DDI_VIDEO_PROCESSOR_STREAM const *s = &paStream[i];
702 VBSVGA3dVideoProcessorStream *d = &paVideoProcessorStreams[i];
703
704 d->Enable = s->Enable;
705 d->StereoFormatSeparate = pVideoProcessor->aStreams[i].StereoFormat.Format == D3D11_1DDI_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE;
706 d->pad = 0;
707 d->OutputIndex = s->OutputIndex;
708 d->InputFrameOrField = s->InputFrameOrField;
709 d->PastFrames = s->PastFrames;
710 d->FutureFrames = s->FutureFrames;
711
712 PVBOXDXVIDEOPROCESSORINPUTVIEW pVideoProcessorInputView;
713 VBSVGA3dVideoProcessorInputViewId *pVPIVId = (VBSVGA3dVideoProcessorInputViewId *)&d[1];
714
715 for (UINT j = 0; j < s->PastFrames; ++j)
716 {
717 pVideoProcessorInputView = (PVBOXDXVIDEOPROCESSORINPUTVIEW)s->pPastSurfaces[j].pDrvPrivate;
718 *pVPIVId++ = pVideoProcessorInputView->uVideoProcessorInputViewId;
719 }
720
721 pVideoProcessorInputView = (PVBOXDXVIDEOPROCESSORINPUTVIEW)s->hInputSurface.pDrvPrivate;
722 *pVPIVId++ = pVideoProcessorInputView->uVideoProcessorInputViewId;
723
724 for (UINT j = 0; j < s->FutureFrames; ++j)
725 {
726 pVideoProcessorInputView = (PVBOXDXVIDEOPROCESSORINPUTVIEW)s->pFutureSurfaces[j].pDrvPrivate;
727 *pVPIVId++ = pVideoProcessorInputView->uVideoProcessorInputViewId;
728 }
729
730 if (d->StereoFormatSeparate)
731 {
732 for (UINT j = 0; j < s->PastFrames; ++j)
733 {
734 pVideoProcessorInputView = (PVBOXDXVIDEOPROCESSORINPUTVIEW)s->pPastSurfacesRight[j].pDrvPrivate;
735 *pVPIVId++ = pVideoProcessorInputView->uVideoProcessorInputViewId;
736 }
737
738 pVideoProcessorInputView = (PVBOXDXVIDEOPROCESSORINPUTVIEW)s->hInputSurfaceRight.pDrvPrivate;
739 *pVPIVId++ = pVideoProcessorInputView->uVideoProcessorInputViewId;
740
741 for (UINT j = 0; j < s->FutureFrames; ++j)
742 {
743 pVideoProcessorInputView = (PVBOXDXVIDEOPROCESSORINPUTVIEW)s->pFutureSurfacesRight[j].pDrvPrivate;
744 *pVPIVId++ = pVideoProcessorInputView->uVideoProcessorInputViewId;
745 }
746 }
747 }
748
749 vgpu10VideoProcessorBlt(pDevice, pVideoProcessor->uVideoProcessorId, pVideoProcessorOutputView->uVideoProcessorOutputViewId,
750 OutputFrame, StreamCount, cbVideoProcessorStreams, paVideoProcessorStreams);
751 RTMemTmpFree(pvTmpBuffer);
752 return S_OK;
753}
754
755
756void vboxDXDestroyVideoDecoder(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEODECODER pVideoDecoder)
757{
758 vgpu10DestroyVideoDecoder(pDevice, pVideoDecoder->uVideoDecoderId);
759 RTHandleTableFree(pDevice->hHTVideoDecoder, pVideoDecoder->uVideoDecoderId);
760}
761
762
763void vboxDXDestroyVideoDecoderOutputView(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEODECODEROUTPUTVIEW pVideoDecoderOutputView)
764{
765 RTListNodeRemove(&pVideoDecoderOutputView->nodeView);
766
767 vgpu10DestroyVideoDecoderOutputView(pDevice, pVideoDecoderOutputView->uVideoDecoderOutputViewId);
768 RTHandleTableFree(pDevice->hHTVideoDecoderOutputView, pVideoDecoderOutputView->uVideoDecoderOutputViewId);
769}
770
771
772void vboxDXDestroyVideoProcessor(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor)
773{
774 vgpu10DestroyVideoProcessor(pDevice, pVideoProcessor->uVideoProcessorId);
775 RTHandleTableFree(pDevice->hHTVideoProcessor, pVideoProcessor->uVideoProcessorId);
776}
777
778
779void vboxDXDestroyVideoProcessorInputView(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSORINPUTVIEW pVideoProcessorInputView)
780{
781 RTListNodeRemove(&pVideoProcessorInputView->nodeView);
782
783 vgpu10DestroyVideoProcessorInputView(pDevice, pVideoProcessorInputView->uVideoProcessorInputViewId);
784 RTHandleTableFree(pDevice->hHTVideoProcessorInputView, pVideoProcessorInputView->uVideoProcessorInputViewId);
785}
786
787
788void vboxDXDestroyVideoProcessorOutputView(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOROUTPUTVIEW pVideoProcessorOutputView)
789{
790 RTListNodeRemove(&pVideoProcessorOutputView->nodeView);
791
792 vgpu10DestroyVideoProcessorOutputView(pDevice, pVideoProcessorOutputView->uVideoProcessorOutputViewId);
793 RTHandleTableFree(pDevice->hHTVideoProcessorOutputView, pVideoProcessorOutputView->uVideoProcessorOutputViewId);
794}
795
796
797void vboxDXVideoProcessorSetOutputTargetRect(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, BOOL Enable, RECT const *pOutputRect)
798{
799 pVideoProcessor->OutputRect.Enable = Enable;
800 pVideoProcessor->OutputRect.Rect = *pOutputRect;
801
802 vgpu10VideoProcessorSetOutputTargetRect(pDevice, pVideoProcessor->uVideoProcessorId, Enable, *pOutputRect);
803}
804
805
806void vboxDXVideoProcessorSetOutputBackgroundColor(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, BOOL YCbCr, D3D11_1DDI_VIDEO_COLOR const *pColor)
807{
808 pVideoProcessor->OutputBackgroundColor.YCbCr = YCbCr;
809 pVideoProcessor->OutputBackgroundColor.Color = *pColor;
810
811 vgpu10VideoProcessorSetOutputBackgroundColor(pDevice, pVideoProcessor->uVideoProcessorId, YCbCr, *pColor);
812}
813
814
815void vboxDXVideoProcessorSetOutputColorSpace(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, D3D11_1DDI_VIDEO_PROCESSOR_COLOR_SPACE const *pColorSpace)
816{
817 pVideoProcessor->Colorspace = *pColorSpace;
818
819 VBSVGA3dVideoProcessorColorSpace svgaColorSpace;
820 svgaColorSpace.Usage = pColorSpace->Usage;
821 svgaColorSpace.RGB_Range = pColorSpace->RGB_Range;
822 svgaColorSpace.YCbCr_Matrix = pColorSpace->YCbCr_Matrix;
823 svgaColorSpace.YCbCr_xvYCC = pColorSpace->YCbCr_xvYCC;
824 svgaColorSpace.Nominal_Range = pColorSpace->Nominal_Range;
825 svgaColorSpace.Reserved = 0;
826
827 vgpu10VideoProcessorSetOutputColorSpace(pDevice, pVideoProcessor->uVideoProcessorId, svgaColorSpace);
828}
829
830
831void vboxDXVideoProcessorSetOutputAlphaFillMode(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, D3D11_1DDI_VIDEO_PROCESSOR_ALPHA_FILL_MODE FillMode, UINT StreamIndex)
832{
833 pVideoProcessor->AlphaFillMode.FillMode = FillMode;
834 pVideoProcessor->AlphaFillMode.StreamIndex = StreamIndex;
835
836 VBSVGA3dVideoProcessorAlphaFillMode svgaFillMode = (VBSVGA3dVideoProcessorAlphaFillMode)FillMode;
837 vgpu10VideoProcessorSetOutputAlphaFillMode(pDevice, pVideoProcessor->uVideoProcessorId, svgaFillMode, StreamIndex);
838}
839
840
841void vboxDXVideoProcessorSetOutputConstriction(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, BOOL Enabled, SIZE ConstrictonSize)
842{
843 pVideoProcessor->OutputConstriction.Enabled = Enabled;
844 pVideoProcessor->OutputConstriction.ConstrictonSize = ConstrictonSize;
845
846 vgpu10VideoProcessorSetOutputConstriction(pDevice, pVideoProcessor->uVideoProcessorId, Enabled, ConstrictonSize);
847}
848
849
850void vboxDXVideoProcessorSetOutputStereoMode(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, BOOL Enable)
851{
852 pVideoProcessor->StereoMode.Enable = Enable;
853
854 vgpu10VideoProcessorSetOutputStereoMode(pDevice, pVideoProcessor->uVideoProcessorId, Enable);
855}
856
857
858void vboxDXVideoProcessorSetStreamFrameFormat(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex, D3D11_1DDI_VIDEO_FRAME_FORMAT Format)
859{
860 pVideoProcessor->aStreams[StreamIndex].FrameFormat = Format;
861
862 VBSVGA3dVideoFrameFormat svgaFormat = (VBSVGA3dVideoFrameFormat)Format;
863 vgpu10VideoProcessorSetStreamFrameFormat(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, svgaFormat);
864}
865
866
867void vboxDXVideoProcessorSetStreamColorSpace(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex, D3D11_1DDI_VIDEO_PROCESSOR_COLOR_SPACE const *pColorSpace)
868{
869 pVideoProcessor->aStreams[StreamIndex].ColorSpace = *pColorSpace;
870
871 VBSVGA3dVideoProcessorColorSpace svgaColorSpace;
872 svgaColorSpace.Usage = pColorSpace->Usage;
873 svgaColorSpace.RGB_Range = pColorSpace->RGB_Range;
874 svgaColorSpace.YCbCr_Matrix = pColorSpace->YCbCr_Matrix;
875 svgaColorSpace.YCbCr_xvYCC = pColorSpace->YCbCr_xvYCC;
876 svgaColorSpace.Nominal_Range = pColorSpace->Nominal_Range;
877 svgaColorSpace.Reserved = 0;
878
879 vgpu10VideoProcessorSetStreamColorSpace(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, svgaColorSpace);
880}
881
882
883void vboxDXVideoProcessorSetStreamOutputRate(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex,
884 D3D11_1DDI_VIDEO_PROCESSOR_OUTPUT_RATE OutputRate, BOOL RepeatFrame, DXGI_RATIONAL const *pCustomRate)
885{
886 pVideoProcessor->aStreams[StreamIndex].OutputRate.OutputRate = OutputRate;
887 pVideoProcessor->aStreams[StreamIndex].OutputRate.RepeatFrame = RepeatFrame;
888 pVideoProcessor->aStreams[StreamIndex].OutputRate.CustomRate = *pCustomRate;
889
890 VBSVGA3dVideoProcessorOutputRate svgaOutputRate = (VBSVGA3dVideoProcessorOutputRate)OutputRate;
891 SVGA3dFraction64 svgaCustomRate;
892 svgaCustomRate.numerator = pCustomRate->Numerator;
893 svgaCustomRate.denominator = pCustomRate->Denominator;
894
895 vgpu10VideoProcessorSetStreamOutputRate(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, svgaOutputRate, RepeatFrame, svgaCustomRate);
896}
897
898
899void vboxDXVideoProcessorSetStreamSourceRect(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex,
900 BOOL Enable, RECT const *pSourceRect)
901{
902 pVideoProcessor->aStreams[StreamIndex].SourceRect.Enable = Enable;
903 pVideoProcessor->aStreams[StreamIndex].SourceRect.SourceRect = *pSourceRect;
904
905 vgpu10VideoProcessorSetStreamSourceRect(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable, pSourceRect);
906}
907
908
909void vboxDXVideoProcessorSetStreamDestRect(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex,
910 BOOL Enable, RECT const *pDestRect)
911{
912 pVideoProcessor->aStreams[StreamIndex].DestRect.Enable = Enable;
913 pVideoProcessor->aStreams[StreamIndex].DestRect.DestRect = *pDestRect;
914
915 vgpu10VideoProcessorSetStreamDestRect(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable, pDestRect);
916}
917
918
919void vboxDXVideoProcessorSetStreamAlpha(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex,
920 BOOL Enable, FLOAT Alpha)
921{
922 vgpu10VideoProcessorSetStreamAlpha(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable, Alpha);
923}
924
925
926void vboxDXVideoProcessorSetStreamPalette(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex,
927 UINT Count, UINT const *pEntries)
928{
929 vgpu10VideoProcessorSetStreamPalette(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex,
930 RT_MIN(Count, VBSVGA3D_MAX_VIDEO_PALETTE_ENTRIES), pEntries);
931}
932
933
934void vboxDXVideoProcessorSetStreamPixelAspectRatio(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex,
935 BOOL Enable, DXGI_RATIONAL const *pSourceRatio, DXGI_RATIONAL const *pDestRatio)
936{
937 SVGA3dFraction64 svgaSourceRatio;
938 svgaSourceRatio.numerator = pSourceRatio->Numerator;
939 svgaSourceRatio.denominator = pSourceRatio->Denominator;
940
941 SVGA3dFraction64 svgaDestRatio;
942 svgaDestRatio.numerator = pDestRatio->Numerator;
943 svgaDestRatio.denominator = pDestRatio->Denominator;
944
945 vgpu10VideoProcessorSetStreamPixelAspectRatio(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable, svgaSourceRatio, svgaDestRatio);
946}
947
948
949void vboxDXVideoProcessorSetStreamLumaKey(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex,
950 BOOL Enable, FLOAT Lower, FLOAT Upper)
951{
952 pVideoProcessor->aStreams[StreamIndex].LumaKey.Enable = Enable;
953 pVideoProcessor->aStreams[StreamIndex].LumaKey.Lower = Lower;
954 pVideoProcessor->aStreams[StreamIndex].LumaKey.Upper = Upper;
955
956 vgpu10VideoProcessorSetStreamLumaKey(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable, Lower, Upper);
957}
958
959
960void vboxDXVideoProcessorSetStreamStereoFormat(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex, BOOL Enable,
961 D3D11_1DDI_VIDEO_PROCESSOR_STEREO_FORMAT StereoFormat, BOOL LeftViewFrame0, BOOL BaseViewFrame0,
962 D3D11_1DDI_VIDEO_PROCESSOR_STEREO_FLIP_MODE FlipMode, int MonoOffset)
963{
964 pVideoProcessor->aStreams[StreamIndex].StereoFormat.Enable = Enable;
965 pVideoProcessor->aStreams[StreamIndex].StereoFormat.Format = StereoFormat;
966
967 VBSVGA3dVideoProcessorStereoFormat svgaStereoFormat = (VBSVGA3dVideoProcessorStereoFormat)StereoFormat;
968 VBSVGA3dVideoProcessorStereoFlipMode svgaFlipMode = (VBSVGA3dVideoProcessorStereoFlipMode)FlipMode;
969
970 vgpu10VideoProcessorSetStreamStereoFormat(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable,
971 svgaStereoFormat, LeftViewFrame0, BaseViewFrame0, svgaFlipMode, MonoOffset);
972}
973
974
975void vboxDXVideoProcessorSetStreamAutoProcessingMode(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex, BOOL Enable)
976{
977 pVideoProcessor->aStreams[StreamIndex].AutoProcessingMode.Enable = Enable;
978
979 vgpu10VideoProcessorSetStreamAutoProcessingMode(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable);
980}
981
982
983void vboxDXVideoProcessorSetStreamFilter(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex, BOOL Enable,
984 D3D11_1DDI_VIDEO_PROCESSOR_FILTER Filter, int Level)
985{
986 pVideoProcessor->aStreams[StreamIndex].aFilters[Filter].Enable = Enable;
987 pVideoProcessor->aStreams[StreamIndex].aFilters[Filter].Level = Level;
988
989 VBSVGA3dVideoProcessorFilter svgaFilter = (VBSVGA3dVideoProcessorFilter)Filter;
990
991 vgpu10VideoProcessorSetStreamFilter(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable, svgaFilter, Level);
992}
993
994
995void vboxDXVideoProcessorSetStreamRotation(PVBOXDX_DEVICE pDevice, PVBOXDXVIDEOPROCESSOR pVideoProcessor, UINT StreamIndex, BOOL Enable,
996 D3D11_1DDI_VIDEO_PROCESSOR_ROTATION Rotation)
997{
998 pVideoProcessor->aStreams[StreamIndex].Rotation.Enable = Enable;
999 pVideoProcessor->aStreams[StreamIndex].Rotation.Rotation = Rotation;
1000
1001 VBSVGA3dVideoProcessorRotation svgaRotation = (VBSVGA3dVideoProcessorRotation)Rotation;
1002
1003 vgpu10VideoProcessorSetStreamRotation(pDevice, pVideoProcessor->uVideoProcessorId, StreamIndex, Enable, svgaRotation);
1004}
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use