1 /*
2 * Copyright (c) 2017-2021, 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_g12.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_g12.h"
29 #include "codechal_secure_decode_interface.h"
30 #include "codechal_decode_histogram.h"
31 #include "mhw_vdbox_mfx_g12_X.h"
32 #include "codechal_mmc_decode_avc_g12.h"
33 #include "hal_oca_interface.h"
34 #include "mos_os_cp_interface_specific.h"
35 
AllocateStandard(CodechalSetting * settings)36 MOS_STATUS CodechalDecodeAvcG12::AllocateStandard(
37     CodechalSetting *          settings)
38 {
39     CODECHAL_DECODE_FUNCTION_ENTER;
40 
41     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
42 
43     CODECHAL_DECODE_CHK_NULL_RETURN(settings);
44 
45     CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeAvc::AllocateStandard(settings));
46 #ifdef _MMC_SUPPORTED
47     // To WA invalid aux data caused HW issue when MMC on
48     // Add disable Clear CCS WA due to green corruption issue
49     if (m_mmc->IsMmcEnabled())
50     {
51         if (MEDIA_IS_WA(m_waTable, Wa_1408785368) || MEDIA_IS_WA(m_waTable, Wa_22010493002) && (!MEDIA_IS_WA(m_waTable, WaDisableClearCCS)))
52         {
53             //Add HUC STATE Commands
54             MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
55 
56             m_hwInterface->GetHucStateCommandSize(
57                 CODECHAL_DECODE_MODE_AVCVLD,
58                 &m_HucStateCmdBufferSizeNeeded,
59                 &m_HucPatchListSizeNeeded,
60                 &stateCmdSizeParams);
61         }
62     }
63 #endif
64 
65     if ( MOS_VE_SUPPORTED(m_osInterface))
66     {
67         static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->DisableScalabilitySupport();
68 
69         //single pipe VE initialize
70         m_veState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
71         CODECHAL_DECODE_CHK_NULL_RETURN(m_veState);
72         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_veState));
73     }
74 
75     return eStatus;
76 }
77 
InitSfcState()78 MOS_STATUS CodechalDecodeAvcG12::InitSfcState()
79 {
80 #ifdef _DECODE_PROCESSING_SUPPORTED
81     m_sfcState = MOS_New(CodechalAvcSfcStateG12);
82     CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
83     CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
84         this,
85         m_hwInterface,
86         m_osInterface));
87 #endif
88     return MOS_STATUS_SUCCESS;
89 }
90 
~CodechalDecodeAvcG12()91 CodechalDecodeAvcG12::~CodechalDecodeAvcG12()
92 {
93     CODECHAL_DECODE_FUNCTION_ENTER;
94 
95     if (m_veState)
96     {
97         MOS_FreeMemAndSetNull(m_veState);
98         m_veState = nullptr;
99     }
100 
101     if (m_histogramSurface)
102     {
103         if (!Mos_ResourceIsNull(&m_histogramSurface->OsResource))
104         {
105             m_osInterface->pfnFreeResource(
106                 m_osInterface,
107                 &m_histogramSurface->OsResource);
108         }
109 
110         MOS_FreeMemory(m_histogramSurface);
111         m_histogramSurface = nullptr;
112     }
113 
114     return;
115 }
116 
InitMmcState()117 MOS_STATUS CodechalDecodeAvcG12::InitMmcState()
118 {
119 #ifdef _MMC_SUPPORTED
120     m_mmc = MOS_New(CodechalMmcDecodeAvcG12, m_hwInterface, this);
121     CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
122 #endif
123 
124     if (m_osInterface->pfnIsMismatchOrderProgrammingSupported())
125     {
126         m_mmc->SetMmcDisabled();
127     }
128 
129     return MOS_STATUS_SUCCESS;
130 }
131 
SetGpuCtxCreatOption(CodechalSetting * codecHalSetting)132 MOS_STATUS CodechalDecodeAvcG12::SetGpuCtxCreatOption(
133     CodechalSetting *codecHalSetting)
134 {
135     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
136 
137     CODECHAL_DECODE_FUNCTION_ENTER;
138 
139     if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
140     {
141         CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
142     }
143     else
144     {
145         m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
146         bool sfcInUse    = (codecHalSetting->sfcInUseHinted && codecHalSetting->downsamplingHinted
147                             && (MEDIA_IS_SKU(m_skuTable, FtrSFCPipe) && !MEDIA_IS_SKU(m_skuTable, FtrDisableVDBox2SFC)));
148         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
149             m_veState,
150             (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
151             sfcInUse));
152         m_videoContext = MOS_GPU_CONTEXT_VIDEO;
153     }
154 
155     return eStatus;
156 }
157 
AllocateHistogramSurface()158 MOS_STATUS CodechalDecodeAvcG12::AllocateHistogramSurface()
159 {
160     MOS_ALLOC_GFXRES_PARAMS allocParams;
161 
162     if (m_histogramSurface == nullptr)
163     {
164         m_histogramSurface = (MOS_SURFACE*)MOS_AllocAndZeroMemory(sizeof(MOS_SURFACE));
165         CODECHAL_DECODE_CHK_NULL_RETURN(m_histogramSurface);
166 
167         MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
168         allocParams.Type = MOS_GFXRES_BUFFER;
169         allocParams.TileType = MOS_TILE_LINEAR;
170         allocParams.Format = Format_Buffer;
171         allocParams.dwBytes = 256 * 4;
172         allocParams.pBufName = "HistogramStreamOut";
173 
174         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
175             m_osInterface,
176             &allocParams,
177             &m_histogramSurface->OsResource));
178 
179         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
180             m_osInterface,
181             m_histogramSurface));
182     }
183 
184     if (m_decodeHistogram)
185         m_decodeHistogram->SetSrcHistogramSurface(m_histogramSurface);
186 
187     return MOS_STATUS_SUCCESS;
188 }
189 
CalcRequestedSpace(uint32_t & requestedSize,uint32_t & additionalSizeNeeded,uint32_t & requestedPatchListSize)190 void CodechalDecodeAvcG12::CalcRequestedSpace(
191     uint32_t &requestedSize,
192     uint32_t &additionalSizeNeeded,
193     uint32_t &requestedPatchListSize)
194 {
195     CODECHAL_DECODE_FUNCTION_ENTER;
196 
197     requestedSize          = m_commandBufferSizeNeeded + m_HucStateCmdBufferSizeNeeded +
198                     (m_standardDecodeSizeNeeded * (m_decodeParams.m_numSlices + 1));
199     requestedPatchListSize = m_commandPatchListSizeNeeded + m_HucPatchListSizeNeeded +
200                              (m_standardDecodePatchListSizeNeeded * (m_decodeParams.m_numSlices + 1));
201     additionalSizeNeeded = COMMAND_BUFFER_RESERVED_SPACE;
202 
203 }
204 
SetFrameStates()205 MOS_STATUS CodechalDecodeAvcG12::SetFrameStates()
206 {
207     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
208 
209     CODECHAL_DECODE_FUNCTION_ENTER;
210 
211     if (m_secureDecoder)
212     {
213         m_secureDecoder->EnableSampleGroupConstantIV();
214     }
215 
216 #ifdef _DECODE_PROCESSING_SUPPORTED
217     if (m_decodeParams.m_procParams)
218     {
219         CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateHistogramSurface());
220 
221         ((DecodeProcessingParams*)m_decodeParams.m_procParams)->m_histogramSurface = m_histogramSurface;
222 
223         if (m_decodeHistogram)
224             m_decodeHistogram->SetSrcHistogramSurface(m_histogramSurface);
225 
226     }
227 #endif
228 
229     CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeAvc::SetFrameStates());
230 
231     if (MOS_VE_SUPPORTED(m_osInterface) && !MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
232     {
233         MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
234 
235         MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
236 #ifdef _DECODE_PROCESSING_SUPPORTED
237         vesetParams.bSFCInUse = m_sfcState->m_sfcPipeOut;
238 #else
239         vesetParams.bSFCInUse                   = false;
240 #endif
241         vesetParams.bNeedSyncWithPrevious = true;
242         vesetParams.bSameEngineAsLastSubmission = false;
243         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_veState, &vesetParams));
244     }
245 
246     return eStatus;
247 }
248 
DecodeStateLevel()249 MOS_STATUS CodechalDecodeAvcG12::DecodeStateLevel()
250 {
251     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
252 
253     CODECHAL_DECODE_FUNCTION_ENTER;
254 
255 #ifdef _MMC_SUPPORTED
256     // To WA invalid aux data caused HW issue when MMC on
257     // Add disable Clear CCS WA due to green corruption issue
258     if (m_mmc->IsMmcEnabled() && m_decodeParams.m_destSurface && !Mos_ResourceIsNull(&m_decodeParams.m_destSurface->OsResource) &&
259         m_decodeParams.m_destSurface->OsResource.bConvertedFromDDIResource)
260     {
261         if (MEDIA_IS_WA(m_waTable, Wa_1408785368) || MEDIA_IS_WA(m_waTable, Wa_22010493002) && (!MEDIA_IS_WA(m_waTable, WaDisableClearCCS)))
262         {
263             if (m_secureDecoder && m_secureDecoder->IsAuxDataInvalid(&m_decodeParams.m_destSurface->OsResource))
264             {
265                 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->InitAuxSurface(&m_decodeParams.m_destSurface->OsResource, false, true));
266             }
267             else
268             {
269                 CODECHAL_DECODE_VERBOSEMESSAGE("Clear CCS by VE resolve before frame %d submission", m_frameNum);
270                 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<CodecHalMmcStateG12 *>(m_mmc)->ClearAuxSurf(
271                     this, m_miInterface, &m_decodeParams.m_destSurface->OsResource, m_veState));
272             }
273         }
274 
275     }
276 #endif
277 
278     if (m_secureDecoder)
279     {
280         CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->Execute(this));
281     }
282 
283     MOS_COMMAND_BUFFER cmdBuffer;
284     CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
285 
286     auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
287     HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
288 
289     MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
290     MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
291     forceWakeupParams.bMFXPowerWellControl = true;
292     forceWakeupParams.bMFXPowerWellControlMask = true;
293     forceWakeupParams.bHEVCPowerWellControl = false;
294     forceWakeupParams.bHEVCPowerWellControlMask = true;
295     CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
296         &cmdBuffer,
297         &forceWakeupParams));
298 
299     CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
300         &cmdBuffer, true));
301 
302     PIC_MHW_PARAMS picMhwParams;
303     CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicMhwParams(&picMhwParams));
304 
305     if (m_cencBuf && m_cencBuf->checkStatusRequired)
306     {
307         CODECHAL_DECODE_COND_ASSERTMESSAGE((m_vdboxIndex > m_hwInterface->GetMfxInterface()->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
308         auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
309 
310         CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetCpInterface()->CheckStatusReportNum(
311             mmioRegisters,
312             m_cencBuf->bufIdx,
313             m_cencBuf->resStatus,
314             &cmdBuffer));
315     }
316 
317     if (m_statusQueryReportingEnabled)
318     {
319         CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer));
320     }
321 
322     CODECHAL_DECODE_CHK_STATUS_RETURN(AddPictureCmds(&cmdBuffer, &picMhwParams));
323 
324     m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
325 
326     return eStatus;
327 }
328 
DecodePrimitiveLevel()329 MOS_STATUS CodechalDecodeAvcG12::DecodePrimitiveLevel()
330 {
331     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
332     CODECHAL_DECODE_FUNCTION_ENTER;
333 
334     CODECHAL_DECODE_CHK_NULL_RETURN(m_avcPicParams);
335 
336     MOS_COMMAND_BUFFER cmdBuffer;
337     CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
338 
339     if (m_cencBuf)
340     {
341         CODECHAL_DECODE_CHK_STATUS_RETURN(SetCencBatchBuffer(&cmdBuffer));
342     }
343     else
344     {
345         CODECHAL_DECODE_CHK_STATUS_RETURN(ParseSlice(&cmdBuffer));
346     }
347 
348     // Check if destination surface needs to be synchronized
349     MOS_SYNC_PARAMS syncParams;
350     syncParams = g_cInitSyncParams;
351     syncParams.GpuContext = m_videoContext;
352     syncParams.presSyncResource         = &m_destSurface.OsResource;
353     syncParams.bReadOnly = false;
354     syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
355     syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
356 
357     if (!CodecHal_PictureIsField(m_avcPicParams->CurrPic) ||
358         !m_isSecondField)
359     {
360         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
361         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
362 
363         // Update the resource tag (s/w tag) for On-Demand Sync
364         m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
365     }
366 
367     MHW_MI_FLUSH_DW_PARAMS flushDwParams;
368     MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
369 
370     CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
371         &cmdBuffer,
372         &flushDwParams));
373 
374     // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
375     if (m_osInterface->bTagResourceSync &&
376         (!CodecHal_PictureIsField(m_avcPicParams->CurrPic) || m_isSecondField))
377     {
378         CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
379     }
380 
381     if (m_statusQueryReportingEnabled)
382     {
383         CodechalDecodeStatusReport decodeStatusReport;
384 
385         decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
386         decodeStatusReport.m_currDecodedPic     = m_avcPicParams->CurrPic;
387         decodeStatusReport.m_currDeblockedPic   = m_avcPicParams->CurrPic;
388         decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
389         decodeStatusReport.m_currDecodedPicRes  = m_avcRefList[m_avcPicParams->CurrPic.FrameIdx]->resRefPic;
390 
391         CODECHAL_DEBUG_TOOL(
392             if (m_streamOutEnabled) {
393                 // add current streamout buffer to the report and move onto the next one
394                 decodeStatusReport.m_streamOutBuf = &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
395                 decodeStatusReport.m_streamoutIdx = m_streamOutCurrBufIdx;
396                 if (++m_streamOutCurrBufIdx >= CODECHAL_DECODE_NUM_STREAM_OUT_BUFFERS)
397                 {
398                     m_streamOutCurrBufIdx = 0;
399                 }
400                 // check next buffer in the list is free.
401                 if (m_streamOutCurrStatusIdx[m_streamOutCurrBufIdx] != CODECHAL_DECODE_STATUS_NUM)
402                 {
403                     // We've run out of buffers. Temporarily lock the next one down to force a wait. Then mark it as free.
404                     CodechalResLock ResourceLock(m_osInterface, &(m_streamOutBuffer[m_streamOutCurrBufIdx]));
405                     ResourceLock.Lock(CodechalResLock::readOnly);
406 
407                     m_streamOutCurrStatusIdx[m_streamOutCurrBufIdx] = CODECHAL_DECODE_STATUS_NUM;
408                 }
409             }
410 
411             decodeStatusReport.m_secondField = m_secondField;
412             decodeStatusReport.m_frameType   = m_perfType;)
413 
414         CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer));
415     }
416 
417 #if (_DEBUG || _RELEASE_INTERNAL)
418     if (CodecHal_PictureIsFrame(m_crrPic) ||
419         CodecHal_PictureIsInterlacedFrame(m_crrPic) ||
420         m_secondField)
421     {
422         uint32_t curIdx = (GetDecodeStatusBuf()->m_currIndex + CODECHAL_DECODE_STATUS_NUM - 1) % CODECHAL_DECODE_STATUS_NUM;
423         uint32_t frameCrcOffset = curIdx * sizeof(CodechalDecodeStatus) + GetDecodeStatusBuf()->m_decFrameCrcOffset + sizeof(uint32_t) * 2;
424         std::vector<MOS_RESOURCE> vSemaResource{GetDecodeStatusBuf()->m_statusBuffer};
425         m_debugInterface->DetectCorruptionHw(m_hwInterface, &m_frameCountTypeBuf, curIdx, frameCrcOffset, vSemaResource, &cmdBuffer, m_frameNum);
426     }
427 #endif
428     if (!m_osInterface->pfnIsMismatchOrderProgrammingSupported())
429     {
430         CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
431     }
432 
433     m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
434 
435     bool syncCompleteFrame = (m_avcPicParams->seq_fields.chroma_format_idc == avcChromaFormatMono && !m_hwInterface->m_noHuC);
436     if (syncCompleteFrame)
437     {
438         syncParams = g_cInitSyncParams;
439         syncParams.GpuContext = m_videoContextForWa;
440         syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
441 
442         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
443 
444         syncParams = g_cInitSyncParams;
445         syncParams.GpuContext = m_videoContext;
446         syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
447 
448         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
449     }
450 
451     CODECHAL_DEBUG_TOOL(
452         CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
453             &cmdBuffer,
454             CODECHAL_NUM_MEDIA_STATES,
455             "_AVC_DECODE_0"));
456 
457     //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
458     //    m_debugInterface,
459     //    &cmdBuffer));
460     )
461 
462     if ( MOS_VE_SUPPORTED(m_osInterface))
463     {
464         CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, true);
465     }
466 
467     HalOcaInterface::DumpCodechalParam(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, m_pCodechalOcaDumper, CODECHAL_AVC);
468     HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
469 
470     CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
471 
472     CODECHAL_DEBUG_TOOL(
473         m_mmc->UpdateUserFeatureKey(&m_destSurface);)
474 #ifdef _DECODE_PROCESSING_SUPPORTED
475     auto decProcessingParams = (DecodeProcessingParams *)m_decodeParams.m_procParams;
476     if (decProcessingParams != nullptr && !m_sfcState->m_sfcPipeOut && (m_isSecondField || m_avcPicParams->seq_fields.mb_adaptive_frame_field_flag))
477     {
478 #ifdef _MMC_SUPPORTED
479         // To Clear invalid aux data of output surface when MMC on
480         if (m_mmc && m_mmc->IsMmcEnabled() &&
481             !Mos_ResourceIsNull(&decProcessingParams->m_outputSurface->OsResource) &&
482             decProcessingParams->m_outputSurface->OsResource.bConvertedFromDDIResource)
483         {
484             CODECHAL_DECODE_VERBOSEMESSAGE("Clear invalid aux data of output surface before frame %d submission", m_frameNum);
485             CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<CodecHalMmcStateG12 *>(m_mmc)->ClearAuxSurf(
486                 this, m_miInterface, &decProcessingParams->m_outputSurface->OsResource, m_veState));
487         }
488 #endif
489         CODECHAL_DECODE_CHK_STATUS_RETURN(m_fieldScalingInterface->DoFieldScaling(
490             decProcessingParams,
491             m_renderContext,
492             m_disableDecodeSyncLock,
493             m_disableLockForTranscode));
494     }
495     else
496 #endif
497     {
498         if (m_statusQueryReportingEnabled)
499         {
500             CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw));
501         }
502     }
503 
504     // Needs to be re-set for Linux buffer re-use scenarios
505     m_avcRefList[m_avcPicParams->CurrPic.FrameIdx]->resRefPic =
506         m_destSurface.OsResource;
507 
508     // Send the signal to indicate decode completion, in case On-Demand Sync is not present
509     if (!CodecHal_PictureIsField(m_avcPicParams->CurrPic) || m_isSecondField)
510     {
511         syncParams = g_cInitSyncParams;
512         syncParams.GpuContext = m_videoContext;
513         syncParams.presSyncResource = &m_destSurface.OsResource;
514 
515         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
516 #ifdef _DECODE_PROCESSING_SUPPORTED
517         if (decProcessingParams && !m_sfcState->m_sfcPipeOut)
518         {
519             syncParams = g_cInitSyncParams;
520             syncParams.GpuContext = m_renderContext;
521             syncParams.presSyncResource = &decProcessingParams->m_outputSurface->OsResource;
522 
523             CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
524         }
525 #endif
526     }
527 #ifdef _DECODE_PROCESSING_SUPPORTED
528     CODECHAL_DEBUG_TOOL(
529         // Dump out downsampling result
530         if (decProcessingParams && decProcessingParams->m_outputSurface)
531         {
532             MOS_SURFACE dstSurface;
533             MOS_ZeroMemory(&dstSurface, sizeof(dstSurface));
534             dstSurface.Format = Format_NV12;
535             dstSurface.OsResource = decProcessingParams->m_outputSurface->OsResource;
536 
537             CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
538                 m_osInterface,
539                 &dstSurface));
540 
541             CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
542                 &dstSurface,
543                 CodechalDbgAttr::attrSfcOutputSurface,
544                 "SfcDstSurf"));
545         }
546     )
547 #endif
548         return eStatus;
549 }
550 
CodechalDecodeAvcG12(CodechalHwInterface * hwInterface,CodechalDebugInterface * debugInterface,PCODECHAL_STANDARD_INFO standardInfo)551 CodechalDecodeAvcG12::CodechalDecodeAvcG12(
552     CodechalHwInterface *   hwInterface,
553     CodechalDebugInterface *debugInterface,
554     PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecodeAvc(hwInterface, debugInterface, standardInfo),
555                                             m_veState(nullptr)
556 {
557     CODECHAL_DECODE_FUNCTION_ENTER;
558 
559     CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
560 
561     m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
562 }
563 
FormatAvcMonoPicture(PMOS_SURFACE surface)564 MOS_STATUS CodechalDecodeAvcG12::FormatAvcMonoPicture(PMOS_SURFACE surface)
565 {
566     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
567 
568     PCODEC_AVC_PIC_PARAMS picParams = (PCODEC_AVC_PIC_PARAMS)m_avcPicParams;
569     if (picParams->seq_fields.chroma_format_idc != avcChromaFormatMono)
570     {
571         CODECHAL_DECODE_VERBOSEMESSAGE("None mono case");
572         return MOS_STATUS_SUCCESS;
573     }
574 
575     if (surface == nullptr || Mos_ResourceIsNull(&surface->OsResource))
576     {
577         CODECHAL_DECODE_ASSERTMESSAGE("Surface pointer is NULL!");
578         return MOS_STATUS_INVALID_PARAMETER;
579     }
580 
581 #ifdef _MMC_SUPPORTED
582     // Initialize the UV aux data of protected surfaces before HucCopy of UV plane
583     if (m_mmc && m_mmc->IsMmcEnabled() && !MEDIA_IS_WA(m_waTable, Wa_1408785368) &&
584         m_secureDecoder && m_osInterface->osCpInterface->IsHMEnabled())
585     {
586         CODECHAL_DECODE_VERBOSEMESSAGE("Initialize the UV aux data for %d submission", m_frameNum);
587         CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->InitAuxSurface(&surface->OsResource, true, true));
588     }
589 #endif
590 
591     return CodechalDecodeAvc::FormatAvcMonoPicture(surface);
592 }
593