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