Debian Codegraph @

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

raw
1 /*
2 * Copyright (c) 2021-2025, 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_aqm_impl.h
24 //! \brief MHW VDBOX AQM interface common base
25 //! \details
26 //!
27
28 #ifndef __MHW_VDBOX_AQM_IMPL_H__
29 #define __MHW_VDBOX_AQM_IMPL_H__
30
31 #include "mhw_vdbox_aqm_itf.h"
32 #include "mhw_impl.h"
33
34 #ifdef _MEDIA_RESERVED
35 #include "mhw_vdbox_aqm_hwcmd_ext.h"
36 #include "mhw_vdbox_aqm_cmdpar_ext.h"
37 #include "mhw_vdbox_aqm_impl_ext.h"
38 #endif
39
40 namespace mhw
41 {
42 namespace vdbox
43 {
44 namespace aqm
45 {
46 template <typename cmd_t>
47 class Impl : public Itf, public mhw::Impl
48 {
49 _AQM_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
50 #if _MEDIA_RESERVED
51 _AQM_CMD_DEF_EXT(_MHW_CMD_ALL_DEF_FOR_IMPL);
52 #endif
53
54 public:
55 MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override
56 {
57 MHW_FUNCTION_ENTER;
58
59 MHW_CHK_NULL_RETURN(settings);
60
61 size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS);
62
63 return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size);
64 }
65
66 protected:
67 using base_t = Itf;
68
69 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {};
70
71 Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf){};
72
73 _MHW_SETCMD_OVERRIDE_DECL(AQM_FRAME_START)
74 {
75 _MHW_SETCMD_CALLBASE(AQM_FRAME_START);
76
77 #define DO_FIELDS() \
78 DO_FIELD(DW1, AqmFrameStart, params.aqmFrameStart)
79
80 #include "mhw_hwcmd_process_cmdfields.h"
81 }
82
83 _MHW_SETCMD_OVERRIDE_DECL(AQM_PIC_STATE)
84 {
85 _MHW_SETCMD_CALLBASE(AQM_PIC_STATE);
86
87 #define DO_FIELDS() \
88 DO_FIELD(DW1, FrameWidthInPixelMinus1, params.frameWidthInPixelMinus1); \
89 DO_FIELD(DW1, FrameHeightInPixelMinus1, params.FrameHeightInPixelMinus1); \
90 DO_FIELD(DW2, VdaqmEnable, params.vdaqmEnable); \
91 DO_FIELD(DW2, TileBasedEngine, params.tileBasedEngine); \
92 DO_FIELD(DW2, LcuSize, params.lcuSize); \
93 DO_FIELD(DW2, Pixelbitdepth, params.pixelbitdepth); \
94 DO_FIELD(DW2, Chromasubsampling, params.chromasubsampling); \
95 DO_FIELD(DW2, AqmMode, params.aqmMode); \
96 DO_FIELD(DW2, Codectype, params.codectype); \
97 DO_FIELD(DW18, SseEnable, params.sseEnable)
98
99 #define DO_FIELDS_EXT() \
100 __MHW_VDBOX_AQM_WRAPPER_EXT(AQM_PIC_STATE_IMPL_EXT)
101
102 #include "mhw_hwcmd_process_cmdfields.h"
103 }
104
105 _MHW_SETCMD_OVERRIDE_DECL(AQM_SURFACE_STATE)
106 {
107 _MHW_SETCMD_CALLBASE(AQM_SURFACE_STATE);
108
109 #define DO_FIELDS() \
110 DO_FIELD(DW1, SurfaceId, params.surfaceStateId); \
111 DO_FIELD(DW1, SurfacePitchMinus1, params.pitch - 1); \
112 DO_FIELD(DW2, SurfaceFormat, static_cast<uint32_t>(params.surfaceFormat)); \
113 DO_FIELD(DW2, YOffsetForUCbInPixel, params.uOffset); \
114 DO_FIELD(DW3, YOffsetForVCr, params.vOffset); \
115 DO_FIELD(DW4, CompressionTypeForSourceFrame, MmcEnabled(params.mmcStateRawSurf) ? 1 : 0); \
116 DO_FIELD(DW4, CompressionTypeForReconstructedFrame, MmcEnabled(params.mmcStateReconSurf) ? 1 : 0); \
117 DO_FIELD(DW4, CompressionFormat, params.compressionFormat)
118 #include "mhw_hwcmd_process_cmdfields.h"
119 }
120
121 _MHW_SETCMD_OVERRIDE_DECL(AQM_PIPE_BUF_ADDR_STATE)
122 {
123 _MHW_SETCMD_CALLBASE(AQM_PIPE_BUF_ADDR_STATE);
124
125 MHW_RESOURCE_PARAMS resourceParams = {};
126 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
127 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
128
129 if (!Mos_ResourceIsNull(params.surfaceRawBuffer))
130 {
131 MOS_SURFACE details = {};
132 MOS_ZeroMemory(&details, sizeof(details));
133 details.Format = Format_Invalid;
134 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.surfaceRawBuffer, &details));
135
136 cmd.SourcePixelsFrameBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.mmcStateRawSurf);
137 cmd.SourcePixelsFrameBufferAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.mmcStateRawSurf);
138 cmd.SourcePixelsFrameBufferAddressAttributes.DW0.Tilemode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
139
140 resourceParams.presResource = params.surfaceRawBuffer;
141 resourceParams.dwOffset = 0;
142 resourceParams.pdwCmd = (cmd.SourcePixelsFrameBufferAddress.DW0_1.Value);
143 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SourcePixelsFrameBufferAddress);
144 resourceParams.bIsWritable = false;
145
146 MOS_GPU_CONTEXT gpuContext = m_osItf->pfnGetGpuContext(m_osItf);
147 m_osItf->pfnSyncOnResource(
148 m_osItf,
149 params.surfaceRawBuffer,
150 gpuContext,
151 false);
152
153 InitMocsParams(resourceParams, &cmd.SourcePixelsFrameBufferAddressAttributes.DW0.Value, 1, 6);
154
155 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
156 this->m_osItf,
157 this->m_currentCmdBuf,
158 &resourceParams));
159 }
160
161 if (!Mos_ResourceIsNull(params.surfaceReconBuffer))
162 {
163 MOS_SURFACE details = {};
164 MOS_ZeroMemory(&details, sizeof(details));
165 details.Format = Format_Invalid;
166 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.surfaceReconBuffer, &details));
167
168 cmd.ReconstructedPixelsFrameBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.mmcStateReconSurf);
169 cmd.ReconstructedPixelsFrameBufferAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.mmcStateReconSurf);
170 cmd.ReconstructedPixelsFrameBufferAddressAttributes.DW0.Tilemode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
171
172 resourceParams.presResource = params.surfaceReconBuffer;
173 resourceParams.dwOffset = 0;
174 resourceParams.pdwCmd = (cmd.ReconstructedPixelsFrameBufferAddress.DW0_1.Value);
175 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ReconstructedPixelsFrameBufferAddress);
176 resourceParams.bIsWritable = false;
177
178 MOS_GPU_CONTEXT gpuContext = m_osItf->pfnGetGpuContext(m_osItf);
179 m_osItf->pfnSyncOnResource(
180 m_osItf,
181 params.surfaceReconBuffer,
182 gpuContext,
183 false);
184
185 InitMocsParams(resourceParams, &cmd.ReconstructedPixelsFrameBufferAddressAttributes.DW0.Value, 1, 6);
186
187 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
188 this->m_osItf,
189 this->m_currentCmdBuf,
190 &resourceParams));
191 }
192
193 typename cmd_t::SPLITBASEADDRESS64BYTEALIGNED_CMD *AqmCmdArr1[] =
194 {&cmd.AQM_PIPE_BUF_ADDR_STATE_DW10, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW13, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW16, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW19, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW22};
195 typename cmd_t::MEMORYADDRESSATTRIBUTES_CMD * AqmCmdArr1Attributes[] =
196 {&cmd.AQM_PIPE_BUF_ADDR_STATE_DW12, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW15, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW18, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW21, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW24};
197 uint32_t AqmCmdArr1DwLoaction[] =
198 {_MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW10), _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW13), _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW16), _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW16), _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW22)};
199
200 for (uint8_t depth = 0; depth < 5; depth++)
201 {
202 if (!Mos_ResourceIsNull(params.AqmPipeBufAddrStatePar0[depth]))
203 {
204 AqmCmdArr1Attributes[depth]->DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 0; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
205
206 resourceParams.presResource = params.AqmPipeBufAddrStatePar0[depth];
207 resourceParams.dwOffset = params.AqmPipeBufAddrStatePar1[depth];
208 resourceParams.pdwCmd = (AqmCmdArr1[depth]->DW0_1.Value);
209 resourceParams.dwLocationInCmd = AqmCmdArr1DwLoaction[depth];
210 resourceParams.bIsWritable = true;
211
212 MHW_MI_CHK_STATUS(AddResourceToCmd(
213 this->m_osItf,
214 this->m_currentCmdBuf,
215 &resourceParams));
216 }
217 }
218
219 if (!Mos_ResourceIsNull(params.AqmPipeBufAddrStatePar2))
220 {
221 cmd.AQM_PIPE_BUF_ADDR_STATE_DW30.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 0; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
222
223 MOS_SURFACE details = {};
224 MOS_ZeroMemory(&details, sizeof(details));
225 details.Format = Format_Invalid;
226 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.AqmPipeBufAddrStatePar2, &details));
227
228 cmd.AQM_PIPE_BUF_ADDR_STATE_DW30.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.AqmPipeBufAddrStatePar3);
229 cmd.AQM_PIPE_BUF_ADDR_STATE_DW30.DW0.CompressionType = MmcRcEnabled(params.AqmPipeBufAddrStatePar3);
230 cmd.AQM_PIPE_BUF_ADDR_STATE_DW30.DW0.Tilemode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
231
232 resourceParams.presResource = params.AqmPipeBufAddrStatePar2;
233 resourceParams.dwOffset = 0;
234 resourceParams.pdwCmd = (cmd.AQM_PIPE_BUF_ADDR_STATE_DW28.DW0_1.Value);
235 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW28);
236 resourceParams.bIsWritable = true;
237
238 MHW_MI_CHK_STATUS(AddResourceToCmd(
239 this->m_osItf,
240 this->m_currentCmdBuf,
241 &resourceParams));
242 }
243
244 typename cmd_t::SPLITBASEADDRESS64BYTEALIGNED_CMD *AqmCmdArr2[] =
245 {&cmd.AQM_PIPE_BUF_ADDR_STATE_DW34, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW37, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW40, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW43, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW46};
246 typename cmd_t::MEMORYADDRESSATTRIBUTES_CMD *AqmCmdArr2Attributes[] =
247 {&cmd.AQM_PIPE_BUF_ADDR_STATE_DW36, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW39, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW42, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW45, &cmd.AQM_PIPE_BUF_ADDR_STATE_DW48};
248 uint32_t AqmCmdArr2DwLoaction[] =
249 {_MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW34), _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW37), _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW40), _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW43), _MHW_CMD_DW_LOCATION(AQM_PIPE_BUF_ADDR_STATE_DW46)};
250
251 for (uint8_t depth = 0; depth < 5; depth++)
252 {
253 if (!Mos_ResourceIsNull(params.AqmPipeBufAddrStatePar4[depth]))
254 {
255 AqmCmdArr2Attributes[depth]->DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 0; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
256
257 MOS_SURFACE details = {};
258 MOS_ZeroMemory(&details, sizeof(details));
259 details.Format = Format_Invalid;
260 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.AqmPipeBufAddrStatePar4[depth], &details));
261
262 AqmCmdArr2Attributes[depth]->DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.AqmPipeBufAddrStatePar5[depth]);
263 AqmCmdArr2Attributes[depth]->DW0.CompressionType = MmcRcEnabled(params.AqmPipeBufAddrStatePar5[depth]);
264 AqmCmdArr2Attributes[depth]->DW0.Tilemode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
265
266 resourceParams.presResource = params.AqmPipeBufAddrStatePar4[depth];
267 resourceParams.dwOffset = 0;
268 resourceParams.pdwCmd = (AqmCmdArr2[depth]->DW0_1.Value);
269 resourceParams.dwLocationInCmd = AqmCmdArr2DwLoaction[depth];
270 resourceParams.bIsWritable = true;
271
272 MHW_MI_CHK_STATUS(AddResourceToCmd(
273 this->m_osItf,
274 this->m_currentCmdBuf,
275 &resourceParams));
276 }
277 }
278
279 return MOS_STATUS_SUCCESS;
280 }
281
282 _MHW_SETCMD_OVERRIDE_DECL(AQM_TILE_CODING)
283 {
284 _MHW_SETCMD_CALLBASE(AQM_TILE_CODING);
285
286 #define DO_FIELDS() \
287 DO_FIELD(DW1, FrameTileId, params.tileId); \
288 DO_FIELD(DW1, TileGroupId, params.tileGroupId); \
289 DO_FIELD(DW2, TileColumnPositionInSbUnit, params.tileColPositionInSb); \
290 DO_FIELD(DW2, TileRowPositionInSbUnit, params.tileRowPositionInSb); \
291 DO_FIELD(DW3, TileWidthInSuperblockUnitMinus1, params.tileWidthInSbMinus1); \
292 DO_FIELD(DW3, TileHeightInSuperblockUnitMinus1, params.tileHeightInSbMinus1); \
293 DO_FIELD(DW4, TileNumber, params.tileNum)
294
295 #include "mhw_hwcmd_process_cmdfields.h"
296 }
297
298
299 _MHW_SETCMD_OVERRIDE_DECL(AQM_SLICE_STATE)
300 {
301 _MHW_SETCMD_CALLBASE(AQM_SLICE_STATE);
302
303 #define DO_FIELDS() \
304 DO_FIELD(DW1, FirstSuperSlice, params.firstSuperSlice); \
305 DO_FIELD(DW1, MbLcuStartXPosition, params.tileSliceStartLcuMbX); \
306 DO_FIELD(DW1, MbLcuStartYPosition, params.tileSliceStartLcuMbY); \
307 \
308 DO_FIELD(DW2, NextsliceMbLcuStartXPosition, params.nextTileSliceStartLcuMbX); \
309 DO_FIELD(DW2, NextsliceMbStartYPosition, params.nextTileSliceStartLcuMbY)
310
311 #include "mhw_hwcmd_process_cmdfields.h"
312 }
313
314 #ifdef _MEDIA_RESERVED
315 _MHW_SETCMD_OVERRIDE_DECL(AQM_HIST_STATE)
316 {
317 _MHW_SETCMD_CALLBASE(AQM_HIST_STATE);
318
319 #define DO_FIELDS() \
320 DO_FIELD(DW1, CodecType, params.CodecType); \
321 DO_FIELD(DW1, InputChromaSubsamplingFormat, params.inputChromaSubsamplingFormat); \
322 DO_FIELD(DW1, LumaPixelBitDepth, params.lumaPixelBitDepth); \
323 DO_FIELD(DW1, OperatingMode, params.operatingMode); \
324 DO_FIELD(DW1, InitializationMode, params.initializationMode); \
325 DO_FIELD(DW1, YHistogramEnable, params.yHistogramEnable); \
326 DO_FIELD(DW1, UHistogramEnable, params.uHistogramEnable); \
327 DO_FIELD(DW1, VHistogramEnable, params.vHistogramEnable); \
328 DO_FIELD(DW1, DisableForStatisticalSummaryOfHistogram, params.disableStatisticalSummaryHistogram); \
329 DO_FIELD(DW1, ChromaPixelBitDepth, params.chromaPixelBitDepth); \
330 DO_FIELD(DW2, FrameOrTileSizeInPixels, params.frameOrTileSizeInPixels)
331
332 #include "mhw_hwcmd_process_cmdfields.h"
333 }
334
335 _MHW_SETCMD_OVERRIDE_DECL(AQM_HIST_BUFF_ADDR_STATE)
336 {
337 _MHW_SETCMD_CALLBASE(AQM_HIST_BUFF_ADDR_STATE);
338
339 MHW_RESOURCE_PARAMS resourceParams = {};
340 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
341 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
342
343 if (!Mos_ResourceIsNull(params.AqmYChannelHistogramOutputBuffer))
344 {
345 cmd.AQMYChannelHistogramOutputAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 1; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
346
347 resourceParams.presResource = params.AqmYChannelHistogramOutputBuffer;
348 resourceParams.dwOffset = 0;
349 resourceParams.pdwCmd = (cmd.AQMYChannelHistogramOutputAddress.DW0_1.Value);
350 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(AQMYChannelHistogramOutputAddress);
351 resourceParams.bIsWritable = true;
352
353 InitMocsParams(resourceParams, &cmd.AQMYChannelHistogramOutputAddressAttributes.DW0.Value, 1, 6);
354
355 MHW_MI_CHK_STATUS(AddResourceToCmd(
356 this->m_osItf,
357 this->m_currentCmdBuf,
358 &resourceParams));
359 }
360
361 if (!Mos_ResourceIsNull(params.AqmUChannelHistogramOutputBuffer))
362 {
363 cmd.AQMUChannelHistogramOutputAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 1; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
364
365 resourceParams.presResource = params.AqmUChannelHistogramOutputBuffer;
366 resourceParams.dwOffset = 0;
367 resourceParams.pdwCmd = (cmd.AQMUChannelHistogramOutputAddress.DW0_1.Value);
368 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(AQMUChannelHistogramOutputAddress);
369 resourceParams.bIsWritable = true;
370
371 InitMocsParams(resourceParams, &cmd.AQMUChannelHistogramOutputAddressAttributes.DW0.Value, 1, 6);
372
373 MHW_MI_CHK_STATUS(AddResourceToCmd(
374 this->m_osItf,
375 this->m_currentCmdBuf,
376 &resourceParams));
377 }
378
379 if (!Mos_ResourceIsNull(params.AqmVChannelHistogramOutputBuffer))
380 {
381 cmd.AQMVChannelHistogramOutputAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 1; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
382
383 resourceParams.presResource = params.AqmVChannelHistogramOutputBuffer;
384 resourceParams.dwOffset = 0;
385 resourceParams.pdwCmd = (cmd.AQMVChannelHistogramOutputAddress.DW0_1.Value);
386 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(AQMVChannelHistogramOutputAddress);
387 resourceParams.bIsWritable = true;
388
389 InitMocsParams(resourceParams, &cmd.AQMVChannelHistogramOutputAddressAttributes.DW0.Value, 1, 6);
390
391 MHW_MI_CHK_STATUS(AddResourceToCmd(
392 this->m_osItf,
393 this->m_currentCmdBuf,
394 &resourceParams));
395 }
396
397 if (!Mos_ResourceIsNull(params.AqmStatisticsSummaryOutputBuffer))
398 {
399 cmd.AQMStatisticsSummaryOutputAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 1; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
400
401 resourceParams.presResource = params.AqmStatisticsSummaryOutputBuffer;
402 resourceParams.dwOffset = 0;
403 resourceParams.pdwCmd = (cmd.AQMStatisticsSummaryOutputAddress.DW0_1.Value);
404 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(AQMStatisticsSummaryOutputAddress);
405 resourceParams.bIsWritable = true;
406
407 InitMocsParams(resourceParams, &cmd.AQMStatisticsSummaryOutputAddressAttributes.DW0.Value, 1, 6);
408
409 MHW_MI_CHK_STATUS(AddResourceToCmd(
410 this->m_osItf,
411 this->m_currentCmdBuf,
412 &resourceParams));
413 }
414
415 if (!Mos_ResourceIsNull(params.MetadataStreamoutOutputBuffer))
416 {
417 cmd.MetadataStreamoutOutputAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 1; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
418
419 resourceParams.presResource = params.MetadataStreamoutOutputBuffer;
420 resourceParams.dwOffset = 0;
421 resourceParams.pdwCmd = (cmd.MetadataStreamoutOutputAddress.DW0_1.Value);
422 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MetadataStreamoutOutputAddress);
423 resourceParams.bIsWritable = true;
424
425 InitMocsParams(resourceParams, &cmd.MetadataStreamoutOutputAddressAttributes.DW0.Value, 1, 6);
426
427 MHW_MI_CHK_STATUS(AddResourceToCmd(
428 this->m_osItf,
429 this->m_currentCmdBuf,
430 &resourceParams));
431 }
432
433 if (!Mos_ResourceIsNull(params.MetadataStreaminInputBuffer))
434 {
435 cmd.MetadataStreaminInputAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 1; //TODO: change to below line when enabling GMM Cacheability for HW resources; this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_AVP_CDF_INIT_CODEC].Value;
436
437 resourceParams.presResource = params.MetadataStreaminInputBuffer;
438 resourceParams.dwOffset = 0;
439 resourceParams.pdwCmd = (cmd.MetadataStreaminInputAddress.DW0_1.Value);
440 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MetadataStreaminInputAddress);
441 resourceParams.bIsWritable = true;
442
443 InitMocsParams(resourceParams, &cmd.MetadataStreaminInputAddressAttributes.DW0.Value, 1, 6);
444
445 MHW_MI_CHK_STATUS(AddResourceToCmd(
446 this->m_osItf,
447 this->m_currentCmdBuf,
448 &resourceParams));
449 }
450 return MOS_STATUS_SUCCESS;
451 }
452
453 _MHW_SETCMD_OVERRIDE_DECL(AQM_HIST_FLUSH)
454 {
455 _MHW_SETCMD_CALLBASE(AQM_HIST_FLUSH);
456
457 #define DO_FIELDS() \
458 DO_FIELD(DW1, AqmHistFlush, params.aqmHistFlush)
459
460 #include "mhw_hwcmd_process_cmdfields.h"
461 }
462 #endif //_MEDIA_RESERVED
463
464 _MHW_SETCMD_OVERRIDE_DECL(AQM_VD_CONTROL_STATE)
465 {
466 _MHW_SETCMD_CALLBASE(AQM_VD_CONTROL_STATE);
467
468 cmd.VdControlStateBody.DW0.PipelineInitialization = params.pipelineInitialization;
469 cmd.VdControlStateBody.DW0.VDboxPipelineArchitectureClockgateDisable = params.VDboxPipelineArchitectureClockgateDisable;
470 cmd.VdControlStateBody.DW1.MemoryImplicitFlush = params.memoryImplicitFlush;
471
472 return MOS_STATUS_SUCCESS;
473 }
474
475 MEDIA_CLASS_DEFINE_END(mhw__vdbox__aqm__Impl)
476 };
477 } // namespace aqm
478 } // namespace vdbox
479 } // namespace mhw
480
481 #endif // __MHW_VDBOX_AQM_IMPL_H__