Debian Codegraph @

media_driver/agnostic/gen12/codec/hal/codechal_decode_vp9_g12.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_vp9_g12.cpp
24 //! \brief Implements the decode interface extension for Gen12 VP9.
25 //! \details Implements all functions required by CodecHal for Gen12 VP9 decoding.
26 //!
27
28 #include "codechal_decoder.h"
29 #include "codechal_secure_decode_interface.h"
30 #include "codechal_decode_vp9_g12.h"
31 #include "codechal_decode_sfc_vp9_g12.h"
32 #include "codechal_mmc_decode_vp9_g12.h"
33 #include "mhw_vdbox_hcp_g12_X.h"
34 #include "mhw_vdbox_mfx_g12_X.h"
35 #include "mhw_vdbox_g12_X.h"
36 #include "codechal_hw_g12_X.h"
37 #include "codechal_decode_histogram.h"
38 #include "mhw_mi_g12_X.h"
39 #include "hal_oca_interface.h"
40
41 CodechalDecodeVp9G12 :: ~CodechalDecodeVp9G12()
42 {
43 CODECHAL_DECODE_FUNCTION_ENTER;
44
45 if (m_sinlgePipeVeState)
46 {
47 MOS_FreeMemAndSetNull(m_sinlgePipeVeState);
48 }
49 if (m_scalabilityState)
50 {
51 CodecHalDecodeScalability_Destroy_G12(m_scalabilityState);
52 MOS_FreeMemAndSetNull(m_scalabilityState);
53 }
54 //Note: virtual engine interface destroy is done in MOS layer
55 #ifdef _DECODE_PROCESSING_SUPPORTED
56 if (m_sfcState)
57 {
58 MOS_Delete(m_sfcState);
59 m_sfcState = nullptr;
60 }
61 #endif
62
63 if (m_histogramSurface)
64 {
65 if (!Mos_ResourceIsNull(&m_histogramSurface->OsResource))
66 {
67 m_osInterface->pfnFreeResource(
68 m_osInterface,
69 &m_histogramSurface->OsResource);
70 }
71 MOS_FreeMemory(m_histogramSurface);
72 m_histogramSurface = nullptr;
73 }
74 }
75
76 CodechalDecodeVp9G12::CodechalDecodeVp9G12(
77 CodechalHwInterface * hwInterface,
78 CodechalDebugInterface *debugInterface,
79 PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecodeVp9(hwInterface, debugInterface, standardInfo),
80 m_frameSizeMaxAlloced(0),
81 m_sinlgePipeVeState(nullptr),
82 m_scalabilityState(nullptr)
83 {
84 CODECHAL_DECODE_FUNCTION_ENTER;
85
86 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
87
88 m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
89
90 #if (_DEBUG || _RELEASE_INTERNAL)
91 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
92 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
93 MOS_UserFeature_ReadValue_ID(
94 nullptr,
95 __MEDIA_USER_FEATURE_VALUE_DECODE_HISTOGRAM_DEBUG_ID,
96 &userFeatureData,
97 m_osInterface->pOsContext);
98 m_histogramDebug = userFeatureData.u32Data ? true : false;
99 #endif
100 }
101
102 MOS_STATUS CodechalDecodeVp9G12::SetGpuCtxCreatOption(
103 CodechalSetting *codecHalSetting)
104 {
105 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
106
107 CODECHAL_DECODE_FUNCTION_ENTER;
108
109 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
110 {
111 CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
112 }
113 else
114 {
115 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
116 CODECHAL_DECODE_CHK_NULL_RETURN(m_gpuCtxCreatOpt);
117
118 if (static_cast<MhwVdboxMfxInterfaceG12 *>(m_mfxInterface)->IsScalabilitySupported())
119 {
120 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeScalability_ConstructParmsForGpuCtxCreation_g12(
121 m_scalabilityState,
122 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
123 codecHalSetting));
124
125 if (((PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt)->LRCACount == 2)
126 {
127 m_videoContext = MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface) ? MOS_GPU_CONTEXT_VIDEO5 : MOS_GPU_CONTEXT_VDBOX2_VIDEO;
128
129 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
130 m_osInterface,
131 m_videoContext,
132 MOS_GPU_NODE_VIDEO,
133 m_gpuCtxCreatOpt));
134
135 MOS_GPUCTX_CREATOPTIONS createOption;
136 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
137 m_osInterface,
138 MOS_GPU_CONTEXT_VIDEO,
139 m_videoGpuNode,
140 &createOption));
141 }
142 else if (((PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt)->LRCACount == 3)
143 {
144 m_videoContext = MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface) ? MOS_GPU_CONTEXT_VIDEO7 : MOS_GPU_CONTEXT_VDBOX2_VIDEO2;
145
146 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
147 m_osInterface,
148 m_videoContext,
149 MOS_GPU_NODE_VIDEO,
150 m_gpuCtxCreatOpt));
151
152 MOS_GPUCTX_CREATOPTIONS createOption;
153 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
154 m_osInterface,
155 MOS_GPU_CONTEXT_VIDEO,
156 m_videoGpuNode,
157 &createOption));
158 }
159 else
160 {
161 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
162 }
163 }
164 else
165 {
166 bool sfcInUse = (codecHalSetting->sfcInUseHinted && codecHalSetting->downsamplingHinted
167 && (MEDIA_IS_SKU(m_skuTable, FtrSFCPipe) && !MEDIA_IS_SKU(m_skuTable, FtrDisableVDBox2SFC)));
168 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
169 m_sinlgePipeVeState,
170 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
171 sfcInUse));
172
173 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
174 }
175 }
176
177 return eStatus;
178 }
179
180 MOS_STATUS CodechalDecodeVp9G12 :: AllocateResourcesVariableSizes()
181 {
182 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
183
184 CODECHAL_DECODE_FUNCTION_ENTER;
185
186 // To WA invalid aux data caused HW issue when MMC on
187 if (m_mmc && m_mmc->IsMmcEnabled() && MEDIA_IS_WA(m_waTable, Wa_1408785368) &&
188 !Mos_ResourceIsNull(&m_destSurface.OsResource) &&
189 m_destSurface.OsResource.bConvertedFromDDIResource)
190 {
191 if (m_secureDecoder && m_secureDecoder->IsAuxDataInvalid(&m_destSurface.OsResource))
192 {
193 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->InitAuxSurface(&m_destSurface.OsResource, false, true));
194 }
195 else
196 {
197 CODECHAL_DECODE_VERBOSEMESSAGE("Clear CCS by VE resolve before frame %d submission", m_frameNum);
198 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnDecompResource(m_osInterface, &m_destSurface.OsResource));
199 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext));
200 }
201 }
202
203 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
204 {
205 uint32_t widthInSb = MOS_ROUNDUP_DIVIDE(m_width, CODEC_VP9_SUPER_BLOCK_WIDTH);
206 uint32_t heightInSb = MOS_ROUNDUP_DIVIDE(m_height, CODEC_VP9_SUPER_BLOCK_HEIGHT);
207 uint32_t frameSizeMax = MOS_MAX((m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize), m_frameSizeMaxAlloced);
208 uint8_t maxBitDepth = 8 + m_vp9DepthIndicator * 2;
209 uint8_t chromaFormat = m_chromaFormatinProfile;
210
211 MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam;
212 MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
213 hcpBufSizeParam.ucMaxBitDepth = maxBitDepth;
214 hcpBufSizeParam.ucChromaFormat = chromaFormat;
215 hcpBufSizeParam.dwPicWidth = widthInSb;
216 hcpBufSizeParam.dwPicHeight = heightInSb;
217 hcpBufSizeParam.dwMaxFrameSize = frameSizeMax;
218
219 MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam;
220 MOS_ZeroMemory(&reallocParam, sizeof(reallocParam));
221 reallocParam.ucMaxBitDepth = maxBitDepth;
222 reallocParam.ucChromaFormat = chromaFormat;
223 reallocParam.dwPicWidth = widthInSb;
224 reallocParam.dwPicWidthAlloced = m_allocatedWidthInSb;
225 reallocParam.dwPicHeight = heightInSb;
226 reallocParam.dwPicHeightAlloced = m_allocatedHeightInSb;
227 reallocParam.dwFrameSize = frameSizeMax;
228 reallocParam.dwFrameSizeAlloced = m_frameSizeMaxAlloced;
229 CODECHAL_DECODE_CHK_STATUS_RETURN(
230 CodecHalDecodeScalability_AllocateResources_VariableSizes_G12(
231 m_scalabilityState,
232 &hcpBufSizeParam,
233 &reallocParam));
234
235 m_frameSizeMaxAlloced = frameSizeMax;
236 }
237
238 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVp9 ::AllocateResourcesVariableSizes());
239
240 return eStatus;
241 }
242
243 MOS_STATUS CodechalDecodeVp9G12::InitSfcState()
244 {
245 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
246 #ifdef _DECODE_PROCESSING_SUPPORTED
247 // Check if SFC can be supported
248 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->CheckAndInitialize(
249 (DecodeProcessingParams *)m_decodeParams.m_procParams,
250 m_vp9PicParams,
251 m_scalabilityState));
252 #endif
253 return eStatus;
254 }
255
256 MOS_STATUS CodechalDecodeVp9G12::CalcDownsamplingParams(
257 void *picParams,
258 uint32_t *refSurfWidth,
259 uint32_t *refSurfHeight,
260 MOS_FORMAT *format,
261 uint8_t *frameIdx)
262 {
263 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
264
265 CODECHAL_DECODE_CHK_NULL_RETURN(picParams);
266 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfWidth);
267 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfHeight);
268 CODECHAL_DECODE_CHK_NULL_RETURN(format);
269 CODECHAL_DECODE_CHK_NULL_RETURN(frameIdx);
270
271 PCODEC_VP9_PIC_PARAMS vp9PicParams = (PCODEC_VP9_PIC_PARAMS)picParams;
272
273 *refSurfWidth = 0;
274 *refSurfHeight = 0;
275 *format = Format_NV12;
276 *frameIdx = vp9PicParams->CurrPic.FrameIdx;
277
278
279 *refSurfWidth = MOS_ALIGN_CEIL(vp9PicParams->FrameWidthMinus1 + 1, CODEC_VP9_SUPER_BLOCK_WIDTH);
280 *refSurfHeight = MOS_ALIGN_CEIL(vp9PicParams->FrameHeightMinus1 + 1, CODEC_VP9_SUPER_BLOCK_HEIGHT);
281
282 if (vp9PicParams->subsampling_x == 1 && vp9PicParams->subsampling_y == 1) //HCP_CHROMA_FORMAT_YUV420
283 {
284 if (vp9PicParams->BitDepthMinus8 > 2)
285 {
286 *format = Format_P016;
287 }
288 else if (vp9PicParams->BitDepthMinus8 > 0)
289 {
290 *format = Format_P010;
291 }
292 else
293 {
294 *format = Format_NV12;
295 }
296 }
297 else if (vp9PicParams->subsampling_x == 0 && vp9PicParams->subsampling_y == 0) //HCP_CHROMA_FORMAT_YUV444
298 {
299 if (vp9PicParams->BitDepthMinus8 > 2)
300 {
301 *format = Format_Y416;
302 }
303 else if (vp9PicParams->BitDepthMinus8 > 0)
304 {
305 *format = Format_Y410;
306 }
307 else
308 {
309 *format = Format_AYUV;
310 }
311 }
312 else
313 {
314 CODECHAL_DECODE_ASSERTMESSAGE("Invalid Chroma sampling format!");
315 eStatus = MOS_STATUS_INVALID_PARAMETER;
316 return eStatus;
317 }
318 return eStatus;
319 }
320
321 MOS_STATUS CodechalDecodeVp9G12 :: InitializeDecodeMode ()
322 {
323 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
324
325 CODECHAL_DECODE_FUNCTION_ENTER;
326
327 if ( MOS_VE_SUPPORTED(m_osInterface) && static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
328 {
329 CODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 initParams;
330
331 MOS_ZeroMemory(&initParams, sizeof(initParams));
332 initParams.u32PicWidthInPixel = m_usFrameWidthAlignedMinBlk;
333 initParams.u32PicHeightInPixel = m_usFrameHeightAlignedMinBlk;
334 initParams.format = m_decodeParams.m_destSurface->Format;
335 initParams.gpuCtxInUse = GetVideoContext();
336 initParams.usingSecureDecode = (m_secureDecoder != nullptr);
337 if (m_decodeHistogram == nullptr)
338 {
339 initParams.usingHistogram = false;
340 #if (_DEBUG || _RELEASE_INTERNAL)
341 if (m_histogramDebug)
342 {
343 initParams.usingHistogram = true;
344 }
345 #endif
346 }
347 else
348 {
349 initParams.usingHistogram = true;
350 }
351 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitScalableParams_G12(
352 m_scalabilityState,
353 &initParams,
354 &m_decodePassNum));
355
356 if (MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
357 {
358 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeScalability_ChkGpuCtxReCreation(
359 m_scalabilityState,
360 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt));
361 SetVideoContext(m_scalabilityState->VideoContext);
362 }
363
364 }
365
366 return eStatus;
367 }
368
369 MOS_STATUS CodechalDecodeVp9G12::DetermineDecodePhase()
370 {
371 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
372
373 CODECHAL_DECODE_FUNCTION_ENTER;
374
375 if (static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
376 {
377 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_DetermineDecodePhase_G12(
378 m_scalabilityState,
379 &m_hcpDecPhase));
380 }
381 else
382 {
383 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVp9 :: DetermineDecodePhase());
384 }
385
386 return eStatus;
387 }
388
389 MOS_STATUS CodechalDecodeVp9G12::SetAndPopulateVEHintParams(
390 PMOS_COMMAND_BUFFER primCmdBuf)
391 {
392 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
393
394 CODECHAL_DECODE_FUNCTION_ENTER;
395
396 if (static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
397 {
398 CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS scalSetParms;
399 MOS_ZeroMemory(&scalSetParms, sizeof(CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS));
400 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
401 {
402 scalSetParms.bNeedSyncWithPrevious = true;
403 scalSetParms.bSameEngineAsLastSubmission = false;
404 scalSetParms.bSFCInUse = false;
405 }
406 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SetHintParams_G12(m_scalabilityState, &scalSetParms));
407 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_PopulateHintParams(m_scalabilityState, primCmdBuf));
408 }
409 else
410 {
411 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
412 {
413 MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
414 MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
415 vesetParams.bNeedSyncWithPrevious = true;
416 vesetParams.bSameEngineAsLastSubmission = false;
417 vesetParams.bSFCInUse = false;
418 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_sinlgePipeVeState, &vesetParams));
419 }
420 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_PopulateHintParams(m_sinlgePipeVeState, primCmdBuf, true));
421 }
422
423 return eStatus;
424 }
425
426 MOS_STATUS CodechalDecodeVp9G12::DetermineSendProlgwithFrmTracking(
427 bool *sendPrologWithFrameTracking)
428 {
429 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
430
431 CODECHAL_DECODE_FUNCTION_ENTER;
432
433 CODECHAL_DECODE_CHK_NULL_RETURN(sendPrologWithFrameTracking);
434
435 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
436 {
437 if (CodecHalDecodeScalability1stPhaseofSubmission(m_scalabilityState))
438 {
439 *sendPrologWithFrameTracking = true;
440 }
441 }
442 else
443 {
444 *sendPrologWithFrameTracking = true;
445 }
446
447 return eStatus;
448 }
449
450 uint32_t CodechalDecodeVp9G12::RequestedSpaceSize(uint32_t requestedSize)
451 {
452 if (m_scalabilityState && m_scalabilityState->bScalableDecodeMode)
453 {
454 //primary cmd buffer only including cmd buffer header .
455 return COMMAND_BUFFER_RESERVED_SPACE * 2;
456 }
457 else
458 {
459 return requestedSize;
460 }
461 }
462
463 MOS_STATUS CodechalDecodeVp9G12::VerifyExtraSpace(
464 uint32_t requestedSize,
465 uint32_t additionalSizeNeeded)
466 {
467 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
468
469 CODECHAL_DECODE_FUNCTION_ENTER;
470
471 if (m_scalabilityState && m_scalabilityState->bScalableDecodeMode)
472 {
473 eStatus = MOS_STATUS_NO_SPACE;
474
475 // Try a maximum of 3 attempts to request the required sizes from OS
476 // OS could reset the sizes if necessary, therefore, requires to re-verify
477 for (auto i = 0; (i < 3) && (eStatus != MOS_STATUS_SUCCESS); i++)
478 {
479 // Verify secondary cmd buffer
480 eStatus = (MOS_STATUS)m_osInterface->pfnVerifyCommandBufferSize(
481 m_osInterface,
482 requestedSize,
483 MOS_VE_HAVE_SECONDARY_CMDBUFFER);
484
485 // Resize command buffer if not enough
486 if (eStatus != MOS_STATUS_SUCCESS)
487 {
488 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResizeCommandBufferAndPatchList(
489 m_osInterface,
490 requestedSize + additionalSizeNeeded,
491 0,
492 MOS_VE_HAVE_SECONDARY_CMDBUFFER));
493 // Set status to NO_SPACE to enter the commaned buffer size verification on next loop.
494 eStatus = MOS_STATUS_NO_SPACE;
495 }
496 }
497 }
498
499 return eStatus;
500 }
501
502 MOS_STATUS CodechalDecodeVp9G12::AllocateHistogramSurface()
503 {
504 MOS_ALLOC_GFXRES_PARAMS allocParams;
505
506 if (m_histogramSurface == nullptr)
507 {
508 m_histogramSurface = (MOS_SURFACE*)MOS_AllocAndZeroMemory(sizeof(MOS_SURFACE));
509 CODECHAL_DECODE_CHK_NULL_RETURN(m_histogramSurface);
510
511 MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
512 allocParams.Type = MOS_GFXRES_BUFFER;
513 allocParams.TileType = MOS_TILE_LINEAR;
514 allocParams.Format = Format_Buffer;
515 allocParams.dwBytes = 256 * 4;
516 allocParams.pBufName = "HistogramStreamOut";
517
518 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
519 m_osInterface,
520 &allocParams,
521 &m_histogramSurface->OsResource));
522
523 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
524 m_osInterface,
525 m_histogramSurface));
526 }
527
528 if(m_decodeHistogram)
529 m_decodeHistogram->SetSrcHistogramSurface(m_histogramSurface);
530
531 return MOS_STATUS_SUCCESS;
532 }
533
534 MOS_STATUS CodechalDecodeVp9G12::AddPicStateMhwCmds(
535 PMOS_COMMAND_BUFFER cmdBuffer)
536 {
537 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
538 MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
539
540 CODECHAL_DECODE_FUNCTION_ENTER;
541
542 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
543
544 // Send VD_CONTROL_STATE Pipe Initialization
545 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
546 vdCtrlParam.initialization = true;
547 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBuffer, &vdCtrlParam));
548
549 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(
550 cmdBuffer,
551 m_picMhwParams.PipeModeSelectParams));
552
553 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) &&
554 CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState))
555 {
556 // Send VD_CONTROL_STATE HcpPipeLock
557 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
558 vdCtrlParam.scalableModePipeLock = true;
559 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBuffer, &vdCtrlParam));
560 }
561 #ifdef _DECODE_PROCESSING_SUPPORTED
562 if (!CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState))
563 {
564 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->AddSfcCommands(cmdBuffer));
565 }
566 #endif
567
568 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceState(m_picMhwParams.SurfaceParams[0]));
569
570 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSurfaceCmd(
571 cmdBuffer,
572 m_picMhwParams.SurfaceParams[0]));
573
574 // For non-key frame, send extra surface commands for reference pictures
575 if (m_vp9PicParams->PicFlags.fields.frame_type == CODEC_VP9_INTER_FRAME &&
576 !m_vp9PicParams->PicFlags.fields.intra_only)
577 {
578 //Get each reference surface state and be recorded by skipMask if current surface state is mmc disabled
579 uint8_t skipMask = 0xf8;
580 for (uint8_t i = 1; i < 4; i++)
581 {
582 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceState(m_picMhwParams.SurfaceParams[i]));
583 if (m_picMhwParams.SurfaceParams[i]->mmcState == MOS_MEMCOMP_DISABLED)
584 {
585 skipMask |= (1 << (i - 1));
586 }
587 }
588 CODECHAL_DECODE_NORMALMESSAGE("MMC skip mask is %d\n", skipMask);
589 for (uint8_t i = 1; i < 4; i++)
590 {
591 //Set each ref surface state as MOS_MEMCOMP_MC to satisfy MmcEnable in AddHcpSurfaceCmd
592 //Because each ref surface state should be programmed as the same
593 //The actual mmc state is recorded by skipMask and set each ref surface too
594 m_picMhwParams.SurfaceParams[i]->mmcState = MOS_MEMCOMP_MC;
595 m_picMhwParams.SurfaceParams[i]->mmcSkipMask = skipMask;
596 }
597
598 for (uint8_t i = 1; i < 4; i++)
599 {
600 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSurfaceCmd(
601 cmdBuffer,
602 m_picMhwParams.SurfaceParams[i]));
603 }
604 }
605
606 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeBufAddrCmd(
607 cmdBuffer,
608 m_picMhwParams.PipeBufAddrParams));
609
610 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpIndObjBaseAddrCmd(
611 cmdBuffer,
612 m_picMhwParams.IndObjBaseAddrParams));
613
614 if (m_cencBuf)
615 {
616 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCencBatchBuffer(cmdBuffer));
617 }
618 else
619 {
620 for (uint8_t i = 0; i < CODEC_VP9_MAX_SEGMENTS; i++)
621 {
622 // Error handling for illegal programming on segmentation fields @ KEY/INTRA_ONLY frames
623 PCODEC_VP9_SEG_PARAMS vp9SegData = &(m_picMhwParams.Vp9SegmentState->pVp9SegmentParams->SegData[i]);
624 if (vp9SegData->SegmentFlags.fields.SegmentReferenceEnabled &&
625 (!m_vp9PicParams->PicFlags.fields.frame_type || m_vp9PicParams->PicFlags.fields.intra_only))
626 {
627 vp9SegData->SegmentFlags.fields.SegmentReference = CODECHAL_DECODE_VP9_INTRA_FRAME;
628 }
629
630 m_picMhwParams.Vp9SegmentState->ucCurrentSegmentId = i;
631 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpVp9SegmentStateCmd(
632 cmdBuffer,
633 nullptr,
634 m_picMhwParams.Vp9SegmentState));
635
636 if (m_vp9PicParams->PicFlags.fields.segmentation_enabled == 0)
637 {
638 break;
639 }
640 }
641
642 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpVp9PicStateCmd(
643 cmdBuffer,
644 nullptr,
645 m_picMhwParams.Vp9PicState));
646
647 if (m_secureDecoder)
648 {
649 // Add secure decode command
650 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AddHcpSecureState(
651 cmdBuffer,
652 this));
653 }
654 }
655 return eStatus;
656 }
657
658 MOS_STATUS CodechalDecodeVp9G12::SetFrameStates()
659 {
660 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
661
662
663 #ifdef _DECODE_PROCESSING_SUPPORTED
664 if (m_decodeParams.m_procParams)
665 {
666 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateHistogramSurface());
667
668 ((DecodeProcessingParams *)m_decodeParams.m_procParams)->m_histogramSurface = m_histogramSurface;
669
670 if(m_decodeHistogram)
671 m_decodeHistogram->SetSrcHistogramSurface(m_histogramSurface);
672
673 }
674 #endif
675
676 CodechalDecodeVp9::SetFrameStates();
677
678 return eStatus;
679 }
680
681 MOS_STATUS CodechalDecodeVp9G12 :: DecodeStateLevel()
682 {
683 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
684
685 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
686 CODECHAL_DECODE_FUNCTION_ENTER;
687
688 CODECHAL_DECODE_CHK_NULL_RETURN(m_hwInterface->GetCpInterface());
689
690 if (m_secureDecoder && m_hcpDecPhase == CodechalHcpDecodePhaseInitialized)
691 {
692 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->Execute(this));
693 }
694
695 //HCP Decode Phase State Machine
696 DetermineDecodePhase();
697
698 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
699 {
700 //Switch GPU context when necessary
701 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SwitchGpuContext(m_scalabilityState));
702 }
703
704 MOS_COMMAND_BUFFER primCmdBuffer;
705 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
706
707 bool sendPrologWithFrameTracking;
708 CODECHAL_DECODE_CHK_STATUS_RETURN(DetermineSendProlgwithFrmTracking(&sendPrologWithFrameTracking));
709 if (sendPrologWithFrameTracking)
710 {
711 if (!CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
712 {
713 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
714 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
715 forceWakeupParams.bMFXPowerWellControl = false;
716 forceWakeupParams.bMFXPowerWellControlMask = true;
717 forceWakeupParams.bHEVCPowerWellControl = true;
718 forceWakeupParams.bHEVCPowerWellControlMask = true;
719 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
720 &primCmdBuffer,
721 &forceWakeupParams));
722 }
723 //Frame tracking functionality is called at the start of primary command buffer.
724 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
725 &primCmdBuffer, true));
726 }
727
728 PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
729 MOS_COMMAND_BUFFER scdryCmdBuffer;
730 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
731
732 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
733 {
734 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse_G12(
735 m_scalabilityState,
736 &scdryCmdBuffer,
737 &cmdBufferInUse));
738
739 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
740 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
741 forceWakeupParams.bMFXPowerWellControl = false;
742 forceWakeupParams.bMFXPowerWellControlMask = true;
743 forceWakeupParams.bHEVCPowerWellControl = true;
744 forceWakeupParams.bHEVCPowerWellControlMask = true;
745 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
746 cmdBufferInUse,
747 &forceWakeupParams));
748
749 if (cmdBufferInUse == &scdryCmdBuffer)
750 {
751 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(cmdBufferInUse, false));
752 }
753
754 HalOcaInterface::On1stLevelBBStart(scdryCmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
755
756 }
757 else
758 {
759 HalOcaInterface::On1stLevelBBStart(primCmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
760 }
761
762 auto pipeModeSelectParams =
763 static_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12>(m_picMhwParams.PipeModeSelectParams);
764 *pipeModeSelectParams = {};
765 auto pipeBufAddrParams =
766 static_cast<PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12>(m_picMhwParams.PipeBufAddrParams);
767 *pipeBufAddrParams = {};
768 CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicStateMhwParams());
769
770 bool secureDecodeStartStatusFlag = true;
771 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
772 {
773 // Put all SecureDecode/Start Status related cmd into FE VDBOX
774 secureDecodeStartStatusFlag = CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState);
775
776 CodecHalDecodeScalablity_DecPhaseToHwWorkMode_G12(
777 pipeModeSelectParams->MultiEngineMode,
778 pipeModeSelectParams->PipeWorkMode);
779
780 pipeBufAddrParams->presCABACSyntaxStreamOutBuffer =
781 m_scalabilityState->presCABACStreamOutBuffer;
782 pipeBufAddrParams->presIntraPredUpRightColStoreBuffer =
783 &m_scalabilityState->resIntraPredUpRightColStoreBuffer;
784 pipeBufAddrParams->presIntraPredLeftReconColStoreBuffer =
785 &m_scalabilityState->resIntraPredLeftReconColStoreBuffer;
786 }
787
788 if (secureDecodeStartStatusFlag)
789 {
790 CODECHAL_DECODE_CHK_STATUS_RETURN(UpdatePicStateBuffers(cmdBufferInUse));
791
792 if (m_statusQueryReportingEnabled)
793 {
794 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(
795 cmdBufferInUse));
796 }
797 else
798 {
799 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StartPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
800 }
801 }
802 else
803 {
804 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StartPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
805 }
806
807 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
808 {
809 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_FEBESync_G12(
810 m_scalabilityState,
811 cmdBufferInUse,
812 m_osInterface->phasedSubmission));
813 if (m_perfFEBETimingEnabled && CodecHalDecodeScalabilityIsLastCompletePhase(m_scalabilityState))
814 {
815 CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectStartCmd((void *)this, m_osInterface, m_miInterface, &scdryCmdBuffer));
816 }
817 }
818
819 if (CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState))
820 {
821 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddWatchdogTimerStartCmd(cmdBufferInUse));
822 }
823
824 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPicStateMhwCmds(
825 cmdBufferInUse));
826
827 if (CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState))
828 {
829 MHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 hcpTileCodingParam;
830 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_CalculateHcpTileCodingParams<MHW_VDBOX_HCP_TILE_CODING_PARAMS_G12>(
831 m_scalabilityState,
832 m_vp9PicParams,
833 &hcpTileCodingParam));
834 //insert 2 dummy VD_CONTROL_STATE packets with data=0 before every HCP_TILE_CODING
835 if (MEDIA_IS_WA(m_waTable, Wa_14010222001))
836 {
837 MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
838 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
839 for (int i = 0; i < 2; i++)
840 {
841 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBufferInUse, &vdCtrlParam));
842 }
843 }
844 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwVdboxHcpInterfaceG12*>(m_hcpInterface)->AddHcpTileCodingCmd(
845 cmdBufferInUse,
846 &hcpTileCodingParam));
847 }
848
849 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
850 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
851 {
852 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(m_scalabilityState, &scdryCmdBuffer));
853 }
854
855 return eStatus;
856 }
857
858 MOS_STATUS CodechalDecodeVp9G12 :: DecodePrimitiveLevel()
859 {
860 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
861 MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
862
863 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
864
865 CODECHAL_DECODE_FUNCTION_ENTER;
866
867 // Bitstream is incomplete, don't do any decoding work.
868 if (m_incompletePicture)
869 {
870 eStatus = MOS_STATUS_SUCCESS;
871 return eStatus;
872 }
873
874 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
875
876 CODECHAL_DECODE_CHK_COND_RETURN(
877 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
878 "ERROR - vdbox index exceed the maximum");
879
880 m_osInterface->pfnSetPerfTag(
881 m_osInterface,
882 (uint16_t)(((m_mode << 4) & 0xF0) | (m_perfType & 0xF)));
883 m_osInterface->pfnResetPerfBufferID(m_osInterface);
884
885 MOS_COMMAND_BUFFER primCmdBuffer;
886 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
887
888 PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
889 MOS_COMMAND_BUFFER scdryCmdBuffer;
890 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
891 {
892 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse_G12(
893 m_scalabilityState,
894 &scdryCmdBuffer,
895 &cmdBufferInUse));
896 CodecHalDecodeScalability_DecPhaseToSubmissionType_G12(m_scalabilityState,cmdBufferInUse);
897 }
898
899 // store CS ENGINE ID register
900 if (static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
901 {
902 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReadCSEngineIDReg_G12(
903 m_scalabilityState,
904 &m_decodeStatusBuf,
905 cmdBufferInUse));
906 }
907
908 //no slice level command for Huc based DRM and scalability decode BE phases
909 if (m_cencBuf == nullptr && !CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState))
910 {
911 MHW_VDBOX_HCP_BSD_PARAMS bsdParams;
912 MOS_ZeroMemory(&bsdParams, sizeof(bsdParams));
913 bsdParams.dwBsdDataLength =
914 m_vp9PicParams->BSBytesInBuffer - m_vp9PicParams->UncompressedHeaderLengthInBytes;
915 bsdParams.dwBsdDataStartOffset = m_vp9PicParams->UncompressedHeaderLengthInBytes;
916
917 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpBsdObjectCmd(
918 cmdBufferInUse,
919 &bsdParams));
920 }
921
922 // Send VD_CONTROL_STATE Memory Implict Flush
923 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
924 vdCtrlParam.memoryImplicitFlush = true;
925 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBufferInUse, &vdCtrlParam));
926
927 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) &&
928 CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState))
929 {
930 // Send VD_CONTROL_STATE HCP Pipe Unlock
931 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
932 vdCtrlParam.scalableModePipeUnlock = true;
933 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBufferInUse, &vdCtrlParam));
934 }
935
936 // Send VD Pipe Flush command for SKL+
937 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
938 MOS_ZeroMemory(&vdpipeFlushParams, sizeof(vdpipeFlushParams));
939 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
940 vdpipeFlushParams.Flags.bFlushHEVC = 1;
941 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
942 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
943 cmdBufferInUse,
944 &vdpipeFlushParams));
945
946 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
947 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
948 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
949 cmdBufferInUse,
950 &flushDwParams));
951
952 if (CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState))
953 {
954 if (m_scalabilityState->bIsEnableEndCurrentBatchBuffLevel)
955 {
956 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalablity_GetFEReportedCabacStreamoutBufferSize(
957 m_scalabilityState,
958 cmdBufferInUse));
959 }
960 else
961 {
962 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalablity_SetFECabacStreamoutOverflowStatus(
963 m_scalabilityState,
964 cmdBufferInUse));
965 }
966
967 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SignalFE2BESemaphore(
968 m_scalabilityState,
969 cmdBufferInUse));
970
971 if (m_perfFEBETimingEnabled)
972 {
973 CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectEndCmd((void *)this, m_osInterface, m_miInterface, &scdryCmdBuffer));
974 }
975 }
976
977 //Sync for decode completion in scalable mode
978 if (CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState))
979 {
980 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_BEsCompletionSync(
981 m_scalabilityState,
982 cmdBufferInUse));
983 }
984
985 //if scalable decode, BE0 finish means whole frame complete.
986 // Check if destination surface needs to be synchronized
987 bool syncDestSurface = true;
988 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
989 {
990 syncDestSurface = CodecHalDecodeScalabilityIsLastCompletePhase(m_scalabilityState);
991 }
992
993 MOS_SYNC_PARAMS syncParams;
994 if (syncDestSurface)
995 {
996 syncParams = g_cInitSyncParams;
997 syncParams.GpuContext = m_videoContext;
998 syncParams.presSyncResource = &m_destSurface.OsResource;
999 syncParams.bReadOnly = false;
1000 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1001 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1002
1003 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(
1004 m_osInterface,
1005 &syncParams));
1006 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(
1007 m_osInterface,
1008 &syncParams));
1009
1010 // Update the resource tag (s/w tag) for On-Demand Sync
1011 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1012
1013 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1014 if (m_osInterface->bTagResourceSync)
1015 {
1016 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
1017 cmdBufferInUse,
1018 &syncParams));
1019 }
1020
1021 if (m_statusQueryReportingEnabled)
1022 {
1023 CodechalDecodeStatusReport decodeStatusReport;
1024
1025 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
1026 decodeStatusReport.m_currDecodedPic = m_vp9PicParams->CurrPic;
1027 decodeStatusReport.m_currDeblockedPic = m_vp9PicParams->CurrPic;
1028 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
1029 decodeStatusReport.m_numMbsAffected = m_usFrameWidthAlignedMinBlk * m_usFrameHeightAlignedMinBlk;
1030 decodeStatusReport.m_currDecodedPicRes = m_vp9RefList[m_vp9PicParams->CurrPic.FrameIdx]->resRefPic;
1031
1032 #ifdef _DECODE_PROCESSING_SUPPORTED
1033 CODECHAL_DEBUG_TOOL(
1034 if (m_downsampledSurfaces && m_sfcState && m_sfcState->m_sfcOutputSurface) {
1035 m_downsampledSurfaces[m_vp9PicParams->CurrPic.FrameIdx].OsResource = m_sfcState->m_sfcOutputSurface->OsResource;
1036 decodeStatusReport.m_currSfcOutputPicRes = &m_downsampledSurfaces[m_vp9PicParams->CurrPic.FrameIdx].OsResource;
1037 })
1038 #endif
1039
1040 // VP9 plug-in/out was NOT fully enabled; this is just to make sure driver would not crash in CodecHal_DecodeEndFrame(),
1041 // which requires the value of DecodeStatusReport.presCurrDecodedPic
1042 CODECHAL_DEBUG_TOOL(
1043 decodeStatusReport.m_frameType = m_perfType;
1044 )
1045
1046 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
1047 decodeStatusReport,
1048 cmdBufferInUse));
1049 }
1050 else
1051 {
1052 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StopPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
1053 }
1054 }
1055 else
1056 {
1057 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StopPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
1058 }
1059
1060 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1061 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1062 cmdBufferInUse,
1063 &flushDwParams));
1064
1065 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1066 cmdBufferInUse,
1067 nullptr));
1068
1069 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
1070 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1071 {
1072 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(m_scalabilityState, &scdryCmdBuffer));
1073 }
1074
1075 CODECHAL_DEBUG_TOOL(
1076
1077 if (m_histogramDebug && m_histogramSurface) {
1078 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1079 &m_histogramSurface->OsResource,
1080 CodechalDbgAttr::attrSfcHistogram,
1081 "_DEC",
1082 256 * 4));
1083 }
1084
1085 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState)) {
1086 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_DbgDumpCmdBuffer_G12(
1087 this,
1088 m_scalabilityState,
1089 m_debugInterface,
1090 &primCmdBuffer));
1091 } else {
1092 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
1093 &primCmdBuffer,
1094 CODECHAL_NUM_MEDIA_STATES,
1095 "_DEC"));
1096 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
1097 // m_debugInterface,
1098 // &primCmdBuffer));
1099 }
1100
1101 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
1102
1103 bool syncCompleteFrame =
1104 (m_copyDataBufferInUse && !m_osInterface->bSimIsActive);
1105 if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1106 {
1107 syncCompleteFrame = syncCompleteFrame && CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState);
1108 }
1109
1110 MOS_SYNC_PARAMS copyDataSyncParams;
1111 if (syncCompleteFrame)
1112 {
1113 //Sync up complete frame
1114 copyDataSyncParams = g_cInitSyncParams;
1115 copyDataSyncParams.GpuContext = m_videoContextForWa;
1116 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1117
1118 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(
1119 m_osInterface,
1120 &copyDataSyncParams));
1121
1122 copyDataSyncParams = g_cInitSyncParams;
1123 copyDataSyncParams.GpuContext = m_videoContext;
1124 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1125
1126 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(
1127 m_osInterface,
1128 &copyDataSyncParams));
1129 }
1130
1131 bool submitCommand = true;
1132 if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1133 {
1134 submitCommand = CodecHalDecodeScalabilityIsToSubmitCmdBuffer_G12(m_scalabilityState);
1135 HalOcaInterface::On1stLevelBBEnd(scdryCmdBuffer, *m_osInterface);
1136 }
1137 else
1138 {
1139 HalOcaInterface::On1stLevelBBEnd(primCmdBuffer, *m_osInterface);
1140 }
1141
1142 if (submitCommand)
1143 {
1144 uint32_t renderingFlags = m_videoContextUsesNullHw;
1145
1146 //command buffer to submit is the primary cmd buffer.
1147 if ( MOS_VE_SUPPORTED(m_osInterface))
1148 {
1149 CODECHAL_DECODE_CHK_STATUS_RETURN(SetAndPopulateVEHintParams(&primCmdBuffer));
1150 }
1151
1152 if (m_osInterface->phasedSubmission
1153 && MOS_VE_SUPPORTED(m_osInterface)
1154 && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1155 {
1156 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
1157 m_osInterface,
1158 cmdBufferInUse,
1159 renderingFlags));
1160 }
1161 else
1162 {
1163 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
1164 m_osInterface,
1165 &primCmdBuffer,
1166 renderingFlags));
1167 }
1168 }
1169
1170 // Reset status report
1171 if (m_statusQueryReportingEnabled)
1172 {
1173 bool resetStatusReport = true;
1174
1175 //if scalable decode, reset status report at final BE phase.
1176 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1177 {
1178 resetStatusReport = CodecHalDecodeScalabilityIsFinalBEPhaseG12(m_scalabilityState);
1179 }
1180
1181 if (resetStatusReport)
1182 {
1183 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
1184 m_videoContextUsesNullHw));
1185 }
1186 }
1187
1188 #ifdef CODECHAL_HUC_KERNEL_DEBUG
1189 CODECHAL_DEBUG_TOOL(
1190 CODECHAL_DECODE_CHK_STATUS(m_debugInterface->DumpHucRegion(
1191 &resHucSharedBuffer,
1192 0,
1193 CODEC_VP9_PROB_MAX_NUM_ELEM,
1194 15,
1195 "",
1196 false,
1197 1,
1198 CodechalHucRegionDumpType::hucRegionDumpDefault));
1199 )
1200 #endif
1201 CODECHAL_DEBUG_TOOL(
1202 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1203 &m_resVp9SegmentIdBuffer,
1204 CodechalDbgAttr::attrSegId,
1205 "SegId",
1206 (m_allocatedWidthInSb * m_allocatedHeightInSb * CODECHAL_CACHELINE_SIZE)));
1207 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1208 &(m_resVp9ProbBuffer[m_frameCtxIdx]),
1209 CodechalDbgAttr::attrCoefProb,
1210 "PakHwCoeffProbs",
1211 CODEC_VP9_PROB_MAX_NUM_ELEM));)
1212
1213 // Needs to be re-set for Linux buffer re-use scenarios
1214 //pVp9State->pVp9RefList[pVp9PicParams->ucCurrPicIndex]->resRefPic =
1215 // pVp9State->sDestSurface.OsResource;
1216
1217 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
1218 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(
1219 m_osInterface,
1220 &syncParams));
1221
1222 #ifdef LINUX
1223 #ifdef _DECODE_PROCESSING_SUPPORTED
1224 CODECHAL_DEBUG_TOOL(
1225 if (m_sfcState->m_sfcOutputSurface)
1226 {
1227 MOS_SURFACE dstSurface;
1228 MOS_ZeroMemory(&dstSurface, sizeof(dstSurface));
1229 dstSurface.Format = Format_NV12;
1230 dstSurface.OsResource = m_sfcState->m_sfcOutputSurface->OsResource;
1231 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
1232 m_osInterface,
1233 &dstSurface));
1234
1235 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
1236 &dstSurface,
1237 CodechalDbgAttr::attrSfcOutputSurface,
1238 "SfcDstSurf"));
1239 }
1240 )
1241 #endif
1242 #endif
1243 return eStatus;
1244 }
1245
1246 MOS_STATUS CodechalDecodeVp9G12::InitMmcState()
1247 {
1248 m_mmc = MOS_New(CodechalMmcDecodeVp9G12, m_hwInterface, this);
1249 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
1250
1251 return MOS_STATUS_SUCCESS;
1252 }
1253
1254 MOS_STATUS CodechalDecodeVp9G12 :: AllocateStandard (
1255 CodechalSetting * settings)
1256 {
1257 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1258
1259 CODECHAL_DECODE_FUNCTION_ENTER;
1260
1261 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
1262
1263 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
1264
1265 m_width = settings->width;
1266 m_height = settings->height;
1267 if (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_8_BITS)
1268 m_vp9DepthIndicator = 0;
1269 if (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS)
1270 m_vp9DepthIndicator = 1;
1271 if (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_12_BITS)
1272 m_vp9DepthIndicator = 2;
1273 m_chromaFormatinProfile = settings->chromaFormat;
1274 #ifdef _DECODE_PROCESSING_SUPPORTED
1275 // Initialize SFC state
1276 m_sfcState = MOS_New(CodechalVp9SfcStateG12);
1277 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
1278 this,
1279 m_hwInterface,
1280 m_osInterface));
1281 #endif
1282 MHW_VDBOX_STATE_CMDSIZE_PARAMS_G12 stateCmdSizeParams;
1283 stateCmdSizeParams.bHucDummyStream = false;
1284 stateCmdSizeParams.bScalableMode = static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported();
1285 stateCmdSizeParams.bSfcInUse = true;
1286 //FE has more commands than BE. To finer control of the cmd buffer size
1287
1288 // Picture Level Commands
1289 m_hwInterface->GetHxxStateCommandSize(
1290 m_mode,
1291 &m_commandBufferSizeNeeded,
1292 &m_commandPatchListSizeNeeded,
1293 &stateCmdSizeParams);
1294
1295 // Primitive Level Commands
1296 m_hwInterface->GetHxxPrimitiveCommandSize(
1297 m_mode,
1298 &m_standardDecodeSizeNeeded,
1299 &m_standardDecodePatchListSizeNeeded,
1300 false);
1301
1302 if ( MOS_VE_SUPPORTED(m_osInterface))
1303 {
1304 if (static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
1305 {
1306 m_scalabilityState = (PCODECHAL_DECODE_SCALABILITY_STATE_G12)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SCALABILITY_STATE_G12));
1307 CODECHAL_DECODE_CHK_NULL_RETURN(m_scalabilityState);
1308 //scalability initialize
1309 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitializeState_G12(
1310 this,
1311 m_scalabilityState,
1312 m_hwInterface,
1313 false,
1314 settings));
1315 }
1316 else
1317 {
1318 //single pipe VE initialize
1319 m_sinlgePipeVeState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
1320 CODECHAL_DECODE_CHK_NULL_RETURN(m_sinlgePipeVeState);
1321 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_sinlgePipeVeState));
1322 }
1323 }
1324
1325 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVp9::AllocateResourcesFixedSizes());
1326
1327 // Prepare Pic Params
1328 m_picMhwParams.PipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12);
1329 m_picMhwParams.PipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12);
1330 m_picMhwParams.IndObjBaseAddrParams = MOS_New(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS);
1331 m_picMhwParams.Vp9PicState = MOS_New(MHW_VDBOX_VP9_PIC_STATE);
1332 m_picMhwParams.Vp9SegmentState = MOS_New(MHW_VDBOX_VP9_SEGMENT_STATE);
1333
1334 MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
1335 MOS_ZeroMemory(m_picMhwParams.Vp9PicState, sizeof(MHW_VDBOX_VP9_PIC_STATE));
1336 MOS_ZeroMemory(m_picMhwParams.Vp9SegmentState, sizeof(MHW_VDBOX_VP9_SEGMENT_STATE));
1337
1338 for (uint16_t i = 0; i < 4; i++)
1339 {
1340 m_picMhwParams.SurfaceParams[i] = MOS_New(MHW_VDBOX_SURFACE_PARAMS);
1341 MOS_ZeroMemory(m_picMhwParams.SurfaceParams[i], sizeof(MHW_VDBOX_SURFACE_PARAMS));
1342 }
1343
1344 return eStatus;
1345 }