Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/shared/pipeline/encode_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 encode_pipeline.cpp
25 //! \brief Defines the common interface for encode pipeline
26 //! \details The encode 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 "encode_pipeline.h"
30 #include "encode_utils.h"
31 #include "media_packet.h"
32
33 #include "codechal_setting.h"
34 #include "encode_status_report_defs.h"
35 #include "encode_status_report.h"
36 #include "mos_solo_generic.h"
37
38 namespace encode {
39 EncodePipeline::EncodePipeline(
40 CodechalHwInterfaceNext *hwInterface,
41 CodechalDebugInterface *debugInterface):
42 MediaPipeline(hwInterface ? hwInterface->GetOsInterface() : nullptr),
43 m_hwInterface(hwInterface)
44 {
45
46 }
47
48 MOS_STATUS EncodePipeline::Initialize(void *settings)
49 {
50 ENCODE_FUNC_CALL();
51 ENCODE_CHK_STATUS_RETURN(InitUserSetting(m_userSettingPtr));
52 ENCODE_CHK_STATUS_RETURN(MediaPipeline::InitPlatform());
53 ENCODE_CHK_STATUS_RETURN(MediaPipeline::CreateMediaCopyWrapper());
54 ENCODE_CHK_NULL_RETURN(m_mediaCopyWrapper);
55
56 ENCODE_CHK_NULL_RETURN(m_hwInterface);
57 ENCODE_CHK_NULL_RETURN(m_hwInterface->GetOsInterface());
58
59 m_osInterface = m_hwInterface->GetOsInterface();
60 ENCODE_CHK_NULL_RETURN(m_osInterface);
61
62 if (m_mediaCopyWrapper->MediaCopyStateIsNull())
63 {
64 m_mediaCopyWrapper->SetMediaCopyState(m_hwInterface->CreateMediaCopy(m_osInterface));
65 }
66
67 m_mediaContext = MOS_New(MediaContext, scalabilityEncoder, m_hwInterface, m_osInterface);
68 ENCODE_CHK_NULL_RETURN(m_mediaContext);
69
70 m_allocator = MOS_New(EncodeAllocator, m_osInterface);
71 ENCODE_CHK_NULL_RETURN(m_allocator);
72
73 m_trackedBuf = MOS_New(TrackedBuffer, m_allocator, (uint8_t)CODEC_NUM_REF_BUFFERS, (uint8_t)CODEC_NUM_NON_REF_BUFFERS);
74 ENCODE_CHK_NULL_RETURN(m_trackedBuf);
75
76 m_recycleBuf = MOS_New(RecycleResource, m_allocator);
77 ENCODE_CHK_NULL_RETURN(m_recycleBuf);
78
79 CodechalSetting *codecSettings = (CodechalSetting*)settings;
80 m_standard = codecSettings->standard;
81 m_mode = codecSettings->mode;
82 m_codecFunction = codecSettings->codecFunction;
83
84 CODECHAL_DEBUG_TOOL(
85 m_debugInterface = MOS_New(CodechalDebugInterface);
86 ENCODE_CHK_NULL_RETURN(m_debugInterface);
87 ENCODE_CHK_STATUS_RETURN(
88 m_debugInterface->Initialize(m_hwInterface, m_codecFunction, m_mediaCopyWrapper)
89 );
90
91 m_statusReportDebugInterface = MOS_New(CodechalDebugInterface);
92 ENCODE_CHK_NULL_RETURN(m_statusReportDebugInterface);
93 ENCODE_CHK_STATUS_RETURN(
94 m_statusReportDebugInterface->Initialize(m_hwInterface, m_codecFunction, m_mediaCopyWrapper));
95 );
96
97 MediaUserSetting::Value outValue;
98 ReadUserSetting(
99 m_userSettingPtr,
100 outValue,
101 "Single Task Phase Enable",
102 MediaUserSetting::Group::Sequence);
103 m_singleTaskPhaseSupported = outValue.Get<bool>();
104
105 ENCODE_CHK_STATUS_RETURN(CreateFeatureManager());
106 ENCODE_CHK_NULL_RETURN(m_featureManager);
107
108 m_featureManager->SetUserSettingPtr(m_userSettingPtr);
109
110 m_encodecp = MOS_New(EncodeCp, m_hwInterface);
111 m_encodecp->RegisterParams(codecSettings);
112 bool cpenable = m_encodecp->isCpEnabled();
113
114 ENCODE_CHK_STATUS_RETURN(m_featureManager->Init(codecSettings));
115
116 m_packetUtilities = MOS_New(PacketUtilities, m_hwInterface, m_featureManager);
117 ENCODE_CHK_NULL_RETURN(m_packetUtilities);
118 ENCODE_CHK_STATUS_RETURN(m_packetUtilities->Init());
119
120 m_statusReport = MOS_New(EncoderStatusReport, m_allocator, m_osInterface, true, true, cpenable);
121 ENCODE_CHK_NULL_RETURN(m_statusReport);
122 ENCODE_CHK_STATUS_RETURN(m_statusReport->Create());
123
124 m_encodecp->setStatusReport(m_statusReport);
125
126 return MOS_STATUS_SUCCESS;
127 }
128
129 MOS_STATUS EncodePipeline::Uninitialize()
130 {
131 ENCODE_FUNC_CALL();
132
133 MOS_Delete(m_mediaContext);
134
135 MOS_Delete(m_encodecp);
136
137 MOS_Delete(m_statusReport);
138
139 CODECHAL_DEBUG_TOOL(
140 MOS_Delete(m_debugInterface);
141 MOS_Delete(m_statusReportDebugInterface);
142 );
143
144 MOS_Delete(m_trackedBuf);
145
146 MOS_Delete(m_recycleBuf);
147
148 if (m_featureManager != nullptr)
149 {
150 m_featureManager->Destroy();
151 MOS_Delete(m_featureManager);
152 }
153
154 // Allocator should not be destroyed until all resources released.
155 if (m_allocator != nullptr)
156 {
157 m_allocator->DestroyAllResources();
158 MOS_Delete(m_allocator);
159 }
160
161 MOS_Delete(m_packetUtilities);
162
163 return MOS_STATUS_SUCCESS;
164 }
165
166 MOS_STATUS EncodePipeline::UserFeatureReport()
167 {
168 ENCODE_FUNC_CALL();
169 ENCODE_CHK_STATUS_RETURN(MediaPipeline::UserFeatureReport());
170
171 // Encode HW Walker Reporting
172 // WriteUserFeature(__MEDIA_USER_FEATURE_VALUE_ENCODE_HW_WALKER_ID, m_hwWalker);
173 // if (m_hwWalker)
174 // {
175 // // Encode HW Walker m_mode Reporting
176 //#if (_DEBUG || _RELEASE_INTERNAL)
177 // WriteUserFeature(__MEDIA_USER_FEATURE_VALUE_ENCODE_HW_WALKER_MODE_ID, m_walkerMode);
178 //#endif // _DEBUG || _RELEASE_INTERNAL
179 // }
180 //
181 // if (MEDIA_IS_SKU(m_skuTable, FtrSliceShutdown))
182 // {
183 // // SliceShutdownEnable Reporting
184 // WriteUserFeature(__MEDIA_USER_FEATURE_VALUE_SLICE_SHUTDOWN_ENABLE_ID, m_sliceShutdownEnable);
185 // }
186 #if (_DEBUG || _RELEASE_INTERNAL)
187 ReportUserSettingForDebug(
188 m_userSettingPtr,
189 "Media Encode Used VDBOX Number",
190 GetPipeNum(),
191 MediaUserSetting::Group::Sequence);
192
193 ReportUserSettingForDebug(
194 m_userSettingPtr,
195 "Media Encode DDI TargetUsage",
196 GetDDITU(),
197 MediaUserSetting::Group::Sequence);
198 #endif // _DEBUG || _RELEASE_INTERNAL
199
200 return MOS_STATUS_SUCCESS;
201 }
202
203 MOS_STATUS EncodePipeline::Prepare(void *params)
204 {
205 ENCODE_FUNC_CALL();
206
207 ENCODE_CHK_NULL_RETURN(params);
208 ENCODE_CHK_NULL_RETURN(m_hwInterface);
209
210 ENCODE_CHK_NULL_RETURN(m_featureManager);
211 ENCODE_CHK_STATUS_RETURN(m_featureManager->CheckFeatures(params));
212 ENCODE_CHK_STATUS_RETURN(m_featureManager->Update(params));
213 m_encodecp->UpdateParams(true);
214
215 ENCODE_CHK_STATUS_RETURN(WaitForBatchBufferComplete());
216
217 EncoderParams *encodeParams = (EncoderParams *)params;
218 ENCODE_CHK_STATUS_RETURN(Mos_Solo_SetGpuAppTaskEvent(m_osInterface, encodeParams->gpuAppTaskEvent));
219
220 m_osInterface->pfnIncPerfFrameID(m_osInterface);
221
222 return MOS_STATUS_SUCCESS;
223 }
224
225 MOS_STATUS EncodePipeline::ContextSwitchBack()
226 {
227 ENCODE_FUNC_CALL();
228
229 ENCODE_CHK_NULL_RETURN(m_scalPars);
230
231 m_scalPars->IsContextSwitchBack = true;
232 m_mediaContext->SwitchContext(VdboxEncodeFunc, m_scalPars.get(), &m_scalability);
233 m_scalPars->IsContextSwitchBack = false;
234
235 ENCODE_CHK_NULL_RETURN(m_scalability);
236
237 m_scalability->SetPassNumber(m_featureManager->GetNumPass());
238
239 return MOS_STATUS_SUCCESS;
240 }
241
242 MOS_STATUS EncodePipeline::GetSystemVdboxNumber()
243 {
244 MEDIA_SYSTEM_INFO *gtSystemInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
245 MEDIA_ENGINE_INFO mediaSysInfo;
246 MOS_ZeroMemory(&mediaSysInfo, sizeof(MEDIA_ENGINE_INFO));
247 MOS_STATUS eStatus = m_osInterface->pfnGetMediaEngineInfo(m_osInterface, mediaSysInfo);
248
249 if (eStatus == MOS_STATUS_SUCCESS && (!MEDIA_IS_SKU(m_skuTable, FtrWithSlimVdbox)))
250 {
251 // Both VE mode and media solo mode should be able to get the VDBOX number via the same interface
252 m_numVdbox = (uint8_t)(mediaSysInfo.VDBoxInfo.NumberOfVDBoxEnabled);
253 }
254 else
255 {
256 m_numVdbox = 1;
257 }
258
259 return MOS_STATUS_SUCCESS;
260 }
261
262 MOS_STATUS EncodePipeline::WaitForBatchBufferComplete()
263 {
264 ENCODE_CHK_NULL_RETURN(m_statusReport);
265
266 const uint32_t completedFrames = m_statusReport->GetCompletedCount();
267
268 if (!m_hwInterface->IsSimActive() &&
269 m_recycledBufStatusNum[m_currRecycledBufIdx] > completedFrames)
270 {
271 uint32_t waitMs;
272
273 // Wait for Batch Buffer complete event OR timeout
274 for (waitMs = MHW_TIMEOUT_MS_DEFAULT; waitMs > 0; waitMs -= MHW_EVENT_TIMEOUT_MS)
275 {
276 if (m_recycledBufStatusNum[m_currRecycledBufIdx] <= completedFrames)
277 {
278 break;
279 }
280
281 MosUtilities::MosSleep(MHW_EVENT_TIMEOUT_MS);
282 }
283
284 ENCODE_VERBOSEMESSAGE("Waited for %d ms", (MHW_TIMEOUT_MS_DEFAULT - waitMs));
285
286 if (m_recycledBufStatusNum[m_currRecycledBufIdx] > completedFrames)
287 {
288 ENCODE_ASSERTMESSAGE("No recycled buffers available, wait timed out at %d ms!", MHW_TIMEOUT_MS_DEFAULT);
289 ENCODE_ASSERTMESSAGE("m_storeData = %d, m_recycledBufStatusNum[%d] = %d, data = %d",
290 m_statusReport->GetSubmittedCount(),
291 m_currRecycledBufIdx,
292 m_recycledBufStatusNum[m_currRecycledBufIdx],
293 completedFrames);
294 return MOS_STATUS_CLIENT_AR_NO_SPACE;
295 }
296 }
297
298 m_recycledBufStatusNum[m_currRecycledBufIdx] = m_statusReport->GetSubmittedCount();
299
300 return MOS_STATUS_SUCCESS;
301 }
302
303 MOS_STATUS EncodePipeline::ExecuteActivePackets()
304 {
305 ENCODE_FUNC_CALL();
306 MOS_TraceEventExt(EVENT_PIPE_EXE, EVENT_TYPE_START, nullptr, 0, nullptr, 0);
307
308 for (auto prop : m_activePacketList)
309 {
310 prop.stateProperty.singleTaskPhaseSupported = m_singleTaskPhaseSupported;
311 prop.stateProperty.statusReport = m_statusReport;
312 MOS_TraceEventExt(EVENT_PIPE_EXE, EVENT_TYPE_INFO, &prop.packetId, sizeof(uint32_t), nullptr, 0);
313
314 MediaTask *task = prop.packet->GetActiveTask();
315 ENCODE_CHK_STATUS_RETURN(task->AddPacket(&prop));
316 if (prop.immediateSubmit)
317 {
318 ENCODE_CHK_STATUS_RETURN(task->Submit(true, m_scalability, m_debugInterface));
319 }
320 }
321
322 m_activePacketList.clear();
323 MOS_TraceEventExt(EVENT_PIPE_EXE, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
324 return MOS_STATUS_SUCCESS;
325 }
326
327 MOS_STATUS EncodePipeline::ExecuteResolveMetaData(PMOS_RESOURCE pInput, PMOS_RESOURCE pOutput)
328 {
329 ENCODE_FUNC_CALL();
330 MOS_COMMAND_BUFFER cmdBuffer;
331 MOS_ZeroMemory(&cmdBuffer, sizeof(cmdBuffer));
332
333 ENCODE_CHK_NULL_RETURN(m_scalability);
334 ENCODE_CHK_STATUS_RETURN(m_scalability->GetCmdBuffer(&cmdBuffer));
335
336 auto basicFeature = dynamic_cast<EncodeBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
337 ENCODE_CHK_NULL_RETURN(basicFeature);
338 uint32_t bufSize = basicFeature->m_metaDataOffset.dwMetaDataSize + basicFeature->m_numSlices * basicFeature->m_metaDataOffset.dwMetaDataSubRegionSize +
339 basicFeature->m_metaDataOffset.dwTilePartitionSize + basicFeature->m_metaDataOffset.dwPostFeatueSize;
340 m_packetUtilities->AddMemCopyCmd(&cmdBuffer, pOutput, pInput, bufSize);
341 ENCODE_CHK_STATUS_RETURN(m_scalability->ReturnCmdBuffer(&cmdBuffer));
342 ENCODE_CHK_STATUS_RETURN(m_scalability->SubmitCmdBuffer(&cmdBuffer));
343
344 return MOS_STATUS_SUCCESS;
345 }
346
347 MOS_STATUS EncodePipeline::ReportErrorFlag(PMOS_RESOURCE pMetadataBuffer,
348 uint32_t size, uint32_t offset, uint32_t flag)
349 {
350 ENCODE_FUNC_CALL();
351 MOS_COMMAND_BUFFER cmdBuffer;
352 MOS_ZeroMemory(&cmdBuffer, sizeof(cmdBuffer));
353
354 ENCODE_CHK_NULL_RETURN(m_scalability);
355 ENCODE_CHK_STATUS_RETURN(m_scalability->GetCmdBuffer(&cmdBuffer));
356
357 auto basicFeature = dynamic_cast<EncodeBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
358 ENCODE_CHK_NULL_RETURN(basicFeature);
359
360 basicFeature->m_metaDataOffset.dwMetaDataSize = size;
361 m_packetUtilities->AddStoreDataImmCmd(&cmdBuffer, pMetadataBuffer, offset, flag);
362 ENCODE_CHK_STATUS_RETURN(m_scalability->ReturnCmdBuffer(&cmdBuffer));
363 ENCODE_CHK_STATUS_RETURN(m_scalability->SubmitCmdBuffer(&cmdBuffer));
364 return MOS_STATUS_SUCCESS;
365 }
366
367 void EncodePipeline::SetFrameTrackingForMultiTaskPhase()
368 {
369 if (!IsSingleTaskPhaseSupported())
370 {
371 for_each(m_activePacketList.begin(), m_activePacketList.end() - 1, [&](PacketProperty &blk) { blk.frameTrackingRequested = false; });
372 }
373 }
374
375 }