Debian Codegraph @

media_softlet/agnostic/common/codec/hal/dec/shared/pipeline/decode_pipeline.cpp

raw
1 /*
2 * Copyright (c) 2018-2025, 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 decode_pipeline.cpp
25 //! \brief Defines the common interface for decode pipeline
26 //! \details The decode pipeline interface is further sub-divided by codec standard,
27 //! this file is for the base interface which is shared by all codecs.
28 //!
29 #include "decode_pipeline.h"
30 #include "decode_utils.h"
31 #include "decode_status_report.h"
32 #include "media_packet.h"
33 #include "decode_predication_packet.h"
34 #include "decode_marker_packet.h"
35 #include "decode_downsampling_packet.h"
36 #include "codechal_setting.h"
37 #include "decode_basic_feature.h"
38 #include "mos_solo_generic.h"
39 #include "decode_sfc_histogram_postsubpipeline.h"
40 #include "decode_common_feature_defs.h"
41 #include "decode_resource_auto_lock.h"
42
43 namespace decode {
44
45 DecodePipeline::DecodePipeline(
46 CodechalHwInterfaceNext *hwInterface,
47 CodechalDebugInterface *debugInterface):
48 MediaPipeline(hwInterface ? hwInterface->GetOsInterface() : nullptr)
49 {
50 DECODE_FUNC_CALL();
51
52 DECODE_ASSERT(hwInterface != nullptr);
53 m_hwInterface = hwInterface;
54 MOS_STATUS m_status = (InitUserSetting(m_userSettingPtr));
55
56 m_singleTaskPhaseSupported =
57 ReadUserFeature(m_userSettingPtr, "Decode Single Task Phase Enable", MediaUserSetting::Group::Sequence).Get<bool>();
58
59 m_pCodechalOcaDumper = MOS_New(CodechalOcaDumper);
60 if (!m_pCodechalOcaDumper)
61 {
62 MOS_OS_ASSERTMESSAGE("Initialize CodechalOcaDumper failed!");
63 }
64 }
65
66 MOS_STATUS DecodePipeline::CreateStatusReport()
67 {
68 m_statusReport = MOS_New(DecodeStatusReport, m_allocator, true, m_osInterface);
69 DECODE_CHK_NULL(m_statusReport);
70 DECODE_CHK_STATUS(m_statusReport->Create());
71
72 return MOS_STATUS_SUCCESS;
73 }
74
75 MOS_STATUS DecodePipeline::CreatePreSubPipeLines(DecodeSubPipelineManager &subPipelineManager)
76 {
77 m_bitstream = MOS_New(DecodeInputBitstream, this, m_task, m_numVdbox);
78 DECODE_CHK_NULL(m_bitstream);
79 DECODE_CHK_STATUS(subPipelineManager.Register(*m_bitstream));
80
81 m_streamout = MOS_New(DecodeStreamOut, this, m_task, m_numVdbox);
82 DECODE_CHK_NULL(m_streamout);
83 DECODE_CHK_STATUS(subPipelineManager.Register(*m_streamout));
84 return MOS_STATUS_SUCCESS;
85 }
86
87 MOS_STATUS DecodePipeline::CreatePostSubPipeLines(DecodeSubPipelineManager &subPipelineManager)
88 {
89 DECODE_FUNC_CALL();
90
91 #ifdef _DECODE_PROCESSING_SUPPORTED
92 auto sfcHistogramPostSubPipeline = MOS_New(DecodeSfcHistogramSubPipeline, this, m_task, m_numVdbox);
93 DECODE_CHK_NULL(sfcHistogramPostSubPipeline);
94 DECODE_CHK_STATUS(m_postSubPipeline->Register(*sfcHistogramPostSubPipeline));
95 #endif
96
97 return MOS_STATUS_SUCCESS;
98 }
99
100 MOS_STATUS DecodePipeline::CreateSubPipeLineManager(CodechalSetting* codecSettings)
101 {
102 m_preSubPipeline = MOS_New(DecodeSubPipelineManager, *this);
103 DECODE_CHK_NULL(m_preSubPipeline);
104 DECODE_CHK_STATUS(CreatePreSubPipeLines(*m_preSubPipeline));
105 DECODE_CHK_STATUS(m_preSubPipeline->Init(*codecSettings));
106
107 m_postSubPipeline = MOS_New(DecodeSubPipelineManager, *this);
108 DECODE_CHK_NULL(m_postSubPipeline);
109 DECODE_CHK_STATUS(CreatePostSubPipeLines(*m_postSubPipeline));
110 DECODE_CHK_STATUS(m_postSubPipeline->Init(*codecSettings));
111
112 return MOS_STATUS_SUCCESS;
113 }
114
115 MOS_STATUS DecodePipeline::CreateSubPackets(DecodeSubPacketManager& subPacketManager, CodechalSetting &codecSettings)
116 {
117 DecodePredicationPkt *predicationPkt = MOS_New(DecodePredicationPkt, this, m_hwInterface);
118 DECODE_CHK_NULL(predicationPkt);
119 DECODE_CHK_STATUS(subPacketManager.Register(
120 DecodePacketId(this, predicationSubPacketId), *predicationPkt));
121
122 DecodeMarkerPkt *markerPkt = MOS_New(DecodeMarkerPkt, this, m_hwInterface);
123 DECODE_CHK_NULL(markerPkt);
124 DECODE_CHK_STATUS(subPacketManager.Register(
125 DecodePacketId(this, markerSubPacketId), *markerPkt));
126 return MOS_STATUS_SUCCESS;
127 }
128
129 DecodeSubPacket* DecodePipeline::GetSubPacket(uint32_t subPacketId)
130 {
131 return m_subPacketManager->GetSubPacket(subPacketId);
132 }
133
134 MOS_STATUS DecodePipeline::CreateSubPacketManager(CodechalSetting* codecSettings)
135 {
136 DECODE_CHK_NULL(codecSettings);
137 m_subPacketManager = MOS_New(DecodeSubPacketManager);
138 DECODE_CHK_NULL(m_subPacketManager);
139 DECODE_CHK_STATUS(CreateSubPackets(*m_subPacketManager, *codecSettings));
140 DECODE_CHK_STATUS(m_subPacketManager->Init());
141 return MOS_STATUS_SUCCESS;
142 }
143
144 MOS_STATUS DecodePipeline::Initialize(void *settings)
145 {
146 DECODE_FUNC_CALL();
147
148 DECODE_CHK_NULL(settings);
149
150 DECODE_CHK_STATUS(MediaPipeline::InitPlatform());
151 DECODE_CHK_STATUS(MediaPipeline::CreateMediaCopyWrapper());
152 DECODE_CHK_NULL(m_mediaCopyWrapper);
153
154 DECODE_CHK_NULL(m_waTable);
155
156 auto *codecSettings = (CodechalSetting*)settings;
157 DECODE_CHK_NULL(m_hwInterface);
158 DECODE_CHK_STATUS(m_hwInterface->Initialize(codecSettings));
159
160 if (m_mediaCopyWrapper->MediaCopyStateIsNull())
161 {
162 m_mediaCopyWrapper->SetMediaCopyState(m_hwInterface->CreateMediaCopy(m_osInterface));
163 }
164
165 CODECHAL_DEBUG_TOOL(
166 m_debugInterface = MOS_New(CodechalDebugInterface);
167 DECODE_CHK_NULL(m_debugInterface);
168 DECODE_CHK_STATUS(
169 m_debugInterface->Initialize(m_hwInterface, codecSettings->codecFunction, m_mediaCopyWrapper));
170 );
171
172 m_mediaContext = MOS_New(MediaContext, scalabilityDecoder, m_hwInterface, m_osInterface);
173 DECODE_CHK_NULL(m_mediaContext);
174
175 m_task = CreateTask(MediaTask::TaskType::cmdTask);
176 DECODE_CHK_NULL(m_task);
177
178 m_numVdbox = GetSystemVdboxNumber();
179
180 bool limitedLMemBar = MEDIA_IS_SKU(m_skuTable, FtrLimitedLMemBar) ? true : false;
181 m_allocator = MOS_New(DecodeAllocator, m_osInterface, limitedLMemBar);
182 DECODE_CHK_NULL(m_allocator);
183
184 DECODE_CHK_STATUS(CreateStatusReport());
185
186 #if (_DEBUG || _RELEASE_INTERNAL)
187 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
188 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
189 MOS_UserFeature_ReadValue_ID(
190 nullptr,
191 __MEDIA_USER_FEATURE_VALUE_VDBOX_COMMAND_COUNTER_OVERRIDE_ID,
192 &userFeatureData,
193 m_osInterface->pOsContext);
194 m_vdboxCommandCounterOverride = userFeatureData.i32Data;
195 DECODE_NORMALMESSAGE("m_vdboxCommandCounterOverride value read: %d", m_vdboxCommandCounterOverride);
196 #endif
197
198 m_decodecp = Create_DecodeCpInterface(codecSettings, m_hwInterface->GetCpInterface(), m_hwInterface->GetOsInterface());
199 if (m_decodecp)
200 {
201 DECODE_CHK_STATUS(m_decodecp->RegisterParams(codecSettings));
202 }
203 DECODE_CHK_STATUS(CreateFeatureManager());
204 DECODE_CHK_STATUS(m_featureManager->Init(codecSettings));
205
206 DECODE_CHK_STATUS(CreateSubPipeLineManager(codecSettings));
207 DECODE_CHK_STATUS(CreateSubPacketManager(codecSettings));
208
209 #if (_DEBUG || _RELEASE_INTERNAL)
210 m_delayMiliseconds = ReadUserFeature(m_userSettingPtr, "Delay Miliseconds", MediaUserSetting::Group::Sequence).Get<uint32_t>();
211 #endif
212
213 #if MHW_HWCMDPARSER_ENABLED
214 mhw::HwcmdParser::InitInstance(m_osInterface, mhw::HwcmdParser::AddOnMode::NoAddOn);
215 #endif
216
217 return MOS_STATUS_SUCCESS;
218 }
219
220 #if (_DEBUG || _RELEASE_INTERNAL)
221 void DecodePipeline::InitMemDataAccessCrcOutputEnable()
222 {
223 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
224 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
225 MOS_UserFeature_ReadValue_ID(
226 nullptr,
227 __MEDIA_USER_FEATURE_VALUE_VDBOX_CRC_OUTPUT_ENABLE_ID,
228 &userFeatureData,
229 m_osInterface->pOsContext);
230 m_memDataAccessCrcOutputEnable = userFeatureData.i32Data ? true : false;
231 }
232 #endif
233
234 MOS_STATUS DecodePipeline::Uninitialize()
235 {
236 DECODE_FUNC_CALL();
237
238 // Wait all cmd completion before delete resource.
239 m_osInterface->pfnWaitAllCmdCompletion(m_osInterface);
240
241 Delete_DecodeCpInterface(m_decodecp);
242 m_decodecp = nullptr;
243
244 MOS_Delete(m_mediaContext);
245
246 MOS_Delete(m_statusReport);
247
248 MOS_Delete(m_featureManager);
249
250 MOS_Delete(m_preSubPipeline);
251 MOS_Delete(m_postSubPipeline);
252 MOS_Delete(m_subPacketManager);
253
254 MOS_Delete(m_allocator);
255
256 CODECHAL_DEBUG_TOOL(MOS_Delete(m_debugInterface););
257
258 return MOS_STATUS_SUCCESS;
259 }
260
261 MOS_STATUS DecodePipeline::UserFeatureReport()
262 {
263 DECODE_FUNC_CALL();
264 return MediaPipeline::UserFeatureReport();
265 }
266
267 bool DecodePipeline::IsFirstProcessPipe(const DecodePipelineParams& pipelineParams)
268 {
269 if (pipelineParams.m_pipeMode != decodePipeModeProcess)
270 {
271 return false;
272 }
273
274 CodechalDecodeParams *decodeParams = pipelineParams.m_params;
275 if (decodeParams == nullptr)
276 {
277 return false;
278 }
279
280 return (decodeParams->m_executeCallIndex == 0);
281 }
282
283 uint8_t DecodePipeline::GetSystemVdboxNumber()
284 {
285 uint8_t numVdbox = 1;
286
287 MEDIA_ENGINE_INFO mediaSysInfo;
288 MOS_ZeroMemory(&mediaSysInfo, sizeof(MEDIA_ENGINE_INFO));
289 MOS_STATUS eStatus = m_osInterface->pfnGetMediaEngineInfo(m_osInterface, mediaSysInfo);
290 if (eStatus == MOS_STATUS_SUCCESS)
291 {
292 numVdbox = (uint8_t)(mediaSysInfo.VDBoxInfo.NumberOfVDBoxEnabled);
293 }
294 else
295 {
296 DECODE_ASSERTMESSAGE("Failed to query media engine info!!");
297 }
298
299 return numVdbox;
300 }
301
302 MOS_STATUS DecodePipeline::Prepare(void *params)
303 {
304 DECODE_FUNC_CALL();
305
306 DECODE_CHK_NULL(params);
307 DecodePipelineParams *pipelineParams = (DecodePipelineParams *)params;
308 CodechalDecodeParams *decodeParams = pipelineParams->m_params;
309 DECODE_CHK_NULL(decodeParams);
310
311 DECODE_CHK_STATUS(m_task->Clear());
312 m_activePacketList.clear();
313
314 DECODE_CHK_NULL(m_featureManager);
315 DECODE_CHK_STATUS(m_featureManager->CheckFeatures(decodeParams));
316 DECODE_CHK_STATUS(m_featureManager->Update(decodeParams));
317 if (m_decodecp)
318 {
319 DECODE_CHK_STATUS(m_decodecp->UpdateParams(true));
320 }
321 DECODE_CHK_STATUS(m_subPacketManager->Prepare());
322
323 DECODE_CHK_STATUS(Mos_Solo_SetGpuAppTaskEvent(m_osInterface, decodeParams->m_gpuAppTaskEvent));
324
325 #if MHW_HWCMDPARSER_ENABLED
326 auto instance = mhw::HwcmdParser::GetInstance();
327 if (instance)
328 {
329 // use I as default frame type
330 instance->Update('I', (void *)m_featureManager, mhw::HwcmdParser::WorkloadType::Decode);
331 }
332 #endif
333
334 return MOS_STATUS_SUCCESS;
335 }
336
337 MOS_STATUS DecodePipeline::ExecuteActivePackets()
338 {
339 DECODE_FUNC_CALL();
340 MOS_TraceEventExt(EVENT_PIPE_EXE, EVENT_TYPE_START, nullptr, 0, nullptr, 0);
341
342 // Last element in m_activePacketList must be immediately submitted
343 m_activePacketList.back().immediateSubmit = true;
344
345 for (PacketProperty prop : m_activePacketList)
346 {
347 prop.stateProperty.singleTaskPhaseSupported = m_singleTaskPhaseSupported;
348 prop.stateProperty.statusReport = m_statusReport;
349 MOS_TraceEventExt(EVENT_PIPE_EXE, EVENT_TYPE_INFO, &prop.packetId, sizeof(uint32_t), nullptr, 0);
350
351 MediaTask *task = prop.packet->GetActiveTask();
352 DECODE_CHK_STATUS(task->AddPacket(&prop));
353 if (prop.immediateSubmit)
354 {
355 DECODE_CHK_STATUS(task->Submit(true, m_scalability, m_debugInterface));
356 }
357 }
358
359 m_activePacketList.clear();
360 MOS_TraceEventExt(EVENT_PIPE_EXE, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
361 return MOS_STATUS_SUCCESS;
362 }
363
364 bool DecodePipeline::IsCompleteBitstream()
365 {
366 return (m_bitstream == nullptr) ? false : m_bitstream->IsComplete();
367 }
368
369 #ifdef _DECODE_PROCESSING_SUPPORTED
370 bool DecodePipeline::IsDownSamplingSupported()
371 {
372 DECODE_ASSERT(m_subPacketManager != nullptr);
373
374 DecodeDownSamplingPkt *downSamplingPkt = dynamic_cast<DecodeDownSamplingPkt *>(
375 GetSubPacket(DecodePacketId(this, downSamplingSubPacketId)));
376 if (downSamplingPkt == nullptr)
377 {
378 return false;
379 }
380
381 return downSamplingPkt->IsSupported();
382 }
383 #endif
384
385 MOS_SURFACE* DecodePipeline::GetDummyReference()
386 {
387 auto* feature = dynamic_cast<DecodeBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
388 return (feature != nullptr) ? &(feature->m_dummyReference) : nullptr;
389 }
390
391 CODECHAL_DUMMY_REFERENCE_STATUS DecodePipeline::GetDummyReferenceStatus()
392 {
393 auto* feature = dynamic_cast<DecodeBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
394 return (feature != nullptr) ? feature->m_dummyReferenceStatus : CODECHAL_DUMMY_REFERENCE_INVALID;
395 }
396
397 void DecodePipeline::SetDummyReferenceStatus(CODECHAL_DUMMY_REFERENCE_STATUS status)
398 {
399 auto* feature = dynamic_cast<DecodeBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
400 if (feature != nullptr)
401 {
402 feature->m_dummyReferenceStatus = status;
403 }
404 }
405
406 #if USE_CODECHAL_DEBUG_TOOL
407 #ifdef _DECODE_PROCESSING_SUPPORTED
408 MOS_STATUS DecodePipeline::DumpDownSamplingParams(DecodeDownSamplingFeature &downSamplingParams)
409 {
410 CODECHAL_DEBUG_FUNCTION_ENTER;
411 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDecodeProcParams))
412 {
413 return MOS_STATUS_SUCCESS;
414 }
415
416 if(!downSamplingParams.IsEnabled())
417 {
418 return MOS_STATUS_SUCCESS;
419 }
420
421 DECODE_CHK_NULL(downSamplingParams.m_inputSurface);
422
423 std::ostringstream oss;
424 oss.setf(std::ios::showbase | std::ios::uppercase);
425
426 oss << "Input Surface Resolution: "
427 << +downSamplingParams.m_inputSurface->dwWidth << " x " << +downSamplingParams.m_inputSurface->dwHeight << std::endl;
428 oss << "Input Region Resolution: "
429 << +downSamplingParams.m_inputSurfaceRegion.m_width << " x " << +downSamplingParams.m_inputSurfaceRegion.m_height << std::endl;
430 oss << "Input Region Offset: ("
431 << +downSamplingParams.m_inputSurfaceRegion.m_x << "," << +downSamplingParams.m_inputSurfaceRegion.m_y << ")" << std::endl;
432 oss << "Input Surface Format: "
433 << (downSamplingParams.m_inputSurface->Format == Format_NV12 ? "NV12" : "P010" )<< std::endl;
434 oss << "Output Surface Resolution: "
435 << +downSamplingParams.m_outputSurface.dwWidth << " x " << +downSamplingParams.m_outputSurface.dwHeight << std::endl;
436 oss << "Output Region Resolution: "
437 << +downSamplingParams.m_outputSurfaceRegion.m_width << " x " << +downSamplingParams.m_outputSurfaceRegion.m_height << std::endl;
438 oss << "Output Region Offset: ("
439 << +downSamplingParams.m_outputSurfaceRegion.m_x << ", " << +downSamplingParams.m_outputSurfaceRegion.m_y << ")" << std::endl;
440 oss << "Output Surface Format: "
441 << (downSamplingParams.m_outputSurface.Format == Format_NV12 ? "NV12" : "YUY2" )<< std::endl;
442
443 const char* filePath = m_debugInterface->CreateFileName(
444 "_DEC",
445 CodechalDbgBufferType::bufDecProcParams,
446 CodechalDbgExtType::txt);
447
448 std::ofstream ofs(filePath, std::ios::out);
449 ofs << oss.str();
450 ofs.close();
451
452 return MOS_STATUS_SUCCESS;
453 }
454 #endif
455
456 MOS_STATUS DecodePipeline::DumpBitstream(PMOS_RESOURCE pBitstream, uint32_t size, uint32_t offset, const char* attrName)
457 {
458 DECODE_FUNC_CALL();
459
460 DECODE_CHK_NULL(pBitstream);
461
462 if(attrName == nullptr)
463 {
464 attrName = CodechalDbgAttr::attrDecodeBitstream;
465 }
466
467 DECODE_CHK_STATUS(m_debugInterface->DumpBuffer(
468 pBitstream,
469 attrName,
470 "_DEC",
471 size,
472 offset,
473 CODECHAL_NUM_MEDIA_STATES));
474
475 if (MOS_TraceKeyEnabled(TR_KEY_DECODE_BITSTREAM_INFO))
476 {
477 MOS_LOCK_PARAMS lockFlags;
478 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
479 lockFlags.ReadOnly = 1;
480
481 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(m_osInterface, pBitstream, &lockFlags);
482 MEDIA_DEBUG_CHK_NULL(data);
483 data += offset;
484
485 DECODE_EVENTDATA_BITSTREAM eventData;
486 eventData.BitstreamSize = size;
487 for (uint32_t i = 0; i < MOS_MIN(BITSTREAM_INFO_SIZE, size); i++)
488 {
489 eventData.Data[i] = data[i];
490 }
491 MOS_TraceEvent(EVENT_DECODE_INFO_BITSTREAM, EVENT_TYPE_INFO, &eventData, sizeof(eventData));
492
493 m_osInterface->pfnUnlockResource(m_osInterface, pBitstream);
494 }
495
496 return MOS_STATUS_SUCCESS;
497 }
498
499 MOS_STATUS DecodePipeline::DelayForDumpOutput()
500 {
501 DECODE_FUNC_CALL();
502
503 if (m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDelayForDumpOutput))
504 {
505 uint32_t completedCount = m_statusReport->GetCompletedCount();
506 for (uint8_t i = 0; i < 20; i++)
507 {
508 if (completedCount <= m_statusCheckCount)
509 {
510 MosUtilities::MosSleep(5);
511 completedCount = m_statusReport->GetCompletedCount();
512 }
513 else
514 {
515 break;
516 }
517 }
518 }
519
520 return MOS_STATUS_SUCCESS;
521 }
522
523 MOS_STATUS DecodePipeline::DumpOutput(const DecodeStatusReportData& reportData)
524 {
525 DECODE_FUNC_CALL();
526
527 if (m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDecodeOutputSurface))
528 {
529 MOS_SURFACE dstSurface;
530 MOS_ZeroMemory(&dstSurface, sizeof(dstSurface));
531 dstSurface.Format = Format_NV12;
532 dstSurface.OsResource = reportData.currDecodedPicRes;
533 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&dstSurface));
534
535 DECODE_CHK_STATUS(m_debugInterface->DumpYUVSurface(
536 &dstSurface, CodechalDbgAttr::attrDecodeOutputSurface, "DstSurf"));
537 }
538
539 if(m_streamout != nullptr)
540 {
541 m_streamout->DumpOutput(reportData);
542 }
543
544 #ifdef _DECODE_PROCESSING_SUPPORTED
545 DecodeDownSamplingFeature* downSamplingFeature = dynamic_cast<DecodeDownSamplingFeature*>(
546 m_featureManager->GetFeature(DecodeFeatureIDs::decodeDownSampling));
547 if (downSamplingFeature != nullptr && downSamplingFeature->IsEnabled())
548 {
549 if (reportData.currSfcOutputSurface != nullptr &&
550 m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSfcOutputSurface))
551 {
552 MOS_SURFACE &sfcDstSurface = *reportData.currSfcOutputSurface;
553
554 if (!Mos_ResourceIsNull(&sfcDstSurface.OsResource))
555 {
556 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&sfcDstSurface));
557
558 //rgb format read from reg key
559 uint32_t sfcOutputRgbFormatFlag =
560 ReadUserFeature(m_userSettingPtr, "Decode SFC RGB Format Output", MediaUserSetting::Group::Sequence).Get<uint32_t>();
561 if (sfcOutputRgbFormatFlag)
562 {
563 DECODE_CHK_STATUS(m_debugInterface->DumpRgbDataOnYUVSurface(
564 &sfcDstSurface, CodechalDbgAttr::attrSfcOutputSurface, "SfcDstRgbSurf"));
565 }
566 else
567 {
568 DECODE_CHK_STATUS(m_debugInterface->DumpYUVSurface(
569 &sfcDstSurface, CodechalDbgAttr::attrSfcOutputSurface, "SfcDstSurf"));
570 }
571 }
572 }
573
574 if (reportData.currHistogramOutBuf != nullptr &&
575 !Mos_ResourceIsNull(reportData.currHistogramOutBuf))
576 {
577 DECODE_CHK_STATUS(m_debugInterface->DumpBuffer(
578 reportData.currHistogramOutBuf,
579 downSamplingFeature->IsVDAQMHistogramEnabled() ? CodechalDbgAttr::attrAqmHistogram : CodechalDbgAttr::attrSfcHistogram,
580 "_DEC",
581 HISTOGRAM_BINCOUNT * downSamplingFeature->m_histogramBinWidth));
582 }
583
584 if (downSamplingFeature->IsVDAQMHistogramEnabled())
585 {
586 downSamplingFeature->DumpSfcOutputs(m_debugInterface);
587 }
588 }
589
590 #endif
591
592 return MOS_STATUS_SUCCESS;
593 }
594 #endif
595
596 #if (_DEBUG || _RELEASE_INTERNAL)
597 MOS_STATUS DecodePipeline::ReportVdboxIds(const DecodeStatusMfx& status)
598 {
599 DECODE_FUNC_CALL();
600
601 uint32_t vdboxIds = 0;
602 uint32_t reportedVdboxIds = 0;
603 // Must add MEDIA_USER_SETTING_INTERNAL_REPORT for different reading path.
604 ReadUserSettingForDebug(
605 m_userSettingPtr,
606 reportedVdboxIds,
607 "Used VDBOX ID",
608 MediaUserSetting::Group::Sequence,
609 0,
610 false,
611 MEDIA_USER_SETTING_INTERNAL_REPORT);
612 vdboxIds = reportedVdboxIds;
613 for (auto i = 0; i < csInstanceIdMax; i++)
614 {
615 CsEngineId csEngineId;
616 csEngineId.value = status.m_mmioCsEngineIdReg[i];
617 if (csEngineId.value != 0)
618 {
619 DECODE_ASSERT(csEngineId.fields.classId == classIdVideoEngine);
620 DECODE_ASSERT(csEngineId.fields.instanceId < csInstanceIdMax);
621 vdboxIds |= 1 << ((csEngineId.fields.instanceId) << 2);
622 }
623 }
624
625 if (vdboxIds != reportedVdboxIds)
626 {
627 WriteUserFeature(__MEDIA_USER_FEATURE_VALUE_VDBOX_ID_USED, vdboxIds, m_osInterface->pOsContext);
628 }
629
630 return MOS_STATUS_SUCCESS;
631 }
632
633 #ifdef _DECODE_PROCESSING_SUPPORTED
634 MOS_STATUS DecodePipeline::ReportSfcLinearSurfaceUsage(const DecodeStatusReportData& reportData)
635 {
636 DECODE_FUNC_CALL();
637
638 DecodeDownSamplingFeature *downSamplingFeature = dynamic_cast<DecodeDownSamplingFeature *>(
639 m_featureManager->GetFeature(DecodeFeatureIDs::decodeDownSampling));
640 if (downSamplingFeature != nullptr && downSamplingFeature->IsEnabled())
641 {
642 if (reportData.currSfcOutputSurface != nullptr)
643 {
644 MOS_SURFACE sfcDstSurface = *reportData.currSfcOutputSurface;
645 if (!Mos_ResourceIsNull(&sfcDstSurface.OsResource))
646 {
647 if (sfcDstSurface.TileType == MOS_TILE_LINEAR)
648 {
649 WriteUserFeature(__MEDIA_USER_FEATURE_VALUE_SFC_LINEAR_OUTPUT_USED_ID, 1, m_osInterface->pOsContext);
650 }
651 else
652 {
653 WriteUserFeature(__MEDIA_USER_FEATURE_VALUE_SFC_LINEAR_OUTPUT_USED_ID, 0, m_osInterface->pOsContext);
654 }
655 }
656 }
657 }
658 return MOS_STATUS_SUCCESS;
659 }
660 #endif
661
662 MOS_STATUS DecodePipeline::StatusCheck()
663 {
664 DECODE_FUNC_CALL();
665
666 #if MHW_HWCMDPARSER_ENABLED
667 auto instance = mhw::HwcmdParser::GetInstance();
668 if (instance)
669 {
670 // Json dump for each frame
671 instance->DumpOutput();
672 }
673 #endif
674
675 #if (_DEBUG || _RELEASE_INTERNAL)
676 if (m_delayMiliseconds > 0)
677 {
678 MosUtilities::MosSleep(m_delayMiliseconds);
679 }
680 #endif
681
682 CODECHAL_DEBUG_TOOL(DECODE_CHK_STATUS(DelayForDumpOutput()));
683
684 uint32_t completedCount = m_statusReport->GetCompletedCount();
685 if (completedCount <= m_statusCheckCount)
686 {
687 DECODE_NORMALMESSAGE("Invalid status check count, completedCount = %d m_statusCheckCount =%d.", completedCount, m_statusCheckCount);
688 return MOS_STATUS_SUCCESS;
689 }
690
691 DecodeStatusReport* statusReport = dynamic_cast<DecodeStatusReport*>(m_statusReport);
692 DECODE_CHK_NULL(statusReport);
693
694 while (m_statusCheckCount < completedCount)
695 {
696 const DecodeStatusMfx& status = statusReport->GetMfxStatus(m_statusCheckCount);
697 if (status.status != DecodeStatusReport::queryEnd)
698 {
699 DECODE_NORMALMESSAGE("Media reset may have occured at frame %d, status is %d, completedCount is %d.",
700 m_statusCheckCount, status.status, completedCount);
701 }
702
703 DECODE_NORMALMESSAGE("hucStatus2 is 0x%x at frame %d.", status.m_hucErrorStatus2, m_statusCheckCount);
704 DECODE_NORMALMESSAGE("hucStatus is 0x%x at frame %d.", status.m_hucErrorStatus, m_statusCheckCount);
705
706 DECODE_CHK_STATUS(HwStatusCheck(status));
707
708 DECODE_CHK_STATUS(ReportVdboxIds(status));
709
710 #if USE_CODECHAL_DEBUG_TOOL
711 const DecodeStatusReportData& reportData = statusReport->GetReportData(m_statusCheckCount);
712
713 auto bufferDumpNumTemp = m_debugInterface->m_bufferDumpFrameNum;
714 auto currPicTemp = m_debugInterface->m_currPic;
715 auto frameTypeTemp = m_debugInterface->m_frameType;
716 auto secondField = m_debugInterface->m_secondField;
717
718 m_debugInterface->m_bufferDumpFrameNum = DecodeOutputIndex;
719 m_debugInterface->m_currPic = reportData.currDecodedPic;
720 m_debugInterface->m_frameType = reportData.frameType;
721 m_debugInterface->m_secondField = reportData.secondField;
722
723 #ifdef _DECODE_PROCESSING_SUPPORTED
724 ReportSfcLinearSurfaceUsage(reportData);
725 #endif
726
727 DECODE_CHK_STATUS(DumpOutput(reportData));
728
729 if ((CodecHal_PictureIsFrame(m_debugInterface->m_currPic)) ||
730 (CodecHal_PictureIsField(m_debugInterface->m_currPic) && m_debugInterface->m_secondField) ||
731 (!CodecHal_PictureIsFrame(m_debugInterface->m_currPic) && !CodecHal_PictureIsField(m_debugInterface->m_currPic)))
732 {
733 DecodeOutputIndex++;
734 }
735
736 m_debugInterface->m_bufferDumpFrameNum = bufferDumpNumTemp;
737 m_debugInterface->m_currPic = currPicTemp;
738 m_debugInterface->m_frameType = frameTypeTemp;
739 m_debugInterface->m_secondField = secondField;
740 #endif
741
742 m_statusCheckCount++;
743 }
744
745 return MOS_STATUS_SUCCESS;
746 }
747 #endif
748
749 }