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