1 /*
2 * Copyright (c) 2012-2018, 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.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.h"
31 #include "codechal_mmc_decode_hevc.h"
32 #include "codechal_decode_nv12top010.h"
33 #include "media_interfaces_nv12top010.h"
34 #include "hal_oca_interface.h"
35 #if USE_CODECHAL_DEBUG_TOOL
36 #include "codechal_debug.h"
37 #endif
38 //==<Functions>=======================================================
39
GetMvBufferIndex(uint8_t frameIdx)40 uint8_t CodechalDecodeHevc::GetMvBufferIndex(
41 uint8_t frameIdx)
42 {
43 PCODECHAL_DECODE_HEVC_MV_LIST hevcMVBufList = &m_hevcMvList[0];
44
45 uint8_t i;
46 for (i = 0; i < CODEC_NUM_HEVC_MV_BUFFERS; i++)
47 {
48 if (!hevcMVBufList[i].bInUse)
49 {
50 hevcMVBufList[i].bInUse = true;
51 hevcMVBufList[i].u8FrameId = frameIdx;
52 break;
53 }
54 }
55 if (i == CODEC_NUM_HEVC_MV_BUFFERS)
56 {
57 // Should never happen, something must be wrong
58 CODECHAL_DECODE_ASSERTMESSAGE("Failed to get avaiable MV buffer.");
59 }
60
61 return i;
62 }
63
AllocateResourcesFixedSizes()64 MOS_STATUS CodechalDecodeHevc::AllocateResourcesFixedSizes()
65 {
66 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
67
68 CODECHAL_DECODE_FUNCTION_ENTER;
69
70 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
71 m_osInterface,
72 &m_resSyncObjectWaContextInUse));
73
74 CodecHalAllocateDataList(
75 m_hevcRefList,
76 CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC);
77
78 MOS_ZeroMemory(&m_secondLevelBatchBuffer, CODEC_HEVC_NUM_SECOND_BB * sizeof(MHW_BATCH_BUFFER));
79 if (m_shortFormatInUse)
80 {
81 // Second level batch buffer for HuC FW to use
82 uint32_t u32Size = MOS_ALIGN_CEIL(CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6 * m_standardDecodeSizeNeeded,
83 CODECHAL_PAGE_SIZE);
84
85 for (int i = 0; i < CODEC_HEVC_NUM_SECOND_BB; i++)
86 {
87 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
88 m_osInterface,
89 &m_secondLevelBatchBuffer[i],
90 nullptr,
91 u32Size));
92 m_secondLevelBatchBuffer[i].bSecondLevel = true;
93 }
94
95 // DMEM buffer send to HuC FW
96 m_dmemBufferSize = GetDmemBufferSize();
97
98 for (uint32_t i = 0; i < CODECHAL_HEVC_NUM_DMEM_BUFFERS; i++)
99 {
100 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
101 &m_resDmemBuffer[i],
102 m_dmemBufferSize,
103 "DmemBuffer"),
104 "Failed to allocate Dmem Buffer.");
105 }
106 }
107
108 return eStatus;
109 }
110
AllocateResourcesVariableSizes()111 MOS_STATUS CodechalDecodeHevc::AllocateResourcesVariableSizes()
112 {
113 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
114
115 CODECHAL_DECODE_FUNCTION_ENTER;
116
117 uint32_t widthMax = MOS_MAX(m_width, m_widthLastMaxAlloced);
118 uint32_t heightMax = MOS_MAX(m_height, m_heightLastMaxAlloced);
119 CODECHAL_DECODE_VERBOSEMESSAGE("m_width = %d, Max Width = %d, m_height %d, Max Height = %d",
120 m_width, widthMax, m_height, heightMax);
121
122 uint8_t maxBitDepth = (m_is12BitHevc) ? 12 :((m_is10BitHevc) ? 10 : 8);
123 uint8_t chromaFormatPic = m_hevcPicParams->chroma_format_idc;
124 uint8_t chromaFormat = m_chromaFormatinProfile;
125 CODECHAL_DECODE_ASSERT(chromaFormat >= chromaFormatPic);
126
127 uint32_t u32CtbLog2SizeYPic = m_hevcPicParams->log2_diff_max_min_luma_coding_block_size +
128 m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3;
129 uint32_t ctbLog2SizeY = MOS_MAX(u32CtbLog2SizeYPic, m_ctbLog2SizeYMax);
130
131 MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam;
132 MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
133 hcpBufSizeParam.ucMaxBitDepth = maxBitDepth;
134 hcpBufSizeParam.ucChromaFormat = chromaFormat;
135 hcpBufSizeParam.dwCtbLog2SizeY = ctbLog2SizeY;
136
137 MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam;
138 MOS_ZeroMemory(&reallocParam, sizeof(reallocParam));
139 reallocParam.ucMaxBitDepth = maxBitDepth;
140 reallocParam.ucChromaFormat = chromaFormat;
141 reallocParam.dwCtbLog2SizeY = ctbLog2SizeY;
142 reallocParam.dwCtbLog2SizeYMax = m_ctbLog2SizeYMax;
143
144 if (m_is8BitFrameIn10BitHevc)
145 {
146 uint32_t i;
147 // Init 8bitRTIndexMap array, 0xff means doesn't map to any InternalNV12RTSurface.
148 if (!m_internalNv12RtIndexMapInitilized)
149 {
150 for (i = 0; i < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC; i++)
151 {
152 m_internalNv12RtIndexMap[i] = 0xff;
153 }
154
155 m_internalNv12RtIndexMapInitilized = true;
156 }
157
158 if (m_internalNv12RtIndexMap[m_currPic.FrameIdx] != 0xff)
159 {
160 if (!Mos_ResourceIsNull(&m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_currPic.FrameIdx]].OsResource))
161 {
162 m_osInterface->pfnFreeResource(m_osInterface,
163 &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_currPic.FrameIdx]].OsResource);
164 }
165 }
166
167 // Seek an available surface in InternalNV12RTSurface array.
168 for (i = 0; i < CODECHAL_NUM_INTERNAL_NV12_RT_HEVC; i++)
169 {
170 if (Mos_ResourceIsNull(&m_internalNv12RtSurfaces[i].OsResource))
171 {
172 m_internalNv12RtIndexMap[m_currPic.FrameIdx] = i;
173 break;
174 }
175 }
176
177 // If there is no available InternalNV12RTSurface in the array.
178 if (i == CODECHAL_NUM_INTERNAL_NV12_RT_HEVC)
179 {
180 // Search an InternalNV12RTSurface to reuse.
181 for (uint32_t j = 0; j < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC; j++)
182 {
183 if (m_internalNv12RtIndexMap[j] != 0xff && j != m_currPic.FrameIdx)
184 {
185 uint32_t k;
186 // Check if InternalNV12RTSurface in reference list.
187 for (k = 0; k < CODEC_MAX_NUM_REF_FRAME_HEVC; k++)
188 {
189 if (j == m_hevcPicParams->RefFrameList[k].FrameIdx)
190 {
191 break;
192 }
193 }
194
195 // If InternalNV12RTSurface is not in reference list, reuse it.
196 if (k == CODEC_MAX_NUM_REF_FRAME_HEVC)
197 {
198 m_internalNv12RtIndexMap[m_currPic.FrameIdx] = m_internalNv12RtIndexMap[j];
199 m_internalNv12RtIndexMap[j] = 0xff;
200 break;
201 }
202 }
203 }
204 }
205
206 uint32_t internalNV12RTIndex = m_internalNv12RtIndexMap[m_currPic.FrameIdx];
207
208 if (Mos_ResourceIsNull(&m_internalNv12RtSurfaces[internalNV12RTIndex].OsResource) ||
209 m_destSurface.dwWidth != m_internalNv12RtSurfaces[internalNV12RTIndex].dwWidth ||
210 m_destSurface.dwHeight != m_internalNv12RtSurfaces[internalNV12RTIndex].dwHeight)
211 {
212 if (!Mos_ResourceIsNull(&m_internalNv12RtSurfaces[internalNV12RTIndex].OsResource))
213 {
214 m_osInterface->pfnFreeResource(m_osInterface, &m_internalNv12RtSurfaces[internalNV12RTIndex].OsResource);
215 }
216
217 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateSurface(
218 &m_internalNv12RtSurfaces[internalNV12RTIndex],
219 m_destSurface.dwWidth,
220 m_destSurface.dwHeight,
221 "HevcInternalNV12RTSurfaces"),
222 "Failed to allocate Hevc Internal NV12 dest surface data buffer.");
223 }
224 }
225
226 if (!m_hcpInterface->IsHevcDfRowstoreCacheEnabled())
227 {
228 uint32_t mfdDeblockingFilterRowStoreScratchBufferPicWidthMax =
229 MOS_MAX(m_width, m_mfdDeblockingFilterRowStoreScratchBufferPicWidth);
230
231 reallocParam.dwPicWidth = mfdDeblockingFilterRowStoreScratchBufferPicWidthMax;
232 reallocParam.dwPicWidthAlloced = m_mfdDeblockingFilterRowStoreScratchBufferPicWidth;
233 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
234 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE,
235 &reallocParam));
236 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
237 {
238 if (!Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
239 {
240 m_osInterface->pfnFreeResource(
241 m_osInterface,
242 &m_resMfdDeblockingFilterRowStoreScratchBuffer);
243 }
244
245 // Deblocking Filter Row Store Scratch buffer
246 hcpBufSizeParam.dwPicWidth = mfdDeblockingFilterRowStoreScratchBufferPicWidthMax;
247 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
248 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE,
249 &hcpBufSizeParam));
250
251 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
252 &m_resMfdDeblockingFilterRowStoreScratchBuffer,
253 hcpBufSizeParam.dwBufferSize,
254 "DeblockingScratchBuffer"),
255 "Failed to allocate Deblocking Filter Row Store Scratch Buffer.");
256 }
257
258 //record the width and height used for allocation internal resources.
259 m_mfdDeblockingFilterRowStoreScratchBufferPicWidth = mfdDeblockingFilterRowStoreScratchBufferPicWidthMax;
260 }
261
262 reallocParam.dwPicWidth = widthMax;
263 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
264 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
265 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE,
266 &reallocParam));
267 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resDeblockingFilterTileRowStoreScratchBuffer))
268 {
269 if (!Mos_ResourceIsNull(&m_resDeblockingFilterTileRowStoreScratchBuffer))
270 {
271 m_osInterface->pfnFreeResource(
272 m_osInterface,
273 &m_resDeblockingFilterTileRowStoreScratchBuffer);
274 }
275
276 // Deblocking Filter Tile Row Store Scratch data surface
277 hcpBufSizeParam.dwPicWidth = widthMax;
278 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
279 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE,
280 &hcpBufSizeParam));
281
282 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
283 &m_resDeblockingFilterTileRowStoreScratchBuffer,
284 hcpBufSizeParam.dwBufferSize,
285 "DeblockingTileScratchBuffer"),
286 "Failed to allocate Deblocking Filter Tile Row Store Scratch Buffer.");
287 }
288
289 reallocParam.dwPicHeight = heightMax;
290 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
291 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
292 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL,
293 &reallocParam));
294 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resDeblockingFilterColumnRowStoreScratchBuffer))
295 {
296 if (!Mos_ResourceIsNull(&m_resDeblockingFilterColumnRowStoreScratchBuffer))
297 {
298 m_osInterface->pfnFreeResource(
299 m_osInterface,
300 &m_resDeblockingFilterColumnRowStoreScratchBuffer);
301 }
302 // Deblocking Filter Column Row Store Scratch data surface
303 hcpBufSizeParam.dwPicHeight = heightMax;
304 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
305 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL,
306 &hcpBufSizeParam));
307
308 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
309 &m_resDeblockingFilterColumnRowStoreScratchBuffer,
310 hcpBufSizeParam.dwBufferSize,
311 "DeblockingColumnScratchBuffer"),
312 "Failed to allocate Deblocking Filter Column Row Store Scratch Buffer.");
313 }
314
315 if (!m_hcpInterface->IsHevcDatRowstoreCacheEnabled())
316 {
317 uint32_t metadataLineBufferPicWidthMax =
318 MOS_MAX(m_width, m_metadataLineBufferPicWidth);
319
320 reallocParam.dwPicWidth = metadataLineBufferPicWidthMax;
321 reallocParam.dwPicWidthAlloced = m_metadataLineBufferPicWidth;
322 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
323 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE,
324 &reallocParam));
325
326 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resMetadataLineBuffer))
327 {
328 if (!Mos_ResourceIsNull(&m_resMetadataLineBuffer))
329 {
330 m_osInterface->pfnFreeResource(
331 m_osInterface,
332 &m_resMetadataLineBuffer);
333 }
334
335 // Metadata Line buffer
336 hcpBufSizeParam.dwPicWidth = metadataLineBufferPicWidthMax;
337 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
338 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE,
339 &hcpBufSizeParam));
340
341 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
342 &m_resMetadataLineBuffer,
343 hcpBufSizeParam.dwBufferSize,
344 "MetadataLineBuffer"),
345 "Failed to allocate Metadata Line Buffer.");
346 }
347
348 //record the width and height used for allocation internal resources.
349 m_metadataLineBufferPicWidth = metadataLineBufferPicWidthMax;
350 }
351
352 reallocParam.dwPicWidth = widthMax;
353 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
354 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
355 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE,
356 &reallocParam));
357 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resMetadataTileLineBuffer))
358 {
359 if (!Mos_ResourceIsNull(&m_resMetadataTileLineBuffer))
360 {
361 m_osInterface->pfnFreeResource(
362 m_osInterface,
363 &m_resMetadataTileLineBuffer);
364 }
365 // Metadata Tile Line buffer
366 hcpBufSizeParam.dwPicWidth = widthMax;
367 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
368 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE,
369 &hcpBufSizeParam));
370
371 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
372 &m_resMetadataTileLineBuffer,
373 hcpBufSizeParam.dwBufferSize,
374 "MetadataTileLineBuffer"),
375 "Failed to allocate Metadata Tile Line Buffer.");
376 }
377
378 reallocParam.dwPicHeight = heightMax;
379 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
380 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
381 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL,
382 &reallocParam));
383 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resMetadataTileColumnBuffer))
384 {
385 if (!Mos_ResourceIsNull(&m_resMetadataTileColumnBuffer))
386 {
387 m_osInterface->pfnFreeResource(
388 m_osInterface,
389 &m_resMetadataTileColumnBuffer);
390 }
391 // Metadata Tile Column buffer
392 hcpBufSizeParam.dwPicHeight = heightMax;
393 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
394 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL,
395 &hcpBufSizeParam));
396
397 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
398 &m_resMetadataTileColumnBuffer,
399 hcpBufSizeParam.dwBufferSize,
400 "MetadataTileColumnBuffer"),
401 "Failed to allocate Metadata Tile Column Buffer.");
402 }
403
404 if (!m_hcpInterface->IsHevcSaoRowstoreCacheEnabled())
405 {
406 uint32_t saoLineBufferPicWidthMax =
407 MOS_MAX(m_width, m_saoLineBufferPicWidth);
408
409 reallocParam.dwPicWidth = saoLineBufferPicWidthMax;
410 reallocParam.dwPicWidthAlloced = m_saoLineBufferPicWidth;
411 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
412 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE,
413 &reallocParam));
414 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resSaoLineBuffer))
415 {
416 if (!Mos_ResourceIsNull(&m_resSaoLineBuffer))
417 {
418 m_osInterface->pfnFreeResource(
419 m_osInterface,
420 &m_resSaoLineBuffer);
421 }
422
423 // SAO Line buffer
424 hcpBufSizeParam.dwPicWidth = saoLineBufferPicWidthMax;
425 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
426 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE,
427 &hcpBufSizeParam));
428
429 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
430 &m_resSaoLineBuffer,
431 hcpBufSizeParam.dwBufferSize,
432 "SaoLineBuffer"),
433 "Failed to allocate SAO Line Buffer.");
434 }
435
436 //record the width and height used for allocation internal resources.
437 m_saoLineBufferPicWidth = saoLineBufferPicWidthMax;
438 }
439
440 reallocParam.dwPicWidth = widthMax;
441 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
442 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
443 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE,
444 &reallocParam));
445 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resSaoTileLineBuffer))
446 {
447 if (!Mos_ResourceIsNull(&m_resSaoTileLineBuffer))
448 {
449 m_osInterface->pfnFreeResource(
450 m_osInterface,
451 &m_resSaoTileLineBuffer);
452 }
453 // SAO Tile Line buffer
454 hcpBufSizeParam.dwPicWidth = widthMax;
455 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
456 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE,
457 &hcpBufSizeParam));
458
459 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
460 &m_resSaoTileLineBuffer,
461 hcpBufSizeParam.dwBufferSize,
462 "SaoTileLineBuffer"),
463 "Failed to allocate SAO Tile Line Buffer.");
464 }
465
466 reallocParam.dwPicHeight = heightMax;
467 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
468 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
469 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL,
470 &reallocParam));
471 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resSaoTileColumnBuffer))
472 {
473 if (!Mos_ResourceIsNull(&m_resSaoTileColumnBuffer))
474 {
475 m_osInterface->pfnFreeResource(
476 m_osInterface,
477 &m_resSaoTileColumnBuffer);
478 }
479 // SAO Tile Column buffer
480 hcpBufSizeParam.dwPicHeight = heightMax;
481 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
482 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL,
483 &hcpBufSizeParam));
484
485 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
486 &m_resSaoTileColumnBuffer,
487 hcpBufSizeParam.dwBufferSize,
488 "SaoTileColumnBuffer"),
489 "Failed to allocate SAO Tile Column Buffer.");
490 }
491
492 for (uint8_t i = 0; i < CODEC_NUM_HEVC_INITIAL_MV_BUFFERS; i++)
493 {
494 AllocateMvTemporalBuffer(i);
495 }
496 m_mvBufferProgrammed = true;
497
498 if (m_secureDecoder)
499 {
500 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AllocateResource(this));
501 }
502
503 m_widthLastMaxAlloced = widthMax;
504 m_heightLastMaxAlloced = heightMax;
505 m_ctbLog2SizeYMax = ctbLog2SizeY;
506
507 return eStatus;
508 }
509
AllocateMvTemporalBuffer(uint8_t hevcMvBuffIndex)510 MOS_STATUS CodechalDecodeHevc::AllocateMvTemporalBuffer(
511 uint8_t hevcMvBuffIndex)
512 {
513 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
514 CODECHAL_DECODE_FUNCTION_ENTER;
515
516 if (hevcMvBuffIndex == CODEC_NUM_HEVC_MV_BUFFERS)
517 {
518 // Should never happen, something must be wrong
519 CODECHAL_DECODE_ASSERTMESSAGE("Failed to get avaiable MV buffer.");
520 return MOS_STATUS_INVALID_PARAMETER;
521 }
522
523 uint32_t widthMax = MOS_MAX(m_width, m_widthLastMaxAlloced);
524 uint32_t heightMax = MOS_MAX(m_height, m_heightLastMaxAlloced);
525
526 MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam;
527 MOS_ZeroMemory(&reallocParam, sizeof(reallocParam));
528
529 reallocParam.dwPicWidth = widthMax;
530 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
531 reallocParam.dwPicHeight = heightMax;
532 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
533 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
534 MHW_VDBOX_HCP_INTERNAL_BUFFER_CURR_MV_TEMPORAL,
535 &reallocParam));
536
537 int32_t isResMvTemporalBufferNull = Mos_ResourceIsNull(&m_resMvTemporalBuffer[hevcMvBuffIndex]);
538
539 if (reallocParam.bNeedBiggerSize || isResMvTemporalBufferNull)
540 {
541 MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam;
542 MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
543
544 if (!isResMvTemporalBufferNull)
545 {
546 m_osInterface->pfnFreeResource(
547 m_osInterface,
548 &m_resMvTemporalBuffer[hevcMvBuffIndex]);
549 }
550
551 // MV Temporal buffers
552 hcpBufSizeParam.dwPicWidth = widthMax;
553 hcpBufSizeParam.dwPicHeight = heightMax;
554 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
555 MHW_VDBOX_HCP_INTERNAL_BUFFER_CURR_MV_TEMPORAL,
556 &hcpBufSizeParam));
557 m_mvBufferSize = hcpBufSizeParam.dwBufferSize;
558
559 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
560 &m_resMvTemporalBuffer[hevcMvBuffIndex],
561 hcpBufSizeParam.dwBufferSize,
562 "CurrentMvTemporalBuffer"),
563 "Failed to allocate MV Temporal Buffer.");
564 }
565
566 return eStatus;
567 }
568
~CodechalDecodeHevc()569 CodechalDecodeHevc::~CodechalDecodeHevc ()
570 {
571 CODECHAL_DECODE_FUNCTION_ENTER;
572
573 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
574 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_hwInterface);
575
576 m_osInterface->pfnDestroySyncResource(m_osInterface, &m_resSyncObjectWaContextInUse);
577
578 CodecHalFreeDataList(m_hevcRefList, CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC);
579
580 if (!Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
581 {
582 m_osInterface->pfnFreeResource(
583 m_osInterface,
584 &m_resMfdDeblockingFilterRowStoreScratchBuffer);
585 }
586
587 m_osInterface->pfnFreeResource(
588 m_osInterface,
589 &m_resDeblockingFilterTileRowStoreScratchBuffer);
590
591 m_osInterface->pfnFreeResource(
592 m_osInterface,
593 &m_resDeblockingFilterColumnRowStoreScratchBuffer);
594
595 if (!Mos_ResourceIsNull(&m_resMetadataLineBuffer))
596 {
597 m_osInterface->pfnFreeResource(
598 m_osInterface,
599 &m_resMetadataLineBuffer);
600 }
601
602 m_osInterface->pfnFreeResource(
603 m_osInterface,
604 &m_resMetadataTileLineBuffer);
605
606 m_osInterface->pfnFreeResource(
607 m_osInterface,
608 &m_resMetadataTileColumnBuffer);
609
610 if (!Mos_ResourceIsNull(&m_resSaoLineBuffer))
611 {
612 m_osInterface->pfnFreeResource(
613 m_osInterface,
614 &m_resSaoLineBuffer);
615 }
616
617 m_osInterface->pfnFreeResource(
618 m_osInterface,
619 &m_resSaoTileLineBuffer);
620
621 m_osInterface->pfnFreeResource(
622 m_osInterface,
623 &m_resSaoTileColumnBuffer);
624
625 for (uint32_t i = 0; i < CODEC_NUM_HEVC_MV_BUFFERS; i++)
626 {
627 m_osInterface->pfnFreeResource(
628 m_osInterface,
629 &m_resMvTemporalBuffer[i]);
630 }
631
632 if (m_shortFormatInUse)
633 {
634 for (uint32_t i = 0; i < CODEC_HEVC_NUM_SECOND_BB; i++)
635 {
636 Mhw_FreeBb(m_osInterface, &m_secondLevelBatchBuffer[i], nullptr);
637 }
638
639 for (uint32_t i = 0; i < CODECHAL_HEVC_NUM_DMEM_BUFFERS; i++)
640 {
641 m_osInterface->pfnFreeResource(m_osInterface, &m_resDmemBuffer[i]);
642 }
643 }
644
645 if (!Mos_ResourceIsNull(&m_resCopyDataBuffer))
646 {
647 m_osInterface->pfnFreeResource(
648 m_osInterface,
649 &m_resCopyDataBuffer);
650 }
651
652 for (uint32_t i = 0; i < CODECHAL_NUM_INTERNAL_NV12_RT_HEVC; i++)
653 {
654 m_osInterface->pfnFreeResource(
655 m_osInterface,
656 &m_internalNv12RtSurfaces[i].OsResource);
657 }
658
659 if (m_decodeNV12ToP010 != nullptr)
660 {
661 MOS_Delete(m_decodeNV12ToP010);
662 }
663 #ifdef _DECODE_PROCESSING_SUPPORTED
664 if (m_sfcState)
665 {
666 MOS_Delete(m_sfcState);
667 m_sfcState = nullptr;
668 }
669 #endif
670 if (m_picMhwParams.PipeModeSelectParams)
671 {
672 MOS_Delete(m_picMhwParams.PipeModeSelectParams);
673 m_picMhwParams.PipeModeSelectParams = nullptr;
674 }
675 if (m_picMhwParams.SurfaceParams)
676 {
677 MOS_Delete(m_picMhwParams.SurfaceParams);
678 m_picMhwParams.SurfaceParams = nullptr;
679 }
680 if (m_picMhwParams.PipeBufAddrParams)
681 {
682 MOS_Delete(m_picMhwParams.PipeBufAddrParams);
683 m_picMhwParams.PipeBufAddrParams = nullptr;
684 }
685 if (m_picMhwParams.IndObjBaseAddrParams)
686 {
687 MOS_Delete(m_picMhwParams.IndObjBaseAddrParams);
688 m_picMhwParams.IndObjBaseAddrParams = nullptr;
689 }
690 if (m_picMhwParams.QmParams)
691 {
692 MOS_Delete(m_picMhwParams.QmParams);
693 m_picMhwParams.QmParams = nullptr;
694 }
695 if (m_picMhwParams.HevcPicState)
696 {
697 MOS_Delete(m_picMhwParams.HevcPicState);
698 m_picMhwParams.HevcPicState = nullptr;
699 }
700 if (m_picMhwParams.HevcTileState)
701 {
702 MOS_Delete(m_picMhwParams.HevcTileState);
703 m_picMhwParams.HevcTileState = nullptr;
704 }
705
706 return;
707 }
708
GetDmemBufferSize()709 uint32_t CodechalDecodeHevc::GetDmemBufferSize()
710 {
711 return MOS_ALIGN_CEIL(sizeof(HUC_HEVC_S2L_BSS), CODECHAL_CACHELINE_SIZE);
712 }
713
SetHucDmemS2LPictureBss(PHUC_HEVC_S2L_PIC_BSS hucHevcS2LPicBss)714 MOS_STATUS CodechalDecodeHevc::SetHucDmemS2LPictureBss(
715 PHUC_HEVC_S2L_PIC_BSS hucHevcS2LPicBss)
716 {
717 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
718
719 CODECHAL_DECODE_FUNCTION_ENTER;
720
721 CODECHAL_DECODE_CHK_NULL_RETURN(hucHevcS2LPicBss);
722
723 hucHevcS2LPicBss->pic_width_in_min_cbs_y = m_hevcPicParams->PicWidthInMinCbsY;
724 hucHevcS2LPicBss->pic_height_in_min_cbs_y = m_hevcPicParams->PicHeightInMinCbsY;
725 hucHevcS2LPicBss->log2_min_luma_coding_block_size_minus3 = m_hevcPicParams->log2_min_luma_coding_block_size_minus3;
726 hucHevcS2LPicBss->log2_diff_max_min_luma_coding_block_size = m_hevcPicParams->log2_diff_max_min_luma_coding_block_size;
727 hucHevcS2LPicBss->chroma_format_idc = m_hevcPicParams->chroma_format_idc;
728 hucHevcS2LPicBss->separate_colour_plane_flag = m_hevcPicParams->separate_colour_plane_flag;
729 hucHevcS2LPicBss->bit_depth_luma_minus8 = m_hevcPicParams->bit_depth_luma_minus8;
730 hucHevcS2LPicBss->bit_depth_chroma_minus8 = m_hevcPicParams->bit_depth_chroma_minus8;
731 hucHevcS2LPicBss->log2_max_pic_order_cnt_lsb_minus4 = m_hevcPicParams->log2_max_pic_order_cnt_lsb_minus4;
732 hucHevcS2LPicBss->sample_adaptive_offset_enabled_flag = m_hevcPicParams->sample_adaptive_offset_enabled_flag;
733 hucHevcS2LPicBss->num_short_term_ref_pic_sets = m_hevcPicParams->num_short_term_ref_pic_sets;
734 hucHevcS2LPicBss->long_term_ref_pics_present_flag = m_hevcPicParams->long_term_ref_pics_present_flag;
735 hucHevcS2LPicBss->num_long_term_ref_pics_sps = m_hevcPicParams->num_long_term_ref_pic_sps;
736 hucHevcS2LPicBss->sps_temporal_mvp_enable_flag = m_hevcPicParams->sps_temporal_mvp_enabled_flag;
737 hucHevcS2LPicBss->num_ref_idx_l0_default_active_minus1 = m_hevcPicParams->num_ref_idx_l0_default_active_minus1;
738 hucHevcS2LPicBss->num_ref_idx_l1_default_active_minus1 = m_hevcPicParams->num_ref_idx_l1_default_active_minus1;
739 hucHevcS2LPicBss->pic_init_qp_minus26 = m_hevcPicParams->init_qp_minus26;
740 hucHevcS2LPicBss->dependent_slice_segments_enabled_flag = m_hevcPicParams->dependent_slice_segments_enabled_flag;
741 hucHevcS2LPicBss->cabac_init_present_flag = m_hevcPicParams->cabac_init_present_flag;
742 hucHevcS2LPicBss->pps_slice_chroma_qp_offsets_present_flag = m_hevcPicParams->pps_slice_chroma_qp_offsets_present_flag;
743 hucHevcS2LPicBss->weighted_pred_flag = m_hevcPicParams->weighted_pred_flag;
744 hucHevcS2LPicBss->weighted_bipred_flag = m_hevcPicParams->weighted_bipred_flag;
745 hucHevcS2LPicBss->output_flag_present_flag = m_hevcPicParams->output_flag_present_flag;
746 hucHevcS2LPicBss->tiles_enabled_flag = m_hevcPicParams->tiles_enabled_flag;
747 hucHevcS2LPicBss->entropy_coding_sync_enabled_flag = m_hevcPicParams->entropy_coding_sync_enabled_flag;
748 hucHevcS2LPicBss->loop_filter_across_slices_enabled_flag = m_hevcPicParams->pps_loop_filter_across_slices_enabled_flag;
749 hucHevcS2LPicBss->deblocking_filter_override_enabled_flag = m_hevcPicParams->deblocking_filter_override_enabled_flag;
750 hucHevcS2LPicBss->pic_disable_deblocking_filter_flag = m_hevcPicParams->pps_deblocking_filter_disabled_flag;
751 hucHevcS2LPicBss->lists_modification_present_flag = m_hevcPicParams->lists_modification_present_flag;
752 hucHevcS2LPicBss->slice_segment_header_extension_present_flag = m_hevcPicParams->slice_segment_header_extension_present_flag;
753 hucHevcS2LPicBss->high_precision_offsets_enabled_flag = 0;
754 hucHevcS2LPicBss->chroma_qp_offset_list_enabled_flag = 0;
755
756 uint32_t i;
757 hucHevcS2LPicBss->CurrPicOrderCntVal = m_hevcPicParams->CurrPicOrderCntVal;
758 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
759 {
760 hucHevcS2LPicBss->PicOrderCntValList[i] = m_hevcPicParams->PicOrderCntValList[i];
761 }
762
763 for (i = 0; i < 8; i++)
764 {
765 hucHevcS2LPicBss->RefPicSetStCurrBefore[i] = m_hevcPicParams->RefPicSetStCurrBefore[i];
766 hucHevcS2LPicBss->RefPicSetStCurrAfter[i] = m_hevcPicParams->RefPicSetStCurrAfter[i];
767 hucHevcS2LPicBss->RefPicSetLtCurr[i] = m_hevcPicParams->RefPicSetLtCurr[i];
768 }
769
770 hucHevcS2LPicBss->RefFieldPicFlag = m_hevcPicParams->RefFieldPicFlag;
771 hucHevcS2LPicBss->RefBottomFieldFlag = (uint8_t)m_hevcPicParams->RefBottomFieldFlag;
772 hucHevcS2LPicBss->pps_beta_offset_div2 = m_hevcPicParams->pps_beta_offset_div2;
773 hucHevcS2LPicBss->pps_tc_offset_div2 = m_hevcPicParams->pps_tc_offset_div2;
774 hucHevcS2LPicBss->StRPSBits = m_hevcPicParams->wNumBitsForShortTermRPSInSlice;
775
776 if (m_hevcPicParams->tiles_enabled_flag)
777 {
778 hucHevcS2LPicBss->num_tile_columns_minus1 = m_hevcPicParams->num_tile_columns_minus1;
779 hucHevcS2LPicBss->num_tile_rows_minus1 = m_hevcPicParams->num_tile_rows_minus1;
780
781 for (i = 0; i < HEVC_NUM_MAX_TILE_COLUMN; i++)
782 {
783 hucHevcS2LPicBss->column_width[i] = m_tileColWidth[i];
784 }
785
786 for (i = 0; i < HEVC_NUM_MAX_TILE_ROW; i++)
787 {
788 hucHevcS2LPicBss->row_height[i] = m_tileRowHeight[i];
789 }
790 }
791
792 hucHevcS2LPicBss->NumSlices = (uint16_t)m_numSlices;
793 hucHevcS2LPicBss->num_extra_slice_header_bits = m_hevcPicParams->num_extra_slice_header_bits;
794
795 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
796 {
797 hucHevcS2LPicBss->RefIdxMapping[i] = m_refIdxMapping[i];
798 }
799
800 return eStatus;
801 }
802
SetHucDmemS2LSliceBss(PHUC_HEVC_S2L_SLICE_BSS hucHevcS2LSliceBss)803 MOS_STATUS CodechalDecodeHevc::SetHucDmemS2LSliceBss(
804 PHUC_HEVC_S2L_SLICE_BSS hucHevcS2LSliceBss)
805 {
806 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
807
808 CODECHAL_DECODE_FUNCTION_ENTER;
809
810 CODECHAL_DECODE_CHK_NULL_RETURN(hucHevcS2LSliceBss);
811
812 for (uint32_t i = 0; i < m_numSlices; i++)
813 {
814 hucHevcS2LSliceBss->BSNALunitDataLocation = m_hevcSliceParams[i].slice_data_offset;
815 hucHevcS2LSliceBss->SliceBytesInBuffer = m_hevcSliceParams[i].slice_data_size;
816 hucHevcS2LSliceBss++;
817 }
818
819 return eStatus;
820 }
821
SetHucDmemParams(PMOS_RESOURCE dmemBuffer)822 MOS_STATUS CodechalDecodeHevc::SetHucDmemParams(
823 PMOS_RESOURCE dmemBuffer)
824 {
825 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
826
827 CODECHAL_DECODE_FUNCTION_ENTER;
828
829 CODECHAL_DECODE_CHK_NULL_RETURN(dmemBuffer);
830
831 CodechalResLock DmemLock(m_osInterface, dmemBuffer);
832 auto hucHevcS2LBss = (PHUC_HEVC_S2L_BSS)DmemLock.Lock(CodechalResLock::writeOnly);
833
834 CODECHAL_DECODE_CHK_NULL_RETURN(hucHevcS2LBss);
835 hucHevcS2LBss->ProductFamily = m_hucInterface->GetHucProductFamily();
836 hucHevcS2LBss->RevId = m_hwInterface->GetPlatform().usRevId;
837 hucHevcS2LBss->DummyRefIdxState =
838 MEDIA_IS_WA(m_waTable, WaDummyReference) && !m_osInterface->bSimIsActive;
839
840 CODECHAL_DECODE_CHK_STATUS_RETURN(SetHucDmemS2LPictureBss(&hucHevcS2LBss->PictureBss));
841 CODECHAL_DECODE_CHK_STATUS_RETURN(SetHucDmemS2LSliceBss(&hucHevcS2LBss->SliceBss[0]));
842
843 if (m_secureDecoder)
844 {
845 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetHevcHucDmemS2LBss(this, &hucHevcS2LBss->PictureBss, &hucHevcS2LBss->SliceBss[0]));
846 }
847
848 if (m_numSlices < CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6)
849 {
850 m_dmemTransferSize = (uint32_t)((uint8_t *)&(hucHevcS2LBss->SliceBss[m_numSlices]) - (uint8_t *)hucHevcS2LBss);
851 m_dmemTransferSize = MOS_ALIGN_CEIL(m_dmemTransferSize, CODECHAL_CACHELINE_SIZE);
852 }
853 else
854 {
855 m_dmemTransferSize = m_dmemBufferSize;
856 }
857 return eStatus;
858 }
859
GetAllTileInfo()860 MOS_STATUS CodechalDecodeHevc::GetAllTileInfo()
861 {
862 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
863
864 CODECHAL_DECODE_FUNCTION_ENTER;
865
866 if ((m_hevcPicParams->num_tile_columns_minus1 >= HEVC_NUM_MAX_TILE_COLUMN) ||
867 (m_hevcPicParams->num_tile_rows_minus1 >= HEVC_NUM_MAX_TILE_ROW))
868 {
869 CODECHAL_DECODE_ASSERTMESSAGE("num_tile_columns_minus1 or num_tile_rows_minus1 is out of range!");
870 return MOS_STATUS_INVALID_PARAMETER;
871 }
872
873 uint32_t ctbSize = 1 << (m_hevcPicParams->log2_diff_max_min_luma_coding_block_size + m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
874 uint32_t widthInPix = (1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) *
875 (m_hevcPicParams->PicWidthInMinCbsY);
876 uint32_t heightInPix = (1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) *
877 (m_hevcPicParams->PicHeightInMinCbsY);
878 uint32_t widthInCtb = MOS_ROUNDUP_DIVIDE(widthInPix, ctbSize);
879 uint32_t heightInCtb = MOS_ROUNDUP_DIVIDE(heightInPix, ctbSize);
880
881 uint16_t *tileColWidth, *tileRowHeight;
882 tileColWidth = &m_tileColWidth[0];
883 tileRowHeight = &m_tileRowHeight[0];
884 if (m_hevcPicParams->uniform_spacing_flag == 1)
885 {
886 uint8_t i;
887 for (i = 0; i <= m_hevcPicParams->num_tile_columns_minus1; i++)
888 {
889 tileColWidth[i] = ((i + 1) * widthInCtb) / (m_hevcPicParams->num_tile_columns_minus1 + 1) -
890 (i * widthInCtb) / (m_hevcPicParams->num_tile_columns_minus1 + 1);
891 }
892
893 for (i = 0; i <= m_hevcPicParams->num_tile_rows_minus1; i++)
894 {
895 tileRowHeight[i] = ((i + 1) * heightInCtb) / (m_hevcPicParams->num_tile_rows_minus1 + 1) -
896 (i * heightInCtb) / (m_hevcPicParams->num_tile_rows_minus1 + 1);
897 }
898 }
899 else
900 {
901 uint8_t i;
902 tileColWidth[m_hevcPicParams->num_tile_columns_minus1] = widthInCtb & 0xffff;
903 for (i = 0; i < m_hevcPicParams->num_tile_columns_minus1; i++)
904 {
905 tileColWidth[i] = m_hevcPicParams->column_width_minus1[i] + 1;
906 tileColWidth[m_hevcPicParams->num_tile_columns_minus1] -= tileColWidth[i];
907 }
908
909 tileRowHeight[m_hevcPicParams->num_tile_rows_minus1] = heightInCtb & 0xffff;
910 for (i = 0; i < m_hevcPicParams->num_tile_rows_minus1; i++)
911 {
912 tileRowHeight[i] = m_hevcPicParams->row_height_minus1[i] + 1;
913 tileRowHeight[m_hevcPicParams->num_tile_rows_minus1] -= tileRowHeight[i];
914 }
915 }
916
917 return eStatus;
918 }
919
InitializeBitstreamCat()920 MOS_STATUS CodechalDecodeHevc::InitializeBitstreamCat ()
921 {
922 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
923
924 CODECHAL_DECODE_FUNCTION_ENTER;
925
926 if (m_cencBuf)
927 {
928 return eStatus;
929 }
930
931 m_incompletePicture = false;
932 m_copyDataBufferInUse = false;
933 m_copyDataOffset = 0;
934
935 // For multiple execution case, each execution for one frame will increase pDecoderInterface->dwFrameNum in CodecHalDecode_Decode.
936 // This will lead to dump index error.
937 // Need to make sure that pDecoderInterface->CurrPic won't update until all bitstream is copied.
938 m_crrPic.PicFlags = PICTURE_INVALID;
939
940 // Estimate Bytes in Bitstream per frame
941 PCODEC_HEVC_SLICE_PARAMS hevcLastSliceParamsInFrame = m_hevcSliceParams + (m_numSlices - 1);
942 m_estiBytesInBitstream = MOS_ALIGN_CEIL(hevcLastSliceParamsInFrame->slice_data_offset + hevcLastSliceParamsInFrame->slice_data_size, 64);
943 CODECHAL_DECODE_NORMALMESSAGE("Estimate bitstream size in this Frame: %u", m_estiBytesInBitstream);
944
945 return eStatus;
946 }
947
CopyDataSurface()948 MOS_STATUS CodechalDecodeHevc::CopyDataSurface()
949 {
950 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
951
952 CODECHAL_DECODE_FUNCTION_ENTER;
953
954 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
955 m_osInterface,
956 m_videoContextForWa));
957 m_osInterface->pfnResetOsStates(m_osInterface);
958
959 m_osInterface->pfnSetPerfTag(
960 m_osInterface,
961 (uint16_t)(((m_mode << 4) & 0xF0) | COPY_TYPE));
962 m_osInterface->pfnResetPerfBufferID(m_osInterface);
963
964 MOS_COMMAND_BUFFER cmdBuffer;
965 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
966 m_osInterface,
967 &cmdBuffer,
968 0));
969
970 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
971 &cmdBuffer,
972 false));
973
974 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
975 &cmdBuffer, // pCmdBuffer
976 &m_resDataBuffer, // presSrc
977 &m_resCopyDataBuffer, // presDst
978 m_dataSize, // u32CopyLength
979 m_dataOffset, // u32CopyInputOffset
980 m_copyDataOffset)); // u32CopyOutputOffset
981
982 m_copyDataOffset += MOS_ALIGN_CEIL(m_dataSize, MHW_CACHELINE_SIZE);
983
984 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
985 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
986 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
987 &cmdBuffer,
988 &flushDwParams));
989
990 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
991 &cmdBuffer,
992 nullptr));
993
994 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
995
996 // sync resource
997 if (!m_incompletePicture)
998 {
999 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
1000 syncParams.GpuContext = m_videoContext;
1001 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1002 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
1003
1004 syncParams = g_cInitSyncParams;
1005 syncParams.GpuContext = m_videoContextForWa;
1006 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1007 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
1008 }
1009
1010 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
1011 m_osInterface,
1012 &cmdBuffer,
1013 m_videoContextForWaUsesNullHw));
1014
1015 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
1016 m_osInterface,
1017 m_videoContext));
1018
1019 return eStatus;
1020 }
1021
CheckAndCopyBitstream()1022 MOS_STATUS CodechalDecodeHevc::CheckAndCopyBitstream()
1023 {
1024 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1025
1026 CODECHAL_DECODE_FUNCTION_ENTER;
1027
1028 if (m_cencBuf)
1029 {
1030 return eStatus;
1031 }
1032
1033 if (IsFirstExecuteCall()) // first exec to decide allocate a larger buf or not
1034 {
1035 if (m_estiBytesInBitstream > MOS_ALIGN_CEIL(m_dataOffset + m_dataSize, 64)) // bitstream contains more bytes than current data.
1036 {
1037 CODECHAL_DECODE_NORMALMESSAGE("Multiple Execution Call for HEVC triggered!");
1038
1039 if (m_copyDataBufferSize < m_estiBytesInBitstream) // allocate an appropriate buffer
1040 {
1041 if (!Mos_ResourceIsNull(&m_resCopyDataBuffer))
1042 {
1043 m_osInterface->pfnFreeResource(
1044 m_osInterface,
1045 &m_resCopyDataBuffer);
1046 }
1047
1048 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
1049 &m_resCopyDataBuffer,
1050 m_estiBytesInBitstream,
1051 "HevcCopyDataBuffer"),
1052 "Failed to allocate Hevc copy data buffer.");
1053
1054 m_copyDataBufferSize = m_estiBytesInBitstream;
1055 CODECHAL_DECODE_NORMALMESSAGE("Create buffersize %d for MEC.", m_copyDataBufferSize);
1056 }
1057
1058 if (m_dataSize)
1059 {
1060 CODECHAL_DECODE_CHK_STATUS_RETURN(CopyDataSurface());
1061
1062 m_copyDataBufferInUse = true;
1063 }
1064
1065 m_incompletePicture = true;
1066 }
1067 }
1068 else
1069 {
1070 if (m_copyDataOffset + m_dataSize > m_copyDataBufferSize)
1071 {
1072 CODECHAL_DECODE_ASSERTMESSAGE("Bitstream size exceeds copy data buffer size!");
1073 return MOS_STATUS_UNKNOWN;
1074 }
1075
1076 if (m_dataSize)
1077 {
1078 CODECHAL_DECODE_CHK_STATUS_RETURN(CopyDataSurface());
1079 m_frameIdx--; // to keep u32FrameIdx as normal logic meaning.
1080 }
1081
1082 if (m_copyDataOffset >= m_estiBytesInBitstream)
1083 {
1084 m_incompletePicture = false;
1085 }
1086 }
1087
1088 return eStatus;
1089 }
1090
SetFrameStates()1091 MOS_STATUS CodechalDecodeHevc::SetFrameStates ()
1092 {
1093 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1094
1095 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
1096 CODECHAL_DECODE_FUNCTION_ENTER;
1097
1098 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_destSurface);
1099 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_dataBuffer);
1100
1101 m_frameIdx++;
1102
1103 // Check HuC_status2 Imem loaded bit, if 0,return error
1104 // As driver doesn't know when can get reg value afer storing HuC_Status2 register,
1105 // Check the reg value here at the beginning of next frame
1106 // Check twice, first entry and second entry
1107 if (m_shortFormatInUse &&
1108 m_frameIdx < 3 &&
1109 m_statusQueryReportingEnabled &&
1110 (((m_decodeStatusBuf.m_decodeStatus->m_hucErrorStatus2 >> 32) & m_hucInterface->GetHucStatus2ImemLoadedMask()) == 0))
1111 {
1112 CODECHAL_DECODE_ASSERTMESSAGE("HuC IMEM Loaded fails");
1113 return MOS_STATUS_UNKNOWN;
1114 }
1115
1116 m_cencBuf = m_decodeParams.m_cencBuf;
1117
1118 if (IsFirstExecuteCall()) // For DRC Multiple Execution Call, no need to update every value in pHevcState except first execute
1119 {
1120 m_dataSize = m_decodeParams.m_dataSize;
1121 m_dataOffset = m_decodeParams.m_dataOffset;
1122 m_numSlices = m_decodeParams.m_numSlices;
1123
1124 if (m_numSlices > CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6)
1125 {
1126 CODECHAL_DECODE_ASSERTMESSAGE("Slice number doesn't support!");
1127 return MOS_STATUS_INVALID_PARAMETER;
1128 }
1129
1130 m_hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)m_decodeParams.m_picParams;
1131 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_sliceParams);
1132 m_hevcSliceParams = (PCODEC_HEVC_SLICE_PARAMS)m_decodeParams.m_sliceParams;
1133 m_hevcIqMatrixParams = (PCODECHAL_HEVC_IQ_MATRIX_PARAMS)m_decodeParams.m_iqMatrixBuffer;
1134 m_destSurface = *(m_decodeParams.m_destSurface);
1135 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
1136
1137 CODECHAL_DECODE_CHK_STATUS_RETURN(InitializeBitstreamCat());
1138 }
1139 else
1140 {
1141 m_dataSize = m_decodeParams.m_dataSize;
1142 m_dataOffset = 0;
1143 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
1144 }
1145
1146 CODECHAL_DECODE_CHK_STATUS_RETURN(CheckAndCopyBitstream());
1147
1148 //For CENC case, the Entry has been initialized with value in SetParamsForDecode
1149 PCODEC_REF_LIST destEntry = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx];
1150 MOS_ZeroMemory(destEntry, sizeof(CODEC_REF_LIST));
1151
1152 if (m_incompletePicture)
1153 {
1154 return MOS_STATUS_SUCCESS;
1155 }
1156
1157 CODECHAL_DECODE_CHK_NULL_RETURN(m_hevcPicParams);
1158 CODECHAL_DECODE_CHK_NULL_RETURN(m_hevcIqMatrixParams);
1159
1160 // Calculate bIs8bitFrameIn10bitHevc
1161 if (MEDIA_IS_WA(m_waTable, Wa8BitFrameIn10BitHevc) &&
1162 m_is10BitHevc &&
1163 m_hevcPicParams->bit_depth_luma_minus8 == 0 &&
1164 m_hevcPicParams->bit_depth_chroma_minus8 == 0 &&
1165 m_decodeParams.m_destSurface->Format == Format_P010)
1166 {
1167 m_is8BitFrameIn10BitHevc = true;
1168 }
1169 else
1170 {
1171 m_is8BitFrameIn10BitHevc = false;
1172 }
1173
1174 // InitNV12ToP010Context
1175 if (m_is8BitFrameIn10BitHevc && m_decodeNV12ToP010 == nullptr)
1176 {
1177 m_decodeNV12ToP010 = Nv12ToP010Device::CreateFactory(m_osInterface);
1178 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeNV12ToP010);
1179 }
1180
1181 // Calculate bCurPicIntra
1182 m_curPicIntra = true;
1183 if (m_hevcPicParams->IntraPicFlag == 0)
1184 {
1185 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1186 {
1187 uint8_t frameIdx = m_hevcPicParams->RefPicSetStCurrBefore[i];
1188 if (frameIdx < 15)
1189 {
1190 m_curPicIntra = false;
1191 break;
1192 }
1193
1194 frameIdx = m_hevcPicParams->RefPicSetStCurrAfter[i];
1195 if (frameIdx < 15)
1196 {
1197 m_curPicIntra = false;
1198 break;
1199 }
1200
1201 frameIdx = m_hevcPicParams->RefPicSetLtCurr[i];
1202 if (frameIdx < 15)
1203 {
1204 m_curPicIntra = false;
1205 break;
1206 }
1207 }
1208 }
1209
1210 CODECHAL_DECODE_CHK_STATUS_RETURN(SetPictureStructs());
1211
1212 uint32_t i;
1213 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1214 {
1215 m_frameUsedAsCurRef[i] = false;
1216 m_refIdxMapping[i] = -1;
1217 }
1218
1219 // Calculate RefIdxMapping
1220 for (i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1221 {
1222 uint8_t frameIdx = m_hevcPicParams->RefPicSetStCurrBefore[i];
1223 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
1224 {
1225 m_frameUsedAsCurRef[frameIdx] = true;
1226 }
1227
1228 frameIdx = m_hevcPicParams->RefPicSetStCurrAfter[i];
1229 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
1230 {
1231 m_frameUsedAsCurRef[frameIdx] = true;
1232 }
1233
1234 frameIdx = m_hevcPicParams->RefPicSetLtCurr[i];
1235 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
1236 {
1237 m_frameUsedAsCurRef[frameIdx] = true;
1238 }
1239 }
1240
1241 uint8_t curRefIdx = 0;
1242 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1243 {
1244 if (m_frameUsedAsCurRef[i])
1245 {
1246 m_refIdxMapping[i] = curRefIdx++;
1247 }
1248 }
1249
1250 CODECHAL_DECODE_CHK_COND_RETURN(curRefIdx > 8,"bitstream has more than 8 references");
1251
1252 m_minCtbSize = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
1253 m_width = m_hevcPicParams->PicWidthInMinCbsY * m_minCtbSize;
1254 m_height = m_hevcPicParams->PicHeightInMinCbsY * m_minCtbSize;
1255
1256 if (m_hcpInterface->IsRowStoreCachingSupported())
1257 {
1258 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams;
1259 rowstoreParams.Mode = CODECHAL_DECODE_MODE_HEVCVLD;
1260 rowstoreParams.dwPicWidth = m_width;
1261 rowstoreParams.bMbaff = false;
1262 rowstoreParams.ucBitDepthMinus8 = (uint8_t)MOS_MAX(m_hevcPicParams->bit_depth_luma_minus8, m_hevcPicParams->bit_depth_chroma_minus8);
1263 rowstoreParams.ucChromaFormat = m_hevcPicParams->chroma_format_idc;
1264 rowstoreParams.ucLCUSize = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3 +
1265 m_hevcPicParams->log2_diff_max_min_luma_coding_block_size);
1266 m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams);
1267 }
1268
1269 AllocateResourcesVariableSizes();
1270
1271 // Calculate Tile info
1272 if (m_hevcPicParams->tiles_enabled_flag)
1273 {
1274 CODECHAL_DECODE_CHK_STATUS_RETURN(GetAllTileInfo());
1275 }
1276
1277 m_hcpDecPhase = CodechalHcpDecodePhaseInitialized;
1278
1279 if (m_curPicIntra)
1280 {
1281 m_perfType = I_TYPE;
1282 }
1283 else
1284 {
1285 // Not possible to determine whether P or B is used for short format.
1286 // For long format iterating through all of the slices to determine P vs
1287 // B, so in order to avoid this, declare all other pictures MIXED_TYPE.
1288 m_perfType = MIXED_TYPE;
1289 }
1290
1291 m_crrPic = m_hevcPicParams->CurrPic;
1292 m_secondField =
1293 CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
1294
1295 CODECHAL_DEBUG_TOOL(
1296 m_debugInterface->m_currPic = m_crrPic;
1297 m_debugInterface->m_secondField = m_secondField;
1298 m_debugInterface->m_frameType = m_perfType;
1299
1300 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(
1301 m_hevcPicParams,
1302 nullptr));
1303
1304 if (m_hevcIqMatrixParams) {
1305 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpIQParams(m_hevcIqMatrixParams));
1306 }
1307
1308 if (m_hevcSliceParams) {
1309 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpSliceParams(
1310 m_hevcSliceParams,
1311 nullptr,
1312 m_numSlices,
1313 m_shortFormatInUse));
1314 })
1315
1316 // Clear DMEM buffer program flag and increase the Dmem buffer index to program
1317 if (m_shortFormatInUse)
1318 {
1319 m_dmemBufferProgrammed = false;
1320 m_dmemBufferIdx++;
1321 m_dmemBufferIdx %= CODECHAL_HEVC_NUM_DMEM_BUFFERS;
1322 }
1323
1324 #ifdef _DECODE_PROCESSING_SUPPORTED
1325 // Check if SFC can be supported
1326 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->CheckAndInitialize((CODECHAL_DECODE_PROCESSING_PARAMS *)m_decodeParams.m_procParams, m_hevcPicParams));
1327 #endif
1328 CODECHAL_DEBUG_TOOL(
1329 if (!m_incompletePicture && !IsFirstExecuteCall()) {
1330 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1331 &m_resCopyDataBuffer,
1332 CodechalDbgAttr::attrBitstream,
1333 "_DEC",
1334 m_estiBytesInBitstream,
1335 0,
1336 CODECHAL_NUM_MEDIA_STATES));
1337 })
1338
1339 return eStatus;
1340 }
1341
SetPictureStructs()1342 MOS_STATUS CodechalDecodeHevc::SetPictureStructs()
1343 {
1344 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1345
1346 CODECHAL_DECODE_FUNCTION_ENTER;
1347
1348 PCODEC_HEVC_PIC_PARAMS picParams = m_hevcPicParams;
1349 PCODEC_REF_LIST * hevcRefList = &m_hevcRefList[0];
1350 PCODECHAL_DECODE_HEVC_MV_LIST hevcMVBufferList = &m_hevcMvList[0];
1351
1352 CODEC_PICTURE prevPic = m_currPic;
1353 m_currPic = picParams->CurrPic;
1354
1355 m_statusReportFeedbackNumber = picParams->StatusReportFeedbackNumber;
1356
1357 if (m_currPic.FrameIdx >= CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
1358 {
1359 CODECHAL_DECODE_ASSERTMESSAGE("currPic.FrameIdx is out of range!");
1360 return MOS_STATUS_INVALID_PARAMETER;
1361 }
1362
1363 hevcRefList[m_currPic.FrameIdx]->RefPic = m_currPic;
1364 hevcRefList[m_currPic.FrameIdx]->sFrameNumber = (int16_t)picParams->CurrPicOrderCntVal;
1365 hevcRefList[m_currPic.FrameIdx]->iFieldOrderCnt[0] = picParams->CurrPicOrderCntVal;
1366 hevcRefList[m_currPic.FrameIdx]->bIsIntra = m_curPicIntra;
1367 hevcRefList[m_currPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
1368
1369 uint8_t i;
1370 for(i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1371 {
1372 hevcRefList[m_currPic.FrameIdx]->RefList[i] = picParams->RefFrameList[i];
1373 }
1374
1375 if(!CodecHal_PictureIsInvalid(prevPic))
1376 {
1377 for(i = 0; i < CODEC_NUM_HEVC_MV_BUFFERS; i++)
1378 {
1379 hevcMVBufferList[i].bInUse = false;
1380 hevcMVBufferList[i].u8FrameId = 0;
1381 }
1382
1383 //Mark Referenced frame's MV buffer as used
1384 for(i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1385 {
1386 uint8_t index = picParams->RefFrameList[i].FrameIdx;
1387 if(!CodecHal_PictureIsInvalid(picParams->RefFrameList[i])
1388 && index != picParams->CurrPic.FrameIdx)
1389 {
1390 if (index < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
1391 {
1392 hevcMVBufferList[hevcRefList[index]->ucDMVIdx[0]].bInUse = true;
1393 hevcMVBufferList[hevcRefList[index]->ucDMVIdx[0]].u8FrameId = index;
1394 }
1395 }
1396 }
1397 }
1398
1399 //Find out an unused MvBuffer for current frame
1400 m_hevcMvBufferIndex = GetMvBufferIndex(
1401 m_currPic.FrameIdx);
1402
1403 if (m_mvBufferProgrammed)
1404 {
1405 AllocateMvTemporalBuffer(m_hevcMvBufferIndex);
1406 }
1407
1408 hevcRefList[m_currPic.FrameIdx]->ucDMVIdx[0] = m_hevcMvBufferIndex;
1409
1410 return eStatus;
1411 }
1412
DetermineDecodePhase()1413 MOS_STATUS CodechalDecodeHevc::DetermineDecodePhase()
1414 {
1415 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1416
1417 CODECHAL_DECODE_FUNCTION_ENTER;
1418
1419 uint32_t curPhase = m_hcpDecPhase;
1420 switch (curPhase)
1421 {
1422 case CodechalHcpDecodePhaseInitialized:
1423 if (m_shortFormatInUse)
1424 {
1425 m_hcpDecPhase = CodechalHcpDecodePhaseLegacyS2L;
1426 }
1427 else
1428 {
1429 m_hcpDecPhase = CodechalHcpDecodePhaseLegacyLong;
1430 }
1431 break;
1432 case CodechalHcpDecodePhaseLegacyS2L:
1433 if (!m_shortFormatInUse)
1434 {
1435 CODECHAL_DECODE_ASSERTMESSAGE("invalid decode phase.");
1436 return MOS_STATUS_INVALID_PARAMETER;
1437 }
1438 m_hcpDecPhase = CodechalHcpDecodePhaseLegacyLong;
1439 break;
1440 default:
1441 CODECHAL_DECODE_ASSERTMESSAGE("invalid decode phase.");
1442 return MOS_STATUS_INVALID_PARAMETER;
1443 }
1444
1445 return eStatus;
1446 }
1447
DecodeStateLevel()1448 MOS_STATUS CodechalDecodeHevc::DecodeStateLevel()
1449 {
1450 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1451
1452 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
1453 CODECHAL_DECODE_FUNCTION_ENTER;
1454
1455 //HEVC Decode Phase State Machine
1456 CODECHAL_DECODE_CHK_STATUS_RETURN(DetermineDecodePhase());
1457
1458 // Set HEVC Decode Phase, and execute it.
1459 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
1460 {
1461 if (m_secureDecoder)
1462 {
1463 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->Execute(this));
1464 }
1465
1466 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPictureS2L());
1467 }
1468 else
1469 {
1470 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPictureLongFormat());
1471 }
1472
1473 return eStatus;
1474 }
1475
AddPictureS2LCmds(PMOS_COMMAND_BUFFER cmdBufferInUse)1476 MOS_STATUS CodechalDecodeHevc::AddPictureS2LCmds(
1477 PMOS_COMMAND_BUFFER cmdBufferInUse)
1478 {
1479 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1480
1481 CODECHAL_DECODE_FUNCTION_ENTER;
1482
1483 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBufferInUse);
1484
1485 if (m_statusQueryReportingEnabled)
1486 {
1487 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(cmdBufferInUse));
1488 }
1489
1490 // Load HuC FW Kernel from WOPCM.
1491 MHW_VDBOX_HUC_IMEM_STATE_PARAMS hucImemStateParams;
1492 MOS_ZeroMemory(&hucImemStateParams, sizeof(hucImemStateParams));
1493 hucImemStateParams.dwKernelDescriptor = m_hucS2lKernelId;
1494 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(
1495 cmdBufferInUse,
1496 &hucImemStateParams));
1497
1498 // Pipe mode select
1499 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
1500 pipeModeSelectParams.Mode = m_mode;
1501 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
1502 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(
1503 cmdBufferInUse,
1504 &pipeModeSelectParams));
1505
1506 // Indirect object base addr
1507 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
1508 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
1509 indObjBaseAddrParams.Mode = m_mode;
1510 indObjBaseAddrParams.dwDataSize = m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize;
1511 indObjBaseAddrParams.dwDataOffset = m_copyDataBufferInUse ? 0 : m_dataOffset;
1512 indObjBaseAddrParams.presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
1513
1514 if (m_secureDecoder)
1515 {
1516 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetBitstreamBuffer(&indObjBaseAddrParams));
1517 }
1518
1519 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucIndObjBaseAddrStateCmd(
1520 cmdBufferInUse,
1521 &indObjBaseAddrParams));
1522
1523 // Virtual addr state
1524 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS hucVirtualStateParams;
1525 MOS_ZeroMemory(&hucVirtualStateParams, sizeof(hucVirtualStateParams));
1526 hucVirtualStateParams.regionParams[0].presRegion = &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].OsResource;
1527 hucVirtualStateParams.regionParams[0].isWritable = true;
1528
1529 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(
1530 cmdBufferInUse,
1531 &hucVirtualStateParams));
1532
1533 // DMEM state. Pass data from driver to HuC FW.
1534 MHW_VDBOX_HUC_DMEM_STATE_PARAMS hucDmemStateParams;
1535 MOS_ZeroMemory(&hucDmemStateParams, sizeof(hucDmemStateParams));
1536 hucDmemStateParams.presHucDataSource = &m_resDmemBuffer[m_dmemBufferIdx];
1537 hucDmemStateParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS; // If RTOS is GEMS, offset is 0x2000.
1538
1539 if (!m_dmemBufferProgrammed)
1540 {
1541 CODECHAL_DECODE_CHK_STATUS_RETURN(SetHucDmemParams(&m_resDmemBuffer[m_dmemBufferIdx]));
1542 m_dmemBufferProgrammed = true;
1543 }
1544
1545 hucDmemStateParams.dwDataLength = m_dmemTransferSize;
1546 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(
1547 cmdBufferInUse,
1548 &hucDmemStateParams));
1549
1550 return eStatus;
1551 }
1552
SendPictureS2L()1553 MOS_STATUS CodechalDecodeHevc::SendPictureS2L()
1554 {
1555 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1556
1557 CODECHAL_DECODE_FUNCTION_ENTER;
1558
1559 if (m_enableSf2DmaSubmits)
1560 {
1561 m_osInterface->pfnSetPerfTag(
1562 m_osInterface,
1563 (uint16_t)(((CODECHAL_DECODE_MODE_HUC << 4) & 0xF0) | (m_perfType & 0xF)));
1564 }
1565
1566 MOS_COMMAND_BUFFER cmdBuffer;
1567 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1568
1569 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1570 &cmdBuffer, true));
1571
1572 PMOS_COMMAND_BUFFER cmdBufferInUse = &cmdBuffer;
1573
1574 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureS2LCmds(cmdBufferInUse));
1575
1576 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1577
1578 return eStatus;
1579 }
1580
InitPicLongFormatMhwParams()1581 MOS_STATUS CodechalDecodeHevc::InitPicLongFormatMhwParams()
1582 {
1583 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1584
1585 CODECHAL_DECODE_FUNCTION_ENTER;
1586
1587 // Reset all pic Mhw Params
1588 *m_picMhwParams.PipeModeSelectParams = {};
1589 *m_picMhwParams.PipeBufAddrParams = {};
1590 *m_picMhwParams.HevcPicState = {};
1591 MOS_ZeroMemory(m_picMhwParams.SurfaceParams, sizeof(MHW_VDBOX_SURFACE_PARAMS ));
1592 MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
1593 MOS_ZeroMemory(m_picMhwParams.QmParams, sizeof(MHW_VDBOX_QM_PARAMS ));
1594 MOS_ZeroMemory(m_picMhwParams.HevcTileState, sizeof(MHW_VDBOX_HEVC_TILE_STATE ));
1595
1596 PMOS_SURFACE destSurface = nullptr;
1597 if (m_is8BitFrameIn10BitHevc)
1598 {
1599 destSurface = &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]];
1600 }
1601 else
1602 {
1603 destSurface = &m_destSurface;
1604 }
1605
1606 m_picMhwParams.PipeModeSelectParams->Mode = m_mode;
1607 m_picMhwParams.PipeModeSelectParams->bStreamOutEnabled = m_streamOutEnabled;
1608 m_picMhwParams.PipeModeSelectParams->bShortFormatInUse = m_shortFormatInUse;
1609
1610 m_picMhwParams.SurfaceParams->Mode = CODECHAL_DECODE_MODE_HEVCVLD;
1611 m_picMhwParams.SurfaceParams->psSurface = destSurface;
1612 m_picMhwParams.SurfaceParams->ucSurfaceStateId = CODECHAL_HCP_DECODED_SURFACE_ID;
1613 m_picMhwParams.SurfaceParams->ChromaType = m_hevcPicParams->chroma_format_idc;
1614 m_picMhwParams.SurfaceParams->ucBitDepthLumaMinus8 = m_hevcPicParams->bit_depth_luma_minus8;
1615 m_picMhwParams.SurfaceParams->ucBitDepthChromaMinus8 = m_hevcPicParams->bit_depth_chroma_minus8;
1616 m_picMhwParams.SurfaceParams->dwUVPlaneAlignment = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
1617
1618 m_picMhwParams.PipeBufAddrParams->Mode = m_mode;
1619 m_picMhwParams.PipeBufAddrParams->psPreDeblockSurface = destSurface;
1620
1621 if (m_is8BitFrameIn10BitHevc)
1622 {
1623 m_picMhwParams.PipeBufAddrParams->presP010RTSurface = &m_destSurface;
1624 }
1625
1626 #ifdef _MMC_SUPPORTED
1627 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(m_picMhwParams.PipeBufAddrParams));
1628 #endif
1629
1630 m_picMhwParams.PipeBufAddrParams->presMfdDeblockingFilterRowStoreScratchBuffer =
1631 &m_resMfdDeblockingFilterRowStoreScratchBuffer;
1632 m_picMhwParams.PipeBufAddrParams->presDeblockingFilterTileRowStoreScratchBuffer =
1633 &m_resDeblockingFilterTileRowStoreScratchBuffer;
1634 m_picMhwParams.PipeBufAddrParams->presDeblockingFilterColumnRowStoreScratchBuffer =
1635 &m_resDeblockingFilterColumnRowStoreScratchBuffer;
1636
1637 m_picMhwParams.PipeBufAddrParams->presMetadataLineBuffer = &m_resMetadataLineBuffer;
1638 m_picMhwParams.PipeBufAddrParams->presMetadataTileLineBuffer = &m_resMetadataTileLineBuffer;
1639 m_picMhwParams.PipeBufAddrParams->presMetadataTileColumnBuffer = &m_resMetadataTileColumnBuffer;
1640 m_picMhwParams.PipeBufAddrParams->presSaoLineBuffer = &m_resSaoLineBuffer;
1641 m_picMhwParams.PipeBufAddrParams->presSaoTileLineBuffer = &m_resSaoTileLineBuffer;
1642 m_picMhwParams.PipeBufAddrParams->presSaoTileColumnBuffer = &m_resSaoTileColumnBuffer;
1643 m_picMhwParams.PipeBufAddrParams->presCurMvTempBuffer = &m_resMvTemporalBuffer[m_hevcMvBufferIndex];
1644
1645 MOS_ZeroMemory(m_presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_HEVC);
1646 MOS_ZeroMemory(m_dummyReferenceSlot, sizeof(m_dummyReferenceSlot));
1647
1648 if (!m_curPicIntra)
1649 {
1650 uint8_t i, k = 0, m = 0;
1651
1652 PMOS_RESOURCE firstValidFrame = nullptr;
1653 PMOS_RESOURCE firstValidMvBuf = nullptr;
1654
1655 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1656 {
1657 if (m_frameUsedAsCurRef[i])
1658 {
1659 uint8_t refFrameValue = m_hevcPicParams->RefFrameList[i].FrameIdx;
1660 if (refFrameValue < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
1661 {
1662 m_presReferences[k] = &(m_hevcRefList[refFrameValue]->resRefPic);
1663
1664 for (uint8_t j = 0; j < CODEC_NUM_HEVC_MV_BUFFERS; j++)
1665 {
1666 if ((m_hevcMvList[j].bInUse) &&
1667 (m_hevcMvList[j].u8FrameId == refFrameValue) &&
1668 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[j]))
1669 {
1670 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[m++] = &m_resMvTemporalBuffer[j];
1671 if (firstValidMvBuf == nullptr)
1672 {
1673 firstValidMvBuf = &m_resMvTemporalBuffer[j];
1674 }
1675 break;
1676 }
1677 }
1678
1679 if (firstValidFrame == nullptr)
1680 {
1681 firstValidFrame = m_presReferences[k];
1682 }
1683
1684 k++;
1685 }
1686 }
1687 }
1688
1689 CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
1690 m_picMhwParams.PipeBufAddrParams->presReferences,
1691 sizeof(PMOS_RESOURCE) * CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC,
1692 m_presReferences,
1693 sizeof(PMOS_RESOURCE) * CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC));
1694
1695 CODECHAL_DECODE_ASSERT(k <= 8);
1696 CODECHAL_DECODE_ASSERT(m <= 8);
1697
1698 // Return error if reference surface's pitch * height is less than dest surface.
1699 MOS_SURFACE destSurfaceDetails;
1700 MOS_SURFACE refSurfaceDetails;
1701
1702 MOS_ZeroMemory(&destSurfaceDetails, sizeof(destSurfaceDetails));
1703 destSurfaceDetails.Format = Format_Invalid;
1704 MOS_ZeroMemory(&refSurfaceDetails, sizeof(refSurfaceDetails));
1705 refSurfaceDetails.Format = Format_Invalid;
1706
1707 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetResourceInfo(
1708 m_osInterface,
1709 &destSurface->OsResource,
1710 &destSurfaceDetails));
1711
1712 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1713 {
1714 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] != nullptr)
1715 {
1716 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetResourceInfo(
1717 m_osInterface,
1718 m_picMhwParams.PipeBufAddrParams->presReferences[i],
1719 &refSurfaceDetails));
1720
1721 if ((refSurfaceDetails.dwPitch * refSurfaceDetails.dwHeight) <
1722 (destSurfaceDetails.dwPitch * destSurfaceDetails.dwHeight))
1723 {
1724 CODECHAL_DECODE_ASSERTMESSAGE("Reference surface's pitch * height is less than Dest surface.");
1725 return MOS_STATUS_INVALID_PARAMETER;
1726 }
1727 }
1728 }
1729
1730 if (firstValidFrame == nullptr)
1731 {
1732 firstValidFrame = &destSurface->OsResource;
1733 }
1734 if (firstValidMvBuf == nullptr &&
1735 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[m_hevcMvBufferIndex]))
1736 {
1737 firstValidMvBuf = &m_resMvTemporalBuffer[m_hevcMvBufferIndex];
1738 }
1739
1740 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1741 {
1742 // error concealment for the unset reference addresses and unset mv buffers
1743 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] == nullptr)
1744 {
1745 m_picMhwParams.PipeBufAddrParams->presReferences[i] = firstValidFrame;
1746 }
1747 }
1748
1749 for (uint32_t n = 0; n < CODEC_NUM_HEVC_MV_BUFFERS; n++)
1750 {
1751 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n] == nullptr &&
1752 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[n]))
1753 {
1754 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n] = &m_resMvTemporalBuffer[n];
1755 }
1756 }
1757 }
1758
1759 // set all ref pic addresses to valid addresses for error concealment purpose
1760 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1761 {
1762 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] == nullptr &&
1763 MEDIA_IS_WA(m_waTable, WaDummyReference) &&
1764 !Mos_ResourceIsNull(&m_dummyReference.OsResource))
1765 {
1766 m_picMhwParams.PipeBufAddrParams->presReferences[i] = &m_dummyReference.OsResource;
1767 m_dummyReferenceSlot[i] = true;
1768 }
1769 }
1770
1771 #ifdef _MMC_SUPPORTED
1772 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(m_picMhwParams.PipeBufAddrParams));
1773
1774 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));
1775 #endif
1776
1777 m_picMhwParams.IndObjBaseAddrParams->Mode = m_mode;
1778 m_picMhwParams.IndObjBaseAddrParams->dwDataSize = m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize;
1779 m_picMhwParams.IndObjBaseAddrParams->dwDataOffset = m_copyDataBufferInUse ? 0 : m_dataOffset;
1780 m_picMhwParams.IndObjBaseAddrParams->presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
1781
1782 if (m_secureDecoder)
1783 {
1784 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetBitstreamBuffer(m_picMhwParams.IndObjBaseAddrParams));
1785 }
1786
1787 m_picMhwParams.QmParams->Standard = CODECHAL_HEVC;
1788 m_picMhwParams.QmParams->pHevcIqMatrix = (PMHW_VDBOX_HEVC_QM_PARAMS)m_hevcIqMatrixParams;
1789
1790 m_picMhwParams.HevcPicState->pHevcPicParams = m_hevcPicParams;
1791
1792 m_picMhwParams.HevcTileState->pHevcPicParams = m_hevcPicParams;
1793 m_picMhwParams.HevcTileState->pTileColWidth = m_tileColWidth;
1794 m_picMhwParams.HevcTileState->pTileRowHeight = m_tileRowHeight;
1795
1796 return eStatus;
1797 }
1798
AddPictureLongFormatCmds(PMOS_COMMAND_BUFFER cmdBufferInUse,PIC_LONG_FORMAT_MHW_PARAMS * picMhwParams)1799 MOS_STATUS CodechalDecodeHevc::AddPictureLongFormatCmds(
1800 PMOS_COMMAND_BUFFER cmdBufferInUse,
1801 PIC_LONG_FORMAT_MHW_PARAMS *picMhwParams)
1802 {
1803 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1804
1805 CODECHAL_DECODE_FUNCTION_ENTER;
1806
1807 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBufferInUse);
1808 CODECHAL_DECODE_CHK_NULL_RETURN(picMhwParams);
1809
1810 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(
1811 cmdBufferInUse,
1812 picMhwParams->PipeModeSelectParams));
1813
1814 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSurfaceCmd(
1815 cmdBufferInUse,
1816 picMhwParams->SurfaceParams));
1817
1818 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeBufAddrCmd(
1819 cmdBufferInUse,
1820 picMhwParams->PipeBufAddrParams));
1821
1822 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpIndObjBaseAddrCmd(
1823 cmdBufferInUse,
1824 picMhwParams->IndObjBaseAddrParams));
1825
1826 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpQmStateCmd(
1827 cmdBufferInUse,
1828 picMhwParams->QmParams));
1829 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPicStateCmd(
1830 cmdBufferInUse,
1831 picMhwParams->HevcPicState));
1832
1833 if (m_hevcPicParams->tiles_enabled_flag)
1834 {
1835 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpTileStateCmd(
1836 cmdBufferInUse,
1837 picMhwParams->HevcTileState));
1838 }
1839
1840 return eStatus;
1841 }
1842
SendPictureLongFormat()1843 MOS_STATUS CodechalDecodeHevc::SendPictureLongFormat()
1844 {
1845 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1846
1847 CODECHAL_DECODE_FUNCTION_ENTER;
1848
1849 if (m_enableSf2DmaSubmits)
1850 {
1851 m_osInterface->pfnSetPerfTag(
1852 m_osInterface,
1853 (uint16_t)(((CODECHAL_DECODE_MODE_HEVCVLD << 4) & 0xF0) | (m_perfType & 0xF)));
1854 }
1855
1856 MOS_COMMAND_BUFFER cmdBuffer;
1857 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1858
1859 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
1860 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
1861
1862 bool sendPrologWithFrameTracking = false;
1863 if (m_shortFormatInUse)
1864 {
1865 sendPrologWithFrameTracking = m_enableSf2DmaSubmits;
1866 }
1867 else
1868 {
1869 sendPrologWithFrameTracking = true;
1870 }
1871
1872 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1873 &cmdBuffer,
1874 sendPrologWithFrameTracking));
1875
1876 CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicLongFormatMhwParams());
1877
1878 CODECHAL_DEBUG_TOOL(
1879 for (uint16_t n = 0; n < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; n++)
1880 {
1881 if (m_picMhwParams.PipeBufAddrParams->presReferences[n])
1882 {
1883 MOS_SURFACE dstSurface;
1884 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
1885 dstSurface.OsResource = *(m_picMhwParams.PipeBufAddrParams->presReferences[n]);
1886 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
1887 m_osInterface,
1888 &dstSurface));
1889
1890 m_debugInterface->m_refIndex = n;
1891 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex)) + "]";
1892 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
1893 &dstSurface,
1894 CodechalDbgAttr::attrReferenceSurfaces,
1895 refSurfName.c_str()));
1896 }
1897
1898 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n])
1899 {
1900 m_debugInterface->m_refIndex = n;
1901 // dump mvdata
1902 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1903 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n],
1904 CodechalDbgAttr::attrMvData,
1905 "DEC",
1906 m_mvBufferSize));
1907 }
1908 }
1909 );
1910
1911 PMOS_COMMAND_BUFFER cmdBufferInUse = &cmdBuffer;
1912
1913 //Send status report Start
1914 if (m_statusQueryReportingEnabled)
1915 {
1916 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(cmdBufferInUse));
1917 }
1918
1919 if (m_statusQueryReportingEnabled && m_shortFormatInUse &&
1920 m_hcpDecPhase == CodechalHcpDecodePhaseLegacyLong)
1921 {
1922 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
1923 m_decodeStatusBuf.m_storeDataOffset +
1924 sizeof(uint32_t) * 2;
1925
1926 // Check HuC_STATUS bit15, HW continue if bit15 > 0, otherwise send COND BB END cmd.
1927 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->SendCondBbEndCmd(
1928 &m_decodeStatusBuf.m_statusBuffer,
1929 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset,
1930 0,
1931 false,
1932 cmdBufferInUse));
1933 }
1934
1935 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureLongFormatCmds(cmdBufferInUse, &m_picMhwParams));
1936
1937 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1938
1939 return eStatus;
1940 }
1941
SendSliceS2L(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)1942 MOS_STATUS CodechalDecodeHevc::SendSliceS2L(
1943 PMOS_COMMAND_BUFFER cmdBuffer,
1944 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
1945 {
1946 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1947
1948 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
1949 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState);
1950 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState->pHevcSliceParams);
1951
1952 CODECHAL_DECODE_CHK_COND_RETURN(
1953 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
1954 "ERROR - vdbox index exceed the maximum");
1955 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
1956
1957 if (m_secureDecoder)
1958 {
1959 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AddHucSecureState(
1960 this,
1961 hevcSliceState,
1962 cmdBuffer));
1963 }
1964
1965 // Send HuC Stream Obj cmd
1966 PCODEC_HEVC_SLICE_PARAMS slc = hevcSliceState->pHevcSliceParams;
1967 MHW_VDBOX_HUC_STREAM_OBJ_PARAMS hucStreamObjParams;
1968 MOS_ZeroMemory(&hucStreamObjParams, sizeof(hucStreamObjParams));
1969 hucStreamObjParams.dwIndStreamInLength = hevcSliceState->dwLength;
1970 hucStreamObjParams.bStreamOutEnable = hevcSliceState->bHucStreamOut ? 1 : 0;
1971 hucStreamObjParams.dwIndStreamInStartAddrOffset = slc->slice_data_offset;
1972 hucStreamObjParams.bHucProcessing = true;
1973
1974 if (m_secureDecoder)
1975 {
1976 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetHucStreamObj(
1977 &hucStreamObjParams));
1978 }
1979
1980 hucStreamObjParams.bStreamInEnable = 1;
1981 hucStreamObjParams.bEmulPreventionByteRemoval = 1;
1982 hucStreamObjParams.bStartCodeSearchEngine = 1;
1983 hucStreamObjParams.ucStartCodeByte0 = 0;
1984 hucStreamObjParams.ucStartCodeByte1 = 0;
1985 hucStreamObjParams.ucStartCodeByte2 = 1;
1986 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStreamObjectCmd(
1987 cmdBuffer,
1988 &hucStreamObjParams));
1989
1990 if (m_statusQueryReportingEnabled &&
1991 hevcSliceState->bLastSlice &&
1992 !hevcSliceState->bHucStreamOut)
1993 {
1994 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
1995 m_decodeStatusBuf.m_storeDataOffset +
1996 sizeof(uint32_t) * 2;
1997
1998 // Write HUC_STATUS2 mask
1999 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2000 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
2001 storeDataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
2002 storeDataParams.dwResourceOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2MaskOffset;
2003 storeDataParams.dwValue = m_hucInterface->GetHucStatus2ImemLoadedMask();
2004 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
2005 cmdBuffer,
2006 &storeDataParams));
2007
2008 // store HUC_STATUS2 register
2009 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
2010 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
2011 storeRegParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
2012 storeRegParams.dwOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2RegOffset;
2013 storeRegParams.dwRegister = mmioRegisters->hucStatus2RegOffset;
2014 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
2015 cmdBuffer,
2016 &storeRegParams));
2017 }
2018
2019 // Send HuC Start
2020 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(
2021 cmdBuffer,
2022 hevcSliceState->bLastSlice ? true : false));
2023
2024 return eStatus;
2025 }
2026
SendSliceLongFormat(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)2027 MOS_STATUS CodechalDecodeHevc::SendSliceLongFormat(
2028 PMOS_COMMAND_BUFFER cmdBuffer,
2029 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
2030 {
2031 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2032
2033 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
2034 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState);
2035 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState->pHevcSliceParams);
2036
2037 PCODEC_HEVC_SLICE_PARAMS slc = hevcSliceState->pHevcSliceParams;
2038
2039 // Disable the flag when ref list is empty for P/B slices to avoid the GPU hang
2040 if (m_curPicIntra &&
2041 !m_hcpInterface->IsHevcISlice(slc->LongSliceFlags.fields.slice_type))
2042 {
2043 slc->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag = 0;
2044 }
2045
2046 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSliceStateCmd(
2047 cmdBuffer,
2048 hevcSliceState));
2049
2050 if (! m_hcpInterface->IsHevcISlice(slc->LongSliceFlags.fields.slice_type))
2051 {
2052 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
2053 refIdxParams.CurrPic = m_hevcPicParams->CurrPic;
2054 refIdxParams.ucList = 0;
2055 refIdxParams.ucNumRefForList = slc->num_ref_idx_l0_active_minus1 + 1;
2056 eStatus = MOS_SecureMemcpy(&refIdxParams.RefPicList, sizeof(refIdxParams.RefPicList), &slc->RefPicList, sizeof(slc->RefPicList));
2057 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2058 refIdxParams.hevcRefList = (void**)m_hevcRefList;
2059 refIdxParams.poc_curr_pic = m_hevcPicParams->CurrPicOrderCntVal;
2060 for (uint8_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
2061 {
2062 refIdxParams.poc_list[i] = m_hevcPicParams->PicOrderCntValList[i];
2063 }
2064
2065 refIdxParams.pRefIdxMapping = hevcSliceState->pRefIdxMapping;
2066 refIdxParams.RefFieldPicFlag = m_hevcPicParams->RefFieldPicFlag;
2067 refIdxParams.RefBottomFieldFlag = m_hevcPicParams->RefBottomFieldFlag;
2068
2069 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2070 cmdBuffer,
2071 nullptr,
2072 &refIdxParams));
2073
2074 if (m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type))
2075 {
2076 refIdxParams.ucList = 1;
2077 refIdxParams.ucNumRefForList = slc->num_ref_idx_l1_active_minus1 + 1;
2078 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2079 cmdBuffer,
2080 nullptr,
2081 &refIdxParams));
2082 }
2083 }
2084 else if (MEDIA_IS_WA(m_waTable, WaDummyReference) && !m_osInterface->bSimIsActive)
2085 {
2086 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
2087 MOS_ZeroMemory(&refIdxParams, sizeof(MHW_VDBOX_HEVC_REF_IDX_PARAMS));
2088 refIdxParams.bDummyReference = true;
2089 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2090 cmdBuffer,
2091 nullptr,
2092 &refIdxParams));
2093 }
2094
2095 if ((m_hevcPicParams->weighted_pred_flag &&
2096 m_hcpInterface->IsHevcPSlice(slc->LongSliceFlags.fields.slice_type)) ||
2097 (m_hevcPicParams->weighted_bipred_flag &&
2098 m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type)))
2099 {
2100 MHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS weightOffsetParams;
2101
2102 weightOffsetParams.ucList = 0;
2103
2104 eStatus = MOS_SecureMemcpy(
2105 &weightOffsetParams.LumaWeights[0],
2106 sizeof(weightOffsetParams.LumaWeights[0]),
2107 &slc->delta_luma_weight_l0,
2108 sizeof(slc->delta_luma_weight_l0));
2109 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2110
2111 eStatus = MOS_SecureMemcpy(
2112 &weightOffsetParams.LumaWeights[1],
2113 sizeof(weightOffsetParams.LumaWeights[1]),
2114 &slc->delta_luma_weight_l1,
2115 sizeof(slc->delta_luma_weight_l1));
2116 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2117
2118 for (int32_t i = 0; i < 15; i++)
2119 {
2120 weightOffsetParams.LumaOffsets[0][i] = (int16_t)slc->luma_offset_l0[i];
2121 weightOffsetParams.LumaOffsets[1][i] = (int16_t)slc->luma_offset_l1[i];
2122
2123 for (int32_t j = 0; j < 2; j++)
2124 {
2125 weightOffsetParams.ChromaOffsets[0][i][j] = (int16_t)slc->ChromaOffsetL0[i][j];
2126 weightOffsetParams.ChromaOffsets[1][i][j] = (int16_t)slc->ChromaOffsetL1[i][j];
2127 }
2128 }
2129
2130 eStatus = MOS_SecureMemcpy(
2131 &weightOffsetParams.ChromaWeights[0],
2132 sizeof(weightOffsetParams.ChromaWeights[0]),
2133 &slc->delta_chroma_weight_l0,
2134 sizeof(slc->delta_chroma_weight_l0));
2135 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2136
2137 eStatus = MOS_SecureMemcpy(
2138 &weightOffsetParams.ChromaWeights[1],
2139 sizeof(weightOffsetParams.ChromaWeights[1]),
2140 &slc->delta_chroma_weight_l1,
2141 sizeof(slc->delta_chroma_weight_l1));
2142 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2143
2144 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(
2145 cmdBuffer,
2146 nullptr,
2147 &weightOffsetParams));
2148
2149 if (m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type))
2150 {
2151 weightOffsetParams.ucList = 1;
2152 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(
2153 cmdBuffer,
2154 nullptr,
2155 &weightOffsetParams));
2156 }
2157 }
2158
2159 if (m_secureDecoder)
2160 {
2161 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AddHcpSecureState(
2162 cmdBuffer,
2163 hevcSliceState));
2164 }
2165
2166 MHW_VDBOX_HCP_BSD_PARAMS bsdParams;
2167 MOS_ZeroMemory(&bsdParams, sizeof(bsdParams));
2168 bsdParams.dwBsdDataLength = hevcSliceState->dwLength;
2169 bsdParams.dwBsdDataStartOffset = slc->slice_data_offset + hevcSliceState->dwOffset;
2170
2171 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpBsdObjectCmd(
2172 cmdBuffer,
2173 &bsdParams));
2174
2175 return eStatus;
2176 }
2177
DecodePrimitiveLevel()2178 MOS_STATUS CodechalDecodeHevc::DecodePrimitiveLevel()
2179 {
2180 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2181
2182 CODECHAL_DECODE_FUNCTION_ENTER;
2183
2184 // Bitstream is incomplete, don't do any decoding work.
2185 if (m_incompletePicture)
2186 {
2187 return MOS_STATUS_SUCCESS;
2188 }
2189
2190 CODECHAL_DECODE_CHK_COND_RETURN(
2191 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
2192 "ERROR - vdbox index exceed the maximum");
2193 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
2194
2195 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
2196 m_decodeStatusBuf.m_storeDataOffset +
2197 sizeof(uint32_t) * 2;
2198
2199 uint32_t renderingFlags = m_videoContextUsesNullHw;
2200
2201 MOS_COMMAND_BUFFER cmdBuffer;
2202 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
2203
2204 PMOS_COMMAND_BUFFER cmdBufferInUse = &cmdBuffer;
2205
2206 // If S2L and 2nd pass, ...
2207 // ... jump to 2nd level batch buffer.
2208 if ((m_shortFormatInUse &&
2209 m_hcpDecPhase == CodechalHcpDecodePhaseLegacyLong) ||
2210 m_cencBuf)
2211 {
2212 if (m_enableSf2DmaSubmits)
2213 {
2214 #if (_DEBUG || _RELEASE_INTERNAL)
2215 m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iLastCurrent = m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize;
2216 #endif
2217
2218 CODECHAL_DEBUG_TOOL(
2219 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
2220 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex],
2221 CODECHAL_NUM_MEDIA_STATES,
2222 "DEC"));)
2223 }
2224
2225 if (m_cencBuf)
2226 {
2227 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCencBatchBuffer(cmdBufferInUse));
2228 }
2229 else
2230 {
2231 // this is S2L conversion
2232 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
2233 cmdBufferInUse,
2234 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex]));
2235 }
2236 }
2237 else
2238 {
2239 // Setup static slice state parameters
2240 MHW_VDBOX_HEVC_SLICE_STATE hevcSliceState;
2241 hevcSliceState.presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
2242 hevcSliceState.pHevcPicParams = m_hevcPicParams;
2243 hevcSliceState.pRefIdxMapping = &m_refIdxMapping[0];
2244
2245 PCODEC_HEVC_SLICE_PARAMS slc = m_hevcSliceParams;
2246 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
2247 {
2248 hevcSliceState.pHevcSliceParams = slc;
2249 hevcSliceState.dwLength = slc->slice_data_size;
2250 hevcSliceState.dwSliceIndex = slcCount;
2251 hevcSliceState.bLastSlice = (slcCount == (m_numSlices - 1));
2252
2253 // If S2L and 1st pass, send HuC commands.
2254 if (m_shortFormatInUse)
2255 {
2256 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceS2L(cmdBufferInUse, &hevcSliceState));
2257 }
2258 else
2259 {
2260 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceLongFormat(cmdBufferInUse, &hevcSliceState));
2261 }
2262
2263 slc++;
2264 }
2265
2266 // If S2L and 1st pass
2267 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
2268 {
2269 // Send VD Pipe Flush command for SKL+
2270 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
2271 MOS_ZeroMemory(&vdpipeFlushParams , sizeof(vdpipeFlushParams));
2272 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
2273 vdpipeFlushParams.Flags.bFlushHEVC = 1;
2274 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
2275 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
2276 cmdBufferInUse,
2277 &vdpipeFlushParams));
2278
2279 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
2280 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2281 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2282 cmdBufferInUse,
2283 &flushDwParams));
2284
2285 if (m_statusQueryReportingEnabled)
2286 {
2287 // Check HuC_STATUS2 bit6, if bit6 > 0 HW continue execution following cmd, otherwise it send a COND BB END cmd.
2288 eStatus = m_hwInterface->SendCondBbEndCmd(
2289 &m_decodeStatusBuf.m_statusBuffer,
2290 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2MaskOffset,
2291 0,
2292 false,
2293 cmdBufferInUse);
2294 CODECHAL_DECODE_CHK_STATUS_RETURN(eStatus);
2295
2296 // Write HUC_STATUS mask
2297 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2298 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
2299 storeDataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
2300 storeDataParams.dwResourceOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset;
2301 storeDataParams.dwValue = m_hucInterface->GetHucStatusHevcS2lFailureMask();
2302 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
2303 cmdBufferInUse,
2304 &storeDataParams));
2305
2306 // store HUC_STATUS register
2307 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
2308 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
2309 storeRegParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
2310 storeRegParams.dwOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusRegOffset;
2311 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
2312 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
2313 cmdBufferInUse,
2314 &storeRegParams));
2315 }
2316
2317 if (m_enableSf2DmaSubmits)
2318 {
2319 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
2320 cmdBufferInUse,
2321 nullptr));
2322 }
2323
2324 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2325
2326 if (m_enableSf2DmaSubmits)
2327 {
2328 CODECHAL_DEBUG_TOOL(
2329 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2330 cmdBufferInUse,
2331 CODECHAL_NUM_MEDIA_STATES,
2332 "DEC"));
2333
2334 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
2335 // m_debugInterface,
2336 // cmdBufferInUse));
2337 );
2338
2339 //CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
2340 // m_osInterface,
2341 // cmdBufferInUse,
2342 // renderingFlags));
2343 }
2344
2345 return eStatus;
2346 }
2347 }
2348
2349 // Send VD Pipe Flush command for SKL+
2350 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
2351 MOS_ZeroMemory(&vdpipeFlushParams , sizeof(vdpipeFlushParams));
2352 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
2353 vdpipeFlushParams.Flags.bFlushHEVC = 1;
2354 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
2355 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
2356 cmdBufferInUse,
2357 &vdpipeFlushParams));
2358
2359 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
2360 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2361 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2362 cmdBufferInUse,
2363 &flushDwParams));
2364
2365 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
2366 syncParams.GpuContext = m_videoContext;
2367 if (m_is8BitFrameIn10BitHevc)
2368 {
2369 syncParams.presSyncResource =
2370 &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource;
2371 }
2372 else
2373 {
2374 syncParams.presSyncResource = &m_destSurface.OsResource;
2375 }
2376 syncParams.bReadOnly = false;
2377 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
2378 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
2379
2380 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
2381 {
2382 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
2383 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
2384
2385 // Update the resource tag (s/w tag) for On-Demand Sync
2386 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
2387 }
2388
2389 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
2390 if (m_osInterface->bTagResourceSync)
2391 {
2392 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
2393 cmdBufferInUse,
2394 &syncParams));
2395 }
2396
2397 if (m_statusQueryReportingEnabled)
2398 {
2399 CodechalDecodeStatusReport decodeStatusReport;
2400 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
2401 decodeStatusReport.m_currDecodedPic = m_hevcPicParams->CurrPic;
2402 decodeStatusReport.m_currDeblockedPic = m_hevcPicParams->CurrPic;
2403 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
2404 if (m_is8BitFrameIn10BitHevc)
2405 {
2406 decodeStatusReport.m_currDecodedPicRes = m_destSurface.OsResource;
2407 }
2408 else
2409 {
2410 decodeStatusReport.m_currDecodedPicRes = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic;
2411 }
2412 #ifdef _DECODE_PROCESSING_SUPPORTED
2413 CODECHAL_DEBUG_TOOL(
2414 if (m_downsampledSurfaces && m_sfcState && m_sfcState->m_sfcOutputSurface) {
2415 m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource =
2416 m_sfcState->m_sfcOutputSurface->OsResource;
2417 decodeStatusReport.m_currSfcOutputPicRes =
2418 &m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource;
2419 })
2420 #endif
2421 CODECHAL_DEBUG_TOOL(
2422 decodeStatusReport.m_secondField = CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
2423 decodeStatusReport.m_frameType = m_perfType;);
2424
2425 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
2426 decodeStatusReport,
2427 cmdBufferInUse));
2428 }
2429
2430 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2431 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2432 cmdBufferInUse,
2433 &flushDwParams));
2434
2435 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
2436 cmdBufferInUse,
2437 nullptr));
2438
2439 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2440
2441 bool syncCompleteFrame = m_copyDataBufferInUse;
2442
2443 if (syncCompleteFrame)
2444 {
2445 //Sync up complete frame
2446 MOS_SYNC_PARAMS copyDataSyncParams = g_cInitSyncParams;
2447 copyDataSyncParams.GpuContext = m_videoContextForWa;
2448 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2449
2450 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, ©DataSyncParams));
2451
2452 copyDataSyncParams = g_cInitSyncParams;
2453 copyDataSyncParams.GpuContext = m_videoContext;
2454 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2455
2456 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, ©DataSyncParams));
2457 }
2458
2459 CODECHAL_DEBUG_TOOL(
2460 {
2461 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2462 cmdBufferInUse,
2463 CODECHAL_NUM_MEDIA_STATES,
2464 "DEC"));
2465
2466 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
2467 // m_debugInterface,
2468 // cmdBufferInUse));
2469 }
2470 );
2471
2472 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface->pOsContext);
2473
2474 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
2475 m_osInterface,
2476 cmdBufferInUse,
2477 renderingFlags));
2478
2479 CODECHAL_DEBUG_TOOL(
2480 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
2481
2482 // Reset status report
2483 if (m_statusQueryReportingEnabled)
2484 {
2485 bool resetStatusReport = true;
2486
2487 if (resetStatusReport)
2488 {
2489 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
2490 m_videoContextUsesNullHw));
2491 }
2492 }
2493
2494 if (m_is8BitFrameIn10BitHevc)
2495 {
2496 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeNV12ToP010);
2497 CODECHAL_DECODE_CHK_STATUS_RETURN(m_decodeNV12ToP010->Execute(
2498 &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource,
2499 &m_destSurface.OsResource));
2500 }
2501
2502 // Needs to be re-set for Linux buffer re-use scenarios
2503 if (m_is8BitFrameIn10BitHevc)
2504 {
2505 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic =
2506 m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource;
2507 }
2508 else
2509 {
2510 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic =
2511 m_destSurface.OsResource;
2512 }
2513
2514 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
2515 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
2516 {
2517 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
2518 syncParams.GpuContext = m_videoContext;
2519 syncParams.presSyncResource = &m_destSurface.OsResource;
2520
2521 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
2522 }
2523
2524 #ifdef _DECODE_PROCESSING_SUPPORTED
2525 // Send Vebox and SFC cmds
2526 if (m_sfcState->m_sfcPipeOut)
2527 {
2528 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->RenderStart());
2529 }
2530 #endif
2531
2532 return eStatus;
2533 }
2534
CalcDownsamplingParams(void * picParams,uint32_t * refSurfWidth,uint32_t * refSurfHeight,MOS_FORMAT * format,uint8_t * frameIdx)2535 MOS_STATUS CodechalDecodeHevc::CalcDownsamplingParams(
2536 void *picParams,
2537 uint32_t *refSurfWidth,
2538 uint32_t *refSurfHeight,
2539 MOS_FORMAT *format,
2540 uint8_t *frameIdx)
2541 {
2542 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2543
2544 CODECHAL_DECODE_CHK_NULL_RETURN(picParams);
2545 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfWidth);
2546 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfHeight);
2547 CODECHAL_DECODE_CHK_NULL_RETURN(format);
2548 CODECHAL_DECODE_CHK_NULL_RETURN(frameIdx);
2549
2550 PCODEC_HEVC_PIC_PARAMS hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)picParams;
2551
2552 *refSurfWidth = 0;
2553 *refSurfHeight = 0;
2554 *format = Format_NV12;
2555 *frameIdx = hevcPicParams->CurrPic.FrameIdx;
2556
2557 uint32_t widthInPix, heightInPix;
2558
2559 widthInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicWidthInMinCbsY);
2560 heightInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicHeightInMinCbsY);
2561
2562 *refSurfWidth = MOS_ALIGN_CEIL(widthInPix, 64);
2563 *refSurfHeight = MOS_ALIGN_CEIL(heightInPix, 64);
2564
2565 if (m_is10BitHevc)
2566 {
2567 *format = Format_P010;
2568 }
2569
2570
2571 return eStatus;
2572 }
2573
InitMmcState()2574 MOS_STATUS CodechalDecodeHevc::InitMmcState()
2575 {
2576 #ifdef _MMC_SUPPORTED
2577 m_mmc = MOS_New(CodechalMmcDecodeHevc, m_hwInterface, this);
2578 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
2579 #endif
2580 return MOS_STATUS_SUCCESS;
2581 }
2582
AllocateStandard(CodechalSetting * settings)2583 MOS_STATUS CodechalDecodeHevc::AllocateStandard (
2584 CodechalSetting *settings)
2585 {
2586 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2587
2588 CODECHAL_DECODE_FUNCTION_ENTER;
2589
2590 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
2591
2592 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
2593
2594 m_width = settings->width;
2595 m_height = settings->height;
2596 m_is10BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS) ? true : false;
2597 m_is12BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_12_BITS) ? true : false;
2598 m_chromaFormatinProfile = settings->chromaFormat;
2599 m_shortFormatInUse = settings->shortFormatInUse;
2600
2601 #ifdef _DECODE_PROCESSING_SUPPORTED
2602 m_sfcState = MOS_New(CodechalHevcSfcState);
2603 CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
2604 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
2605 this,
2606 m_hwInterface,
2607 m_osInterface));
2608 #endif
2609
2610 MOS_ZeroMemory(&m_currPic, sizeof(m_currPic));
2611
2612 m_frameIdx = 0;
2613
2614 if (m_shortFormatInUse)
2615 {
2616 // Legacy SF has 2 passes, 1st pass is S2L, 2nd pass is HEVC Long decode.
2617 m_decodePassNum = 2;
2618
2619 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
2620 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
2621 MOS_UserFeature_ReadValue_ID(
2622 nullptr,
2623 __MEDIA_USER_FEATURE_VALUE_HEVC_SF_2_DMA_SUBMITS_ENABLE_ID,
2624 &userFeatureData);
2625 m_enableSf2DmaSubmits = userFeatureData.u32Data ? true : false;
2626 }
2627
2628 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
2629 stateCmdSizeParams.bShortFormat = m_shortFormatInUse;
2630 stateCmdSizeParams.bHucDummyStream = (m_secureDecoder ? m_secureDecoder->IsDummyStreamEnabled() : false);
2631
2632 // Picture Level Commands
2633 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxStateCommandSize(
2634 m_mode,
2635 &m_commandBufferSizeNeeded,
2636 &m_commandPatchListSizeNeeded,
2637 &stateCmdSizeParams));
2638
2639 // Primitive Level Commands
2640 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxPrimitiveCommandSize(
2641 m_mode,
2642 &m_standardDecodeSizeNeeded,
2643 &m_standardDecodePatchListSizeNeeded,
2644 m_shortFormatInUse));
2645
2646 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesFixedSizes());
2647
2648 // Prepare Pic Params
2649 m_picMhwParams.PipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS);
2650 m_picMhwParams.SurfaceParams = MOS_New(MHW_VDBOX_SURFACE_PARAMS);
2651 m_picMhwParams.PipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS);
2652 m_picMhwParams.IndObjBaseAddrParams = MOS_New(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS);
2653 m_picMhwParams.QmParams = MOS_New(MHW_VDBOX_QM_PARAMS);
2654 m_picMhwParams.HevcPicState = MOS_New(MHW_VDBOX_HEVC_PIC_STATE);
2655 m_picMhwParams.HevcTileState = MOS_New(MHW_VDBOX_HEVC_TILE_STATE);
2656
2657 MOS_ZeroMemory(m_picMhwParams.SurfaceParams, sizeof(MHW_VDBOX_SURFACE_PARAMS));
2658 MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
2659 MOS_ZeroMemory(m_picMhwParams.QmParams, sizeof(MHW_VDBOX_QM_PARAMS));
2660 MOS_ZeroMemory(m_picMhwParams.HevcTileState, sizeof(MHW_VDBOX_HEVC_TILE_STATE));
2661
2662 return eStatus;
2663 }
2664
CodechalDecodeHevc(CodechalHwInterface * hwInterface,CodechalDebugInterface * debugInterface,PCODECHAL_STANDARD_INFO standardInfo)2665 CodechalDecodeHevc::CodechalDecodeHevc(
2666 CodechalHwInterface * hwInterface,
2667 CodechalDebugInterface *debugInterface,
2668 PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecode(hwInterface, debugInterface, standardInfo),
2669 m_minCtbSize(0),
2670 m_is10BitHevc(false),
2671 m_is12BitHevc(false),
2672 m_chromaFormatinProfile(0),
2673 m_shortFormatInUse(false),
2674 m_dataSize(0),
2675 m_dataOffset(0),
2676 m_numSlices(0),
2677 m_is8BitFrameIn10BitHevc(false),
2678 m_internalNv12RtIndexMapInitilized(false),
2679 m_mfdDeblockingFilterRowStoreScratchBufferPicWidth(0),
2680 m_metadataLineBufferPicWidth(0),
2681 m_saoLineBufferPicWidth(0),
2682 m_mvBufferProgrammed(false),
2683 m_secondLevelBatchBufferIndex(0),
2684 m_dmemBufferIdx(0),
2685 m_dmemBufferSize(0),
2686 m_dmemTransferSize(0),
2687 m_dmemBufferProgrammed(false),
2688 m_copyDataBufferSize(0),
2689 m_copyDataOffset(0),
2690 m_copyDataBufferInUse(false),
2691 m_estiBytesInBitstream(0),
2692 m_curPicIntra(false),
2693 m_mvBufferSize(0),
2694 m_hevcMvBufferIndex(0),
2695 m_frameIdx(0),
2696 m_enableSf2DmaSubmits(false),
2697 m_widthLastMaxAlloced(0),
2698 m_heightLastMaxAlloced(0),
2699 m_ctbLog2SizeYMax(0),
2700 m_hcpDecPhase(0)
2701 {
2702 CODECHAL_DECODE_FUNCTION_ENTER;
2703
2704 MOS_ZeroMemory(m_internalNv12RtSurfaces, sizeof(m_internalNv12RtSurfaces));
2705 MOS_ZeroMemory(&m_resDataBuffer, sizeof(m_resDataBuffer));
2706 MOS_ZeroMemory(&m_resMfdDeblockingFilterRowStoreScratchBuffer, sizeof(m_resMfdDeblockingFilterRowStoreScratchBuffer));
2707 MOS_ZeroMemory(&m_resDeblockingFilterTileRowStoreScratchBuffer, sizeof(m_resDeblockingFilterTileRowStoreScratchBuffer));
2708 MOS_ZeroMemory(&m_resDeblockingFilterColumnRowStoreScratchBuffer, sizeof(m_resDeblockingFilterColumnRowStoreScratchBuffer));
2709 MOS_ZeroMemory(&m_resMetadataLineBuffer, sizeof(m_resMetadataLineBuffer));
2710 MOS_ZeroMemory(&m_resMetadataTileLineBuffer, sizeof(m_resMetadataTileLineBuffer));
2711 MOS_ZeroMemory(&m_resMetadataTileColumnBuffer, sizeof(m_resMetadataTileColumnBuffer));
2712 MOS_ZeroMemory(&m_resSaoLineBuffer, sizeof(m_resSaoLineBuffer));
2713 MOS_ZeroMemory(&m_resSaoTileLineBuffer, sizeof(m_resSaoTileLineBuffer));
2714 MOS_ZeroMemory(&m_resSaoTileColumnBuffer, sizeof(m_resSaoTileColumnBuffer));
2715 MOS_ZeroMemory(m_resMvTemporalBuffer, sizeof(m_resMvTemporalBuffer));
2716 MOS_ZeroMemory(m_resDmemBuffer, sizeof(m_resDmemBuffer));
2717 MOS_ZeroMemory(&m_resCopyDataBuffer, sizeof(m_resCopyDataBuffer));
2718 MOS_ZeroMemory(&m_resSyncObjectWaContextInUse, sizeof(m_resSyncObjectWaContextInUse));
2719 MOS_ZeroMemory(&m_picMhwParams,sizeof(m_picMhwParams));
2720 MOS_ZeroMemory(&m_hevcPicParams,sizeof(m_hevcPicParams));
2721 MOS_ZeroMemory(&m_hevcSliceParams,sizeof(m_hevcSliceParams));
2722 MOS_ZeroMemory(&m_hevcIqMatrixParams,sizeof(m_hevcIqMatrixParams));
2723 MOS_ZeroMemory(&m_destSurface,sizeof(m_destSurface));
2724 MOS_ZeroMemory(&m_currPic,sizeof(m_currPic));
2725
2726 m_hcpInUse = true;
2727 }
2728
2729 #if USE_CODECHAL_DEBUG_TOOL
DumpPicParams(PCODEC_HEVC_PIC_PARAMS picParams,void * extPicParams)2730 MOS_STATUS CodechalDecodeHevc::DumpPicParams(
2731 PCODEC_HEVC_PIC_PARAMS picParams,
2732 void* extPicParams)
2733 {
2734 CODECHAL_DEBUG_FUNCTION_ENTER;
2735
2736 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
2737 {
2738 return MOS_STATUS_SUCCESS;
2739 }
2740
2741 CODECHAL_DEBUG_CHK_NULL(picParams);
2742
2743 std::ostringstream oss;
2744 oss.setf(std::ios::showbase | std::ios::uppercase);
2745 oss.setf(std::ios::hex, std::ios::basefield);
2746
2747 oss << "PicWidthInMinCbsY: " << +picParams->PicWidthInMinCbsY << std::endl;
2748 oss << "PicHeightInMinCbsY: " << +picParams->PicHeightInMinCbsY << std::endl;
2749 //wFormatAndSequenceInfoFlags
2750 oss << "chroma_format_idc: " << +picParams->chroma_format_idc << std::endl;
2751 oss << "separate_colour_plane_flag: " << +picParams->separate_colour_plane_flag << std::endl;
2752 oss << "bit_depth_luma_minus8: " << +picParams->bit_depth_luma_minus8 << std::endl;
2753 oss << "bit_depth_chroma_minus8: " << +picParams->bit_depth_chroma_minus8 << std::endl;
2754 oss << "log2_max_pic_order_cnt_lsb_minus4: " << +picParams->log2_max_pic_order_cnt_lsb_minus4 << std::endl;
2755 oss << "NoPicReorderingFlag: " << +picParams->NoPicReorderingFlag << std::endl;
2756 oss << "ReservedBits1: " << +picParams->ReservedBits1 << std::endl;
2757 oss << "wFormatAndSequenceInfoFlags: " << +picParams->wFormatAndSequenceInfoFlags << std::endl;
2758 oss << "CurrPic FrameIdx: " << +picParams->CurrPic.FrameIdx << std::endl;
2759 oss << "CurrPic PicFlags: " << +picParams->CurrPic.PicFlags << std::endl;
2760 oss << "sps_max_dec_pic_buffering_minus1: " << +picParams->sps_max_dec_pic_buffering_minus1 << std::endl;
2761 oss << "log2_min_luma_coding_block_size_minus3: " << +picParams->log2_min_luma_coding_block_size_minus3 << std::endl;
2762 oss << "log2_diff_max_min_luma_coding_block_size: " << +picParams->log2_diff_max_min_luma_coding_block_size << std::endl;
2763 oss << "log2_min_transform_block_size_minus2: " << +picParams->log2_min_transform_block_size_minus2 << std::endl;
2764 oss << "log2_diff_max_min_transform_block_size: " << +picParams->log2_diff_max_min_transform_block_size << std::endl;
2765 oss << "max_transform_hierarchy_depth_intra: " << +picParams->max_transform_hierarchy_depth_intra << std::endl;
2766 oss << "max_transform_hierarchy_depth_inter: " << +picParams->max_transform_hierarchy_depth_inter << std::endl;
2767 oss << "num_short_term_ref_pic_sets: " << +picParams->num_short_term_ref_pic_sets << std::endl;
2768 oss << "num_long_term_ref_pic_sps: " << +picParams->num_long_term_ref_pic_sps << std::endl;
2769 oss << "num_ref_idx_l0_default_active_minus1: " << +picParams->num_ref_idx_l0_default_active_minus1 << std::endl;
2770 oss << "num_ref_idx_l1_default_active_minus1: " << +picParams->num_ref_idx_l1_default_active_minus1 << std::endl;
2771 oss << "init_qp_minus26: " << +picParams->init_qp_minus26 << std::endl;
2772 oss << "ucNumDeltaPocsOfRefRpsIdx: " << +picParams->ucNumDeltaPocsOfRefRpsIdx << std::endl;
2773 oss << "wNumBitsForShortTermRPSInSlice: " << +picParams->wNumBitsForShortTermRPSInSlice << std::endl;
2774 oss << "ReservedBits2: " << +picParams->ReservedBits2 << std::endl;
2775 //dwCodingParamToolFlags
2776 oss << "scaling_list_enabled_flag: " << +picParams->scaling_list_enabled_flag << std::endl;
2777 oss << "amp_enabled_flag: " << +picParams->amp_enabled_flag << std::endl;
2778 oss << "sample_adaptive_offset_enabled_flag: " << +picParams->sample_adaptive_offset_enabled_flag << std::endl;
2779 oss << "pcm_enabled_flag: " << +picParams->pcm_enabled_flag << std::endl;
2780 oss << "pcm_sample_bit_depth_luma_minus1: " << +picParams->pcm_sample_bit_depth_luma_minus1 << std::endl;
2781 oss << "pcm_sample_bit_depth_chroma_minus1: " << +picParams->pcm_sample_bit_depth_chroma_minus1 << std::endl;
2782 oss << "log2_min_pcm_luma_coding_block_size_minus3: " << +picParams->log2_min_pcm_luma_coding_block_size_minus3 << std::endl;
2783 oss << "log2_diff_max_min_pcm_luma_coding_block_size: " << +picParams->log2_diff_max_min_pcm_luma_coding_block_size << std::endl;
2784 oss << "pcm_loop_filter_disabled_flag: " << +picParams->pcm_loop_filter_disabled_flag << std::endl;
2785 oss << "long_term_ref_pics_present_flag: " << +picParams->long_term_ref_pics_present_flag << std::endl;
2786 oss << "sps_temporal_mvp_enabled_flag: " << +picParams->sps_temporal_mvp_enabled_flag << std::endl;
2787 oss << "strong_intra_smoothing_enabled_flag: " << +picParams->strong_intra_smoothing_enabled_flag << std::endl;
2788 oss << "dependent_slice_segments_enabled_flag: " << +picParams->dependent_slice_segments_enabled_flag << std::endl;
2789 oss << "output_flag_present_flag: " << +picParams->output_flag_present_flag << std::endl;
2790 oss << "num_extra_slice_header_bits: " << +picParams->num_extra_slice_header_bits << std::endl;
2791 oss << "sign_data_hiding_enabled_flag: " << +picParams->sign_data_hiding_enabled_flag << std::endl;
2792 oss << "cabac_init_present_flag: " << +picParams->cabac_init_present_flag << std::endl;
2793 oss << "ReservedBits3: " << +picParams->ReservedBits3 << std::endl;
2794 oss << "dwCodingParamToolFlags: " << +picParams->dwCodingParamToolFlags << std::endl;
2795 //dwCodingSettingPicturePropertyFlags
2796 oss << "constrained_intra_pred_flag: " << +picParams->constrained_intra_pred_flag << std::endl;
2797 oss << "transform_skip_enabled_flag: " << +picParams->transform_skip_enabled_flag << std::endl;
2798 oss << "cu_qp_delta_enabled_flag: " << +picParams->cu_qp_delta_enabled_flag << std::endl;
2799 oss << "diff_cu_qp_delta_depth: " << +picParams->diff_cu_qp_delta_depth << std::endl;
2800 oss << "pps_slice_chroma_qp_offsets_present_flag: " << +picParams->pps_slice_chroma_qp_offsets_present_flag << std::endl;
2801 oss << "weighted_pred_flag: " << +picParams->weighted_pred_flag << std::endl;
2802 oss << "weighted_bipred_flag: " << +picParams->weighted_bipred_flag << std::endl;
2803 oss << "transquant_bypass_enabled_flag: " << +picParams->transquant_bypass_enabled_flag << std::endl;
2804 oss << "tiles_enabled_flag: " << +picParams->tiles_enabled_flag << std::endl;
2805 oss << "entropy_coding_sync_enabled_flag: " << +picParams->entropy_coding_sync_enabled_flag << std::endl;
2806 oss << "uniform_spacing_flag: " << +picParams->uniform_spacing_flag << std::endl;
2807 oss << "loop_filter_across_tiles_enabled_flag: " << +picParams->loop_filter_across_tiles_enabled_flag << std::endl;
2808 oss << "pps_loop_filter_across_slices_enabled_flag: " << +picParams->pps_loop_filter_across_slices_enabled_flag << std::endl;
2809 oss << "deblocking_filter_override_enabled_flag: " << +picParams->deblocking_filter_override_enabled_flag << std::endl;
2810 oss << "pps_deblocking_filter_disabled_flag: " << +picParams->pps_deblocking_filter_disabled_flag << std::endl;
2811 oss << "lists_modification_present_flag: " << +picParams->lists_modification_present_flag << std::endl;
2812 oss << "slice_segment_header_extension_present_flag: " << +picParams->slice_segment_header_extension_present_flag << std::endl;
2813 oss << "IrapPicFlag: " << +picParams->IrapPicFlag << std::endl;
2814 oss << "IdrPicFlag: " << +picParams->IdrPicFlag << std::endl;
2815 oss << "IntraPicFlag: " << +picParams->IntraPicFlag << std::endl;
2816 oss << "ReservedBits4: " << +picParams->ReservedBits4 << std::endl;
2817 oss << "dwCodingSettingPicturePropertyFlags: " << +picParams->dwCodingSettingPicturePropertyFlags << std::endl;
2818 oss << "pps_cb_qp_offset: " << +picParams->pps_cb_qp_offset << std::endl;
2819 oss << "pps_cr_qp_offset: " << +picParams->pps_cr_qp_offset << std::endl;
2820 oss << "num_tile_columns_minus1: " << +picParams->num_tile_columns_minus1 << std::endl;
2821 oss << "num_tile_rows_minus1: " << +picParams->num_tile_rows_minus1 << std::endl;
2822 //Dump column width
2823 oss << "column_width_minus1[19]:";
2824 for (uint8_t i = 0; i < 19; i++)
2825 oss << picParams->column_width_minus1[i] << " ";
2826 oss << std::endl;
2827
2828 //Dump row height
2829 oss << "row_height_minus1[21]:";
2830 for (uint8_t i = 0; i < 21; i++)
2831 oss << picParams->row_height_minus1[i] << " ";
2832 oss << std::endl;
2833
2834 oss << "pps_beta_offset_div2: " << +picParams->pps_beta_offset_div2 << std::endl;
2835 oss << "pps_tc_offset_div2: " << +picParams->pps_tc_offset_div2 << std::endl;
2836 oss << "log2_parallel_merge_level_minus2: " << +picParams->log2_parallel_merge_level_minus2 << std::endl;
2837 oss << "CurrPicOrderCntVal: " << +picParams->CurrPicOrderCntVal << std::endl;
2838
2839 oss.setf(std::ios::dec, std::ios::basefield);
2840 //Dump RefFrameList[15]
2841 for (uint8_t i = 0; i < 15; ++i)
2842 {
2843 oss << "RefFrameList[" << +i << "] FrameIdx:" << +picParams->RefFrameList[i].FrameIdx << std::endl;
2844 oss << "RefFrameList[" << +i << "] PicFlags:" << +picParams->RefFrameList[i].PicFlags << std::endl;
2845 }
2846
2847 //Dump POC List
2848 oss << "PicOrderCntValList[15]:";
2849 for (uint8_t i = 0; i < 15; i++)
2850 oss << std::hex << picParams->PicOrderCntValList[i] << " ";
2851 oss << std::endl;
2852
2853 //Dump Ref RefPicSetStCurrBefore List
2854 oss << "RefPicSetStCurrBefore[8]:";
2855 for (uint8_t i = 0; i < 8; i++)
2856 oss << picParams->RefPicSetStCurrBefore[i] << " ";
2857 oss << std::endl;
2858
2859 //Dump Ref RefPicSetStCurrAfter List
2860 oss << "RefPicSetStCurrAfter[16]:";
2861 for (uint8_t i = 0; i < 8; i++)
2862 oss << picParams->RefPicSetStCurrAfter[i] << " ";
2863 oss << std::endl;
2864
2865 //Dump Ref PicSetStCurr List
2866 oss << "RefPicSetLtCurr[16]:";
2867 for (uint8_t i = 0; i < 8; i++)
2868 oss << picParams->RefPicSetLtCurr[i] << " ";
2869 oss << std::endl;
2870
2871 //Dump Ref RefPicSetStCurrBefore List with POC
2872 oss << "RefPicSetStCurrBefore[8] (POC): ";
2873 for (uint8_t i = 0; i < 8; i++)
2874 oss << picParams->PicOrderCntValList[picParams->RefPicSetStCurrBefore[i]] << " ";
2875 oss << std::endl;
2876
2877 //Dump Ref RefPicSetStCurrAfter List with POC
2878 oss << "RefPicSetStCurrAfter[16] (POC):";
2879 for (uint8_t i = 0; i < 8; i++)
2880 oss << picParams->PicOrderCntValList[picParams->RefPicSetStCurrAfter[i]] << " ";
2881 oss << std::endl;
2882
2883 //Dump Ref PicSetStCurr List with POC
2884 oss << "RefPicSetLtCurr[16] (POC): ";
2885 for (uint8_t i = 0; i < 8; i++)
2886 oss << picParams->PicOrderCntValList[picParams->RefPicSetLtCurr[i]] << " ";
2887 oss << std::endl;
2888
2889 oss << "RefFieldPicFlag: " << +picParams->RefFieldPicFlag << std::endl;
2890 oss << "RefBottomFieldFlag: " << +picParams->RefBottomFieldFlag << std::endl;
2891 oss << "StatusReportFeedbackNumber: " << +picParams->StatusReportFeedbackNumber << std::endl;
2892
2893 const char *fileName = m_debugInterface->CreateFileName(
2894 "_DEC",
2895 CodechalDbgBufferType::bufPicParams,
2896 CodechalDbgExtType::txt);
2897
2898 std::ofstream ofs(fileName, std::ios::out);
2899 ofs << oss.str();
2900 ofs.close();
2901
2902 return MOS_STATUS_SUCCESS;
2903 }
2904
DumpSliceParams(PCODEC_HEVC_SLICE_PARAMS sliceParams,void * extSliceParams,uint32_t numSlices,bool shortFormatInUse)2905 MOS_STATUS CodechalDecodeHevc::DumpSliceParams(
2906 PCODEC_HEVC_SLICE_PARAMS sliceParams,
2907 void* extSliceParams,
2908 uint32_t numSlices,
2909 bool shortFormatInUse)
2910 {
2911 CODECHAL_DEBUG_FUNCTION_ENTER;
2912 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
2913 {
2914 return MOS_STATUS_SUCCESS;
2915 }
2916
2917 CODECHAL_DEBUG_CHK_NULL(sliceParams);
2918
2919 PCODEC_HEVC_SLICE_PARAMS hevcSliceControl = nullptr;
2920
2921 std::ostringstream oss;
2922 oss.setf(std::ios::showbase | std::ios::uppercase);
2923
2924 for (uint16_t j = 0; j < numSlices; j++)
2925 {
2926 hevcSliceControl = &sliceParams[j];
2927
2928 oss << "====================================================================================================" << std::endl;
2929 oss << "Data for Slice number = " << +j << std::endl;
2930 oss << "slice_data_size: " << +hevcSliceControl->slice_data_size << std::endl;
2931 oss << "slice_data_offset: " << +hevcSliceControl->slice_data_offset << std::endl;
2932
2933 if (!shortFormatInUse)
2934 {
2935 //Dump Long format specific
2936 oss << "ByteOffsetToSliceData: " << +hevcSliceControl->ByteOffsetToSliceData << std::endl;
2937 oss << "slice_segment_address: " << +hevcSliceControl->slice_segment_address << std::endl;
2938
2939 //Dump RefPicList[2][15]
2940 for (uint8_t i = 0; i < 15; ++i)
2941 {
2942 oss << "RefPicList[0][" << +i << "]";
2943 oss << "FrameIdx: " << +hevcSliceControl->RefPicList[0][i].FrameIdx;
2944 oss << ", PicFlags: " << +hevcSliceControl->RefPicList[0][i].PicFlags;
2945 oss << std::endl;
2946 }
2947 for (uint8_t i = 0; i < 15; ++i)
2948 {
2949 oss << "RefPicList[1][" << +i << "]";
2950 oss << "FrameIdx: " << +hevcSliceControl->RefPicList[1][i].FrameIdx;
2951 oss << ", PicFlags: " << +hevcSliceControl->RefPicList[1][i].PicFlags;
2952 oss << std::endl;
2953 }
2954
2955 oss << "last_slice_of_pic: " << +hevcSliceControl->LongSliceFlags.fields.LastSliceOfPic << std::endl;
2956 oss << "dependent_slice_segment_flag: " << +hevcSliceControl->LongSliceFlags.fields.dependent_slice_segment_flag << std::endl;
2957 oss << "slice_type: " << +hevcSliceControl->LongSliceFlags.fields.slice_type << std::endl;
2958 oss << "color_plane_id: " << +hevcSliceControl->LongSliceFlags.fields.color_plane_id << std::endl;
2959 oss << "slice_sao_luma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_luma_flag << std::endl;
2960 oss << "slice_sao_chroma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_chroma_flag << std::endl;
2961 oss << "mvd_l1_zero_flag: " << +hevcSliceControl->LongSliceFlags.fields.mvd_l1_zero_flag << std::endl;
2962 oss << "cabac_init_flag: " << +hevcSliceControl->LongSliceFlags.fields.cabac_init_flag << std::endl;
2963 oss << "slice_temporal_mvp_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag << std::endl;
2964 oss << "slice_deblocking_filter_disabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag << std::endl;
2965 oss << "collocated_from_l0_flag: " << +hevcSliceControl->LongSliceFlags.fields.collocated_from_l0_flag << std::endl;
2966 oss << "slice_loop_filter_across_slices_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag << std::endl;
2967 oss << "reserved: " << +hevcSliceControl->LongSliceFlags.fields.reserved << std::endl;
2968 oss << "collocated_ref_idx: " << +hevcSliceControl->collocated_ref_idx << std::endl;
2969 oss << "num_ref_idx_l0_active_minus1: " << +hevcSliceControl->num_ref_idx_l0_active_minus1 << std::endl;
2970 oss << "num_ref_idx_l1_active_minus1: " << +hevcSliceControl->num_ref_idx_l1_active_minus1 << std::endl;
2971 oss << "slice_qp_delta: " << +hevcSliceControl->slice_qp_delta << std::endl;
2972 oss << "slice_cb_qp_offset: " << +hevcSliceControl->slice_cb_qp_offset << std::endl;
2973 oss << "slice_cr_qp_offset: " << +hevcSliceControl->slice_cr_qp_offset << std::endl;
2974 oss << "slice_beta_offset_div2: " << +hevcSliceControl->slice_beta_offset_div2 << std::endl;
2975 oss << "slice_tc_offset_div2: " << +hevcSliceControl->slice_tc_offset_div2 << std::endl;
2976 oss << "luma_log2_weight_denom: " << +hevcSliceControl->luma_log2_weight_denom << std::endl;
2977 oss << "delta_chroma_log2_weight_denom: " << +hevcSliceControl->delta_chroma_log2_weight_denom << std::endl;
2978
2979 //Dump luma_offset[2][15]
2980 for (uint8_t i = 0; i < 15; i++)
2981 {
2982 oss << "luma_offset_l0[" << +i << "]: " << (+hevcSliceControl->luma_offset_l0[i]) << std::endl;
2983 oss << "luma_offset_l1[" << +i << "]: " << (+hevcSliceControl->luma_offset_l1[i]) << std::endl;
2984 }
2985 //Dump delta_luma_weight[2][15]
2986 for (uint8_t i = 0; i < 15; i++)
2987 {
2988 oss << "delta_luma_weight_l0[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
2989 oss << "delta_luma_weight_l1[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
2990 }
2991 //Dump chroma_offset[2][15][2]
2992 for (uint8_t i = 0; i < 15; i++)
2993 {
2994 oss << "ChromaOffsetL0[" << +i << "][0]: " << (+hevcSliceControl->ChromaOffsetL0[i][0]) << std::endl;
2995
2996 oss << "ChromaOffsetL0[" << +i << "][1]: " << (+hevcSliceControl->ChromaOffsetL0[i][1]) << std::endl;
2997
2998 oss << "ChromaOffsetL1[" << +i << "][0]: " << (+hevcSliceControl->ChromaOffsetL1[i][0]) << std::endl;
2999
3000 oss << "ChromaOffsetL1[" << +i << "][1]: " << (+hevcSliceControl->ChromaOffsetL1[i][1]) << std::endl;
3001 }
3002 //Dump delta_chroma_weight[2][15][2]
3003 for (uint8_t i = 0; i < 15; i++)
3004 {
3005 oss << "delta_chroma_weight_l0[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l0[i][0] << std::endl;
3006 oss << "delta_chroma_weight_l0[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l0[i][1] << std::endl;
3007 oss << "delta_chroma_weight_l1[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l1[i][0] << std::endl;
3008 oss << "delta_chroma_weight_l1[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l1[i][1] << std::endl;
3009 }
3010
3011 oss << "five_minus_max_num_merge_cand: " << +hevcSliceControl->five_minus_max_num_merge_cand << std::endl;
3012
3013 }
3014
3015 const char *fileName = m_debugInterface->CreateFileName(
3016 "_DEC",
3017 CodechalDbgBufferType::bufSlcParams,
3018 CodechalDbgExtType::txt);
3019
3020 std::ofstream ofs;
3021 if (j == 0)
3022 {
3023 ofs.open(fileName, std::ios::out);
3024 }
3025 else
3026 {
3027 ofs.open(fileName, std::ios::app);
3028 }
3029 ofs << oss.str();
3030 ofs.close();
3031 }
3032 return MOS_STATUS_SUCCESS;
3033 }
3034
DumpIQParams(PCODECHAL_HEVC_IQ_MATRIX_PARAMS matrixData)3035 MOS_STATUS CodechalDecodeHevc::DumpIQParams(
3036 PCODECHAL_HEVC_IQ_MATRIX_PARAMS matrixData)
3037 {
3038 CODECHAL_DEBUG_FUNCTION_ENTER;
3039
3040 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
3041 {
3042 return MOS_STATUS_SUCCESS;
3043 }
3044
3045 CODECHAL_DEBUG_CHK_NULL(matrixData);
3046
3047 std::ostringstream oss;
3048 oss.setf(std::ios::showbase | std::ios::uppercase);
3049
3050 uint32_t idx;
3051 uint32_t idx2;
3052 // 4x4 block
3053 for (idx2 = 0; idx2 < 6; idx2++)
3054 {
3055 oss << "Qmatrix_HEVC_ucScalingLists0[" << std::dec << +idx2 << "]:" << std::endl;
3056
3057 oss << "ucScalingLists0[" << +idx2 << "]:";
3058 for (uint8_t i = 0; i < 16; i++)
3059 oss << std::hex << +matrixData->ucScalingLists0[idx2][i] << " ";
3060 oss << std::endl;
3061 }
3062
3063 // 8x8 block
3064 for (idx2 = 0; idx2 < 6; idx2++)
3065 {
3066 oss << "ucScalingLists1[" << std::dec << +idx2 << "]:" << std::endl;
3067
3068 for (idx = 0; idx < 56; idx += 8)
3069 {
3070 oss << "ucScalingLists1[" << std::dec << +idx / 8 << "]:" << std::endl;
3071 for (uint8_t i = 0; i < 8; i++)
3072 oss << std::hex << +matrixData->ucScalingLists1[idx2][idx + i] << " ";
3073 oss << std::endl;
3074 }
3075 }
3076
3077 // 16x16 block
3078 for (idx2 = 0; idx2 < 6; idx2++)
3079 {
3080 oss << "ucScalingLists2[" << std::dec << +idx2 << "]:" << std::endl;
3081
3082 for (idx = 0; idx < 56; idx += 8)
3083 {
3084 oss << "ucScalingLists2[" << std::dec << +idx / 8 << "]:" << std::endl;
3085 for (uint8_t i = 0; i < 8; i++)
3086 oss << std::hex << +matrixData->ucScalingLists2[idx2][idx + i] << " ";
3087 oss << std::endl;
3088 }
3089 }
3090 // 32x32 block
3091 for (idx2 = 0; idx2 < 2; idx2++)
3092 {
3093 oss << "ucScalingLists3[" << std::dec << +idx2 << "]:" << std::endl;
3094
3095 for (idx = 0; idx < 56; idx += 8)
3096 {
3097 oss << "ucScalingLists3[" << std::dec << +idx / 8 << "]:" << std::endl;
3098 for (uint8_t i = 0; i < 8; i++)
3099 oss << std::hex << +matrixData->ucScalingLists3[idx2][idx + i] << " ";
3100 oss << std::endl;
3101 }
3102 }
3103
3104 //DC16x16 block
3105 oss << "ucScalingListDCCoefSizeID2: ";
3106 for (uint8_t i = 0; i < 6; i++)
3107 oss << std::hex << +matrixData->ucScalingListDCCoefSizeID2[i] << " ";
3108
3109 oss << std::endl;
3110
3111 //DC32x32 block
3112
3113 oss << "ucScalingListDCCoefSizeID3: ";
3114 oss << +matrixData->ucScalingListDCCoefSizeID3[0] << " " << +matrixData->ucScalingListDCCoefSizeID3[1] << std::endl;
3115
3116 const char *fileName = m_debugInterface->CreateFileName(
3117 "_DEC",
3118 CodechalDbgBufferType::bufIqParams,
3119 CodechalDbgExtType::txt);
3120
3121 std::ofstream ofs(fileName, std::ios::out);
3122 ofs << oss.str();
3123 ofs.close();
3124
3125 return MOS_STATUS_SUCCESS;
3126 }
3127
3128 #endif
3129