Debian Codegraph @

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

raw
1 /*
2 * Copyright (c) 2011-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file codechal_decode_mpeg2.cpp
24 //! \brief Implements the decode interface extension for MPEG2.
25 //! \details Implements all functions and constants required by CodecHal for MPEG2 decoding.
26 //!
27
28 #include "codechal_decoder.h"
29 #include "codechal_decode_mpeg2.h"
30 #include "codechal_secure_decode_interface.h"
31 #include "codechal_mmc_decode_mpeg2.h"
32 #include "hal_oca_interface.h"
33 #if USE_CODECHAL_DEBUG_TOOL
34 #include <sstream>
35 #include <fstream>
36 #include "codechal_debug.h"
37 #endif
38 #include "mos_os_cp_interface_specific.h"
39
40 #define CODECHAL_DECODE_MPEG2_IDCTBLOCK_SIZE 64
41
42 // One MB size (16x16) intra MB, color = RGB[4, 4, 4]
43 const uint32_t CODECHAL_DECODE_MPEG2_WaDummyBitstream[] =
44 {0x01010000, 0x54e29752, 0x002022a5, //Dummy Slice 0, q_scale_type = 0, intra_vlc_format = 0
45 0x01010000, 0x4de29752, 0x8661341a, //Dummy Slice 1, q_scale_type = 0, intra_vlc_format = 1
46 0x01010000, 0x54e2a772, 0x002022a5, //Dummy Slice 2, q_scale_type = 1, intra_vlc_format = 0
47 0x01010000, 0x4de2a772, 0x8661341a //Dummy Slice 3, q_scale_type = 1, intra_vlc_format = 1
48 };
49
50 const uint32_t CODECHAL_DECODE_MPEG2_WaDummySliceLengths[] = {0x8, 0x8, 0x8, 0x8};
51 const uint32_t CODECHAL_DECODE_MPEG2_WaDummySliceOffsets[] = {0x4, 0x10, 0x1c, 0x28};
52
53 bool CodechalDecodeMpeg2::DetectSliceError(
54 uint16_t slcNum,
55 uint32_t prevSliceMbEnd,
56 bool firstValidSlice)
57 {
58 bool result = false;
59 CODECHAL_VLD_SLICE_RECORD currSliceRecord = m_vldSliceRecord[slcNum];
60
61 if (currSliceRecord.dwLength == 0 || currSliceRecord.dwLength > (uint32_t)(1 << (sizeof(uint32_t) * 8 - 1)))
62 {
63 result = true;
64 }
65 else if ((m_sliceParams[slcNum].m_sliceDataOffset + currSliceRecord.dwLength) >
66 m_dataSize)
67 {
68 // error handling for garbage data
69 result = true;
70 }
71 else if (m_slicesInvalid)
72 {
73 // If cp copy failed for this interation due to lack of buffer space, cannot use any
74 // slices in this iteration since there is no bitstream data for them
75 result = true;
76 }
77 else if (prevSliceMbEnd > currSliceRecord.dwSliceStartMbOffset ||
78 m_sliceParams[slcNum].m_sliceVerticalPosition >= m_picHeightInMb ||
79 m_sliceParams[slcNum].m_sliceHorizontalPosition >= m_picWidthInMb)
80 {
81 result = true;
82 m_slicesInvalid = true;
83 }
84 else if (!m_sliceParams[slcNum].m_numMbsForSlice)
85 {
86 // For SNB HW will not process BSD objects where the MbCount is 0, and if an invalid
87 // slice start position has been detected or the number of MBs in the current slice
88 // is invalid, the rest of the data may be garbage since SNB does not have
89 // robust error concealment for MPEG2 VLD, skipping these slices prevents HW hangs
90
91 result = true;
92 m_slicesInvalid = true;
93 }
94 else if (m_sliceParams[slcNum].m_numMbsForSliceOverflow)
95 {
96 // Special case for last slice of an incomplete frame
97 if ((slcNum == m_numSlices - 1) &&
98 !firstValidSlice &&
99 ((currSliceRecord.dwSliceStartMbOffset + m_sliceParams[slcNum].m_numMbsForSlice) <
100 (uint32_t)(m_picHeightInMb * m_picWidthInMb)))
101 {
102 m_sliceParams[slcNum].m_numMbsForSlice = m_picWidthInMb;
103 }
104 else
105 {
106 result = true;
107 m_slicesInvalid = true;
108 }
109 }
110
111 return result;
112 }
113
114 MOS_STATUS CodechalDecodeMpeg2::InsertDummySlices(
115 PMHW_BATCH_BUFFER batchBuffer,
116 uint16_t startMB,
117 uint16_t endMB)
118 {
119 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
120 bool cpEnable = false;
121
122 CODECHAL_DECODE_FUNCTION_ENTER;
123
124 CODECHAL_DECODE_CHK_NULL_RETURN(batchBuffer);
125 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
126 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface->osCpInterface);
127
128 // A copied data buffer must be present
129 if (m_nextCopiedDataOffset && !m_dummySliceDataPresent)
130 {
131 // slice header uses 4 bytes
132 CODECHAL_DECODE_CHK_STATUS_RETURN(CopyDataSurface(
133 sizeof(CODECHAL_DECODE_MPEG2_WaDummyBitstream),
134 m_resMpeg2DummyBistream,
135 &m_resCopiedDataBuffer[m_currCopiedData],
136 &m_dummySliceDataOffset));
137
138 m_dummySliceDataPresent = true;
139 }
140
141 // force disable cp for dummy slices
142 cpEnable = m_osInterface->osCpInterface->IsCpEnabled();
143 if (cpEnable)
144 {
145 m_osInterface->osCpInterface->SetCpEnabled(false);
146 }
147
148 uint16_t intraVLDFormat = m_picParams->W0.m_intraVlcFormat;
149 uint16_t quantizerScaleType = m_picParams->W0.m_quantizerScaleType;
150 uint16_t dummySliceIndex = quantizerScaleType * 2 + intraVLDFormat;
151
152 MHW_VDBOX_MPEG2_SLICE_STATE mpeg2SliceState;
153 mpeg2SliceState.presDataBuffer = nullptr;
154 mpeg2SliceState.wPicWidthInMb = m_picWidthInMb;
155 mpeg2SliceState.wPicHeightInMb = m_picHeightInMb;
156 mpeg2SliceState.dwLength =
157 CODECHAL_DECODE_MPEG2_WaDummySliceLengths[dummySliceIndex];
158 mpeg2SliceState.dwOffset =
159 m_dummySliceDataOffset + CODECHAL_DECODE_MPEG2_WaDummySliceOffsets[dummySliceIndex];
160
161 bool isLastSlice = false;
162 uint16_t expectedEndMB = m_picWidthInMb * m_picHeightInMb;
163
164 CodecDecodeMpeg2SliceParams slc;
165 MOS_ZeroMemory(&slc, sizeof(CodecDecodeMpeg2SliceParams));
166
167 while (startMB < endMB)
168 {
169 slc.m_macroblockOffset = 6;
170 slc.m_sliceHorizontalPosition = startMB % m_picWidthInMb;
171 slc.m_sliceVerticalPosition = startMB / m_picWidthInMb;
172 slc.m_quantiserScaleCode = 10;
173 slc.m_numMbsForSlice = 1;
174
175 isLastSlice = ((startMB + 1) == expectedEndMB);
176
177 mpeg2SliceState.pMpeg2SliceParams = &slc;
178 mpeg2SliceState.dwSliceStartMbOffset = startMB;
179 mpeg2SliceState.bLastSlice = isLastSlice;
180
181 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdMpeg2BsdObject(
182 nullptr,
183 batchBuffer,
184 &mpeg2SliceState));
185
186 startMB++;
187 }
188
189 // restore Cp state
190 if (cpEnable)
191 {
192 m_osInterface->osCpInterface->SetCpEnabled(true);
193 }
194
195 if (isLastSlice)
196 {
197 m_incompletePicture = false;
198 }
199
200 return eStatus;
201 }
202
203 MOS_STATUS CodechalDecodeMpeg2::CopyDataSurface(
204 uint32_t dataSize,
205 MOS_RESOURCE sourceSurface,
206 PMOS_RESOURCE copiedSurface,
207 uint32_t *currOffset)
208 {
209 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
210
211 CODECHAL_DECODE_FUNCTION_ENTER;
212
213 if (Mos_ResourceIsNull(copiedSurface))
214 {
215 // Allocate resCopiedDataBuffer if not already allocated.
216 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
217 copiedSurface,
218 m_copiedDataBufferSize,
219 "CopiedDataBuffer"),
220 "Failed to allocate copied residual data buffer.");
221 }
222
223 if ((m_nextCopiedDataOffset + dataSize) > m_copiedDataBufferSize)
224 {
225 CODECHAL_DECODE_ASSERTMESSAGE("Copied data buffer is not large enough.");
226
227 m_slicesInvalid = true;
228 return MOS_STATUS_UNKNOWN;
229 }
230
231 uint32_t size = MOS_ALIGN_CEIL(dataSize, 16); // 16 byte aligned
232
233 // HuC is not supported on BDW
234 if (m_hwInterface->m_noHuC)
235 {
236 CodechalDataCopyParams dataCopyParams;
237 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
238 dataCopyParams.srcResource = &sourceSurface;
239 dataCopyParams.srcSize = size;
240 dataCopyParams.srcOffset = 0;
241 dataCopyParams.dstResource = copiedSurface;
242 dataCopyParams.dstSize = size;
243 dataCopyParams.dstOffset = m_nextCopiedDataOffset;
244
245 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(
246 &dataCopyParams));
247
248 *currOffset = m_nextCopiedDataOffset;
249 m_nextCopiedDataOffset += MOS_ALIGN_CEIL(size, MHW_CACHELINE_SIZE); // 64-byte aligned
250 return MOS_STATUS_SUCCESS;
251 }
252
253 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
254 m_osInterface,
255 m_videoContextForWa));
256 m_osInterface->pfnResetOsStates(m_osInterface);
257
258 m_osInterface->pfnSetPerfTag(
259 m_osInterface,
260 (uint16_t)(((m_mode << 4) & 0xF0) | COPY_TYPE));
261 m_osInterface->pfnResetPerfBufferID(m_osInterface);
262
263 MOS_COMMAND_BUFFER cmdBuffer;
264 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
265 m_osInterface,
266 &cmdBuffer,
267 0));
268
269 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
270 &cmdBuffer,
271 false));
272
273 // Use huc stream out to do the copy
274 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
275 &cmdBuffer, // pCmdBuffer
276 &sourceSurface, // presSrc
277 copiedSurface, // presDst
278 size, // u32CopyLength
279 0, // u32CopyInputOffset
280 m_nextCopiedDataOffset)); // u32CopyOutputOffset
281
282 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
283 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
284 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
285 &cmdBuffer,
286 &flushDwParams));
287
288 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
289 &cmdBuffer,
290 nullptr));
291
292 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
293
294 if (!m_incompletePicture)
295 {
296 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
297 syncParams.GpuContext = m_videoContext;
298 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
299
300 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
301
302 syncParams = g_cInitSyncParams;
303 syncParams.GpuContext = m_videoContextForWa;
304 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
305
306 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
307 }
308
309 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
310 m_osInterface,
311 &cmdBuffer,
312 m_videoContextForWaUsesNullHw));
313
314 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
315 m_osInterface,
316 m_videoContext));
317
318 *currOffset = m_nextCopiedDataOffset;
319 m_nextCopiedDataOffset += MOS_ALIGN_CEIL(size, 64); // offsets are 64-byte aligned
320
321 return eStatus;
322 }
323
324 /*--------------------------------------------------------------------------
325 | Name : CodecHalMpeg2Decode_InitializeBeginFrame
326 | Purpose : Initialize MPEG2 incomplete frame values in the DecodeBeginFrame
327 | Arguments : IN -> pMpeg2State : the pointer to mpeg2 state
328 IN -> pDecoder : the pointer to codechal decoder structure
329 | Returns : MOS_STATUS_SUCCESS : Function successfully completed its task
330 | MOS_STATUS_UNKNOWN: Error condition encountered (frame will not be rendered)
331 \---------------------------------------------------------------------------*/
332 MOS_STATUS CodechalDecodeMpeg2::InitializeBeginFrame()
333 {
334 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
335
336 CODECHAL_DECODE_FUNCTION_ENTER;
337
338 m_incompletePicture = false;
339 m_copiedDataBufferInUse = false;
340 m_copiedDataOffset = 0;
341 m_nextCopiedDataOffset = 0;
342 m_lastMbAddress = 0;
343 m_slicesInvalid = false;
344
345 m_currCopiedData =
346 (m_currCopiedData + 1) % CODECHAL_DECODE_MPEG2_COPIED_SURFACES;
347 m_dummySliceDataPresent = false;
348 m_dummySliceDataOffset = 0;
349 m_bbInUsePerFrame = 0;
350
351 return eStatus;
352 }
353
354 MOS_STATUS CodechalDecodeMpeg2::AllocateResources ()
355 {
356 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
357
358 CODECHAL_DECODE_FUNCTION_ENTER;
359
360 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
361 m_osInterface,
362 &m_resSyncObjectWaContextInUse));
363 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
364 m_osInterface,
365 &m_resSyncObjectVideoContextInUse));
366
367 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalAllocateDataList(
368 m_mpeg2RefList,
369 CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2));
370
371 for (uint32_t i = 0; i < CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2; i++)
372 {
373 m_mpeg2RefList[i]->RefPic.PicFlags = PICTURE_INVALID;
374 }
375
376 uint32_t numMacroblocks = m_picWidthInMb * m_picHeightInMb;
377
378 if (m_mode == CODECHAL_DECODE_MODE_MPEG2VLD)
379 {
380 m_vldSliceRecord =
381 (PCODECHAL_VLD_SLICE_RECORD)MOS_AllocAndZeroMemory(numMacroblocks * sizeof(CODECHAL_VLD_SLICE_RECORD));
382 CODECHAL_DECODE_CHK_NULL_RETURN(m_vldSliceRecord);
383 }
384
385 for (uint16_t i = 0; i < m_bbAllocated; i++)
386 {
387 MOS_ZeroMemory(&m_mediaObjectBatchBuffer[i], sizeof(MHW_BATCH_BUFFER));
388 uint32_t size = (m_standardDecodeSizeNeeded * numMacroblocks) + m_hwInterface->m_sizeOfCmdBatchBufferEnd;
389 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
390 m_osInterface,
391 &m_mediaObjectBatchBuffer[i],
392 nullptr,
393 size));
394 }
395
396 // Deblocking Filter Row Store Scratch buffer
397 //(Num MacroBlock Width) * (Num Cachlines) * (Cachline size)
398 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
399 &m_resMfdDeblockingFilterRowStoreScratchBuffer,
400 m_picWidthInMb * 7 * CODECHAL_CACHELINE_SIZE,
401 "DeblockingFilterScratch"),
402 "Failed to allocate BSD/MPC Row Store Scratch Buffer.");
403
404 // MPR Row Store Scratch buffer
405 // (FrameWidth in MB) * (CacheLine size per MB) * 2
406 // IVB+ platforms need to have double MPR size for MBAFF
407 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
408 &m_resBsdMpcRowStoreScratchBuffer,
409 ((uint32_t)(m_picWidthInMb * CODECHAL_CACHELINE_SIZE)) * 2,
410 "MprScratchBuffer"),
411 "Failed to allocate AVC BSD MPR Row Store Scratch Buffer.");
412
413 m_consecutiveMbErrorConcealmentInUse = true;
414
415 // Dummy slice buffer
416 if (m_mode == CODECHAL_DECODE_MODE_MPEG2VLD)
417 {
418 uint32_t size = MOS_ALIGN_CEIL(sizeof(CODECHAL_DECODE_MPEG2_WaDummyBitstream), 64);
419 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
420 &m_resMpeg2DummyBistream,
421 size,
422 "Mpeg2DummyBitstream"),
423 "Failed to allocate MPEG2 bitstream buffer for format switching WA.");
424
425 CodechalResLock DummyBitstreamLock(m_osInterface, &m_resMpeg2DummyBistream);
426 auto data = DummyBitstreamLock.Lock(CodechalResLock::writeOnly);
427
428 CODECHAL_DECODE_CHK_NULL_RETURN(data);
429
430 MOS_ZeroMemory(data, size);
431 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(
432 data,
433 size,
434 (void *)CODECHAL_DECODE_MPEG2_WaDummyBitstream,
435 sizeof(CODECHAL_DECODE_MPEG2_WaDummyBitstream)),
436 "Failed to copy memory.");
437
438 }
439
440 if (m_mode == CODECHAL_DECODE_MODE_MPEG2IDCT)
441 {
442 // The common indirect IT-COEFF data structure is defined as a uint32_t.
443 m_copiedDataBufferSize = (numMacroblocks + 2) *
444 (CODEC_NUM_BLOCK_PER_MB * CODECHAL_DECODE_MPEG2_IDCTBLOCK_SIZE * sizeof(uint32_t));
445 }
446 else
447 {
448 // Bitstream buffer size = height * width + dummy slice + 512 (for padding)
449 m_copiedDataBufferSize =
450 (m_picWidthInMb * m_picHeightInMb * CODECHAL_DECODE_MPEG2_BYTES_PER_MB) +
451 sizeof(CODECHAL_DECODE_MPEG2_WaDummyBitstream) +
452 512;
453 }
454
455 return eStatus;
456 }
457
458 CodechalDecodeMpeg2::~CodechalDecodeMpeg2 ()
459 {
460 CODECHAL_DECODE_FUNCTION_ENTER;
461
462 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
463
464 m_osInterface->pfnDestroySyncResource(m_osInterface, &m_resSyncObjectWaContextInUse);
465 m_osInterface->pfnDestroySyncResource(m_osInterface, &m_resSyncObjectVideoContextInUse);
466
467 CodecHalFreeDataList(m_mpeg2RefList, CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2);
468
469 MOS_FreeMemory(m_vldSliceRecord);
470
471 for (uint32_t i = 0; i < m_bbAllocated; i++)
472 {
473 Mhw_FreeBb(m_osInterface, &m_mediaObjectBatchBuffer[i], nullptr);
474 }
475
476 m_osInterface->pfnFreeResource(
477 m_osInterface,
478 &m_resMfdDeblockingFilterRowStoreScratchBuffer);
479
480 m_osInterface->pfnFreeResource(
481 m_osInterface,
482 &m_resBsdMpcRowStoreScratchBuffer);
483
484 // Dummy slice buffer
485 if (!Mos_ResourceIsNull(&m_resMpeg2DummyBistream))
486 {
487 m_osInterface->pfnFreeResource(
488 m_osInterface,
489 &m_resMpeg2DummyBistream);
490 }
491
492 for (uint32_t i = 0; i < CODECHAL_DECODE_MPEG2_COPIED_SURFACES; i++)
493 {
494 m_osInterface->pfnFreeResource(
495 m_osInterface,
496 &m_resCopiedDataBuffer[i]);
497 }
498 }
499
500 MOS_STATUS CodechalDecodeMpeg2::SetFrameStates ()
501 {
502 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
503
504 CODECHAL_DECODE_FUNCTION_ENTER;
505
506 uint32_t totalMBInFrame = 0;
507
508 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_destSurface);
509 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_dataBuffer);
510 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_picParams);
511
512 m_dataSize = m_decodeParams.m_dataSize;
513 m_dataOffset = m_decodeParams.m_dataOffset;
514 m_numSlices = m_decodeParams.m_numSlices;
515 m_picParams = (CodecDecodeMpeg2PicParams *)m_decodeParams.m_picParams;
516 m_sliceParams = (CodecDecodeMpeg2SliceParams *)m_decodeParams.m_sliceParams;
517 m_iqMatrixBuffer = (CodecMpeg2IqMatrix *)m_decodeParams.m_iqMatrixBuffer;
518 m_destSurface = *m_decodeParams.m_destSurface;
519 m_resDataBuffer = *m_decodeParams.m_dataBuffer;
520 m_numMacroblocks = m_decodeParams.m_numMacroblocks;
521 m_mbParams = (CodecDecodeMpeg2MbParams *)m_decodeParams.m_macroblockParams;
522 m_mpeg2ISliceConcealmentMode = m_decodeParams.m_mpeg2ISliceConcealmentMode;
523 m_mpeg2PbSliceConcealmentMode = m_decodeParams.m_mpeg2PBSliceConcealmentMode;
524 m_mpeg2PbSlicePredBiDirMvTypeOverride = m_decodeParams.m_mpeg2PBSlicePredBiDirMVTypeOverride;
525 m_mpeg2PbSlicePredMvOverride = m_decodeParams.m_mpeg2PBSlicePredMVOverride;
526
527 m_picWidthInMb = CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_picParams->m_horizontalSize);
528 m_picHeightInMb = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_picParams->m_verticalSize);
529
530 // For some corrupted mpeg2 streams, need to use dwHeight or dwWidth because they are updated at decode create time.
531 // Horizontal_size or vertical_size may be different and wrong in first pic parameter.
532 totalMBInFrame = (m_picParams->m_currPic.PicFlags == PICTURE_FRAME) ? (CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_width) * CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_height))
533 : (CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_width) * CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_height) / 2);
534
535 if (m_numSlices > totalMBInFrame)
536 {
537 CODECHAL_DECODE_ASSERTMESSAGE("Invalid slice number due to larger than MB number.");
538 return MOS_STATUS_INVALID_PARAMETER;
539 }
540
541 PCODEC_REF_LIST destEntry = m_mpeg2RefList[m_picParams->m_currPic.FrameIdx];
542 MOS_ZeroMemory(destEntry, sizeof(CODEC_REF_LIST));
543 destEntry->RefPic = m_picParams->m_currPic;
544 destEntry->resRefPic = m_destSurface.OsResource;
545
546 m_statusReportFeedbackNumber = m_picParams->m_statusReportFeedbackNumber;
547
548 MOS_ZeroMemory(m_vldSliceRecord, (m_numSlices * sizeof(CODECHAL_VLD_SLICE_RECORD)));
549
550 if (IsFirstExecuteCall())
551 {
552 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(InitializeBeginFrame(),
553 "Initial Beginframe in CodecHal failed.");
554 }
555
556 uint32_t firstMbAddress = 0;
557 bool skippedSlicePresent = false;
558 bool invalidFrame = true;
559 uint32_t numMBs = 0;
560
561 // Determine the number of MBs for MPEG2 VLD
562 if (m_mode == CODECHAL_DECODE_MODE_MPEG2VLD)
563 {
564 CODECHAL_DECODE_CHK_NULL_RETURN(m_sliceParams);
565
566 CodecDecodeMpeg2SliceParams *slc = m_sliceParams;
567
568 if (m_numSlices == 0)
569 {
570 CODECHAL_DECODE_ASSERTMESSAGE(
571 "MPEG2 VLD slice data invalid, unable to determine final MB address.");
572 numMBs = m_lastMbAddress = 0;
573 return MOS_STATUS_INVALID_PARAMETER;
574 }
575 else
576 {
577 uint16_t lastSlice = 0;
578 uint32_t prevSliceMbEnd = m_lastMbAddress;
579 bool firstValidSlice = m_incompletePicture ? true : false;
580
581 for (uint16_t i = 0; i < m_numSlices; i++)
582 {
583 uint32_t sliceStartMbOffset =
584 slc->m_sliceHorizontalPosition +
585 (slc->m_sliceVerticalPosition * m_picWidthInMb);
586
587 uint32_t slcLength = ((slc->m_sliceDataSize + 0x0007) >> 3);
588
589 // HW limitation and won't be fixed
590 if (slcLength > 0x1FFE0)
591 {
592 slcLength = 0x1FFE0;
593 }
594
595 uint32_t u32Offset = ((slc ->m_macroblockOffset & 0x0000fff8) >> 3); // #of bytes of header data in bitstream buffer (before video data)
596
597 slcLength -= u32Offset;
598 m_vldSliceRecord[i].dwLength = slcLength;
599 m_vldSliceRecord[i].dwOffset = u32Offset;
600 m_vldSliceRecord[i].dwSliceStartMbOffset = sliceStartMbOffset;
601
602 if (DetectSliceError(i, prevSliceMbEnd, firstValidSlice))
603 {
604 m_vldSliceRecord[i].dwSkip = true;
605 skippedSlicePresent = true;
606 }
607 else
608 {
609 if (firstValidSlice)
610 {
611 // First MB Address
612 firstMbAddress =
613 slc->m_sliceHorizontalPosition +
614 (slc->m_sliceVerticalPosition * m_picWidthInMb);
615 }
616
617 lastSlice = i;
618 firstValidSlice = false;
619 invalidFrame = false;
620 }
621
622 prevSliceMbEnd =
623 m_vldSliceRecord[i].dwSliceStartMbOffset +
624 slc->m_numMbsForSlice;
625
626 slc++;
627 }
628
629 slc -= m_numSlices;
630 m_vldSliceRecord[lastSlice].bIsLastSlice = true;
631
632 // Last MB Address
633 slc += lastSlice;
634
635 numMBs =
636 (uint16_t)(m_vldSliceRecord[lastSlice].dwSliceStartMbOffset +
637 slc->m_numMbsForSlice);
638 }
639 }
640 else if (m_mode == CODECHAL_DECODE_MODE_MPEG2IDCT)
641 {
642 CODECHAL_DECODE_CHK_NULL_RETURN(m_mbParams);
643 numMBs = m_numMacroblocks;
644 }
645
646 // It means all slices in the frame are wrong, we just need skip decoding for this frame
647 // and don't insert any dummy slices
648 if (m_mode == CODECHAL_DECODE_MODE_MPEG2VLD &&
649 invalidFrame && m_numSlices && !m_incompletePicture)
650 {
651 CODECHAL_DECODE_ASSERTMESSAGE("Current frame is invalid.");
652 return MOS_STATUS_UNKNOWN;
653 }
654
655 // MPEG2 Error Concealment for Gen6+
656 // Applicable for both IT and VLD modes
657 bool copiedDataNeeded = (m_incompletePicture ||
658 (numMBs != (m_picWidthInMb * m_picHeightInMb)));
659
660 if (m_mode == CODECHAL_DECODE_MODE_MPEG2VLD)
661 {
662 copiedDataNeeded |= (skippedSlicePresent || firstMbAddress);
663 }
664
665 if (copiedDataNeeded)
666 {
667 if (m_dataSize)
668 {
669 CODECHAL_DECODE_CHK_STATUS_RETURN(CopyDataSurface(
670 m_dataSize,
671 m_resDataBuffer,
672 &m_resCopiedDataBuffer[m_currCopiedData],
673 &m_copiedDataOffset));
674 }
675
676 m_copiedDataBufferInUse = true;
677 }
678
679 m_perfType = (uint16_t)m_picParams->m_pictureCodingType;
680
681 m_crrPic = m_picParams->m_currPic;
682 m_secondField = m_picParams->m_secondField ? true : false;
683
684 CODECHAL_DEBUG_TOOL(
685 CODECHAL_DECODE_CHK_NULL_RETURN(m_debugInterface);
686 m_debugInterface->m_currPic = m_crrPic;
687 m_debugInterface->m_secondField = m_secondField;
688 m_debugInterface->m_frameType = m_perfType;
689
690 if (m_picParams) {
691 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(
692 m_picParams));
693 }
694
695 if (m_iqMatrixBuffer) {
696 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpIQParams(
697 m_iqMatrixBuffer));
698 }
699
700 if (m_sliceParams) {
701 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpSliceParams(
702 m_sliceParams,
703 m_numSlices));
704 }
705
706 if (m_mbParams) {
707 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpMbParams(
708 m_mbParams));
709 }
710
711 )
712
713 return eStatus;
714 }
715
716 MOS_STATUS CodechalDecodeMpeg2::DecodeStateLevel()
717 {
718 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
719
720 CODECHAL_DECODE_FUNCTION_ENTER;
721
722 uint8_t fwdRefIdx = (uint8_t)m_picParams->m_forwardRefIdx;
723 uint8_t bwdRefIdx = (uint8_t)m_picParams->m_backwardRefIdx;
724
725 // Do not use data that has not been initialized
726 if (CodecHal_PictureIsInvalid(m_mpeg2RefList[fwdRefIdx]->RefPic))
727 {
728 fwdRefIdx = m_picParams->m_currPic.FrameIdx;
729 }
730 if (CodecHal_PictureIsInvalid(m_mpeg2RefList[bwdRefIdx]->RefPic))
731 {
732 bwdRefIdx = m_picParams->m_currPic.FrameIdx;
733 }
734
735 MOS_COMMAND_BUFFER cmdBuffer;
736 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
737
738 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
739 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
740
741 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
742 pipeModeSelectParams.Mode = m_mode;
743 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
744 pipeModeSelectParams.bPostDeblockOutEnable = m_deblockingEnabled;
745 pipeModeSelectParams.bPreDeblockOutEnable = !m_deblockingEnabled;
746
747 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
748 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
749 surfaceParams.Mode = m_mode;
750 surfaceParams.psSurface = &m_destSurface;
751
752 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
753 pipeBufAddrParams.Mode = m_mode;
754 if (m_deblockingEnabled)
755 {
756 pipeBufAddrParams.psPostDeblockSurface = &m_destSurface;
757 }
758 else
759 {
760 pipeBufAddrParams.psPreDeblockSurface = &m_destSurface;
761 }
762
763 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams));
764
765 // when there is not a forward or backward reference,
766 // the index is set to the destination frame index
767 m_presReferences[CodechalDecodeFwdRefTop] =
768 m_presReferences[CodechalDecodeFwdRefBottom] =
769 m_presReferences[CodechalDecodeBwdRefTop] =
770 m_presReferences[CodechalDecodeBwdRefBottom] = &m_destSurface.OsResource;
771
772 if (fwdRefIdx < CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
773 {
774 m_presReferences[CodechalDecodeFwdRefTop] =
775 m_presReferences[CodechalDecodeFwdRefBottom] = &m_mpeg2RefList[fwdRefIdx]->resRefPic;
776 }
777 if (bwdRefIdx < CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
778 {
779 m_presReferences[CodechalDecodeBwdRefTop] =
780 m_presReferences[CodechalDecodeBwdRefBottom] = &m_mpeg2RefList[bwdRefIdx]->resRefPic;
781 }
782
783 // special case for second fields
784 if (m_picParams->m_secondField && m_picParams->m_pictureCodingType == P_TYPE)
785 {
786 if (m_picParams->m_topFieldFirst)
787 {
788 m_presReferences[CodechalDecodeFwdRefTop] =
789 &m_destSurface.OsResource;
790 }
791 else
792 {
793 m_presReferences[CodechalDecodeFwdRefBottom] =
794 &m_destSurface.OsResource;
795 }
796 }
797
798 // set all ref pic addresses to valid addresses for error concealment purpose
799 for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
800 {
801 if (m_presReferences[i] == nullptr &&
802 MEDIA_IS_WA(m_waTable, WaDummyReference) &&
803 !Mos_ResourceIsNull(&m_dummyReference.OsResource))
804 {
805 m_presReferences[i] = &m_dummyReference.OsResource;
806 }
807 }
808
809 CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
810 pipeBufAddrParams.presReferences,
811 sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC,
812 m_presReferences,
813 sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC));
814
815 pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer =
816 &m_resMfdDeblockingFilterRowStoreScratchBuffer;
817
818 if (m_streamOutEnabled)
819 {
820 pipeBufAddrParams.presStreamOutBuffer =
821 &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
822 }
823
824 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(&pipeBufAddrParams));
825
826 CODECHAL_DEBUG_TOOL(
827 for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
828 {
829 if (pipeBufAddrParams.presReferences[i])
830 {
831 MOS_SURFACE dstSurface;
832
833 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
834 dstSurface.Format = Format_NV12;
835 dstSurface.OsResource = *(pipeBufAddrParams.presReferences[i]);
836 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
837 m_osInterface,
838 &dstSurface));
839
840 m_debugInterface->m_refIndex = (uint16_t)i;
841 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex)) + "]";
842 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
843 &dstSurface,
844 CodechalDbgAttr::attrDecodeReferenceSurfaces,
845 refSurfName.data()));
846 }
847 }
848 )
849
850 //set correctly indirect BSD object base address.
851 PMOS_RESOURCE indObjBase;
852 if (m_copiedDataBufferInUse)
853 {
854 indObjBase = &m_resCopiedDataBuffer[m_currCopiedData];
855 }
856 else
857 {
858 indObjBase = &m_resDataBuffer;
859 }
860
861 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
862 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
863 indObjBaseAddrParams.Mode = m_mode;
864 indObjBaseAddrParams.dwDataSize =
865 m_copiedDataBufferInUse ? m_copiedDataBufferSize : m_dataSize;
866 indObjBaseAddrParams.presDataBuffer = indObjBase;
867
868 MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams;
869 MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams));
870 bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer;
871
872 MHW_VDBOX_MPEG2_PIC_STATE mpeg2PicState;
873 mpeg2PicState.Mode = m_mode;
874 mpeg2PicState.pMpeg2PicParams = m_picParams;
875 mpeg2PicState.bDeblockingEnabled = m_deblockingEnabled;
876 mpeg2PicState.dwMPEG2ISliceConcealmentMode = m_mpeg2ISliceConcealmentMode;
877 mpeg2PicState.dwMPEG2PBSliceConcealmentMode = m_mpeg2PbSliceConcealmentMode;
878 mpeg2PicState.dwMPEG2PBSlicePredBiDirMVTypeOverride = m_mpeg2PbSlicePredBiDirMvTypeOverride;
879 mpeg2PicState.dwMPEG2PBSlicePredMVOverride = m_mpeg2PbSlicePredMvOverride;
880
881 MHW_VDBOX_QM_PARAMS qmParams;
882 qmParams.Standard = CODECHAL_MPEG2;
883 qmParams.pMpeg2IqMatrix = m_iqMatrixBuffer;
884
885 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
886 &cmdBuffer, true));
887
888 if (m_statusQueryReportingEnabled)
889 {
890 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(
891 &cmdBuffer));
892 }
893
894 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(
895 &cmdBuffer,
896 &pipeModeSelectParams));
897
898 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(
899 &cmdBuffer,
900 &surfaceParams));
901
902 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(
903 &cmdBuffer,
904 &pipeBufAddrParams));
905
906 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(
907 &cmdBuffer,
908 &indObjBaseAddrParams));
909
910 if (CodecHalIsDecodeModeVLD(m_mode))
911 {
912 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(
913 &cmdBuffer,
914 &bspBufBaseAddrParams));
915 }
916
917 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxMpeg2PicCmd(
918 &cmdBuffer,
919 &mpeg2PicState));
920
921 if (CodecHalIsDecodeModeVLD(m_mode))
922 {
923 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxQmCmd(
924 &cmdBuffer,
925 &qmParams));
926 }
927
928 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
929
930 return eStatus;
931 }
932
933 MOS_STATUS CodechalDecodeMpeg2::DecodePrimitiveLevel()
934 {
935 if (m_mode == CODECHAL_DECODE_MODE_MPEG2VLD)
936 {
937 return SliceLevel();
938 }
939 else
940 {
941 return MacroblockLevel();
942 }
943 }
944
945 MOS_STATUS CodechalDecodeMpeg2::SliceLevel()
946 {
947 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
948
949 CODECHAL_DECODE_FUNCTION_ENTER;
950
951 if ((m_decodePhantomMbs) || (m_incompletePicture))
952 {
953 if (m_bbInUsePerFrame >= m_bbAllocated / CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP)
954 {
955 m_bbAllocated += CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP;
956 if (m_bbAllocated >= CODECHAL_DECODE_MPEG2_MAXIMUM_BATCH_BUFFERS)
957 {
958 CODECHAL_DECODE_ASSERTMESSAGE(
959 "The number of MPEG2 second level batch buffer is not big enough to hold the whole frame.");
960 return MOS_STATUS_EXCEED_MAX_BB_SIZE;
961 }
962
963 for (uint32_t i = 0; i < CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP; i++)
964 {
965 uint32_t j = m_bbAllocated - i - 1;
966 MOS_ZeroMemory(&m_mediaObjectBatchBuffer[j], sizeof(MHW_BATCH_BUFFER));
967
968 uint32_t u32Size = m_standardDecodeSizeNeeded * CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_width) * CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_height) +
969 m_hwInterface->m_sizeOfCmdBatchBufferEnd;
970
971 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
972 m_osInterface,
973 &m_mediaObjectBatchBuffer[j],
974 nullptr,
975 u32Size));
976 m_mediaObjectBatchBuffer[j].bSecondLevel = true;
977 }
978 }
979 }
980
981 MOS_COMMAND_BUFFER cmdBuffer;
982 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
983 m_osInterface,
984 &cmdBuffer,
985 0));
986
987 MHW_BATCH_BUFFER batchBuffer = m_mediaObjectBatchBuffer[m_bbInUse];
988
989 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
990 &cmdBuffer,
991 &batchBuffer));
992
993 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_LockBb(
994 m_osInterface,
995 &batchBuffer));
996
997 if (m_decodePhantomMbs)
998 {
999 CODECHAL_DECODE_CHK_STATUS_RETURN(InsertDummySlices(
1000 &batchBuffer,
1001 m_lastMbAddress,
1002 m_picWidthInMb * m_picHeightInMb));
1003 }
1004 else
1005 {
1006 CodecDecodeMpeg2SliceParams *slc = m_sliceParams;
1007
1008 uint16_t prevSliceMBEnd = m_lastMbAddress;
1009
1010 for (uint16_t slcCount = 0; slcCount < m_numSlices; slcCount++)
1011 {
1012 if (!m_vldSliceRecord[slcCount].dwSkip)
1013 {
1014 if (prevSliceMBEnd != m_vldSliceRecord[slcCount].dwSliceStartMbOffset)
1015 {
1016 CODECHAL_DECODE_CHK_STATUS_RETURN(InsertDummySlices(
1017 &batchBuffer,
1018 prevSliceMBEnd,
1019 (uint16_t)m_vldSliceRecord[slcCount].dwSliceStartMbOffset));
1020 }
1021
1022 if (m_vldSliceRecord[slcCount].bIsLastSlice)
1023 {
1024 uint16_t expectedFinalMb = m_picWidthInMb * m_picHeightInMb;
1025
1026 m_lastMbAddress =
1027 (uint16_t)(m_vldSliceRecord[slcCount].dwSliceStartMbOffset +
1028 slc->m_numMbsForSlice);
1029
1030 if (m_lastMbAddress < expectedFinalMb)
1031 {
1032 m_incompletePicture = true;
1033 m_vldSliceRecord[slcCount].bIsLastSlice = false;
1034 }
1035 else
1036 {
1037 //Indicate It's complete picture now
1038 m_incompletePicture = false;
1039 }
1040 }
1041
1042 // static MPEG2 slice parameters
1043 MHW_VDBOX_MPEG2_SLICE_STATE mpeg2SliceState;
1044 mpeg2SliceState.presDataBuffer = &m_resDataBuffer;
1045 mpeg2SliceState.wPicWidthInMb = m_picWidthInMb;
1046 mpeg2SliceState.wPicHeightInMb = m_picHeightInMb;
1047 mpeg2SliceState.pMpeg2SliceParams = slc;
1048 mpeg2SliceState.dwLength = m_vldSliceRecord[slcCount].dwLength;
1049 mpeg2SliceState.dwOffset =
1050 m_vldSliceRecord[slcCount].dwOffset + m_copiedDataOffset;
1051 mpeg2SliceState.dwSliceStartMbOffset = m_vldSliceRecord[slcCount].dwSliceStartMbOffset;
1052 mpeg2SliceState.bLastSlice = m_vldSliceRecord[slcCount].bIsLastSlice;
1053
1054 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdMpeg2BsdObject(
1055 nullptr,
1056 &batchBuffer,
1057 &mpeg2SliceState));
1058
1059 prevSliceMBEnd =
1060 (uint16_t)(m_vldSliceRecord[slcCount].dwSliceStartMbOffset +
1061 slc->m_numMbsForSlice);
1062 }
1063
1064 slc++;
1065 }
1066 }
1067
1068 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1069 nullptr,
1070 &batchBuffer));
1071
1072 CODECHAL_DEBUG_TOOL(
1073 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
1074 &batchBuffer,
1075 CODECHAL_NUM_MEDIA_STATES,
1076 "_DEC"));
1077 )
1078
1079 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_UnlockBb(
1080 m_osInterface,
1081 &batchBuffer,
1082 true));
1083
1084 m_bbInUse = (m_bbInUse + 1) % m_bbAllocated;
1085 m_bbInUsePerFrame++;
1086
1087 if (!m_incompletePicture)
1088 {
1089 // Check if destination surface needs to be synchronized
1090 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
1091 syncParams.GpuContext = m_videoContext;
1092 syncParams.presSyncResource = &m_destSurface.OsResource;
1093 syncParams.bReadOnly = false;
1094 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1095 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1096
1097 if (!CodecHal_PictureIsField(m_picParams->m_currPic) ||
1098 !m_picParams->m_secondField)
1099 {
1100 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(
1101 m_osInterface,
1102 &syncParams));
1103 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(
1104 m_osInterface,
1105 &syncParams));
1106
1107 // Update the resource tag (s/w tag) for On-Demand Sync
1108 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1109 }
1110
1111 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1112 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1113
1114 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1115 &cmdBuffer,
1116 &flushDwParams));
1117
1118 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1119 if (m_osInterface->bTagResourceSync &&
1120 (!CodecHal_PictureIsField(m_picParams->m_currPic) || m_picParams->m_secondField))
1121 {
1122 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
1123 &cmdBuffer,
1124 &syncParams));
1125 }
1126
1127 if (m_statusQueryReportingEnabled)
1128 {
1129 CodechalDecodeStatusReport decodeStatusReport;
1130
1131 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
1132 decodeStatusReport.m_currDecodedPic = m_picParams->m_currPic;
1133 decodeStatusReport.m_currDeblockedPic = m_picParams->m_currPic;
1134 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
1135 decodeStatusReport.m_currDecodedPicRes = m_mpeg2RefList[m_picParams->m_currPic.FrameIdx]->resRefPic;
1136
1137 CODECHAL_DEBUG_TOOL(
1138 decodeStatusReport.m_secondField = m_picParams->m_secondField ? true : false;
1139 decodeStatusReport.m_frameType = m_perfType;)
1140
1141 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
1142 decodeStatusReport,
1143 &cmdBuffer));
1144 }
1145
1146 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1147 &cmdBuffer,
1148 nullptr));
1149
1150 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1151
1152 CODECHAL_DEBUG_TOOL(
1153 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
1154 &cmdBuffer,
1155 CODECHAL_NUM_MEDIA_STATES,
1156 "_DEC"));
1157
1158 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
1159 // m_debugInterface,
1160 // &cmdBuffer));
1161 )
1162
1163 //Sync up complete frame
1164 syncParams = g_cInitSyncParams;
1165 syncParams.GpuContext = m_videoContextForWa;
1166 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1167
1168 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
1169
1170 syncParams = g_cInitSyncParams;
1171 syncParams.GpuContext = m_videoContext;
1172 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1173
1174 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
1175
1176 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
1177
1178 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
1179 m_osInterface,
1180 &cmdBuffer,
1181 m_videoContextUsesNullHw));
1182
1183 CODECHAL_DEBUG_TOOL(
1184 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
1185
1186 if (m_statusQueryReportingEnabled)
1187 {
1188 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
1189 m_videoContextUsesNullHw));
1190 }
1191
1192 // Needs to be re-set for Linux buffer re-use scenarios
1193 m_mpeg2RefList[m_picParams->m_currPic.FrameIdx]->resRefPic =
1194 m_destSurface.OsResource;
1195
1196 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
1197 if (!CodecHal_PictureIsField(m_picParams->m_currPic) || m_picParams->m_secondField)
1198 {
1199 syncParams = g_cInitSyncParams;
1200 syncParams.GpuContext = m_videoContext;
1201 syncParams.presSyncResource = &m_destSurface.OsResource;
1202
1203 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
1204 }
1205 }
1206 else
1207 {
1208 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1209 }
1210
1211 return eStatus;
1212 }
1213
1214 void CodechalDecodeMpeg2::PackMotionVectors(
1215 CODEC_PICTURE_FLAG pic_flag,
1216 PMHW_VDBOX_MPEG2_MB_STATE mpeg2MbState)
1217 {
1218 CodecDecodeMpeg2MbParams *mbParams = mpeg2MbState->pMBParams;
1219
1220 uint16_t motionType = mbParams->MBType.m_motionType;
1221 uint16_t intelMotionType = CODECHAL_MPEG2_IMT_NONE;
1222
1223 //convert to Intel Motion Type
1224 if (pic_flag == PICTURE_FRAME)
1225 {
1226 switch(motionType)
1227 {
1228 case CodechalDecodeMcFrame:
1229 intelMotionType = CODECHAL_MPEG2_IMT_FRAME_FRAME;
1230 break;
1231 case CodechalDecodeMcField:
1232 intelMotionType = CODECHAL_MPEG2_IMT_FRAME_FIELD;
1233 break;
1234 case CodechalDecodeMcDmv:
1235 intelMotionType = CODECHAL_MPEG2_IMT_FRAME_DUAL_PRIME;
1236 break;
1237 default:
1238 break;
1239 }
1240 }
1241 else // must be field picture...
1242 {
1243 switch(motionType)
1244 {
1245 case CodechalDecodeMcField:
1246 intelMotionType = CODECHAL_MPEG2_IMT_FIELD_FIELD;
1247 break;
1248 case CodechalDecodeMcDmv:
1249 intelMotionType = CODECHAL_MPEG2_IMT_FIELD_DUAL_PRIME;
1250 break;
1251 case CodechalDecodeMc16x8:
1252 intelMotionType = CODECHAL_MPEG2_IMT_16X8;
1253 break;
1254 default:
1255 break;
1256 }
1257 }
1258
1259 int16_t *mv = mbParams->m_motionVectors;
1260
1261 switch (intelMotionType)
1262 {
1263 case CODECHAL_MPEG2_IMT_16X8:
1264 case CODECHAL_MPEG2_IMT_FIELD_FIELD:
1265 case CODECHAL_MPEG2_IMT_FRAME_FRAME:
1266 case CODECHAL_MPEG2_IMT_FIELD_DUAL_PRIME:
1267 mpeg2MbState->sPackedMVs0[0] = (short)mv[CodechalDecodeRstFirstForwHorz];
1268 mpeg2MbState->sPackedMVs0[1] = (short)mv[CodechalDecodeRstFirstForwVert];
1269 mpeg2MbState->sPackedMVs0[2] = (short)mv[CodechalDecodeRstFirstBackHorz];
1270 mpeg2MbState->sPackedMVs0[3] = (short)mv[CodechalDecodeRstFirstBackVert];
1271 break;
1272
1273 case CODECHAL_MPEG2_IMT_FRAME_FIELD:
1274 case CODECHAL_MPEG2_IMT_FRAME_DUAL_PRIME:
1275 mpeg2MbState->sPackedMVs0[0] = (short)mv[CodechalDecodeRstFirstForwHorz];
1276 mpeg2MbState->sPackedMVs0[1] = (short)(mv[CodechalDecodeRstFirstForwVert] >> 1) ;
1277 mpeg2MbState->sPackedMVs0[2] = (short)mv[CodechalDecodeRstFirstBackHorz];
1278 mpeg2MbState->sPackedMVs0[3] = (short)(mv[CodechalDecodeRstFirstBackVert] >> 1);
1279 break;
1280
1281 default:
1282 break;
1283 }
1284
1285 switch (intelMotionType)
1286 {
1287 case CODECHAL_MPEG2_IMT_16X8:
1288 mpeg2MbState->sPackedMVs1[0] = (short)mv[CodechalDecodeRstSecndForwHorz];
1289 mpeg2MbState->sPackedMVs1[1] = (short)mv[CodechalDecodeRstSecndForwVert];
1290 mpeg2MbState->sPackedMVs1[2] = (short)mv[CodechalDecodeRstSecndBackHorz];
1291 mpeg2MbState->sPackedMVs1[3] = (short)mv[CodechalDecodeRstSecndBackVert];
1292 break;
1293
1294 case CODECHAL_MPEG2_IMT_FRAME_DUAL_PRIME:
1295 mpeg2MbState->sPackedMVs1[0] = (short)mv[CodechalDecodeRstFirstForwHorz];
1296 mpeg2MbState->sPackedMVs1[1] = (short)(mv[CodechalDecodeRstFirstForwVert] >> 1);
1297 mpeg2MbState->sPackedMVs1[2] = (short)mv[CodechalDecodeRstSecndBackHorz];
1298 mpeg2MbState->sPackedMVs1[3] = (short)(mv[CodechalDecodeRstSecndBackVert] >> 1);
1299 break;
1300
1301 case CODECHAL_MPEG2_IMT_FRAME_FIELD:
1302 mpeg2MbState->sPackedMVs1[0] = (short)mv[CodechalDecodeRstSecndForwHorz];
1303 mpeg2MbState->sPackedMVs1[1] = (short)(mv[CodechalDecodeRstSecndForwVert] >> 1);
1304 mpeg2MbState->sPackedMVs1[2] = (short)mv[CodechalDecodeRstSecndBackHorz];
1305 mpeg2MbState->sPackedMVs1[3] = (short)(mv[CodechalDecodeRstSecndBackVert] >> 1);
1306 break;
1307
1308 default:
1309 break;
1310 }
1311 }
1312 MOS_STATUS CodechalDecodeMpeg2::InsertSkippedMacroblocks(
1313 PMHW_BATCH_BUFFER batchBuffer,
1314 PMHW_VDBOX_MPEG2_MB_STATE params,
1315 uint16_t nextMBStart,
1316 uint16_t skippedMBs)
1317 {
1318 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1319
1320 CODECHAL_DECODE_FUNCTION_ENTER;
1321
1322 CODECHAL_DECODE_CHK_NULL_RETURN(batchBuffer);
1323 CODECHAL_DECODE_CHK_NULL_RETURN(params);
1324 CODECHAL_DECODE_CHK_NULL_RETURN(params->pMBParams);
1325
1326 //save the original MB params, and restore the orignal MB params when function exit.
1327 CodechalDecodeRestoreData<CodecDecodeMpeg2MbParams> MBParamsRestore(params->pMBParams);
1328
1329 params->dwDCTLength = 0;
1330 params->dwITCoffDataAddrOffset = 0;
1331 params->pMBParams->m_codedBlockPattern = 0;
1332
1333 MOS_ZeroMemory(params->sPackedMVs0,sizeof(params->sPackedMVs0));
1334 MOS_ZeroMemory(params->sPackedMVs1,sizeof(params->sPackedMVs1));
1335
1336 for (uint16_t i = 0; i < skippedMBs; i++)
1337 {
1338 params->pMBParams->m_mbAddr = nextMBStart + i;
1339 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdMpeg2ITObject(
1340 nullptr,
1341 batchBuffer,
1342 params));
1343 }
1344
1345 return eStatus;
1346 }
1347
1348 MOS_STATUS CodechalDecodeMpeg2::MacroblockLevel()
1349 {
1350 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1351
1352 CODECHAL_DECODE_FUNCTION_ENTER;
1353
1354 if ((m_decodePhantomMbs) || (m_incompletePicture))
1355 {
1356 if (m_bbInUsePerFrame >= m_bbAllocated / CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP)
1357 {
1358 m_bbAllocated += CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP;
1359 if (m_bbAllocated >= CODECHAL_DECODE_MPEG2_MAXIMUM_BATCH_BUFFERS)
1360 {
1361 CODECHAL_DECODE_ASSERTMESSAGE(
1362 "The number of MPEG2 second level batch buffer is not big enough to hold the whole frame.");
1363 return MOS_STATUS_EXCEED_MAX_BB_SIZE;
1364 }
1365
1366 for (uint32_t i = 0; i < CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP; i++)
1367 {
1368 uint32_t j = m_bbAllocated - i - 1;
1369 MOS_ZeroMemory(&m_mediaObjectBatchBuffer[j], sizeof(MHW_BATCH_BUFFER));
1370
1371 uint32_t u32Size = m_standardDecodeSizeNeeded * m_picWidthInMb * m_picHeightInMb +
1372 m_hwInterface->m_sizeOfCmdBatchBufferEnd;
1373
1374 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
1375 m_osInterface,
1376 &m_mediaObjectBatchBuffer[j],
1377 nullptr,
1378 u32Size));
1379 m_mediaObjectBatchBuffer[j].bSecondLevel = true;
1380 }
1381 }
1382 }
1383
1384 MOS_COMMAND_BUFFER cmdBuffer;
1385 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
1386 m_osInterface,
1387 &cmdBuffer,
1388 0));
1389
1390 MHW_BATCH_BUFFER batchBuffer = m_mediaObjectBatchBuffer[m_bbInUse];
1391
1392 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
1393 &cmdBuffer,
1394 &batchBuffer));
1395
1396 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_LockBb(m_osInterface, &batchBuffer));
1397
1398 //static member
1399 MHW_VDBOX_MPEG2_MB_STATE mpeg2MbState;
1400 mpeg2MbState.wPicWidthInMb = m_picWidthInMb;
1401 mpeg2MbState.wPicHeightInMb = m_picHeightInMb;
1402 mpeg2MbState.wPicCodingType = (uint16_t)m_picParams->m_pictureCodingType;
1403
1404 if (m_decodePhantomMbs)
1405 {
1406 uint16_t u16NextMBStart = m_savedMpeg2MbParam.m_mbAddr + 1; // = 1 + saved last MB's address in this picture.
1407 uint16_t numMBs = (mpeg2MbState.wPicWidthInMb * mpeg2MbState.wPicHeightInMb) - u16NextMBStart;
1408
1409 mpeg2MbState.pMBParams = &m_savedMpeg2MbParam; //use saved last MB param to insert Skipped MBs.
1410 CODECHAL_DECODE_CHK_STATUS_RETURN(InsertSkippedMacroblocks(
1411 &batchBuffer,
1412 &mpeg2MbState,
1413 u16NextMBStart,
1414 numMBs));
1415 m_incompletePicture = false;
1416 }
1417 else
1418 {
1419 uint16_t expectedMBAddress = (m_incompletePicture) ? m_lastMbAddress : 0;
1420
1421 for (uint16_t mbcount = 0; mbcount < m_numMacroblocks; mbcount++)
1422 {
1423 if (m_mbParams[mbcount].m_mbAddr >= expectedMBAddress)
1424 {
1425 uint16_t skippedMBs = m_mbParams[mbcount].m_mbAddr - expectedMBAddress;
1426
1427 if (skippedMBs)
1428 {
1429 //insert skipped Macroblock, use the first available MB params to insert skipped MBs.
1430 mpeg2MbState.pMBParams = &(m_mbParams[mbcount]);
1431 CODECHAL_DECODE_CHK_STATUS_RETURN(InsertSkippedMacroblocks(
1432 &batchBuffer,
1433 &mpeg2MbState,
1434 expectedMBAddress,
1435 skippedMBs));
1436 }
1437 }
1438
1439 //common field for MBs in I picture and PB picture .
1440 mpeg2MbState.pMBParams = &m_mbParams[mbcount];
1441 mpeg2MbState.dwDCTLength = 0;
1442 for (uint32_t i = 0; i < CODEC_NUM_BLOCK_PER_MB; i++)
1443 {
1444 mpeg2MbState.dwDCTLength += m_mbParams[mbcount].m_numCoeff[i];
1445 }
1446
1447 mpeg2MbState.dwITCoffDataAddrOffset = m_copiedDataOffset + (m_mbParams[mbcount].m_mbDataLoc << 2); // byte offset
1448
1449 //only for MB in PB picture.
1450 if (mpeg2MbState.wPicCodingType != I_TYPE)
1451 {
1452 bool intraMB = mpeg2MbState.pMBParams->MBType.m_intraMb? true: false;
1453
1454 MOS_ZeroMemory(mpeg2MbState.sPackedMVs0,sizeof(mpeg2MbState.sPackedMVs0));
1455 MOS_ZeroMemory(mpeg2MbState.sPackedMVs1,sizeof(mpeg2MbState.sPackedMVs1));
1456 if ((!intraMB) && (mpeg2MbState.pMBParams->MBType.m_value &
1457 (CODECHAL_DECODE_MPEG2_MB_MOTION_BACKWARD | CODECHAL_DECODE_MPEG2_MB_MOTION_FORWARD)))
1458 {
1459 PackMotionVectors(m_picParams->m_currPic.PicFlags, &mpeg2MbState);
1460 }
1461 }
1462
1463 // add IT OBJECT command for each macroblock
1464 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdMpeg2ITObject(
1465 nullptr,
1466 &batchBuffer,
1467 &mpeg2MbState));
1468
1469 if (mpeg2MbState.wPicCodingType != I_TYPE && m_mbParams[mbcount].m_mbSkipFollowing)
1470 {
1471 uint16_t skippedMBs = m_mbParams[mbcount].m_mbSkipFollowing;
1472 uint16_t skippedMBSart = m_mbParams[mbcount].m_mbAddr + 1;
1473
1474 // Insert Skipped MBs
1475 CODECHAL_DECODE_CHK_STATUS_RETURN(InsertSkippedMacroblocks(
1476 &batchBuffer,
1477 &mpeg2MbState,
1478 skippedMBSart,
1479 skippedMBs));
1480
1481 m_mbParams[mbcount].m_mbAddr += skippedMBs;
1482 }
1483
1484 //save the last MB's parameters for later use to insert skipped MBs.
1485 m_savedMpeg2MbParam = m_mbParams[mbcount];
1486
1487 expectedMBAddress = m_mbParams[mbcount].m_mbAddr + 1;
1488
1489 // insert extra MBs to ensure expected number of MBs sent to HW
1490 if (mbcount + 1 == m_numMacroblocks)
1491 {
1492 uint16_t expectedFinalMB = m_picWidthInMb * m_picHeightInMb;
1493
1494 if (expectedMBAddress != expectedFinalMB)
1495 {
1496 m_incompletePicture = true;
1497 m_lastMbAddress = expectedMBAddress;
1498 }
1499 else
1500 {
1501 m_incompletePicture = false;
1502 }
1503 }
1504 }
1505 }
1506
1507 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1508 nullptr,
1509 &batchBuffer));
1510
1511 CODECHAL_DEBUG_TOOL(
1512 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
1513 &batchBuffer,
1514 CODECHAL_NUM_MEDIA_STATES,
1515 "_DEC"));
1516 )
1517
1518 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_UnlockBb(m_osInterface, &batchBuffer, true));
1519
1520 m_bbInUse = (m_bbInUse + 1) % m_bbAllocated;
1521 m_bbInUsePerFrame++;
1522
1523 if (!m_incompletePicture)
1524 {
1525 // Check if destination surface needs to be synchronized
1526 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
1527 syncParams.GpuContext = m_videoContext;
1528 syncParams.presSyncResource = &m_destSurface.OsResource;
1529 syncParams.bReadOnly = false;
1530 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1531 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1532
1533 if (!CodecHal_PictureIsField(m_picParams->m_currPic) ||
1534 !m_picParams->m_secondField)
1535 {
1536 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(
1537 m_osInterface,
1538 &syncParams));
1539 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(
1540 m_osInterface,
1541 &syncParams));
1542
1543 // Update the resource tag (s/w tag) for On-Demand Sync
1544 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1545 }
1546
1547 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1548 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1549
1550 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1551 &cmdBuffer,
1552 &flushDwParams));
1553
1554 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1555 if (m_osInterface->bTagResourceSync &&
1556 (!CodecHal_PictureIsField(m_picParams->m_currPic) || m_picParams->m_secondField))
1557 {
1558 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
1559 &cmdBuffer,
1560 &syncParams));
1561 }
1562
1563 if (m_statusQueryReportingEnabled)
1564 {
1565 CodechalDecodeStatusReport decodeStatusReport;
1566
1567 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
1568 decodeStatusReport.m_currDecodedPic = m_picParams->m_currPic;
1569 decodeStatusReport.m_currDeblockedPic = m_picParams->m_currPic;
1570 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
1571 decodeStatusReport.m_currDecodedPicRes =
1572 m_mpeg2RefList[m_picParams->m_currPic.FrameIdx]->resRefPic;
1573
1574 CODECHAL_DEBUG_TOOL(
1575 decodeStatusReport.m_secondField = m_picParams->m_secondField ? true : false;
1576 decodeStatusReport.m_frameType = m_perfType;)
1577
1578 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
1579 decodeStatusReport,
1580 &cmdBuffer));
1581 }
1582
1583 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1584 &cmdBuffer,
1585 nullptr));
1586
1587 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1588
1589 CODECHAL_DEBUG_TOOL(
1590 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
1591 &cmdBuffer,
1592 CODECHAL_NUM_MEDIA_STATES,
1593 "_DEC"));
1594
1595 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
1596 // m_debugInterface,
1597 // &cmdBuffer));
1598 )
1599
1600 //Sync up complete frame
1601 syncParams = g_cInitSyncParams;
1602 syncParams.GpuContext = m_videoContextForWa;
1603 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1604
1605 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
1606
1607 syncParams = g_cInitSyncParams;
1608 syncParams.GpuContext = m_videoContext;
1609 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1610
1611 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
1612
1613 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
1614
1615 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
1616 m_osInterface,
1617 &cmdBuffer,
1618 m_videoContextUsesNullHw));
1619
1620 CODECHAL_DEBUG_TOOL(
1621 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
1622
1623 if (m_statusQueryReportingEnabled)
1624 {
1625 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
1626 m_videoContextUsesNullHw));
1627 }
1628
1629 // Needs to be re-set for Linux buffer re-use scenarios
1630 m_mpeg2RefList[m_picParams->m_currPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
1631
1632 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
1633 if (!CodecHal_PictureIsField(m_picParams->m_currPic) || m_picParams->m_secondField)
1634 {
1635 syncParams = g_cInitSyncParams;
1636 syncParams.GpuContext = m_videoContext;
1637 syncParams.presSyncResource = &m_destSurface.OsResource;
1638
1639 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
1640 }
1641 }
1642 else
1643 {
1644 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1645 }
1646
1647 return eStatus;
1648 }
1649
1650 MOS_STATUS CodechalDecodeMpeg2::InitMmcState()
1651 {
1652 m_mmc = MOS_New(CodechalMmcDecodeMpeg2, m_hwInterface, this);
1653 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
1654
1655 return MOS_STATUS_SUCCESS;
1656 }
1657
1658 MOS_STATUS CodechalDecodeMpeg2::AllocateStandard (
1659 CodechalSetting *settings)
1660 {
1661 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1662
1663 CODECHAL_DECODE_FUNCTION_ENTER;
1664
1665 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
1666
1667 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
1668
1669 m_width = settings->width;
1670 m_height = settings->height;
1671 m_picWidthInMb = (uint16_t)CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_width);
1672 m_picHeightInMb = (uint16_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_height);
1673 m_bbAllocated = CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP;
1674
1675 // Picture Level Commands
1676 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetMfxStateCommandsDataSize(
1677 m_mode,
1678 &m_commandBufferSizeNeeded,
1679 &m_commandPatchListSizeNeeded,
1680 0));
1681
1682 // Primitive Level Commands
1683 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetMfxPrimitiveCommandsDataSize(
1684 m_mode,
1685 &m_standardDecodeSizeNeeded,
1686 &m_standardDecodePatchListSizeNeeded,
1687 0));
1688
1689 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResources());
1690
1691 return eStatus;
1692 }
1693
1694 CodechalDecodeMpeg2::CodechalDecodeMpeg2 (
1695 CodechalHwInterface *hwInterface,
1696 CodechalDebugInterface* debugInterface,
1697 PCODECHAL_STANDARD_INFO standardInfo) :
1698 CodechalDecode(hwInterface, debugInterface, standardInfo)
1699 {
1700 CODECHAL_DECODE_FUNCTION_ENTER;
1701
1702 MOS_ZeroMemory(&m_destSurface, sizeof(m_destSurface));
1703 MOS_ZeroMemory(m_presReferences, sizeof(m_presReferences));
1704 MOS_ZeroMemory(&m_resDataBuffer, sizeof(m_resDataBuffer));
1705 MOS_ZeroMemory(&m_resMfdDeblockingFilterRowStoreScratchBuffer, sizeof(m_resMfdDeblockingFilterRowStoreScratchBuffer));
1706 MOS_ZeroMemory(&m_resBsdMpcRowStoreScratchBuffer, sizeof(m_resBsdMpcRowStoreScratchBuffer));
1707 MOS_ZeroMemory(m_mpeg2RefList, sizeof(m_mpeg2RefList));
1708 MOS_ZeroMemory(m_mediaObjectBatchBuffer, sizeof(m_mediaObjectBatchBuffer));
1709 MOS_ZeroMemory(&m_resMpeg2DummyBistream, sizeof(m_resMpeg2DummyBistream));
1710 MOS_ZeroMemory(m_resCopiedDataBuffer, sizeof(m_resCopiedDataBuffer));
1711 MOS_ZeroMemory(&m_resSyncObjectWaContextInUse, sizeof(m_resSyncObjectWaContextInUse));
1712 MOS_ZeroMemory(&m_resSyncObjectVideoContextInUse, sizeof(m_resSyncObjectVideoContextInUse));
1713 MOS_ZeroMemory(&m_savedMpeg2MbParam, sizeof(m_savedMpeg2MbParam));
1714 #if (_DEBUG || _RELEASE_INTERNAL)
1715 m_reportFrameCrc = true;
1716 #endif
1717 m_hwInterface = hwInterface;
1718 }
1719
1720 #if USE_CODECHAL_DEBUG_TOOL
1721 MOS_STATUS CodechalDecodeMpeg2::DumpPicParams(
1722 CodecDecodeMpeg2PicParams *picParams)
1723 {
1724 CODECHAL_DEBUG_FUNCTION_ENTER;
1725
1726 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
1727 {
1728 return MOS_STATUS_SUCCESS;
1729 }
1730
1731 CODECHAL_DEBUG_CHK_NULL(picParams);
1732
1733 std::ostringstream oss;
1734 oss.setf(std::ios::showbase | std::ios::uppercase);
1735
1736 oss << "m_currPic FrameIdx: " << +picParams->m_currPic.FrameIdx << std::endl;
1737 oss << "m_currPic PicFlags: " << +picParams->m_currPic.PicFlags << std::endl;
1738 oss << "m_forwardRefIdx: " << +picParams->m_forwardRefIdx << std::endl;
1739 oss << "m_backwardRefIdx: " << +picParams->m_backwardRefIdx << std::endl;
1740 oss << "m_topFieldFirst: " << +picParams->m_topFieldFirst << std::endl;
1741 oss << "m_secondField: " << +picParams->m_secondField << std::endl;
1742 oss << "m_statusReportFeedbackNumber: " << +picParams->m_statusReportFeedbackNumber << std::endl;
1743 //Dump union w0
1744 oss << "w0 m_value: " << +picParams->W0.m_value << std::endl;
1745 oss << "m_scanOrder: " << +picParams->W0.m_scanOrder << std::endl;
1746 oss << "m_intraVlcFormat: " << +picParams->W0.m_intraVlcFormat << std::endl;
1747 oss << "m_quantizerScaleType: " << +picParams->W0.m_quantizerScaleType << std::endl;
1748 oss << "m_concealmentMVFlag: " << +picParams->W0.m_concealmentMVFlag << std::endl;
1749 oss << "m_frameDctPrediction: " << +picParams->W0.m_frameDctPrediction << std::endl;
1750 oss << "m_topFieldFirst: " << +picParams->W0.m_topFieldFirst << std::endl;
1751 oss << "m_intraDCPrecision: " << +picParams->W0.m_intraDCPrecision << std::endl;
1752 //Dump union w1
1753 oss << "w1 m_value: " << +picParams->W1.m_value << std::endl;
1754 oss << "m_fcode11: " << +picParams->W1.m_fcode11 << std::endl;
1755 oss << "m_fcode10: " << +picParams->W1.m_fcode10 << std::endl;
1756 oss << "m_fcode01: " << +picParams->W1.m_fcode01 << std::endl;
1757 oss << "m_fcode00: " << +picParams->W1.m_fcode00 << std::endl;
1758 oss << "m_horizontalSize: " << +picParams->m_horizontalSize << std::endl;
1759 oss << "m_verticalSize: " << +picParams->m_verticalSize << std::endl;
1760 oss << "m_pictureCodingType: " << +picParams->m_pictureCodingType << std::endl;
1761
1762 const char *fileName = m_debugInterface->CreateFileName(
1763 "_DEC",
1764 CodechalDbgBufferType::bufPicParams,
1765 CodechalDbgExtType::txt);
1766
1767 std::ofstream ofs(fileName, std::ios::out);
1768 ofs << oss.str();
1769 ofs.close();
1770 return MOS_STATUS_SUCCESS;
1771 }
1772
1773 MOS_STATUS CodechalDecodeMpeg2::DumpSliceParams(
1774 CodecDecodeMpeg2SliceParams *sliceParams,
1775 uint32_t numSlices)
1776 {
1777 CODECHAL_DEBUG_FUNCTION_ENTER;
1778
1779 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
1780 {
1781 return MOS_STATUS_SUCCESS;
1782 }
1783
1784 CODECHAL_DEBUG_CHK_NULL(sliceParams);
1785
1786 const char *fileName = m_debugInterface->CreateFileName(
1787 "_DEC",
1788 CodechalDbgBufferType::bufSlcParams,
1789 CodechalDbgExtType::txt);
1790
1791 std::ostringstream oss;
1792 oss.setf(std::ios::showbase | std::ios::uppercase);
1793
1794 CodecDecodeMpeg2SliceParams *sliceControl = nullptr;
1795
1796 for (uint16_t i = 0; i < numSlices; i++)
1797 {
1798 sliceControl = &sliceParams[i];
1799
1800 oss << "====================================================================================================" << std::endl;
1801 oss << "Data for Slice number = " << +i << std::endl;
1802 oss << "m_sliceDataSize: " << +sliceControl->m_sliceDataSize << std::endl;
1803 oss << "m_sliceDataOffset: " << +sliceControl->m_sliceDataOffset << std::endl;
1804 oss << "m_macroblockOffset: " << +sliceControl->m_macroblockOffset << std::endl;
1805 oss << "m_sliceHorizontalPosition: " << +sliceControl->m_sliceHorizontalPosition << std::endl;
1806 oss << "m_sliceVerticalPosition: " << +sliceControl->m_sliceVerticalPosition << std::endl;
1807 oss << "m_quantiserScaleCode: " << +sliceControl->m_quantiserScaleCode << std::endl;
1808 oss << "m_numMbsForSlice: " << +sliceControl->m_numMbsForSlice << std::endl;
1809 oss << "m_numMbsForSliceOverflow: " << +sliceControl->m_numMbsForSliceOverflow << std::endl;
1810 oss << "m_reservedBits: " << +sliceControl->m_reservedBits << std::endl;
1811 oss << "m_startCodeBitOffset: " << +sliceControl->m_startCodeBitOffset << std::endl;
1812
1813 std::ofstream ofs;
1814 if (i == 0)
1815 {
1816 ofs.open(fileName, std::ios::out);
1817 }
1818 else
1819 {
1820 ofs.open(fileName, std::ios::app);
1821 }
1822 ofs << oss.str();
1823 ofs.close();
1824 }
1825
1826 return MOS_STATUS_SUCCESS;
1827 }
1828
1829 MOS_STATUS CodechalDecodeMpeg2::DumpIQParams(
1830 CodecMpeg2IqMatrix *matrixData)
1831 {
1832 CODECHAL_DEBUG_FUNCTION_ENTER;
1833
1834 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
1835 {
1836 return MOS_STATUS_SUCCESS;
1837 }
1838
1839 CODECHAL_DEBUG_CHK_NULL(matrixData);
1840
1841 std::ostringstream oss;
1842 oss.setf(std::ios::showbase | std::ios::uppercase);
1843
1844 if (matrixData->m_loadIntraQuantiserMatrix)
1845 {
1846 oss << "intra_QmatrixData:" << std::endl;
1847
1848 for (uint8_t i = 0; i < 56; i += 8)
1849 {
1850 oss << "Qmatrix[" << +i / 8 << "]: ";
1851 for (uint8_t j = 0; j < 8; j++)
1852 oss << +matrixData->m_intraQuantiserMatrix[i + j] << " ";
1853 oss << std::endl;
1854 }
1855 }
1856 if (matrixData->m_loadNonIntraQuantiserMatrix)
1857 {
1858 oss << "non_intra_QmatrixData:" << std::endl;
1859
1860 for (uint8_t i = 0; i < 56; i += 8)
1861 {
1862 oss << "Qmatrix[" << +i / 8 << "]: ";
1863 for (uint8_t j = 0; j < 8; j++)
1864 oss << +matrixData->m_nonIntraQuantiserMatrix[i + j] << " ";
1865 oss << std::endl;
1866 }
1867 }
1868 if (matrixData->m_loadChromaIntraQuantiserMatrix)
1869 {
1870 oss << "chroma_intra_QmatrixData:" << std::endl;
1871
1872 for (uint8_t i = 0; i < 56; i += 8)
1873 {
1874 oss << "Qmatrix[" << +i / 8 << "]: ";
1875 for (uint8_t j = 0; j < 8; j++)
1876 oss << +matrixData->m_chromaIntraQuantiserMatrix[i + j] << " ";
1877 oss << std::endl;
1878 }
1879 }
1880 if (matrixData->m_loadChromaNonIntraQuantiserMatrix)
1881 {
1882 oss << "chroma_non_intra_QmatrixData:" << std::endl;
1883
1884 for (uint8_t i = 0; i < 56; i += 8)
1885 {
1886 oss << "Qmatrix[" << +i / 8 << "]: ";
1887 for (uint8_t j = 0; j < 8; j++)
1888 oss << +matrixData->m_chromaNonIntraQuantiserMatrix[i + j] << " ";
1889 oss << std::endl;
1890 }
1891 }
1892
1893 const char *fileName = m_debugInterface->CreateFileName(
1894 "_DEC",
1895 CodechalDbgBufferType::bufIqParams,
1896 CodechalDbgExtType::txt);
1897
1898 std::ofstream ofs(fileName, std::ios::out);
1899 ofs << oss.str();
1900 ofs.close();
1901
1902 return MOS_STATUS_SUCCESS;
1903 }
1904
1905 MOS_STATUS CodechalDecodeMpeg2::DumpMbParams(
1906 CodecDecodeMpeg2MbParams *mbParams)
1907 {
1908 CODECHAL_DEBUG_FUNCTION_ENTER;
1909
1910 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrMbParams))
1911 {
1912 return MOS_STATUS_SUCCESS;
1913 }
1914
1915 CODECHAL_DEBUG_CHK_NULL(mbParams);
1916
1917 std::ostringstream oss;
1918 oss.setf(std::ios::showbase | std::ios::uppercase);
1919
1920 oss << "m_mbAddr: " << +mbParams->m_mbAddr << std::endl;
1921 //Dump union MBType
1922 oss << "MBType.m_intraMb: " << +mbParams->MBType.m_intraMb << std::endl;
1923 oss << "MBType.m_motionFwd: " << +mbParams->MBType.m_motionFwd << std::endl;
1924 oss << "MBType.m_motionBwd: " << +mbParams->MBType.m_motionBwd << std::endl;
1925 oss << "MBType.m_motion4mv: " << +mbParams->MBType.m_motion4mv << std::endl;
1926 oss << "MBType.m_h261Lpfilter: " << +mbParams->MBType.m_h261Lpfilter << std::endl;
1927 oss << "MBType.m_fieldResidual: " << +mbParams->MBType.m_fieldResidual << std::endl;
1928 oss << "MBType.m_mbScanMethod: " << +mbParams->MBType.m_mbScanMethod << std::endl;
1929 oss << "MBType.m_motionType: " << +mbParams->MBType.m_motionType << std::endl;
1930 oss << "MBType.m_hostResidualDiff: " << +mbParams->MBType.m_hostResidualDiff << std::endl;
1931 oss << "MBType.m_mvertFieldSel: " << +mbParams->MBType.m_mvertFieldSel << std::endl;
1932 oss << "m_mbSkipFollowing: " << +mbParams->m_mbSkipFollowing << std::endl;
1933 oss << "m_mbDataLoc: " << +mbParams->m_mbDataLoc << std::endl;
1934 oss << "m_codedBlockPattern: " << +mbParams->m_codedBlockPattern << std::endl;
1935
1936 //Dump NumCoeff[CODEC_NUM_BLOCK_PER_MB]
1937 for (uint16_t i = 0; i < CODEC_NUM_BLOCK_PER_MB; ++i)
1938 {
1939 oss << "m_numCoeff[" << +i << "]: " << +mbParams->m_numCoeff[i] << std::endl;
1940 }
1941
1942 //Dump motion_vectors[8],printing them in 4 value chunks per line
1943 for (uint8_t i = 0; i < 2; ++i)
1944 {
1945 oss << "m_motionVectors[" << +i * 4 << "-" << (+i * 4) + 3 << "]: ";
1946 for (uint8_t j = 0; j < 4; j++)
1947 oss << +mbParams->m_motionVectors[i * 4 + j] << " ";
1948 oss << std::endl;
1949 }
1950
1951 const char *fileName = m_debugInterface->CreateFileName(
1952 "_DEC",
1953 CodechalDbgBufferType::bufMbParams,
1954 CodechalDbgExtType::txt);
1955
1956 std::ofstream ofs(fileName, std::ios::out);
1957 ofs << oss.str();
1958 ofs.close();
1959 return MOS_STATUS_SUCCESS;
1960 }
1961
1962 #endif