1 /*
2 * Copyright (c) 2017-2021, 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_hevc_g12.cpp
24 //! \brief Implements the decode interface extension for HEVC.
25 //! \details Implements all functions required by CodecHal for HEVC decoding.
26 //!
27
28 #include "codechal_decoder.h"
29 #include "codechal_secure_decode_interface.h"
30 #include "codechal_decode_hevc_g12.h"
31 #include "codechal_decode_hevc_long_g12.h"
32 #include "codechal_decode_sfc_hevc_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 "mhw_mi_g12_X.h"
37 #include "codechal_mmc_decode_hevc_g12.h"
38 #include "codechal_hw_g12_X.h"
39 #include "codechal_decode_histogram.h"
40 #include "codechal_debug.h"
41 #include "hal_oca_interface.h"
42
43 //==<Functions>=======================================================
AllocateResourcesVariableSizes()44 MOS_STATUS CodechalDecodeHevcG12::AllocateResourcesVariableSizes ()
45 {
46 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
47
48 CODECHAL_DECODE_FUNCTION_ENTER;
49
50 uint8_t maxBitDepth = (m_is12BitHevc) ? 12: ((m_is10BitHevc) ? 10 : 8);
51 uint8_t chromaFormatPic = m_hevcPicParams->chroma_format_idc;
52 uint8_t chromaFormat = m_chromaFormatinProfile;
53 CODECHAL_DECODE_ASSERT(chromaFormat >= chromaFormatPic);
54
55 uint32_t widthMax = MOS_MAX(m_width, m_widthLastMaxAlloced);
56 uint32_t heightMax = MOS_MAX(m_height, m_heightLastMaxAlloced);
57 uint32_t frameSizeMax = MOS_MAX((m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize), m_frameSizeMaxAlloced);
58
59 uint32_t ctbLog2SizeYPic = m_hevcPicParams->log2_diff_max_min_luma_coding_block_size +
60 m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3;
61 uint32_t ctbLog2SizeY = MOS_MAX(ctbLog2SizeYPic, m_ctbLog2SizeYMax);
62
63 //for Scalability
64 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
65 {
66 MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam;
67 MOS_ZeroMemory(&reallocParam, sizeof(reallocParam));
68 reallocParam.ucMaxBitDepth = maxBitDepth;
69 reallocParam.ucChromaFormat = chromaFormat;
70 reallocParam.dwCtbLog2SizeY = ctbLog2SizeY;
71 reallocParam.dwCtbLog2SizeYMax = m_ctbLog2SizeYMax;
72 reallocParam.dwPicWidth = widthMax;
73 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
74 reallocParam.dwPicHeight = heightMax;
75 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
76 reallocParam.dwFrameSize = frameSizeMax;
77 reallocParam.dwFrameSizeAlloced = m_frameSizeMaxAlloced;
78
79 MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam;
80 MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
81 hcpBufSizeParam.ucMaxBitDepth = maxBitDepth;
82 hcpBufSizeParam.ucChromaFormat = chromaFormat;
83 hcpBufSizeParam.dwCtbLog2SizeY = ctbLog2SizeY;
84 hcpBufSizeParam.dwPicWidth = widthMax;
85 hcpBufSizeParam.dwPicHeight = heightMax;
86 hcpBufSizeParam.dwMaxFrameSize = frameSizeMax;
87
88 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateResources_VariableSizes_G12(
89 m_scalabilityState,
90 &hcpBufSizeParam,
91 &reallocParam));
92
93 m_frameSizeMaxAlloced = frameSizeMax;
94 }
95
96 if (CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams))
97 {
98 bool isNeedBiggerSize = (widthMax > m_widthLastMaxAlloced) || (heightMax > m_heightLastMaxAlloced);
99 bool isResourceNull = Mos_ResourceIsNull(&m_resRefBeforeLoopFilter.OsResource);
100 if (isNeedBiggerSize || isResourceNull)
101 {
102 if (!isResourceNull)
103 {
104 DestroySurface(&m_resRefBeforeLoopFilter);
105 }
106
107 // allocate an internal temporary buffer as reference which holds pixels before in-loop filter
108 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourceRefBefLoopFilter());
109 }
110 }
111
112 // Reallocate second level batch buffer if it is needed
113 if (!m_cencBuf)
114 {
115 uint32_t count, size;
116
117 if (m_isRealTile)
118 {
119 count = m_hevcPicParams->num_tile_columns_minus1 + 1;
120 size = m_standardDecodeSizeNeeded * (m_decodeParams.m_numSlices + 1 + m_hevcPicParams->num_tile_rows_minus1);
121 }
122 else if (m_isSeparateTileDecoding)
123 {
124 count = 1;
125 size = m_standardDecodeSizeNeeded * (m_decodeParams.m_numSlices
126 + (m_hevcPicParams->num_tile_rows_minus1 + 1) * (m_hevcPicParams->num_tile_columns_minus1 + 1));
127 }
128 else
129 {
130 count = 1;
131 size = m_standardDecodeSizeNeeded * m_decodeParams.m_numSlices;
132 }
133
134 if ((!Mos_ResourceIsNull(&m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].OsResource) &&
135 (size > (uint32_t)m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize)) ||
136 (count > m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].count))
137 {
138 Mhw_FreeBb(m_osInterface, &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex], nullptr);
139 }
140 if (Mos_ResourceIsNull(&m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].OsResource))
141 {
142 MOS_ZeroMemory(&m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex], sizeof(MHW_BATCH_BUFFER));
143 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
144 m_osInterface,
145 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex],
146 nullptr,
147 size,
148 count));
149 m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].bSecondLevel = true;
150 }
151 }
152
153 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::AllocateResourcesVariableSizes());
154
155 #ifdef _MMC_SUPPORTED
156 // To WA invalid aux data caused HW issue when MMC on
157 if (m_mmc && m_mmc->IsMmcEnabled() && MEDIA_IS_WA(m_waTable, Wa_1408785368) &&
158 !Mos_ResourceIsNull(&m_destSurface.OsResource) &&
159 m_destSurface.OsResource.bConvertedFromDDIResource)
160 {
161 if (m_secureDecoder && m_secureDecoder->IsAuxDataInvalid(&m_destSurface.OsResource))
162 {
163 // Not use CODECHAL_DECODE_CHK_STATUS_RETURN() here to avoid adding local variable
164 // Error can still be caught by CODECHAL_DECODE_CHK_STATUS_RETURN() in InitAuxSurface
165 eStatus = m_secureDecoder->InitAuxSurface(&m_destSurface.OsResource, false, true);
166 }
167 else
168 {
169 CODECHAL_DECODE_VERBOSEMESSAGE("Clear CCS by VE resolve before frame %d submission", m_frameNum);
170 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnDecompResource(m_osInterface, &m_destSurface.OsResource));
171 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext));
172 }
173 }
174 #endif
175
176 return eStatus;
177 }
178
AllocateResourceRefBefLoopFilter()179 MOS_STATUS CodechalDecodeHevcG12::AllocateResourceRefBefLoopFilter()
180 {
181 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
182
183 CODECHAL_DECODE_FUNCTION_ENTER;
184
185 if (!Mos_ResourceIsNull(&m_resRefBeforeLoopFilter.OsResource))
186 {
187 return MOS_STATUS_SUCCESS;
188 }
189
190 MOS_SURFACE surface;
191 MOS_ZeroMemory(&surface, sizeof(MOS_SURFACE));
192
193 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateSurface(
194 &surface,
195 m_destSurface.dwPitch,
196 m_destSurface.dwHeight,
197 "Reference before loop filter",
198 m_destSurface.Format,
199 m_destSurface.bCompressible),
200 "Failed to allocate reference before loop filter for IBC.");
201
202 m_resRefBeforeLoopFilter = surface;
203
204 return eStatus;
205 }
206
AllocateHistogramSurface()207 MOS_STATUS CodechalDecodeHevcG12::AllocateHistogramSurface()
208 {
209 MOS_ALLOC_GFXRES_PARAMS allocParams;
210
211 if (m_histogramSurface == nullptr)
212 {
213 m_histogramSurface = (MOS_SURFACE*)MOS_AllocAndZeroMemory(sizeof(MOS_SURFACE));
214 CODECHAL_DECODE_CHK_NULL_RETURN(m_histogramSurface);
215
216 MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
217 allocParams.Type = MOS_GFXRES_BUFFER;
218 allocParams.TileType = MOS_TILE_LINEAR;
219 allocParams.Format = Format_Buffer;
220 allocParams.dwBytes = 256 * 4;
221 allocParams.pBufName = "HistogramStreamOut";
222
223 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
224 m_osInterface,
225 &allocParams,
226 &m_histogramSurface->OsResource));
227
228 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
229 m_osInterface,
230 m_histogramSurface));
231 }
232
233 if(m_decodeHistogram)
234 m_decodeHistogram->SetSrcHistogramSurface(m_histogramSurface);
235
236 return MOS_STATUS_SUCCESS;
237 }
238
~CodechalDecodeHevcG12()239 CodechalDecodeHevcG12::~CodechalDecodeHevcG12 ()
240 {
241 CODECHAL_DECODE_FUNCTION_ENTER;
242
243 if (m_sinlgePipeVeState)
244 {
245 MOS_FreeMemAndSetNull(m_sinlgePipeVeState);
246 }
247 if (m_scalabilityState)
248 {
249 CodecHalDecodeScalability_Destroy_G12(m_scalabilityState);
250 MOS_FreeMemAndSetNull(m_scalabilityState);
251 }
252
253 if (!Mos_ResourceIsNull(&m_resRefBeforeLoopFilter.OsResource))
254 {
255 DestroySurface(&m_resRefBeforeLoopFilter);
256 }
257 for (uint32_t i = 0; i < CODEC_HEVC_NUM_SECOND_BB; i++)
258 {
259 if (!Mos_ResourceIsNull(&m_secondLevelBatchBuffer[i].OsResource))
260 {
261 Mhw_FreeBb(m_osInterface, &m_secondLevelBatchBuffer[i], nullptr);
262 }
263 }
264 //Note: virtual engine interface destroy is done in MOS layer
265 #if (_DEBUG || _RELEASE_INTERNAL)
266 // Report real tile frame count and virtual tile frame count
267 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
268
269 userFeatureWriteData.Value.i32Data = m_rtFrameCount;
270 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_ENABLE_HEVC_DECODE_RT_FRAME_COUNT_ID;
271 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
272
273 userFeatureWriteData.Value.i32Data = m_vtFrameCount;
274 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_ENABLE_HEVC_DECODE_VT_FRAME_COUNT_ID;
275 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
276
277 userFeatureWriteData.Value.i32Data = m_spFrameCount;
278 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_ENABLE_HEVC_DECODE_SP_FRAME_COUNT_ID;
279 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
280
281 #endif
282
283 if (m_histogramSurface)
284 {
285 if (!Mos_ResourceIsNull(&m_histogramSurface->OsResource))
286 {
287 m_osInterface->pfnFreeResource(
288 m_osInterface,
289 &m_histogramSurface->OsResource);
290 }
291 MOS_FreeMemory(m_histogramSurface);
292 m_histogramSurface = nullptr;
293 }
294
295 return;
296 }
297
CheckLCUSize()298 MOS_STATUS CodechalDecodeHevcG12::CheckLCUSize()
299 {
300 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
301
302 CODECHAL_DECODE_FUNCTION_ENTER;
303
304 uint16_t LCUSize = 1 << (m_hevcPicParams->log2_diff_max_min_luma_coding_block_size +
305 m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
306
307 if (m_width > CODECHAL_HEVC_MAX_DIM_FOR_MIN_LCU || m_height > CODECHAL_HEVC_MAX_DIM_FOR_MIN_LCU)
308 {
309 if (LCUSize == CODECHAL_HEVC_MIN_LCU)
310 {
311 CODECHAL_DECODE_ASSERTMESSAGE("Invalid LCU size.");
312 return MOS_STATUS_INVALID_PARAMETER;
313 }
314 }
315
316 return eStatus;
317 }
318
SetGpuCtxCreatOption(CodechalSetting * codecHalSetting)319 MOS_STATUS CodechalDecodeHevcG12::SetGpuCtxCreatOption(
320 CodechalSetting *codecHalSetting)
321 {
322 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
323
324 CODECHAL_DECODE_FUNCTION_ENTER;
325
326 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
327 {
328 CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
329 }
330 else
331 {
332 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
333 CODECHAL_DECODE_CHK_NULL_RETURN(m_gpuCtxCreatOpt);
334
335 if (static_cast<MhwVdboxMfxInterfaceG12 *>(m_mfxInterface)->IsScalabilitySupported())
336 {
337 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeScalability_ConstructParmsForGpuCtxCreation_g12(
338 m_scalabilityState,
339 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
340 codecHalSetting));
341
342 if (((PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt)->LRCACount == 2)
343 {
344 m_videoContext = MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface) ? MOS_GPU_CONTEXT_VIDEO5 : MOS_GPU_CONTEXT_VDBOX2_VIDEO;;
345
346 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
347 m_osInterface,
348 m_videoContext,
349 MOS_GPU_NODE_VIDEO,
350 m_gpuCtxCreatOpt));
351
352 MOS_GPUCTX_CREATOPTIONS createOption;
353 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
354 m_osInterface,
355 MOS_GPU_CONTEXT_VIDEO,
356 m_videoGpuNode,
357 &createOption));
358 }
359 else if (((PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt)->LRCACount == 3)
360 {
361 m_videoContext = MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface) ? MOS_GPU_CONTEXT_VIDEO7 : MOS_GPU_CONTEXT_VDBOX2_VIDEO2;
362
363 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
364 m_osInterface,
365 m_videoContext,
366 MOS_GPU_NODE_VIDEO,
367 m_gpuCtxCreatOpt));
368
369 MOS_GPUCTX_CREATOPTIONS createOption;
370 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
371 m_osInterface,
372 MOS_GPU_CONTEXT_VIDEO,
373 m_videoGpuNode,
374 &createOption));
375 }
376 else
377 {
378 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
379 }
380 }
381 else
382 {
383 bool sfcInUse = (codecHalSetting->sfcInUseHinted && codecHalSetting->downsamplingHinted
384 && (MEDIA_IS_SKU(m_skuTable, FtrSFCPipe) && !MEDIA_IS_SKU(m_skuTable, FtrDisableVDBox2SFC)));
385 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
386 m_sinlgePipeVeState,
387 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
388 sfcInUse));
389
390 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
391 }
392 }
393
394 return eStatus;
395 }
396
GetDmemBufferSize()397 uint32_t CodechalDecodeHevcG12::GetDmemBufferSize()
398 {
399 return MOS_ALIGN_CEIL(sizeof(HUC_HEVC_S2L_BSS_G12), CODECHAL_CACHELINE_SIZE);
400 }
401
SetHucDmemS2LPictureBss(PHUC_HEVC_S2L_PIC_BSS hucHevcS2LPicBss)402 MOS_STATUS CodechalDecodeHevcG12::SetHucDmemS2LPictureBss(
403 PHUC_HEVC_S2L_PIC_BSS hucHevcS2LPicBss)
404 {
405 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
406
407 CODECHAL_DECODE_FUNCTION_ENTER;
408
409 CODECHAL_DECODE_CHK_NULL_RETURN(hucHevcS2LPicBss);
410
411 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::SetHucDmemS2LPictureBss(hucHevcS2LPicBss));
412
413 if (m_hevcExtPicParams)
414 {
415 hucHevcS2LPicBss->high_precision_offsets_enabled_flag =
416 m_hevcExtPicParams->PicRangeExtensionFlags.fields.high_precision_offsets_enabled_flag;
417 hucHevcS2LPicBss->chroma_qp_offset_list_enabled_flag =
418 m_hevcExtPicParams->PicRangeExtensionFlags.fields.chroma_qp_offset_list_enabled_flag;
419 }
420 else
421 {
422 hucHevcS2LPicBss->high_precision_offsets_enabled_flag = 0;
423 hucHevcS2LPicBss->chroma_qp_offset_list_enabled_flag = 0;
424 }
425
426 PHUC_HEVC_S2L_PIC_BSS_G12 hucHevcS2LPicBssG12 = static_cast<PHUC_HEVC_S2L_PIC_BSS_G12>(hucHevcS2LPicBss);
427
428 hucHevcS2LPicBssG12->IsRealTileEnable = 0;
429 if (m_isRealTile)
430 {
431 hucHevcS2LPicBssG12->IsRealTileEnable = 1;
432 hucHevcS2LPicBssG12->BatchBufferSize = m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize;
433 hucHevcS2LPicBssG12->NumScalablePipes = m_scalabilityState->ucScalablePipeNum;
434 }
435 else if (CodecHalDecodeNeedsTileDecoding(m_hevcPicParams, m_hevcSccPicParams))
436 {
437 hucHevcS2LPicBssG12->NumScalablePipes = 1;
438 }
439
440 hucHevcS2LPicBssG12->IsSCCIBCMode = CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams);
441 hucHevcS2LPicBssG12->IsSCCPLTMode = CodecHalDecodeIsSCCPLTMode(m_hevcSccPicParams);
442 if (hucHevcS2LPicBssG12->IsSCCIBCMode)
443 {
444 uint8_t i = 0, k = 0;
445 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
446 {
447 if (hucHevcS2LPicBssG12->PicOrderCntValList[i] == hucHevcS2LPicBssG12->CurrPicOrderCntVal)
448 {
449 break;
450 }
451 }
452 for (k = 0; k < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; k++)
453 {
454 if (hucHevcS2LPicBssG12->RefPicSetLtCurr[k] == 0xFF)
455 {
456 hucHevcS2LPicBssG12->RefPicSetLtCurr[k] = i;
457 break;
458 }
459 }
460 }
461
462 if (hucHevcS2LPicBssG12->IsSCCPLTMode)
463 {
464 hucHevcS2LPicBssG12->PredictorPaletteSize = m_hevcSccPicParams->PredictorPaletteSize;
465 MOS_SecureMemcpy(hucHevcS2LPicBssG12->PredictorPaletteEntries,
466 sizeof(hucHevcS2LPicBssG12->PredictorPaletteEntries),
467 m_hevcSccPicParams->PredictorPaletteEntries,
468 sizeof(m_hevcSccPicParams->PredictorPaletteEntries));
469 }
470 else
471 {
472 hucHevcS2LPicBssG12->PredictorPaletteSize = 0;
473 MOS_ZeroMemory(hucHevcS2LPicBssG12->PredictorPaletteEntries, sizeof(hucHevcS2LPicBssG12->PredictorPaletteEntries));
474 }
475
476 if (m_hevcSccPicParams)
477 {
478 hucHevcS2LPicBssG12->UseSliceACTOffset = m_hevcSccPicParams->PicSCCExtensionFlags.fields.pps_slice_act_qp_offsets_present_flag;
479 hucHevcS2LPicBssG12->pps_act_y_qp_offset = m_hevcSccPicParams->pps_act_y_qp_offset_plus5 - 5;
480 hucHevcS2LPicBssG12->pps_act_cb_qp_offset = m_hevcSccPicParams->pps_act_cb_qp_offset_plus5 - 5;
481 hucHevcS2LPicBssG12->pps_act_cr_qp_offset = m_hevcSccPicParams->pps_act_cr_qp_offset_plus3 - 3;
482 hucHevcS2LPicBssG12->MVRControlIdc = m_hevcSccPicParams->PicSCCExtensionFlags.fields.motion_vector_resolution_control_idc;
483 }
484 else
485 {
486 hucHevcS2LPicBssG12->UseSliceACTOffset = 0;
487 hucHevcS2LPicBssG12->pps_act_y_qp_offset = 0;
488 hucHevcS2LPicBssG12->pps_act_cb_qp_offset = 0;
489 hucHevcS2LPicBssG12->pps_act_cr_qp_offset = 0;
490 hucHevcS2LPicBssG12->MVRControlIdc = 0;
491 }
492
493 return eStatus;
494 }
495
CalcDownsamplingParams(void * picParams,uint32_t * refSurfWidth,uint32_t * refSurfHeight,MOS_FORMAT * format,uint8_t * frameIdx)496 MOS_STATUS CodechalDecodeHevcG12::CalcDownsamplingParams(
497 void *picParams,
498 uint32_t *refSurfWidth,
499 uint32_t *refSurfHeight,
500 MOS_FORMAT *format,
501 uint8_t *frameIdx)
502 {
503 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
504
505 CODECHAL_DECODE_CHK_NULL_RETURN(picParams);
506 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfWidth);
507 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfHeight);
508 CODECHAL_DECODE_CHK_NULL_RETURN(format);
509 CODECHAL_DECODE_CHK_NULL_RETURN(frameIdx);
510
511 PCODEC_HEVC_PIC_PARAMS hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)picParams;
512
513 *refSurfWidth = 0;
514 *refSurfHeight = 0;
515 *format = Format_NV12;
516 *frameIdx = hevcPicParams->CurrPic.FrameIdx;
517
518 uint32_t widthInPix, heightInPix;
519
520 widthInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicWidthInMinCbsY);
521 heightInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicHeightInMinCbsY);
522
523 *refSurfWidth = MOS_ALIGN_CEIL(widthInPix, 64);
524 *refSurfHeight = MOS_ALIGN_CEIL(heightInPix, 64);
525
526 if (hevcPicParams->chroma_format_idc == HCP_CHROMA_FORMAT_YUV444)
527 {
528 if (hevcPicParams->bit_depth_luma_minus8 > 2 || hevcPicParams->bit_depth_chroma_minus8 > 2)
529 {
530 *format = Format_Y416;
531 }
532 else if (hevcPicParams->bit_depth_luma_minus8 > 0 || hevcPicParams->bit_depth_chroma_minus8 > 0)
533 {
534 *format = Format_Y410;
535 }
536 else
537 {
538 *format = Format_AYUV;
539 }
540 }
541 else if (hevcPicParams->chroma_format_idc == HCP_CHROMA_FORMAT_YUV422)
542 {
543 if (hevcPicParams->bit_depth_luma_minus8 > 2 || hevcPicParams->bit_depth_chroma_minus8 > 2)
544 {
545 *format = Format_Y216;
546 }
547 else if (hevcPicParams->bit_depth_luma_minus8 > 0 || hevcPicParams->bit_depth_chroma_minus8 > 0)
548 {
549 *format = Format_Y210;
550 }
551 else
552 {
553 *format = Format_YUY2;
554 }
555 }
556 else
557 {
558 if (hevcPicParams->bit_depth_luma_minus8 > 2 || hevcPicParams->bit_depth_chroma_minus8 > 2)
559 {
560 *format = Format_P016;
561 }
562 else if (hevcPicParams->bit_depth_luma_minus8 > 0 || hevcPicParams->bit_depth_chroma_minus8 > 0)
563 {
564 *format = Format_P010;
565 }
566 else
567 {
568 *format = Format_NV12;
569 }
570 }
571
572 return eStatus;
573 }
574
SetHucDmemParams(PMOS_RESOURCE dmemBuffer)575 MOS_STATUS CodechalDecodeHevcG12::SetHucDmemParams (
576 PMOS_RESOURCE dmemBuffer)
577 {
578 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
579
580 CODECHAL_DECODE_FUNCTION_ENTER;
581
582 CODECHAL_DECODE_CHK_NULL_RETURN(dmemBuffer);
583
584 CodechalResLock DmemLock(m_osInterface, dmemBuffer);
585
586 PHUC_HEVC_S2L_BSS_G12 hucHevcS2LBss = (PHUC_HEVC_S2L_BSS_G12)DmemLock.Lock(CodechalResLock::writeOnly);
587
588 CODECHAL_DECODE_CHK_NULL_RETURN(hucHevcS2LBss);
589 hucHevcS2LBss->PictureBss.reserve.reserve_0 = 0;
590 hucHevcS2LBss->PictureBss.reserve.reserve_1 = 0;
591 hucHevcS2LBss->PictureBss.reserve.reserve_2 = 0;
592 hucHevcS2LBss->PictureBss.reserve.reserve_3 = 0;
593
594 hucHevcS2LBss->ProductFamily = m_hucInterface->GetHucProductFamily();
595 hucHevcS2LBss->RevId = m_hwInterface->GetPlatform().usRevId;
596 hucHevcS2LBss->DummyRefIdxState =
597 MEDIA_IS_WA(m_waTable, WaDummyReference) && !m_osInterface->bSimIsActive;
598 hucHevcS2LBss->DummyVDControlState = MEDIA_IS_WA(m_waTable, Wa_14010222001);
599 hucHevcS2LBss->WaTileFlushScalability = MEDIA_IS_WA(m_waTable, Wa_2209620131);
600
601 CODECHAL_DECODE_CHK_STATUS_RETURN(SetHucDmemS2LPictureBss(&hucHevcS2LBss->PictureBss));
602 CODECHAL_DECODE_CHK_STATUS_RETURN(SetHucDmemS2LSliceBss(&hucHevcS2LBss->SliceBss[0]));
603
604 if (m_secureDecoder)
605 {
606 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetHevcHucDmemS2LBss(this, &hucHevcS2LBss->PictureBss, &hucHevcS2LBss->SliceBss[0]));
607 }
608
609 if (m_numSlices < CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6)
610 {
611 m_dmemTransferSize = (uint32_t)((uint8_t *)&(hucHevcS2LBss->SliceBss[m_numSlices]) - (uint8_t *)hucHevcS2LBss);
612 m_dmemTransferSize = MOS_ALIGN_CEIL(m_dmemTransferSize, CODECHAL_CACHELINE_SIZE);
613 }
614 else
615 {
616 m_dmemTransferSize = m_dmemBufferSize;
617 }
618
619 return eStatus;
620 }
621
InitializeDecodeMode()622 MOS_STATUS CodechalDecodeHevcG12 ::InitializeDecodeMode()
623 {
624 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
625
626 CODECHAL_DECODE_FUNCTION_ENTER;
627
628 if (MOS_VE_SUPPORTED(m_osInterface) && static_cast<MhwVdboxMfxInterfaceG12 *>(m_mfxInterface)->IsScalabilitySupported())
629 {
630 CODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 initParams;
631
632 MOS_ZeroMemory(&initParams, sizeof(initParams));
633 initParams.u32PicWidthInPixel = m_width;
634 initParams.u32PicHeightInPixel = m_height;
635 initParams.bIsTileEnabled = m_hevcPicParams->tiles_enabled_flag;
636 initParams.bHasSubsetParams = !!m_decodeParams.m_subsetParams;
637 initParams.format = m_decodeParams.m_destSurface->Format;
638 initParams.usingSecureDecode = (m_secureDecoder != nullptr);
639 if (m_decodeHistogram == nullptr)
640 {
641 initParams.usingHistogram = false;
642 #if (_DEBUG || _RELEASE_INTERNAL)
643 if (m_histogramDebug)
644 {
645 initParams.usingHistogram = true;
646 }
647 #endif
648 }
649 else
650 {
651 initParams.usingHistogram = true;
652 }
653 // Only support SCC real tile mode. SCC virtual tile scalability mode is disabled here
654 initParams.bIsSccDecoding = m_hevcSccPicParams != nullptr;
655 initParams.u8NumTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
656 initParams.u8NumTileRows = m_hevcPicParams->num_tile_rows_minus1 + 1;
657 initParams.gpuCtxInUse = GetVideoContext();
658
659 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitScalableParams_G12(
660 m_scalabilityState,
661 &initParams,
662 &m_decodePassNum));
663
664 if (MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
665 {
666 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeScalability_ChkGpuCtxReCreation(
667 m_scalabilityState,
668 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt));
669 SetVideoContext(m_scalabilityState->VideoContext);
670 }
671
672 m_isRealTile = CodecHalDecodeScalabilityIsRealTileMode(m_scalabilityState);
673 if (m_isRealTile)
674 {
675 m_isSeparateTileDecoding = false;
676 }
677
678 m_isVirtualTile = CodecHalDecodeScalabilityIsVirtualTileMode(m_scalabilityState);
679
680 #if (_DEBUG || _RELEASE_INTERNAL)
681 if (m_isRealTile)
682 {
683 m_rtFrameCount++;
684 }
685 else if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
686 {
687 m_vtFrameCount++;
688 }
689 else if (m_isSeparateTileDecoding)
690 {
691 m_spFrameCount++;
692 }
693 #endif
694 }
695
696 return eStatus;
697 }
698
SetFrameStates()699 MOS_STATUS CodechalDecodeHevcG12::SetFrameStates ()
700 {
701 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
702
703 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
704 CODECHAL_DECODE_FUNCTION_ENTER;
705
706 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_destSurface);
707 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_dataBuffer);
708
709 if (m_secureDecoder)
710 {
711 m_secureDecoder->EnableSampleGroupConstantIV();
712 }
713
714 m_frameIdx++;
715
716 // Check HuC_status2 Imem loaded bit, if 0,return error
717 // As driver doesn't know when can get reg value afer storing HuC_Status2 register,
718 // Check the reg value here at the beginning of next frame
719 // Check twice, first entry and second entry
720 if (m_shortFormatInUse && m_frameIdx < 3 && m_statusQueryReportingEnabled &&
721 (((m_decodeStatusBuf.m_decodeStatus->m_hucErrorStatus2 >> 32) & m_hucInterface->GetHucStatus2ImemLoadedMask()) == 0))
722 {
723 if (!m_reportHucStatus)
724 {
725 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
726 MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
727 userFeatureWriteData.Value.i32Data = true;
728 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_HUC_LOAD_STATUS_ID;
729 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
730 m_reportHucStatus = true;
731 }
732
733 CODECHAL_DECODE_ASSERTMESSAGE("HuC IMEM Loaded fails");
734 MT_ERR1(MT_DEC_HEVC, MT_DEC_HUC_ERROR_STATUS2, (m_decodeStatusBuf.m_decodeStatus->m_hucErrorStatus2 >> 32));
735 return MOS_STATUS_UNKNOWN;
736 }
737
738 m_cencBuf = m_decodeParams.m_cencBuf;
739
740 if (IsFirstExecuteCall()) // For DRC Multiple Execution Call, no need to update every value in pHevcState except first execute
741 {
742 m_dataSize = m_decodeParams.m_dataSize;
743 m_dataOffset = m_decodeParams.m_dataOffset;
744 m_numSlices = m_decodeParams.m_numSlices;
745
746 if (m_numSlices > CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6)
747 {
748 CODECHAL_DECODE_ASSERTMESSAGE("Slice number doesn't support!");
749 return MOS_STATUS_INVALID_PARAMETER;
750 }
751
752 m_hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)m_decodeParams.m_picParams;
753 m_hevcExtPicParams = (PCODEC_HEVC_EXT_PIC_PARAMS)m_decodeParams.m_extPicParams;
754 m_hevcSccPicParams = (PCODEC_HEVC_SCC_PIC_PARAMS)m_decodeParams.m_advPicParams;
755 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_sliceParams);
756 m_hevcSliceParams = (PCODEC_HEVC_SLICE_PARAMS)m_decodeParams.m_sliceParams;
757 m_hevcExtSliceParams = (PCODEC_HEVC_EXT_SLICE_PARAMS)m_decodeParams.m_extSliceParams;
758 m_hevcSubsetParams = (PCODEC_HEVC_SUBSET_PARAMS)m_decodeParams.m_subsetParams;
759 m_hevcIqMatrixParams = (PCODECHAL_HEVC_IQ_MATRIX_PARAMS)m_decodeParams.m_iqMatrixBuffer;
760 m_destSurface = *(m_decodeParams.m_destSurface);
761 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
762 CODECHAL_DECODE_CHK_STATUS_RETURN(InitializeBitstreamCat());
763 }
764 else
765 {
766 m_dataSize = m_decodeParams.m_dataSize;
767 m_dataOffset = 0;
768 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
769 }
770
771 m_reportFrameCrc = true;
772
773 CODECHAL_DECODE_CHK_STATUS_RETURN(CheckAndCopyBitstream());
774
775 PCODEC_REF_LIST destEntry = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx];
776 MOS_ZeroMemory(destEntry, sizeof(CODEC_REF_LIST));
777
778 if (m_incompletePicture)
779 {
780 return MOS_STATUS_SUCCESS;
781 }
782
783 CODECHAL_DECODE_CHK_NULL_RETURN(m_hevcPicParams);
784 CODECHAL_DECODE_CHK_NULL_RETURN(m_hevcIqMatrixParams);
785
786 // sanity check to make sure no same reference exists
787 uint32_t m = 0, n = 0;
788 for (m = 0; m < CODEC_MAX_NUM_REF_FRAME_HEVC; m++)
789 {
790
791 int32_t poc = m_hevcPicParams->PicOrderCntValList[m];
792 for (n = m + 1; n < CODEC_MAX_NUM_REF_FRAME_HEVC; n++)
793 {
794 if (poc == m_hevcPicParams->PicOrderCntValList[n])
795 {
796 m_hevcPicParams->RefFrameList[n].PicFlags = PICTURE_INVALID;
797 }
798 }
799 }
800
801 // Calculate bCurPicIntra
802 m_curPicIntra = true;
803 if (m_hevcPicParams->IntraPicFlag == 0)
804 {
805 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
806 {
807 uint8_t frameIdx = m_hevcPicParams->RefPicSetStCurrBefore[i];
808 if (frameIdx < 15)
809 {
810 m_curPicIntra = false;
811 break;
812 }
813
814 frameIdx = m_hevcPicParams->RefPicSetStCurrAfter[i];
815 if (frameIdx < 15)
816 {
817 m_curPicIntra = false;
818 break;
819 }
820
821 frameIdx = m_hevcPicParams->RefPicSetLtCurr[i];
822 if (frameIdx < 15)
823 {
824 m_curPicIntra = false;
825 break;
826 }
827 }
828 }
829
830 if (!(CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams)))
831 {
832 uint8_t refCurrIndex = -1;
833 uint8_t refBeforeIndex = -1;
834 uint8_t refAfterIndex = -1;
835
836 for (int i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
837 {
838 uint8_t indexCurr = m_hevcPicParams->RefPicSetLtCurr[i];
839 uint8_t indexBefore = m_hevcPicParams->RefPicSetStCurrBefore[i];
840 uint8_t indexAfter = m_hevcPicParams->RefPicSetStCurrAfter[i];
841
842 if (indexCurr < CODEC_MAX_NUM_REF_FRAME_HEVC)
843 {
844 refCurrIndex = m_hevcPicParams->RefFrameList[indexCurr].FrameIdx;
845 }
846 if (indexBefore < CODEC_MAX_NUM_REF_FRAME_HEVC)
847 {
848 refBeforeIndex = m_hevcPicParams->RefFrameList[indexBefore].FrameIdx;
849 }
850 if (indexAfter < CODEC_MAX_NUM_REF_FRAME_HEVC)
851 {
852 refAfterIndex = m_hevcPicParams->RefFrameList[indexAfter].FrameIdx;
853 }
854
855 if ((refCurrIndex == m_hevcPicParams->CurrPic.FrameIdx) || (refBeforeIndex == m_hevcPicParams->CurrPic.FrameIdx) || (refAfterIndex == m_hevcPicParams->CurrPic.FrameIdx))
856 {
857 return MOS_STATUS_INVALID_PARAMETER;
858 }
859 }
860 }
861
862
863 m_twoVersionsOfCurrDecPicFlag = 0;
864 if (CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams))
865 {
866 m_curPicIntra = false;
867 m_twoVersionsOfCurrDecPicFlag = !m_hevcPicParams->pps_deblocking_filter_disabled_flag
868 || m_hevcPicParams->sample_adaptive_offset_enabled_flag
869 || m_hevcPicParams->deblocking_filter_override_enabled_flag;
870 #ifdef _MMC_SUPPORTED
871 if (m_mmc->IsMmcEnabled())
872 {
873 // Due to limitation, IBC reference has to be uncompressed, while recon surface is still compressed.
874 // Always need internal surface for IBC reference for MMC.
875 m_twoVersionsOfCurrDecPicFlag = true;
876 }
877 #endif
878 }
879
880 CODECHAL_DECODE_CHK_STATUS_RETURN(SetPictureStructs());
881
882 uint32_t i;
883 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
884 {
885 m_frameUsedAsCurRef[i] = false;
886 m_refIdxMapping[i] = -1;
887 }
888
889 // Calculate RefIdxMapping
890 for (i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
891 {
892 uint8_t frameIdx = m_hevcPicParams->RefPicSetStCurrBefore[i];
893 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
894 {
895 m_frameUsedAsCurRef[frameIdx] = true;
896 }
897
898 frameIdx = m_hevcPicParams->RefPicSetStCurrAfter[i];
899 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
900 {
901 m_frameUsedAsCurRef[frameIdx] = true;
902 }
903
904 frameIdx = m_hevcPicParams->RefPicSetLtCurr[i];
905 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
906 {
907 m_frameUsedAsCurRef[frameIdx] = true;
908 }
909 }
910
911 if (CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams))
912 {
913 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
914 {
915 if (!CodecHal_PictureIsInvalid(m_hevcPicParams->RefFrameList[i])
916 && m_hevcPicParams->PicOrderCntValList[i] == m_hevcPicParams->CurrPicOrderCntVal)
917 {
918 m_frameUsedAsCurRef[i] = true;
919 break;
920 }
921 }
922 }
923
924 uint8_t curRefIdx = 0;
925 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
926 {
927 if (m_frameUsedAsCurRef[i])
928 {
929 if (CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams))
930 {
931 if (m_hevcPicParams->PicOrderCntValList[i] == m_hevcPicParams->CurrPicOrderCntVal)
932 {
933 // pre-dbk reference id for IBC mode
934 m_IBCRefIdx = curRefIdx;
935 }
936 }
937 m_refIdxMapping[i] = curRefIdx++;
938 }
939 }
940
941 CODECHAL_DECODE_ASSERT(curRefIdx <= 8);
942
943 m_minCtbSize = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
944 m_width = m_hevcPicParams->PicWidthInMinCbsY * m_minCtbSize;
945 m_height = m_hevcPicParams->PicHeightInMinCbsY * m_minCtbSize;
946
947 m_ctbSize = 1 << (m_hevcPicParams->log2_diff_max_min_luma_coding_block_size +
948 m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
949
950 CODECHAL_DECODE_CHK_STATUS_RETURN(CheckLCUSize());
951
952 if (m_hcpInterface->IsRowStoreCachingSupported())
953 {
954 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams;
955 rowstoreParams.Mode = CODECHAL_DECODE_MODE_HEVCVLD;
956 rowstoreParams.dwPicWidth = m_width;
957 rowstoreParams.bMbaff = false;
958 rowstoreParams.ucBitDepthMinus8 = (uint8_t)MOS_MAX(m_hevcPicParams->bit_depth_luma_minus8, m_hevcPicParams->bit_depth_chroma_minus8);
959 rowstoreParams.ucChromaFormat = m_hevcPicParams->chroma_format_idc;
960 rowstoreParams.ucLCUSize = (uint8_t)m_ctbSize;
961 m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams);
962 }
963
964 // Calculate Tile info
965 if (m_hevcPicParams->tiles_enabled_flag)
966 {
967 CODECHAL_DECODE_CHK_STATUS_RETURN(GetAllTileInfo());
968 }
969
970 if (m_curPicIntra)
971 {
972 m_perfType = I_TYPE;
973 }
974 else
975 {
976 // Not possible to determine whether P or B is used for short format.
977 // For long format iterating through all of the slices to determine P vs
978 // B, so in order to avoid this, declare all other pictures MIXED_TYPE.
979 m_perfType = MIXED_TYPE;
980 }
981
982 m_crrPic = m_hevcPicParams->CurrPic;
983 m_secondField =
984 CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
985
986 if (m_pCodechalOcaDumper)
987 {
988 m_pCodechalOcaDumper->SetHevcDecodeParam(
989 m_hevcPicParams,
990 m_hevcExtPicParams,
991 m_hevcSccPicParams,
992 m_hevcSliceParams,
993 m_hevcExtSliceParams,
994 m_numSlices,
995 m_shortFormatInUse);
996 }
997
998 CODECHAL_DEBUG_TOOL(
999 m_debugInterface->m_currPic = m_crrPic;
1000 m_debugInterface->m_secondField = m_secondField;
1001 m_debugInterface->m_frameType = m_perfType;
1002
1003 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(
1004 m_hevcPicParams,
1005 m_hevcExtPicParams,
1006 m_hevcSccPicParams));
1007
1008 if (m_hevcIqMatrixParams) {
1009 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpIQParams(m_hevcIqMatrixParams));
1010 }
1011
1012 if (m_hevcSliceParams) {
1013 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpSliceParams(
1014 m_hevcSliceParams,
1015 m_hevcExtSliceParams,
1016 m_numSlices,
1017 m_shortFormatInUse));
1018 }
1019
1020 if(m_hevcSubsetParams) {
1021 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpSubsetsParams(m_hevcSubsetParams));
1022 })
1023
1024 // Clear DMEM buffer program flag
1025 if (m_shortFormatInUse)
1026 {
1027 m_dmemBufferProgrammed = false;
1028 m_dmemBufferIdx++;
1029 m_dmemBufferIdx %= CODECHAL_HEVC_NUM_DMEM_BUFFERS;
1030 }
1031
1032 m_isSeparateTileDecoding = CodecHalDecodeNeedsTileDecoding(m_hevcPicParams, m_hevcSccPicParams);
1033
1034 InitializeDecodeMode();
1035
1036 #ifdef _DECODE_PROCESSING_SUPPORTED
1037 if (m_decodeParams.m_procParams)
1038 {
1039 CodechalHevcSfcStateG12 *sfcStateG12 = static_cast<CodechalHevcSfcStateG12*>(m_sfcState);
1040
1041 CODECHAL_DECODE_CHK_NULL_RETURN(sfcStateG12);
1042
1043 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateHistogramSurface());
1044
1045 CODECHAL_DECODE_CHK_STATUS_RETURN(sfcStateG12->CheckAndInitialize(
1046 (DecodeProcessingParams *)m_decodeParams.m_procParams,
1047 m_hevcPicParams,
1048 m_scalabilityState,
1049 m_histogramSurface));
1050 }
1051 #endif
1052
1053 CODECHAL_DEBUG_TOOL(
1054 if (!m_incompletePicture && !IsFirstExecuteCall()) {
1055 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1056 &m_resCopyDataBuffer,
1057 CodechalDbgAttr::attrDecodeBitstream,
1058 "_DEC",
1059 m_estiBytesInBitstream,
1060 0,
1061 CODECHAL_NUM_MEDIA_STATES));
1062 })
1063
1064 m_secondLevelBatchBufferIndex++;
1065 m_secondLevelBatchBufferIndex %= CODEC_HEVC_NUM_SECOND_BB;
1066 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesVariableSizes());
1067
1068 if (m_twoVersionsOfCurrDecPicFlag)
1069 {
1070 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic = m_resRefBeforeLoopFilter.OsResource;
1071 }
1072 else
1073 {
1074 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
1075 }
1076
1077 m_hcpDecPhase = CodechalHcpDecodePhaseInitialized;
1078
1079 if (!m_shortFormatInUse&&!m_cencBuf)
1080 {
1081 CodechalResLock bbLock(m_osInterface, &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].OsResource);
1082 uint8_t *bbBase = (uint8_t*)bbLock.Lock(CodechalResLock::writeOnly);
1083 CODECHAL_DECODE_CHK_NULL_RETURN(bbBase);
1084
1085 HevcDecodeSliceLongG12 hevcLong(this, m_hcpInterface, m_miInterface);
1086
1087 CODECHAL_DECODE_CHK_STATUS_RETURN(hevcLong.ProcessSliceLong(bbBase, m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize));
1088 }
1089
1090 return eStatus;
1091 }
1092
1093 //!
1094 //! \brief Determine Decode Phase
1095 //! \details Determine decode phase in hevc decode
1096 //! \param N/A
1097 //! \return MOS_STATUS
1098 //! MOS_STATUS_SUCCESS if success, else fail reason
1099 //!
DetermineDecodePhase()1100 MOS_STATUS CodechalDecodeHevcG12::DetermineDecodePhase()
1101 {
1102 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1103
1104 CODECHAL_DECODE_FUNCTION_ENTER;
1105
1106 if (static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
1107 {
1108 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_DetermineDecodePhase_G12(
1109 m_scalabilityState,
1110 &m_hcpDecPhase));
1111 }
1112 else
1113 {
1114 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::DetermineDecodePhase());
1115 }
1116
1117 CODECHAL_DECODE_VERBOSEMESSAGE("Current Decode Phase: %d.", m_hcpDecPhase);
1118
1119 return eStatus;
1120 }
1121
SetAndPopulateVEHintParams(PMOS_COMMAND_BUFFER primCmdBuf)1122 MOS_STATUS CodechalDecodeHevcG12::SetAndPopulateVEHintParams(
1123 PMOS_COMMAND_BUFFER primCmdBuf)
1124 {
1125 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1126
1127 CODECHAL_DECODE_FUNCTION_ENTER;
1128
1129 if (static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
1130 {
1131 CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS scalSetParms;
1132 MOS_ZeroMemory(&scalSetParms, sizeof(CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS));
1133 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
1134 {
1135 scalSetParms.bNeedSyncWithPrevious = true;
1136 scalSetParms.bSameEngineAsLastSubmission = false;
1137 scalSetParms.bSFCInUse = false;
1138 }
1139 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SetHintParams_G12(m_scalabilityState, &scalSetParms));
1140 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_PopulateHintParams(m_scalabilityState, primCmdBuf));
1141 }
1142 else
1143 {
1144 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
1145 {
1146 MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
1147 MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
1148 vesetParams.bNeedSyncWithPrevious = true;
1149 vesetParams.bSameEngineAsLastSubmission = false;
1150 vesetParams.bSFCInUse = false;
1151 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_sinlgePipeVeState, &vesetParams));
1152 }
1153 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_PopulateHintParams(m_sinlgePipeVeState, primCmdBuf, true));
1154 }
1155
1156 return eStatus;
1157 }
1158
DetermineSendProlgwithFrmTracking(bool * sendPrologWithFrameTracking)1159 MOS_STATUS CodechalDecodeHevcG12::DetermineSendProlgwithFrmTracking(
1160 bool *sendPrologWithFrameTracking)
1161 {
1162 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1163
1164 CODECHAL_DECODE_FUNCTION_ENTER;
1165
1166 CODECHAL_DECODE_CHK_NULL_RETURN(sendPrologWithFrameTracking);
1167
1168 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1169 {
1170 if (CodecHalDecodeScalability1stPhaseofSubmission(m_scalabilityState) ||
1171 (CodecHalDecodeScalabilityIsFirstRealTilePhase(m_scalabilityState) && (m_scalabilityState->u8RtCurPipe == 0)))
1172 {
1173 *sendPrologWithFrameTracking = true;
1174 }
1175 }
1176 else
1177 {
1178 if (m_shortFormatInUse)
1179 {
1180 *sendPrologWithFrameTracking = m_enableSf2DmaSubmits ? true : false;
1181 }
1182 else
1183 {
1184 *sendPrologWithFrameTracking = true;
1185 }
1186 }
1187
1188 return eStatus;
1189 }
1190
RequestedSpaceSize(uint32_t requestedSize)1191 uint32_t CodechalDecodeHevcG12::RequestedSpaceSize(uint32_t requestedSize)
1192 {
1193 CODECHAL_DECODE_FUNCTION_ENTER;
1194
1195 if (m_scalabilityState && m_scalabilityState->bScalableDecodeMode)
1196 {
1197 //primary cmd buffer only including cmd buffer header .
1198 return COMMAND_BUFFER_RESERVED_SPACE * 2;
1199 }
1200 else
1201 {
1202 return requestedSize;
1203 }
1204 }
1205
CalcRequestedSpace(uint32_t & requestedSize,uint32_t & additionalSizeNeeded,uint32_t & requestedPatchListSize)1206 void CodechalDecodeHevcG12::CalcRequestedSpace(
1207 uint32_t &requestedSize,
1208 uint32_t &additionalSizeNeeded,
1209 uint32_t &requestedPatchListSize)
1210 {
1211 if (m_isRealTile)
1212 {
1213 if (m_cencBuf)
1214 {
1215 requestedSize = m_commandBufferSizeNeeded;
1216 requestedPatchListSize = m_commandPatchListSizeNeeded;
1217 additionalSizeNeeded = 0;
1218 }
1219 else
1220 {
1221 //Since G12, HCP primitive level buffers are in separate allocated 2nd level batch buffer. So only have state level size here
1222 requestedSize = m_HcpStateCmdBufferSizeNeeded * m_scalabilityState->u8RtPhaseNum + m_HucStateCmdBufferSizeNeeded +
1223 m_HucPrimitiveCmdBufferSizeNeeded + m_CpPrimitiveCmdBufferSizeNeeded * m_numSlices;
1224 //Patch list is still submit with primitive level buffers, so requestedPatchListSize still need to contain the primitive level size.
1225 requestedPatchListSize = m_HcpPatchListSizeNeeded * m_scalabilityState->u8RtPhaseNum + m_HucPatchListSizeNeeded +
1226 m_HucPrimitivePatchListSizeNeeded + m_CpPrimitivePatchListSizeNeeded * m_numSlices +
1227 (m_standardDecodePatchListSizeNeeded * (m_decodeParams.m_numSlices + 1 + m_hevcPicParams->num_tile_rows_minus1));
1228 additionalSizeNeeded = COMMAND_BUFFER_RESERVED_SPACE;
1229 }
1230 }
1231 else
1232 {
1233 if (m_cencBuf)
1234 {
1235 requestedSize = m_commandBufferSizeNeeded;
1236 requestedPatchListSize = m_commandPatchListSizeNeeded;
1237 additionalSizeNeeded = 0;
1238 }
1239 else
1240 {
1241 //Since G12, HCP primitive level buffers are in separate allocated 2nd level batch buffer. So only have state level size here.
1242 requestedSize = m_HcpStateCmdBufferSizeNeeded + m_HucStateCmdBufferSizeNeeded + m_HucPrimitiveCmdBufferSizeNeeded +
1243 m_CpPrimitiveCmdBufferSizeNeeded * m_numSlices;
1244
1245 //Patch list is still submit with primitive level buffers, so requestedPatchListSize still need to contain the primitive level size.
1246 requestedPatchListSize = m_HcpPatchListSizeNeeded + m_HucPatchListSizeNeeded + m_HucPrimitivePatchListSizeNeeded +
1247 m_CpPrimitivePatchListSizeNeeded * m_numSlices +
1248 (m_standardDecodePatchListSizeNeeded * (m_decodeParams.m_numSlices + 1));
1249
1250 additionalSizeNeeded = COMMAND_BUFFER_RESERVED_SPACE;
1251 }
1252 }
1253 }
1254
VerifyExtraSpace(uint32_t requestedSize,uint32_t additionalSizeNeeded)1255 MOS_STATUS CodechalDecodeHevcG12::VerifyExtraSpace(
1256 uint32_t requestedSize,
1257 uint32_t additionalSizeNeeded)
1258 {
1259 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1260
1261 CODECHAL_DECODE_FUNCTION_ENTER;
1262
1263 if (m_scalabilityState && m_scalabilityState->bScalableDecodeMode)
1264 {
1265 eStatus = MOS_STATUS_NO_SPACE;
1266
1267 // Try a maximum of 3 attempts to request the required sizes from OS
1268 // OS could reset the sizes if necessary, therefore, requires to re-verify
1269 for (auto i = 0; (i < 3) && (eStatus != MOS_STATUS_SUCCESS); i++)
1270 {
1271 // Verify secondary cmd buffer
1272 eStatus = (MOS_STATUS)m_osInterface->pfnVerifyCommandBufferSize(
1273 m_osInterface,
1274 requestedSize,
1275 MOS_VE_HAVE_SECONDARY_CMDBUFFER);
1276
1277 // Resize command buffer if not enough
1278 if (eStatus != MOS_STATUS_SUCCESS)
1279 {
1280 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResizeCommandBufferAndPatchList(
1281 m_osInterface,
1282 requestedSize + additionalSizeNeeded,
1283 0,
1284 MOS_VE_HAVE_SECONDARY_CMDBUFFER));
1285 // Set status to NO_SPACE to enter the commaned buffer size verification on next loop.
1286 eStatus = MOS_STATUS_NO_SPACE;
1287 }
1288 }
1289 }
1290
1291 return eStatus;
1292 }
1293
DecodeStateLevel()1294 MOS_STATUS CodechalDecodeHevcG12::DecodeStateLevel()
1295 {
1296 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1297
1298 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
1299 CODECHAL_DECODE_FUNCTION_ENTER;
1300
1301 if (m_secureDecoder && m_hcpDecPhase == CodechalHcpDecodePhaseInitialized)
1302 {
1303 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->Execute(this));
1304 }
1305
1306 //HCP Decode Phase State Machine
1307 CODECHAL_DECODE_CHK_STATUS_RETURN(DetermineDecodePhase());
1308
1309 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1310 {
1311 //Switch GPU context when necessary
1312 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SwitchGpuContext(m_scalabilityState));
1313 }
1314
1315 // Set HEVC Decode Phase, and execute it.
1316 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
1317 {
1318 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPictureS2L());
1319 }
1320 else
1321 {
1322 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPictureLongFormat());
1323 }
1324
1325 return eStatus;
1326 }
1327
SendPictureS2L()1328 MOS_STATUS CodechalDecodeHevcG12::SendPictureS2L()
1329 {
1330 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1331
1332 CODECHAL_DECODE_FUNCTION_ENTER;
1333
1334 if (m_enableSf2DmaSubmits)
1335 {
1336 m_osInterface->pfnSetPerfTag(
1337 m_osInterface,
1338 (uint16_t)(((CODECHAL_DECODE_MODE_HUC << 4) & 0xF0) | (m_perfType & 0xF)));
1339 }
1340
1341 MOS_COMMAND_BUFFER primCmdBuffer;
1342 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
1343
1344 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
1345 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
1346 forceWakeupParams.bMFXPowerWellControl = false;
1347 forceWakeupParams.bMFXPowerWellControlMask = true;
1348 forceWakeupParams.bHEVCPowerWellControl = true;
1349 forceWakeupParams.bHEVCPowerWellControlMask = true;
1350
1351 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
1352 &primCmdBuffer,
1353 &forceWakeupParams));
1354
1355 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1356 &primCmdBuffer, true));
1357
1358 PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
1359 MOS_COMMAND_BUFFER scdryCmdBuffer;
1360
1361 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1362 {
1363 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse_G12(
1364 m_scalabilityState,
1365 &scdryCmdBuffer,
1366 &cmdBufferInUse));
1367
1368 if (cmdBufferInUse == &scdryCmdBuffer)
1369 {
1370 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
1371 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
1372 forceWakeupParams.bMFXPowerWellControl = false;
1373 forceWakeupParams.bMFXPowerWellControlMask = true;
1374 forceWakeupParams.bHEVCPowerWellControl = true;
1375 forceWakeupParams.bHEVCPowerWellControlMask = true;
1376 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
1377 cmdBufferInUse,
1378 &forceWakeupParams));
1379
1380 //send prolog at the start of a secondary cmd buffer
1381 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(cmdBufferInUse, false));
1382 }
1383 }
1384
1385 if (CodecHalDecodeScalabilityIsVirtualTileMode(m_scalabilityState) && CodecHalDecodeScalability1stDecPhase(m_scalabilityState))
1386 {
1387 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitSemaMemResources(m_scalabilityState, cmdBufferInUse));
1388 }
1389
1390 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureS2LCmds(cmdBufferInUse));
1391
1392 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
1393
1394 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1395 {
1396 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(m_scalabilityState, &scdryCmdBuffer));
1397 }
1398
1399 return eStatus;
1400 }
1401
InitPicLongFormatMhwParams()1402 MOS_STATUS CodechalDecodeHevcG12::InitPicLongFormatMhwParams()
1403 {
1404 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1405
1406 CODECHAL_DECODE_FUNCTION_ENTER;
1407
1408 // Reset all pic Mhw Params
1409 auto pipeModeSelectParams =
1410 static_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12>(m_picMhwParams.PipeModeSelectParams);
1411 *pipeModeSelectParams = {};
1412 auto pipeBufAddrParams =
1413 static_cast<PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12>(m_picMhwParams.PipeBufAddrParams);
1414 *pipeBufAddrParams = {};
1415 auto hevcPicStateParams =
1416 static_cast<PMHW_VDBOX_HEVC_PIC_STATE_G12>(m_picMhwParams.HevcPicState);
1417 *hevcPicStateParams = {};
1418
1419 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::InitPicLongFormatMhwParams());
1420
1421 pipeModeSelectParams->bHEVCSeparateTileProgramming = m_isSeparateTileDecoding;
1422
1423 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1424 {
1425 CodecHalDecodeScalablity_DecPhaseToHwWorkMode_G12(
1426 pipeModeSelectParams->MultiEngineMode,
1427 pipeModeSelectParams->PipeWorkMode);
1428
1429 if (m_isRealTile)
1430 {
1431 CodecHalDecodeScalablity_SetPhaseIndicator(
1432 pipeModeSelectParams->ucPhaseIndicator);
1433 }
1434
1435 pipeBufAddrParams->presSliceStateStreamOutBuffer =
1436 &m_scalabilityState->resSliceStateStreamOutBuffer;
1437 pipeBufAddrParams->presMvUpRightColStoreBuffer =
1438 &m_scalabilityState->resMvUpRightColStoreBuffer;
1439 pipeBufAddrParams->presIntraPredUpRightColStoreBuffer =
1440 &m_scalabilityState->resIntraPredUpRightColStoreBuffer;
1441 pipeBufAddrParams->presIntraPredLeftReconColStoreBuffer =
1442 &m_scalabilityState->resIntraPredLeftReconColStoreBuffer;
1443 pipeBufAddrParams->presCABACSyntaxStreamOutBuffer =
1444 m_scalabilityState->presCABACStreamOutBuffer;
1445 }
1446
1447 hevcPicStateParams->pHevcExtPicParams = m_hevcExtPicParams;
1448 hevcPicStateParams->pHevcSccPicParams = m_hevcSccPicParams;
1449
1450 hevcPicStateParams->ucRecNotFilteredID = CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams) ? m_IBCRefIdx : 0;
1451
1452 return eStatus;
1453 }
1454
AddPictureLongFormatCmds(PMOS_COMMAND_BUFFER cmdBufferInUse,PIC_LONG_FORMAT_MHW_PARAMS * picMhwParams)1455 MOS_STATUS CodechalDecodeHevcG12::AddPictureLongFormatCmds(
1456 PMOS_COMMAND_BUFFER cmdBufferInUse,
1457 PIC_LONG_FORMAT_MHW_PARAMS *picMhwParams)
1458 {
1459 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1460 MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
1461
1462 CODECHAL_DECODE_FUNCTION_ENTER;
1463
1464 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBufferInUse);
1465 CODECHAL_DECODE_CHK_NULL_RETURN(picMhwParams);
1466
1467 // Send VD_CONTROL_STATE Pipe Initialization
1468 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
1469 vdCtrlParam.initialization = true;
1470 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12*>(m_miInterface)->AddMiVdControlStateCmd(cmdBufferInUse, &vdCtrlParam));
1471
1472 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(
1473 cmdBufferInUse,
1474 picMhwParams->PipeModeSelectParams));
1475
1476 if (CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState) ||
1477 m_isRealTile)
1478 {
1479 // Send VD_CONTROL_STATE HcpPipeLock
1480 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
1481 vdCtrlParam.scalableModePipeLock = true;
1482 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBufferInUse, &vdCtrlParam));
1483 }
1484
1485 #ifdef _DECODE_PROCESSING_SUPPORTED
1486 if (!CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState))
1487 {
1488 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->AddSfcCommands(cmdBufferInUse));
1489 }
1490 #endif
1491
1492 #ifdef _MMC_SUPPORTED
1493 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceState(picMhwParams->SurfaceParams));
1494 #endif
1495
1496 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSurfaceCmd(
1497 cmdBufferInUse,
1498 picMhwParams->SurfaceParams));
1499
1500 // Let ref always use the same state (including MMC) as decode
1501 picMhwParams->SurfaceParams->ucSurfaceStateId = CODECHAL_HCP_REF_SURFACE_ID;
1502 #ifdef _MMC_SUPPORTED
1503 if (CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams))
1504 {
1505 uint8_t skipMask = 0;
1506 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1507 {
1508 if (picMhwParams->PipeBufAddrParams->presReferences[i] == m_presReferences[m_IBCRefIdx])
1509 {
1510 skipMask |= (1 << i);
1511 }
1512 }
1513 picMhwParams->SurfaceParams->mmcSkipMask = skipMask;
1514 CODECHAL_DECODE_NORMALMESSAGE("IBC ref index %d, MMC skip mask %d,", m_IBCRefIdx, skipMask);
1515 }
1516
1517 if (MEDIA_IS_WA(m_waTable, WaDummyReference))
1518 {
1519 uint8_t skipMask = 0;
1520 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1521 {
1522 if (m_dummyReferenceSlot[i])
1523 {
1524 skipMask |= (1 << i);
1525 }
1526 }
1527 picMhwParams->SurfaceParams->mmcSkipMask |= skipMask;
1528 }
1529 #endif
1530 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSurfaceCmd(
1531 cmdBufferInUse,
1532 picMhwParams->SurfaceParams));
1533
1534 if (CodecHalDecodeIsSCCIBCMode(m_hevcSccPicParams))
1535 {
1536 uint8_t refIdxMask = 0;
1537 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1538 {
1539 if (picMhwParams->PipeBufAddrParams->presReferences[i] == m_presReferences[m_IBCRefIdx])
1540 {
1541 refIdxMask |= (1 << i);
1542 }
1543 }
1544 picMhwParams->PipeBufAddrParams->IBCRefIdxMask = refIdxMask;
1545 }
1546
1547 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeBufAddrCmd(
1548 cmdBufferInUse,
1549 picMhwParams->PipeBufAddrParams));
1550
1551 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpIndObjBaseAddrCmd(
1552 cmdBufferInUse,
1553 picMhwParams->IndObjBaseAddrParams));
1554
1555 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpQmStateCmd(
1556 cmdBufferInUse,
1557 picMhwParams->QmParams));
1558 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPicStateCmd(
1559 cmdBufferInUse,
1560 picMhwParams->HevcPicState));
1561
1562 if (m_hevcPicParams->tiles_enabled_flag)
1563 {
1564 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpTileStateCmd(
1565 cmdBufferInUse,
1566 picMhwParams->HevcTileState));
1567 }
1568
1569 return eStatus;
1570 }
1571
SendPictureLongFormat()1572 MOS_STATUS CodechalDecodeHevcG12::SendPictureLongFormat()
1573 {
1574 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1575
1576 CODECHAL_DECODE_FUNCTION_ENTER;
1577
1578 if (m_enableSf2DmaSubmits)
1579 {
1580 m_osInterface->pfnSetPerfTag(
1581 m_osInterface,
1582 (uint16_t)(((CODECHAL_DECODE_MODE_HEVCVLD << 4) & 0xF0) | (m_perfType & 0xF)));
1583 }
1584
1585 MOS_COMMAND_BUFFER primCmdBuffer;
1586 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
1587
1588 bool sendPrologWithFrameTracking = false;
1589 CODECHAL_DECODE_CHK_STATUS_RETURN(DetermineSendProlgwithFrmTracking(&sendPrologWithFrameTracking));
1590
1591 if (sendPrologWithFrameTracking)
1592 {
1593 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
1594 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
1595 forceWakeupParams.bMFXPowerWellControl = false;
1596 forceWakeupParams.bMFXPowerWellControlMask = true;
1597 forceWakeupParams.bHEVCPowerWellControl = true;
1598 forceWakeupParams.bHEVCPowerWellControlMask = true;
1599 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
1600 &primCmdBuffer,
1601 &forceWakeupParams));
1602
1603 //Frame tracking functionality is called at the start of a command buffer.
1604 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1605 &primCmdBuffer, true));
1606 }
1607
1608 PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
1609 MOS_COMMAND_BUFFER scdryCmdBuffer;
1610 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
1611
1612 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1613 {
1614 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse_G12(
1615 m_scalabilityState,
1616 &scdryCmdBuffer,
1617 &cmdBufferInUse));
1618
1619 if ((!m_shortFormatInUse && !CodecHalDecodeScalabilityIsFESeparateSubmission(m_scalabilityState) &&
1620 !m_isRealTile) ||
1621 CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState) ||
1622 CodecHalDecodeScalabilityIsFirstRealTilePhase(m_scalabilityState) ||
1623 (m_secureDecoder != nullptr && m_osInterface->phasedSubmission))
1624 {
1625 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
1626 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
1627 forceWakeupParams.bMFXPowerWellControl = false;
1628 forceWakeupParams.bMFXPowerWellControlMask = true;
1629 forceWakeupParams.bHEVCPowerWellControl = true;
1630 forceWakeupParams.bHEVCPowerWellControlMask = true;
1631 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
1632 cmdBufferInUse,
1633 &forceWakeupParams));
1634
1635 //send prolog at the start of a secondary cmd buffer
1636 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(cmdBufferInUse, false));
1637 }
1638
1639 HalOcaInterface::On1stLevelBBStart(scdryCmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
1640 }
1641 else
1642 {
1643 HalOcaInterface::On1stLevelBBStart(primCmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
1644 }
1645
1646 CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicLongFormatMhwParams());
1647
1648 CODECHAL_DEBUG_TOOL(
1649 uint32_t activeReferenceNumber = 0;
1650 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1651 {
1652 if (m_frameUsedAsCurRef[i])
1653 {
1654 activeReferenceNumber++;
1655 }
1656 }
1657 for (uint32_t n = 0; n < activeReferenceNumber; n++)
1658 {
1659 if (m_picMhwParams.PipeBufAddrParams->presReferences[n])
1660 {
1661 MOS_SURFACE dstSurface;
1662
1663 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
1664 dstSurface.OsResource = *(m_picMhwParams.PipeBufAddrParams->presReferences[n]);
1665 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
1666 m_osInterface,
1667 &dstSurface));
1668
1669 std::string refSurfDumpName = "RefSurf[" + std::to_string(n) + "]";
1670 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
1671 &dstSurface,
1672 CodechalDbgAttr::attrDecodeReferenceSurfaces,
1673 refSurfDumpName.c_str()));
1674 }
1675
1676 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n])
1677 {
1678 m_debugInterface->m_refIndex = (uint16_t)n;
1679 // dump mvdata
1680 std::string mvBufDumpName = "_DEC_" + std::to_string(n);
1681 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1682 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n],
1683 CodechalDbgAttr::attrMvData,
1684 mvBufDumpName.c_str(),
1685 m_mvBufferSize));
1686 }
1687 }
1688 );
1689
1690 if (CodecHalDecodeScalabilityIsVirtualTileMode(m_scalabilityState) && CodecHalDecodeScalability1stDecPhase(m_scalabilityState))
1691 {
1692 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitSemaMemResources(m_scalabilityState, cmdBufferInUse));
1693 }
1694
1695 //Send status report Start
1696 if (m_statusQueryReportingEnabled)
1697 {
1698 bool sendStatusReportStart = true;
1699 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1700 {
1701 sendStatusReportStart = CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState) || m_scalabilityState->bIsRtMode;
1702 }
1703 if (sendStatusReportStart)
1704 {
1705 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(cmdBufferInUse));
1706 }
1707 else
1708 {
1709 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StartPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
1710 }
1711 }
1712 else
1713 {
1714 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StartPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
1715 }
1716
1717 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1718 {
1719 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_FEBESync_G12(
1720 m_scalabilityState,
1721 cmdBufferInUse,
1722 m_osInterface->phasedSubmission));
1723 if (m_perfFEBETimingEnabled && CodecHalDecodeScalabilityIsLastCompletePhase(m_scalabilityState))
1724 {
1725 CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectStartCmd((void *)this, m_osInterface, m_miInterface, &scdryCmdBuffer));
1726 }
1727 }
1728
1729 if (m_shortFormatInUse &&
1730 m_statusQueryReportingEnabled &&
1731 (!CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) ||
1732 CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState) ||
1733 CodecHalDecodeScalabilityIsRealTileMode(m_scalabilityState)))
1734 {
1735 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
1736 m_decodeStatusBuf.m_storeDataOffset +
1737 sizeof(uint32_t) * 2;
1738
1739 // Check HuC_STATUS bit15, HW continue if bit15 > 0, otherwise send COND BB END cmd.
1740 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<CodechalHwInterfaceG12 *>(m_hwInterface)->SendCondBbEndCmd(&m_decodeStatusBuf.m_statusBuffer, statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset, 0, false, false, mhw_mi_g12_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::COMPARE_OPERATION_MADGREATERTHANIDD, cmdBufferInUse));
1741 }
1742
1743 if (CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState) || CodecHalDecodeScalabilityIsFirstRealTilePhase(m_scalabilityState))
1744 {
1745 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddWatchdogTimerStartCmd(cmdBufferInUse));
1746 }
1747
1748 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureLongFormatCmds(cmdBufferInUse, &m_picMhwParams));
1749
1750 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
1751 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1752 {
1753 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(m_scalabilityState, &scdryCmdBuffer));
1754 }
1755
1756 return eStatus;
1757 }
1758
AddPipeEpilog(PMOS_COMMAND_BUFFER cmdBufferInUse,MOS_COMMAND_BUFFER & scdryCmdBuffer)1759 MOS_STATUS CodechalDecodeHevcG12::AddPipeEpilog(
1760 PMOS_COMMAND_BUFFER cmdBufferInUse,
1761 MOS_COMMAND_BUFFER &scdryCmdBuffer)
1762 {
1763 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1764
1765 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1766 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1767 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1768 cmdBufferInUse,
1769 &flushDwParams));
1770
1771 if (CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState))
1772 {
1773 if (m_scalabilityState->bIsEnableEndCurrentBatchBuffLevel)
1774 {
1775 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalablity_GetFEReportedCabacStreamoutBufferSize(
1776 m_scalabilityState,
1777 cmdBufferInUse));
1778 }
1779 else
1780 {
1781 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalablity_SetFECabacStreamoutOverflowStatus(
1782 m_scalabilityState,
1783 cmdBufferInUse));
1784 }
1785
1786 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SignalFE2BESemaphore(
1787 m_scalabilityState,
1788 cmdBufferInUse));
1789
1790 if (m_perfFEBETimingEnabled)
1791 {
1792 CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectEndCmd((void *)this, m_osInterface, m_miInterface, &scdryCmdBuffer));
1793 }
1794 }
1795
1796 //Sync for decode completion in scalable mode
1797 if (CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState))
1798 {
1799 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_BEsCompletionSync(
1800 m_scalabilityState,
1801 cmdBufferInUse));
1802 }
1803
1804 bool syncDestSurface = true;
1805 //if scalable decode, BE0 finish means whole frame complete.
1806 // Check if destination surface needs to be synchronized
1807 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1808 {
1809 syncDestSurface = CodecHalDecodeScalabilityIsLastCompletePhase(m_scalabilityState) ||
1810 CodecHalDecodeScalabilityIsLastRealTilePass(m_scalabilityState);
1811 }
1812
1813 if (syncDestSurface)
1814 {
1815 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
1816 syncParams.GpuContext = m_videoContext;
1817 syncParams.presSyncResource = &m_destSurface.OsResource;
1818 syncParams.bReadOnly = false;
1819 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1820 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1821
1822 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
1823 {
1824 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
1825 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
1826
1827 // Update the resource tag (s/w tag) for On-Demand Sync
1828 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1829 }
1830
1831 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1832 if (m_osInterface->bTagResourceSync)
1833 {
1834 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
1835 cmdBufferInUse,
1836 &syncParams));
1837 }
1838
1839 if (m_statusQueryReportingEnabled)
1840 {
1841 CodechalDecodeStatusReport decodeStatusReport;
1842 MOS_ZeroMemory(&decodeStatusReport, sizeof(decodeStatusReport));
1843
1844 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
1845 decodeStatusReport.m_currDecodedPic = m_hevcPicParams->CurrPic;
1846 decodeStatusReport.m_currDeblockedPic = m_hevcPicParams->CurrPic;
1847 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
1848 decodeStatusReport.m_currDecodedPicRes = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic;
1849
1850 #ifdef _DECODE_PROCESSING_SUPPORTED
1851 CODECHAL_DEBUG_TOOL(
1852 if (m_sfcState && m_sfcState->m_sfcOutputSurface) {
1853 if(m_downsampledSurfaces)
1854 {
1855 m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource = m_sfcState->m_sfcOutputSurface->OsResource;
1856 decodeStatusReport.m_currSfcOutputPicRes = &m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource;
1857 }
1858 else
1859 {
1860 decodeStatusReport.m_currSfcOutputPicRes = &(m_sfcState->m_sfcOutputSurface->OsResource);
1861 }
1862 })
1863 #endif
1864 CODECHAL_DEBUG_TOOL(
1865 decodeStatusReport.m_secondField = CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
1866 decodeStatusReport.m_frameType = m_perfType;);
1867
1868 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
1869 decodeStatusReport,
1870 cmdBufferInUse));
1871 }
1872 else
1873 {
1874 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StopPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
1875 }
1876 }
1877 else
1878 {
1879 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StopPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
1880 }
1881
1882 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1883 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1884 cmdBufferInUse,
1885 &flushDwParams));
1886
1887 if (!m_osInterface->pfnIsMismatchOrderProgrammingSupported())
1888 {
1889 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1890 cmdBufferInUse,
1891 nullptr));
1892 }
1893
1894 return eStatus;
1895 }
1896
SendShortSlices(PMOS_COMMAND_BUFFER cmdBuffer)1897 MOS_STATUS CodechalDecodeHevcG12::SendShortSlices(PMOS_COMMAND_BUFFER cmdBuffer)
1898 {
1899 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
1900
1901 MHW_VDBOX_HEVC_SLICE_STATE_G12 hevcSliceState;
1902 hevcSliceState.presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
1903
1904 auto slc = m_hevcSliceParams;
1905 for (uint16_t i = 0; i < m_numSlices; i++, slc++)
1906 {
1907 hevcSliceState.pHevcSliceParams = slc;
1908 hevcSliceState.dwLength = slc->slice_data_size;
1909 hevcSliceState.dwSliceIndex = i;
1910 hevcSliceState.bLastSlice = (i == (m_numSlices - 1));
1911
1912 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceS2L(cmdBuffer, &hevcSliceState));
1913 }
1914
1915 return MOS_STATUS_SUCCESS;
1916 }
1917
SendHucFlush(PMOS_COMMAND_BUFFER cmdBuffer,MOS_COMMAND_BUFFER & primCmdBuffer,MOS_COMMAND_BUFFER & scdryCmdBuffer,uint32_t renderingFlags)1918 MOS_STATUS CodechalDecodeHevcG12::SendHucFlush(PMOS_COMMAND_BUFFER cmdBuffer,
1919 MOS_COMMAND_BUFFER &primCmdBuffer,
1920 MOS_COMMAND_BUFFER &scdryCmdBuffer,
1921 uint32_t renderingFlags)
1922 {
1923 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1924
1925 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
1926
1927 CODECHAL_DECODE_CHK_COND_RETURN(
1928 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
1929 "ERROR - vdbox index exceed the maximum");
1930 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
1931
1932 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
1933 m_decodeStatusBuf.m_storeDataOffset +
1934 sizeof(uint32_t) * 2;
1935
1936 // Send VD Pipe Flush command for SKL+
1937 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
1938 MOS_ZeroMemory(&vdpipeFlushParams, sizeof(vdpipeFlushParams));
1939 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
1940 vdpipeFlushParams.Flags.bFlushHEVC = 1;
1941 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
1942 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
1943 cmdBuffer,
1944 &vdpipeFlushParams));
1945
1946 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1947 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1948 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1949 cmdBuffer,
1950 &flushDwParams));
1951
1952 if (m_statusQueryReportingEnabled)
1953 {
1954 // Check HuC_STATUS2 bit6, if bit6 > 0 HW continue execution following cmd, otherwise it send a COND BB END cmd.
1955 eStatus = static_cast<CodechalHwInterfaceG12*>(m_hwInterface)->SendCondBbEndCmd(
1956 &m_decodeStatusBuf.m_statusBuffer,
1957 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2MaskOffset,
1958 0,
1959 false,
1960 false,
1961 mhw_mi_g12_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::COMPARE_OPERATION_MADGREATERTHANIDD,
1962 cmdBuffer);
1963 CODECHAL_DECODE_CHK_STATUS_RETURN(eStatus);
1964
1965 // Write HUC_STATUS mask
1966 MHW_MI_STORE_DATA_PARAMS storeDataParams;
1967 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
1968 storeDataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
1969 storeDataParams.dwResourceOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset;
1970 storeDataParams.dwValue = m_hucInterface->GetHucStatusHevcS2lFailureMask();
1971 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
1972 cmdBuffer,
1973 &storeDataParams));
1974
1975 // store HUC_STATUS register
1976 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
1977 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
1978 storeRegParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
1979 storeRegParams.dwOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusRegOffset;
1980 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
1981 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
1982 cmdBuffer,
1983 &storeRegParams));
1984 }
1985
1986 if (m_enableSf2DmaSubmits)
1987 {
1988 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1989 cmdBuffer,
1990 nullptr));
1991 }
1992
1993 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
1994
1995 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
1996 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1997 {
1998 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(m_scalabilityState, &scdryCmdBuffer));
1999 }
2000
2001 if (m_enableSf2DmaSubmits)
2002 {
2003 CODECHAL_DEBUG_TOOL(
2004 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2005 cmdBuffer,
2006 CODECHAL_NUM_MEDIA_STATES,
2007 "_DEC"));
2008
2009 );
2010
2011 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
2012 m_osInterface,
2013 cmdBuffer,
2014 renderingFlags));
2015 }
2016
2017 return eStatus;
2018 }
2019
DecodePrimitiveLevel()2020 MOS_STATUS CodechalDecodeHevcG12::DecodePrimitiveLevel()
2021 {
2022 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2023 MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
2024
2025 CODECHAL_DECODE_FUNCTION_ENTER;
2026
2027 // Bitstream is incomplete, don't do any decoding work.
2028 if (m_incompletePicture)
2029 {
2030 return MOS_STATUS_SUCCESS;
2031 }
2032
2033 uint32_t renderingFlags = m_videoContextUsesNullHw;
2034
2035 MOS_COMMAND_BUFFER primCmdBuffer;
2036 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
2037
2038 PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
2039 MOS_COMMAND_BUFFER scdryCmdBuffer;
2040 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
2041 {
2042 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse_G12(
2043 m_scalabilityState,
2044 &scdryCmdBuffer,
2045 &cmdBufferInUse));
2046 CodecHalDecodeScalability_DecPhaseToSubmissionType_G12(m_scalabilityState,cmdBufferInUse);
2047 }
2048
2049 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
2050 {
2051 CODECHAL_DECODE_CHK_STATUS_RETURN(SendShortSlices(cmdBufferInUse));
2052 return SendHucFlush(cmdBufferInUse, primCmdBuffer, scdryCmdBuffer, renderingFlags);
2053 }
2054 else if (CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState))
2055 {
2056 MHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 hcpTileCodingParam;
2057 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_CalculateHcpTileCodingParams<MHW_VDBOX_HCP_TILE_CODING_PARAMS_G12>(
2058 m_scalabilityState,
2059 m_hevcPicParams,
2060 &hcpTileCodingParam));
2061 //insert 2 dummy VD_CONTROL_STATE packets with data=0 before every HCP_TILE_CODING
2062 if (MEDIA_IS_WA(m_waTable, Wa_14010222001))
2063 {
2064 MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
2065 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
2066 for (int i = 0; i < 2; i++)
2067 {
2068 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBufferInUse, &vdCtrlParam));
2069 }
2070 }
2071 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwVdboxHcpInterfaceG12*>(m_hcpInterface)->AddHcpTileCodingCmd(
2072 cmdBufferInUse,
2073 &hcpTileCodingParam));
2074 }
2075 else if (m_cencBuf)
2076 {
2077 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCencBatchBuffer(cmdBufferInUse));
2078 }
2079 else
2080 {
2081 if (m_isRealTile)
2082 {
2083 uint8_t col = 0;
2084 CodecHalDecodeScalability_GetCurrentRealTileColumnId(m_scalabilityState, col);
2085 CODECHAL_DECODE_ASSERT(col < m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].count);
2086 m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].dwOffset = col * m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize;
2087 }
2088 else
2089 {
2090 m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].dwOffset = 0;
2091 }
2092
2093 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
2094 cmdBufferInUse,
2095 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex]));
2096 }
2097
2098 // Send VD_CONTROL_STATE Memory Implict Flush
2099 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
2100 vdCtrlParam.memoryImplicitFlush = true;
2101 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBufferInUse, &vdCtrlParam));
2102
2103 if (CodecHalDecodeScalabilityIsBEPhaseG12(m_scalabilityState) ||
2104 m_isRealTile)
2105 {
2106 // Send VD_CONTROL_STATE HCP Pipe Unlock
2107 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
2108 vdCtrlParam.scalableModePipeUnlock = true;
2109 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(cmdBufferInUse, &vdCtrlParam));
2110 }
2111
2112 if (m_isRealTile)
2113 {
2114 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMfxWaitCmd(cmdBufferInUse, nullptr, true));
2115 }
2116
2117 // store CS ENGINE ID register
2118 if (static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
2119 {
2120 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReadCSEngineIDReg_G12(
2121 m_scalabilityState,
2122 &m_decodeStatusBuf,
2123 cmdBufferInUse));
2124 }
2125
2126 // Send VD Pipe Flush command for SKL+
2127 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
2128 MOS_ZeroMemory(&vdpipeFlushParams, sizeof(vdpipeFlushParams));
2129 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
2130 vdpipeFlushParams.Flags.bFlushHEVC = 1;
2131 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
2132 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
2133 cmdBufferInUse,
2134 &vdpipeFlushParams));
2135
2136 // Needs to be re-set for Linux buffer re-use scenarios
2137 if (CodecHalDecodeScalabilityIsLastRealTilePass(m_scalabilityState) || !CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
2138 {
2139 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic =
2140 m_destSurface.OsResource;
2141 }
2142
2143 if (!m_isRealTile ||
2144 CodecHalDecodeScalabilityIsLastRealTilePhase(m_scalabilityState))
2145 {
2146 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPipeEpilog(cmdBufferInUse, scdryCmdBuffer));
2147 }
2148 else
2149 {
2150 CODECHAL_DECODE_CHK_STATUS_RETURN(NullHW::StopPredicate(m_osInterface, m_miInterface, cmdBufferInUse));
2151 }
2152
2153 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
2154 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
2155 {
2156 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(m_scalabilityState, &scdryCmdBuffer));
2157 }
2158
2159 bool syncCompleteFrame = m_copyDataBufferInUse;
2160 if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
2161 {
2162 syncCompleteFrame = syncCompleteFrame && CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState);
2163 }
2164
2165 if (syncCompleteFrame)
2166 {
2167 //Sync up complete frame
2168 MOS_SYNC_PARAMS copyDataSyncParams = g_cInitSyncParams;
2169 copyDataSyncParams.GpuContext = m_videoContextForWa;
2170 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2171
2172 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, ©DataSyncParams));
2173
2174 copyDataSyncParams = g_cInitSyncParams;
2175 copyDataSyncParams.GpuContext = m_videoContext;
2176 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2177
2178 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, ©DataSyncParams));
2179 }
2180
2181 CODECHAL_DEBUG_TOOL(
2182 {
2183 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
2184 {
2185 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_DbgDumpCmdBuffer_G12(
2186 this,
2187 m_scalabilityState,
2188 m_debugInterface,
2189 &primCmdBuffer));
2190 }
2191 else
2192 {
2193 std::string packetName = "";
2194 if (m_shortFormatInUse)
2195 {
2196 packetName = "_S2L_DECODE_PASS0__0";
2197 }
2198 else
2199 {
2200 packetName = "_DEC";
2201 }
2202 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2203 &primCmdBuffer,
2204 CODECHAL_NUM_MEDIA_STATES,
2205 packetName.c_str()));
2206 }
2207 });
2208
2209 bool submitCommand = true;
2210 //submit command buffer
2211 if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
2212 {
2213 submitCommand = CodecHalDecodeScalabilityIsToSubmitCmdBuffer_G12(m_scalabilityState);
2214
2215 HalOcaInterface::DumpCodechalParam(scdryCmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, m_pCodechalOcaDumper, CODECHAL_HEVC);
2216 HalOcaInterface::On1stLevelBBEnd(scdryCmdBuffer, *m_osInterface);
2217 }
2218 else
2219 {
2220 HalOcaInterface::DumpCodechalParam(primCmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, m_pCodechalOcaDumper, CODECHAL_HEVC);
2221 HalOcaInterface::On1stLevelBBEnd(primCmdBuffer, *m_osInterface);
2222 }
2223
2224 if (submitCommand)
2225 {
2226 //command buffer to submit is the primary cmd buffer.
2227 if ( MOS_VE_SUPPORTED(m_osInterface))
2228 {
2229 CODECHAL_DECODE_CHK_STATUS_RETURN(SetAndPopulateVEHintParams(&primCmdBuffer));
2230 }
2231
2232 if(m_osInterface->phasedSubmission
2233 && MOS_VE_SUPPORTED(m_osInterface)
2234 && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
2235 {
2236 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, cmdBufferInUse, renderingFlags));
2237 }
2238 else
2239 {
2240 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &primCmdBuffer, renderingFlags));
2241 }
2242 }
2243
2244 // If S2L and 2nd pass, jump to 2nd level batch buffer
2245 if ((!Mos_ResourceIsNull(&m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].OsResource))
2246 && m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].dwOffset == 0)
2247 {
2248 #if (_DEBUG || _RELEASE_INTERNAL)
2249 m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iLastCurrent = m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize * m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].count;
2250 #endif
2251
2252 CODECHAL_DEBUG_TOOL(
2253 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
2254 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex],
2255 CODECHAL_NUM_MEDIA_STATES,
2256 "_DEC"));)
2257 }
2258
2259 CODECHAL_DEBUG_TOOL(
2260 m_mmc->UpdateUserFeatureKey(&m_destSurface);
2261
2262 if (m_histogramDebug && m_histogramSurface)
2263 {
2264 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
2265 &m_histogramSurface->OsResource,
2266 CodechalDbgAttr::attrSfcHistogram,
2267 "_DEC",
2268 256 * 4));
2269 })
2270
2271 // Reset status report
2272 if (m_statusQueryReportingEnabled)
2273 {
2274 bool resetStatusReport = true;
2275
2276 //if scalable decode, reset status report at final BE phase.
2277 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
2278 {
2279 resetStatusReport = CodecHalDecodeScalabilityIsFinalBEPhaseG12(m_scalabilityState);
2280 }
2281
2282 if (resetStatusReport)
2283 {
2284 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
2285 m_videoContextUsesNullHw));
2286 }
2287 }
2288
2289 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
2290 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
2291 {
2292 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
2293 syncParams.GpuContext = m_videoContext;
2294 syncParams.presSyncResource = &m_destSurface.OsResource;
2295
2296 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
2297 }
2298
2299 // Scalability real tile, move to next tile column
2300 if (m_isRealTile)
2301 {
2302 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AdvanceRealTilePass(m_scalabilityState));
2303 }
2304 return eStatus;
2305 }
2306
InitMmcState()2307 MOS_STATUS CodechalDecodeHevcG12::InitMmcState()
2308 {
2309 #ifdef _MMC_SUPPORTED
2310 m_mmc = MOS_New(CodechalMmcDecodeHevcG12, m_hwInterface, this);
2311 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
2312 #endif
2313 if (m_osInterface->pfnIsMismatchOrderProgrammingSupported())
2314 {
2315 m_mmc->SetMmcDisabled();
2316 }
2317
2318 return MOS_STATUS_SUCCESS;
2319 }
2320
AllocateStandard(CodechalSetting * settings)2321 MOS_STATUS CodechalDecodeHevcG12::AllocateStandard (
2322 CodechalSetting * settings)
2323 {
2324 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2325
2326 CODECHAL_DECODE_FUNCTION_ENTER;
2327
2328 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
2329
2330 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
2331
2332 m_width = settings->width;
2333 m_height = settings->height;
2334 m_is10BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS) ? true : false;
2335 m_is12BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_12_BITS) ? true : false;
2336 m_chromaFormatinProfile = settings->chromaFormat;
2337 m_shortFormatInUse = settings->shortFormatInUse;
2338
2339 #ifdef _DECODE_PROCESSING_SUPPORTED
2340 m_sfcState = MOS_New(CodechalHevcSfcStateG12);
2341 CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
2342 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
2343 this,
2344 m_hwInterface,
2345 m_osInterface));
2346 #endif
2347 MOS_ZeroMemory(&m_currPic, sizeof(m_currPic));
2348
2349 m_frameIdx = 0;
2350
2351 if (m_shortFormatInUse)
2352 {
2353 // Legacy SF has 2 passes, 1st pass is S2L, 2nd pass is HEVC Long decode
2354 // The pass number will be changed again if is scalable decode mode.
2355 m_decodePassNum = 2;
2356
2357 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
2358 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
2359 MOS_UserFeature_ReadValue_ID(
2360 nullptr,
2361 __MEDIA_USER_FEATURE_VALUE_HEVC_SF_2_DMA_SUBMITS_ENABLE_ID,
2362 &userFeatureData,
2363 m_osInterface->pOsContext);
2364 m_enableSf2DmaSubmits = userFeatureData.u32Data ? true : false;
2365 }
2366
2367 MHW_VDBOX_STATE_CMDSIZE_PARAMS_G12 stateCmdSizeParams;
2368 stateCmdSizeParams.bShortFormat = m_shortFormatInUse;
2369 stateCmdSizeParams.bHucDummyStream = (m_secureDecoder ? m_secureDecoder->IsDummyStreamEnabled() : false);
2370 stateCmdSizeParams.bScalableMode = static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported();
2371 stateCmdSizeParams.bSfcInUse = true;
2372
2373 // Picture Level Commands
2374 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxStateCommandSize(
2375 m_mode,
2376 &m_commandBufferSizeNeeded,
2377 &m_commandPatchListSizeNeeded,
2378 &stateCmdSizeParams));
2379
2380 // Primitive Level Commands
2381 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxPrimitiveCommandSize(
2382 m_mode,
2383 &m_standardDecodeSizeNeeded,
2384 &m_standardDecodePatchListSizeNeeded,
2385 m_shortFormatInUse));
2386
2387 //HCP Commands
2388 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHcpStateCommandSize(
2389 m_mode,
2390 &m_HcpStateCmdBufferSizeNeeded,
2391 &m_HcpPatchListSizeNeeded,
2392 &stateCmdSizeParams));
2393
2394 //Huc State Commands
2395 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHucStateCommandSize(
2396 m_mode,
2397 &m_HucStateCmdBufferSizeNeeded,
2398 &m_HucPatchListSizeNeeded,
2399 &stateCmdSizeParams));
2400
2401 //Huc Primitive Commands
2402 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHucPrimitiveCommandSize(
2403 m_mode,
2404 &m_HucPrimitiveCmdBufferSizeNeeded,
2405 &m_HucPrimitivePatchListSizeNeeded));
2406
2407 //CP Primitive Commands
2408 m_cpInterface->GetCpSliceLevelCmdSize(
2409 m_CpPrimitiveCmdBufferSizeNeeded,
2410 m_CpPrimitivePatchListSizeNeeded);
2411
2412 if ( MOS_VE_SUPPORTED(m_osInterface))
2413 {
2414 if (static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->IsScalabilitySupported())
2415 {
2416 m_scalabilityState = (PCODECHAL_DECODE_SCALABILITY_STATE_G12)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SCALABILITY_STATE_G12));
2417 CODECHAL_DECODE_CHK_NULL_RETURN(m_scalabilityState);
2418 //scalability initialize
2419 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitializeState_G12(
2420 this,
2421 m_scalabilityState,
2422 m_hwInterface,
2423 m_shortFormatInUse,
2424 settings));
2425 }
2426 else
2427 {
2428 //single pipe VE initialize
2429 m_sinlgePipeVeState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
2430 CODECHAL_DECODE_CHK_NULL_RETURN(m_sinlgePipeVeState);
2431 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_sinlgePipeVeState));
2432 }
2433 }
2434
2435 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::AllocateResourcesFixedSizes());
2436
2437 // Prepare Pic Params
2438 m_picMhwParams.PipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12);
2439 m_picMhwParams.SurfaceParams = MOS_New(MHW_VDBOX_SURFACE_PARAMS);
2440 m_picMhwParams.PipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12);
2441 m_picMhwParams.IndObjBaseAddrParams = MOS_New(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS);
2442 m_picMhwParams.QmParams = MOS_New(MHW_VDBOX_QM_PARAMS);
2443 m_picMhwParams.HevcPicState = MOS_New(MHW_VDBOX_HEVC_PIC_STATE_G12);
2444 m_picMhwParams.HevcTileState = MOS_New(MHW_VDBOX_HEVC_TILE_STATE);
2445
2446 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.PipeModeSelectParams);
2447 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.SurfaceParams);
2448 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.PipeBufAddrParams);
2449 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.IndObjBaseAddrParams);
2450 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.QmParams);
2451 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.HevcPicState);
2452 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.HevcTileState);
2453
2454 MOS_ZeroMemory(m_picMhwParams.SurfaceParams, sizeof(MHW_VDBOX_SURFACE_PARAMS));
2455 MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
2456 MOS_ZeroMemory(m_picMhwParams.QmParams, sizeof(MHW_VDBOX_QM_PARAMS));
2457 MOS_ZeroMemory(m_picMhwParams.HevcTileState, sizeof(MHW_VDBOX_HEVC_TILE_STATE));
2458
2459 return eStatus;
2460 }
2461
CodechalDecodeHevcG12(CodechalHwInterface * hwInterface,CodechalDebugInterface * debugInterface,PCODECHAL_STANDARD_INFO standardInfo)2462 CodechalDecodeHevcG12::CodechalDecodeHevcG12(
2463 CodechalHwInterface * hwInterface,
2464 CodechalDebugInterface *debugInterface,
2465 PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecodeHevc(hwInterface, debugInterface, standardInfo),
2466 m_hevcExtPicParams(nullptr),
2467 m_hevcExtSliceParams(nullptr),
2468 m_hevcSccPicParams(nullptr),
2469 m_hevcSubsetParams(nullptr),
2470 m_ctbSize(0),
2471 m_frameSizeMaxAlloced(0),
2472 m_twoVersionsOfCurrDecPicFlag(false),
2473 m_IBCRefIdx(0),
2474
2475 #if (_DEBUG || _RELEASE_INTERNAL)
2476 m_rtFrameCount(0),
2477 m_vtFrameCount(0),
2478 m_spFrameCount(0),
2479 #endif
2480 m_sinlgePipeVeState(nullptr),
2481 m_scalabilityState(nullptr)
2482 {
2483 CODECHAL_DECODE_FUNCTION_ENTER;
2484
2485 MOS_ZeroMemory(&m_resRefBeforeLoopFilter, sizeof(m_resRefBeforeLoopFilter));
2486
2487 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
2488
2489 m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
2490
2491 #if (_DEBUG || _RELEASE_INTERNAL)
2492 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
2493 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
2494 MOS_UserFeature_ReadValue_ID(
2495 nullptr,
2496 __MEDIA_USER_FEATURE_VALUE_DECODE_HISTOGRAM_DEBUG_ID,
2497 &userFeatureData,
2498 m_osInterface->pOsContext);
2499 m_histogramDebug = userFeatureData.u32Data ? true : false;
2500 #endif
2501 }
2502
2503 #if USE_CODECHAL_DEBUG_TOOL
DumpPicParams(PCODEC_HEVC_PIC_PARAMS picParams,PCODEC_HEVC_EXT_PIC_PARAMS extPicParams,PCODEC_HEVC_SCC_PIC_PARAMS sccPicParams)2504 MOS_STATUS CodechalDecodeHevcG12::DumpPicParams(
2505 PCODEC_HEVC_PIC_PARAMS picParams,
2506 PCODEC_HEVC_EXT_PIC_PARAMS extPicParams,
2507 PCODEC_HEVC_SCC_PIC_PARAMS sccPicParams)
2508 {
2509 CODECHAL_DEBUG_FUNCTION_ENTER;
2510
2511 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
2512 {
2513 return MOS_STATUS_SUCCESS;
2514 }
2515
2516 CODECHAL_DEBUG_CHK_NULL(picParams);
2517
2518 std::ostringstream oss;
2519 oss.setf(std::ios::showbase | std::ios::uppercase);
2520 oss.setf(std::ios::hex, std::ios::basefield);
2521
2522 oss << "PicWidthInMinCbsY: " << +picParams->PicWidthInMinCbsY << std::endl;
2523 oss << "PicHeightInMinCbsY: " << +picParams->PicHeightInMinCbsY << std::endl;
2524 //wFormatAndSequenceInfoFlags
2525 oss << "chroma_format_idc: " << +picParams->chroma_format_idc << std::endl;
2526 oss << "separate_colour_plane_flag: " << +picParams->separate_colour_plane_flag << std::endl;
2527 oss << "bit_depth_luma_minus8: " << +picParams->bit_depth_luma_minus8 << std::endl;
2528 oss << "bit_depth_chroma_minus8: " << +picParams->bit_depth_chroma_minus8 << std::endl;
2529 oss << "log2_max_pic_order_cnt_lsb_minus4: " << +picParams->log2_max_pic_order_cnt_lsb_minus4 << std::endl;
2530 oss << "NoPicReorderingFlag: " << +picParams->NoPicReorderingFlag << std::endl;
2531 oss << "ReservedBits1: " << +picParams->ReservedBits1 << std::endl;
2532 oss << "wFormatAndSequenceInfoFlags: " << +picParams->wFormatAndSequenceInfoFlags << std::endl;
2533 oss << "CurrPic FrameIdx: " << +picParams->CurrPic.FrameIdx << std::endl;
2534 oss << "CurrPic PicFlags: " << +picParams->CurrPic.PicFlags << std::endl;
2535 oss << "sps_max_dec_pic_buffering_minus1: " << +picParams->sps_max_dec_pic_buffering_minus1 << std::endl;
2536 oss << "log2_min_luma_coding_block_size_minus3: " << +picParams->log2_min_luma_coding_block_size_minus3 << std::endl;
2537 oss << "log2_diff_max_min_luma_coding_block_size: " << +picParams->log2_diff_max_min_luma_coding_block_size << std::endl;
2538 oss << "log2_min_transform_block_size_minus2: " << +picParams->log2_min_transform_block_size_minus2 << std::endl;
2539 oss << "log2_diff_max_min_transform_block_size: " << +picParams->log2_diff_max_min_transform_block_size << std::endl;
2540 oss << "max_transform_hierarchy_depth_intra: " << +picParams->max_transform_hierarchy_depth_intra << std::endl;
2541 oss << "max_transform_hierarchy_depth_inter: " << +picParams->max_transform_hierarchy_depth_inter << std::endl;
2542 oss << "num_short_term_ref_pic_sets: " << +picParams->num_short_term_ref_pic_sets << std::endl;
2543 oss << "num_long_term_ref_pic_sps: " << +picParams->num_long_term_ref_pic_sps << std::endl;
2544 oss << "num_ref_idx_l0_default_active_minus1: " << +picParams->num_ref_idx_l0_default_active_minus1 << std::endl;
2545 oss << "num_ref_idx_l1_default_active_minus1: " << +picParams->num_ref_idx_l1_default_active_minus1 << std::endl;
2546 oss << "init_qp_minus26: " << +picParams->init_qp_minus26 << std::endl;
2547 oss << "ucNumDeltaPocsOfRefRpsIdx: " << +picParams->ucNumDeltaPocsOfRefRpsIdx << std::endl;
2548 oss << "wNumBitsForShortTermRPSInSlice: " << +picParams->wNumBitsForShortTermRPSInSlice << std::endl;
2549 oss << "ReservedBits2: " << +picParams->ReservedBits2 << std::endl;
2550 //dwCodingParamToolFlags
2551 oss << "scaling_list_enabled_flag: " << +picParams->scaling_list_enabled_flag << std::endl;
2552 oss << "amp_enabled_flag: " << +picParams->amp_enabled_flag << std::endl;
2553 oss << "sample_adaptive_offset_enabled_flag: " << +picParams->sample_adaptive_offset_enabled_flag << std::endl;
2554 oss << "pcm_enabled_flag: " << +picParams->pcm_enabled_flag << std::endl;
2555 oss << "pcm_sample_bit_depth_luma_minus1: " << +picParams->pcm_sample_bit_depth_luma_minus1 << std::endl;
2556 oss << "pcm_sample_bit_depth_chroma_minus1: " << +picParams->pcm_sample_bit_depth_chroma_minus1 << std::endl;
2557 oss << "log2_min_pcm_luma_coding_block_size_minus3: " << +picParams->log2_min_pcm_luma_coding_block_size_minus3 << std::endl;
2558 oss << "log2_diff_max_min_pcm_luma_coding_block_size: " << +picParams->log2_diff_max_min_pcm_luma_coding_block_size << std::endl;
2559 oss << "pcm_loop_filter_disabled_flag: " << +picParams->pcm_loop_filter_disabled_flag << std::endl;
2560 oss << "long_term_ref_pics_present_flag: " << +picParams->long_term_ref_pics_present_flag << std::endl;
2561 oss << "sps_temporal_mvp_enabled_flag: " << +picParams->sps_temporal_mvp_enabled_flag << std::endl;
2562 oss << "strong_intra_smoothing_enabled_flag: " << +picParams->strong_intra_smoothing_enabled_flag << std::endl;
2563 oss << "dependent_slice_segments_enabled_flag: " << +picParams->dependent_slice_segments_enabled_flag << std::endl;
2564 oss << "output_flag_present_flag: " << +picParams->output_flag_present_flag << std::endl;
2565 oss << "num_extra_slice_header_bits: " << +picParams->num_extra_slice_header_bits << std::endl;
2566 oss << "sign_data_hiding_enabled_flag: " << +picParams->sign_data_hiding_enabled_flag << std::endl;
2567 oss << "cabac_init_present_flag: " << +picParams->cabac_init_present_flag << std::endl;
2568 oss << "ReservedBits3: " << +picParams->ReservedBits3 << std::endl;
2569 oss << "dwCodingParamToolFlags: " << +picParams->dwCodingParamToolFlags << std::endl;
2570 //dwCodingSettingPicturePropertyFlags
2571 oss << "constrained_intra_pred_flag: " << +picParams->constrained_intra_pred_flag << std::endl;
2572 oss << "transform_skip_enabled_flag: " << +picParams->transform_skip_enabled_flag << std::endl;
2573 oss << "cu_qp_delta_enabled_flag: " << +picParams->cu_qp_delta_enabled_flag << std::endl;
2574 oss << "diff_cu_qp_delta_depth: " << +picParams->diff_cu_qp_delta_depth << std::endl;
2575 oss << "pps_slice_chroma_qp_offsets_present_flag: " << +picParams->pps_slice_chroma_qp_offsets_present_flag << std::endl;
2576 oss << "weighted_pred_flag: " << +picParams->weighted_pred_flag << std::endl;
2577 oss << "weighted_bipred_flag: " << +picParams->weighted_bipred_flag << std::endl;
2578 oss << "transquant_bypass_enabled_flag: " << +picParams->transquant_bypass_enabled_flag << std::endl;
2579 oss << "tiles_enabled_flag: " << +picParams->tiles_enabled_flag << std::endl;
2580 oss << "entropy_coding_sync_enabled_flag: " << +picParams->entropy_coding_sync_enabled_flag << std::endl;
2581 oss << "uniform_spacing_flag: " << +picParams->uniform_spacing_flag << std::endl;
2582 oss << "loop_filter_across_tiles_enabled_flag: " << +picParams->loop_filter_across_tiles_enabled_flag << std::endl;
2583 oss << "pps_loop_filter_across_slices_enabled_flag: " << +picParams->pps_loop_filter_across_slices_enabled_flag << std::endl;
2584 oss << "deblocking_filter_override_enabled_flag: " << +picParams->deblocking_filter_override_enabled_flag << std::endl;
2585 oss << "pps_deblocking_filter_disabled_flag: " << +picParams->pps_deblocking_filter_disabled_flag << std::endl;
2586 oss << "lists_modification_present_flag: " << +picParams->lists_modification_present_flag << std::endl;
2587 oss << "slice_segment_header_extension_present_flag: " << +picParams->slice_segment_header_extension_present_flag << std::endl;
2588 oss << "IrapPicFlag: " << +picParams->IrapPicFlag << std::endl;
2589 oss << "IdrPicFlag: " << +picParams->IdrPicFlag << std::endl;
2590 oss << "IntraPicFlag: " << +picParams->IntraPicFlag << std::endl;
2591 oss << "ReservedBits4: " << +picParams->ReservedBits4 << std::endl;
2592 oss << "dwCodingSettingPicturePropertyFlags: " << +picParams->dwCodingSettingPicturePropertyFlags << std::endl;
2593 oss << "pps_cb_qp_offset: " << +picParams->pps_cb_qp_offset << std::endl;
2594 oss << "pps_cr_qp_offset: " << +picParams->pps_cr_qp_offset << std::endl;
2595 oss << "num_tile_columns_minus1: " << +picParams->num_tile_columns_minus1 << std::endl;
2596 oss << "num_tile_rows_minus1: " << +picParams->num_tile_rows_minus1 << std::endl;
2597 //Dump column width
2598 oss << "column_width_minus1[19]:";
2599 for (uint8_t i = 0; i < 19; i++)
2600 oss << picParams->column_width_minus1[i] << " ";
2601 oss << std::endl;
2602
2603 //Dump row height
2604 oss << "row_height_minus1[21]:";
2605 for (uint8_t i = 0; i < 21; i++)
2606 oss << picParams->row_height_minus1[i] << " ";
2607 oss << std::endl;
2608
2609 oss << "pps_beta_offset_div2: " << +picParams->pps_beta_offset_div2 << std::endl;
2610 oss << "pps_tc_offset_div2: " << +picParams->pps_tc_offset_div2 << std::endl;
2611 oss << "log2_parallel_merge_level_minus2: " << +picParams->log2_parallel_merge_level_minus2 << std::endl;
2612 oss << "CurrPicOrderCntVal: " << +picParams->CurrPicOrderCntVal << std::endl;
2613
2614 oss.setf(std::ios::dec, std::ios::basefield);
2615 //Dump RefFrameList[15]
2616 for (uint8_t i = 0; i < 15; ++i)
2617 {
2618 oss << "RefFrameList[" << +i << "].FrameIdx:" << +picParams->RefFrameList[i].FrameIdx << std::endl;
2619 oss << "RefFrameList[" << +i << "].PicFlags:" << +picParams->RefFrameList[i].PicFlags << std::endl;
2620 }
2621
2622 //Dump POC List
2623 oss << "PicOrderCntValList[15]:";
2624 for (uint8_t i = 0; i < 15; i++)
2625 oss << std::hex << picParams->PicOrderCntValList[i] << " ";
2626 oss << std::endl;
2627
2628 //Dump Ref RefPicSetStCurrBefore List
2629 oss << "RefPicSetStCurrBefore[8]:";
2630 for (uint8_t i = 0; i < 8; i++)
2631 oss << +picParams->RefPicSetStCurrBefore[i] << " ";
2632 oss << std::endl;
2633
2634 //Dump Ref RefPicSetStCurrAfter List
2635 oss << "RefPicSetStCurrAfter[16]:";
2636 for (uint8_t i = 0; i < 8; i++)
2637 oss << +picParams->RefPicSetStCurrAfter[i] << " ";
2638 oss << std::endl;
2639
2640 //Dump Ref PicSetStCurr List
2641 oss << "RefPicSetLtCurr[16]:";
2642 for (uint8_t i = 0; i < 8; i++)
2643 oss << +picParams->RefPicSetLtCurr[i] << " ";
2644 oss << std::endl;
2645
2646 //Dump Ref RefPicSetStCurrBefore List with POC
2647 oss << "POC of RefPicSetStCurrBefore[8]: ";
2648 for (uint8_t i = 0; i < 8; i++)
2649 oss << +picParams->PicOrderCntValList[picParams->RefPicSetStCurrBefore[i]%15] << " ";
2650 oss << std::endl;
2651
2652 //Dump Ref RefPicSetStCurrAfter List with POC
2653 oss << "POC of RefPicSetStCurrAfter[16]:";
2654 for (uint8_t i = 0; i < 8; i++)
2655 oss << +picParams->PicOrderCntValList[picParams->RefPicSetStCurrAfter[i]%15] << " ";
2656 oss << std::endl;
2657
2658 //Dump Ref PicSetStCurr List with POC
2659 oss << "POC of RefPicSetLtCurr[16]: ";
2660 for (uint8_t i = 0; i < 8; i++)
2661 oss << +picParams->PicOrderCntValList[picParams->RefPicSetLtCurr[i]%15] << " ";
2662 oss << std::endl;
2663
2664 oss << "RefFieldPicFlag: " << +picParams->RefFieldPicFlag << std::endl;
2665 oss << "RefBottomFieldFlag: " << +picParams->RefBottomFieldFlag << std::endl;
2666 oss << "StatusReportFeedbackNumber: " << +picParams->StatusReportFeedbackNumber << std::endl;
2667
2668 if (extPicParams)
2669 {
2670 //PicRangeExtensionFlags
2671 oss << "transform_skip_rotation_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.transform_skip_rotation_enabled_flag << std::endl;
2672 oss << "transform_skip_context_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.transform_skip_context_enabled_flag << std::endl;
2673 oss << "implicit_rdpcm_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.implicit_rdpcm_enabled_flag << std::endl;
2674 oss << "explicit_rdpcm_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.explicit_rdpcm_enabled_flag << std::endl;
2675 oss << "extended_precision_processing_flag: " << +extPicParams->PicRangeExtensionFlags.fields.extended_precision_processing_flag << std::endl;
2676 oss << "intra_smoothing_disabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.intra_smoothing_disabled_flag << std::endl;
2677 oss << "high_precision_offsets_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.high_precision_offsets_enabled_flag << std::endl;
2678 oss << "persistent_rice_adaptation_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.persistent_rice_adaptation_enabled_flag << std::endl;
2679 oss << "cabac_bypass_alignment_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.cabac_bypass_alignment_enabled_flag << std::endl;
2680 oss << "cross_component_prediction_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.cross_component_prediction_enabled_flag << std::endl;
2681 oss << "chroma_qp_offset_list_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.chroma_qp_offset_list_enabled_flag << std::endl;
2682 oss << "BitDepthLuma16: " << +extPicParams->PicRangeExtensionFlags.fields.BitDepthLuma16 << std::endl;
2683 oss << "BitDepthChroma16: " << +extPicParams->PicRangeExtensionFlags.fields.BitDepthChroma16 << std::endl;
2684 oss << "diff_cu_chroma_qp_offset_depth: " << +extPicParams->diff_cu_chroma_qp_offset_depth << std::endl;
2685 oss << "chroma_qp_offset_list_len_minus1: " << +extPicParams->chroma_qp_offset_list_len_minus1 << std::endl;
2686 oss << "log2_sao_offset_scale_luma: " << +extPicParams->log2_sao_offset_scale_luma << std::endl;
2687 oss << "log2_sao_offset_scale_chroma: " << +extPicParams->log2_sao_offset_scale_chroma << std::endl;
2688 oss << "log2_max_transform_skip_block_size_minus2: " << +extPicParams->log2_max_transform_skip_block_size_minus2 << std::endl;
2689
2690 //Dump cb_qp_offset_list[6]
2691 oss << "cb_qp_offset_list[6]: ";
2692 for (uint8_t i = 0; i < 6; i++)
2693 oss << +extPicParams->cb_qp_offset_list[i] << " ";
2694 oss << std::endl;
2695
2696 //Dump cr_qp_offset_list[6]
2697 oss << "cr_qp_offset_list[6]: ";
2698 for (uint8_t i = 0; i < 6; i++)
2699 oss << +extPicParams->cr_qp_offset_list[i] << " ";
2700 oss << std::endl;
2701
2702 //Dump scc pic parameters
2703 if(sccPicParams)
2704 {
2705 oss << "pps_curr_pic_ref_enabled_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.pps_curr_pic_ref_enabled_flag<< std::endl;
2706 oss << "palette_mode_enabled_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.palette_mode_enabled_flag << std::endl;
2707 oss << "motion_vector_resolution_control_idc: " << +sccPicParams->PicSCCExtensionFlags.fields.motion_vector_resolution_control_idc << std::endl;
2708 oss << "intra_boundary_filtering_disabled_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.intra_boundary_filtering_disabled_flag << std::endl;
2709 oss << "residual_adaptive_colour_transform_enabled_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.residual_adaptive_colour_transform_enabled_flag << std::endl;
2710 oss << "pps_slice_act_qp_offsets_present_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.pps_slice_act_qp_offsets_present_flag << std::endl;
2711 oss << "palette_max_size: " << +sccPicParams->palette_max_size << std::endl;
2712 oss << "delta_palette_max_predictor_size: " << +sccPicParams->delta_palette_max_predictor_size << std::endl;
2713 oss << "PredictorPaletteSize: " << +sccPicParams->PredictorPaletteSize << std::endl;
2714
2715 for(uint8_t i = 0; i < 128; i++)
2716 {
2717 oss << "PredictorPaletteEntries[0][" << +i << "]: " << +sccPicParams->PredictorPaletteEntries[0][i] << std::endl;
2718 oss << "PredictorPaletteEntries[1][" << +i << "]: " << +sccPicParams->PredictorPaletteEntries[1][i] << std::endl;
2719 oss << "PredictorPaletteEntries[2][" << +i << "]: " << +sccPicParams->PredictorPaletteEntries[2][i] << std::endl;
2720 }
2721
2722 oss << "pps_act_y_qp_offset_plus5: " << +sccPicParams->pps_act_y_qp_offset_plus5 << std::endl;
2723 oss << "pps_act_cb_qp_offset_plus5: " << +sccPicParams->pps_act_y_qp_offset_plus5 << std::endl;
2724 oss << "pps_act_cr_qp_offset_plus3: " << +sccPicParams->pps_act_y_qp_offset_plus5 << std::endl;
2725 }
2726 }
2727
2728 const char *fileName = m_debugInterface->CreateFileName(
2729 "_DEC",
2730 CodechalDbgBufferType::bufPicParams,
2731 CodechalDbgExtType::txt);
2732
2733 std::ofstream ofs(fileName, std::ios::out);
2734 ofs << oss.str();
2735 ofs.close();
2736
2737 return MOS_STATUS_SUCCESS;
2738 }
2739
DumpSliceParams(PCODEC_HEVC_SLICE_PARAMS sliceParams,PCODEC_HEVC_EXT_SLICE_PARAMS extSliceParams,uint32_t numSlices,bool shortFormatInUse)2740 MOS_STATUS CodechalDecodeHevcG12::DumpSliceParams(
2741 PCODEC_HEVC_SLICE_PARAMS sliceParams,
2742 PCODEC_HEVC_EXT_SLICE_PARAMS extSliceParams,
2743 uint32_t numSlices,
2744 bool shortFormatInUse)
2745 {
2746 CODECHAL_DEBUG_FUNCTION_ENTER;
2747 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
2748 {
2749 return MOS_STATUS_SUCCESS;
2750 }
2751
2752 CODECHAL_DEBUG_CHK_NULL(sliceParams);
2753
2754 PCODEC_HEVC_SLICE_PARAMS hevcSliceControl = nullptr;
2755 PCODEC_HEVC_EXT_SLICE_PARAMS hevcExtSliceControl = nullptr;
2756
2757 std::ostringstream oss;
2758 oss.setf(std::ios::showbase | std::ios::uppercase);
2759
2760 for (uint16_t j = 0; j < numSlices; j++)
2761 {
2762 hevcSliceControl = &sliceParams[j];
2763 if (extSliceParams)
2764 {
2765 hevcExtSliceControl = &extSliceParams[j];
2766 }
2767
2768 oss << "====================================================================================================" << std::endl;
2769 oss << "Data for Slice number = " << +j << std::endl;
2770 oss << "slice_data_size: " << +hevcSliceControl->slice_data_size << std::endl;
2771 oss << "slice_data_offset: " << +hevcSliceControl->slice_data_offset << std::endl;
2772
2773 if (!shortFormatInUse)
2774 {
2775 //Dump Long format specific
2776 oss << "ByteOffsetToSliceData: " << +hevcSliceControl->ByteOffsetToSliceData << std::endl;
2777 oss << "slice_segment_address: " << +hevcSliceControl->slice_segment_address << std::endl;
2778
2779 //Dump RefPicList[2][15]
2780 for (uint8_t i = 0; i < 15; ++i)
2781 {
2782 oss << "RefPicList[0][" << +i << "]";
2783 oss << ".FrameIdx: " << +hevcSliceControl->RefPicList[0][i].FrameIdx << std::endl;
2784 oss << "RefPicList[0][" << +i << "]";
2785 oss << ".PicFlags: " << +hevcSliceControl->RefPicList[0][i].PicFlags << std::endl;
2786 }
2787 for (uint8_t i = 0; i < 15; ++i)
2788 {
2789 oss << "RefPicList[1][" << +i << "]";
2790 oss << ".FrameIdx: " << +hevcSliceControl->RefPicList[1][i].FrameIdx << std::endl;
2791 oss << "RefPicList[1][" << +i << "]";
2792 oss << ".PicFlags: " << +hevcSliceControl->RefPicList[1][i].PicFlags << std::endl;
2793 }
2794
2795 oss << "last_slice_of_pic: " << +hevcSliceControl->LongSliceFlags.fields.LastSliceOfPic << std::endl;
2796 oss << "dependent_slice_segment_flag: " << +hevcSliceControl->LongSliceFlags.fields.dependent_slice_segment_flag << std::endl;
2797 oss << "slice_type: " << +hevcSliceControl->LongSliceFlags.fields.slice_type << std::endl;
2798 oss << "color_plane_id: " << +hevcSliceControl->LongSliceFlags.fields.color_plane_id << std::endl;
2799 oss << "slice_sao_luma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_luma_flag << std::endl;
2800 oss << "slice_sao_chroma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_chroma_flag << std::endl;
2801 oss << "mvd_l1_zero_flag: " << +hevcSliceControl->LongSliceFlags.fields.mvd_l1_zero_flag << std::endl;
2802 oss << "cabac_init_flag: " << +hevcSliceControl->LongSliceFlags.fields.cabac_init_flag << std::endl;
2803 oss << "slice_temporal_mvp_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag << std::endl;
2804 oss << "slice_deblocking_filter_disabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag << std::endl;
2805 oss << "collocated_from_l0_flag: " << +hevcSliceControl->LongSliceFlags.fields.collocated_from_l0_flag << std::endl;
2806 oss << "slice_loop_filter_across_slices_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag << std::endl;
2807 oss << "reserved: " << +hevcSliceControl->LongSliceFlags.fields.reserved << std::endl;
2808 oss << "collocated_ref_idx: " << +hevcSliceControl->collocated_ref_idx << std::endl;
2809 oss << "num_ref_idx_l0_active_minus1: " << +hevcSliceControl->num_ref_idx_l0_active_minus1 << std::endl;
2810 oss << "num_ref_idx_l1_active_minus1: " << +hevcSliceControl->num_ref_idx_l1_active_minus1 << std::endl;
2811 oss << "slice_qp_delta: " << +hevcSliceControl->slice_qp_delta << std::endl;
2812 oss << "slice_cb_qp_offset: " << +hevcSliceControl->slice_cb_qp_offset << std::endl;
2813 oss << "slice_cr_qp_offset: " << +hevcSliceControl->slice_cr_qp_offset << std::endl;
2814 oss << "slice_beta_offset_div2: " << +hevcSliceControl->slice_beta_offset_div2 << std::endl;
2815 oss << "slice_tc_offset_div2: " << +hevcSliceControl->slice_tc_offset_div2 << std::endl;
2816 oss << "luma_log2_weight_denom: " << +hevcSliceControl->luma_log2_weight_denom << std::endl;
2817 oss << "delta_chroma_log2_weight_denom: " << +hevcSliceControl->delta_chroma_log2_weight_denom << std::endl;
2818
2819 //Dump luma_offset[2][15]
2820 for (uint8_t i = 0; i < 15; i++)
2821 {
2822 oss << "luma_offset_l0[" << +i << "]: " << (extSliceParams ? +hevcExtSliceControl->luma_offset_l0[i] : +hevcSliceControl->luma_offset_l0[i]) << std::endl;
2823 oss << "luma_offset_l1[" << +i << "]: " << (extSliceParams ? +hevcExtSliceControl->luma_offset_l1[i] : +hevcSliceControl->luma_offset_l1[i]) << std::endl;
2824 }
2825 //Dump delta_luma_weight[2][15]
2826 for (uint8_t i = 0; i < 15; i++)
2827 {
2828 oss << "delta_luma_weight_l0[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
2829 oss << "delta_luma_weight_l1[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l1[i] << std::endl;
2830 }
2831 //Dump chroma_offset[2][15][2]
2832 for (uint8_t i = 0; i < 15; i++)
2833 {
2834 oss << "ChromaOffsetL0[" << +i << "][0]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL0[i][0] : +hevcSliceControl->ChromaOffsetL0[i][0]) << std::endl;
2835
2836 oss << "ChromaOffsetL0[" << +i << "][1]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL0[i][1] : +hevcSliceControl->ChromaOffsetL0[i][1]) << std::endl;
2837
2838 oss << "ChromaOffsetL1[" << +i << "][0]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL1[i][0] : +hevcSliceControl->ChromaOffsetL1[i][0]) << std::endl;
2839
2840 oss << "ChromaOffsetL1[" << +i << "][1]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL1[i][1] : +hevcSliceControl->ChromaOffsetL1[i][1]) << std::endl;
2841 }
2842 //Dump delta_chroma_weight[2][15][2]
2843 for (uint8_t i = 0; i < 15; i++)
2844 {
2845 oss << "delta_chroma_weight_l0[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l0[i][0] << std::endl;
2846 oss << "delta_chroma_weight_l0[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l0[i][1] << std::endl;
2847 oss << "delta_chroma_weight_l1[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l1[i][0] << std::endl;
2848 oss << "delta_chroma_weight_l1[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l1[i][1] << std::endl;
2849 }
2850
2851 oss << "five_minus_max_num_merge_cand: " << +hevcSliceControl->five_minus_max_num_merge_cand << std::endl;
2852 oss << "num_entry_point_offsets: " << +hevcSliceControl->num_entry_point_offsets << std::endl;
2853 oss << "EntryOffsetToSubsetArray: " << +hevcSliceControl->EntryOffsetToSubsetArray << std::endl;
2854
2855 if (extSliceParams)
2856 {
2857 oss << "cu_chroma_qp_offset_enabled_flag: " << +hevcExtSliceControl->cu_chroma_qp_offset_enabled_flag << std::endl;
2858
2859 //Dump scc slice parameters
2860 oss << "slice_act_y_qp_offset: " << +hevcExtSliceControl->slice_act_y_qp_offset<< std::endl;
2861 oss << "slice_act_cb_qp_offset: " << +hevcExtSliceControl->slice_act_cb_qp_offset << std::endl;
2862 oss << "slice_act_cr_qp_offset: " << +hevcExtSliceControl->slice_act_cr_qp_offset << std::endl;
2863 oss << "use_integer_mv_flag: " << +hevcExtSliceControl->use_integer_mv_flag << std::endl;
2864 }
2865 }
2866 }
2867
2868 const char *fileName = m_debugInterface->CreateFileName(
2869 "_DEC",
2870 CodechalDbgBufferType::bufSlcParams,
2871 CodechalDbgExtType::txt);
2872 CODECHAL_DEBUG_CHK_NULL(fileName);
2873 std::ofstream ofs;
2874 ofs.open(fileName, std::ios::out);
2875 ofs << oss.str();
2876 ofs.close();
2877
2878 return MOS_STATUS_SUCCESS;
2879 }
2880
DumpSubsetsParams(PCODEC_HEVC_SUBSET_PARAMS subsetsParams)2881 MOS_STATUS CodechalDecodeHevcG12::DumpSubsetsParams(
2882 PCODEC_HEVC_SUBSET_PARAMS subsetsParams)
2883 {
2884 CODECHAL_DEBUG_FUNCTION_ENTER;
2885 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSubsetsParams))
2886 {
2887 return MOS_STATUS_SUCCESS;
2888 }
2889
2890 if(subsetsParams)
2891 {
2892 std::ostringstream oss;
2893 oss.setf(std::ios::showbase | std::ios::uppercase);
2894
2895 for(uint16_t i = 0; i < 440; i++)
2896 {
2897 oss << "entry_point_offset_minus1[" << +i << "]: " << +subsetsParams->entry_point_offset_minus1[i]<< std::endl;
2898 }
2899
2900 //create the file
2901 const char *fileName = m_debugInterface->CreateFileName(
2902 "_DEC",
2903 CodechalDbgBufferType::bufSubsetsParams,
2904 CodechalDbgExtType::txt);
2905
2906 std::ofstream ofs(fileName, std::ios::out);
2907 ofs << oss.str();
2908 ofs.close();
2909 }
2910 return MOS_STATUS_SUCCESS;
2911 }
2912 #endif
2913