Debian Codegraph @

media_driver/agnostic/gen12/codec/hal/codechal_decode_vc1_g12.cpp

raw
1 /*
2 * Copyright (c) 2017-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 //!
24 //! \file codechal_decode_vc1_g12.cpp
25 //! \brief Implements the decode interface extension for Gen12 VC1.
26 //! \details Implements all functions required by CodecHal for Gen12 VC1 decoding.
27 //!
28
29 #include "codeckrnheader.h"
30
31 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
32 #include "igcodeckrn_g12.h"
33 #endif
34
35 #include "codechal_decode_vc1_g12.h"
36 #include "codechal_secure_decode_interface.h"
37 #include "mhw_vdbox_mfx_g12_X.h"
38 #include "codechal_mmc_decode_vc1_g12.h"
39 #include "mhw_render_g12_X.h"
40 #include "hal_oca_interface.h"
41
42 MOS_STATUS CodechalDecodeVc1G12::InitMmcState()
43 {
44 m_mmc = MOS_New(CodechalMmcDecodeVc1G12, m_hwInterface, this);
45 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
46
47 return MOS_STATUS_SUCCESS;
48 }
49
50 MOS_STATUS CodechalDecodeVc1G12::AllocateStandard(
51 CodechalSetting * settings)
52 {
53 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
54
55 CODECHAL_DECODE_FUNCTION_ENTER;
56
57 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
58
59 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVc1::AllocateStandard(settings));
60
61 // Disable Decode MMC for IGFX
62 if (!MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrFlatPhysCCS))
63 {
64 m_mmc->SetMmcDisabled();
65 }
66
67 // To WA invalid aux data caused HW issue when MMC on
68 if (m_mmc->IsMmcEnabled() && (MEDIA_IS_WA(m_waTable, Wa_1408785368) || MEDIA_IS_WA(m_waTable, Wa_22010493002)))
69 {
70 //Add HUC STATE Commands
71 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
72
73 m_hwInterface->GetHucStateCommandSize(
74 CODECHAL_DECODE_MODE_VC1VLD,
75 &m_HucStateCmdBufferSizeNeeded,
76 &m_HucPatchListSizeNeeded,
77 &stateCmdSizeParams);
78 }
79
80 if ( MOS_VE_SUPPORTED(m_osInterface))
81 {
82 static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->DisableScalabilitySupport();
83
84 //single pipe VE initialize
85 m_veState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
86 CODECHAL_DECODE_CHK_NULL_RETURN(m_veState);
87 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_veState));
88 }
89
90 return eStatus;
91 }
92
93 MOS_STATUS CodechalDecodeVc1G12::SetGpuCtxCreatOption(
94 CodechalSetting *codecHalSetting)
95 {
96 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
97
98 CODECHAL_DECODE_FUNCTION_ENTER;
99
100 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
101 {
102 CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
103 }
104 else
105 {
106 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
107 bool sfcInUse = (codecHalSetting->sfcInUseHinted && codecHalSetting->downsamplingHinted
108 && (MEDIA_IS_SKU(m_skuTable, FtrSFCPipe) && !MEDIA_IS_SKU(m_skuTable, FtrDisableVDBox2SFC)));
109 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
110 m_veState,
111 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
112 sfcInUse));
113 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
114 }
115
116 return eStatus;
117 }
118
119 MOS_STATUS CodechalDecodeVc1G12::SetFrameStates()
120 {
121 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
122
123 CODECHAL_DECODE_FUNCTION_ENTER;
124
125 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVc1::SetFrameStates());
126
127 if (MOS_VE_SUPPORTED(m_osInterface) && !MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
128 {
129 MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
130
131 MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
132 vesetParams.bSFCInUse = false;
133 vesetParams.bNeedSyncWithPrevious = true;
134 vesetParams.bSameEngineAsLastSubmission = false;
135 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_veState, &vesetParams));
136 }
137
138 bool isBPicture = m_mfxInterface->IsVc1BPicture(
139 m_vc1PicParams->CurrPic,
140 m_vc1PicParams->picture_fields.is_first_field,
141 m_vc1PicParams->picture_fields.picture_type);
142
143 bool isOverlapSmoothingFilter = false;
144
145 isOverlapSmoothingFilter |= m_vc1PicParams->sequence_fields.AdvancedProfileFlag &&
146 m_vc1PicParams->sequence_fields.overlap;
147
148 isOverlapSmoothingFilter |= !(isBPicture ||
149 (m_vc1PicParams->pic_quantizer_fields.pic_quantizer_scale < 9) ||
150 !m_vc1PicParams->sequence_fields.overlap);
151
152 isOverlapSmoothingFilter |= m_intelEntrypointInUse &&
153 (m_mode == CODECHAL_DECODE_MODE_VC1VLD) &&
154 m_vc1PicParams->conditional_overlap_flag;
155
156 //For VC1 frame with overlap smoothing filter enabled, force to post-deblock if MMC on
157 if (m_mmc && m_mmc->IsMmcEnabled() && isOverlapSmoothingFilter)
158 {
159 m_deblockingEnabled = true;
160 }
161
162 return eStatus;
163 }
164
165 MOS_STATUS CodechalDecodeVc1G12::DecodeStateLevel()
166 {
167 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
168
169 CODECHAL_DECODE_FUNCTION_ENTER;
170
171 // To make sure aux table is clear when MMC off(IGFX)
172 // Can not clear aux table for DGFX because of stolen memory
173 if (!m_mmc->IsMmcEnabled() && !Mos_ResourceIsNull(&m_destSurface.OsResource) && m_destSurface.OsResource.bConvertedFromDDIResource)
174 {
175 if (m_secureDecoder && m_secureDecoder->IsAuxDataInvalid(&m_destSurface.OsResource))
176 {
177 // Not use CODECHAL_DECODE_CHK_STATUS_RETURN() here to avoid adding local variable
178 // Error can still be caught by CODECHAL_DECODE_CHK_STATUS_RETURN() in InitAuxSurface
179 CODECHAL_DECODE_VERBOSEMESSAGE("Clear CCS for secure decode before frame %d submission", m_frameNum);
180 CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->InitAuxSurface(&m_destSurface.OsResource, false, true));
181 }
182 else
183 {
184 CODECHAL_DECODE_VERBOSEMESSAGE("Clear CCS by Huc Copy before frame %d submission", m_frameNum);
185 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<CodecHalMmcStateG12 *>(m_mmc)->ClearAuxSurf(
186 this, m_miInterface, &m_destSurface.OsResource, m_veState));
187 }
188 }
189
190 PCODEC_REF_LIST *vc1RefList;
191 vc1RefList = &(m_vc1RefList[0]);
192
193 uint8_t destIdx = m_vc1PicParams->CurrPic.FrameIdx;
194 uint8_t fwdRefIdx = (uint8_t)m_vc1PicParams->ForwardRefIdx;
195 uint8_t bwdRefIdx = (uint8_t)m_vc1PicParams->BackwardRefIdx;
196
197 bool isIPicture = m_mfxInterface->IsVc1IPicture(
198 m_vc1PicParams->CurrPic,
199 m_vc1PicParams->picture_fields.is_first_field,
200 m_vc1PicParams->picture_fields.picture_type)
201 ? true
202 : false;
203 bool isPPicture = m_mfxInterface->IsVc1PPicture(
204 m_vc1PicParams->CurrPic,
205 m_vc1PicParams->picture_fields.is_first_field,
206 m_vc1PicParams->picture_fields.picture_type)
207 ? true
208 : false;
209 bool isBPicture = m_mfxInterface->IsVc1BPicture(
210 m_vc1PicParams->CurrPic,
211 m_vc1PicParams->picture_fields.is_first_field,
212 m_vc1PicParams->picture_fields.picture_type)
213 ? true
214 : false;
215
216 PMOS_SURFACE destSurface;
217 PMOS_RESOURCE fwdRefSurface, bwdRefSurface;
218 if (m_unequalFieldWaInUse && CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
219 {
220 destSurface =
221 &(m_unequalFieldSurface[vc1RefList[destIdx]->dwUnequalFieldSurfaceIdx]);
222 fwdRefSurface =
223 &(m_unequalFieldSurface[vc1RefList[fwdRefIdx]->dwUnequalFieldSurfaceIdx].OsResource);
224 bwdRefSurface =
225 &(m_unequalFieldSurface[vc1RefList[bwdRefIdx]->dwUnequalFieldSurfaceIdx].OsResource);
226
227 // Overwrite the actual surface height with the coded height and width of the frame
228 // for VC1 since it's possible for a VC1 frame to change size during playback
229 destSurface->dwWidth = m_width;
230 destSurface->dwHeight = m_height;
231 }
232 else
233 {
234 destSurface = &m_destSurface;
235 fwdRefSurface = &(vc1RefList[fwdRefIdx]->resRefPic);
236 bwdRefSurface = &(vc1RefList[bwdRefIdx]->resRefPic);
237 }
238
239 // WA for SP/MP short format
240 if (m_shortFormatInUse &&
241 !m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
242 {
243 CODECHAL_DECODE_CHK_STATUS_RETURN(ConstructBistreamBuffer());
244 }
245
246 MOS_COMMAND_BUFFER cmdBuffer;
247 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
248
249 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
250 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
251
252 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
253 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
254 forceWakeupParams.bMFXPowerWellControl = true;
255 forceWakeupParams.bMFXPowerWellControlMask = true;
256 forceWakeupParams.bHEVCPowerWellControl = false;
257 forceWakeupParams.bHEVCPowerWellControlMask = true;
258 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
259 &cmdBuffer,
260 &forceWakeupParams));
261
262 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
263 pipeModeSelectParams.Mode = m_mode;
264 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
265 pipeModeSelectParams.bPostDeblockOutEnable = m_deblockingEnabled;
266 pipeModeSelectParams.bPreDeblockOutEnable = !m_deblockingEnabled;
267 pipeModeSelectParams.bShortFormatInUse = m_shortFormatInUse;
268 pipeModeSelectParams.bVC1OddFrameHeight = m_vc1OddFrameHeight;
269
270 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
271 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
272 surfaceParams.Mode = m_mode;
273 surfaceParams.psSurface = destSurface;
274
275 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
276 pipeBufAddrParams.Mode = m_mode;
277 if (m_deblockingEnabled)
278 {
279 pipeBufAddrParams.psPostDeblockSurface = destSurface;
280 }
281 else
282 {
283 pipeBufAddrParams.psPreDeblockSurface = destSurface;
284 }
285
286 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams));
287
288 // when there is not a forward or backward reference,
289 // the index is set to the destination frame index
290 m_presReferences[CodechalDecodeFwdRefTop] =
291 m_presReferences[CodechalDecodeFwdRefBottom] =
292 fwdRefSurface;
293 m_presReferences[CodechalDecodeBwdRefTop] =
294 m_presReferences[CodechalDecodeBwdRefBottom] =
295 bwdRefSurface;
296 // special case for second fields
297 if (!m_vc1PicParams->picture_fields.is_first_field &&
298 !m_mfxInterface->IsVc1IPicture(
299 m_vc1PicParams->CurrPic,
300 m_vc1PicParams->picture_fields.is_first_field,
301 m_vc1PicParams->picture_fields.picture_type))
302 {
303 if (m_vc1PicParams->picture_fields.top_field_first)
304 {
305 m_presReferences[CodechalDecodeFwdRefTop] =
306 &destSurface->OsResource;
307 }
308 else
309 {
310 m_presReferences[CodechalDecodeFwdRefBottom] =
311 &destSurface->OsResource;
312 }
313 }
314
315 // set all ref pic addresses to valid addresses for error concealment purpose
316 for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
317 {
318 if (m_presReferences[i] == nullptr &&
319 MEDIA_IS_WA(m_waTable, WaDummyReference) &&
320 !Mos_ResourceIsNull(&m_dummyReference.OsResource))
321 {
322 m_presReferences[i] = &m_dummyReference.OsResource;
323 }
324 }
325
326 CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(pipeBufAddrParams.presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC, m_presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC));
327
328 pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer =
329 &m_resMfdDeblockingFilterRowStoreScratchBuffer;
330
331 if (m_streamOutEnabled)
332 {
333 pipeBufAddrParams.presStreamOutBuffer =
334 &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
335 }
336
337 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(&pipeBufAddrParams));
338
339 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));
340
341 CODECHAL_DEBUG_TOOL(
342 for (int i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
343 {
344 if (pipeBufAddrParams.presReferences[i])
345 {
346 MOS_SURFACE dstSurface;
347
348 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
349 dstSurface.Format = Format_NV12;
350 dstSurface.OsResource = *(pipeBufAddrParams.presReferences[i]);
351 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
352 m_osInterface,
353 &dstSurface));
354
355 m_debugInterface->m_refIndex = (uint16_t)i;
356 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex)) + "]";
357 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
358 &dstSurface,
359 CodechalDbgAttr::attrDecodeReferenceSurfaces,
360 refSurfName.data()));
361 }
362 }
363 )
364
365 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
366 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
367 indObjBaseAddrParams.Mode = m_mode;
368 if (m_shortFormatInUse &&
369 !m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
370 {
371 indObjBaseAddrParams.dwDataSize = m_dataSize + CODECHAL_DECODE_VC1_STUFFING_BYTES;
372 indObjBaseAddrParams.presDataBuffer = &m_resPrivateBistreamBuffer;
373 }
374 else
375 {
376 indObjBaseAddrParams.dwDataSize = m_dataSize;
377 indObjBaseAddrParams.presDataBuffer = &m_resDataBuffer;
378 }
379
380 MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams;
381 MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams));
382 bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer;
383
384 if (m_vc1PicParams->raw_coding.bitplane_present || m_shortFormatInUse)
385 {
386 bspBufBaseAddrParams.presBitplaneBuffer = &m_resBitplaneBuffer;
387 }
388
389 MHW_VDBOX_VC1_PRED_PIPE_PARAMS vc1PredPipeParams;
390 vc1PredPipeParams.pVc1PicParams = m_vc1PicParams;
391 vc1PredPipeParams.ppVc1RefList = vc1RefList;
392
393 MHW_VDBOX_VC1_PIC_STATE vc1PicState;
394 vc1PicState.pVc1PicParams = m_vc1PicParams;
395 vc1PicState.Mode = m_mode;
396 vc1PicState.ppVc1RefList = vc1RefList;
397 vc1PicState.wPrevAnchorPictureTFF = m_prevAnchorPictureTff;
398 vc1PicState.bPrevEvenAnchorPictureIsP = m_prevEvenAnchorPictureIsP;
399 vc1PicState.bPrevOddAnchorPictureIsP = m_prevOddAnchorPictureIsP;
400
401 if (m_shortFormatInUse)
402 {
403 // WA for WMP. WMP does not provide REFDIST for I/P pictures correctly
404 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag &&
405 CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
406 (isIPicture || isPPicture) &&
407 m_vc1PicParams->reference_fields.reference_distance_flag)
408 {
409 if (m_vc1PicParams->picture_fields.is_first_field)
410 {
411 CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeader());
412 m_referenceDistance = m_vc1PicParams->reference_fields.reference_distance;
413 }
414 else
415 {
416 m_vc1PicParams->reference_fields.reference_distance = m_referenceDistance;
417 }
418 }
419
420 // WA for WMP. WMP does not provide BFRACTION correctly. So parse picture header to get BFRACTION
421 if (isBPicture)
422 {
423 if (m_vc1PicParams->picture_fields.is_first_field)
424 {
425 CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeader());
426 }
427 }
428 }
429
430 MHW_VDBOX_VC1_DIRECTMODE_PARAMS vc1DirectmodeParams;
431 if (m_mode == CODECHAL_DECODE_MODE_VC1VLD)
432 {
433 uint8_t dmvBufferIdx = (m_vc1PicParams->CurrPic.PicFlags == PICTURE_BOTTOM_FIELD) ? CODECHAL_DECODE_VC1_DMV_ODD : CODECHAL_DECODE_VC1_DMV_EVEN;
434 vc1DirectmodeParams.presDmvReadBuffer = &m_resVc1BsdMvData[dmvBufferIdx];
435 vc1DirectmodeParams.presDmvWriteBuffer = &m_resVc1BsdMvData[dmvBufferIdx];
436 }
437
438 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, !m_olpNeeded));
439
440 if (m_statusQueryReportingEnabled)
441 {
442 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer));
443 }
444
445 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
446 m_vc1PicParams->picture_fields.picture_type == vc1SkippedFrame)
447 {
448 // no further picture level commands needed for skipped frames
449 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
450
451 return eStatus;
452 }
453
454 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
455
456 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceState(&surfaceParams));
457
458 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams));
459
460 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams));
461
462 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams));
463
464 if (m_mode == CODECHAL_DECODE_MODE_VC1VLD)
465 {
466 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(&cmdBuffer, &bspBufBaseAddrParams));
467 }
468
469 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1PredPipeCmd(&cmdBuffer, &vc1PredPipeParams));
470
471 if (m_intelEntrypointInUse || m_mode == CODECHAL_DECODE_MODE_VC1IT)
472 {
473 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1LongPicCmd(&cmdBuffer, &vc1PicState));
474 }
475 else if (m_shortFormatInUse)
476 {
477 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ShortPicCmd(&cmdBuffer, &vc1PicState));
478 }
479 else
480 {
481 CODECHAL_DECODE_ASSERTMESSAGE("Unsupported decode mode.");
482 eStatus = MOS_STATUS_UNKNOWN;
483 return eStatus;
484 }
485
486 if (m_mode == CODECHAL_DECODE_MODE_VC1VLD)
487 {
488 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1DirectmodeCmd(&cmdBuffer, &vc1DirectmodeParams));
489 }
490
491 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
492
493 return eStatus;
494 }
495
496 MOS_STATUS CodechalDecodeVc1G12::DecodePrimitiveLevelVLD()
497 {
498 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
499
500 CODECHAL_DECODE_FUNCTION_ENTER;
501
502 MOS_SYNC_PARAMS syncParams;
503
504 // static VC1 slice parameters
505 MHW_VDBOX_VC1_SLICE_STATE vc1SliceState;
506 vc1SliceState.presDataBuffer = &m_resDataBuffer;
507
508 uint16_t frameFieldHeightInMb;
509 CodecHal_GetFrameFieldHeightInMb(
510 m_vc1PicParams->CurrPic,
511 m_picHeightInMb,
512 frameFieldHeightInMb);
513
514 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
515
516 MOS_COMMAND_BUFFER cmdBuffer;
517 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
518
519 if (m_incompletePicture)
520 {
521 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
522 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
523 forceWakeupParams.bMFXPowerWellControl = true;
524 forceWakeupParams.bMFXPowerWellControlMask = true;
525 forceWakeupParams.bHEVCPowerWellControl = false;
526 forceWakeupParams.bHEVCPowerWellControlMask = true;
527 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
528 &cmdBuffer,
529 &forceWakeupParams));
530 }
531
532 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
533 m_vc1PicParams->picture_fields.picture_type == vc1SkippedFrame)
534 {
535 if (!bSkipFrameReported)
536 {
537 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
538 MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
539 userFeatureWriteData.Value.i32Data = true;
540 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_SKIP_FRAME_IN_USE_ID;
541 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
542 bSkipFrameReported = true;
543 }
544
545 CODECHAL_DECODE_CHK_STATUS_RETURN(HandleSkipFrame());
546 goto submit;
547 }
548 else
549 {
550 PCODEC_VC1_SLICE_PARAMS slc = m_vc1SliceParams;
551 bool firstValidSlice = true;
552 int prevValidSlc = 0;
553 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
554 {
555 m_vldSliceRecord[slcCount].dwSliceYOffset = slc->slice_vertical_position;
556 m_vldSliceRecord[slcCount].dwNextSliceYOffset = frameFieldHeightInMb; // init to last slice
557
558 int32_t lLength = slc->slice_data_size >> 3;
559 int32_t lOffset = slc->macroblock_offset >> 3;
560
561 CodechalResLock ResourceLock(m_osInterface, &m_resDataBuffer);
562 auto buf = (uint8_t*)ResourceLock.Lock(CodechalResLock::readOnly);
563 if(buf != nullptr)
564 {
565 buf += slc->slice_data_offset;
566 }
567 if (lOffset > 3 && buf != nullptr &&
568 m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
569 {
570 int i = 0;
571 int j = 0;
572 for (i = 0, j = 0; i < lOffset - 1; i++, j++)
573 {
574 if (!buf[j] && !buf[j + 1] && buf[j + 2] == 3 && buf[j + 3] < 4)
575 {
576 i++, j += 2;
577 }
578 }
579 if (i == lOffset - 1)
580 {
581 if (!buf[j] && !buf[j + 1] && buf[j + 2] == 3 && buf[j + 3] < 4)
582 {
583 buf[j + 2] = 0;
584 j++;
585 }
586 j++;
587 }
588 lOffset = (8 * j + slc->macroblock_offset % 8)>>3;
589 }
590
591 // Check that the slice data does not overrun the bitstream buffer size
592 if ((slc->slice_data_offset + lLength) > m_dataSize)
593 {
594 lLength = m_dataSize - slc->slice_data_offset;
595
596 if (lLength < 0)
597 {
598 lLength = 0;
599 }
600 }
601
602 // Error handling for garbage data
603 if (slc->slice_data_offset > m_dataSize)
604 {
605 slc++;
606 m_vldSliceRecord[slcCount].dwSkip = true;
607 continue;
608 }
609
610 // Check offset not larger than slice length, can have slice length of 0
611 if (lOffset > lLength)
612 {
613 slc++;
614 m_vldSliceRecord[slcCount].dwSkip = true;
615 continue;
616 }
617
618 // Check that the slices do not overlap, else do not send the lower slice
619 if (!firstValidSlice &&
620 (m_vldSliceRecord[slcCount].dwSliceYOffset <= m_vldSliceRecord[prevValidSlc].dwSliceYOffset))
621 {
622 slc++;
623 m_vldSliceRecord[slcCount].dwSkip = true;
624 continue;
625 }
626
627 if (firstValidSlice)
628 {
629 // Ensure that the first slice starts from 0
630 m_vldSliceRecord[slcCount].dwSliceYOffset = 0;
631 slc->slice_vertical_position = 0;
632 }
633 else
634 {
635 // Set next slice start Y offset of previous slice
636 m_vldSliceRecord[prevValidSlc].dwNextSliceYOffset =
637 m_vldSliceRecord[slcCount].dwSliceYOffset;
638 }
639
640 if (m_shortFormatInUse)
641 {
642 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
643 {
644 if ((slc->macroblock_offset >> 3) < CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH)
645 {
646 slc++;
647 m_vldSliceRecord[slcCount].dwSkip = true;
648 continue;
649 }
650
651 // set macroblock_offset of the first slice to 0 to avoid crash
652 if (slcCount == 0)
653 {
654 slc->macroblock_offset = CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH << 3;
655 }
656
657 lOffset = CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH;
658 }
659 else // Simple Profile or Main Profile
660 {
661 {
662 lOffset = CODECHAL_DECODE_VC1_STUFFING_BYTES - 1;
663 lLength += CODECHAL_DECODE_VC1_STUFFING_BYTES;
664 slc->macroblock_offset += CODECHAL_DECODE_VC1_STUFFING_BYTES << 3;
665 slc->macroblock_offset &= (~0x7); // Clear bit offset of first MB for short format
666 }
667 }
668 }
669
670 m_vldSliceRecord[slcCount].dwOffset = lOffset;
671 m_vldSliceRecord[slcCount].dwLength = lLength - lOffset;
672 firstValidSlice = false;
673 prevValidSlc = slcCount;
674 slc++;
675 }
676
677 if (m_shortFormatInUse &&
678 m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
679 {
680 CODECHAL_DECODE_CHK_STATUS_RETURN(GetSliceMbDataOffset());
681 }
682
683 // Reset slc pointer
684 slc -= m_numSlices;
685
686 //------------------------------------
687 // Fill BSD Object Commands
688 //------------------------------------
689 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
690 {
691 if (m_vldSliceRecord[slcCount].dwSkip)
692 {
693 slc++;
694 continue;
695 }
696
697 vc1SliceState.pSlc = slc;
698 vc1SliceState.dwOffset = m_vldSliceRecord[slcCount].dwOffset;
699 vc1SliceState.dwLength = m_vldSliceRecord[slcCount].dwLength;
700 vc1SliceState.dwNextVerticalPosition = m_vldSliceRecord[slcCount].dwNextSliceYOffset;
701
702 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1BsdObjectCmd(&cmdBuffer, &vc1SliceState));
703
704 slc++;
705 }
706
707 // Free VLD slice record
708 MOS_ZeroMemory(m_vldSliceRecord, (m_numSlices * sizeof(CODECHAL_VC1_VLD_SLICE_RECORD)));
709 }
710
711 // Check if destination surface needs to be synchronized
712 if (m_unequalFieldWaInUse &&
713 CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
714 !m_vc1PicParams->picture_fields.is_first_field)
715 {
716 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
717 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
718
719 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
720 }
721 else
722 {
723 // Check if destination surface needs to be synchronized
724 syncParams = g_cInitSyncParams;
725 syncParams.GpuContext = m_videoContext;
726 syncParams.presSyncResource = &m_destSurface.OsResource;
727 syncParams.bReadOnly = false;
728 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
729 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
730
731 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) ||
732 m_vc1PicParams->picture_fields.is_first_field)
733 {
734 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
735 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
736
737 // Update the resource tag (s/w tag) for On-Demand Sync
738 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
739 }
740
741 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
742 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
743
744 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
745
746 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
747 if (m_osInterface->bTagResourceSync &&
748 !(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.is_first_field))
749 {
750 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
751 }
752 }
753
754 submit:
755 if (m_statusQueryReportingEnabled)
756 {
757 CodechalDecodeStatusReport decodeStatusReport;
758
759 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
760 decodeStatusReport.m_currDecodedPic = m_vc1PicParams->CurrPic;
761 if (m_olpNeeded)
762 {
763 CODECHAL_DEBUG_TOOL(
764 decodeStatusReport.m_currDeblockedPic.FrameIdx = (uint8_t)m_vc1PicParams->DeblockedPicIdx;
765 decodeStatusReport.m_currDeblockedPic.PicFlags = PICTURE_FRAME;)
766 decodeStatusReport.m_deblockedPicResOlp = m_deblockSurface.OsResource;
767 }
768 else
769 {
770 decodeStatusReport.m_currDeblockedPic = m_vc1PicParams->CurrPic;
771 }
772 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
773 decodeStatusReport.m_currDecodedPicRes = m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic;
774
775 CODECHAL_DEBUG_TOOL(
776 decodeStatusReport.m_secondField =
777 (m_vc1PicParams->picture_fields.is_first_field == 1) ? false : true;
778 decodeStatusReport.m_olpNeeded = m_olpNeeded;
779 decodeStatusReport.m_frameType = m_perfType;)
780
781 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer));
782 }
783
784 #if (_DEBUG || _RELEASE_INTERNAL)
785 uint32_t curIdx = (GetDecodeStatusBuf()->m_currIndex + CODECHAL_DECODE_STATUS_NUM - 1) % CODECHAL_DECODE_STATUS_NUM;
786 uint32_t frameCrcOffset = curIdx * sizeof(CodechalDecodeStatus) + GetDecodeStatusBuf()->m_decFrameCrcOffset + sizeof(uint32_t) * 2;
787 std::vector<MOS_RESOURCE> vSemaResource{GetDecodeStatusBuf()->m_statusBuffer};
788 m_debugInterface->DetectCorruptionHw(m_hwInterface, &m_frameCountTypeBuf, curIdx, frameCrcOffset, vSemaResource, &cmdBuffer, m_frameNum);
789 #endif
790
791 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
792
793 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
794
795 CODECHAL_DEBUG_TOOL(
796 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
797 &cmdBuffer,
798 CODECHAL_NUM_MEDIA_STATES,
799 "_DEC"));
800
801 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
802 // m_debugInterface,
803 // &cmdBuffer));
804 )
805
806 if ( MOS_VE_SUPPORTED(m_osInterface))
807 {
808 CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false);
809 }
810
811 if (m_huCCopyInUse)
812 {
813 syncParams = g_cInitSyncParams;
814 syncParams.GpuContext = m_videoContextForWa;
815 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
816
817 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
818
819 syncParams = g_cInitSyncParams;
820 syncParams.GpuContext = m_videoContext;
821 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
822
823 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
824
825 m_huCCopyInUse = false;
826 }
827
828 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
829
830 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
831
832 CODECHAL_DEBUG_TOOL(
833 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
834
835 if (m_unequalFieldWaInUse &&
836 CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
837 !m_vc1PicParams->picture_fields.is_first_field)
838 {
839 CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1RefList);
840
841 uint32_t destFrameIdx = m_vc1PicParams->CurrPic.FrameIdx;
842
843 CODECHAL_DECODE_CHK_STATUS_RETURN(FormatUnequalFieldPicture(
844 m_unequalFieldSurface[m_vc1RefList[destFrameIdx]->dwUnequalFieldSurfaceIdx],
845 m_destSurface,
846 true,
847 m_videoContextUsesNullHw ? true : false));
848 }
849
850 if (m_olpNeeded)
851 {
852 if (!bOlpReported)
853 {
854 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
855 MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
856 userFeatureWriteData.Value.i32Data = m_olpNeeded;
857 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_OLP_IN_USE_ID;
858 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
859 bOlpReported = true;
860 }
861
862 CODECHAL_DECODE_CHK_STATUS_RETURN(PerformVc1Olp());
863 }
864 else
865 {
866 if (m_statusQueryReportingEnabled)
867 {
868 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw));
869 }
870 }
871
872 // Needs to be re-set for Linux buffer re-use scenarios
873 m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
874
875 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
876 if (!(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
877 m_vc1PicParams->picture_fields.is_first_field))
878 {
879 MOS_SYNC_PARAMS syncParams;
880 syncParams = g_cInitSyncParams;
881 syncParams.GpuContext = m_videoContext;
882 syncParams.presSyncResource = &m_destSurface.OsResource;
883
884 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
885
886 if (m_olpNeeded)
887 {
888 syncParams = g_cInitSyncParams;
889 syncParams.GpuContext = m_renderContext;
890 syncParams.presSyncResource = &m_deblockSurface.OsResource;
891
892 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
893 }
894 }
895
896 m_olpNeeded = false;
897
898 return eStatus;
899 }
900
901 MOS_STATUS CodechalDecodeVc1G12::DecodePrimitiveLevelIT()
902 {
903 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
904
905 CODECHAL_DECODE_FUNCTION_ENTER;
906
907 MOS_SYNC_PARAMS syncParams;
908
909 PCODEC_VC1_MB_PARAMS mb = m_vc1MbParams;
910
911 MHW_VDBOX_VC1_MB_STATE vc1MbState;
912 MOS_ZeroMemory(&vc1MbState, sizeof(vc1MbState));
913
914 // static VC1 MB parameters
915 vc1MbState.presDataBuffer = &m_resDataBuffer;
916 vc1MbState.pVc1PicParams = m_vc1PicParams;
917 vc1MbState.pWaTable = m_waTable;
918 vc1MbState.pDeblockDataBuffer = m_deblockDataBuffer;
919 vc1MbState.dwDataSize = m_dataSize;
920 vc1MbState.wPicWidthInMb = m_picWidthInMb;
921 vc1MbState.wPicHeightInMb = m_picHeightInMb;
922 vc1MbState.PicFlags = m_vc1PicParams->CurrPic.PicFlags;
923 vc1MbState.bFieldPolarity = m_fieldPolarity;
924
925 uint16_t frameFieldHeightInMb;
926 CodecHal_GetFrameFieldHeightInMb(
927 m_vc1PicParams->CurrPic,
928 m_picHeightInMb,
929 frameFieldHeightInMb);
930
931 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
932
933 MOS_COMMAND_BUFFER cmdBuffer;
934 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
935
936 if (m_incompletePicture)
937 {
938 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
939 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
940 forceWakeupParams.bMFXPowerWellControl = true;
941 forceWakeupParams.bMFXPowerWellControlMask = true;
942 forceWakeupParams.bHEVCPowerWellControl = false;
943 forceWakeupParams.bHEVCPowerWellControlMask = true;
944 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
945 &cmdBuffer,
946 &forceWakeupParams));
947 }
948
949 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, &m_itObjectBatchBuffer));
950
951 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_LockBb(m_osInterface, &m_itObjectBatchBuffer));
952
953 PMHW_BATCH_BUFFER batchBuffer = &m_itObjectBatchBuffer;
954
955 uint32_t mbAddress = 0;
956 uint32_t mbCount;
957 for (mbCount = 0; mbCount < m_numMacroblocks; mbCount++)
958 {
959 vc1MbState.pMb = mb + mbCount;
960
961 // Skipped MBs before current MB
962 uint16_t skippedMBs = (mbCount) ?
963 (mb[mbCount].mb_address - mb[mbCount - 1].mb_address - 1) :
964 (mb[mbCount].mb_address);
965
966 while (skippedMBs--)
967 {
968 vc1MbState.bMbHorizOrigin = (uint8_t)(mbAddress % m_picWidthInMb);
969 vc1MbState.bMbVertOrigin = (uint8_t)(mbAddress / m_picWidthInMb);
970 vc1MbState.bSkipped = true;
971
972 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState));
973
974 mbAddress++;
975 }
976
977 // Current MB
978 if (mbCount + 1 == m_numMacroblocks)
979 {
980 vc1MbState.dwLength = m_dataSize - mb[mbCount].data_offset;
981 }
982 else
983 {
984 vc1MbState.dwLength = mb[mbCount + 1].data_offset - mb[mbCount].data_offset;
985 }
986
987 vc1MbState.bMbHorizOrigin = mb[mbCount].mb_address % m_picWidthInMb;
988 vc1MbState.bMbVertOrigin = mb[mbCount].mb_address / m_picWidthInMb;
989 vc1MbState.dwOffset = (vc1MbState.dwLength) ? mb[mbCount].data_offset : 0;
990 vc1MbState.bSkipped = false;
991
992 if (m_vc1PicParams->entrypoint_fields.loopfilter)
993 {
994 eStatus = MOS_SecureMemcpy(vc1MbState.DeblockData,
995 CODEC_NUM_BLOCK_PER_MB,
996 m_deblockDataBuffer + CODEC_NUM_BLOCK_PER_MB * mb[mbCount].mb_address,
997 CODEC_NUM_BLOCK_PER_MB);
998 if (eStatus != MOS_STATUS_SUCCESS)
999 {
1000 CODECHAL_DECODE_ASSERTMESSAGE("Failed to copy memory.");
1001 m_olpNeeded = false;
1002 return eStatus;
1003 }
1004 }
1005
1006 if (!mb[mbCount].mb_type.intra_mb)
1007 {
1008 if (mb[mbCount].mb_type.motion_forward || mb[mbCount].mb_type.motion_backward)
1009 {
1010 PackMotionVectors(
1011 &vc1MbState,
1012 (short *)mb[mbCount].motion_vector,
1013 (short *)vc1MbState.PackedLumaMvs,
1014 (short *)&vc1MbState.PackedChromaMv);
1015 }
1016 else
1017 {
1018 mb[mbCount].mb_type.motion_forward = 1;
1019 MOS_ZeroMemory(vc1MbState.PackedLumaMvs, sizeof(vc1MbState.PackedLumaMvs)); // MV's of zero
1020 vc1MbState.bMotionSwitch = 0;
1021 }
1022 }
1023
1024 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState));
1025
1026 mbAddress = mb[mbCount].mb_address;
1027 }
1028
1029 m_fieldPolarity = vc1MbState.bFieldPolarity;
1030
1031 // skipped MBs at the end
1032 uint16_t skippedMBs = m_picWidthInMb * frameFieldHeightInMb - mb[mbCount - 1].mb_address - 1;
1033
1034 while (skippedMBs--)
1035 {
1036 vc1MbState.bSkipped = true;
1037 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState));
1038 }
1039
1040 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, &m_itObjectBatchBuffer));
1041
1042 CODECHAL_DEBUG_TOOL(
1043 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
1044 batchBuffer,
1045 CODECHAL_NUM_MEDIA_STATES,
1046 "_DEC"));
1047 )
1048
1049 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_UnlockBb(m_osInterface, &m_itObjectBatchBuffer, true));
1050
1051 // Check if destination surface needs to be synchronized
1052 if (m_unequalFieldWaInUse &&
1053 CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
1054 {
1055 if (!m_vc1PicParams->picture_fields.is_first_field)
1056 {
1057 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1058 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1059
1060 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
1061 }
1062 }
1063 else
1064 {
1065 syncParams = g_cInitSyncParams;
1066 syncParams.GpuContext = m_videoContext;
1067 syncParams.presSyncResource = &m_destSurface.OsResource;
1068 syncParams.bReadOnly = false;
1069 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1070 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1071
1072 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) ||
1073 m_vc1PicParams->picture_fields.is_first_field)
1074 {
1075 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
1076 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
1077
1078 // Update the resource tag (s/w tag) for On-Demand Sync
1079 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1080 }
1081
1082 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1083 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1084
1085 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
1086
1087 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1088 if (m_osInterface->bTagResourceSync &&
1089 !(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.is_first_field))
1090 {
1091 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
1092 }
1093 }
1094
1095 if (m_statusQueryReportingEnabled)
1096 {
1097 CodechalDecodeStatusReport decodeStatusReport;
1098
1099 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
1100 decodeStatusReport.m_currDecodedPic = m_vc1PicParams->CurrPic;
1101 if (m_olpNeeded)
1102 {
1103 CODECHAL_DEBUG_TOOL(
1104 decodeStatusReport.m_currDeblockedPic.FrameIdx = (uint8_t)m_vc1PicParams->DeblockedPicIdx;
1105 decodeStatusReport.m_currDeblockedPic.PicFlags = PICTURE_FRAME;)
1106 decodeStatusReport.m_deblockedPicResOlp = m_deblockSurface.OsResource;
1107 }
1108 else
1109 {
1110 decodeStatusReport.m_currDeblockedPic = m_vc1PicParams->CurrPic;
1111 }
1112 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
1113 decodeStatusReport.m_currDecodedPicRes = m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic;
1114
1115 CODECHAL_DEBUG_TOOL(
1116 decodeStatusReport.m_secondField =
1117 (m_vc1PicParams->picture_fields.is_first_field == 1) ? false : true;
1118 decodeStatusReport.m_olpNeeded = m_olpNeeded;
1119 decodeStatusReport.m_frameType = m_perfType;)
1120
1121 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer));
1122 }
1123
1124 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
1125
1126 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1127
1128 CODECHAL_DEBUG_TOOL(
1129 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
1130 &cmdBuffer,
1131 CODECHAL_NUM_MEDIA_STATES,
1132 "_DEC"));
1133
1134 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
1135 // m_debugInterface,
1136 // &cmdBuffer));
1137 )
1138
1139 if ( MOS_VE_SUPPORTED(m_osInterface))
1140 {
1141 CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false);
1142 }
1143
1144 if (m_huCCopyInUse)
1145 {
1146 syncParams = g_cInitSyncParams;
1147 syncParams.GpuContext = m_videoContextForWa;
1148 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1149
1150 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
1151
1152 syncParams = g_cInitSyncParams;
1153 syncParams.GpuContext = m_videoContext;
1154 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
1155
1156 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
1157
1158 m_huCCopyInUse = false;
1159 }
1160
1161 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
1162
1163 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
1164
1165 CODECHAL_DEBUG_TOOL(
1166 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
1167
1168 if (m_unequalFieldWaInUse &&
1169 CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
1170 !m_vc1PicParams->picture_fields.is_first_field)
1171 {
1172 CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1RefList);
1173
1174 uint32_t destFrameIdx = m_vc1PicParams->CurrPic.FrameIdx;
1175
1176 CODECHAL_DECODE_CHK_STATUS_RETURN(FormatUnequalFieldPicture(
1177 m_unequalFieldSurface[m_vc1RefList[destFrameIdx]->dwUnequalFieldSurfaceIdx],
1178 m_destSurface,
1179 true,
1180 m_videoContextUsesNullHw ? true : false));
1181 }
1182
1183 if (m_olpNeeded)
1184 {
1185 CODECHAL_DECODE_CHK_STATUS_RETURN(PerformVc1Olp());
1186 }
1187 else
1188 {
1189 if (m_statusQueryReportingEnabled)
1190 {
1191 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw));
1192 }
1193 }
1194
1195 // Needs to be re-set for Linux buffer re-use scenarios
1196 m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
1197
1198 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
1199 if (!(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
1200 m_vc1PicParams->picture_fields.is_first_field))
1201 {
1202 MOS_SYNC_PARAMS syncParams;
1203 syncParams = g_cInitSyncParams;
1204 syncParams.GpuContext = m_videoContext;
1205 syncParams.presSyncResource = &m_destSurface.OsResource;
1206
1207 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
1208
1209 if (m_olpNeeded)
1210 {
1211 syncParams = g_cInitSyncParams;
1212 syncParams.GpuContext = m_renderContext;
1213 syncParams.presSyncResource = &m_deblockSurface.OsResource;
1214
1215 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
1216 }
1217 }
1218
1219 m_olpNeeded = false;
1220
1221 return eStatus;
1222 }
1223
1224 MOS_STATUS CodechalDecodeVc1G12::HandleSkipFrame()
1225 {
1226 MOS_COMMAND_BUFFER cmdBuffer;
1227 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1228 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
1229 MOS_SURFACE srcSurface;
1230 uint8_t fwdRefIdx;
1231 uint32_t surfaceSize;
1232 MOS_SYNC_PARAMS syncParams;
1233 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1234
1235 CODECHAL_DECODE_FUNCTION_ENTER;
1236
1237 fwdRefIdx = (uint8_t)m_vc1PicParams->ForwardRefIdx;
1238
1239 MOS_ZeroMemory(&srcSurface, sizeof(MOS_SURFACE));
1240 srcSurface.Format = Format_NV12;
1241 srcSurface.OsResource = m_vc1RefList[fwdRefIdx]->resRefPic;
1242 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(m_osInterface, &srcSurface));
1243
1244 CODECHAL_DECODE_CHK_NULL_RETURN(srcSurface.OsResource.pGmmResInfo);
1245 surfaceSize = ((srcSurface.OsResource.pGmmResInfo->GetArraySize()) > 1) ?
1246 ((uint32_t)(srcSurface.OsResource.pGmmResInfo->GetQPitchPlanar(GMM_PLANE_Y) *
1247 srcSurface.OsResource.pGmmResInfo->GetRenderPitch())) :
1248 (uint32_t)(srcSurface.OsResource.pGmmResInfo->GetSizeMainSurface());
1249
1250 if (m_hwInterface->m_noHuC)
1251 {
1252 CodechalDataCopyParams dataCopyParams;
1253 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
1254 dataCopyParams.srcResource = &srcSurface.OsResource;
1255 dataCopyParams.srcSize = surfaceSize;
1256 dataCopyParams.srcOffset = srcSurface.dwOffset;
1257 dataCopyParams.dstResource = &m_destSurface.OsResource;
1258 dataCopyParams.dstSize = surfaceSize;
1259 dataCopyParams.dstOffset = m_destSurface.dwOffset;
1260
1261 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams));
1262 }
1263 else
1264 {
1265 m_huCCopyInUse = true;
1266
1267 syncParams = g_cInitSyncParams;
1268 syncParams.GpuContext = m_videoContext;
1269 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
1270
1271 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
1272
1273 syncParams = g_cInitSyncParams;
1274 syncParams.GpuContext = m_videoContextForWa;
1275 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
1276
1277 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
1278
1279 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContextForWa));
1280 m_osInterface->pfnResetOsStates(m_osInterface);
1281
1282 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1283
1284 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, false));
1285
1286 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
1287 &cmdBuffer, // pCmdBuffer
1288 &srcSurface.OsResource, // presSrc
1289 &m_destSurface.OsResource, // presDst
1290 surfaceSize, // u32CopyLength
1291 srcSurface.dwOffset, // u32CopyInputOffset
1292 m_destSurface.dwOffset)); // u32CopyOutputOffset
1293
1294 auto mmc = static_cast<CodechalMmcDecodeVc1G12*>(m_mmc);
1295 CODECHAL_DECODE_CHK_STATUS_RETURN(mmc->CopyAuxSurfForSkip(&cmdBuffer, &srcSurface.OsResource, &m_destSurface.OsResource));
1296
1297 syncParams = g_cInitSyncParams;
1298 syncParams.GpuContext = m_videoContextForWa;
1299 syncParams.presSyncResource = &m_destSurface.OsResource;
1300 syncParams.bReadOnly = false;
1301 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1302 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1303
1304 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
1305 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
1306
1307 // Update the resource tag (s/w tag) for On-Demand Sync
1308 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1309
1310 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1311 if (m_osInterface->bTagResourceSync)
1312 {
1313 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
1314 &cmdBuffer,
1315 &syncParams));
1316 }
1317
1318 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1319 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1320 &cmdBuffer,
1321 &flushDwParams));
1322
1323 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1324 &cmdBuffer,
1325 nullptr));
1326
1327 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1328
1329 if ( MOS_VE_SUPPORTED(m_osInterface))
1330 {
1331 CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false);
1332 }
1333
1334 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
1335
1336 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext));
1337 }
1338
1339 return (MOS_STATUS)eStatus;
1340 }
1341
1342 MOS_STATUS CodechalDecodeVc1G12::PerformVc1Olp()
1343 {
1344 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1345
1346 CODECHAL_DECODE_FUNCTION_ENTER;
1347
1348 MhwRenderInterface *renderEngineInterface = m_hwInterface->GetRenderInterface();
1349 PMHW_KERNEL_STATE kernelState = &m_olpKernelState;
1350 PMHW_STATE_HEAP_INTERFACE stateHeapInterface = renderEngineInterface->m_stateHeapInterface;
1351
1352 CODECHAL_DECODE_CHK_NULL_RETURN(stateHeapInterface);
1353
1354 MOS_SYNC_PARAMS syncParams;
1355 syncParams = g_cInitSyncParams;
1356 syncParams.GpuContext = m_videoContext;
1357 syncParams.presSyncResource = &m_resSyncObject;
1358
1359 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
1360
1361 syncParams = g_cInitSyncParams;
1362 syncParams.GpuContext = m_renderContext;
1363 syncParams.presSyncResource = &m_resSyncObject;
1364
1365 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
1366
1367 // Initialize DSH kernel region
1368 m_osInterface->pfnSetGpuContext(m_osInterface, m_renderContext);
1369 m_osInterface->pfnResetOsStates(m_osInterface);
1370
1371 m_osInterface->pfnSetPerfTag(
1372 m_osInterface,
1373 (uint16_t)(((m_mode << 4) & 0xF0) | OLP_TYPE));
1374 m_osInterface->pfnResetPerfBufferID(m_osInterface);
1375
1376 CodecHalGetResourceInfo(m_osInterface, &m_deblockSurface); // DstSurface
1377
1378 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
1379 stateHeapInterface,
1380 kernelState->KernelParams.iBTCount));
1381
1382 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
1383 stateHeapInterface,
1384 kernelState,
1385 false,
1386 m_olpDshSize,
1387 false,
1388 m_decodeStatusBuf.m_swStoreData));
1389
1390 MHW_INTERFACE_DESCRIPTOR_PARAMS idParams;
1391 MOS_ZeroMemory(&idParams, sizeof(idParams));
1392 idParams.pKernelState = kernelState;
1393 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetInterfaceDescriptor(
1394 stateHeapInterface,
1395 1,
1396 &idParams));
1397 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCurbeOlp());
1398
1399 // Send HW commands (including SSH)
1400 MOS_COMMAND_BUFFER cmdBuffer;
1401 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1402
1403 MHW_PIPE_CONTROL_PARAMS pipeControlParams;
1404 MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams));
1405
1406 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetDefaultSSEuSetting(CODECHAL_MEDIA_STATE_OLP, false, false, false));
1407
1408 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
1409 &cmdBuffer, true));
1410
1411 if (renderEngineInterface->GetL3CacheConfig()->bL3CachingEnabled)
1412 {
1413 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->SetL3Cache(&cmdBuffer));
1414 }
1415
1416 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->EnablePreemption(&cmdBuffer));
1417
1418 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddPipelineSelectCmd(&cmdBuffer, false));
1419
1420 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetBindingTable(
1421 stateHeapInterface,
1422 kernelState));
1423
1424 // common function for codec needed when we make change for AVC
1425 MHW_RCS_SURFACE_PARAMS surfaceParamsSrc;
1426 MOS_ZeroMemory(&surfaceParamsSrc, sizeof(surfaceParamsSrc));
1427 surfaceParamsSrc.dwNumPlanes = 2; // Y, UV
1428 surfaceParamsSrc.psSurface = &m_destSurface;
1429 surfaceParamsSrc.psSurface->dwDepth = 1; // depth needs to be 0 for codec 2D surface
1430 // Y Plane
1431 surfaceParamsSrc.dwBindingTableOffset[MHW_Y_PLANE] = CODECHAL_DECODE_VC1_OLP_SRC_Y;
1432 surfaceParamsSrc.ForceSurfaceFormat[MHW_Y_PLANE] = MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM;
1433 // UV Plane
1434 surfaceParamsSrc.dwBindingTableOffset[MHW_U_PLANE] = CODECHAL_DECODE_VC1_OLP_SRC_UV;
1435 surfaceParamsSrc.ForceSurfaceFormat[MHW_U_PLANE] = MHW_GFX3DSTATE_SURFACEFORMAT_R16_UINT;
1436 surfaceParamsSrc.dwBaseAddrOffset[MHW_U_PLANE] =
1437 m_destSurface.dwPitch *
1438 MOS_ALIGN_FLOOR(m_destSurface.UPlaneOffset.iYOffset, MOS_YTILE_H_ALIGNMENT);
1439 surfaceParamsSrc.dwHeightToUse[MHW_U_PLANE] = surfaceParamsSrc.psSurface->dwHeight / 2;
1440 surfaceParamsSrc.dwYOffset[MHW_U_PLANE] =
1441 (m_destSurface.UPlaneOffset.iYOffset % MOS_YTILE_H_ALIGNMENT);
1442 surfaceParamsSrc.dwCacheabilityControl =
1443 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC].Value;
1444
1445 if (m_mmc)
1446 {
1447 CODECHAL_SURFACE_CODEC_PARAMS srcSurfaceParam = {};
1448 srcSurfaceParam.psSurface = &m_destSurface;
1449 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceParams(&srcSurfaceParam));
1450 }
1451
1452 MHW_RCS_SURFACE_PARAMS surfaceParamsDst;
1453 MOS_ZeroMemory(&surfaceParamsDst, sizeof(surfaceParamsDst));
1454 surfaceParamsDst = surfaceParamsSrc;
1455 surfaceParamsDst.bIsWritable = true;
1456 surfaceParamsDst.psSurface = &m_deblockSurface;
1457 surfaceParamsDst.psSurface->dwDepth = 1; // depth needs to be 0 for codec 2D surface
1458 surfaceParamsDst.dwBindingTableOffset[MHW_Y_PLANE] = CODECHAL_DECODE_VC1_OLP_DST_Y;
1459 surfaceParamsDst.dwBindingTableOffset[MHW_U_PLANE] = CODECHAL_DECODE_VC1_OLP_DST_UV;
1460 surfaceParamsDst.dwCacheabilityControl =
1461 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_POST_DEBLOCKING_CODEC].Value;
1462
1463 if (m_mmc)
1464 {
1465 CODECHAL_SURFACE_CODEC_PARAMS dstSurfaceParam = {};
1466 dstSurfaceParam.psSurface = &m_deblockSurface;
1467 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceParams(&dstSurfaceParam));
1468 }
1469
1470 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetSurfaceState(
1471 stateHeapInterface,
1472 kernelState,
1473 &cmdBuffer,
1474 1,
1475 &surfaceParamsSrc));
1476 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetSurfaceState(
1477 stateHeapInterface,
1478 kernelState,
1479 &cmdBuffer,
1480 1,
1481 &surfaceParamsDst));
1482
1483 MHW_STATE_BASE_ADDR_PARAMS stateBaseAddrParams;
1484 MOS_ZeroMemory(&stateBaseAddrParams, sizeof(stateBaseAddrParams));
1485 MOS_RESOURCE *dsh = nullptr, *ish = nullptr;
1486 CODECHAL_DECODE_CHK_NULL_RETURN(dsh = kernelState->m_dshRegion.GetResource());
1487 CODECHAL_DECODE_CHK_NULL_RETURN(ish = kernelState->m_ishRegion.GetResource());
1488 stateBaseAddrParams.presDynamicState = dsh;
1489 stateBaseAddrParams.dwDynamicStateSize = kernelState->m_dshRegion.GetHeapSize();
1490 stateBaseAddrParams.presInstructionBuffer = ish;
1491 stateBaseAddrParams.dwInstructionBufferSize = kernelState->m_ishRegion.GetHeapSize();
1492 stateBaseAddrParams.mocs4GeneralState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1493 stateBaseAddrParams.mocs4DynamicState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1494 stateBaseAddrParams.mocs4SurfaceState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1495 stateBaseAddrParams.mocs4IndirectObjectBuffer = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1496 stateBaseAddrParams.mocs4StatelessDataport = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1497 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddStateBaseAddrCmd(&cmdBuffer, &stateBaseAddrParams));
1498
1499 MHW_VFE_PARAMS_G12 vfeParams= {};
1500 vfeParams.pKernelState = kernelState;
1501 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaVfeCmd(&cmdBuffer, &vfeParams));
1502
1503 MHW_CURBE_LOAD_PARAMS curbeLoadParams;
1504 MOS_ZeroMemory(&curbeLoadParams, sizeof(curbeLoadParams));
1505 curbeLoadParams.pKernelState = kernelState;
1506 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaCurbeLoadCmd(&cmdBuffer, &curbeLoadParams));
1507
1508 MHW_ID_LOAD_PARAMS idLoadParams;
1509 MOS_ZeroMemory(&idLoadParams, sizeof(idLoadParams));
1510 idLoadParams.pKernelState = kernelState;
1511 idLoadParams.dwNumKernelsLoaded = 1;
1512 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaIDLoadCmd(&cmdBuffer, &idLoadParams));
1513
1514 CODECHAL_DEBUG_TOOL(
1515 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
1516 CODECHAL_MEDIA_STATE_OLP,
1517 MHW_DSH_TYPE,
1518 kernelState));
1519
1520 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
1521 CODECHAL_MEDIA_STATE_OLP,
1522 MHW_SSH_TYPE,
1523 kernelState));
1524 )
1525
1526 CODECHAL_DECODE_VC1_OLP_PARAMS vc1OlpParams;
1527 vc1OlpParams.pCmdBuffer = &cmdBuffer;
1528 vc1OlpParams.pPipeControlParams = &pipeControlParams;
1529 vc1OlpParams.pStateBaseAddrParams = &stateBaseAddrParams;
1530 vc1OlpParams.pVfeParams = &vfeParams;
1531 vc1OlpParams.pCurbeLoadParams = &curbeLoadParams;
1532 vc1OlpParams.pIdLoadParams = &idLoadParams;
1533 CODECHAL_DECODE_CHK_STATUS_RETURN(AddVc1OlpCmd(&vc1OlpParams));
1534
1535 // Check if destination surface needs to be synchronized, before command buffer submission
1536 syncParams = g_cInitSyncParams;
1537 syncParams.GpuContext = m_renderContext;
1538 syncParams.presSyncResource = &m_deblockSurface.OsResource;
1539 syncParams.bReadOnly = false;
1540 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1541 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1542
1543 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
1544 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
1545
1546 // Update the resource tag (s/w tag) for On-Demand Sync
1547 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1548
1549 // Update GPU Sync tag for on demand synchronization
1550 if (m_osInterface->bTagResourceSync)
1551 {
1552 pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
1553 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(&cmdBuffer, nullptr, &pipeControlParams));
1554 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
1555 }
1556 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSubmitBlocks(
1557 stateHeapInterface,
1558 kernelState));
1559 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnUpdateGlobalCmdBufId(
1560 stateHeapInterface));
1561
1562 // Add PipeControl to invalidate ISP and MediaState to avoid PageFault issue
1563 // This code is temporal and it will be moved to batch buffer end in short
1564 MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams));
1565 pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
1566 pipeControlParams.bGenericMediaStateClear = true;
1567 pipeControlParams.bIndirectStatePointersDisable = true;
1568 pipeControlParams.bDisableCSStall = false;
1569 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(&cmdBuffer, nullptr, &pipeControlParams));
1570
1571 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
1572
1573 // To clear the SSEU values in the hw interface struct, so next kernel can be programmed correctly
1574 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(&cmdBuffer, false, true));
1575
1576 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1577
1578 CODECHAL_DEBUG_TOOL(
1579 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
1580 &cmdBuffer,
1581 CODECHAL_MEDIA_STATE_OLP,
1582 "_DEC"));
1583 )
1584
1585 if ( MOS_VE_SUPPORTED(m_osInterface))
1586 {
1587 CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false);
1588 }
1589
1590 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw));
1591
1592 if (m_statusQueryReportingEnabled)
1593 {
1594 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_renderContextUsesNullHw));
1595 }
1596
1597 m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext);
1598
1599 return eStatus;
1600 }
1601
1602 CodechalDecodeVc1G12::CodechalDecodeVc1G12(
1603 CodechalHwInterface *hwInterface,
1604 CodechalDebugInterface* debugInterface,
1605 PCODECHAL_STANDARD_INFO standardInfo) :
1606 CodechalDecodeVc1(hwInterface, debugInterface, standardInfo)
1607 {
1608 CODECHAL_DECODE_FUNCTION_ENTER;
1609
1610 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(hwInterface);
1611 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
1612
1613 m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
1614
1615 m_olpCurbeStaticDataLength = CODECHAL_DECODE_VC1_CURBE_SIZE_OLP;
1616
1617 uint32_t kuid = 0;
1618 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1619
1620 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
1621 eStatus = CodecHalGetKernelBinaryAndSize(
1622 (uint8_t *)IGCODECKRN_G12,
1623 IDR_CODEC_AllVC1_NV12,
1624 &m_olpKernelBase,
1625 &m_olpKernelSize);
1626 #endif
1627
1628 CODECHAL_DECODE_ASSERT(eStatus == MOS_STATUS_SUCCESS);
1629
1630 hwInterface->GetStateHeapSettings()->dwNumSyncTags = CODECHAL_DECODE_VC1_NUM_SYNC_TAGS;
1631 hwInterface->GetStateHeapSettings()->dwIshSize =
1632 MOS_ALIGN_CEIL(m_olpKernelSize, (1 << MHW_KERNEL_OFFSET_SHIFT));
1633 hwInterface->GetStateHeapSettings()->dwDshSize = CODECHAL_DECODE_VC1_INITIAL_DSH_SIZE;
1634 }
1635
1636 CodechalDecodeVc1G12::~CodechalDecodeVc1G12()
1637 {
1638 CODECHAL_DECODE_FUNCTION_ENTER;
1639
1640 if (m_veState != nullptr)
1641 {
1642 MOS_FreeMemAndSetNull(m_veState);
1643 m_veState = nullptr;
1644 }
1645 }
1646
1647 void CodechalDecodeVc1G12::CalcRequestedSpace(
1648 uint32_t &requestedSize,
1649 uint32_t &additionalSizeNeeded,
1650 uint32_t &requestedPatchListSize)
1651 {
1652 CODECHAL_DECODE_FUNCTION_ENTER;
1653
1654 requestedSize = m_commandBufferSizeNeeded + m_HucStateCmdBufferSizeNeeded +
1655 (m_standardDecodeSizeNeeded * (m_decodeParams.m_numSlices + 1));
1656 requestedPatchListSize = m_commandPatchListSizeNeeded + m_HucPatchListSizeNeeded +
1657 (m_standardDecodePatchListSizeNeeded * (m_decodeParams.m_numSlices + 1));
1658 additionalSizeNeeded = COMMAND_BUFFER_RESERVED_SPACE;
1659 }