Debian Codegraph @

media_softlet/agnostic/common/codec/hal/shared/codec_hw_next.cpp

raw
1 /*
2 * Copyright (c) 2021-2023, 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 codec_hw_next.cpp
24 //! \brief This modules implements HW interface layer to be used on all platforms on all operating systems/DDIs, across CODECHAL components.
25 //!
26 #include "codec_hw_next.h"
27 #include "codechal_setting.h"
28 #include "mos_os_cp_interface_specific.h"
29 #include "mhw_vdbox_vvcp_itf.h"
30
31 CodechalHwInterfaceNext::CodechalHwInterfaceNext(
32 PMOS_INTERFACE osInterface,
33 CODECHAL_FUNCTION codecFunction,
34 MhwInterfacesNext *mhwInterfacesNext,
35 bool disableScalability)
36 {
37 CODEC_HW_FUNCTION_ENTER;
38
39 m_avpItf = mhwInterfacesNext->m_avpItf;
40 m_vdencItf = mhwInterfacesNext->m_vdencItf;
41 m_hucItf = mhwInterfacesNext->m_hucItf;
42 m_miItf = mhwInterfacesNext->m_miItf;
43 m_hcpItf = mhwInterfacesNext->m_hcpItf;
44 m_mfxItf = mhwInterfacesNext->m_mfxItf;
45 m_renderItf = mhwInterfacesNext->m_renderItf;
46 m_vvcpItf = mhwInterfacesNext->m_vvcpItf;
47 m_aqmItf = mhwInterfacesNext->m_aqmItf;
48
49 CODEC_HW_ASSERT(osInterface);
50 m_osInterface = osInterface;
51
52 MOS_ZeroMemory(&m_platform, sizeof(PLATFORM));
53 m_osInterface->pfnGetPlatform(m_osInterface, &m_platform);
54
55 m_skuTable = m_osInterface->pfnGetSkuTable(m_osInterface);
56 m_waTable = m_osInterface->pfnGetWaTable(m_osInterface);
57 CODEC_HW_ASSERT(m_skuTable);
58 CODEC_HW_ASSERT(m_waTable);
59
60 MOS_ZeroMemory(&m_hucDmemDummy, sizeof(m_hucDmemDummy));
61 MOS_ZeroMemory(&m_dummyStreamIn, sizeof(m_dummyStreamIn));
62 MOS_ZeroMemory(&m_dummyStreamOut, sizeof(m_dummyStreamOut));
63 MOS_ZeroMemory(&m_conditionalBbEndDummy, sizeof(m_conditionalBbEndDummy));
64
65 // Remove legacy mhw sub interfaces.
66 m_cpInterface = mhwInterfacesNext->m_cpInterface;
67 m_veboxInterface = mhwInterfacesNext->m_veboxInterface;
68 m_sfcInterface = mhwInterfacesNext->m_sfcInterface;
69 //Prevent double free
70 mhwInterfacesNext->m_cpInterface = nullptr;
71 mhwInterfacesNext->m_veboxInterface = nullptr;
72 mhwInterfacesNext->m_sfcInterface = nullptr;
73
74 m_disableScalability = disableScalability;
75 m_userSettingPtr = osInterface->pfnGetUserSettingInstance(osInterface);
76
77 InitMemoryObjectCacheSettings();
78 }
79
80 CodechalHwInterfaceNext::~CodechalHwInterfaceNext()
81 {
82 CODEC_HW_FUNCTION_ENTER;
83
84 if (m_osInterface != nullptr)
85 {
86 m_osInterface->pfnFreeResource(m_osInterface, &m_hucDmemDummy);
87 m_osInterface->pfnFreeResource(m_osInterface, &m_dummyStreamIn);
88 m_osInterface->pfnFreeResource(m_osInterface, &m_dummyStreamOut);
89
90 m_osInterface->pfnFreeResource(m_osInterface, &m_conditionalBbEndDummy);
91 if (m_cpInterface)
92 {
93 m_osInterface->pfnDeleteMhwCpInterface(m_cpInterface);
94 m_cpInterface = nullptr;
95 }
96 }
97
98 if (m_veboxInterface)
99 {
100 m_veboxInterface->DestroyHeap();
101 MOS_Delete(m_veboxInterface);
102 m_veboxInterface = nullptr;
103 }
104
105 if (m_sfcInterface)
106 {
107 MOS_Delete(m_sfcInterface);
108 m_sfcInterface = nullptr;
109 }
110 }
111
112 CodechalHwInterfaceNext* CodechalHwInterfaceNext::Create(
113 PMOS_INTERFACE osInterface,
114 CODECHAL_FUNCTION codecFunction,
115 MhwInterfacesNext* mhwInterfacesNext,
116 bool disableScalability)
117 {
118 return MOS_New(CodechalHwInterfaceNext,
119 osInterface,
120 codecFunction,
121 mhwInterfacesNext,
122 disableScalability);
123 }
124
125 MOS_STATUS CodechalHwInterfaceNext::Initialize(
126 CodechalSetting *settings)
127 {
128 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
129 MediaUserSettingSharedPtr userSettingPtr = nullptr;
130 uint32_t value = 0;
131
132 CODEC_HW_FUNCTION_ENTER;
133
134 if (UsesRenderEngine(settings->codecFunction, settings->standard) ||
135 CodecHalIsEnableFieldScaling(settings->codecFunction, settings->standard, settings->downsamplingHinted))
136 {
137 CODEC_HW_CHK_NULL_RETURN(m_renderItf);
138
139 m_stateHeapSettings.m_ishBehavior = HeapManager::Behavior::clientControlled;
140 m_stateHeapSettings.m_dshBehavior = HeapManager::Behavior::destructiveExtend;
141 // As a performance optimization keep the DSH locked always,
142 // the ISH is only accessed at device creation and thus does not need to be locked
143 m_stateHeapSettings.m_keepDshLocked = true;
144 m_stateHeapSettings.dwDshIncrement = 2 * MOS_PAGE_SIZE;
145
146 if (m_stateHeapSettings.dwIshSize > 0 &&
147 m_stateHeapSettings.dwDshSize > 0 &&
148 m_stateHeapSettings.dwNumSyncTags > 0)
149 {
150 CODEC_HW_CHK_STATUS_RETURN(m_renderItf->AllocateHeaps(
151 m_stateHeapSettings));
152 }
153 }
154
155 #if (_DEBUG || _RELEASE_INTERNAL)
156 userSettingPtr = m_osInterface->pfnGetUserSettingInstance(m_osInterface);
157 ReadUserSettingForDebug(
158 userSettingPtr,
159 value,
160 __MEDIA_USER_FEATURE_VALUE_SSEU_SETTING_OVERRIDE,
161 MediaUserSetting::Group::Device);
162
163 if (value != 0xDEADC0DE)
164 {
165 m_numRequestedEuSlicesOverride = value & 0xFF; // Bits 0-7
166 m_numRequestedSubSlicesOverride = (value >> 8) & 0xFF; // Bits 8-15
167 m_numRequestedEusOverride = (value >> 16) & 0xFFFF; // Bits 16-31
168 m_numRequestedOverride = true;
169 }
170 #endif
171
172 m_enableCodecMmc = !MEDIA_IS_WA(GetWaTable(), WaDisableCodecMmc);
173
174 return eStatus;
175 }
176
177 MOS_STATUS CodechalHwInterfaceNext::InitCacheabilityControlSettings(
178 CODECHAL_FUNCTION codecFunction)
179 {
180 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
181
182 CODEC_HW_FUNCTION_ENTER;
183
184 CODEC_HW_CHK_STATUS_RETURN(InitMemoryObjectCacheSettings());
185 CODEC_HW_CHK_STATUS_RETURN(InitL3CacheSettings());
186
187 return eStatus;
188 }
189
190 MOS_STATUS CodechalHwInterfaceNext::InitMemoryObjectCacheSettings()
191 {
192 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
193
194 CODEC_HW_FUNCTION_ENTER;
195
196 CODEC_HW_CHK_NULL_RETURN(m_osInterface);
197
198 for (uint32_t i = MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC + 1; i < MOS_CODEC_RESOURCE_USAGE_END_CODEC; i++)
199 {
200 CODEC_HW_CHK_STATUS_RETURN(CachePolicyGetMemoryObject(
201 (MOS_HW_RESOURCE_DEF)i));
202 }
203
204 SetCacheabilitySettings(m_cacheabilitySettings);
205
206 return eStatus;
207 }
208
209 MOS_STATUS CodechalHwInterfaceNext::CachePolicyGetMemoryObject(
210 MOS_HW_RESOURCE_DEF mosUsage)
211 {
212 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
213
214 m_cacheabilitySettings[mosUsage].Value =
215 (m_osInterface->pfnCachePolicyGetMemoryObject(
216 mosUsage,
217 m_osInterface->pfnGetGmmClientContext(m_osInterface))).DwordValue;
218
219 return eStatus;
220 }
221
222 CodechalHwInterfaceNext::CodechalHwInterfaceNext(
223 PMOS_INTERFACE osInterface,
224 bool disableScalability)
225 {
226 CODEC_HW_ASSERT(osInterface);
227 m_osInterface = osInterface;
228
229 m_skuTable = m_osInterface->pfnGetSkuTable(m_osInterface);
230 m_waTable = m_osInterface->pfnGetWaTable(m_osInterface);
231 CODEC_HW_ASSERT(m_skuTable);
232 CODEC_HW_ASSERT(m_waTable);
233
234 MOS_ZeroMemory(&m_hucDmemDummy, sizeof(m_hucDmemDummy));
235 MOS_ZeroMemory(&m_dummyStreamIn, sizeof(m_dummyStreamIn));
236 MOS_ZeroMemory(&m_dummyStreamOut, sizeof(m_dummyStreamOut));
237
238 MOS_ZeroMemory(&m_conditionalBbEndDummy, sizeof(m_conditionalBbEndDummy));
239
240 m_enableCodecMmc = !MEDIA_IS_WA(GetWaTable(), WaDisableCodecMmc);
241 m_disableScalability = disableScalability;
242 }
243 MOS_STATUS CodechalHwInterfaceNext::GetAvpStateCommandSize(
244 uint32_t mode,
245 uint32_t *commandsSize,
246 uint32_t *patchListSize,
247 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
248 {
249 CODEC_HW_FUNCTION_ENTER;
250
251 //calculate AVP related commands size
252 uint32_t avpCommandsSize = 0;
253 uint32_t avpPatchListSize = 0;
254 uint32_t cpCmdsize = 0;
255 uint32_t cpPatchListSize = 0;
256
257 if (m_avpItf)
258 {
259 CODEC_HW_CHK_STATUS_RETURN(m_avpItf->GetAvpStateCmdSize(
260 (uint32_t *)&avpCommandsSize,
261 (uint32_t *)&avpPatchListSize,
262 params));
263 }
264
265 if (m_cpInterface != nullptr)
266 {
267 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
268 }
269
270 //Calc final command size
271 *commandsSize = avpCommandsSize + cpCmdsize;
272 *patchListSize = avpPatchListSize + cpPatchListSize;
273
274 return MOS_STATUS_SUCCESS;
275 }
276
277 MOS_STATUS CodechalHwInterfaceNext::GetMfxStateCommandsDataSize(
278 uint32_t mode,
279 uint32_t *commandsSize,
280 uint32_t *patchListSize,
281 bool shortFormat)
282 {
283 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
284
285 CODEC_HW_FUNCTION_ENTER;
286
287 uint32_t cpCmdsize = 0;
288 uint32_t cpPatchListSize = 0;
289
290 if (m_mfxItf)
291 {
292 CODEC_HW_CHK_STATUS_RETURN(m_mfxItf->GetMfxStateCommandsDataSize(
293 mode, (uint32_t *)commandsSize, (uint32_t *)patchListSize, shortFormat ? true : false));
294
295 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
296 }
297 *commandsSize += (uint32_t)cpCmdsize;
298 *patchListSize += (uint32_t)cpPatchListSize;
299
300 return eStatus;
301 }
302
303 MOS_STATUS CodechalHwInterfaceNext::GetAvpPrimitiveCommandSize(
304 uint32_t mode,
305 uint32_t *commandsSize,
306 uint32_t *patchListSize)
307 {
308 CODEC_HW_FUNCTION_ENTER;
309
310 //calculate AVP related commands size
311 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
312
313 if (mode == CODECHAL_DECODE_MODE_AV1VLD)
314 {
315 stateCmdSizeParams.bDecodeInUse = true;
316 }
317
318 uint32_t avpCommandsSize = 0;
319 uint32_t avpPatchListSize = 0;
320 uint32_t cpCmdsize = 0;
321 uint32_t cpPatchListSize = 0;
322
323 if (m_avpItf)
324 {
325 CODEC_HW_CHK_STATUS_RETURN(m_avpItf->GetAvpPrimitiveCmdSize(
326 (uint32_t*)&avpCommandsSize,
327 (uint32_t*)&avpPatchListSize,
328 &stateCmdSizeParams));
329 }
330
331 if (m_cpInterface)
332 {
333 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
334 }
335
336 //Calc final command size
337 *commandsSize = avpCommandsSize + cpCmdsize;
338 *patchListSize = avpPatchListSize + cpPatchListSize;
339
340 return MOS_STATUS_SUCCESS;
341 }
342
343 MOS_STATUS CodechalHwInterfaceNext::GetVdencPictureSecondLevelCommandsSize(
344 uint32_t mode,
345 uint32_t *commandsSize)
346 {
347 CODEC_HW_FUNCTION_ENTER;
348
349 uint32_t commandSz = 0;
350
351 MHW_MI_CHK_NULL(m_hcpItf);
352
353 uint32_t standard = CodecHal_GetStandardFromMode(mode);
354
355 if (standard == CODECHAL_VP9)
356 {
357 commandSz += m_hcpItf->MHW_GETSIZE_F(HCP_VP9_PIC_STATE)();
358 commandSz += m_hcpItf->MHW_GETSIZE_F(HCP_VP9_SEGMENT_STATE)() * 8;
359 commandSz += m_vdencItf->MHW_GETSIZE_F(VDENC_CMD1)();
360 commandSz += m_vdencItf->MHW_GETSIZE_F(VDENC_CMD2)();
361 commandSz += m_sizeOfCmdBatchBufferEnd;
362 commandSz += (MOS_ALIGN_CEIL(commandSz, 64) - commandSz); // padding for alignment on 64
363 }
364 else
365 {
366 MHW_ASSERTMESSAGE("Unsupported encode mode.");
367 return MOS_STATUS_UNKNOWN;
368 }
369
370 *commandsSize = commandSz;
371
372 return MOS_STATUS_SUCCESS;
373 }
374
375 MOS_STATUS CodechalHwInterfaceNext::SetCacheabilitySettings(
376 MHW_MEMORY_OBJECT_CONTROL_PARAMS cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC])
377 {
378 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
379
380 CODEC_HW_FUNCTION_ENTER;
381
382 /* New Mhw sub interfaces usage */
383 if (m_avpItf)
384 {
385 CODEC_HW_CHK_STATUS_RETURN(m_avpItf->SetCacheabilitySettings(cacheabilitySettings));
386 }
387 if (m_hcpItf)
388 {
389 CODEC_HW_CHK_STATUS_RETURN(m_hcpItf->SetCacheabilitySettings(cacheabilitySettings));
390 }
391 if (m_mfxItf)
392 {
393 CODEC_HW_CHK_STATUS_RETURN(m_mfxItf->SetCacheabilitySettings(cacheabilitySettings));
394 }
395 if (m_vdencItf)
396 {
397 CODEC_HW_CHK_STATUS_RETURN(m_vdencItf->SetCacheabilitySettings(cacheabilitySettings));
398 }
399 if (m_vvcpItf != nullptr)
400 {
401 CODEC_HW_CHK_STATUS_RETURN(m_vvcpItf->SetCacheabilitySettings(cacheabilitySettings));
402 }
403 if (m_hucItf)
404 {
405 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->SetCacheabilitySettings(cacheabilitySettings));
406 }
407
408
409 return eStatus;
410 }
411
412 MOS_STATUS CodechalHwInterfaceNext::GetHucStateCommandSize(
413 uint32_t mode,
414 uint32_t* commandsSize,
415 uint32_t* patchListSize,
416 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
417
418 {
419 MHW_FUNCTION_ENTER;
420
421 uint32_t maxSize = 0;
422 uint32_t patchListMaxSize = 0;
423 uint32_t standard = CodecHal_GetStandardFromMode(mode);
424 uint32_t numSlices = 1;
425 uint32_t numStoreDataImm = 1;
426 uint32_t numStoreReg = 1;
427
428 MHW_MI_CHK_NULL(commandsSize);
429 MHW_MI_CHK_NULL(patchListSize);
430 MHW_MI_CHK_NULL(params);
431
432 if(params->uNumStoreDataImm)
433 {
434 numStoreDataImm = params->uNumStoreDataImm;
435 }
436 if(params->uNumStoreReg)
437 {
438 numStoreReg = params->uNumStoreReg;
439 }
440
441 if (mode == CODECHAL_DECODE_MODE_HEVCVLD && params->bShortFormat)
442 {
443 numSlices = CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6;
444 numStoreDataImm = 2;
445 numStoreReg = 2;
446
447 maxSize +=
448 2 * m_miItf->MHW_GETSIZE_F(MI_CONDITIONAL_BATCH_BUFFER_END)();
449
450 patchListMaxSize +=
451 2 * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_CONDITIONAL_BATCH_BUFFER_END_CMD);
452 }
453 else if (standard == CODECHAL_CENC)
454 {
455 numStoreDataImm = 3;
456 numStoreReg = 3;
457
458 maxSize +=
459 m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)() * 2 +
460 m_miItf->MHW_GETSIZE_F(MI_BATCH_BUFFER_END)();
461
462 patchListMaxSize +=
463 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_FLUSH_DW_CMD) * 2;
464
465 }
466 else if (mode == CODECHAL_ENCODE_MODE_VP9)
467 {
468 // for huc status 2 register and semaphore signal and reset
469 numStoreDataImm = 3;
470
471 maxSize +=
472 m_miItf->MHW_GETSIZE_F(MI_BATCH_BUFFER_END)() +
473 m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)();
474
475 patchListMaxSize +=
476 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_FLUSH_DW_CMD);
477 }
478 else if (mode == CODECHAL_ENCODE_MODE_AVC)
479 {
480 numStoreDataImm = 2;
481 numStoreReg = 2;
482
483 maxSize +=
484 2 * m_miItf->MHW_GETSIZE_F(MI_CONDITIONAL_BATCH_BUFFER_END)();
485
486 patchListMaxSize +=
487 2 * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_CONDITIONAL_BATCH_BUFFER_END_CMD);
488 }
489
490 maxSize +=
491 m_hucItf->MHW_GETSIZE_F(HUC_PIPE_MODE_SELECT)() +
492 m_hucItf->MHW_GETSIZE_F(HUC_IMEM_STATE)() +
493 m_hucItf->MHW_GETSIZE_F(HUC_DMEM_STATE)() +
494 m_hucItf->MHW_GETSIZE_F(HUC_VIRTUAL_ADDR_STATE)() +
495 m_hucItf->MHW_GETSIZE_F(HUC_IND_OBJ_BASE_ADDR_STATE)() +
496 numSlices * m_hucItf->MHW_GETSIZE_F(HUC_STREAM_OBJECT)() +
497 numSlices * m_hucItf->MHW_GETSIZE_F(HUC_START)() +
498 numStoreDataImm * m_miItf->MHW_GETSIZE_F(MI_STORE_DATA_IMM)() +
499 numStoreReg * m_miItf->MHW_GETSIZE_F(MI_STORE_REGISTER_MEM)();
500
501 if(params->uNumMfxWait)
502 {
503 maxSize +=
504 params->uNumMfxWait * m_miItf->MHW_GETSIZE_F(MFX_WAIT)();
505 }
506
507 patchListMaxSize +=
508 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_PIPE_MODE_SELECT_CMD) +
509 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_IMEM_STATE_CMD) +
510 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_DMEM_STATE_CMD) +
511 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_VIRTUAL_ADDR_STATE_CMD) +
512 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_IND_OBJ_BASE_ADDR_STATE_CMD) +
513 numSlices * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_STREAM_OBJECT_CMD) +
514 numSlices * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_START_CMD) +
515 numStoreDataImm * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_STORE_DATA_IMM_CMD) +
516 numStoreReg * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_STORE_REGISTER_MEM_CMD);
517
518 if(params->uNumAddConBBEnd)
519 {
520 maxSize +=
521 params->uNumAddConBBEnd * m_miItf->MHW_GETSIZE_F(MI_CONDITIONAL_BATCH_BUFFER_END)();
522
523 patchListMaxSize +=
524 params->uNumAddConBBEnd * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_CONDITIONAL_BATCH_BUFFER_END_CMD);
525 }
526 if(params->uNumMiCopy)
527 {
528 maxSize +=
529 params->uNumMiCopy * m_miItf->MHW_GETSIZE_F(MI_COPY_MEM_MEM)();
530
531 patchListMaxSize +=
532 params->uNumMiCopy * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_COPY_MEM_MEM_CMD);
533 }
534 if(params->uNumMiFlush)
535 {
536 maxSize +=
537 params->uNumMiFlush * m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)();
538
539 patchListMaxSize +=
540 params->uNumMiFlush * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_FLUSH_DW_CMD);
541 }
542
543 if (params->bHucDummyStream || params->bPerformHucStreamOut)
544 {
545 uint32_t dummyTimes = params->bPerformHucStreamOut ? 2: 1;
546 for (uint32_t i = 0; i < dummyTimes; i++)
547 {
548 maxSize +=
549 m_hucItf->MHW_GETSIZE_F(HUC_PIPE_MODE_SELECT)() +
550 m_hucItf->MHW_GETSIZE_F(HUC_IMEM_STATE)() +
551 m_hucItf->MHW_GETSIZE_F(HUC_DMEM_STATE)() +
552 m_hucItf->MHW_GETSIZE_F(HUC_VIRTUAL_ADDR_STATE)() +
553 m_hucItf->MHW_GETSIZE_F(HUC_IND_OBJ_BASE_ADDR_STATE)() +
554 m_hucItf->MHW_GETSIZE_F(HUC_STREAM_OBJECT)() +
555 m_hucItf->MHW_GETSIZE_F(HUC_START)() +
556 m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)();
557
558 patchListMaxSize +=
559 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_PIPE_MODE_SELECT_CMD) +
560 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_IMEM_STATE_CMD) +
561 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_DMEM_STATE_CMD) +
562 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_VIRTUAL_ADDR_STATE_CMD) +
563 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_IND_OBJ_BASE_ADDR_STATE_CMD) +
564 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_STREAM_OBJECT_CMD) +
565 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_START_CMD) +
566 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_FLUSH_DW_CMD);
567 }
568 if (params->bPerformHucStreamOut)
569 {
570 maxSize +=
571 m_hucItf->MHW_GETSIZE_F(HUC_PIPE_MODE_SELECT)() +
572 m_hucItf->MHW_GETSIZE_F(HUC_IND_OBJ_BASE_ADDR_STATE)() +
573 m_hucItf->MHW_GETSIZE_F(HUC_STREAM_OBJECT)() +
574 4 * m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)();
575
576 patchListMaxSize +=
577 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_PIPE_MODE_SELECT_CMD) +
578 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_IND_OBJ_BASE_ADDR_STATE_CMD) +
579 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::HUC_STREAM_OBJECT_CMD) +
580 4 * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_FLUSH_DW_CMD);
581 }
582 }
583
584 *commandsSize = maxSize;
585 *patchListSize = patchListMaxSize;
586
587 return MOS_STATUS_SUCCESS;
588 }
589
590 MOS_STATUS CodechalHwInterfaceNext::GetMfxPrimitiveCommandsDataSize(
591 uint32_t mode,
592 uint32_t *commandsSize,
593 uint32_t *patchListSize,
594 bool modeSpecific)
595 {
596 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
597
598 CODEC_HW_FUNCTION_ENTER;
599
600 uint32_t cpCmdsize = 0;
601 uint32_t cpPatchListSize = 0;
602
603 if (m_mfxItf)
604 {
605 CODEC_HW_CHK_STATUS_RETURN(m_mfxItf->GetMfxPrimitiveCommandsDataSize(
606 mode, (uint32_t*)commandsSize, (uint32_t*)patchListSize, modeSpecific ? true : false));
607
608 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
609 }
610
611 *commandsSize += (uint32_t)cpCmdsize;
612 *patchListSize += (uint32_t)cpPatchListSize;
613
614 return eStatus;
615 }
616
617 MOS_STATUS CodechalHwInterfaceNext::GetHcpPrimitiveCommandSize(
618 uint32_t mode,
619 uint32_t *commandsSize,
620 uint32_t *patchListSize,
621 bool modeSpecific)
622 {
623 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
624
625 CODEC_HW_FUNCTION_ENTER;
626
627 uint32_t standard = CodecHal_GetStandardFromMode(mode);
628
629 uint32_t hcpCommandsSize = 0;
630 uint32_t hcpPatchListSize = 0;
631 uint32_t cpCmdsize = 0;
632 uint32_t cpPatchListSize = 0;
633
634 if (m_hcpItf && (standard == CODECHAL_HEVC || standard == CODECHAL_VP9))
635 {
636 CODEC_HW_CHK_STATUS_RETURN(m_hcpItf->GetHcpPrimitiveCommandSize(
637 mode, &hcpCommandsSize, &hcpPatchListSize, modeSpecific ? true : false));
638
639 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
640 }
641
642 *commandsSize = hcpCommandsSize + cpCmdsize;
643 *patchListSize = hcpPatchListSize + cpPatchListSize;
644
645 return eStatus;
646 }
647
648 MOS_STATUS CodechalHwInterfaceNext::GetVvcpStateCommandSize(
649 uint32_t mode,
650 uint32_t *commandsSize,
651 uint32_t *patchListSize,
652 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
653 {
654 CODEC_HW_FUNCTION_ENTER;
655
656 //calculate VVCP related commands size
657 uint32_t vvcpCommandsSize = 0;
658 uint32_t vvcpPatchListSize = 0;
659 uint32_t cpCmdsize = 0;
660 uint32_t cpPatchListSize = 0;
661
662 if (m_vvcpItf)
663 {
664 CODEC_HW_CHK_STATUS_RETURN(m_vvcpItf->GetVvcpStateCmdSize(
665 (uint32_t *)&vvcpCommandsSize,
666 (uint32_t *)&vvcpPatchListSize,
667 params));
668 }
669
670 if (m_cpInterface)
671 {
672 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
673 }
674
675 //Calc final command size
676 *commandsSize = vvcpCommandsSize + cpCmdsize;
677 *patchListSize = vvcpPatchListSize + cpPatchListSize;
678
679 return MOS_STATUS_SUCCESS;
680 }
681
682 MOS_STATUS CodechalHwInterfaceNext::GetVvcpSliceLvlCmdSize(uint32_t *sliceLvlCmdSize)
683 {
684 CODEC_HW_FUNCTION_ENTER;
685 if (m_vvcpItf)
686 {
687 CODEC_HW_CHK_STATUS_RETURN(m_vvcpItf->GetVvcpSliceLvlCmdSize(sliceLvlCmdSize));
688 }
689 return MOS_STATUS_SUCCESS;
690 }
691
692 MOS_STATUS CodechalHwInterfaceNext::GetVvcpPrimitiveCommandSize(
693 uint32_t mode,
694 uint32_t *sliceCommandsSize,
695 uint32_t *slicePatchListSize,
696 uint32_t *tileCommandsSize,
697 uint32_t *tilePatchListSize)
698 {
699 CODEC_HW_FUNCTION_ENTER;
700
701 //calculate VVCP related commands size
702 uint32_t vvcpSliceCommandsSize = 0;
703 uint32_t vvcpSlicePatchListSize = 0;
704 uint32_t vvcpTileCommandsSize = 0;
705 uint32_t vvcpTilePatchListSize = 0;
706 uint32_t cpCmdsize = 0;
707 uint32_t cpPatchListSize = 0;
708
709 if (m_vvcpItf)
710 {
711 CODEC_HW_CHK_STATUS_RETURN(m_vvcpItf->GetVvcpPrimitiveCmdSize(
712 (uint32_t *)&vvcpSliceCommandsSize,
713 (uint32_t *)&vvcpSlicePatchListSize,
714 (uint32_t *)&vvcpTileCommandsSize,
715 (uint32_t *)&vvcpTilePatchListSize));
716 }
717
718 if (m_cpInterface)
719 {
720 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
721 }
722
723 //Calc final command size
724 *sliceCommandsSize = vvcpSliceCommandsSize + cpCmdsize;
725 *slicePatchListSize = vvcpSlicePatchListSize + cpPatchListSize;
726 *tileCommandsSize = vvcpTileCommandsSize;
727 *tilePatchListSize = vvcpTilePatchListSize;
728
729 return MOS_STATUS_SUCCESS;
730 }
731
732 MOS_STATUS CodechalHwInterfaceNext::AddHucDummyStreamOut(
733 PMOS_COMMAND_BUFFER cmdBuffer)
734 {
735 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
736
737 if (!MEDIA_IS_WA(m_waTable, WaHucStreamoutEnable))
738 {
739 return eStatus;
740 }
741
742 CODEC_HW_FUNCTION_ENTER;
743
744 CODEC_HW_CHK_NULL_RETURN(cmdBuffer);
745 CODEC_HW_CHK_NULL_RETURN(m_miItf);
746
747 if (Mos_ResourceIsNull(&m_dummyStreamOut))
748 {
749 MOS_LOCK_PARAMS lockFlags;
750 uint8_t* data;
751 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
752
753 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
754 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
755 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
756 allocParamsForBufferLinear.Format = Format_Buffer;
757
758 m_dmemBufSize = MHW_CACHELINE_SIZE;
759
760 allocParamsForBufferLinear.dwBytes = m_dmemBufSize;
761 allocParamsForBufferLinear.pBufName = "HucDmemBufferDummy";
762 CODEC_HW_CHK_STATUS_RETURN((MOS_STATUS)m_osInterface->pfnAllocateResource(
763 m_osInterface,
764 &allocParamsForBufferLinear,
765 &m_hucDmemDummy));
766 // set lock flag to WRITE_ONLY
767 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
768 lockFlags.WriteOnly = 1;
769 data =
770 (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, &m_hucDmemDummy, &lockFlags);
771 CODEC_HW_CHK_NULL_RETURN(data);
772 MOS_ZeroMemory(data, m_dmemBufSize);
773 *data = 8;
774 m_osInterface->pfnUnlockResource(m_osInterface, &m_hucDmemDummy);
775
776 allocParamsForBufferLinear.dwBytes = CODECHAL_CACHELINE_SIZE;
777
778 allocParamsForBufferLinear.pBufName = "HucDummyStreamInBuffer";
779 CODEC_HW_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
780 m_osInterface,
781 &allocParamsForBufferLinear,
782 &m_dummyStreamIn));
783 allocParamsForBufferLinear.pBufName = "HucDummyStreamOutBuffer";
784 CODEC_HW_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
785 m_osInterface,
786 &allocParamsForBufferLinear,
787 &m_dummyStreamOut));
788 }
789
790 auto &flushDwParams = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
791 flushDwParams = {};
792 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
793
794 // pipe mode select
795 auto &pipeModeSelectParams = m_hucItf->MHW_GETPAR_F(HUC_PIPE_MODE_SELECT)();
796 pipeModeSelectParams = {};
797
798 pipeModeSelectParams.mediaSoftResetCounterValue = 2400;
799
800 // pass bit-stream buffer by Ind Obj Addr command. Set size to 1 for dummy stream
801 auto &indObjParams = m_hucItf->MHW_GETPAR_F(HUC_IND_OBJ_BASE_ADDR_STATE)();
802 indObjParams = {};
803 indObjParams.DataBuffer = &m_dummyStreamIn;
804 indObjParams.DataSize = 1;
805 indObjParams.StreamOutObjectBuffer = &m_dummyStreamOut;
806 indObjParams.StreamOutObjectSize = 1;
807
808 // set stream object with stream out enabled
809 auto &streamObjParams = m_hucItf->MHW_GETPAR_F(HUC_STREAM_OBJECT)();
810 streamObjParams = {};
811 streamObjParams.IndirectStreamInDataLength = 1;
812 streamObjParams.IndirectStreamInStartAddress = 0;
813 streamObjParams.HucProcessing = true;
814 streamObjParams.IndirectStreamOutStartAddress = 0;
815 streamObjParams.StreamOut = 1;
816
817 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
818
819 auto &imemParams = m_hucItf->MHW_GETPAR_F(HUC_IMEM_STATE)();
820 imemParams = {};
821 imemParams.kernelDescriptor = VDBOX_HUC_VDENC_BRC_INIT_KERNEL_DESCRIPTOR;
822
823 // set HuC DMEM param
824 auto &dmemParams = m_hucItf->MHW_GETPAR_F(HUC_DMEM_STATE)();
825 dmemParams = {};
826 dmemParams.hucDataSource = &m_hucDmemDummy;
827 dmemParams.dataLength = m_dmemBufSize;
828 dmemParams.dmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
829
830 auto &virtualAddrParams = m_hucItf->MHW_GETPAR_F(HUC_VIRTUAL_ADDR_STATE)();
831 virtualAddrParams = {};
832 virtualAddrParams.regionParams[0].presRegion = &m_dummyStreamOut;
833
834 streamObjParams.HucProcessing = true;
835 streamObjParams.HucBitstreamEnable = 1;
836
837 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_IMEM_STATE)(cmdBuffer));
838 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_PIPE_MODE_SELECT)(cmdBuffer));
839 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_DMEM_STATE)(cmdBuffer));
840 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_VIRTUAL_ADDR_STATE)(cmdBuffer));
841 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_IND_OBJ_BASE_ADDR_STATE)(cmdBuffer));
842 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_STREAM_OBJECT)(cmdBuffer));
843 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_START)(cmdBuffer));
844
845 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
846
847 return eStatus;
848 }
849
850 MOS_STATUS CodechalHwInterfaceNext::PerformHucStreamOut(
851 CodechalHucStreamoutParams *hucStreamOutParams,
852 PMOS_COMMAND_BUFFER cmdBuffer)
853 {
854 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
855
856 CODEC_HW_FUNCTION_ENTER;
857 CODEC_HW_CHK_NULL_RETURN(cmdBuffer);
858
859 if (MEDIA_IS_SKU(m_skuTable, FtrEnableMediaKernels) && MEDIA_IS_WA(m_waTable, WaHucStreamoutEnable))
860 {
861 CODEC_HW_CHK_STATUS_RETURN(AddHucDummyStreamOut(cmdBuffer));
862 }
863
864 // pipe mode select
865 auto &pipeModeSelectParams = m_hucItf->MHW_GETPAR_F(HUC_PIPE_MODE_SELECT)();
866 pipeModeSelectParams = {};
867 pipeModeSelectParams.mode = hucStreamOutParams->mode;
868 pipeModeSelectParams.mediaSoftResetCounterValue = 2400;
869 pipeModeSelectParams.streamOutEnabled = true;
870 if (hucStreamOutParams->segmentInfo == nullptr && m_osInterface->osCpInterface->IsCpEnabled())
871 {
872 // Disable protection control setting in huc drm
873 pipeModeSelectParams.disableProtectionSetting = true;
874 }
875
876 // Enlarge the stream in/out data size to avoid upper bound hit assert in HuC
877 hucStreamOutParams->dataSize += hucStreamOutParams->inputRelativeOffset;
878 hucStreamOutParams->streamOutObjectSize += hucStreamOutParams->outputRelativeOffset;
879
880 // pass bit-stream buffer by Ind Obj Addr command
881 auto &indObjParams = m_hucItf->MHW_GETPAR_F(HUC_IND_OBJ_BASE_ADDR_STATE)();
882 indObjParams = {};
883 indObjParams.DataBuffer = hucStreamOutParams->dataBuffer;
884 indObjParams.DataSize = MOS_ALIGN_CEIL(hucStreamOutParams->dataSize, MHW_PAGE_SIZE);
885 indObjParams.DataOffset = hucStreamOutParams->dataOffset;
886 indObjParams.StreamOutObjectBuffer = hucStreamOutParams->streamOutObjectBuffer;
887 indObjParams.StreamOutObjectSize = MOS_ALIGN_CEIL(hucStreamOutParams->streamOutObjectSize, MHW_PAGE_SIZE);
888 indObjParams.StreamOutObjectOffset = hucStreamOutParams->streamOutObjectOffset;
889
890 // set stream object with stream out enabled
891 auto &streamObjParams = m_hucItf->MHW_GETPAR_F(HUC_STREAM_OBJECT)();
892 streamObjParams = {};
893 streamObjParams.IndirectStreamInDataLength = hucStreamOutParams->indStreamInLength;
894 streamObjParams.IndirectStreamInStartAddress = hucStreamOutParams->inputRelativeOffset;
895 streamObjParams.IndirectStreamOutStartAddress = hucStreamOutParams->outputRelativeOffset;
896 streamObjParams.HucProcessing = true;
897 streamObjParams.HucBitstreamEnable = true;
898 streamObjParams.StreamOut = true;
899
900 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_PIPE_MODE_SELECT)(cmdBuffer));
901 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_IND_OBJ_BASE_ADDR_STATE)(cmdBuffer));
902 CODEC_HW_CHK_STATUS_RETURN(m_hucItf->MHW_ADDCMD_F(HUC_STREAM_OBJECT)(cmdBuffer));
903
904 // This flag is always false if huc fw is not loaded.
905 if (MEDIA_IS_SKU(m_skuTable, FtrEnableMediaKernels) &&
906 MEDIA_IS_WA(m_waTable, WaHucStreamoutOnlyDisable))
907 {
908 CODEC_HW_CHK_STATUS_RETURN(AddHucDummyStreamOut(cmdBuffer));
909 }
910
911 return eStatus;
912 }
913
914 MOS_STATUS CodechalHwInterfaceNext::ReadHcpStatus(
915 MHW_VDBOX_NODE_IND vdboxIndex,
916 const EncodeStatusReadParams &params,
917 PMOS_COMMAND_BUFFER cmdBuffer)
918 {
919 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
920
921 CODEC_HW_FUNCTION_ENTER;;
922
923 CODEC_HW_CHK_NULL_RETURN(cmdBuffer);
924
925 CODEC_HW_CHK_COND_RETURN((vdboxIndex > GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
926
927 auto &par1 = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
928 par1 = {};
929 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
930
931 auto mmioRegisters = m_hcpItf->GetMmioRegisters(vdboxIndex);
932
933 auto &par2 = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
934 par2 = {};
935 par2.presStoreBuffer = params.resBitstreamByteCountPerFrame;
936 par2.dwOffset = params.bitstreamByteCountPerFrameOffset;
937 par2.dwRegister = mmioRegisters->hcpEncBitstreamBytecountFrameRegOffset;
938 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
939
940 auto &par3 = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
941 par3 = {};
942 par3.presStoreBuffer = params.resBitstreamSyntaxElementOnlyBitCount;
943 par3.dwOffset = params.bitstreamSyntaxElementOnlyBitCountOffset;
944 par3.dwRegister = mmioRegisters->hcpEncBitstreamSeBitcountFrameRegOffset;
945 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
946
947 auto &par4 = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
948 par4 = {};
949 par4.presStoreBuffer = params.resQpStatusCount;
950 par4.dwOffset = params.qpStatusCountOffset;
951 par4.dwRegister = mmioRegisters->hcpEncQpStatusCountRegOffset;
952 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
953
954 return eStatus;
955 }
956
957 MOS_STATUS CodechalHwInterfaceNext::ReadImageStatusForHcp(
958 MHW_VDBOX_NODE_IND vdboxIndex,
959 const EncodeStatusReadParams &params,
960 PMOS_COMMAND_BUFFER cmdBuffer)
961 {
962 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
963
964 CODEC_HW_FUNCTION_ENTER;
965
966 CODEC_HW_CHK_NULL_RETURN(cmdBuffer);
967
968 CODEC_HW_CHK_COND_RETURN((vdboxIndex > GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
969
970 auto mmioRegisters = m_hcpItf->GetMmioRegisters(vdboxIndex);
971
972 auto &par1 = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
973 par1 = {};
974 par1.presStoreBuffer = params.resImageStatusMask;
975 par1.dwOffset = params.imageStatusMaskOffset;
976 par1.dwRegister = mmioRegisters->hcpEncImageStatusMaskRegOffset;
977 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
978
979 auto &par2 = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
980 par2 = {};
981 par2.presStoreBuffer = params.resImageStatusCtrl;
982 par2.dwOffset = params.imageStatusCtrlOffset;
983 par2.dwRegister = mmioRegisters->hcpEncImageStatusCtrlRegOffset;
984 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
985
986 auto &par3 = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
987 par3 = {};
988 CODEC_HW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
989
990 return eStatus;
991 }
992
993 MOS_STATUS CodechalHwInterfaceNext::SetRowstoreCachingOffsets(
994 PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
995 {
996 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
997
998 CODEC_HW_FUNCTION_ENTER;
999
1000 if (m_vdencItf)
1001 {
1002 mhw::vdbox::vdenc::RowStorePar par = {};
1003 if (rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AVC)
1004 {
1005 par.mode = mhw::vdbox::vdenc::RowStorePar::AVC;
1006 par.isField = !rowstoreParams->bIsFrame;
1007 }
1008 else if (rowstoreParams->Mode == CODECHAL_ENCODE_MODE_VP9)
1009 {
1010 par.mode = mhw::vdbox::vdenc::RowStorePar::VP9;
1011 par.bitDepth = mhw::vdbox::vdenc::RowStorePar::DEPTH_8;
1012 if (rowstoreParams->ucBitDepthMinus8 == 1 || rowstoreParams->ucBitDepthMinus8 == 2)
1013 {
1014 par.bitDepth = mhw::vdbox::vdenc::RowStorePar::DEPTH_10;
1015 }
1016 else if (rowstoreParams->ucBitDepthMinus8 > 2)
1017 {
1018 par.bitDepth = mhw::vdbox::vdenc::RowStorePar::DEPTH_12;
1019 }
1020 par.frameWidth = rowstoreParams->dwPicWidth;
1021 switch (rowstoreParams->ucChromaFormat)
1022 {
1023 case HCP_CHROMA_FORMAT_MONOCHROME:
1024 par.format = mhw ::vdbox::vdenc::RowStorePar::MONOCHROME;
1025 break;
1026 case HCP_CHROMA_FORMAT_YUV420:
1027 par.format = mhw ::vdbox::vdenc::RowStorePar::YUV420;
1028 break;
1029 case HCP_CHROMA_FORMAT_YUV422:
1030 par.format = mhw ::vdbox::vdenc::RowStorePar::YUV422;
1031 break;
1032 case HCP_CHROMA_FORMAT_YUV444:
1033 par.format = mhw ::vdbox::vdenc::RowStorePar::YUV444;
1034 break;
1035 }
1036 }
1037 else if (rowstoreParams->Mode == CODECHAL_ENCODE_MODE_HEVC)
1038 {
1039 par.mode = mhw::vdbox::vdenc::RowStorePar::HEVC;
1040 par.bitDepth = mhw::vdbox::vdenc::RowStorePar::DEPTH_8;
1041 if (rowstoreParams->ucBitDepthMinus8 == 1 || rowstoreParams->ucBitDepthMinus8 == 2)
1042 {
1043 par.bitDepth = mhw::vdbox::vdenc::RowStorePar::DEPTH_10;
1044 }
1045 else if (rowstoreParams->ucBitDepthMinus8 > 2)
1046 {
1047 par.bitDepth = mhw::vdbox::vdenc::RowStorePar::DEPTH_12;
1048 }
1049 par.lcuSize = mhw ::vdbox::vdenc::RowStorePar::SIZE_OTHER;
1050 if (rowstoreParams->ucLCUSize == 32)
1051 {
1052 par.lcuSize = mhw ::vdbox::vdenc::RowStorePar::SIZE_32;
1053 }
1054 else if (rowstoreParams->ucLCUSize == 64)
1055 {
1056 par.lcuSize = mhw ::vdbox::vdenc::RowStorePar::SIZE_64;
1057 }
1058 par.frameWidth = rowstoreParams->dwPicWidth;
1059 switch (rowstoreParams->ucChromaFormat)
1060 {
1061 case HCP_CHROMA_FORMAT_MONOCHROME:
1062 par.format = mhw ::vdbox::vdenc::RowStorePar::MONOCHROME;
1063 break;
1064 case HCP_CHROMA_FORMAT_YUV420:
1065 par.format = mhw ::vdbox::vdenc::RowStorePar::YUV420;
1066 break;
1067 case HCP_CHROMA_FORMAT_YUV422:
1068 par.format = mhw ::vdbox::vdenc::RowStorePar::YUV422;
1069 break;
1070 case HCP_CHROMA_FORMAT_YUV444:
1071 par.format = mhw ::vdbox::vdenc::RowStorePar::YUV444;
1072 break;
1073 }
1074 }
1075 else if (rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AV1)
1076 {
1077 par.mode = mhw::vdbox::vdenc::RowStorePar::AV1;
1078 par.frameWidth = rowstoreParams->dwPicWidth;
1079 }
1080 CODEC_HW_CHK_STATUS_RETURN(m_vdencItf->SetRowstoreCachingOffsets(par));
1081 }
1082 if (m_mfxItf)
1083 {
1084 CODEC_HW_CHK_STATUS_RETURN(m_mfxItf->GetRowstoreCachingAddrs(rowstoreParams));
1085 }
1086 if (m_hcpItf)
1087 {
1088 mhw::vdbox::hcp::HcpVdboxRowStorePar rowstoreParamsHCP = {};
1089 rowstoreParamsHCP.Mode = rowstoreParams->Mode;
1090 rowstoreParamsHCP.dwPicWidth = rowstoreParams->dwPicWidth;
1091 rowstoreParamsHCP.ucChromaFormat = rowstoreParams->ucChromaFormat;
1092 rowstoreParamsHCP.ucBitDepthMinus8 = rowstoreParams->ucBitDepthMinus8;
1093 rowstoreParamsHCP.ucLCUSize = rowstoreParams->ucLCUSize;
1094 CODEC_HW_CHK_STATUS_RETURN(m_hcpItf->SetRowstoreCachingOffsets(rowstoreParamsHCP));
1095 }
1096 if (m_avpItf)
1097 {
1098 mhw::vdbox::avp::AvpVdboxRowStorePar rowstoreParamsAVP = {};
1099 rowstoreParamsAVP.picWidth = rowstoreParams->dwPicWidth;
1100 rowstoreParamsAVP.mbaff = rowstoreParams->bMbaff;
1101 rowstoreParamsAVP.mode = rowstoreParams->Mode;
1102 rowstoreParamsAVP.bitDepthMinus8 = rowstoreParams->ucBitDepthMinus8;
1103 rowstoreParamsAVP.chromaFormat = rowstoreParams->ucChromaFormat;
1104 CODEC_HW_CHK_STATUS_RETURN(m_avpItf->GetRowstoreCachingAddrs(rowstoreParamsAVP));
1105 }
1106
1107 if (m_vvcpItf != nullptr)
1108 {
1109 CODEC_HW_CHK_STATUS_RETURN(m_vvcpItf->GetRowstoreCachingAddrs(rowstoreParams));
1110 }
1111
1112 return eStatus;
1113 }
1114
1115 MOS_STATUS CodechalHwInterfaceNext::InitL3CacheSettings()
1116 {
1117 CODEC_HW_FUNCTION_ENTER;
1118
1119 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1120
1121 CODEC_HW_CHK_NULL_RETURN(m_osInterface);
1122
1123 for (uint32_t i = MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC + 1; i < MOS_CODEC_RESOURCE_USAGE_END_CODEC; i++)
1124 {
1125 CODEC_HW_CHK_STATUS_RETURN(CachePolicyGetMemoryObject(
1126 (MOS_HW_RESOURCE_DEF)i));
1127 }
1128
1129 SetCacheabilitySettings(m_cacheabilitySettings);
1130
1131 bool l3CachingEnabled = !m_osInterface->bSimIsActive;
1132
1133 if (m_checkBankCount)
1134 {
1135 CODEC_HW_CHK_NULL_RETURN(m_osInterface);
1136 auto gtSysInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
1137 CODEC_HW_CHK_NULL_RETURN(gtSysInfo);
1138
1139 l3CachingEnabled = (gtSysInfo->L3BankCount != 0 || gtSysInfo->L3CacheSizeInKb != 0);
1140 }
1141
1142 if (l3CachingEnabled)
1143 {
1144 if (m_renderItf)
1145 {
1146 // Get default L3 cache settings
1147 CODEC_HW_CHK_STATUS_RETURN(m_renderItf->EnableL3Caching(nullptr));
1148
1149 #if (_DEBUG || _RELEASE_INTERNAL)
1150 // Override default L3 cache settings
1151 auto l3CacheConfig =
1152 m_renderItf->GetL3CacheConfig();
1153 mhw::render::MHW_RENDER_ENGINE_L3_CACHE_SETTINGS l3Overrides = {};
1154 l3Overrides.dwTcCntlReg =
1155 static_cast<mhw::render::MHW_RENDER_ENGINE_L3_CACHE_CONFIG *>(l3CacheConfig)->dwL3CacheTcCntlReg_Setting;
1156 l3Overrides.dwAllocReg =
1157 static_cast<mhw::render::MHW_RENDER_ENGINE_L3_CACHE_CONFIG *>(l3CacheConfig)->dwL3CacheAllocReg_Setting;
1158 CODEC_HW_CHK_STATUS_RETURN(InitL3ControlUserFeatureSettings(
1159 l3CacheConfig,
1160 &l3Overrides));
1161 CODEC_HW_CHK_STATUS_RETURN(m_renderItf->EnableL3Caching(
1162 &l3Overrides));
1163 #endif // (_DEBUG || _RELEASE_INTERNAL)
1164 }
1165 }
1166
1167 return MOS_STATUS_SUCCESS;
1168 }
1169
1170 #if (_DEBUG || _RELEASE_INTERNAL)
1171 MOS_STATUS CodechalHwInterfaceNext::InitL3ControlUserFeatureSettings(
1172 mhw::render::MHW_RENDER_ENGINE_L3_CACHE_CONFIG *l3CacheConfig,
1173 mhw::render::MHW_RENDER_ENGINE_L3_CACHE_SETTINGS *l3Overrides)
1174 {
1175 CODEC_HW_FUNCTION_ENTER;
1176
1177 CODEC_HW_CHK_NULL_RETURN(l3CacheConfig);
1178 CODEC_HW_CHK_NULL_RETURN(l3Overrides);
1179
1180 MediaUserSetting::Value outValue;
1181 ReadUserSettingForDebug(
1182 m_userSettingPtr,
1183 outValue,
1184 "Encode L3CNTLREG Override",
1185 MediaUserSetting::Group::Device,
1186 l3CacheConfig->dwL3CacheCntlReg_Setting,
1187 true);
1188 l3Overrides->dwCntlReg = outValue.Get<uint32_t>();
1189
1190 ReadUserSettingForDebug(
1191 m_userSettingPtr,
1192 outValue,
1193 "Encode L3CNTLREG2 Override",
1194 MediaUserSetting::Group::Device,
1195 l3CacheConfig->dwL3CacheCntlReg2_Setting,
1196 true);
1197 l3Overrides->dwCntlReg2 = outValue.Get<uint32_t>();
1198
1199 ReadUserSettingForDebug(
1200 m_userSettingPtr,
1201 outValue,
1202 "Encode L3CNTLREG3 Override",
1203 MediaUserSetting::Group::Device,
1204 l3CacheConfig->dwL3CacheCntlReg3_Setting,
1205 true);
1206 l3Overrides->dwCntlReg3 = outValue.Get<uint32_t>();
1207
1208 ReadUserSettingForDebug(
1209 m_userSettingPtr,
1210 outValue,
1211 "Encode L3SQCREG1 Override",
1212 MediaUserSetting::Group::Device,
1213 l3CacheConfig->dwL3CacheSqcReg1_Setting,
1214 true);
1215 l3Overrides->dwSqcReg1 = outValue.Get<uint32_t>();
1216
1217 ReadUserSettingForDebug(
1218 m_userSettingPtr,
1219 outValue,
1220 "Encode L3SQCREG4 Override",
1221 MediaUserSetting::Group::Device,
1222 l3CacheConfig->dwL3CacheSqcReg4_Setting,
1223 true);
1224 l3Overrides->dwSqcReg4 = outValue.Get<uint32_t>();
1225
1226 ReadUserSettingForDebug(
1227 m_userSettingPtr,
1228 outValue,
1229 "L3LRA1RegOverride",
1230 MediaUserSetting::Group::Device,
1231 l3CacheConfig->dwL3LRA1Reg_Setting,
1232 true);
1233 l3Overrides->dwLra1Reg = outValue.Get<uint32_t>();
1234
1235 return MOS_STATUS_SUCCESS;
1236 }
1237 #endif // _DEBUG || _RELEASE_INTERNAL
1238
1239 MmioRegistersMfx *CodechalHwInterfaceNext::SelectVdAndGetMmioReg(
1240 MHW_VDBOX_NODE_IND index,
1241 PMOS_COMMAND_BUFFER pCmdBuffer)
1242 {
1243 if (m_getVdboxNodeByUMD)
1244 {
1245 pCmdBuffer->iVdboxNodeIndex = m_osInterface->pfnGetVdboxNodeId(m_osInterface, pCmdBuffer);
1246 switch (pCmdBuffer->iVdboxNodeIndex)
1247 {
1248 case MOS_VDBOX_NODE_1:
1249 index = MHW_VDBOX_NODE_1;
1250 break;
1251 case MOS_VDBOX_NODE_2:
1252 index = MHW_VDBOX_NODE_2;
1253 break;
1254 case MOS_VDBOX_NODE_INVALID:
1255 // That's a legal case meaning that we were not assigned with per-bb index because
1256 // balancing algorithm can't work (forcedly diabled or miss kernel support).
1257 // If that's the case we just proceed with the further static context assignment.
1258 break;
1259 default:
1260 // That's the case when MHW and MOS enumerations mismatch. We again proceed with the
1261 // best effort (static context assignment, but provide debug note).
1262 MHW_ASSERTMESSAGE("MOS and MHW VDBOX enumerations mismatch! Adjust HW description!");
1263 break;
1264 }
1265 }
1266
1267 return m_vdencItf->GetMmioRegisters(index);
1268 }