Debian Codegraph @

media_driver/agnostic/gen11/codec/hal/codechal_decode_mpeg2_g11.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_g11.h"
30 #include "codechal_secure_decode_interface.h"
31 #include "mhw_vdbox_mfx_g11_X.h"
32 #include "hal_oca_interface.h"
33
34 CodechalDecodeMpeg2G11::~CodechalDecodeMpeg2G11 ()
35 {
36 CODECHAL_DECODE_FUNCTION_ENTER;
37
38 if (m_veState != nullptr)
39 {
40 MOS_FreeMemAndSetNull(m_veState);
41 m_veState = nullptr;
42 }
43 }
44
45 MOS_STATUS CodechalDecodeMpeg2G11::SetGpuCtxCreatOption(
46 CodechalSetting * codecHalSetting)
47 {
48 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
49
50 CODECHAL_DECODE_FUNCTION_ENTER;
51
52 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
53 {
54 CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
55 }
56 else
57 {
58 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
59
60 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
61 m_veState,
62 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
63 false));
64 m_videoContext = MOS_GPU_CONTEXT_VIDEO; // Move functionality to CodecHalDecodeMapGpuNodeToGpuContex
65 }
66 return eStatus;
67 }
68
69 MOS_STATUS CodechalDecodeMpeg2G11::SetFrameStates ()
70 {
71 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
72
73 CODECHAL_DECODE_FUNCTION_ENTER;
74
75 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeMpeg2::SetFrameStates());
76
77 if ( MOS_VE_SUPPORTED(m_osInterface))
78 {
79 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
80 {
81 MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
82
83 MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
84 vesetParams.bSFCInUse = false;
85 vesetParams.bNeedSyncWithPrevious = true;
86 vesetParams.bSameEngineAsLastSubmission = false;
87 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_veState, &vesetParams));
88 }
89 }
90
91 return eStatus;
92 }
93
94 MOS_STATUS CodechalDecodeMpeg2G11::DecodeStateLevel()
95 {
96 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
97
98 CODECHAL_DECODE_FUNCTION_ENTER;
99
100 uint8_t fwdRefIdx = (uint8_t)m_picParams->m_forwardRefIdx;
101 uint8_t bwdRefIdx = (uint8_t)m_picParams->m_backwardRefIdx;
102
103 // Do not use data that has not been initialized
104 if (CodecHal_PictureIsInvalid(m_mpeg2RefList[fwdRefIdx]->RefPic))
105 {
106 fwdRefIdx = m_picParams->m_currPic.FrameIdx;
107 }
108 if (CodecHal_PictureIsInvalid(m_mpeg2RefList[bwdRefIdx]->RefPic))
109 {
110 bwdRefIdx = m_picParams->m_currPic.FrameIdx;
111 }
112
113 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
114
115 MOS_COMMAND_BUFFER cmdBuffer;
116 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
117
118 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
119 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
120
121 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
122 &cmdBuffer, true));
123
124 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
125 pipeModeSelectParams.Mode = m_mode;
126 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
127 pipeModeSelectParams.bPostDeblockOutEnable = m_deblockingEnabled;
128 pipeModeSelectParams.bPreDeblockOutEnable = !m_deblockingEnabled;
129
130 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
131 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
132 surfaceParams.Mode = m_mode;
133 surfaceParams.psSurface = &m_destSurface;
134
135 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
136 pipeBufAddrParams.Mode = m_mode;
137 if (m_deblockingEnabled)
138 {
139 pipeBufAddrParams.psPostDeblockSurface = &m_destSurface;
140 }
141 else
142 {
143 pipeBufAddrParams.psPreDeblockSurface = &m_destSurface;
144 }
145
146 // when there is not a forward or backward reference,
147 // the index is set to the destination frame index
148 m_presReferences[CodechalDecodeFwdRefTop] =
149 m_presReferences[CodechalDecodeFwdRefBottom] =
150 m_presReferences[CodechalDecodeBwdRefTop] =
151 m_presReferences[CodechalDecodeBwdRefBottom] = &m_destSurface.OsResource;
152
153 if (fwdRefIdx < CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
154 {
155 m_presReferences[CodechalDecodeFwdRefTop] =
156 m_presReferences[CodechalDecodeFwdRefBottom] = &m_mpeg2RefList[fwdRefIdx]->resRefPic;
157 }
158 if (bwdRefIdx < CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
159 {
160 m_presReferences[CodechalDecodeBwdRefTop] =
161 m_presReferences[CodechalDecodeBwdRefBottom] = &m_mpeg2RefList[bwdRefIdx]->resRefPic;
162 }
163
164 // special case for second fields
165 if (m_picParams->m_secondField && m_picParams->m_pictureCodingType == P_TYPE)
166 {
167 if (m_picParams->m_topFieldFirst)
168 {
169 m_presReferences[CodechalDecodeFwdRefTop] =
170 &m_destSurface.OsResource;
171 }
172 else
173 {
174 m_presReferences[CodechalDecodeFwdRefBottom] =
175 &m_destSurface.OsResource;
176 }
177 }
178
179 // set all ref pic addresses to valid addresses for error concealment purpose
180 for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
181 {
182 if (m_presReferences[i] == nullptr &&
183 MEDIA_IS_WA(m_waTable, WaDummyReference) &&
184 !Mos_ResourceIsNull(&m_dummyReference.OsResource))
185 {
186 m_presReferences[i] = &m_dummyReference.OsResource;
187 }
188 }
189
190 CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
191 pipeBufAddrParams.presReferences,
192 sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC,
193 m_presReferences,
194 sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC));
195
196 pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer =
197 &m_resMfdDeblockingFilterRowStoreScratchBuffer;
198
199 if (m_streamOutEnabled)
200 {
201 pipeBufAddrParams.presStreamOutBuffer =
202 &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
203 }
204
205 pipeBufAddrParams.pDecodedReconParam = &surfaceParams;
206 pipeBufAddrParams.psRawSurface = nullptr;
207
208 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams, &cmdBuffer));
209
210 pipeBufAddrParams.pDecodedReconParam = nullptr;
211
212 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(&pipeBufAddrParams));
213
214 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));
215
216 CODECHAL_DEBUG_TOOL(
217 for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
218 {
219 if (pipeBufAddrParams.presReferences[i])
220 {
221 MOS_SURFACE dstSurface;
222
223 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
224 dstSurface.Format = Format_NV12;
225 dstSurface.OsResource = *(pipeBufAddrParams.presReferences[i]);
226 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
227 m_osInterface,
228 &dstSurface));
229
230 m_debugInterface->m_refIndex = (uint16_t)i;
231 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
232 &dstSurface,
233 CodechalDbgAttr::attrReferenceSurfaces,
234 "RefSurf"));
235 }
236 }
237 )
238
239 //set correctly indirect BSD object base address.
240 PMOS_RESOURCE indObjBase;
241 if (m_copiedDataBufferInUse)
242 {
243 indObjBase = &m_resCopiedDataBuffer[m_currCopiedData];
244 }
245 else
246 {
247 indObjBase = &m_resDataBuffer;
248 }
249
250 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
251 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
252 indObjBaseAddrParams.Mode = m_mode;
253 indObjBaseAddrParams.dwDataSize =
254 m_copiedDataBufferInUse ? m_copiedDataBufferSize : m_dataSize;
255 indObjBaseAddrParams.presDataBuffer = indObjBase;
256
257 MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams;
258 MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams));
259 bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer;
260
261 MHW_VDBOX_MPEG2_PIC_STATE mpeg2PicState;
262 mpeg2PicState.Mode = m_mode;
263 mpeg2PicState.pMpeg2PicParams = m_picParams;
264 mpeg2PicState.bDeblockingEnabled = m_deblockingEnabled;
265 mpeg2PicState.dwMPEG2ISliceConcealmentMode = m_mpeg2ISliceConcealmentMode;
266 mpeg2PicState.dwMPEG2PBSliceConcealmentMode = m_mpeg2PbSliceConcealmentMode;
267 mpeg2PicState.dwMPEG2PBSlicePredBiDirMVTypeOverride = m_mpeg2PbSlicePredBiDirMvTypeOverride;
268 mpeg2PicState.dwMPEG2PBSlicePredMVOverride = m_mpeg2PbSlicePredMvOverride;
269
270 MHW_VDBOX_QM_PARAMS qmParams;
271 qmParams.Standard = CODECHAL_MPEG2;
272 qmParams.pMpeg2IqMatrix = m_iqMatrixBuffer;
273
274 if (m_statusQueryReportingEnabled)
275 {
276 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(
277 &cmdBuffer));
278 }
279
280 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(
281 &cmdBuffer,
282 &pipeModeSelectParams));
283
284 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(
285 &cmdBuffer,
286 &surfaceParams));
287
288 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(
289 &cmdBuffer,
290 &pipeBufAddrParams));
291
292 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(
293 &cmdBuffer,
294 &indObjBaseAddrParams));
295
296 if (CodecHalIsDecodeModeVLD(m_mode))
297 {
298 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(
299 &cmdBuffer,
300 &bspBufBaseAddrParams));
301 }
302
303 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxMpeg2PicCmd(
304 &cmdBuffer,
305 &mpeg2PicState));
306
307 if (CodecHalIsDecodeModeVLD(m_mode))
308 {
309 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxQmCmd(
310 &cmdBuffer,
311 &qmParams));
312 }
313
314 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
315
316 return eStatus;
317 }
318
319 MOS_STATUS CodechalDecodeMpeg2G11::SliceLevel()
320 {
321 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
322
323 CODECHAL_DECODE_FUNCTION_ENTER;
324
325 if ((m_decodePhantomMbs) || (m_incompletePicture))
326 {
327 if (m_bbInUsePerFrame >= m_bbAllocated / CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP)
328 {
329 m_bbAllocated += CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP;
330 if (m_bbAllocated >= CODECHAL_DECODE_MPEG2_MAXIMUM_BATCH_BUFFERS)
331 {
332 CODECHAL_DECODE_ASSERTMESSAGE(
333 "The number of MPEG2 second level batch buffer is not big enough to hold the whole frame.");
334 return MOS_STATUS_EXCEED_MAX_BB_SIZE;
335 }
336
337 for (uint32_t i = 0; i < CODECHAL_DECODE_MPEG2_BATCH_BUFFERS_PER_GROUP; i++)
338 {
339 uint32_t j = m_bbAllocated - i - 1;
340 MOS_ZeroMemory(&m_mediaObjectBatchBuffer[j], sizeof(MHW_BATCH_BUFFER));
341
342 uint32_t size = m_standardDecodeSizeNeeded * m_picWidthInMb * m_picHeightInMb +
343 m_hwInterface->m_sizeOfCmdBatchBufferEnd;
344
345 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
346 m_osInterface,
347 &m_mediaObjectBatchBuffer[j],
348 nullptr,
349 size));
350 m_mediaObjectBatchBuffer[j].bSecondLevel = true;
351 }
352 }
353 }
354
355 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
356
357 MOS_COMMAND_BUFFER cmdBuffer;
358 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
359 m_osInterface,
360 &cmdBuffer,
361 0));
362
363 MHW_BATCH_BUFFER batchBuffer = m_mediaObjectBatchBuffer[m_bbInUse];
364
365 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
366 &cmdBuffer,
367 &batchBuffer));
368
369 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_LockBb(
370 m_osInterface,
371 &batchBuffer));
372
373 if (m_decodePhantomMbs)
374 {
375 CODECHAL_DECODE_CHK_STATUS_RETURN(InsertDummySlices(
376 &batchBuffer,
377 m_lastMbAddress,
378 m_picWidthInMb * m_picHeightInMb));
379 }
380 else
381 {
382 CodecDecodeMpeg2SliceParams *slc = m_sliceParams;
383
384 uint16_t prevSliceMBEnd = m_lastMbAddress;
385
386 for (uint16_t slcCount = 0; slcCount < m_numSlices; slcCount++)
387 {
388 if (!m_vldSliceRecord[slcCount].dwSkip)
389 {
390 if (prevSliceMBEnd != m_vldSliceRecord[slcCount].dwSliceStartMbOffset)
391 {
392 CODECHAL_DECODE_CHK_STATUS_RETURN(InsertDummySlices(
393 &batchBuffer,
394 prevSliceMBEnd,
395 (uint16_t)m_vldSliceRecord[slcCount].dwSliceStartMbOffset));
396 }
397
398 if (m_vldSliceRecord[slcCount].bIsLastSlice)
399 {
400 uint16_t expectedFinalMb = m_picWidthInMb * m_picHeightInMb;
401
402 m_lastMbAddress =
403 (uint16_t)(m_vldSliceRecord[slcCount].dwSliceStartMbOffset +
404 slc->m_numMbsForSlice);
405
406 if (m_lastMbAddress < expectedFinalMb)
407 {
408 m_incompletePicture = true;
409 m_vldSliceRecord[slcCount].bIsLastSlice = false;
410 }
411 else
412 {
413 //Indicate It's complete picture now
414 m_incompletePicture = false;
415 }
416 }
417
418 // static MPEG2 slice parameters
419 MHW_VDBOX_MPEG2_SLICE_STATE mpeg2SliceState;
420 mpeg2SliceState.presDataBuffer = &m_resDataBuffer;
421 mpeg2SliceState.wPicWidthInMb = m_picWidthInMb;
422 mpeg2SliceState.wPicHeightInMb = m_picHeightInMb;
423 mpeg2SliceState.pMpeg2SliceParams = slc;
424 mpeg2SliceState.dwLength = m_vldSliceRecord[slcCount].dwLength;
425 mpeg2SliceState.dwOffset =
426 m_vldSliceRecord[slcCount].dwOffset + m_copiedDataOffset;
427 mpeg2SliceState.dwSliceStartMbOffset = m_vldSliceRecord[slcCount].dwSliceStartMbOffset;
428 mpeg2SliceState.bLastSlice = m_vldSliceRecord[slcCount].bIsLastSlice;
429
430 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdMpeg2BsdObject(
431 nullptr,
432 &batchBuffer,
433 &mpeg2SliceState));
434
435 prevSliceMBEnd =
436 (uint16_t)(m_vldSliceRecord[slcCount].dwSliceStartMbOffset +
437 slc->m_numMbsForSlice);
438 }
439
440 slc++;
441 }
442 }
443
444 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
445 nullptr,
446 &batchBuffer));
447
448 CODECHAL_DEBUG_TOOL(
449 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
450 &batchBuffer,
451 CODECHAL_NUM_MEDIA_STATES,
452 "_DEC"));
453 )
454
455 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_UnlockBb(
456 m_osInterface,
457 &batchBuffer,
458 true));
459
460 m_bbInUse = (m_bbInUse + 1) % m_bbAllocated;
461 m_bbInUsePerFrame++;
462
463 if (!m_incompletePicture)
464 {
465 // Check if destination surface needs to be synchronized
466 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
467 syncParams.GpuContext = m_videoContext;
468 syncParams.presSyncResource = &m_destSurface.OsResource;
469 syncParams.bReadOnly = false;
470 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
471 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
472
473 if (!CodecHal_PictureIsField(m_picParams->m_currPic) ||
474 !m_picParams->m_secondField)
475 {
476 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(
477 m_osInterface,
478 &syncParams));
479 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(
480 m_osInterface,
481 &syncParams));
482
483 // Update the resource tag (s/w tag) for On-Demand Sync
484 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
485 }
486
487 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
488 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
489
490 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
491 &cmdBuffer,
492 &flushDwParams));
493
494 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
495 if (m_osInterface->bTagResourceSync &&
496 (!CodecHal_PictureIsField(m_picParams->m_currPic) || m_picParams->m_secondField))
497 {
498 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
499 &cmdBuffer,
500 &syncParams));
501 }
502
503 if (m_statusQueryReportingEnabled)
504 {
505 CodechalDecodeStatusReport decodeStatusReport;
506
507 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
508 decodeStatusReport.m_currDecodedPic = m_picParams->m_currPic;
509 decodeStatusReport.m_currDeblockedPic = m_picParams->m_currPic;
510 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
511 decodeStatusReport.m_currDecodedPicRes = m_mpeg2RefList[m_picParams->m_currPic.FrameIdx]->resRefPic;
512
513 CODECHAL_DEBUG_TOOL(
514 decodeStatusReport.m_secondField = m_picParams->m_secondField ? true : false;
515 decodeStatusReport.m_frameType = m_perfType;)
516
517 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
518 decodeStatusReport,
519 &cmdBuffer));
520 }
521
522 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
523 &cmdBuffer,
524 nullptr));
525
526 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
527
528 CODECHAL_DEBUG_TOOL(
529 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
530 &cmdBuffer,
531 CODECHAL_NUM_MEDIA_STATES,
532 "_DEC"));
533
534 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
535 // m_debugInterface,
536 // &cmdBuffer));
537 )
538
539 //Sync up complete frame
540 syncParams = g_cInitSyncParams;
541 syncParams.GpuContext = m_videoContextForWa;
542 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
543
544 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
545
546 syncParams = g_cInitSyncParams;
547 syncParams.GpuContext = m_videoContext;
548 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
549
550 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
551
552 if (MOS_VE_SUPPORTED(m_osInterface))
553 {
554 CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, true);
555 }
556
557 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
558
559 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
560 m_osInterface,
561 &cmdBuffer,
562 m_videoContextUsesNullHw));
563
564 CODECHAL_DEBUG_TOOL(
565 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
566
567 if (m_statusQueryReportingEnabled)
568 {
569 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
570 m_videoContextUsesNullHw));
571 }
572
573 // Needs to be re-set for Linux buffer re-use scenarios
574 m_mpeg2RefList[m_picParams->m_currPic.FrameIdx]->resRefPic =
575 m_destSurface.OsResource;
576
577 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
578 if (!CodecHal_PictureIsField(m_picParams->m_currPic) || m_picParams->m_secondField)
579 {
580 syncParams = g_cInitSyncParams;
581 syncParams.GpuContext = m_videoContext;
582 syncParams.presSyncResource = &m_destSurface.OsResource;
583
584 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
585 }
586 }
587 else
588 {
589 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
590 }
591
592 return eStatus;
593 }
594
595 MOS_STATUS CodechalDecodeMpeg2G11::AllocateStandard (
596 CodechalSetting * settings)
597 {
598 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
599
600 CODECHAL_DECODE_FUNCTION_ENTER;
601
602 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeMpeg2::AllocateStandard(
603 settings));
604
605 if ( MOS_VE_SUPPORTED(m_osInterface))
606 {
607 static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->DisableScalabilitySupport();
608
609 //single pipe VE initialize
610 m_veState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
611 CODECHAL_DECODE_CHK_NULL_RETURN(m_veState);
612 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_veState));
613 }
614
615 return eStatus;
616 }
617
618 CodechalDecodeMpeg2G11::CodechalDecodeMpeg2G11 (
619 CodechalHwInterface *hwInterface,
620 CodechalDebugInterface* debugInterface,
621 PCODECHAL_STANDARD_INFO standardInfo) :
622 CodechalDecodeMpeg2(hwInterface, debugInterface, standardInfo)
623 {
624 CODECHAL_DECODE_FUNCTION_ENTER;
625
626 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
627
628 m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
629 }
630