1 /*
2 * Copyright (c) 2020-2024, 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_avc_picture_packet.cpp
24 //! \brief Defines the interface for avc decode picture packet
25 //!
26 #include "decode_avc_picture_packet.h"
27 #include "codechal_debug.h"
28 #include "decode_common_feature_defs.h"
29 #include "decode_resource_auto_lock.h"
30
31 namespace decode
32 {
~AvcDecodePicPkt()33 AvcDecodePicPkt::~AvcDecodePicPkt()
34 {
35 FreeResources();
36 }
37
FreeResources()38 MOS_STATUS AvcDecodePicPkt::FreeResources()
39 {
40 DECODE_FUNC_CALL();
41
42 if (m_allocator != nullptr)
43 {
44 m_allocator->Destroy(m_resMfdDeblockingFilterRowStoreScratchBuffer);
45 if (!m_mfxItf->IsBsdMpcRowstoreCacheEnabled())
46 {
47 m_allocator->Destroy(m_resBsdMpcRowStoreScratchBuffer);
48 }
49 if (!m_mfxItf->IsIntraRowstoreCacheEnabled())
50 {
51 m_allocator->Destroy(m_resMfdIntraRowStoreScratchBuffer);
52 }
53 if (!m_mfxItf->IsMprRowstoreCacheEnabled())
54 {
55 m_allocator->Destroy(m_resMprRowStoreScratchBuffer);
56 }
57 }
58
59 return MOS_STATUS_SUCCESS;
60 }
61
Init()62 MOS_STATUS AvcDecodePicPkt::Init()
63 {
64 DECODE_FUNC_CALL();
65
66 DECODE_CHK_NULL(m_featureManager);
67 DECODE_CHK_NULL(m_hwInterface);
68 DECODE_CHK_NULL(m_osInterface);
69 DECODE_CHK_NULL(m_miItf);
70 DECODE_CHK_NULL(m_avcPipeline);
71 DECODE_CHK_NULL(m_mfxItf);
72
73 m_avcBasicFeature = dynamic_cast<AvcBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
74 DECODE_CHK_NULL(m_avcBasicFeature);
75
76 #ifdef _DECODE_PROCESSING_SUPPORTED
77 m_downSamplingFeature = dynamic_cast<DecodeDownSamplingFeature *>(m_featureManager->GetFeature(DecodeFeatureIDs::decodeDownSampling));
78 DecodeSubPacket *subPacket = m_avcPipeline->GetSubPacket(DecodePacketId(m_avcPipeline, downSamplingSubPacketId));
79 m_downSamplingPkt = dynamic_cast<DecodeDownSamplingPkt *>(subPacket);
80 #endif
81 m_allocator = m_pipeline->GetDecodeAllocator();
82 DECODE_CHK_NULL(m_allocator);
83
84 DECODE_CHK_STATUS(AllocateFixedResources());
85
86 return MOS_STATUS_SUCCESS;
87 }
88
Prepare()89 MOS_STATUS AvcDecodePicPkt::Prepare()
90 {
91 DECODE_FUNC_CALL();
92
93 m_avcPicParams = m_avcBasicFeature->m_avcPicParams;
94
95 #ifdef _MMC_SUPPORTED
96 m_mmcState = m_avcPipeline->GetMmcState();
97 DECODE_CHK_NULL(m_mmcState);
98 #endif
99
100 DECODE_CHK_STATUS(SetRowstoreCachingOffsets());
101
102 DECODE_CHK_STATUS(AllocateVariableResources());
103
104 return MOS_STATUS_SUCCESS;
105 }
106
SetRowstoreCachingOffsets()107 MOS_STATUS AvcDecodePicPkt::SetRowstoreCachingOffsets()
108 {
109 if (m_mfxItf->IsRowStoreCachingSupported())
110 {
111 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams;
112 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams));
113 rowstoreParams.dwPicWidth = m_avcBasicFeature->m_width;
114 rowstoreParams.bMbaff = m_avcPicParams->seq_fields.mb_adaptive_frame_field_flag;
115 rowstoreParams.Mode = CODECHAL_DECODE_MODE_AVCVLD;
116 rowstoreParams.bIsFrame = !m_avcPicParams->pic_fields.field_pic_flag;
117 DECODE_CHK_STATUS(m_mfxItf->GetRowstoreCachingAddrs(&rowstoreParams));
118 }
119
120 return MOS_STATUS_SUCCESS;
121 }
122
AllocateFixedResources()123 MOS_STATUS AvcDecodePicPkt::AllocateFixedResources()
124 {
125 DECODE_FUNC_CALL();
126
127 return MOS_STATUS_SUCCESS;
128 }
129
AllocateVariableResources()130 MOS_STATUS AvcDecodePicPkt::AllocateVariableResources()
131 {
132 DECODE_FUNC_CALL();
133
134 uint16_t picWidthInMB = MOS_MAX(m_picWidthInMbLastMaxAlloced, (m_avcPicParams->pic_width_in_mbs_minus1 + 1));
135 uint16_t picHeightInMB = MOS_MAX(m_picHeightInMbLastMaxAlloced, (m_avcPicParams->pic_height_in_mbs_minus1 + 1));
136 uint32_t numMacroblocks = picWidthInMB * picHeightInMB;
137
138 if (m_resMfdDeblockingFilterRowStoreScratchBuffer == nullptr)
139 {
140 m_resMfdDeblockingFilterRowStoreScratchBuffer = m_allocator->AllocateBuffer(
141 picWidthInMB * 4 * CODECHAL_CACHELINE_SIZE,
142 "DeblockingScratchBuffer",
143 resourceInternalReadWriteCache,
144 notLockableVideoMem);
145 DECODE_CHK_NULL(m_resMfdDeblockingFilterRowStoreScratchBuffer);
146 }
147 else
148 {
149 DECODE_CHK_STATUS(m_allocator->Resize(
150 m_resMfdDeblockingFilterRowStoreScratchBuffer,
151 picWidthInMB * 4 * CODECHAL_CACHELINE_SIZE,
152 notLockableVideoMem));
153 }
154
155 if (m_mfxItf->IsBsdMpcRowstoreCacheEnabled() == false)
156 {
157 if (m_resBsdMpcRowStoreScratchBuffer == nullptr)
158 {
159 m_resBsdMpcRowStoreScratchBuffer = m_allocator->AllocateBuffer(
160 picWidthInMB * 2 * CODECHAL_CACHELINE_SIZE,
161 "MpcScratchBuffer",
162 resourceInternalReadWriteCache,
163 notLockableVideoMem);
164 }
165 else
166 {
167 DECODE_CHK_STATUS(m_allocator->Resize(
168 m_resBsdMpcRowStoreScratchBuffer,
169 picWidthInMB * 2 * CODECHAL_CACHELINE_SIZE,
170 notLockableVideoMem));
171 }
172 }
173
174 if (m_mfxItf->IsIntraRowstoreCacheEnabled() == false)
175 {
176 if (m_resMfdIntraRowStoreScratchBuffer == nullptr)
177 {
178 m_resMfdIntraRowStoreScratchBuffer = m_allocator->AllocateBuffer(
179 picWidthInMB * CODECHAL_CACHELINE_SIZE,
180 "IntraScratchBuffer",
181 resourceInternalReadWriteCache,
182 notLockableVideoMem);
183 }
184 else
185 {
186 DECODE_CHK_STATUS(m_allocator->Resize(
187 m_resMfdIntraRowStoreScratchBuffer,
188 picWidthInMB * CODECHAL_CACHELINE_SIZE,
189 notLockableVideoMem));
190 }
191 }
192
193 if (m_mfxItf->IsMprRowstoreCacheEnabled() == false)
194 {
195 if (m_resMprRowStoreScratchBuffer == nullptr)
196 {
197 m_resMprRowStoreScratchBuffer = m_allocator->AllocateBuffer(
198 picWidthInMB * 2 * CODECHAL_CACHELINE_SIZE,
199 "MprScratchBuffer",
200 resourceInternalReadWriteCache,
201 notLockableVideoMem);
202 }
203 else
204 {
205 DECODE_CHK_STATUS(m_allocator->Resize(
206 m_resMprRowStoreScratchBuffer,
207 picWidthInMB * 2 * CODECHAL_CACHELINE_SIZE,
208 notLockableVideoMem));
209 }
210 }
211
212 //record the width and height used for allocation internal resources.
213 m_picWidthInMbLastMaxAlloced = picWidthInMB;
214 m_picHeightInMbLastMaxAlloced = picHeightInMB;
215
216 return MOS_STATUS_SUCCESS;
217 }
218
CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)219 MOS_STATUS AvcDecodePicPkt::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize)
220 {
221 DECODE_FUNC_CALL();
222
223 commandBufferSize = m_pictureStatesSize;
224 requestedPatchListSize = m_picturePatchListSize;
225
226 return MOS_STATUS_SUCCESS;
227 }
228
MHW_SETPAR_DECL_SRC(MFX_PIPE_MODE_SELECT,AvcDecodePicPkt)229 MHW_SETPAR_DECL_SRC(MFX_PIPE_MODE_SELECT, AvcDecodePicPkt)
230 {
231 params.Mode = CODECHAL_DECODE_MODE_AVCVLD;
232 params.deblockerStreamOutEnable = false;
233 params.streamOutEnable = m_avcBasicFeature->m_streamOutEnabled;
234 params.postDeblockingOutputEnablePostdeblockoutenable = m_avcBasicFeature->m_deblockingEnabled;
235 params.preDeblockingOutputEnablePredeblockoutenable = !m_avcBasicFeature->m_deblockingEnabled;
236 params.shortFormatInUse = m_avcBasicFeature->m_shortFormatInUse;
237 if (params.shortFormatInUse)//Short format Mode
238 {
239 params.decoderShortFormatMode = shortFormatMode;
240 }
241 if (!params.shortFormatInUse)//Long format Mode
242 {
243 params.decoderShortFormatMode = longFormatMode;
244 }
245
246 params.codecSelect = 0;
247 if (CodecHalIsDecodeModeVLD(params.Mode))
248 {
249 params.decoderModeSelect = 0;
250 }
251 else if (CodecHalIsDecodeModeIT(params.Mode))
252 {
253 params.decoderModeSelect = 1;
254 }
255 params.standardSelect = CodecHal_GetStandardFromMode(params.Mode);
256 return MOS_STATUS_SUCCESS;
257 }
258
MHW_SETPAR_DECL_SRC(MFX_SURFACE_STATE,AvcDecodePicPkt)259 MHW_SETPAR_DECL_SRC(MFX_SURFACE_STATE, AvcDecodePicPkt)
260 {
261 uint32_t uvPlaneAlignment = MHW_VDBOX_MFX_RECON_UV_PLANE_ALIGNMENT;
262 params.psSurface = &m_avcBasicFeature->m_destSurface;
263 params.tilemode = m_mfxItf->MosGetHWTileType(params.psSurface->TileType, params.psSurface->TileModeGMM, params.psSurface->bGMMTileEnabled);
264 params.height = params.psSurface->dwHeight - 1;
265 params.width = params.psSurface->dwWidth - 1;
266 params.surfacePitch = params.psSurface->dwPitch - 1;
267 if (params.surfaceId == CODECHAL_MFX_SRC_SURFACE_ID)
268 {
269 uvPlaneAlignment = MHW_VDBOX_MFX_RAW_UV_PLANE_ALIGNMENT_GEN9;
270 }
271 else if ((params.surfaceId == CODECHAL_MFX_REF_SURFACE_ID) || params.surfaceId == CODECHAL_MFX_DSRECON_SURFACE_ID)
272 {
273 uvPlaneAlignment = params.uvPlaneAlignment ? params.uvPlaneAlignment : MHW_VDBOX_MFX_RECON_UV_PLANE_ALIGNMENT;
274 }
275 else
276 {
277 uvPlaneAlignment = MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY;
278 }
279 params.surfaceFormat = SURFACE_FORMAT_PLANAR4208;
280 params.interleaveChroma = 1;
281
282 if (params.psSurface->Format == Format_P8)
283 {
284 params.interleaveChroma = 0;
285 }
286
287 params.yOffsetForUCb = MOS_ALIGN_CEIL((params.psSurface->UPlaneOffset.iSurfaceOffset - params.psSurface->dwOffset) /
288 params.psSurface->dwPitch + params.psSurface->RenderOffset.YUV.U.YOffset, uvPlaneAlignment);
289 params.yOffsetForVCr = MOS_ALIGN_CEIL((params.psSurface->VPlaneOffset.iSurfaceOffset - params.psSurface->dwOffset) /
290 params.psSurface->dwPitch + params.psSurface->RenderOffset.YUV.V.YOffset, uvPlaneAlignment);
291
292 #ifdef _MMC_SUPPORTED
293 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(&(m_avcBasicFeature->m_destSurface)));
294 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(params.psSurface, ¶ms.mmcState));
295 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(&m_avcBasicFeature->m_destSurface, ¶ms.compressionFormat));
296 #endif
297 return MOS_STATUS_SUCCESS;
298 }
299
MHW_SETPAR_DECL_SRC(MFX_PIPE_BUF_ADDR_STATE,AvcDecodePicPkt)300 MHW_SETPAR_DECL_SRC(MFX_PIPE_BUF_ADDR_STATE, AvcDecodePicPkt)
301 {
302 params.decodeInUse = true;
303 params.Mode = CODECHAL_DECODE_MODE_AVCVLD;
304 if (m_avcBasicFeature->m_deblockingEnabled)
305 {
306 params.psPostDeblockSurface = &(m_avcBasicFeature->m_destSurface);
307 }
308 else
309 {
310 params.psPreDeblockSurface = &(m_avcBasicFeature->m_destSurface);
311 }
312 params.presMfdIntraRowStoreScratchBuffer = &m_resMfdIntraRowStoreScratchBuffer->OsResource;
313 params.presMfdDeblockingFilterRowStoreScratchBuffer = &m_resMfdDeblockingFilterRowStoreScratchBuffer->OsResource;
314 if (m_avcBasicFeature->m_streamOutEnabled)
315 {
316 params.presStreamOutBuffer = m_avcBasicFeature->m_externalStreamOutBuffer;
317 }
318 AvcReferenceFrames & refFrames = m_avcBasicFeature->m_refFrames;
319 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_avcPicParams);
320 for (uint8_t i = 0; i < activeRefList.size(); i++)
321 {
322 uint8_t frameIdx = activeRefList[i];
323 uint8_t frameId = (m_avcBasicFeature->m_picIdRemappingInUse) ? i : refFrames.m_refList[frameIdx]->ucFrameId;
324 params.presReferences[frameId] = refFrames.GetReferenceByFrameIndex(frameIdx);
325
326 // Return error if reference surface's width or height is less than dest surface.
327 if (params.presReferences[frameId] != nullptr)
328 {
329 MOS_SURFACE refSurface;
330 refSurface.OsResource = *(params.presReferences[frameId]);
331 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface));
332 DECODE_CHK_COND(((refSurface.dwWidth < m_avcBasicFeature->m_destSurface.dwWidth)
333 || (refSurface.dwHeight < m_avcBasicFeature->m_destSurface.dwHeight)),
334 "Reference surface's width or height is less than Dest surface.");
335 }
336 }
337 DECODE_CHK_STATUS(FixMfxPipeBufAddrParams());
338 params.references = params.presReferences;
339 #ifdef _MMC_SUPPORTED
340 DECODE_CHK_STATUS(SetSurfaceMmcState());
341 #endif
342 return MOS_STATUS_SUCCESS;
343 }
344
FixMfxPipeBufAddrParams() const345 MOS_STATUS AvcDecodePicPkt::FixMfxPipeBufAddrParams() const
346 {
347 DECODE_FUNC_CALL();
348 auto & par = m_mfxItf->MHW_GETPAR_F(MFX_PIPE_BUF_ADDR_STATE)();
349 PMOS_RESOURCE validRefPic = nullptr;
350 PMOS_RESOURCE dummyRef = &(m_avcBasicFeature->m_dummyReference.OsResource);
351 if (m_avcBasicFeature->m_useDummyReference && !m_allocator->ResourceIsNull(dummyRef))
352 {
353 validRefPic = dummyRef;
354 }
355 else
356 {
357 validRefPic = m_avcBasicFeature->m_refFrames.GetValidReference();
358 if (validRefPic == nullptr)
359 {
360 validRefPic = &m_avcBasicFeature->m_destSurface.OsResource;
361 }
362 }
363
364 for (uint8_t i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
365 {
366 if (par.presReferences[i] == nullptr)
367 {
368 par.presReferences[i] = validRefPic;
369 }
370 }
371 return MOS_STATUS_SUCCESS;
372 }
MHW_SETPAR_DECL_SRC(MFX_IND_OBJ_BASE_ADDR_STATE,AvcDecodePicPkt)373 MHW_SETPAR_DECL_SRC(MFX_IND_OBJ_BASE_ADDR_STATE, AvcDecodePicPkt)
374 {
375 params.Mode = CODECHAL_DECODE_MODE_AVCVLD;
376 params.dwDataSize = m_avcBasicFeature->m_dataSize;
377 params.dwDataOffset = m_avcBasicFeature->m_dataOffset;
378 params.presDataBuffer = &(m_avcBasicFeature->m_resDataBuffer.OsResource);
379 return MOS_STATUS_SUCCESS;
380 }
381
MHW_SETPAR_DECL_SRC(MFX_BSP_BUF_BASE_ADDR_STATE,AvcDecodePicPkt)382 MHW_SETPAR_DECL_SRC(MFX_BSP_BUF_BASE_ADDR_STATE, AvcDecodePicPkt)
383 {
384 params.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer->OsResource;
385 params.presMprRowStoreScratchBuffer = &m_resMprRowStoreScratchBuffer->OsResource;
386 return MOS_STATUS_SUCCESS;
387 }
388
MHW_SETPAR_DECL_SRC(MFX_AVC_IMG_STATE,AvcDecodePicPkt)389 MHW_SETPAR_DECL_SRC(MFX_AVC_IMG_STATE, AvcDecodePicPkt)
390 {
391 params.decodeInUse = true;
392 params.avcPicParams = m_avcPicParams;
393 params.mvcExtPicParams = m_avcBasicFeature->m_mvcExtPicParams;
394 params.vdencEnabled = false;
395
396 AvcReferenceFrames & refFrames = m_avcBasicFeature->m_refFrames;
397 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_avcPicParams);
398 uint8_t activeFrameCnt = activeRefList.size();
399 params.activeFrameCnt = activeFrameCnt;
400
401 params.numMBs =
402 (m_avcPicParams->pic_height_in_mbs_minus1 + 1) *
403 (m_avcPicParams->pic_width_in_mbs_minus1 + 1);
404 params.imgstructImageStructureImgStructure10 = ((m_avcPicParams->CurrPic.PicFlags == PICTURE_FRAME) ? 0 : (CodecHal_PictureIsTopField(m_avcPicParams->CurrPic) ? 1 : 3));
405 params.frameSize = params.numMBs;
406 params.frameHeight = m_avcPicParams->pic_height_in_mbs_minus1;
407 params.frameWidth = m_avcPicParams->pic_width_in_mbs_minus1;
408 params.secondChromaQpOffset = m_avcPicParams->second_chroma_qp_index_offset;
409 params.firstChromaQpOffset = m_avcPicParams->chroma_qp_index_offset;
410 params.weightedPredFlag = m_avcPicParams->pic_fields.weighted_pred_flag;
411 params.weightedBipredIdc = m_avcPicParams->pic_fields.weighted_bipred_idc;
412 params.chromaformatidc = m_avcPicParams->seq_fields.chroma_format_idc;
413 params.entropycodingflag = m_avcPicParams->pic_fields.entropy_coding_mode_flag;
414 params.imgdisposableflag = !m_avcPicParams->pic_fields.reference_pic_flag;
415 params.constrainedipredflag = m_avcPicParams->pic_fields.constrained_intra_pred_flag;
416 params.direct8X8Infflag = m_avcPicParams->seq_fields.direct_8x8_inference_flag;
417 params.transform8X8Flag = m_avcPicParams->pic_fields.transform_8x8_mode_flag;
418 params.framembonlyflag = m_avcPicParams->seq_fields.frame_mbs_only_flag;
419 params.mbaffflameflag = m_avcPicParams->seq_fields.mb_adaptive_frame_field_flag && !m_avcPicParams->pic_fields.field_pic_flag;
420 params.fieldpicflag = m_avcPicParams->pic_fields.field_pic_flag;
421 params.numberOfActiveReferencePicturesFromL0 = m_avcPicParams->num_ref_idx_l0_active_minus1 + 1;
422 params.numberOfActiveReferencePicturesFromL1 = m_avcPicParams->num_ref_idx_l1_active_minus1 + 1;
423 params.initialQpValue = m_avcPicParams->pic_init_qp_minus26;
424 params.log2MaxFrameNumMinus4 = m_avcPicParams->seq_fields.log2_max_frame_num_minus4;
425 params.log2MaxPicOrderCntLsbMinus4 = m_avcPicParams->seq_fields.log2_max_pic_order_cnt_lsb_minus4;
426 params.numSliceGroupsMinus1 = m_avcPicParams->num_slice_groups_minus1;
427 params.redundantPicCntPresentFlag = m_avcPicParams->pic_fields.redundant_pic_cnt_present_flag;
428 params.picOrderPresentFlag = m_avcPicParams->pic_fields.pic_order_present_flag;
429 params.sliceGroupMapType = m_avcPicParams->slice_group_map_type;
430 params.picOrderCntType = m_avcPicParams->seq_fields.pic_order_cnt_type;
431 params.deblockingFilterControlPresentFlag = m_avcPicParams->pic_fields.deblocking_filter_control_present_flag;
432 params.deltaPicOrderAlwaysZeroFlag = m_avcPicParams->seq_fields.delta_pic_order_always_zero_flag;
433 params.currPicFrameNum = m_avcPicParams->frame_num;
434 params.sliceGroupChangeRate = m_avcPicParams->slice_group_change_rate_minus1;
435 params.numberOfReferenceFrames = params.activeFrameCnt;
436 if (params.mvcExtPicParams)
437 {
438 params.currentFrameViewId = params.mvcExtPicParams->CurrViewID;
439 params.maxViewIdxl0 = params.mvcExtPicParams->NumInterViewRefsL0;
440 params.maxViewIdxl1 = params.mvcExtPicParams->NumInterViewRefsL1;
441 params.interViewOrderDisable = 0;
442 }
443 return MOS_STATUS_SUCCESS;
444 }
445
MHW_SETPAR_DECL_SRC(MFX_AVC_DIRECTMODE_STATE,AvcDecodePicPkt)446 MHW_SETPAR_DECL_SRC(MFX_AVC_DIRECTMODE_STATE, AvcDecodePicPkt)
447 {
448 AvcReferenceFrames &refFrames = m_avcBasicFeature->m_refFrames;
449 auto mvBuffers = &(m_avcBasicFeature->m_mvBuffers);
450 PMOS_BUFFER curMvBuffer = mvBuffers->GetCurBuffer();
451 DECODE_CHK_NULL(curMvBuffer);
452
453 params.resAvcDmvBuffers[0] = curMvBuffer->OsResource;
454 PMOS_BUFFER curAvailableBuffers = mvBuffers->GetAvailableBuffer();
455 DECODE_CHK_NULL(curAvailableBuffers);
456 params.resAvcDmvBuffers[CODEC_AVC_NUM_REF_DMV_BUFFERS] = curAvailableBuffers->OsResource;
457
458 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_avcPicParams);
459
460 for (uint8_t i = 0; i < activeRefList.size(); i++)
461 {
462 uint8_t frameIdx = activeRefList[i];
463 if (m_avcBasicFeature->m_secondField && activeRefList.size() > m_avcBasicFeature->m_avcPicParams->frame_num &&
464 (frameIdx == m_avcBasicFeature->m_curRenderPic.FrameIdx))
465 {
466 params.resAvcDmvBuffers[i + 1] = curMvBuffer->OsResource;
467 }
468 else
469 {
470 PMOS_BUFFER mvBuf = mvBuffers->GetBufferByFrameIndex(frameIdx);
471
472 // m_resAvcDmvBuffers[0] is used as current mv buffer itself.
473 if (mvBuf != nullptr)
474 {
475 params.resAvcDmvBuffers[i + 1] = mvBuf->OsResource;
476 }
477 else
478 {
479 PMOS_BUFFER curAvailableBuf = mvBuffers->GetAvailableBuffer();
480 DECODE_CHK_NULL(curAvailableBuf);
481 params.resAvcDmvBuffers[i + 1] = curAvailableBuf->OsResource;
482 }
483 }
484 refFrames.m_refList[frameIdx]->ucDMVIdx[0] = i + 1;
485 }
486 params.CurrPic = m_avcPicParams->CurrPic;
487 params.uiUsedForReferenceFlags = m_avcPicParams->UsedForReferenceFlags;
488 params.ucAvcDmvIdx = 0;
489 params.presAvcDmvBuffers = params.resAvcDmvBuffers;
490 params.pAvcPicIdx = &(refFrames.m_avcPicIdx[0]);
491 params.avcRefList = (void **)refFrames.m_refList;
492 params.bPicIdRemappingInUse = m_avcBasicFeature->m_picIdRemappingInUse;
493
494 CODECHAL_DEBUG_TOOL(DECODE_CHK_STATUS(DumpResources(curMvBuffer->size)));
495
496 return MOS_STATUS_SUCCESS;
497 }
498
MHW_SETPAR_DECL_SRC(MFD_AVC_DPB_STATE,AvcDecodePicPkt)499 MHW_SETPAR_DECL_SRC(MFD_AVC_DPB_STATE, AvcDecodePicPkt)
500 {
501 params.pAvcPicParams = m_avcPicParams;
502 params.pMvcExtPicParams = m_avcBasicFeature->m_mvcExtPicParams;
503 params.ppAvcRefList = &(m_avcBasicFeature->m_refFrames.m_refList[0]);
504 params.bPicIdRemappingInUse = m_avcBasicFeature->m_picIdRemappingInUse;
505 auto avcPicParams = params.pAvcPicParams;
506 auto currFrameIdx = avcPicParams->CurrPic.FrameIdx;
507 auto currAvcRefList = params.ppAvcRefList[currFrameIdx];
508
509 int16_t refFrameOrder[CODEC_MAX_NUM_REF_FRAME] = {0};
510 uint32_t usedForRef = 0;
511 uint16_t nonExistingFrameFlags = 0;
512 uint16_t longTermFrame = 0;
513
514 for (uint8_t i = 0; i < currAvcRefList->ucNumRef; i++)
515 {
516 auto picIdx = currAvcRefList->RefList[i].FrameIdx;
517 auto refAvcRefList = params.ppAvcRefList[picIdx];
518 bool longTermFrameFlag = (currAvcRefList->RefList[i].PicFlags == PICTURE_LONG_TERM_REFERENCE);
519
520 uint8_t frameID = params.bPicIdRemappingInUse ? i : refAvcRefList->ucFrameId;
521 int16_t frameNum = refAvcRefList->sFrameNumber;
522
523 refFrameOrder[frameID] = frameNum;
524 usedForRef |= (((currAvcRefList->uiUsedForReferenceFlags >> (i * 2)) & 3) << (frameID * 2));
525 nonExistingFrameFlags |= (((currAvcRefList->usNonExistingFrameFlags >> i) & 1) << frameID);
526 longTermFrame |= (((uint16_t)longTermFrameFlag) << frameID);
527 }
528 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
529 {
530 params.refFrameOrder[i] = refFrameOrder[i];
531 }
532
533 params.NonExistingframeFlag161Bit = nonExistingFrameFlags;
534 params.LongtermframeFlag161Bit = longTermFrame;
535 params.usedForRef = usedForRef;
536 return MOS_STATUS_SUCCESS;
537 }
538
MHW_SETPAR_DECL_SRC(MFD_AVC_PICID_STATE,AvcDecodePicPkt)539 MHW_SETPAR_DECL_SRC(MFD_AVC_PICID_STATE, AvcDecodePicPkt)
540 {
541 AvcReferenceFrames &refFrames = m_avcBasicFeature->m_refFrames;
542 params.bPicIdRemappingInUse = m_avcBasicFeature->m_picIdRemappingInUse;
543 params.pAvcPicIdx = &(refFrames.m_avcPicIdx[0]);
544 params.PictureidRemappingDisable = 1;
545 if (params.bPicIdRemappingInUse)
546 {
547 uint32_t j = 0;
548 params.PictureidRemappingDisable = 0;
549 for (auto i = 0; i < (CODEC_MAX_NUM_REF_FRAME / 2); i++)
550 {
551 params.Pictureidlist1616Bits[i] = -1;
552 if (params.pAvcPicIdx[j++].bValid)
553 {
554 params.Pictureidlist1616Bits[i] = (params.Pictureidlist1616Bits[i] & 0xffff0000) | (params.pAvcPicIdx[j - 1].ucPicIdx);
555 }
556 if (params.pAvcPicIdx[j++].bValid)
557 {
558 params.Pictureidlist1616Bits[i] = (params.Pictureidlist1616Bits[i] & 0x0000ffff) | (params.pAvcPicIdx[j - 1].ucPicIdx << 16);
559 }
560 }
561 }
562 else
563 {
564 for (auto i = 0; i < (CODEC_MAX_NUM_REF_FRAME / 2); i++)
565 {
566 params.Pictureidlist1616Bits[i] = 0;
567 }
568 }
569 return MOS_STATUS_SUCCESS;
570 }
571
572
AddAllCmds_MFX_QM_STATE(PMOS_COMMAND_BUFFER cmdBuffer)573 MOS_STATUS AvcDecodePicPkt::AddAllCmds_MFX_QM_STATE(PMOS_COMMAND_BUFFER cmdBuffer)
574 {
575 auto pAvcIqMatrix = (PMHW_VDBOX_AVC_QM_PARAMS)m_avcBasicFeature->m_avcIqMatrixParams;
576 MHW_MI_CHK_NULL(pAvcIqMatrix);
577 auto ¶ms = m_mfxItf->MHW_GETPAR_F(MFX_QM_STATE)();
578 params = {};
579
580 auto iqMatrix = pAvcIqMatrix;
581 uint8_t *qMatrix = (uint8_t *)params.quantizermatrix;
582
583 for (uint8_t i = 0; i < 16; i++)
584 {
585 params.quantizermatrix[i] = 0;
586 }
587
588 params.qmType = m_avcBasicFeature->avcQmIntra4x4;
589 for (auto i = 0; i < 3; i++)
590 {
591 for (auto ii = 0; ii < 16; ii++)
592 {
593 qMatrix[i * 16 + ii] = iqMatrix->List4x4[i][ii];
594 }
595 }
596 DECODE_CHK_STATUS(m_mfxItf->MHW_ADDCMD_F(MFX_QM_STATE)(cmdBuffer));
597
598 params.qmType = m_avcBasicFeature->avcQmInter4x4;
599 for (auto i = 3; i < 6; i++)
600 {
601 for (auto ii = 0; ii < 16; ii++)
602 {
603 qMatrix[(i - 3) * 16 + ii] = iqMatrix->List4x4[i][ii];
604 }
605 }
606 DECODE_CHK_STATUS(m_mfxItf->MHW_ADDCMD_F(MFX_QM_STATE)(cmdBuffer));
607
608 params.qmType = m_avcBasicFeature->avcQmIntra8x8;
609 for (auto ii = 0; ii < 64; ii++)
610 {
611 qMatrix[ii] = iqMatrix->List8x8[0][ii];
612 }
613 DECODE_CHK_STATUS(m_mfxItf->MHW_ADDCMD_F(MFX_QM_STATE)(cmdBuffer));
614
615 params.qmType = m_avcBasicFeature->avcQmInter8x8;
616 for (auto ii = 0; ii < 64; ii++)
617 {
618 qMatrix[ii] = iqMatrix->List8x8[1][ii];
619 }
620 DECODE_CHK_STATUS(m_mfxItf->MHW_ADDCMD_F(MFX_QM_STATE)(cmdBuffer));
621
622 return MOS_STATUS_SUCCESS;
623 }
624
625 #if USE_CODECHAL_DEBUG_TOOL
DumpResources(uint32_t mvBufferSize) const626 MOS_STATUS AvcDecodePicPkt::DumpResources(uint32_t mvBufferSize) const
627 {
628 DECODE_FUNC_CALL();
629
630 CodechalDebugInterface *debugInterface = m_avcPipeline->GetDebugInterface();
631
632 auto &par = m_mfxItf->MHW_GETPAR_F(MFX_PIPE_BUF_ADDR_STATE)();
633 auto &mvParam = m_mfxItf->MHW_GETPAR_F(MFX_AVC_DIRECTMODE_STATE)();
634
635 for (auto n = 0; n < CODEC_AVC_MAX_NUM_REF_FRAME; n++)
636 {
637 if (m_avcBasicFeature->m_refFrames.m_avcPicIdx[n].bValid)
638 {
639 MOS_SURFACE destSurface;
640 MOS_ZeroMemory(&destSurface, sizeof(MOS_SURFACE));
641 destSurface.OsResource = *(par.presReferences[n]);
642 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&destSurface));
643 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(n)) + "]";
644 DECODE_CHK_STATUS(debugInterface->DumpYUVSurface(
645 &destSurface,
646 CodechalDbgAttr::attrDecodeReferenceSurfaces,
647 refSurfName.c_str()));
648
649 std::string mvBufDumpName = "_DEC_Ref_MV_" + std::to_string(n);
650 DECODE_CHK_STATUS(debugInterface->DumpBuffer(
651 &mvParam.presAvcDmvBuffers[n+1],
652 CodechalDbgAttr::attrMvData,
653 mvBufDumpName.c_str(),
654 mvBufferSize));
655 }
656 }
657
658 DECODE_CHK_STATUS(debugInterface->DumpBuffer(
659 &mvParam.presAvcDmvBuffers[0],
660 CodechalDbgAttr::attrMvData,
661 "DEC_Cur_MV_",
662 mvBufferSize));
663
664 return MOS_STATUS_SUCCESS;
665 }
666 #endif
667
SetSurfaceMmcState() const668 MOS_STATUS AvcDecodePicPkt::SetSurfaceMmcState() const
669 {
670 DECODE_FUNC_CALL();
671 auto &par = m_mfxItf->MHW_GETPAR_F(MFX_PIPE_BUF_ADDR_STATE)();
672 if (m_mmcState->IsMmcEnabled())
673 {
674 if (m_avcBasicFeature->m_deblockingEnabled)
675 {
676 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(
677 &m_avcBasicFeature->m_destSurface,
678 &par.PostDeblockSurfMmcState));
679 }
680 else
681 {
682 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(
683 &m_avcBasicFeature->m_destSurface,
684 &par.PreDeblockSurfMmcState));
685 }
686 }
687 else
688 {
689 par.PreDeblockSurfMmcState = MOS_MEMCOMP_DISABLED;
690 par.PostDeblockSurfMmcState = MOS_MEMCOMP_DISABLED;
691 }
692
693 return MOS_STATUS_SUCCESS;
694 }
695
696 } // namespace decode
697