Debian Codegraph @

media_softlet/agnostic/common/codec/hal/dec/mpeg2/packet/decode_mpeg2_packet.cpp

raw
1 /*
2 * Copyright (c) 2021-2022, 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_mpeg2_packet.cpp
24 //! \brief Defines the interface for mpeg2 decode packet.
25 //!
26
27 #include "decode_mpeg2_packet.h"
28 #include "decode_utils.h"
29 #include "decode_marker_packet.h"
30 #include "decode_status_report_defs.h"
31 #include "decode_predication_packet.h"
32 #include "codechal_debug.h"
33
34 namespace decode {
35
36 MOS_STATUS Mpeg2DecodePkt::Init()
37 {
38 DECODE_FUNC_CALL();
39 DECODE_CHK_NULL(m_miItf);
40 DECODE_CHK_NULL(m_statusReport);
41 DECODE_CHK_NULL(m_featureManager);
42 DECODE_CHK_NULL(m_mpeg2Pipeline);
43 DECODE_CHK_NULL(m_osInterface);
44
45 DECODE_CHK_STATUS(CmdPacket::Init());
46
47 m_mpeg2BasicFeature = dynamic_cast<Mpeg2BasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
48 DECODE_CHK_NULL(m_mpeg2BasicFeature);
49
50 m_allocator = m_mpeg2Pipeline->GetDecodeAllocator();
51 DECODE_CHK_NULL(m_allocator);
52
53 DECODE_CHK_STATUS(m_statusReport->RegistObserver(this));
54
55 DecodeSubPacket* subPacket = m_mpeg2Pipeline->GetSubPacket(DecodePacketId(m_mpeg2Pipeline, mpeg2PictureSubPacketId));
56 m_picturePkt = dynamic_cast<Mpeg2DecodePicPkt*>(subPacket);
57 DECODE_CHK_NULL(m_picturePkt);
58 DECODE_CHK_STATUS(m_picturePkt->CalculateCommandSize(m_pictureStatesSize, m_picturePatchListSize));
59
60 uint32_t secondLevelBBSize = 0;
61 uint32_t numMacroblocks = m_mpeg2BasicFeature->m_picWidthInMb * m_mpeg2BasicFeature->m_picHeightInMb;
62
63 if (m_mpeg2BasicFeature->m_mode == CODECHAL_DECODE_MODE_MPEG2VLD)
64 {
65 subPacket = m_mpeg2Pipeline->GetSubPacket(DecodePacketId(m_mpeg2Pipeline, mpeg2SliceSubPacketId));
66 m_slicePkt = dynamic_cast<Mpeg2DecodeSlcPkt*>(subPacket);
67 DECODE_CHK_NULL(m_slicePkt);
68 DECODE_CHK_STATUS(m_slicePkt->CalculateCommandSize(m_sliceStatesSize, m_slicePatchListSize));
69 secondLevelBBSize = (m_sliceStatesSize * numMacroblocks) + m_hwInterface->m_sizeOfCmdBatchBufferEnd;
70 }
71 else
72 {
73 subPacket = m_mpeg2Pipeline->GetSubPacket(DecodePacketId(m_mpeg2Pipeline, mpeg2MbSubPacketId));
74 m_mbPkt = dynamic_cast<Mpeg2DecodeMbPkt*>(subPacket);
75 DECODE_CHK_NULL(m_mbPkt);
76 DECODE_CHK_STATUS(m_mbPkt->CalculateCommandSize(m_mbStatesSize, m_mbPatchListSize));
77 secondLevelBBSize = (m_mbStatesSize * numMacroblocks) + m_hwInterface->m_sizeOfCmdBatchBufferEnd;
78 }
79
80 m_secondLevelBBArray = m_allocator->AllocateBatchBufferArray(
81 secondLevelBBSize, 1, CODEC_MPEG2_BATCH_BUFFERS_NUM, true, lockableVideoMem);
82 DECODE_CHK_NULL(m_secondLevelBBArray);
83
84 return MOS_STATUS_SUCCESS;
85 }
86
87 MOS_STATUS Mpeg2DecodePkt::Prepare()
88 {
89 DECODE_FUNC_CALL();
90
91 DECODE_CHK_NULL(m_mpeg2BasicFeature->m_mpeg2PicParams);
92 m_mpeg2PicParams = m_mpeg2BasicFeature->m_mpeg2PicParams;
93
94 return MOS_STATUS_SUCCESS;
95 }
96
97 MOS_STATUS Mpeg2DecodePkt::Destroy()
98 {
99 m_statusReport->UnregistObserver(this);
100 if (m_allocator != nullptr)
101 {
102 DECODE_CHK_STATUS(m_allocator->Destroy(m_secondLevelBBArray));
103 }
104
105 return MOS_STATUS_SUCCESS;
106 }
107
108 void Mpeg2DecodePkt::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 Mpeg2DecodePkt::IsPrologRequired()
119 {
120 return true;
121 }
122
123 MOS_STATUS Mpeg2DecodePkt::AddForceWakeup(MOS_COMMAND_BUFFER& cmdBuffer)
124 {
125 DECODE_FUNC_CALL();
126 // NativeFence sync BB may cause preemption and ring idle, so force wakeup after it
127 DECODE_CHK_STATUS(AddNativeFenceSyncBBStartCmd(cmdBuffer));
128
129 auto &par = m_miItf->GETPAR_MI_FORCE_WAKEUP();
130 par = {};
131 par.bMFXPowerWellControl = true;
132 par.bMFXPowerWellControlMask = true;
133 par.bHEVCPowerWellControl = false;
134 par.bHEVCPowerWellControlMask = true;
135
136 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_FORCE_WAKEUP(&cmdBuffer));
137
138 return MOS_STATUS_SUCCESS;
139 }
140
141 MOS_STATUS Mpeg2DecodePkt::SendPrologWithFrameTracking(MOS_COMMAND_BUFFER& cmdBuffer, bool frameTrackingRequested)
142 {
143 DECODE_FUNC_CALL();
144
145 DecodeSubPacket* subPacket = m_mpeg2Pipeline->GetSubPacket(DecodePacketId(m_mpeg2Pipeline, markerSubPacketId));
146 DecodeMarkerPkt *makerPacket = dynamic_cast<DecodeMarkerPkt*>(subPacket);
147 DECODE_CHK_NULL(makerPacket);
148 DECODE_CHK_STATUS(makerPacket->Execute(cmdBuffer));
149
150 m_mmcState = m_mpeg2Pipeline->GetMmcState();
151 bool isMmcEnabled = (m_mmcState != nullptr && m_mmcState->IsMmcEnabled());
152 if (isMmcEnabled)
153 {
154 DECODE_CHK_STATUS(m_mmcState->SendPrologCmd(&cmdBuffer, false));
155 }
156
157 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
158 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
159 genericPrologParams.pOsInterface = m_osInterface;
160 genericPrologParams.pvMiInterface = nullptr;
161
162 genericPrologParams.bMmcEnabled = isMmcEnabled;
163
164 DECODE_CHK_STATUS(Mhw_SendGenericPrologCmdNext(&cmdBuffer, &genericPrologParams, m_miItf));
165
166 subPacket = m_mpeg2Pipeline->GetSubPacket(DecodePacketId(m_mpeg2Pipeline, predicationSubPacketId));
167 DecodePredicationPkt *predicationPacket = dynamic_cast<DecodePredicationPkt*>(subPacket);
168 DECODE_CHK_NULL(predicationPacket);
169 DECODE_CHK_STATUS(predicationPacket->Execute(cmdBuffer));
170
171 return MOS_STATUS_SUCCESS;
172 }
173
174 MOS_STATUS Mpeg2DecodePkt::MiFlush(MOS_COMMAND_BUFFER & cmdBuffer)
175 {
176 DECODE_FUNC_CALL();
177
178 auto &par = m_miItf->GETPAR_MI_FLUSH_DW();
179 par = {};
180 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_FLUSH_DW(&cmdBuffer));
181
182 return MOS_STATUS_SUCCESS;
183 }
184
185 MOS_STATUS Mpeg2DecodePkt::Completed(void *mfxStatus, void *rcsStatus, void *statusReport)
186 {
187 DECODE_FUNC_CALL();
188
189 DecodeStatusMfx *decodeStatusMfx = (DecodeStatusMfx *)mfxStatus;
190 DecodeStatusReportData *statusReportData = (DecodeStatusReportData *)statusReport;
191 auto mfxItf = std::static_pointer_cast<mhw::vdbox::mfx::Itf>(m_hwInterface->GetMfxInterfaceNext());
192
193 if (mfxItf && decodeStatusMfx && statusReportData)
194 {
195 if ((decodeStatusMfx->m_mmioErrorStatusReg & mfxItf->GetMfxErrorFlagsMask()) != 0)
196 {
197 statusReportData->codecStatus = CODECHAL_STATUS_ERROR;
198 statusReportData->numMbsAffected = decodeStatusMfx->m_mmioMBCountReg & 0xFFFF;
199 }
200 DECODE_VERBOSEMESSAGE("Current Frame Index = %d", statusReportData->currDecodedPic.FrameIdx);
201 }
202
203 return MOS_STATUS_SUCCESS;
204 }
205
206 MOS_STATUS Mpeg2DecodePkt::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize)
207 {
208 commandBufferSize = CalculateCommandBufferSize();
209 requestedPatchListSize = CalculatePatchListSize();
210
211 return MOS_STATUS_SUCCESS;
212 }
213
214 uint32_t Mpeg2DecodePkt::CalculateCommandBufferSize()
215 {
216 // slice/macroblock level commands are put into 2nd level BB.
217 return (m_pictureStatesSize + COMMAND_BUFFER_RESERVED_SPACE);
218 }
219
220 uint32_t Mpeg2DecodePkt::CalculatePatchListSize()
221 {
222 if (!m_osInterface->bUsesPatchList)
223 {
224 return 0;
225 }
226
227 return m_picturePatchListSize;
228 }
229
230 MOS_STATUS Mpeg2DecodePkt::ReadMfxStatus(MediaStatusReport* statusReport, MOS_COMMAND_BUFFER& cmdBuffer)
231 {
232 DECODE_FUNC_CALL();
233
234 DECODE_CHK_NULL(statusReport);
235
236 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
237 MOS_RESOURCE* osResource = nullptr;
238 uint32_t offset = 0;
239
240 auto &par = m_miItf->GETPAR_MI_STORE_REGISTER_MEM();
241 par = {};
242
243 DECODE_CHK_NULL(m_hwInterface->GetVdencInterfaceNext());
244 auto mmioRegisters = m_hwInterface->GetVdencInterfaceNext()->GetMmioRegisters(MHW_VDBOX_NODE_1);
245
246 DECODE_CHK_STATUS(statusReport->GetAddress(decode::DecodeStatusReportType::DecErrorStatusOffset, osResource, offset));
247 par.presStoreBuffer = osResource;
248 par.dwOffset = offset;
249 par.dwRegister = mmioRegisters->mfxErrorFlagsRegOffset;
250
251 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_STORE_REGISTER_MEM(&cmdBuffer));
252
253 DECODE_CHK_STATUS(statusReport->GetAddress(decode::DecodeStatusReportType::DecMBCountOffset, osResource, offset));
254 par.presStoreBuffer = osResource;
255 par.dwOffset = offset;
256 par.dwRegister = mmioRegisters->mfxMBCountRegOffset;
257
258 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_STORE_REGISTER_MEM(&cmdBuffer));
259
260 return MOS_STATUS_SUCCESS;
261 }
262
263 MOS_STATUS Mpeg2DecodePkt::StartStatusReport(uint32_t srType, MOS_COMMAND_BUFFER* cmdBuffer)
264 {
265 DECODE_FUNC_CALL();
266
267 DECODE_CHK_STATUS(MediaPacket::StartStatusReportNext(srType, cmdBuffer));
268
269 SetPerfTag(m_mpeg2BasicFeature->m_mode, m_mpeg2BasicFeature->m_pictureCodingType);
270
271 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
272 DECODE_CHK_NULL(perfProfiler);
273 DECODE_CHK_STATUS(perfProfiler->AddPerfCollectStartCmd(
274 (void*)m_mpeg2Pipeline, m_osInterface, m_miItf, cmdBuffer));
275 #if (_DEBUG || _RELEASE_INTERNAL)
276 if (m_statusReport && m_statusReport->IsVdboxIdReportEnabled())
277 {
278 StoreEngineId(cmdBuffer, decode::DecodeStatusReportType::CsEngineIdOffset_0);
279 }
280 #endif
281 return MOS_STATUS_SUCCESS;
282 }
283
284 MOS_STATUS Mpeg2DecodePkt::EndStatusReport(uint32_t srType, MOS_COMMAND_BUFFER* cmdBuffer)
285 {
286 DECODE_FUNC_CALL();
287
288 DECODE_CHK_NULL(cmdBuffer);
289 DECODE_CHK_STATUS(ReadMfxStatus(m_statusReport, *cmdBuffer));
290 DECODE_CHK_STATUS(MediaPacket::EndStatusReportNext(srType, cmdBuffer));
291
292 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
293 DECODE_CHK_NULL(perfProfiler);
294 DECODE_CHK_STATUS(perfProfiler->AddPerfCollectEndCmd(
295 (void*)m_mpeg2Pipeline, m_osInterface, m_miItf, cmdBuffer));
296
297 DECODE_CHK_STATUS(MiFlush(*cmdBuffer));
298
299 return MOS_STATUS_SUCCESS;
300 }
301
302 }