1 /*
2 * Copyright (c) 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_vp9_picture_packet_g12.cpp
24 //! \brief    Defines the interface for vp9 decode picture packet
25 //!
26 #include "codechal_utilities.h"
27 #include "decode_vp9_picture_packet_xe_m_base.h"
28 #include "decode_vp9_picture_packet_m12.h"
29 #include "decode_vp9_mem_compression_m12.h"
30 #include "mhw_mi_g12_X.h"
31 #include "mhw_vdbox_g12_X.h"
32 #include "mhw_vdbox_hcp_g12_X.h"
33 #include "decode_common_feature_defs.h"
34 
35 namespace decode
36 {
Init()37     MOS_STATUS Vp9DecodePicPktM12::Init()
38     {
39         DECODE_FUNC_CALL();
40         DECODE_CHK_STATUS(Vp9DecodePicPktXe_M_Base::Init());
41         DECODE_CHK_STATUS(CalculatePictureStateCommandSize());
42         return MOS_STATUS_SUCCESS;
43     }
44 
Execute(MOS_COMMAND_BUFFER & cmdBuffer)45     MOS_STATUS Vp9DecodePicPktM12::Execute(MOS_COMMAND_BUFFER& cmdBuffer)
46     {
47         // Send VD_CONTROL_STATE Pipe Initialization
48         DECODE_CHK_STATUS(VdInit(cmdBuffer));
49 
50         DECODE_CHK_STATUS(AddHcpPipeModeSelectCmd(cmdBuffer));
51         if (IsBackEndPhase())
52         {
53             VdScalabPipeLock(cmdBuffer);
54         }
55 
56 #ifdef _DECODE_PROCESSING_SUPPORTED
57         if (m_downSamplingFeature != nullptr && m_downSamplingPkt != nullptr &&
58             m_downSamplingFeature->IsEnabled())
59         {
60             if (!IsFrontEndPhase())
61             {
62                 DECODE_CHK_STATUS(m_downSamplingPkt->Execute(cmdBuffer));
63             }
64         }
65 #endif
66 
67         DECODE_CHK_STATUS(AddHcpSurfacesCmd(cmdBuffer));
68         DECODE_CHK_STATUS(AddHcpPipeBufAddrCmd(cmdBuffer));
69 
70         DECODE_CHK_STATUS(AddHcpIndObjBaseAddrCmd(cmdBuffer));
71 
72         DECODE_CHK_STATUS(AddHcpSegmentStateCmd(cmdBuffer));
73         DECODE_CHK_STATUS(AddHcpPicStateCmd(cmdBuffer));
74 
75         return MOS_STATUS_SUCCESS;
76     }
77 
VdInit(MOS_COMMAND_BUFFER & cmdBuffer)78     MOS_STATUS Vp9DecodePicPktM12::VdInit(MOS_COMMAND_BUFFER &cmdBuffer)
79     {
80         MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
81         MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
82         vdCtrlParam.initialization = true;
83 
84         MhwMiInterfaceG12 *miInterfaceG12 = dynamic_cast<MhwMiInterfaceG12 *>(m_miInterface);
85         DECODE_CHK_NULL(miInterfaceG12);
86         DECODE_CHK_STATUS(miInterfaceG12->AddMiVdControlStateCmd(&cmdBuffer, &vdCtrlParam));
87 
88         return MOS_STATUS_SUCCESS;
89     }
90 
VdScalabPipeLock(MOS_COMMAND_BUFFER & cmdBuffer)91     MOS_STATUS Vp9DecodePicPktM12::VdScalabPipeLock(MOS_COMMAND_BUFFER &cmdBuffer)
92     {
93         MHW_MI_VD_CONTROL_STATE_PARAMS vdCtrlParam;
94         MOS_ZeroMemory(&vdCtrlParam, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
95         vdCtrlParam.scalableModePipeLock = true;
96 
97         MhwMiInterfaceG12* miInterfaceG12 = dynamic_cast<MhwMiInterfaceG12*>(m_miInterface);
98         DECODE_CHK_NULL(miInterfaceG12);
99         DECODE_CHK_STATUS(miInterfaceG12->AddMiVdControlStateCmd(&cmdBuffer, &vdCtrlParam));
100 
101         return MOS_STATUS_SUCCESS;
102     }
103 
SetHcpPipeModeSelectParams(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS & pipeModeSelectParamsBase)104     void Vp9DecodePicPktM12::SetHcpPipeModeSelectParams(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS &pipeModeSelectParamsBase)
105     {
106         DECODE_FUNC_CALL();
107         Vp9DecodePicPktXe_M_Base::SetHcpPipeModeSelectParams(pipeModeSelectParamsBase);
108 
109         MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12 &pipeModeSelectParams =
110             static_cast<MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12&>(pipeModeSelectParamsBase);
111 
112         uint32_t pipeWorkMode    = MHW_VDBOX_HCP_PIPE_WORK_MODE_LEGACY;
113         uint32_t multiEngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY;
114         if (m_phase != nullptr)
115         {
116             m_phase->GetMode(pipeWorkMode, multiEngineMode);
117         }
118         pipeModeSelectParams.PipeWorkMode    = static_cast<MHW_VDBOX_HCP_PIPE_WORK_MODE>(pipeWorkMode);
119         pipeModeSelectParams.MultiEngineMode = static_cast<MHW_VDBOX_HCP_MULTI_ENGINE_MODE>(multiEngineMode);
120     }
121 
AddHcpPipeModeSelectCmd(MOS_COMMAND_BUFFER & cmdBuffer)122     MOS_STATUS Vp9DecodePicPktM12::AddHcpPipeModeSelectCmd(MOS_COMMAND_BUFFER &cmdBuffer)
123     {
124         DECODE_FUNC_CALL();
125 
126         MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12 pipeModeSelectParams;
127         pipeModeSelectParams ={};
128         SetHcpPipeModeSelectParams(pipeModeSelectParams);
129         DECODE_CHK_STATUS(m_hcpInterface->AddHcpPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
130 
131         return MOS_STATUS_SUCCESS;
132     }
133 
SetHcpPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS & pipeBufAddrParamsBase)134     MOS_STATUS Vp9DecodePicPktM12::SetHcpPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS &pipeBufAddrParamsBase)
135     {
136         DECODE_FUNC_CALL();
137         DECODE_CHK_STATUS(Vp9DecodePicPktXe_M_Base::SetHcpPipeBufAddrParams(pipeBufAddrParamsBase));
138 
139 #ifdef _MMC_SUPPORTED
140         Vp9DecodeMemCompM12 *vp9DecodeMemComp = dynamic_cast<Vp9DecodeMemCompM12 *>(m_mmcState);
141         DECODE_CHK_NULL(vp9DecodeMemComp);
142         DECODE_CHK_STATUS(vp9DecodeMemComp->CheckReferenceList(*m_vp9BasicFeature, pipeBufAddrParamsBase));
143 #endif
144 
145         MHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12 &pipeBufAddrParams =
146             static_cast<MHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12&>(pipeBufAddrParamsBase);
147 
148         if (m_vp9Pipeline->GetDecodeMode() == Vp9Pipeline::virtualTileDecodeMode)
149         {
150             pipeBufAddrParams.presCABACSyntaxStreamOutBuffer = &(m_resCABACSyntaxStreamOutBuffer->OsResource);
151             pipeBufAddrParams.presIntraPredUpRightColStoreBuffer = &(m_resIntraPredUpRightColStoreBuffer->OsResource);
152             pipeBufAddrParams.presIntraPredLeftReconColStoreBuffer = &(m_resIntraPredLeftReconColStoreBuffer->OsResource);
153         }
154         return MOS_STATUS_SUCCESS;
155     }
156 
AddHcpPipeBufAddrCmd(MOS_COMMAND_BUFFER & cmdBuffer)157     MOS_STATUS Vp9DecodePicPktM12::AddHcpPipeBufAddrCmd(MOS_COMMAND_BUFFER &cmdBuffer)
158     {
159         DECODE_FUNC_CALL();
160         MHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12 pipeBufAddrParams;
161         SetHcpPipeBufAddrParams(pipeBufAddrParams);
162 
163         DECODE_CHK_STATUS(m_hcpInterface->AddHcpPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams));
164         return MOS_STATUS_SUCCESS;
165     }
166 
SetHcpPicStateParams(MHW_VDBOX_VP9_PIC_STATE & picStateParams)167     MOS_STATUS Vp9DecodePicPktM12::SetHcpPicStateParams(MHW_VDBOX_VP9_PIC_STATE &picStateParams)
168     {
169         DECODE_FUNC_CALL();
170 
171         DECODE_CHK_STATUS(Vp9DecodePicPktXe_M_Base::SetHcpPicStateParams(picStateParams));
172 
173         return MOS_STATUS_SUCCESS;
174     }
175 
AddHcpPicStateCmd(MOS_COMMAND_BUFFER & cmdBuffer)176     MOS_STATUS Vp9DecodePicPktM12::AddHcpPicStateCmd(MOS_COMMAND_BUFFER &cmdBuffer)
177     {
178         DECODE_FUNC_CALL();
179 
180         MHW_VDBOX_VP9_PIC_STATE picStateParams;
181         DECODE_CHK_STATUS(SetHcpPicStateParams(picStateParams));
182         DECODE_CHK_STATUS(m_hcpInterface->AddHcpVp9PicStateCmd(&cmdBuffer, nullptr, &picStateParams));
183 
184         return MOS_STATUS_SUCCESS;
185     }
186 
AddHcpSegmentStateCmd(MOS_COMMAND_BUFFER & cmdBuffer)187     MOS_STATUS Vp9DecodePicPktM12::AddHcpSegmentStateCmd(MOS_COMMAND_BUFFER &cmdBuffer)
188     {
189         DECODE_FUNC_CALL();
190         DECODE_CHK_STATUS(Vp9DecodePicPktXe_M_Base::AddHcpSegmentStateCmd(cmdBuffer));
191 
192         return MOS_STATUS_SUCCESS;
193     }
194 
CalculatePictureStateCommandSize()195     MOS_STATUS Vp9DecodePicPktM12::CalculatePictureStateCommandSize()
196     {
197         MHW_VDBOX_STATE_CMDSIZE_PARAMS_G12 stateCmdSizeParams;
198 
199         stateCmdSizeParams.bHucDummyStream = false;
200 #ifdef _DECODE_PROCESSING_SUPPORTED
201         DecodeDownSamplingFeature *decodeDownSampling =
202             dynamic_cast<DecodeDownSamplingFeature *>(m_featureManager->GetFeature(DecodeFeatureIDs::decodeDownSampling));
203         stateCmdSizeParams.bSfcInUse = (decodeDownSampling != nullptr);
204 #endif
205         stateCmdSizeParams.bScalableMode = (m_vp9Pipeline->GetDecodeMode() == Vp9Pipeline::virtualTileDecodeMode);
206 
207         // Picture Level Commands
208         DECODE_CHK_STATUS(static_cast<CodechalHwInterfaceG12*>(m_hwInterface)->GetHcpStateCommandSize(
209                 m_vp9BasicFeature->m_mode,
210                 &m_pictureStatesSize,
211                 &m_picturePatchListSize,
212                 &stateCmdSizeParams));
213 
214         return MOS_STATUS_SUCCESS;
215     }
216 
ValidateCabacStreamOutSize(MOS_COMMAND_BUFFER & cmdBuffer)217     MOS_STATUS Vp9DecodePicPktM12::ValidateCabacStreamOutSize(MOS_COMMAND_BUFFER &cmdBuffer)
218     {
219         DECODE_CHK_NULL(m_resCABACStreamOutSizeBuffer);
220         DECODE_CHK_NULL(m_resCABACSyntaxStreamOutBuffer);
221 
222         CodechalHwInterfaceG12* hwInterface = dynamic_cast<CodechalHwInterfaceG12*>(m_hwInterface);
223         DECODE_CHK_NULL(hwInterface);
224 
225         uint32_t compareOperation = mhw_mi_g12_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::COMPARE_OPERATION_MADLESSTHANIDD;
226         DECODE_CHK_STATUS(hwInterface->SendCondBbEndCmd(
227             &m_resCABACStreamOutSizeBuffer->OsResource,
228             0,
229             m_resCABACSyntaxStreamOutBuffer->size,
230             true,
231             true,
232             compareOperation,
233             &cmdBuffer));
234 
235         return MOS_STATUS_SUCCESS;
236     }
237 
238 }
239