Debian Codegraph @

media_driver/agnostic/gen12/codec/hal/codechal_decode_hevc_g12.cpp

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