Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_decode_hevc.cpp

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