1 /*
2 * Copyright (c) 2022, 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 decode_vp9_picture_packet.cpp
24 //! \brief Defines the interface for vp9 decode picture packet
25 //!
26 #include "codec_utilities_next.h"
27 #include "decode_vp9_picture_packet.h"
28 #include "codechal_debug.h"
29 #include "decode_vp9_mem_compression.h"
30 #include "decode_common_feature_defs.h"
31 #include "decode_vp9_phase_front_end.h"
32 #include "decode_vp9_phase_back_end.h"
33
34 namespace decode
35 {
~Vp9DecodePicPkt()36 Vp9DecodePicPkt::~Vp9DecodePicPkt()
37 {
38 DECODE_FUNC_CALL();
39
40 FreeResources();
41 }
42
FreeResources()43 MOS_STATUS Vp9DecodePicPkt::FreeResources()
44 {
45 DECODE_FUNC_CALL();
46
47 if (m_allocator != nullptr)
48 {
49 m_allocator->Destroy(m_resMfdDeblockingFilterRowStoreScratchBuffer);
50 m_allocator->Destroy(m_resDeblockingFilterTileRowStoreScratchBuffer);
51 m_allocator->Destroy(m_resDeblockingFilterColumnRowStoreScratchBuffer);
52 m_allocator->Destroy(m_resMetadataLineBuffer);
53 m_allocator->Destroy(m_resMetadataTileLineBuffer);
54 m_allocator->Destroy(m_resMetadataTileColumnBuffer);
55 m_allocator->Destroy(m_resSaoLineBuffer);
56 m_allocator->Destroy(m_resSaoTileLineBuffer);
57 m_allocator->Destroy(m_resSaoTileColumnBuffer);
58 m_allocator->Destroy(m_resDeblockingFilterLineRowStoreScratchBuffer);
59 m_allocator->Destroy(m_resHvcLineRowstoreBuffer);
60 m_allocator->Destroy(m_resHvcTileRowstoreBuffer);
61 m_allocator->Destroy(m_resIntraPredUpRightColStoreBuffer);
62 m_allocator->Destroy(m_resIntraPredLeftReconColStoreBuffer);
63 m_allocator->Destroy(m_resCABACSyntaxStreamOutBuffer);
64 m_allocator->Destroy(m_resCABACStreamOutSizeBuffer);
65 }
66
67 return MOS_STATUS_SUCCESS;
68 }
69
Init()70 MOS_STATUS Vp9DecodePicPkt::Init()
71 {
72 DECODE_FUNC_CALL();
73
74 DECODE_CHK_NULL(m_featureManager);
75 DECODE_CHK_NULL(m_hwInterface);
76 DECODE_CHK_NULL(m_osInterface);
77 DECODE_CHK_NULL(m_miItf);
78 DECODE_CHK_NULL(m_vp9Pipeline);
79 DECODE_CHK_NULL(m_hcpItf);
80
81 m_vp9BasicFeature = dynamic_cast<Vp9BasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
82 DECODE_CHK_NULL(m_vp9BasicFeature);
83
84 #ifdef _DECODE_PROCESSING_SUPPORTED
85 m_downSamplingFeature = dynamic_cast<DecodeDownSamplingFeature *>(m_featureManager->GetFeature(DecodeFeatureIDs::decodeDownSampling));
86 DecodeSubPacket *subPacket = m_vp9Pipeline->GetSubPacket(DecodePacketId(m_vp9Pipeline, downSamplingSubPacketId));
87 m_downSamplingPkt = dynamic_cast<DecodeDownSamplingPkt *>(subPacket);
88 #endif
89
90 m_allocator = m_pipeline->GetDecodeAllocator();
91 DECODE_CHK_NULL(m_allocator);
92
93 // DECODE_CHK_STATUS(m_statusReport->RegistObserver(this));
94
95 DECODE_CHK_STATUS(AllocateFixedResources());
96
97 return MOS_STATUS_SUCCESS;
98 }
99
Prepare()100 MOS_STATUS Vp9DecodePicPkt::Prepare()
101 {
102 DECODE_FUNC_CALL();
103
104 m_vp9PicParams = m_vp9BasicFeature->m_vp9PicParams;
105
106 if (m_vp9PicParams->subsampling_x == 1 && m_vp9PicParams->subsampling_y == 1)
107 {
108 chromaSamplingFormat = HCP_CHROMA_FORMAT_YUV420;
109 }
110 else if (m_vp9PicParams->subsampling_x == 0 && m_vp9PicParams->subsampling_y == 0)
111 {
112 chromaSamplingFormat = HCP_CHROMA_FORMAT_YUV444;
113 }
114 else
115 {
116 DECODE_ASSERTMESSAGE("Invalid Chroma sampling format!");
117 return MOS_STATUS_INVALID_PARAMETER;
118 }
119
120 #ifdef _MMC_SUPPORTED
121 m_mmcState = m_vp9Pipeline->GetMmcState();
122 DECODE_CHK_NULL(m_mmcState);
123 #endif
124
125 DECODE_CHK_STATUS(SetRowstoreCachingOffsets());
126
127 DECODE_CHK_STATUS(AllocateVariableResources());
128
129 return MOS_STATUS_SUCCESS;
130 }
131
SetPhase(DecodePhase * phase)132 MOS_STATUS Vp9DecodePicPkt::SetPhase(DecodePhase *phase)
133 {
134 DECODE_FUNC_CALL();
135 m_phase = phase;
136 return MOS_STATUS_SUCCESS;
137 }
138
ReportCabacStreamOutSize(MOS_COMMAND_BUFFER & cmdBuffer)139 MOS_STATUS Vp9DecodePicPkt::ReportCabacStreamOutSize(MOS_COMMAND_BUFFER &cmdBuffer)
140 {
141 DECODE_FUNC_CALL();
142 DECODE_CHK_NULL(m_resCABACStreamOutSizeBuffer);
143
144 auto mmioRegistersHcp = m_hwInterface->GetHcpInterfaceNext()->GetMmioRegisters(MHW_VDBOX_NODE_1);
145
146 auto &par = m_miItf->GETPAR_MI_STORE_REGISTER_MEM();
147 par = {};
148 par.presStoreBuffer = &m_resCABACStreamOutSizeBuffer->OsResource;
149 par.dwOffset = 0;
150 par.dwRegister = mmioRegistersHcp->hcpDebugFEStreamOutSizeRegOffset;
151
152 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_STORE_REGISTER_MEM(&cmdBuffer));
153
154 return MOS_STATUS_SUCCESS;
155 }
156
IsFrontEndPhase()157 bool Vp9DecodePicPkt::IsFrontEndPhase()
158 {
159 DECODE_FUNC_CALL();
160
161 if (m_phase == nullptr)
162 {
163 return false;
164 }
165 Vp9PhaseFrontEnd *frontEndPhase = dynamic_cast<Vp9PhaseFrontEnd *>(m_phase);
166 return (frontEndPhase != nullptr);
167 }
168
IsBackEndPhase()169 bool Vp9DecodePicPkt::IsBackEndPhase()
170 {
171 DECODE_FUNC_CALL();
172
173 if (m_phase == nullptr)
174 {
175 return false;
176 }
177 Vp9PhaseBackEnd *backEndPhase = dynamic_cast<Vp9PhaseBackEnd *>(m_phase);
178 return (backEndPhase != nullptr);
179 }
180
SetRowstoreCachingOffsets()181 MOS_STATUS Vp9DecodePicPkt::SetRowstoreCachingOffsets()
182 {
183 DECODE_FUNC_CALL();
184
185 if (m_hcpItf->IsRowStoreCachingSupported() &&
186 (m_vp9BasicFeature->m_frameWidthAlignedMinBlk != MOS_ALIGN_CEIL(m_vp9BasicFeature->m_prevFrmWidth, CODEC_VP9_MIN_BLOCK_WIDTH)))
187 {
188 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams;
189 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams));
190
191 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams));
192 rowstoreParams.dwPicWidth = m_vp9BasicFeature->m_frameWidthAlignedMinBlk;
193 rowstoreParams.bMbaff = false;
194 rowstoreParams.Mode = CODECHAL_DECODE_MODE_VP9VLD;
195 rowstoreParams.ucBitDepthMinus8 = m_vp9PicParams->BitDepthMinus8;
196 rowstoreParams.ucChromaFormat = (uint8_t)chromaSamplingFormat;
197 DECODE_CHK_STATUS(m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams));
198 }
199
200 return MOS_STATUS_SUCCESS;
201 }
202
AllocateFixedResources()203 MOS_STATUS Vp9DecodePicPkt::AllocateFixedResources()
204 {
205 DECODE_FUNC_CALL();
206
207 if (m_resCABACStreamOutSizeBuffer == nullptr)
208 {
209 m_resCABACStreamOutSizeBuffer = m_allocator->AllocateBuffer(
210 sizeof(uint64_t),
211 "CABACStreamOutSizeBuffer",
212 resourceInternalReadWriteCache,
213 notLockableVideoMem);
214 DECODE_CHK_NULL(m_resCABACStreamOutSizeBuffer);
215 }
216
217 return MOS_STATUS_SUCCESS;
218 }
219
AllocateVariableResources()220 MOS_STATUS Vp9DecodePicPkt::AllocateVariableResources()
221 {
222 DECODE_FUNC_CALL();
223
224 uint8_t maxBitDepth = 8 + m_vp9BasicFeature->m_vp9DepthIndicator * 2;
225 m_widthInSb = MOS_ROUNDUP_DIVIDE(m_vp9BasicFeature->m_width, CODEC_VP9_SUPER_BLOCK_WIDTH);
226 m_heightInSb = MOS_ROUNDUP_DIVIDE(m_vp9BasicFeature->m_height, CODEC_VP9_SUPER_BLOCK_HEIGHT);
227
228 HcpBufferSizePar vp9BufSizeParams;
229 MOS_ZeroMemory(&vp9BufSizeParams, sizeof(HcpBufferSizePar));
230 vp9BufSizeParams.ucMaxBitDepth = maxBitDepth;
231 vp9BufSizeParams.ucChromaFormat = m_vp9BasicFeature->m_chromaFormat;
232 vp9BufSizeParams.dwPicWidth = m_widthInSb;
233 vp9BufSizeParams.dwPicHeight = m_heightInSb;
234 vp9BufSizeParams.dwMaxFrameSize = m_vp9BasicFeature->m_dataSize;
235
236 auto AllocateBuffer = [&](PMOS_BUFFER &buffer, HCP_INTERNAL_BUFFER_TYPE bufferType, const char *bufferName) {
237 uint32_t bufSize = 0;
238 vp9BufSizeParams.bufferType = bufferType;
239 DECODE_CHK_STATUS(m_hcpItf->GetVP9BufSize(vp9BufSizeParams, bufSize));
240 if (buffer == nullptr)
241 {
242 buffer = m_allocator->AllocateBuffer(
243 bufSize, bufferName, resourceInternalReadWriteCache, notLockableVideoMem);
244 DECODE_CHK_NULL(buffer);
245 }
246 else
247 {
248 DECODE_CHK_STATUS(m_allocator->Resize(buffer, bufSize, notLockableVideoMem));
249 }
250 return MOS_STATUS_SUCCESS;
251 };
252
253
254 if (!m_hcpItf->IsVp9DfRowstoreCacheEnabled())
255 {
256 // Deblocking Filter Line Row Store Scratch data surface
257 DECODE_CHK_STATUS(AllocateBuffer(m_resDeblockingFilterLineRowStoreScratchBuffer, HCP_INTERNAL_BUFFER_TYPE::DBLK_LINE, "BitstreamDecodeLineBuffer"));
258 }
259
260 // Deblocking Filter Tile Row Store Scratch data surface
261 DECODE_CHK_STATUS(AllocateBuffer(m_resDeblockingFilterTileRowStoreScratchBuffer, HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_LINE, "DeblockingTileScratchBuffer"));
262
263 // Deblocking Filter Column Row Store Scratch data surface
264 DECODE_CHK_STATUS(AllocateBuffer(m_resDeblockingFilterColumnRowStoreScratchBuffer, HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_COL, "DeblockingColumnScratchBuffer"));
265
266 // Metadata Line buffer
267 DECODE_CHK_STATUS(AllocateBuffer(m_resMetadataLineBuffer, HCP_INTERNAL_BUFFER_TYPE::META_LINE, "MetadataLineBuffer"));
268
269 // Metadata Tile Line buffer
270 DECODE_CHK_STATUS(AllocateBuffer(m_resMetadataTileLineBuffer, HCP_INTERNAL_BUFFER_TYPE::META_TILE_LINE, "MetadataTileLineBuffer"));
271
272 // Metadata Tile Column buffer
273 DECODE_CHK_STATUS(AllocateBuffer(m_resMetadataTileColumnBuffer, HCP_INTERNAL_BUFFER_TYPE::META_TILE_COL, "MetadataTileColumnBuffer"));
274
275 // HVC Line Row Store Buffer
276 DECODE_CHK_STATUS(AllocateBuffer(m_resHvcLineRowstoreBuffer, HCP_INTERNAL_BUFFER_TYPE::HVD_LINE, "HvcLineRowStoreBuffer"));
277
278 // HVC Tile Row Store Buffer
279 DECODE_CHK_STATUS(AllocateBuffer(m_resHvcTileRowstoreBuffer, HCP_INTERNAL_BUFFER_TYPE::HVD_TILE, "HvcTileRowStoreBuffer"));
280
281 // Cabac stream out buffer
282 DECODE_CHK_STATUS(AllocateBuffer(m_resCABACSyntaxStreamOutBuffer, HCP_INTERNAL_BUFFER_TYPE::CABAC_STREAMOUT, "CABACStreamOutBuffer"));
283
284 // Intra prediction up right column store buffer
285 DECODE_CHK_STATUS(AllocateBuffer(m_resIntraPredUpRightColStoreBuffer, HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_UP_RIGHT_COL, "IntraPredUpperRightColumnStore"));
286
287 // Intra prediction left recon column store buffer
288 DECODE_CHK_STATUS(AllocateBuffer(m_resIntraPredLeftReconColStoreBuffer, HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_LFT_RECON_COL, "IntraPredLeftReconColumnStore"));
289
290 return MOS_STATUS_SUCCESS;
291 }
292
MHW_SETPAR_DECL_SRC(HCP_PIPE_MODE_SELECT,Vp9DecodePicPkt)293 MHW_SETPAR_DECL_SRC(HCP_PIPE_MODE_SELECT, Vp9DecodePicPkt)
294 {
295 DECODE_FUNC_CALL();
296
297 params.codecSelect = 0; // CODEC_SELECT_DECODE
298 params.codecStandardSelect = CodecHal_GetStandardFromMode(m_vp9BasicFeature->m_mode) - CODECHAL_HCP_BASE;
299 params.bStreamOutEnabled = false;
300
301 auto cpInterface = m_hwInterface->GetCpInterface();
302 DECODE_CHK_NULL(cpInterface);
303
304 bool twoPassScalable = params.multiEngineMode != MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY && !params.bTileBasedReplayMode;
305 params.setProtectionSettings = [=](uint32_t *data) { return cpInterface->SetProtectionSettingsForHcpPipeModeSelect(data, twoPassScalable); };
306
307 params.mediaSoftResetCounterPer1000Clocks = 0;
308 #if (_DEBUG || _RELEASE_INTERNAL)
309 if (m_osInterface->bSoftReset)
310 {
311 params.mediaSoftResetCounterPer1000Clocks = 500;
312 }
313 #endif
314
315 auto waTable = m_osInterface->pfnGetWaTable(m_osInterface);
316 DECODE_CHK_NULL(waTable);
317
318 if (MEDIA_IS_WA(waTable, Wa_14012254246))
319 {
320 auto userSettingPtr = m_osInterface->pfnGetUserSettingInstance(m_osInterface);
321 params.prefetchDisable = ReadUserFeature(userSettingPtr, "DisableTlbPrefetch", MediaUserSetting::Group::Sequence).Get<bool>();
322 }
323
324 return MOS_STATUS_SUCCESS;
325 }
326
327 #ifdef _MMC_SUPPORTED
SetRefMmcStatus(uint8_t surfaceID,PMOS_SURFACE pSurface)328 MOS_STATUS Vp9DecodePicPkt::SetRefMmcStatus(uint8_t surfaceID, PMOS_SURFACE pSurface)
329 {
330 MOS_MEMCOMP_STATE mmcState = MOS_MEMCOMP_DISABLED;
331 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(pSurface));
332 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(pSurface, &mmcState));
333 m_refsMmcEnable |= (mmcState == MOS_MEMCOMP_RC || mmcState == MOS_MEMCOMP_MC) ? (1 << (surfaceID - 2)) : 0;
334 m_refsMmcType |= (mmcState == MOS_MEMCOMP_RC) ? (1 << (surfaceID - 2)) : 0;
335 if (m_mmcState->IsMmcEnabled())
336 {
337 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(pSurface, &m_mmcFormat));
338 }
339 return MOS_STATUS_SUCCESS;
340 }
341 #endif
342
MHW_SETPAR_DECL_SRC(HCP_SURFACE_STATE,Vp9DecodePicPkt)343 MHW_SETPAR_DECL_SRC(HCP_SURFACE_STATE, Vp9DecodePicPkt)
344 {
345 DECODE_FUNC_CALL();
346
347 uint8_t chromaType = (uint8_t)chromaSamplingFormat;
348 uint32_t dwUVPlaneAlignment = 8;
349 uint8_t ucBitDepthLumaMinus8 = (m_curHcpSurfStateId == CODECHAL_HCP_DECODED_SURFACE_ID) ? m_vp9PicParams->BitDepthMinus8 : 0;
350 uint8_t ucBitDepthChromaMinus8 = (m_curHcpSurfStateId == CODECHAL_HCP_DECODED_SURFACE_ID) ? m_vp9PicParams->BitDepthMinus8 : 0;
351
352 DECODE_CHK_NULL(psSurface);
353
354 #ifdef _MMC_SUPPORTED
355 if (m_curHcpSurfStateId == CODECHAL_HCP_DECODED_SURFACE_ID)
356 {
357 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(&(m_vp9BasicFeature->m_destSurface)));
358 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(psSurface, ¶ms.mmcState));
359 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(psSurface, ¶ms.dwCompressionFormat));
360 }
361 #endif
362
363 uint32_t uvPlaneAlignment = m_uvPlaneAlignmentLegacy;
364 params.surfaceStateId = m_curHcpSurfStateId;
365 params.surfacePitchMinus1 = psSurface->dwPitch - 1;
366
367 if (ucBitDepthLumaMinus8 == 0 && ucBitDepthChromaMinus8 == 0)
368 {
369 if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_NV12) // 4:2:0 8bit surface
370 {
371 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_PLANAR4208;
372 }
373 else if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P010) // 4:2:0 10bit surface
374 {
375 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P010;
376 }
377 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_YUY2) // 4:2:2 8bit surface
378 {
379 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_YUY2FORMAT;
380 }
381 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y210) // 4:2:2 10bit surface
382 {
383 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT;
384 }
385 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_AYUV) // 4:4:4 8bit surface
386 {
387 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_AYUV4444FORMAT;
388 }
389 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y410) // 4:4:4 10bit surface
390 {
391 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y410FORMAT;
392 }
393 else if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P016) // 4:2:0 16bit surface
394 {
395 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P016;
396 }
397 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y216) // 4:2:2 16bit surface
398 {
399 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT;
400 }
401 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y416) // 4:4:4
402 {
403 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y416FORMAT;
404 }
405 else
406 {
407 return MOS_STATUS_INVALID_PARAMETER;
408 }
409 }
410 else if ((ucBitDepthLumaMinus8 <= 2) && (ucBitDepthChromaMinus8 <= 2)) // only support bitdepth <= 10bit
411 {
412 if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P010) // 4:2:0
413 {
414 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P010;
415 }
416 else if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P016) // 4:2:0
417 {
418 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P016;
419 }
420 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y210) // 4:2:2
421 {
422 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT;
423 }
424 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y216) // 4:2:2
425 {
426 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT;
427 }
428 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y410) // 4:4:4
429 {
430 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y410FORMAT;
431 }
432 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y416) // 4:4:4
433 {
434 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y416FORMAT;
435 }
436 else
437 {
438 return MOS_STATUS_INVALID_PARAMETER;
439 }
440 }
441 else // 12bit
442 {
443 if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P016) // 4:2:0
444 {
445 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P016;
446 }
447 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y216) // 4:2:2
448 {
449 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT;
450 }
451 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y416) // 4:4:4
452 {
453 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y416FORMAT;
454 }
455 else
456 {
457 return MOS_STATUS_INVALID_PARAMETER;
458 }
459 }
460
461 uvPlaneAlignment = dwUVPlaneAlignment;
462
463 params.yOffsetForUCbInPixel =
464 MOS_ALIGN_CEIL((psSurface->UPlaneOffset.iSurfaceOffset - psSurface->dwOffset) / psSurface->dwPitch + psSurface->RenderOffset.YUV.U.YOffset, uvPlaneAlignment);
465
466 if ((ucBitDepthLumaMinus8 == 4) || (ucBitDepthChromaMinus8 == 4)) // 12 bit
467 {
468 params.defaultAlphaValue = 0xfff0;
469 }
470 else
471 {
472 params.defaultAlphaValue = 0xffff;
473 }
474
475 return MOS_STATUS_SUCCESS;
476 }
477
AddAllCmds_HCP_SURFACE_STATE(MOS_COMMAND_BUFFER & cmdBuffer)478 MOS_STATUS Vp9DecodePicPkt::AddAllCmds_HCP_SURFACE_STATE(MOS_COMMAND_BUFFER &cmdBuffer)
479 {
480 DECODE_FUNC_CALL();
481
482 auto ¶ms = m_hcpItf->MHW_GETPAR_F(HCP_SURFACE_STATE)();
483 params = {};
484
485 // destsurface surface cmd set
486 m_curHcpSurfStateId = CODECHAL_HCP_DECODED_SURFACE_ID;
487 psSurface = &m_vp9BasicFeature->m_destSurface;
488 SETPAR_AND_ADDCMD(HCP_SURFACE_STATE, m_hcpItf, &cmdBuffer);
489
490 // For non-key frame, send extra surface commands for reference pictures
491 if (m_vp9PicParams->PicFlags.fields.frame_type == CODEC_VP9_INTER_FRAME &&
492 !m_vp9PicParams->PicFlags.fields.intra_only)
493 {
494 mhw::vdbox::hcp::HCP_SURFACE_STATE_PAR refSurfaceParams[3] = {m_hcpItf->MHW_GETPAR_F(HCP_SURFACE_STATE)()};
495 MOS_ZeroMemory(refSurfaceParams, sizeof(refSurfaceParams));
496
497 for (uint8_t i = 0; i < 3; i++)
498 {
499 switch (i)
500 {
501 case 0:
502 psSurface = &(m_vp9BasicFeature->m_lastRefSurface);
503 m_curHcpSurfStateId = CODECHAL_HCP_LAST_SURFACE_ID;
504 break;
505 case 1:
506 psSurface = &(m_vp9BasicFeature->m_goldenRefSurface);
507 m_curHcpSurfStateId = CODECHAL_HCP_GOLDEN_SURFACE_ID;
508 break;
509 case 2:
510 psSurface = &(m_vp9BasicFeature->m_altRefSurface);
511 m_curHcpSurfStateId = CODECHAL_HCP_ALTREF_SURFACE_ID;
512 break;
513 }
514 #ifdef _MMC_SUPPORTED
515 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(psSurface));
516 DECODE_CHK_STATUS(SetRefMmcStatus(m_curHcpSurfStateId, psSurface));
517 #endif
518 MHW_SETPAR_F(HCP_SURFACE_STATE)(refSurfaceParams[i]);
519 }
520
521 for (uint8_t i = 0; i < 3; i++)
522 {
523 params = refSurfaceParams[i];
524 #ifdef _MMC_SUPPORTED
525 params.refsMmcEnable = m_refsMmcEnable;
526 params.refsMmcType = m_refsMmcType;
527 params.dwCompressionFormat = m_mmcFormat;
528 #endif
529 DECODE_CHK_STATUS(m_hcpItf->MHW_ADDCMD_F(HCP_SURFACE_STATE)(&cmdBuffer));
530 }
531 }
532
533 return MOS_STATUS_SUCCESS;
534 }
535
AddAllCmds_HCP_VP9_SEGMENT_STATE(MOS_COMMAND_BUFFER & cmdBuffer)536 MOS_STATUS Vp9DecodePicPkt::AddAllCmds_HCP_VP9_SEGMENT_STATE(MOS_COMMAND_BUFFER &cmdBuffer)
537 {
538 DECODE_FUNC_CALL();
539
540 auto ¶ms = m_hcpItf->MHW_GETPAR_F(HCP_VP9_SEGMENT_STATE)();
541 params = {};
542
543 PCODEC_VP9_SEGMENT_PARAMS pVp9SegmentParams = m_vp9BasicFeature->m_vp9SegmentParams;
544
545 for (uint8_t i = 0; i < CODEC_VP9_MAX_SEGMENTS; i++)
546 {
547 // Error handling for illegal programming on segmentation fields @ KEY/INTRA_ONLY frames
548 PCODEC_VP9_SEG_PARAMS vp9SegData = &(pVp9SegmentParams->SegData[i]);
549
550 if (vp9SegData->SegmentFlags.fields.SegmentReferenceEnabled &&
551 (!m_vp9PicParams->PicFlags.fields.frame_type || m_vp9PicParams->PicFlags.fields.intra_only))
552 {
553 vp9SegData->SegmentFlags.fields.SegmentReference = CODECHAL_DECODE_VP9_INTRA_FRAME;
554 }
555
556 params.segmentId = i;
557 params.segmentSkipped = vp9SegData->SegmentFlags.fields.SegmentReferenceSkipped;
558 params.segmentReference = vp9SegData->SegmentFlags.fields.SegmentReference;
559 params.segmentReferenceEnabled = vp9SegData->SegmentFlags.fields.SegmentReferenceEnabled;
560 params.filterLevelRef0Mode0 = vp9SegData->FilterLevel[0][0];
561 params.filterLevelRef0Mode1 = vp9SegData->FilterLevel[0][1];
562 params.filterLevelRef1Mode0 = vp9SegData->FilterLevel[1][0];
563 params.filterLevelRef1Mode1 = vp9SegData->FilterLevel[1][1];
564 params.filterLevelRef2Mode0 = vp9SegData->FilterLevel[2][0];
565 params.filterLevelRef2Mode1 = vp9SegData->FilterLevel[2][1];
566 params.filterLevelRef3Mode0 = vp9SegData->FilterLevel[3][0];
567 params.filterLevelRef3Mode1 = vp9SegData->FilterLevel[3][1];
568 params.lumaDcQuantScaleDecodeModeOnly = vp9SegData->LumaDCQuantScale;
569 params.lumaAcQuantScaleDecodeModeOnly = vp9SegData->LumaACQuantScale;
570 params.chromaDcQuantScaleDecodeModeOnly = vp9SegData->ChromaDCQuantScale;
571 params.chromaAcQuantScaleDecodeModeOnly = vp9SegData->ChromaACQuantScale;
572
573 DECODE_CHK_STATUS(m_hcpItf->MHW_ADDCMD_F(HCP_VP9_SEGMENT_STATE)(&cmdBuffer));
574
575 if (m_vp9PicParams->PicFlags.fields.segmentation_enabled == 0)
576 {
577 break;
578 }
579 }
580
581 return MOS_STATUS_SUCCESS;
582 }
583
MHW_SETPAR_DECL_SRC(HCP_PIPE_BUF_ADDR_STATE,Vp9DecodePicPkt)584 MHW_SETPAR_DECL_SRC(HCP_PIPE_BUF_ADDR_STATE, Vp9DecodePicPkt)
585 {
586 DECODE_FUNC_CALL();
587
588 params.Mode = (CODECHAL_MODE)CODECHAL_DECODE_MODE_VP9VLD;
589 params.psPreDeblockSurface = &(m_vp9BasicFeature->m_destSurface);
590 params.presReferences[CodechalDecodeLastRef] = m_vp9BasicFeature->m_presLastRefSurface;
591 params.presReferences[CodechalDecodeGoldenRef] = m_vp9BasicFeature->m_presGoldenRefSurface;
592 params.presReferences[CodechalDecodeAlternateRef] = m_vp9BasicFeature->m_presAltRefSurface;
593
594 params.presMfdDeblockingFilterRowStoreScratchBuffer = &(m_resDeblockingFilterLineRowStoreScratchBuffer->OsResource);
595 params.presDeblockingFilterTileRowStoreScratchBuffer = &(m_resDeblockingFilterTileRowStoreScratchBuffer->OsResource);
596 params.presDeblockingFilterColumnRowStoreScratchBuffer = &(m_resDeblockingFilterColumnRowStoreScratchBuffer->OsResource);
597
598 params.presMetadataLineBuffer = &(m_resMetadataLineBuffer->OsResource);
599 params.presMetadataTileLineBuffer = &(m_resMetadataTileLineBuffer->OsResource);
600 params.presMetadataTileColumnBuffer = &(m_resMetadataTileColumnBuffer->OsResource);
601
602 params.presHvdLineRowStoreBuffer = &(m_resHvcLineRowstoreBuffer->OsResource);
603 params.presHvdTileRowStoreBuffer = &(m_resHvcTileRowstoreBuffer->OsResource);
604
605 #ifdef _MMC_SUPPORTED
606 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(params.psPreDeblockSurface, ¶ms.PreDeblockSurfMmcState));
607 #endif
608
609 params.presVp9SegmentIdBuffer = &(m_vp9BasicFeature->m_resVp9SegmentIdBuffer->OsResource);
610 params.presVp9ProbBuffer = &(m_vp9BasicFeature->m_resVp9ProbBuffer[m_vp9BasicFeature->m_frameCtxIdx]->OsResource);
611
612 Vp9ReferenceFrames &refFrames = m_vp9BasicFeature->m_refFrames;
613 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_vp9PicParams);
614
615 if ((m_vp9PicParams->PicFlags.fields.frame_type == CODEC_VP9_INTER_FRAME) && !m_vp9PicParams->PicFlags.fields.intra_only)
616 {
617 params.presCurMvTempBuffer = &(m_vp9BasicFeature->m_resVp9MvTemporalBuffer[m_vp9BasicFeature->m_curMvTempBufIdx]->OsResource);
618
619 if (!m_vp9BasicFeature->m_prevFrameParams.fields.KeyFrame && !m_vp9PicParams->PicFlags.fields.intra_only)
620 {
621 params.presColMvTempBuffer[0] = &(m_vp9BasicFeature->m_resVp9MvTemporalBuffer[m_vp9BasicFeature->m_colMvTempBufIdx]->OsResource);
622 }
623 }
624
625 DECODE_CHK_STATUS(FixHcpPipeBufAddrParams());
626
627 CODECHAL_DEBUG_TOOL(DumpResources(params, activeRefList.size(), m_vp9BasicFeature->m_resVp9MvTemporalBuffer[0]->size));
628
629 return MOS_STATUS_SUCCESS;
630 }
631
FixHcpPipeBufAddrParams() const632 MOS_STATUS Vp9DecodePicPkt::FixHcpPipeBufAddrParams() const
633 {
634 DECODE_FUNC_CALL();
635 auto ¶ms = m_hcpItf->MHW_GETPAR_F(HCP_PIPE_BUF_ADDR_STATE)();
636
637 PMOS_RESOURCE dummyRef = nullptr ;
638
639 if (m_vp9BasicFeature->m_dummyReferenceStatus &&
640 !m_allocator->ResourceIsNull(&(m_vp9BasicFeature->m_dummyReference.OsResource)))
641 {
642 dummyRef = &(m_vp9BasicFeature->m_dummyReference.OsResource);
643 }
644 else
645 {
646 dummyRef = &(m_vp9BasicFeature->m_destSurface.OsResource);
647 }
648
649 for (uint8_t i = 0; i < CODECHAL_DECODE_VP9_MAX_NUM_REF_FRAME; i++)
650 {
651 if (!params.presReferences[i])
652 {
653 params.presReferences[i] = dummyRef;
654 }
655 }
656
657 return MOS_STATUS_SUCCESS;
658 }
659
MHW_SETPAR_DECL_SRC(HCP_IND_OBJ_BASE_ADDR_STATE,Vp9DecodePicPkt)660 MHW_SETPAR_DECL_SRC(HCP_IND_OBJ_BASE_ADDR_STATE, Vp9DecodePicPkt)
661 {
662 DECODE_FUNC_CALL();
663 params = {};
664
665 params.bDecodeInUse = true;
666 params.dwDataSize = m_vp9BasicFeature->m_dataSize;
667 params.dwDataOffset = m_vp9BasicFeature->m_dataOffset;
668 params.presDataBuffer = &(m_vp9BasicFeature->m_resDataBuffer.OsResource);
669
670 return MOS_STATUS_SUCCESS;
671 }
672
MHW_SETPAR_DECL_SRC(HCP_VP9_PIC_STATE,Vp9DecodePicPkt)673 MHW_SETPAR_DECL_SRC(HCP_VP9_PIC_STATE, Vp9DecodePicPkt)
674 {
675 DECODE_FUNC_CALL();
676
677 params.bDecodeInUse = true;
678
679 auto vp9RefList = &(m_vp9BasicFeature->m_refFrames.m_vp9RefList[0]);
680 PrevFrameParams prevFramePar = {};
681 prevFramePar.value = m_vp9BasicFeature->m_prevFrameParams.value;
682 uint32_t dwPrevFrmWidth = m_vp9BasicFeature->m_prevFrmWidth;
683 uint32_t dwPrevFrmHeight = m_vp9BasicFeature->m_prevFrmHeight;
684
685 m_vp9BasicFeature->m_prevFrmWidth = m_vp9PicParams->FrameWidthMinus1 + 1;
686 m_vp9BasicFeature->m_prevFrmHeight = m_vp9PicParams->FrameHeightMinus1 + 1;
687
688 // Update preframe field here, as pre frame keyframe was used for presColMvTempBuffer in SetHcpPipeBufAddrParams
689 // Make sure the value was not updated before SetHcpPipeBufAddrParams
690 m_vp9BasicFeature->m_prevFrameParams.fields.KeyFrame = !m_vp9PicParams->PicFlags.fields.frame_type;
691 m_vp9BasicFeature->m_prevFrameParams.fields.IntraOnly = m_vp9PicParams->PicFlags.fields.intra_only;
692 m_vp9BasicFeature->m_prevFrameParams.fields.Display = m_vp9PicParams->PicFlags.fields.show_frame;
693
694 uint32_t curFrameWidth = m_vp9PicParams->FrameWidthMinus1 + 1;
695 uint32_t curFrameHeight = m_vp9PicParams->FrameHeightMinus1 + 1;
696 bool isScaling = (curFrameWidth == dwPrevFrmWidth) && (curFrameHeight == dwPrevFrmHeight) ? false : true;
697
698 params.frameWidthInPixelsMinus1 = MOS_ALIGN_CEIL(curFrameWidth, CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
699 params.frameHeightInPixelsMinus1 = MOS_ALIGN_CEIL(curFrameHeight, CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
700 params.frameType = m_vp9PicParams->PicFlags.fields.frame_type;
701 params.adaptProbabilitiesFlag = !m_vp9PicParams->PicFlags.fields.error_resilient_mode && !m_vp9PicParams->PicFlags.fields.frame_parallel_decoding_mode;
702 params.intraOnlyFlag = m_vp9PicParams->PicFlags.fields.intra_only;
703 params.refreshFrameContext = m_vp9PicParams->PicFlags.fields.refresh_frame_context;
704 params.errorResilientMode = m_vp9PicParams->PicFlags.fields.error_resilient_mode;
705 params.frameParallelDecodingMode = m_vp9PicParams->PicFlags.fields.frame_parallel_decoding_mode;
706 params.filterLevel = m_vp9PicParams->filter_level;
707 params.sharpnessLevel = m_vp9PicParams->sharpness_level;
708 params.segmentationEnabled = m_vp9PicParams->PicFlags.fields.segmentation_enabled;
709 params.segmentationUpdateMap = params.segmentationEnabled && m_vp9PicParams->PicFlags.fields.segmentation_update_map;
710 params.losslessMode = m_vp9PicParams->PicFlags.fields.LosslessFlag;
711 params.segmentIdStreamOutEnable = params.segmentationUpdateMap;
712
713 uint8_t segmentIDStreaminEnable = 0;
714 if (m_vp9PicParams->PicFlags.fields.intra_only ||
715 (m_vp9PicParams->PicFlags.fields.frame_type == CODEC_VP9_KEY_FRAME))
716 {
717 segmentIDStreaminEnable = 1;
718 }
719 else if (m_vp9PicParams->PicFlags.fields.segmentation_enabled)
720 {
721 if (!m_vp9PicParams->PicFlags.fields.segmentation_update_map)
722 {
723 segmentIDStreaminEnable = 1;
724 }
725 else if (m_vp9PicParams->PicFlags.fields.segmentation_temporal_update)
726 {
727 segmentIDStreaminEnable = 1;
728 }
729 }
730 if (m_vp9PicParams->PicFlags.fields.error_resilient_mode)
731 {
732 segmentIDStreaminEnable = 1;
733 }
734 // Resolution change will reset the segment ID buffer
735 if (isScaling)
736 {
737 segmentIDStreaminEnable = 1;
738 }
739 params.segmentIdStreamInEnable = segmentIDStreaminEnable;
740
741 params.log2TileRow = m_vp9PicParams->log2_tile_rows; // No need to minus 1 here.
742 params.log2TileColumn = m_vp9PicParams->log2_tile_columns; // No need to minus 1 here.
743 if (m_vp9PicParams->subsampling_x == 1 && m_vp9PicParams->subsampling_y == 1)
744 {
745 // 4:2:0
746 params.chromaSamplingFormat = 0;
747 }
748 else if (m_vp9PicParams->subsampling_x == 1 && m_vp9PicParams->subsampling_y == 0)
749 {
750 // 4:2:2
751 params.chromaSamplingFormat = 1;
752 }
753 else if (m_vp9PicParams->subsampling_x == 0 && m_vp9PicParams->subsampling_y == 0)
754 {
755 // 4:4:4
756 params.chromaSamplingFormat = 2;
757 }
758 params.bitdepthMinus8 = m_vp9PicParams->BitDepthMinus8;
759 params.profileLevel = m_vp9PicParams->profile;
760
761 params.uncompressedHeaderLengthInBytes70 = m_vp9PicParams->UncompressedHeaderLengthInBytes;
762 params.firstPartitionSizeInBytes150 = m_vp9PicParams->FirstPartitionSize;
763
764 if (m_vp9PicParams->PicFlags.fields.frame_type && !m_vp9PicParams->PicFlags.fields.intra_only)
765 {
766 PCODEC_PICTURE refFrameList = &(m_vp9PicParams->RefFrameList[0]);
767
768 uint8_t lastRefPicIndex = refFrameList[m_vp9PicParams->PicFlags.fields.LastRefIdx].FrameIdx;
769 uint32_t lastRefFrameWidth = vp9RefList[lastRefPicIndex]->dwFrameWidth;
770 uint32_t lastRefFrameHeight = vp9RefList[lastRefPicIndex]->dwFrameHeight;
771
772 uint8_t goldenRefPicIndex = refFrameList[m_vp9PicParams->PicFlags.fields.GoldenRefIdx].FrameIdx;
773 uint32_t goldenRefFrameWidth = vp9RefList[goldenRefPicIndex]->dwFrameWidth;
774 uint32_t goldenRefFrameHeight = vp9RefList[goldenRefPicIndex]->dwFrameHeight;
775
776 uint8_t altRefPicIndex = refFrameList[m_vp9PicParams->PicFlags.fields.AltRefIdx].FrameIdx;
777 uint32_t altRefFrameWidth = vp9RefList[altRefPicIndex]->dwFrameWidth;
778 uint32_t altRefFrameHeight = vp9RefList[altRefPicIndex]->dwFrameHeight;
779
780 params.allowHiPrecisionMv = m_vp9PicParams->PicFlags.fields.allow_high_precision_mv;
781 params.mcompFilterType = m_vp9PicParams->PicFlags.fields.mcomp_filter_type;
782 params.segmentationTemporalUpdate = params.segmentationUpdateMap && m_vp9PicParams->PicFlags.fields.segmentation_temporal_update;
783
784 params.refFrameSignBias02 = m_vp9PicParams->PicFlags.fields.LastRefSignBias |
785 (m_vp9PicParams->PicFlags.fields.GoldenRefSignBias << 1) |
786 (m_vp9PicParams->PicFlags.fields.AltRefSignBias << 2);
787
788 params.lastFrameType = !prevFramePar.fields.KeyFrame;
789
790 // Reset UsePrevInFindMvReferences to zero if last picture has a different size,
791 // Current picture is error-resilient mode, Last picture was intra_only or keyframe,
792 // Last picture was not a displayed picture.
793 params.usePrevInFindMvReferences =
794 !(m_vp9PicParams->PicFlags.fields.error_resilient_mode ||
795 prevFramePar.fields.KeyFrame ||
796 prevFramePar.fields.IntraOnly ||
797 !prevFramePar.fields.Display);
798
799 // Reset UsePrevInFindMvReferences in case of resolution change on inter frames
800 if (isScaling)
801 {
802 params.usePrevInFindMvReferences = 0;
803 }
804
805 params.horizontalScaleFactorForLast = (lastRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
806 params.verticalScaleFactorForLast = (lastRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
807 params.horizontalScaleFactorForGolden = (goldenRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
808 params.verticalScaleFactorForGolden = (goldenRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
809 params.horizontalScaleFactorForAltref = (altRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
810 params.verticalScaleFactorForAltref = (altRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
811 params.lastFrameWidthInPixelsMinus1 = lastRefFrameWidth - 1;
812 params.lastFrameHeightInPixelsMinus1 = lastRefFrameHeight - 1;
813 params.goldenFrameWidthInPixelsMinus1 = goldenRefFrameWidth - 1;
814 params.goldenFrameHeightInPixelsMinus1 = goldenRefFrameHeight - 1;
815 params.altrefFrameWidthInPixelsMinus1 = altRefFrameWidth - 1;
816 params.altrefFrameHeightInPixelsMinus1 = altRefFrameHeight - 1;
817 }
818
819 return MOS_STATUS_SUCCESS;
820 }
821
MHW_SETPAR_DECL_SRC(HCP_BSD_OBJECT,Vp9DecodePicPkt)822 MHW_SETPAR_DECL_SRC(HCP_BSD_OBJECT, Vp9DecodePicPkt)
823 {
824 DECODE_FUNC_CALL();
825
826 params.bsdDataLength = m_vp9PicParams->BSBytesInBuffer - m_vp9PicParams->UncompressedHeaderLengthInBytes;
827 params.bsdDataStartOffset = m_vp9PicParams->UncompressedHeaderLengthInBytes; // already defined in HEVC patch
828
829 return MOS_STATUS_SUCCESS;
830 }
831
CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)832 MOS_STATUS Vp9DecodePicPkt::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize)
833 {
834 DECODE_FUNC_CALL();
835
836 commandBufferSize = m_pictureStatesSize;
837 requestedPatchListSize = m_picturePatchListSize;
838
839 return MOS_STATUS_SUCCESS;
840 }
841
842 #if USE_CODECHAL_DEBUG_TOOL
DumpResources(HCP_PIPE_BUF_ADDR_STATE_PAR & params,uint32_t refSize,uint32_t mvBufferSize) const843 MOS_STATUS Vp9DecodePicPkt::DumpResources(HCP_PIPE_BUF_ADDR_STATE_PAR ¶ms, uint32_t refSize, uint32_t mvBufferSize) const
844 {
845 DECODE_FUNC_CALL();
846
847 CodechalDebugInterface *debugInterface = m_pipeline->GetDebugInterface();
848 DECODE_CHK_NULL(debugInterface);
849
850 if (m_vp9PicParams->PicFlags.fields.frame_type == CODEC_VP9_INTER_FRAME)
851 {
852 for (uint16_t n = 0; n < refSize; n++)
853 {
854 if (params.presReferences[n])
855 {
856 MOS_SURFACE refSurface;
857 MOS_ZeroMemory(&refSurface, sizeof(MOS_SURFACE));
858 refSurface.OsResource = *(params.presReferences[n]);
859 DECODE_CHK_STATUS(CodecUtilities::CodecHalGetResourceInfo(
860 m_osInterface,
861 &refSurface));
862
863 debugInterface->m_refIndex = n;
864 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(debugInterface->m_refIndex)) + "]";
865 DECODE_CHK_STATUS(debugInterface->DumpYUVSurface(
866 &refSurface,
867 CodechalDbgAttr::attrDecodeReferenceSurfaces,
868 refSurfName.c_str()));
869 }
870 }
871 }
872
873 if (params.presColMvTempBuffer[0])
874 {
875 // dump mvdata
876 DECODE_CHK_STATUS(debugInterface->DumpBuffer(
877 params.presColMvTempBuffer[0],
878 CodechalDbgAttr::attrMvData,
879 "DEC_Col_MV_",
880 mvBufferSize));
881 };
882
883 if (params.presCurMvTempBuffer)
884 {
885 // dump mvdata
886 DECODE_CHK_STATUS(debugInterface->DumpBuffer(
887 params.presCurMvTempBuffer,
888 CodechalDbgAttr::attrMvData,
889 "DEC_Cur_MV_",
890 mvBufferSize));
891 };
892
893 return MOS_STATUS_SUCCESS;
894 }
895 #endif
896
897 } // namespace decode
898
899