Debian Codegraph @

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

raw
1 /*
2 * Copyright (c) 2011-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 codechal_decode_avc.cpp
24 //! \brief This modules implements Render interface layer for AVC decoding to be used on all operating systems/DDIs, across CODECHAL components.
25 //!
26
27 #include "codechal_decoder.h"
28 #include "codechal_decode_avc.h"
29 #include "codechal_decode_sfc_avc.h"
30 #include "codechal_mmc_decode_avc.h"
31 #include "codechal_secure_decode_interface.h"
32 #include "hal_oca_interface.h"
33 #if USE_CODECHAL_DEBUG_TOOL
34 #include "codechal_debug.h"
35 #endif
36
37 //Check whether interview prediction is used through POC
38 #define CodecHalAVC_IsInterviewPred(currPic, currPoc, avcRefListIdx) ( ((avcRefListIdx)!=(currPic).FrameIdx) && \
39 (!CodecHal_PictureIsTopField(currPic) && (pAvcRefList[avcRefListIdx]->iFieldOrderCnt[1] == (currPoc)[1]) || \
40 !CodecHal_PictureIsBottomField(currPic) && (pAvcRefList[avcRefListIdx]->iFieldOrderCnt[0] == (currPoc)[0])) && \
41 ((currPic).FrameIdx != 0x7f) )
42
43 MOS_STATUS CodechalDecodeAvc::SendSlice(
44 PMHW_VDBOX_AVC_SLICE_STATE avcSliceState,
45 PMOS_COMMAND_BUFFER cmdBuffer)
46 {
47
48 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
49
50 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuffer);
51 CODECHAL_DECODE_CHK_NULL_RETURN(avcSliceState);
52 CODECHAL_DECODE_CHK_NULL_RETURN(avcSliceState->pAvcPicIdx);
53 CODECHAL_DECODE_CHK_NULL_RETURN(avcSliceState->pAvcPicParams);
54 CODECHAL_DECODE_CHK_NULL_RETURN(avcSliceState->pAvcSliceParams);
55
56 PCODEC_AVC_PIC_PARAMS avcPicParams = avcSliceState->pAvcPicParams;
57 PCODEC_AVC_SLICE_PARAMS slc = avcSliceState->pAvcSliceParams;
58
59 avcSliceState->ucDisableDeblockingFilterIdc = slc->disable_deblocking_filter_idc;
60 avcSliceState->ucSliceBetaOffsetDiv2 = slc->slice_beta_offset_div2;
61 avcSliceState->ucSliceAlphaC0OffsetDiv2 = slc->slice_alpha_c0_offset_div2;
62
63 if (avcSliceState->bShortFormatInUse)
64 {
65 // send slice address except last one
66 if (!avcSliceState->bLastSlice)
67 {
68 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdAvcSliceAddrCmd(
69 cmdBuffer,
70 avcSliceState));
71 }
72 }
73 else
74 {
75 MHW_VDBOX_AVC_REF_IDX_PARAMS refIdxParams;
76 MOS_ZeroMemory(&refIdxParams, sizeof(MHW_VDBOX_AVC_REF_IDX_PARAMS));
77
78 if (!m_mfxInterface->IsAvcISlice(slc->slice_type))
79 {
80 refIdxParams.CurrPic = avcPicParams->CurrPic;
81 refIdxParams.uiList = LIST_0;
82 refIdxParams.uiNumRefForList[LIST_0] = slc->num_ref_idx_l0_active_minus1 + 1;
83
84 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(
85 &refIdxParams.RefPicList,
86 sizeof(refIdxParams.RefPicList),
87 &slc->RefPicList,
88 sizeof(slc->RefPicList)),
89 "Failed to copy memory");
90
91 refIdxParams.pAvcPicIdx = avcSliceState->pAvcPicIdx;
92 refIdxParams.avcRefList = (void**)m_avcRefList;
93 refIdxParams.bIntelEntrypointInUse = avcSliceState->bIntelEntrypointInUse;
94 refIdxParams.bPicIdRemappingInUse = avcSliceState->bPicIdRemappingInUse;
95
96 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcRefIdx(cmdBuffer, nullptr, &refIdxParams));
97
98 MHW_VDBOX_AVC_WEIGHTOFFSET_PARAMS weightOffsetParams;
99
100 if (m_mfxInterface->IsAvcPSlice(slc->slice_type) &&
101 avcPicParams->pic_fields.weighted_pred_flag == 1)
102 {
103 weightOffsetParams.uiList = 0;
104 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(
105 &weightOffsetParams.Weights,
106 sizeof(weightOffsetParams.Weights),
107 &slc->Weights,
108 sizeof(slc->Weights)),
109 "Failed to copy memory");
110
111 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcWeightOffset(cmdBuffer, nullptr, &weightOffsetParams));
112 }
113
114 if (m_mfxInterface->IsAvcBSlice(slc->slice_type))
115 {
116 refIdxParams.uiList = LIST_1;
117 refIdxParams.uiNumRefForList[LIST_1] = slc->num_ref_idx_l1_active_minus1 + 1;
118 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcRefIdx(cmdBuffer, nullptr, &refIdxParams));
119
120 if (avcPicParams->pic_fields.weighted_bipred_idc == 1)
121 {
122 weightOffsetParams.uiList = 0;
123 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(
124 &weightOffsetParams.Weights,
125 sizeof(weightOffsetParams.Weights),
126 &slc->Weights,
127 sizeof(slc->Weights)),
128 "Failed to copy memory");
129
130 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcWeightOffset(cmdBuffer, nullptr, &weightOffsetParams));
131 weightOffsetParams.uiList = 1;
132 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcWeightOffset(cmdBuffer, nullptr, &weightOffsetParams));
133 }
134 }
135 }
136 else if (MEDIA_IS_WA(m_waTable, WaDummyReference) && !m_osInterface->bSimIsActive)
137 {
138 MHW_VDBOX_AVC_REF_IDX_PARAMS refIdxParams;
139 MOS_ZeroMemory(&refIdxParams, sizeof(MHW_VDBOX_AVC_REF_IDX_PARAMS));
140 refIdxParams.bDummyReference = true;
141 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcRefIdx(cmdBuffer, nullptr, &refIdxParams));
142 }
143
144 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcSlice(cmdBuffer, nullptr, avcSliceState));
145 }
146
147 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdAvcBsdObjectCmd(
148 cmdBuffer,
149 avcSliceState));
150
151 return eStatus;
152 }
153
154 MOS_STATUS CodechalDecodeAvc::FormatAvcMonoPicture(PMOS_SURFACE surface)
155 {
156 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
157
158 PCODEC_AVC_PIC_PARAMS picParams = (PCODEC_AVC_PIC_PARAMS)m_avcPicParams;
159 if (picParams->seq_fields.chroma_format_idc != avcChromaFormatMono)
160 {
161 return MOS_STATUS_SUCCESS;
162 }
163
164 MOS_SURFACE dstSurface;
165 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
166 dstSurface.Format = Format_NV12;
167 if(surface != nullptr && !Mos_ResourceIsNull(&surface->OsResource))
168 {
169 dstSurface.OsResource = surface->OsResource;
170 }
171 else
172 {
173 CODECHAL_DECODE_ASSERTMESSAGE("Surface pointer is NULL!");
174 return MOS_STATUS_INVALID_PARAMETER;
175 }
176 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(m_osInterface, &dstSurface));
177
178 uint32_t height = dstSurface.dwHeight;
179 uint32_t pitch = dstSurface.dwPitch;
180 uint32_t chromaHeight = height / 2;
181 uint32_t frameHeight = MOS_ALIGN_CEIL(height, 16);
182 uint32_t alignedFrameHeight = MOS_ALIGN_CEIL(frameHeight, MOS_YTILE_H_ALIGNMENT);
183 uint32_t alignedChromaHeight = MOS_ALIGN_CEIL(chromaHeight, MOS_YTILE_H_ALIGNMENT);
184 uint32_t frameSize = pitch * MOS_ALIGN_CEIL((frameHeight + chromaHeight), MOS_YTILE_H_ALIGNMENT);
185 uint32_t chromaBufSize = MOS_ALIGN_CEIL(pitch * alignedChromaHeight, MHW_PAGE_SIZE);
186
187 if (Mos_ResourceIsNull(&m_resMonoPictureChromaBuffer))
188 {
189 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
190 &m_resMonoPictureChromaBuffer,
191 chromaBufSize,
192 "MonoPictureChromaBuffer",
193 true,
194 CODECHAL_DECODE_AVC_MONOPIC_CHROMA_DEFAULT),
195 "Failed to allocate MonoPicture Chroma Buffer.");
196 }
197
198 MOS_COMMAND_BUFFER cmdBuffer;
199 CodechalHucStreamoutParams hucStreamOutParams;
200 if (!m_hwInterface->m_noHuC)
201 {
202 m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContextForWa);
203 m_osInterface->pfnResetOsStates(m_osInterface);
204
205 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
206
207 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, false));
208
209 // use huc stream out to do clear to clear copy
210
211 MOS_ZeroMemory(&hucStreamOutParams, sizeof(hucStreamOutParams));
212 hucStreamOutParams.dataBuffer = &m_resMonoPictureChromaBuffer;
213 hucStreamOutParams.streamOutObjectBuffer = &surface->OsResource;
214 }
215
216 uint32_t uvblockHeight = CODECHAL_MACROBLOCK_HEIGHT;
217 uint32_t uvrowSize = pitch * uvblockHeight * 2;
218
219 uint32_t dstOffset = 0, x = 0, uvsize = 0;
220 if (frameHeight % MOS_YTILE_H_ALIGNMENT)
221 {
222 dstOffset = LinearToYTiledAddress(x, frameHeight, pitch);
223
224 if (m_hwInterface->m_noHuC)
225 {
226 CodechalDataCopyParams dataCopyParams;
227 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
228 dataCopyParams.srcResource = &m_resMonoPictureChromaBuffer;
229 dataCopyParams.srcSize = uvrowSize;
230 dataCopyParams.srcOffset = 0;
231 dataCopyParams.dstResource = &surface->OsResource;
232 dataCopyParams.dstSize = frameSize;
233 dataCopyParams.dstOffset = dstOffset;
234
235 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams));
236 }
237 else
238 {
239 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
240 &cmdBuffer, // pCmdBuffer
241 &m_resMonoPictureChromaBuffer, // presSrc
242 &surface->OsResource, // presDst
243 uvrowSize, // u32CopyLength
244 0, // u32CopyInputOffset
245 dstOffset)); // u32CopyOutputOffset
246 }
247 }
248
249 dstOffset = dstSurface.UPlaneOffset.iSurfaceOffset;
250 uvsize = frameSize - pitch * alignedFrameHeight;
251
252 if (m_hwInterface->m_noHuC)
253 {
254 CodechalDataCopyParams dataCopyParams;
255 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
256 dataCopyParams.srcResource = &m_resMonoPictureChromaBuffer;
257 dataCopyParams.srcSize = uvsize;
258 dataCopyParams.srcOffset = 0;
259 dataCopyParams.dstResource = &surface->OsResource;
260 dataCopyParams.dstSize = frameSize;
261 dataCopyParams.dstOffset = dstOffset;
262
263 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams));
264 }
265 else
266 {
267 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
268 &cmdBuffer, // pCmdBuffer
269 &m_resMonoPictureChromaBuffer, // presSrc
270 &surface->OsResource, // presDst
271 uvsize, // u32CopyLength
272 0, // u32CopyInputOffset
273 dstOffset)); // u32CopyOutputOffset
274
275 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
276 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
277 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
278
279 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
280
281 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
282
283 MOS_SYNC_PARAMS syncParams;
284
285 syncParams = g_cInitSyncParams;
286 syncParams.GpuContext = m_videoContext;
287 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
288
289 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
290
291 syncParams = g_cInitSyncParams;
292 syncParams.GpuContext = m_videoContextForWa;
293 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
294
295 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
296
297 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
298
299 m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext);
300 }
301
302 return eStatus;
303 }
304
305 MOS_STATUS CodechalDecodeAvc::AllocateInvalidRefBuffer()
306 {
307 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
308
309 //AlloctateResource
310 if (Mos_ResourceIsNull(&m_resInvalidRefBuffer))
311 {
312 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(m_osInterface, &m_destSurface));
313
314 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
315
316 if(m_mmc != nullptr && m_mmc->IsMmcEnabled())
317 {
318 CODECHAL_DECODE_CHK_STATUS_RETURN(
319 m_osInterface->pfnGetMemoryCompressionMode(
320 m_osInterface,
321 &m_destSurface.OsResource,
322 &mmcMode));
323 }
324
325 MOS_SURFACE surface;
326 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateSurface(
327 &surface,
328 m_destSurface.dwPitch,
329 m_destSurface.dwHeight,
330 "InvalidRefBuffer",
331 Format_NV12,
332 mmcMode != MOS_MEMCOMP_DISABLED ? true : false),
333 "Failed to allocate invalid reference buffer.");
334 m_resInvalidRefBuffer = surface.OsResource;
335
336 // set all the pixels to 1<<(BitDepth-1) according to the AVC spec
337 CodechalResLock ResourceLock(m_osInterface, &m_resInvalidRefBuffer);
338 auto data = (uint8_t*)ResourceLock.Lock(CodechalResLock::writeOnly);
339 CODECHAL_DECODE_CHK_NULL_RETURN(data);
340
341 uint32_t size = m_destSurface.dwPitch * m_destSurface.dwHeight * 3 / 2;
342 MOS_FillMemory(data, size, CODECHAL_DECODE_AVC_INVALID_REFPIC_VALUE); //INVALID_REFPIC_VALUE = 1<<(8-1): Intel Graphic only support 8bit AVC output now.
343 }
344
345 return eStatus;
346 }
347
348 MOS_STATUS CodechalDecodeAvc::SetAndAllocateDmvBufferIndex(
349 PCODEC_AVC_DMV_LIST avcMVBufList,
350 bool usedForRef,
351 uint8_t frameIdx,
352 uint32_t avcDmvBufferSize,
353 uint8_t *dmvIdx,
354 MOS_RESOURCE *avcDmvBuffers)
355 {
356 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
357
358 CODECHAL_DECODE_CHK_NULL_RETURN(avcMVBufList);
359 CODECHAL_DECODE_CHK_NULL_RETURN(dmvIdx);
360 CODECHAL_DECODE_CHK_NULL_RETURN(avcDmvBuffers);
361
362 uint8_t index = 0;
363 if (usedForRef)
364 {
365 uint8_t i;
366 for (i = 0; i < CODEC_AVC_NUM_REF_DMV_BUFFERS; i++)
367 {
368 if (!avcMVBufList[i].bInUse)
369 {
370 index = i;
371 avcMVBufList[i].bInUse = true;
372 avcMVBufList[i].ucFrameId = frameIdx;
373 break;
374 }
375 }
376 if (i == CODEC_AVC_NUM_REF_DMV_BUFFERS)
377 {
378 // Should never happen, something must be wrong
379 CODECHAL_DECODE_ASSERTMESSAGE("No DMV Buffer found.");
380 eStatus = MOS_STATUS_INVALID_PARAMETER;
381 return eStatus;
382 }
383 }
384 else
385 {
386 index = CODEC_AVC_NUM_REF_DMV_BUFFERS;
387 }
388
389 if (Mos_ResourceIsNull(&avcDmvBuffers[index]))
390 {
391 // Allocate DMV buffer if it has not been allocated already.
392 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
393 &avcDmvBuffers[index],
394 avcDmvBufferSize,
395 "MvBuffer",
396 true),
397 "Failed to allocate MV Buffer.");
398 }
399
400 *dmvIdx = index;
401 return eStatus;
402 }
403
404
405 MOS_STATUS CodechalDecodeAvc::SetAndAllocateDmvBufferIndexMismatched(
406 uint8_t frameIdx,
407 uint32_t avcDmvBufferSize,
408 uint8_t *dmvIdx,
409 MOS_RESOURCE *avcDmvBuffers)
410 {
411 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
412
413 CODECHAL_DECODE_CHK_NULL_RETURN(dmvIdx);
414 CODECHAL_DECODE_CHK_NULL_RETURN(avcDmvBuffers);
415
416 uint8_t index = frameIdx;
417
418 if (Mos_ResourceIsNull(&avcDmvBuffers[index]))
419 {
420 // Allocate DMV buffer if it has not been allocated already.
421 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
422 &avcDmvBuffers[index],
423 avcDmvBufferSize,
424 "MvBuffer",
425 true),
426 "Failed to allocate MV Buffer.");
427 }
428
429 *dmvIdx = index;
430 return eStatus;
431 }
432
433 MOS_STATUS CodechalDecodeAvc::InitMvcDummyDmvBuffer(
434 uint32_t *mvcWaDummyDmvBuf,
435 uint32_t size,
436 PMOS_RESOURCE mvcDummyDmvBuffer)
437 {
438 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
439
440 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
441 mvcDummyDmvBuffer,
442 size,
443 "MvBuffer"),
444 "Failed to allocate WA Mvc Dummy DMV Buffer.");
445
446 uint8_t *dummyDmvBuffer = nullptr, *mbDmvBuffer = nullptr;
447 CODECHAL_DECODE_CHK_NULL_RETURN(dummyDmvBuffer = (uint8_t*)MOS_AllocAndZeroMemory(size));
448 mbDmvBuffer = dummyDmvBuffer;
449
450 uint32_t i, numMBs = size / 64;
451 for (i = 0; i<numMBs; i++)
452 {
453 eStatus = (MOS_STATUS)MOS_SecureMemcpy(mbDmvBuffer, 64, mvcWaDummyDmvBuf, 64);
454 if (eStatus != MOS_STATUS_SUCCESS)
455 {
456 MOS_SafeFreeMemory(dummyDmvBuffer);
457 CODECHAL_DECODE_CHK_STATUS_RETURN(eStatus);
458 }
459 mbDmvBuffer += 64;
460 }
461
462 CodechalResLock ResourceLock(m_osInterface, mvcDummyDmvBuffer);
463 auto data = (uint8_t*)ResourceLock.Lock(CodechalResLock::writeOnly);
464
465 if (data == nullptr)
466 {
467 MOS_FreeMemory(dummyDmvBuffer);
468 CODECHAL_DECODE_CHK_NULL_RETURN(nullptr);
469 }
470
471 eStatus = (MOS_STATUS)MOS_SecureMemcpy(data, size, (void*)dummyDmvBuffer, size);
472 if (eStatus != MOS_STATUS_SUCCESS)
473 {
474 MOS_SafeFreeMemory(dummyDmvBuffer);
475 CODECHAL_DECODE_CHK_STATUS_RETURN(eStatus);
476 }
477
478 MOS_FreeMemAndSetNull(dummyDmvBuffer);
479 return eStatus;
480 }
481
482 MOS_STATUS CodechalDecodeAvc::SetPictureStructs()
483 {
484 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
485
486 CODECHAL_DECODE_FUNCTION_ENTER;
487
488 PCODEC_AVC_PIC_PARAMS picParams = m_avcPicParams;
489 CODEC_PICTURE prevPic = m_currPic;
490 CODEC_PICTURE currPic = picParams->CurrPic;
491
492 uint8_t i, ii;
493 if (picParams->pic_fields.field_pic_flag)
494 {
495 // Note: The AVC criteria of second field following first field is not compatible with MVC.
496 // For MVC compatibility, a buffer of 16 frame indexes are used to store
497 // the consecutive first fiels of different views in the same Acess Unit.
498 ii = CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS;
499 // Find if the current field is a second field (no matching first field)
500 for (i = 0; i < CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS; i++)
501 {
502 if (m_firstFieldIdxList[i] == currPic.FrameIdx)
503 {
504 break;
505 }
506 // At the same time, find the first empty entrance to store the frame index.
507 // Used when the current field is a first field.
508 ii = (m_firstFieldIdxList[i] == CODECHAL_DECODE_AVC_INVALID_FRAME_IDX && ii == CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS) ? i : ii;
509 }
510
511 if ((prevPic.PicFlags != currPic.PicFlags) || (prevPic.FrameIdx != currPic.FrameIdx) || (currPic.PicFlags == PICTURE_INVALID))
512 {
513 if (i < CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS)
514 {
515 m_isSecondField = true;
516 m_firstFieldIdxList[i] = CODECHAL_DECODE_AVC_INVALID_FRAME_IDX;
517 while (i > 0) // Clear all smaller indexes in case there are missing fields.
518 {
519 m_firstFieldIdxList[--i] = CODECHAL_DECODE_AVC_INVALID_FRAME_IDX;
520 }
521 }
522 else
523 {
524 m_isSecondField = false;
525 if (ii == CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS)
526 {
527 ii = 0;
528 }
529 else
530 {
531 m_firstFieldIdxList[ii++] = currPic.FrameIdx;
532 }
533 // Clear all larger indexes in case there are missing fields.
534 while (ii < CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS)
535 {
536 m_firstFieldIdxList[ii++] = CODECHAL_DECODE_AVC_INVALID_FRAME_IDX;
537 }
538 }
539 }
540
541 m_height =
542 MOS_ALIGN_CEIL(m_height, MOS_YTILE_H_ALIGNMENT);
543 }
544 else
545 {
546 for (i = 0; i < CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS; i++)
547 {
548 m_firstFieldIdxList[i] = CODECHAL_DECODE_AVC_INVALID_FRAME_IDX;
549 }
550 m_isSecondField = false;
551 }
552
553 m_statusReportFeedbackNumber = picParams->StatusReportFeedbackNumber;
554 m_currPic = currPic;
555 m_avcRefList[currPic.FrameIdx]->RefPic = m_currPic;
556 m_avcRefList[currPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
557
558 // Override reference list with ref surface passed from DDI
559 uint8_t surfCount = 0;
560 uint8_t surfIndex = 0;
561 if (m_osInterface->pfnIsMismatchOrderProgrammingSupported())
562 {
563 while (surfIndex < CODEC_AVC_NUM_UNCOMPRESSED_SURFACE)
564 {
565 if (!Mos_ResourceIsNull(&m_refFrameSurface[surfIndex].OsResource))
566 {
567 m_avcRefList[surfIndex]->resRefPic = m_refFrameSurface[surfIndex].OsResource;
568 }
569 surfIndex++;
570 }
571 }
572 else
573 {
574 while (surfCount < m_refSurfaceNum && surfIndex < CODEC_AVC_NUM_UNCOMPRESSED_SURFACE)
575 {
576 if (!Mos_ResourceIsNull(&m_refFrameSurface[surfIndex].OsResource))
577 {
578 m_avcRefList[surfIndex]->resRefPic = m_refFrameSurface[surfIndex].OsResource;
579 surfCount++;
580 }
581 surfIndex++;
582 }
583 }
584
585 uint8_t index, duplicatedIdx;
586 for (i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
587 {
588 if (!CodecHal_PictureIsInvalid(picParams->RefFrameList[i]))
589 {
590 index = picParams->RefFrameList[i].FrameIdx;
591 m_avcRefList[index]->sFrameNumber = picParams->FrameNumList[i];
592 }
593 }
594
595 PCODEC_AVC_DMV_LIST avcMVBufList = &m_avcDmvList[0];
596 uint8_t dmvidx;
597 if (!CodecHal_PictureIsInvalid(prevPic))
598 {
599 for (i = 0; i < CODEC_AVC_NUM_REF_DMV_BUFFERS; i++)
600 {
601 avcMVBufList[i].bInUse = false;
602 }
603 for (i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
604 {
605 if (!CodecHal_PictureIsInvalid(picParams->RefFrameList[i]))
606 {
607 index = picParams->RefFrameList[i].FrameIdx;
608 avcMVBufList[m_avcRefList[index]->ucDMVIdx[0]].bInUse = true;
609 avcMVBufList[m_avcRefList[index]->ucDMVIdx[1]].bInUse = true;
610 }
611 }
612 }
613 else if (m_avcRefList[currPic.FrameIdx]->bUsedAsRef && !m_isSecondField)
614 {
615 dmvidx = m_avcRefList[currPic.FrameIdx]->ucFrameId;
616 if (m_avcFrameStoreId[dmvidx].reUse)
617 {
618 m_avcFrameStoreId[dmvidx].reUse = false;
619 }
620 else
621 {
622 m_avcFrameStoreId[dmvidx].inUse = false;
623 }
624
625 dmvidx = m_avcRefList[currPic.FrameIdx]->ucDMVIdx[0];
626 if (m_avcDmvList[dmvidx].bReUse)
627 {
628 m_avcDmvList[dmvidx].bReUse = false;
629 }
630 else
631 {
632 m_avcDmvList[dmvidx].bInUse = false;
633 }
634 dmvidx = m_avcRefList[currPic.FrameIdx]->ucDMVIdx[1];
635 if (m_avcDmvList[dmvidx].bReUse)
636 {
637 m_avcDmvList[dmvidx].bReUse = false;
638 }
639 else
640 {
641 m_avcDmvList[dmvidx].bInUse = false;
642 }
643 }
644
645 if (picParams->pic_fields.reference_pic_flag)
646 {
647 if (!m_isSecondField)
648 {
649 m_avcRefList[currPic.FrameIdx]->bUsedAsRef = true;
650 }
651 }
652 else
653 {
654 m_avcRefList[currPic.FrameIdx]->bUsedAsRef = false;
655 }
656
657 if (!m_isSecondField)
658 {
659 if (m_osInterface->pfnIsMismatchOrderProgrammingSupported())
660 {
661 for (i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
662 {
663 auto frameIdx = picParams->RefFrameList[i].FrameIdx;
664 if (frameIdx != CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC)
665 {
666 CODECHAL_DECODE_CHK_STATUS_RETURN(SetAndAllocateDmvBufferIndexMismatched(
667 frameIdx,
668 m_avcDmvBufferSize,
669 &m_avcMvBufferIndex,
670 m_resAvcDmvBuffers));
671 dmvidx = m_avcMvBufferIndex;
672 m_avcRefList[frameIdx]->ucDMVIdx[0] = dmvidx;
673 m_avcRefList[frameIdx]->ucDMVIdx[1] = dmvidx;
674 }
675 }
676 CODECHAL_DECODE_CHK_STATUS_RETURN(SetAndAllocateDmvBufferIndexMismatched(
677 currPic.FrameIdx,
678 m_avcDmvBufferSize,
679 &m_avcMvBufferIndex,
680 m_resAvcDmvBuffers));
681 dmvidx = m_avcMvBufferIndex;
682
683 //first and second field will use the same DMV buffer in field mode
684 m_avcRefList[currPic.FrameIdx]->ucDMVIdx[0] = dmvidx;
685 m_avcRefList[currPic.FrameIdx]->ucDMVIdx[1] = dmvidx;
686 }
687 else
688 {
689 CODECHAL_DECODE_CHK_STATUS_RETURN(SetAndAllocateDmvBufferIndex(
690 &m_avcDmvList[0],
691 (bool)picParams->pic_fields.reference_pic_flag,
692 currPic.FrameIdx,
693 m_avcDmvBufferSize,
694 &m_avcMvBufferIndex,
695 m_resAvcDmvBuffers));
696
697 dmvidx = m_avcMvBufferIndex;
698
699 //first and second field will use the same DMV buffer in field mode
700 m_avcRefList[currPic.FrameIdx]->ucDMVIdx[0] = dmvidx;
701 m_avcRefList[currPic.FrameIdx]->ucDMVIdx[1] = dmvidx;
702 }
703 }
704 else
705 {
706 dmvidx = m_avcRefList[currPic.FrameIdx]->ucDMVIdx[1];
707 m_avcMvBufferIndex = dmvidx;
708 }
709
710 m_avcDmvList[dmvidx].ucFrameId = currPic.FrameIdx;
711
712 for (i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
713 {
714 m_avcFrameStoreId[i].inUse = false;
715 }
716
717 PCODEC_PIC_ID picIdx = &m_avcPicIdx[0];
718 bool invalidRef = false;
719 for (i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
720 {
721 picIdx[i].bValid = false;
722 index = picParams->RefFrameList[i].FrameIdx;
723
724 if (!CodecHal_PictureIsInvalid(picParams->RefFrameList[i]))
725 {
726 if (Mos_ResourceIsNull(&(m_avcRefList[index]->resRefPic)))
727 {
728 // when I picture has invalid reference pictures, reallocate resource for the referecnce pictures.
729 if (picParams->pic_fields.IntraPicFlag)
730 {
731 eStatus = AllocateInvalidRefBuffer();
732 if (eStatus != MOS_STATUS_SUCCESS)
733 {
734 invalidRef = true;
735 CODECHAL_DECODE_ASSERTMESSAGE("Can not allocate Invalid Ref Buffer.");
736 continue;
737 }
738
739 m_avcRefList[index]->RefPic = picParams->RefFrameList[i];
740 m_avcRefList[index]->resRefPic = m_resInvalidRefBuffer;
741 m_avcRefList[index]->bUsedAsRef = true;
742 m_avcRefList[index]->ucDMVIdx[0] = m_avcRefList[currPic.FrameIdx]->ucDMVIdx[0];
743 m_avcRefList[index]->ucDMVIdx[1] = m_avcRefList[currPic.FrameIdx]->ucDMVIdx[1];
744 }
745 else
746 {
747 invalidRef = false;
748 CODECHAL_DECODE_ASSERTMESSAGE("Found Invalid Ref.");
749 continue;
750 }
751 }
752
753 duplicatedIdx = 0;
754 for (ii = 0; ii < i; ii++)
755 {
756 if (picIdx[ii].bValid && index == picParams->RefFrameList[ii].FrameIdx)
757 {
758 duplicatedIdx = 1;
759 break;
760 }
761 }
762 if (duplicatedIdx)
763 {
764 continue;
765 }
766
767 m_avcRefList[index]->RefPic.PicFlags =
768 CodecHal_CombinePictureFlags(m_avcRefList[index]->RefPic, picParams->RefFrameList[i]);
769 m_avcRefList[index]->iFieldOrderCnt[0] = picParams->FieldOrderCntList[i][0];
770 m_avcRefList[index]->iFieldOrderCnt[1] = picParams->FieldOrderCntList[i][1];
771
772 picIdx[i].bValid = true;
773 picIdx[i].ucPicIdx = index;
774
775 if (!CodecHal_PictureIsInvalid(prevPic) && !m_osInterface->pfnIsMismatchOrderProgrammingSupported())
776 {
777 for (ii = 0; ii < m_avcRefList[prevPic.FrameIdx]->ucNumRef; ii++)
778 {
779 if (index == m_avcRefList[prevPic.FrameIdx]->RefList[ii].FrameIdx)
780 {
781 if (m_avcRefList[index]->ucFrameId == 0x7f)
782 {
783 // Should never happen, something must be wrong
784 CODECHAL_DECODE_ASSERTMESSAGE("Invaid Ref Frame Id Found");
785 m_avcRefList[index]->ucFrameId = 0;
786 }
787 m_avcFrameStoreId[m_avcRefList[index]->ucFrameId].inUse = true;
788 break;
789 }
790 }
791 if (ii == m_avcRefList[prevPic.FrameIdx]->ucNumRef)
792 {
793 m_avcRefList[index]->ucFrameId = 0x7f;
794 }
795 }
796 else
797 {
798 m_avcDmvList[m_avcRefList[index]->ucDMVIdx[0]].ucFrameId =
799 m_avcDmvList[m_avcRefList[index]->ucDMVIdx[1]].ucFrameId =
800 m_avcRefList[index]->ucFrameId;
801 }
802 picIdx[i].ucDMVOffset[0] = m_avcRefList[index]->ucDMVIdx[0];
803 picIdx[i].ucDMVOffset[1] = m_avcRefList[index]->ucDMVIdx[1];
804 }
805 }
806
807 // Save the current RefList and corresponding reference frame flags
808 ii = 0;
809 uint16_t nonExistingFrameFlags = 0;
810 uint32_t usedForReferenceFlags = 0;
811 for (i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
812 {
813 if (picIdx[i].bValid)
814 {
815 m_avcRefList[currPic.FrameIdx]->RefList[ii] = picParams->RefFrameList[i];
816 nonExistingFrameFlags |= ((picParams->NonExistingFrameFlags >> i) & 1) << ii;
817 usedForReferenceFlags |= ((picParams->UsedForReferenceFlags >> (i * 2)) & 3) << (ii * 2);
818 ii++;
819 }
820 }
821 m_avcRefList[currPic.FrameIdx]->ucNumRef = ii;
822 m_avcRefList[currPic.FrameIdx]->usNonExistingFrameFlags = nonExistingFrameFlags;
823 m_avcRefList[currPic.FrameIdx]->uiUsedForReferenceFlags = usedForReferenceFlags;
824
825 if (m_osInterface->pfnIsMismatchOrderProgrammingSupported())
826 {
827 for (uint32_t ii = 0; ii < CODEC_AVC_NUM_UNCOMPRESSED_SURFACE; ii++)
828 {
829 m_avcRefList[ii]->ucFrameId = 0x7f;
830 }
831 }
832
833 SetFrameStoreIds(currPic.FrameIdx);
834
835 // Store CurrFieldOrderCnt
836 if (CodecHal_PictureIsBottomField(currPic))
837 {
838 m_avcRefList[currPic.FrameIdx]->iFieldOrderCnt[1] = picParams->CurrFieldOrderCnt[1];
839 }
840 else
841 {
842 m_avcRefList[currPic.FrameIdx]->iFieldOrderCnt[0] = picParams->CurrFieldOrderCnt[0];
843 if (CodecHal_PictureIsFrame(currPic))
844 {
845 m_avcRefList[currPic.FrameIdx]->iFieldOrderCnt[1] = picParams->CurrFieldOrderCnt[1];
846 }
847 }
848
849 //MVC related inter-view reference
850 m_avcRefList[currPic.FrameIdx]->bUsedAsInterViewRef = false;
851 if (m_mvcExtPicParams)
852 {
853 if (m_mvcExtPicParams->inter_view_flag)
854 {
855 m_avcRefList[currPic.FrameIdx]->bUsedAsInterViewRef = true;
856 }
857 }
858
859 if (invalidRef)
860 {
861 // There was an invalid reference, do not process the picture.
862 return MOS_STATUS_UNKNOWN;
863 }
864 else
865 {
866 return MOS_STATUS_SUCCESS;
867 }
868 }
869
870 MOS_STATUS CodechalDecodeAvc::AllocateResourcesVariableSizes()
871 {
872 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
873
874 CODECHAL_DECODE_FUNCTION_ENTER;
875
876 PCODEC_AVC_PIC_PARAMS picParam = m_avcPicParams;
877 uint32_t numMacroblocks, numSliceRecords;
878 uint16_t picWidthInMB, picHeightInMB;
879 bool invalidSliceNum = false;
880 picWidthInMB = MOS_MAX(m_picWidthInMbLastMaxAlloced, (picParam->pic_width_in_mbs_minus1 + 1));
881 picHeightInMB = MOS_MAX(m_picHeightInMbLastMaxAlloced, (picParam->pic_height_in_mbs_minus1 + 1));
882 numMacroblocks = picWidthInMB * picHeightInMB;
883
884 numSliceRecords = numMacroblocks;
885 if (m_numSlices > numMacroblocks)
886 {
887 invalidSliceNum = true;
888 numSliceRecords = m_numSlices;
889 }
890
891 if ((numSliceRecords > (uint32_t)m_picWidthInMbLastMaxAlloced * m_picHeightInMbLastMaxAlloced) ||
892 (m_vldSliceRecord == nullptr))
893 {
894 if (m_vldSliceRecord != nullptr)
895 {
896 MOS_FreeMemory(m_vldSliceRecord);
897 }
898 m_vldSliceRecord =
899 (PCODECHAL_VLD_SLICE_RECORD)MOS_AllocAndZeroMemory(numSliceRecords * sizeof(CODECHAL_VLD_SLICE_RECORD));
900 if (m_vldSliceRecord == nullptr)
901 {
902 CODECHAL_DECODE_ASSERTMESSAGE("Failed to allocate memory.");
903 eStatus = MOS_STATUS_NO_SPACE;
904 return eStatus;
905 }
906 }
907
908 if (invalidSliceNum == true)
909 {
910 for (uint32_t i = 0; i < numSliceRecords; i++)
911 {
912 m_vldSliceRecord[i].dwSkip = true;
913 }
914 }
915
916 if ((picWidthInMB > m_picWidthInMbLastMaxAlloced) ||
917 Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
918 {
919 if (!Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
920 {
921 m_osInterface->pfnFreeResource(
922 m_osInterface,
923 &m_resMfdDeblockingFilterRowStoreScratchBuffer);
924 }
925
926 // Deblocking Filter Row Store Scratch buffer
927 //(Num MacroBlock Width) * (Num Cachlines) * (Cachline size)
928 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
929 &m_resMfdDeblockingFilterRowStoreScratchBuffer,
930 picWidthInMB * 4 * CODECHAL_CACHELINE_SIZE,
931 "DeblockingScratchBuffer"),
932 "Failed to allocate Deblocking Filter Row Store Scratch Buffer.");
933 }
934
935 if (m_mfxInterface->IsBsdMpcRowstoreCacheEnabled() == false)
936 {
937 uint16_t tempBsdMpcRowStoreScratchBufferPicWidthInMB;
938 tempBsdMpcRowStoreScratchBufferPicWidthInMB = MOS_MAX(m_bsdMpcRowStoreScratchBufferPicWidthInMb, (picParam->pic_width_in_mbs_minus1 + 1));
939
940 if ((tempBsdMpcRowStoreScratchBufferPicWidthInMB > m_bsdMpcRowStoreScratchBufferPicWidthInMb) ||
941 Mos_ResourceIsNull(&m_resBsdMpcRowStoreScratchBuffer))
942 {
943 if (!Mos_ResourceIsNull(&m_resBsdMpcRowStoreScratchBuffer))
944 {
945 m_osInterface->pfnFreeResource(
946 m_osInterface,
947 &m_resBsdMpcRowStoreScratchBuffer);
948 }
949 // BSD/MPC Row Store Scratch buffer
950 // (FrameWidth in MB) * (2) * (CacheLine size per MB)
951 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
952 &m_resBsdMpcRowStoreScratchBuffer,
953 tempBsdMpcRowStoreScratchBufferPicWidthInMB * 2 * CODECHAL_CACHELINE_SIZE,
954 "MpcScratchBuffer"),
955 "Failed to allocate BSD/MPC Row Store Scratch Buffer.");
956 }
957
958 //record the width and height used for allocation internal resources.
959 m_bsdMpcRowStoreScratchBufferPicWidthInMb = tempBsdMpcRowStoreScratchBufferPicWidthInMB;
960 }
961
962 if (m_mfxInterface->IsIntraRowstoreCacheEnabled() == false)
963 {
964 uint16_t tempMfdIntraRowStoreScratchBufferPicWidthInMB;
965 tempMfdIntraRowStoreScratchBufferPicWidthInMB = MOS_MAX(m_mfdIntraRowStoreScratchBufferPicWidthInMb, (picParam->pic_width_in_mbs_minus1 + 1));
966
967 if ((tempMfdIntraRowStoreScratchBufferPicWidthInMB > m_mfdIntraRowStoreScratchBufferPicWidthInMb) ||
968 Mos_ResourceIsNull(&m_resMfdIntraRowStoreScratchBuffer))
969 {
970 if (!Mos_ResourceIsNull(&m_resMfdIntraRowStoreScratchBuffer))
971 {
972 m_osInterface->pfnFreeResource(
973 m_osInterface,
974 &m_resMfdIntraRowStoreScratchBuffer);
975 }
976 // Intra Row Store Scratch buffer
977 // (FrameWidth in MB) * (CacheLine size per MB)
978 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
979 &m_resMfdIntraRowStoreScratchBuffer,
980 tempMfdIntraRowStoreScratchBufferPicWidthInMB * CODECHAL_CACHELINE_SIZE,
981 "IntraScratchBuffer"),
982 "Failed to allocate AVC BSD Intra Row Store Scratch Buffer.");
983 }
984
985 //record the width and height used for allocation internal resources.
986 m_mfdIntraRowStoreScratchBufferPicWidthInMb = tempMfdIntraRowStoreScratchBufferPicWidthInMB;
987 }
988
989 if (m_mfxInterface->IsMprRowstoreCacheEnabled() == false)
990 {
991 uint16_t tempMprRowStoreScratchBufferPicWidthInMB;
992 tempMprRowStoreScratchBufferPicWidthInMB = MOS_MAX(m_mprRowStoreScratchBufferPicWidthInMb, (picParam->pic_width_in_mbs_minus1 + 1));
993
994 if ((tempMprRowStoreScratchBufferPicWidthInMB > m_mprRowStoreScratchBufferPicWidthInMb) ||
995 Mos_ResourceIsNull(&m_resMprRowStoreScratchBuffer))
996 {
997 if (!Mos_ResourceIsNull(&m_resMprRowStoreScratchBuffer))
998 {
999 m_osInterface->pfnFreeResource(
1000 m_osInterface,
1001 &m_resMprRowStoreScratchBuffer);
1002 }
1003 // MPR Row Store Scratch buffer
1004 // (FrameWidth in MB) * (CacheLine size per MB) * 2
1005 // IVB+ platforms need to have double MPR size for MBAFF
1006 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
1007 &m_resMprRowStoreScratchBuffer,
1008 tempMprRowStoreScratchBufferPicWidthInMB * CODECHAL_CACHELINE_SIZE * 2,
1009 "MprScratchBuffer"),
1010 "Failed to allocate AVC BSD MPR Row Store Scratch Buffer.");
1011 }
1012
1013 //record the width and height used for allocation internal resources.
1014 m_mprRowStoreScratchBufferPicWidthInMb = tempMprRowStoreScratchBufferPicWidthInMB;
1015 }
1016
1017 uint32_t ctr;
1018 if ((picWidthInMB > m_picWidthInMbLastMaxAlloced) ||
1019 (picHeightInMB > m_picHeightInMbLastMaxAlloced) ||
1020 (m_avcDmvBufferSize == 0))
1021 {
1022 uint32_t maxMvBuf = m_osInterface->pfnIsMismatchOrderProgrammingSupported() ?
1023 CODEC_AVC_NUM_UNCOMPRESSED_SURFACE :
1024 CODEC_AVC_NUM_DMV_BUFFERS;
1025 for (ctr = 0; ctr < maxMvBuf; ctr++)
1026 {
1027 if (!Mos_ResourceIsNull(&m_resAvcDmvBuffers[ctr]))
1028 {
1029 m_osInterface->pfnFreeResource(
1030 m_osInterface,
1031 &m_resAvcDmvBuffers[ctr]);
1032 }
1033 }
1034
1035 // AVC MV buffer, 64 bytes per MB
1036 m_avcDmvBufferSize =
1037 64 * picWidthInMB * (uint32_t)(MOS_ALIGN_CEIL(picHeightInMB, 2));
1038
1039 for (ctr = 0; ctr < 4; ctr++)
1040 {
1041 // Allocate first 3 ref DMV buffers and then grow as needed, always
1042 // allocate the last DMV buffer which is used for non referenced pictures.
1043 if (ctr == 3)
1044 {
1045 ctr = CODEC_AVC_NUM_DMV_BUFFERS - 1;
1046 }
1047
1048 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
1049 &m_resAvcDmvBuffers[ctr],
1050 m_avcDmvBufferSize,
1051 "MvBuffer",
1052 true),
1053 "Failed to allocate Linux WA AVC BSD MV Buffer.");
1054 }
1055 }
1056
1057 if (m_secureDecoder)
1058 {
1059 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->AllocateResource(this));
1060 }
1061
1062 //record the width and height used for allocation internal resources.
1063 m_picWidthInMbLastMaxAlloced = picWidthInMB;
1064 m_picHeightInMbLastMaxAlloced = picHeightInMB;
1065
1066 return eStatus;
1067 }
1068
1069 MOS_STATUS CodechalDecodeAvc::AllocateResourcesFixedSizes()
1070 {
1071 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1072
1073 CODECHAL_DECODE_FUNCTION_ENTER;
1074
1075 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
1076 m_osInterface,
1077 &m_resSyncObjectWaContextInUse));
1078
1079 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
1080 m_osInterface,
1081 &m_resSyncObjectVideoContextInUse));
1082
1083 MOS_LOCK_PARAMS lockFlagsWriteOnly;
1084 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
1085 lockFlagsWriteOnly.WriteOnly = 1;
1086
1087 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalAllocateDataList(
1088 m_avcRefList,
1089 CODEC_AVC_NUM_UNCOMPRESSED_SURFACE));
1090
1091 m_currPic.PicFlags = PICTURE_INVALID;
1092 m_currPic.FrameIdx = CODEC_AVC_NUM_UNCOMPRESSED_SURFACE;
1093
1094 return eStatus;
1095 }
1096
1097 MOS_STATUS CodechalDecodeAvc::InitMmcState()
1098 {
1099 m_mmc = MOS_New(CodechalMmcDecodeAvc, m_hwInterface, this);
1100 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
1101
1102 return MOS_STATUS_SUCCESS;
1103 }
1104
1105 MOS_STATUS CodechalDecodeAvc::InitSfcState()
1106 {
1107 #ifdef _DECODE_PROCESSING_SUPPORTED
1108 m_sfcState = MOS_New(CodechalAvcSfcState);
1109 CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
1110 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
1111 this,
1112 m_hwInterface,
1113 m_osInterface));
1114 #endif
1115 return MOS_STATUS_SUCCESS;
1116 }
1117
1118 MOS_STATUS CodechalDecodeAvc::AllocateStandard(
1119 CodechalSetting *settings)
1120 {
1121 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1122
1123 CODECHAL_DECODE_FUNCTION_ENTER;
1124
1125 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
1126
1127 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
1128
1129 if (settings->downsamplingHinted)
1130 {
1131 bool isComputeContextEnabled = false;
1132 MOS_GPUCTX_CREATOPTIONS createOption;
1133
1134 #if (_DEBUG || _RELEASE_INTERNAL)
1135 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
1136 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1137 MOS_UserFeature_ReadValue_ID(
1138 nullptr,
1139 __MEDIA_USER_FEATURE_VALUE_DECODE_ENABLE_COMPUTE_CONTEXT_ID,
1140 &userFeatureData,
1141 m_osInterface->pOsContext);
1142 isComputeContextEnabled = (userFeatureData.u32Data) ? true : false;
1143 #endif
1144
1145 if (!MEDIA_IS_SKU(m_skuTable, FtrCCSNode))
1146 {
1147 isComputeContextEnabled = false;
1148 }
1149
1150 if (isComputeContextEnabled)
1151 {
1152 // Create Render Context for field scaling
1153 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
1154 m_osInterface,
1155 MOS_GPU_CONTEXT_COMPUTE,
1156 MOS_GPU_NODE_COMPUTE,
1157 &createOption));
1158 m_renderContext = MOS_GPU_CONTEXT_COMPUTE;
1159 }
1160 else
1161 {
1162 // Create Render Context for field scaling
1163 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
1164 m_osInterface,
1165 MOS_GPU_CONTEXT_RENDER,
1166 MOS_GPU_NODE_3D,
1167 &createOption));
1168 m_renderContext = MOS_GPU_CONTEXT_RENDER;
1169 }
1170 }
1171
1172 m_intelEntrypointInUse = (settings->intelEntrypointInUse) ? true : false;
1173 m_width = settings->width;
1174 m_height = settings->height;
1175 m_picWidthInMb = (uint16_t)CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_width);
1176 m_picHeightInMb = (uint16_t)CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_height);
1177 m_shortFormatInUse = (settings->shortFormatInUse) ? true : false;
1178
1179 CODECHAL_DECODE_CHK_STATUS_RETURN(InitSfcState());
1180
1181 for (uint8_t i = 0; i < CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS; i++)
1182 {
1183 m_firstFieldIdxList[i] = CODECHAL_DECODE_AVC_INVALID_FRAME_IDX;
1184 }
1185
1186 // Picture Level Commands
1187 m_hwInterface->GetMfxStateCommandsDataSize(
1188 CODECHAL_DECODE_MODE_AVCVLD,
1189 &m_commandBufferSizeNeeded,
1190 &m_commandPatchListSizeNeeded,
1191 m_shortFormatInUse);
1192
1193 // Slice Level Commands (cannot be placed in 2nd level batch)
1194 m_hwInterface->GetMfxPrimitiveCommandsDataSize(
1195 CODECHAL_DECODE_MODE_AVCVLD,
1196 &m_standardDecodeSizeNeeded,
1197 &m_standardDecodePatchListSizeNeeded,
1198 m_shortFormatInUse);
1199
1200 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesFixedSizes());
1201
1202 return eStatus;
1203 }
1204
1205 CodechalDecodeAvc::~CodechalDecodeAvc()
1206 {
1207 CODECHAL_DECODE_FUNCTION_ENTER;
1208
1209 CodecHalFreeDataList(m_avcRefList, CODEC_AVC_NUM_UNCOMPRESSED_SURFACE);
1210
1211 m_osInterface->pfnDestroySyncResource(
1212 m_osInterface,
1213 &m_resSyncObjectWaContextInUse);
1214
1215 m_osInterface->pfnDestroySyncResource(
1216 m_osInterface,
1217 &m_resSyncObjectVideoContextInUse);
1218
1219 MOS_FreeMemory(m_vldSliceRecord);
1220
1221 m_osInterface->pfnFreeResource(
1222 m_osInterface,
1223 &m_resMfdDeblockingFilterRowStoreScratchBuffer);
1224
1225 m_osInterface->pfnFreeResource(
1226 m_osInterface,
1227 &m_resBsdMpcRowStoreScratchBuffer);
1228
1229 m_osInterface->pfnFreeResource(
1230 m_osInterface,
1231 &m_resMfdIntraRowStoreScratchBuffer);
1232
1233 m_osInterface->pfnFreeResource(
1234 m_osInterface,
1235 &m_resMprRowStoreScratchBuffer);
1236
1237 if (!Mos_ResourceIsNull(&m_resMonoPictureChromaBuffer))
1238 {
1239 m_osInterface->pfnFreeResource(
1240 m_osInterface,
1241 &m_resMonoPictureChromaBuffer);
1242 }
1243
1244 uint32_t maxMvBuf = m_osInterface->pfnIsMismatchOrderProgrammingSupported() ?
1245 CODEC_AVC_NUM_UNCOMPRESSED_SURFACE :
1246 CODEC_AVC_NUM_DMV_BUFFERS;
1247 for (uint32_t ctr = 0; ctr < maxMvBuf; ctr++)
1248 {
1249 m_osInterface->pfnFreeResource(
1250 m_osInterface,
1251 &m_resAvcDmvBuffers[ctr]);
1252 }
1253
1254 if (!Mos_ResourceIsNull(&m_resInvalidRefBuffer))
1255 {
1256 m_osInterface->pfnFreeResource(
1257 m_osInterface,
1258 &m_resInvalidRefBuffer);
1259 }
1260
1261 #ifdef _DECODE_PROCESSING_SUPPORTED
1262 if (m_sfcState)
1263 {
1264 MOS_Delete(m_sfcState);
1265 m_sfcState = nullptr;
1266 }
1267 #endif
1268
1269 return;
1270 }
1271
1272 MOS_STATUS CodechalDecodeAvc::SetFrameStates()
1273 {
1274 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1275
1276 CODECHAL_DECODE_FUNCTION_ENTER;
1277
1278 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_destSurface);
1279
1280 m_dataSize = m_decodeParams.m_dataSize;
1281 m_dataOffset = m_decodeParams.m_dataOffset;
1282 m_numSlices = m_decodeParams.m_numSlices;
1283 m_avcPicParams = (PCODEC_AVC_PIC_PARAMS)m_decodeParams.m_picParams;
1284 m_mvcExtPicParams = (PCODEC_MVC_EXT_PIC_PARAMS)m_decodeParams.m_extPicParams;
1285 m_avcSliceParams = (PCODEC_AVC_SLICE_PARAMS)m_decodeParams.m_sliceParams;
1286 m_avcIqMatrixParams = (PCODEC_AVC_IQ_MATRIX_PARAMS)m_decodeParams.m_iqMatrixBuffer;
1287 m_destSurface = *(m_decodeParams.m_destSurface);
1288 m_refFrameSurface = m_decodeParams.m_refFrameSurface;
1289 m_refSurfaceNum = m_decodeParams.m_refSurfaceNum;
1290 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_dataBuffer);
1291 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
1292 m_picIdRemappingInUse = (m_decodeParams.m_picIdRemappingInUse) ? true : false;
1293
1294 m_cencBuf = m_decodeParams.m_cencBuf;
1295 m_fullFrameData = m_decodeParams.m_bFullFrameData;
1296
1297 CODECHAL_DECODE_CHK_NULL_RETURN(m_avcPicParams);
1298 CODECHAL_DECODE_CHK_NULL_RETURN(m_avcIqMatrixParams);
1299
1300 m_width = (m_avcPicParams->pic_width_in_mbs_minus1 + 1) * CODECHAL_MACROBLOCK_WIDTH;
1301 m_height = (m_avcPicParams->pic_height_in_mbs_minus1 + 1) * CODECHAL_MACROBLOCK_HEIGHT;
1302 m_deblockingEnabled = false;
1303
1304 if (m_shortFormatInUse)
1305 {
1306 // When HW parses the slice_header, disable_deblocking_filter_idc is not yet known,
1307 // so always enable ILDB in this case.
1308 m_deblockingEnabled = true;
1309 }
1310 else
1311 {
1312 for (uint32_t i = 0; i < m_numSlices; i++)
1313 {
1314 if (m_avcSliceParams[i].disable_deblocking_filter_idc != 1)
1315 {
1316 m_deblockingEnabled = true;
1317 break;
1318 }
1319 }
1320 }
1321
1322 if (m_mfxInterface->IsRowStoreCachingSupported())
1323 {
1324 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams;
1325 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams));
1326 rowstoreParams.Mode = CODECHAL_DECODE_MODE_AVCVLD;
1327 rowstoreParams.bMbaff = m_avcPicParams->seq_fields.mb_adaptive_frame_field_flag;
1328 rowstoreParams.bIsFrame = m_avcPicParams->seq_fields.frame_mbs_only_flag;
1329 rowstoreParams.dwPicWidth = m_width;
1330 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams));
1331 }
1332
1333 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesVariableSizes());
1334
1335 CODECHAL_DECODE_CHK_STATUS_RETURN(SetPictureStructs());
1336
1337 CODECHAL_DECODE_CHK_STATUS_RETURN(FormatAvcMonoPicture(m_decodeParams.m_destSurface));
1338
1339 if (m_avcPicParams->pic_fields.IntraPicFlag)
1340 {
1341 m_perfType = I_TYPE;
1342 }
1343 else
1344 {
1345 // Not possible to determine whether P or B is used for short format.
1346 // For long format iterating through all of the slices to determine P vs
1347 // B, so in order to avoid this, declare all other pictures MIXED_TYPE.
1348 m_perfType = MIXED_TYPE;
1349 }
1350 #ifdef _DECODE_PROCESSING_SUPPORTED
1351 auto decProcessingParams = (DecodeProcessingParams *)m_decodeParams.m_procParams;
1352 if (decProcessingParams != nullptr)
1353 {
1354 if (!decProcessingParams->m_isReferenceOnlyPattern && m_downsamplingHinted)
1355 {
1356 CODECHAL_DECODE_CHK_NULL_RETURN(m_fieldScalingInterface);
1357 }
1358
1359 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->CheckAndInitialize(
1360 decProcessingParams,
1361 m_avcPicParams,
1362 m_width,
1363 m_height,
1364 m_deblockingEnabled));
1365
1366 if (!((!CodecHal_PictureIsFrame(m_avcPicParams->CurrPic) ||
1367 m_avcPicParams->seq_fields.mb_adaptive_frame_field_flag) &&
1368 (m_downsamplingHinted && m_fieldScalingInterface->IsFieldScalingSupported(decProcessingParams))) &&
1369 m_sfcState->m_sfcPipeOut == false &&
1370 !decProcessingParams->m_isReferenceOnlyPattern)
1371 {
1372 m_vdSfcSupported = false;
1373 }
1374 else
1375 {
1376 m_vdSfcSupported = true;
1377 }
1378 }
1379 #endif
1380 m_crrPic = m_avcPicParams->CurrPic;
1381
1382 if(m_fullFieldsFrame == (PICTURE_BOTTOM_FIELD | PICTURE_TOP_FIELD))
1383 {
1384 m_fullFieldsFrame = 0;
1385 }
1386
1387 m_secondField = false;
1388
1389 if(CodecHal_PictureIsField(m_avcPicParams->CurrPic))
1390 {
1391 if(CodecHal_PictureIsTopField(m_avcPicParams->CurrPic))
1392 {
1393 m_fullFieldsFrame |= PICTURE_TOP_FIELD;
1394 }
1395 if (CodecHal_PictureIsBottomField(m_avcPicParams->CurrPic))
1396 {
1397 m_fullFieldsFrame |= PICTURE_BOTTOM_FIELD;
1398 }
1399 }
1400 else
1401 {
1402 m_fullFieldsFrame = 0;
1403 }
1404
1405 if(m_fullFieldsFrame == (PICTURE_BOTTOM_FIELD | PICTURE_TOP_FIELD))
1406 {
1407 m_secondField = true;
1408 }
1409
1410 if (m_pCodechalOcaDumper)
1411 {
1412 m_pCodechalOcaDumper->SetAvcDecodeParam(
1413 m_avcPicParams,
1414 m_avcSliceParams,
1415 m_numSlices);
1416 }
1417
1418 CODECHAL_DEBUG_TOOL(
1419 m_debugInterface->m_currPic = m_crrPic;
1420 m_debugInterface->m_secondField = m_secondField;
1421 m_debugInterface->m_frameType = m_perfType;
1422
1423 if (m_avcPicParams) {
1424 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(
1425 m_avcPicParams));
1426 }
1427
1428 if (m_avcIqMatrixParams) {
1429 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpIQParams(
1430 m_avcIqMatrixParams));
1431 }
1432
1433 if (m_mvcExtPicParams) {
1434 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpMvcExtPicParams(
1435 m_mvcExtPicParams));
1436 }
1437
1438 if (m_avcSliceParams) {
1439 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpSliceParams(
1440 m_avcSliceParams,
1441 m_numSlices));
1442 })
1443
1444 return eStatus;
1445 }
1446
1447 MOS_STATUS CodechalDecodeAvc::InitPicMhwParams(
1448 PIC_MHW_PARAMS *picMhwParams)
1449 {
1450 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1451
1452 CODECHAL_DECODE_FUNCTION_ENTER;
1453 PMOS_RESOURCE firstValidFrame = nullptr;
1454
1455 if (MEDIA_IS_WA(m_waTable, WaDummyReference) && !Mos_ResourceIsNull(&m_dummyReference.OsResource))
1456 {
1457 firstValidFrame = &m_dummyReference.OsResource;
1458 }
1459 else
1460 {
1461 firstValidFrame = &m_destSurface.OsResource;
1462 }
1463
1464 CODECHAL_DECODE_CHK_NULL_RETURN(picMhwParams);
1465
1466 picMhwParams->PipeModeSelectParams = {};
1467 picMhwParams->PipeBufAddrParams = {};
1468 picMhwParams->ImgParams = {};
1469 MOS_ZeroMemory(&picMhwParams->SurfaceParams,
1470 sizeof(picMhwParams->SurfaceParams));
1471 MOS_ZeroMemory(&picMhwParams->IndObjBaseAddrParams,
1472 sizeof(picMhwParams->IndObjBaseAddrParams));
1473 MOS_ZeroMemory(&picMhwParams->BspBufBaseAddrParams,
1474 sizeof(picMhwParams->BspBufBaseAddrParams));
1475 MOS_ZeroMemory(&picMhwParams->QmParams,
1476 sizeof(picMhwParams->QmParams));
1477 MOS_ZeroMemory(&picMhwParams->PicIdParams,
1478 sizeof(picMhwParams->PicIdParams));
1479 MOS_ZeroMemory(&picMhwParams->AvcDirectmodeParams,
1480 sizeof(picMhwParams->AvcDirectmodeParams));
1481
1482 picMhwParams->PipeModeSelectParams.Mode = CODECHAL_DECODE_MODE_AVCVLD;
1483 //enable decodestreamout if either app or codechal dump need it
1484 picMhwParams->PipeModeSelectParams.bStreamOutEnabled =
1485 m_decodeParams.m_streamOutEnabled || m_streamOutEnabled;
1486 picMhwParams->PipeModeSelectParams.bPostDeblockOutEnable = m_deblockingEnabled;
1487 picMhwParams->PipeModeSelectParams.bPreDeblockOutEnable = !m_deblockingEnabled;
1488 picMhwParams->PipeModeSelectParams.bShortFormatInUse = m_shortFormatInUse;
1489
1490 picMhwParams->SurfaceParams.Mode = CODECHAL_DECODE_MODE_AVCVLD;
1491 picMhwParams->SurfaceParams.psSurface = &m_destSurface;
1492
1493 picMhwParams->PipeBufAddrParams.Mode = CODECHAL_DECODE_MODE_AVCVLD;
1494 if (m_deblockingEnabled)
1495 {
1496 picMhwParams->PipeBufAddrParams.psPostDeblockSurface = &m_destSurface;
1497 }
1498 else
1499 {
1500 picMhwParams->PipeBufAddrParams.psPreDeblockSurface = &m_destSurface;
1501 }
1502
1503 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&picMhwParams->PipeBufAddrParams));
1504
1505 picMhwParams->PipeBufAddrParams.presMfdIntraRowStoreScratchBuffer =
1506 &m_resMfdIntraRowStoreScratchBuffer;
1507 picMhwParams->PipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer =
1508 &m_resMfdDeblockingFilterRowStoreScratchBuffer;
1509
1510 //Do not support export decode streamout to app buffer and codechal_dump simultenously
1511 //which can lead to extra memory copy
1512 //decode streamout to application
1513 if (m_decodeParams.m_streamOutEnabled)
1514 {
1515 picMhwParams->PipeBufAddrParams.presStreamOutBuffer = m_decodeParams.m_externalStreamOutBuffer;
1516 }
1517 //decode streamout to codechal_dump
1518 else if (m_streamOutEnabled)
1519 {
1520 picMhwParams->PipeBufAddrParams.presStreamOutBuffer =
1521 &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
1522
1523 CODECHAL_DEBUG_TOOL(
1524 // mark the buffer as in-use
1525 m_streamOutCurrStatusIdx[m_streamOutCurrBufIdx] = 0;
1526 )
1527 }
1528
1529 MOS_SURFACE dstSurface;
1530 uint8_t firstValidFrameId = CODEC_AVC_MAX_NUM_REF_FRAME;
1531 uint8_t activeFrameCnt = 0;
1532 uint8_t picIdx, frameId, i;
1533 MOS_ZeroMemory(m_presReferences, (sizeof(PMOS_RESOURCE) * CODEC_AVC_MAX_NUM_REF_FRAME));
1534 for (i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
1535 {
1536 if (m_avcPicIdx[i].bValid)
1537 {
1538 activeFrameCnt++;
1539 picIdx = m_avcPicIdx[i].ucPicIdx;
1540 frameId =
1541 (m_picIdRemappingInUse) ? i : m_avcRefList[picIdx]->ucFrameId;
1542
1543 m_presReferences[frameId] =
1544 &(m_avcRefList[picIdx]->resRefPic);
1545
1546 CODECHAL_DEBUG_TOOL(
1547 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
1548 dstSurface.Format = Format_NV12;
1549 dstSurface.OsResource = *(m_presReferences[frameId]);
1550 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
1551 m_osInterface,
1552 &dstSurface));
1553
1554 m_debugInterface->m_refIndex = frameId;
1555 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex)) + "]";
1556 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
1557 &dstSurface,
1558 CodechalDbgAttr::attrDecodeReferenceSurfaces,
1559 refSurfName.data()));)
1560
1561 if (frameId < firstValidFrameId)
1562 {
1563 firstValidFrameId = frameId;
1564 firstValidFrame = m_presReferences[frameId];
1565 }
1566 }
1567 }
1568
1569 for (i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
1570 {
1571 // error concealment for the unset reference addresses
1572 if (!m_presReferences[i])
1573 {
1574 m_presReferences[i] = firstValidFrame;
1575 }
1576 }
1577
1578 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(&picMhwParams->PipeBufAddrParams));
1579
1580 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));
1581
1582 CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(picMhwParams->PipeBufAddrParams.presReferences, sizeof(PMOS_RESOURCE) * CODEC_AVC_MAX_NUM_REF_FRAME, m_presReferences, sizeof(PMOS_RESOURCE) * CODEC_AVC_MAX_NUM_REF_FRAME));
1583
1584 picMhwParams->IndObjBaseAddrParams.Mode = CODECHAL_DECODE_MODE_AVCVLD;
1585 picMhwParams->IndObjBaseAddrParams.presDataBuffer = &m_resDataBuffer;
1586 picMhwParams->IndObjBaseAddrParams.dwDataSize = m_dataSize;
1587 picMhwParams->IndObjBaseAddrParams.dwDataOffset = m_dataOffset;
1588
1589 if (m_secureDecoder)
1590 {
1591 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->SetBitstreamBuffer(&picMhwParams->IndObjBaseAddrParams));
1592 }
1593
1594 picMhwParams->BspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer;
1595 picMhwParams->BspBufBaseAddrParams.presMprRowStoreScratchBuffer = &m_resMprRowStoreScratchBuffer;
1596
1597 picMhwParams->QmParams.Standard = CODECHAL_AVC;
1598 picMhwParams->QmParams.pAvcIqMatrix = (PMHW_VDBOX_AVC_QM_PARAMS)m_avcIqMatrixParams;
1599
1600 picMhwParams->PicIdParams.bPicIdRemappingInUse = m_picIdRemappingInUse;
1601 picMhwParams->PicIdParams.pAvcPicIdx = &(m_avcPicIdx[0]);
1602
1603 picMhwParams->ImgParams.pAvcPicParams = m_avcPicParams;
1604 picMhwParams->ImgParams.pMvcExtPicParams = m_mvcExtPicParams;
1605 picMhwParams->ImgParams.ucActiveFrameCnt = activeFrameCnt;
1606
1607 picMhwParams->AvcDirectmodeParams.CurrPic = m_currPic;
1608 picMhwParams->AvcDirectmodeParams.uiUsedForReferenceFlags = m_avcPicParams->UsedForReferenceFlags;
1609 picMhwParams->AvcDirectmodeParams.presAvcDmvBuffers = &(m_resAvcDmvBuffers[0]);
1610 picMhwParams->AvcDirectmodeParams.ucAvcDmvIdx = m_avcMvBufferIndex;
1611 picMhwParams->AvcDirectmodeParams.pAvcDmvList = &(m_avcDmvList[0]);
1612 picMhwParams->AvcDirectmodeParams.pAvcPicIdx = &(m_avcPicIdx[0]);
1613 picMhwParams->AvcDirectmodeParams.avcRefList = (void**)m_avcRefList;
1614 picMhwParams->AvcDirectmodeParams.bPicIdRemappingInUse = m_picIdRemappingInUse;
1615 picMhwParams->AvcDirectmodeParams.presMvcDummyDmvBuffer = &(m_resMvcDummyDmvBuffer[(m_avcPicParams->seq_fields.direct_8x8_inference_flag) ? 1 : 0]);
1616
1617 CODECHAL_DEBUG_TOOL(
1618
1619 CODEC_REF_LIST * *refList;
1620 MHW_MI_CHK_NULL(refList = (CODEC_REF_LIST **)picMhwParams->AvcDirectmodeParams.avcRefList);
1621
1622 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
1623 {
1624 if (picMhwParams->AvcDirectmodeParams.pAvcPicIdx[i].bValid)
1625 {
1626 uint8_t idx = picMhwParams->AvcDirectmodeParams.pAvcPicIdx[i].ucPicIdx;
1627 uint8_t picID = picMhwParams->AvcDirectmodeParams.bPicIdRemappingInUse ? i : refList[idx]->ucFrameId;
1628 uint8_t mvIdx = refList[idx]->ucDMVIdx[0];
1629
1630 // dump Reference mvdata
1631 std::string mvBufDumpName = "_DEC_Ref_MV_" + std::to_string(i);
1632 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1633 &picMhwParams->AvcDirectmodeParams.presAvcDmvBuffers[mvIdx],
1634 CodechalDbgAttr::attrMvData,
1635 mvBufDumpName.c_str(),
1636 m_avcDmvBufferSize));
1637 }
1638 }
1639
1640 // dump Current mvdata
1641 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1642 &picMhwParams->AvcDirectmodeParams.presAvcDmvBuffers[picMhwParams->AvcDirectmodeParams.ucAvcDmvIdx],
1643 CodechalDbgAttr::attrMvData,
1644 "DEC_Cur_MV_",
1645 m_avcDmvBufferSize));
1646 );
1647
1648 return eStatus;
1649 }
1650
1651 MOS_STATUS CodechalDecodeAvc::AddPictureCmds(
1652 PMOS_COMMAND_BUFFER cmdBuf,
1653 PIC_MHW_PARAMS *picMhwParams)
1654 {
1655 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1656
1657 CODECHAL_DECODE_FUNCTION_ENTER;
1658
1659 CODECHAL_DECODE_CHK_NULL_RETURN(cmdBuf);
1660 CODECHAL_DECODE_CHK_NULL_RETURN(picMhwParams);
1661
1662 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(cmdBuf, &picMhwParams->PipeModeSelectParams));
1663
1664 #ifdef _DECODE_PROCESSING_SUPPORTED
1665 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->AddSfcCommands(cmdBuf));
1666 #endif
1667
1668 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(cmdBuf, &picMhwParams->SurfaceParams));
1669
1670 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(cmdBuf, &picMhwParams->PipeBufAddrParams));
1671
1672 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(cmdBuf, &picMhwParams->IndObjBaseAddrParams));
1673
1674 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(cmdBuf, &picMhwParams->BspBufBaseAddrParams));
1675
1676 if (m_shortFormatInUse)
1677 {
1678 MHW_VDBOX_AVC_DPB_PARAMS dpbParams;
1679 MOS_ZeroMemory(&dpbParams, sizeof(dpbParams));
1680 dpbParams.pAvcPicParams = m_avcPicParams;
1681 dpbParams.pMvcExtPicParams = m_mvcExtPicParams;
1682 dpbParams.ppAvcRefList = &(m_avcRefList[0]);
1683 dpbParams.pAvcPicIdx = &(m_avcPicIdx[0]);
1684 dpbParams.bPicIdRemappingInUse = m_picIdRemappingInUse;
1685
1686 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdAvcDpbCmd(cmdBuf, &dpbParams));
1687 }
1688
1689 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdAvcPicidCmd(cmdBuf, &picMhwParams->PicIdParams));
1690
1691 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcImgCmd(cmdBuf, nullptr, &picMhwParams->ImgParams));
1692
1693 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxQmCmd(cmdBuf, &picMhwParams->QmParams));
1694
1695 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcDirectmodeCmd(cmdBuf, &picMhwParams->AvcDirectmodeParams));
1696
1697 return eStatus;
1698 }
1699
1700 MOS_STATUS CodechalDecodeAvc::DecodeStateLevel()
1701 {
1702 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1703
1704 CODECHAL_DECODE_FUNCTION_ENTER;
1705
1706 if (m_secureDecoder)
1707 {
1708 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->Execute(this));
1709 }
1710
1711 MOS_COMMAND_BUFFER cmdBuffer;
1712 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1713
1714 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1715 &cmdBuffer, true));
1716
1717 PIC_MHW_PARAMS picMhwParams;
1718 CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicMhwParams(&picMhwParams));
1719
1720 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
1721 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
1722
1723 if (m_cencBuf && m_cencBuf->checkStatusRequired)
1724 {
1725 CODECHAL_DECODE_COND_ASSERTMESSAGE((m_vdboxIndex > m_hwInterface->GetMfxInterface()->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
1726
1727 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetCpInterface()->CheckStatusReportNum(
1728 mmioRegisters,
1729 m_cencBuf->bufIdx,
1730 m_cencBuf->resStatus,
1731 &cmdBuffer));
1732 }
1733
1734 if (m_statusQueryReportingEnabled)
1735 {
1736 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer));
1737 }
1738
1739 CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureCmds(&cmdBuffer, &picMhwParams));
1740
1741 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1742
1743 return eStatus;
1744 }
1745
1746 MOS_STATUS CodechalDecodeAvc::ParseSlice(
1747 PMOS_COMMAND_BUFFER cmdBuf)
1748 {
1749 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1750 CODECHAL_DECODE_FUNCTION_ENTER;
1751
1752 PCODEC_AVC_SLICE_PARAMS slc = m_avcSliceParams;
1753 uint16_t frameInMbs = (m_avcPicParams->pic_height_in_mbs_minus1 + 1) * (m_avcPicParams->pic_width_in_mbs_minus1 + 1);
1754
1755 CODECHAL_DECODE_CHK_NULL_RETURN(m_vldSliceRecord);
1756 CODECHAL_DECODE_CHK_NULL_RETURN(slc);
1757
1758 // Setup static slice state parameters
1759 MHW_VDBOX_AVC_SLICE_STATE avcSliceState;
1760 MOS_ZeroMemory(&avcSliceState, sizeof(avcSliceState));
1761 avcSliceState.bIntelEntrypointInUse = m_intelEntrypointInUse;
1762 avcSliceState.bPicIdRemappingInUse = m_picIdRemappingInUse;
1763 avcSliceState.bShortFormatInUse = m_shortFormatInUse;
1764 avcSliceState.presDataBuffer = &m_resDataBuffer;
1765 avcSliceState.pAvcPicParams = m_avcPicParams;
1766 avcSliceState.pMvcExtPicParams = m_mvcExtPicParams;
1767 avcSliceState.pAvcPicIdx = &(m_avcPicIdx[0]);
1768 avcSliceState.bPhantomSlice = false;
1769 avcSliceState.dwTotalBytesConsumed = 0;
1770
1771 uint32_t length = 0, slcCount = 0;
1772 uint32_t offset = 0;
1773 uint32_t lastValidSlice = 0;
1774 bool firstValidSlice = true;
1775 bool invalidSlicePresent = false;
1776 for (slcCount = 0; slcCount < m_numSlices; slcCount++)
1777 {
1778
1779 if (invalidSlicePresent == true)
1780 {
1781 break;
1782 }
1783
1784 if (m_vldSliceRecord[slcCount].dwSkip)
1785 {
1786 continue;
1787 }
1788
1789 length = slc->slice_data_size;
1790
1791 if (slcCount < m_numSlices - 1)
1792 {
1793 // Skip remaining slices if the number of MBs already reaches the total before the last slice or slice overlap occurs.
1794 if ((!m_shortFormatInUse) &&
1795 ((slc->first_mb_in_slice + slc->NumMbsForSlice >= frameInMbs) ||
1796 ((slc + 1)->first_mb_in_slice <= slc->first_mb_in_slice)))
1797 {
1798 uint32_t count = slcCount + 1;
1799
1800 slc->first_mb_in_next_slice = 0;
1801 invalidSlicePresent = true;
1802
1803 while (count < m_numSlices)
1804 {
1805 m_vldSliceRecord[count++].dwSkip = true;
1806 }
1807 }
1808 else
1809 {
1810 slc->first_mb_in_next_slice = (slc + 1)->first_mb_in_slice;
1811 }
1812 }
1813 else
1814 {
1815 slc->first_mb_in_next_slice = 0;
1816 }
1817
1818 // error handling for garbage data
1819 if (((uint64_t)(slc->slice_data_offset) + length) > m_dataSize)
1820 {
1821 slc++;
1822 m_vldSliceRecord[slcCount].dwSkip = true;
1823 continue;
1824 }
1825
1826 if (!m_shortFormatInUse)
1827 {
1828 offset = (slc->slice_data_bit_offset >> 3) + m_osInterface->dwNumNalUnitBytesIncluded;
1829
1830 if (offset > length)
1831 {
1832 slc++;
1833 m_vldSliceRecord[slcCount].dwSkip = true;
1834 continue;
1835 }
1836
1837 // For first slice, first_mb_in_slice must be 0, otherwise it is corrupted
1838 // Skip slice when first_mb_in_slice is corrupted.
1839 if ((0 == slcCount && slc->first_mb_in_slice) ||
1840 (slc->first_mb_in_slice >= frameInMbs) ||
1841 (m_avcPicParams->seq_fields.mb_adaptive_frame_field_flag &&
1842 !m_avcPicParams->pic_fields.field_pic_flag &&
1843 (slc->first_mb_in_slice >= frameInMbs / 2)))
1844 {
1845 slc++;
1846 m_vldSliceRecord[slcCount].dwSkip = true;
1847 continue;
1848 }
1849
1850 if (firstValidSlice && slc->first_mb_in_slice)
1851 {
1852
1853 uint16_t usStartMbNum, usNextStartMbNum;
1854
1855 // ensure that slc->first_mb_in_next_slice is always non-zero for this phantom slice
1856
1857 usNextStartMbNum = slc->first_mb_in_next_slice;
1858 usStartMbNum = slc->first_mb_in_slice;
1859 slc->first_mb_in_slice = 0;
1860 slc->first_mb_in_next_slice = usStartMbNum;
1861
1862 avcSliceState.pAvcSliceParams = slc;
1863 avcSliceState.dwOffset = 0;
1864 avcSliceState.dwLength = slc->slice_data_offset;
1865 avcSliceState.dwNextOffset = slc->slice_data_offset;
1866 avcSliceState.dwNextLength = slc->slice_data_size;
1867
1868 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSlice(&avcSliceState, cmdBuf));
1869
1870 slc->first_mb_in_slice = usStartMbNum;
1871 slc->first_mb_in_next_slice = usNextStartMbNum;
1872 }
1873 }
1874
1875 firstValidSlice = false;
1876 lastValidSlice = slcCount;
1877 length -= offset;
1878 m_vldSliceRecord[slcCount].dwLength = length;
1879 m_vldSliceRecord[slcCount].dwOffset = offset;
1880 slc++;
1881 }
1882 slc = m_avcSliceParams;
1883
1884 uint32_t skippedSlc = 0;
1885 for (slcCount = 0; slcCount < m_numSlices; slcCount++)
1886 {
1887 if (m_vldSliceRecord[slcCount].dwSkip)
1888 {
1889 //For DECE clear bytes calculation: Total bytes in the bit-stream consumed so far
1890 avcSliceState.dwTotalBytesConsumed = slc->slice_data_offset + slc->slice_data_size;
1891
1892 slc++;
1893 skippedSlc++;
1894 continue;
1895 }
1896
1897 if (slcCount < lastValidSlice)
1898 {
1899 offset = (slc + 1)->slice_data_offset;
1900 length = (slc + 1)->slice_data_size;
1901 }
1902 avcSliceState.pAvcSliceParams = slc;
1903 avcSliceState.dwOffset = m_vldSliceRecord[slcCount].dwOffset;
1904 avcSliceState.dwLength = m_vldSliceRecord[slcCount].dwLength;
1905 avcSliceState.dwNextOffset = offset;
1906 avcSliceState.dwNextLength = length;
1907 avcSliceState.dwSliceIndex = slcCount;
1908 avcSliceState.bLastSlice = (slcCount == lastValidSlice);
1909 avcSliceState.bFullFrameData = m_fullFrameData;
1910
1911 CODECHAL_DECODE_CHK_STATUS_RETURN(SendSlice(&avcSliceState, cmdBuf));
1912
1913 //For DECE clear bytes calculation: Total bytes in the bit-stream consumed so far
1914 avcSliceState.dwTotalBytesConsumed = slc->slice_data_offset + slc->slice_data_size;
1915
1916 slc++;
1917 }
1918
1919 MOS_ZeroMemory(m_vldSliceRecord, (m_numSlices * sizeof(CODECHAL_VLD_SLICE_RECORD)));
1920
1921 return eStatus;
1922 }
1923
1924 MOS_STATUS CodechalDecodeAvc::DecodePrimitiveLevel()
1925 {
1926 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1927 CODECHAL_DECODE_FUNCTION_ENTER;
1928
1929 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
1930 CODECHAL_DECODE_CHK_NULL_RETURN(m_avcPicParams);
1931
1932 MOS_COMMAND_BUFFER cmdBuffer;
1933 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1934
1935 if (m_cencBuf)
1936 {
1937 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCencBatchBuffer(&cmdBuffer));
1938 }
1939 else
1940 {
1941 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseSlice(&cmdBuffer));
1942 }
1943
1944 // Check if destination surface needs to be synchronized
1945 MOS_SYNC_PARAMS syncParams;
1946 syncParams = g_cInitSyncParams;
1947 syncParams.GpuContext = m_videoContext;
1948 syncParams.presSyncResource = &m_destSurface.OsResource;
1949 syncParams.bReadOnly = false;
1950 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1951 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1952
1953 if (!CodecHal_PictureIsField(m_avcPicParams->CurrPic) ||
1954 !m_isSecondField)
1955 {
1956 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
1957 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
1958
1959 // Update the resource tag (s/w tag) for On-Demand Sync
1960 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1961 }
1962
1963 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1964 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1965
1966 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1967 &cmdBuffer,
1968 &flushDwParams));
1969
1970 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1971 if (m_osInterface->bTagResourceSync &&
1972 (!CodecHal_PictureIsField(m_avcPicParams->CurrPic) || m_isSecondField))
1973 {
1974 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
1975 }
1976
1977 if (m_statusQueryReportingEnabled)
1978 {
1979 CodechalDecodeStatusReport decodeStatusReport;
1980
1981 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
1982 decodeStatusReport.m_currDecodedPic = m_avcPicParams->CurrPic;
1983 decodeStatusReport.m_currDeblockedPic = m_avcPicParams->CurrPic;
1984 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
1985 decodeStatusReport.m_currDecodedPicRes = m_avcRefList[m_avcPicParams->CurrPic.FrameIdx]->resRefPic;
1986
1987 CODECHAL_DEBUG_TOOL(
1988 if (m_streamOutEnabled) {
1989 // add current streamout buffer to the report and move onto the next one
1990 decodeStatusReport.m_streamOutBuf = &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
1991 decodeStatusReport.m_streamoutIdx = m_streamOutCurrBufIdx;
1992 if (++m_streamOutCurrBufIdx >= CODECHAL_DECODE_NUM_STREAM_OUT_BUFFERS)
1993 {
1994 m_streamOutCurrBufIdx = 0;
1995 }
1996 // check next buffer in the list is free.
1997 if (m_streamOutCurrStatusIdx[m_streamOutCurrBufIdx] != CODECHAL_DECODE_STATUS_NUM)
1998 {
1999 // We've run out of buffers. Temporarily lock the next one down to force a wait. Then mark it as free.
2000 CodechalResLock ResourceLock(m_osInterface, &(m_streamOutBuffer[m_streamOutCurrBufIdx]));
2001 ResourceLock.Lock(CodechalResLock::readOnly);
2002
2003 m_streamOutCurrStatusIdx[m_streamOutCurrBufIdx] = CODECHAL_DECODE_STATUS_NUM;
2004 }
2005 }
2006
2007 decodeStatusReport.m_secondField = m_secondField;
2008 decodeStatusReport.m_frameType = m_perfType;)
2009
2010 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer));
2011 }
2012
2013 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
2014
2015 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2016
2017 bool syncCompleteFrame = (m_avcPicParams->seq_fields.chroma_format_idc == avcChromaFormatMono && !m_hwInterface->m_noHuC);
2018 if (syncCompleteFrame)
2019 {
2020 syncParams = g_cInitSyncParams;
2021 syncParams.GpuContext = m_videoContextForWa;
2022 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2023
2024 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
2025
2026 syncParams = g_cInitSyncParams;
2027 syncParams.GpuContext = m_videoContext;
2028 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
2029
2030 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
2031 }
2032
2033 CODECHAL_DEBUG_TOOL(
2034 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2035 &cmdBuffer,
2036 CODECHAL_NUM_MEDIA_STATES,
2037 "_DEC"));
2038
2039 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
2040 // m_debugInterface,
2041 // &cmdBuffer));
2042 )
2043
2044 HalOcaInterface::DumpCodechalParam(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, m_pCodechalOcaDumper, CODECHAL_AVC);
2045 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
2046
2047 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
2048
2049 CODECHAL_DEBUG_TOOL(
2050 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
2051
2052 #ifdef _DECODE_PROCESSING_SUPPORTED
2053 auto decProcessingParams = (DecodeProcessingParams *)m_decodeParams.m_procParams;
2054 if (decProcessingParams != nullptr && !m_sfcState->m_sfcPipeOut && (m_isSecondField || m_avcPicParams->seq_fields.mb_adaptive_frame_field_flag))
2055 {
2056 CODECHAL_DECODE_CHK_STATUS_RETURN(m_fieldScalingInterface->DoFieldScaling(
2057 decProcessingParams,
2058 m_renderContext,
2059 m_disableDecodeSyncLock,
2060 m_disableLockForTranscode));
2061 }
2062 else
2063 #endif
2064 {
2065 if (m_statusQueryReportingEnabled)
2066 {
2067 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw));
2068 }
2069 }
2070
2071 // Needs to be re-set for Linux buffer re-use scenarios
2072 m_avcRefList[m_avcPicParams->CurrPic.FrameIdx]->resRefPic =
2073 m_destSurface.OsResource;
2074
2075 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
2076 if (!CodecHal_PictureIsField(m_avcPicParams->CurrPic) || m_isSecondField)
2077 {
2078 syncParams = g_cInitSyncParams;
2079 syncParams.GpuContext = m_videoContext;
2080 syncParams.presSyncResource = &m_destSurface.OsResource;
2081
2082 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
2083 #ifdef _DECODE_PROCESSING_SUPPORTED
2084 if (decProcessingParams && !m_sfcState->m_sfcPipeOut)
2085 {
2086 syncParams = g_cInitSyncParams;
2087 syncParams.GpuContext = m_renderContext;
2088 syncParams.presSyncResource = &decProcessingParams->m_outputSurface->OsResource;
2089
2090 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
2091 }
2092 #endif
2093 }
2094 #ifdef _DECODE_PROCESSING_SUPPORTED
2095 CODECHAL_DEBUG_TOOL(
2096 // Dump out downsampling result
2097 if (decProcessingParams && decProcessingParams->m_outputSurface)
2098 {
2099 MOS_SURFACE dstSurface;
2100 MOS_ZeroMemory(&dstSurface, sizeof(dstSurface));
2101 dstSurface.Format = Format_NV12;
2102 dstSurface.OsResource = decProcessingParams->m_outputSurface->OsResource;
2103
2104 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
2105 m_osInterface,
2106 &dstSurface));
2107
2108 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
2109 &dstSurface,
2110 CodechalDbgAttr::attrSfcOutputSurface,
2111 "SfcDstSurf"));
2112 }
2113 )
2114 #endif
2115 return eStatus;
2116 }
2117
2118 MOS_STATUS CodechalDecodeAvc::CalcDownsamplingParams(
2119 void *picParams,
2120 uint32_t *refSurfWidth,
2121 uint32_t *refSurfHeight,
2122 MOS_FORMAT *format,
2123 uint8_t *frameIdx)
2124 {
2125 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2126
2127 CODECHAL_DECODE_CHK_NULL_RETURN(picParams);
2128 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfWidth);
2129 CODECHAL_DECODE_CHK_NULL_RETURN(refSurfHeight);
2130 CODECHAL_DECODE_CHK_NULL_RETURN(format);
2131 CODECHAL_DECODE_CHK_NULL_RETURN(frameIdx);
2132
2133 PCODEC_AVC_PIC_PARAMS avcPicParams = (PCODEC_AVC_PIC_PARAMS)picParams;
2134
2135 *refSurfWidth = 0;
2136 *refSurfHeight = 0;
2137 *format = Format_NV12;
2138 *frameIdx = avcPicParams->CurrPic.FrameIdx;
2139
2140 *refSurfWidth = (avcPicParams->pic_width_in_mbs_minus1 + 1) * CODECHAL_MACROBLOCK_WIDTH;
2141 *refSurfHeight = (avcPicParams->pic_height_in_mbs_minus1 + 1) * CODECHAL_MACROBLOCK_HEIGHT;
2142
2143
2144 return eStatus;
2145 }
2146
2147 CodechalDecodeAvc::CodechalDecodeAvc(
2148 CodechalHwInterface *hwInterface,
2149 CodechalDebugInterface* debugInterface,
2150 PCODECHAL_STANDARD_INFO standardInfo) :
2151 CodechalDecode(hwInterface, debugInterface, standardInfo)
2152 {
2153 m_mmc = nullptr;
2154 m_hwInterface = hwInterface;
2155 // Parameters passed by application
2156 m_picWidthInMb = 0;
2157 m_picHeightInMb = 0;
2158 m_picWidthInMbLastMaxAlloced = 0;
2159 m_picHeightInMbLastMaxAlloced = 0;
2160 m_intelEntrypointInUse = false;
2161 m_shortFormatInUse = false;
2162 m_picIdRemappingInUse = false;
2163 m_dataSize = 0;
2164 m_dataOffset = 0;
2165 m_numSlices = 0;
2166 m_refSurfaceNum = 0;
2167 m_avcPicParams = nullptr;
2168 m_mvcExtPicParams = nullptr;
2169 m_avcSliceParams = nullptr;
2170 m_avcIqMatrixParams = nullptr;
2171
2172 MOS_ZeroMemory(m_presReferences, (sizeof(PMOS_RESOURCE) * CODEC_AVC_MAX_NUM_REF_FRAME));
2173 MOS_ZeroMemory(&m_resDataBuffer, sizeof(MOS_RESOURCE));
2174 MOS_ZeroMemory(&m_resMonoPictureChromaBuffer, sizeof(MOS_RESOURCE));
2175 MOS_ZeroMemory(&m_resMfdIntraRowStoreScratchBuffer, sizeof(MOS_RESOURCE));
2176 MOS_ZeroMemory(&m_resMfdDeblockingFilterRowStoreScratchBuffer, sizeof(MOS_RESOURCE));
2177 MOS_ZeroMemory(&m_resBsdMpcRowStoreScratchBuffer, sizeof(MOS_RESOURCE));
2178 MOS_ZeroMemory(&m_resMprRowStoreScratchBuffer, sizeof(MOS_RESOURCE));
2179 MOS_ZeroMemory(&m_resAvcDmvBuffers, (sizeof(MOS_RESOURCE) * CODEC_AVC_NUM_UNCOMPRESSED_SURFACE));
2180 MOS_ZeroMemory(&m_resInvalidRefBuffer, sizeof(MOS_RESOURCE));
2181 MOS_ZeroMemory(&m_resMvcDummyDmvBuffer, (sizeof(MOS_RESOURCE) * 2));
2182 MOS_ZeroMemory(&m_destSurface, sizeof(MOS_SURFACE));
2183 MOS_ZeroMemory(&m_resSyncObjectWaContextInUse, sizeof(MOS_RESOURCE));
2184 MOS_ZeroMemory(&m_resSyncObjectVideoContextInUse, sizeof(MOS_RESOURCE));
2185 m_refFrameSurface = nullptr;
2186
2187 m_vldSliceRecord = nullptr;
2188
2189 m_bsdMpcRowStoreScratchBufferPicWidthInMb = 0;
2190 m_mfdIntraRowStoreScratchBufferPicWidthInMb = 0;
2191 m_mprRowStoreScratchBufferPicWidthInMb = 0;
2192
2193 MOS_ZeroMemory(m_firstFieldIdxList, (sizeof(uint8_t) * CODECHAL_DECODE_AVC_MAX_NUM_MVC_VIEWS));
2194
2195 m_isSecondField = false;
2196 m_deblockingEnabled = false;
2197
2198 // Decode process usage
2199 MOS_ZeroMemory(&m_currPic, sizeof(CODEC_PICTURE));
2200
2201 MOS_ZeroMemory(&m_avcFrameStoreId, (sizeof(CODEC_AVC_FRAME_STORE_ID) * CODEC_AVC_MAX_NUM_REF_FRAME));
2202
2203 m_avcMvBufferIndex = 0;
2204 MOS_ZeroMemory(&m_avcDmvList, (sizeof(CODEC_AVC_DMV_LIST) * CODEC_AVC_NUM_DMV_BUFFERS));
2205
2206 MOS_ZeroMemory(&m_avcPicIdx, (sizeof(CODEC_PIC_ID) * CODEC_AVC_MAX_NUM_REF_FRAME));
2207 MOS_ZeroMemory(m_avcRefList, (sizeof(PCODEC_REF_LIST) * CODEC_AVC_NUM_UNCOMPRESSED_SURFACE));
2208
2209 m_avcDmvBufferSize = 0;
2210
2211 //Currently, crc calculation is only supported in AVC decoder
2212 m_reportFrameCrc = true;
2213
2214 m_fullFrameData = false;
2215
2216 };
2217
2218 #if USE_CODECHAL_DEBUG_TOOL
2219 MOS_STATUS CodechalDecodeAvc::DumpMvcExtPicParams(
2220 PCODEC_MVC_EXT_PIC_PARAMS mvcExtPicParams)
2221 {
2222 CODECHAL_DEBUG_FUNCTION_ENTER;
2223
2224 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrMvcExtPicParams))
2225 {
2226 return MOS_STATUS_SUCCESS;
2227 }
2228 CODECHAL_DEBUG_CHK_NULL(mvcExtPicParams);
2229
2230 std::ostringstream oss;
2231 oss.setf(std::ios::showbase | std::ios::uppercase);
2232
2233 oss << "CurrViewID: " << std::hex << +mvcExtPicParams->CurrViewID << std::endl;
2234 oss << "anchor_pic_flag: " << +mvcExtPicParams->anchor_pic_flag << std::endl;
2235 oss << "inter_view_flag: " << +mvcExtPicParams->inter_view_flag << std::endl;
2236 oss << "NumInterViewRefsL0: " << +mvcExtPicParams->NumInterViewRefsL0 << std::endl;
2237 oss << "NumInterViewRefsL1: " << +mvcExtPicParams->NumInterViewRefsL1 << std::endl;
2238 oss << "bPicFlags: " << +mvcExtPicParams->bPicFlags << std::endl;
2239 oss << "SwitchToAVC: " << +mvcExtPicParams->SwitchToAVC << std::endl;
2240 oss << "Reserved7Bits: " << +mvcExtPicParams->Reserved7Bits << std::endl;
2241 oss << "Reserved8Bits: " << +mvcExtPicParams->Reserved8Bits << std::endl;
2242
2243 //Dump ViewIDList[16]
2244 for (uint8_t i = 0; i < 16; ++i)
2245 {
2246 oss << "ViewIDList[" << +i << "]: "
2247 << +mvcExtPicParams->ViewIDList[i] << std::endl;
2248 }
2249
2250 //Dump InterViewRefList[2][16]
2251 for (uint8_t i = 0; i < 16; ++i)
2252 {
2253 oss << "InterViewRefList[0][" << +i << "]: "
2254 << +mvcExtPicParams->InterViewRefList[0][i] << std::endl;
2255 oss << "InterViewRefList[1][" << +i << "]: "
2256 << +mvcExtPicParams->InterViewRefList[1][i] << std::endl;
2257 }
2258
2259 const char *fileName = m_debugInterface->CreateFileName(
2260 "_DEC",
2261 CodechalDbgBufferType::bufMvcPicParams,
2262 CodechalDbgExtType::txt);
2263
2264 std::ofstream ofs(fileName, std::ios::out);
2265 ofs << oss.str();
2266 ofs.close();
2267
2268 return MOS_STATUS_SUCCESS;
2269 }
2270
2271 MOS_STATUS CodechalDecodeAvc::DumpPicParams(
2272 PCODEC_AVC_PIC_PARAMS picParams)
2273 {
2274 CODECHAL_DEBUG_FUNCTION_ENTER;
2275
2276 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
2277 {
2278 return MOS_STATUS_SUCCESS;
2279 }
2280
2281 CODECHAL_DEBUG_CHK_NULL(picParams);
2282
2283 std::ostringstream oss;
2284 oss.setf(std::ios::showbase | std::ios::uppercase);
2285
2286 oss << "CurrPic FrameIdx: " << std::dec << +picParams->CurrPic.FrameIdx << std::endl;
2287 oss << "CurrPic PicFlags: " << std::hex << +picParams->CurrPic.PicFlags << std::endl;
2288
2289 //Dump RefFrameList[15]
2290 for (uint8_t i = 0; i < 15; ++i)
2291 {
2292 oss << "RefFrameList[" << std::dec << +i << "] FrameIdx:" << +picParams->RefFrameList[i].FrameIdx << std::endl;
2293 oss << "RefFrameList[" << +i << "] PicFlags:" << std::hex << +picParams->RefFrameList[i].PicFlags << std::endl;
2294 }
2295
2296 oss << "pic_width_in_mbs_minus1: " << std::dec << +picParams->pic_width_in_mbs_minus1 << std::endl;
2297 oss << "pic_height_in_mbs_minus1: " << +picParams->pic_height_in_mbs_minus1 << std::endl;
2298 oss << "bit_depth_luma_minus8: " << +picParams->bit_depth_luma_minus8 << std::endl;
2299 oss << "bit_depth_chroma_minus8: " << +picParams->bit_depth_chroma_minus8 << std::endl;
2300 oss << "num_ref_frames: " << +picParams->num_ref_frames << std::endl;
2301 oss << "CurrFieldOrderCnt: " << +picParams->CurrFieldOrderCnt[0] << std::endl;
2302 oss << "CurrFieldOrderCnt: " << +picParams->CurrFieldOrderCnt[1] << std::endl;
2303
2304 //Dump FieldOrderCntList (16x2)
2305 for (uint8_t i = 0; i < 2; ++i)
2306 {
2307 oss << "FieldOrderCntList[" << +i << "]:";
2308 for (uint8_t j = 0; j < 16; j++)
2309 oss << +picParams->FieldOrderCntList[j][i] << " ";
2310 oss << std::endl;
2311 }
2312
2313 //Dump seq_fields
2314 oss << "seq_fields value: " << +picParams->seq_fields.value << std::endl;
2315 oss << "chroma_format_idc: " << +picParams->seq_fields.chroma_format_idc << std::endl;
2316 oss << "residual_colour_transform_flag: " << std::hex << +picParams->seq_fields.residual_colour_transform_flag << std::endl;
2317 oss << "frame_mbs_only_flag: " << std::hex << +picParams->seq_fields.frame_mbs_only_flag << std::endl;
2318 oss << "mb_adaptive_frame_field_flag: " << std::hex << +picParams->seq_fields.mb_adaptive_frame_field_flag << std::endl;
2319 oss << "direct_8x8_inference_flag: " << std::hex << +picParams->seq_fields.direct_8x8_inference_flag << std::endl;
2320 oss << "log2_max_frame_num_minus4: " << std::dec << +picParams->seq_fields.log2_max_frame_num_minus4 << std::endl;
2321 oss << "pic_order_cnt_type: " << +picParams->seq_fields.pic_order_cnt_type << std::endl;
2322 oss << "log2_max_pic_order_cnt_lsb_minus4: " << +picParams->seq_fields.log2_max_pic_order_cnt_lsb_minus4 << std::endl;
2323 oss << "delta_pic_order_always_zero_flag: " << std::hex << +picParams->seq_fields.delta_pic_order_always_zero_flag << std::endl;
2324 oss << "num_slice_groups_minus1:" << std::dec << +picParams->num_slice_groups_minus1 << std::endl;
2325 oss << "slice_group_map_type:" << std::dec << +picParams->slice_group_map_type << std::endl;
2326 oss << "slice_group_change_rate_minus1:" << std::dec << +picParams->slice_group_change_rate_minus1 << std::endl;
2327 oss << "pic_init_qp_minus26:" << std::dec << +picParams->pic_init_qp_minus26 << std::endl;
2328 oss << "chroma_qp_index_offset:" << std::dec << +picParams->chroma_qp_index_offset << std::endl;
2329 oss << "second_chroma_qp_index_offset:" << std::dec << +picParams->second_chroma_qp_index_offset << std::endl;
2330
2331 //Dump pic_fields
2332 oss << "pic_fields value: " << std::dec << +picParams->pic_fields.value << std::endl;
2333 oss << "entropy_coding_mode_flag: " << std::hex << +picParams->pic_fields.entropy_coding_mode_flag << std::endl;
2334 oss << "weighted_pred_flag: " << std::hex << +picParams->pic_fields.weighted_pred_flag << std::endl;
2335 oss << "weighted_bipred_idc: " << std::dec << +picParams->pic_fields.weighted_bipred_idc << std::endl;
2336 oss << "transform_8x8_mode_flag: " << std::hex << +picParams->pic_fields.transform_8x8_mode_flag << std::endl;
2337 oss << "field_pic_flag: " << std::hex << +picParams->pic_fields.field_pic_flag << std::endl;
2338 oss << "constrained_intra_pred_flag: " << std::hex << +picParams->pic_fields.constrained_intra_pred_flag << std::endl;
2339 oss << "pic_order_present_flag: " << std::hex << +picParams->pic_fields.pic_order_present_flag << std::endl;
2340 oss << "deblocking_filter_control_present_flag: " << std::hex << +picParams->pic_fields.deblocking_filter_control_present_flag << std::endl;
2341 oss << "redundant_pic_cnt_present_flag: " << std::hex << +picParams->pic_fields.redundant_pic_cnt_present_flag << std::endl;
2342 oss << "reference_pic_flag: " << std::hex << +picParams->pic_fields.reference_pic_flag << std::endl;
2343 oss << "IntraPicFlag: " << std::hex << +picParams->pic_fields.IntraPicFlag << std::endl;
2344
2345 //Dump Short format specific
2346 oss << "num_ref_idx_l0_active_minus1: " << std::dec << +picParams->num_ref_idx_l0_active_minus1 << std::endl;
2347 oss << "num_ref_idx_l1_active_minus1: " << std::dec << +picParams->num_ref_idx_l1_active_minus1 << std::endl;
2348 oss << "NonExistingFrameFlags: " << std::hex << +picParams->NonExistingFrameFlags << std::endl;
2349 oss << "UsedForReferenceFlags: " << std::hex << +picParams->UsedForReferenceFlags << std::endl;
2350 oss << "frame_num: " << std::dec << +picParams->frame_num << std::endl;
2351 oss << "StatusReportFeedbackNumber: " << std::dec << +picParams->StatusReportFeedbackNumber << std::endl;
2352
2353 //Dump FrameNumList[16]
2354 oss << "scaling_list_present_flag_buffer:";
2355 for (uint8_t i = 0; i < 16; i++)
2356 oss << std::hex << picParams->FrameNumList[i];
2357 oss << std::endl;
2358
2359 const char *fileName = m_debugInterface->CreateFileName(
2360 "_DEC",
2361 CodechalDbgBufferType::bufPicParams,
2362 CodechalDbgExtType::txt);
2363
2364 std::ofstream ofs(fileName, std::ios::out);
2365 ofs << oss.str();
2366 ofs.close();
2367 return MOS_STATUS_SUCCESS;
2368 }
2369
2370 MOS_STATUS CodechalDecodeAvc::DumpSliceParams(
2371 PCODEC_AVC_SLICE_PARAMS sliceParams,
2372 uint32_t numSlices)
2373 {
2374 CODECHAL_DEBUG_FUNCTION_ENTER;
2375
2376 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
2377 {
2378 return MOS_STATUS_SUCCESS;
2379 }
2380
2381 CODECHAL_DEBUG_CHK_NULL(sliceParams);
2382
2383 PCODEC_AVC_SLICE_PARAMS sliceControl = nullptr;
2384
2385 std::ostringstream oss;
2386 oss.setf(std::ios::showbase | std::ios::uppercase);
2387
2388 for (uint16_t j = 0; j < numSlices; j++)
2389 {
2390 sliceControl = &sliceParams[j];
2391
2392 oss << "Data for Slice number = " << std::dec << +j << std::endl;
2393 oss << "slice_data_size: " << std::dec << +sliceControl->slice_data_size << std::endl;
2394 oss << "slice_data_offset: " << std::dec << +sliceControl->slice_data_offset << std::endl;
2395 //Dump Long format specific
2396 oss << "slice_data_bit_offset: " << std::dec << +sliceControl->slice_data_bit_offset << std::endl;
2397 oss << "first_mb_in_slice: " << std::dec << +sliceControl->first_mb_in_slice << std::endl;
2398 oss << "NumMbsForSlice: " << std::dec << +sliceControl->NumMbsForSlice << std::endl;
2399 oss << "slice_type: " << std::dec << +sliceControl->slice_type << std::endl;
2400 oss << "direct_spatial_mv_pred_flag: " << std::hex << +sliceControl->direct_spatial_mv_pred_flag << std::endl;
2401 oss << "num_ref_idx_l0_active_minus1: " << std::dec << +sliceControl->num_ref_idx_l0_active_minus1 << std::endl;
2402 oss << "num_ref_idx_l1_active_minus1: " << std::dec << +sliceControl->num_ref_idx_l1_active_minus1 << std::endl;
2403 oss << "cabac_init_idc: " << std::dec << +sliceControl->cabac_init_idc << std::endl;
2404 oss << "slice_qp_delta: " << std::dec << +sliceControl->slice_qp_delta << std::endl;
2405 oss << "disable_deblocking_filter_idc: " << std::dec << +sliceControl->disable_deblocking_filter_idc << std::endl;
2406 oss << "slice_alpha_c0_offset_div2: " << std::dec << +sliceControl->slice_alpha_c0_offset_div2 << std::endl;
2407 oss << "slice_beta_offset_div2: " << std::dec << +sliceControl->slice_beta_offset_div2 << std::endl;
2408
2409 //Dump RefPicList[2][32]
2410 for (uint8_t i = 0; i < 32; ++i)
2411 {
2412 oss << "RefPicList[0][" << std::dec << +i << "] FrameIdx: " << std::dec << +sliceControl->RefPicList[0][i].FrameIdx << std::endl;
2413 oss << "RefPicList[0][" << std::dec << +i << "] PicFlags: " << std::hex << +sliceControl->RefPicList[0][i].PicFlags << std::endl;
2414 oss << "RefPicList[1][" << std::dec << +i << "] FrameIdx: " << std::dec << +sliceControl->RefPicList[1][i].FrameIdx << std::endl;
2415 oss << "RefPicList[1][" << std::dec << +i << "] PicFlags: " << std::hex << +sliceControl->RefPicList[1][i].PicFlags << std::endl;
2416 }
2417
2418 oss << "luma_log2_weight_denom: " << std::dec << +sliceControl->luma_log2_weight_denom << std::endl;
2419 oss << "chroma_log2_weight_denom: " << std::dec << +sliceControl->chroma_log2_weight_denom << std::endl;
2420 oss << "slice_id: " << std::dec << +sliceControl->slice_id << std::endl;
2421
2422 //Dump Weights[2][32][3][2]
2423 for (uint8_t i = 0; i < 32; ++i)
2424 {
2425 oss << "Weights[0][" << std::dec << +i << "][0][0]: " << std::hex << +sliceControl->Weights[0][i][0][0] << std::endl;
2426 oss << "Weights[0][" << std::dec << +i << "][0][1]: " << std::hex << +sliceControl->Weights[0][i][0][1] << std::endl;
2427 oss << "Weights[0][" << std::dec << +i << "][1][0]: " << std::hex << +sliceControl->Weights[0][i][1][0] << std::endl;
2428 oss << "Weights[0][" << std::dec << +i << "][1][1]: " << std::hex << +sliceControl->Weights[0][i][1][1] << std::endl;
2429 oss << "Weights[1][" << std::dec << +i << "][0][0]: " << std::hex << +sliceControl->Weights[1][i][0][0] << std::endl;
2430 oss << "Weights[1][" << std::dec << +i << "][0][1]: " << std::hex << +sliceControl->Weights[1][i][0][1] << std::endl;
2431 oss << "Weights[1][" << std::dec << +i << "][1][0]: " << std::hex << +sliceControl->Weights[1][i][1][0] << std::endl;
2432 oss << "Weights[1][" << std::dec << +i << "][1][1]: " << std::hex << +sliceControl->Weights[1][i][1][1] << std::endl;
2433 oss << "Weights[0][" << std::dec << +i << "][2][0]: " << std::hex << +sliceControl->Weights[0][i][2][0] << std::endl;
2434 oss << "Weights[0][" << std::dec << +i << "][2][1]: " << std::hex << +sliceControl->Weights[0][i][2][1] << std::endl;
2435 oss << "Weights[1][" << std::dec << +i << "][2][0]: " << std::hex << +sliceControl->Weights[1][i][2][0] << std::endl;
2436 oss << "Weights[1][" << std::dec << +i << "][2][1]: " << std::hex << +sliceControl->Weights[1][i][2][1] << std::endl;
2437 }
2438
2439 const char *fileName = m_debugInterface->CreateFileName(
2440 "_DEC",
2441 CodechalDbgBufferType::bufSlcParams,
2442 CodechalDbgExtType::txt);
2443
2444 std::ofstream ofs;
2445 if (j == 0)
2446 {
2447 ofs.open(fileName, std::ios::out);
2448 }
2449 else
2450 {
2451 ofs.open(fileName, std::ios::app);
2452 }
2453 ofs << oss.str();
2454 ofs.close();
2455 }
2456
2457 return MOS_STATUS_SUCCESS;
2458 }
2459
2460 MOS_STATUS CodechalDecodeAvc::DumpIQParams(
2461 PCODEC_AVC_IQ_MATRIX_PARAMS matrixData)
2462 {
2463 CODECHAL_DEBUG_FUNCTION_ENTER;
2464
2465 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
2466 {
2467 return MOS_STATUS_SUCCESS;
2468 }
2469
2470 CODECHAL_DEBUG_CHK_NULL(matrixData);
2471
2472 std::ostringstream oss;
2473 oss.setf(std::ios::showbase | std::ios::uppercase);
2474
2475 uint32_t idx, idx2;
2476 // 4x4 block
2477 for (idx2 = 0; idx2 < 6; idx2++)
2478 {
2479 oss << "Qmatrix_H264_ScalingLists4x4[" << std::dec << +idx2 << "]:" << std::endl;
2480 for (idx = 0; idx < 12; idx += 4)
2481 {
2482 oss << "ScalingList4x4[" << std::dec << +idx / 4 << "]:";
2483 oss << std::hex << +matrixData->ScalingList4x4[idx2][idx] << " ";
2484 oss << std::hex << +matrixData->ScalingList4x4[idx2][idx + 1] << " ";
2485 oss << std::hex << +matrixData->ScalingList4x4[idx2][idx + 2] << " ";
2486 oss << std::hex << +matrixData->ScalingList4x4[idx2][idx + 3] << " ";
2487 oss << std::endl;
2488 }
2489 oss << std::endl;
2490 }
2491 // 8x8 block
2492 for (idx2 = 0; idx2 < 2; idx2++)
2493 {
2494 oss << "Qmatrix_H264_ScalingLists8x8[" << std::dec << +idx2 << "]:" << std::endl;
2495 for (idx = 0; idx < 56; idx += 8)
2496 {
2497 oss << "ScalingList8x8[" << std::dec << +idx / 8 << "]:";
2498 oss << std::hex << +matrixData->ScalingList8x8[idx2][idx] << " " ;
2499 oss << std::hex << +matrixData->ScalingList8x8[idx2][idx + 1] << " " ;
2500 oss << std::hex << +matrixData->ScalingList8x8[idx2][idx + 2] << " " ;
2501 oss << std::hex << +matrixData->ScalingList8x8[idx2][idx + 3] << " " ;
2502 oss << std::hex << +matrixData->ScalingList8x8[idx2][idx + 4] << " " ;
2503 oss << std::hex << +matrixData->ScalingList8x8[idx2][idx + 5] << " " ;
2504 oss << std::hex << +matrixData->ScalingList8x8[idx2][idx + 6] << " " ;
2505 oss << std::hex << +matrixData->ScalingList8x8[idx2][idx + 7] << " " ;
2506 oss << std::endl;
2507 }
2508 oss << std::endl;
2509 }
2510
2511 const char *fileName = m_debugInterface->CreateFileName(
2512 "_DEC",
2513 CodechalDbgBufferType::bufIqParams,
2514 CodechalDbgExtType::txt);
2515
2516 std::ofstream ofs(fileName, std::ios::out);
2517 ofs << oss.str();
2518 ofs.close();
2519
2520 return MOS_STATUS_SUCCESS;
2521 }
2522 #endif
2523
2524 MOS_STATUS CodechalDecodeAvc::SetFrameStoreIds(uint8_t frameIdx)
2525 {
2526 CODECHAL_DECODE_CHK_NULL_RETURN(m_avcFrameStoreId);
2527
2528 uint8_t invalidFrame = 0x7f;
2529
2530 for (uint8_t i = 0; i < m_avcRefList[frameIdx]->ucNumRef; i++)
2531 {
2532 uint8_t index;
2533 index = m_avcRefList[frameIdx]->RefList[i].FrameIdx;
2534 if (m_avcRefList[index]->ucFrameId == invalidFrame)
2535 {
2536 uint8_t j;
2537 for (j = 0; j < CODEC_AVC_MAX_NUM_REF_FRAME; j++)
2538 {
2539 if (!m_avcFrameStoreId[j].inUse)
2540 {
2541 m_avcRefList[index]->ucFrameId = j;
2542 m_avcFrameStoreId[j].inUse = true;
2543 break;
2544 }
2545 }
2546 if (j == CODEC_AVC_MAX_NUM_REF_FRAME)
2547 {
2548 // should never happen, something must be wrong
2549 CODECHAL_PUBLIC_ASSERT(false);
2550 m_avcRefList[index]->ucFrameId = 0;
2551 m_avcFrameStoreId[0].inUse = true;
2552 }
2553 }
2554 }
2555 return MOS_STATUS_SUCCESS;
2556 }