Debian Codegraph @

media_driver/agnostic/gen11/codec/hal/codechal_decode_vp8_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_vp8_g11.cpp
24 //! \brief Implements the decode interface extension for VP8.
25 //! \details Implements all functions and constants required by CodecHal for VP8 decoding.
26 //!
27
28 #include "codechal_decoder.h"
29 #include "codechal_decode_vp8_g11.h"
30 #include "mhw_vdbox_mfx_g11_X.h"
31 #include "hal_oca_interface.h"
32
33 CodechalDecodeVp8G11::~CodechalDecodeVp8G11()
34 {
35 CODECHAL_DECODE_FUNCTION_ENTER;
36
37 if (m_veState != nullptr)
38 {
39 MOS_FreeMemAndSetNull(m_veState);
40 m_veState = nullptr;
41 }
42 }
43
44 MOS_STATUS CodechalDecodeVp8G11::SetGpuCtxCreatOption(
45 CodechalSetting * codecHalSetting)
46 {
47 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
48
49 CODECHAL_DECODE_FUNCTION_ENTER;
50
51 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
52 {
53 CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
54 }
55 else
56 {
57 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
58
59 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
60 m_veState,
61 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
62 false));
63 m_videoContext = MOS_GPU_CONTEXT_VIDEO; // Move functionality to CodecHalDecodeMapGpuNodeToGpuContex
64 }
65 return eStatus;
66 }
67
68 MOS_STATUS CodechalDecodeVp8G11::SetFrameStates()
69 {
70 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
71
72 CODECHAL_DECODE_FUNCTION_ENTER;
73
74 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVp8::SetFrameStates());
75
76 if ( MOS_VE_SUPPORTED(m_osInterface))
77 {
78 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
79 {
80 MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
81
82 MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
83 vesetParams.bSFCInUse = false;
84 vesetParams.bNeedSyncWithPrevious = true;
85 vesetParams.bSameEngineAsLastSubmission = false;
86 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_veState, &vesetParams));
87 }
88 }
89
90 return eStatus;
91 }
92
93 MOS_STATUS CodechalDecodeVp8G11::DecodeStateLevel()
94 {
95 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
96
97 CODECHAL_DECODE_FUNCTION_ENTER;
98
99 PCODEC_REF_LIST *vp8RefList = m_vp8RefList;
100
101 uint8_t lastRefPicIndex = m_vp8PicParams->ucLastRefPicIndex;
102 uint8_t goldenRefPicIndex = m_vp8PicParams->ucGoldenRefPicIndex;
103 uint8_t altRefPicIndex = m_vp8PicParams->ucAltRefPicIndex;
104
105 PMOS_SURFACE destSurface = &m_destSurface;
106 if (m_vp8PicParams->key_frame) // reference surface should be nullptr when key_frame == true
107 {
108 m_presLastRefSurface = nullptr;
109 m_presGoldenRefSurface = nullptr;
110 m_presAltRefSurface = nullptr;
111 }
112 else
113 {
114 if((Mos_ResourceIsNull(&vp8RefList[m_vp8PicParams->ucLastRefPicIndex]->resRefPic)) && (m_presLastRefSurface))
115 {
116 vp8RefList[m_vp8PicParams->ucLastRefPicIndex]->resRefPic = *m_presLastRefSurface;
117 }
118 else
119 {
120 m_presLastRefSurface = &(vp8RefList[lastRefPicIndex]->resRefPic);
121 }
122 if((Mos_ResourceIsNull(&vp8RefList[m_vp8PicParams->ucGoldenRefPicIndex]->resRefPic)) && (m_presGoldenRefSurface))
123 {
124 vp8RefList[m_vp8PicParams->ucGoldenRefPicIndex]->resRefPic = *m_presGoldenRefSurface;
125 }
126 else
127 {
128 m_presGoldenRefSurface = &(vp8RefList[goldenRefPicIndex]->resRefPic);
129 }
130 if((Mos_ResourceIsNull(&vp8RefList[m_vp8PicParams->ucAltRefPicIndex]->resRefPic)) && (m_presAltRefSurface))
131 {
132 vp8RefList[m_vp8PicParams->ucAltRefPicIndex]->resRefPic = *m_presAltRefSurface;
133 }
134 else
135 {
136 m_presAltRefSurface = &(vp8RefList[altRefPicIndex]->resRefPic);
137 }
138 }
139
140 MOS_COMMAND_BUFFER cmdBuffer;
141 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
142
143 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
144 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
145
146 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
147 pipeModeSelectParams.Mode = m_mode;
148 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
149 pipeModeSelectParams.bPostDeblockOutEnable = m_deblockingEnabled;
150 pipeModeSelectParams.bPreDeblockOutEnable = !m_deblockingEnabled;
151 pipeModeSelectParams.bShortFormatInUse = m_shortFormatInUse;
152
153 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
154 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
155 surfaceParams.Mode = m_mode;
156 surfaceParams.psSurface = destSurface;
157
158 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
159 pipeBufAddrParams.Mode = m_mode;
160 // MMC is only enabled for frame decoding and no interlaced support in VP8
161 // So no need to check frame/field type here.
162 if (m_deblockingEnabled)
163 {
164 pipeBufAddrParams.psPostDeblockSurface = destSurface;
165 }
166 else
167 {
168 pipeBufAddrParams.psPreDeblockSurface = destSurface;
169 }
170
171 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams));
172
173 // when there is no last, golden and alternate reference,
174 // the index is set to the destination frame index
175 pipeBufAddrParams.presReferences[CodechalDecodeLastRef] = m_presLastRefSurface;
176 pipeBufAddrParams.presReferences[CodechalDecodeGoldenRef] = m_presGoldenRefSurface;
177 pipeBufAddrParams.presReferences[CodechalDecodeAlternateRef] = m_presAltRefSurface;
178
179 pipeBufAddrParams.presMfdIntraRowStoreScratchBuffer = &m_resMfdIntraRowStoreScratchBuffer;
180 pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer = &m_resMfdDeblockingFilterRowStoreScratchBuffer;
181 if (m_streamOutEnabled)
182 {
183 pipeBufAddrParams.presStreamOutBuffer =
184 &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
185 }
186
187 // set all ref pic addresses to valid addresses for error concealment purpose
188 for (uint32_t i = 0; i <= CodechalDecodeAlternateRef; i++)
189 {
190 if (pipeBufAddrParams.presReferences[i] == nullptr &&
191 MEDIA_IS_WA(m_waTable, WaDummyReference) &&
192 !Mos_ResourceIsNull(&m_dummyReference.OsResource))
193 {
194 pipeBufAddrParams.presReferences[i] = &m_dummyReference.OsResource;
195 }
196 }
197
198 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(&pipeBufAddrParams));
199
200 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));
201
202 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
203 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
204 indObjBaseAddrParams.Mode = m_mode;
205 indObjBaseAddrParams.dwDataSize = m_dataSize;
206 indObjBaseAddrParams.presDataBuffer = &m_resDataBuffer;
207
208 MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams;
209 MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams));
210 bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer;
211 bspBufBaseAddrParams.presMprRowStoreScratchBuffer = &m_resMprRowStoreScratchBuffer;
212
213 MHW_VDBOX_VP8_PIC_STATE vp8PicState;
214 vp8PicState.pVp8PicParams = m_vp8PicParams;
215 vp8PicState.pVp8IqMatrixParams = m_vp8IqMatrixParams;
216 vp8PicState.presSegmentationIdStreamBuffer = &m_resSegmentationIdStreamBuffer;
217 vp8PicState.dwCoefProbTableOffset = 0;
218 vp8PicState.presCoefProbBuffer = &m_resCoefProbBuffer;
219
220 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
221 &cmdBuffer, true));
222
223 if (m_statusQueryReportingEnabled)
224 {
225 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer));
226 }
227
228 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
229
230 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams));
231
232 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams));
233
234 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams));
235
236 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(&cmdBuffer, &bspBufBaseAddrParams));
237
238 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVp8PicCmd(&cmdBuffer, &vp8PicState));
239
240 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
241
242 return eStatus;
243 }
244
245 MOS_STATUS CodechalDecodeVp8G11::DecodePrimitiveLevel()
246 {
247 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
248
249 CODECHAL_DECODE_FUNCTION_ENTER;
250
251 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
252
253 MOS_COMMAND_BUFFER cmdBuffer;
254 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
255
256 // Fill BSD Object Commands
257 MHW_VDBOX_VP8_BSD_PARAMS vp8BsdParams;
258 vp8BsdParams.pVp8PicParams = m_vp8PicParams;
259
260 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVp8BsdObjectCmd(&cmdBuffer, &vp8BsdParams));
261
262 // Check if destination surface needs to be synchronized
263 MOS_SYNC_PARAMS syncParams;
264 syncParams = g_cInitSyncParams;
265 syncParams.GpuContext = m_videoContext;
266 syncParams.presSyncResource = &m_destSurface.OsResource;
267 syncParams.bReadOnly = false;
268 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
269 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
270
271 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
272 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
273
274 // Update the resource tag (s/w tag) for On-Demand Sync
275 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
276
277 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
278 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
279
280 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
281
282 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
283 if (m_osInterface->bTagResourceSync)
284 {
285 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
286 }
287
288 if (m_statusQueryReportingEnabled)
289 {
290 CodechalDecodeStatusReport decodeStatusReport;
291
292 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
293 decodeStatusReport.m_currDecodedPic = m_vp8PicParams->CurrPic;
294 decodeStatusReport.m_currDeblockedPic = m_vp8PicParams->CurrPic;
295 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
296 decodeStatusReport.m_currDecodedPicRes = m_vp8RefList[m_vp8PicParams->CurrPic.FrameIdx]->resRefPic;
297 CODECHAL_DEBUG_TOOL(
298 decodeStatusReport.m_secondField = CodecHal_PictureIsBottomField(m_vp8PicParams->CurrPic);
299 decodeStatusReport.m_frameType = m_perfType;)
300 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer));
301 }
302
303 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
304
305 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
306
307 CODECHAL_DEBUG_TOOL(
308 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
309 &cmdBuffer,
310 CODECHAL_NUM_MEDIA_STATES,
311 "_DEC"));
312 )
313
314 if ( MOS_VE_SUPPORTED(m_osInterface))
315 {
316 CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, true);
317 }
318
319 if (m_huCCopyInUse)
320 {
321 syncParams = g_cInitSyncParams;
322 syncParams.GpuContext = m_videoContextForWa;
323 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
324
325 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
326
327 syncParams = g_cInitSyncParams;
328 syncParams.GpuContext = m_videoContext;
329 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
330
331 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
332
333 m_huCCopyInUse = false;
334 }
335
336 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
337
338 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
339
340 CODECHAL_DEBUG_TOOL(
341 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
342
343 if (m_statusQueryReportingEnabled)
344 {
345 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw));
346 }
347
348 // Needs to be re-set for Linux buffer re-use scenarios
349 m_vp8RefList[m_vp8PicParams->ucCurrPicIndex]->resRefPic =
350 m_destSurface.OsResource;
351
352 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
353 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
354
355 return eStatus;
356 }
357
358 MOS_STATUS CodechalDecodeVp8G11::AllocateStandard(
359 CodechalSetting * settings)
360 {
361 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
362
363 CODECHAL_DECODE_FUNCTION_ENTER;
364
365 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
366
367 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVp8::AllocateStandard(settings));
368
369 if ( MOS_VE_SUPPORTED(m_osInterface))
370 {
371 static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->DisableScalabilitySupport();
372
373 //single pipe VE initialize
374 m_veState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
375 CODECHAL_DECODE_CHK_NULL_RETURN(m_veState);
376 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_veState));
377 }
378
379 return eStatus;
380 }
381
382 CodechalDecodeVp8G11::CodechalDecodeVp8G11(
383 CodechalHwInterface *hwInterface,
384 CodechalDebugInterface* debugInterface,
385 PCODECHAL_STANDARD_INFO standardInfo) :
386 CodechalDecodeVp8(hwInterface, debugInterface, standardInfo)
387 {
388 CODECHAL_DECODE_FUNCTION_ENTER;
389
390 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
391
392 m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
393 }
394