Debian Codegraph @

media_driver/agnostic/gen11/codec/hal/codechal_decode_vc1_g11.cpp

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