Debian Codegraph @

media_softlet/agnostic/common/codec/hal/dec/vvc/packet/decode_vvc_packet.cpp

raw
1 /*
2 * Copyright (c) 2021-2024, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file decode_vvc_packet.cpp
24 //! \brief Defines the interface for vvc decode packet
25 //!
26 #include "decode_vvc_packet.h"
27 #include "decode_status_report_defs.h"
28 #include "decode_predication_packet.h"
29 #include "decode_marker_packet.h"
30 #include "decode_utils.h"
31 #include "decode_status_report_defs.h"
32 #include "mos_solo_generic.h"
33 #include "decode_resource_auto_lock.h"
34 #include "hal_oca_interface_next.h"
35 #include "decode_vvc_debug_packet.h"
36
37 namespace decode {
38
39 MOS_STATUS VvcDecodePkt::Init()
40 {
41 DECODE_FUNC_CALL();
42
43 DECODE_CHK_NULL(m_statusReport);
44 DECODE_CHK_NULL(m_featureManager);
45 DECODE_CHK_NULL(m_vvcPipeline);
46 DECODE_CHK_NULL(m_osInterface);
47 DECODE_CHK_NULL(m_vdencItf);
48
49 DECODE_CHK_STATUS(CmdPacket::Init());
50
51 CalculateVvcSliceLvlCmdSize();
52
53 m_vvcBasicFeature = dynamic_cast<VvcBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
54 DECODE_CHK_NULL(m_vvcBasicFeature);
55
56 m_allocator = m_vvcPipeline->GetDecodeAllocator();
57 DECODE_CHK_NULL(m_allocator);
58
59 DECODE_CHK_STATUS(m_statusReport->RegistObserver(this));
60
61 DecodeSubPacket* subPacket = m_vvcPipeline->GetSubPacket(DecodePacketId(m_vvcPipeline, vvcPictureSubPacketId));
62
63 m_picturePkt = dynamic_cast<VvcDecodePicPkt*>(subPacket);
64 DECODE_CHK_NULL(m_picturePkt);
65 DECODE_CHK_STATUS(m_picturePkt->CalculateCommandSize(m_pictureStatesSize, m_picturePatchListSize));
66
67 subPacket = m_vvcPipeline->GetSubPacket(DecodePacketId(m_vvcPipeline, vvcSliceSubPacketId));
68 m_slicePkt = dynamic_cast<VvcDecodeSlicePkt*>(subPacket);
69 DECODE_CHK_NULL(m_slicePkt);
70 DECODE_CHK_STATUS(m_slicePkt->CalculateCommandSize(m_sliceStatesSize, m_slicePatchListSize));
71 DECODE_CHK_STATUS(m_slicePkt->CalculateTileCommandSize(m_tileStateSize, m_tilePatchListSize));
72
73 #if (_DEBUG || _RELEASE_INTERNAL)
74 subPacket = m_vvcPipeline->GetSubPacket(DecodePacketId(m_vvcPipeline, vvcDebugSubPacketId));
75 m_debugPkt = dynamic_cast<VvcDecodeDebugPkt*>(subPacket);
76 // Debug packet is optional, don't fail if not present
77 if (m_debugPkt != nullptr)
78 {
79 DECODE_CHK_STATUS(m_debugPkt->CalculateCommandSize(m_debugStatesSize, m_debugPatchListSize));
80 }
81 else
82 {
83 m_debugStatesSize = 0;
84 m_debugPatchListSize = 0;
85 }
86 #endif
87
88 return MOS_STATUS_SUCCESS;
89 }
90
91 MOS_STATUS VvcDecodePkt::Prepare()
92 {
93 DECODE_FUNC_CALL();
94
95 DECODE_CHK_NULL(m_vvcBasicFeature->m_vvcPicParams);
96 m_vvcPicParams = m_vvcBasicFeature->m_vvcPicParams;
97
98 return MOS_STATUS_SUCCESS;
99 }
100
101 MOS_STATUS VvcDecodePkt::Destroy()
102 {
103 m_statusReport->UnregistObserver(this);
104
105 return MOS_STATUS_SUCCESS;
106 }
107
108 void VvcDecodePkt::SetPerfTag(CODECHAL_MODE mode, uint16_t picCodingType)
109 {
110 DECODE_FUNC_CALL();
111
112 uint16_t perfTag = ((mode << 4) & 0xF0) | (picCodingType & 0xF);
113 m_osInterface->pfnIncPerfFrameID(m_osInterface);
114 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag);
115 m_osInterface->pfnResetPerfBufferID(m_osInterface);
116 }
117
118 bool VvcDecodePkt::IsPrologRequired()
119 {
120 //If long format mode, vvc packet will be first packet to execute, need send prolog
121 //If not single task mode, vvc packet will submit separatly, also need send prolog
122 if (!m_vvcBasicFeature->m_shortFormatInUse || !m_vvcPipeline->IsSingleTaskPhaseSupported())
123 {
124 return true;
125 }
126
127 return false;
128 }
129
130 MOS_STATUS VvcDecodePkt::AddForceWakeup(MOS_COMMAND_BUFFER& cmdBuffer)
131 {
132 DECODE_FUNC_CALL();
133 // NativeFence sync BB may cause preemption and ring idle, so force wakeup after it
134 DECODE_CHK_STATUS(AddNativeFenceSyncBBStartCmd(cmdBuffer));
135
136 auto &par = m_miItf->GETPAR_MI_FORCE_WAKEUP();
137 MOS_ZeroMemory(&par, sizeof(mhw::mi::MI_FORCE_WAKEUP_PAR));
138 par.bMFXPowerWellControl = false;
139 par.bMFXPowerWellControlMask = true;
140 par.bHEVCPowerWellControl = true;
141 par.bHEVCPowerWellControlMask = true;
142
143 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_FORCE_WAKEUP(&cmdBuffer));
144
145 return MOS_STATUS_SUCCESS;
146 }
147
148 MOS_STATUS VvcDecodePkt::SendPrologWithFrameTracking(MOS_COMMAND_BUFFER& cmdBuffer, bool frameTrackingRequested)
149 {
150 DecodeSubPacket* subPacket = m_vvcPipeline->GetSubPacket(DecodePacketId(m_vvcPipeline, markerSubPacketId));
151 DecodeMarkerPkt *makerPacket = dynamic_cast<DecodeMarkerPkt*>(subPacket);
152 DECODE_CHK_NULL(makerPacket);
153 DECODE_CHK_STATUS(makerPacket->Execute(cmdBuffer));
154
155 m_mmcState = m_vvcPipeline->GetMmcState();
156 bool isMmcEnabled = (m_mmcState != nullptr && m_mmcState->IsMmcEnabled());
157
158 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
159 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
160 genericPrologParams.pOsInterface = m_osInterface;
161 genericPrologParams.pvMiInterface = nullptr;
162
163 genericPrologParams.bMmcEnabled = isMmcEnabled;
164
165 DECODE_CHK_STATUS(Mhw_SendGenericPrologCmdNext(&cmdBuffer, &genericPrologParams, m_miItf));
166
167 subPacket = m_vvcPipeline->GetSubPacket(DecodePacketId(m_vvcPipeline, predicationSubPacketId));
168 DecodePredicationPkt *predicationPacket = dynamic_cast<DecodePredicationPkt*>(subPacket);
169 DECODE_CHK_NULL(predicationPacket);
170 DECODE_CHK_STATUS(predicationPacket->Execute(cmdBuffer));
171
172 return MOS_STATUS_SUCCESS;
173 }
174
175 MOS_STATUS VvcDecodePkt::VdPipelineFlush(MOS_COMMAND_BUFFER & cmdBuffer)
176 {
177 DECODE_FUNC_CALL();
178
179 auto &par = m_vdencItf->MHW_GETPAR_F(VD_PIPELINE_FLUSH)();
180 par = {};
181
182 par.waitDoneVDCmdMsgParser = true;
183 #ifdef _MEDIA_RESERVED
184 par.vvcpPipelineCommandFlush = true;
185 par.vvcpPipelineDone = true;
186 #endif
187 DECODE_CHK_STATUS(m_vdencItf->MHW_ADDCMD_F(VD_PIPELINE_FLUSH)(&cmdBuffer));
188
189 return MOS_STATUS_SUCCESS;
190 }
191
192 MOS_STATUS VvcDecodePkt::MiFlush(MOS_COMMAND_BUFFER & cmdBuffer)
193 {
194 DECODE_FUNC_CALL();
195
196 auto &par = m_miItf->GETPAR_MI_FLUSH_DW();
197 MOS_ZeroMemory(&par, sizeof(mhw::mi::MI_FLUSH_DW_PAR));
198 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_FLUSH_DW(&cmdBuffer));
199
200 return MOS_STATUS_SUCCESS;
201 }
202
203 MOS_STATUS VvcDecodePkt::Completed(void *mfxStatus, void *rcsStatus, void *statusReport)
204 {
205 DECODE_FUNC_CALL();
206
207 DECODE_CHK_NULL(mfxStatus);
208 DECODE_CHK_NULL(statusReport);
209 DECODE_CHK_NULL(m_vvcBasicFeature);
210
211 DecodeStatusMfx * decodeStatusMfx = (DecodeStatusMfx *)mfxStatus;
212 DecodeStatusReportData *statusReportData = (DecodeStatusReportData *)statusReport;
213 DECODE_VERBOSEMESSAGE("Current Frame Index = %d", statusReportData->currDecodedPic.FrameIdx);
214
215 #if (_DEBUG || _RELEASE_INTERNAL)
216 // Call debug packet completion handling for VVCP debug functionality
217 if (m_debugPkt != nullptr)
218 {
219 DECODE_CHK_STATUS(m_debugPkt->Completed(mfxStatus));
220 }
221 #endif
222
223 return MOS_STATUS_SUCCESS;
224 }
225
226 MOS_STATUS VvcDecodePkt::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize)
227 {
228 commandBufferSize = CalculateCommandBufferSize();
229 requestedPatchListSize = CalculatePatchListSize();
230
231 // Picture-level cmd / patch list size is added only one time
232 if (m_picCmdSizeCalculated == false)
233 {
234 commandBufferSize += CalculatePicCommandSize();
235 requestedPatchListSize += CalculatePicPatchListSize();
236 m_picCmdSizeCalculated = true;
237 }
238
239 #if (_DEBUG || _RELEASE_INTERNAL)
240 commandBufferSize += m_debugStatesSize;
241 requestedPatchListSize += m_debugPatchListSize;
242 #endif
243
244 return MOS_STATUS_SUCCESS;
245 }
246
247 uint32_t VvcDecodePkt::CalculateCommandBufferSize()
248 {
249 // Cmd buffer size added per slice
250 return m_sliceStatesSize;
251 }
252
253 uint32_t VvcDecodePkt::CalculatePatchListSize()
254 {
255 // Patch list size added per slice
256 if (!m_osInterface->bUsesPatchList)
257 {
258 return 0;
259 }
260
261 return m_slicePatchListSize;
262 }
263
264 uint32_t VvcDecodePkt::CalculatePicCommandSize()
265 {
266 // add tile cmd size for each frame
267 uint32_t tileCmdSize = (m_vvcBasicFeature->m_tileCols * m_vvcBasicFeature->m_tileRows) * m_tileStateSize;
268
269 return tileCmdSize + m_pictureStatesSize + COMMAND_BUFFER_RESERVED_SPACE;
270 }
271
272 uint32_t VvcDecodePkt::CalculatePicPatchListSize()
273 {
274 if (!m_osInterface->bUsesPatchList)
275 {
276 return 0;
277 }
278 // add tile patch list size for each frame
279 uint32_t tilePatchListSize = (m_vvcBasicFeature->m_tileCols * m_vvcBasicFeature->m_tileRows) * m_tilePatchListSize;
280
281 return tilePatchListSize + m_picturePatchListSize;
282 }
283
284 MOS_STATUS VvcDecodePkt::ReadVvcpStatus(MediaStatusReport* statusReport, MOS_COMMAND_BUFFER& cmdBuffer)
285 {
286 DECODE_FUNC_CALL();
287
288 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
289
290 DECODE_CHK_NULL(statusReport);
291
292 //TODO: VVC MMIO has new mechanism
293
294 return eStatus;
295 }
296
297 MOS_STATUS VvcDecodePkt::StartStatusReport(uint32_t srType, MOS_COMMAND_BUFFER* cmdBuffer)
298 {
299 DECODE_FUNC_CALL();
300 DECODE_CHK_NULL(cmdBuffer);
301 DECODE_CHK_STATUS(MediaPacket::StartStatusReportNext(srType, cmdBuffer));
302
303 SetPerfTag(CODECHAL_MODE(CODECHAL_DECODE_MODE_VVCVLD), m_vvcBasicFeature->m_pictureCodingType);
304
305 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
306 DECODE_CHK_NULL(perfProfiler);
307 DECODE_CHK_STATUS(perfProfiler->AddPerfCollectStartCmd(
308 (void *)m_vvcPipeline, m_osInterface, m_miItf, cmdBuffer));
309 #if (_DEBUG || _RELEASE_INTERNAL)
310 if (m_statusReport && m_statusReport->IsVdboxIdReportEnabled())
311 {
312 StoreEngineId(cmdBuffer, decode::DecodeStatusReportType::CsEngineIdOffset_0);
313 }
314 // Add command counter commands for debug
315 if (m_debugPkt != nullptr)
316 {
317 DECODE_CHK_STATUS(m_debugPkt->AddCommandCounterCmds(*cmdBuffer, m_statusReport));
318 }
319 #endif
320 return MOS_STATUS_SUCCESS;
321 }
322
323 MOS_STATUS VvcDecodePkt::EndStatusReport(uint32_t srType, MOS_COMMAND_BUFFER* cmdBuffer)
324 {
325 DECODE_FUNC_CALL();
326
327 DECODE_CHK_NULL(cmdBuffer);
328
329 DECODE_CHK_STATUS(ReadVvcpStatus(m_statusReport, *cmdBuffer));
330 #if (_DEBUG || _RELEASE_INTERNAL)
331 // Execute debug packet for VVCP debug
332 if (m_debugPkt != nullptr)
333 {
334 DECODE_CHK_STATUS(m_debugPkt->Execute(*cmdBuffer, m_statusReport));
335 }
336 #endif
337 DECODE_CHK_STATUS(MediaPacket::EndStatusReportNext(srType, cmdBuffer));
338
339 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
340 DECODE_CHK_NULL(perfProfiler);
341 DECODE_CHK_STATUS(perfProfiler->AddPerfCollectEndCmd(
342 (void *)m_vvcPipeline, m_osInterface, m_miItf, cmdBuffer));
343
344 return MOS_STATUS_SUCCESS;
345 }
346
347 MOS_STATUS VvcDecodePkt::InitPicLevelCmdBuffer(MHW_BATCH_BUFFER &batchBuffer, uint8_t *batchBufBase)
348 {
349 DECODE_FUNC_CALL();
350
351 auto &cmdBuffer = m_picCmdBuffer;
352 MOS_ZeroMemory(&cmdBuffer, sizeof(MOS_COMMAND_BUFFER));
353 cmdBuffer.pCmdBase = (uint32_t*)batchBufBase;
354 cmdBuffer.pCmdPtr = cmdBuffer.pCmdBase;
355 cmdBuffer.iRemaining = batchBuffer.iSize;
356 cmdBuffer.OsResource = batchBuffer.OsResource;
357
358 return MOS_STATUS_SUCCESS;
359 }
360
361 #if USE_CODECHAL_DEBUG_TOOL
362 MOS_STATUS VvcDecodePkt::DumpResources(
363 DecodeStatusMfx * decodeStatusMfx,
364 DecodeStatusReportData *statusReportData)
365 {
366 DECODE_FUNC_CALL();
367 DECODE_CHK_NULL(decodeStatusMfx);
368 DECODE_CHK_NULL(statusReportData);
369
370 return MOS_STATUS_SUCCESS;
371 }
372 #endif
373
374 MOS_STATUS VvcDecodePkt::Submit(
375 MOS_COMMAND_BUFFER* cmdBuffer,
376 uint8_t packetPhase)
377 {
378 DECODE_FUNC_CALL()
379
380 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
381
382 DECODE_CHK_NULL(cmdBuffer);
383 DECODE_CHK_NULL(m_hwInterface);
384
385 m_isFirstSliceInFrame = (m_vvcBasicFeature->m_curSlice == 0) ? true : false;
386 m_isLastSliceInFrame = (m_vvcBasicFeature->m_curSlice == m_vvcBasicFeature->m_numSlices - 1) ? true : false;
387
388 if (m_isFirstSliceInFrame)
389 {
390 DECODE_CHK_STATUS(m_miItf->SetWatchdogTimerThreshold(m_vvcBasicFeature->m_width, m_vvcBasicFeature->m_height, false));
391
392 DECODE_CHK_STATUS(Mos_Solo_PreProcessDecode(m_osInterface, &m_vvcBasicFeature->m_destSurface));
393
394 auto mmioRegisters = m_hwInterface->GetVdencInterfaceNext()->GetMmioRegisters(MHW_VDBOX_NODE_1);
395
396 HalOcaInterfaceNext::On1stLevelBBStart(*cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, m_miItf, *mmioRegisters);
397 HalOcaInterfaceNext::OnDispatch(*cmdBuffer, *m_osInterface, m_miItf, *m_miItf->GetMmioRegisters());
398 if (m_vvcBasicFeature->m_shortFormatInUse)
399 {
400 m_tileLevelBB = m_vvcPipeline->GetTileLvlCmdBuffer();
401 }
402 }
403
404 DECODE_CHK_STATUS(PackPictureLevelCmds(*cmdBuffer));
405
406 if (!m_vvcBasicFeature->m_shortFormatInUse)
407 {
408 DECODE_CHK_STATUS(PackSliceLevelCmds(*cmdBuffer));
409 }
410 else
411 {
412 DECODE_CHK_STATUS(PackS2LSliceLevelCmds(*cmdBuffer));
413 }
414
415 if (m_isLastSliceInFrame)
416 {
417 HalOcaInterfaceNext::On1stLevelBBEnd(*cmdBuffer, *m_osInterface);
418 m_picCmdSizeCalculated = false; // Reset flag for running next frame
419 }
420
421 if (m_isFirstSliceInFrame)
422 {
423 DECODE_CHK_STATUS(m_allocator->SyncOnResource(&m_vvcBasicFeature->m_resDataBuffer, false));
424 }
425
426 m_vvcBasicFeature->m_curSlice++; //Update current slice index
427
428 //Set ReadyToExecute to true for the last slice of the frame
429 Mos_Solo_SetReadyToExecute(m_osInterface, m_vvcBasicFeature->m_frameCompletedFlag);
430 DECODE_CHK_STATUS(Mos_Solo_PostProcessDecode(m_osInterface, &m_vvcBasicFeature->m_destSurface));
431
432 return MOS_STATUS_SUCCESS;
433 }
434
435 MOS_STATUS VvcDecodePkt::PackPictureLevelCmds(MOS_COMMAND_BUFFER& cmdBuffer)
436 {
437 DECODE_FUNC_CALL()
438
439 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
440
441 if (m_isFirstSliceInFrame)
442 {
443 if (IsPrologRequired())
444 {
445 DECODE_CHK_STATUS(AddForceWakeup(cmdBuffer));
446 DECODE_CHK_STATUS(SendPrologWithFrameTracking(cmdBuffer, true));
447 }
448 DECODE_CHK_STATUS(StartStatusReport(statusReportMfx, &cmdBuffer));
449 }
450
451 DECODE_CHK_STATUS(m_picturePkt->InitVvcState(cmdBuffer));
452
453 // For multi-slice case, picture level cmds are the same among different slices.
454 // Put them into 2nd level BB to prepare them only once for the 1st slice of the frame to reduce SW latency.
455 if (m_isFirstSliceInFrame)
456 {
457 m_picBatchBuf = m_picturePkt->GetPicLvlBB();
458
459 if (m_picBatchBuf != nullptr)
460 {
461 ResourceAutoLock resLock(m_allocator, &m_picBatchBuf->OsResource);
462 uint8_t *batchBufBase = (uint8_t *)resLock.LockResourceForWrite();
463 DECODE_CHK_STATUS(InitPicLevelCmdBuffer(*m_picBatchBuf, batchBufBase));
464 DECODE_CHK_STATUS(m_picturePkt->Execute(m_picCmdBuffer));
465 DECODE_CHK_STATUS(m_miItf->AddMiBatchBufferEnd(&m_picCmdBuffer, nullptr));
466 }
467 }
468
469 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_BATCH_BUFFER_START(&cmdBuffer, m_picBatchBuf));
470
471 return MOS_STATUS_SUCCESS;
472 }
473
474 void VvcDecodePkt::CalculateVvcSliceLvlCmdSize()
475 {
476 m_vvcpSliceCmdSize = m_vvcpItf->GETSIZE_VVCP_SLICE_STATE() +
477 m_vvcpItf->GETSIZE_VVCP_REF_IDX_STATE() * 2 +
478 m_vvcpItf->GETSIZE_VVCP_WEIGHTOFFSET_STATE() * 2 +
479 m_vvcpItf->GETSIZE_VVCP_BSD_OBJECT() +
480 m_miItf->GETSIZE_MI_BATCH_BUFFER_START();
481 }
482
483 MOS_STATUS VvcDecodePkt::PackS2LSliceLevelCmds(MOS_COMMAND_BUFFER &cmdBuffer)
484 {
485 DECODE_FUNC_CALL()
486
487 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
488 uint16_t sliceIdx = m_vvcBasicFeature->m_curSlice;
489
490 if (sliceIdx < m_vvcBasicFeature->m_numSlices)
491 {
492 auto buf = m_vvcPipeline->GetSliceLvlCmdBuffer();
493 DECODE_CHK_NULL(buf);
494 buf->dwOffset = m_vvcPipeline->GetSliceLvlBufSize() * sliceIdx;
495 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_BATCH_BUFFER_START(&cmdBuffer, buf)); //Jump to Slice Batch Buffer
496 DECODE_CHK_STATUS(VdMemoryFlush(cmdBuffer));
497 DECODE_CHK_STATUS(VdPipelineFlush(cmdBuffer));
498 }
499 if (m_isLastSliceInFrame)
500 {
501 DECODE_CHK_STATUS(EnsureAllCommandsExecuted(cmdBuffer));
502 DECODE_CHK_STATUS(EndStatusReport(statusReportMfx, &cmdBuffer));
503 DECODE_CHK_STATUS(UpdateStatusReportNext(statusReportGlobalCount, &cmdBuffer));
504 }
505
506 CODECHAL_DEBUG_TOOL(
507 if (m_mmcState) {
508 m_mmcState->UpdateUserFeatureKey(&(m_vvcBasicFeature->m_destSurface));
509 })
510
511 if (m_isLastSliceInFrame)
512 {
513 DECODE_CHK_STATUS(m_miItf->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
514 }
515 return MOS_STATUS_SUCCESS;
516 }
517
518 MOS_STATUS VvcDecodePkt::PackSliceLevelCmds(MOS_COMMAND_BUFFER& cmdBuffer)
519 {
520 DECODE_FUNC_CALL()
521
522 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
523
524 uint16_t sliceIdx = m_vvcBasicFeature->m_curSlice;
525 if ( sliceIdx < m_vvcBasicFeature->m_numSlices)
526 {
527 DECODE_CHK_STATUS(m_slicePkt->Execute(cmdBuffer, m_vvcBasicFeature->m_sliceIdxInOrder[sliceIdx]));
528 DECODE_CHK_STATUS(VdMemoryFlush(cmdBuffer));
529 DECODE_CHK_STATUS(VdPipelineFlush(cmdBuffer));
530 }
531
532 if (m_isLastSliceInFrame)
533 {
534 DECODE_CHK_STATUS(EnsureAllCommandsExecuted(cmdBuffer));
535 DECODE_CHK_STATUS(EndStatusReport(statusReportMfx, &cmdBuffer));
536 DECODE_CHK_STATUS(UpdateStatusReportNext(statusReportGlobalCount, &cmdBuffer));
537 }
538
539 CODECHAL_DEBUG_TOOL(
540 if (m_mmcState)
541 {
542 m_mmcState->UpdateUserFeatureKey(&(m_vvcBasicFeature->m_destSurface));
543 })
544
545 if (m_isLastSliceInFrame)
546 {
547 DECODE_CHK_STATUS(m_miItf->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
548 }
549
550 return MOS_STATUS_SUCCESS;
551 }
552
553 MOS_STATUS VvcDecodePkt::VdMemoryFlush(MOS_COMMAND_BUFFER& cmdBuffer)
554 {
555 DECODE_FUNC_CALL()
556
557 auto &par = m_vvcpItf->MHW_GETPAR_F(VVCP_VD_CONTROL_STATE)();
558 par = {};
559
560 par.memoryImplicitFlush = true;
561
562 DECODE_CHK_STATUS(m_vvcpItf->MHW_ADDCMD_F(VVCP_VD_CONTROL_STATE)(&cmdBuffer));
563
564 return MOS_STATUS_SUCCESS;
565 }
566
567 MOS_STATUS VvcDecodePkt::EnsureAllCommandsExecuted(MOS_COMMAND_BUFFER& cmdBuffer)
568 {
569 DECODE_FUNC_CALL()
570
571 // Send MI_FLUSH command
572 auto &par = m_miItf->GETPAR_MI_FLUSH_DW();
573 par = {};
574 auto *skuTable = m_vvcPipeline->GetSkuTable();
575 if (skuTable && MEDIA_IS_SKU(skuTable, FtrEnablePPCFlush))
576 {
577 // Add PPC fulsh
578 par.bEnablePPCFlush = true;
579 }
580 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_FLUSH_DW(&cmdBuffer));
581
582 return MOS_STATUS_SUCCESS;
583 }
584
585 }