Debian Codegraph @

media_softlet/agnostic/common/hw/vdbox/mhw_vdbox_mfx_impl.h

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 mhw_vdbox_mfx_impl.h
24 //! \brief MHW VDBOX MFX interface common base
25 //! \details
26 //!
27 #ifndef __MHW_VDBOX_MFX_IMPL_H__
28 #define __MHW_VDBOX_MFX_IMPL_H__
29
30 #include "mhw_vdbox_mfx_itf.h"
31 #include "mhw_impl.h"
32 #include "mhw_mi_impl.h"
33
34 #ifdef IGFX_MFX_INTERFACE_EXT_SUPPORT
35 #include "mhw_vdbox_mfx_hwcmd_ext.h"
36 #endif
37
38 #define AVC_MPR_ROWSTORE_BASEADDRESS 256
39 #define AVC_MPR_ROWSTORE_BASEADDRESS_MBAFF 512
40 #define AVC_IP_ROWSTORE_BASEADDRESS 512
41 #define AVC_IP_ROWSTORE_BASEADDRESS_MBAFF 1024
42 #define AVC_VLF_ROWSTORE_BASEADDRESS 768
43 #define AVC_VLF_ROWSTORE_BASEADDRESS_MBAFF 1280
44 #define VP8_IP_ROWSTORE_BASEADDRESS 256
45 #define VP8_VLF_ROWSTORE_BASEADDRESS 512
46
47 namespace mhw
48 {
49 namespace vdbox
50 {
51 namespace mfx
52 {
53
54 template<typename cmd_t>
55 class Impl : public Itf, public mhw::Impl
56 {
57 _MFX_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
58
59 public:
60 MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override
61 {
62 MHW_FUNCTION_ENTER;
63
64 MHW_CHK_NULL_RETURN(settings);
65
66 size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS);
67
68 return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size);
69 }
70
71 MOS_STATUS GetRowstoreCachingAddrs(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) override
72 {
73 MHW_FUNCTION_ENTER;
74
75 MHW_MI_CHK_NULL(rowstoreParams);
76
77 bool avc = IsAvcMode(rowstoreParams);
78 bool vp8 = IsVp8Mode(rowstoreParams);
79 bool widthLE4K = IsPictureWidthLE4K(rowstoreParams);
80 bool mbaffOrField = IsMbaffOrField(rowstoreParams);
81
82 //BSD row store cache
83 m_bsdMpcRowstoreCache.enabled = m_bsdMpcRowstoreCache.supported && widthLE4K && (avc || vp8);
84 m_bsdMpcRowstoreCache.dwAddress = m_bsdMpcRowstoreCache.enabled ? BSDMPCROWSTORE_BASEADDRESS : 0;
85
86 //MPR row store cache
87 m_mprRowstoreCache.enabled = m_mprRowstoreCache.supported && widthLE4K && avc;
88 m_mprRowstoreCache.dwAddress = m_mprRowstoreCache.enabled ? (mbaffOrField ? AVC_MPR_ROWSTORE_BASEADDRESS_MBAFF : AVC_MPR_ROWSTORE_BASEADDRESS) : 0;
89
90 //Intra Prediction row store cache
91 m_intraRowstoreCache.enabled = m_intraRowstoreCache.supported && widthLE4K && (avc || vp8);
92 if (m_intraRowstoreCache.enabled)
93 {
94 m_intraRowstoreCache.dwAddress = avc ? (mbaffOrField ? AVC_IP_ROWSTORE_BASEADDRESS_MBAFF
95 : AVC_IP_ROWSTORE_BASEADDRESS)
96 : VP8_IP_ROWSTORE_BASEADDRESS;
97 }
98 else
99 {
100 m_intraRowstoreCache.dwAddress = 0;
101 }
102
103 //VLF row store cache - platform-aware configuration
104 ConfigureVlfRowstoreCache(rowstoreParams);
105
106 return MOS_STATUS_SUCCESS;
107 }
108
109 virtual void SetCacheabilitySettings()
110 {
111 MHW_FUNCTION_ENTER;
112 m_preDeblockingMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject(
113 MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC,
114 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
115 m_postDeblockingMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject(
116 MOS_CODEC_RESOURCE_USAGE_POST_DEBLOCKING_CODEC,
117 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
118 m_OriginalUncompressedPictureSourceMemoryCtrl.Value =
119 m_osItf->pfnCachePolicyGetMemoryObject(
120 MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE,
121 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
122 m_streamoutDataDestinationMemoryCtrl.Value =
123 m_osItf->pfnCachePolicyGetMemoryObject(
124 MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC,
125 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
126 m_intraRowStoreScratchBufferMemoryCtrl.Value =
127 m_osItf->pfnCachePolicyGetMemoryObject(
128 MOS_CODEC_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC,
129 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
130 m_deblockingFilterRowStoreScratchMemoryCtrl.Value =
131 m_osItf->pfnCachePolicyGetMemoryObject(
132 MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC,
133 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
134 m_referncePictureMemoryObjectControlStateCtrl.Value =
135 m_osItf->pfnCachePolicyGetMemoryObject(
136 MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC,
137 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
138 m_referncePictureMemoryObjectControlStateCtrlDecode.Value =
139 m_osItf->pfnCachePolicyGetMemoryObject(
140 MOS_HW_RESOURCE_USAGE_DECODE_INPUT_REFERENCE,
141 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
142 m_referncePictureMemoryObjectControlStateCtrlEncode.Value =
143 m_osItf->pfnCachePolicyGetMemoryObject(
144 MOS_HW_RESOURCE_USAGE_ENCODE_INPUT_RECON,
145 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
146 m_macroblockIldbStreamoutBufferCtrl.Value =
147 m_osItf->pfnCachePolicyGetMemoryObject(
148 MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC,
149 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
150 m_secondMacroblockIldbStreamoutBufferCtrl.Value =
151 m_osItf->pfnCachePolicyGetMemoryObject(
152 MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC,
153 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
154 m_slicesizeStreamoutDataDestinationCtrl.Value =
155 m_osItf->pfnCachePolicyGetMemoryObject(
156 MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC,
157 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
158 m_mfxIndirectBitstreamCtrl.Value =
159 m_osItf->pfnCachePolicyGetMemoryObject(
160 MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE,
161 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
162 m_mfdIndirectItCoeffCtrl.Value =
163 m_osItf->pfnCachePolicyGetMemoryObject(
164 MOS_CODEC_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE,
165 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
166 m_mfxIndirectMvCtrl.Value =
167 m_osItf->pfnCachePolicyGetMemoryObject(
168 MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC,
169 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
170 m_mfcIndirectPakBseCtrl.Value =
171 m_osItf->pfnCachePolicyGetMemoryObject(
172 MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC,
173 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
174 m_bsdMpcRowStoreScratchBufferCtrl.Value =
175 m_osItf->pfnCachePolicyGetMemoryObject(
176 MOS_CODEC_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC,
177 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
178 m_mprRowStoreScratchBufferCtrl.Value =
179 m_osItf->pfnCachePolicyGetMemoryObject(
180 MOS_CODEC_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC,
181 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
182 m_bitplaneReadBufferIndexToMemoryCtrl.Value =
183 m_osItf->pfnCachePolicyGetMemoryObject(
184 MOS_CODEC_RESOURCE_USAGE_BITPLANE_READ_CODEC,
185 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
186
187 m_directMvBufferForWriteCtrl.Value =
188 m_osItf->pfnCachePolicyGetMemoryObject(
189 MOS_CODEC_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC,
190 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue;
191
192 }
193
194 bool IsRowStoreCachingSupported() override
195 {
196 return m_rowstoreCachingSupported;
197 }
198
199 bool IsMprRowstoreCacheEnabled() override
200 {
201 return m_mprRowstoreCache.enabled;
202 }
203
204 uint32_t GetViewOrder(
205 MFD_AVC_DPB_STATE_PAR params,
206 uint32_t currIdx,
207 uint32_t list)
208 {
209 MHW_FUNCTION_ENTER;
210
211 auto avcPicParams = params.pAvcPicParams;
212 auto mvcExtPicParams = params.pMvcExtPicParams;
213 auto avcRefList = params.ppAvcRefList;
214
215 // No need to check if bottom field since only progressive is supported for mvc clips.
216 int32_t currPOC = avcPicParams->CurrFieldOrderCnt[0];
217 uint32_t numRefs = (list == LIST_0) ? mvcExtPicParams->NumInterViewRefsL0 : mvcExtPicParams->NumInterViewRefsL1;
218 uint32_t viewOrder = 0xF;
219 uint32_t currRef = params.pAvcPicIdx[currIdx].ucPicIdx;
220
221 if (params.pAvcPicIdx[currIdx].bValid &&
222 avcRefList[currRef]->bUsedAsInterViewRef &&
223 (currPOC == avcRefList[currRef]->iFieldOrderCnt[0]))
224 {
225 for (uint32_t i = 0; i < numRefs; i++)
226 {
227 if (mvcExtPicParams->ViewIDList[currIdx] == mvcExtPicParams->InterViewRefList[list][i])
228 {
229 viewOrder = mvcExtPicParams->ViewIDList[currIdx];
230 break;
231 }
232 }
233 }
234
235 return viewOrder;
236 }
237
238 bool IsDeblockingFilterRowstoreCacheEnabled() override
239 {
240 return m_deblockingFilterRowstoreCache.enabled;
241 }
242
243 bool IsIntraRowstoreCacheEnabled() override
244 {
245 return m_intraRowstoreCache.enabled;
246 }
247
248 bool IsBsdMpcRowstoreCacheEnabled() override
249 {
250 return m_bsdMpcRowstoreCache.enabled;
251 }
252
253 MHW_VDBOX_NODE_IND GetMaxVdboxIndex() override
254 {
255 return MEDIA_IS_SKU(m_osItf->pfnGetSkuTable(m_osItf), FtrVcs2) ? MHW_VDBOX_NODE_2 : MHW_VDBOX_NODE_1;
256 }
257
258 //!
259 //! \brief Get the vdbox num
260 //!
261 //! \return bool
262 //! vdbox num got
263 //!
264 uint8_t GetNumVdbox() override
265 {
266 MHW_FUNCTION_ENTER;
267
268 MEDIA_ENGINE_INFO mediaEngineInfo = {};
269 m_osItf->pfnGetMediaEngineInfo(m_osItf, mediaEngineInfo);
270
271 m_numVdbox = (uint8_t)(mediaEngineInfo.VDBoxInfo.NumberOfVDBoxEnabled);
272
273 return m_numVdbox;
274 }
275
276 #if (_DEBUG || _RELEASE_INTERNAL)
277 MOS_STATUS CheckScalabilityOverrideValidity()
278 {
279 MHW_FUNCTION_ENTER;
280
281 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
282
283 MEDIA_SYSTEM_INFO *gtSystemInfo;
284 uint32_t forceVdbox;
285 bool scalableDecMode;
286 bool useVD1, useVD2, useVD3, useVD4;
287
288 MHW_MI_CHK_NULL(m_osItf);
289 scalableDecMode = m_osItf->bHcpDecScalabilityMode ? true : false;
290 forceVdbox = m_osItf->eForceVdbox;
291 gtSystemInfo = m_osItf->pfnGetGtSystemInfo(m_osItf);
292 MHW_MI_CHK_NULL(gtSystemInfo);
293
294 if (forceVdbox != MOS_FORCE_VDBOX_NONE &&
295 forceVdbox != MOS_FORCE_VDBOX_1 &&
296 forceVdbox != MOS_FORCE_VDBOX_2 &&
297 // 2 pipes, VDBOX1-BE1, VDBOX2-BE2
298 forceVdbox != MOS_FORCE_VDBOX_1_1_2 &&
299 forceVdbox != MOS_FORCE_VDBOX_2_1_2)
300 {
301 eStatus = MOS_STATUS_INVALID_PARAMETER;
302 MHW_ASSERTMESSAGE("user feature forceVdbox value is invalid.");
303 return eStatus;
304 }
305
306 if (!scalableDecMode &&
307 (forceVdbox == MOS_FORCE_VDBOX_1_1_2 ||
308 forceVdbox == MOS_FORCE_VDBOX_2_1_2))
309 {
310 eStatus = MOS_STATUS_INVALID_PARAMETER;
311 MHW_ASSERTMESSAGE("user feature forceVdbox valude does not consistent with regkey scalability mode.");
312 return eStatus;
313 }
314
315 if (scalableDecMode && !m_scalabilitySupported)
316 {
317 eStatus = MOS_STATUS_INVALID_PARAMETER;
318 MHW_ASSERTMESSAGE("user feature scalability mode is not allowed on current platform!");
319 return eStatus;
320 }
321
322 useVD1 = useVD2 = false;
323 if (forceVdbox == 0)
324 {
325 useVD1 = true;
326 }
327 else
328 {
329 MHW_VDBOX_IS_VDBOX_SPECIFIED(forceVdbox, MOS_FORCE_VDBOX_1, MOS_FORCEVDBOX_VDBOXID_BITSNUM, MOS_FORCEVDBOX_MASK, useVD1);
330 MHW_VDBOX_IS_VDBOX_SPECIFIED(forceVdbox, MOS_FORCE_VDBOX_2, MOS_FORCEVDBOX_VDBOXID_BITSNUM, MOS_FORCEVDBOX_MASK, useVD2);
331 }
332
333 if (!gtSystemInfo->VDBoxInfo.IsValid ||
334 (useVD1 && !gtSystemInfo->VDBoxInfo.Instances.Bits.VDBox0Enabled) ||
335 (useVD2 && !gtSystemInfo->VDBoxInfo.Instances.Bits.VDBox1Enabled))
336 {
337 eStatus = MOS_STATUS_INVALID_PARAMETER;
338 MHW_ASSERTMESSAGE("the forced VDBOX is not enabled in current platform.");
339 return eStatus;
340 }
341
342 return eStatus;
343 }
344 #endif
345
346 MOS_STATUS FindGpuNodeToUse(PMHW_VDBOX_GPUNODE_LIMIT gpuNodeLimit) override
347 {
348 MHW_FUNCTION_ENTER;
349
350 bool setVideoNode = false;
351 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
352
353 MOS_GPU_NODE videoGpuNode = MOS_GPU_NODE_VIDEO;
354
355 if (MOS_VE_MULTINODESCALING_SUPPORTED(m_osItf))
356 {
357 if (GetNumVdbox() == 1)
358 {
359 videoGpuNode = MOS_GPU_NODE_VIDEO;
360 }
361 else
362 {
363 MHW_MI_CHK_STATUS(m_osItf->pfnCreateVideoNodeAssociation(
364 m_osItf,
365 setVideoNode,
366 &videoGpuNode));
367 }
368 }
369
370 #if (_DEBUG || _RELEASE_INTERNAL)
371 if (m_osItf != nullptr && m_osItf->bEnableDbgOvrdInVE &&
372 (!m_osItf->bSupportVirtualEngine || !m_scalabilitySupported))
373 {
374 eStatus = MOS_STATUS_INVALID_PARAMETER;
375 MHW_ASSERTMESSAGE("not support DebugOverrid on current OS or Platform.");
376 return eStatus;
377 }
378
379 if (m_osItf != nullptr && m_osItf->bEnableDbgOvrdInVE)
380 {
381 MHW_MI_CHK_STATUS(CheckScalabilityOverrideValidity());
382 }
383 #endif
384
385 gpuNodeLimit->dwGpuNodeToUse = videoGpuNode;
386
387 return eStatus;
388 }
389
390 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_preDeblockingMemoryCtrl;
391 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_postDeblockingMemoryCtrl;
392 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_OriginalUncompressedPictureSourceMemoryCtrl;
393 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_streamoutDataDestinationMemoryCtrl;
394 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_intraRowStoreScratchBufferMemoryCtrl;
395 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_deblockingFilterRowStoreScratchMemoryCtrl;
396 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrl;
397 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrlDecode;
398 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrlEncode;
399 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_macroblockIldbStreamoutBufferCtrl;
400 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_secondMacroblockIldbStreamoutBufferCtrl;
401 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_slicesizeStreamoutDataDestinationCtrl;
402 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfxIndirectBitstreamCtrl;
403 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfdIndirectItCoeffCtrl;
404 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfxIndirectMvCtrl;
405 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfcIndirectPakBseCtrl;
406 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_bsdMpcRowStoreScratchBufferCtrl;
407 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mprRowStoreScratchBufferCtrl;
408 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_bitplaneReadBufferIndexToMemoryCtrl;
409 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_directMvBufferForWriteCtrl;
410
411 protected:
412 bool IsAvcMode(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) const
413 {
414 return rowstoreParams->Mode == CODECHAL_DECODE_MODE_AVCVLD ||
415 rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AVC;
416 }
417
418 bool IsVp8Mode(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) const
419 {
420 return rowstoreParams->Mode == CODECHAL_DECODE_MODE_VP8VLD ||
421 rowstoreParams->Mode == CODECHAL_ENCODE_MODE_VP8;
422 }
423
424 bool IsPictureWidthLE4K(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) const
425 {
426 return rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_4K;
427 }
428
429 bool IsMbaffOrField(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) const
430 {
431 return rowstoreParams->bMbaff || !rowstoreParams->bIsFrame;
432 }
433
434 virtual bool GetVlfRowstoreCacheMbaffSupport() const
435 {
436 return false; // Base implementation: no MBAFF support for VLF cache
437 }
438
439 void ConfigureVlfRowstoreCache(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
440 {
441 bool avc = IsAvcMode(rowstoreParams);
442 bool vp8 = IsVp8Mode(rowstoreParams);
443 bool widthLE4K = IsPictureWidthLE4K(rowstoreParams);
444 bool mbaffOrField = IsMbaffOrField(rowstoreParams);
445 bool supportMbaff = GetVlfRowstoreCacheMbaffSupport();
446
447 // Enable VLF cache based on platform support
448 if (supportMbaff)
449 {
450 // xe3+ platforms: Enable VLF for AVC or VP8, including MBAFF
451 m_deblockingFilterRowstoreCache.enabled =
452 m_deblockingFilterRowstoreCache.supported && widthLE4K && (avc || vp8);
453 }
454 else
455 {
456 // Base/older platforms: Enable VLF for AVC (non-MBAFF) or VP8
457 m_deblockingFilterRowstoreCache.enabled =
458 m_deblockingFilterRowstoreCache.supported && widthLE4K && ((avc && !mbaffOrField) || vp8);
459 }
460
461 // Configure VLF address based on enablement and codec/format
462 if (m_deblockingFilterRowstoreCache.enabled)
463 {
464 if (avc)
465 {
466 m_deblockingFilterRowstoreCache.dwAddress =
467 mbaffOrField ? AVC_VLF_ROWSTORE_BASEADDRESS_MBAFF : AVC_VLF_ROWSTORE_BASEADDRESS;
468 }
469 else // VP8
470 {
471 m_deblockingFilterRowstoreCache.dwAddress = VP8_VLF_ROWSTORE_BASEADDRESS;
472 }
473 }
474 else
475 {
476 m_deblockingFilterRowstoreCache.dwAddress = 0;
477 }
478 }
479
480 using base_t = Itf;
481 MhwCpInterface *m_cpItf = nullptr;
482 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {};
483
484 Impl(PMOS_INTERFACE osItf, MhwCpInterface *cpItf) : mhw::Impl(osItf)
485 {
486 MHW_FUNCTION_ENTER;
487 m_cpItf = cpItf;
488
489 InitRowstoreUserFeatureSettings();
490 SetCacheabilitySettings();
491 }
492
493 virtual ~Impl()
494 {
495 MHW_FUNCTION_ENTER;
496
497 #if (_DEBUG || _RELEASE_INTERNAL)
498 if (m_intraRowstoreCache.enabled ||
499 m_deblockingFilterRowstoreCache.enabled ||
500 m_bsdMpcRowstoreCache.enabled ||
501 m_mprRowstoreCache.enabled)
502 {
503 // Report rowstore cache usage status to regkey
504 ReportUserSettingForDebug(
505 m_userSettingPtr,
506 __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED,
507 1,
508 MediaUserSetting::Group::Device);
509 }
510 #endif
511
512 }
513
514 MOS_STATUS InitRowstoreUserFeatureSettings()
515 {
516 MHW_FUNCTION_ENTER;
517
518 bool rowstoreCachingDisableDefaultValue = false;
519 if (m_osItf->bSimIsActive)
520 {
521 // Disable RowStore Cache on simulation by default
522 rowstoreCachingDisableDefaultValue = true;
523 }
524 else
525 {
526 rowstoreCachingDisableDefaultValue = false;
527 }
528 m_rowstoreCachingSupported = !rowstoreCachingDisableDefaultValue;
529 #if (_DEBUG || _RELEASE_INTERNAL)
530 auto userSettingPtr = m_osItf->pfnGetUserSettingInstance(m_osItf);
531 {
532 MediaUserSetting::Value outValue;
533 ReadUserSettingForDebug(userSettingPtr,
534 outValue,
535 "Disable RowStore Cache",
536 MediaUserSetting::Group::Device,
537 rowstoreCachingDisableDefaultValue,
538 true);
539 m_rowstoreCachingSupported = !(outValue.Get<bool>());
540 }
541 #endif // _DEBUG || _RELEASE_INTERNAL
542
543 if (m_rowstoreCachingSupported)
544 {
545 m_intraRowstoreCache.supported = true;
546 #if (_DEBUG || _RELEASE_INTERNAL)
547 {
548 MediaUserSetting::Value outValue;
549 ReadUserSettingForDebug(userSettingPtr,
550 outValue,
551 "DisableIntraRowStoreCache",
552 MediaUserSetting::Group::Device);
553 m_intraRowstoreCache.supported = !(outValue.Get<bool>());
554 }
555 #endif // _DEBUG || _RELEASE_INTERNAL
556
557 m_deblockingFilterRowstoreCache.supported = true;
558 #if (_DEBUG || _RELEASE_INTERNAL)
559 {
560 MediaUserSetting::Value outValue;
561 ReadUserSettingForDebug(userSettingPtr,
562 outValue,
563 "DisableDeblockingFilterRowStoreCache",
564 MediaUserSetting::Group::Device);
565 m_deblockingFilterRowstoreCache.supported = !(outValue.Get<bool>());
566 }
567 #endif // _DEBUG || _RELEASE_INTERNAL
568
569 m_bsdMpcRowstoreCache.supported = true;
570 #if (_DEBUG || _RELEASE_INTERNAL)
571 {
572 MediaUserSetting::Value outValue;
573 ReadUserSettingForDebug(userSettingPtr,
574 outValue,
575 "DisableBsdMpcRowStoreCache",
576 MediaUserSetting::Group::Device);
577 m_bsdMpcRowstoreCache.supported = !(outValue.Get<bool>());
578 }
579 #endif // _DEBUG || _RELEASE_INTERNAL
580
581 m_mprRowstoreCache.supported = true;
582 #if (_DEBUG || _RELEASE_INTERNAL)
583 {
584 MediaUserSetting::Value outValue;
585 ReadUserSettingForDebug(userSettingPtr,
586 outValue,
587 "DisableMprRowStoreCache",
588 MediaUserSetting::Group::Device);
589 m_mprRowstoreCache.supported = !(outValue.Get<bool>());
590 }
591 #endif // _DEBUG || _RELEASE_INTERNAL
592 }
593
594 return MOS_STATUS_SUCCESS;
595 }
596
597 _MHW_SETCMD_OVERRIDE_DECL(MFX_QM_STATE)
598 {
599 _MHW_SETCMD_CALLBASE(MFX_QM_STATE);
600
601 for (uint8_t i = 0; i < 16; i++)
602 {
603 cmd.ForwardQuantizerMatrix[i] = params.quantizermatrix[i];
604 }
605
606 cmd.DW1.Obj2.Avc = params.qmType;
607
608 return MOS_STATUS_SUCCESS;
609 }
610
611 _MHW_SETCMD_OVERRIDE_DECL(MFX_FQM_STATE)
612 {
613 _MHW_SETCMD_CALLBASE(MFX_FQM_STATE);
614
615 for (uint8_t i = 0; i < 32; i++)
616 {
617 cmd.ForwardQuantizerMatrix[i] = params.quantizermatrix[i];
618 }
619
620 cmd.DW1.Obj2.Avc = params.qmType;
621
622 return MOS_STATUS_SUCCESS;
623 }
624
625 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_MODE_SELECT)
626 {
627 _MHW_SETCMD_CALLBASE(MFX_PIPE_MODE_SELECT);
628
629 MHW_MI_CHK_STATUS(m_cpItf->SetProtectionSettingsForMfxPipeModeSelect((uint32_t *)&cmd));
630
631 #define DO_FIELDS() \
632 DO_FIELD(DW1, StandardSelect, params.standardSelect); \
633 DO_FIELD(DW1, CodecSelect, params.codecSelect); \
634 DO_FIELD(DW1, FrameStatisticsStreamoutEnable, params.frameStatisticsStreamoutEnable); \
635 DO_FIELD(DW1, ScaledSurfaceEnable, params.scaledSurfaceEnable); \
636 DO_FIELD(DW1, PreDeblockingOutputEnablePredeblockoutenable, params.preDeblockingOutputEnablePredeblockoutenable); \
637 DO_FIELD(DW1, PostDeblockingOutputEnablePostdeblockoutenable, params.postDeblockingOutputEnablePostdeblockoutenable); \
638 DO_FIELD(DW1, StreamOutEnable, params.streamOutEnable); \
639 DO_FIELD(DW1, DeblockerStreamOutEnable, params.deblockerStreamOutEnable); \
640 DO_FIELD(DW1, VdencMode, params.vdencMode); \
641 DO_FIELD(DW1, DecoderModeSelect, params.decoderModeSelect); \
642 DO_FIELD(DW1, DecoderShortFormatMode, params.decoderShortFormatMode); \
643 DO_FIELD(DW1, ExtendedStreamOutEnable, params.extendedStreamOutEnable); \
644 DO_FIELD(DW2, Vlf720IOddHeightInVc1Mode, params.vlf720IOddHeightInVc1Mode);
645
646 #include "mhw_hwcmd_process_cmdfields.h"
647 }
648
649 _MHW_SETCMD_OVERRIDE_DECL(MFX_SURFACE_STATE)
650 {
651 _MHW_SETCMD_CALLBASE(MFX_SURFACE_STATE);
652
653 #define DO_FIELDS() \
654 DO_FIELD(DW1, SurfaceId, params.surfaceId); \
655 DO_FIELD(DW2, Height, params.height); \
656 DO_FIELD(DW2, Width, params.width); \
657 DO_FIELD(DW3, Tilemode, params.tilemode); \
658 DO_FIELD(DW3, SurfacePitch, params.surfacePitch); \
659 DO_FIELD(DW3, CompressionFormat, params.compressionFormat); \
660 DO_FIELD(DW3, InterleaveChroma, params.interleaveChroma); \
661 DO_FIELD(DW3, SurfaceFormat, params.surfaceFormat); \
662 DO_FIELD(DW4, YOffsetForUCb, params.yOffsetForUCb); \
663 DO_FIELD(DW5, YOffsetForVCr, params.yOffsetForVCr);
664
665 #include "mhw_hwcmd_process_cmdfields.h"
666 }
667
668 _MHW_SETCMD_OVERRIDE_DECL(MFX_IND_OBJ_BASE_ADDR_STATE)
669 {
670 _MHW_SETCMD_CALLBASE(MFX_IND_OBJ_BASE_ADDR_STATE);
671
672 MHW_RESOURCE_PARAMS resourceParams;
673 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
674 resourceParams.dwLsbNum = MHW_VDBOX_MFX_UPPER_BOUND_STATE_SHIFT;
675 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
676
677 // mode specific settings
678 if (CodecHalIsDecodeModeVLD(params.Mode) || (params.Mode == CODECHAL_ENCODE_MODE_VP8))
679 {
680 MHW_MI_CHK_NULL(params.presDataBuffer);
681
682 InitMocsParams(resourceParams, &cmd.MfxIndirectBitstreamObjectAttributes.DW0.Value, 1, 6);
683
684 resourceParams.presResource = params.presDataBuffer;
685 resourceParams.dwOffset = params.dwDataOffset;
686 resourceParams.pdwCmd = cmd.MfxIndirectBitstreamObjectBaseAddress.DW0_1.Value;
687 resourceParams.dwLocationInCmd = 1;
688 resourceParams.dwSize = params.dwDataSize;
689 resourceParams.bIsWritable = false;
690
691 // upper bound of the allocated resource will be set at 3 DW apart from address location
692 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
693
694 MHW_MI_CHK_STATUS(AddResourceToCmd(
695 this->m_osItf,
696 this->m_currentCmdBuf,
697 &resourceParams));
698 }
699 else if (CodecHalIsDecodeModeIT(params.Mode))
700 {
701 MHW_MI_CHK_NULL(params.presDataBuffer);
702 InitMocsParams(resourceParams, &cmd.MfdIndirectItCoeffObjectAttributes.DW0.Value, 1, 6);
703
704 resourceParams.presResource = params.presDataBuffer;
705 resourceParams.dwOffset = params.dwDataOffset;
706 resourceParams.pdwCmd = cmd.MfdIndirectItCoeffObjectBaseAddress.DW0_1.Value;
707 resourceParams.dwLocationInCmd = 11;
708 resourceParams.dwSize = params.dwDataSize;
709 resourceParams.bIsWritable = false;
710
711 // upper bound of the allocated resource will be set at 3 DW apart from address location
712 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
713
714 MHW_MI_CHK_STATUS(AddResourceToCmd(
715 this->m_osItf,
716 this->m_currentCmdBuf,
717 &resourceParams));
718 }
719
720 if (params.presMvObjectBuffer)
721 {
722 InitMocsParams(resourceParams, &cmd.MfxIndirectMvObjectAttributes.DW0.Value, 1, 6);
723 cmd.MfxIndirectMvObjectAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_mfxIndirectMvCtrl.Gen12_7.Index;
724
725 resourceParams.presResource = params.presMvObjectBuffer;
726 resourceParams.dwOffset = params.dwMvObjectOffset;
727 resourceParams.pdwCmd = cmd.MfxIndirectMvObjectBaseAddress.DW0_1.Value;
728 resourceParams.dwLocationInCmd = 6;
729 resourceParams.dwSize = MOS_ALIGN_CEIL(params.dwMvObjectSize, 0x1000);
730 resourceParams.bIsWritable = false;
731
732 // upper bound of the allocated resource will be set at 3 DW apart from address location
733 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
734
735 MHW_MI_CHK_STATUS(AddResourceToCmd(
736 this->m_osItf,
737 this->m_currentCmdBuf,
738 &resourceParams));
739 }
740
741 if (params.presPakBaseObjectBuffer)
742 {
743 InitMocsParams(resourceParams, &cmd.MfcIndirectPakBseObjectAttributes.DW0.Value, 1, 6);
744 cmd.MfcIndirectPakBseObjectAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_mfcIndirectPakBseCtrl.Gen12_7.Index;
745
746 resourceParams.presResource = params.presPakBaseObjectBuffer;
747 resourceParams.dwOffset = 0;
748 resourceParams.pdwCmd = cmd.MfcIndirectPakBseObjectBaseAddress.DW0_1.Value;
749 resourceParams.dwLocationInCmd = 21;
750 resourceParams.dwSize = MOS_ALIGN_CEIL(params.dwPakBaseObjectSize, 0x1000);
751 resourceParams.bIsWritable = true;
752
753 // upper bound of the allocated resource will be set at 3 DW apart from address location
754 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
755
756 MHW_MI_CHK_STATUS(AddResourceToCmd(
757 this->m_osItf,
758 this->m_currentCmdBuf,
759 &resourceParams));
760 }
761
762 return MOS_STATUS_SUCCESS;
763 }
764
765 _MHW_SETCMD_OVERRIDE_DECL(MFX_BSP_BUF_BASE_ADDR_STATE)
766 {
767 _MHW_SETCMD_CALLBASE(MFX_BSP_BUF_BASE_ADDR_STATE);
768
769 MHW_RESOURCE_PARAMS resourceParams;
770 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
771 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
772 resourceParams.HwCommandType = MOS_MFX_BSP_BUF_BASE_ADDR;
773
774 if (m_bsdMpcRowstoreCache.enabled) // mbaff and non mbaff mode for all resolutions
775 {
776 cmd.DW3.BsdMpcRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
777 cmd.DW1.BsdMpcRowStoreScratchBufferBaseAddressReadWrite = m_bsdMpcRowstoreCache.dwAddress;
778 }
779 else if (params.presBsdMpcRowStoreScratchBuffer)
780 {
781 InitMocsParams(resourceParams, &cmd.DW3.Value, 1, 6);
782 cmd.DW3.BsdMpcRowStoreScratchBufferIndexToMemoryObjectControlStateMocsTables = m_bsdMpcRowStoreScratchBufferCtrl.Gen12_7.Index;
783 cmd.DW1.BsdMpcRowStoreScratchBufferBaseAddressReadWrite = 0;
784
785 resourceParams.presResource = params.presBsdMpcRowStoreScratchBuffer;
786 resourceParams.dwOffset = 0;
787 resourceParams.pdwCmd = &(cmd.DW1.Value);
788 resourceParams.dwLocationInCmd = 1;
789 resourceParams.bIsWritable = true;
790
791 MHW_MI_CHK_STATUS(AddResourceToCmd(
792 this->m_osItf,
793 this->m_currentCmdBuf,
794 &resourceParams));
795 }
796
797 if (m_mprRowstoreCache.enabled)
798 {
799 cmd.DW6.MprRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
800 cmd.DW4.MprRowStoreScratchBufferBaseAddressReadWriteDecoderOnly = m_mprRowstoreCache.dwAddress;
801 }
802 else if (params.presMprRowStoreScratchBuffer)
803 {
804 InitMocsParams(resourceParams, &cmd.DW6.Value, 1, 6);
805 cmd.DW4.MprRowStoreScratchBufferBaseAddressReadWriteDecoderOnly = 0;
806
807 resourceParams.presResource = params.presMprRowStoreScratchBuffer;
808 resourceParams.dwOffset = 0;
809 resourceParams.pdwCmd = &(cmd.DW4.Value);
810 resourceParams.dwLocationInCmd = 4;
811 resourceParams.bIsWritable = true;
812
813 MHW_MI_CHK_STATUS(AddResourceToCmd(
814 this->m_osItf,
815 this->m_currentCmdBuf,
816 &resourceParams));
817 }
818
819 return MOS_STATUS_SUCCESS;
820 }
821
822 _MHW_SETCMD_OVERRIDE_DECL(MFX_PAK_INSERT_OBJECT)
823 {
824 _MHW_SETCMD_CALLBASE(MFX_PAK_INSERT_OBJECT);
825
826 uint32_t dwordsUsed = cmd.dwSize;
827
828 dwordsUsed += params.dwPadding;
829
830 #define DO_FIELDS() \
831 DO_FIELD(DW0, DwordLength, OP_LENGTH(dwordsUsed)); \
832 DO_FIELD(DW1, BitstreamstartresetResetbitstreamstartingpos, params.bitstreamstartresetResetbitstreamstartingpos); \
833 DO_FIELD(DW1, EndofsliceflagLastdstdatainsertcommandflag, params.endofsliceflagLastdstdatainsertcommandflag); \
834 DO_FIELD(DW1, LastheaderflagLastsrcheaderdatainsertcommandflag, params.lastheaderflagLastsrcheaderdatainsertcommandflag); \
835 DO_FIELD(DW1, EmulationflagEmulationbytebitsinsertenable, params.emulationflagEmulationbytebitsinsertenable); \
836 DO_FIELD(DW1, SkipemulbytecntSkipEmulationByteCount, params.skipemulbytecntSkipEmulationByteCount); \
837 DO_FIELD(DW1, DatabitsinlastdwSrcdataendingbitinclusion50, params.databitsinlastdwSrcdataendingbitinclusion50); \
838 DO_FIELD(DW1, SliceHeaderIndicator, params.sliceHeaderIndicator); \
839 DO_FIELD(DW1, Headerlengthexcludefrmsize, params.headerlengthexcludefrmsize); \
840 DO_FIELD(DW1, DatabyteoffsetSrcdatastartingbyteoffset10, 0);
841
842 #include "mhw_hwcmd_process_cmdfields.h"
843 }
844
845 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_IMG_STATE)
846 {
847 _MHW_SETCMD_CALLBASE(MFX_AVC_IMG_STATE);
848
849 #define DO_FIELDS() \
850 DO_FIELD(DW1, FrameSize, params.frameSize); \
851 DO_FIELD(DW2, FrameWidth, params.frameWidth); \
852 DO_FIELD(DW2, FrameHeight, params.frameHeight); \
853 DO_FIELD(DW3, ImgstructImageStructureImgStructure10, params.imgstructImageStructureImgStructure10); \
854 DO_FIELD(DW3, WeightedBipredIdc, params.weightedBipredIdc); \
855 DO_FIELD(DW3, WeightedPredFlag, params.weightedPredFlag); \
856 DO_FIELD(DW3, RhodomainRateControlEnable, params.vdencEnabled); \
857 DO_FIELD(DW3, FirstChromaQpOffset, params.firstChromaQpOffset); \
858 DO_FIELD(DW3, SecondChromaQpOffset, params.secondChromaQpOffset); \
859 DO_FIELD(DW4, Fieldpicflag, params.fieldpicflag); \
860 DO_FIELD(DW4, Mbaffflameflag, params.mbaffflameflag); \
861 DO_FIELD(DW4, Framembonlyflag, params.framembonlyflag); \
862 DO_FIELD(DW4, Transform8X8Flag, params.transform8X8Flag); \
863 DO_FIELD(DW4, Direct8X8Infflag, params.direct8X8Infflag); \
864 DO_FIELD(DW4, Constrainedipredflag, params.constrainedipredflag); \
865 DO_FIELD(DW4, Imgdisposableflag, params.imgdisposableflag); \
866 DO_FIELD(DW4, Entropycodingflag, params.entropycodingflag); \
867 DO_FIELD(DW4, Mbmvformatflag, params.mbmvformatflag); \
868 DO_FIELD(DW4, Chromaformatidc, params.chromaformatidc); \
869 DO_FIELD(DW4, Mvunpackedflag, params.mvunpackedflag); \
870 DO_FIELD(DW4, Inserttestflag, 0); \
871 DO_FIELD(DW4, Loadslicepointerflag, 0); \
872 DO_FIELD(DW4, Mbstatenabled, params.mbstatenabled); \
873 DO_FIELD(DW4, Minframewsize, 0); \
874 DO_FIELD(DW5, IntrambmaxbitflagIntrambmaxsizereportmask, params.intrambmaxbitflagIntrambmaxsizereportmask); \
875 DO_FIELD(DW5, IntermbmaxbitflagIntermbmaxsizereportmask, params.intermbmaxbitflagIntermbmaxsizereportmask); \
876 DO_FIELD(DW5, FrameszoverflagFramebitratemaxreportmask, params.frameszoverflagFramebitratemaxreportmask); \
877 DO_FIELD(DW5, FrameszunderflagFramebitrateminreportmask, params.frameszunderflagFramebitrateminreportmask); \
878 DO_FIELD(DW5, IntraIntermbipcmflagForceipcmcontrolmask, params.intraIntermbipcmflagForceipcmcontrolmask); \
879 DO_FIELD(DW5, MbratectrlflagMbLevelRateControlEnablingFlag, params.mbratectrlflagMbLevelRateControlEnablingFlag); \
880 DO_FIELD(DW5, Nonfirstpassflag, false); \
881 DO_FIELD(DW5, TrellisQuantizationChromaDisableTqchromadisable, true); \
882 DO_FIELD(DW5, TrellisQuantizationRoundingTqr, params.trellisQuantizationRoundingTqr); \
883 DO_FIELD(DW5, TrellisQuantizationEnabledTqenb, params.trellisQuantizationEnabledTqenb); \
884 DO_FIELD(DW6, Intrambmaxsz, params.intrambmaxsz); \
885 DO_FIELD(DW6, Intermbmaxsz, params.intermbmaxsz); \
886 DO_FIELD(DW8, Slicedeltaqppmax0, 0); \
887 DO_FIELD(DW8, Slicedeltaqpmax1, 0); \
888 DO_FIELD(DW8, Slicedeltaqpmax2, 0); \
889 DO_FIELD(DW8, Slicedeltaqpmax3, 0); \
890 DO_FIELD(DW9, Slicedeltaqpmin0, 0); \
891 DO_FIELD(DW9, Slicedeltaqpmin1, 0); \
892 DO_FIELD(DW9, Slicedeltaqpmin2, 0); \
893 DO_FIELD(DW9, Slicedeltaqpmin3, 0); \
894 DO_FIELD(DW10, Framebitratemin, params.framebitratemin); \
895 DO_FIELD(DW10, Framebitrateminunitmode, params.framebitrateminunitmode); \
896 DO_FIELD(DW10, Framebitrateminunit, params.framebitrateminunit); \
897 DO_FIELD(DW10, Framebitratemax, params.framebitratemax); \
898 DO_FIELD(DW10, Framebitratemaxunitmode, params.framebitratemaxunitmode); \
899 DO_FIELD(DW10, Framebitratemaxunit, params.framebitratemaxunit); \
900 DO_FIELD(DW11, Framebitratemindelta, params.framebitratemindelta); \
901 DO_FIELD(DW11, Framebitratemaxdelta, params.framebitratemaxdelta); \
902 DO_FIELD(DW11, SliceStatsStreamoutEnable, params.sliceStatsStreamoutEnable); \
903 DO_FIELD(DW13, InitialQpValue, params.initialQpValue); \
904 DO_FIELD(DW13, NumberOfActiveReferencePicturesFromL0, params.numberOfActiveReferencePicturesFromL0); \
905 DO_FIELD(DW13, NumberOfActiveReferencePicturesFromL1, params.numberOfActiveReferencePicturesFromL1); \
906 DO_FIELD(DW13, NumberOfReferenceFrames, params.numberOfReferenceFrames); \
907 DO_FIELD(DW13, CurrentPictureHasPerformedMmco5, 0); \
908 DO_FIELD(DW14, PicOrderPresentFlag, params.picOrderPresentFlag); \
909 DO_FIELD(DW14, DeltaPicOrderAlwaysZeroFlag, params.deltaPicOrderAlwaysZeroFlag); \
910 DO_FIELD(DW14, PicOrderCntType, params.picOrderCntType); \
911 DO_FIELD(DW14, SliceGroupMapType, params.sliceGroupMapType); \
912 DO_FIELD(DW14, RedundantPicCntPresentFlag, params.redundantPicCntPresentFlag); \
913 DO_FIELD(DW14, NumSliceGroupsMinus1, params.numSliceGroupsMinus1); \
914 DO_FIELD(DW14, DeblockingFilterControlPresentFlag, params.deblockingFilterControlPresentFlag); \
915 DO_FIELD(DW14, Log2MaxFrameNumMinus4, params.log2MaxFrameNumMinus4); \
916 DO_FIELD(DW14, Log2MaxPicOrderCntLsbMinus4, params.log2MaxPicOrderCntLsbMinus4); \
917 DO_FIELD(DW15, SliceGroupChangeRate, params.sliceGroupChangeRate); \
918 DO_FIELD(DW15, CurrPicFrameNum, params.currPicFrameNum); \
919 DO_FIELD(DW16, CurrentFrameViewId, params.currentFrameViewId); \
920 DO_FIELD(DW16, MaxViewIdxl0, params.maxViewIdxl0); \
921 DO_FIELD(DW16, MaxViewIdxl1, params.maxViewIdxl1); \
922 DO_FIELD(DW16, InterViewOrderDisable, 0); \
923 DO_FIELD(DW17, ExtendedRhodomainStatisticsEnable, params.extendedRhodomainStatisticsEnable); \
924 DO_FIELD(DW19, ThresholdSizeInBytes, params.thresholdSizeInBytes); \
925 DO_FIELD(DW20, TargetSliceSizeInBytes, params.targetSliceSizeInBytes);
926
927 #include "mhw_hwcmd_process_cmdfields.h"
928 }
929
930 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_REF_IDX_STATE)
931 {
932 _MHW_SETCMD_CALLBASE(MFX_AVC_REF_IDX_STATE);
933
934 cmd.DW1.RefpiclistSelect = params.uiList;
935
936 for (uint8_t i = 0; i < 8; i++)
937 {
938 cmd.ReferenceListEntry[i] = params.referenceListEntry[i];
939 }
940
941 return MOS_STATUS_SUCCESS;
942 }
943
944 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_WEIGHTOFFSET_STATE)
945 {
946 _MHW_SETCMD_CALLBASE(MFX_AVC_WEIGHTOFFSET_STATE);
947
948 cmd.DW1.WeightAndOffsetSelect = params.uiList;
949
950 for (uint8_t i = 0; i < 96; i++)
951 {
952 cmd.Weightoffset[i] = params.weightoffset[i];
953 }
954
955 return MOS_STATUS_SUCCESS;
956 }
957
958 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_SLICE_STATE)
959 {
960 _MHW_SETCMD_CALLBASE(MFX_AVC_SLICE_STATE);
961
962 #define DO_FIELDS() \
963 DO_FIELD(DW1, SliceType, params.sliceType); \
964 DO_FIELD(DW2, Log2WeightDenomLuma, params.log2WeightDenomLuma); \
965 DO_FIELD(DW2, Log2WeightDenomChroma, params.log2WeightDenomChroma); \
966 DO_FIELD(DW2, NumberOfReferencePicturesInInterPredictionList0, params.numberOfReferencePicturesInInterPredictionList0); \
967 DO_FIELD(DW2, NumberOfReferencePicturesInInterPredictionList1, params.numberOfReferencePicturesInInterPredictionList1); \
968 DO_FIELD(DW3, SliceAlphaC0OffsetDiv2, params.sliceAlphaC0OffsetDiv2); \
969 DO_FIELD(DW3, SliceBetaOffsetDiv2, params.sliceBetaOffsetDiv2); \
970 DO_FIELD(DW3, SliceQuantizationParameter, params.sliceQuantizationParameter); \
971 DO_FIELD(DW3, CabacInitIdc10, params.cabacInitIdc10); \
972 DO_FIELD(DW3, DisableDeblockingFilterIndicator, params.disableDeblockingFilterIndicator); \
973 DO_FIELD(DW3, DirectPredictionType, params.directPredictionType); \
974 DO_FIELD(DW3, WeightedPredictionIndicator, params.weightedPredictionIndicator); \
975 DO_FIELD(DW4, SliceStartMbNum, params.sliceStartMbNum); \
976 DO_FIELD(DW4, SliceHorizontalPosition, params.sliceHorizontalPosition); \
977 DO_FIELD(DW4, SliceVerticalPosition, params.sliceVerticalPosition); \
978 DO_FIELD(DW5, NextSliceHorizontalPosition, params.nextSliceHorizontalPosition); \
979 DO_FIELD(DW5, NextSliceVerticalPosition, params.nextSliceVerticalPosition); \
980 DO_FIELD(DW6, StreamId10, 0); \
981 DO_FIELD(DW6, SliceId30, params.sliceId30); \
982 DO_FIELD(DW6, Cabaczerowordinsertionenable, params.cabaczerowordinsertionenable); \
983 DO_FIELD(DW6, Emulationbytesliceinsertenable, params.emulationbytesliceinsertenable); \
984 DO_FIELD(DW6, TailInsertionPresentInBitstream, params.tailInsertionPresentInBitstream); \
985 DO_FIELD(DW6, SlicedataInsertionPresentInBitstream, params.slicedataInsertionPresentInBitstream); \
986 DO_FIELD(DW6, HeaderInsertionPresentInBitstream, params.headerInsertionPresentInBitstream); \
987 DO_FIELD(DW6, IsLastSlice, params.isLastSlice); \
988 DO_FIELD(DW6, MbTypeSkipConversionDisable, false); \
989 DO_FIELD(DW6, MbTypeDirectConversionDisable, false); \
990 DO_FIELD(DW6, RateControlCounterEnable, false); \
991 DO_FIELD(DW9, Roundintra, params.roundintra); \
992 DO_FIELD(DW9, Roundintraenable, true); \
993 DO_FIELD(DW9, Roundinter, params.roundinter); \
994 DO_FIELD(DW9, Roundinterenable, params.roundinterenable);
995
996 #include "mhw_hwcmd_process_cmdfields.h"
997 }
998
999 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_DIRECTMODE_STATE)
1000 {
1001 _MHW_SETCMD_CALLBASE(MFX_AVC_DIRECTMODE_STATE);
1002
1003 MHW_RESOURCE_PARAMS resourceParams;
1004 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1005 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
1006 resourceParams.HwCommandType = MOS_MFX_AVC_DIRECT_MODE;
1007
1008 if (!params.bDisableDmvBuffers)
1009 {
1010 MHW_MI_CHK_NULL(params.presAvcDmvBuffers);
1011 InitMocsParams(resourceParams, &cmd.DirectMvBufferForWriteAttributes.DW0.Value, 1, 6);
1012
1013 // current picture
1014 resourceParams.presResource = &params.presAvcDmvBuffers[params.ucAvcDmvIdx];
1015 resourceParams.dwOffset = 0;
1016 resourceParams.pdwCmd = &(cmd.DirectMvBufferForWriteBaseAddress.DW0_1.Value[0]);
1017 resourceParams.dwLocationInCmd = 34;
1018 resourceParams.bIsWritable = true;
1019
1020 MHW_MI_CHK_STATUS(AddResourceToCmd(
1021 this->m_osItf,
1022 this->m_currentCmdBuf,
1023 &resourceParams));
1024 }
1025
1026 CODEC_REF_LIST** refList;
1027 MHW_MI_CHK_NULL(refList = (CODEC_REF_LIST**)params.avcRefList);
1028
1029 if (CodecHal_PictureIsBottomField(params.CurrPic))
1030 {
1031 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = 0;
1032 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] = refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[1];
1033 }
1034 else
1035 {
1036 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] =
1037 refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[0];
1038 if (CodecHal_PictureIsFrame(params.CurrPic))
1039 {
1040 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] = refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[1];
1041 }
1042 }
1043
1044 if (!params.bDisableDmvBuffers)
1045 {
1046 InitMocsParams(resourceParams, &cmd.DirectMvBufferAttributes.DW0.Value, 1, 6);
1047 }
1048
1049 bool dmvPresent[CODEC_AVC_NUM_REF_DMV_BUFFERS] = { false };
1050 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
1051 {
1052 if (params.pAvcPicIdx[i].bValid)
1053 {
1054 uint8_t idx = params.pAvcPicIdx[i].ucPicIdx;
1055 uint8_t picID = params.bPicIdRemappingInUse ? i : refList[idx]->ucFrameId;
1056 uint8_t mvIdx = refList[idx]->ucDMVIdx[0];
1057
1058 uint8_t validRef = ((params.uiUsedForReferenceFlags >> (i * 2)) >> 0) & 1;
1059 uint8_t frameID = picID << 1;
1060 if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2)
1061 {
1062 if (!params.bDisableDmvBuffers)
1063 {
1064 dmvPresent[picID] = true;
1065
1066 resourceParams.presResource = &params.presAvcDmvBuffers[mvIdx];
1067 resourceParams.dwOffset = 0;
1068 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[picID].DW0_1.Value[0]);
1069 resourceParams.dwLocationInCmd = picID * 2 + 1;
1070 resourceParams.bIsWritable = false;
1071
1072 resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd;
1073
1074 MHW_MI_CHK_STATUS(AddResourceToCmd(
1075 this->m_osItf,
1076 this->m_currentCmdBuf,
1077 &resourceParams));
1078 }
1079
1080 cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[0] * validRef;
1081 }
1082 else
1083 {
1084 return MOS_STATUS_UNKNOWN;
1085 }
1086
1087 validRef = ((params.uiUsedForReferenceFlags >> (i * 2)) >> 1) & 1;
1088 frameID = (picID << 1) + 1;
1089 if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2)
1090 {
1091 cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[1] * validRef;
1092 }
1093 else
1094 {
1095 return MOS_STATUS_UNKNOWN;
1096 }
1097 }
1098 }
1099
1100 if (!params.bDisableDmvBuffers)
1101 {
1102 // Use a valid address for remaining DMV buffers
1103 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
1104 {
1105 if (dmvPresent[i] == false)
1106 {
1107 //Give default buffer to the MV
1108 resourceParams.presResource = &params.presAvcDmvBuffers[CODEC_AVC_NUM_REF_DMV_BUFFERS];
1109 resourceParams.dwOffset = 0;
1110 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[i].DW0_1.Value[0]);
1111 resourceParams.dwLocationInCmd = i * 2 + 1;
1112 resourceParams.bIsWritable = false;
1113
1114 resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd;
1115
1116 MHW_MI_CHK_STATUS(AddResourceToCmd(
1117 this->m_osItf,
1118 this->m_currentCmdBuf,
1119 &resourceParams));
1120 }
1121 }
1122 }
1123
1124 return MOS_STATUS_SUCCESS;
1125 }
1126
1127 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_SLICEADDR)
1128 {
1129 _MHW_SETCMD_CALLBASE(MFD_AVC_SLICEADDR);
1130
1131 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
1132 sliceInfoParam.presDataBuffer = params.presDataBuffer;
1133 sliceInfoParam.dwSliceIndex = params.dwSliceIndex;
1134 sliceInfoParam.dwTotalBytesConsumed = params.dwTotalBytesConsumed;
1135 sliceInfoParam.dwDataStartOffset[0] = params.IndirectBsdDataStartAddress;
1136 sliceInfoParam.dwDataStartOffset[1] = params.avcSliceParams->slice_data_offset;
1137
1138 MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState(
1139 params.decodeInUse,
1140 this->m_currentCmdBuf,
1141 nullptr,
1142 &sliceInfoParam));
1143 #define DO_FIELDS() \
1144 DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \
1145 DO_FIELD(DW2, IndirectBsdDataStartAddress, params.IndirectBsdDataStartAddress);
1146
1147 #include "mhw_hwcmd_process_cmdfields.h"
1148 }
1149
1150 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_BSD_OBJECT)
1151 {
1152 _MHW_SETCMD_CALLBASE(MFD_AVC_BSD_OBJECT);
1153 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
1154 sliceInfoParam.presDataBuffer = params.presDataBuffer;
1155 sliceInfoParam.dwSliceIndex = params.dwSliceIndex;
1156 sliceInfoParam.dwTotalBytesConsumed = params.dwTotalBytesConsumed;
1157 sliceInfoParam.dwDataStartOffset[0] = params.IndirectBsdDataStartAddress;
1158 sliceInfoParam.dwDataStartOffset[1] = params.pAvcSliceParams->slice_data_offset;
1159 sliceInfoParam.dwDataLength[1] = params.pAvcSliceParams->slice_data_size;
1160 MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState(
1161 params.decodeInUse,
1162 this->m_currentCmdBuf,
1163 nullptr,
1164 &sliceInfoParam));
1165 #define DO_FIELDS() \
1166 DO_FIELD(DW4, LastsliceFlag, params.LastsliceFlag); \
1167 DO_FIELD(DW3, IntraPredmode4X48X8LumaErrorControlBit, 1); \
1168 DO_FIELD(DW5, IntraPredictionErrorControlBitAppliedToIntra16X16Intra8X8Intra4X4LumaAndChroma, 1); \
1169 DO_FIELD(DW5, Intra8X84X4PredictionErrorConcealmentControlBit, 1); \
1170 DO_FIELD(DW5, ISliceConcealmentMode, 1); \
1171 DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \
1172 DO_FIELD(DW2, IndirectBsdDataStartAddress, params.IndirectBsdDataStartAddress); \
1173 DO_FIELD(DW4, FirstMbByteOffsetOfSliceDataOrSliceHeader, params.FirstMbByteOffsetOfSliceDataOrSliceHeader); \
1174 DO_FIELD(DW4, FirstMacroblockMbBitOffset, params.FirstMacroblockMbBitOffset); \
1175 DO_FIELD(DW4, FixPrevMbSkipped, 1);
1176 #include "mhw_hwcmd_process_cmdfields.h"
1177 }
1178
1179 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_PICID_STATE)
1180 {
1181 _MHW_SETCMD_CALLBASE(MFD_AVC_PICID_STATE);
1182 MOS_SecureMemcpy(cmd.Pictureidlist1616Bits,
1183 sizeof(params.Pictureidlist1616Bits),
1184 params.Pictureidlist1616Bits,
1185 sizeof(params.Pictureidlist1616Bits));
1186 #define DO_FIELDS() \
1187 DO_FIELD(DW1, PictureidRemappingDisable, params.PictureidRemappingDisable);
1188
1189 #include "mhw_hwcmd_process_cmdfields.h"
1190 }
1191
1192 _MHW_SETCMD_OVERRIDE_DECL(MFX_JPEG_PIC_STATE)
1193 {
1194 _MHW_SETCMD_CALLBASE(MFX_JPEG_PIC_STATE);
1195
1196 #define DO_FIELDS() \
1197 if (params.decodeInUse) \
1198 { \
1199 DO_FIELD(DW1, Obj1.InputFormatYuv, params.inputFormatYuv); \
1200 DO_FIELD(DW1, Obj1.Rotation, params.rotation); \
1201 DO_FIELD(DW1, Obj1.OutputFormatYuv, params.outputFormatYuv); \
1202 DO_FIELD(DW1, Obj1.VerticalDownSamplingEnable, params.verticalDownSamplingEnable); \
1203 DO_FIELD(DW1, Obj1.HorizontalDownSamplingEnable, params.horizontalDownSamplingEnable); \
1204 DO_FIELD(DW1, Obj1.VerticalUpSamplingEnable, params.verticalUpSamplingEnable); \
1205 } \
1206 else \
1207 { \
1208 DO_FIELD(DW1, Obj0.OutputMcuStructure, params.outputMcuStructure); \
1209 DO_FIELD(DW1, Obj0.InputSurfaceFormatYuv, params.inputSurfaceFormatYuv); \
1210 DO_FIELD(DW1, Obj0.PixelsInVerticalLastMcu, params.pixelsInVerticalLastMcu); \
1211 DO_FIELD(DW1, Obj0.PixelsInHorizontalLastMcu, params.pixelsInHorizontalLastMcu); \
1212 } \
1213 DO_FIELD(DW2, Obj0.FrameWidthInBlocksMinus1, params.frameWidthInBlocksMinus1); \
1214 DO_FIELD(DW2, Obj0.FrameHeightInBlocksMinus1, params.frameHeightInBlocksMinus1);
1215 #include "mhw_hwcmd_process_cmdfields.h"
1216 }
1217
1218 _MHW_SETCMD_OVERRIDE_DECL(MFX_JPEG_HUFF_TABLE_STATE)
1219 {
1220 _MHW_SETCMD_CALLBASE(MFX_JPEG_HUFF_TABLE_STATE);
1221
1222 MHW_MI_CHK_STATUS(MOS_SecureMemcpy(
1223 cmd.DcBits128BitArray,
1224 sizeof(cmd.DcBits128BitArray),
1225 params.pDCBits,
1226 sizeof(cmd.DcBits128BitArray)));
1227 MHW_MI_CHK_STATUS(MOS_SecureMemcpy(
1228 cmd.DcHuffval128BitArray,
1229 sizeof(cmd.DcHuffval128BitArray),
1230 params.pDCValues,
1231 sizeof(cmd.DcHuffval128BitArray)));
1232 MHW_MI_CHK_STATUS(MOS_SecureMemcpy(
1233 cmd.AcBits168BitArray,
1234 sizeof(cmd.AcBits168BitArray),
1235 params.pACBits,
1236 sizeof(cmd.AcBits168BitArray)));
1237 MHW_MI_CHK_STATUS(MOS_SecureMemcpy(
1238 cmd.AcHuffval1608BitArray,
1239 sizeof(cmd.AcHuffval1608BitArray),
1240 params.pACValues,
1241 sizeof(cmd.AcHuffval1608BitArray)));
1242
1243 MHW_MI_CHK_STATUS(MOS_SecureMemcpy(
1244 &cmd.DW52.Value,
1245 sizeof(uint16_t),
1246 (uint8_t *)params.pACValues + sizeof(cmd.AcHuffval1608BitArray),
1247 sizeof(uint16_t)));
1248
1249 #define DO_FIELDS() \
1250 DO_FIELD(DW1, Hufftableid1Bit, params.huffTableID);
1251
1252 #include "mhw_hwcmd_process_cmdfields.h"
1253 }
1254
1255 _MHW_SETCMD_OVERRIDE_DECL(MFD_JPEG_BSD_OBJECT)
1256 {
1257 _MHW_SETCMD_CALLBASE(MFD_JPEG_BSD_OBJECT);
1258
1259 #define DO_FIELDS() \
1260 DO_FIELD(DW1, IndirectDataLength, params.indirectDataLength); \
1261 DO_FIELD(DW2, IndirectDataStartAddress, params.dataStartAddress); \
1262 DO_FIELD(DW3, ScanVerticalPosition, params.scanVerticalPosition); \
1263 DO_FIELD(DW3, ScanHorizontalPosition, params.scanHorizontalPosition); \
1264 DO_FIELD(DW4, McuCount, params.mcuCount); \
1265 DO_FIELD(DW4, ScanComponents, params.scanComponent); \
1266 DO_FIELD(DW4, Interleaved, params.interleaved); \
1267 DO_FIELD(DW5, Restartinterval16Bit, params.restartInterval);
1268
1269 #include "mhw_hwcmd_process_cmdfields.h"
1270 }
1271
1272 _MHW_SETCMD_OVERRIDE_DECL(MFC_JPEG_HUFF_TABLE_STATE)
1273 {
1274 _MHW_SETCMD_CALLBASE(MFC_JPEG_HUFF_TABLE_STATE);
1275
1276 for (uint8_t i = 0; i < 12; i++)
1277 {
1278 cmd.DcTable[i] = params.dcTable[i];
1279 }
1280
1281 for (uint8_t i = 0; i < 162; i++)
1282 {
1283 cmd.AcTable[i] = params.acTable[i];
1284 }
1285
1286 cmd.DW1.HuffTableId = params.huffTableId;
1287
1288 return MOS_STATUS_SUCCESS;
1289 }
1290
1291 _MHW_SETCMD_OVERRIDE_DECL(MFC_JPEG_SCAN_OBJECT)
1292 {
1293 _MHW_SETCMD_CALLBASE(MFC_JPEG_SCAN_OBJECT);
1294
1295 #define DO_FIELDS() \
1296 DO_FIELD(DW1, McuCount, params.mcuCount); \
1297 DO_FIELD(DW2, RestartInterval, params.restartInterval); \
1298 DO_FIELD(DW2, IsLastScan, 1); \
1299 DO_FIELD(DW2, HeadPresentFlag, 1); \
1300 DO_FIELD(DW2, HuffmanDcTable, params.huffmanDcTable); \
1301 DO_FIELD(DW2, HuffmanAcTable, params.huffmanAcTable);
1302
1303 #include "mhw_hwcmd_process_cmdfields.h"
1304 }
1305
1306 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_DPB_STATE)
1307 {
1308 _MHW_SETCMD_CALLBASE(MFD_AVC_DPB_STATE);
1309 for (auto i = 0, j = 0; i < 8; i++, j++)
1310 {
1311 cmd.Ltstframenumlist1616Bits[i] = (params.refFrameOrder[j++] & 0xFFFF);
1312 cmd.Ltstframenumlist1616Bits[i] = cmd.Ltstframenumlist1616Bits[i] | ((params.refFrameOrder[j] & 0xFFFF) << 16); //SecondEntry
1313 }
1314 if (params.pMvcExtPicParams)
1315 {
1316 for (auto i = 0, j = 0; j < (CODEC_MAX_NUM_REF_FRAME / 2); i++, j++)
1317 {
1318 cmd.Viewidlist1616Bits[i] = params.pMvcExtPicParams->ViewIDList[j++];
1319 cmd.Viewidlist1616Bits[i] = cmd.Viewidlist1616Bits[i] | (params.pMvcExtPicParams->ViewIDList[j] << 16);
1320 }
1321 for (auto i = 0, j = 0; i < (CODEC_MAX_NUM_REF_FRAME / 4); i++, j++)
1322 {
1323 cmd.Vieworderlistl0168Bits[i] = GetViewOrder(params, j++, LIST_0); //FirstEntry
1324 cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j++, LIST_0) << 8); //SecondEntry
1325 cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j++, LIST_0) << 16); //ThirdEntry
1326 cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j, LIST_0) << 24); //FourthEntry
1327 }
1328 for (auto i = 0, j = 0; i < (CODEC_MAX_NUM_REF_FRAME / 4); i++, j++)
1329 {
1330 cmd.Vieworderlistl1168Bits[i] = GetViewOrder(params, j++, LIST_1); //FirstEntry
1331 cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j++, LIST_1) << 8); //SecondEntry
1332 cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j++, LIST_1) << 16); //ThirdEntry
1333 cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j, LIST_1) << 24); //FourthEntry
1334 }
1335 }
1336 else
1337 {
1338 // non-MVC usage
1339 MOS_ZeroMemory(cmd.Viewidlist1616Bits, sizeof(cmd.Viewidlist1616Bits));
1340 MOS_FillMemory(cmd.Vieworderlistl0168Bits, sizeof(cmd.Vieworderlistl0168Bits), 0xF);
1341 MOS_FillMemory(cmd.Vieworderlistl1168Bits, sizeof(cmd.Vieworderlistl1168Bits), 0xF);
1342 }
1343
1344 #define DO_FIELDS() \
1345 DO_FIELD(DW1, NonExistingframeFlag161Bit, params.NonExistingframeFlag161Bit); \
1346 DO_FIELD(DW1, LongtermframeFlag161Bit, params.LongtermframeFlag161Bit); \
1347 DO_FIELD(DW2, Value, params.usedForRef);
1348
1349 #include "mhw_hwcmd_process_cmdfields.h"
1350 }
1351
1352 _MHW_SETCMD_OVERRIDE_DECL(MFX_MPEG2_PIC_STATE)
1353 {
1354 _MHW_SETCMD_CALLBASE(MFX_MPEG2_PIC_STATE);
1355
1356 #define DO_FIELDS() \
1357 DO_FIELD(DW1, ScanOrder, params.ScanOrder); \
1358 DO_FIELD(DW1, IntraVlcFormat, params.IntraVlcFormat); \
1359 DO_FIELD(DW1, QuantizerScaleType, params.QuantizerScaleType); \
1360 DO_FIELD(DW1, ConcealmentMotionVectorFlag, params.ConcealmentMotionVectorFlag); \
1361 DO_FIELD(DW1, FramePredictionFrameDct, params.FramePredictionFrameDct); \
1362 DO_FIELD(DW1, TffTopFieldFirst, params.TffTopFieldFirst); \
1363 DO_FIELD(DW1, PictureStructure, params.PictureStructure); \
1364 DO_FIELD(DW1, IntraDcPrecision, params.IntraDcPrecision); \
1365 DO_FIELD(DW1, FCode00, params.FCode00); \
1366 DO_FIELD(DW1, FCode01, params.FCode01); \
1367 DO_FIELD(DW1, FCode10, params.FCode10); \
1368 DO_FIELD(DW1, FCode11, params.FCode11); \
1369 DO_FIELD(DW2, PictureCodingType, params.PictureCodingType); \
1370 DO_FIELD(DW2, ISliceConcealmentMode, params.ISliceConcealmentMode); \
1371 DO_FIELD(DW2, PBSliceConcealmentMode, params.PBSliceConcealmentMode); \
1372 DO_FIELD(DW2, PBSlicePredictedBidirMotionTypeOverrideBiDirectionMvTypeOverride, params.PBSlicePredictedBidirMotionTypeOverrideBiDirectionMvTypeOverride); \
1373 DO_FIELD(DW2, PBSlicePredictedMotionVectorOverrideFinalMvValueOverride, params.PBSlicePredictedMotionVectorOverrideFinalMvValueOverride); \
1374 DO_FIELD(DW3, SliceConcealmentDisableBit, params.SliceConcealmentDisableBit); \
1375 DO_FIELD(DW3, Framewidthinmbsminus170PictureWidthInMacroblocks, params.Framewidthinmbsminus170PictureWidthInMacroblocks); \
1376 DO_FIELD(DW3, Frameheightinmbsminus170PictureHeightInMacroblocks, params.Frameheightinmbsminus170PictureHeightInMacroblocks); \
1377 DO_FIELD(DW4, Roundintradc, 3); \
1378 DO_FIELD(DW4, Roundinterdc, 1); \
1379 DO_FIELD(DW4, Roundintraac, 5); \
1380 DO_FIELD(DW4, Roundinterac, 1); \
1381 DO_FIELD(DW3, MFX_MPEG2_PIC_STATE_CMD_DW3_BIT24_28, params.mfxMpeg2PicStatePar0); \
1382
1383 #include "mhw_hwcmd_process_cmdfields.h"
1384 }
1385
1386 _MHW_SETCMD_OVERRIDE_DECL(MFD_MPEG2_BSD_OBJECT)
1387 {
1388 _MHW_SETCMD_CALLBASE(MFD_MPEG2_BSD_OBJECT);
1389
1390 #define DO_FIELDS() \
1391 DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \
1392 DO_FIELD(DW2, IndirectDataStartAddress, params.IndirectDataStartAddress); \
1393 DO_FIELD(DW3, FirstMacroblockBitOffset, params.FirstMacroblockBitOffset); \
1394 DO_FIELD(DW3, IsLastMb, params.IsLastMb); \
1395 DO_FIELD(DW3, LastPicSlice, params.LastPicSlice); \
1396 DO_FIELD(DW3, MbRowLastSlice, params.MbRowLastSlice); \
1397 DO_FIELD(DW3, MacroblockCount, params.MacroblockCount); \
1398 DO_FIELD(DW3, SliceHorizontalPosition, params.SliceHorizontalPosition); \
1399 DO_FIELD(DW3, SliceVerticalPosition, params.SliceVerticalPosition); \
1400 DO_FIELD(DW4, QuantizerScaleCode, params.QuantizerScaleCode); \
1401 DO_FIELD(DW4, NextSliceHorizontalPosition, params.NextSliceHorizontalPosition); \
1402 DO_FIELD(DW4, NextSliceVerticalPosition, params.NextSliceVerticalPosition);
1403
1404 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
1405 sliceInfoParam.presDataBuffer = params.presDataBuffer;
1406 sliceInfoParam.dwDataStartOffset[0] = params.dwDataStartOffset;
1407
1408 MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState(
1409 params.decodeInUse,
1410 nullptr,
1411 this->m_currentBatchBuf,
1412 &sliceInfoParam));
1413
1414 #include "mhw_hwcmd_process_cmdfields.h"
1415 }
1416
1417 _MHW_SETCMD_OVERRIDE_DECL(MFD_IT_OBJECT)
1418 {
1419 _MHW_SETCMD_CALLBASE(MFD_IT_OBJECT);
1420
1421 #define DO_FIELDS() \
1422 DO_FIELD(DW0, DwordLength, params.DwordLength); \
1423 DO_FIELD(DW3, IndirectItCoeffDataLength, (params.dwDCTLength) << 2); \
1424 DO_FIELD(DW4, IndirectItCoeffDataStartAddressOffset, params.IndirectItCoeffDataStartAddressOffset);
1425
1426 #include "mhw_hwcmd_process_cmdfields.h"
1427 }
1428
1429 _MHW_SETCMD_OVERRIDE_DECL(MFD_IT_OBJECT_MPEG2_INLINE_DATA)
1430 {
1431 _MHW_SETCMD_CALLBASE(MFD_IT_OBJECT_MPEG2_INLINE_DATA);
1432
1433 auto MBType = params.pMBParams->MBType;
1434
1435 cmd.DW0.MacroblockIntraType = 1;
1436 cmd.DW0.DctType = MBType.m_fieldResidual;
1437 cmd.DW0.CodedBlockPattern = params.CodedBlockPattern;
1438 cmd.DW0.Lastmbinrow = params.Lastmbinrow;
1439 cmd.DW1.Horzorigin = params.Horzorigin;
1440 cmd.DW1.Vertorigin = params.Vertorigin;
1441
1442 if (params.CodingType != I_TYPE)
1443 {
1444 cmd.DW0.MacroblockIntraType = MBType.m_intraMb;
1445 cmd.DW0.MacroblockMotionForward = MBType.m_motionFwd;
1446 cmd.DW0.MacroblockMotionBackward = MBType.m_motionBwd;
1447 cmd.DW0.MotionType = MBType.m_motionType;
1448 cmd.DW0.MotionVerticalFieldSelect = MBType.m_mvertFieldSel;
1449
1450 // Next, copy in the motion vectors
1451 if (MBType.m_intraMb == 0)
1452 {
1453 uint32_t *point = (uint32_t *)(params.sPackedMVs0);
1454 cmd.DW2.Value = *point++;
1455 cmd.DW3.Value = *point++;
1456
1457 point = (uint32_t *)(params.sPackedMVs1);
1458 cmd.DW4.Value = *point++;
1459 cmd.DW5.Value = *point++;
1460 }
1461 }
1462
1463 #include "mhw_hwcmd_process_cmdfields.h"
1464 }
1465
1466 _MHW_SETCMD_OVERRIDE_DECL(MFX_VP8_PIC_STATE)
1467 {
1468 _MHW_SETCMD_CALLBASE(MFX_VP8_PIC_STATE);
1469
1470 #define DO_FIELDS() \
1471 DO_FIELD(DW1, FrameWidthMinus1 , params.FrameWidthMinus1); \
1472 DO_FIELD(DW1, FrameHeightMinus1 , params.FrameHeightMinus1); \
1473 DO_FIELD(DW2, McFilterSelect , params.McFilterSelect); \
1474 DO_FIELD(DW2, ChromaFullPixelMcFilterMode , params.ChromaFullPixelMcFilterMode); \
1475 DO_FIELD(DW2, Dblkfiltertype , params.Dblkfiltertype); \
1476 DO_FIELD(DW2, Skeyframeflag , params.Skeyframeflag); \
1477 DO_FIELD(DW2, SegmentationIdStreamoutEnable , params.SegmentationIdStreamoutEnable); \
1478 DO_FIELD(DW2, SegmentationIdStreaminEnable , params.SegmentationIdStreaminEnable); \
1479 DO_FIELD(DW2, SegmentEnableFlag , params.SegmentEnableFlag); \
1480 DO_FIELD(DW2, UpdateMbsegmentMapFlag , params.UpdateMbsegmentMapFlag); \
1481 DO_FIELD(DW2, MbNocoeffSkipflag , params.MbNocoeffSkipflag); \
1482 DO_FIELD(DW2, ModeReferenceLoopFilterDeltaEnabled , params.ModeReferenceLoopFilterDeltaEnabled); \
1483 DO_FIELD(DW2, GoldenRefPictureMvSignbiasFlag , params.GoldenRefPictureMvSignbiasFlag); \
1484 DO_FIELD(DW2, AlternateRefPicMvSignbiasFlag , params.AlternateRefPicMvSignbiasFlag); \
1485 DO_FIELD(DW2, DeblockSharpnessLevel , params.DeblockSharpnessLevel); \
1486 DO_FIELD(DW3, DblkfilterlevelForSegment3 , params.DblkfilterlevelForSegment3); \
1487 DO_FIELD(DW3, DblkfilterlevelForSegment2 , params.DblkfilterlevelForSegment2); \
1488 DO_FIELD(DW3, DblkfilterlevelForSegment1 , params.DblkfilterlevelForSegment1); \
1489 DO_FIELD(DW3, DblkfilterlevelForSegment0 , params.DblkfilterlevelForSegment0); \
1490 DO_FIELD(DW8, QuantizerValue1Blocktype2Uvdc , params.QuantizerValue1Blocktype2Uvdc); \
1491 DO_FIELD(DW8, QuantizerValue1Blocktype3Uvac , params.QuantizerValue1Blocktype3Uvac); \
1492 DO_FIELD(DW9, QuantizerValue1Blocktype4Y2Dc , params.QuantizerValue1Blocktype4Y2Dc); \
1493 DO_FIELD(DW9, QuantizerValue1Blocktype5Y2Ac , params.QuantizerValue1Blocktype5Y2Ac); \
1494 DO_FIELD(DW10, QuantizerValue2Blocktype0Y1Dc , params.QuantizerValue2Blocktype0Y1Dc); \
1495 DO_FIELD(DW10, QuantizerValue2Blocktype1Y1Ac , params.QuantizerValue2Blocktype1Y1Ac); \
1496 DO_FIELD(DW11, QuantizerValue2Blocktype2Uvdc , params.QuantizerValue2Blocktype2Uvdc); \
1497 DO_FIELD(DW11, QuantizerValue2Blocktype3Uvac , params.QuantizerValue2Blocktype3Uvac); \
1498 DO_FIELD(DW12, QuantizerValue2Blocktype4Y2Dc , params.QuantizerValue2Blocktype4Y2Dc); \
1499 DO_FIELD(DW12, QuantizerValue2Blocktype5Y2Ac , params.QuantizerValue2Blocktype5Y2Ac); \
1500 DO_FIELD(DW13, QuantizerValue3Blocktype0Y1Dc , params.QuantizerValue3Blocktype0Y1Dc); \
1501 DO_FIELD(DW13, QuantizerValue3Blocktype1Y1Ac , params.QuantizerValue3Blocktype1Y1Ac); \
1502 DO_FIELD(DW14, QuantizerValue3Blocktype2Uvdc , params.QuantizerValue3Blocktype2Uvdc); \
1503 DO_FIELD(DW14, QuantizerValue3Blocktype3Uvac , params.QuantizerValue3Blocktype3Uvac); \
1504 DO_FIELD(DW15, QuantizerValue3Blocktype4Y2Dc , params.QuantizerValue3Blocktype4Y2Dc); \
1505 DO_FIELD(DW15, QuantizerValue3Blocktype5Y2Ac , params.QuantizerValue3Blocktype5Y2Ac); \
1506 DO_FIELD(DW19, Mbsegmentidtreeprobs2 , params.Mbsegmentidtreeprobs2); \
1507 DO_FIELD(DW19, Mbsegmentidtreeprobs1 , params.Mbsegmentidtreeprobs1); \
1508 DO_FIELD(DW19, Mbsegmentidtreeprobs0 , params.Mbsegmentidtreeprobs0); \
1509 DO_FIELD(DW20, Mbnocoeffskipfalseprob , params.Mbnocoeffskipfalseprob); \
1510 DO_FIELD(DW20, Intrambprob , params.Intrambprob); \
1511 DO_FIELD(DW20, Interpredfromlastrefprob , params.Interpredfromlastrefprob); \
1512 DO_FIELD(DW20, Interpredfromgrefrefprob , params.Interpredfromgrefrefprob); \
1513 DO_FIELD(DW21, Ymodeprob3 , params.Ymodeprob3); \
1514 DO_FIELD(DW21, Ymodeprob2 , params.Ymodeprob2); \
1515 DO_FIELD(DW21, Ymodeprob1 , params.Ymodeprob1); \
1516 DO_FIELD(DW21, Ymodeprob0 , params.Ymodeprob0); \
1517 DO_FIELD(DW22, Uvmodeprob2 , params.Uvmodeprob2); \
1518 DO_FIELD(DW22, Uvmodeprob1 , params.Uvmodeprob1); \
1519 DO_FIELD(DW22, Uvmodeprob0 , params.Uvmodeprob0); \
1520 DO_FIELD(DW23, Mvupdateprobs00 , params.Mvupdateprobs00); \
1521 DO_FIELD(DW23, Mvupdateprobs01 , params.Mvupdateprobs01); \
1522 DO_FIELD(DW23, Mvupdateprobs02 , params.Mvupdateprobs02); \
1523 DO_FIELD(DW23, Mvupdateprobs03 , params.Mvupdateprobs03); \
1524 DO_FIELD(DW24, Mvupdateprobs04 , params.Mvupdateprobs04); \
1525 DO_FIELD(DW24, Mvupdateprobs05 , params.Mvupdateprobs05); \
1526 DO_FIELD(DW24, Mvupdateprobs06 , params.Mvupdateprobs06); \
1527 DO_FIELD(DW24, Mvupdateprobs07 , params.Mvupdateprobs07); \
1528 DO_FIELD(DW25, Mvupdateprobs08 , params.Mvupdateprobs08); \
1529 DO_FIELD(DW25, Mvupdateprobs09 , params.Mvupdateprobs09); \
1530 DO_FIELD(DW25, Mvupdateprobs010 , params.Mvupdateprobs010); \
1531 DO_FIELD(DW25, Mvupdateprobs011 , params.Mvupdateprobs011); \
1532 DO_FIELD(DW26, Mvupdateprobs012 , params.Mvupdateprobs012); \
1533 DO_FIELD(DW26, Mvupdateprobs013 , params.Mvupdateprobs013); \
1534 DO_FIELD(DW26, Mvupdateprobs014 , params.Mvupdateprobs014); \
1535 DO_FIELD(DW26, Mvupdateprobs015 , params.Mvupdateprobs015); \
1536 DO_FIELD(DW27, Mvupdateprobs016 , params.Mvupdateprobs016); \
1537 DO_FIELD(DW27, Mvupdateprobs017 , params.Mvupdateprobs017); \
1538 DO_FIELD(DW27, Mvupdateprobs018 , params.Mvupdateprobs018); \
1539 DO_FIELD(DW28, Mvupdateprobs10 , params.Mvupdateprobs10); \
1540 DO_FIELD(DW28, Mvupdateprobs11 , params.Mvupdateprobs11); \
1541 DO_FIELD(DW28, Mvupdateprobs12 , params.Mvupdateprobs12); \
1542 DO_FIELD(DW28, Mvupdateprobs13 , params.Mvupdateprobs13); \
1543 DO_FIELD(DW29, Mvupdateprobs14 , params.Mvupdateprobs14); \
1544 DO_FIELD(DW29, Mvupdateprobs15 , params.Mvupdateprobs15); \
1545 DO_FIELD(DW29, Mvupdateprobs16 , params.Mvupdateprobs16); \
1546 DO_FIELD(DW29, Mvupdateprobs17 , params.Mvupdateprobs17); \
1547 DO_FIELD(DW30, Mvupdateprobs18 , params.Mvupdateprobs18); \
1548 DO_FIELD(DW30, Mvupdateprobs19 , params.Mvupdateprobs19); \
1549 DO_FIELD(DW30, Mvupdateprobs110 , params.Mvupdateprobs110); \
1550 DO_FIELD(DW30, Mvupdateprobs111 , params.Mvupdateprobs111); \
1551 DO_FIELD(DW31, Mvupdateprobs112 , params.Mvupdateprobs112); \
1552 DO_FIELD(DW31, Mvupdateprobs113 , params.Mvupdateprobs113); \
1553 DO_FIELD(DW31, Mvupdateprobs114 , params.Mvupdateprobs114); \
1554 DO_FIELD(DW31, Mvupdateprobs115 , params.Mvupdateprobs115); \
1555 DO_FIELD(DW32, Mvupdateprobs116 , params.Mvupdateprobs116); \
1556 DO_FIELD(DW32, Mvupdateprobs117 , params.Mvupdateprobs117); \
1557 DO_FIELD(DW32, Mvupdateprobs118 , params.Mvupdateprobs118); \
1558 DO_FIELD(DW33, Reflfdelta0ForIntraFrame , params.Reflfdelta0ForIntraFrame); \
1559 DO_FIELD(DW33, Reflfdelta1ForLastFrame , params.Reflfdelta1ForLastFrame); \
1560 DO_FIELD(DW33, Reflfdelta2ForGoldenFrame , params.Reflfdelta2ForGoldenFrame); \
1561 DO_FIELD(DW33, Reflfdelta3ForAltrefFrame , params.Reflfdelta3ForAltrefFrame); \
1562 DO_FIELD(DW34, Modelfdelta0ForBPredMode , params.Modelfdelta0ForBPredMode); \
1563 DO_FIELD(DW34, Modelfdelta1ForZeromvMode , params.Modelfdelta1ForZeromvMode); \
1564 DO_FIELD(DW34, Modelfdelta2ForNearestNearAndNewMode , params.Modelfdelta2ForNearestNearAndNewMode); \
1565 DO_FIELD(DW34, Modelfdelta3ForSplitmvMode , params.Modelfdelta3ForSplitmvMode);
1566
1567
1568 cmd.DW4.dec.QuantizerValue0Blocktype0Y1Dc = params.QuantizerValue0Blocktype0Y1Dc;
1569 cmd.DW4.dec.QuantizerValue0Blocktype1Y1Ac = params.QuantizerValue0Blocktype1Y1Ac;
1570
1571 cmd.DW5.dec.QuantizerValue0Blocktype2Uvdc = params.QuantizerValue0Blocktype2Uvdc;
1572 cmd.DW5.dec.QuantizerValue0Blocktype3Uvac = params.QuantizerValue0Blocktype3Uvac;
1573
1574 cmd.DW6.dec.QuantizerValue0Blocktype4Y2Dc = params.QuantizerValue0Blocktype4Y2Dc;
1575 cmd.DW6.dec.QuantizerValue0Blocktype5Y2Ac = params.QuantizerValue0Blocktype5Y2Ac;
1576
1577 cmd.DW7.dec.QuantizerValue1Blocktype0Y1Dc = params.QuantizerValue1Blocktype0Y1Dc;
1578 cmd.DW7.dec.QuantizerValue1Blocktype1Y1Ac = params.QuantizerValue1Blocktype1Y1Ac;
1579
1580
1581 MHW_RESOURCE_PARAMS resourceParams;
1582 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1583 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
1584 resourceParams.HwCommandType = MOS_MFX_VP8_PIC;
1585
1586 resourceParams.presResource = params.presCoefProbBuffer;
1587 resourceParams.dwOffset = params.dwCoefProbTableOffset;
1588 resourceParams.pdwCmd = cmd.CoeffprobabilityStreaminBaseAddress.DW0_1.Value;
1589 resourceParams.dwLocationInCmd = 16;
1590 resourceParams.bIsWritable = false;
1591
1592 MHW_MI_CHK_STATUS(AddResourceToCmd(
1593 this->m_osItf,
1594 this->m_currentCmdBuf,
1595 &resourceParams));
1596
1597 if (params.SegmentEnableFlag)
1598 {
1599 resourceParams.presResource = params.presSegmentationIdStreamBuffer;
1600 resourceParams.dwOffset = 0;
1601 resourceParams.pdwCmd = cmd.SegmentationIdStreamBaseAddress.DW0_1.Value;
1602 resourceParams.dwLocationInCmd = 35;
1603 resourceParams.bIsWritable = true;
1604
1605
1606 MHW_MI_CHK_STATUS(AddResourceToCmd(
1607 this->m_osItf,
1608 this->m_currentCmdBuf,
1609 &resourceParams));
1610 }
1611
1612
1613 #include "mhw_hwcmd_process_cmdfields.h"
1614 }
1615
1616 _MHW_SETCMD_OVERRIDE_DECL(MFD_VP8_BSD_OBJECT)
1617 {
1618 _MHW_SETCMD_CALLBASE(MFD_VP8_BSD_OBJECT);
1619
1620 #define DO_FIELDS() \
1621 DO_FIELD(DW1, CodedNumOfCoeffTokenPartitions, params.CodedNumOfCoeffTokenPartitions); \
1622 DO_FIELD(DW1, Partition0CpbacEntropyRange, params.Partition0CpbacEntropyRange); \
1623 DO_FIELD(DW1, Partition0CpbacEntropyCount, params.Partition0CpbacEntropyCount); \
1624 DO_FIELD(DW2, Partition0CpbacEntropyValue, params.Partition0CpbacEntropyValue); \
1625 DO_FIELD(DW3, IndirectPartition0DataLength, params.IndirectPartition0DataLength); \
1626 DO_FIELD(DW4, IndirectPartition0DataStartOffset, params.IndirectPartition0DataStartOffset); \
1627 DO_FIELD(DW5, IndirectPartition1DataLength, params.IndirectPartition1DataLength); \
1628 DO_FIELD(DW6, IndirectPartition1DataStartOffset, params.IndirectPartition1DataStartOffset); \
1629 DO_FIELD(DW7, IndirectPartition2DataLength, params.IndirectPartition2DataLength); \
1630 DO_FIELD(DW8, IndirectPartition2DataStartOffset, params.IndirectPartition2DataStartOffset); \
1631 DO_FIELD(DW9, IndirectPartition3DataLength, params.IndirectPartition3DataLength); \
1632 DO_FIELD(DW10, IndirectPartition3DataStartOffset, params.IndirectPartition3DataStartOffset); \
1633 DO_FIELD(DW11, IndirectPartition4DataLength, params.IndirectPartition4DataLength); \
1634 DO_FIELD(DW12, IndirectPartition4DataStartOffset, params.IndirectPartition4DataStartOffset); \
1635 DO_FIELD(DW13, IndirectPartition5DataLength, params.IndirectPartition5DataLength); \
1636 DO_FIELD(DW14, IndirectPartition5DataStartOffset, params.IndirectPartition5DataStartOffset); \
1637 DO_FIELD(DW15, IndirectPartition6DataLength, params.IndirectPartition6DataLength); \
1638 DO_FIELD(DW16, IndirectPartition6DataStartOffset, params.IndirectPartition6DataStartOffset); \
1639 DO_FIELD(DW17, IndirectPartition7DataLength, params.IndirectPartition7DataLength); \
1640 DO_FIELD(DW18, IndirectPartition7DataStartOffset, params.IndirectPartition7DataStartOffset); \
1641 DO_FIELD(DW19, IndirectPartition8DataLength, params.IndirectPartition8DataLength); \
1642 DO_FIELD(DW20, IndirectPartition8DataStartOffset, params.IndirectPartition8DataStartOffset); \
1643
1644 #include "mhw_hwcmd_process_cmdfields.h"
1645 }
1646 MEDIA_CLASS_DEFINE_END(mhw__vdbox__mfx__Impl)
1647 };
1648 }//namespace mfx
1649 }//namespace vdbox
1650 }//namespace mhw
1651
1652 #endif // __MHW_VDBOX_MFX_IMPL_H__