1 /*
2 * Copyright (c) 2012-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file codechal_decode_hevc.cpp
24 //! \brief Implements the decode interface extension for HEVC.
25 //! \details Implements all functions required by CodecHal for HEVC decoding.
26 //!
27
28 #include "codechal_decoder.h"
29 #include "codechal_secure_decode_interface.h"
30 #include "codechal_decode_hevc.h"
31 #include "codechal_mmc_decode_hevc.h"
32 #include "codechal_decode_nv12top010.h"
33 #include "media_interfaces_nv12top010.h"
34 #include "hal_oca_interface.h"
35 #if USE_CODECHAL_DEBUG_TOOL
36 #include "codechal_debug.h"
37 #endif
38 //==<Functions>=======================================================
39
GetMvBufferIndex(uint8_t frameIdx)40 uint8_t CodechalDecodeHevc::GetMvBufferIndex(
41 uint8_t frameIdx)
42 {
43 PCODECHAL_DECODE_HEVC_MV_LIST hevcMVBufList = &m_hevcMvList[0];
44
45 uint8_t i;
46 for (i = 0; i < CODEC_NUM_HEVC_MV_BUFFERS; i++)
47 {
48 if (!hevcMVBufList[i].bInUse)
49 {
50 hevcMVBufList[i].bInUse = true;
51 hevcMVBufList[i].u8FrameId = frameIdx;
52 break;
53 }
54 }
55 if (i == CODEC_NUM_HEVC_MV_BUFFERS)
56 {
57 // Should never happen, something must be wrong
58 CODECHAL_DECODE_ASSERTMESSAGE("Failed to get avaiable MV buffer.");
59 }
60
61 return i;
62 }
63
AllocateResourcesFixedSizes()64 MOS_STATUS CodechalDecodeHevc::AllocateResourcesFixedSizes()
65 {
66 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
67
68 CODECHAL_DECODE_FUNCTION_ENTER;
69
70 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
71 m_osInterface,
72 &m_resSyncObjectWaContextInUse));
73
74 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalAllocateDataList(
75 m_hevcRefList,
76 CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC));
77
78 MOS_ZeroMemory(&m_secondLevelBatchBuffer, CODEC_HEVC_NUM_SECOND_BB * sizeof(MHW_BATCH_BUFFER));
79 if (m_shortFormatInUse)
80 {
81 // Second level batch buffer for HuC FW to use
82 uint32_t u32Size = MOS_ALIGN_CEIL(CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6 * m_standardDecodeSizeNeeded,
83 CODECHAL_PAGE_SIZE);
84
85 for (int i = 0; i < CODEC_HEVC_NUM_SECOND_BB; i++)
86 {
87 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
88 m_osInterface,
89 &m_secondLevelBatchBuffer[i],
90 nullptr,
91 u32Size));
92 m_secondLevelBatchBuffer[i].bSecondLevel = true;
93 }
94
95 // DMEM buffer send to HuC FW
96 m_dmemBufferSize = GetDmemBufferSize();
97
98 for (uint32_t i = 0; i < CODECHAL_HEVC_NUM_DMEM_BUFFERS; i++)
99 {
100 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
101 &m_resDmemBuffer[i],
102 m_dmemBufferSize,
103 "DmemBuffer"),
104 "Failed to allocate Dmem Buffer.");
105 }
106 }
107
108 return eStatus;
109 }
110
AllocateResourcesVariableSizes()111 MOS_STATUS CodechalDecodeHevc::AllocateResourcesVariableSizes()
112 {
113 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
114
115 CODECHAL_DECODE_FUNCTION_ENTER;
116
117 uint32_t widthMax = MOS_MAX(m_width, m_widthLastMaxAlloced);
118 uint32_t heightMax = MOS_MAX(m_height, m_heightLastMaxAlloced);
119 CODECHAL_DECODE_VERBOSEMESSAGE("m_width = %d, Max Width = %d, m_height %d, Max Height = %d",
120 m_width, widthMax, m_height, heightMax);
121
122 uint8_t maxBitDepth = (m_is12BitHevc) ? 12 :((m_is10BitHevc) ? 10 : 8);
123 uint8_t chromaFormatPic = m_hevcPicParams->chroma_format_idc;
124 uint8_t chromaFormat = m_chromaFormatinProfile;
125 CODECHAL_DECODE_ASSERT(chromaFormat >= chromaFormatPic);
126
127 uint32_t u32CtbLog2SizeYPic = m_hevcPicParams->log2_diff_max_min_luma_coding_block_size +
128 m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3;
129 uint32_t ctbLog2SizeY = MOS_MAX(u32CtbLog2SizeYPic, m_ctbLog2SizeYMax);
130
131 MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam;
132 MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
133 hcpBufSizeParam.ucMaxBitDepth = maxBitDepth;
134 hcpBufSizeParam.ucChromaFormat = chromaFormat;
135 hcpBufSizeParam.dwCtbLog2SizeY = ctbLog2SizeY;
136
137 MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam;
138 MOS_ZeroMemory(&reallocParam, sizeof(reallocParam));
139 reallocParam.ucMaxBitDepth = maxBitDepth;
140 reallocParam.ucChromaFormat = chromaFormat;
141 reallocParam.dwCtbLog2SizeY = ctbLog2SizeY;
142 reallocParam.dwCtbLog2SizeYMax = m_ctbLog2SizeYMax;
143
144 if (m_is8BitFrameIn10BitHevc)
145 {
146 uint32_t i;
147 // Init 8bitRTIndexMap array, 0xff means doesn't map to any InternalNV12RTSurface.
148 if (!m_internalNv12RtIndexMapInitilized)
149 {
150 for (i = 0; i < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC; i++)
151 {
152 m_internalNv12RtIndexMap[i] = 0xff;
153 }
154
155 m_internalNv12RtIndexMapInitilized = true;
156 }
157
158 if (m_internalNv12RtIndexMap[m_currPic.FrameIdx] != 0xff)
159 {
160 if (!Mos_ResourceIsNull(&m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_currPic.FrameIdx]].OsResource))
161 {
162 m_osInterface->pfnFreeResource(m_osInterface,
163 &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_currPic.FrameIdx]].OsResource);
164 }
165 }
166
167 // Seek an available surface in InternalNV12RTSurface array.
168 for (i = 0; i < CODECHAL_NUM_INTERNAL_NV12_RT_HEVC; i++)
169 {
170 if (Mos_ResourceIsNull(&m_internalNv12RtSurfaces[i].OsResource))
171 {
172 m_internalNv12RtIndexMap[m_currPic.FrameIdx] = i;
173 break;
174 }
175 }
176
177 // If there is no available InternalNV12RTSurface in the array.
178 if (i == CODECHAL_NUM_INTERNAL_NV12_RT_HEVC)
179 {
180 // Search an InternalNV12RTSurface to reuse.
181 for (uint32_t j = 0; j < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC; j++)
182 {
183 if (m_internalNv12RtIndexMap[j] != 0xff && j != m_currPic.FrameIdx)
184 {
185 uint32_t k;
186 // Check if InternalNV12RTSurface in reference list.
187 for (k = 0; k < CODEC_MAX_NUM_REF_FRAME_HEVC; k++)
188 {
189 if (j == m_hevcPicParams->RefFrameList[k].FrameIdx)
190 {
191 break;
192 }
193 }
194
195 // If InternalNV12RTSurface is not in reference list, reuse it.
196 if (k == CODEC_MAX_NUM_REF_FRAME_HEVC)
197 {
198 m_internalNv12RtIndexMap[m_currPic.FrameIdx] = m_internalNv12RtIndexMap[j];
199 m_internalNv12RtIndexMap[j] = 0xff;
200 break;
201 }
202 }
203 }
204 }
205
206 uint32_t internalNV12RTIndex = m_internalNv12RtIndexMap[m_currPic.FrameIdx];
207
208 if (Mos_ResourceIsNull(&m_internalNv12RtSurfaces[internalNV12RTIndex].OsResource) ||
209 m_destSurface.dwWidth != m_internalNv12RtSurfaces[internalNV12RTIndex].dwWidth ||
210 m_destSurface.dwHeight != m_internalNv12RtSurfaces[internalNV12RTIndex].dwHeight)
211 {
212 if (!Mos_ResourceIsNull(&m_internalNv12RtSurfaces[internalNV12RTIndex].OsResource))
213 {
214 m_osInterface->pfnFreeResource(m_osInterface, &m_internalNv12RtSurfaces[internalNV12RTIndex].OsResource);
215 }
216
217 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateSurface(
218 &m_internalNv12RtSurfaces[internalNV12RTIndex],
219 m_destSurface.dwWidth,
220 m_destSurface.dwHeight,
221 "HevcInternalNV12RTSurfaces"),
222 "Failed to allocate Hevc Internal NV12 dest surface data buffer.");
223 }
224 }
225
226 if (!m_hcpInterface->IsHevcDfRowstoreCacheEnabled())
227 {
228 uint32_t mfdDeblockingFilterRowStoreScratchBufferPicWidthMax =
229 MOS_MAX(m_width, m_mfdDeblockingFilterRowStoreScratchBufferPicWidth);
230
231 reallocParam.dwPicWidth = mfdDeblockingFilterRowStoreScratchBufferPicWidthMax;
232 reallocParam.dwPicWidthAlloced = m_mfdDeblockingFilterRowStoreScratchBufferPicWidth;
233 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
234 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE,
235 &reallocParam));
236 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
237 {
238 if (!Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
239 {
240 m_osInterface->pfnFreeResource(
241 m_osInterface,
242 &m_resMfdDeblockingFilterRowStoreScratchBuffer);
243 }
244
245 // Deblocking Filter Row Store Scratch buffer
246 hcpBufSizeParam.dwPicWidth = mfdDeblockingFilterRowStoreScratchBufferPicWidthMax;
247 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
248 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE,
249 &hcpBufSizeParam));
250
251 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
252 &m_resMfdDeblockingFilterRowStoreScratchBuffer,
253 hcpBufSizeParam.dwBufferSize,
254 "DeblockingScratchBuffer"),
255 "Failed to allocate Deblocking Filter Row Store Scratch Buffer.");
256 }
257
258 //record the width and height used for allocation internal resources.
259 m_mfdDeblockingFilterRowStoreScratchBufferPicWidth = mfdDeblockingFilterRowStoreScratchBufferPicWidthMax;
260 }
261
262 reallocParam.dwPicWidth = widthMax;
263 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
264 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
265 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE,
266 &reallocParam));
267 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resDeblockingFilterTileRowStoreScratchBuffer))
268 {
269 if (!Mos_ResourceIsNull(&m_resDeblockingFilterTileRowStoreScratchBuffer))
270 {
271 m_osInterface->pfnFreeResource(
272 m_osInterface,
273 &m_resDeblockingFilterTileRowStoreScratchBuffer);
274 }
275
276 // Deblocking Filter Tile Row Store Scratch data surface
277 hcpBufSizeParam.dwPicWidth = widthMax;
278 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
279 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE,
280 &hcpBufSizeParam));
281
282 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
283 &m_resDeblockingFilterTileRowStoreScratchBuffer,
284 hcpBufSizeParam.dwBufferSize,
285 "DeblockingTileScratchBuffer"),
286 "Failed to allocate Deblocking Filter Tile Row Store Scratch Buffer.");
287 }
288
289 reallocParam.dwPicHeight = heightMax;
290 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
291 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
292 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL,
293 &reallocParam));
294 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resDeblockingFilterColumnRowStoreScratchBuffer))
295 {
296 if (!Mos_ResourceIsNull(&m_resDeblockingFilterColumnRowStoreScratchBuffer))
297 {
298 m_osInterface->pfnFreeResource(
299 m_osInterface,
300 &m_resDeblockingFilterColumnRowStoreScratchBuffer);
301 }
302 // Deblocking Filter Column Row Store Scratch data surface
303 hcpBufSizeParam.dwPicHeight = heightMax;
304 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
305 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL,
306 &hcpBufSizeParam));
307
308 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
309 &m_resDeblockingFilterColumnRowStoreScratchBuffer,
310 hcpBufSizeParam.dwBufferSize,
311 "DeblockingColumnScratchBuffer"),
312 "Failed to allocate Deblocking Filter Column Row Store Scratch Buffer.");
313 }
314
315 if (!m_hcpInterface->IsHevcDatRowstoreCacheEnabled())
316 {
317 uint32_t metadataLineBufferPicWidthMax =
318 MOS_MAX(m_width, m_metadataLineBufferPicWidth);
319
320 reallocParam.dwPicWidth = metadataLineBufferPicWidthMax;
321 reallocParam.dwPicWidthAlloced = m_metadataLineBufferPicWidth;
322 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
323 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE,
324 &reallocParam));
325
326 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resMetadataLineBuffer))
327 {
328 if (!Mos_ResourceIsNull(&m_resMetadataLineBuffer))
329 {
330 m_osInterface->pfnFreeResource(
331 m_osInterface,
332 &m_resMetadataLineBuffer);
333 }
334
335 // Metadata Line buffer
336 hcpBufSizeParam.dwPicWidth = metadataLineBufferPicWidthMax;
337 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
338 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE,
339 &hcpBufSizeParam));
340
341 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
342 &m_resMetadataLineBuffer,
343 hcpBufSizeParam.dwBufferSize,
344 "MetadataLineBuffer"),
345 "Failed to allocate Metadata Line Buffer.");
346 }
347
348 //record the width and height used for allocation internal resources.
349 m_metadataLineBufferPicWidth = metadataLineBufferPicWidthMax;
350 }
351
352 reallocParam.dwPicWidth = widthMax;
353 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
354 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
355 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE,
356 &reallocParam));
357 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resMetadataTileLineBuffer))
358 {
359 if (!Mos_ResourceIsNull(&m_resMetadataTileLineBuffer))
360 {
361 m_osInterface->pfnFreeResource(
362 m_osInterface,
363 &m_resMetadataTileLineBuffer);
364 }
365 // Metadata Tile Line buffer
366 hcpBufSizeParam.dwPicWidth = widthMax;
367 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
368 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE,
369 &hcpBufSizeParam));
370
371 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
372 &m_resMetadataTileLineBuffer,
373 hcpBufSizeParam.dwBufferSize,
374 "MetadataTileLineBuffer"),
375 "Failed to allocate Metadata Tile Line Buffer.");
376 }
377
378 reallocParam.dwPicHeight = heightMax;
379 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
380 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
381 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL,
382 &reallocParam));
383 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resMetadataTileColumnBuffer))
384 {
385 if (!Mos_ResourceIsNull(&m_resMetadataTileColumnBuffer))
386 {
387 m_osInterface->pfnFreeResource(
388 m_osInterface,
389 &m_resMetadataTileColumnBuffer);
390 }
391 // Metadata Tile Column buffer
392 hcpBufSizeParam.dwPicHeight = heightMax;
393 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
394 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL,
395 &hcpBufSizeParam));
396
397 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
398 &m_resMetadataTileColumnBuffer,
399 hcpBufSizeParam.dwBufferSize,
400 "MetadataTileColumnBuffer"),
401 "Failed to allocate Metadata Tile Column Buffer.");
402 }
403
404 if (!m_hcpInterface->IsHevcSaoRowstoreCacheEnabled())
405 {
406 uint32_t saoLineBufferPicWidthMax =
407 MOS_MAX(m_width, m_saoLineBufferPicWidth);
408
409 reallocParam.dwPicWidth = saoLineBufferPicWidthMax;
410 reallocParam.dwPicWidthAlloced = m_saoLineBufferPicWidth;
411 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
412 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE,
413 &reallocParam));
414 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resSaoLineBuffer))
415 {
416 if (!Mos_ResourceIsNull(&m_resSaoLineBuffer))
417 {
418 m_osInterface->pfnFreeResource(
419 m_osInterface,
420 &m_resSaoLineBuffer);
421 }
422
423 // SAO Line buffer
424 hcpBufSizeParam.dwPicWidth = saoLineBufferPicWidthMax;
425 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
426 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE,
427 &hcpBufSizeParam));
428
429 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
430 &m_resSaoLineBuffer,
431 hcpBufSizeParam.dwBufferSize,
432 "SaoLineBuffer"),
433 "Failed to allocate SAO Line Buffer.");
434 }
435
436 //record the width and height used for allocation internal resources.
437 m_saoLineBufferPicWidth = saoLineBufferPicWidthMax;
438 }
439
440 reallocParam.dwPicWidth = widthMax;
441 reallocParam.dwPicWidthAlloced = m_widthLastMaxAlloced;
442 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
443 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE,
444 &reallocParam));
445 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resSaoTileLineBuffer))
446 {
447 if (!Mos_ResourceIsNull(&m_resSaoTileLineBuffer))
448 {
449 m_osInterface->pfnFreeResource(
450 m_osInterface,
451 &m_resSaoTileLineBuffer);
452 }
453 // SAO Tile Line buffer
454 hcpBufSizeParam.dwPicWidth = widthMax;
455 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
456 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE,
457 &hcpBufSizeParam));
458
459 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
460 &m_resSaoTileLineBuffer,
461 hcpBufSizeParam.dwBufferSize,
462 "SaoTileLineBuffer"),
463 "Failed to allocate SAO Tile Line Buffer.");
464 }
465
466 reallocParam.dwPicHeight = heightMax;
467 reallocParam.dwPicHeightAlloced = m_heightLastMaxAlloced;
468 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->IsHevcBufferReallocNeeded(
469 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL,
470 &reallocParam));
471 if (reallocParam.bNeedBiggerSize || Mos_ResourceIsNull(&m_resSaoTileColumnBuffer))
472 {
473 if (!Mos_ResourceIsNull(&m_resSaoTileColumnBuffer))
474 {
475 m_osInterface->pfnFreeResource(
476 m_osInterface,
477 &m_resSaoTileColumnBuffer);
478 }
479 // SAO Tile Column buffer
480 hcpBufSizeParam.dwPicHeight = heightMax;
481 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->GetHevcBufferSize(
482 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL,
483 &hcpBufSizeParam));
484
485 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
486 &m_resSaoTileColumnBuffer,
487 hcpBufSizeParam.dwBufferSize,
488 "SaoTileColumnBuffer"),
489 "Failed to allocate SAO Tile Column Buffer.");
490 }
491
492 for (uint8_t i = 0; i < CODEC_NUM_HEVC_INITIAL_MV_BUFFERS; i++)
493 {
494 AllocateMvTemporalBuffer(i);
495 }
496 m_mvBufferProgrammed = true;
497
498 if (m_secureDecoder)
499 {
500 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AllocateResource(this));
501 }
502
503 m_widthLastMaxAlloced = widthMax;
504 m_heightLastMaxAlloced = heightMax;
505 m_ctbLog2SizeYMax = ctbLog2SizeY;
506
507 return eStatus;
508 }
509
AllocateMvTemporalBuffer(uint8_t hevcMvBuffIndex)510 MOS_STATUS CodechalDecodeHevc::AllocateMvTemporalBuffer(
511 uint8_t hevcMvBuffIndex)
512 {
513 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
514 CODECHAL_DECODE_FUNCTION_ENTER;
515
516 // 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
~CodechalDecodeHevc()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
GetDmemBufferSize()713 uint32_t CodechalDecodeHevc::GetDmemBufferSize()
714 {
715 return MOS_ALIGN_CEIL(sizeof(HUC_HEVC_S2L_BSS), CODECHAL_CACHELINE_SIZE);
716 }
717
SetHucDmemS2LPictureBss(PHUC_HEVC_S2L_PIC_BSS hucHevcS2LPicBss)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
SetHucDmemS2LSliceBss(PHUC_HEVC_S2L_SLICE_BSS hucHevcS2LSliceBss)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
SetHucDmemParams(PMOS_RESOURCE dmemBuffer)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
GetAllTileInfo()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
InitializeBitstreamCat()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
CopyDataSurface()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
CheckAndCopyBitstream()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
SetFrameStates()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
SetPictureStructs()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
DetermineDecodePhase()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
DecodeStateLevel()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
AddPictureS2LCmds(PMOS_COMMAND_BUFFER cmdBufferInUse)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
SendPictureS2L()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
InitPicLongFormatMhwParams()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 #ifdef _MMC_SUPPORTED
1682 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(m_picMhwParams.PipeBufAddrParams));
1683 #endif
1684
1685 m_picMhwParams.PipeBufAddrParams->presMfdDeblockingFilterRowStoreScratchBuffer =
1686 &m_resMfdDeblockingFilterRowStoreScratchBuffer;
1687 m_picMhwParams.PipeBufAddrParams->presDeblockingFilterTileRowStoreScratchBuffer =
1688 &m_resDeblockingFilterTileRowStoreScratchBuffer;
1689 m_picMhwParams.PipeBufAddrParams->presDeblockingFilterColumnRowStoreScratchBuffer =
1690 &m_resDeblockingFilterColumnRowStoreScratchBuffer;
1691
1692 m_picMhwParams.PipeBufAddrParams->presMetadataLineBuffer = &m_resMetadataLineBuffer;
1693 m_picMhwParams.PipeBufAddrParams->presMetadataTileLineBuffer = &m_resMetadataTileLineBuffer;
1694 m_picMhwParams.PipeBufAddrParams->presMetadataTileColumnBuffer = &m_resMetadataTileColumnBuffer;
1695 m_picMhwParams.PipeBufAddrParams->presSaoLineBuffer = &m_resSaoLineBuffer;
1696 m_picMhwParams.PipeBufAddrParams->presSaoTileLineBuffer = &m_resSaoTileLineBuffer;
1697 m_picMhwParams.PipeBufAddrParams->presSaoTileColumnBuffer = &m_resSaoTileColumnBuffer;
1698 m_picMhwParams.PipeBufAddrParams->presCurMvTempBuffer = &m_resMvTemporalBuffer[m_hevcMvBufferIndex];
1699
1700 MOS_ZeroMemory(m_presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_HEVC);
1701 MOS_ZeroMemory(m_dummyReferenceSlot, sizeof(m_dummyReferenceSlot));
1702
1703 if (!m_curPicIntra)
1704 {
1705 uint8_t i, k = 0, m = 0;
1706
1707 PMOS_RESOURCE firstValidFrame = nullptr;
1708 PMOS_RESOURCE firstValidMvBuf = nullptr;
1709
1710 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1711 {
1712 if (m_frameUsedAsCurRef[i])
1713 {
1714 uint8_t refFrameValue = m_hevcPicParams->RefFrameList[i].FrameIdx;
1715 if (refFrameValue < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
1716 {
1717 m_presReferences[k] = &(m_hevcRefList[refFrameValue]->resRefPic);
1718
1719 if (m_osInterface->pfnIsMismatchOrderProgrammingSupported())
1720 {
1721 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[m++] = &m_resMvTemporalBuffer[refFrameValue];
1722 if (firstValidMvBuf == nullptr)
1723 {
1724 firstValidMvBuf = &m_resMvTemporalBuffer[refFrameValue];
1725 }
1726 }
1727 else
1728 {
1729 for (uint8_t j = 0; j < CODEC_NUM_HEVC_MV_BUFFERS; j++)
1730 {
1731 if ((m_hevcMvList[j].bInUse) &&
1732 (m_hevcMvList[j].u8FrameId == refFrameValue) &&
1733 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[j]))
1734 {
1735 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[m++] = &m_resMvTemporalBuffer[j];
1736 if (firstValidMvBuf == nullptr)
1737 {
1738 firstValidMvBuf = &m_resMvTemporalBuffer[j];
1739 }
1740 break;
1741 }
1742 }
1743 }
1744
1745 if (firstValidFrame == nullptr)
1746 {
1747 firstValidFrame = m_presReferences[k];
1748 }
1749
1750 k++;
1751 }
1752 }
1753 }
1754
1755 CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
1756 m_picMhwParams.PipeBufAddrParams->presReferences,
1757 sizeof(PMOS_RESOURCE) * CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC,
1758 m_presReferences,
1759 sizeof(PMOS_RESOURCE) * CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC));
1760
1761 CODECHAL_DECODE_ASSERT(k <= 8);
1762 CODECHAL_DECODE_ASSERT(m <= 8);
1763
1764 // Return error if reference surface's pitch * height is less than dest surface.
1765 MOS_SURFACE destSurfaceDetails;
1766 MOS_SURFACE refSurfaceDetails;
1767 bool hasRefs = false;
1768
1769 MOS_ZeroMemory(&destSurfaceDetails, sizeof(destSurfaceDetails));
1770 destSurfaceDetails.Format = Format_Invalid;
1771 MOS_ZeroMemory(&refSurfaceDetails, sizeof(refSurfaceDetails));
1772 refSurfaceDetails.Format = Format_Invalid;
1773
1774 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetResourceInfo(
1775 m_osInterface,
1776 &destSurface->OsResource,
1777 &destSurfaceDetails));
1778
1779 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1780 {
1781 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] != nullptr)
1782 {
1783 if (Mos_ResourceIsNull(m_picMhwParams.PipeBufAddrParams->presReferences[i]))
1784 {
1785 MOS_ZeroMemory(&m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic, sizeof(MOS_RESOURCE));
1786 CODECHAL_DECODE_ASSERTMESSAGE("Ref frame for Current Frame is not exist. Current frame will be skipped. Thus, clear current frame Ref List.");
1787 return MOS_STATUS_INVALID_PARAMETER;
1788 }
1789 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetResourceInfo(
1790 m_osInterface,
1791 m_picMhwParams.PipeBufAddrParams->presReferences[i],
1792 &refSurfaceDetails));
1793
1794 if ((refSurfaceDetails.dwPitch * refSurfaceDetails.dwHeight) <
1795 (destSurfaceDetails.dwPitch * destSurfaceDetails.dwHeight))
1796 {
1797 CODECHAL_DECODE_ASSERTMESSAGE("Reference surface's pitch * height is less than Dest surface.");
1798 return MOS_STATUS_INVALID_PARAMETER;
1799 }
1800
1801 hasRefs = true;
1802 }
1803 }
1804
1805 if (!m_curPicIntra && !hasRefs)
1806 {
1807 MOS_ZeroMemory(&m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic, sizeof(MOS_RESOURCE));
1808 CODECHAL_DECODE_ASSERTMESSAGE("No any Ref frame for Current Frame. Current frame will be skipped. Thus, clear current frame Ref List.");
1809 return MOS_STATUS_INVALID_PARAMETER;
1810 }
1811
1812 if (firstValidFrame == nullptr)
1813 {
1814 firstValidFrame = &destSurface->OsResource;
1815 }
1816 if (firstValidMvBuf == nullptr &&
1817 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[m_hevcMvBufferIndex]))
1818 {
1819 firstValidMvBuf = &m_resMvTemporalBuffer[m_hevcMvBufferIndex];
1820 }
1821
1822 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1823 {
1824 // error concealment for the unset reference addresses and unset mv buffers
1825 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] == nullptr)
1826 {
1827 m_picMhwParams.PipeBufAddrParams->presReferences[i] = firstValidFrame;
1828 }
1829 }
1830
1831 if (m_osInterface->pfnIsMismatchOrderProgrammingSupported())
1832 {
1833 for (uint32_t n = 0; n < CODEC_NUM_HEVC_MV_BUFFERS; n++)
1834 {
1835 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n] == nullptr)
1836 {
1837 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n] = firstValidMvBuf;
1838 }
1839 }
1840 }
1841 else
1842 {
1843 for (uint32_t n = 0; n < CODEC_NUM_HEVC_MV_BUFFERS; n++)
1844 {
1845 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n] == nullptr &&
1846 !Mos_ResourceIsNull(&m_resMvTemporalBuffer[n]))
1847 {
1848 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n] = &m_resMvTemporalBuffer[n];
1849 }
1850 }
1851 }
1852 }
1853
1854 // set all ref pic addresses to valid addresses for error concealment purpose
1855 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1856 {
1857 if (m_picMhwParams.PipeBufAddrParams->presReferences[i] == nullptr &&
1858 MEDIA_IS_WA(m_waTable, WaDummyReference) &&
1859 !Mos_ResourceIsNull(&m_dummyReference.OsResource))
1860 {
1861 m_picMhwParams.PipeBufAddrParams->presReferences[i] = &m_dummyReference.OsResource;
1862 m_dummyReferenceSlot[i] = true;
1863 }
1864 }
1865
1866 #ifdef _MMC_SUPPORTED
1867 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(m_picMhwParams.PipeBufAddrParams));
1868
1869 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));
1870 #endif
1871
1872 m_picMhwParams.IndObjBaseAddrParams->Mode = m_mode;
1873 m_picMhwParams.IndObjBaseAddrParams->dwDataSize = m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize;
1874 m_picMhwParams.IndObjBaseAddrParams->dwDataOffset = m_copyDataBufferInUse ? 0 : m_dataOffset;
1875 m_picMhwParams.IndObjBaseAddrParams->presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
1876
1877 if (m_secureDecoder)
1878 {
1879 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetBitstreamBuffer(m_picMhwParams.IndObjBaseAddrParams));
1880 }
1881
1882 m_picMhwParams.QmParams->Standard = CODECHAL_HEVC;
1883 m_picMhwParams.QmParams->pHevcIqMatrix = (PMHW_VDBOX_HEVC_QM_PARAMS)m_hevcIqMatrixParams;
1884
1885 m_picMhwParams.HevcPicState->pHevcPicParams = m_hevcPicParams;
1886
1887 m_picMhwParams.HevcTileState->pHevcPicParams = m_hevcPicParams;
1888 m_picMhwParams.HevcTileState->pTileColWidth = m_tileColWidth;
1889 m_picMhwParams.HevcTileState->pTileRowHeight = m_tileRowHeight;
1890
1891 return eStatus;
1892 }
1893
AddPictureLongFormatCmds(PMOS_COMMAND_BUFFER cmdBufferInUse,PIC_LONG_FORMAT_MHW_PARAMS * picMhwParams)1894 MOS_STATUS CodechalDecodeHevc::AddPictureLongFormatCmds(
1895 PMOS_COMMAND_BUFFER cmdBufferInUse,
1896 PIC_LONG_FORMAT_MHW_PARAMS *picMhwParams)
1897 {
1898 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1899
1900 CODECHAL_DECODE_FUNCTION_ENTER;
1901
1902 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBufferInUse);
1903 CODECHAL_DECODE_CHK_NULL_RETURN(picMhwParams);
1904
1905 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(
1906 cmdBufferInUse,
1907 picMhwParams->PipeModeSelectParams));
1908
1909 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSurfaceCmd(
1910 cmdBufferInUse,
1911 picMhwParams->SurfaceParams));
1912
1913 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeBufAddrCmd(
1914 cmdBufferInUse,
1915 picMhwParams->PipeBufAddrParams));
1916
1917 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpIndObjBaseAddrCmd(
1918 cmdBufferInUse,
1919 picMhwParams->IndObjBaseAddrParams));
1920
1921 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpQmStateCmd(
1922 cmdBufferInUse,
1923 picMhwParams->QmParams));
1924 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPicStateCmd(
1925 cmdBufferInUse,
1926 picMhwParams->HevcPicState));
1927
1928 if (m_hevcPicParams->tiles_enabled_flag)
1929 {
1930 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpTileStateCmd(
1931 cmdBufferInUse,
1932 picMhwParams->HevcTileState));
1933 }
1934
1935 return eStatus;
1936 }
1937
SendPictureLongFormat()1938 MOS_STATUS CodechalDecodeHevc::SendPictureLongFormat()
1939 {
1940 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1941
1942 CODECHAL_DECODE_FUNCTION_ENTER;
1943
1944 if (m_enableSf2DmaSubmits)
1945 {
1946 m_osInterface->pfnSetPerfTag(
1947 m_osInterface,
1948 (uint16_t)(((CODECHAL_DECODE_MODE_HEVCVLD << 4) & 0xF0) | (m_perfType & 0xF)));
1949 }
1950
1951 MOS_COMMAND_BUFFER cmdBuffer;
1952 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1953
1954 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
1955 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
1956
1957 bool sendPrologWithFrameTracking = false;
1958 if (m_shortFormatInUse)
1959 {
1960 sendPrologWithFrameTracking = m_enableSf2DmaSubmits;
1961 }
1962 else
1963 {
1964 sendPrologWithFrameTracking = true;
1965 }
1966
1967 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1968 &cmdBuffer,
1969 sendPrologWithFrameTracking));
1970
1971 CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicLongFormatMhwParams());
1972
1973 CODECHAL_DEBUG_TOOL(
1974 for (uint16_t n = 0; n < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; n++)
1975 {
1976 if (m_picMhwParams.PipeBufAddrParams->presReferences[n])
1977 {
1978 MOS_SURFACE dstSurface;
1979 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
1980 dstSurface.OsResource = *(m_picMhwParams.PipeBufAddrParams->presReferences[n]);
1981 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
1982 m_osInterface,
1983 &dstSurface));
1984
1985 m_debugInterface->m_refIndex = n;
1986 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex)) + "]";
1987 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
1988 &dstSurface,
1989 CodechalDbgAttr::attrDecodeReferenceSurfaces,
1990 refSurfName.c_str()));
1991 }
1992
1993 if (m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n])
1994 {
1995 m_debugInterface->m_refIndex = n;
1996 // dump mvdata
1997 std::string mvBufDumpName = "_DEC_" + std::to_string(int32_t(n));
1998
1999 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
2000 m_picMhwParams.PipeBufAddrParams->presColMvTempBuffer[n],
2001 CodechalDbgAttr::attrMvData,
2002 mvBufDumpName.c_str(),
2003 m_mvBufferSize));
2004 }
2005 }
2006 );
2007
2008 PMOS_COMMAND_BUFFER cmdBufferInUse = &cmdBuffer;
2009
2010 //Send status report Start
2011 if (m_statusQueryReportingEnabled)
2012 {
2013 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(cmdBufferInUse));
2014 }
2015
2016 if (m_statusQueryReportingEnabled && m_shortFormatInUse &&
2017 m_hcpDecPhase == CodechalHcpDecodePhaseLegacyLong)
2018 {
2019 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
2020 m_decodeStatusBuf.m_storeDataOffset +
2021 sizeof(uint32_t) * 2;
2022
2023 // Check HuC_STATUS bit15, HW continue if bit15 > 0, otherwise send COND BB END cmd.
2024 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->SendCondBbEndCmd(
2025 &m_decodeStatusBuf.m_statusBuffer,
2026 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset,
2027 0,
2028 false,
2029 cmdBufferInUse));
2030 }
2031
2032 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureLongFormatCmds(cmdBufferInUse, &m_picMhwParams));
2033
2034 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2035
2036 return eStatus;
2037 }
2038
SendSliceS2L(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)2039 MOS_STATUS CodechalDecodeHevc::SendSliceS2L(
2040 PMOS_COMMAND_BUFFER cmdBuffer,
2041 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
2042 {
2043 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2044
2045 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
2046 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState);
2047 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState->pHevcSliceParams);
2048
2049 CODECHAL_DECODE_CHK_COND_RETURN(
2050 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
2051 "ERROR - vdbox index exceed the maximum");
2052 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
2053
2054 if (m_secureDecoder)
2055 {
2056 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AddHucSecureState(
2057 this,
2058 hevcSliceState,
2059 cmdBuffer));
2060 }
2061
2062 // Send HuC Stream Obj cmd
2063 PCODEC_HEVC_SLICE_PARAMS slc = hevcSliceState->pHevcSliceParams;
2064 MHW_VDBOX_HUC_STREAM_OBJ_PARAMS hucStreamObjParams;
2065 MOS_ZeroMemory(&hucStreamObjParams, sizeof(hucStreamObjParams));
2066 hucStreamObjParams.dwIndStreamInLength = hevcSliceState->dwLength;
2067 hucStreamObjParams.bStreamOutEnable = hevcSliceState->bHucStreamOut ? 1 : 0;
2068 hucStreamObjParams.dwIndStreamInStartAddrOffset = slc->slice_data_offset;
2069 hucStreamObjParams.bHucProcessing = true;
2070
2071 if (m_secureDecoder)
2072 {
2073 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetHucStreamObj(
2074 &hucStreamObjParams));
2075 }
2076
2077 hucStreamObjParams.bStreamInEnable = 1;
2078 hucStreamObjParams.bEmulPreventionByteRemoval = 1;
2079 hucStreamObjParams.bStartCodeSearchEngine = 1;
2080 hucStreamObjParams.ucStartCodeByte0 = 0;
2081 hucStreamObjParams.ucStartCodeByte1 = 0;
2082 hucStreamObjParams.ucStartCodeByte2 = 1;
2083 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStreamObjectCmd(
2084 cmdBuffer,
2085 &hucStreamObjParams));
2086
2087 if (m_statusQueryReportingEnabled &&
2088 hevcSliceState->bLastSlice &&
2089 !hevcSliceState->bHucStreamOut)
2090 {
2091 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
2092 m_decodeStatusBuf.m_storeDataOffset +
2093 sizeof(uint32_t) * 2;
2094
2095 // Write HUC_STATUS2 mask
2096 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2097 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
2098 storeDataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
2099 storeDataParams.dwResourceOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2MaskOffset;
2100 storeDataParams.dwValue = m_hucInterface->GetHucStatus2ImemLoadedMask();
2101 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
2102 cmdBuffer,
2103 &storeDataParams));
2104
2105 // store HUC_STATUS2 register
2106 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
2107 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
2108 storeRegParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
2109 storeRegParams.dwOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2RegOffset;
2110 storeRegParams.dwRegister = mmioRegisters->hucStatus2RegOffset;
2111 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
2112 cmdBuffer,
2113 &storeRegParams));
2114 }
2115
2116 // Send HuC Start
2117 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(
2118 cmdBuffer,
2119 hevcSliceState->bLastSlice ? true : false));
2120
2121 return eStatus;
2122 }
2123
SendSliceLongFormat(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)2124 MOS_STATUS CodechalDecodeHevc::SendSliceLongFormat(
2125 PMOS_COMMAND_BUFFER cmdBuffer,
2126 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
2127 {
2128 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2129
2130 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
2131 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState);
2132 CODECHAL_DECODE_CHK_NULL_RETURN(hevcSliceState->pHevcSliceParams);
2133
2134 PCODEC_HEVC_SLICE_PARAMS slc = hevcSliceState->pHevcSliceParams;
2135
2136 // Disable the flag when ref list is empty for P/B slices to avoid the GPU hang
2137 if (m_curPicIntra &&
2138 !m_hcpInterface->IsHevcISlice(slc->LongSliceFlags.fields.slice_type))
2139 {
2140 slc->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag = 0;
2141 }
2142
2143 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSliceStateCmd(
2144 cmdBuffer,
2145 hevcSliceState));
2146
2147 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpProtectStateCmd(
2148 cmdBuffer,
2149 hevcSliceState));
2150
2151 if (! m_hcpInterface->IsHevcISlice(slc->LongSliceFlags.fields.slice_type))
2152 {
2153 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
2154 refIdxParams.CurrPic = m_hevcPicParams->CurrPic;
2155 refIdxParams.ucList = 0;
2156 refIdxParams.ucNumRefForList = slc->num_ref_idx_l0_active_minus1 + 1;
2157 eStatus = MOS_SecureMemcpy(&refIdxParams.RefPicList, sizeof(refIdxParams.RefPicList), &slc->RefPicList, sizeof(slc->RefPicList));
2158 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2159 refIdxParams.hevcRefList = (void**)m_hevcRefList;
2160 refIdxParams.poc_curr_pic = m_hevcPicParams->CurrPicOrderCntVal;
2161 for (uint8_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
2162 {
2163 refIdxParams.poc_list[i] = m_hevcPicParams->PicOrderCntValList[i];
2164 }
2165
2166 refIdxParams.pRefIdxMapping = hevcSliceState->pRefIdxMapping;
2167 refIdxParams.RefFieldPicFlag = m_hevcPicParams->RefFieldPicFlag;
2168 refIdxParams.RefBottomFieldFlag = m_hevcPicParams->RefBottomFieldFlag;
2169
2170 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2171 cmdBuffer,
2172 nullptr,
2173 &refIdxParams));
2174
2175 if (m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type))
2176 {
2177 refIdxParams.ucList = 1;
2178 refIdxParams.ucNumRefForList = slc->num_ref_idx_l1_active_minus1 + 1;
2179 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2180 cmdBuffer,
2181 nullptr,
2182 &refIdxParams));
2183 }
2184 }
2185 else if (MEDIA_IS_WA(m_waTable, WaDummyReference) && !m_osInterface->bSimIsActive)
2186 {
2187 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
2188 MOS_ZeroMemory(&refIdxParams, sizeof(MHW_VDBOX_HEVC_REF_IDX_PARAMS));
2189 refIdxParams.bDummyReference = true;
2190 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(
2191 cmdBuffer,
2192 nullptr,
2193 &refIdxParams));
2194 }
2195
2196 if ((m_hevcPicParams->weighted_pred_flag &&
2197 m_hcpInterface->IsHevcPSlice(slc->LongSliceFlags.fields.slice_type)) ||
2198 (m_hevcPicParams->weighted_bipred_flag &&
2199 m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type)))
2200 {
2201 MHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS weightOffsetParams;
2202
2203 weightOffsetParams.ucList = 0;
2204
2205 eStatus = MOS_SecureMemcpy(
2206 &weightOffsetParams.LumaWeights[0],
2207 sizeof(weightOffsetParams.LumaWeights[0]),
2208 &slc->delta_luma_weight_l0,
2209 sizeof(slc->delta_luma_weight_l0));
2210 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2211
2212 eStatus = MOS_SecureMemcpy(
2213 &weightOffsetParams.LumaWeights[1],
2214 sizeof(weightOffsetParams.LumaWeights[1]),
2215 &slc->delta_luma_weight_l1,
2216 sizeof(slc->delta_luma_weight_l1));
2217 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2218
2219 for (int32_t i = 0; i < 15; i++)
2220 {
2221 weightOffsetParams.LumaOffsets[0][i] = (int16_t)slc->luma_offset_l0[i];
2222 weightOffsetParams.LumaOffsets[1][i] = (int16_t)slc->luma_offset_l1[i];
2223
2224 for (int32_t j = 0; j < 2; j++)
2225 {
2226 weightOffsetParams.ChromaOffsets[0][i][j] = (int16_t)slc->ChromaOffsetL0[i][j];
2227 weightOffsetParams.ChromaOffsets[1][i][j] = (int16_t)slc->ChromaOffsetL1[i][j];
2228 }
2229 }
2230
2231 eStatus = MOS_SecureMemcpy(
2232 &weightOffsetParams.ChromaWeights[0],
2233 sizeof(weightOffsetParams.ChromaWeights[0]),
2234 &slc->delta_chroma_weight_l0,
2235 sizeof(slc->delta_chroma_weight_l0));
2236 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2237
2238 eStatus = MOS_SecureMemcpy(
2239 &weightOffsetParams.ChromaWeights[1],
2240 sizeof(weightOffsetParams.ChromaWeights[1]),
2241 &slc->delta_chroma_weight_l1,
2242 sizeof(slc->delta_chroma_weight_l1));
2243 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Failed to copy memory.");
2244
2245 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(
2246 cmdBuffer,
2247 nullptr,
2248 &weightOffsetParams));
2249
2250 if (m_hcpInterface->IsHevcBSlice(slc->LongSliceFlags.fields.slice_type))
2251 {
2252 weightOffsetParams.ucList = 1;
2253 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(
2254 cmdBuffer,
2255 nullptr,
2256 &weightOffsetParams));
2257 }
2258 }
2259
2260 if (m_secureDecoder)
2261 {
2262 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AddHcpSecureState(
2263 cmdBuffer,
2264 hevcSliceState));
2265 }
2266
2267 MHW_VDBOX_HCP_BSD_PARAMS bsdParams;
2268 MOS_ZeroMemory(&bsdParams, sizeof(bsdParams));
2269 bsdParams.dwBsdDataLength = hevcSliceState->dwLength;
2270 bsdParams.dwBsdDataStartOffset = slc->slice_data_offset + hevcSliceState->dwOffset;
2271
2272 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpBsdObjectCmd(
2273 cmdBuffer,
2274 &bsdParams));
2275
2276 return eStatus;
2277 }
2278
DecodePrimitiveLevel()2279 MOS_STATUS CodechalDecodeHevc::DecodePrimitiveLevel()
2280 {
2281 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2282
2283 CODECHAL_DECODE_FUNCTION_ENTER;
2284
2285 // Bitstream is incomplete, don't do any decoding work.
2286 if (m_incompletePicture)
2287 {
2288 return MOS_STATUS_SUCCESS;
2289 }
2290
2291 CODECHAL_DECODE_CHK_COND_RETURN(
2292 (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
2293 "ERROR - vdbox index exceed the maximum");
2294 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
2295
2296 uint32_t statusBufferOffset = (m_decodeStatusBuf.m_currIndex * sizeof(CodechalDecodeStatus)) +
2297 m_decodeStatusBuf.m_storeDataOffset +
2298 sizeof(uint32_t) * 2;
2299
2300 uint32_t renderingFlags = m_videoContextUsesNullHw;
2301
2302 MOS_COMMAND_BUFFER cmdBuffer;
2303 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
2304
2305 PMOS_COMMAND_BUFFER cmdBufferInUse = &cmdBuffer;
2306
2307 // If S2L and 2nd pass, ...
2308 // ... jump to 2nd level batch buffer.
2309 if ((m_shortFormatInUse &&
2310 m_hcpDecPhase == CodechalHcpDecodePhaseLegacyLong) ||
2311 m_cencBuf)
2312 {
2313 if (m_enableSf2DmaSubmits)
2314 {
2315 #if (_DEBUG || _RELEASE_INTERNAL)
2316 m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iLastCurrent = m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex].iSize;
2317 #endif
2318
2319 CODECHAL_DEBUG_TOOL(
2320 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
2321 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex],
2322 CODECHAL_NUM_MEDIA_STATES,
2323 "DEC"));)
2324 }
2325
2326 if (m_cencBuf)
2327 {
2328 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCencBatchBuffer(cmdBufferInUse));
2329 }
2330 else
2331 {
2332 // this is S2L conversion
2333 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
2334 cmdBufferInUse,
2335 &m_secondLevelBatchBuffer[m_secondLevelBatchBufferIndex]));
2336 }
2337 }
2338 else
2339 {
2340 // Setup static slice state parameters
2341 MHW_VDBOX_HEVC_SLICE_STATE hevcSliceState;
2342 hevcSliceState.presDataBuffer = m_copyDataBufferInUse ? &m_resCopyDataBuffer : &m_resDataBuffer;
2343 hevcSliceState.pHevcPicParams = m_hevcPicParams;
2344 hevcSliceState.pRefIdxMapping = &m_refIdxMapping[0];
2345
2346 PCODEC_HEVC_SLICE_PARAMS slc = m_hevcSliceParams;
2347 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
2348 {
2349 hevcSliceState.pHevcSliceParams = slc;
2350 hevcSliceState.dwLength = slc->slice_data_size;
2351 hevcSliceState.dwSliceIndex = slcCount;
2352 hevcSliceState.bLastSlice = (slcCount == (m_numSlices - 1));
2353
2354 // If S2L and 1st pass, send HuC commands.
2355 if (m_shortFormatInUse)
2356 {
2357 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceS2L(cmdBufferInUse, &hevcSliceState));
2358 }
2359 else
2360 {
2361 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSliceLongFormat(cmdBufferInUse, &hevcSliceState));
2362 }
2363
2364 slc++;
2365 }
2366
2367 // If S2L and 1st pass
2368 if (m_shortFormatInUse && m_hcpDecPhase == CodechalHcpDecodePhaseLegacyS2L)
2369 {
2370 // Send VD Pipe Flush command for SKL+
2371 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
2372 MOS_ZeroMemory(&vdpipeFlushParams , sizeof(vdpipeFlushParams));
2373 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
2374 vdpipeFlushParams.Flags.bFlushHEVC = 1;
2375 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
2376 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
2377 cmdBufferInUse,
2378 &vdpipeFlushParams));
2379
2380 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
2381 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2382 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2383 cmdBufferInUse,
2384 &flushDwParams));
2385
2386 if (m_statusQueryReportingEnabled)
2387 {
2388 // Check HuC_STATUS2 bit6, if bit6 > 0 HW continue execution following cmd, otherwise it send a COND BB END cmd.
2389 eStatus = m_hwInterface->SendCondBbEndCmd(
2390 &m_decodeStatusBuf.m_statusBuffer,
2391 statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatus2MaskOffset,
2392 0,
2393 false,
2394 cmdBufferInUse);
2395 CODECHAL_DECODE_CHK_STATUS_RETURN(eStatus);
2396
2397 // Write HUC_STATUS mask
2398 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2399 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
2400 storeDataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
2401 storeDataParams.dwResourceOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusMaskOffset;
2402 storeDataParams.dwValue = m_hucInterface->GetHucStatusHevcS2lFailureMask();
2403 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
2404 cmdBufferInUse,
2405 &storeDataParams));
2406
2407 // store HUC_STATUS register
2408 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
2409 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
2410 storeRegParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
2411 storeRegParams.dwOffset = statusBufferOffset + m_decodeStatusBuf.m_hucErrorStatusRegOffset;
2412 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
2413 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
2414 cmdBufferInUse,
2415 &storeRegParams));
2416 }
2417
2418 if (m_enableSf2DmaSubmits)
2419 {
2420 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
2421 cmdBufferInUse,
2422 nullptr));
2423 }
2424
2425 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2426
2427 if (m_enableSf2DmaSubmits)
2428 {
2429 CODECHAL_DEBUG_TOOL(
2430 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2431 cmdBufferInUse,
2432 CODECHAL_NUM_MEDIA_STATES,
2433 "DEC"));
2434
2435 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
2436 // m_debugInterface,
2437 // cmdBufferInUse));
2438 );
2439
2440 //CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
2441 // m_osInterface,
2442 // cmdBufferInUse,
2443 // renderingFlags));
2444 }
2445
2446 return eStatus;
2447 }
2448 }
2449
2450 // Send VD Pipe Flush command for SKL+
2451 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
2452 MOS_ZeroMemory(&vdpipeFlushParams , sizeof(vdpipeFlushParams));
2453 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
2454 vdpipeFlushParams.Flags.bFlushHEVC = 1;
2455 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
2456 CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
2457 cmdBufferInUse,
2458 &vdpipeFlushParams));
2459
2460 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
2461 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2462 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2463 cmdBufferInUse,
2464 &flushDwParams));
2465
2466 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
2467 syncParams.GpuContext = m_videoContext;
2468 if (m_is8BitFrameIn10BitHevc)
2469 {
2470 syncParams.presSyncResource =
2471 &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource;
2472 }
2473 else
2474 {
2475 syncParams.presSyncResource = &m_destSurface.OsResource;
2476 }
2477 syncParams.bReadOnly = false;
2478 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
2479 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
2480
2481 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
2482 {
2483 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
2484 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
2485
2486 // Update the resource tag (s/w tag) for On-Demand Sync
2487 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
2488 }
2489
2490 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
2491 if (m_osInterface->bTagResourceSync)
2492 {
2493 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
2494 cmdBufferInUse,
2495 &syncParams));
2496 }
2497
2498 if (m_statusQueryReportingEnabled)
2499 {
2500 CodechalDecodeStatusReport decodeStatusReport;
2501 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
2502 decodeStatusReport.m_currDecodedPic = m_hevcPicParams->CurrPic;
2503 decodeStatusReport.m_currDeblockedPic = m_hevcPicParams->CurrPic;
2504 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
2505 if (m_is8BitFrameIn10BitHevc)
2506 {
2507 decodeStatusReport.m_currDecodedPicRes = m_destSurface.OsResource;
2508 }
2509 else
2510 {
2511 decodeStatusReport.m_currDecodedPicRes = m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic;
2512 }
2513 #ifdef _DECODE_PROCESSING_SUPPORTED
2514 CODECHAL_DEBUG_TOOL(
2515 if (m_downsampledSurfaces && m_sfcState && m_sfcState->m_sfcOutputSurface) {
2516 m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource =
2517 m_sfcState->m_sfcOutputSurface->OsResource;
2518 decodeStatusReport.m_currSfcOutputPicRes =
2519 &m_downsampledSurfaces[m_hevcPicParams->CurrPic.FrameIdx].OsResource;
2520 })
2521 #endif
2522 CODECHAL_DEBUG_TOOL(
2523 decodeStatusReport.m_secondField = CodecHal_PictureIsBottomField(m_hevcPicParams->CurrPic);
2524 decodeStatusReport.m_frameType = m_perfType;);
2525
2526 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
2527 decodeStatusReport,
2528 cmdBufferInUse));
2529 }
2530
2531 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2532 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2533 cmdBufferInUse,
2534 &flushDwParams));
2535
2536 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
2537 cmdBufferInUse,
2538 nullptr));
2539
2540 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2541
2542 bool syncCompleteFrame = m_copyDataBufferInUse;
2543
2544 if (syncCompleteFrame)
2545 {
2546 //Sync up complete frame
2547 MOS_SYNC_PARAMS copyDataSyncParams = g_cInitSyncParams;
2548 copyDataSyncParams.GpuContext = m_videoContextForWa;
2549 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2550
2551 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, ©DataSyncParams));
2552
2553 copyDataSyncParams = g_cInitSyncParams;
2554 copyDataSyncParams.GpuContext = m_videoContext;
2555 copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2556
2557 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, ©DataSyncParams));
2558 }
2559
2560 CODECHAL_DEBUG_TOOL(
2561 {
2562 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2563 cmdBufferInUse,
2564 CODECHAL_NUM_MEDIA_STATES,
2565 "DEC"));
2566
2567 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
2568 // m_debugInterface,
2569 // cmdBufferInUse));
2570 }
2571 );
2572
2573 HalOcaInterface::DumpCodechalParam(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, m_pCodechalOcaDumper, CODECHAL_HEVC);
2574 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
2575
2576 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
2577 m_osInterface,
2578 cmdBufferInUse,
2579 renderingFlags));
2580
2581 CODECHAL_DEBUG_TOOL(
2582 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
2583
2584 // Reset status report
2585 if (m_statusQueryReportingEnabled)
2586 {
2587 bool resetStatusReport = true;
2588
2589 if (resetStatusReport)
2590 {
2591 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
2592 m_videoContextUsesNullHw));
2593 }
2594 }
2595
2596 if (m_is8BitFrameIn10BitHevc)
2597 {
2598 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeNV12ToP010);
2599 CODECHAL_DECODE_CHK_STATUS_RETURN(m_decodeNV12ToP010->Execute(
2600 &m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource,
2601 &m_destSurface.OsResource));
2602 }
2603
2604 // Needs to be re-set for Linux buffer re-use scenarios
2605 if (m_is8BitFrameIn10BitHevc)
2606 {
2607 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic =
2608 m_internalNv12RtSurfaces[m_internalNv12RtIndexMap[m_hevcPicParams->CurrPic.FrameIdx]].OsResource;
2609 }
2610 else
2611 {
2612 m_hevcRefList[m_hevcPicParams->CurrPic.FrameIdx]->resRefPic =
2613 m_destSurface.OsResource;
2614 }
2615
2616 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
2617 if (!CodecHal_PictureIsField(m_hevcPicParams->CurrPic))
2618 {
2619 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
2620 syncParams.GpuContext = m_videoContext;
2621 syncParams.presSyncResource = &m_destSurface.OsResource;
2622
2623 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
2624 }
2625
2626 #ifdef _DECODE_PROCESSING_SUPPORTED
2627 // Send Vebox and SFC cmds
2628 if (m_sfcState->m_sfcPipeOut)
2629 {
2630 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->RenderStart());
2631 }
2632 #endif
2633
2634 return eStatus;
2635 }
2636
CalcDownsamplingParams(void * picParams,uint32_t * refSurfWidth,uint32_t * refSurfHeight,MOS_FORMAT * format,uint8_t * frameIdx)2637 MOS_STATUS CodechalDecodeHevc::CalcDownsamplingParams(
2638 void *picParams,
2639 uint32_t *refSurfWidth,
2640 uint32_t *refSurfHeight,
2641 MOS_FORMAT *format,
2642 uint8_t *frameIdx)
2643 {
2644 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2645
2646 CODECHAL_DECODE_CHK_NULL_RETURN(picParams);
2647 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfWidth);
2648 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfHeight);
2649 CODECHAL_DECODE_CHK_NULL_RETURN(format);
2650 CODECHAL_DECODE_CHK_NULL_RETURN(frameIdx);
2651
2652 PCODEC_HEVC_PIC_PARAMS hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)picParams;
2653
2654 *refSurfWidth = 0;
2655 *refSurfHeight = 0;
2656 *format = Format_NV12;
2657 *frameIdx = hevcPicParams->CurrPic.FrameIdx;
2658
2659 uint32_t widthInPix, heightInPix;
2660
2661 widthInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicWidthInMinCbsY);
2662 heightInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicHeightInMinCbsY);
2663
2664 *refSurfWidth = MOS_ALIGN_CEIL(widthInPix, 64);
2665 *refSurfHeight = MOS_ALIGN_CEIL(heightInPix, 64);
2666
2667 if (m_is10BitHevc)
2668 {
2669 *format = Format_P010;
2670 }
2671
2672
2673 return eStatus;
2674 }
2675
InitMmcState()2676 MOS_STATUS CodechalDecodeHevc::InitMmcState()
2677 {
2678 #ifdef _MMC_SUPPORTED
2679 m_mmc = MOS_New(CodechalMmcDecodeHevc, m_hwInterface, this);
2680 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
2681 #endif
2682 return MOS_STATUS_SUCCESS;
2683 }
2684
AllocateStandard(CodechalSetting * settings)2685 MOS_STATUS CodechalDecodeHevc::AllocateStandard (
2686 CodechalSetting *settings)
2687 {
2688 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2689
2690 CODECHAL_DECODE_FUNCTION_ENTER;
2691
2692 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
2693
2694 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
2695
2696 m_width = settings->width;
2697 m_height = settings->height;
2698 m_is10BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS) ? true : false;
2699 m_is12BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_12_BITS) ? true : false;
2700 m_chromaFormatinProfile = settings->chromaFormat;
2701 m_shortFormatInUse = settings->shortFormatInUse;
2702
2703 #ifdef _DECODE_PROCESSING_SUPPORTED
2704 m_sfcState = MOS_New(CodechalHevcSfcState);
2705 CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
2706 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
2707 this,
2708 m_hwInterface,
2709 m_osInterface));
2710 #endif
2711
2712 MOS_ZeroMemory(&m_currPic, sizeof(m_currPic));
2713
2714 m_frameIdx = 0;
2715
2716 if (m_shortFormatInUse)
2717 {
2718 // Legacy SF has 2 passes, 1st pass is S2L, 2nd pass is HEVC Long decode.
2719 m_decodePassNum = 2;
2720
2721 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
2722 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
2723 MOS_UserFeature_ReadValue_ID(
2724 nullptr,
2725 __MEDIA_USER_FEATURE_VALUE_HEVC_SF_2_DMA_SUBMITS_ENABLE_ID,
2726 &userFeatureData,
2727 m_osInterface->pOsContext);
2728 m_enableSf2DmaSubmits = userFeatureData.u32Data ? true : false;
2729 }
2730
2731 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
2732 stateCmdSizeParams.bShortFormat = m_shortFormatInUse;
2733 stateCmdSizeParams.bHucDummyStream = (m_secureDecoder ? m_secureDecoder->IsDummyStreamEnabled() : false);
2734
2735 // Picture Level Commands
2736 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxStateCommandSize(
2737 m_mode,
2738 &m_commandBufferSizeNeeded,
2739 &m_commandPatchListSizeNeeded,
2740 &stateCmdSizeParams));
2741
2742 // Primitive Level Commands
2743 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetHxxPrimitiveCommandSize(
2744 m_mode,
2745 &m_standardDecodeSizeNeeded,
2746 &m_standardDecodePatchListSizeNeeded,
2747 m_shortFormatInUse));
2748
2749 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesFixedSizes());
2750
2751 // Prepare Pic Params
2752 m_picMhwParams.PipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS);
2753 m_picMhwParams.SurfaceParams = MOS_New(MHW_VDBOX_SURFACE_PARAMS);
2754 m_picMhwParams.PipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS);
2755 m_picMhwParams.IndObjBaseAddrParams = MOS_New(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS);
2756 m_picMhwParams.QmParams = MOS_New(MHW_VDBOX_QM_PARAMS);
2757 m_picMhwParams.HevcPicState = MOS_New(MHW_VDBOX_HEVC_PIC_STATE);
2758 m_picMhwParams.HevcTileState = MOS_New(MHW_VDBOX_HEVC_TILE_STATE);
2759
2760 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.PipeModeSelectParams);
2761 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.SurfaceParams);
2762 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.PipeBufAddrParams);
2763 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.IndObjBaseAddrParams);
2764 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.QmParams);
2765 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.HevcPicState);
2766 CODECHAL_DECODE_CHK_NULL_RETURN(m_picMhwParams.HevcTileState);
2767
2768 MOS_ZeroMemory(m_picMhwParams.SurfaceParams, sizeof(MHW_VDBOX_SURFACE_PARAMS));
2769 MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
2770 MOS_ZeroMemory(m_picMhwParams.QmParams, sizeof(MHW_VDBOX_QM_PARAMS));
2771 MOS_ZeroMemory(m_picMhwParams.HevcTileState, sizeof(MHW_VDBOX_HEVC_TILE_STATE));
2772
2773 return eStatus;
2774 }
2775
CodechalDecodeHevc(CodechalHwInterface * hwInterface,CodechalDebugInterface * debugInterface,PCODECHAL_STANDARD_INFO standardInfo)2776 CodechalDecodeHevc::CodechalDecodeHevc(
2777 CodechalHwInterface * hwInterface,
2778 CodechalDebugInterface *debugInterface,
2779 PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecode(hwInterface, debugInterface, standardInfo),
2780 m_minCtbSize(0),
2781 m_is10BitHevc(false),
2782 m_is12BitHevc(false),
2783 m_chromaFormatinProfile(0),
2784 m_shortFormatInUse(false),
2785 m_dataSize(0),
2786 m_dataOffset(0),
2787 m_numSlices(0),
2788 m_is8BitFrameIn10BitHevc(false),
2789 m_internalNv12RtIndexMapInitilized(false),
2790 m_mfdDeblockingFilterRowStoreScratchBufferPicWidth(0),
2791 m_metadataLineBufferPicWidth(0),
2792 m_saoLineBufferPicWidth(0),
2793 m_mvBufferProgrammed(false),
2794 m_secondLevelBatchBufferIndex(0),
2795 m_dmemBufferIdx(0),
2796 m_dmemBufferSize(0),
2797 m_dmemTransferSize(0),
2798 m_dmemBufferProgrammed(false),
2799 m_copyDataBufferSize(0),
2800 m_copyDataOffset(0),
2801 m_copyDataBufferInUse(false),
2802 m_estiBytesInBitstream(0),
2803 m_curPicIntra(false),
2804 m_mvBufferSize(0),
2805 m_hevcMvBufferIndex(0),
2806 m_frameIdx(0),
2807 m_enableSf2DmaSubmits(false),
2808 m_widthLastMaxAlloced(0),
2809 m_heightLastMaxAlloced(0),
2810 m_ctbLog2SizeYMax(0),
2811 m_hcpDecPhase(0)
2812 {
2813 CODECHAL_DECODE_FUNCTION_ENTER;
2814
2815 MOS_ZeroMemory(m_internalNv12RtSurfaces, sizeof(m_internalNv12RtSurfaces));
2816 MOS_ZeroMemory(&m_resDataBuffer, sizeof(m_resDataBuffer));
2817 MOS_ZeroMemory(&m_resMfdDeblockingFilterRowStoreScratchBuffer, sizeof(m_resMfdDeblockingFilterRowStoreScratchBuffer));
2818 MOS_ZeroMemory(&m_resDeblockingFilterTileRowStoreScratchBuffer, sizeof(m_resDeblockingFilterTileRowStoreScratchBuffer));
2819 MOS_ZeroMemory(&m_resDeblockingFilterColumnRowStoreScratchBuffer, sizeof(m_resDeblockingFilterColumnRowStoreScratchBuffer));
2820 MOS_ZeroMemory(&m_resMetadataLineBuffer, sizeof(m_resMetadataLineBuffer));
2821 MOS_ZeroMemory(&m_resMetadataTileLineBuffer, sizeof(m_resMetadataTileLineBuffer));
2822 MOS_ZeroMemory(&m_resMetadataTileColumnBuffer, sizeof(m_resMetadataTileColumnBuffer));
2823 MOS_ZeroMemory(&m_resSaoLineBuffer, sizeof(m_resSaoLineBuffer));
2824 MOS_ZeroMemory(&m_resSaoTileLineBuffer, sizeof(m_resSaoTileLineBuffer));
2825 MOS_ZeroMemory(&m_resSaoTileColumnBuffer, sizeof(m_resSaoTileColumnBuffer));
2826 MOS_ZeroMemory(m_resMvTemporalBuffer, sizeof(m_resMvTemporalBuffer));
2827 MOS_ZeroMemory(m_resDmemBuffer, sizeof(m_resDmemBuffer));
2828 MOS_ZeroMemory(&m_resCopyDataBuffer, sizeof(m_resCopyDataBuffer));
2829 MOS_ZeroMemory(&m_resSyncObjectWaContextInUse, sizeof(m_resSyncObjectWaContextInUse));
2830 MOS_ZeroMemory(&m_picMhwParams,sizeof(m_picMhwParams));
2831 MOS_ZeroMemory(&m_hevcPicParams,sizeof(m_hevcPicParams));
2832 MOS_ZeroMemory(&m_hevcSliceParams,sizeof(m_hevcSliceParams));
2833 MOS_ZeroMemory(&m_hevcIqMatrixParams,sizeof(m_hevcIqMatrixParams));
2834 MOS_ZeroMemory(&m_destSurface,sizeof(m_destSurface));
2835 MOS_ZeroMemory(&m_currPic,sizeof(m_currPic));
2836 MOS_ZeroMemory(&m_hevcMvList, CODEC_NUM_HEVC_MV_BUFFERS * sizeof(CODECHAL_DECODE_HEVC_MV_LIST));
2837 MOS_ZeroMemory(m_presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_HEVC);
2838
2839 m_hcpInUse = true;
2840
2841 m_hwInterface = hwInterface;
2842 }
2843
2844 #if USE_CODECHAL_DEBUG_TOOL
DumpPicParams(PCODEC_HEVC_PIC_PARAMS picParams,void * extPicParams)2845 MOS_STATUS CodechalDecodeHevc::DumpPicParams(
2846 PCODEC_HEVC_PIC_PARAMS picParams,
2847 void* extPicParams)
2848 {
2849 CODECHAL_DEBUG_FUNCTION_ENTER;
2850
2851 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
2852 {
2853 return MOS_STATUS_SUCCESS;
2854 }
2855
2856 CODECHAL_DEBUG_CHK_NULL(picParams);
2857
2858 std::ostringstream oss;
2859 oss.setf(std::ios::showbase | std::ios::uppercase);
2860 oss.setf(std::ios::hex, std::ios::basefield);
2861
2862 oss << "PicWidthInMinCbsY: " << +picParams->PicWidthInMinCbsY << std::endl;
2863 oss << "PicHeightInMinCbsY: " << +picParams->PicHeightInMinCbsY << std::endl;
2864 //wFormatAndSequenceInfoFlags
2865 oss << "chroma_format_idc: " << +picParams->chroma_format_idc << std::endl;
2866 oss << "separate_colour_plane_flag: " << +picParams->separate_colour_plane_flag << std::endl;
2867 oss << "bit_depth_luma_minus8: " << +picParams->bit_depth_luma_minus8 << std::endl;
2868 oss << "bit_depth_chroma_minus8: " << +picParams->bit_depth_chroma_minus8 << std::endl;
2869 oss << "log2_max_pic_order_cnt_lsb_minus4: " << +picParams->log2_max_pic_order_cnt_lsb_minus4 << std::endl;
2870 oss << "NoPicReorderingFlag: " << +picParams->NoPicReorderingFlag << std::endl;
2871 oss << "ReservedBits1: " << +picParams->ReservedBits1 << std::endl;
2872 oss << "wFormatAndSequenceInfoFlags: " << +picParams->wFormatAndSequenceInfoFlags << std::endl;
2873 oss << "CurrPic FrameIdx: " << +picParams->CurrPic.FrameIdx << std::endl;
2874 oss << "CurrPic PicFlags: " << +picParams->CurrPic.PicFlags << std::endl;
2875 oss << "sps_max_dec_pic_buffering_minus1: " << +picParams->sps_max_dec_pic_buffering_minus1 << std::endl;
2876 oss << "log2_min_luma_coding_block_size_minus3: " << +picParams->log2_min_luma_coding_block_size_minus3 << std::endl;
2877 oss << "log2_diff_max_min_luma_coding_block_size: " << +picParams->log2_diff_max_min_luma_coding_block_size << std::endl;
2878 oss << "log2_min_transform_block_size_minus2: " << +picParams->log2_min_transform_block_size_minus2 << std::endl;
2879 oss << "log2_diff_max_min_transform_block_size: " << +picParams->log2_diff_max_min_transform_block_size << std::endl;
2880 oss << "max_transform_hierarchy_depth_intra: " << +picParams->max_transform_hierarchy_depth_intra << std::endl;
2881 oss << "max_transform_hierarchy_depth_inter: " << +picParams->max_transform_hierarchy_depth_inter << std::endl;
2882 oss << "num_short_term_ref_pic_sets: " << +picParams->num_short_term_ref_pic_sets << std::endl;
2883 oss << "num_long_term_ref_pic_sps: " << +picParams->num_long_term_ref_pic_sps << std::endl;
2884 oss << "num_ref_idx_l0_default_active_minus1: " << +picParams->num_ref_idx_l0_default_active_minus1 << std::endl;
2885 oss << "num_ref_idx_l1_default_active_minus1: " << +picParams->num_ref_idx_l1_default_active_minus1 << std::endl;
2886 oss << "init_qp_minus26: " << +picParams->init_qp_minus26 << std::endl;
2887 oss << "ucNumDeltaPocsOfRefRpsIdx: " << +picParams->ucNumDeltaPocsOfRefRpsIdx << std::endl;
2888 oss << "wNumBitsForShortTermRPSInSlice: " << +picParams->wNumBitsForShortTermRPSInSlice << std::endl;
2889 oss << "ReservedBits2: " << +picParams->ReservedBits2 << std::endl;
2890 //dwCodingParamToolFlags
2891 oss << "scaling_list_enabled_flag: " << +picParams->scaling_list_enabled_flag << std::endl;
2892 oss << "amp_enabled_flag: " << +picParams->amp_enabled_flag << std::endl;
2893 oss << "sample_adaptive_offset_enabled_flag: " << +picParams->sample_adaptive_offset_enabled_flag << std::endl;
2894 oss << "pcm_enabled_flag: " << +picParams->pcm_enabled_flag << std::endl;
2895 oss << "pcm_sample_bit_depth_luma_minus1: " << +picParams->pcm_sample_bit_depth_luma_minus1 << std::endl;
2896 oss << "pcm_sample_bit_depth_chroma_minus1: " << +picParams->pcm_sample_bit_depth_chroma_minus1 << std::endl;
2897 oss << "log2_min_pcm_luma_coding_block_size_minus3: " << +picParams->log2_min_pcm_luma_coding_block_size_minus3 << std::endl;
2898 oss << "log2_diff_max_min_pcm_luma_coding_block_size: " << +picParams->log2_diff_max_min_pcm_luma_coding_block_size << std::endl;
2899 oss << "pcm_loop_filter_disabled_flag: " << +picParams->pcm_loop_filter_disabled_flag << std::endl;
2900 oss << "long_term_ref_pics_present_flag: " << +picParams->long_term_ref_pics_present_flag << std::endl;
2901 oss << "sps_temporal_mvp_enabled_flag: " << +picParams->sps_temporal_mvp_enabled_flag << std::endl;
2902 oss << "strong_intra_smoothing_enabled_flag: " << +picParams->strong_intra_smoothing_enabled_flag << std::endl;
2903 oss << "dependent_slice_segments_enabled_flag: " << +picParams->dependent_slice_segments_enabled_flag << std::endl;
2904 oss << "output_flag_present_flag: " << +picParams->output_flag_present_flag << std::endl;
2905 oss << "num_extra_slice_header_bits: " << +picParams->num_extra_slice_header_bits << std::endl;
2906 oss << "sign_data_hiding_enabled_flag: " << +picParams->sign_data_hiding_enabled_flag << std::endl;
2907 oss << "cabac_init_present_flag: " << +picParams->cabac_init_present_flag << std::endl;
2908 oss << "ReservedBits3: " << +picParams->ReservedBits3 << std::endl;
2909 oss << "dwCodingParamToolFlags: " << +picParams->dwCodingParamToolFlags << std::endl;
2910 //dwCodingSettingPicturePropertyFlags
2911 oss << "constrained_intra_pred_flag: " << +picParams->constrained_intra_pred_flag << std::endl;
2912 oss << "transform_skip_enabled_flag: " << +picParams->transform_skip_enabled_flag << std::endl;
2913 oss << "cu_qp_delta_enabled_flag: " << +picParams->cu_qp_delta_enabled_flag << std::endl;
2914 oss << "diff_cu_qp_delta_depth: " << +picParams->diff_cu_qp_delta_depth << std::endl;
2915 oss << "pps_slice_chroma_qp_offsets_present_flag: " << +picParams->pps_slice_chroma_qp_offsets_present_flag << std::endl;
2916 oss << "weighted_pred_flag: " << +picParams->weighted_pred_flag << std::endl;
2917 oss << "weighted_bipred_flag: " << +picParams->weighted_bipred_flag << std::endl;
2918 oss << "transquant_bypass_enabled_flag: " << +picParams->transquant_bypass_enabled_flag << std::endl;
2919 oss << "tiles_enabled_flag: " << +picParams->tiles_enabled_flag << std::endl;
2920 oss << "entropy_coding_sync_enabled_flag: " << +picParams->entropy_coding_sync_enabled_flag << std::endl;
2921 oss << "uniform_spacing_flag: " << +picParams->uniform_spacing_flag << std::endl;
2922 oss << "loop_filter_across_tiles_enabled_flag: " << +picParams->loop_filter_across_tiles_enabled_flag << std::endl;
2923 oss << "pps_loop_filter_across_slices_enabled_flag: " << +picParams->pps_loop_filter_across_slices_enabled_flag << std::endl;
2924 oss << "deblocking_filter_override_enabled_flag: " << +picParams->deblocking_filter_override_enabled_flag << std::endl;
2925 oss << "pps_deblocking_filter_disabled_flag: " << +picParams->pps_deblocking_filter_disabled_flag << std::endl;
2926 oss << "lists_modification_present_flag: " << +picParams->lists_modification_present_flag << std::endl;
2927 oss << "slice_segment_header_extension_present_flag: " << +picParams->slice_segment_header_extension_present_flag << std::endl;
2928 oss << "IrapPicFlag: " << +picParams->IrapPicFlag << std::endl;
2929 oss << "IdrPicFlag: " << +picParams->IdrPicFlag << std::endl;
2930 oss << "IntraPicFlag: " << +picParams->IntraPicFlag << std::endl;
2931 oss << "ReservedBits4: " << +picParams->ReservedBits4 << std::endl;
2932 oss << "dwCodingSettingPicturePropertyFlags: " << +picParams->dwCodingSettingPicturePropertyFlags << std::endl;
2933 oss << "pps_cb_qp_offset: " << +picParams->pps_cb_qp_offset << std::endl;
2934 oss << "pps_cr_qp_offset: " << +picParams->pps_cr_qp_offset << std::endl;
2935 oss << "num_tile_columns_minus1: " << +picParams->num_tile_columns_minus1 << std::endl;
2936 oss << "num_tile_rows_minus1: " << +picParams->num_tile_rows_minus1 << std::endl;
2937 //Dump column width
2938 oss << "column_width_minus1[19]:";
2939 for (uint8_t i = 0; i < 19; i++)
2940 oss << picParams->column_width_minus1[i] << " ";
2941 oss << std::endl;
2942
2943 //Dump row height
2944 oss << "row_height_minus1[21]:";
2945 for (uint8_t i = 0; i < 21; i++)
2946 oss << picParams->row_height_minus1[i] << " ";
2947 oss << std::endl;
2948
2949 oss << "pps_beta_offset_div2: " << +picParams->pps_beta_offset_div2 << std::endl;
2950 oss << "pps_tc_offset_div2: " << +picParams->pps_tc_offset_div2 << std::endl;
2951 oss << "log2_parallel_merge_level_minus2: " << +picParams->log2_parallel_merge_level_minus2 << std::endl;
2952 oss << "CurrPicOrderCntVal: " << +picParams->CurrPicOrderCntVal << std::endl;
2953
2954 oss.setf(std::ios::dec, std::ios::basefield);
2955 //Dump RefFrameList[15]
2956 for (uint8_t i = 0; i < 15; ++i)
2957 {
2958 oss << "RefFrameList[" << +i << "] FrameIdx:" << +picParams->RefFrameList[i].FrameIdx << std::endl;
2959 oss << "RefFrameList[" << +i << "] PicFlags:" << +picParams->RefFrameList[i].PicFlags << std::endl;
2960 }
2961
2962 //Dump POC List
2963 oss << "PicOrderCntValList[15]:";
2964 for (uint8_t i = 0; i < 15; i++)
2965 oss << std::hex << picParams->PicOrderCntValList[i] << " ";
2966 oss << std::endl;
2967
2968 //Dump Ref RefPicSetStCurrBefore List
2969 oss << "RefPicSetStCurrBefore[8]:";
2970 for (uint8_t i = 0; i < 8; i++)
2971 oss << picParams->RefPicSetStCurrBefore[i] << " ";
2972 oss << std::endl;
2973
2974 //Dump Ref RefPicSetStCurrAfter List
2975 oss << "RefPicSetStCurrAfter[16]:";
2976 for (uint8_t i = 0; i < 8; i++)
2977 oss << picParams->RefPicSetStCurrAfter[i] << " ";
2978 oss << std::endl;
2979
2980 //Dump Ref PicSetStCurr List
2981 oss << "RefPicSetLtCurr[16]:";
2982 for (uint8_t i = 0; i < 8; i++)
2983 oss << picParams->RefPicSetLtCurr[i] << " ";
2984 oss << std::endl;
2985
2986 //Dump Ref RefPicSetStCurrBefore List with POC
2987 oss << "RefPicSetStCurrBefore[8] (POC): ";
2988 for (uint8_t i = 0; i < 8; i++)
2989 oss << picParams->PicOrderCntValList[picParams->RefPicSetStCurrBefore[i]] << " ";
2990 oss << std::endl;
2991
2992 //Dump Ref RefPicSetStCurrAfter List with POC
2993 oss << "RefPicSetStCurrAfter[16] (POC):";
2994 for (uint8_t i = 0; i < 8; i++)
2995 oss << picParams->PicOrderCntValList[picParams->RefPicSetStCurrAfter[i]] << " ";
2996 oss << std::endl;
2997
2998 //Dump Ref PicSetStCurr List with POC
2999 oss << "RefPicSetLtCurr[16] (POC): ";
3000 for (uint8_t i = 0; i < 8; i++)
3001 oss << picParams->PicOrderCntValList[picParams->RefPicSetLtCurr[i]] << " ";
3002 oss << std::endl;
3003
3004 oss << "RefFieldPicFlag: " << +picParams->RefFieldPicFlag << std::endl;
3005 oss << "RefBottomFieldFlag: " << +picParams->RefBottomFieldFlag << std::endl;
3006 oss << "StatusReportFeedbackNumber: " << +picParams->StatusReportFeedbackNumber << std::endl;
3007
3008 const char *fileName = m_debugInterface->CreateFileName(
3009 "_DEC",
3010 CodechalDbgBufferType::bufPicParams,
3011 CodechalDbgExtType::txt);
3012
3013 std::ofstream ofs(fileName, std::ios::out);
3014 ofs << oss.str();
3015 ofs.close();
3016
3017 return MOS_STATUS_SUCCESS;
3018 }
3019
DumpSliceParams(PCODEC_HEVC_SLICE_PARAMS sliceParams,void * extSliceParams,uint32_t numSlices,bool shortFormatInUse)3020 MOS_STATUS CodechalDecodeHevc::DumpSliceParams(
3021 PCODEC_HEVC_SLICE_PARAMS sliceParams,
3022 void* extSliceParams,
3023 uint32_t numSlices,
3024 bool shortFormatInUse)
3025 {
3026 CODECHAL_DEBUG_FUNCTION_ENTER;
3027 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
3028 {
3029 return MOS_STATUS_SUCCESS;
3030 }
3031
3032 CODECHAL_DEBUG_CHK_NULL(sliceParams);
3033
3034 PCODEC_HEVC_SLICE_PARAMS hevcSliceControl = nullptr;
3035
3036 std::ostringstream oss;
3037 oss.setf(std::ios::showbase | std::ios::uppercase);
3038
3039 for (uint16_t j = 0; j < numSlices; j++)
3040 {
3041 hevcSliceControl = &sliceParams[j];
3042
3043 oss << "====================================================================================================" << std::endl;
3044 oss << "Data for Slice number = " << +j << std::endl;
3045 oss << "slice_data_size: " << +hevcSliceControl->slice_data_size << std::endl;
3046 oss << "slice_data_offset: " << +hevcSliceControl->slice_data_offset << std::endl;
3047
3048 if (!shortFormatInUse)
3049 {
3050 //Dump Long format specific
3051 oss << "ByteOffsetToSliceData: " << +hevcSliceControl->ByteOffsetToSliceData << std::endl;
3052 oss << "slice_segment_address: " << +hevcSliceControl->slice_segment_address << std::endl;
3053
3054 //Dump RefPicList[2][15]
3055 for (uint8_t i = 0; i < 15; ++i)
3056 {
3057 oss << "RefPicList[0][" << +i << "]";
3058 oss << "FrameIdx: " << +hevcSliceControl->RefPicList[0][i].FrameIdx;
3059 oss << ", PicFlags: " << +hevcSliceControl->RefPicList[0][i].PicFlags;
3060 oss << std::endl;
3061 }
3062 for (uint8_t i = 0; i < 15; ++i)
3063 {
3064 oss << "RefPicList[1][" << +i << "]";
3065 oss << "FrameIdx: " << +hevcSliceControl->RefPicList[1][i].FrameIdx;
3066 oss << ", PicFlags: " << +hevcSliceControl->RefPicList[1][i].PicFlags;
3067 oss << std::endl;
3068 }
3069
3070 oss << "last_slice_of_pic: " << +hevcSliceControl->LongSliceFlags.fields.LastSliceOfPic << std::endl;
3071 oss << "dependent_slice_segment_flag: " << +hevcSliceControl->LongSliceFlags.fields.dependent_slice_segment_flag << std::endl;
3072 oss << "slice_type: " << +hevcSliceControl->LongSliceFlags.fields.slice_type << std::endl;
3073 oss << "color_plane_id: " << +hevcSliceControl->LongSliceFlags.fields.color_plane_id << std::endl;
3074 oss << "slice_sao_luma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_luma_flag << std::endl;
3075 oss << "slice_sao_chroma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_chroma_flag << std::endl;
3076 oss << "mvd_l1_zero_flag: " << +hevcSliceControl->LongSliceFlags.fields.mvd_l1_zero_flag << std::endl;
3077 oss << "cabac_init_flag: " << +hevcSliceControl->LongSliceFlags.fields.cabac_init_flag << std::endl;
3078 oss << "slice_temporal_mvp_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag << std::endl;
3079 oss << "slice_deblocking_filter_disabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag << std::endl;
3080 oss << "collocated_from_l0_flag: " << +hevcSliceControl->LongSliceFlags.fields.collocated_from_l0_flag << std::endl;
3081 oss << "slice_loop_filter_across_slices_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag << std::endl;
3082 oss << "reserved: " << +hevcSliceControl->LongSliceFlags.fields.reserved << std::endl;
3083 oss << "collocated_ref_idx: " << +hevcSliceControl->collocated_ref_idx << std::endl;
3084 oss << "num_ref_idx_l0_active_minus1: " << +hevcSliceControl->num_ref_idx_l0_active_minus1 << std::endl;
3085 oss << "num_ref_idx_l1_active_minus1: " << +hevcSliceControl->num_ref_idx_l1_active_minus1 << std::endl;
3086 oss << "slice_qp_delta: " << +hevcSliceControl->slice_qp_delta << std::endl;
3087 oss << "slice_cb_qp_offset: " << +hevcSliceControl->slice_cb_qp_offset << std::endl;
3088 oss << "slice_cr_qp_offset: " << +hevcSliceControl->slice_cr_qp_offset << std::endl;
3089 oss << "slice_beta_offset_div2: " << +hevcSliceControl->slice_beta_offset_div2 << std::endl;
3090 oss << "slice_tc_offset_div2: " << +hevcSliceControl->slice_tc_offset_div2 << std::endl;
3091 oss << "luma_log2_weight_denom: " << +hevcSliceControl->luma_log2_weight_denom << std::endl;
3092 oss << "delta_chroma_log2_weight_denom: " << +hevcSliceControl->delta_chroma_log2_weight_denom << std::endl;
3093
3094 //Dump luma_offset[2][15]
3095 for (uint8_t i = 0; i < 15; i++)
3096 {
3097 oss << "luma_offset_l0[" << +i << "]: " << (+hevcSliceControl->luma_offset_l0[i]) << std::endl;
3098 oss << "luma_offset_l1[" << +i << "]: " << (+hevcSliceControl->luma_offset_l1[i]) << std::endl;
3099 }
3100 //Dump delta_luma_weight[2][15]
3101 for (uint8_t i = 0; i < 15; i++)
3102 {
3103 oss << "delta_luma_weight_l0[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
3104 oss << "delta_luma_weight_l1[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
3105 }
3106 //Dump chroma_offset[2][15][2]
3107 for (uint8_t i = 0; i < 15; i++)
3108 {
3109 oss << "ChromaOffsetL0[" << +i << "][0]: " << (+hevcSliceControl->ChromaOffsetL0[i][0]) << std::endl;
3110
3111 oss << "ChromaOffsetL0[" << +i << "][1]: " << (+hevcSliceControl->ChromaOffsetL0[i][1]) << std::endl;
3112
3113 oss << "ChromaOffsetL1[" << +i << "][0]: " << (+hevcSliceControl->ChromaOffsetL1[i][0]) << std::endl;
3114
3115 oss << "ChromaOffsetL1[" << +i << "][1]: " << (+hevcSliceControl->ChromaOffsetL1[i][1]) << std::endl;
3116 }
3117 //Dump delta_chroma_weight[2][15][2]
3118 for (uint8_t i = 0; i < 15; i++)
3119 {
3120 oss << "delta_chroma_weight_l0[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l0[i][0] << std::endl;
3121 oss << "delta_chroma_weight_l0[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l0[i][1] << std::endl;
3122 oss << "delta_chroma_weight_l1[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l1[i][0] << std::endl;
3123 oss << "delta_chroma_weight_l1[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l1[i][1] << std::endl;
3124 }
3125
3126 oss << "five_minus_max_num_merge_cand: " << +hevcSliceControl->five_minus_max_num_merge_cand << std::endl;
3127
3128 }
3129
3130 const char *fileName = m_debugInterface->CreateFileName(
3131 "_DEC",
3132 CodechalDbgBufferType::bufSlcParams,
3133 CodechalDbgExtType::txt);
3134
3135 std::ofstream ofs;
3136 if (j == 0)
3137 {
3138 ofs.open(fileName, std::ios::out);
3139 }
3140 else
3141 {
3142 ofs.open(fileName, std::ios::app);
3143 }
3144 ofs << oss.str();
3145 ofs.close();
3146 }
3147 return MOS_STATUS_SUCCESS;
3148 }
3149
DumpIQParams(PCODECHAL_HEVC_IQ_MATRIX_PARAMS matrixData)3150 MOS_STATUS CodechalDecodeHevc::DumpIQParams(
3151 PCODECHAL_HEVC_IQ_MATRIX_PARAMS matrixData)
3152 {
3153 CODECHAL_DEBUG_FUNCTION_ENTER;
3154
3155 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
3156 {
3157 return MOS_STATUS_SUCCESS;
3158 }
3159
3160 CODECHAL_DEBUG_CHK_NULL(matrixData);
3161
3162 std::ostringstream oss;
3163 oss.setf(std::ios::showbase | std::ios::uppercase);
3164
3165 uint32_t idx;
3166 uint32_t idx2;
3167 // 4x4 block
3168 for (idx2 = 0; idx2 < 6; idx2++)
3169 {
3170 oss << "Qmatrix_HEVC_ucScalingLists0[" << std::dec << +idx2 << "]:" << std::endl;
3171
3172 oss << "ucScalingLists0[" << +idx2 << "]:";
3173 for (uint8_t i = 0; i < 16; i++)
3174 oss << std::hex << +matrixData->ucScalingLists0[idx2][i] << " ";
3175 oss << std::endl;
3176 }
3177
3178 // 8x8 block
3179 for (idx2 = 0; idx2 < 6; idx2++)
3180 {
3181 oss << "ucScalingLists1[" << std::dec << +idx2 << "]:" << std::endl;
3182
3183 for (idx = 0; idx < 64; idx += 8)
3184 {
3185 oss << "ucScalingLists1[" << std::dec << +idx / 8 << "]:" << std::endl;
3186 for (uint8_t i = 0; i < 8; i++)
3187 oss << std::hex << +matrixData->ucScalingLists1[idx2][idx + i] << " ";
3188 oss << std::endl;
3189 }
3190 }
3191
3192 // 16x16 block
3193 for (idx2 = 0; idx2 < 6; idx2++)
3194 {
3195 oss << "ucScalingLists2[" << std::dec << +idx2 << "]:" << std::endl;
3196
3197 for (idx = 0; idx < 64; idx += 8)
3198 {
3199 oss << "ucScalingLists2[" << std::dec << +idx / 8 << "]:" << std::endl;
3200 for (uint8_t i = 0; i < 8; i++)
3201 oss << std::hex << +matrixData->ucScalingLists2[idx2][idx + i] << " ";
3202 oss << std::endl;
3203 }
3204 }
3205 // 32x32 block
3206 for (idx2 = 0; idx2 < 2; idx2++)
3207 {
3208 oss << "ucScalingLists3[" << std::dec << +idx2 << "]:" << std::endl;
3209
3210 for (idx = 0; idx < 64; idx += 8)
3211 {
3212 oss << "ucScalingLists3[" << std::dec << +idx / 8 << "]:" << std::endl;
3213 for (uint8_t i = 0; i < 8; i++)
3214 oss << std::hex << +matrixData->ucScalingLists3[idx2][idx + i] << " ";
3215 oss << std::endl;
3216 }
3217 }
3218
3219 //DC16x16 block
3220 oss << "ucScalingListDCCoefSizeID2: ";
3221 for (uint8_t i = 0; i < 6; i++)
3222 oss << std::hex << +matrixData->ucScalingListDCCoefSizeID2[i] << " ";
3223
3224 oss << std::endl;
3225
3226 //DC32x32 block
3227
3228 oss << "ucScalingListDCCoefSizeID3: ";
3229 oss << +matrixData->ucScalingListDCCoefSizeID3[0] << " " << +matrixData->ucScalingListDCCoefSizeID3[1] << std::endl;
3230
3231 const char *fileName = m_debugInterface->CreateFileName(
3232 "_DEC",
3233 CodechalDbgBufferType::bufIqParams,
3234 CodechalDbgExtType::txt);
3235
3236 std::ofstream ofs(fileName, std::ios::out);
3237 ofs << oss.str();
3238 ofs.close();
3239
3240 return MOS_STATUS_SUCCESS;
3241 }
3242
DumpHucS2l(PMHW_VDBOX_HUC_DMEM_STATE_PARAMS hucDmemStateParams)3243 MOS_STATUS CodechalDecodeHevc::DumpHucS2l(PMHW_VDBOX_HUC_DMEM_STATE_PARAMS hucDmemStateParams)
3244 {
3245 CODECHAL_DEBUG_FUNCTION_ENTER;
3246
3247 CODECHAL_DEBUG_CHK_NULL(m_debugInterface);
3248
3249 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucDmem(
3250 hucDmemStateParams->presHucDataSource,
3251 m_dmemTransferSize,
3252 0,
3253 hucRegionDumpDefault));
3254
3255 return MOS_STATUS_SUCCESS;
3256 }
3257
3258 #endif
3259