1 /*
2 * Copyright (c) 2020, 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_front_end_m12.cpp
24 //! \brief Defines the interface for hevc front end decode packet of M12
25 //!
26 #include "decode_hevc_packet_front_end_m12.h"
27 #include "decode_utils.h"
28 #include "decode_hevc_pipeline.h"
29 #include "decode_hevc_basic_feature.h"
30 #include "decode_status_report_defs.h"
31 #include "mos_solo_generic.h"
32 #include "decode_status_report_defs.h"
33 #include "decode_resource_auto_lock.h"
34 #include "hal_oca_interface.h"
35 #include "mhw_vdbox_vdenc_g12_X.h"
36
37 namespace decode
38 {
39
Submit(MOS_COMMAND_BUFFER * cmdBuffer,uint8_t packetPhase)40 MOS_STATUS HevcDecodeFrontEndPktM12::Submit(
41 MOS_COMMAND_BUFFER* cmdBuffer,
42 uint8_t packetPhase)
43 {
44 DECODE_FUNC_CALL();
45
46 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
47
48 DECODE_CHK_NULL(cmdBuffer);
49 DECODE_CHK_NULL(m_hwInterface);
50
51 DECODE_CHK_STATUS(m_picturePkt->SetPhase(m_phase));
52
53 DECODE_CHK_STATUS(Mos_Solo_PreProcessDecode(m_osInterface, &m_hevcBasicFeature->m_destSurface));
54
55 DECODE_CHK_STATUS(m_miInterface->SetWatchdogTimerThreshold(m_hevcBasicFeature->m_width, m_hevcBasicFeature->m_height, false));
56
57 if (IsPrologRequired())
58 {
59 DECODE_CHK_STATUS(AddForceWakeup(*cmdBuffer));
60 DECODE_CHK_STATUS(SendPrologWithFrameTracking(*cmdBuffer, true));
61 }
62
63 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(MHW_VDBOX_NODE_1);
64 HalOcaInterface::On1stLevelBBStart(*cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
65
66 if (m_hevcPipeline->IsShortFormat())
67 {
68 MOS_RESOURCE* osResource = nullptr;
69 uint32_t offset = 0;
70
71 DECODE_CHK_STATUS(m_statusReport->GetAddress(decode::DecodeStatusReportType::HucErrorStatusMask, osResource, offset));
72
73 // Check HuC_STATUS bit15, HW continue if bit15 > 0, otherwise send COND BB END cmd.
74 uint32_t compareOperation = mhw_mi_g12_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::COMPARE_OPERATION_MADGREATERTHANIDD;
75 DECODE_CHK_STATUS(m_hwInterface->SendCondBbEndCmd(
76 osResource, offset, 0, false, false, compareOperation, cmdBuffer));
77 }
78
79 DECODE_CHK_STATUS(PackPictureLevelCmds(*cmdBuffer));
80
81 if (!m_hevcPipeline->IsShortFormat())
82 {
83 DECODE_CHK_STATUS(PackSliceLevelCmds(*cmdBuffer));
84 }
85
86 HalOcaInterface::On1stLevelBBEnd(*cmdBuffer, *m_osInterface);
87
88 DECODE_CHK_STATUS(m_allocator->SyncOnResource(&m_hevcBasicFeature->m_resDataBuffer, false));
89
90 DECODE_CHK_STATUS(Mos_Solo_PostProcessDecode(m_osInterface, &m_hevcBasicFeature->m_destSurface));
91
92 #if USE_CODECHAL_DEBUG_TOOL
93 if (m_phase->GetCmdBufIndex() == DecodePhase::m_secondaryCmdBufIdxBase)
94 {
95 DECODE_CHK_STATUS(DumpSecondaryCommandBuffer(*cmdBuffer));
96 }
97 #endif
98
99 return MOS_STATUS_SUCCESS;
100 }
101
VdMemoryFlush(MOS_COMMAND_BUFFER & cmdBuffer)102 MOS_STATUS HevcDecodeFrontEndPktM12::VdMemoryFlush(MOS_COMMAND_BUFFER &cmdBuffer)
103 {
104 MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
105 MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
106 vdCtrlParam.memoryImplicitFlush = true;
107
108 MhwMiInterfaceG12* miInterfaceG12 = dynamic_cast<MhwMiInterfaceG12*>(m_miInterface);
109 DECODE_CHK_NULL(miInterfaceG12);
110 DECODE_CHK_STATUS(miInterfaceG12->AddMiVdControlStateCmd(&cmdBuffer, &vdCtrlParam));
111
112 return MOS_STATUS_SUCCESS;
113 }
114
VdPipelineFlush(MOS_COMMAND_BUFFER & cmdBuffer)115 MOS_STATUS HevcDecodeFrontEndPktM12::VdPipelineFlush(MOS_COMMAND_BUFFER & cmdBuffer)
116 {
117 DECODE_FUNC_CALL();
118
119 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS_G12 vdpipeFlushParams;
120 MOS_ZeroMemory(&vdpipeFlushParams, sizeof(vdpipeFlushParams));
121 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
122 vdpipeFlushParams.Flags.bFlushHEVC = 1;
123 vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
124 DECODE_CHK_STATUS(m_vdencInterface->AddVdPipelineFlushCmd(
125 &cmdBuffer, (MHW_VDBOX_VD_PIPE_FLUSH_PARAMS*)&vdpipeFlushParams));
126
127 return MOS_STATUS_SUCCESS;
128 }
129
PackPictureLevelCmds(MOS_COMMAND_BUFFER & cmdBuffer)130 MOS_STATUS HevcDecodeFrontEndPktM12::PackPictureLevelCmds(MOS_COMMAND_BUFFER &cmdBuffer)
131 {
132 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
133
134 DECODE_CHK_STATUS(StartStatusReport(statusReportMfx, &cmdBuffer));
135
136 DECODE_CHK_STATUS(m_picturePkt->Execute(cmdBuffer));
137
138 PMHW_BATCH_BUFFER batchBuffer = m_hevcPipeline->GetSliceLvlCmdBuffer();
139 DECODE_CHK_NULL(batchBuffer);
140 batchBuffer->dwOffset = 0;
141 DECODE_CHK_STATUS(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, batchBuffer));
142
143 DECODE_CHK_STATUS(VdMemoryFlush(cmdBuffer));
144 DECODE_CHK_STATUS(ReadVdboxId(cmdBuffer));
145 DECODE_CHK_STATUS(VdPipelineFlush(cmdBuffer));
146 DECODE_CHK_STATUS(MiFlush(cmdBuffer));
147
148 DECODE_CHK_STATUS(m_picturePkt->ReportCabacStreamOutSize(cmdBuffer));
149 DECODE_CHK_STATUS(MiFlush(cmdBuffer));
150
151 DECODE_CHK_STATUS(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
152
153 return MOS_STATUS_SUCCESS;
154 }
155
PackSliceLevelCmds(MOS_COMMAND_BUFFER & cmdBuffer)156 MOS_STATUS HevcDecodeFrontEndPktM12::PackSliceLevelCmds(MOS_COMMAND_BUFFER &cmdBuffer)
157 {
158 PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
159
160 PMHW_BATCH_BUFFER batchBuffer = m_hevcPipeline->GetSliceLvlCmdBuffer();
161 DECODE_CHK_NULL(batchBuffer);
162
163 ResourceAutoLock resLock(m_allocator, &batchBuffer->OsResource);
164 uint32_t *batchBufBase = (uint32_t *)resLock.LockResourceForWrite();
165 DECODE_CHK_NULL(batchBufBase);
166
167 MOS_COMMAND_BUFFER sliceLevelCmdBuffer;
168 MOS_ZeroMemory(&sliceLevelCmdBuffer, sizeof(MOS_COMMAND_BUFFER));
169 sliceLevelCmdBuffer.pCmdBase = batchBufBase;
170 sliceLevelCmdBuffer.pCmdPtr = sliceLevelCmdBuffer.pCmdBase;
171 sliceLevelCmdBuffer.iRemaining = batchBuffer->iSize;
172
173 for (uint32_t i = 0; i < m_hevcBasicFeature->m_numSlices; i++)
174 {
175 DECODE_CHK_STATUS(m_slicePkt->Execute(sliceLevelCmdBuffer, i, 0));
176 }
177
178 DECODE_CHK_STATUS(m_miInterface->AddMiBatchBufferEnd(&sliceLevelCmdBuffer, nullptr));
179 return MOS_STATUS_SUCCESS;
180 }
181
182 }
183
184