1 /*
2 * Copyright (c) 2012-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file codechal_decode_hevc_g11.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_g11.h"
31 #include "codechal_mmc_decode_hevc.h"
32 #include "mhw_vdbox_hcp_g11_X.h"
33 #include "mhw_vdbox_mfx_g11_X.h"
34 #include "mhw_vdbox_g11_X.h"
35 #include "codechal_hw_g11_X.h"
36 #include "hal_oca_interface.h"
37
38 //==<Functions>=======================================================
AllocateResourcesVariableSizes()39 MOS_STATUS CodechalDecodeHevcG11::AllocateResourcesVariableSizes ()
40 {
41 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
42
43 CODECHAL_DECODE_FUNCTION_ENTER;
44
45 uint8_t maxBitDepth = (m_is10BitHevc) ? 10 : 8;
46 uint8_t chromaFormatPic = m_hevcPicParams->chroma_format_idc;
47 uint8_t chromaFormat = m_chromaFormatinProfile;
48 CODECHAL_DECODE_ASSERT(chromaFormat >= chromaFormatPic);
49
50 uint32_t widthMax = MOS_MAX(m_width, m_widthLastMaxAlloced);
51 uint32_t heightMax = MOS_MAX(m_height, m_heightLastMaxAlloced);
52 uint32_t frameSizeMax = MOS_MAX((m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize), m_frameSizeMaxAlloced);
53
54 uint32_t ctbLog2SizeYPic = m_hevcPicParams->log2_diff_max_min_luma_coding_block_size +
55 m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3;
56 uint32_t ctbLog2SizeY = MOS_MAX(ctbLog2SizeYPic, m_ctbLog2SizeYMax);
57
58 //for Scalability
59 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
60 {
61 MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam;
62 MOS_ZeroMemory(&reallocParam, sizeof(reallocParam));
63 reallocParam.ucMaxBitDepth = maxBitDepth;
64 reallocParam.ucChromaFormat = chromaFormat;
65 reallocParam.dwCtbLog2SizeY = ctbLog2SizeY;
66 reallocParam.dwCtbLog2SizeYMax = m_ctbLog2SizeYMax;
67 reallocParam.dwPicWidth = widthMax;
68 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
69 reallocParam.dwPicHeight = heightMax;
70 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
71 reallocParam.dwFrameSize = frameSizeMax;
72 reallocParam.dwFrameSizeAlloced = m_frameSizeMaxAlloced;
73
74 MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam;
75 MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
76 hcpBufSizeParam.ucMaxBitDepth = maxBitDepth;
77 hcpBufSizeParam.ucChromaFormat = chromaFormat;
78 hcpBufSizeParam.dwCtbLog2SizeY = ctbLog2SizeY;
79 hcpBufSizeParam.dwPicWidth = widthMax;
80 hcpBufSizeParam.dwPicHeight = heightMax;
81 hcpBufSizeParam.dwMaxFrameSize = frameSizeMax;
82
83 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateResources_VariableSizes(
84 m_scalabilityState,
85 &hcpBufSizeParam,
86 &reallocParam));
87
88 m_frameSizeMaxAlloced = frameSizeMax;
89 }
90
91 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::AllocateResourcesVariableSizes());
92
93 return eStatus;
94 }
95
~CodechalDecodeHevcG11()96 CodechalDecodeHevcG11::~CodechalDecodeHevcG11 ()
97 {
98 CODECHAL_DECODE_FUNCTION_ENTER;
99
100 if (m_sinlgePipeVeState)
101 {
102 MOS_FreeMemAndSetNull(m_sinlgePipeVeState);
103 }
104 if (m_scalabilityState)
105 {
106 CodecHalDecodeScalability_Destroy(m_scalabilityState);
107 MOS_FreeMemAndSetNull(m_scalabilityState);
108 }
109 //Note: virtual engine interface destroy is done in MOS layer
110
111 return;
112 }
113
CheckLCUSize()114 MOS_STATUS CodechalDecodeHevcG11::CheckLCUSize()
115 {
116 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
117
118 CODECHAL_DECODE_FUNCTION_ENTER;
119
120 uint16_t LCUSize = 1 << (m_hevcPicParams->log2_diff_max_min_luma_coding_block_size +
121 m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
122
123 if (m_width > CODECHAL_HEVC_MAX_DIM_FOR_MIN_LCU || m_height > CODECHAL_HEVC_MAX_DIM_FOR_MIN_LCU)
124 {
125 if (LCUSize == CODECHAL_HEVC_MIN_LCU)
126 {
127 CODECHAL_DECODE_ASSERTMESSAGE("Invalid LCU size.");
128 return MOS_STATUS_INVALID_PARAMETER;
129 }
130 }
131
132 return eStatus;
133 }
134
SetGpuCtxCreatOption(CodechalSetting * codecHalSetting)135 MOS_STATUS CodechalDecodeHevcG11::SetGpuCtxCreatOption(
136 CodechalSetting * codecHalSetting)
137 {
138 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
139
140 CODECHAL_DECODE_FUNCTION_ENTER;
141
142 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
143 {
144 CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
145 }
146 else
147 {
148 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
149 CODECHAL_DECODE_CHK_NULL_RETURN(m_gpuCtxCreatOpt);
150
151 if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
152 {
153 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeScalability_ConstructParmsForGpuCtxCreation(
154 m_scalabilityState,
155 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
156 codecHalSetting));
157
158 if (((PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt)->LRCACount == 2)
159 {
160 m_videoContext = MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface) ? MOS_GPU_CONTEXT_VIDEO5 : MOS_GPU_CONTEXT_VDBOX2_VIDEO;
161
162 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
163 m_osInterface,
164 m_videoContext,
165 MOS_GPU_NODE_VIDEO,
166 m_gpuCtxCreatOpt));
167
168 MOS_GPUCTX_CREATOPTIONS createOption;
169 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
170 m_osInterface,
171 MOS_GPU_CONTEXT_VIDEO,
172 m_videoGpuNode,
173 &createOption));
174 }
175 else if (((PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt)->LRCACount == 3)
176 {
177 m_videoContext = MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface) ? MOS_GPU_CONTEXT_VIDEO7 : MOS_GPU_CONTEXT_VDBOX2_VIDEO2;
178
179 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
180 m_osInterface,
181 m_videoContext,
182 MOS_GPU_NODE_VIDEO,
183 m_gpuCtxCreatOpt));
184
185 MOS_GPUCTX_CREATOPTIONS createOption;
186 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
187 m_osInterface,
188 MOS_GPU_CONTEXT_VIDEO,
189 m_videoGpuNode,
190 &createOption));
191 }
192 else
193 {
194 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
195 }
196 }
197 else
198 {
199 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
200 m_sinlgePipeVeState,
201 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
202 false));
203
204 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
205 }
206 }
207
208 return eStatus;
209 }
210
SetHucDmemS2LPictureBss(PHUC_HEVC_S2L_PIC_BSS hucHevcS2LPicBss)211 MOS_STATUS CodechalDecodeHevcG11::SetHucDmemS2LPictureBss(
212 PHUC_HEVC_S2L_PIC_BSS hucHevcS2LPicBss)
213 {
214 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
215
216 CODECHAL_DECODE_FUNCTION_ENTER;
217
218 CODECHAL_DECODE_CHK_NULL_RETURN(hucHevcS2LPicBss);
219
220 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::SetHucDmemS2LPictureBss(hucHevcS2LPicBss));
221
222 if (m_hevcExtPicParams)
223 {
224 hucHevcS2LPicBss->high_precision_offsets_enabled_flag =
225 m_hevcExtPicParams->PicRangeExtensionFlags.fields.high_precision_offsets_enabled_flag;
226 hucHevcS2LPicBss->chroma_qp_offset_list_enabled_flag =
227 m_hevcExtPicParams->PicRangeExtensionFlags.fields.chroma_qp_offset_list_enabled_flag;
228 }
229 else
230 {
231 hucHevcS2LPicBss->high_precision_offsets_enabled_flag = 0;
232 hucHevcS2LPicBss->chroma_qp_offset_list_enabled_flag = 0;
233 }
234
235 return eStatus;
236 }
237
SetFrameStates()238 MOS_STATUS CodechalDecodeHevcG11::SetFrameStates ()
239 {
240 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
241
242 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
243 CODECHAL_DECODE_FUNCTION_ENTER;
244
245 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_destSurface);
246 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_dataBuffer);
247
248 m_frameIdx++;
249
250 // Check HuC_status2 Imem loaded bit, if 0,return error
251 // As driver doesn't know when can get reg value afer storing HuC_Status2 register,
252 // Check the reg value here at the beginning of next frame
253 // Check twice, first entry and second entry
254 if (m_shortFormatInUse &&
255 m_frameIdx < 3 &&
256 m_statusQueryReportingEnabled &&
257 (((m_decodeStatusBuf.m_decodeStatus->m_hucErrorStatus2 >> 32) & m_hucInterface->GetHucStatus2ImemLoadedMask()) == 0))
258 {
259 CODECHAL_DECODE_ASSERTMESSAGE("HuC IMEM Loaded fails");
260 MT_ERR1(MT_DEC_HEVC, MT_DEC_HUC_ERROR_STATUS2, (m_decodeStatusBuf.m_decodeStatus->m_hucErrorStatus2 >> 32));
261 return MOS_STATUS_UNKNOWN;
262 }
263
264 m_cencBuf = m_decodeParams.m_cencBuf;
265
266 if (IsFirstExecuteCall()) // For DRC Multiple Execution Call, no need to update every value in pHevcState except first execute
267 {
268 m_dataSize = m_decodeParams.m_dataSize;
269 m_dataOffset = m_decodeParams.m_dataOffset;
270 m_numSlices = m_decodeParams.m_numSlices;
271
272 if (m_numSlices > CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6)
273 {
274 CODECHAL_DECODE_ASSERTMESSAGE("Slice number doesn't support!");
275 return MOS_STATUS_INVALID_PARAMETER;
276 }
277
278 m_hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)m_decodeParams.m_picParams;
279 m_hevcExtPicParams = (PCODEC_HEVC_EXT_PIC_PARAMS)m_decodeParams.m_extPicParams;
280 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_sliceParams);
281 m_hevcSliceParams = (PCODEC_HEVC_SLICE_PARAMS)m_decodeParams.m_sliceParams;
282 m_hevcExtSliceParams = (PCODEC_HEVC_EXT_SLICE_PARAMS)m_decodeParams.m_extSliceParams;
283 m_hevcIqMatrixParams = (PCODECHAL_HEVC_IQ_MATRIX_PARAMS)m_decodeParams.m_iqMatrixBuffer;
284 m_destSurface = *(m_decodeParams.m_destSurface);
285 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
286
287 CODECHAL_DECODE_CHK_STATUS_RETURN(InitializeBitstreamCat());
288 }
289 else
290 {
291 m_dataSize = m_decodeParams.m_dataSize;
292 m_dataOffset = 0;
293 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
294 }
295
296 CODECHAL_DECODE_CHK_STATUS_RETURN(CheckAndCopyBitstream());
297 if (m_hevcPicParams->CurrPic.FrameIdx < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
298 {
299 PCODEC_REF_LIST destEntry = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx];
300 MOS_ZeroMemory(destEntry, sizeof(CODEC_REF_LIST));
301 }
302
303 if (m_incompletePicture)
304 {
305 return MOS_STATUS_SUCCESS;
306 }
307
308 CODECHAL_DECODE_CHK_NULL_RETURN(m_hevcPicParams);
309 CODECHAL_DECODE_CHK_NULL_RETURN(m_hevcIqMatrixParams);
310
311 // Calculate bCurPicIntra
312 m_curPicIntra = true;
313 if (m_hevcPicParams->IntraPicFlag == 0)
314 {
315 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
316 {
317 uint8_t frameIdx = m_hevcPicParams->RefPicSetStCurrBefore[i];
318 if (frameIdx < 15)
319 {
320 m_curPicIntra = false;
321 break;
322 }
323
324 frameIdx = m_hevcPicParams->RefPicSetStCurrAfter[i];
325 if (frameIdx < 15)
326 {
327 m_curPicIntra = false;
328 break;
329 }
330
331 frameIdx = m_hevcPicParams->RefPicSetLtCurr[i];
332 if (frameIdx < 15)
333 {
334 m_curPicIntra = false;
335 break;
336 }
337 }
338 }
339
340 CODECHAL_DECODE_CHK_STATUS_RETURN(SetPictureStructs());
341
342 uint32_t i;
343 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
344 {
345 m_frameUsedAsCurRef[i] = false;
346 m_refIdxMapping[i] = -1;
347 }
348
349 // Calculate RefIdxMapping
350 for (i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
351 {
352 uint8_t frameIdx = m_hevcPicParams->RefPicSetStCurrBefore[i];
353 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
354 {
355 m_frameUsedAsCurRef[frameIdx] = true;
356 }
357
358 frameIdx = m_hevcPicParams->RefPicSetStCurrAfter[i];
359 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
360 {
361 m_frameUsedAsCurRef[frameIdx] = true;
362 }
363
364 frameIdx = m_hevcPicParams->RefPicSetLtCurr[i];
365 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
366 {
367 m_frameUsedAsCurRef[frameIdx] = true;
368 }
369 }
370
371 uint8_t curRefIdx = 0;
372 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
373 {
374 if (m_frameUsedAsCurRef[i])
375 {
376 m_refIdxMapping[i] = curRefIdx++;
377 }
378 }
379
380 CODECHAL_DECODE_CHK_COND_RETURN(curRefIdx > 8, "bitstream has more than 8 references");
381
382 m_minCtbSize = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
383 m_width = m_hevcPicParams->PicWidthInMinCbsY * m_minCtbSize;
384 m_height = m_hevcPicParams->PicHeightInMinCbsY * m_minCtbSize;
385
386 CODECHAL_DECODE_CHK_STATUS_RETURN(CheckLCUSize());
387
388 if (m_hcpInterface->IsRowStoreCachingSupported())
389 {
390 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams;
391 rowstoreParams.Mode = CODECHAL_DECODE_MODE_HEVCVLD;
392 rowstoreParams.dwPicWidth = m_width;
393 rowstoreParams.bMbaff = false;
394 rowstoreParams.ucBitDepthMinus8 = (m_is10BitHevc) ? 2 : 0;
395 rowstoreParams.ucChromaFormat = m_hevcPicParams->chroma_format_idc;
396 rowstoreParams.ucLCUSize = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3 +
397 m_hevcPicParams->log2_diff_max_min_luma_coding_block_size);
398 m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams);
399 }
400
401 // Calculate Tile info
402 if (m_hevcPicParams->tiles_enabled_flag)
403 {
404 CODECHAL_DECODE_CHK_STATUS_RETURN(GetAllTileInfo());
405 }
406
407 if (m_curPicIntra)
408 {
409 m_perfType = I_TYPE;
410 }
411 else
412 {
413 // Not possible to determine whether P or B is used for short format.
414 // For long format iterating through all of the slices to determine P vs
415 // B, so in order to avoid this, declare all other pictures MIXED_TYPE.
416 m_perfType = MIXED_TYPE;
417 }
418 if (m_pCodechalOcaDumper)
419 {
420 m_pCodechalOcaDumper->SetHevcDecodeParam(
421 m_hevcPicParams,
422 m_hevcExtPicParams,
423 nullptr,
424 m_hevcSliceParams,
425 m_hevcExtSliceParams,
426 m_numSlices,
427 m_shortFormatInUse);
428 }
429
430
431 m_crrPic = m_hevcPicParams->CurrPic;
432 m_secondField =
433 CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
434
435 CODECHAL_DEBUG_TOOL(
436 m_debugInterface->m_currPic = m_crrPic;
437 m_debugInterface->m_secondField = m_secondField;
438 m_debugInterface->m_frameType = m_perfType;
439
440 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(
441 m_hevcPicParams,
442 m_hevcExtPicParams));
443
444 if (m_hevcIqMatrixParams) {
445 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpIQParams(m_hevcIqMatrixParams));
446 }
447
448 if (m_hevcSliceParams) {
449 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpSliceParams(
450 m_hevcSliceParams,
451 m_hevcExtSliceParams,
452 m_numSlices,
453 m_shortFormatInUse));
454 })
455
456 // Clear DMEM buffer program flag
457 if (m_shortFormatInUse)
458 {
459 m_dmemBufferProgrammed = false;
460 m_dmemBufferIdx++;
461 m_dmemBufferIdx %= CODECHAL_HEVC_NUM_DMEM_BUFFERS;
462 }
463
464 #ifdef _DECODE_PROCESSING_SUPPORTED
465 // Check if SFC can be supported
466 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->CheckAndInitialize((DecodeProcessingParams *)m_decodeParams.m_procParams, m_hevcPicParams));
467 #endif
468 CODECHAL_DEBUG_TOOL(
469 if (!m_incompletePicture && !IsFirstExecuteCall()) {
470 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
471 &m_resCopyDataBuffer,
472 CodechalDbgAttr::attrBitstream,
473 "_DEC",
474 m_estiBytesInBitstream,
475 0,
476 CODECHAL_NUM_MEDIA_STATES));
477 })
478
479 if (MOS_VE_SUPPORTED(m_osInterface) && static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
480 {
481 CODECHAL_DECODE_SCALABILITY_INIT_PARAMS initParams;
482
483 MOS_ZeroMemory(&initParams, sizeof(initParams));
484 initParams.u32PicWidthInPixel = m_width;
485 initParams.u32PicHeightInPixel = m_height;
486 initParams.format = m_decodeParams.m_destSurface->Format;
487 initParams.usingSFC = false;
488 initParams.gpuCtxInUse = GetVideoContext();
489
490 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitScalableParams(
491 m_scalabilityState,
492 &initParams,
493 &m_decodePassNum));
494
495 if (MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
496 {
497 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeScalability_ChkGpuCtxReCreation(
498 m_scalabilityState,
499 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt));
500 SetVideoContext(m_scalabilityState->VideoContext);
501 }
502 }
503
504 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesVariableSizes());
505
506 m_hcpDecPhase = CodechalHcpDecodePhaseInitialized;
507
508 return eStatus;
509 }
510
511 //!
512 //! \brief Determine Decode Phase
513 //! \details Determine decode phase in hevc decode
514 //! \param N/A
515 //! \return MOS_STATUS
516 //! MOS_STATUS_SUCCESS if success, else fail reason
517 //!
DetermineDecodePhase()518 MOS_STATUS CodechalDecodeHevcG11::DetermineDecodePhase()
519 {
520 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
521
522 CODECHAL_DECODE_FUNCTION_ENTER;
523
524 if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported() && MOS_VE_SUPPORTED(m_osInterface))
525 {
526 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_DetermineDecodePhase(
527 m_scalabilityState,
528 &m_hcpDecPhase));
529 }
530 else
531 {
532 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::DetermineDecodePhase());
533 }
534
535 CODECHAL_DECODE_VERBOSEMESSAGE("Current Decode Phase: %d.", m_hcpDecPhase);
536
537 return eStatus;
538 }
539
EndStatusReport(CodechalDecodeStatusReport & decodeStatusReport,PMOS_COMMAND_BUFFER cmdBuffer)540 MOS_STATUS CodechalDecodeHevcG11::EndStatusReport(
541 CodechalDecodeStatusReport &decodeStatusReport,
542 PMOS_COMMAND_BUFFER cmdBuffer)
543 {
544 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
545
546 CODECHAL_DECODE_FUNCTION_ENTER;
547
548 CODECHAL_DECODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
549 "ERROR - vdbox index exceed the maximum");
550
551 auto mmioRegistersMfx = m_mfxInterface->GetMmioRegisters(m_vdboxIndex);
552 uint32_t currIndex = m_decodeStatusBuf.m_currIndex;
553
554 MHW_MI_STORE_REGISTER_MEM_PARAMS regParams;
555 MOS_ZeroMemory(®Params, sizeof(regParams));
556
557 //Frame CRC
558 if (m_reportFrameCrc)
559 {
560 uint32_t frameCrcOffset =
561 currIndex * sizeof(CodechalDecodeStatus) +
562 m_decodeStatusBuf.m_decFrameCrcOffset +
563 sizeof(uint32_t) * 2;
564
565 regParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
566 regParams.dwOffset = frameCrcOffset;
567 regParams.dwRegister = mmioRegistersMfx->mfxFrameCrcRegOffset;
568
569 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
570 cmdBuffer,
571 ®Params));
572 }
573
574 // First copy all the SW data in to the eStatus buffer
575 m_decodeStatusBuf.m_decodeStatus[currIndex].m_swStoredData = m_decodeStatusBuf.m_swStoreData;
576 m_decodeStatusBuf.m_decodeStatus[currIndex].m_decodeStatusReport = decodeStatusReport;
577
578 uint32_t storeDataOffset =
579 currIndex * sizeof(CodechalDecodeStatus) +
580 m_decodeStatusBuf.m_storeDataOffset +
581 sizeof(uint32_t) * 2;
582
583 MHW_MI_STORE_DATA_PARAMS dataParams;
584 dataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
585 dataParams.dwResourceOffset = storeDataOffset;
586 dataParams.dwValue = CODECHAL_STATUS_QUERY_END_FLAG;
587
588 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
589 cmdBuffer,
590 &dataParams));
591
592 m_decodeStatusBuf.m_currIndex = (m_decodeStatusBuf.m_currIndex + 1) % CODECHAL_DECODE_STATUS_NUM;
593
594 CodechalDecodeStatus *decodeStatus = &m_decodeStatusBuf.m_decodeStatus[m_decodeStatusBuf.m_currIndex];
595 MOS_ZeroMemory(decodeStatus, sizeof(CodechalDecodeStatus));
596
597 CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectEndCmd((void *)this, m_osInterface, m_miInterface, cmdBuffer));
598
599 if (!m_osInterface->bEnableKmdMediaFrameTracking && m_osInterface->bInlineCodecStatusUpdate)
600 {
601 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
602 // Send MI_FLUSH with protection bit off, which will FORCE exit protected mode for MFX
603 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
604 flushDwParams.bVideoPipelineCacheInvalidate = true;
605 flushDwParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
606 flushDwParams.dwDataDW1 = m_decodeStatusBuf.m_swStoreData;
607 MHW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
608 cmdBuffer,
609 &flushDwParams));
610 }
611
612 return eStatus;
613 }
614
EndStatusReportForFE(PMOS_COMMAND_BUFFER cmdBuffer)615 MOS_STATUS CodechalDecodeHevcG11::EndStatusReportForFE(
616 PMOS_COMMAND_BUFFER cmdBuffer)
617 {
618 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
619
620 CODECHAL_DECODE_FUNCTION_ENTER;
621
622 CODECHAL_DECODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
623 "ERROR - vdbox index exceed the maximum");
624 auto mmioRegistersMfx = m_mfxInterface->GetMmioRegisters(m_vdboxIndex);
625 auto mmioRegistersHcp = m_hcpInterface ? m_hcpInterface->GetMmioRegisters(m_vdboxIndex) : nullptr;
626
627 uint32_t currIndex = m_decodeStatusBuf.m_currIndex;
628 //Error Status report
629 uint32_t errStatusOffset =
630 currIndex * sizeof(CodechalDecodeStatus) +
631 m_decodeStatusBuf.m_decErrorStatusOffset +
632 sizeof(uint32_t) * 2;
633
634 MHW_MI_STORE_REGISTER_MEM_PARAMS regParams;
635 MOS_ZeroMemory(®Params, sizeof(regParams));
636
637 regParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
638 regParams.dwOffset = errStatusOffset;
639 regParams.dwRegister = mmioRegistersHcp ?
640 mmioRegistersHcp->hcpCabacStatusRegOffset : mmioRegistersMfx->mfxErrorFlagsRegOffset;
641 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
642 cmdBuffer,
643 ®Params));
644
645 //MB Count
646 uint32_t mbCountOffset =
647 currIndex * sizeof(CodechalDecodeStatus) +
648 m_decodeStatusBuf.m_decMBCountOffset +
649 sizeof(uint32_t) * 2;
650
651 regParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
652 regParams.dwOffset = mbCountOffset;
653 regParams.dwRegister = mmioRegistersHcp ?
654 mmioRegistersHcp->hcpDecStatusRegOffset : mmioRegistersMfx->mfxMBCountRegOffset;
655 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
656 cmdBuffer,
657 ®Params));
658
659 return eStatus;
660 }
661
SetAndPopulateVEHintParams(PMOS_COMMAND_BUFFER primCmdBuf)662 MOS_STATUS CodechalDecodeHevcG11::SetAndPopulateVEHintParams(
663 PMOS_COMMAND_BUFFER primCmdBuf)
664 {
665 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
666
667 CODECHAL_DECODE_FUNCTION_ENTER;
668
669 if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported() && MOS_VE_SUPPORTED(m_osInterface))
670 {
671 CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS scalSetParms;
672 MOS_ZeroMemory(&scalSetParms, sizeof(CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS));
673 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
674 {
675 scalSetParms.bNeedSyncWithPrevious = true;
676 scalSetParms.bSameEngineAsLastSubmission = false;
677 scalSetParms.bSFCInUse = false;
678 }
679 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SetHintParams(m_scalabilityState, &scalSetParms));
680 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_PopulateHintParams(m_scalabilityState, primCmdBuf));
681 }
682 else
683 {
684 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
685 {
686 MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
687 MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
688 vesetParams.bNeedSyncWithPrevious = true;
689 vesetParams.bSameEngineAsLastSubmission = false;
690 vesetParams.bSFCInUse = false;
691 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_sinlgePipeVeState, &vesetParams));
692 }
693 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_PopulateHintParams(m_sinlgePipeVeState, primCmdBuf, true));
694 }
695
696 return eStatus;
697 }
698
DetermineSendProlgwithFrmTracking(bool * sendPrologWithFrameTracking)699 MOS_STATUS CodechalDecodeHevcG11::DetermineSendProlgwithFrmTracking(
700 bool *sendPrologWithFrameTracking)
701 {
702 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
703
704 CODECHAL_DECODE_FUNCTION_ENTER;
705
706 CODECHAL_DECODE_CHK_NULL_RETURN(sendPrologWithFrameTracking);
707
708 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
709 {
710 if (CodecHalDecodeScalability1stPhaseofSubmission(m_scalabilityState))
711 {
712 *sendPrologWithFrameTracking = true;
713 }
714 }
715 else
716 {
717 if (m_shortFormatInUse)
718 {
719 *sendPrologWithFrameTracking = m_enableSf2DmaSubmits;
720 }
721 else
722 {
723 *sendPrologWithFrameTracking = true;
724 }
725 }
726
727 return eStatus;
728 }
729
RequestedSpaceSize(uint32_t requestedSize)730 uint32_t CodechalDecodeHevcG11::RequestedSpaceSize(uint32_t requestedSize)
731 {
732 if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
733 {
734 //primary cmd buffer only including cmd buffer header .
735 return COMMAND_BUFFER_RESERVED_SPACE * 2;
736 }
737 else
738 {
739 return requestedSize;
740 }
741 }
742
VerifyExtraSpace(uint32_t requestedSize,uint32_t additionalSizeNeeded)743 MOS_STATUS CodechalDecodeHevcG11::VerifyExtraSpace(
744 uint32_t requestedSize,
745 uint32_t additionalSizeNeeded)
746 {
747 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
748
749 CODECHAL_DECODE_FUNCTION_ENTER;
750
751 if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
752 {
753 eStatus = MOS_STATUS_NO_SPACE;
754
755 // Try a maximum of 3 attempts to request the required sizes from OS
756 // OS could reset the sizes if necessary, therefore, requires to re-verify
757 for (auto i = 0; (i < 3) && (eStatus != MOS_STATUS_SUCCESS); i++)
758 {
759 // Verify secondary cmd buffer
760 eStatus = (MOS_STATUS)m_osInterface->pfnVerifyCommandBufferSize(
761 m_osInterface,
762 requestedSize,
763 MOS_VE_HAVE_SECONDARY_CMDBUFFER);
764
765 // Resize command buffer if not enough
766 if (eStatus != MOS_STATUS_SUCCESS)
767 {
768 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResizeCommandBufferAndPatchList(
769 m_osInterface,
770 requestedSize + additionalSizeNeeded,
771 0,
772 MOS_VE_HAVE_SECONDARY_CMDBUFFER));
773 // Set status to NO_SPACE to enter the commaned buffer size verification on next loop.
774 eStatus = MOS_STATUS_NO_SPACE;
775 }
776 }
777 }
778
779 return eStatus;
780 }
781
DecodeStateLevel()782 MOS_STATUS CodechalDecodeHevcG11::DecodeStateLevel()
783 {
784 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
785
786 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
787 CODECHAL_DECODE_FUNCTION_ENTER;
788
789 //HCP Decode Phase State Machine
790 CODECHAL_DECODE_CHK_STATUS_RETURN(DetermineDecodePhase());
791
792 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
793 {
794 //Switch GPU context when necessary
795 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SwitchGpuContext(m_scalabilityState));
796 }
797
798 // Set HEVC Decode Phase, and execute it.
799 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
800 {
801 if (m_secureDecoder)
802 {
803 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->Execute(this));
804 }
805
806 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPictureS2L());
807 }
808 else
809 {
810 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPictureLongFormat());
811 }
812
813 return eStatus;
814 }
815
SendPictureS2L()816 MOS_STATUS CodechalDecodeHevcG11::SendPictureS2L()
817 {
818 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
819
820 CODECHAL_DECODE_FUNCTION_ENTER;
821
822 if (m_enableSf2DmaSubmits)
823 {
824 m_osInterface->pfnSetPerfTag(
825 m_osInterface,
826 (uint16_t)(((CODECHAL_DECODE_MODE_HUC << 4) & 0xF0) | (m_perfType & 0xF)));
827 }
828
829 MOS_COMMAND_BUFFER primCmdBuffer;
830 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
831
832 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
833 &primCmdBuffer, true));
834
835 PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
836 MOS_COMMAND_BUFFER scdryCmdBuffer;
837
838 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
839 {
840 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse(
841 m_scalabilityState,
842 &scdryCmdBuffer,
843 &cmdBufferInUse));
844
845 if (cmdBufferInUse == &scdryCmdBuffer)
846 {
847 //send prolog at the start of a secondary cmd buffer
848 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(cmdBufferInUse, false));
849 }
850 }
851
852 if (MOS_VE_SUPPORTED(m_osInterface))
853 {
854 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && CodecHalDecodeScalability1stDecPhase(m_scalabilityState))
855 {
856 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitSemaMemResources(m_scalabilityState, cmdBufferInUse));
857 }
858 }
859
860 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureS2LCmds(cmdBufferInUse));
861
862 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
863
864 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
865 {
866 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer(m_scalabilityState, &scdryCmdBuffer));
867 }
868
869 return eStatus;
870 }
871
InitPicLongFormatMhwParams()872 MOS_STATUS CodechalDecodeHevcG11::InitPicLongFormatMhwParams()
873 {
874 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
875
876 CODECHAL_DECODE_FUNCTION_ENTER;
877
878 // Reset all pic Mhw Params
879 auto pipeModeSelectParams =
880 static_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G11>(m_picMhwParams.PipeModeSelectParams);
881 *pipeModeSelectParams = {};
882 auto pipeBufAddrParams =
883 static_cast<PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G11>(m_picMhwParams.PipeBufAddrParams);
884 *pipeBufAddrParams = {};
885 auto hevcPicStateParams =
886 static_cast<PMHW_VDBOX_HEVC_PIC_STATE_G11>(m_picMhwParams.HevcPicState);
887
888 *hevcPicStateParams = {};
889 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::InitPicLongFormatMhwParams());
890
891 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
892 {
893 CodecHalDecodeScalablity_DecPhaseToHwWorkMode(
894 pipeModeSelectParams->MultiEngineMode,
895 pipeModeSelectParams->PipeWorkMode);
896
897 pipeBufAddrParams->presSliceStateStreamOutBuffer =
898 &m_scalabilityState->resSliceStateStreamOutBuffer;
899 pipeBufAddrParams->presMvUpRightColStoreBuffer =
900 &m_scalabilityState->resMvUpRightColStoreBuffer;
901 pipeBufAddrParams->presIntraPredUpRightColStoreBuffer =
902 &m_scalabilityState->resIntraPredUpRightColStoreBuffer;
903 pipeBufAddrParams->presIntraPredLeftReconColStoreBuffer =
904 &m_scalabilityState->resIntraPredLeftReconColStoreBuffer;
905 pipeBufAddrParams->presCABACSyntaxStreamOutBuffer =
906 m_scalabilityState->presCABACStreamOutBuffer;
907 }
908
909 hevcPicStateParams->pHevcExtPicParams = m_hevcExtPicParams;
910
911 return eStatus;
912 }
913
SendPictureLongFormat()914 MOS_STATUS CodechalDecodeHevcG11::SendPictureLongFormat()
915 {
916 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
917
918 CODECHAL_DECODE_FUNCTION_ENTER;
919
920 if (m_enableSf2DmaSubmits)
921 {
922 m_osInterface->pfnSetPerfTag(
923 m_osInterface,
924 (uint16_t)(((CODECHAL_DECODE_MODE_HEVCVLD << 4) & 0xF0) | (m_perfType & 0xF)));
925 }
926
927 MOS_COMMAND_BUFFER primCmdBuffer;
928 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
929
930 bool sendPrologWithFrameTracking = false;
931 CODECHAL_DECODE_CHK_STATUS_RETURN(DetermineSendProlgwithFrmTracking(&sendPrologWithFrameTracking));
932
933 if (sendPrologWithFrameTracking)
934 {
935 //Frame tracking functionality is called at the start of a command buffer.
936 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
937 &primCmdBuffer, true));
938 }
939
940 PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
941 MOS_COMMAND_BUFFER scdryCmdBuffer;
942 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
943
944 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
945 {
946 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse(
947 m_scalabilityState,
948 &scdryCmdBuffer,
949 &cmdBufferInUse));
950
951 if ((!m_shortFormatInUse && !CodecHalDecodeScalabilityIsFESeparateSubmission(m_scalabilityState)) ||
952 CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
953 {
954 //send prolog at the start of a secondary cmd buffer
955 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(cmdBufferInUse, false));
956 }
957
958 HalOcaInterface::On1stLevelBBStart(scdryCmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
959 }
960 else
961 {
962 HalOcaInterface::On1stLevelBBStart(primCmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
963 }
964
965 CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicLongFormatMhwParams());
966
967 CODECHAL_DEBUG_TOOL(
968 for (uint16_t n = 0; n < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; n++)
969 {
970 if (m_picMhwParams.PipeBufAddrParams->presReferences[n])
971 {
972 MOS_SURFACE dstSurface;
973
974 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
975 dstSurface.OsResource = *(m_picMhwParams.PipeBufAddrParams->presReferences[n]);
976 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
977 m_osInterface,
978 &dstSurface));
979
980 m_debugInterface->m_refIndex = n;
981 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
982 &dstSurface,
983 CodechalDbgAttr::attrReferenceSurfaces,
984 "RefSurf"));
985 }
986
987 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n])
988 {
989 m_debugInterface->m_refIndex = n;
990 // dump mvdata
991 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
992 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n],
993 CodechalDbgAttr::attrMvData,
994 "_DEC",
995 m_mvBufferSize));
996 }
997 }
998 );
999
1000 if (MOS_VE_SUPPORTED(m_osInterface))
1001 {
1002 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && CodecHalDecodeScalability1stDecPhase(m_scalabilityState))
1003 {
1004 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitSemaMemResources(m_scalabilityState, cmdBufferInUse));
1005 }
1006 }
1007
1008 //Send status report Start
1009 if (m_statusQueryReportingEnabled)
1010 {
1011 bool sendStatusReportStart = true;
1012 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1013 {
1014 sendStatusReportStart = CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState);
1015 }
1016 if (sendStatusReportStart)
1017 {
1018 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(cmdBufferInUse));
1019 }
1020 }
1021
1022 if (m_shortFormatInUse && m_statusQueryReportingEnabled &&
1023 (!CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) ||
1024 CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState)))
1025 {
1026 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
1027 m_decodeStatusBuf.m_storeDataOffset +
1028 sizeof(uint32_t) * 2;
1029
1030 // Check HuC_STATUS bit15, HW continue if bit15 > 0, otherwise send COND BB END cmd.
1031 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->SendCondBbEndCmd(
1032 &m_decodeStatusBuf.m_statusBuffer,
1033 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset,
1034 0,
1035 false,
1036 cmdBufferInUse));
1037 }
1038
1039 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1040 {
1041 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_FEBESync(
1042 m_scalabilityState,
1043 cmdBufferInUse));
1044 if (m_perfFEBETimingEnabled && CodecHalDecodeScalabilityIsLastCompletePhase(m_scalabilityState))
1045 {
1046 CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectStartCmd((void *)this, m_osInterface, m_miInterface, &scdryCmdBuffer));
1047 }
1048 }
1049
1050 if (CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
1051 {
1052 CODECHAL_DECODE_CHK_STATUS_RETURN(
1053 m_miInterface->AddWatchdogTimerStartCmd(cmdBufferInUse));
1054 }
1055
1056 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureLongFormatCmds(cmdBufferInUse, &m_picMhwParams));
1057
1058 if (CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
1059 {
1060 MHW_VDBOX_HCP_TILE_CODING_PARAMS_G11 hcpTileCodingParam;
1061 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_CalculateHcpTileCodingParams<MHW_VDBOX_HCP_TILE_CODING_PARAMS_G11>(
1062 m_scalabilityState,
1063 m_hevcPicParams,
1064 &hcpTileCodingParam));
1065 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwVdboxHcpInterfaceG11*>(m_hcpInterface)->AddHcpTileCodingCmd(
1066 cmdBufferInUse,
1067 &hcpTileCodingParam));
1068 }
1069
1070 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
1071 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1072 {
1073 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer(m_scalabilityState, &scdryCmdBuffer));
1074 }
1075
1076 return eStatus;
1077 }
1078
SendSliceLongFormat(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)1079 MOS_STATUS CodechalDecodeHevcG11::SendSliceLongFormat(
1080 PMOS_COMMAND_BUFFER cmdBuffer,
1081 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
1082 {
1083 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1084
1085 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
1086 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState);
1087 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState->pHevcSliceParams);
1088
1089 PCODEC_HEVC_SLICE_PARAMS slc = hevcSliceState->pHevcSliceParams;
1090 PCODEC_HEVC_EXT_SLICE_PARAMS slcExt =
1091 static_cast<PMHW_VDBOX_HEVC_SLICE_STATE_G11>(hevcSliceState)->pHevcExtSliceParams;
1092
1093 // Disable the flag when ref list is empty for P/B slices to avoid the GPU hang
1094 if (m_curPicIntra &&
1095 !m_hcpInterface->IsHevcISlice(slc->LongSliceFlags.fields.slice_type))
1096
1097 {
1098 slc->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag = 0;
1099 }
1100
1101 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSliceStateCmd(
1102 cmdBuffer,
1103 hevcSliceState));
1104
1105 if (! m_hcpInterface->IsHevcISlice(slc->LongSliceFlags.fields.slice_type))
1106 {
1107 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
1108 refIdxParams.CurrPic = m_hevcPicParams->CurrPic;
1109 refIdxParams.ucList = 0;
1110 refIdxParams.ucNumRefForList = slc->num_ref_idx_l0_active_minus1 + 1;
1111 eStatus = MOS_SecureMemcpy(
1112 &refIdxParams.RefPicList,
1113 sizeof(refIdxParams.RefPicList),
1114 &slc->RefPicList,
1115 sizeof(slc->RefPicList));
1116 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1117 refIdxParams.hevcRefList = (void**)m_hevcRefList;
1118 refIdxParams.poc_curr_pic = m_hevcPicParams->CurrPicOrderCntVal;
1119 for (uint8_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1120 {
1121 refIdxParams.poc_list[i] = m_hevcPicParams->PicOrderCntValList[i];
1122 }
1123
1124 refIdxParams.pRefIdxMapping = hevcSliceState->pRefIdxMapping;
1125 refIdxParams.RefFieldPicFlag = m_hevcPicParams->RefFieldPicFlag;
1126 refIdxParams.RefBottomFieldFlag = m_hevcPicParams->RefBottomFieldFlag;
1127
1128 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
1129 cmdBuffer,
1130 nullptr,
1131 &refIdxParams));
1132
1133 if (m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type))
1134 {
1135 refIdxParams.ucList = 1;
1136 refIdxParams.ucNumRefForList = slc->num_ref_idx_l1_active_minus1 + 1;
1137 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
1138 cmdBuffer,
1139 nullptr,
1140 &refIdxParams));
1141 }
1142 }
1143 else if (MEDIA_IS_WA(m_waTable, WaDummyReference) && !m_osInterface->bSimIsActive)
1144 {
1145 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
1146 MOS_ZeroMemory(&refIdxParams, sizeof(MHW_VDBOX_HEVC_REF_IDX_PARAMS));
1147 refIdxParams.bDummyReference = true;
1148 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
1149 cmdBuffer,
1150 nullptr,
1151 &refIdxParams));
1152 }
1153
1154 if ((m_hevcPicParams->weighted_pred_flag &&
1155 m_hcpInterface->IsHevcPSlice(slc->LongSliceFlags.fields.slice_type)) ||
1156 (m_hevcPicParams->weighted_bipred_flag &&
1157 m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type)))
1158 {
1159 MHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS weightOffsetParams;
1160
1161 weightOffsetParams.ucList = 0;
1162
1163 eStatus = MOS_SecureMemcpy(
1164 &weightOffsetParams.LumaWeights[0],
1165 sizeof(weightOffsetParams.LumaWeights[0]),
1166 &slc->delta_luma_weight_l0,
1167 sizeof(slc->delta_luma_weight_l0));
1168 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1169
1170 eStatus = MOS_SecureMemcpy(
1171 &weightOffsetParams.LumaWeights[1],
1172 sizeof(weightOffsetParams.LumaWeights[1]),
1173 &slc->delta_luma_weight_l1,
1174 sizeof(slc->delta_luma_weight_l1));
1175 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1176
1177 if (slcExt)//REXT
1178 {
1179 eStatus = MOS_SecureMemcpy(
1180 &weightOffsetParams.LumaOffsets[0],
1181 sizeof(weightOffsetParams.LumaOffsets[0]),
1182 &slcExt->luma_offset_l0,
1183 sizeof(slcExt->luma_offset_l0));
1184 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1185
1186 eStatus = MOS_SecureMemcpy(
1187 &weightOffsetParams.LumaOffsets[1],
1188 sizeof(weightOffsetParams.LumaOffsets[1]),
1189 &slcExt->luma_offset_l1,
1190 sizeof(slcExt->luma_offset_l1));
1191 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1192
1193 eStatus = MOS_SecureMemcpy(
1194 &weightOffsetParams.ChromaOffsets[0],
1195 sizeof(weightOffsetParams.ChromaOffsets[0]),
1196 &slcExt->ChromaOffsetL0,
1197 sizeof(slcExt->ChromaOffsetL0));
1198 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1199
1200 eStatus = MOS_SecureMemcpy(
1201 &weightOffsetParams.ChromaOffsets[1],
1202 sizeof(weightOffsetParams.ChromaOffsets[1]),
1203 &slcExt->ChromaOffsetL1,
1204 sizeof(slcExt->ChromaOffsetL1));
1205 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1206 }
1207 else
1208 {
1209 for (int32_t i = 0; i < 15; i++)
1210 {
1211 weightOffsetParams.LumaOffsets[0][i] = (int16_t)slc->luma_offset_l0[i];
1212 weightOffsetParams.LumaOffsets[1][i] = (int16_t)slc->luma_offset_l1[i];
1213
1214 for (int32_t j = 0; j < 2; j++)
1215 {
1216 weightOffsetParams.ChromaOffsets[0][i][j] = (int16_t)slc->ChromaOffsetL0[i][j];
1217 weightOffsetParams.ChromaOffsets[1][i][j] = (int16_t)slc->ChromaOffsetL1[i][j];
1218 }
1219 }
1220 }
1221
1222 eStatus = MOS_SecureMemcpy(
1223 &weightOffsetParams.ChromaWeights[0],
1224 sizeof(weightOffsetParams.ChromaWeights[0]),
1225 &slc->delta_chroma_weight_l0,
1226 sizeof(slc->delta_chroma_weight_l0));
1227 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1228
1229 eStatus = MOS_SecureMemcpy(
1230 &weightOffsetParams.ChromaWeights[1],
1231 sizeof(weightOffsetParams.ChromaWeights[1]),
1232 &slc->delta_chroma_weight_l1,
1233 sizeof(slc->delta_chroma_weight_l1));
1234 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
1235
1236 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(
1237 cmdBuffer,
1238 nullptr,
1239 &weightOffsetParams));
1240
1241 if (m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type))
1242 {
1243 weightOffsetParams.ucList = 1;
1244 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(
1245 cmdBuffer,
1246 nullptr,
1247 &weightOffsetParams));
1248 }
1249 }
1250
1251 if (m_secureDecoder)
1252 {
1253 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AddHcpSecureState(
1254 cmdBuffer,
1255 hevcSliceState));
1256 }
1257
1258 MHW_VDBOX_HCP_BSD_PARAMS bsdParams;
1259 MOS_ZeroMemory(&bsdParams, sizeof(bsdParams));
1260 bsdParams.dwBsdDataLength = hevcSliceState->dwLength;
1261 bsdParams.dwBsdDataStartOffset = slc->slice_data_offset + hevcSliceState->dwOffset;
1262
1263 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpBsdObjectCmd(
1264 cmdBuffer,
1265 &bsdParams));
1266
1267 return eStatus;
1268 }
1269
DecodePrimitiveLevel()1270 MOS_STATUS CodechalDecodeHevcG11::DecodePrimitiveLevel()
1271 {
1272 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1273
1274 CODECHAL_DECODE_FUNCTION_ENTER;
1275
1276 // Bitstream is incomplete, don't do any decoding work.
1277 if (m_incompletePicture)
1278 {
1279 return MOS_STATUS_SUCCESS;
1280 }
1281
1282 CODECHAL_DECODE_CHK_COND_RETURN(
1283 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
1284 "ERROR - vdbox index exceed the maximum");
1285 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
1286
1287 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
1288 m_decodeStatusBuf.m_storeDataOffset +
1289 sizeof(uint32_t) * 2;
1290
1291 uint32_t renderingFlags = m_videoContextUsesNullHw;
1292
1293 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
1294
1295 MOS_COMMAND_BUFFER primCmdBuffer;
1296 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
1297
1298 PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
1299 MOS_COMMAND_BUFFER scdryCmdBuffer;
1300 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1301 {
1302 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse(
1303 m_scalabilityState,
1304 &scdryCmdBuffer,
1305 &cmdBufferInUse));
1306 CodecHalDecodeScalability_DecPhaseToSubmissionType(m_scalabilityState,cmdBufferInUse);
1307 }
1308
1309 // store CS ENGINE ID register
1310 if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported() && MOS_VE_SUPPORTED(m_osInterface))
1311 {
1312 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReadCSEngineIDReg(
1313 m_scalabilityState,
1314 &m_decodeStatusBuf,
1315 cmdBufferInUse));
1316 }
1317
1318 if (CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
1319 {
1320 //no slice level command for scalability decode BE phases
1321 }
1322 else if (m_cencBuf)
1323 {
1324 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCencBatchBuffer(cmdBufferInUse));
1325 }
1326 else if (m_shortFormatInUse &&
1327 (m_hcpDecPhase == CodechalHcpDecodePhaseLegacyLong ||
1328 CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState)))
1329 {
1330 // If S2L and 2nd pass, jump to 2nd level batch buffer
1331 if (m_enableSf2DmaSubmits)
1332 {
1333 #if (_DEBUG || _RELEASE_INTERNAL)
1334 m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iLastCurrent = m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize;
1335 #endif
1336
1337 CODECHAL_DEBUG_TOOL(
1338 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
1339 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex],
1340 CODECHAL_NUM_MEDIA_STATES,
1341 "_DEC"));)
1342 }
1343
1344 //S2L conversion
1345 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
1346 cmdBufferInUse,
1347 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex]));
1348 }
1349 else
1350 {
1351 //Short format 1st pass or long format
1352 // Setup static slice state parameters
1353 MHW_VDBOX_HEVC_SLICE_STATE_G11 hevcSliceState;
1354 hevcSliceState.presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
1355 hevcSliceState.pHevcPicParams = m_hevcPicParams;
1356 hevcSliceState.pHevcExtPicParam = m_hevcExtPicParams;
1357 hevcSliceState.pRefIdxMapping = &m_refIdxMapping[0];
1358
1359 PCODEC_HEVC_SLICE_PARAMS slc = m_hevcSliceParams;
1360 PCODEC_HEVC_EXT_SLICE_PARAMS slcExt = m_hevcExtSliceParams;
1361 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
1362 {
1363 hevcSliceState.pHevcSliceParams = slc;
1364 hevcSliceState.pHevcExtSliceParams = slcExt;
1365 hevcSliceState.dwLength = slc->slice_data_size;
1366 hevcSliceState.dwSliceIndex = slcCount;
1367 hevcSliceState.bLastSlice = (slcCount == (m_numSlices - 1));
1368
1369 // If S2L and 1st pass, send HuC commands.
1370 if (m_shortFormatInUse)
1371 {
1372 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceS2L(cmdBufferInUse, &hevcSliceState));
1373 }
1374 else
1375 {
1376 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceLongFormat(cmdBufferInUse, &hevcSliceState));
1377 }
1378
1379 slc++;
1380 if (slcExt)
1381 {
1382 slcExt++;
1383 }
1384 }
1385
1386 // If S2L and 1st pass
1387 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
1388 {
1389 // Send VD Pipe Flush command for SKL+
1390 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
1391 MOS_ZeroMemory(&vdpipeFlushParams , sizeof(vdpipeFlushParams));
1392 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
1393 vdpipeFlushParams.Flags.bFlushHEVC = 1;
1394 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
1395 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
1396 cmdBufferInUse,
1397 &vdpipeFlushParams));
1398
1399 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1400 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1401 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1402 cmdBufferInUse,
1403 &flushDwParams));
1404
1405 if (m_statusQueryReportingEnabled)
1406 {
1407 // Check HuC_STATUS2 bit6, if bit6 > 0 HW continue execution following cmd, otherwise it send a COND BB END cmd.
1408 eStatus = m_hwInterface->SendCondBbEndCmd(
1409 &m_decodeStatusBuf.m_statusBuffer,
1410 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2MaskOffset,
1411 0,
1412 false,
1413 cmdBufferInUse);
1414 CODECHAL_DECODE_CHK_STATUS_RETURN(eStatus);
1415
1416 // Write HUC_STATUS mask
1417 MHW_MI_STORE_DATA_PARAMS storeDataParams;
1418 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
1419 storeDataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
1420 storeDataParams.dwResourceOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset;
1421 storeDataParams.dwValue = m_hucInterface->GetHucStatusHevcS2lFailureMask();
1422 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
1423 cmdBufferInUse,
1424 &storeDataParams));
1425
1426 // store HUC_STATUS register
1427 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
1428 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
1429 storeRegParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
1430 storeRegParams.dwOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusRegOffset;
1431 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
1432 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
1433 cmdBufferInUse,
1434 &storeRegParams));
1435 }
1436
1437 if (m_enableSf2DmaSubmits)
1438 {
1439 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1440 cmdBufferInUse,
1441 nullptr));
1442 }
1443
1444 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
1445 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1446 {
1447 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer(m_scalabilityState, &scdryCmdBuffer));
1448 }
1449
1450 if (m_enableSf2DmaSubmits)
1451 {
1452 CODECHAL_DEBUG_TOOL(
1453 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
1454 cmdBufferInUse,
1455 CODECHAL_NUM_MEDIA_STATES,
1456 "_DEC"));
1457
1458 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
1459 // m_debugInterface,
1460 // cmdBufferInUse));
1461 );
1462
1463 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
1464 m_osInterface,
1465 cmdBufferInUse,
1466 renderingFlags));
1467 }
1468
1469 return eStatus;
1470 }
1471 }
1472
1473 // Send VD Pipe Flush command for SKL+
1474 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
1475 MOS_ZeroMemory(&vdpipeFlushParams , sizeof(vdpipeFlushParams));
1476 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
1477 vdpipeFlushParams.Flags.bFlushHEVC = 1;
1478 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
1479 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
1480 cmdBufferInUse,
1481 &vdpipeFlushParams));
1482
1483 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1484 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1485 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1486 cmdBufferInUse,
1487 &flushDwParams));
1488
1489 if (CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState))
1490 {
1491 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalablity_SetFECabacStreamoutOverflowStatus(
1492 m_scalabilityState,
1493 cmdBufferInUse));
1494
1495 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SignalFE2BESemaphore(
1496 m_scalabilityState,
1497 cmdBufferInUse));
1498
1499 //hcp decode status read at end of FE to support scalability
1500 if (m_statusQueryReportingEnabled)
1501 {
1502 EndStatusReportForFE(cmdBufferInUse);
1503 if (m_perfFEBETimingEnabled)
1504 {
1505 CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectEndCmd((void *)this, m_osInterface, m_miInterface, &scdryCmdBuffer));
1506 }
1507 }
1508 }
1509
1510 //Sync for decode completion in scalable mode
1511 if (CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
1512 {
1513 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_BEsCompletionSync(
1514 m_scalabilityState,
1515 cmdBufferInUse));
1516 }
1517
1518 bool syncDestSurface = true;
1519 //if scalable decode, BE0 finish means whole frame complete.
1520 // Check if destination surface needs to be synchronized
1521 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1522 {
1523 syncDestSurface = CodecHalDecodeScalabilityIsLastCompletePhase(m_scalabilityState);
1524 }
1525
1526 if (syncDestSurface)
1527 {
1528 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
1529 syncParams.GpuContext = m_videoContext;
1530 syncParams.presSyncResource = &m_destSurface.OsResource;
1531 syncParams.bReadOnly = false;
1532 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1533 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1534
1535 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
1536 {
1537 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
1538 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
1539
1540 // Update the resource tag (s/w tag) for On-Demand Sync
1541 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1542 }
1543
1544 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1545 if (m_osInterface->bTagResourceSync)
1546 {
1547 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
1548 cmdBufferInUse,
1549 &syncParams));
1550 }
1551
1552 if (m_statusQueryReportingEnabled)
1553 {
1554 CodechalDecodeStatusReport decodeStatusReport;
1555 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
1556 decodeStatusReport.m_currDecodedPic = m_hevcPicParams->CurrPic;
1557 decodeStatusReport.m_currDeblockedPic = m_hevcPicParams->CurrPic;
1558 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
1559 decodeStatusReport.m_currDecodedPicRes = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic;
1560 #ifdef _DECODE_PROCESSING_SUPPORTED
1561 CODECHAL_DEBUG_TOOL(
1562 if (m_downsampledSurfaces && m_sfcState && m_sfcState->m_sfcOutputSurface) {
1563 m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource =
1564 m_sfcState->m_sfcOutputSurface->OsResource;
1565 decodeStatusReport.m_currSfcOutputPicRes =
1566 &m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource;
1567 })
1568 #endif
1569 CODECHAL_DEBUG_TOOL(
1570 decodeStatusReport.m_secondField = CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
1571 decodeStatusReport.m_frameType = m_perfType;);
1572
1573 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1574 {
1575 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
1576 decodeStatusReport,
1577 cmdBufferInUse));
1578 }
1579 else
1580 {
1581 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecode::EndStatusReport(
1582 decodeStatusReport,
1583 cmdBufferInUse));
1584 }
1585 }
1586 }
1587
1588 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1589 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1590 cmdBufferInUse,
1591 &flushDwParams));
1592
1593 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1594 cmdBufferInUse,
1595 nullptr));
1596
1597 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
1598 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
1599 {
1600 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer(m_scalabilityState, &scdryCmdBuffer));
1601 }
1602
1603 bool syncCompleteFrame = m_copyDataBufferInUse;
1604 if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1605 {
1606 syncCompleteFrame = syncCompleteFrame && CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState);
1607 }
1608
1609 if (syncCompleteFrame)
1610 {
1611 //Sync up complete frame
1612 MOS_SYNC_PARAMS copyDataSyncParams = g_cInitSyncParams;
1613 copyDataSyncParams.GpuContext = m_videoContextForWa;
1614 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1615
1616 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, ©DataSyncParams));
1617
1618 copyDataSyncParams = g_cInitSyncParams;
1619 copyDataSyncParams.GpuContext = m_videoContext;
1620 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1621
1622 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, ©DataSyncParams));
1623 }
1624
1625 CODECHAL_DEBUG_TOOL(
1626 {
1627 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1628 {
1629 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_DbgDumpCmdBuffer(
1630 this,
1631 m_scalabilityState,
1632 m_debugInterface,
1633 &primCmdBuffer));
1634 }
1635 else
1636 {
1637 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
1638 &primCmdBuffer,
1639 CODECHAL_NUM_MEDIA_STATES,
1640 "_DEC"));
1641
1642 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
1643 // m_debugInterface,
1644 // &primCmdBuffer));
1645 }
1646 });
1647
1648 bool submitCommand = true;
1649 //submit command buffer
1650 if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1651 {
1652 submitCommand = CodecHalDecodeScalabilityIsToSubmitCmdBuffer(m_scalabilityState);
1653
1654 HalOcaInterface::DumpCodechalParam(scdryCmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, m_pCodechalOcaDumper, CODECHAL_HEVC);
1655 HalOcaInterface::On1stLevelBBEnd(scdryCmdBuffer, *m_osInterface);
1656 }
1657 else
1658 {
1659 HalOcaInterface::DumpCodechalParam(primCmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, m_pCodechalOcaDumper, CODECHAL_HEVC);
1660 HalOcaInterface::On1stLevelBBEnd(primCmdBuffer, *m_osInterface);
1661 }
1662 if (submitCommand)
1663 {
1664 //command buffer to submit is the primary cmd buffer.
1665 if (MOS_VE_SUPPORTED(m_osInterface))
1666 {
1667 CODECHAL_DECODE_CHK_STATUS_RETURN(SetAndPopulateVEHintParams(&primCmdBuffer));
1668 }
1669
1670 if(m_osInterface->phasedSubmission
1671 && MOS_VE_SUPPORTED(m_osInterface)
1672 && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1673 {
1674 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, cmdBufferInUse, renderingFlags));
1675 }
1676 else
1677 {
1678 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &primCmdBuffer, renderingFlags));
1679 }
1680 }
1681
1682 CODECHAL_DEBUG_TOOL(
1683 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
1684
1685 // Reset status report
1686 if (m_statusQueryReportingEnabled)
1687 {
1688 bool resetStatusReport = true;
1689
1690 //if scalable decode, reset status report at final BE phase.
1691 if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1692 {
1693 resetStatusReport = CodecHalDecodeScalabilityIsFinalBEPhase(m_scalabilityState);
1694 }
1695
1696 if (resetStatusReport)
1697 {
1698 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
1699 m_videoContextUsesNullHw));
1700 }
1701 }
1702
1703 // Needs to be re-set for Linux buffer re-use scenarios
1704 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic =
1705 m_destSurface.OsResource;
1706
1707 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
1708 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
1709 {
1710 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
1711 syncParams.GpuContext = m_videoContext;
1712 syncParams.presSyncResource = &m_destSurface.OsResource;
1713
1714 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
1715 }
1716 #ifdef _DECODE_PROCESSING_SUPPORTED
1717 // Send Vebox and SFC cmds
1718 bool sendSFC = m_sfcState->m_sfcPipeOut ? true : false;
1719 if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
1720 {
1721 sendSFC = (m_sfcState->m_sfcPipeOut ? true : false) && CodecHalDecodeScalabilityIsFinalBEPhase(m_scalabilityState);
1722 }
1723 if (sendSFC)
1724 {
1725 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->RenderStart());
1726 }
1727 #endif
1728 return eStatus;
1729 }
1730
AllocateStandard(CodechalSetting * settings)1731 MOS_STATUS CodechalDecodeHevcG11::AllocateStandard (
1732 CodechalSetting * settings)
1733 {
1734 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1735
1736 CODECHAL_DECODE_FUNCTION_ENTER;
1737
1738 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
1739
1740 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
1741
1742 m_width = settings->width;
1743 m_height = settings->height;
1744 m_is10BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS) ? true : false;
1745 m_chromaFormatinProfile = settings->chromaFormat;
1746 m_shortFormatInUse = settings->shortFormatInUse;
1747
1748 #ifdef _DECODE_PROCESSING_SUPPORTED
1749 m_sfcState = MOS_New(CodechalHevcSfcState);
1750 CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
1751 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
1752 this,
1753 m_hwInterface,
1754 m_osInterface));
1755 #endif
1756
1757 MOS_ZeroMemory(&m_currPic, sizeof(m_currPic));
1758
1759 m_frameIdx = 0;
1760
1761 if (m_shortFormatInUse)
1762 {
1763 // Legacy SF has 2 passes, 1st pass is S2L, 2nd pass is HEVC Long decode
1764 // The pass number will be changed again if is scalable decode mode.
1765 m_decodePassNum = 2;
1766
1767 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
1768 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1769 MOS_UserFeature_ReadValue_ID(
1770 nullptr,
1771 __MEDIA_USER_FEATURE_VALUE_HEVC_SF_2_DMA_SUBMITS_ENABLE_ID,
1772 &userFeatureData,
1773 m_osInterface->pOsContext);
1774 m_enableSf2DmaSubmits = userFeatureData.u32Data ? true : false;
1775 }
1776
1777 MHW_VDBOX_STATE_CMDSIZE_PARAMS_G11 stateCmdSizeParams;
1778 stateCmdSizeParams.bShortFormat = m_shortFormatInUse;
1779 stateCmdSizeParams.bHucDummyStream = (m_secureDecoder ? m_secureDecoder->IsDummyStreamEnabled() : false);
1780 stateCmdSizeParams.bScalableMode = static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported();
1781
1782 // Picture Level Commands
1783 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxStateCommandSize(
1784 m_mode,
1785 &m_commandBufferSizeNeeded,
1786 &m_commandPatchListSizeNeeded,
1787 &stateCmdSizeParams));
1788
1789 // Primitive Level Commands
1790 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxPrimitiveCommandSize(
1791 m_mode,
1792 &m_standardDecodeSizeNeeded,
1793 &m_standardDecodePatchListSizeNeeded,
1794 m_shortFormatInUse));
1795
1796 if (MOS_VE_SUPPORTED(m_osInterface))
1797 {
1798 if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
1799 {
1800 m_scalabilityState = (PCODECHAL_DECODE_SCALABILITY_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SCALABILITY_STATE));
1801 CODECHAL_DECODE_CHK_NULL_RETURN(m_scalabilityState);
1802 //scalability initialize
1803 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitializeState(
1804 this,
1805 m_scalabilityState,
1806 m_hwInterface,
1807 m_shortFormatInUse));
1808 }
1809 else
1810 {
1811 //single pipe VE initialize
1812 m_sinlgePipeVeState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
1813 CODECHAL_DECODE_CHK_NULL_RETURN(m_sinlgePipeVeState);
1814 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_sinlgePipeVeState));
1815 }
1816 }
1817
1818 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeHevc::AllocateResourcesFixedSizes());
1819
1820 // Prepare Pic Params
1821 m_picMhwParams.PipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G11);
1822 m_picMhwParams.SurfaceParams = MOS_New(MHW_VDBOX_SURFACE_PARAMS);
1823 m_picMhwParams.PipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G11);
1824 m_picMhwParams.IndObjBaseAddrParams = MOS_New(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS);
1825 m_picMhwParams.QmParams = MOS_New(MHW_VDBOX_QM_PARAMS);
1826 m_picMhwParams.HevcPicState = MOS_New(MHW_VDBOX_HEVC_PIC_STATE_G11);
1827 m_picMhwParams.HevcTileState = MOS_New(MHW_VDBOX_HEVC_TILE_STATE);
1828
1829 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.PipeModeSelectParams);
1830 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.SurfaceParams);
1831 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.PipeBufAddrParams);
1832 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.IndObjBaseAddrParams);
1833 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.QmParams);
1834 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.HevcPicState);
1835 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.HevcTileState);
1836
1837 MOS_ZeroMemory(m_picMhwParams.SurfaceParams, sizeof(MHW_VDBOX_SURFACE_PARAMS));
1838 MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
1839 MOS_ZeroMemory(m_picMhwParams.QmParams, sizeof(MHW_VDBOX_QM_PARAMS));
1840 MOS_ZeroMemory(m_picMhwParams.HevcTileState, sizeof(MHW_VDBOX_HEVC_TILE_STATE));
1841
1842 return eStatus;
1843 }
1844
CodechalDecodeHevcG11(CodechalHwInterface * hwInterface,CodechalDebugInterface * debugInterface,PCODECHAL_STANDARD_INFO standardInfo)1845 CodechalDecodeHevcG11::CodechalDecodeHevcG11(
1846 CodechalHwInterface * hwInterface,
1847 CodechalDebugInterface *debugInterface,
1848 PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecodeHevc(hwInterface, debugInterface, standardInfo),
1849 m_hevcExtPicParams(nullptr),
1850 m_hevcExtSliceParams(nullptr),
1851 m_frameSizeMaxAlloced(0),
1852 m_sinlgePipeVeState(nullptr),
1853 m_scalabilityState(nullptr)
1854 {
1855 CODECHAL_DECODE_FUNCTION_ENTER;
1856
1857 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
1858
1859 m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
1860 }
1861
1862 #if USE_CODECHAL_DEBUG_TOOL
DumpPicParams(PCODEC_HEVC_PIC_PARAMS picParams,PCODEC_HEVC_EXT_PIC_PARAMS extPicParams)1863 MOS_STATUS CodechalDecodeHevcG11::DumpPicParams(
1864 PCODEC_HEVC_PIC_PARAMS picParams,
1865 PCODEC_HEVC_EXT_PIC_PARAMS extPicParams)
1866 {
1867 CODECHAL_DEBUG_FUNCTION_ENTER;
1868
1869 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
1870 {
1871 return MOS_STATUS_SUCCESS;
1872 }
1873
1874 CODECHAL_DEBUG_CHK_NULL(picParams);
1875
1876 std::ostringstream oss;
1877 oss.setf(std::ios::showbase | std::ios::uppercase);
1878 oss.setf(std::ios::hex, std::ios::basefield);
1879
1880 oss << "PicWidthInMinCbsY: " << +picParams->PicWidthInMinCbsY << std::endl;
1881 oss << "PicHeightInMinCbsY: " << +picParams->PicHeightInMinCbsY << std::endl;
1882 //wFormatAndSequenceInfoFlags
1883 oss << "chroma_format_idc: " << +picParams->chroma_format_idc << std::endl;
1884 oss << "separate_colour_plane_flag: " << +picParams->separate_colour_plane_flag << std::endl;
1885 oss << "bit_depth_luma_minus8: " << +picParams->bit_depth_luma_minus8 << std::endl;
1886 oss << "bit_depth_chroma_minus8: " << +picParams->bit_depth_chroma_minus8 << std::endl;
1887 oss << "log2_max_pic_order_cnt_lsb_minus4: " << +picParams->log2_max_pic_order_cnt_lsb_minus4 << std::endl;
1888 oss << "NoPicReorderingFlag: " << +picParams->NoPicReorderingFlag << std::endl;
1889 oss << "ReservedBits1: " << +picParams->ReservedBits1 << std::endl;
1890 oss << "wFormatAndSequenceInfoFlags: " << +picParams->wFormatAndSequenceInfoFlags << std::endl;
1891 oss << "CurrPic FrameIdx: " << +picParams->CurrPic.FrameIdx << std::endl;
1892 oss << "CurrPic PicFlags: " << +picParams->CurrPic.PicFlags << std::endl;
1893 oss << "sps_max_dec_pic_buffering_minus1: " << +picParams->sps_max_dec_pic_buffering_minus1 << std::endl;
1894 oss << "log2_min_luma_coding_block_size_minus3: " << +picParams->log2_min_luma_coding_block_size_minus3 << std::endl;
1895 oss << "log2_diff_max_min_luma_coding_block_size: " << +picParams->log2_diff_max_min_luma_coding_block_size << std::endl;
1896 oss << "log2_min_transform_block_size_minus2: " << +picParams->log2_min_transform_block_size_minus2 << std::endl;
1897 oss << "log2_diff_max_min_transform_block_size: " << +picParams->log2_diff_max_min_transform_block_size << std::endl;
1898 oss << "max_transform_hierarchy_depth_intra: " << +picParams->max_transform_hierarchy_depth_intra << std::endl;
1899 oss << "max_transform_hierarchy_depth_inter: " << +picParams->max_transform_hierarchy_depth_inter << std::endl;
1900 oss << "num_short_term_ref_pic_sets: " << +picParams->num_short_term_ref_pic_sets << std::endl;
1901 oss << "num_long_term_ref_pic_sps: " << +picParams->num_long_term_ref_pic_sps << std::endl;
1902 oss << "num_ref_idx_l0_default_active_minus1: " << +picParams->num_ref_idx_l0_default_active_minus1 << std::endl;
1903 oss << "num_ref_idx_l1_default_active_minus1: " << +picParams->num_ref_idx_l1_default_active_minus1 << std::endl;
1904 oss << "init_qp_minus26: " << +picParams->init_qp_minus26 << std::endl;
1905 oss << "ucNumDeltaPocsOfRefRpsIdx: " << +picParams->ucNumDeltaPocsOfRefRpsIdx << std::endl;
1906 oss << "wNumBitsForShortTermRPSInSlice: " << +picParams->wNumBitsForShortTermRPSInSlice << std::endl;
1907 oss << "ReservedBits2: " << +picParams->ReservedBits2 << std::endl;
1908 //dwCodingParamToolFlags
1909 oss << "scaling_list_enabled_flag: " << +picParams->scaling_list_enabled_flag << std::endl;
1910 oss << "amp_enabled_flag: " << +picParams->amp_enabled_flag << std::endl;
1911 oss << "sample_adaptive_offset_enabled_flag: " << +picParams->sample_adaptive_offset_enabled_flag << std::endl;
1912 oss << "pcm_enabled_flag: " << +picParams->pcm_enabled_flag << std::endl;
1913 oss << "pcm_sample_bit_depth_luma_minus1: " << +picParams->pcm_sample_bit_depth_luma_minus1 << std::endl;
1914 oss << "pcm_sample_bit_depth_chroma_minus1: " << +picParams->pcm_sample_bit_depth_chroma_minus1 << std::endl;
1915 oss << "log2_min_pcm_luma_coding_block_size_minus3: " << +picParams->log2_min_pcm_luma_coding_block_size_minus3 << std::endl;
1916 oss << "log2_diff_max_min_pcm_luma_coding_block_size: " << +picParams->log2_diff_max_min_pcm_luma_coding_block_size << std::endl;
1917 oss << "pcm_loop_filter_disabled_flag: " << +picParams->pcm_loop_filter_disabled_flag << std::endl;
1918 oss << "long_term_ref_pics_present_flag: " << +picParams->long_term_ref_pics_present_flag << std::endl;
1919 oss << "sps_temporal_mvp_enabled_flag: " << +picParams->sps_temporal_mvp_enabled_flag << std::endl;
1920 oss << "strong_intra_smoothing_enabled_flag: " << +picParams->strong_intra_smoothing_enabled_flag << std::endl;
1921 oss << "dependent_slice_segments_enabled_flag: " << +picParams->dependent_slice_segments_enabled_flag << std::endl;
1922 oss << "output_flag_present_flag: " << +picParams->output_flag_present_flag << std::endl;
1923 oss << "num_extra_slice_header_bits: " << +picParams->num_extra_slice_header_bits << std::endl;
1924 oss << "sign_data_hiding_enabled_flag: " << +picParams->sign_data_hiding_enabled_flag << std::endl;
1925 oss << "cabac_init_present_flag: " << +picParams->cabac_init_present_flag << std::endl;
1926 oss << "ReservedBits3: " << +picParams->ReservedBits3 << std::endl;
1927 oss << "dwCodingParamToolFlags: " << +picParams->dwCodingParamToolFlags << std::endl;
1928 //dwCodingSettingPicturePropertyFlags
1929 oss << "constrained_intra_pred_flag: " << +picParams->constrained_intra_pred_flag << std::endl;
1930 oss << "transform_skip_enabled_flag: " << +picParams->transform_skip_enabled_flag << std::endl;
1931 oss << "cu_qp_delta_enabled_flag: " << +picParams->cu_qp_delta_enabled_flag << std::endl;
1932 oss << "diff_cu_qp_delta_depth: " << +picParams->diff_cu_qp_delta_depth << std::endl;
1933 oss << "pps_slice_chroma_qp_offsets_present_flag: " << +picParams->pps_slice_chroma_qp_offsets_present_flag << std::endl;
1934 oss << "weighted_pred_flag: " << +picParams->weighted_pred_flag << std::endl;
1935 oss << "weighted_bipred_flag: " << +picParams->weighted_bipred_flag << std::endl;
1936 oss << "transquant_bypass_enabled_flag: " << +picParams->transquant_bypass_enabled_flag << std::endl;
1937 oss << "tiles_enabled_flag: " << +picParams->tiles_enabled_flag << std::endl;
1938 oss << "entropy_coding_sync_enabled_flag: " << +picParams->entropy_coding_sync_enabled_flag << std::endl;
1939 oss << "uniform_spacing_flag: " << +picParams->uniform_spacing_flag << std::endl;
1940 oss << "loop_filter_across_tiles_enabled_flag: " << +picParams->loop_filter_across_tiles_enabled_flag << std::endl;
1941 oss << "pps_loop_filter_across_slices_enabled_flag: " << +picParams->pps_loop_filter_across_slices_enabled_flag << std::endl;
1942 oss << "deblocking_filter_override_enabled_flag: " << +picParams->deblocking_filter_override_enabled_flag << std::endl;
1943 oss << "pps_deblocking_filter_disabled_flag: " << +picParams->pps_deblocking_filter_disabled_flag << std::endl;
1944 oss << "lists_modification_present_flag: " << +picParams->lists_modification_present_flag << std::endl;
1945 oss << "slice_segment_header_extension_present_flag: " << +picParams->slice_segment_header_extension_present_flag << std::endl;
1946 oss << "IrapPicFlag: " << +picParams->IrapPicFlag << std::endl;
1947 oss << "IdrPicFlag: " << +picParams->IdrPicFlag << std::endl;
1948 oss << "IntraPicFlag: " << +picParams->IntraPicFlag << std::endl;
1949 oss << "ReservedBits4: " << +picParams->ReservedBits4 << std::endl;
1950 oss << "dwCodingSettingPicturePropertyFlags: " << +picParams->dwCodingSettingPicturePropertyFlags << std::endl;
1951 oss << "pps_cb_qp_offset: " << +picParams->pps_cb_qp_offset << std::endl;
1952 oss << "pps_cr_qp_offset: " << +picParams->pps_cr_qp_offset << std::endl;
1953 oss << "num_tile_columns_minus1: " << +picParams->num_tile_columns_minus1 << std::endl;
1954 oss << "num_tile_rows_minus1: " << +picParams->num_tile_rows_minus1 << std::endl;
1955 //Dump column width
1956 oss << "column_width_minus1[19]:";
1957 for (uint8_t i = 0; i < 19; i++)
1958 oss << picParams->column_width_minus1[i] << " ";
1959 oss << std::endl;
1960
1961 //Dump row height
1962 oss << "row_height_minus1[21]:";
1963 for (uint8_t i = 0; i < 21; i++)
1964 oss << picParams->row_height_minus1[i] << " ";
1965 oss << std::endl;
1966
1967 oss << "pps_beta_offset_div2: " << +picParams->pps_beta_offset_div2 << std::endl;
1968 oss << "pps_tc_offset_div2: " << +picParams->pps_tc_offset_div2 << std::endl;
1969 oss << "log2_parallel_merge_level_minus2: " << +picParams->log2_parallel_merge_level_minus2 << std::endl;
1970 oss << "CurrPicOrderCntVal: " << +picParams->CurrPicOrderCntVal << std::endl;
1971
1972 oss.setf(std::ios::dec, std::ios::basefield);
1973 //Dump RefFrameList[15]
1974 for (uint8_t i = 0; i < 15; ++i)
1975 {
1976 oss << "RefFrameList[" << +i << "] FrameIdx:" << +picParams->RefFrameList[i].FrameIdx << std::endl;
1977 oss << "RefFrameList[" << +i << "] PicFlags:" << +picParams->RefFrameList[i].PicFlags << std::endl;
1978 }
1979
1980 //Dump POC List
1981 oss << "PicOrderCntValList[15]:";
1982 for (uint8_t i = 0; i < 15; i++)
1983 oss << std::hex << picParams->PicOrderCntValList[i] << " ";
1984 oss << std::endl;
1985
1986 //Dump Ref RefPicSetStCurrBefore List
1987 oss << "RefPicSetStCurrBefore[8]:";
1988 for (uint8_t i = 0; i < 8; i++)
1989 oss << picParams->RefPicSetStCurrBefore[i] << " ";
1990 oss << std::endl;
1991
1992 //Dump Ref RefPicSetStCurrAfter List
1993 oss << "RefPicSetStCurrAfter[16]:";
1994 for (uint8_t i = 0; i < 8; i++)
1995 oss << picParams->RefPicSetStCurrAfter[i] << " ";
1996 oss << std::endl;
1997
1998 //Dump Ref PicSetStCurr List
1999 oss << "RefPicSetLtCurr[16]:";
2000 for (uint8_t i = 0; i < 8; i++)
2001 oss << picParams->RefPicSetLtCurr[i] << " ";
2002 oss << std::endl;
2003
2004 //Dump Ref RefPicSetStCurrBefore List with POC
2005 oss << "RefPicSetStCurrBefore[8] (POC): ";
2006 for (uint8_t i = 0; i < 8; i++)
2007 oss << picParams->PicOrderCntValList[picParams->RefPicSetStCurrBefore[i]] << " ";
2008 oss << std::endl;
2009
2010 //Dump Ref RefPicSetStCurrAfter List with POC
2011 oss << "RefPicSetStCurrAfter[16] (POC):";
2012 for (uint8_t i = 0; i < 8; i++)
2013 oss << picParams->PicOrderCntValList[picParams->RefPicSetStCurrAfter[i]] << " ";
2014 oss << std::endl;
2015
2016 //Dump Ref PicSetStCurr List with POC
2017 oss << "RefPicSetLtCurr[16] (POC): ";
2018 for (uint8_t i = 0; i < 8; i++)
2019 oss << picParams->PicOrderCntValList[picParams->RefPicSetLtCurr[i]] << " ";
2020 oss << std::endl;
2021
2022 oss << "RefFieldPicFlag: " << +picParams->RefFieldPicFlag << std::endl;
2023 oss << "RefBottomFieldFlag: " << +picParams->RefBottomFieldFlag << std::endl;
2024 oss << "StatusReportFeedbackNumber: " << +picParams->StatusReportFeedbackNumber << std::endl;
2025
2026 if (extPicParams)
2027 {
2028 //PicRangeExtensionFlags
2029 oss << "transform_skip_rotation_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.transform_skip_rotation_enabled_flag << std::endl;
2030 oss << "transform_skip_context_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.transform_skip_context_enabled_flag << std::endl;
2031 oss << "implicit_rdpcm_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.implicit_rdpcm_enabled_flag << std::endl;
2032 oss << "explicit_rdpcm_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.explicit_rdpcm_enabled_flag << std::endl;
2033 oss << "extended_precision_processing_flag: " << +extPicParams->PicRangeExtensionFlags.fields.extended_precision_processing_flag << std::endl;
2034 oss << "intra_smoothing_disabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.intra_smoothing_disabled_flag << std::endl;
2035 oss << "high_precision_offsets_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.high_precision_offsets_enabled_flag << std::endl;
2036 oss << "persistent_rice_adaptation_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.persistent_rice_adaptation_enabled_flag << std::endl;
2037 oss << "cabac_bypass_alignment_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.cabac_bypass_alignment_enabled_flag << std::endl;
2038 oss << "cross_component_prediction_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.cross_component_prediction_enabled_flag << std::endl;
2039 oss << "chroma_qp_offset_list_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.chroma_qp_offset_list_enabled_flag << std::endl;
2040 oss << "BitDepthLuma16: " << +extPicParams->PicRangeExtensionFlags.fields.BitDepthLuma16 << std::endl;
2041 oss << "BitDepthChroma16: " << +extPicParams->PicRangeExtensionFlags.fields.BitDepthChroma16 << std::endl;
2042 oss << "diff_cu_chroma_qp_offset_depth: " << +extPicParams->diff_cu_chroma_qp_offset_depth << std::endl;
2043 oss << "chroma_qp_offset_list_len_minus1: " << +extPicParams->chroma_qp_offset_list_len_minus1 << std::endl;
2044 oss << "log2_sao_offset_scale_luma: " << +extPicParams->log2_sao_offset_scale_luma << std::endl;
2045 oss << "log2_sao_offset_scale_chroma: " << +extPicParams->log2_sao_offset_scale_chroma << std::endl;
2046 oss << "log2_max_transform_skip_block_size_minus2: " << +extPicParams->log2_max_transform_skip_block_size_minus2 << std::endl;
2047
2048 //Dump cb_qp_offset_list[6]
2049 oss << "cb_qp_offset_list[6]: ";
2050 for (uint8_t i = 0; i < 6; i++)
2051 oss << extPicParams->cb_qp_offset_list[i] << " ";
2052 oss << std::endl;
2053
2054 //Dump cr_qp_offset_list[6]
2055 oss << "cr_qp_offset_list[6]: ";
2056 for (uint8_t i = 0; i < 6; i++)
2057 oss << extPicParams->cr_qp_offset_list[i] << " ";
2058 }
2059
2060 const char *fileName = m_debugInterface->CreateFileName(
2061 "_DEC",
2062 CodechalDbgBufferType::bufPicParams,
2063 CodechalDbgExtType::txt);
2064
2065 std::ofstream ofs(fileName, std::ios::out);
2066 ofs << oss.str();
2067 ofs.close();
2068
2069 return MOS_STATUS_SUCCESS;
2070 }
2071
DumpSliceParams(PCODEC_HEVC_SLICE_PARAMS sliceParams,PCODEC_HEVC_EXT_SLICE_PARAMS extSliceParams,uint32_t numSlices,bool shortFormatInUse)2072 MOS_STATUS CodechalDecodeHevcG11::DumpSliceParams(
2073 PCODEC_HEVC_SLICE_PARAMS sliceParams,
2074 PCODEC_HEVC_EXT_SLICE_PARAMS extSliceParams,
2075 uint32_t numSlices,
2076 bool shortFormatInUse)
2077 {
2078 CODECHAL_DEBUG_FUNCTION_ENTER;
2079 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
2080 {
2081 return MOS_STATUS_SUCCESS;
2082 }
2083
2084 CODECHAL_DEBUG_CHK_NULL(sliceParams);
2085
2086 PCODEC_HEVC_SLICE_PARAMS hevcSliceControl = nullptr;
2087 PCODEC_HEVC_EXT_SLICE_PARAMS hevcExtSliceControl = nullptr;
2088
2089 std::ostringstream oss;
2090 oss.setf(std::ios::showbase | std::ios::uppercase);
2091
2092 for (uint16_t j = 0; j < numSlices; j++)
2093 {
2094 hevcSliceControl = &sliceParams[j];
2095 if (extSliceParams)
2096 {
2097 hevcExtSliceControl = &extSliceParams[j];
2098 }
2099
2100 oss << "====================================================================================================" << std::endl;
2101 oss << "Data for Slice number = " << +j << std::endl;
2102 oss << "slice_data_size: " << +hevcSliceControl->slice_data_size << std::endl;
2103 oss << "slice_data_offset: " << +hevcSliceControl->slice_data_offset << std::endl;
2104
2105 if (!shortFormatInUse)
2106 {
2107 //Dump Long format specific
2108 oss << "ByteOffsetToSliceData: " << +hevcSliceControl->ByteOffsetToSliceData << std::endl;
2109 oss << "slice_segment_address: " << +hevcSliceControl->slice_segment_address << std::endl;
2110
2111 //Dump RefPicList[2][15]
2112 for (uint8_t i = 0; i < 15; ++i)
2113 {
2114 oss << "RefPicList[0][" << +i << "]";
2115 oss << "FrameIdx: " << +hevcSliceControl->RefPicList[0][i].FrameIdx;
2116 oss << ", PicFlags: " << +hevcSliceControl->RefPicList[0][i].PicFlags;
2117 oss << std::endl;
2118 }
2119 for (uint8_t i = 0; i < 15; ++i)
2120 {
2121 oss << "RefPicList[1][" << +i << "]";
2122 oss << "FrameIdx: " << +hevcSliceControl->RefPicList[1][i].FrameIdx;
2123 oss << ", PicFlags: " << +hevcSliceControl->RefPicList[1][i].PicFlags;
2124 oss << std::endl;
2125 }
2126
2127 oss << "last_slice_of_pic: " << +hevcSliceControl->LongSliceFlags.fields.LastSliceOfPic << std::endl;
2128 oss << "dependent_slice_segment_flag: " << +hevcSliceControl->LongSliceFlags.fields.dependent_slice_segment_flag << std::endl;
2129 oss << "slice_type: " << +hevcSliceControl->LongSliceFlags.fields.slice_type << std::endl;
2130 oss << "color_plane_id: " << +hevcSliceControl->LongSliceFlags.fields.color_plane_id << std::endl;
2131 oss << "slice_sao_luma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_luma_flag << std::endl;
2132 oss << "slice_sao_chroma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_chroma_flag << std::endl;
2133 oss << "mvd_l1_zero_flag: " << +hevcSliceControl->LongSliceFlags.fields.mvd_l1_zero_flag << std::endl;
2134 oss << "cabac_init_flag: " << +hevcSliceControl->LongSliceFlags.fields.cabac_init_flag << std::endl;
2135 oss << "slice_temporal_mvp_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag << std::endl;
2136 oss << "slice_deblocking_filter_disabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag << std::endl;
2137 oss << "collocated_from_l0_flag: " << +hevcSliceControl->LongSliceFlags.fields.collocated_from_l0_flag << std::endl;
2138 oss << "slice_loop_filter_across_slices_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag << std::endl;
2139 oss << "reserved: " << +hevcSliceControl->LongSliceFlags.fields.reserved << std::endl;
2140 oss << "collocated_ref_idx: " << +hevcSliceControl->collocated_ref_idx << std::endl;
2141 oss << "num_ref_idx_l0_active_minus1: " << +hevcSliceControl->num_ref_idx_l0_active_minus1 << std::endl;
2142 oss << "num_ref_idx_l1_active_minus1: " << +hevcSliceControl->num_ref_idx_l1_active_minus1 << std::endl;
2143 oss << "slice_qp_delta: " << +hevcSliceControl->slice_qp_delta << std::endl;
2144 oss << "slice_cb_qp_offset: " << +hevcSliceControl->slice_cb_qp_offset << std::endl;
2145 oss << "slice_cr_qp_offset: " << +hevcSliceControl->slice_cr_qp_offset << std::endl;
2146 oss << "slice_beta_offset_div2: " << +hevcSliceControl->slice_beta_offset_div2 << std::endl;
2147 oss << "slice_tc_offset_div2: " << +hevcSliceControl->slice_tc_offset_div2 << std::endl;
2148 oss << "luma_log2_weight_denom: " << +hevcSliceControl->luma_log2_weight_denom << std::endl;
2149 oss << "delta_chroma_log2_weight_denom: " << +hevcSliceControl->delta_chroma_log2_weight_denom << std::endl;
2150
2151 //Dump luma_offset[2][15]
2152 for (uint8_t i = 0; i < 15; i++)
2153 {
2154 oss << "luma_offset_l0[" << +i << "]: " << (extSliceParams ? +hevcExtSliceControl->luma_offset_l0[i] : +hevcSliceControl->luma_offset_l0[i]) << std::endl;
2155 oss << "luma_offset_l1[" << +i << "]: " << (extSliceParams ? +hevcExtSliceControl->luma_offset_l1[i] : +hevcSliceControl->luma_offset_l1[i]) << std::endl;
2156 }
2157 //Dump delta_luma_weight[2][15]
2158 for (uint8_t i = 0; i < 15; i++)
2159 {
2160 oss << "delta_luma_weight_l0[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
2161 oss << "delta_luma_weight_l1[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
2162 }
2163 //Dump chroma_offset[2][15][2]
2164 for (uint8_t i = 0; i < 15; i++)
2165 {
2166 oss << "ChromaOffsetL0[" << +i << "][0]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL0[i][0] : +hevcSliceControl->ChromaOffsetL0[i][0]) << std::endl;
2167
2168 oss << "ChromaOffsetL0[" << +i << "][1]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL0[i][1] : +hevcSliceControl->ChromaOffsetL0[i][1]) << std::endl;
2169
2170 oss << "ChromaOffsetL1[" << +i << "][0]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL1[i][0] : +hevcSliceControl->ChromaOffsetL1[i][0]) << std::endl;
2171
2172 oss << "ChromaOffsetL1[" << +i << "][1]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL1[i][1] : +hevcSliceControl->ChromaOffsetL1[i][1]) << std::endl;
2173 }
2174 //Dump delta_chroma_weight[2][15][2]
2175 for (uint8_t i = 0; i < 15; i++)
2176 {
2177 oss << "delta_chroma_weight_l0[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l0[i][0] << std::endl;
2178 oss << "delta_chroma_weight_l0[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l0[i][1] << std::endl;
2179 oss << "delta_chroma_weight_l1[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l1[i][0] << std::endl;
2180 oss << "delta_chroma_weight_l1[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l1[i][1] << std::endl;
2181 }
2182
2183 oss << "five_minus_max_num_merge_cand: " << +hevcSliceControl->five_minus_max_num_merge_cand << std::endl;
2184
2185 if (extSliceParams)
2186 {
2187 oss << "cu_chroma_qp_offset_enabled_flag: " << +hevcExtSliceControl->cu_chroma_qp_offset_enabled_flag << std::endl;
2188 }
2189 }
2190
2191 const char *fileName = m_debugInterface->CreateFileName(
2192 "_DEC",
2193 CodechalDbgBufferType::bufSlcParams,
2194 CodechalDbgExtType::txt);
2195
2196 std::ofstream ofs;
2197 if (j == 0)
2198 {
2199 ofs.open(fileName, std::ios::out);
2200 }
2201 else
2202 {
2203 ofs.open(fileName, std::ios::app);
2204 }
2205 ofs << oss.str();
2206 ofs.close();
2207 }
2208 return MOS_STATUS_SUCCESS;
2209 }
2210 #endif
2211