1 /*
2 * Copyright (c) 2012-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file codechal_decode_hevc.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 CODECHAL_DECODE_CHK_STATUS_RETURN(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 MT_ERR1(MT_DEC_HEVC, MT_DEC_HUC_ERROR_STATUS2, (m_decodeStatusBuf.m_decodeStatus->m_hucErrorStatus2 >> 32));
1114 return MOS_STATUS_UNKNOWN;
1115 }
1116
1117 m_cencBuf = m_decodeParams.m_cencBuf;
1118
1119 if (IsFirstExecuteCall()) // For DRC Multiple Execution Call, no need to update every value in pHevcState except first execute
1120 {
1121 m_dataSize = m_decodeParams.m_dataSize;
1122 m_dataOffset = m_decodeParams.m_dataOffset;
1123 m_numSlices = m_decodeParams.m_numSlices;
1124
1125 if (m_numSlices > CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6)
1126 {
1127 CODECHAL_DECODE_ASSERTMESSAGE("Slice number doesn't support!");
1128 return MOS_STATUS_INVALID_PARAMETER;
1129 }
1130
1131 m_hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)m_decodeParams.m_picParams;
1132 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_sliceParams);
1133 m_hevcSliceParams = (PCODEC_HEVC_SLICE_PARAMS)m_decodeParams.m_sliceParams;
1134 m_hevcIqMatrixParams = (PCODECHAL_HEVC_IQ_MATRIX_PARAMS)m_decodeParams.m_iqMatrixBuffer;
1135 m_destSurface = *(m_decodeParams.m_destSurface);
1136 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
1137
1138 CODECHAL_DECODE_CHK_STATUS_RETURN(InitializeBitstreamCat());
1139 }
1140 else
1141 {
1142 m_dataSize = m_decodeParams.m_dataSize;
1143 m_dataOffset = 0;
1144 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
1145 }
1146
1147 CODECHAL_DECODE_CHK_STATUS_RETURN(CheckAndCopyBitstream());
1148
1149 //For CENC case, the Entry has been initialized with value in SetParamsForDecode
1150 PCODEC_REF_LIST destEntry = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx];
1151 MOS_ZeroMemory(destEntry, sizeof(CODEC_REF_LIST));
1152
1153 if (m_incompletePicture)
1154 {
1155 return MOS_STATUS_SUCCESS;
1156 }
1157
1158 CODECHAL_DECODE_CHK_NULL_RETURN(m_hevcPicParams);
1159 CODECHAL_DECODE_CHK_NULL_RETURN(m_hevcIqMatrixParams);
1160
1161 // Calculate bIs8bitFrameIn10bitHevc
1162 if (MEDIA_IS_WA(m_waTable, Wa8BitFrameIn10BitHevc) &&
1163 m_is10BitHevc &&
1164 m_hevcPicParams->bit_depth_luma_minus8 == 0 &&
1165 m_hevcPicParams->bit_depth_chroma_minus8 == 0 &&
1166 m_decodeParams.m_destSurface->Format == Format_P010)
1167 {
1168 m_is8BitFrameIn10BitHevc = true;
1169 }
1170 else
1171 {
1172 m_is8BitFrameIn10BitHevc = false;
1173 }
1174
1175 // InitNV12ToP010Context
1176 if (m_is8BitFrameIn10BitHevc && m_decodeNV12ToP010 == nullptr)
1177 {
1178 m_decodeNV12ToP010 = Nv12ToP010Device::CreateFactory(m_osInterface);
1179 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeNV12ToP010);
1180 }
1181
1182 // Calculate bCurPicIntra
1183 m_curPicIntra = true;
1184 if (m_hevcPicParams->IntraPicFlag == 0)
1185 {
1186 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1187 {
1188 uint8_t frameIdx = m_hevcPicParams->RefPicSetStCurrBefore[i];
1189 if (frameIdx < 15)
1190 {
1191 m_curPicIntra = false;
1192 break;
1193 }
1194
1195 frameIdx = m_hevcPicParams->RefPicSetStCurrAfter[i];
1196 if (frameIdx < 15)
1197 {
1198 m_curPicIntra = false;
1199 break;
1200 }
1201
1202 frameIdx = m_hevcPicParams->RefPicSetLtCurr[i];
1203 if (frameIdx < 15)
1204 {
1205 m_curPicIntra = false;
1206 break;
1207 }
1208 }
1209 }
1210
1211 CODECHAL_DECODE_CHK_STATUS_RETURN(SetPictureStructs());
1212
1213 uint32_t i;
1214 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1215 {
1216 m_frameUsedAsCurRef[i] = false;
1217 m_refIdxMapping[i] = -1;
1218 }
1219
1220 // Calculate RefIdxMapping
1221 for (i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1222 {
1223 uint8_t frameIdx = m_hevcPicParams->RefPicSetStCurrBefore[i];
1224 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
1225 {
1226 m_frameUsedAsCurRef[frameIdx] = true;
1227 }
1228
1229 frameIdx = m_hevcPicParams->RefPicSetStCurrAfter[i];
1230 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
1231 {
1232 m_frameUsedAsCurRef[frameIdx] = true;
1233 }
1234
1235 frameIdx = m_hevcPicParams->RefPicSetLtCurr[i];
1236 if (frameIdx < CODEC_MAX_NUM_REF_FRAME_HEVC)
1237 {
1238 m_frameUsedAsCurRef[frameIdx] = true;
1239 }
1240 }
1241
1242 uint8_t curRefIdx = 0;
1243 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1244 {
1245 if (m_frameUsedAsCurRef[i])
1246 {
1247 m_refIdxMapping[i] = curRefIdx++;
1248 }
1249 }
1250
1251 CODECHAL_DECODE_CHK_COND_RETURN(curRefIdx > 8,"bitstream has more than 8 references");
1252
1253 m_minCtbSize = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
1254 m_width = m_hevcPicParams->PicWidthInMinCbsY * m_minCtbSize;
1255 m_height = m_hevcPicParams->PicHeightInMinCbsY * m_minCtbSize;
1256
1257 if (m_hcpInterface->IsRowStoreCachingSupported())
1258 {
1259 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams;
1260 rowstoreParams.Mode = CODECHAL_DECODE_MODE_HEVCVLD;
1261 rowstoreParams.dwPicWidth = m_width;
1262 rowstoreParams.bMbaff = false;
1263 rowstoreParams.ucBitDepthMinus8 = (uint8_t)MOS_MAX(m_hevcPicParams->bit_depth_luma_minus8, m_hevcPicParams->bit_depth_chroma_minus8);
1264 rowstoreParams.ucChromaFormat = m_hevcPicParams->chroma_format_idc;
1265 rowstoreParams.ucLCUSize = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3 +
1266 m_hevcPicParams->log2_diff_max_min_luma_coding_block_size);
1267 m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams);
1268 }
1269
1270 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesVariableSizes());
1271
1272 // Calculate Tile info
1273 if (m_hevcPicParams->tiles_enabled_flag)
1274 {
1275 CODECHAL_DECODE_CHK_STATUS_RETURN(GetAllTileInfo());
1276 }
1277
1278 m_hcpDecPhase = CodechalHcpDecodePhaseInitialized;
1279
1280 if (m_curPicIntra)
1281 {
1282 m_perfType = I_TYPE;
1283 }
1284 else
1285 {
1286 // Not possible to determine whether P or B is used for short format.
1287 // For long format iterating through all of the slices to determine P vs
1288 // B, so in order to avoid this, declare all other pictures MIXED_TYPE.
1289 m_perfType = MIXED_TYPE;
1290 }
1291
1292 m_crrPic = m_hevcPicParams->CurrPic;
1293 m_secondField =
1294 CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
1295
1296 CODECHAL_DEBUG_TOOL(
1297 m_debugInterface->m_currPic = m_crrPic;
1298 m_debugInterface->m_secondField = m_secondField;
1299 m_debugInterface->m_frameType = m_perfType;
1300
1301 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(
1302 m_hevcPicParams,
1303 nullptr));
1304
1305 if (m_hevcIqMatrixParams) {
1306 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpIQParams(m_hevcIqMatrixParams));
1307 }
1308
1309 if (m_hevcSliceParams) {
1310 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpSliceParams(
1311 m_hevcSliceParams,
1312 nullptr,
1313 m_numSlices,
1314 m_shortFormatInUse));
1315 })
1316
1317 // Clear DMEM buffer program flag and increase the Dmem buffer index to program
1318 if (m_shortFormatInUse)
1319 {
1320 m_dmemBufferProgrammed = false;
1321 m_dmemBufferIdx++;
1322 m_dmemBufferIdx %= CODECHAL_HEVC_NUM_DMEM_BUFFERS;
1323 }
1324
1325 #ifdef _DECODE_PROCESSING_SUPPORTED
1326 // Check if SFC can be supported
1327 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->CheckAndInitialize((DecodeProcessingParams *)m_decodeParams.m_procParams, m_hevcPicParams));
1328 #endif
1329 CODECHAL_DEBUG_TOOL(
1330 if (!m_incompletePicture && !IsFirstExecuteCall()) {
1331 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1332 &m_resCopyDataBuffer,
1333 CodechalDbgAttr::attrBitstream,
1334 "_DEC",
1335 m_estiBytesInBitstream,
1336 0,
1337 CODECHAL_NUM_MEDIA_STATES));
1338 })
1339
1340 return eStatus;
1341 }
1342
SetPictureStructs()1343 MOS_STATUS CodechalDecodeHevc::SetPictureStructs()
1344 {
1345 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1346
1347 CODECHAL_DECODE_FUNCTION_ENTER;
1348
1349 PCODEC_HEVC_PIC_PARAMS picParams = m_hevcPicParams;
1350 PCODEC_REF_LIST * hevcRefList = &m_hevcRefList[0];
1351 PCODECHAL_DECODE_HEVC_MV_LIST hevcMVBufferList = &m_hevcMvList[0];
1352
1353 CODEC_PICTURE prevPic = m_currPic;
1354 m_currPic = picParams->CurrPic;
1355
1356 m_statusReportFeedbackNumber = picParams->StatusReportFeedbackNumber;
1357
1358 if (m_currPic.FrameIdx >= CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
1359 {
1360 CODECHAL_DECODE_ASSERTMESSAGE("currPic.FrameIdx is out of range!");
1361 return MOS_STATUS_INVALID_PARAMETER;
1362 }
1363
1364 hevcRefList[m_currPic.FrameIdx]->RefPic = m_currPic;
1365 hevcRefList[m_currPic.FrameIdx]->sFrameNumber = (int16_t)picParams->CurrPicOrderCntVal;
1366 hevcRefList[m_currPic.FrameIdx]->iFieldOrderCnt[0] = picParams->CurrPicOrderCntVal;
1367 hevcRefList[m_currPic.FrameIdx]->bIsIntra = m_curPicIntra;
1368 hevcRefList[m_currPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
1369
1370 uint8_t i;
1371 for(i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1372 {
1373 hevcRefList[m_currPic.FrameIdx]->RefList[i] = picParams->RefFrameList[i];
1374 }
1375
1376 if(!CodecHal_PictureIsInvalid(prevPic))
1377 {
1378 for(i = 0; i < CODEC_NUM_HEVC_MV_BUFFERS; i++)
1379 {
1380 hevcMVBufferList[i].bInUse = false;
1381 hevcMVBufferList[i].u8FrameId = 0;
1382 }
1383
1384 //Mark Referenced frame's MV buffer as used
1385 for(i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1386 {
1387 uint8_t index = picParams->RefFrameList[i].FrameIdx;
1388 if(!CodecHal_PictureIsInvalid(picParams->RefFrameList[i])
1389 && index != picParams->CurrPic.FrameIdx)
1390 {
1391 if (index < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
1392 {
1393 hevcMVBufferList[hevcRefList[index]->ucDMVIdx[0]].bInUse = true;
1394 hevcMVBufferList[hevcRefList[index]->ucDMVIdx[0]].u8FrameId = index;
1395 }
1396 }
1397 }
1398 }
1399
1400 //Find out an unused MvBuffer for current frame
1401 m_hevcMvBufferIndex = GetMvBufferIndex(
1402 m_currPic.FrameIdx);
1403
1404 if (m_mvBufferProgrammed)
1405 {
1406 AllocateMvTemporalBuffer(m_hevcMvBufferIndex);
1407 }
1408
1409 hevcRefList[m_currPic.FrameIdx]->ucDMVIdx[0] = m_hevcMvBufferIndex;
1410
1411 return eStatus;
1412 }
1413
DetermineDecodePhase()1414 MOS_STATUS CodechalDecodeHevc::DetermineDecodePhase()
1415 {
1416 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1417
1418 CODECHAL_DECODE_FUNCTION_ENTER;
1419
1420 uint32_t curPhase = m_hcpDecPhase;
1421 switch (curPhase)
1422 {
1423 case CodechalHcpDecodePhaseInitialized:
1424 if (m_shortFormatInUse)
1425 {
1426 m_hcpDecPhase = CodechalHcpDecodePhaseLegacyS2L;
1427 }
1428 else
1429 {
1430 m_hcpDecPhase = CodechalHcpDecodePhaseLegacyLong;
1431 }
1432 break;
1433 case CodechalHcpDecodePhaseLegacyS2L:
1434 if (!m_shortFormatInUse)
1435 {
1436 CODECHAL_DECODE_ASSERTMESSAGE("invalid decode phase.");
1437 return MOS_STATUS_INVALID_PARAMETER;
1438 }
1439 m_hcpDecPhase = CodechalHcpDecodePhaseLegacyLong;
1440 break;
1441 default:
1442 CODECHAL_DECODE_ASSERTMESSAGE("invalid decode phase.");
1443 return MOS_STATUS_INVALID_PARAMETER;
1444 }
1445
1446 return eStatus;
1447 }
1448
DecodeStateLevel()1449 MOS_STATUS CodechalDecodeHevc::DecodeStateLevel()
1450 {
1451 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1452
1453 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
1454 CODECHAL_DECODE_FUNCTION_ENTER;
1455
1456 //HEVC Decode Phase State Machine
1457 CODECHAL_DECODE_CHK_STATUS_RETURN(DetermineDecodePhase());
1458
1459 // Set HEVC Decode Phase, and execute it.
1460 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
1461 {
1462 if (m_secureDecoder)
1463 {
1464 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->Execute(this));
1465 }
1466
1467 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPictureS2L());
1468 }
1469 else
1470 {
1471 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPictureLongFormat());
1472 }
1473
1474 return eStatus;
1475 }
1476
AddPictureS2LCmds(PMOS_COMMAND_BUFFER cmdBufferInUse)1477 MOS_STATUS CodechalDecodeHevc::AddPictureS2LCmds(
1478 PMOS_COMMAND_BUFFER cmdBufferInUse)
1479 {
1480 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1481
1482 CODECHAL_DECODE_FUNCTION_ENTER;
1483
1484 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBufferInUse);
1485
1486 if (m_statusQueryReportingEnabled)
1487 {
1488 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(cmdBufferInUse));
1489 }
1490
1491 // Load HuC FW Kernel from WOPCM.
1492 MHW_VDBOX_HUC_IMEM_STATE_PARAMS hucImemStateParams;
1493 MOS_ZeroMemory(&hucImemStateParams, sizeof(hucImemStateParams));
1494 hucImemStateParams.dwKernelDescriptor = m_hucS2lKernelId;
1495 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(
1496 cmdBufferInUse,
1497 &hucImemStateParams));
1498
1499 // Pipe mode select
1500 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
1501 pipeModeSelectParams.Mode = m_mode;
1502 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
1503 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(
1504 cmdBufferInUse,
1505 &pipeModeSelectParams));
1506
1507 // Indirect object base addr
1508 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
1509 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
1510 indObjBaseAddrParams.Mode = m_mode;
1511 indObjBaseAddrParams.dwDataSize = m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize;
1512 indObjBaseAddrParams.dwDataOffset = m_copyDataBufferInUse ? 0 : m_dataOffset;
1513 indObjBaseAddrParams.presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
1514
1515 if (m_secureDecoder)
1516 {
1517 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetBitstreamBuffer(&indObjBaseAddrParams));
1518 }
1519
1520 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucIndObjBaseAddrStateCmd(
1521 cmdBufferInUse,
1522 &indObjBaseAddrParams));
1523
1524 // Virtual addr state
1525 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS hucVirtualStateParams;
1526 MOS_ZeroMemory(&hucVirtualStateParams, sizeof(hucVirtualStateParams));
1527 hucVirtualStateParams.regionParams[0].presRegion = &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].OsResource;
1528 hucVirtualStateParams.regionParams[0].isWritable = true;
1529
1530 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(
1531 cmdBufferInUse,
1532 &hucVirtualStateParams));
1533
1534 // DMEM state. Pass data from driver to HuC FW.
1535 MHW_VDBOX_HUC_DMEM_STATE_PARAMS hucDmemStateParams;
1536 MOS_ZeroMemory(&hucDmemStateParams, sizeof(hucDmemStateParams));
1537 hucDmemStateParams.presHucDataSource = &m_resDmemBuffer[m_dmemBufferIdx];
1538 hucDmemStateParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS; // If RTOS is GEMS, offset is 0x2000.
1539
1540 if (!m_dmemBufferProgrammed)
1541 {
1542 CODECHAL_DECODE_CHK_STATUS_RETURN(SetHucDmemParams(&m_resDmemBuffer[m_dmemBufferIdx]));
1543 m_dmemBufferProgrammed = true;
1544 }
1545
1546 hucDmemStateParams.dwDataLength = m_dmemTransferSize;
1547 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(
1548 cmdBufferInUse,
1549 &hucDmemStateParams));
1550
1551 return eStatus;
1552 }
1553
SendPictureS2L()1554 MOS_STATUS CodechalDecodeHevc::SendPictureS2L()
1555 {
1556 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1557
1558 CODECHAL_DECODE_FUNCTION_ENTER;
1559
1560 if (m_enableSf2DmaSubmits)
1561 {
1562 m_osInterface->pfnSetPerfTag(
1563 m_osInterface,
1564 (uint16_t)(((CODECHAL_DECODE_MODE_HUC << 4) & 0xF0) | (m_perfType & 0xF)));
1565 }
1566
1567 MOS_COMMAND_BUFFER cmdBuffer;
1568 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1569
1570 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1571 &cmdBuffer, true));
1572
1573 PMOS_COMMAND_BUFFER cmdBufferInUse = &cmdBuffer;
1574
1575 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureS2LCmds(cmdBufferInUse));
1576
1577 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1578
1579 return eStatus;
1580 }
1581
InitPicLongFormatMhwParams()1582 MOS_STATUS CodechalDecodeHevc::InitPicLongFormatMhwParams()
1583 {
1584 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1585
1586 CODECHAL_DECODE_FUNCTION_ENTER;
1587
1588 // Reset all pic Mhw Params
1589 *m_picMhwParams.PipeModeSelectParams = {};
1590 *m_picMhwParams.PipeBufAddrParams = {};
1591 *m_picMhwParams.HevcPicState = {};
1592 MOS_ZeroMemory(m_picMhwParams.SurfaceParams, sizeof(MHW_VDBOX_SURFACE_PARAMS ));
1593 MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
1594 MOS_ZeroMemory(m_picMhwParams.QmParams, sizeof(MHW_VDBOX_QM_PARAMS ));
1595 MOS_ZeroMemory(m_picMhwParams.HevcTileState, sizeof(MHW_VDBOX_HEVC_TILE_STATE ));
1596
1597 PMOS_SURFACE destSurface = nullptr;
1598 if (m_is8BitFrameIn10BitHevc)
1599 {
1600 destSurface = &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]];
1601 }
1602 else
1603 {
1604 destSurface = &m_destSurface;
1605 }
1606
1607 m_picMhwParams.PipeModeSelectParams->Mode = m_mode;
1608 m_picMhwParams.PipeModeSelectParams->bStreamOutEnabled = m_streamOutEnabled;
1609 m_picMhwParams.PipeModeSelectParams->bShortFormatInUse = m_shortFormatInUse;
1610
1611 m_picMhwParams.SurfaceParams->Mode = CODECHAL_DECODE_MODE_HEVCVLD;
1612 m_picMhwParams.SurfaceParams->psSurface = destSurface;
1613 m_picMhwParams.SurfaceParams->ucSurfaceStateId = CODECHAL_HCP_DECODED_SURFACE_ID;
1614 m_picMhwParams.SurfaceParams->ChromaType = m_hevcPicParams->chroma_format_idc;
1615 m_picMhwParams.SurfaceParams->ucBitDepthLumaMinus8 = m_hevcPicParams->bit_depth_luma_minus8;
1616 m_picMhwParams.SurfaceParams->ucBitDepthChromaMinus8 = m_hevcPicParams->bit_depth_chroma_minus8;
1617 m_picMhwParams.SurfaceParams->dwUVPlaneAlignment = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
1618
1619 m_picMhwParams.PipeBufAddrParams->Mode = m_mode;
1620 m_picMhwParams.PipeBufAddrParams->psPreDeblockSurface = destSurface;
1621
1622 if (m_is8BitFrameIn10BitHevc)
1623 {
1624 m_picMhwParams.PipeBufAddrParams->presP010RTSurface = &m_destSurface;
1625 }
1626
1627 #ifdef _MMC_SUPPORTED
1628 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(m_picMhwParams.PipeBufAddrParams));
1629 #endif
1630
1631 m_picMhwParams.PipeBufAddrParams->presMfdDeblockingFilterRowStoreScratchBuffer =
1632 &m_resMfdDeblockingFilterRowStoreScratchBuffer;
1633 m_picMhwParams.PipeBufAddrParams->presDeblockingFilterTileRowStoreScratchBuffer =
1634 &m_resDeblockingFilterTileRowStoreScratchBuffer;
1635 m_picMhwParams.PipeBufAddrParams->presDeblockingFilterColumnRowStoreScratchBuffer =
1636 &m_resDeblockingFilterColumnRowStoreScratchBuffer;
1637
1638 m_picMhwParams.PipeBufAddrParams->presMetadataLineBuffer = &m_resMetadataLineBuffer;
1639 m_picMhwParams.PipeBufAddrParams->presMetadataTileLineBuffer = &m_resMetadataTileLineBuffer;
1640 m_picMhwParams.PipeBufAddrParams->presMetadataTileColumnBuffer = &m_resMetadataTileColumnBuffer;
1641 m_picMhwParams.PipeBufAddrParams->presSaoLineBuffer = &m_resSaoLineBuffer;
1642 m_picMhwParams.PipeBufAddrParams->presSaoTileLineBuffer = &m_resSaoTileLineBuffer;
1643 m_picMhwParams.PipeBufAddrParams->presSaoTileColumnBuffer = &m_resSaoTileColumnBuffer;
1644 m_picMhwParams.PipeBufAddrParams->presCurMvTempBuffer = &m_resMvTemporalBuffer[m_hevcMvBufferIndex];
1645
1646 MOS_ZeroMemory(m_presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_HEVC);
1647 MOS_ZeroMemory(m_dummyReferenceSlot, sizeof(m_dummyReferenceSlot));
1648
1649 if (!m_curPicIntra)
1650 {
1651 uint8_t i, k = 0, m = 0;
1652
1653 PMOS_RESOURCE firstValidFrame = nullptr;
1654 PMOS_RESOURCE firstValidMvBuf = nullptr;
1655
1656 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1657 {
1658 if (m_frameUsedAsCurRef[i])
1659 {
1660 uint8_t refFrameValue = m_hevcPicParams->RefFrameList[i].FrameIdx;
1661 if (refFrameValue < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
1662 {
1663 m_presReferences[k] = &(m_hevcRefList[refFrameValue]->resRefPic);
1664
1665 for (uint8_t j = 0; j < CODEC_NUM_HEVC_MV_BUFFERS; j++)
1666 {
1667 if ((m_hevcMvList[j].bInUse) &&
1668 (m_hevcMvList[j].u8FrameId == refFrameValue) &&
1669 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[j]))
1670 {
1671 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[m++] = &m_resMvTemporalBuffer[j];
1672 if (firstValidMvBuf == nullptr)
1673 {
1674 firstValidMvBuf = &m_resMvTemporalBuffer[j];
1675 }
1676 break;
1677 }
1678 }
1679
1680 if (firstValidFrame == nullptr)
1681 {
1682 firstValidFrame = m_presReferences[k];
1683 }
1684
1685 k++;
1686 }
1687 }
1688 }
1689
1690 CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
1691 m_picMhwParams.PipeBufAddrParams->presReferences,
1692 sizeof(PMOS_RESOURCE) * CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC,
1693 m_presReferences,
1694 sizeof(PMOS_RESOURCE) * CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC));
1695
1696 CODECHAL_DECODE_ASSERT(k <= 8);
1697 CODECHAL_DECODE_ASSERT(m <= 8);
1698
1699 // Return error if reference surface's pitch * height is less than dest surface.
1700 MOS_SURFACE destSurfaceDetails;
1701 MOS_SURFACE refSurfaceDetails;
1702
1703 MOS_ZeroMemory(&destSurfaceDetails, sizeof(destSurfaceDetails));
1704 destSurfaceDetails.Format = Format_Invalid;
1705 MOS_ZeroMemory(&refSurfaceDetails, sizeof(refSurfaceDetails));
1706 refSurfaceDetails.Format = Format_Invalid;
1707
1708 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetResourceInfo(
1709 m_osInterface,
1710 &destSurface->OsResource,
1711 &destSurfaceDetails));
1712
1713 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1714 {
1715 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] != nullptr)
1716 {
1717 if (Mos_ResourceIsNull(m_picMhwParams.PipeBufAddrParams->presReferences[i]))
1718 {
1719 MOS_ZeroMemory(&m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic, sizeof(MOS_RESOURCE));
1720 CODECHAL_DECODE_ASSERTMESSAGE("Ref frame for Current Frame is not exist. Current frame will be skipped. Thus, clear current frame Ref List.");
1721 return MOS_STATUS_INVALID_PARAMETER;
1722 }
1723 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetResourceInfo(
1724 m_osInterface,
1725 m_picMhwParams.PipeBufAddrParams->presReferences[i],
1726 &refSurfaceDetails));
1727
1728 if ((refSurfaceDetails.dwPitch * refSurfaceDetails.dwHeight) <
1729 (destSurfaceDetails.dwPitch * destSurfaceDetails.dwHeight))
1730 {
1731 CODECHAL_DECODE_ASSERTMESSAGE("Reference surface's pitch * height is less than Dest surface.");
1732 return MOS_STATUS_INVALID_PARAMETER;
1733 }
1734 }
1735 }
1736
1737 if (firstValidFrame == nullptr)
1738 {
1739 firstValidFrame = &destSurface->OsResource;
1740 }
1741 if (firstValidMvBuf == nullptr &&
1742 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[m_hevcMvBufferIndex]))
1743 {
1744 firstValidMvBuf = &m_resMvTemporalBuffer[m_hevcMvBufferIndex];
1745 }
1746
1747 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1748 {
1749 // error concealment for the unset reference addresses and unset mv buffers
1750 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] == nullptr)
1751 {
1752 m_picMhwParams.PipeBufAddrParams->presReferences[i] = firstValidFrame;
1753 }
1754 }
1755
1756 for (uint32_t n = 0; n < CODEC_NUM_HEVC_MV_BUFFERS; n++)
1757 {
1758 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n] == nullptr &&
1759 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[n]))
1760 {
1761 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n] = &m_resMvTemporalBuffer[n];
1762 }
1763 }
1764 }
1765
1766 // set all ref pic addresses to valid addresses for error concealment purpose
1767 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1768 {
1769 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] == nullptr &&
1770 MEDIA_IS_WA(m_waTable, WaDummyReference) &&
1771 !Mos_ResourceIsNull(&m_dummyReference.OsResource))
1772 {
1773 m_picMhwParams.PipeBufAddrParams->presReferences[i] = &m_dummyReference.OsResource;
1774 m_dummyReferenceSlot[i] = true;
1775 }
1776 }
1777
1778 #ifdef _MMC_SUPPORTED
1779 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(m_picMhwParams.PipeBufAddrParams));
1780
1781 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));
1782 #endif
1783
1784 m_picMhwParams.IndObjBaseAddrParams->Mode = m_mode;
1785 m_picMhwParams.IndObjBaseAddrParams->dwDataSize = m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize;
1786 m_picMhwParams.IndObjBaseAddrParams->dwDataOffset = m_copyDataBufferInUse ? 0 : m_dataOffset;
1787 m_picMhwParams.IndObjBaseAddrParams->presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
1788
1789 if (m_secureDecoder)
1790 {
1791 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetBitstreamBuffer(m_picMhwParams.IndObjBaseAddrParams));
1792 }
1793
1794 m_picMhwParams.QmParams->Standard = CODECHAL_HEVC;
1795 m_picMhwParams.QmParams->pHevcIqMatrix = (PMHW_VDBOX_HEVC_QM_PARAMS)m_hevcIqMatrixParams;
1796
1797 m_picMhwParams.HevcPicState->pHevcPicParams = m_hevcPicParams;
1798
1799 m_picMhwParams.HevcTileState->pHevcPicParams = m_hevcPicParams;
1800 m_picMhwParams.HevcTileState->pTileColWidth = m_tileColWidth;
1801 m_picMhwParams.HevcTileState->pTileRowHeight = m_tileRowHeight;
1802
1803 return eStatus;
1804 }
1805
AddPictureLongFormatCmds(PMOS_COMMAND_BUFFER cmdBufferInUse,PIC_LONG_FORMAT_MHW_PARAMS * picMhwParams)1806 MOS_STATUS CodechalDecodeHevc::AddPictureLongFormatCmds(
1807 PMOS_COMMAND_BUFFER cmdBufferInUse,
1808 PIC_LONG_FORMAT_MHW_PARAMS *picMhwParams)
1809 {
1810 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1811
1812 CODECHAL_DECODE_FUNCTION_ENTER;
1813
1814 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBufferInUse);
1815 CODECHAL_DECODE_CHK_NULL_RETURN(picMhwParams);
1816
1817 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(
1818 cmdBufferInUse,
1819 picMhwParams->PipeModeSelectParams));
1820
1821 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSurfaceCmd(
1822 cmdBufferInUse,
1823 picMhwParams->SurfaceParams));
1824
1825 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeBufAddrCmd(
1826 cmdBufferInUse,
1827 picMhwParams->PipeBufAddrParams));
1828
1829 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpIndObjBaseAddrCmd(
1830 cmdBufferInUse,
1831 picMhwParams->IndObjBaseAddrParams));
1832
1833 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpQmStateCmd(
1834 cmdBufferInUse,
1835 picMhwParams->QmParams));
1836 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPicStateCmd(
1837 cmdBufferInUse,
1838 picMhwParams->HevcPicState));
1839
1840 if (m_hevcPicParams->tiles_enabled_flag)
1841 {
1842 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpTileStateCmd(
1843 cmdBufferInUse,
1844 picMhwParams->HevcTileState));
1845 }
1846
1847 return eStatus;
1848 }
1849
SendPictureLongFormat()1850 MOS_STATUS CodechalDecodeHevc::SendPictureLongFormat()
1851 {
1852 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1853
1854 CODECHAL_DECODE_FUNCTION_ENTER;
1855
1856 if (m_enableSf2DmaSubmits)
1857 {
1858 m_osInterface->pfnSetPerfTag(
1859 m_osInterface,
1860 (uint16_t)(((CODECHAL_DECODE_MODE_HEVCVLD << 4) & 0xF0) | (m_perfType & 0xF)));
1861 }
1862
1863 MOS_COMMAND_BUFFER cmdBuffer;
1864 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1865
1866 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
1867 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
1868
1869 bool sendPrologWithFrameTracking = false;
1870 if (m_shortFormatInUse)
1871 {
1872 sendPrologWithFrameTracking = m_enableSf2DmaSubmits;
1873 }
1874 else
1875 {
1876 sendPrologWithFrameTracking = true;
1877 }
1878
1879 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1880 &cmdBuffer,
1881 sendPrologWithFrameTracking));
1882
1883 CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicLongFormatMhwParams());
1884
1885 CODECHAL_DEBUG_TOOL(
1886 for (uint16_t n = 0; n < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; n++)
1887 {
1888 if (m_picMhwParams.PipeBufAddrParams->presReferences[n])
1889 {
1890 MOS_SURFACE dstSurface;
1891 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
1892 dstSurface.OsResource = *(m_picMhwParams.PipeBufAddrParams->presReferences[n]);
1893 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
1894 m_osInterface,
1895 &dstSurface));
1896
1897 m_debugInterface->m_refIndex = n;
1898 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex)) + "]";
1899 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
1900 &dstSurface,
1901 CodechalDbgAttr::attrReferenceSurfaces,
1902 refSurfName.c_str()));
1903 }
1904
1905 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n])
1906 {
1907 m_debugInterface->m_refIndex = n;
1908 // dump mvdata
1909 std::string mvBufDumpName = "_DEC_" + std::to_string(int32_t(n));
1910
1911 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1912 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n],
1913 CodechalDbgAttr::attrMvData,
1914 mvBufDumpName.c_str(),
1915 m_mvBufferSize));
1916 }
1917 }
1918 );
1919
1920 PMOS_COMMAND_BUFFER cmdBufferInUse = &cmdBuffer;
1921
1922 //Send status report Start
1923 if (m_statusQueryReportingEnabled)
1924 {
1925 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(cmdBufferInUse));
1926 }
1927
1928 if (m_statusQueryReportingEnabled && m_shortFormatInUse &&
1929 m_hcpDecPhase == CodechalHcpDecodePhaseLegacyLong)
1930 {
1931 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
1932 m_decodeStatusBuf.m_storeDataOffset +
1933 sizeof(uint32_t) * 2;
1934
1935 // Check HuC_STATUS bit15, HW continue if bit15 > 0, otherwise send COND BB END cmd.
1936 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->SendCondBbEndCmd(
1937 &m_decodeStatusBuf.m_statusBuffer,
1938 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset,
1939 0,
1940 false,
1941 cmdBufferInUse));
1942 }
1943
1944 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureLongFormatCmds(cmdBufferInUse, &m_picMhwParams));
1945
1946 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1947
1948 return eStatus;
1949 }
1950
SendSliceS2L(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)1951 MOS_STATUS CodechalDecodeHevc::SendSliceS2L(
1952 PMOS_COMMAND_BUFFER cmdBuffer,
1953 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
1954 {
1955 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1956
1957 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
1958 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState);
1959 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState->pHevcSliceParams);
1960
1961 CODECHAL_DECODE_CHK_COND_RETURN(
1962 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
1963 "ERROR - vdbox index exceed the maximum");
1964 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
1965
1966 if (m_secureDecoder)
1967 {
1968 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AddHucSecureState(
1969 this,
1970 hevcSliceState,
1971 cmdBuffer));
1972 }
1973
1974 // Send HuC Stream Obj cmd
1975 PCODEC_HEVC_SLICE_PARAMS slc = hevcSliceState->pHevcSliceParams;
1976 MHW_VDBOX_HUC_STREAM_OBJ_PARAMS hucStreamObjParams;
1977 MOS_ZeroMemory(&hucStreamObjParams, sizeof(hucStreamObjParams));
1978 hucStreamObjParams.dwIndStreamInLength = hevcSliceState->dwLength;
1979 hucStreamObjParams.bStreamOutEnable = hevcSliceState->bHucStreamOut ? 1 : 0;
1980 hucStreamObjParams.dwIndStreamInStartAddrOffset = slc->slice_data_offset;
1981 hucStreamObjParams.bHucProcessing = true;
1982
1983 if (m_secureDecoder)
1984 {
1985 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetHucStreamObj(
1986 &hucStreamObjParams));
1987 }
1988
1989 hucStreamObjParams.bStreamInEnable = 1;
1990 hucStreamObjParams.bEmulPreventionByteRemoval = 1;
1991 hucStreamObjParams.bStartCodeSearchEngine = 1;
1992 hucStreamObjParams.ucStartCodeByte0 = 0;
1993 hucStreamObjParams.ucStartCodeByte1 = 0;
1994 hucStreamObjParams.ucStartCodeByte2 = 1;
1995 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStreamObjectCmd(
1996 cmdBuffer,
1997 &hucStreamObjParams));
1998
1999 if (m_statusQueryReportingEnabled &&
2000 hevcSliceState->bLastSlice &&
2001 !hevcSliceState->bHucStreamOut)
2002 {
2003 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
2004 m_decodeStatusBuf.m_storeDataOffset +
2005 sizeof(uint32_t) * 2;
2006
2007 // Write HUC_STATUS2 mask
2008 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2009 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
2010 storeDataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
2011 storeDataParams.dwResourceOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2MaskOffset;
2012 storeDataParams.dwValue = m_hucInterface->GetHucStatus2ImemLoadedMask();
2013 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
2014 cmdBuffer,
2015 &storeDataParams));
2016
2017 // store HUC_STATUS2 register
2018 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
2019 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
2020 storeRegParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
2021 storeRegParams.dwOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2RegOffset;
2022 storeRegParams.dwRegister = mmioRegisters->hucStatus2RegOffset;
2023 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
2024 cmdBuffer,
2025 &storeRegParams));
2026 }
2027
2028 // Send HuC Start
2029 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(
2030 cmdBuffer,
2031 hevcSliceState->bLastSlice ? true : false));
2032
2033 return eStatus;
2034 }
2035
SendSliceLongFormat(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)2036 MOS_STATUS CodechalDecodeHevc::SendSliceLongFormat(
2037 PMOS_COMMAND_BUFFER cmdBuffer,
2038 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
2039 {
2040 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2041
2042 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
2043 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState);
2044 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState->pHevcSliceParams);
2045
2046 PCODEC_HEVC_SLICE_PARAMS slc = hevcSliceState->pHevcSliceParams;
2047
2048 // Disable the flag when ref list is empty for P/B slices to avoid the GPU hang
2049 if (m_curPicIntra &&
2050 !m_hcpInterface->IsHevcISlice(slc->LongSliceFlags.fields.slice_type))
2051 {
2052 slc->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag = 0;
2053 }
2054
2055 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSliceStateCmd(
2056 cmdBuffer,
2057 hevcSliceState));
2058
2059 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpProtectStateCmd(
2060 cmdBuffer,
2061 hevcSliceState));
2062
2063 if (! m_hcpInterface->IsHevcISlice(slc->LongSliceFlags.fields.slice_type))
2064 {
2065 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
2066 refIdxParams.CurrPic = m_hevcPicParams->CurrPic;
2067 refIdxParams.ucList = 0;
2068 refIdxParams.ucNumRefForList = slc->num_ref_idx_l0_active_minus1 + 1;
2069 eStatus = MOS_SecureMemcpy(&refIdxParams.RefPicList, sizeof(refIdxParams.RefPicList), &slc->RefPicList, sizeof(slc->RefPicList));
2070 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2071 refIdxParams.hevcRefList = (void**)m_hevcRefList;
2072 refIdxParams.poc_curr_pic = m_hevcPicParams->CurrPicOrderCntVal;
2073 for (uint8_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
2074 {
2075 refIdxParams.poc_list[i] = m_hevcPicParams->PicOrderCntValList[i];
2076 }
2077
2078 refIdxParams.pRefIdxMapping = hevcSliceState->pRefIdxMapping;
2079 refIdxParams.RefFieldPicFlag = m_hevcPicParams->RefFieldPicFlag;
2080 refIdxParams.RefBottomFieldFlag = m_hevcPicParams->RefBottomFieldFlag;
2081
2082 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2083 cmdBuffer,
2084 nullptr,
2085 &refIdxParams));
2086
2087 if (m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type))
2088 {
2089 refIdxParams.ucList = 1;
2090 refIdxParams.ucNumRefForList = slc->num_ref_idx_l1_active_minus1 + 1;
2091 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2092 cmdBuffer,
2093 nullptr,
2094 &refIdxParams));
2095 }
2096 }
2097 else if (MEDIA_IS_WA(m_waTable, WaDummyReference) && !m_osInterface->bSimIsActive)
2098 {
2099 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
2100 MOS_ZeroMemory(&refIdxParams, sizeof(MHW_VDBOX_HEVC_REF_IDX_PARAMS));
2101 refIdxParams.bDummyReference = true;
2102 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2103 cmdBuffer,
2104 nullptr,
2105 &refIdxParams));
2106 }
2107
2108 if ((m_hevcPicParams->weighted_pred_flag &&
2109 m_hcpInterface->IsHevcPSlice(slc->LongSliceFlags.fields.slice_type)) ||
2110 (m_hevcPicParams->weighted_bipred_flag &&
2111 m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type)))
2112 {
2113 MHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS weightOffsetParams;
2114
2115 weightOffsetParams.ucList = 0;
2116
2117 eStatus = MOS_SecureMemcpy(
2118 &weightOffsetParams.LumaWeights[0],
2119 sizeof(weightOffsetParams.LumaWeights[0]),
2120 &slc->delta_luma_weight_l0,
2121 sizeof(slc->delta_luma_weight_l0));
2122 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2123
2124 eStatus = MOS_SecureMemcpy(
2125 &weightOffsetParams.LumaWeights[1],
2126 sizeof(weightOffsetParams.LumaWeights[1]),
2127 &slc->delta_luma_weight_l1,
2128 sizeof(slc->delta_luma_weight_l1));
2129 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2130
2131 for (int32_t i = 0; i < 15; i++)
2132 {
2133 weightOffsetParams.LumaOffsets[0][i] = (int16_t)slc->luma_offset_l0[i];
2134 weightOffsetParams.LumaOffsets[1][i] = (int16_t)slc->luma_offset_l1[i];
2135
2136 for (int32_t j = 0; j < 2; j++)
2137 {
2138 weightOffsetParams.ChromaOffsets[0][i][j] = (int16_t)slc->ChromaOffsetL0[i][j];
2139 weightOffsetParams.ChromaOffsets[1][i][j] = (int16_t)slc->ChromaOffsetL1[i][j];
2140 }
2141 }
2142
2143 eStatus = MOS_SecureMemcpy(
2144 &weightOffsetParams.ChromaWeights[0],
2145 sizeof(weightOffsetParams.ChromaWeights[0]),
2146 &slc->delta_chroma_weight_l0,
2147 sizeof(slc->delta_chroma_weight_l0));
2148 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2149
2150 eStatus = MOS_SecureMemcpy(
2151 &weightOffsetParams.ChromaWeights[1],
2152 sizeof(weightOffsetParams.ChromaWeights[1]),
2153 &slc->delta_chroma_weight_l1,
2154 sizeof(slc->delta_chroma_weight_l1));
2155 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2156
2157 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(
2158 cmdBuffer,
2159 nullptr,
2160 &weightOffsetParams));
2161
2162 if (m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type))
2163 {
2164 weightOffsetParams.ucList = 1;
2165 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(
2166 cmdBuffer,
2167 nullptr,
2168 &weightOffsetParams));
2169 }
2170 }
2171
2172 if (m_secureDecoder)
2173 {
2174 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AddHcpSecureState(
2175 cmdBuffer,
2176 hevcSliceState));
2177 }
2178
2179 MHW_VDBOX_HCP_BSD_PARAMS bsdParams;
2180 MOS_ZeroMemory(&bsdParams, sizeof(bsdParams));
2181 bsdParams.dwBsdDataLength = hevcSliceState->dwLength;
2182 bsdParams.dwBsdDataStartOffset = slc->slice_data_offset + hevcSliceState->dwOffset;
2183
2184 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpBsdObjectCmd(
2185 cmdBuffer,
2186 &bsdParams));
2187
2188 return eStatus;
2189 }
2190
DecodePrimitiveLevel()2191 MOS_STATUS CodechalDecodeHevc::DecodePrimitiveLevel()
2192 {
2193 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2194
2195 CODECHAL_DECODE_FUNCTION_ENTER;
2196
2197 // Bitstream is incomplete, don't do any decoding work.
2198 if (m_incompletePicture)
2199 {
2200 return MOS_STATUS_SUCCESS;
2201 }
2202
2203 CODECHAL_DECODE_CHK_COND_RETURN(
2204 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
2205 "ERROR - vdbox index exceed the maximum");
2206 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
2207
2208 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
2209 m_decodeStatusBuf.m_storeDataOffset +
2210 sizeof(uint32_t) * 2;
2211
2212 uint32_t renderingFlags = m_videoContextUsesNullHw;
2213
2214 MOS_COMMAND_BUFFER cmdBuffer;
2215 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
2216
2217 PMOS_COMMAND_BUFFER cmdBufferInUse = &cmdBuffer;
2218
2219 // If S2L and 2nd pass, ...
2220 // ... jump to 2nd level batch buffer.
2221 if ((m_shortFormatInUse &&
2222 m_hcpDecPhase == CodechalHcpDecodePhaseLegacyLong) ||
2223 m_cencBuf)
2224 {
2225 if (m_enableSf2DmaSubmits)
2226 {
2227 #if (_DEBUG || _RELEASE_INTERNAL)
2228 m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iLastCurrent = m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize;
2229 #endif
2230
2231 CODECHAL_DEBUG_TOOL(
2232 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
2233 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex],
2234 CODECHAL_NUM_MEDIA_STATES,
2235 "DEC"));)
2236 }
2237
2238 if (m_cencBuf)
2239 {
2240 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCencBatchBuffer(cmdBufferInUse));
2241 }
2242 else
2243 {
2244 // this is S2L conversion
2245 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
2246 cmdBufferInUse,
2247 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex]));
2248 }
2249 }
2250 else
2251 {
2252 // Setup static slice state parameters
2253 MHW_VDBOX_HEVC_SLICE_STATE hevcSliceState;
2254 hevcSliceState.presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
2255 hevcSliceState.pHevcPicParams = m_hevcPicParams;
2256 hevcSliceState.pRefIdxMapping = &m_refIdxMapping[0];
2257
2258 PCODEC_HEVC_SLICE_PARAMS slc = m_hevcSliceParams;
2259 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
2260 {
2261 hevcSliceState.pHevcSliceParams = slc;
2262 hevcSliceState.dwLength = slc->slice_data_size;
2263 hevcSliceState.dwSliceIndex = slcCount;
2264 hevcSliceState.bLastSlice = (slcCount == (m_numSlices - 1));
2265
2266 // If S2L and 1st pass, send HuC commands.
2267 if (m_shortFormatInUse)
2268 {
2269 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceS2L(cmdBufferInUse, &hevcSliceState));
2270 }
2271 else
2272 {
2273 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceLongFormat(cmdBufferInUse, &hevcSliceState));
2274 }
2275
2276 slc++;
2277 }
2278
2279 // If S2L and 1st pass
2280 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
2281 {
2282 // Send VD Pipe Flush command for SKL+
2283 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
2284 MOS_ZeroMemory(&vdpipeFlushParams , sizeof(vdpipeFlushParams));
2285 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
2286 vdpipeFlushParams.Flags.bFlushHEVC = 1;
2287 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
2288 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
2289 cmdBufferInUse,
2290 &vdpipeFlushParams));
2291
2292 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
2293 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2294 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2295 cmdBufferInUse,
2296 &flushDwParams));
2297
2298 if (m_statusQueryReportingEnabled)
2299 {
2300 // Check HuC_STATUS2 bit6, if bit6 > 0 HW continue execution following cmd, otherwise it send a COND BB END cmd.
2301 eStatus = m_hwInterface->SendCondBbEndCmd(
2302 &m_decodeStatusBuf.m_statusBuffer,
2303 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2MaskOffset,
2304 0,
2305 false,
2306 cmdBufferInUse);
2307 CODECHAL_DECODE_CHK_STATUS_RETURN(eStatus);
2308
2309 // Write HUC_STATUS mask
2310 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2311 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
2312 storeDataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
2313 storeDataParams.dwResourceOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset;
2314 storeDataParams.dwValue = m_hucInterface->GetHucStatusHevcS2lFailureMask();
2315 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
2316 cmdBufferInUse,
2317 &storeDataParams));
2318
2319 // store HUC_STATUS register
2320 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
2321 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
2322 storeRegParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
2323 storeRegParams.dwOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusRegOffset;
2324 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
2325 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
2326 cmdBufferInUse,
2327 &storeRegParams));
2328 }
2329
2330 if (m_enableSf2DmaSubmits)
2331 {
2332 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
2333 cmdBufferInUse,
2334 nullptr));
2335 }
2336
2337 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2338
2339 if (m_enableSf2DmaSubmits)
2340 {
2341 CODECHAL_DEBUG_TOOL(
2342 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2343 cmdBufferInUse,
2344 CODECHAL_NUM_MEDIA_STATES,
2345 "DEC"));
2346
2347 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
2348 // m_debugInterface,
2349 // cmdBufferInUse));
2350 );
2351
2352 //CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
2353 // m_osInterface,
2354 // cmdBufferInUse,
2355 // renderingFlags));
2356 }
2357
2358 return eStatus;
2359 }
2360 }
2361
2362 // Send VD Pipe Flush command for SKL+
2363 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
2364 MOS_ZeroMemory(&vdpipeFlushParams , sizeof(vdpipeFlushParams));
2365 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
2366 vdpipeFlushParams.Flags.bFlushHEVC = 1;
2367 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
2368 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
2369 cmdBufferInUse,
2370 &vdpipeFlushParams));
2371
2372 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
2373 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2374 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2375 cmdBufferInUse,
2376 &flushDwParams));
2377
2378 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
2379 syncParams.GpuContext = m_videoContext;
2380 if (m_is8BitFrameIn10BitHevc)
2381 {
2382 syncParams.presSyncResource =
2383 &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource;
2384 }
2385 else
2386 {
2387 syncParams.presSyncResource = &m_destSurface.OsResource;
2388 }
2389 syncParams.bReadOnly = false;
2390 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
2391 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
2392
2393 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
2394 {
2395 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
2396 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
2397
2398 // Update the resource tag (s/w tag) for On-Demand Sync
2399 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
2400 }
2401
2402 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
2403 if (m_osInterface->bTagResourceSync)
2404 {
2405 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
2406 cmdBufferInUse,
2407 &syncParams));
2408 }
2409
2410 if (m_statusQueryReportingEnabled)
2411 {
2412 CodechalDecodeStatusReport decodeStatusReport;
2413 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
2414 decodeStatusReport.m_currDecodedPic = m_hevcPicParams->CurrPic;
2415 decodeStatusReport.m_currDeblockedPic = m_hevcPicParams->CurrPic;
2416 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
2417 if (m_is8BitFrameIn10BitHevc)
2418 {
2419 decodeStatusReport.m_currDecodedPicRes = m_destSurface.OsResource;
2420 }
2421 else
2422 {
2423 decodeStatusReport.m_currDecodedPicRes = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic;
2424 }
2425 #ifdef _DECODE_PROCESSING_SUPPORTED
2426 CODECHAL_DEBUG_TOOL(
2427 if (m_downsampledSurfaces && m_sfcState && m_sfcState->m_sfcOutputSurface) {
2428 m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource =
2429 m_sfcState->m_sfcOutputSurface->OsResource;
2430 decodeStatusReport.m_currSfcOutputPicRes =
2431 &m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource;
2432 })
2433 #endif
2434 CODECHAL_DEBUG_TOOL(
2435 decodeStatusReport.m_secondField = CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
2436 decodeStatusReport.m_frameType = m_perfType;);
2437
2438 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
2439 decodeStatusReport,
2440 cmdBufferInUse));
2441 }
2442
2443 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2444 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2445 cmdBufferInUse,
2446 &flushDwParams));
2447
2448 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
2449 cmdBufferInUse,
2450 nullptr));
2451
2452 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2453
2454 bool syncCompleteFrame = m_copyDataBufferInUse;
2455
2456 if (syncCompleteFrame)
2457 {
2458 //Sync up complete frame
2459 MOS_SYNC_PARAMS copyDataSyncParams = g_cInitSyncParams;
2460 copyDataSyncParams.GpuContext = m_videoContextForWa;
2461 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2462
2463 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, ©DataSyncParams));
2464
2465 copyDataSyncParams = g_cInitSyncParams;
2466 copyDataSyncParams.GpuContext = m_videoContext;
2467 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2468
2469 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, ©DataSyncParams));
2470 }
2471
2472 CODECHAL_DEBUG_TOOL(
2473 {
2474 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2475 cmdBufferInUse,
2476 CODECHAL_NUM_MEDIA_STATES,
2477 "DEC"));
2478
2479 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
2480 // m_debugInterface,
2481 // cmdBufferInUse));
2482 }
2483 );
2484
2485 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
2486
2487 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
2488 m_osInterface,
2489 cmdBufferInUse,
2490 renderingFlags));
2491
2492 CODECHAL_DEBUG_TOOL(
2493 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
2494
2495 // Reset status report
2496 if (m_statusQueryReportingEnabled)
2497 {
2498 bool resetStatusReport = true;
2499
2500 if (resetStatusReport)
2501 {
2502 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
2503 m_videoContextUsesNullHw));
2504 }
2505 }
2506
2507 if (m_is8BitFrameIn10BitHevc)
2508 {
2509 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeNV12ToP010);
2510 CODECHAL_DECODE_CHK_STATUS_RETURN(m_decodeNV12ToP010->Execute(
2511 &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource,
2512 &m_destSurface.OsResource));
2513 }
2514
2515 // Needs to be re-set for Linux buffer re-use scenarios
2516 if (m_is8BitFrameIn10BitHevc)
2517 {
2518 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic =
2519 m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource;
2520 }
2521 else
2522 {
2523 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic =
2524 m_destSurface.OsResource;
2525 }
2526
2527 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
2528 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
2529 {
2530 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
2531 syncParams.GpuContext = m_videoContext;
2532 syncParams.presSyncResource = &m_destSurface.OsResource;
2533
2534 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
2535 }
2536
2537 #ifdef _DECODE_PROCESSING_SUPPORTED
2538 // Send Vebox and SFC cmds
2539 if (m_sfcState->m_sfcPipeOut)
2540 {
2541 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->RenderStart());
2542 }
2543 #endif
2544
2545 return eStatus;
2546 }
2547
CalcDownsamplingParams(void * picParams,uint32_t * refSurfWidth,uint32_t * refSurfHeight,MOS_FORMAT * format,uint8_t * frameIdx)2548 MOS_STATUS CodechalDecodeHevc::CalcDownsamplingParams(
2549 void *picParams,
2550 uint32_t *refSurfWidth,
2551 uint32_t *refSurfHeight,
2552 MOS_FORMAT *format,
2553 uint8_t *frameIdx)
2554 {
2555 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2556
2557 CODECHAL_DECODE_CHK_NULL_RETURN(picParams);
2558 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfWidth);
2559 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfHeight);
2560 CODECHAL_DECODE_CHK_NULL_RETURN(format);
2561 CODECHAL_DECODE_CHK_NULL_RETURN(frameIdx);
2562
2563 PCODEC_HEVC_PIC_PARAMS hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)picParams;
2564
2565 *refSurfWidth = 0;
2566 *refSurfHeight = 0;
2567 *format = Format_NV12;
2568 *frameIdx = hevcPicParams->CurrPic.FrameIdx;
2569
2570 uint32_t widthInPix, heightInPix;
2571
2572 widthInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicWidthInMinCbsY);
2573 heightInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicHeightInMinCbsY);
2574
2575 *refSurfWidth = MOS_ALIGN_CEIL(widthInPix, 64);
2576 *refSurfHeight = MOS_ALIGN_CEIL(heightInPix, 64);
2577
2578 if (m_is10BitHevc)
2579 {
2580 *format = Format_P010;
2581 }
2582
2583
2584 return eStatus;
2585 }
2586
InitMmcState()2587 MOS_STATUS CodechalDecodeHevc::InitMmcState()
2588 {
2589 #ifdef _MMC_SUPPORTED
2590 m_mmc = MOS_New(CodechalMmcDecodeHevc, m_hwInterface, this);
2591 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
2592 #endif
2593 return MOS_STATUS_SUCCESS;
2594 }
2595
AllocateStandard(CodechalSetting * settings)2596 MOS_STATUS CodechalDecodeHevc::AllocateStandard (
2597 CodechalSetting *settings)
2598 {
2599 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2600
2601 CODECHAL_DECODE_FUNCTION_ENTER;
2602
2603 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
2604
2605 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
2606
2607 m_width = settings->width;
2608 m_height = settings->height;
2609 m_is10BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS) ? true : false;
2610 m_is12BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_12_BITS) ? true : false;
2611 m_chromaFormatinProfile = settings->chromaFormat;
2612 m_shortFormatInUse = settings->shortFormatInUse;
2613
2614 #ifdef _DECODE_PROCESSING_SUPPORTED
2615 m_sfcState = MOS_New(CodechalHevcSfcState);
2616 CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
2617 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
2618 this,
2619 m_hwInterface,
2620 m_osInterface));
2621 #endif
2622
2623 MOS_ZeroMemory(&m_currPic, sizeof(m_currPic));
2624
2625 m_frameIdx = 0;
2626
2627 if (m_shortFormatInUse)
2628 {
2629 // Legacy SF has 2 passes, 1st pass is S2L, 2nd pass is HEVC Long decode.
2630 m_decodePassNum = 2;
2631
2632 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
2633 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
2634 MOS_UserFeature_ReadValue_ID(
2635 nullptr,
2636 __MEDIA_USER_FEATURE_VALUE_HEVC_SF_2_DMA_SUBMITS_ENABLE_ID,
2637 &userFeatureData,
2638 m_osInterface->pOsContext);
2639 m_enableSf2DmaSubmits = userFeatureData.u32Data ? true : false;
2640 }
2641
2642 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
2643 stateCmdSizeParams.bShortFormat = m_shortFormatInUse;
2644 stateCmdSizeParams.bHucDummyStream = (m_secureDecoder ? m_secureDecoder->IsDummyStreamEnabled() : false);
2645
2646 // Picture Level Commands
2647 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxStateCommandSize(
2648 m_mode,
2649 &m_commandBufferSizeNeeded,
2650 &m_commandPatchListSizeNeeded,
2651 &stateCmdSizeParams));
2652
2653 // Primitive Level Commands
2654 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxPrimitiveCommandSize(
2655 m_mode,
2656 &m_standardDecodeSizeNeeded,
2657 &m_standardDecodePatchListSizeNeeded,
2658 m_shortFormatInUse));
2659
2660 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesFixedSizes());
2661
2662 // Prepare Pic Params
2663 m_picMhwParams.PipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS);
2664 m_picMhwParams.SurfaceParams = MOS_New(MHW_VDBOX_SURFACE_PARAMS);
2665 m_picMhwParams.PipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS);
2666 m_picMhwParams.IndObjBaseAddrParams = MOS_New(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS);
2667 m_picMhwParams.QmParams = MOS_New(MHW_VDBOX_QM_PARAMS);
2668 m_picMhwParams.HevcPicState = MOS_New(MHW_VDBOX_HEVC_PIC_STATE);
2669 m_picMhwParams.HevcTileState = MOS_New(MHW_VDBOX_HEVC_TILE_STATE);
2670
2671 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.PipeModeSelectParams);
2672 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.SurfaceParams);
2673 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.PipeBufAddrParams);
2674 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.IndObjBaseAddrParams);
2675 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.QmParams);
2676 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.HevcPicState);
2677 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.HevcTileState);
2678
2679 MOS_ZeroMemory(m_picMhwParams.SurfaceParams, sizeof(MHW_VDBOX_SURFACE_PARAMS));
2680 MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
2681 MOS_ZeroMemory(m_picMhwParams.QmParams, sizeof(MHW_VDBOX_QM_PARAMS));
2682 MOS_ZeroMemory(m_picMhwParams.HevcTileState, sizeof(MHW_VDBOX_HEVC_TILE_STATE));
2683
2684 return eStatus;
2685 }
2686
CodechalDecodeHevc(CodechalHwInterface * hwInterface,CodechalDebugInterface * debugInterface,PCODECHAL_STANDARD_INFO standardInfo)2687 CodechalDecodeHevc::CodechalDecodeHevc(
2688 CodechalHwInterface * hwInterface,
2689 CodechalDebugInterface *debugInterface,
2690 PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecode(hwInterface, debugInterface, standardInfo),
2691 m_minCtbSize(0),
2692 m_is10BitHevc(false),
2693 m_is12BitHevc(false),
2694 m_chromaFormatinProfile(0),
2695 m_shortFormatInUse(false),
2696 m_dataSize(0),
2697 m_dataOffset(0),
2698 m_numSlices(0),
2699 m_is8BitFrameIn10BitHevc(false),
2700 m_internalNv12RtIndexMapInitilized(false),
2701 m_mfdDeblockingFilterRowStoreScratchBufferPicWidth(0),
2702 m_metadataLineBufferPicWidth(0),
2703 m_saoLineBufferPicWidth(0),
2704 m_mvBufferProgrammed(false),
2705 m_secondLevelBatchBufferIndex(0),
2706 m_dmemBufferIdx(0),
2707 m_dmemBufferSize(0),
2708 m_dmemTransferSize(0),
2709 m_dmemBufferProgrammed(false),
2710 m_copyDataBufferSize(0),
2711 m_copyDataOffset(0),
2712 m_copyDataBufferInUse(false),
2713 m_estiBytesInBitstream(0),
2714 m_curPicIntra(false),
2715 m_mvBufferSize(0),
2716 m_hevcMvBufferIndex(0),
2717 m_frameIdx(0),
2718 m_enableSf2DmaSubmits(false),
2719 m_widthLastMaxAlloced(0),
2720 m_heightLastMaxAlloced(0),
2721 m_ctbLog2SizeYMax(0),
2722 m_hcpDecPhase(0)
2723 {
2724 CODECHAL_DECODE_FUNCTION_ENTER;
2725
2726 MOS_ZeroMemory(m_internalNv12RtSurfaces, sizeof(m_internalNv12RtSurfaces));
2727 MOS_ZeroMemory(&m_resDataBuffer, sizeof(m_resDataBuffer));
2728 MOS_ZeroMemory(&m_resMfdDeblockingFilterRowStoreScratchBuffer, sizeof(m_resMfdDeblockingFilterRowStoreScratchBuffer));
2729 MOS_ZeroMemory(&m_resDeblockingFilterTileRowStoreScratchBuffer, sizeof(m_resDeblockingFilterTileRowStoreScratchBuffer));
2730 MOS_ZeroMemory(&m_resDeblockingFilterColumnRowStoreScratchBuffer, sizeof(m_resDeblockingFilterColumnRowStoreScratchBuffer));
2731 MOS_ZeroMemory(&m_resMetadataLineBuffer, sizeof(m_resMetadataLineBuffer));
2732 MOS_ZeroMemory(&m_resMetadataTileLineBuffer, sizeof(m_resMetadataTileLineBuffer));
2733 MOS_ZeroMemory(&m_resMetadataTileColumnBuffer, sizeof(m_resMetadataTileColumnBuffer));
2734 MOS_ZeroMemory(&m_resSaoLineBuffer, sizeof(m_resSaoLineBuffer));
2735 MOS_ZeroMemory(&m_resSaoTileLineBuffer, sizeof(m_resSaoTileLineBuffer));
2736 MOS_ZeroMemory(&m_resSaoTileColumnBuffer, sizeof(m_resSaoTileColumnBuffer));
2737 MOS_ZeroMemory(m_resMvTemporalBuffer, sizeof(m_resMvTemporalBuffer));
2738 MOS_ZeroMemory(m_resDmemBuffer, sizeof(m_resDmemBuffer));
2739 MOS_ZeroMemory(&m_resCopyDataBuffer, sizeof(m_resCopyDataBuffer));
2740 MOS_ZeroMemory(&m_resSyncObjectWaContextInUse, sizeof(m_resSyncObjectWaContextInUse));
2741 MOS_ZeroMemory(&m_picMhwParams,sizeof(m_picMhwParams));
2742 MOS_ZeroMemory(&m_hevcPicParams,sizeof(m_hevcPicParams));
2743 MOS_ZeroMemory(&m_hevcSliceParams,sizeof(m_hevcSliceParams));
2744 MOS_ZeroMemory(&m_hevcIqMatrixParams,sizeof(m_hevcIqMatrixParams));
2745 MOS_ZeroMemory(&m_destSurface,sizeof(m_destSurface));
2746 MOS_ZeroMemory(&m_currPic,sizeof(m_currPic));
2747
2748 m_hcpInUse = true;
2749 }
2750
2751 #if USE_CODECHAL_DEBUG_TOOL
DumpPicParams(PCODEC_HEVC_PIC_PARAMS picParams,void * extPicParams)2752 MOS_STATUS CodechalDecodeHevc::DumpPicParams(
2753 PCODEC_HEVC_PIC_PARAMS picParams,
2754 void* extPicParams)
2755 {
2756 CODECHAL_DEBUG_FUNCTION_ENTER;
2757
2758 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
2759 {
2760 return MOS_STATUS_SUCCESS;
2761 }
2762
2763 CODECHAL_DEBUG_CHK_NULL(picParams);
2764
2765 std::ostringstream oss;
2766 oss.setf(std::ios::showbase | std::ios::uppercase);
2767 oss.setf(std::ios::hex, std::ios::basefield);
2768
2769 oss << "PicWidthInMinCbsY: " << +picParams->PicWidthInMinCbsY << std::endl;
2770 oss << "PicHeightInMinCbsY: " << +picParams->PicHeightInMinCbsY << std::endl;
2771 //wFormatAndSequenceInfoFlags
2772 oss << "chroma_format_idc: " << +picParams->chroma_format_idc << std::endl;
2773 oss << "separate_colour_plane_flag: " << +picParams->separate_colour_plane_flag << std::endl;
2774 oss << "bit_depth_luma_minus8: " << +picParams->bit_depth_luma_minus8 << std::endl;
2775 oss << "bit_depth_chroma_minus8: " << +picParams->bit_depth_chroma_minus8 << std::endl;
2776 oss << "log2_max_pic_order_cnt_lsb_minus4: " << +picParams->log2_max_pic_order_cnt_lsb_minus4 << std::endl;
2777 oss << "NoPicReorderingFlag: " << +picParams->NoPicReorderingFlag << std::endl;
2778 oss << "ReservedBits1: " << +picParams->ReservedBits1 << std::endl;
2779 oss << "wFormatAndSequenceInfoFlags: " << +picParams->wFormatAndSequenceInfoFlags << std::endl;
2780 oss << "CurrPic FrameIdx: " << +picParams->CurrPic.FrameIdx << std::endl;
2781 oss << "CurrPic PicFlags: " << +picParams->CurrPic.PicFlags << std::endl;
2782 oss << "sps_max_dec_pic_buffering_minus1: " << +picParams->sps_max_dec_pic_buffering_minus1 << std::endl;
2783 oss << "log2_min_luma_coding_block_size_minus3: " << +picParams->log2_min_luma_coding_block_size_minus3 << std::endl;
2784 oss << "log2_diff_max_min_luma_coding_block_size: " << +picParams->log2_diff_max_min_luma_coding_block_size << std::endl;
2785 oss << "log2_min_transform_block_size_minus2: " << +picParams->log2_min_transform_block_size_minus2 << std::endl;
2786 oss << "log2_diff_max_min_transform_block_size: " << +picParams->log2_diff_max_min_transform_block_size << std::endl;
2787 oss << "max_transform_hierarchy_depth_intra: " << +picParams->max_transform_hierarchy_depth_intra << std::endl;
2788 oss << "max_transform_hierarchy_depth_inter: " << +picParams->max_transform_hierarchy_depth_inter << std::endl;
2789 oss << "num_short_term_ref_pic_sets: " << +picParams->num_short_term_ref_pic_sets << std::endl;
2790 oss << "num_long_term_ref_pic_sps: " << +picParams->num_long_term_ref_pic_sps << std::endl;
2791 oss << "num_ref_idx_l0_default_active_minus1: " << +picParams->num_ref_idx_l0_default_active_minus1 << std::endl;
2792 oss << "num_ref_idx_l1_default_active_minus1: " << +picParams->num_ref_idx_l1_default_active_minus1 << std::endl;
2793 oss << "init_qp_minus26: " << +picParams->init_qp_minus26 << std::endl;
2794 oss << "ucNumDeltaPocsOfRefRpsIdx: " << +picParams->ucNumDeltaPocsOfRefRpsIdx << std::endl;
2795 oss << "wNumBitsForShortTermRPSInSlice: " << +picParams->wNumBitsForShortTermRPSInSlice << std::endl;
2796 oss << "ReservedBits2: " << +picParams->ReservedBits2 << std::endl;
2797 //dwCodingParamToolFlags
2798 oss << "scaling_list_enabled_flag: " << +picParams->scaling_list_enabled_flag << std::endl;
2799 oss << "amp_enabled_flag: " << +picParams->amp_enabled_flag << std::endl;
2800 oss << "sample_adaptive_offset_enabled_flag: " << +picParams->sample_adaptive_offset_enabled_flag << std::endl;
2801 oss << "pcm_enabled_flag: " << +picParams->pcm_enabled_flag << std::endl;
2802 oss << "pcm_sample_bit_depth_luma_minus1: " << +picParams->pcm_sample_bit_depth_luma_minus1 << std::endl;
2803 oss << "pcm_sample_bit_depth_chroma_minus1: " << +picParams->pcm_sample_bit_depth_chroma_minus1 << std::endl;
2804 oss << "log2_min_pcm_luma_coding_block_size_minus3: " << +picParams->log2_min_pcm_luma_coding_block_size_minus3 << std::endl;
2805 oss << "log2_diff_max_min_pcm_luma_coding_block_size: " << +picParams->log2_diff_max_min_pcm_luma_coding_block_size << std::endl;
2806 oss << "pcm_loop_filter_disabled_flag: " << +picParams->pcm_loop_filter_disabled_flag << std::endl;
2807 oss << "long_term_ref_pics_present_flag: " << +picParams->long_term_ref_pics_present_flag << std::endl;
2808 oss << "sps_temporal_mvp_enabled_flag: " << +picParams->sps_temporal_mvp_enabled_flag << std::endl;
2809 oss << "strong_intra_smoothing_enabled_flag: " << +picParams->strong_intra_smoothing_enabled_flag << std::endl;
2810 oss << "dependent_slice_segments_enabled_flag: " << +picParams->dependent_slice_segments_enabled_flag << std::endl;
2811 oss << "output_flag_present_flag: " << +picParams->output_flag_present_flag << std::endl;
2812 oss << "num_extra_slice_header_bits: " << +picParams->num_extra_slice_header_bits << std::endl;
2813 oss << "sign_data_hiding_enabled_flag: " << +picParams->sign_data_hiding_enabled_flag << std::endl;
2814 oss << "cabac_init_present_flag: " << +picParams->cabac_init_present_flag << std::endl;
2815 oss << "ReservedBits3: " << +picParams->ReservedBits3 << std::endl;
2816 oss << "dwCodingParamToolFlags: " << +picParams->dwCodingParamToolFlags << std::endl;
2817 //dwCodingSettingPicturePropertyFlags
2818 oss << "constrained_intra_pred_flag: " << +picParams->constrained_intra_pred_flag << std::endl;
2819 oss << "transform_skip_enabled_flag: " << +picParams->transform_skip_enabled_flag << std::endl;
2820 oss << "cu_qp_delta_enabled_flag: " << +picParams->cu_qp_delta_enabled_flag << std::endl;
2821 oss << "diff_cu_qp_delta_depth: " << +picParams->diff_cu_qp_delta_depth << std::endl;
2822 oss << "pps_slice_chroma_qp_offsets_present_flag: " << +picParams->pps_slice_chroma_qp_offsets_present_flag << std::endl;
2823 oss << "weighted_pred_flag: " << +picParams->weighted_pred_flag << std::endl;
2824 oss << "weighted_bipred_flag: " << +picParams->weighted_bipred_flag << std::endl;
2825 oss << "transquant_bypass_enabled_flag: " << +picParams->transquant_bypass_enabled_flag << std::endl;
2826 oss << "tiles_enabled_flag: " << +picParams->tiles_enabled_flag << std::endl;
2827 oss << "entropy_coding_sync_enabled_flag: " << +picParams->entropy_coding_sync_enabled_flag << std::endl;
2828 oss << "uniform_spacing_flag: " << +picParams->uniform_spacing_flag << std::endl;
2829 oss << "loop_filter_across_tiles_enabled_flag: " << +picParams->loop_filter_across_tiles_enabled_flag << std::endl;
2830 oss << "pps_loop_filter_across_slices_enabled_flag: " << +picParams->pps_loop_filter_across_slices_enabled_flag << std::endl;
2831 oss << "deblocking_filter_override_enabled_flag: " << +picParams->deblocking_filter_override_enabled_flag << std::endl;
2832 oss << "pps_deblocking_filter_disabled_flag: " << +picParams->pps_deblocking_filter_disabled_flag << std::endl;
2833 oss << "lists_modification_present_flag: " << +picParams->lists_modification_present_flag << std::endl;
2834 oss << "slice_segment_header_extension_present_flag: " << +picParams->slice_segment_header_extension_present_flag << std::endl;
2835 oss << "IrapPicFlag: " << +picParams->IrapPicFlag << std::endl;
2836 oss << "IdrPicFlag: " << +picParams->IdrPicFlag << std::endl;
2837 oss << "IntraPicFlag: " << +picParams->IntraPicFlag << std::endl;
2838 oss << "ReservedBits4: " << +picParams->ReservedBits4 << std::endl;
2839 oss << "dwCodingSettingPicturePropertyFlags: " << +picParams->dwCodingSettingPicturePropertyFlags << std::endl;
2840 oss << "pps_cb_qp_offset: " << +picParams->pps_cb_qp_offset << std::endl;
2841 oss << "pps_cr_qp_offset: " << +picParams->pps_cr_qp_offset << std::endl;
2842 oss << "num_tile_columns_minus1: " << +picParams->num_tile_columns_minus1 << std::endl;
2843 oss << "num_tile_rows_minus1: " << +picParams->num_tile_rows_minus1 << std::endl;
2844 //Dump column width
2845 oss << "column_width_minus1[19]:";
2846 for (uint8_t i = 0; i < 19; i++)
2847 oss << picParams->column_width_minus1[i] << " ";
2848 oss << std::endl;
2849
2850 //Dump row height
2851 oss << "row_height_minus1[21]:";
2852 for (uint8_t i = 0; i < 21; i++)
2853 oss << picParams->row_height_minus1[i] << " ";
2854 oss << std::endl;
2855
2856 oss << "pps_beta_offset_div2: " << +picParams->pps_beta_offset_div2 << std::endl;
2857 oss << "pps_tc_offset_div2: " << +picParams->pps_tc_offset_div2 << std::endl;
2858 oss << "log2_parallel_merge_level_minus2: " << +picParams->log2_parallel_merge_level_minus2 << std::endl;
2859 oss << "CurrPicOrderCntVal: " << +picParams->CurrPicOrderCntVal << std::endl;
2860
2861 oss.setf(std::ios::dec, std::ios::basefield);
2862 //Dump RefFrameList[15]
2863 for (uint8_t i = 0; i < 15; ++i)
2864 {
2865 oss << "RefFrameList[" << +i << "] FrameIdx:" << +picParams->RefFrameList[i].FrameIdx << std::endl;
2866 oss << "RefFrameList[" << +i << "] PicFlags:" << +picParams->RefFrameList[i].PicFlags << std::endl;
2867 }
2868
2869 //Dump POC List
2870 oss << "PicOrderCntValList[15]:";
2871 for (uint8_t i = 0; i < 15; i++)
2872 oss << std::hex << picParams->PicOrderCntValList[i] << " ";
2873 oss << std::endl;
2874
2875 //Dump Ref RefPicSetStCurrBefore List
2876 oss << "RefPicSetStCurrBefore[8]:";
2877 for (uint8_t i = 0; i < 8; i++)
2878 oss << picParams->RefPicSetStCurrBefore[i] << " ";
2879 oss << std::endl;
2880
2881 //Dump Ref RefPicSetStCurrAfter List
2882 oss << "RefPicSetStCurrAfter[16]:";
2883 for (uint8_t i = 0; i < 8; i++)
2884 oss << picParams->RefPicSetStCurrAfter[i] << " ";
2885 oss << std::endl;
2886
2887 //Dump Ref PicSetStCurr List
2888 oss << "RefPicSetLtCurr[16]:";
2889 for (uint8_t i = 0; i < 8; i++)
2890 oss << picParams->RefPicSetLtCurr[i] << " ";
2891 oss << std::endl;
2892
2893 //Dump Ref RefPicSetStCurrBefore List with POC
2894 oss << "RefPicSetStCurrBefore[8] (POC): ";
2895 for (uint8_t i = 0; i < 8; i++)
2896 oss << picParams->PicOrderCntValList[picParams->RefPicSetStCurrBefore[i]] << " ";
2897 oss << std::endl;
2898
2899 //Dump Ref RefPicSetStCurrAfter List with POC
2900 oss << "RefPicSetStCurrAfter[16] (POC):";
2901 for (uint8_t i = 0; i < 8; i++)
2902 oss << picParams->PicOrderCntValList[picParams->RefPicSetStCurrAfter[i]] << " ";
2903 oss << std::endl;
2904
2905 //Dump Ref PicSetStCurr List with POC
2906 oss << "RefPicSetLtCurr[16] (POC): ";
2907 for (uint8_t i = 0; i < 8; i++)
2908 oss << picParams->PicOrderCntValList[picParams->RefPicSetLtCurr[i]] << " ";
2909 oss << std::endl;
2910
2911 oss << "RefFieldPicFlag: " << +picParams->RefFieldPicFlag << std::endl;
2912 oss << "RefBottomFieldFlag: " << +picParams->RefBottomFieldFlag << std::endl;
2913 oss << "StatusReportFeedbackNumber: " << +picParams->StatusReportFeedbackNumber << std::endl;
2914
2915 const char *fileName = m_debugInterface->CreateFileName(
2916 "_DEC",
2917 CodechalDbgBufferType::bufPicParams,
2918 CodechalDbgExtType::txt);
2919
2920 std::ofstream ofs(fileName, std::ios::out);
2921 ofs << oss.str();
2922 ofs.close();
2923
2924 return MOS_STATUS_SUCCESS;
2925 }
2926
DumpSliceParams(PCODEC_HEVC_SLICE_PARAMS sliceParams,void * extSliceParams,uint32_t numSlices,bool shortFormatInUse)2927 MOS_STATUS CodechalDecodeHevc::DumpSliceParams(
2928 PCODEC_HEVC_SLICE_PARAMS sliceParams,
2929 void* extSliceParams,
2930 uint32_t numSlices,
2931 bool shortFormatInUse)
2932 {
2933 CODECHAL_DEBUG_FUNCTION_ENTER;
2934 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
2935 {
2936 return MOS_STATUS_SUCCESS;
2937 }
2938
2939 CODECHAL_DEBUG_CHK_NULL(sliceParams);
2940
2941 PCODEC_HEVC_SLICE_PARAMS hevcSliceControl = nullptr;
2942
2943 std::ostringstream oss;
2944 oss.setf(std::ios::showbase | std::ios::uppercase);
2945
2946 for (uint16_t j = 0; j < numSlices; j++)
2947 {
2948 hevcSliceControl = &sliceParams[j];
2949
2950 oss << "====================================================================================================" << std::endl;
2951 oss << "Data for Slice number = " << +j << std::endl;
2952 oss << "slice_data_size: " << +hevcSliceControl->slice_data_size << std::endl;
2953 oss << "slice_data_offset: " << +hevcSliceControl->slice_data_offset << std::endl;
2954
2955 if (!shortFormatInUse)
2956 {
2957 //Dump Long format specific
2958 oss << "ByteOffsetToSliceData: " << +hevcSliceControl->ByteOffsetToSliceData << std::endl;
2959 oss << "slice_segment_address: " << +hevcSliceControl->slice_segment_address << std::endl;
2960
2961 //Dump RefPicList[2][15]
2962 for (uint8_t i = 0; i < 15; ++i)
2963 {
2964 oss << "RefPicList[0][" << +i << "]";
2965 oss << "FrameIdx: " << +hevcSliceControl->RefPicList[0][i].FrameIdx;
2966 oss << ", PicFlags: " << +hevcSliceControl->RefPicList[0][i].PicFlags;
2967 oss << std::endl;
2968 }
2969 for (uint8_t i = 0; i < 15; ++i)
2970 {
2971 oss << "RefPicList[1][" << +i << "]";
2972 oss << "FrameIdx: " << +hevcSliceControl->RefPicList[1][i].FrameIdx;
2973 oss << ", PicFlags: " << +hevcSliceControl->RefPicList[1][i].PicFlags;
2974 oss << std::endl;
2975 }
2976
2977 oss << "last_slice_of_pic: " << +hevcSliceControl->LongSliceFlags.fields.LastSliceOfPic << std::endl;
2978 oss << "dependent_slice_segment_flag: " << +hevcSliceControl->LongSliceFlags.fields.dependent_slice_segment_flag << std::endl;
2979 oss << "slice_type: " << +hevcSliceControl->LongSliceFlags.fields.slice_type << std::endl;
2980 oss << "color_plane_id: " << +hevcSliceControl->LongSliceFlags.fields.color_plane_id << std::endl;
2981 oss << "slice_sao_luma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_luma_flag << std::endl;
2982 oss << "slice_sao_chroma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_chroma_flag << std::endl;
2983 oss << "mvd_l1_zero_flag: " << +hevcSliceControl->LongSliceFlags.fields.mvd_l1_zero_flag << std::endl;
2984 oss << "cabac_init_flag: " << +hevcSliceControl->LongSliceFlags.fields.cabac_init_flag << std::endl;
2985 oss << "slice_temporal_mvp_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag << std::endl;
2986 oss << "slice_deblocking_filter_disabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag << std::endl;
2987 oss << "collocated_from_l0_flag: " << +hevcSliceControl->LongSliceFlags.fields.collocated_from_l0_flag << std::endl;
2988 oss << "slice_loop_filter_across_slices_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag << std::endl;
2989 oss << "reserved: " << +hevcSliceControl->LongSliceFlags.fields.reserved << std::endl;
2990 oss << "collocated_ref_idx: " << +hevcSliceControl->collocated_ref_idx << std::endl;
2991 oss << "num_ref_idx_l0_active_minus1: " << +hevcSliceControl->num_ref_idx_l0_active_minus1 << std::endl;
2992 oss << "num_ref_idx_l1_active_minus1: " << +hevcSliceControl->num_ref_idx_l1_active_minus1 << std::endl;
2993 oss << "slice_qp_delta: " << +hevcSliceControl->slice_qp_delta << std::endl;
2994 oss << "slice_cb_qp_offset: " << +hevcSliceControl->slice_cb_qp_offset << std::endl;
2995 oss << "slice_cr_qp_offset: " << +hevcSliceControl->slice_cr_qp_offset << std::endl;
2996 oss << "slice_beta_offset_div2: " << +hevcSliceControl->slice_beta_offset_div2 << std::endl;
2997 oss << "slice_tc_offset_div2: " << +hevcSliceControl->slice_tc_offset_div2 << std::endl;
2998 oss << "luma_log2_weight_denom: " << +hevcSliceControl->luma_log2_weight_denom << std::endl;
2999 oss << "delta_chroma_log2_weight_denom: " << +hevcSliceControl->delta_chroma_log2_weight_denom << std::endl;
3000
3001 //Dump luma_offset[2][15]
3002 for (uint8_t i = 0; i < 15; i++)
3003 {
3004 oss << "luma_offset_l0[" << +i << "]: " << (+hevcSliceControl->luma_offset_l0[i]) << std::endl;
3005 oss << "luma_offset_l1[" << +i << "]: " << (+hevcSliceControl->luma_offset_l1[i]) << std::endl;
3006 }
3007 //Dump delta_luma_weight[2][15]
3008 for (uint8_t i = 0; i < 15; i++)
3009 {
3010 oss << "delta_luma_weight_l0[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
3011 oss << "delta_luma_weight_l1[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
3012 }
3013 //Dump chroma_offset[2][15][2]
3014 for (uint8_t i = 0; i < 15; i++)
3015 {
3016 oss << "ChromaOffsetL0[" << +i << "][0]: " << (+hevcSliceControl->ChromaOffsetL0[i][0]) << std::endl;
3017
3018 oss << "ChromaOffsetL0[" << +i << "][1]: " << (+hevcSliceControl->ChromaOffsetL0[i][1]) << std::endl;
3019
3020 oss << "ChromaOffsetL1[" << +i << "][0]: " << (+hevcSliceControl->ChromaOffsetL1[i][0]) << std::endl;
3021
3022 oss << "ChromaOffsetL1[" << +i << "][1]: " << (+hevcSliceControl->ChromaOffsetL1[i][1]) << std::endl;
3023 }
3024 //Dump delta_chroma_weight[2][15][2]
3025 for (uint8_t i = 0; i < 15; i++)
3026 {
3027 oss << "delta_chroma_weight_l0[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l0[i][0] << std::endl;
3028 oss << "delta_chroma_weight_l0[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l0[i][1] << std::endl;
3029 oss << "delta_chroma_weight_l1[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l1[i][0] << std::endl;
3030 oss << "delta_chroma_weight_l1[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l1[i][1] << std::endl;
3031 }
3032
3033 oss << "five_minus_max_num_merge_cand: " << +hevcSliceControl->five_minus_max_num_merge_cand << std::endl;
3034
3035 }
3036
3037 const char *fileName = m_debugInterface->CreateFileName(
3038 "_DEC",
3039 CodechalDbgBufferType::bufSlcParams,
3040 CodechalDbgExtType::txt);
3041
3042 std::ofstream ofs;
3043 if (j == 0)
3044 {
3045 ofs.open(fileName, std::ios::out);
3046 }
3047 else
3048 {
3049 ofs.open(fileName, std::ios::app);
3050 }
3051 ofs << oss.str();
3052 ofs.close();
3053 }
3054 return MOS_STATUS_SUCCESS;
3055 }
3056
DumpIQParams(PCODECHAL_HEVC_IQ_MATRIX_PARAMS matrixData)3057 MOS_STATUS CodechalDecodeHevc::DumpIQParams(
3058 PCODECHAL_HEVC_IQ_MATRIX_PARAMS matrixData)
3059 {
3060 CODECHAL_DEBUG_FUNCTION_ENTER;
3061
3062 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
3063 {
3064 return MOS_STATUS_SUCCESS;
3065 }
3066
3067 CODECHAL_DEBUG_CHK_NULL(matrixData);
3068
3069 std::ostringstream oss;
3070 oss.setf(std::ios::showbase | std::ios::uppercase);
3071
3072 uint32_t idx;
3073 uint32_t idx2;
3074 // 4x4 block
3075 for (idx2 = 0; idx2 < 6; idx2++)
3076 {
3077 oss << "Qmatrix_HEVC_ucScalingLists0[" << std::dec << +idx2 << "]:" << std::endl;
3078
3079 oss << "ucScalingLists0[" << +idx2 << "]:";
3080 for (uint8_t i = 0; i < 16; i++)
3081 oss << std::hex << +matrixData->ucScalingLists0[idx2][i] << " ";
3082 oss << std::endl;
3083 }
3084
3085 // 8x8 block
3086 for (idx2 = 0; idx2 < 6; idx2++)
3087 {
3088 oss << "ucScalingLists1[" << std::dec << +idx2 << "]:" << std::endl;
3089
3090 for (idx = 0; idx < 64; idx += 8)
3091 {
3092 oss << "ucScalingLists1[" << std::dec << +idx / 8 << "]:" << std::endl;
3093 for (uint8_t i = 0; i < 8; i++)
3094 oss << std::hex << +matrixData->ucScalingLists1[idx2][idx + i] << " ";
3095 oss << std::endl;
3096 }
3097 }
3098
3099 // 16x16 block
3100 for (idx2 = 0; idx2 < 6; idx2++)
3101 {
3102 oss << "ucScalingLists2[" << std::dec << +idx2 << "]:" << std::endl;
3103
3104 for (idx = 0; idx < 64; idx += 8)
3105 {
3106 oss << "ucScalingLists2[" << std::dec << +idx / 8 << "]:" << std::endl;
3107 for (uint8_t i = 0; i < 8; i++)
3108 oss << std::hex << +matrixData->ucScalingLists2[idx2][idx + i] << " ";
3109 oss << std::endl;
3110 }
3111 }
3112 // 32x32 block
3113 for (idx2 = 0; idx2 < 2; idx2++)
3114 {
3115 oss << "ucScalingLists3[" << std::dec << +idx2 << "]:" << std::endl;
3116
3117 for (idx = 0; idx < 64; idx += 8)
3118 {
3119 oss << "ucScalingLists3[" << std::dec << +idx / 8 << "]:" << std::endl;
3120 for (uint8_t i = 0; i < 8; i++)
3121 oss << std::hex << +matrixData->ucScalingLists3[idx2][idx + i] << " ";
3122 oss << std::endl;
3123 }
3124 }
3125
3126 //DC16x16 block
3127 oss << "ucScalingListDCCoefSizeID2: ";
3128 for (uint8_t i = 0; i < 6; i++)
3129 oss << std::hex << +matrixData->ucScalingListDCCoefSizeID2[i] << " ";
3130
3131 oss << std::endl;
3132
3133 //DC32x32 block
3134
3135 oss << "ucScalingListDCCoefSizeID3: ";
3136 oss << +matrixData->ucScalingListDCCoefSizeID3[0] << " " << +matrixData->ucScalingListDCCoefSizeID3[1] << std::endl;
3137
3138 const char *fileName = m_debugInterface->CreateFileName(
3139 "_DEC",
3140 CodechalDbgBufferType::bufIqParams,
3141 CodechalDbgExtType::txt);
3142
3143 std::ofstream ofs(fileName, std::ios::out);
3144 ofs << oss.str();
3145 ofs.close();
3146
3147 return MOS_STATUS_SUCCESS;
3148 }
3149
3150 #endif
3151