[82330] | 1 | /* $Id: GaDxva.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * VirtualBox WDDM DXVA for the Gallium based driver.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2019-2023 Oracle and/or its affiliates.
|
---|
[82330] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
| 11 | *
|
---|
| 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
| 25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[82330] | 26 | */
|
---|
| 27 |
|
---|
| 28 | #include "../VBoxDispD3DCmn.h"
|
---|
| 29 |
|
---|
| 30 | #define D3D_RELEASE(ptr) do { \
|
---|
| 31 | if (ptr) \
|
---|
| 32 | { \
|
---|
| 33 | (ptr)->Release(); \
|
---|
| 34 | (ptr) = 0; \
|
---|
| 35 | } \
|
---|
| 36 | } while (0)
|
---|
| 37 |
|
---|
| 38 | struct Vertex
|
---|
| 39 | {
|
---|
[82415] | 40 | float x, y; /* The vertex position in pixels. */
|
---|
| 41 | float u, v; /* Normalized texture coordinates. */
|
---|
[82330] | 42 | };
|
---|
| 43 |
|
---|
[82415] | 44 | /* Saved context. */
|
---|
| 45 | typedef struct VBOXDXVAD3D9SAVEDSTATE
|
---|
| 46 | {
|
---|
| 47 | D3DVIEWPORT9 Viewport;
|
---|
| 48 | DWORD rsCull;
|
---|
| 49 | DWORD rsZEnable;
|
---|
| 50 | IDirect3DSurface9 *pRT;
|
---|
| 51 | IDirect3DVertexShader9 *pVS;
|
---|
| 52 | IDirect3DPixelShader9 *pPS;
|
---|
| 53 | IDirect3DBaseTexture9 *pTexture;
|
---|
| 54 | float aVSConstantData[4];
|
---|
| 55 | float aPSConstantData[4];
|
---|
| 56 | DWORD ssMagFilter;
|
---|
| 57 | DWORD ssMinFilter;
|
---|
| 58 | DWORD ssMipFilter;
|
---|
| 59 | } VBOXDXVAD3D9SAVEDSTATE;
|
---|
| 60 |
|
---|
[82330] | 61 | /*
|
---|
| 62 | * Draw a quad in order to convert the input resource to the output render target.
|
---|
| 63 | * The pixel shader will provide required conversion.
|
---|
| 64 | */
|
---|
| 65 | typedef struct VBOXWDDMVIDEOPROCESSDEVICE
|
---|
| 66 | {
|
---|
| 67 | /* Creation parameters. */
|
---|
| 68 | PVBOXWDDMDISP_DEVICE pDevice;
|
---|
| 69 | GUID VideoProcGuid;
|
---|
| 70 | DXVADDI_VIDEODESC VideoDesc;
|
---|
| 71 | D3DDDIFORMAT RenderTargetFormat;
|
---|
| 72 | UINT MaxSubStreams;
|
---|
| 73 |
|
---|
| 74 | /* The current render target, i.e. the Blt destination. */
|
---|
| 75 | PVBOXWDDMDISP_RESOURCE pRenderTarget;
|
---|
[82415] | 76 | UINT RTSubResourceIndex;
|
---|
| 77 | IDirect3DTexture9 *pRTTexture;
|
---|
| 78 | IDirect3DSurface9 *pRTSurface;
|
---|
[82330] | 79 |
|
---|
| 80 | /* Private objects for video processing. */
|
---|
[82415] | 81 | IDirect3DTexture9 *pStagingTexture; /* Intermediate texture. */
|
---|
[82330] | 82 | IDirect3DVertexBuffer9 *pVB; /* Vertex buffer which describes the quad we render. */
|
---|
| 83 | IDirect3DVertexDeclaration9 *pVertexDecl; /* Vertex declaration for the quad vertices. */
|
---|
| 84 | IDirect3DVertexShader9 *pVS; /* Vertex shader. */
|
---|
| 85 | IDirect3DPixelShader9 *pPS; /* Pixel shader. */
|
---|
[82415] | 86 |
|
---|
| 87 | /* Saved D3D device state, which the blitter changes. */
|
---|
| 88 | VBOXDXVAD3D9SAVEDSTATE SavedState;
|
---|
[82330] | 89 | } VBOXWDDMVIDEOPROCESSDEVICE;
|
---|
| 90 |
|
---|
[82415] | 91 | static GUID const gaDeviceGuids[] =
|
---|
[82330] | 92 | {
|
---|
| 93 | DXVADDI_VideoProcProgressiveDevice,
|
---|
| 94 | DXVADDI_VideoProcBobDevice
|
---|
| 95 | };
|
---|
| 96 |
|
---|
[82415] | 97 | static D3DDDIFORMAT const gaInputFormats[] =
|
---|
[82330] | 98 | {
|
---|
| 99 | D3DDDIFMT_YUY2
|
---|
| 100 | };
|
---|
| 101 |
|
---|
[82415] | 102 | static D3DDDIFORMAT const gaOutputFormats[] =
|
---|
[82330] | 103 | {
|
---|
| 104 | D3DDDIFMT_A8R8G8B8,
|
---|
| 105 | D3DDDIFMT_X8R8G8B8
|
---|
| 106 | };
|
---|
| 107 |
|
---|
| 108 | static int vboxDxvaFindDeviceGuid(GUID const *pGuid)
|
---|
| 109 | {
|
---|
| 110 | for (int i = 0; i < RT_ELEMENTS(gaDeviceGuids); ++i)
|
---|
| 111 | {
|
---|
| 112 | if (memcmp(pGuid, &gaDeviceGuids[i], sizeof(GUID)) == 0)
|
---|
| 113 | return i;
|
---|
| 114 | }
|
---|
| 115 | return -1;
|
---|
| 116 | }
|
---|
| 117 |
|
---|
| 118 | static int vboxDxvaFindInputFormat(D3DDDIFORMAT enmFormat)
|
---|
| 119 | {
|
---|
| 120 | for (int i = 0; i < RT_ELEMENTS(gaInputFormats); ++i)
|
---|
| 121 | {
|
---|
| 122 | if (enmFormat == gaInputFormats[0])
|
---|
| 123 | return i;
|
---|
| 124 | }
|
---|
| 125 | return -1;
|
---|
| 126 | }
|
---|
| 127 |
|
---|
[82415] | 128 | static HRESULT vboxDxvaCopyToVertexBuffer(IDirect3DVertexBuffer9 *pVB, const void *pvSrc, int cbSrc)
|
---|
| 129 | {
|
---|
| 130 | void *pvDst = 0;
|
---|
| 131 | HRESULT hr = pVB->Lock(0, 0, &pvDst, 0);
|
---|
| 132 | if (SUCCEEDED(hr))
|
---|
| 133 | {
|
---|
| 134 | memcpy(pvDst, pvSrc, cbSrc);
|
---|
| 135 | hr = pVB->Unlock();
|
---|
| 136 | }
|
---|
| 137 | return hr;
|
---|
| 138 | }
|
---|
[82330] | 139 |
|
---|
[82415] | 140 | static HRESULT vboxDxvaDeviceStateSave(IDirect3DDevice9 *pDevice9, VBOXDXVAD3D9SAVEDSTATE *pState)
|
---|
[82330] | 141 | {
|
---|
| 142 | HRESULT hr;
|
---|
| 143 |
|
---|
[82415] | 144 | hr = pDevice9->GetViewport(&pState->Viewport);
|
---|
| 145 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 146 |
|
---|
| 147 | hr = pDevice9->GetRenderState(D3DRS_CULLMODE, &pState->rsCull);
|
---|
| 148 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 149 |
|
---|
| 150 | hr = pDevice9->GetRenderState(D3DRS_ZENABLE, &pState->rsZEnable);
|
---|
| 151 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 152 |
|
---|
| 153 | hr = pDevice9->GetRenderTarget(0, &pState->pRT);
|
---|
| 154 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 155 |
|
---|
| 156 | hr = pDevice9->GetVertexShader(&pState->pVS);
|
---|
| 157 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 158 |
|
---|
| 159 | hr = pDevice9->GetPixelShader(&pState->pPS);
|
---|
| 160 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 161 |
|
---|
| 162 | hr = pDevice9->GetTexture(0, &pState->pTexture);
|
---|
| 163 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 164 |
|
---|
| 165 | hr = pDevice9->GetVertexShaderConstantF(0, pState->aVSConstantData, 1);
|
---|
| 166 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 167 |
|
---|
| 168 | hr = pDevice9->GetPixelShaderConstantF(0, pState->aPSConstantData, 1);
|
---|
| 169 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 170 |
|
---|
| 171 | hr = pDevice9->GetSamplerState(0, D3DSAMP_MAGFILTER, &pState->ssMagFilter);
|
---|
| 172 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 173 |
|
---|
| 174 | hr = pDevice9->GetSamplerState(0, D3DSAMP_MINFILTER, &pState->ssMinFilter);
|
---|
| 175 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 176 |
|
---|
| 177 | hr = pDevice9->GetSamplerState(0, D3DSAMP_MIPFILTER, &pState->ssMipFilter);
|
---|
| 178 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 179 |
|
---|
| 180 | return hr;
|
---|
| 181 | }
|
---|
| 182 |
|
---|
| 183 | static void vboxDxvaDeviceStateRestore(IDirect3DDevice9 *pDevice9, VBOXDXVAD3D9SAVEDSTATE const *pState)
|
---|
| 184 | {
|
---|
| 185 | HRESULT hr;
|
---|
| 186 |
|
---|
| 187 | hr = pDevice9->SetViewport(&pState->Viewport);
|
---|
| 188 | Assert(hr == D3D_OK);
|
---|
| 189 |
|
---|
| 190 | hr = pDevice9->SetRenderState(D3DRS_CULLMODE, pState->rsCull);
|
---|
| 191 | Assert(hr == D3D_OK);
|
---|
| 192 |
|
---|
| 193 | hr = pDevice9->SetRenderState(D3DRS_ZENABLE, pState->rsZEnable);
|
---|
| 194 | Assert(hr == D3D_OK);
|
---|
| 195 |
|
---|
| 196 | hr = pDevice9->SetRenderTarget(0, pState->pRT);
|
---|
| 197 | Assert(hr == D3D_OK);
|
---|
| 198 |
|
---|
| 199 | hr = pDevice9->SetVertexShader(pState->pVS);
|
---|
| 200 | Assert(hr == D3D_OK);
|
---|
| 201 |
|
---|
| 202 | hr = pDevice9->SetPixelShader(pState->pPS);
|
---|
| 203 | Assert(hr == D3D_OK);
|
---|
| 204 |
|
---|
| 205 | hr = pDevice9->SetTexture(0, pState->pTexture);
|
---|
| 206 | Assert(hr == D3D_OK);
|
---|
| 207 |
|
---|
| 208 | hr = pDevice9->SetVertexShaderConstantF(0, pState->aVSConstantData, 1);
|
---|
| 209 | Assert(hr == D3D_OK);
|
---|
| 210 |
|
---|
| 211 | hr = pDevice9->SetPixelShaderConstantF(0, pState->aPSConstantData, 1);
|
---|
| 212 | Assert(hr == D3D_OK);
|
---|
| 213 |
|
---|
| 214 | hr = pDevice9->SetSamplerState(0, D3DSAMP_MAGFILTER, pState->ssMagFilter);
|
---|
| 215 | Assert(hr == D3D_OK);
|
---|
| 216 |
|
---|
| 217 | hr = pDevice9->SetSamplerState(0, D3DSAMP_MINFILTER, pState->ssMinFilter);
|
---|
| 218 | Assert(hr == D3D_OK);
|
---|
| 219 |
|
---|
| 220 | hr = pDevice9->SetSamplerState(0, D3DSAMP_MIPFILTER, pState->ssMipFilter);
|
---|
| 221 | Assert(hr == D3D_OK);
|
---|
| 222 | }
|
---|
| 223 |
|
---|
| 224 | static HRESULT vboxDxvaUploadSample(VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice,
|
---|
| 225 | IDirect3DTexture9 *pSrcTexture,
|
---|
| 226 | UINT SrcSubResourceIndex)
|
---|
| 227 | {
|
---|
| 228 | HRESULT hr;
|
---|
| 229 |
|
---|
| 230 | /*
|
---|
| 231 | * Upload the source data to the staging texture.
|
---|
| 232 | */
|
---|
| 233 | D3DLOCKED_RECT StagingLockedRect;
|
---|
| 234 | hr = pVideoProcessDevice->pStagingTexture->LockRect(0, /* texture level */
|
---|
| 235 | &StagingLockedRect,
|
---|
| 236 | NULL, /* entire texture */
|
---|
| 237 | D3DLOCK_DISCARD);
|
---|
| 238 | Assert(hr == D3D_OK);
|
---|
| 239 | if (hr == D3D_OK)
|
---|
| 240 | {
|
---|
| 241 | D3DLOCKED_RECT SampleLockedRect;
|
---|
| 242 | hr = pSrcTexture->LockRect(SrcSubResourceIndex, /* texture level */
|
---|
| 243 | &SampleLockedRect,
|
---|
| 244 | NULL, /* entire texture */
|
---|
| 245 | D3DLOCK_READONLY);
|
---|
| 246 | Assert(hr == D3D_OK);
|
---|
| 247 | if (hr == D3D_OK)
|
---|
| 248 | {
|
---|
| 249 | uint8_t *pDst = (uint8_t *)StagingLockedRect.pBits;
|
---|
| 250 | const uint8_t *pSrc = (uint8_t *)SampleLockedRect.pBits;
|
---|
| 251 | for (uint32_t j = 0; j < pVideoProcessDevice->VideoDesc.SampleHeight; ++j)
|
---|
| 252 | {
|
---|
| 253 | memcpy(pDst, pSrc, RT_MIN(SampleLockedRect.Pitch, StagingLockedRect.Pitch));
|
---|
| 254 |
|
---|
| 255 | pDst += StagingLockedRect.Pitch;
|
---|
| 256 | pSrc += SampleLockedRect.Pitch;
|
---|
| 257 | }
|
---|
| 258 |
|
---|
| 259 | pSrcTexture->UnlockRect(SrcSubResourceIndex /* texture level */);
|
---|
| 260 | }
|
---|
| 261 | pVideoProcessDevice->pStagingTexture->UnlockRect(0 /* texture level */);
|
---|
| 262 | }
|
---|
| 263 |
|
---|
| 264 | return hr;
|
---|
| 265 | }
|
---|
| 266 |
|
---|
| 267 | /*
|
---|
| 268 | * The shader code has been obtained from the hex listing file (hexdump.txt) produced by fxc HLSL compiler:
|
---|
| 269 | * fxc.exe /Op /Tfx_2_0 /Fxhexdump.txt shader.fx
|
---|
| 270 | *
|
---|
| 271 | uniform extern float4 gTextureInfo; // .xy = (TargetWidth, TargetHeight), .zw = (SourceWidth, SourceHeight) in pixels
|
---|
| 272 | uniform extern texture gTexSource;
|
---|
| 273 | sampler sSource = sampler_state
|
---|
| 274 | {
|
---|
| 275 | Texture = <gTexSource>;
|
---|
| 276 | };
|
---|
| 277 |
|
---|
| 278 | struct VS_INPUT
|
---|
| 279 | {
|
---|
| 280 | float2 Position : POSITION; // In pixels
|
---|
| 281 | float2 TexCoord : TEXCOORD0; // Normalized
|
---|
| 282 | };
|
---|
| 283 |
|
---|
| 284 | struct VS_OUTPUT
|
---|
| 285 | {
|
---|
| 286 | float4 Position : POSITION; // Normalized
|
---|
| 287 | float2 TexCoord : TEXCOORD0; // Normalized
|
---|
| 288 | };
|
---|
| 289 |
|
---|
| 290 | VS_OUTPUT VS(VS_INPUT In)
|
---|
| 291 | {
|
---|
| 292 | VS_OUTPUT Output;
|
---|
| 293 |
|
---|
| 294 | // Target position is in pixels, i.e left,top is 0,0; right,bottom is width - 1,height - 1.
|
---|
| 295 | // Convert to the normalized coords in the -1;1 range (x right, y up).
|
---|
| 296 | float4 Position;
|
---|
| 297 | Position.x = 2.0f * In.Position.x / (gTextureInfo.x - 1.0f) - 1.0f;
|
---|
| 298 | Position.y = -2.0f * In.Position.y / (gTextureInfo.y - 1.0f) + 1.0f;
|
---|
| 299 | Position.z = 0.0f; // Not used.
|
---|
| 300 | Position.w = 1.0f; // It is a point.
|
---|
| 301 |
|
---|
| 302 | Output.Position = Position;
|
---|
| 303 | Output.TexCoord = In.TexCoord;
|
---|
| 304 |
|
---|
| 305 | return Output;
|
---|
| 306 | }
|
---|
| 307 |
|
---|
| 308 | struct PS_OUTPUT
|
---|
| 309 | {
|
---|
| 310 | float4 Color : COLOR0;
|
---|
| 311 | };
|
---|
| 312 |
|
---|
| 313 | static const float3x3 yuvCoeffs =
|
---|
| 314 | {
|
---|
| 315 | 1.164383f, 1.164383f, 1.164383f,
|
---|
| 316 | 0.0f, -0.391762f, 2.017232f,
|
---|
| 317 | 1.596027f, -0.812968f, 0.0f
|
---|
| 318 | };
|
---|
| 319 |
|
---|
| 320 | PS_OUTPUT PS(VS_OUTPUT In)
|
---|
| 321 | {
|
---|
| 322 | PS_OUTPUT Output;
|
---|
| 323 |
|
---|
| 324 | // 4 bytes of an YUV macropixel contain 2 pixels in X for the target.
|
---|
| 325 | // I.e. each YUV texture pixel is sampled twice: for both even and odd target pixels.
|
---|
| 326 |
|
---|
| 327 | // In.TexCoord are in [0;1] range for the source texture.
|
---|
| 328 | float2 texCoord = In.TexCoord;
|
---|
| 329 |
|
---|
| 330 | // Source texture data is half width, i.e. it contains data in pixels [0; width / 2 - 1].
|
---|
| 331 | texCoord.x = texCoord.x / 2.0f;
|
---|
| 332 |
|
---|
| 333 | // Which source pixel needs to be read: xPixel = TexCoord.x * SourceWidth.
|
---|
| 334 | float xSourcePixel = texCoord.x * gTextureInfo.z;
|
---|
| 335 |
|
---|
| 336 | // Remainder is about 0.25 for even pixels and about 0.75 for odd pixels.
|
---|
| 337 | float remainder = xSourcePixel - trunc(xSourcePixel);
|
---|
| 338 |
|
---|
| 339 | // Fetch YUV
|
---|
| 340 | float4 texColor = tex2D(sSource, texCoord);
|
---|
| 341 |
|
---|
| 342 | // Get YUV components.
|
---|
| 343 | float y0 = texColor.b;
|
---|
| 344 | float u = texColor.g;
|
---|
| 345 | float y1 = texColor.r;
|
---|
| 346 | float v = texColor.a;
|
---|
| 347 |
|
---|
| 348 | // Get y0 for even x coordinates and y1 for odd ones.
|
---|
| 349 | float y = remainder < 0.5f ? y0 : y1;
|
---|
| 350 |
|
---|
| 351 | // Make a vector for easier calculation.
|
---|
| 352 | float3 yuv = float3(y, u, v);
|
---|
| 353 |
|
---|
| 354 | // Convert YUV to RGB for BT.601:
|
---|
| 355 | // https://docs.microsoft.com/en-us/windows/win32/medfound/recommended-8-bit-yuv-formats-for-video-rendering#converting-8-bit-yuv-to-rgb888
|
---|
| 356 | //
|
---|
| 357 | // For 8bit [0;255] when Y = [16;235], U,V = [16;239]:
|
---|
| 358 | //
|
---|
| 359 | // C = Y - 16
|
---|
| 360 | // D = U - 128
|
---|
| 361 | // E = V - 128
|
---|
| 362 | //
|
---|
| 363 | // R = 1.164383 * C + 1.596027 * E
|
---|
| 364 | // G = 1.164383 * C - 0.391762 * D - 0.812968 * E
|
---|
| 365 | // B = 1.164383 * C + 2.017232 * D
|
---|
| 366 | //
|
---|
| 367 | // For shader values [0;1.0] when Y = [16/255;235/255], U,V = [16/255;239/255]:
|
---|
| 368 | //
|
---|
| 369 | // C = Y - 0.0627
|
---|
| 370 | // D = U - 0.5020
|
---|
| 371 | // E = V - 0.5020
|
---|
| 372 | //
|
---|
| 373 | // R = 1.164383 * C + 1.596027 * E
|
---|
| 374 | // G = 1.164383 * C - 0.391762 * D - 0.812968 * E
|
---|
| 375 | // B = 1.164383 * C + 2.017232 * D
|
---|
| 376 | //
|
---|
| 377 | yuv -= float3(0.0627f, 0.502f, 0.502f);
|
---|
| 378 | float3 bgr = mul(yuv, yuvCoeffs);
|
---|
| 379 |
|
---|
| 380 | // Clamp to [0;1]
|
---|
| 381 | bgr = saturate(bgr);
|
---|
| 382 |
|
---|
| 383 | // Return RGBA
|
---|
| 384 | Output.Color = float4(bgr, 1.0f);
|
---|
| 385 |
|
---|
| 386 | return Output;
|
---|
| 387 | }
|
---|
| 388 |
|
---|
| 389 | technique RenderScene
|
---|
| 390 | {
|
---|
| 391 | pass P0
|
---|
| 392 | {
|
---|
| 393 | VertexShader = compile vs_2_0 VS();
|
---|
| 394 | PixelShader = compile ps_2_0 PS();
|
---|
| 395 | }
|
---|
| 396 | }
|
---|
| 397 | */
|
---|
| 398 |
|
---|
| 399 | static DWORD const aVSCode[] =
|
---|
| 400 | {
|
---|
| 401 | 0xfffe0200, // vs_2_0
|
---|
| 402 | 0x05000051, 0xa00f0001, 0xbf800000, 0xc0000000, 0x3f800000, 0x00000000, // def c1, -1, -2, 1, 0
|
---|
| 403 | 0x0200001f, 0x80000000, 0x900f0000, // dcl_position v0
|
---|
| 404 | 0x0200001f, 0x80000005, 0x900f0001, // dcl_texcoord v1
|
---|
| 405 | 0x03000002, 0x80010000, 0x90000000, 0x90000000, // add r0.x, v0.x, v0.x
|
---|
| 406 | 0x02000001, 0x80010001, 0xa0000001, // mov r1.x, c1.x
|
---|
| 407 | 0x03000002, 0x80060000, 0x80000001, 0xa0d00000, // add r0.yz, r1.x, c0.xxyw
|
---|
| 408 | 0x02000006, 0x80020000, 0x80550000, // rcp r0.y, r0.y
|
---|
| 409 | 0x02000006, 0x80040000, 0x80aa0000, // rcp r0.z, r0.z
|
---|
| 410 | 0x04000004, 0xc0010000, 0x80000000, 0x80550000, 0xa0000001, // mad oPos.x, r0.x, r0.y, c1.x
|
---|
| 411 | 0x03000005, 0x80010000, 0x90550000, 0xa0550001, // mul r0.x, v0.y, c1.y
|
---|
| 412 | 0x04000004, 0xc0020000, 0x80000000, 0x80aa0000, 0xa0aa0001, // mad oPos.y, r0.x, r0.z, c1.z
|
---|
| 413 | 0x02000001, 0xc00c0000, 0xa0b40001, // mov oPos.zw, c1.xywz
|
---|
| 414 | 0x02000001, 0xe0030000, 0x90e40001, // mov oT0.xy, v1
|
---|
| 415 | 0x0000ffff
|
---|
| 416 | };
|
---|
| 417 |
|
---|
| 418 | static DWORD const aPSCodeYUY2toRGB[] =
|
---|
| 419 | {
|
---|
| 420 | 0xffff0200, // ps_2_0
|
---|
[82584] | 421 | 0x05000051, 0xa00f0005, 0x3f000000, 0x00000000, 0x3f800000, 0x3f000000, // def c5, 0.5, 0, 1, 0.5
|
---|
[82415] | 422 | 0x0200001f, 0x80000000, 0xb0030000, // dcl t0.xy
|
---|
| 423 | 0x0200001f, 0x90000000, 0xa00f0800, // dcl_2d s0
|
---|
[82584] | 424 | 0x03000005, 0x80080000, 0xb0000000, 0xa0000005, // mul r0.w, t0.x, c5.x
|
---|
[82415] | 425 | 0x03000005, 0x80010000, 0x80ff0000, 0xa0aa0000, // mul r0.x, r0.w, c0.z
|
---|
| 426 | 0x02000013, 0x80020000, 0x80000000, // frc r0.y, r0.x
|
---|
[82584] | 427 | 0x04000058, 0x80040000, 0x81550000, 0xa0550005, 0xa0aa0005, // cmp r0.z, -r0.y, c5.y, c5.z
|
---|
[82415] | 428 | 0x03000002, 0x80020000, 0x80000000, 0x81550000, // add r0.y, r0.x, -r0.y
|
---|
[82584] | 429 | 0x04000058, 0x80010000, 0x80000000, 0xa0550005, 0x80aa0000, // cmp r0.x, r0.x, c5.y, r0.z
|
---|
[82415] | 430 | 0x03000002, 0x80010000, 0x80000000, 0x80550000, // add r0.x, r0.x, r0.y
|
---|
| 431 | 0x04000004, 0x80010000, 0x80ff0000, 0xa0aa0000, 0x81000000, // mad r0.x, r0.w, c0.z, -r0.x
|
---|
[82584] | 432 | 0x03000002, 0x80010000, 0x80000000, 0xa1ff0005, // add r0.x, r0.x, -c5.w
|
---|
| 433 | 0x03000005, 0x80030001, 0xb0e40000, 0xa01b0005, // mul r1.xy, t0, c5.wzyx
|
---|
[82415] | 434 | 0x03000042, 0x800f0001, 0x80e40001, 0xa0e40800, // texld r1, r1, s0
|
---|
| 435 | 0x04000058, 0x80010001, 0x80000000, 0x80000001, 0x80aa0001, // cmp r1.x, r0.x, r1.x, r1.z
|
---|
| 436 | 0x02000001, 0x80040001, 0x80ff0001, // mov r1.z, r1.w
|
---|
[82584] | 437 | 0x03000002, 0x80070000, 0x80e40001, 0xa1e40001, // add r0.xyz, r1, -c1
|
---|
| 438 | 0x03000008, 0x80110001, 0x80e40000, 0xa0e40002, // dp3_sat r1.x, r0, c2
|
---|
| 439 | 0x03000008, 0x80120001, 0x80e40000, 0xa0e40003, // dp3_sat r1.y, r0, c3
|
---|
| 440 | 0x03000008, 0x80140001, 0x80e40000, 0xa0e40004, // dp3_sat r1.z, r0, c4
|
---|
| 441 | 0x02000001, 0x80080001, 0xa0aa0005, // mov r1.w, c5.z
|
---|
[82415] | 442 | 0x02000001, 0x800f0800, 0x80e40001, // mov oC0, r1
|
---|
| 443 | 0x0000ffff
|
---|
| 444 | };
|
---|
| 445 |
|
---|
| 446 |
|
---|
| 447 | static HRESULT vboxDxvaInit(VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice)
|
---|
| 448 | {
|
---|
| 449 | HRESULT hr;
|
---|
| 450 |
|
---|
[82330] | 451 | IDirect3DDevice9 *pDevice9 = pVideoProcessDevice->pDevice->pDevice9If;
|
---|
| 452 |
|
---|
[82415] | 453 | DWORD const *paVS = &aVSCode[0];
|
---|
| 454 | DWORD const *paPS = &aPSCodeYUY2toRGB[0];
|
---|
| 455 |
|
---|
[82330] | 456 | static D3DVERTEXELEMENT9 const aVertexElements[] =
|
---|
| 457 | {
|
---|
| 458 | {0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
|
---|
| 459 | {0, 8, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
|
---|
| 460 | D3DDECL_END()
|
---|
| 461 | };
|
---|
| 462 |
|
---|
[82415] | 463 | hr = pDevice9->CreateVertexDeclaration(aVertexElements, &pVideoProcessDevice->pVertexDecl);
|
---|
[82330] | 464 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 465 |
|
---|
| 466 | hr = pDevice9->CreateVertexBuffer(6 * sizeof(Vertex), /* 2 triangles. */
|
---|
| 467 | D3DUSAGE_WRITEONLY,
|
---|
| 468 | 0, /* FVF */
|
---|
| 469 | D3DPOOL_DEFAULT,
|
---|
| 470 | &pVideoProcessDevice->pVB,
|
---|
| 471 | 0);
|
---|
| 472 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 473 |
|
---|
| 474 | hr = pDevice9->CreateVertexShader(paVS, &pVideoProcessDevice->pVS);
|
---|
| 475 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 476 |
|
---|
| 477 | hr = pDevice9->CreatePixelShader(paPS, &pVideoProcessDevice->pPS);
|
---|
| 478 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 479 |
|
---|
| 480 | hr = pDevice9->CreateTexture(pVideoProcessDevice->VideoDesc.SampleWidth,
|
---|
[82415] | 481 | pVideoProcessDevice->VideoDesc.SampleHeight,
|
---|
| 482 | 0, /* Levels */
|
---|
| 483 | 0, /* D3DUSAGE_ */
|
---|
| 484 | D3DFMT_A8R8G8B8, //D3DFMT_YUY2,
|
---|
| 485 | D3DPOOL_DEFAULT,
|
---|
| 486 | &pVideoProcessDevice->pStagingTexture,
|
---|
| 487 | NULL);
|
---|
[82330] | 488 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 489 |
|
---|
| 490 | return S_OK;
|
---|
| 491 | }
|
---|
| 492 |
|
---|
[82584] | 493 | static float const aPSConstsBT601[] =
|
---|
[82330] | 494 | {
|
---|
[82584] | 495 | 0.062745f, 0.501961f, 0.501961f, 0.0f, // offsets
|
---|
| 496 | // Y U V
|
---|
| 497 | 1.164384f, 0.000000f, 1.596027f, 0.0f, // R
|
---|
| 498 | 1.164384f, -0.391762f, -0.812968f, 0.0f, // G
|
---|
| 499 | 1.164384f, 2.017232f, 0.000000f, 0.0f, // B
|
---|
| 500 | };
|
---|
| 501 | static float const aPSConstsBT709[] =
|
---|
| 502 | {
|
---|
| 503 | 0.062745f, 0.501961f, 0.501961f, 0.0f, // offsets
|
---|
| 504 | // Y U V
|
---|
| 505 | 1.164384f, 0.000000f, 1.792741f, 0.0f, // R
|
---|
| 506 | 1.164384f, -0.213249f, -0.532909f, 0.0f, // G
|
---|
| 507 | 1.164384f, 2.112402f, 0.000000f, 0.0f, // B
|
---|
| 508 | };
|
---|
| 509 | static float const aPSConstsSMPTE240M[] =
|
---|
| 510 | {
|
---|
| 511 | 0.062745f, 0.501961f, 0.501961f, 0.0f, // offsets
|
---|
| 512 | // Y U V
|
---|
| 513 | 1.164384f, 0.000000f, 1.794107f, 0.0f, // R
|
---|
| 514 | 1.164384f, -0.257985f, -0.542583f, 0.0f, // G
|
---|
| 515 | 1.164384f, 2.078705f, 0.000000f, 0.0f, // B
|
---|
| 516 | };
|
---|
| 517 |
|
---|
| 518 | static HRESULT vboxDxvaSetState(VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice, DXVADDI_EXTENDEDFORMAT const *pSampleFormat)
|
---|
| 519 | {
|
---|
[82330] | 520 | HRESULT hr;
|
---|
| 521 |
|
---|
| 522 | IDirect3DDevice9 *pDevice9 = pVideoProcessDevice->pDevice->pDevice9If;
|
---|
| 523 |
|
---|
[82415] | 524 | hr = pDevice9->SetStreamSource(0, pVideoProcessDevice->pVB, 0, sizeof(Vertex));
|
---|
[82330] | 525 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 526 |
|
---|
[82415] | 527 | hr = pDevice9->SetVertexDeclaration(pVideoProcessDevice->pVertexDecl);
|
---|
[82330] | 528 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 529 |
|
---|
[82415] | 530 | hr = pDevice9->SetVertexShader(pVideoProcessDevice->pVS);
|
---|
| 531 | AssertReturn(hr == D3D_OK, hr);
|
---|
[82330] | 532 |
|
---|
[82415] | 533 | hr = pDevice9->SetPixelShader(pVideoProcessDevice->pPS);
|
---|
| 534 | AssertReturn(hr == D3D_OK, hr);
|
---|
[82330] | 535 |
|
---|
[82415] | 536 | hr = pDevice9->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
|
---|
| 537 | AssertReturn(hr == D3D_OK, hr);
|
---|
[82330] | 538 |
|
---|
[82415] | 539 | hr = pDevice9->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
|
---|
[82330] | 540 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 541 |
|
---|
[82415] | 542 | hr = pDevice9->SetTexture(0, pVideoProcessDevice->pStagingTexture);
|
---|
| 543 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 544 |
|
---|
| 545 | float const cTargetWidth = pVideoProcessDevice->pRenderTarget->aAllocations[0].SurfDesc.width;
|
---|
| 546 | float const cTargetHeight = pVideoProcessDevice->pRenderTarget->aAllocations[0].SurfDesc.height;
|
---|
| 547 |
|
---|
| 548 | float const cSampleWidth = pVideoProcessDevice->VideoDesc.SampleWidth;
|
---|
| 549 | float const cSampleHeight = pVideoProcessDevice->VideoDesc.SampleHeight;
|
---|
| 550 |
|
---|
| 551 | float aTextureInfo[4];
|
---|
| 552 | aTextureInfo[0] = cTargetWidth;
|
---|
| 553 | aTextureInfo[1] = cTargetHeight;
|
---|
| 554 | aTextureInfo[2] = cSampleWidth;
|
---|
| 555 | aTextureInfo[3] = cSampleHeight;
|
---|
| 556 |
|
---|
| 557 | hr = pDevice9->SetVertexShaderConstantF(0, aTextureInfo, 1);
|
---|
| 558 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 559 | hr = pDevice9->SetPixelShaderConstantF(0, aTextureInfo, 1);
|
---|
| 560 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 561 |
|
---|
[82584] | 562 | float const *pConstantData;
|
---|
| 563 | UINT Vector4fCount;
|
---|
| 564 | switch (pSampleFormat->VideoTransferMatrix)
|
---|
| 565 | {
|
---|
| 566 | case DXVADDI_VideoTransferMatrix_BT709:
|
---|
| 567 | pConstantData = aPSConstsBT709;
|
---|
| 568 | Vector4fCount = RT_ELEMENTS(aPSConstsBT709) / 4;
|
---|
| 569 | break;
|
---|
| 570 | case DXVADDI_VideoTransferMatrix_SMPTE240M:
|
---|
| 571 | pConstantData = aPSConstsSMPTE240M;
|
---|
| 572 | Vector4fCount = RT_ELEMENTS(aPSConstsSMPTE240M) / 4;
|
---|
| 573 | break;
|
---|
| 574 | case DXVADDI_VideoTransferMatrix_BT601:
|
---|
| 575 | default:
|
---|
| 576 | pConstantData = aPSConstsBT601;
|
---|
| 577 | Vector4fCount = RT_ELEMENTS(aPSConstsBT601) / 4;
|
---|
| 578 | break;
|
---|
| 579 | }
|
---|
| 580 |
|
---|
| 581 | hr = pDevice9->SetPixelShaderConstantF(1, pConstantData, Vector4fCount);
|
---|
| 582 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 583 |
|
---|
[82415] | 584 | hr = pDevice9->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
|
---|
| 585 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 586 | hr = pDevice9->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
|
---|
| 587 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 588 | hr = pDevice9->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
|
---|
| 589 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 590 |
|
---|
| 591 | hr = pDevice9->SetRenderTarget(0, pVideoProcessDevice->pRTSurface);
|
---|
| 592 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 593 |
|
---|
[82330] | 594 | return S_OK;
|
---|
| 595 | }
|
---|
| 596 |
|
---|
[82415] | 597 | static HRESULT vboxDxvaUpdateVertexBuffer(VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice,
|
---|
| 598 | RECT const *pSrcRect,
|
---|
| 599 | RECT const *pDstRect)
|
---|
| 600 | {
|
---|
| 601 | HRESULT hr;
|
---|
| 602 |
|
---|
| 603 | /* Do not display anything if the source rectangle is not what is expected.
|
---|
| 604 | * But assert anyway in order to be able to investigate.
|
---|
| 605 | */
|
---|
| 606 | AssertReturn(pSrcRect->right > pSrcRect->left, S_OK);
|
---|
| 607 | AssertReturn(pSrcRect->bottom > pSrcRect->top, S_OK);
|
---|
| 608 |
|
---|
[93299] | 609 | float const cSrcWidth = pVideoProcessDevice->VideoDesc.SampleWidth;
|
---|
[82415] | 610 | float const cSrcHeight = pVideoProcessDevice->VideoDesc.SampleHeight;
|
---|
| 611 |
|
---|
[93299] | 612 | float const uSrcLeft = (float)pSrcRect->left / cSrcWidth;
|
---|
| 613 | float const uSrcRight = (float)pSrcRect->right / cSrcWidth;
|
---|
| 614 | float const vSrcTop = (float)pSrcRect->top / cSrcHeight;
|
---|
| 615 | float const vSrcBottom = (float)pSrcRect->bottom / cSrcHeight;
|
---|
[82415] | 616 |
|
---|
| 617 | /* Subtract 0.5 to line up the pixel centers with texels
|
---|
| 618 | * https://docs.microsoft.com/en-us/windows/win32/direct3d9/directly-mapping-texels-to-pixels
|
---|
| 619 | */
|
---|
[93299] | 620 | float const xDstLeft = (float)pDstRect->left - 0.5f;
|
---|
| 621 | float const xDstRight = (float)pDstRect->right - 0.5f;
|
---|
| 622 | float const yDstTop = (float)pDstRect->top - 0.5f;
|
---|
| 623 | float const yDstBottom = (float)pDstRect->bottom - 0.5f;
|
---|
[82415] | 624 |
|
---|
| 625 | Vertex const aVertices[] =
|
---|
| 626 | {
|
---|
| 627 | { xDstLeft, yDstTop, uSrcLeft, vSrcTop},
|
---|
| 628 | { xDstRight, yDstTop, uSrcRight, vSrcTop},
|
---|
| 629 | { xDstRight, yDstBottom, uSrcRight, vSrcBottom},
|
---|
| 630 |
|
---|
| 631 | { xDstLeft, yDstTop, uSrcLeft, vSrcTop},
|
---|
| 632 | { xDstRight, yDstBottom, uSrcRight, vSrcBottom},
|
---|
| 633 | { xDstLeft, yDstBottom, uSrcLeft, vSrcBottom},
|
---|
| 634 | };
|
---|
| 635 |
|
---|
| 636 | hr = vboxDxvaCopyToVertexBuffer(pVideoProcessDevice->pVB, aVertices, sizeof(aVertices));
|
---|
| 637 | AssertReturn(hr == D3D_OK, hr);
|
---|
| 638 |
|
---|
| 639 | return S_OK;
|
---|
| 640 | }
|
---|
| 641 |
|
---|
| 642 | static HRESULT vboxDxvaProcessBlt(VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice,
|
---|
| 643 | D3DDDIARG_VIDEOPROCESSBLT const *pData,
|
---|
| 644 | IDirect3DTexture9 *paSrcTextures[])
|
---|
| 645 | {
|
---|
| 646 | HRESULT hr;
|
---|
| 647 |
|
---|
| 648 | IDirect3DDevice9 *pDevice9 = pVideoProcessDevice->pDevice->pDevice9If;
|
---|
| 649 |
|
---|
| 650 | hr = vboxDxvaDeviceStateSave(pDevice9, &pVideoProcessDevice->SavedState);
|
---|
| 651 | if (hr == D3D_OK)
|
---|
| 652 | {
|
---|
| 653 | /* Set the required state for the blits, inclusding the render target. */
|
---|
[82584] | 654 | hr = vboxDxvaSetState(pVideoProcessDevice, &pData->pSrcSurfaces[0].SampleFormat);
|
---|
[82415] | 655 | if (hr == D3D_OK)
|
---|
| 656 | {
|
---|
| 657 | /* Clear the target rectangle. */
|
---|
| 658 | /** @todo Use pData->BackgroundColor */
|
---|
| 659 | D3DCOLOR BgColor = 0;
|
---|
| 660 | D3DRECT TargetRect;
|
---|
| 661 | TargetRect.x1 = pData->TargetRect.left;
|
---|
| 662 | TargetRect.y1 = pData->TargetRect.top;
|
---|
| 663 | TargetRect.x2 = pData->TargetRect.right;
|
---|
| 664 | TargetRect.y2 = pData->TargetRect.bottom;
|
---|
| 665 | hr = pDevice9->Clear(1, &TargetRect, D3DCLEAR_TARGET, BgColor, 0.0f, 0);
|
---|
| 666 | Assert(hr == D3D_OK); /* Ignore errors. */
|
---|
| 667 |
|
---|
| 668 | DXVADDI_VIDEOSAMPLE const *pSrcSample = &pData->pSrcSurfaces[0];
|
---|
| 669 | IDirect3DTexture9 *pSrcTexture = paSrcTextures[0];
|
---|
| 670 |
|
---|
| 671 | /* Upload the source data to the staging texture. */
|
---|
| 672 | hr = vboxDxvaUploadSample(pVideoProcessDevice, pSrcTexture, pSrcSample->SrcSubResourceIndex);
|
---|
| 673 | if (hr == D3D_OK)
|
---|
| 674 | {
|
---|
| 675 | /* Setup the blit dimensions. */
|
---|
| 676 | hr = vboxDxvaUpdateVertexBuffer(pVideoProcessDevice, &pSrcSample->SrcRect, &pSrcSample->DstRect);
|
---|
| 677 | Assert(hr == D3D_OK);
|
---|
| 678 | if (hr == D3D_OK)
|
---|
| 679 | {
|
---|
| 680 |
|
---|
| 681 | hr = pDevice9->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
|
---|
| 682 | Assert(hr == D3D_OK);
|
---|
| 683 | }
|
---|
| 684 | }
|
---|
| 685 | }
|
---|
| 686 |
|
---|
| 687 | vboxDxvaDeviceStateRestore(pDevice9, &pVideoProcessDevice->SavedState);
|
---|
| 688 | }
|
---|
| 689 |
|
---|
| 690 | return hr;
|
---|
| 691 | }
|
---|
| 692 |
|
---|
[82330] | 693 | /*
|
---|
| 694 | *
|
---|
| 695 | * Public API.
|
---|
| 696 | *
|
---|
| 697 | */
|
---|
| 698 | HRESULT VBoxDxvaGetDeviceGuidCount(UINT *pcGuids)
|
---|
| 699 | {
|
---|
| 700 | *pcGuids = RT_ELEMENTS(gaDeviceGuids);
|
---|
| 701 | return S_OK;
|
---|
| 702 | }
|
---|
| 703 |
|
---|
| 704 | HRESULT VBoxDxvaGetDeviceGuids(GUID *paGuids, UINT cbGuids)
|
---|
| 705 | {
|
---|
| 706 | if (cbGuids >= sizeof(gaDeviceGuids))
|
---|
| 707 | {
|
---|
| 708 | memcpy(paGuids, &gaDeviceGuids[0], sizeof(gaDeviceGuids));
|
---|
| 709 | return S_OK;
|
---|
| 710 | }
|
---|
| 711 |
|
---|
| 712 | AssertFailed();
|
---|
| 713 | return E_INVALIDARG;
|
---|
| 714 | }
|
---|
| 715 |
|
---|
| 716 | HRESULT VBoxDxvaGetOutputFormatCount(UINT *pcFormats, DXVADDI_VIDEOPROCESSORINPUT const *pVPI, bool fSubstream)
|
---|
| 717 | {
|
---|
| 718 | RT_NOREF(fSubstream);
|
---|
| 719 |
|
---|
| 720 | UINT cFormats = 0;
|
---|
| 721 | if (pVPI)
|
---|
| 722 | {
|
---|
| 723 | if (vboxDxvaFindDeviceGuid(pVPI->pVideoProcGuid) >= 0)
|
---|
| 724 | {
|
---|
| 725 | if (vboxDxvaFindInputFormat(pVPI->VideoDesc.Format) >= 0)
|
---|
| 726 | {
|
---|
| 727 | cFormats = RT_ELEMENTS(gaOutputFormats);
|
---|
| 728 | }
|
---|
| 729 | }
|
---|
| 730 | }
|
---|
| 731 |
|
---|
| 732 | *pcFormats = cFormats;
|
---|
| 733 | return S_OK;
|
---|
| 734 | }
|
---|
| 735 |
|
---|
| 736 | HRESULT VBoxDxvaGetOutputFormats(D3DDDIFORMAT *paFormats, UINT cbFormats, DXVADDI_VIDEOPROCESSORINPUT const *pVPI, bool fSubstream)
|
---|
| 737 | {
|
---|
| 738 | RT_NOREF(fSubstream);
|
---|
| 739 |
|
---|
| 740 | if (pVPI)
|
---|
| 741 | {
|
---|
| 742 | if (vboxDxvaFindDeviceGuid(pVPI->pVideoProcGuid) >= 0)
|
---|
| 743 | {
|
---|
| 744 | if (vboxDxvaFindInputFormat(pVPI->VideoDesc.Format) >= 0)
|
---|
| 745 | {
|
---|
| 746 | if (cbFormats >= sizeof(gaOutputFormats))
|
---|
| 747 | {
|
---|
| 748 | memcpy(paFormats, gaOutputFormats, sizeof(gaOutputFormats));
|
---|
| 749 | return S_OK;
|
---|
| 750 | }
|
---|
| 751 | }
|
---|
| 752 | }
|
---|
| 753 | }
|
---|
| 754 |
|
---|
| 755 | AssertFailed();
|
---|
| 756 | return E_INVALIDARG;
|
---|
| 757 | }
|
---|
| 758 |
|
---|
| 759 | HRESULT VBoxDxvaGetCaps(DXVADDI_VIDEOPROCESSORCAPS *pVideoProcessorCaps,
|
---|
| 760 | DXVADDI_VIDEOPROCESSORINPUT const *pVPI)
|
---|
| 761 | {
|
---|
| 762 | RT_ZERO(*pVideoProcessorCaps);
|
---|
| 763 |
|
---|
| 764 | if (pVPI)
|
---|
| 765 | {
|
---|
| 766 | if (vboxDxvaFindDeviceGuid(pVPI->pVideoProcGuid) >= 0)
|
---|
| 767 | {
|
---|
| 768 | if (vboxDxvaFindInputFormat(pVPI->VideoDesc.Format) >= 0)
|
---|
| 769 | {
|
---|
| 770 | pVideoProcessorCaps->InputPool = D3DDDIPOOL_SYSTEMMEM;
|
---|
| 771 | pVideoProcessorCaps->NumForwardRefSamples = 0; /// @todo 1 for deinterlacing?
|
---|
| 772 | pVideoProcessorCaps->NumBackwardRefSamples = 0;
|
---|
| 773 | pVideoProcessorCaps->OutputFormat = D3DDDIFMT_X8R8G8B8;
|
---|
| 774 | pVideoProcessorCaps->DeinterlaceTechnology = DXVADDI_DEINTERLACETECH_UNKNOWN;
|
---|
| 775 | pVideoProcessorCaps->ProcAmpControlCaps = DXVADDI_PROCAMP_NONE; /// @todo Maybe some?
|
---|
| 776 | pVideoProcessorCaps->VideoProcessorOperations = DXVADDI_VIDEOPROCESS_YUV2RGB
|
---|
| 777 | | DXVADDI_VIDEOPROCESS_STRETCHX
|
---|
| 778 | | DXVADDI_VIDEOPROCESS_STRETCHY
|
---|
| 779 | | DXVADDI_VIDEOPROCESS_YUV2RGBEXTENDED
|
---|
| 780 | | DXVADDI_VIDEOPROCESS_CONSTRICTION
|
---|
| 781 | | DXVADDI_VIDEOPROCESS_LINEARSCALING
|
---|
| 782 | | DXVADDI_VIDEOPROCESS_GAMMACOMPENSATED;
|
---|
| 783 | pVideoProcessorCaps->NoiseFilterTechnology = DXVADDI_NOISEFILTERTECH_UNSUPPORTED;
|
---|
| 784 | pVideoProcessorCaps->DetailFilterTechnology = DXVADDI_DETAILFILTERTECH_UNSUPPORTED;
|
---|
| 785 | return S_OK;
|
---|
| 786 | }
|
---|
| 787 | }
|
---|
| 788 | }
|
---|
| 789 |
|
---|
| 790 | AssertFailed();
|
---|
| 791 | return E_INVALIDARG;
|
---|
| 792 | }
|
---|
| 793 |
|
---|
| 794 | HRESULT VBoxDxvaCreateVideoProcessDevice(PVBOXWDDMDISP_DEVICE pDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE *pData)
|
---|
| 795 | {
|
---|
| 796 | /*
|
---|
| 797 | * Do minimum here. Devices are created and destroyed without being used.
|
---|
| 798 | */
|
---|
| 799 | VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice =
|
---|
| 800 | (VBOXWDDMVIDEOPROCESSDEVICE *)RTMemAllocZ(sizeof(VBOXWDDMVIDEOPROCESSDEVICE));
|
---|
| 801 | if (pVideoProcessDevice)
|
---|
| 802 | {
|
---|
| 803 | pVideoProcessDevice->pDevice = pDevice;
|
---|
| 804 | pVideoProcessDevice->VideoProcGuid = *pData->pVideoProcGuid;
|
---|
| 805 | pVideoProcessDevice->VideoDesc = pData->VideoDesc;
|
---|
| 806 | pVideoProcessDevice->RenderTargetFormat = pData->RenderTargetFormat;
|
---|
| 807 | pVideoProcessDevice->MaxSubStreams = pData->MaxSubStreams;
|
---|
| 808 |
|
---|
| 809 | pData->hVideoProcess = pVideoProcessDevice;
|
---|
| 810 | return S_OK;
|
---|
| 811 | }
|
---|
| 812 |
|
---|
| 813 | return E_OUTOFMEMORY;
|
---|
| 814 | }
|
---|
| 815 |
|
---|
| 816 | HRESULT VBoxDxvaDestroyVideoProcessDevice(PVBOXWDDMDISP_DEVICE pDevice, HANDLE hVideoProcessor)
|
---|
| 817 | {
|
---|
| 818 | VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice = (VBOXWDDMVIDEOPROCESSDEVICE *)hVideoProcessor;
|
---|
[82415] | 819 | AssertReturn(pDevice == pVideoProcessDevice->pDevice, E_INVALIDARG);
|
---|
[82330] | 820 |
|
---|
[82415] | 821 | D3D_RELEASE(pVideoProcessDevice->pRTSurface);
|
---|
| 822 |
|
---|
| 823 | D3D_RELEASE(pVideoProcessDevice->pStagingTexture);
|
---|
| 824 | D3D_RELEASE(pVideoProcessDevice->pVertexDecl);
|
---|
| 825 | D3D_RELEASE(pVideoProcessDevice->pVB);
|
---|
| 826 | D3D_RELEASE(pVideoProcessDevice->pVS);
|
---|
| 827 | D3D_RELEASE(pVideoProcessDevice->pPS);
|
---|
| 828 |
|
---|
| 829 | RTMemFree(pVideoProcessDevice);
|
---|
| 830 |
|
---|
[82330] | 831 | return S_OK;
|
---|
| 832 | }
|
---|
| 833 |
|
---|
| 834 | HRESULT VBoxDxvaVideoProcessBeginFrame(PVBOXWDDMDISP_DEVICE pDevice, HANDLE hVideoProcessor)
|
---|
| 835 | {
|
---|
| 836 | VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice = (VBOXWDDMVIDEOPROCESSDEVICE *)hVideoProcessor;
|
---|
| 837 | AssertReturn(pDevice == pVideoProcessDevice->pDevice, E_INVALIDARG);
|
---|
[82415] | 838 | AssertPtrReturn(pDevice->pDevice9If, E_INVALIDARG);
|
---|
[82330] | 839 |
|
---|
| 840 | HRESULT hr = S_OK;
|
---|
[82415] | 841 | if (!pVideoProcessDevice->pStagingTexture)
|
---|
[82330] | 842 | {
|
---|
| 843 | hr = vboxDxvaInit(pVideoProcessDevice);
|
---|
| 844 | }
|
---|
| 845 |
|
---|
| 846 | return hr;
|
---|
| 847 | }
|
---|
| 848 |
|
---|
| 849 | HRESULT VBoxDxvaVideoProcessEndFrame(PVBOXWDDMDISP_DEVICE pDevice, D3DDDIARG_VIDEOPROCESSENDFRAME *pData)
|
---|
| 850 | {
|
---|
| 851 | VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice = (VBOXWDDMVIDEOPROCESSDEVICE *)pData->hVideoProcess;
|
---|
| 852 | AssertReturn(pDevice == pVideoProcessDevice->pDevice, E_INVALIDARG);
|
---|
| 853 | return S_OK;
|
---|
| 854 | }
|
---|
| 855 |
|
---|
| 856 | HRESULT VBoxDxvaSetVideoProcessRenderTarget(PVBOXWDDMDISP_DEVICE pDevice,
|
---|
| 857 | const D3DDDIARG_SETVIDEOPROCESSRENDERTARGET *pData)
|
---|
| 858 | {
|
---|
| 859 | VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice = (VBOXWDDMVIDEOPROCESSDEVICE *)pData->hVideoProcess;
|
---|
| 860 | AssertReturn(pDevice == pVideoProcessDevice->pDevice, E_INVALIDARG);
|
---|
| 861 |
|
---|
[82415] | 862 | D3D_RELEASE(pVideoProcessDevice->pRTSurface);
|
---|
| 863 | pVideoProcessDevice->pRenderTarget = NULL;
|
---|
| 864 | pVideoProcessDevice->RTSubResourceIndex = 0;
|
---|
| 865 | pVideoProcessDevice->pRTTexture = NULL;
|
---|
| 866 |
|
---|
[82330] | 867 | PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
|
---|
| 868 | AssertReturn(pRc->cAllocations > pData->SubResourceIndex, E_INVALIDARG);
|
---|
| 869 |
|
---|
| 870 | VBOXWDDMDISP_ALLOCATION *pAllocation = &pRc->aAllocations[pData->SubResourceIndex];
|
---|
| 871 | AssertPtrReturn(pAllocation->pD3DIf, E_INVALIDARG);
|
---|
| 872 | AssertReturn(pAllocation->enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE, E_INVALIDARG);
|
---|
| 873 |
|
---|
[82415] | 874 | #ifdef LOG_ENABLED
|
---|
[82330] | 875 | LOGREL_EXACT(("VideoProcess RT %dx%d sid=%u\n",
|
---|
| 876 | pRc->aAllocations[0].SurfDesc.width, pRc->aAllocations[0].SurfDesc.height, pAllocation->hostID));
|
---|
[82415] | 877 | #endif
|
---|
[82330] | 878 |
|
---|
[82415] | 879 | IDirect3DTexture9 *pRTTexture = (IDirect3DTexture9 *)pAllocation->pD3DIf;
|
---|
| 880 | HRESULT hr = pRTTexture->GetSurfaceLevel(pData->SubResourceIndex, &pVideoProcessDevice->pRTSurface);
|
---|
| 881 | AssertReturn(hr == D3D_OK, E_INVALIDARG);
|
---|
| 882 |
|
---|
| 883 | pVideoProcessDevice->pRenderTarget = pRc;
|
---|
| 884 | pVideoProcessDevice->RTSubResourceIndex = pData->SubResourceIndex;
|
---|
| 885 | pVideoProcessDevice->pRTTexture = pRTTexture;
|
---|
| 886 |
|
---|
[82330] | 887 | return S_OK;
|
---|
| 888 | }
|
---|
| 889 |
|
---|
| 890 | HRESULT VBoxDxvaVideoProcessBlt(PVBOXWDDMDISP_DEVICE pDevice, const D3DDDIARG_VIDEOPROCESSBLT *pData)
|
---|
| 891 | {
|
---|
| 892 | VBOXWDDMVIDEOPROCESSDEVICE *pVideoProcessDevice = (VBOXWDDMVIDEOPROCESSDEVICE *)pData->hVideoProcess;
|
---|
| 893 | AssertReturn(pDevice == pVideoProcessDevice->pDevice, E_INVALIDARG);
|
---|
[82415] | 894 | AssertPtrReturn(pDevice->pDevice9If, E_INVALIDARG);
|
---|
| 895 | AssertPtrReturn(pVideoProcessDevice->pRTSurface, E_INVALIDARG);
|
---|
[82330] | 896 |
|
---|
[82415] | 897 | AssertReturn(pData->NumSrcSurfaces > 0, E_INVALIDARG);
|
---|
| 898 |
|
---|
[82330] | 899 | PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->pSrcSurfaces[0].SrcResource;
|
---|
[82415] | 900 | AssertReturn(pSrcRc->cAllocations > pData->pSrcSurfaces[0].SrcSubResourceIndex, E_INVALIDARG);
|
---|
[82330] | 901 |
|
---|
[82415] | 902 | VBOXWDDMDISP_ALLOCATION *pAllocation = &pSrcRc->aAllocations[pData->pSrcSurfaces[0].SrcSubResourceIndex];
|
---|
[82330] | 903 | AssertPtrReturn(pAllocation->pD3DIf, E_INVALIDARG);
|
---|
| 904 | AssertReturn(pAllocation->enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE, E_INVALIDARG);
|
---|
| 905 |
|
---|
| 906 | IDirect3DTexture9 *pSrcTexture = (IDirect3DTexture9 *)pAllocation->pD3DIf;
|
---|
| 907 |
|
---|
[82415] | 908 | #ifdef LOG_ENABLED
|
---|
| 909 | LOGREL_EXACT(("VideoProcess Blt sid = %u fmt 0x%08x %d,%d %dx%d (%dx%d) -> %d,%d %dx%d (%d,%d %dx%d, %dx%d)\n",
|
---|
| 910 | pAllocation->hostID, pSrcRc->aAllocations[0].SurfDesc.format,
|
---|
[82330] | 911 | pData->pSrcSurfaces[0].SrcRect.left, pData->pSrcSurfaces[0].SrcRect.top,
|
---|
| 912 | pData->pSrcSurfaces[0].SrcRect.right - pData->pSrcSurfaces[0].SrcRect.left,
|
---|
| 913 | pData->pSrcSurfaces[0].SrcRect.bottom - pData->pSrcSurfaces[0].SrcRect.top,
|
---|
| 914 |
|
---|
| 915 | pSrcRc->aAllocations[0].SurfDesc.width,
|
---|
| 916 | pSrcRc->aAllocations[0].SurfDesc.height,
|
---|
| 917 |
|
---|
| 918 | pData->pSrcSurfaces[0].DstRect.left, pData->pSrcSurfaces[0].DstRect.top,
|
---|
| 919 | pData->pSrcSurfaces[0].DstRect.right - pData->pSrcSurfaces[0].DstRect.left,
|
---|
| 920 | pData->pSrcSurfaces[0].DstRect.bottom - pData->pSrcSurfaces[0].DstRect.top,
|
---|
| 921 |
|
---|
| 922 | pData->TargetRect.left, pData->TargetRect.top,
|
---|
| 923 | pData->TargetRect.right - pData->TargetRect.left, pData->TargetRect.bottom - pData->TargetRect.top,
|
---|
| 924 |
|
---|
| 925 | pVideoProcessDevice->pRenderTarget->aAllocations[0].SurfDesc.width,
|
---|
| 926 | pVideoProcessDevice->pRenderTarget->aAllocations[0].SurfDesc.height));
|
---|
[82584] | 927 |
|
---|
| 928 | DXVADDI_EXTENDEDFORMAT *pSampleFormat = &pData->pSrcSurfaces[0].SampleFormat;
|
---|
| 929 | LOGREL_EXACT(("VideoProcess Blt SampleFormat %u, VideoChromaSubsampling %u, NominalRange %u, VideoTransferMatrix %u, VideoLighting %u, VideoPrimaries %u, VideoTransferFunction %u\n",
|
---|
| 930 | pSampleFormat->SampleFormat, pSampleFormat->VideoChromaSubsampling, pSampleFormat->NominalRange,
|
---|
| 931 | pSampleFormat->VideoTransferMatrix, pSampleFormat->VideoLighting, pSampleFormat->VideoPrimaries,
|
---|
| 932 | pSampleFormat->VideoTransferFunction));
|
---|
[82415] | 933 | #endif
|
---|
[82330] | 934 |
|
---|
[82415] | 935 | HRESULT hr = vboxDxvaProcessBlt(pVideoProcessDevice, pData, &pSrcTexture);
|
---|
| 936 | return hr;
|
---|
[82330] | 937 | }
|
---|