Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_decode_downsampling.cpp

raw
1 /*
2 * Copyright (c) 2017-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file codechal_decode_downsampling.cpp
24 //! \brief Implements the decode interface extension for field downsampling.
25 //! \details Downsampling in this case is supported by EU kernels.
26 //!
27 #include "codechal_decoder.h"
28 #include "codeckrnheader.h"
29
30 // Construct function of Class MediaWalkerFieldScalingStaticData
31 MediaWalkerFieldScalingStaticData::MediaWalkerFieldScalingStaticData()
32 {
33 CODECHAL_DECODE_FUNCTION_ENTER;
34
35 memset(&m_mediaWalkerData, 0, sizeof(m_mediaWalkerData));
36 m_mediaWalkerData.m_dword07.m_value = 0x7;
37 m_mediaWalkerData.m_dword14.m_nlasEnable = false;
38 }
39
40 // Initialize the static const float variables in class FieldScalingInterface.
41 const float FieldScalingInterface::m_maxScaleRatio = 1.0f;
42 const float FieldScalingInterface::m_minScaleRatio = 0.125f;
43
44 FieldScalingInterface::FieldScalingInterface()
45 {
46 CODECHAL_DECODE_FUNCTION_ENTER;
47
48 memset(&m_kernelSize, 0, sizeof(m_kernelSize));
49 memset(&m_dshSize, 0, sizeof(m_dshSize));
50 memset(&m_syncObject, 0, sizeof(m_syncObject));
51
52 for (uint8_t i = stateNv12; i < stateMax; i++)
53 {
54 m_kernelBinary[i] = nullptr;
55 m_kernelStates[i] = MHW_KERNEL_STATE();
56 }
57
58 m_kernelUID[stateNv12] = IDR_CODEC_ALLPL2ToNV12iScale;
59 m_kernelUID[stateYuy2] = IDR_CODEC_ALLPL2ToPAiScale;
60
61 m_curbeLength = MediaWalkerFieldScalingStaticData::m_byteSize;
62 }
63
64 FieldScalingInterface::~FieldScalingInterface()
65 {
66 CODECHAL_DECODE_FUNCTION_ENTER;
67
68 if (m_mmcState != nullptr)
69 {
70 MOS_Delete(m_mmcState);
71 m_mmcState = nullptr;
72 }
73
74 CODECHAL_DECODE_ASSERT(m_osInterface);
75 if (m_osInterface != nullptr)
76 {
77 m_osInterface->pfnDestroySyncResource(m_osInterface, &m_syncObject);
78 }
79 }
80
81 MOS_STATUS FieldScalingInterface::InitInterfaceStateHeapSetting(
82 CodechalHwInterface *hwInterface)
83 {
84 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
85
86 CODECHAL_DECODE_FUNCTION_ENTER;
87
88 MHW_KERNEL_STATE *kernelState;
89 for (auto krnlIdx = 0; krnlIdx < stateMax; krnlIdx++)
90 {
91 kernelState = &m_kernelStates[krnlIdx];
92
93 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(
94 m_kernelBase,
95 m_kernelUID[krnlIdx],
96 &m_kernelBinary[krnlIdx],
97 &m_kernelSize[krnlIdx]));
98
99 kernelState->KernelParams.iCurbeLength = m_curbeLength;
100 kernelState->KernelParams.pBinary = m_kernelBinary[krnlIdx];
101 kernelState->KernelParams.iSize = m_kernelSize[krnlIdx];
102
103 hwInterface->GetStateHeapSettings()->dwIshSize +=
104 MOS_ALIGN_CEIL(
105 kernelState->KernelParams.iSize,
106 (1 << MHW_KERNEL_OFFSET_SHIFT));
107 }
108
109 hwInterface->GetStateHeapSettings()->dwNumSyncTags += m_numSyncTags;
110 hwInterface->GetStateHeapSettings()->dwDshSize += m_initDshSize;
111
112 return eStatus;
113 }
114
115 MOS_STATUS FieldScalingInterface::SetCurbeFieldScaling(
116 MHW_KERNEL_STATE *kernelState,
117 DecodeProcessingParams *procParams)
118 {
119 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
120
121 CODECHAL_DECODE_FUNCTION_ENTER;
122
123 CODECHAL_DECODE_CHK_NULL_RETURN(kernelState);
124 CODECHAL_DECODE_CHK_NULL_RETURN(procParams);
125 CODECHAL_DECODE_CHK_NULL_RETURN(procParams->m_inputSurface);
126 CODECHAL_DECODE_CHK_NULL_RETURN(procParams->m_outputSurface);
127
128 MOS_SURFACE *inputSurface = procParams->m_inputSurface;
129 MOS_SURFACE *outputSurface = procParams->m_outputSurface;
130
131 float stepX = (float)procParams->m_inputSurfaceRegion.m_width /
132 (float)(procParams->m_outputSurfaceRegion.m_width * inputSurface->dwWidth);
133 float stepY = (float)procParams->m_inputSurfaceRegion.m_height /
134 (float)(procParams->m_outputSurfaceRegion.m_height * inputSurface->dwHeight);
135
136 MediaWalkerFieldScalingStaticData cmd;
137 cmd.m_mediaWalkerData.m_dword07.m_pointerToInlineParameters = 0xB;
138 cmd.m_mediaWalkerData.m_dword08.m_destinationRectangleWidth = procParams->m_outputSurfaceRegion.m_width;
139 cmd.m_mediaWalkerData.m_dword08.m_destinationRectangleHeight = procParams->m_outputSurfaceRegion.m_height;
140
141 if (outputSurface->Format == Format_NV12)
142 {
143 cmd.m_mediaWalkerData.m_dword10.m_chromaSitingLocation = CODECHAL_CHROMA_SUBSAMPLING_CENTER_LEFT;
144 }
145 else
146 {
147 cmd.m_mediaWalkerData.m_dword10.m_chromaSitingLocation = CODECHAL_CHROMA_SUBSAMPLING_TOP_LEFT;
148 }
149
150 cmd.m_mediaWalkerData.m_dword16.m_horizontalScalingStepRatioLayer0 = stepX;
151 cmd.m_mediaWalkerData.m_dword24.m_verticalScalingStepRatioLayer0 = stepY;
152 cmd.m_mediaWalkerData.m_dword48.m_destXTopLeftLayer0 = 0;
153 cmd.m_mediaWalkerData.m_dword48.m_destYTopLeftLayer0 = 0;
154 cmd.m_mediaWalkerData.m_dword56.m_destXBottomRightLayer0 = procParams->m_outputSurfaceRegion.m_width - 1;
155 cmd.m_mediaWalkerData.m_dword56.m_destYBottomRightLayer0 = procParams->m_outputSurfaceRegion.m_height - 1;
156 cmd.m_mediaWalkerData.m_dword64.m_mainVideoXScalingStepLeft = 1.0F;
157
158 CODECHAL_DECODE_CHK_STATUS_RETURN(kernelState->m_dshRegion.AddData(
159 &cmd.m_mediaWalkerData,
160 kernelState->dwCurbeOffset,
161 cmd.m_byteSize));
162
163 return eStatus;
164 }
165
166 bool FieldScalingInterface::IsFieldScalingSupported(DecodeProcessingParams *params)
167 {
168 CODECHAL_DECODE_FUNCTION_ENTER;
169
170 if (!params || !params->m_inputSurface || !params->m_outputSurface)
171 {
172 CODECHAL_DECODE_ASSERTMESSAGE("Invalid Parameters");
173 return false;
174 }
175
176 MOS_SURFACE *srcSurface = params->m_inputSurface;
177 MOS_SURFACE *destSurface = params->m_outputSurface;
178
179 // Check input size
180 if (!MOS_WITHIN_RANGE(srcSurface->dwWidth, m_minInputWidth, m_maxInputWidth) ||
181 !MOS_WITHIN_RANGE(srcSurface->dwHeight, m_minInputHeight, m_maxInputHeight))
182 {
183 CODECHAL_DECODE_ASSERTMESSAGE("Unsupported Input Resolution '0x%08x'x'0x%08x' for field scaling.", srcSurface->dwWidth, srcSurface->dwHeight);
184 return false;
185 }
186
187 // Check input format
188 if (srcSurface->Format != Format_NV12)
189 {
190 CODECHAL_DECODE_ASSERTMESSAGE("Unsupported Input Format '0x%08x' for field scaling.", srcSurface->Format);
191 return false;
192 }
193
194 // Check input region rectangles
195 if ((params->m_inputSurfaceRegion.m_width > srcSurface->dwWidth) ||
196 (params->m_inputSurfaceRegion.m_height > srcSurface->dwHeight))
197 {
198 CODECHAL_DECODE_ASSERTMESSAGE("Input region is out of bound for field scaling.");
199 return false;
200 }
201
202 // Check output format
203 if (destSurface->Format != Format_NV12 && destSurface->Format != Format_YUY2)
204 {
205 CODECHAL_DECODE_ASSERTMESSAGE("Unsupported Output Format '0x%08x' for field scaling.", destSurface->Format);
206 return false;
207 }
208
209 // Check output size
210 if (!MOS_WITHIN_RANGE(destSurface->dwWidth, m_minInputWidth, m_maxInputWidth) ||
211 !MOS_WITHIN_RANGE(destSurface->dwHeight, m_minInputHeight, m_maxInputHeight))
212 {
213 CODECHAL_DECODE_ASSERTMESSAGE("Unsupported Output Resolution '0x%08x'x'0x%08x' for field scaling.", destSurface->dwWidth, destSurface->dwHeight);
214 return false;
215 }
216
217 // Check output region rectangles
218 if ((params->m_outputSurfaceRegion.m_width > destSurface->dwWidth) ||
219 (params->m_outputSurfaceRegion.m_height > destSurface->dwHeight))
220 {
221 CODECHAL_DECODE_ASSERTMESSAGE("Output region is out of bound for field scaling.");
222 return false;
223 }
224
225 // Check scaling ratio
226 // Scaling range is [0.125, 1] for both X and Y direction.
227 float scaleX = (float)params->m_outputSurfaceRegion.m_width / (float)params->m_inputSurfaceRegion.m_width;
228 float scaleY = (float)params->m_outputSurfaceRegion.m_height / (float)params->m_inputSurfaceRegion.m_height;
229
230 if (!MOS_WITHIN_RANGE(scaleX, m_minScaleRatio, m_maxScaleRatio) ||
231 !MOS_WITHIN_RANGE(scaleY, m_minScaleRatio, m_maxScaleRatio))
232 {
233 CODECHAL_DECODE_ASSERTMESSAGE("Scaling factor not supported by field scaling.");
234 return false;
235 }
236
237 return true;
238 }
239
240 MOS_STATUS FieldScalingInterface::InitializeKernelState(
241 CodechalDecode *decoder,
242 CodechalHwInterface *hwInterface,
243 PMOS_INTERFACE osInterface)
244 {
245 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
246
247 CODECHAL_DECODE_FUNCTION_ENTER;
248
249 CODECHAL_DECODE_CHK_NULL_RETURN(hwInterface);
250 CODECHAL_DECODE_CHK_NULL_RETURN(osInterface);
251 CODECHAL_DECODE_CHK_NULL_RETURN(hwInterface->GetMiInterface());
252 CODECHAL_DECODE_CHK_NULL_RETURN(hwInterface->GetRenderInterface());
253 CODECHAL_DECODE_CHK_NULL_RETURN(hwInterface->GetRenderInterface()->GetHwCaps());
254 CODECHAL_DECODE_CHK_NULL_RETURN(hwInterface->GetRenderInterface()->m_stateHeapInterface);
255
256 this->m_decoder = decoder;
257 m_osInterface = osInterface;
258 m_hwInterface = hwInterface;
259 m_renderInterface = m_hwInterface->GetRenderInterface();
260 m_stateHeapInterface = m_renderInterface->m_stateHeapInterface;
261 m_miInterface = m_hwInterface->GetMiInterface();
262
263 MHW_KERNEL_STATE *kernelState;
264 for (auto krnIdx = 0; krnIdx < stateMax; krnIdx++)
265 {
266 kernelState = &m_kernelStates[krnIdx];
267
268 kernelState->KernelParams.iThreadCount = m_renderInterface->GetHwCaps()->dwMaxThreads;
269 kernelState->KernelParams.iBTCount = numSurfaces;
270 kernelState->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
271 kernelState->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
272 kernelState->KernelParams.iIdCount = 1;
273 kernelState->KernelParams.iSamplerCount = m_samplerNum;
274 kernelState->KernelParams.iSamplerLength = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdSampleState();
275
276 kernelState->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
277 kernelState->dwSamplerOffset =
278 kernelState->dwCurbeOffset +
279 MOS_ALIGN_CEIL(kernelState->KernelParams.iCurbeLength, m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment());
280 kernelState->dwKernelBinaryOffset = 0;
281
282 MHW_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
283 m_stateHeapInterface,
284 kernelState->KernelParams.iBTCount,
285 &kernelState->dwSshSize,
286 &kernelState->dwBindingTableSize));
287
288 m_dshSize[krnIdx] =
289 m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData() +
290 MOS_ALIGN_CEIL(kernelState->KernelParams.iCurbeLength, m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment()) +
291 kernelState->KernelParams.iSamplerLength * m_samplerNum;
292
293 MHW_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(
294 m_stateHeapInterface,
295 kernelState));
296 }
297
298 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
299 m_osInterface,
300 &m_syncObject));
301
302 return eStatus;
303 }
304
305 MOS_STATUS FieldScalingInterface::SetupMediaVfe(
306 PMOS_COMMAND_BUFFER cmdBuffer,
307 MHW_KERNEL_STATE *kernelState)
308 {
309 MHW_VFE_PARAMS vfeParams = {};
310
311 vfeParams.pKernelState = kernelState;
312 CODECHAL_DECODE_CHK_STATUS_RETURN(m_renderInterface->AddMediaVfeCmd(cmdBuffer, &vfeParams));
313
314 return MOS_STATUS_SUCCESS;
315 }
316
317 MOS_STATUS FieldScalingInterface::DoFieldScaling(
318 DecodeProcessingParams *procParams,
319 MOS_GPU_CONTEXT renderContext,
320 bool disableDecodeSyncLock,
321 bool disableLockForTranscode)
322 {
323 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
324
325 CODECHAL_DECODE_FUNCTION_ENTER;
326
327 CODECHAL_DECODE_CHK_NULL_RETURN(procParams);
328 CODECHAL_DECODE_CHK_NULL_RETURN(procParams->m_inputSurface);
329 CODECHAL_DECODE_CHK_NULL_RETURN(procParams->m_outputSurface);
330 CODECHAL_DECODE_CHK_NULL_RETURN(m_hwInterface->GetMiInterface());
331
332 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
333
334 MOS_SYNC_PARAMS syncParams;
335 syncParams = g_cInitSyncParams;
336 syncParams.GpuContext = m_decoder->GetVideoContext();
337 syncParams.presSyncResource = &m_syncObject;
338
339 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
340
341 syncParams = g_cInitSyncParams;
342 syncParams.GpuContext = renderContext;
343 syncParams.presSyncResource = &m_syncObject;
344
345 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
346
347 FieldScalingKernelStateIdx kernelStateIdx;
348 if (procParams->m_outputSurface->Format == Format_NV12)
349 {
350 kernelStateIdx = stateNv12;
351 }
352 else if (procParams->m_outputSurface->Format == Format_YUY2)
353 {
354 kernelStateIdx = stateYuy2;
355 }
356 else
357 {
358 return MOS_STATUS_INVALID_PARAMETER;
359 }
360
361 m_osInterface->pfnSetGpuContext(m_osInterface, renderContext);
362 m_osInterface->pfnResetOsStates(m_osInterface);
363
364 MHW_KERNEL_STATE *kernelState = &m_kernelStates[kernelStateIdx];
365
366 CODECHAL_DECODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
367 m_stateHeapInterface,
368 kernelState->KernelParams.iBTCount));
369
370 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
371 m_stateHeapInterface,
372 kernelState,
373 false,
374 m_dshSize[kernelStateIdx],
375 false,
376 m_decoder->GetDecodeStatusBuf()->m_swStoreData));
377
378 // Initialize DSH kernel region
379 MHW_INTERFACE_DESCRIPTOR_PARAMS idParams;
380 memset(&idParams, 0, sizeof(idParams));
381 idParams.pKernelState = kernelState;
382 CODECHAL_DECODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
383 m_stateHeapInterface,
384 kernelState->KernelParams.iIdCount,
385 &idParams));
386
387 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCurbeFieldScaling(
388 kernelState,
389 procParams));
390
391 MHW_SAMPLER_STATE_PARAM samplerParams[m_samplerNum];
392 memset(&samplerParams[0], 0, sizeof(MHW_SAMPLER_STATE_PARAM) * m_samplerNum);
393 samplerParams[0].bInUse = false;
394 samplerParams[0].pKernelState = kernelState;
395 for (uint32_t index = 1; index < m_samplerNum - 1; index++)
396 {
397 samplerParams[index].bInUse = true;
398 samplerParams[index].pKernelState = kernelState;
399 }
400 CODECHAL_DECODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetSamplerState(
401 m_stateHeapInterface,
402 nullptr,
403 &samplerParams[0]));
404
405 // Send HW commands (including SSH)
406 MOS_COMMAND_BUFFER cmdBuffer;
407 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
408
409 MHW_PIPE_CONTROL_PARAMS pipeControlParams;
410 memset(&pipeControlParams, 0, sizeof(pipeControlParams));
411
412 // Send command buffer header at the beginning (OS dependent)
413 CODECHAL_DECODE_CHK_STATUS_RETURN(m_decoder->SendPrologWithFrameTracking(
414 &cmdBuffer, true));
415
416 if (m_renderInterface->GetL3CacheConfig()->bL3CachingEnabled)
417 {
418 CODECHAL_DECODE_CHK_STATUS_RETURN(m_renderInterface->SetL3Cache(&cmdBuffer));
419 }
420
421 CODECHAL_DECODE_CHK_STATUS_RETURN(m_renderInterface->EnablePreemption(&cmdBuffer));
422
423 CODECHAL_DECODE_CHK_STATUS_RETURN(m_renderInterface->AddPipelineSelectCmd(&cmdBuffer, false));
424
425 CODECHAL_DECODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
426 m_stateHeapInterface,
427 kernelState));
428
429 // Source Surface
430 // Top Field
431 CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
432 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
433 surfaceCodecParams.bIs2DSurface = true;
434 surfaceCodecParams.bUseHalfHeight = true;
435 surfaceCodecParams.bUseUVPlane = true;
436 surfaceCodecParams.psSurface = procParams->m_inputSurface;
437 surfaceCodecParams.dwCacheabilityControl = surfaceCacheabilityControlBitsFromGtt;
438
439 surfaceCodecParams.dwBindingTableOffset = fieldTopSrcY;
440 surfaceCodecParams.dwUVBindingTableOffset = fieldTopSrcUV;
441 surfaceCodecParams.dwVerticalLineStride = 1;
442 surfaceCodecParams.dwVerticalLineStrideOffset = 0;
443
444 surfaceCodecParams.bForceChromaFormat = true;
445 surfaceCodecParams.ChromaType = MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM;
446
447 PMOS_INTERFACE osInterface = m_osInterface;
448 CodecHalGetResourceInfo(osInterface,surfaceCodecParams.psSurface);
449
450 if (m_mmcState)
451 {
452 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(&surfaceCodecParams));
453 }
454
455 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
456 m_hwInterface,
457 &cmdBuffer,
458 &surfaceCodecParams,
459 kernelState));
460
461 // Bottom Field
462 surfaceCodecParams.dwBindingTableOffset = fieldBotSrcY;
463 surfaceCodecParams.dwUVBindingTableOffset = fieldBotSrcUV;
464 surfaceCodecParams.dwVerticalLineStrideOffset = 1;
465
466 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
467 m_hwInterface,
468 &cmdBuffer,
469 &surfaceCodecParams,
470 kernelState));
471
472 // Destination Surface (NV12 & YUY2, RGB8 support is not yet implemented)
473 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
474 surfaceCodecParams.bIs2DSurface = true;
475 surfaceCodecParams.psSurface = procParams->m_outputSurface;
476 surfaceCodecParams.bMediaBlockRW = true;
477 surfaceCodecParams.bIsWritable = true;
478 surfaceCodecParams.dwBindingTableOffset = dstY;
479 surfaceCodecParams.dwUVBindingTableOffset = dstUV;
480 surfaceCodecParams.dwCacheabilityControl = surfaceCacheabilityControlBitsFromGtt;
481
482 if (procParams->m_outputSurface->Format == Format_NV12)
483 {
484 surfaceCodecParams.bUseUVPlane = true;
485 surfaceCodecParams.bForceChromaFormat = true;
486 surfaceCodecParams.ChromaType = MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM;
487 }
488
489 if (m_mmcState)
490 {
491 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(&surfaceCodecParams));
492 }
493
494 CodecHalGetResourceInfo(osInterface,surfaceCodecParams.psSurface);
495 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
496 m_hwInterface,
497 &cmdBuffer,
498 &surfaceCodecParams,
499 kernelState));
500
501 MHW_STATE_BASE_ADDR_PARAMS stateBaseAddrParams;
502 memset(&stateBaseAddrParams, 0, sizeof(stateBaseAddrParams));
503 MOS_RESOURCE *dsh = nullptr, *ish = nullptr;
504 CODECHAL_DECODE_CHK_NULL_RETURN(dsh = kernelState->m_dshRegion.GetResource());
505 CODECHAL_DECODE_CHK_NULL_RETURN(ish = kernelState->m_ishRegion.GetResource());
506 stateBaseAddrParams.presDynamicState = dsh;
507 stateBaseAddrParams.dwDynamicStateSize = kernelState->m_dshRegion.GetHeapSize();
508 stateBaseAddrParams.presInstructionBuffer = ish;
509 stateBaseAddrParams.dwInstructionBufferSize = kernelState->m_ishRegion.GetHeapSize();
510
511 //Function is shared by Gen9 Gen10 Gen11 Gen12, here Gen9 will be used when fetching cache's Index.
512 stateBaseAddrParams.mocs4GeneralState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen9.Index;
513 stateBaseAddrParams.mocs4DynamicState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen9.Index;
514 stateBaseAddrParams.mocs4SurfaceState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen9.Index;
515 stateBaseAddrParams.mocs4IndirectObjectBuffer = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen9.Index;
516 stateBaseAddrParams.mocs4StatelessDataport = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen9.Index;
517 CODECHAL_DECODE_CHK_STATUS_RETURN(m_renderInterface->AddStateBaseAddrCmd(&cmdBuffer, &stateBaseAddrParams));
518
519 CODECHAL_DECODE_CHK_STATUS_RETURN(SetupMediaVfe(&cmdBuffer, kernelState));
520
521 MHW_CURBE_LOAD_PARAMS curbeLoadParams;
522 memset(&curbeLoadParams, 0, sizeof(curbeLoadParams));
523 curbeLoadParams.pKernelState = kernelState;
524 CODECHAL_DECODE_CHK_STATUS_RETURN(m_renderInterface->AddMediaCurbeLoadCmd(&cmdBuffer, &curbeLoadParams));
525
526 MHW_ID_LOAD_PARAMS idLoadParams;
527 memset(&idLoadParams, 0, sizeof(idLoadParams));
528 idLoadParams.pKernelState = kernelState;
529 idLoadParams.dwNumKernelsLoaded = 1;
530 CODECHAL_DECODE_CHK_STATUS_RETURN(m_renderInterface->AddMediaIDLoadCmd(&cmdBuffer, &idLoadParams));
531
532 uint32_t resolutionX = MOS_ROUNDUP_DIVIDE(procParams->m_outputSurfaceRegion.m_width, 16);
533 uint32_t resolutionY = MOS_ROUNDUP_DIVIDE(procParams->m_outputSurfaceRegion.m_height, 16);
534
535 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
536 memset(&walkerCodecParams, 0, sizeof(walkerCodecParams));
537 walkerCodecParams.WalkerMode = MHW_WALKER_MODE_DUAL;
538 walkerCodecParams.dwResolutionX = resolutionX;
539 walkerCodecParams.dwResolutionY = resolutionY;
540 walkerCodecParams.bNoDependency = true; // raster scan mode
541
542 MHW_WALKER_PARAMS walkerParams;
543 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
544 m_hwInterface,
545 &walkerParams,
546 &walkerCodecParams));
547
548 CODECHAL_DECODE_CHK_STATUS_RETURN(m_renderInterface->AddMediaObjectWalkerCmd(&cmdBuffer, &walkerParams));
549
550 // Check if destination surface needs to be synchronized, before command buffer submission
551 syncParams = g_cInitSyncParams;
552 syncParams.GpuContext = renderContext;
553 syncParams.presSyncResource = &procParams->m_outputSurface->OsResource;
554 syncParams.bReadOnly = false;
555 syncParams.bDisableDecodeSyncLock = disableDecodeSyncLock;
556 syncParams.bDisableLockForTranscode = disableLockForTranscode;
557
558 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
559 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
560
561 // Update the resource tag (s/w tag) for On-Demand Sync
562 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
563
564 // Update GPU Sync tag for on demand synchronization
565 if (m_osInterface->bTagResourceSync)
566 {
567 pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
568 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(&cmdBuffer, nullptr, &pipeControlParams));
569 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
570 }
571
572 CODECHAL_DECODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnUpdateGlobalCmdBufId(
573 m_stateHeapInterface));
574
575 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
576
577 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
578
579 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_decoder->GetRenderContextUsesNullHw()));
580
581 if (m_decoder->IsStatusQueryReportingEnabled())
582 {
583 CODECHAL_DECODE_CHK_STATUS_RETURN(m_decoder->ResetStatusReport(m_decoder->GetRenderContextUsesNullHw()));
584 }
585
586 m_osInterface->pfnSetGpuContext(m_osInterface, m_decoder->GetVideoContext());
587
588 return (MOS_STATUS)eStatus;
589 }
590
591 MOS_STATUS FieldScalingInterface::InitMmcState()
592 {
593 if (m_mmcState == nullptr)
594 {
595 m_mmcState = MOS_New(CodecHalMmcState, m_hwInterface);
596 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmcState);
597 }
598
599 return MOS_STATUS_SUCCESS;
600 }