1 /*===================== begin_copyright_notice ==================================
2 # Copyright (c) 2020-2024, Intel Corporation
3 # Permission is hereby granted, free of charge, to any person obtaining a
4 # copy of this software and associated documentation files (the "Software"),
5 # to deal in the Software without restriction, including without limitation
6 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
7 # and/or sell copies of the Software, and to permit persons to whom the
8 # Software is furnished to do so, subject to the following conditions:
9 # The above copyright notice and this permission notice shall be included
10 # in all copies or substantial portions of the Software.
11 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
14 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
15 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
16 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
17 # OTHER DEALINGS IN THE SOFTWARE.
18 ======================= end_copyright_notice ==================================*/
19 //!
20 //! \file codechal_hw_xe_hpm.cpp
21 //! \brief Implements HW interface layer for dg2 used on all OSs.
22 //! \details Implements HW interface layer for dg2 to be used on on all operating systems/DDIs, across CODECHAL components.
23 //! This module must not contain any OS dependent code.
24 //!
25
26 #include "codechal_hw_next_xe_hpm.h"
27 #include "codechal_hw_g12_X.h"
28 #include "mhw_render_g12_X.h"
29 #include "mhw_vdbox_hcp_hwcmd_xe_hpm.h" // temporary include for calculating size of various hardware commands
30 #include "mhw_vdbox_vdenc_g12_X.h"
31 #include "mhw_vdbox_hcp_g12_X.h"
32 #include "media_interfaces_xehp_sdv.h"// temporary include for getting avp interface
33 #include "media_interfaces_dg2.h"
34
~CodechalHwInterfaceNextXe_Hpm()35 CodechalHwInterfaceNextXe_Hpm::~CodechalHwInterfaceNextXe_Hpm()
36 {
37 if (m_renderHal != nullptr && m_renderHal->pfnDestroy != nullptr)
38 {
39 MOS_STATUS eStatus = m_renderHal->pfnDestroy(m_renderHal);
40 if (eStatus != MOS_STATUS_SUCCESS)
41 {
42 MHW_ASSERTMESSAGE("Failed to destroy RenderHal, eStatus:%d.\n", eStatus);
43 }
44
45 if (m_renderHalCpInterface)
46 {
47 if (m_osInterface)
48 {
49 m_osInterface->pfnDeleteMhwCpInterface(m_renderHalCpInterface);
50 m_renderHalCpInterface = nullptr;
51 }
52 else
53 {
54 MHW_ASSERTMESSAGE("Failed to destroy renderHalCpInterface.");
55 }
56 }
57 }
58
59 if (m_renderHal != nullptr)
60 {
61 MOS_FreeMemory(m_renderHal);
62 m_renderHal = nullptr;
63 }
64 if (m_renderInterface != nullptr)
65 {
66 MOS_Delete(m_renderInterface);
67 }
68 }
69
PrepareCmdSize(CODECHAL_FUNCTION codecFunction)70 void CodechalHwInterfaceNextXe_Hpm::PrepareCmdSize(CODECHAL_FUNCTION codecFunction)
71 {
72 InitCacheabilityControlSettings(codecFunction);
73
74 // Set platform dependent parameters
75 m_sizeOfCmdBatchBufferEnd = mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
76 m_sizeOfCmdMediaReset = mhw_mi_g12_X::MI_LOAD_REGISTER_IMM_CMD::byteSize * 8;
77 m_vdencBrcImgStateBufferSize = 80 + mhw_vdbox_mfx_g12_X::MFX_AVC_IMG_STATE_CMD::byteSize + 92 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
78
79 m_vdencBatchBuffer1stGroupSize = mhw::vdbox::hcp::xe_xpm_base::xe_hpm::Cmd::HCP_PIPE_MODE_SELECT_CMD::byteSize + mhw_mi_g12_X::MFX_WAIT_CMD::byteSize * 2 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
80
81 m_vdencBatchBuffer2ndGroupSize = 132 + mhw::vdbox::hcp::xe_xpm_base::xe_hpm::Cmd::HCP_PIC_STATE_CMD::byteSize + 248 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
82
83 m_vdencReadBatchBufferSize =
84 m_vdenc2ndLevelBatchBufferSize = m_vdencBatchBuffer1stGroupSize + m_vdencBatchBuffer2ndGroupSize + ENCODE_HEVC_VDENC_NUM_MAX_SLICES * (2 * mhw::vdbox::hcp::xe_xpm_base::xe_hpm::Cmd::HCP_WEIGHTOFFSET_STATE_CMD::byteSize + mhw::vdbox::hcp::xe_xpm_base::xe_hpm::Cmd::HCP_SLICE_STATE_CMD::byteSize + 3 * mhw::vdbox::hcp::xe_xpm_base::xe_hpm::Cmd::HCP_PAK_INSERT_OBJECT_CMD::byteSize + 28 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize + 4 * ENCODE_VDENC_HEVC_PADDING_DW_SIZE);
85
86 m_HucStitchCmdBatchBufferSize = 7 * 4 + 14 * 4 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
87
88 // HCP_WEIGHTOFFSET_STATE_CMD cmds is planned to be added in near future
89 m_vdencBatchBufferPerSliceConstSize = mhw::vdbox::hcp::xe_xpm_base::xe_hpm::Cmd::HCP_SLICE_STATE_CMD::byteSize + mhw::vdbox::hcp::xe_xpm_base::xe_hpm::Cmd::HCP_PAK_INSERT_OBJECT_CMD::byteSize // 1st PakInsertObject cmd is not always inserted for each slice, 2nd PakInsertObject cmd is always inserted for each slice
90 + 28 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
91 }
92
CodechalHwInterfaceNextXe_Hpm(PMOS_INTERFACE osInterface,CODECHAL_FUNCTION codecFunction,MhwInterfacesNext * mhwInterfacesNext,bool disableScalability)93 CodechalHwInterfaceNextXe_Hpm::CodechalHwInterfaceNextXe_Hpm(
94 PMOS_INTERFACE osInterface,
95 CODECHAL_FUNCTION codecFunction,
96 MhwInterfacesNext *mhwInterfacesNext,
97 bool disableScalability)
98 : CodechalHwInterfaceNext(osInterface, codecFunction, mhwInterfacesNext, disableScalability)
99 {
100 CODECHAL_HW_FUNCTION_ENTER;
101 PrepareCmdSize(codecFunction);
102 m_miInterface = static_cast<MhwInterfacesDg2_Next*>(mhwInterfacesNext)->m_miInterface;
103 m_renderInterface = static_cast<MhwInterfacesDg2_Next*>(mhwInterfacesNext)->m_renderInterface;
104 //prevent double free
105 static_cast<MhwInterfacesDg2_Next *>(mhwInterfacesNext)->m_renderInterface = nullptr;
106 }
107
UsesRenderEngine(CODECHAL_FUNCTION codecFunction,uint32_t standard)108 bool CodechalHwInterfaceNextXe_Hpm::UsesRenderEngine(CODECHAL_FUNCTION codecFunction, uint32_t standard)
109 {
110 if (codecFunction == CODECHAL_FUNCTION_ENC_VDENC_PAK && standard == CODECHAL_AV1)
111 return false;
112 else
113 return UsesRenderEngine(codecFunction, standard);
114 }
115
GetAvpStateCommandSize(uint32_t mode,uint32_t * commandsSize,uint32_t * patchListSize,PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)116 MOS_STATUS CodechalHwInterfaceNextXe_Hpm::GetAvpStateCommandSize(
117 uint32_t mode,
118 uint32_t *commandsSize,
119 uint32_t *patchListSize,
120 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
121 {
122 CODECHAL_HW_FUNCTION_ENTER;
123
124 //calculate AVP related commands size
125 uint32_t avpCommandsSize = 0;
126 uint32_t avpPatchListSize = 0;
127 uint32_t cpCmdsize = 0;
128 uint32_t cpPatchListSize = 0;
129
130
131 if (GetAvpInterfaceNext())
132 {
133 CODECHAL_HW_CHK_STATUS_RETURN(GetAvpInterfaceNext()->GetAvpStateCmdSize(
134 (uint32_t *)&avpCommandsSize,
135 (uint32_t *)&avpPatchListSize,
136 params));
137 }
138
139 if (m_cpInterface)
140 {
141 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
142 }
143
144 //Calc final command size
145 *commandsSize = avpCommandsSize + cpCmdsize;
146 *patchListSize = avpPatchListSize + cpPatchListSize;
147
148 return MOS_STATUS_SUCCESS;
149 }
150
151
GetAvpPrimitiveCommandSize(uint32_t mode,uint32_t * commandsSize,uint32_t * patchListSize)152 MOS_STATUS CodechalHwInterfaceNextXe_Hpm::GetAvpPrimitiveCommandSize(
153 uint32_t mode,
154 uint32_t *commandsSize,
155 uint32_t *patchListSize)
156 {
157 CODECHAL_HW_FUNCTION_ENTER;
158
159 //calculate AVP related commands size
160 uint32_t avpCommandsSize = 0;
161 uint32_t avpPatchListSize = 0;
162 uint32_t cpCmdsize = 0;
163 uint32_t cpPatchListSize = 0;
164
165
166 if (GetAvpInterfaceNext())
167 {
168 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
169 CODECHAL_HW_CHK_STATUS_RETURN(GetAvpInterfaceNext()->GetAvpPrimitiveCmdSize(
170 (uint32_t*)&avpCommandsSize,
171 (uint32_t*)&avpPatchListSize,
172 &stateCmdSizeParams));
173 }
174
175 if (m_cpInterface)
176 {
177 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
178 }
179
180 //Calc final command size
181 *commandsSize = avpCommandsSize + cpCmdsize;
182 *patchListSize = avpPatchListSize + cpPatchListSize;
183
184 return MOS_STATUS_SUCCESS;
185 }
186
Initialize(CodechalSetting * settings)187 MOS_STATUS CodechalHwInterfaceNextXe_Hpm::Initialize(
188 CodechalSetting *settings)
189 {
190 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
191
192 CODECHAL_HW_FUNCTION_ENTER;
193
194 CODECHAL_HW_CHK_STATUS_RETURN(CodechalHwInterfaceNext::Initialize(settings));
195 // Added isRenderHalNeeded flag into settings
196 // Indicate whether RenderHal is needed or not
197 if (settings->isRenderHalNeeded)
198 {
199 //Initialize renderHal
200 m_renderHal = (PRENDERHAL_INTERFACE_LEGACY)MOS_AllocAndZeroMemory(sizeof(RENDERHAL_INTERFACE_LEGACY));
201 CODECHAL_HW_CHK_NULL_RETURN(m_renderHal);
202 CODECHAL_HW_CHK_STATUS_RETURN(RenderHal_InitInterface_Legacy(
203 (PRENDERHAL_INTERFACE_LEGACY)m_renderHal,
204 &m_renderHalCpInterface,
205 m_osInterface));
206
207 RENDERHAL_SETTINGS_LEGACY RenderHalSettings;
208 RenderHalSettings.iMediaStates = 32;
209 CODECHAL_HW_CHK_STATUS_RETURN(m_renderHal->pfnInitialize(m_renderHal, &RenderHalSettings));
210
211 //set SSEU table
212 m_renderHal->sseuTable = m_ssEuTable;
213 }
214 return eStatus;
215 }
216 #if USE_CODECHAL_DEBUG_TOOL
CreateMediaCopy(PMOS_INTERFACE mosInterface)217 MediaCopyBaseState *CodechalHwInterfaceNextXe_Hpm::CreateMediaCopy(PMOS_INTERFACE mosInterface)
218 {
219 CODECHAL_HW_FUNCTION_ENTER;
220 MediaCopyBaseState *mediaCopy = nullptr;
221 PMOS_CONTEXT mos_context = nullptr;
222
223 if (mosInterface && mosInterface->pfnGetMosContext)
224 {
225 mosInterface->pfnGetMosContext(mosInterface, &mos_context);
226 }
227 mediaCopy = static_cast<MediaCopyBaseState *>(McpyDevice::CreateFactory(mos_context));
228
229 return mediaCopy;
230 }
231 #endif