1 /*
2 * Copyright (c) 2019-2021, 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_hevc_packet_xe_m_base.cpp
24 //! \brief Defines the interface for hevc decode packet
25 //!
26 #include "codechal_utilities.h"
27 #include "decode_hevc_packet_xe_m_base.h"
28 #include "decode_status_report_defs.h"
29 #include "decode_predication_packet.h"
30 #include "decode_marker_packet.h"
31
32 namespace decode {
33
Init()34 MOS_STATUS HevcDecodePktXe_M_Base::Init()
35 {
36 DECODE_FUNC_CALL();
37 DECODE_CHK_NULL(m_miInterface);
38 DECODE_CHK_NULL(m_statusReport);
39 DECODE_CHK_NULL(m_featureManager);
40 DECODE_CHK_NULL(m_hevcPipeline);
41 DECODE_CHK_NULL(m_osInterface);
42 DECODE_CHK_NULL(m_vdencInterface);
43
44 DECODE_CHK_STATUS(CmdPacket::Init());
45
46 m_hevcBasicFeature = dynamic_cast<HevcBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
47 DECODE_CHK_NULL(m_hevcBasicFeature);
48
49 m_allocator = m_hevcPipeline->GetDecodeAllocator();
50 DECODE_CHK_NULL(m_allocator);
51
52 return MOS_STATUS_SUCCESS;
53 }
54
Prepare()55 MOS_STATUS HevcDecodePktXe_M_Base::Prepare()
56 {
57 DECODE_FUNC_CALL();
58
59 m_phase = static_cast<DecodePhase *>(m_hevcPipeline->GetComponentState());
60 DECODE_CHK_NULL(m_phase);
61
62 DECODE_CHK_NULL(m_hevcBasicFeature);
63 DECODE_CHK_NULL(m_hevcBasicFeature->m_hevcPicParams);
64 m_hevcPicParams = m_hevcBasicFeature->m_hevcPicParams;
65
66 return MOS_STATUS_SUCCESS;
67 }
68
SetPerfTag(CODECHAL_MODE mode,uint16_t picCodingType)69 void HevcDecodePktXe_M_Base::SetPerfTag(CODECHAL_MODE mode, uint16_t picCodingType)
70 {
71 DECODE_FUNC_CALL();
72
73 uint16_t perfTag = ((mode << 4) & 0xF0) | (picCodingType & 0xF);
74 m_osInterface->pfnIncPerfFrameID(m_osInterface);
75 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag);
76 m_osInterface->pfnResetPerfBufferID(m_osInterface);
77 }
78
AddForceWakeup(MOS_COMMAND_BUFFER & cmdBuffer)79 MOS_STATUS HevcDecodePktXe_M_Base::AddForceWakeup(MOS_COMMAND_BUFFER& cmdBuffer)
80 {
81 DECODE_FUNC_CALL();
82
83 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
84 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
85 forceWakeupParams.bMFXPowerWellControl = false;
86 forceWakeupParams.bMFXPowerWellControlMask = true;
87 forceWakeupParams.bHEVCPowerWellControl = true;
88 forceWakeupParams.bHEVCPowerWellControlMask = true;
89
90 DECODE_CHK_STATUS(m_miInterface->AddMiForceWakeupCmd(&cmdBuffer, &forceWakeupParams));
91
92 return MOS_STATUS_SUCCESS;
93 }
94
SendPrologWithFrameTracking(MOS_COMMAND_BUFFER & cmdBuffer,bool frameTrackingRequested)95 MOS_STATUS HevcDecodePktXe_M_Base::SendPrologWithFrameTracking(MOS_COMMAND_BUFFER& cmdBuffer, bool frameTrackingRequested)
96 {
97 DecodeSubPacket* subPacket = m_hevcPipeline->GetSubPacket(DecodePacketId(m_hevcPipeline, markerSubPacketId));
98 DecodeMarkerPkt *makerPacket = dynamic_cast<DecodeMarkerPkt*>(subPacket);
99 DECODE_CHK_NULL(makerPacket);
100 DECODE_CHK_STATUS(makerPacket->Execute(cmdBuffer));
101
102 #ifdef _MMC_SUPPORTED
103 DecodeMemComp *mmcState = m_hevcPipeline->GetMmcState();
104 bool isMmcEnabled = (mmcState != nullptr && mmcState->IsMmcEnabled());
105 if (isMmcEnabled)
106 {
107 DECODE_CHK_STATUS(mmcState->SendPrologCmd(&cmdBuffer, false));
108 }
109 #endif
110
111 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
112 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
113 genericPrologParams.pOsInterface = m_osInterface;
114 genericPrologParams.pvMiInterface = m_miInterface;
115 #ifdef _MMC_SUPPORTED
116 genericPrologParams.bMmcEnabled = isMmcEnabled;
117 #endif
118
119 DECODE_CHK_STATUS(Mhw_SendGenericPrologCmd(&cmdBuffer, &genericPrologParams));
120
121 subPacket = m_hevcPipeline->GetSubPacket(DecodePacketId(m_hevcPipeline, predicationSubPacketId));
122 DecodePredicationPkt *predicationPacket = dynamic_cast<DecodePredicationPkt*>(subPacket);
123 DECODE_CHK_NULL(predicationPacket);
124 DECODE_CHK_STATUS(predicationPacket->Execute(cmdBuffer));
125
126 return MOS_STATUS_SUCCESS;
127 }
128
MiFlush(MOS_COMMAND_BUFFER & cmdBuffer)129 MOS_STATUS HevcDecodePktXe_M_Base::MiFlush(MOS_COMMAND_BUFFER & cmdBuffer)
130 {
131 DECODE_FUNC_CALL();
132
133 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
134 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
135 DECODE_CHK_STATUS(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
136
137 return MOS_STATUS_SUCCESS;
138 }
139
Completed(void * mfxStatus,void * rcsStatus,void * statusReport)140 MOS_STATUS HevcDecodePktXe_M_Base::Completed(void *mfxStatus, void *rcsStatus, void *statusReport)
141 {
142 DECODE_FUNC_CALL();
143
144 DECODE_CHK_NULL(mfxStatus);
145 DECODE_CHK_NULL(statusReport);
146
147 DecodeStatusMfx * decodeStatusMfx = (DecodeStatusMfx *)mfxStatus;
148 DecodeStatusReportData *statusReportData = (DecodeStatusReportData *)statusReport;
149
150 MhwVdboxHcpInterface* hcpInterface = m_hwInterface->GetHcpInterface();
151 if(hcpInterface != nullptr)
152 {
153 if((decodeStatusMfx->m_mmioErrorStatusReg & hcpInterface->GetHcpCabacErrorFlagsMask()) != 0)
154 {
155 statusReportData->codecStatus = CODECHAL_STATUS_ERROR;
156 statusReportData->numMbsAffected = (decodeStatusMfx->m_mmioMBCountReg & 0xFFFC0000) >> 18;
157 }
158
159 statusReportData->frameCrc = decodeStatusMfx->m_mmioFrameCrcReg;
160 }
161
162 DECODE_VERBOSEMESSAGE("Index = %d", statusReportData->currDecodedPic.FrameIdx);
163 DECODE_VERBOSEMESSAGE("FrameCrc = 0x%x", statusReportData->frameCrc);
164
165 return MOS_STATUS_SUCCESS;
166 }
167
ReadVdboxId(MOS_COMMAND_BUFFER & cmdBuffer)168 MOS_STATUS HevcDecodePktXe_M_Base::ReadVdboxId(MOS_COMMAND_BUFFER &cmdBuffer)
169 {
170 DECODE_FUNC_CALL();
171 DECODE_CHK_NULL(m_phase);
172 DECODE_CHK_NULL(m_statusReport);
173
174 uint8_t curPipe = m_phase->GetPipe();
175 DECODE_CHK_COND(curPipe >= csInstanceIdMax, "Invalid pipe index.");
176 uint32_t csEngineIdOffsetIdx = decode::DecodeStatusReportType::CsEngineIdOffset_0 + curPipe;
177
178 MHW_MI_STORE_REGISTER_MEM_PARAMS params;
179 MOS_ZeroMemory(¶ms, sizeof(MHW_MI_STORE_REGISTER_MEM_PARAMS));
180
181 auto mmioRegistersHcp = m_hwInterface->GetHcpInterface()->GetMmioRegisters(MHW_VDBOX_NODE_1);
182
183 MOS_RESOURCE* osResource = nullptr;
184 uint32_t offset = 0;
185 DECODE_CHK_STATUS(m_statusReport->GetAddress(csEngineIdOffsetIdx, osResource, offset));
186 params.presStoreBuffer = osResource;
187 params.dwOffset = offset;
188 params.dwRegister = mmioRegistersHcp->csEngineIdOffset;
189
190 DECODE_CHK_STATUS(m_miInterface->AddMiStoreRegisterMemCmd(
191 &cmdBuffer,
192 ¶ms));
193
194 return MOS_STATUS_SUCCESS;
195 }
196
ReadHcpStatus(MediaStatusReport * statusReport,MOS_COMMAND_BUFFER & cmdBuffer)197 MOS_STATUS HevcDecodePktXe_M_Base::ReadHcpStatus(MediaStatusReport* statusReport, MOS_COMMAND_BUFFER& cmdBuffer)
198 {
199 DECODE_FUNC_CALL();
200
201 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
202
203 DECODE_CHK_NULL(statusReport);
204
205 MOS_RESOURCE* osResource = nullptr;
206 uint32_t offset = 0;
207
208 MHW_MI_STORE_REGISTER_MEM_PARAMS params;
209 MOS_ZeroMemory(¶ms, sizeof(MHW_MI_STORE_REGISTER_MEM_PARAMS));
210
211 auto mmioRegistersHcp = m_hwInterface->GetHcpInterface()->GetMmioRegisters(MHW_VDBOX_NODE_1);
212
213 DECODE_CHK_STATUS(statusReport->GetAddress(decode::DecodeStatusReportType::DecErrorStatusOffset, osResource, offset));
214 params.presStoreBuffer = osResource;
215 params.dwOffset = offset;
216 params.dwRegister = mmioRegistersHcp->hcpCabacStatusRegOffset;
217
218 DECODE_CHK_STATUS(m_miInterface->AddMiStoreRegisterMemCmd(
219 &cmdBuffer,
220 ¶ms));
221
222 DECODE_CHK_STATUS(statusReport->GetAddress(decode::DecodeStatusReportType::DecFrameCrcOffset, osResource, offset));
223 params.presStoreBuffer = osResource;
224 params.dwOffset = offset;
225 params.dwRegister = mmioRegistersHcp->hcpFrameCrcRegOffset;
226
227 DECODE_CHK_STATUS(m_miInterface->AddMiStoreRegisterMemCmd(
228 &cmdBuffer,
229 ¶ms));
230
231 DECODE_CHK_STATUS(statusReport->GetAddress(decode::DecodeStatusReportType::DecMBCountOffset, osResource, offset));
232 params.presStoreBuffer = osResource;
233 params.dwOffset = offset;
234 params.dwRegister = mmioRegistersHcp->hcpDecStatusRegOffset;
235
236 DECODE_CHK_STATUS(m_miInterface->AddMiStoreRegisterMemCmd(
237 &cmdBuffer,
238 ¶ms));
239
240 return eStatus;
241 }
242
StartStatusReport(uint32_t srType,MOS_COMMAND_BUFFER * cmdBuffer)243 MOS_STATUS HevcDecodePktXe_M_Base::StartStatusReport(uint32_t srType, MOS_COMMAND_BUFFER* cmdBuffer)
244 {
245 DECODE_FUNC_CALL();
246 DECODE_CHK_NULL(cmdBuffer);
247 DECODE_CHK_STATUS(MediaPacket::StartStatusReport(srType, cmdBuffer));
248
249 MediaPerfProfiler* perfProfiler = MediaPerfProfiler::Instance();
250 DECODE_CHK_NULL(perfProfiler);
251 DECODE_CHK_STATUS(perfProfiler->AddPerfCollectStartCmd(
252 (void*)m_hevcPipeline, m_osInterface, m_miInterface, cmdBuffer));
253
254 return MOS_STATUS_SUCCESS;
255 }
256
EndStatusReport(uint32_t srType,MOS_COMMAND_BUFFER * cmdBuffer)257 MOS_STATUS HevcDecodePktXe_M_Base::EndStatusReport(uint32_t srType, MOS_COMMAND_BUFFER* cmdBuffer)
258 {
259 DECODE_FUNC_CALL();
260 DECODE_CHK_NULL(cmdBuffer);
261 DECODE_CHK_STATUS(ReadHcpStatus(m_statusReport, *cmdBuffer));
262 DECODE_CHK_STATUS(MediaPacket::EndStatusReport(srType, cmdBuffer));
263
264 SetPerfTag(CODECHAL_DECODE_MODE_HEVCVLD, m_hevcBasicFeature->m_pictureCodingType);
265
266 MediaPerfProfiler* perfProfiler = MediaPerfProfiler::Instance();
267 DECODE_CHK_NULL(perfProfiler);
268 DECODE_CHK_STATUS(perfProfiler->AddPerfCollectEndCmd(
269 (void*)m_hevcPipeline, m_osInterface, m_miInterface, cmdBuffer));
270
271 // Add Mi flush here to ensure end status tag flushed to memory earlier than completed count
272 DECODE_CHK_STATUS(MiFlush(*cmdBuffer));
273
274 return MOS_STATUS_SUCCESS;
275 }
276
277 #if USE_CODECHAL_DEBUG_TOOL
DumpSecondaryCommandBuffer(MOS_COMMAND_BUFFER & cmdBuffer)278 MOS_STATUS HevcDecodePktXe_M_Base::DumpSecondaryCommandBuffer(MOS_COMMAND_BUFFER &cmdBuffer)
279 {
280 DECODE_ASSERT(m_phase != nullptr);
281 CodechalDebugInterface *debugInterface = m_hevcPipeline->GetDebugInterface();
282 DECODE_CHK_NULL(debugInterface);
283 std::string cmdName = "DEC_secondary_" + std::to_string(m_phase->GetCmdBufIndex());
284 DECODE_CHK_STATUS(debugInterface->DumpCmdBuffer(
285 &cmdBuffer, CODECHAL_NUM_MEDIA_STATES, cmdName.c_str()));
286
287 return MOS_STATUS_SUCCESS;
288 }
289 #endif
290
291 }
292