Debian Codegraph @

media_driver/agnostic/gen12/codec/hal/codechal_hw_g12_X.cpp

raw
1 /*
2 * Copyright (c) 2017-2022, 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 codechal_hw_g12_X.cpp
24 //! \brief Implements HW interface layer for Gen12+ used on all OSs.
25 //! \details Implements HW interface layer for CNL+ to be used on on all operating systems/DDIs, across CODECHAL components.
26 //! This module must not contain any OS dependent code.
27 //!
28
29 #include "codechal_hw_g12_X.h"
30 #include "mhw_render_g12_X.h"
31 #include "mhw_mi_hwcmd_g12_X.h"
32 #include "mhw_mi_g12_X.h"
33 #include "mhw_vdbox_hcp_hwcmd_g12_X.h" // temporary include for calculating size of various hardware commands
34 #include "mhw_vdbox_vdenc_g12_X.h"
35 #include "mhw_vdbox_hcp_g12_X.h"
36 #include "mhw_vdbox_huc_g12_X.h"
37 #include "mhw_vdbox_mfx_g12_X.h"
38 #if (IGFX_GEN12_TGLLP_SUPPORTED)
39 #include "media_interfaces_g12_tgllp.h"
40 #endif
41 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
42 #include "igcodeckrn_g12.h"
43 #endif
44 #include "codechal_utilities.h"
45 #include "codeckrnheader.h"
46
47 // Currently initialized with dummy values, just as an example. Will be updated later.
48 const CODECHAL_SSEU_SETTING CodechalHwInterfaceG12::m_defaultSsEuLutG12[CODECHAL_NUM_MEDIA_STATES_G12] =
49 {
50 // Slice Sub-Slice EU Rsvd(freq)
51 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_OLP
52 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ENC_NORMAL
53 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ENC_PERFORMANCE
54 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ENC_QUALITY
55 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ENC_I_FRAME_DIST
56 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_32X_SCALING
57 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_16X_SCALING
58 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_4X_SCALING
59 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_32X_ME
60 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_16X_ME
61 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_4X_ME
62 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_BRC_INIT_RESET
63 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_BRC_UPDATE
64 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_BRC_BLOCK_COPY
65 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_HYBRID_PAK_P1
66 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_HYBRID_PAK_P2
67 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ENC_I_FRAME_CHROMA
68 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ENC_I_FRAME_LUMA
69 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_MPU_FHB
70 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_TPU_FHB
71 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_PA_COPY
72 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_PL2_COPY
73 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ENC_ADV
74 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_2X_SCALING
75 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_32x32_PU_MODE_DECISION
76 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_16x16_PU_SAD
77 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_16x16_PU_MODE_DECISION
78 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_8x8_PU
79 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_8x8_PU_FMODE
80 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_32x32_B_INTRA_CHECK
81 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_HEVC_B_MBENC
82 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_RESET_VLINE_STRIDE
83 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_HEVC_B_PAK
84 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_HEVC_BRC_LCU_UPDATE
85 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ME_VDENC_STREAMIN
86 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_ENC_I_32x32
87 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_ENC_I_16x16
88 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_ENC_P
89 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_ENC_TX
90 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_LUMA_RECON
91 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_CHROMA_RECON
92 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_DEBLOCK_MASK
93 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_LUMA_DEBLOCK
94 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_CHROMA_DEBLOCK
95 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_MC_PRED
96 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_LUMA_RECON
97 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_CHROMA_RECON
98 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_INTRA_LUMA_RECON
99 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_VP9_PAK_P_FRAME_INTRA_CHROMA_RECON
100 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_PREPROC
101 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_ENC_WP
102 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_HEVC_I_MBENC
103 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_CSC_DS_COPY
104 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_2X_4X_SCALING
105 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_HEVC_LCU64_B_MBENC
106 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_MB_BRC_UPDATE
107 { 1, 0, 8, 0 }, // CODECHAL_MEDIA_STATE_STATIC_FRAME_DETECTION
108 { 1, 0, 8, 0 },
109 { 1, 0, 8, 0 },
110 { 1, 0, 8, 0 },
111 { 1, 0, 8, 0 },
112 { 2, 3, 8, 0 },
113 { 2, 3, 8, 0 },
114 { 2, 3, 8, 0 },
115 { 2, 3, 8, 0 },
116 };
117
118 void CodechalHwInterfaceG12::InternalInit(CODECHAL_FUNCTION codecFunction)
119 {
120 InitCacheabilityControlSettings(codecFunction);
121 m_isVdencSuperSliceEnabled = true;
122 m_ssEuTable = m_defaultSsEuLutG12;
123 m_numMediaStates = CODECHAL_NUM_MEDIA_STATES_G12;
124
125 PrepareCmdSize(codecFunction);
126 }
127
128 void CodechalHwInterfaceG12::PrepareCmdSize(CODECHAL_FUNCTION codecFunction)
129 {
130 // Set platform dependent parameters
131 m_sizeOfCmdBatchBufferEnd = mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
132 m_sizeOfCmdMediaReset = mhw_mi_g12_X::MI_LOAD_REGISTER_IMM_CMD::byteSize * 8;
133 m_vdencBrcImgStateBufferSize = mhw_vdbox_vdenc_g12_X::VDENC_IMG_STATE_CMD::byteSize + mhw_vdbox_mfx_g12_X::MFX_AVC_IMG_STATE_CMD::byteSize +
134 mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;;
135
136 m_vdencBatchBuffer1stGroupSize = mhw_vdbox_hcp_g12_X::HCP_PIPE_MODE_SELECT_CMD::byteSize
137 + mhw_mi_g12_X::MFX_WAIT_CMD::byteSize * 2
138 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
139
140 m_vdencBatchBuffer2ndGroupSize = 124
141 + mhw_vdbox_hcp_g12_X::HCP_PIC_STATE_CMD::byteSize
142 + 204
143 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
144
145 m_vdencReadBatchBufferSize =
146 m_vdenc2ndLevelBatchBufferSize = m_vdencBatchBuffer1stGroupSize
147 + m_vdencBatchBuffer2ndGroupSize
148 + ENCODE_HEVC_VDENC_NUM_MAX_SLICES
149 * (2 * mhw_vdbox_hcp_g12_X::HCP_WEIGHTOFFSET_STATE_CMD::byteSize
150 + mhw_vdbox_hcp_g12_X::HCP_SLICE_STATE_CMD::byteSize
151 + (HEVC_MAX_NAL_UNIT_TYPE + 2) * mhw_vdbox_hcp_g12_X::HCP_PAK_INSERT_OBJECT_CMD::byteSize
152 + mhw_vdbox_vdenc_g12_X::VDENC_WEIGHTSOFFSETS_STATE_CMD::byteSize
153 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize
154 + 4 * ENCODE_VDENC_HEVC_PADDING_DW_SIZE);
155
156 m_HucStitchCmdBatchBufferSize = 7 * 4
157 + 14 * 4
158 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
159
160 // HCP_WEIGHTOFFSET_STATE_CMD cmds is planned to be added in near future
161 m_vdencBatchBufferPerSliceConstSize = mhw_vdbox_hcp_g12_X::HCP_SLICE_STATE_CMD::byteSize
162 + mhw_vdbox_hcp_g12_X::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
163 + mhw_vdbox_vdenc_g12_X::VDENC_WEIGHTSOFFSETS_STATE_CMD::byteSize
164 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
165
166 // Set to size of the BRC update command buffer, since it is larger than BRC Init/ PAK integration commands
167 m_hucCommandBufferSize = mhw_vdbox_huc_g12_X::HUC_IMEM_STATE_CMD::byteSize
168 + mhw_vdbox_huc_g12_X::HUC_PIPE_MODE_SELECT_CMD::byteSize
169 + mhw_mi_g12_X::MFX_WAIT_CMD::byteSize * 3
170 + mhw_vdbox_huc_g12_X::HUC_DMEM_STATE_CMD::byteSize
171 + mhw_vdbox_huc_g12_X::HUC_VIRTUAL_ADDR_STATE_CMD::byteSize
172 + mhw_vdbox_huc_g12_X::HUC_STREAM_OBJECT_CMD::byteSize
173 + mhw_mi_g12_X::MI_STORE_DATA_IMM_CMD::byteSize
174 + mhw_mi_g12_X::MI_STORE_REGISTER_MEM_CMD::byteSize
175 + mhw_vdbox_huc_g12_X::HUC_START_CMD::byteSize
176 + mhw_vdbox_vdenc_g12_X::VD_PIPELINE_FLUSH_CMD::byteSize
177 + mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize
178 + mhw_mi_g12_X::MI_STORE_DATA_IMM_CMD::byteSize * 2
179 + mhw_mi_g12_X::MI_STORE_REGISTER_MEM_CMD::byteSize * 2
180 + mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
181
182 m_maxKernelLoadCmdSize =
183 mhw_mi_g12_X::PIPE_CONTROL_CMD::byteSize +
184 mhw_render_g12_X::PIPELINE_SELECT_CMD::byteSize +
185 mhw_render_g12_X::MEDIA_OBJECT_CMD::byteSize +
186 mhw_render_g12_X::STATE_BASE_ADDRESS_CMD::byteSize +
187 mhw_render_g12_X::MEDIA_VFE_STATE_CMD::byteSize +
188 mhw_render_g12_X::MEDIA_CURBE_LOAD_CMD::byteSize +
189 mhw_render_g12_X::MEDIA_INTERFACE_DESCRIPTOR_LOAD_CMD::byteSize +
190 mhw_mi_g12_X::MI_BATCH_BUFFER_START_CMD::byteSize +
191 mhw_render_g12_X::MEDIA_OBJECT_WALKER_CMD::byteSize +
192 mhw_mi_g12_X::MI_STORE_DATA_IMM_CMD::byteSize;
193
194 m_sizeOfCmdMediaObject = mhw_render_g12_X::MEDIA_OBJECT_CMD::byteSize;
195 m_sizeOfCmdMediaStateFlush = mhw_mi_g12_X::MEDIA_STATE_FLUSH_CMD::byteSize;
196 }
197
198 CodechalHwInterfaceG12::CodechalHwInterfaceG12(
199 PMOS_INTERFACE osInterface,
200 CODECHAL_FUNCTION codecFunction,
201 MhwInterfaces *mhwInterfaces,
202 bool disableScalability)
203 : CodechalHwInterface(osInterface, codecFunction, mhwInterfaces, disableScalability)
204 {
205 CODECHAL_HW_FUNCTION_ENTER;
206 m_avpInterface = mhwInterfaces->m_avpInterface;
207 //Set the original m_avpInterface to nullptr to avoid double free and wild pointer
208 mhwInterfaces->m_avpInterface = nullptr;
209 m_mediaSfcItf = std::make_shared<MediaSfcInterfaceLegacy>(m_osInterface);
210
211 InternalInit(codecFunction);
212 }
213
214 MOS_STATUS CodechalHwInterfaceG12::InitL3CacheSettings()
215 {
216 // Get default L3 cache settings
217 if (m_renderInterface)
218 {
219 CODECHAL_HW_CHK_STATUS_RETURN(m_renderInterface->EnableL3Caching(nullptr));
220 }
221 else
222 {
223 CODECHAL_HW_CHK_STATUS_RETURN(m_hwInterfaceNext->GetRenderInterfaceNext()->EnableL3Caching(nullptr));
224 }
225
226 #if (_DEBUG || _RELEASE_INTERNAL)
227 // Override default L3 cache settings
228 if (m_renderInterface)
229 {
230 auto l3CacheConfig = m_renderInterface->GetL3CacheConfig();
231 MHW_RENDER_ENGINE_L3_CACHE_SETTINGS_G12 l3Overrides;
232 l3Overrides.dwTcCntlReg =
233 static_cast<MHW_RENDER_ENGINE_L3_CACHE_CONFIG_G12 *>(l3CacheConfig)->dwL3CacheTcCntlReg_Setting;
234 l3Overrides.dwAllocReg =
235 static_cast<MHW_RENDER_ENGINE_L3_CACHE_CONFIG_G12 *>(l3CacheConfig)->dwL3CacheAllocReg_Setting;
236 CODECHAL_HW_CHK_STATUS_RETURN(InitL3ControlUserFeatureSettings(
237 l3CacheConfig,
238 &l3Overrides));
239 CODECHAL_HW_CHK_STATUS_RETURN(m_renderInterface->EnableL3Caching(
240 &l3Overrides));
241 }
242 else
243 {
244 auto l3CacheConfig = m_hwInterfaceNext->GetRenderInterfaceNext()->GetL3CacheConfig();
245 mhw::render::MHW_RENDER_ENGINE_L3_CACHE_SETTINGS l3Overrides;
246 l3Overrides.dwTcCntlReg =
247 static_cast<mhw::render::MHW_RENDER_ENGINE_L3_CACHE_CONFIG *>(l3CacheConfig)->dwL3CacheTcCntlReg_Setting;
248 l3Overrides.dwAllocReg =
249 static_cast<mhw::render::MHW_RENDER_ENGINE_L3_CACHE_CONFIG *>(l3CacheConfig)->dwL3CacheAllocReg_Setting;
250 CODECHAL_HW_CHK_STATUS_RETURN(InitL3ControlUserFeatureSettings(
251 (MHW_RENDER_ENGINE_L3_CACHE_CONFIG *)l3CacheConfig,
252 (MHW_RENDER_ENGINE_L3_CACHE_SETTINGS_G12 *)&l3Overrides));
253 CODECHAL_HW_CHK_STATUS_RETURN(m_hwInterfaceNext->GetRenderInterfaceNext()->EnableL3Caching(
254 &l3Overrides));
255
256 }
257
258 #endif // (_DEBUG || _RELEASE_INTERNAL)
259
260 return MOS_STATUS_SUCCESS;
261 }
262
263 MOS_STATUS CodechalHwInterfaceG12::GetStreamoutCommandSize(
264 uint32_t *commandsSize,
265 uint32_t *patchListSize)
266 {
267 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
268
269 CODECHAL_HW_FUNCTION_ENTER;
270
271 MHW_VDBOX_STATE_CMDSIZE_PARAMS_G12 stateCmdSizeParams;
272
273 stateCmdSizeParams.bShortFormat = false;
274 stateCmdSizeParams.bHucDummyStream = MEDIA_IS_WA(m_waTable, WaHucStreamoutEnable);
275 CODECHAL_HW_CHK_STATUS_RETURN(GetHxxStateCommandSize(
276 CODECHAL_DECODE_MODE_CENC, // For CENC phase
277 commandsSize,
278 patchListSize,
279 &stateCmdSizeParams));
280
281 return eStatus;
282 }
283
284 MOS_STATUS CodechalHwInterfaceG12::SetCacheabilitySettings(
285 MHW_MEMORY_OBJECT_CONTROL_PARAMS cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC])
286 {
287 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
288
289 CODECHAL_HW_FUNCTION_ENTER;
290
291 if (m_mfxInterface)
292 {
293 CODECHAL_HW_CHK_STATUS_RETURN(m_mfxInterface->SetCacheabilitySettings(cacheabilitySettings));
294 }
295 if (m_hcpInterface)
296 {
297 CODECHAL_HW_CHK_STATUS_RETURN(m_hcpInterface->SetCacheabilitySettings(cacheabilitySettings));
298 }
299 if (m_vdencInterface)
300 {
301 CODECHAL_HW_CHK_STATUS_RETURN(m_vdencInterface->SetCacheabilitySettings(cacheabilitySettings));
302 }
303 if (m_avpInterface)
304 {
305 CODECHAL_HW_CHK_STATUS_RETURN(m_avpInterface->SetCacheabilitySettings(cacheabilitySettings));
306 }
307 if (m_hucInterface)
308 {
309 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->SetCacheabilitySettings(cacheabilitySettings));
310 }
311
312 return eStatus;
313 }
314
315 MOS_STATUS CodechalHwInterfaceG12::SetRowstoreCachingOffsets(
316 PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
317 {
318 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
319
320 CODECHAL_HW_FUNCTION_ENTER;
321
322 CODECHAL_HW_CHK_STATUS_RETURN(CodechalHwInterface::SetRowstoreCachingOffsets(rowstoreParams));
323
324 if (m_avpInterface)
325 {
326 CODECHAL_HW_CHK_STATUS_RETURN(m_avpInterface->GetRowstoreCachingAddrs(rowstoreParams));
327 }
328
329 return eStatus;
330 }
331
332 MOS_STATUS CodechalHwInterfaceG12::GetAvpStateCommandSize(
333 uint32_t mode,
334 uint32_t *commandsSize,
335 uint32_t *patchListSize,
336 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
337 {
338 CODECHAL_HW_FUNCTION_ENTER;
339
340 //calculate AVP related commands size
341 uint32_t avpCommandsSize = 0;
342 uint32_t avpPatchListSize = 0;
343 uint32_t cpCmdsize = 0;
344 uint32_t cpPatchListSize = 0;
345
346 if (m_avpInterface)
347 {
348 CODECHAL_HW_CHK_STATUS_RETURN(m_avpInterface->GetAvpStateCommandSize(
349 (uint32_t *)&avpCommandsSize,
350 (uint32_t *)&avpPatchListSize,
351 params));
352 }
353
354 if (m_cpInterface)
355 {
356 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
357 }
358
359 //Calc final command size
360 *commandsSize = avpCommandsSize + cpCmdsize;
361 *patchListSize = avpPatchListSize + cpPatchListSize;
362
363 return MOS_STATUS_SUCCESS;
364 }
365
366 MOS_STATUS CodechalHwInterfaceG12::GetAvpPrimitiveCommandSize(
367 uint32_t mode,
368 uint32_t *commandsSize,
369 uint32_t *patchListSize)
370 {
371 CODECHAL_HW_FUNCTION_ENTER;
372
373 //calculate AVP related commands size
374 uint32_t avpCommandsSize = 0;
375 uint32_t avpPatchListSize = 0;
376 uint32_t cpCmdsize = 0;
377 uint32_t cpPatchListSize = 0;
378
379 if (m_avpInterface)
380 {
381 CODECHAL_HW_CHK_STATUS_RETURN(m_avpInterface->GetAvpPrimitiveCommandSize(
382 (uint32_t*)&avpCommandsSize,
383 (uint32_t*)&avpPatchListSize));
384 }
385
386 if (m_cpInterface)
387 {
388 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
389 }
390
391 //Calc final command size
392 *commandsSize = avpCommandsSize + cpCmdsize;
393 *patchListSize = avpPatchListSize + cpPatchListSize;
394
395 return MOS_STATUS_SUCCESS;
396 }
397
398
399 MOS_STATUS CodechalHwInterfaceG12::SendCondBbEndCmd(
400 PMOS_RESOURCE resource,
401 uint32_t offset,
402 uint32_t compData,
403 bool disableCompMask,
404 bool enableEndCurrentBatchBuffLevel,
405 uint32_t compareOperation,
406 PMOS_COMMAND_BUFFER cmdBuffer)
407 {
408 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
409
410 CODECHAL_HW_FUNCTION_ENTER;
411
412 if (!Mos_ResourceIsNull(&m_conditionalBbEndDummy))
413 {
414 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
415 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
416 flushDwParams.postSyncOperation = 1;
417 flushDwParams.pOsResource = &m_conditionalBbEndDummy;
418 flushDwParams.dwDataDW1 = 0;
419 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
420 }
421
422 MHW_MI_ENHANCED_CONDITIONAL_BATCH_BUFFER_END_PARAMS conditionalBatchBufferEndParams;
423 MOS_ZeroMemory(&conditionalBatchBufferEndParams, sizeof(conditionalBatchBufferEndParams));
424 conditionalBatchBufferEndParams.presSemaphoreBuffer = resource;
425 conditionalBatchBufferEndParams.dwOffset = offset;
426 conditionalBatchBufferEndParams.dwValue = compData;
427 conditionalBatchBufferEndParams.bDisableCompareMask = disableCompMask;
428 conditionalBatchBufferEndParams.dwParamsType = MHW_MI_ENHANCED_CONDITIONAL_BATCH_BUFFER_END_PARAMS::ENHANCED_PARAMS;
429 if (enableEndCurrentBatchBuffLevel)
430 {
431 conditionalBatchBufferEndParams.enableEndCurrentBatchBuffLevel = enableEndCurrentBatchBuffLevel;
432 conditionalBatchBufferEndParams.compareOperation = compareOperation;
433 }
434 eStatus = m_miInterface->AddMiConditionalBatchBufferEndCmd(cmdBuffer, &conditionalBatchBufferEndParams);
435
436 return eStatus;
437 }
438
439 MOS_STATUS CodechalHwInterfaceG12::Initialize(
440 CodechalSetting *settings)
441 {
442 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
443
444 CODECHAL_HW_FUNCTION_ENTER;
445
446 CODECHAL_HW_CHK_STATUS_RETURN(CodechalHwInterface::Initialize(settings));
447 // Added isRenderHalNeeded flag into settings
448 // Indicate whether RenderHal is needed or not
449 if (settings->isRenderHalNeeded ||
450 (settings->codecFunction == CODECHAL_FUNCTION_DECODE &&
451 settings->standard == CODECHAL_AV1))
452 {
453 //Initialize renderHal
454 m_renderHal = (PRENDERHAL_INTERFACE_LEGACY)MOS_AllocAndZeroMemory(sizeof(RENDERHAL_INTERFACE_LEGACY));
455 CODECHAL_HW_CHK_NULL_RETURN(m_renderHal);
456 CODECHAL_HW_CHK_STATUS_RETURN(RenderHal_InitInterface_Legacy(
457 (PRENDERHAL_INTERFACE_LEGACY)m_renderHal,
458 &m_renderHalCpInterface,
459 m_osInterface));
460
461 RENDERHAL_SETTINGS_LEGACY RenderHalSettings;
462 RenderHalSettings.iMediaStates = 32;
463 CODECHAL_HW_CHK_STATUS_RETURN(m_renderHal->pfnInitialize(m_renderHal, &RenderHalSettings));
464
465 //set SSEU table
466 m_renderHal->sseuTable = m_ssEuTable;
467 }
468 return eStatus;
469 }
470
471 MOS_STATUS CodechalHwInterfaceG12::ReadAvpStatus(MHW_VDBOX_NODE_IND vdboxIndex, const EncodeStatusReadParams &params, PMOS_COMMAND_BUFFER cmdBuffer)
472 {
473 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
474
475 CODECHAL_HW_FUNCTION_ENTER;
476
477 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
478
479 CODECHAL_HW_CHK_COND_RETURN((vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
480
481 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
482 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
483 std::shared_ptr<mhw::mi::Itf> m_miItf = GetMiInterfaceNext();
484 if (m_miInterface)
485 {
486 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
487 }
488 else
489 {
490 auto &parFlush = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
491 parFlush = {};
492 CODECHAL_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
493 }
494
495 std::shared_ptr<mhw::vdbox::avp::Itf> m_avpItf = GetAvpInterfaceNext();
496 CODECHAL_HW_CHK_NULL_RETURN(m_avpItf);
497 auto mmioRegisters = m_avpItf->GetMmioRegisters(vdboxIndex);
498 if (m_miInterface)
499 {
500 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
501 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
502 miStoreRegMemParams.presStoreBuffer = params.resBitstreamByteCountPerFrame;
503 miStoreRegMemParams.dwOffset = params.bitstreamByteCountPerFrameOffset;
504 miStoreRegMemParams.dwRegister = mmioRegisters->avpAv1BitstreamByteCountTileRegOffset;
505 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
506 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
507 miStoreRegMemParams.presStoreBuffer = params.resQpStatusCount;
508 miStoreRegMemParams.dwOffset = params.qpStatusCountOffset;
509 miStoreRegMemParams.dwRegister = mmioRegisters->avpAv1QpStatusCountRegOffset;
510 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
511
512 }
513 else
514 {
515 auto &storeRegMemParams = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
516 storeRegMemParams = {};
517 storeRegMemParams.presStoreBuffer = params.resBitstreamByteCountPerFrame;
518 storeRegMemParams.dwOffset = params.bitstreamByteCountPerFrameOffset;
519 storeRegMemParams.dwRegister = mmioRegisters->avpAv1BitstreamByteCountTileRegOffset;
520 CODECHAL_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
521 storeRegMemParams = {};
522 storeRegMemParams.presStoreBuffer = params.resQpStatusCount;
523 storeRegMemParams.dwOffset = params.qpStatusCountOffset;
524 storeRegMemParams.dwRegister = mmioRegisters->avpAv1QpStatusCountRegOffset;
525 CODECHAL_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
526 }
527 return eStatus;
528 }
529
530 MOS_STATUS CodechalHwInterfaceG12::ReadImageStatusForAvp(MHW_VDBOX_NODE_IND vdboxIndex, const EncodeStatusReadParams &params, PMOS_COMMAND_BUFFER cmdBuffer)
531 {
532 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
533
534 CODECHAL_HW_FUNCTION_ENTER;
535
536 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
537
538 CODECHAL_HW_CHK_COND_RETURN((vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
539
540 std::shared_ptr<mhw::vdbox::avp::Itf> m_avpItf = GetAvpInterfaceNext();
541 CODECHAL_HW_CHK_NULL_RETURN(m_avpItf);
542 auto mmioRegisters = GetAvpInterfaceNext()->GetMmioRegisters(vdboxIndex);
543 std::shared_ptr<mhw::mi::Itf> m_miItf = GetMiInterfaceNext();
544 if (m_miInterface)
545 {
546 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
547 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
548 miStoreRegMemParams.presStoreBuffer = params.resImageStatusMask;
549 miStoreRegMemParams.dwOffset = params.imageStatusMaskOffset;
550 miStoreRegMemParams.dwRegister = mmioRegisters->avpAv1ImageStatusMaskRegOffset;
551 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
552
553 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
554 miStoreRegMemParams.presStoreBuffer = params.resImageStatusCtrl;
555 miStoreRegMemParams.dwOffset = params.imageStatusCtrlOffset;
556 miStoreRegMemParams.dwRegister = mmioRegisters->avpAv1ImageStatusControlRegOffset;
557 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
558
559 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
560 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
561 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
562 }
563 else
564 {
565 auto &storeRegMemParams = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
566 storeRegMemParams = {};
567 storeRegMemParams.presStoreBuffer = params.resImageStatusMask;
568 storeRegMemParams.dwOffset = params.imageStatusMaskOffset;
569 storeRegMemParams.dwRegister = mmioRegisters->avpAv1ImageStatusMaskRegOffset;
570 CODECHAL_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
571 storeRegMemParams = {};
572 storeRegMemParams.presStoreBuffer = params.resImageStatusCtrl;
573 storeRegMemParams.dwOffset = params.imageStatusCtrlOffset;
574 storeRegMemParams.dwRegister = mmioRegisters->avpAv1ImageStatusControlRegOffset;
575 CODECHAL_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
576 auto &parFlush = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
577 parFlush = {};
578 CODECHAL_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
579 }
580 return eStatus;
581 }
582
583 CodechalHwInterfaceG12::~CodechalHwInterfaceG12()
584 {
585 if (m_renderHal != nullptr && m_renderHal->pfnDestroy != nullptr)
586 {
587 MOS_STATUS eStatus = m_renderHal->pfnDestroy(m_renderHal);
588 if (eStatus != MOS_STATUS_SUCCESS)
589 {
590 MHW_ASSERTMESSAGE("Failed to destroy RenderHal, eStatus:%d.\n", eStatus);
591 }
592
593 if (m_renderHalCpInterface)
594 {
595 if (m_osInterface)
596 {
597 m_osInterface->pfnDeleteMhwCpInterface(m_renderHalCpInterface);
598 m_renderHalCpInterface = nullptr;
599 }
600 else
601 {
602 MHW_ASSERTMESSAGE("Failed to destroy renderHalCpInterface.");
603 }
604 }
605 }
606
607 if (m_renderHal != nullptr)
608 {
609 MOS_FreeMemory(m_renderHal);
610 m_renderHal = nullptr;
611 }
612
613 if (m_avpInterface)
614 {
615 MOS_Delete(m_avpInterface);
616 }
617 }
618
619 MOS_STATUS CodechalHwInterfaceG12::GetFilmGrainKernelInfo(
620 uint8_t*& kernelBase,
621 uint32_t& kernelSize)
622 {
623 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
624 uint8_t* kernelArrayBase = nullptr;
625
626 auto kuidCommon = IDR_CODEC_VID_ApplyNoise_Combined;
627 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
628 kernelArrayBase = (uint8_t*)IGCODECKRN_G12;
629 CODECHAL_HW_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(kernelArrayBase,
630 kuidCommon,
631 &kernelBase,
632 &kernelSize));
633 #else
634 kernelBase = nullptr;
635 kernelSize = 0;
636 #endif
637
638 return eStatus;
639 }