Debian Codegraph @

media_softlet/agnostic/common/hw/vdbox/mhw_vdbox_hcp_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_hcp_impl.h
24 //! \brief MHW VDBOX HCP interface common base
25 //! \details
26 //!
27
28 #ifndef __MHW_VDBOX_HCP_IMPL_H__
29 #define __MHW_VDBOX_HCP_IMPL_H__
30
31 #include "mhw_vdbox_hcp_itf.h"
32 #include "mhw_impl.h"
33 #include "mhw_vdbox_hcp_def.h"
34
35 #define MHW_HCP_WORST_CASE_LCU_CU_TU_INFO (26 * MHW_CACHELINE_SIZE) // 18+4+4
36 #define MHW_HCP_WORST_CASE_LCU_CU_TU_INFO_REXT (35 * MHW_CACHELINE_SIZE) // 27+4+4
37
38 #define MHW_HCP_WORST_CASE_CU_TU_INFO (4 * MHW_CACHELINE_SIZE) // 2+1+1
39 #define MHW_HCP_WORST_CASE_CU_TU_INFO_REXT (6 * MHW_CACHELINE_SIZE) // 4+1+1
40
41 namespace mhw
42 {
43 namespace vdbox
44 {
45 namespace hcp
46 {
47 static constexpr uint32_t WATCHDOG_COUNT_CTRL_OFFSET_INIT = 0x1C0178;
48 static constexpr uint32_t WATCHDOG_COUNT_THRESTHOLD_OFFSET_INIT = 0x1C017C;
49 static constexpr uint32_t HCP_DEBUG_FE_STREAM_OUT_SIZE_REG_OFFSET_INIT = 0x1C2828;
50 static constexpr uint32_t HCP_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT = 0x1C28B8;
51 static constexpr uint32_t HCP_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT = 0x1C28BC;
52 static constexpr uint32_t HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT = 0x1C28A0;
53 static constexpr uint32_t HCP_ENC_BIT_STREAM_SE_BIT_COUNT_FRAME_REG_OFFSET_INIT = 0x1C28A8;
54 static constexpr uint32_t HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT = 0x1C28A4;
55 static constexpr uint32_t HCP_ENC_QP_STATUS_COUNT_REG_OFFSET_INIT = 0x1C28C0;
56 static constexpr uint32_t HCP_ENC_SLICE_COUNT_REG_OFFSET_INIT = 0x1C28C8;
57 static constexpr uint32_t HCP_ENC_VDENC_MODE_TIMER_REG_OFFSET_INIT = 0x1C28DC;
58 static constexpr uint32_t HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT = 0x1C28E0;
59 static constexpr uint32_t HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT = 0x1C28E4;
60 static constexpr uint32_t HCP_VP9_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT = 0x1C28F0;
61 static constexpr uint32_t HCP_VP9_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT = 0x1C28F4;
62 static constexpr uint32_t CS_ENGINE_ID_OFFSET_INIT = 0x1C008C;
63 static constexpr uint32_t HCP_DEC_STATUS_REG_OFFSET_INIT = 0x1C2800;
64 static constexpr uint32_t HCP_CABAC_STATUS_REG_OFFSET_INIT = 0x1C2804;
65 static constexpr uint32_t HCP_FRAME_CRC_REG_OFFSET_INIT = 0x1C2920;
66 static constexpr uint32_t HCP_COMMAND_COUNTER_REG_OFFSET_INIT = 0x1C2820;
67 static constexpr uint32_t HCP_COMMAND_COUNTER_OVERRIDE_REG_OFFSET_INIT = 0x1C2824;
68 static constexpr uint32_t MEMORY_ADDRESS_ATTRIBUTES_MOCS_CLEAN_MASK = 0xFFFFFF81;
69
70 template <typename cmd_t>
71 class Impl : public Itf, public mhw::Impl
72 {
73 _HCP_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
74
75 public:
76 MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override
77 {
78 MHW_FUNCTION_ENTER;
79
80 MHW_CHK_NULL_RETURN(settings);
81
82 size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS);
83
84 return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size);
85 }
86
87 MOS_STATUS GetHcpBufSize(const HcpBufferSizePar &par, uint32_t &size) override
88 {
89 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
90
91 MHW_FUNCTION_ENTER;
92
93 uint8_t bitDepthMultFactor = 0;
94 uint32_t mvtSize = 0;
95 uint32_t mvtbSize = 0;
96 uint32_t bufferSize = 0;
97 uint32_t rowStoreSzLCU = 0;
98 uint32_t colStoreSzLCU = 0;
99 double dbFormatMultFactor = 0;
100
101 uint8_t maxBitDepth = par.ucMaxBitDepth;
102 uint32_t lcusize = 1 << par.dwCtbLog2SizeY;
103 uint32_t maxFrameSize = par.dwMaxFrameSize;
104 // HEVC decoder has WA here, change to lcusize when the WA is removed
105 uint32_t widthInCtb = MOS_ROUNDUP_DIVIDE(par.dwPicWidth, 16);
106 uint32_t heightInCtb = MOS_ROUNDUP_DIVIDE(par.dwPicHeight, 16);
107 uint32_t numBaseUnitsInLCU = 1 << (par.dwCtbLog2SizeY - 2); //size in number of 4x4 in the LCU per column
108 HCP_CHROMA_FORMAT_IDC chromaFormat = (HCP_CHROMA_FORMAT_IDC)par.ucChromaFormat;
109
110 switch (par.bufferType)
111 {
112 case HCP_INTERNAL_BUFFER_TYPE::DBLK_LINE:
113 dbFormatMultFactor = (chromaFormat == HCP_CHROMA_FORMAT_YUV444) ? 1.5 : 1;
114 bitDepthMultFactor = (maxBitDepth > 8) ? 2 : 1;
115 rowStoreSzLCU = (uint32_t)(((2 * numBaseUnitsInLCU * dbFormatMultFactor * 128 * bitDepthMultFactor) + 511) / 512);
116 bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb;
117 break;
118 case HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_LINE:
119 dbFormatMultFactor = (chromaFormat == HCP_CHROMA_FORMAT_YUV444) ? 1.5 : 1;
120 bitDepthMultFactor = (maxBitDepth > 8) ? 2 : 1;
121 rowStoreSzLCU = (uint32_t)(((2 * numBaseUnitsInLCU * dbFormatMultFactor * 128 * bitDepthMultFactor) + 511) / 512);
122 bufferSize = 2 * rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb;
123 break;
124 case HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_COL:
125 dbFormatMultFactor = (chromaFormat == HCP_CHROMA_FORMAT_YUV420) ? 1 : 1.5;
126 bitDepthMultFactor = (maxBitDepth > 8) ? 2 : 1;
127 colStoreSzLCU = (uint32_t)(((2 * numBaseUnitsInLCU * dbFormatMultFactor * 128 * bitDepthMultFactor + 3 * 128 * bitDepthMultFactor) + 511) / 512);
128 bufferSize = 2 * colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb;
129 break;
130 case HCP_INTERNAL_BUFFER_TYPE::MV_UP_RT_COL:
131 colStoreSzLCU = 1;
132 bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb;
133 break;
134 case HCP_INTERNAL_BUFFER_TYPE::META_LINE:
135 rowStoreSzLCU = (par.dwCtbLog2SizeY == 6) ? 2 : 1;
136 bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb;
137 break;
138 case HCP_INTERNAL_BUFFER_TYPE::META_TILE_LINE:
139 rowStoreSzLCU = (par.dwCtbLog2SizeY == 6) ? 4 : 2;
140 bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb;
141 break;
142 case HCP_INTERNAL_BUFFER_TYPE::META_TILE_COL:
143 colStoreSzLCU = (par.dwCtbLog2SizeY == 6) ? 4 : 2;
144 bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb;
145 break;
146 case HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_UP_RIGHT_COL:
147 {
148 uint32_t colStoreSizeLCU[2][3]; //[bitdepth 8/10 or 12][LCU 16/32/64]
149 if (chromaFormat == HCP_CHROMA_FORMAT_YUV420)
150 {
151 colStoreSizeLCU[0][0] = 1;
152 colStoreSizeLCU[0][1] = 1;
153 colStoreSizeLCU[0][2] = 1;
154 colStoreSizeLCU[1][0] = 1;
155 colStoreSizeLCU[1][1] = 2;
156 colStoreSizeLCU[1][2] = 2;
157 }
158 else if (chromaFormat == HCP_CHROMA_FORMAT_YUV422)
159 {
160 colStoreSizeLCU[0][0] = 1;
161 colStoreSizeLCU[0][1] = 1;
162 colStoreSizeLCU[0][2] = 1;
163 colStoreSizeLCU[1][0] = 1;
164 colStoreSizeLCU[1][1] = 2;
165 colStoreSizeLCU[1][2] = 2;
166 }
167 else
168 {
169 colStoreSizeLCU[0][0] = 1;
170 colStoreSizeLCU[0][1] = 2;
171 colStoreSizeLCU[0][2] = 2;
172 colStoreSizeLCU[1][0] = 2;
173 colStoreSizeLCU[1][1] = 3;
174 colStoreSizeLCU[1][2] = 3;
175 }
176 colStoreSzLCU = colStoreSizeLCU[(maxBitDepth == 8) ? 0 : 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0];
177 bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb;
178 break;
179 }
180 case HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_LFT_RECON_COL:
181 {
182 uint32_t colStoreSizeLCU[2][3]; //[bitdepth 8/10 or 12][LCU 16/32/64]
183 if (chromaFormat == HCP_CHROMA_FORMAT_YUV420)
184 {
185 colStoreSizeLCU[0][0] = 1;
186 colStoreSizeLCU[0][1] = 2;
187 colStoreSizeLCU[0][2] = 2;
188 colStoreSizeLCU[1][0] = 1;
189 colStoreSizeLCU[1][1] = 2;
190 colStoreSizeLCU[1][2] = 4;
191 }
192 else if (chromaFormat == HCP_CHROMA_FORMAT_YUV422)
193 {
194 colStoreSizeLCU[0][0] = 1;
195 colStoreSizeLCU[0][1] = 2;
196 colStoreSizeLCU[0][2] = 3;
197 colStoreSizeLCU[1][0] = 2;
198 colStoreSizeLCU[1][1] = 3;
199 colStoreSizeLCU[1][2] = 6;
200 }
201 else
202 {
203 colStoreSizeLCU[0][0] = 1;
204 colStoreSizeLCU[0][1] = 2;
205 colStoreSizeLCU[0][2] = 3;
206 colStoreSizeLCU[1][0] = 2;
207 colStoreSizeLCU[1][1] = 3;
208 colStoreSizeLCU[1][2] = 6;
209 }
210 colStoreSzLCU = colStoreSizeLCU[(maxBitDepth == 8) ? 0 : 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0];
211 bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb;
212 break;
213 }
214 case HCP_INTERNAL_BUFFER_TYPE::SAO_LINE:
215 {
216 uint32_t uiRowStoreSizeLCU[2][3]; //[bitdepth 8 or10/12][LCU 16/32/64]
217 if (chromaFormat == HCP_CHROMA_FORMAT_YUV420 || chromaFormat == HCP_CHROMA_FORMAT_YUV422)
218 {
219 uiRowStoreSizeLCU[0][0] = 2;
220 uiRowStoreSizeLCU[0][1] = 3;
221 uiRowStoreSizeLCU[0][2] = 5;
222 uiRowStoreSizeLCU[1][0] = 2;
223 uiRowStoreSizeLCU[1][1] = 4;
224 uiRowStoreSizeLCU[1][2] = 6;
225 }
226 else
227 {
228 uiRowStoreSizeLCU[0][0] = 3;
229 uiRowStoreSizeLCU[0][1] = 4;
230 uiRowStoreSizeLCU[0][2] = 7;
231 uiRowStoreSizeLCU[1][0] = 3;
232 uiRowStoreSizeLCU[1][1] = 5;
233 uiRowStoreSizeLCU[1][2] = 8;
234 }
235 rowStoreSzLCU = uiRowStoreSizeLCU[(maxBitDepth < 12) ? 0 : 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0];
236 bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb;
237 break;
238 }
239 case HCP_INTERNAL_BUFFER_TYPE::SAO_TILE_LINE:
240 {
241 uint32_t uiRowStoreSizeLCU[2][3]; //[bitdepth 8 or 10/12][LCU 16/32/64]
242 if (chromaFormat == HCP_CHROMA_FORMAT_YUV420 || chromaFormat == HCP_CHROMA_FORMAT_YUV422)
243 {
244 uiRowStoreSizeLCU[0][0] = 4;
245 uiRowStoreSizeLCU[0][1] = 6;
246 uiRowStoreSizeLCU[0][2] = 10;
247 uiRowStoreSizeLCU[1][0] = 4;
248 uiRowStoreSizeLCU[1][1] = 8;
249 uiRowStoreSizeLCU[1][2] = 12;
250 }
251 else
252 {
253 uiRowStoreSizeLCU[0][0] = 6;
254 uiRowStoreSizeLCU[0][1] = 8;
255 uiRowStoreSizeLCU[0][2] = 14;
256 uiRowStoreSizeLCU[1][0] = 6;
257 uiRowStoreSizeLCU[1][1] = 10;
258 uiRowStoreSizeLCU[1][2] = 16;
259 }
260 rowStoreSzLCU = uiRowStoreSizeLCU[(maxBitDepth < 12) ? 0 : 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0];
261 bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb;
262 break;
263 }
264 case HCP_INTERNAL_BUFFER_TYPE::SAO_TILE_COL:
265 {
266 // [chroma_format_idc][lcu_size] = [420/422/444][lcu16/lcu32/lcu64]
267 uint32_t formatMultFactorTab[3][3] = {{8, 10, 18}, {10, 14, 24}, {10, 14, 24}};
268 uint32_t formatMultFactor;
269
270 if (chromaFormat == HCP_CHROMA_FORMAT_MONOCHROME)
271 {
272 eStatus = MOS_STATUS_INVALID_PARAMETER;
273 MHW_ASSERTMESSAGE("invalid input chroma format.\n");
274 return eStatus;
275 }
276
277 formatMultFactor = formatMultFactorTab[chromaFormat - 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0];
278 colStoreSzLCU = formatMultFactor;
279 bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb;
280 break;
281 }
282 case HCP_INTERNAL_BUFFER_TYPE::HSAO_RS:
283 {
284 uint32_t maxTileColumn = MOS_ROUNDUP_DIVIDE(par.dwPicWidth, 128);
285 bufferSize = MOS_ALIGN_CEIL(widthInCtb + 3 * maxTileColumn, 4) * 16;
286 break;
287 }
288 //Add HSSE here
289 case HCP_INTERNAL_BUFFER_TYPE::CURR_MV_TEMPORAL:
290 mvtSize = ((((par.dwPicWidth + 63) >> 6) * (((par.dwPicHeight + 15) >> 4)) + 1) & (-2));
291 mvtbSize = ((((par.dwPicWidth + 31) >> 5) * (((par.dwPicHeight + 31) >> 5)) + 1) & (-2));
292 bufferSize = MOS_MAX(mvtSize, mvtbSize) * MHW_CACHELINE_SIZE;
293 break;
294 case HCP_INTERNAL_BUFFER_TYPE::CABAC_STREAMOUT:
295 //From sas, cabac stream out buffer size =
296 //(#LCU) in picture * (Worst case LCU_CU_TU_info) + 1 byte aligned per LCU + Bitstream Size * 3
297 if ((chromaFormat == HCP_CHROMA_FORMAT_YUV420) && (maxBitDepth == 8))
298 {
299 bufferSize = widthInCtb * heightInCtb * MHW_HCP_WORST_CASE_CU_TU_INFO + widthInCtb * heightInCtb + maxFrameSize * 3;
300 }
301 else
302 {
303 bufferSize = widthInCtb * heightInCtb * MHW_HCP_WORST_CASE_CU_TU_INFO_REXT + widthInCtb * heightInCtb + maxFrameSize * 3;
304 }
305 bufferSize = MOS_ALIGN_CEIL(bufferSize, MHW_CACHELINE_SIZE);
306 break;
307 default:
308 eStatus = MOS_STATUS_INVALID_PARAMETER;
309 break;
310 }
311
312 size = bufferSize;
313
314 return eStatus;
315 }
316
317 MOS_STATUS GetVP9BufSize(const HcpBufferSizePar &par, uint32_t &size) override
318 {
319 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
320
321 MHW_FUNCTION_ENTER;
322
323 uint32_t bufferSize = 0;
324 uint32_t dblkRsbSizeMultiplier = 0;
325 uint32_t dblkCsbSizeMultiplier = 0;
326 uint32_t intraPredMultiplier = 0;
327
328 uint8_t maxBitDepth = par.ucMaxBitDepth;
329 uint32_t widthInSb = par.dwPicWidth;
330 uint32_t heightInSb = par.dwPicHeight;
331 uint32_t widthInMinCb = widthInSb * 64 / 8; //using smallest cb to get max width
332 uint32_t heightInMinCb = heightInSb * 64 / 8;
333 HCP_CHROMA_FORMAT_IDC chromaFormat = (HCP_CHROMA_FORMAT_IDC)par.ucChromaFormat;
334 uint32_t maxFrameSize = par.dwMaxFrameSize;
335
336 if (chromaFormat == HCP_CHROMA_FORMAT_YUV420)
337 {
338 dblkRsbSizeMultiplier = (maxBitDepth > 8) ? 36 : 18;
339 dblkCsbSizeMultiplier = (maxBitDepth > 8) ? 34 : 17;
340 intraPredMultiplier = (maxBitDepth > 8) ? 4 : 2;
341 }
342 else if (chromaFormat == HCP_CHROMA_FORMAT_YUV444)
343 {
344 dblkRsbSizeMultiplier = (maxBitDepth > 8) ? 54 : 27;
345 dblkCsbSizeMultiplier = (maxBitDepth > 8) ? 50 : 25;
346 intraPredMultiplier = (maxBitDepth > 8) ? 6 : 3;
347 }
348 else
349 {
350 eStatus = MOS_STATUS_INVALID_PARAMETER;
351 MHW_ASSERTMESSAGE("Format not supported.");
352 return eStatus;
353 }
354
355 switch (par.bufferType)
356 {
357 case HCP_INTERNAL_BUFFER_TYPE::DBLK_LINE:
358 case HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_LINE:
359 bufferSize = widthInSb * dblkRsbSizeMultiplier * MHW_CACHELINE_SIZE;
360 break;
361 case HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_COL:
362 bufferSize = heightInSb * dblkCsbSizeMultiplier * MHW_CACHELINE_SIZE;
363 break;
364 case HCP_INTERNAL_BUFFER_TYPE::META_LINE:
365 case HCP_INTERNAL_BUFFER_TYPE::META_TILE_LINE:
366 bufferSize = widthInSb * 5 * MHW_CACHELINE_SIZE;
367 break;
368 case HCP_INTERNAL_BUFFER_TYPE::META_TILE_COL:
369 bufferSize = heightInSb * 5 * MHW_CACHELINE_SIZE;
370 break;
371 case HCP_INTERNAL_BUFFER_TYPE::CURR_MV_TEMPORAL:
372 case HCP_INTERNAL_BUFFER_TYPE::COLL_MV_TEMPORAL:
373 bufferSize = widthInSb * heightInSb * 9 * MHW_CACHELINE_SIZE;
374 break;
375 case HCP_INTERNAL_BUFFER_TYPE::SEGMENT_ID:
376 bufferSize = widthInSb * heightInSb * MHW_CACHELINE_SIZE;
377 break;
378 case HCP_INTERNAL_BUFFER_TYPE::HVD_LINE:
379 case HCP_INTERNAL_BUFFER_TYPE::HVD_TILE:
380 bufferSize = widthInSb * MHW_CACHELINE_SIZE;
381 break;
382 // scalable mode specific buffers
383 case HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_UP_RIGHT_COL:
384 case HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_LFT_RECON_COL:
385 bufferSize = intraPredMultiplier * heightInSb * MHW_CACHELINE_SIZE;
386 break;
387 case HCP_INTERNAL_BUFFER_TYPE::CABAC_STREAMOUT:
388 // From sas, cabac stream out buffer size =
389 // (#LCU) in picture * (Worst case LCU_CU_TU_info) + 1 byte aligned per LCU + Bitstream Size * 3
390 if ((chromaFormat == HCP_CHROMA_FORMAT_YUV420) && (maxBitDepth == 8))
391 {
392 bufferSize = widthInMinCb * heightInMinCb * MHW_HCP_WORST_CASE_CU_TU_INFO + widthInMinCb * heightInMinCb + maxFrameSize * 3;
393 }
394 else
395 {
396 bufferSize = widthInMinCb * heightInMinCb * MHW_HCP_WORST_CASE_CU_TU_INFO_REXT + widthInMinCb * heightInMinCb + maxFrameSize * 3;
397 }
398 bufferSize = MOS_ALIGN_CEIL(bufferSize, MHW_CACHELINE_SIZE);
399 break;
400 default:
401 eStatus = MOS_STATUS_INVALID_PARAMETER;
402 break;
403 }
404
405 size = bufferSize;
406
407 return eStatus;
408 }
409
410 const HcpMmioRegisters *GetMmioRegisters(const MHW_VDBOX_NODE_IND index) const override
411 {
412 MHW_FUNCTION_ENTER;
413
414 if (index < MHW_VDBOX_NODE_MAX)
415 {
416 return &m_mmioRegisters[index];
417 }
418 else
419 {
420 MHW_ASSERT("index is out of range!");
421 return &m_mmioRegisters[MHW_VDBOX_NODE_1];
422 }
423 }
424
425 uint32_t GetEncCuRecordSize() override
426 {
427 return 8 * sizeof(uint32_t);
428 }
429
430 uint32_t GetHcpPakObjSize() override
431 {
432 return 8;
433 }
434
435 MOS_STATUS SetRowstoreCachingOffsets(const HcpVdboxRowStorePar &rowstoreParams) override
436 {
437 MHW_FUNCTION_ENTER;
438
439 bool is8bit = rowstoreParams.ucBitDepthMinus8 == 0;
440 bool is10bit = rowstoreParams.ucBitDepthMinus8 == 1 || rowstoreParams.ucBitDepthMinus8 == 2;
441 bool is12bit = rowstoreParams.ucBitDepthMinus8 > 2;
442 bool isLcu32or64 = rowstoreParams.ucLCUSize == 32 || rowstoreParams.ucLCUSize == 64;
443 bool isGt2k = rowstoreParams.dwPicWidth > 2048;
444 bool isGt4k = rowstoreParams.dwPicWidth > 4096;
445 bool isGt8k = rowstoreParams.dwPicWidth > 8192;
446
447 uint32_t index = 0;
448
449 //HCP pipe for both HEVC decoder and HEVC encoder
450 if (rowstoreParams.Mode == CODECHAL_DECODE_MODE_HEVCVLD || rowstoreParams.Mode == CODECHAL_ENCODE_MODE_HEVC)
451 {
452 constexpr bool RowStoreCacheEnableHEVC[16][5] =
453 {
454 { 1, 1, 1, 0, 1 }, { 1, 1, 1, 1, 1 }, { 1, 1, 0, 0, 0 }, { 1, 1, 0, 1, 0 },
455 { 1, 1, 1, 1, 1 }, { 1, 1, 0, 0, 1 }, { 1, 1, 1, 0, 0 }, { 1, 0, 1, 0, 1 },
456 { 1, 1, 1, 0, 0 }, { 1, 0, 1, 0, 1 }, { 1, 1, 1, 1, 1 }, { 1, 1, 0, 1, 1 },
457 { 1, 1, 1, 1, 1 }, { 1, 0, 1, 1, 1 }, { 1, 1, 1, 1, 1 }, { 1, 0, 1, 1, 1 }
458 };
459
460 constexpr uint32_t RowStoreCacheAddrHEVC[16][5] =
461 {
462 { 0, 256, 1280, 0, 2048 }, { 0, 256, 1280, 1824, 1792 }, { 0, 512, 0, 0, 0 }, { 0, 256, 0, 2304, 0 },
463 { 0, 256, 1024, 0, 1792 }, { 0, 512, 0, 0, 2048 }, { 0, 256, 1792, 0, 0 }, { 0, 0, 512, 0, 2048 },
464 { 0, 256, 1792, 0, 0 }, { 0, 0, 256, 0, 1792 }, { 0, 256, 1024, 1568, 1536 }, { 0, 512, 0, 2112, 2048 },
465 { 0, 256, 1792, 2336, 2304 }, { 0, 0, 512, 1600, 1536 }, { 0, 128, 1664, 2336, 2304 }, { 0, 0, 256, 1600, 1536 }
466 };
467 m_hevcDatRowStoreCache.enabled = false;
468 m_hevcDatRowStoreCache.dwAddress = 0;
469 m_hevcDfRowStoreCache.enabled = false;
470 m_hevcDfRowStoreCache.dwAddress = 0;
471 m_hevcSaoRowStoreCache.enabled = false;
472 m_hevcSaoRowStoreCache.dwAddress = 0;
473 m_hevcHSaoRowStoreCache.enabled = false;
474 m_hevcHSaoRowStoreCache.dwAddress = 0;
475
476 if (isGt8k)
477 {
478 return MOS_STATUS_SUCCESS;
479 }
480
481 if ((rowstoreParams.ucChromaFormat == HCP_CHROMA_FORMAT_YUV420) ||
482 (rowstoreParams.ucChromaFormat == HCP_CHROMA_FORMAT_YUV422))
483 {
484 index = 2 * isGt4k + isLcu32or64;
485 }
486 else if (rowstoreParams.ucChromaFormat == HCP_CHROMA_FORMAT_YUV444)
487 {
488 uint32_t subidx = is12bit ? 2 : (is10bit ? 1 : 0);
489 index = 4 + 6 * isLcu32or64 + 2 * subidx + isGt4k;
490 }
491 else
492 {
493 return MOS_STATUS_SUCCESS;
494 }
495
496 if (m_hevcDatRowStoreCache.supported)
497 {
498 m_hevcDatRowStoreCache.enabled = RowStoreCacheEnableHEVC[index][0];
499 m_hevcDatRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][0];
500 }
501
502 if (m_hevcDfRowStoreCache.supported)
503 {
504 m_hevcDfRowStoreCache.enabled = RowStoreCacheEnableHEVC[index][1];
505 m_hevcDfRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][1];
506 }
507
508 if (m_hevcSaoRowStoreCache.supported)
509 {
510 m_hevcSaoRowStoreCache.enabled = RowStoreCacheEnableHEVC[index][2];
511 m_hevcSaoRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][2];
512 }
513
514 if (m_hevcHSaoRowStoreCache.supported)
515 {
516 m_hevcHSaoRowStoreCache.enabled = RowStoreCacheEnableHEVC[index][4];
517 m_hevcHSaoRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][4];
518 }
519 }
520
521 if (rowstoreParams.Mode == CODECHAL_DECODE_MODE_VP9VLD || rowstoreParams.Mode == CODECHAL_ENCODE_MODE_VP9)
522 {
523 constexpr bool RowStoreCacheEnableVP9[13][4] =
524 {
525 { 1, 1, 1, 1 }, { 0, 0, 1, 1 }, { 1, 0, 1, 1 }, { 1, 1, 0, 1 },
526 { 1, 1, 1, 1 }, { 0, 0, 1, 1 }, { 0, 0, 1, 0 }, { 1, 1, 0, 1 },
527 { 1, 1, 1, 1 }, { 1, 1, 0, 1 }, { 1, 1, 1, 1 }, { 1, 1, 0, 1 },
528 { 1, 1, 0, 1 }
529 };
530
531 constexpr uint32_t RowStoreCacheAddrVP9[13][4] =
532 {
533 { 0, 64, 384, 1536, }, { 0, 0, 0, 2304, }, { 0, 0, 64, 2368, }, { 0, 128, 0, 768, },
534 { 0, 64, 384, 1536, }, { 0, 0, 0, 2304, }, { 0, 0, 0, 0, }, { 0, 128, 0, 768, },
535 { 0, 64, 384, 2112, }, { 0, 128, 0, 768, }, { 0, 32, 192, 1920, }, { 0, 128, 0, 768, },
536 { 0, 128, 0, 768, }
537 };
538
539 m_vp9HvdRowStoreCache.enabled = false;
540 m_vp9HvdRowStoreCache.dwAddress = 0;
541 m_vp9DatRowStoreCache.enabled = false;
542 m_vp9DatRowStoreCache.dwAddress = 0;
543 m_vp9DfRowStoreCache.enabled = false;
544 m_vp9DfRowStoreCache.dwAddress = 0;
545
546 if (isGt8k)
547 {
548 return MOS_STATUS_SUCCESS;
549 }
550
551 if ((rowstoreParams.ucChromaFormat >= HCP_CHROMA_FORMAT_YUV420) &&
552 (rowstoreParams.ucChromaFormat <= HCP_CHROMA_FORMAT_YUV444))
553 {
554 index = 4 * (rowstoreParams.ucChromaFormat - HCP_CHROMA_FORMAT_YUV420) + 2 * (!is8bit) + isGt4k;
555 }
556 else
557 {
558 return MOS_STATUS_SUCCESS;
559 }
560
561 if (rowstoreParams.ucChromaFormat == HCP_CHROMA_FORMAT_YUV444 && !is8bit)
562 {
563 index += isGt2k;
564 }
565
566 if (m_vp9HvdRowStoreCache.supported)
567 {
568 m_vp9HvdRowStoreCache.enabled = RowStoreCacheEnableVP9[index][0];
569 m_vp9HvdRowStoreCache.dwAddress = RowStoreCacheAddrVP9[index][0];
570 }
571
572 if (m_vp9DatRowStoreCache.supported)
573 {
574 m_vp9DatRowStoreCache.enabled = RowStoreCacheEnableVP9[index][1];
575 m_vp9DatRowStoreCache.dwAddress = RowStoreCacheAddrVP9[index][1];
576 }
577
578 if (m_vp9DfRowStoreCache.supported)
579 {
580 m_vp9DfRowStoreCache.enabled = RowStoreCacheEnableVP9[index][2];
581 m_vp9DfRowStoreCache.dwAddress = RowStoreCacheAddrVP9[index][2];
582 }
583 }
584
585 return MOS_STATUS_SUCCESS;
586 }
587
588 bool IsRowStoreCachingSupported() override
589 {
590 return m_rowstoreCachingSupported;
591 }
592
593 uint32_t GetPakHWTileSizeRecordSize() override
594 {
595 return m_pakHWTileSizeRecordSize;
596 }
597
598 MOS_STATUS GetHcpStateCommandSize(
599 uint32_t mode,
600 uint32_t *commandsSize,
601 uint32_t *patchListSize,
602 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params) override
603 {
604 // Just return success here, please implement logic in platform sepecific impl class.
605 return MOS_STATUS_SUCCESS;
606 }
607
608 MOS_STATUS GetHcpPrimitiveCommandSize(
609 uint32_t mode,
610 uint32_t *commandsSize,
611 uint32_t *patchListSize,
612 bool modeSpecific) override
613 {
614 // Just return success here, please implement logic in platform sepecific impl class.
615 return MOS_STATUS_SUCCESS;
616 }
617
618 private:
619 bool m_rowstoreCachingSupported = false;
620 uint32_t m_pakHWTileSizeRecordSize = sizeof(HCPPakHWTileSizeRecord);
621
622 virtual MOS_STATUS InitRowstoreUserFeatureSettings()
623 {
624 MHW_FUNCTION_ENTER;
625
626 bool rowstoreCachingDisableDefaultValue = false;
627 if (m_osItf->bSimIsActive)
628 {
629 // Disable RowStore Cache on simulation by default
630 rowstoreCachingDisableDefaultValue = true;
631 }
632 else
633 {
634 rowstoreCachingDisableDefaultValue = false;
635 }
636 m_rowstoreCachingSupported = !rowstoreCachingDisableDefaultValue;
637 #if (_DEBUG || _RELEASE_INTERNAL)
638 auto userSettingPtr = m_osItf->pfnGetUserSettingInstance(m_osItf);
639 {
640 MediaUserSetting::Value outValue;
641 ReadUserSettingForDebug(userSettingPtr,
642 outValue,
643 "Disable RowStore Cache",
644 MediaUserSetting::Group::Device,
645 rowstoreCachingDisableDefaultValue,
646 true);
647 m_rowstoreCachingSupported = !(outValue.Get<bool>());
648 }
649 #endif // _DEBUG || _RELEASE_INTERNAL
650
651 if (m_rowstoreCachingSupported)
652 {
653 m_hevcDatRowStoreCache.supported = true;
654 #if (_DEBUG || _RELEASE_INTERNAL)
655 {
656 MediaUserSetting::Value outValue;
657 ReadUserSettingForDebug(userSettingPtr,
658 outValue,
659 "DisableHevcDatRowStoreCache",
660 MediaUserSetting::Group::Device);
661 m_hevcDatRowStoreCache.supported = !(outValue.Get<bool>());
662 }
663 #endif // _DEBUG || _RELEASE_INTERNAL
664
665 m_hevcDfRowStoreCache.supported = true;
666 #if (_DEBUG || _RELEASE_INTERNAL)
667 {
668 MediaUserSetting::Value outValue;
669 ReadUserSettingForDebug(userSettingPtr,
670 outValue,
671 "DisableHevcDfRowStoreCache",
672 MediaUserSetting::Group::Device);
673 m_hevcDfRowStoreCache.supported = !(outValue.Get<bool>());
674 }
675 #endif // _DEBUG || _RELEASE_INTERNAL
676
677 m_hevcSaoRowStoreCache.supported = true;
678 #if (_DEBUG || _RELEASE_INTERNAL)
679 {
680 MediaUserSetting::Value outValue;
681 ReadUserSettingForDebug(userSettingPtr,
682 outValue,
683 "DisableHevcSaoRowStoreCache",
684 MediaUserSetting::Group::Device);
685 m_hevcSaoRowStoreCache.supported = !(outValue.Get<bool>());
686 }
687 #endif // _DEBUG || _RELEASE_INTERNAL
688 m_hevcHSaoRowStoreCache.supported = m_hevcSaoRowStoreCache.supported;
689
690 m_vp9HvdRowStoreCache.supported = true;
691 #if (_DEBUG || _RELEASE_INTERNAL)
692 {
693 MediaUserSetting::Value outValue;
694 ReadUserSettingForDebug(userSettingPtr,
695 outValue,
696 "DisableVp9HvdRowStoreCache",
697 MediaUserSetting::Group::Device);
698 m_vp9HvdRowStoreCache.supported = !(outValue.Get<bool>());
699 }
700 #endif // _DEBUG || _RELEASE_INTERNAL
701
702 m_vp9DatRowStoreCache.supported = true;
703 #if (_DEBUG || _RELEASE_INTERNAL)
704 {
705 MediaUserSetting::Value outValue;
706 ReadUserSettingForDebug(userSettingPtr,
707 outValue,
708 "DisableVp9DatRowStoreCache",
709 MediaUserSetting::Group::Device);
710 m_vp9DatRowStoreCache.supported = !(outValue.Get<bool>());
711 }
712 #endif // _DEBUG || _RELEASE_INTERNAL
713
714 m_vp9DfRowStoreCache.supported = true;
715 #if (_DEBUG || _RELEASE_INTERNAL)
716 {
717 MediaUserSetting::Value outValue;
718 ReadUserSettingForDebug(userSettingPtr,
719 outValue,
720 "DisableVp9DfRowStoreCache",
721 MediaUserSetting::Group::Device);
722 m_vp9DfRowStoreCache.supported = !(outValue.Get<bool>());
723 }
724 #endif // _DEBUG || _RELEASE_INTERNAL
725 }
726
727 return MOS_STATUS_SUCCESS;
728 }
729
730 void InitMmioRegisters()
731 {
732 MHW_FUNCTION_ENTER;
733
734 HcpMmioRegisters *mmioRegisters = &m_mmioRegisters[MHW_VDBOX_NODE_1];
735
736 mmioRegisters->watchdogCountCtrlOffset = WATCHDOG_COUNT_CTRL_OFFSET_INIT;
737 mmioRegisters->watchdogCountThresholdOffset = WATCHDOG_COUNT_THRESTHOLD_OFFSET_INIT;
738 mmioRegisters->hcpDebugFEStreamOutSizeRegOffset = HCP_DEBUG_FE_STREAM_OUT_SIZE_REG_OFFSET_INIT;
739 mmioRegisters->hcpEncImageStatusMaskRegOffset = HCP_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT;
740 mmioRegisters->hcpEncImageStatusCtrlRegOffset = HCP_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT;
741 mmioRegisters->hcpEncBitstreamBytecountFrameRegOffset = HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT;
742 mmioRegisters->hcpEncBitstreamSeBitcountFrameRegOffset = HCP_ENC_BIT_STREAM_SE_BIT_COUNT_FRAME_REG_OFFSET_INIT;
743 mmioRegisters->hcpEncBitstreamBytecountFrameNoHeaderRegOffset = HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT;
744 mmioRegisters->hcpEncQpStatusCountRegOffset = HCP_ENC_QP_STATUS_COUNT_REG_OFFSET_INIT;
745 mmioRegisters->hcpEncSliceCountRegOffset = HCP_ENC_SLICE_COUNT_REG_OFFSET_INIT;
746 mmioRegisters->hcpEncVdencModeTimerRegOffset = HCP_ENC_VDENC_MODE_TIMER_REG_OFFSET_INIT;
747 mmioRegisters->hcpVp9EncBitstreamBytecountFrameRegOffset = HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT;
748 mmioRegisters->hcpVp9EncBitstreamBytecountFrameNoHeaderRegOffset = HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT;
749 mmioRegisters->hcpVp9EncImageStatusMaskRegOffset = HCP_VP9_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT;
750 mmioRegisters->hcpVp9EncImageStatusCtrlRegOffset = HCP_VP9_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT;
751 mmioRegisters->csEngineIdOffset = CS_ENGINE_ID_OFFSET_INIT;
752 mmioRegisters->hcpDecStatusRegOffset = HCP_DEC_STATUS_REG_OFFSET_INIT;
753 mmioRegisters->hcpCabacStatusRegOffset = HCP_CABAC_STATUS_REG_OFFSET_INIT;
754 mmioRegisters->hcpFrameCrcRegOffset = HCP_FRAME_CRC_REG_OFFSET_INIT;
755
756 m_mmioRegisters[MHW_VDBOX_NODE_2] = m_mmioRegisters[MHW_VDBOX_NODE_1];
757 }
758
759 protected:
760 using base_t = Itf;
761
762 HcpMmioRegisters m_mmioRegisters[MHW_VDBOX_NODE_MAX] = {}; //!< hcp mmio registers
763
764 vdbox::RowStoreCache m_hevcDatRowStoreCache = {};
765 vdbox::RowStoreCache m_hevcDfRowStoreCache = {};
766 vdbox::RowStoreCache m_hevcSaoRowStoreCache = {};
767 vdbox::RowStoreCache m_hevcHSaoRowStoreCache = {};
768 vdbox::RowStoreCache m_vp9HvdRowStoreCache = {};
769 vdbox::RowStoreCache m_vp9DfRowStoreCache = {};
770 vdbox::RowStoreCache m_vp9DatRowStoreCache = {};
771
772 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {};
773
774 Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf)
775 {
776 MHW_FUNCTION_ENTER;
777
778 InitRowstoreUserFeatureSettings();
779 InitMmioRegisters();
780 }
781
782 virtual ~Impl()
783 {
784 MHW_FUNCTION_ENTER;
785
786 #if (_DEBUG || _RELEASE_INTERNAL)
787 if (m_hevcDatRowStoreCache.enabled ||
788 m_hevcDfRowStoreCache.enabled ||
789 m_hevcSaoRowStoreCache.enabled ||
790 m_hevcHSaoRowStoreCache.enabled ||
791 m_vp9HvdRowStoreCache.enabled ||
792 m_vp9DatRowStoreCache.enabled ||
793 m_vp9DfRowStoreCache.enabled)
794 {
795 // Report rowstore cache usage status to regkey
796 ReportUserSettingForDebug(
797 m_userSettingPtr,
798 __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED,
799 1,
800 MediaUserSetting::Group::Device);
801 }
802 #endif
803
804 }
805
806 _MHW_SETCMD_OVERRIDE_DECL(HCP_SURFACE_STATE)
807 {
808 _MHW_SETCMD_CALLBASE(HCP_SURFACE_STATE);
809
810 #define DO_FIELDS() \
811 DO_FIELD(DW1, SurfaceId, params.surfaceStateId); \
812 DO_FIELD(DW1, SurfacePitchMinus1, params.surfacePitchMinus1); \
813 DO_FIELD(DW2, SurfaceFormat, static_cast<uint32_t>(params.surfaceFormat)); \
814 DO_FIELD(DW2, YOffsetForUCbInPixel, params.yOffsetForUCbInPixel); \
815 DO_FIELD(DW3, YOffsetForVCr, params.yOffsetForVCr); \
816 DO_FIELD(DW3, DefaultAlphaValue, params.defaultAlphaValue); \
817 DO_FIELD(DW4, MemoryCompressionEnable, params.refsMmcEnable & (~params.mmcSkipMask)); \
818 DO_FIELD(DW4, CompressionType, params.refsMmcType); \
819 DO_FIELD(DW4, CompressionFormat, params.dwCompressionFormat);
820
821 #include "mhw_hwcmd_process_cmdfields.h"
822 }
823
824 _MHW_SETCMD_OVERRIDE_DECL(HCP_PIC_STATE)
825 {
826 _MHW_SETCMD_CALLBASE(HCP_PIC_STATE);
827
828 #define DO_FIELDS() \
829 DO_FIELD(DW1, Framewidthinmincbminus1, params.framewidthinmincbminus1); \
830 DO_FIELD(DW1, PakTransformSkipEnable, (params.bDecodeInUse ? false : params.transformSkipEnabled)); \
831 DO_FIELD(DW1, Frameheightinmincbminus1, params.frameheightinmincbminus1); \
832 DO_FIELD(DW2, Mincusize, params.mincusize); \
833 DO_FIELD(DW2, CtbsizeLcusize, params.ctbsizeLcusize); \
834 DO_FIELD(DW2, Maxtusize, params.maxtusize); \
835 DO_FIELD(DW2, Mintusize, params.mintusize); \
836 DO_FIELD(DW2, ChromaSubsampling, params.chromaSubsampling); \
837 DO_FIELD(DW2, Minpcmsize, params.minpcmsize); \
838 DO_FIELD(DW2, Maxpcmsize, params.maxpcmsize); \
839 DO_FIELD(DW3, Colpicisi, 0); \
840 DO_FIELD(DW3, Curpicisi, 0); \
841 DO_FIELD(DW3, Log2Maxtransformskipsize, params.log2Maxtransformskipsize); \
842 DO_FIELD(DW4, SampleAdaptiveOffsetEnabledFlag, params.sampleAdaptiveOffsetEnabled); \
843 DO_FIELD(DW4, PcmEnabledFlag, params.pcmEnabledFlag); \
844 DO_FIELD(DW4, CuQpDeltaEnabledFlag, params.cuQpDeltaEnabledFlag); \
845 DO_FIELD(DW4, DiffCuQpDeltaDepthOrNamedAsMaxDqpDepth, params.diffCuQpDeltaDepth); \
846 DO_FIELD(DW4, PcmLoopFilterDisableFlag, params.pcmLoopFilterDisableFlag); \
847 DO_FIELD(DW4, ConstrainedIntraPredFlag, params.constrainedIntraPredFlag); \
848 DO_FIELD(DW4, Log2ParallelMergeLevelMinus2, params.log2ParallelMergeLevelMinus2); \
849 DO_FIELD(DW4, SignDataHidingFlag, params.signDataHidingFlag); \
850 DO_FIELD(DW4, EntropyCodingSyncEnabledFlag, params.entropyCodingSyncEnabled); \
851 DO_FIELD(DW4, WeightedPredFlag, params.weightedPredFlag); \
852 DO_FIELD(DW4, WeightedBipredFlag, params.weightedBipredFlag); \
853 DO_FIELD(DW4, Fieldpic, params.fieldpic); \
854 DO_FIELD(DW4, Bottomfield, params.bottomfield); \
855 DO_FIELD(DW4, AmpEnabledFlag, params.ampEnabledFlag); \
856 DO_FIELD(DW4, TransquantBypassEnableFlag, params.transquantBypassEnableFlag); \
857 DO_FIELD(DW4, StrongIntraSmoothingEnableFlag, params.strongIntraSmoothingEnableFlag); \
858 DO_FIELD(DW4, CuPacketStructure, 0); \
859 DO_FIELD(DW4, TransformSkipEnabledFlag, params.transformSkipEnabled); \
860 DO_FIELD(DW4, TilesEnabledFlag, params.tilesEnabledFlag); \
861 DO_FIELD(DW4, LoopFilterAcrossTilesEnabledFlag, params.loopFilterAcrossTilesEnabled); \
862 DO_FIELD(DW5, PicCbQpOffset, params.picCbQpOffset); \
863 DO_FIELD(DW5, PicCrQpOffset, params.picCrQpOffset); \
864 DO_FIELD(DW5, MaxTransformHierarchyDepthIntraOrNamedAsTuMaxDepthIntra, params.maxTransformHierarchyDepthIntra); \
865 DO_FIELD(DW5, MaxTransformHierarchyDepthInterOrNamedAsTuMaxDepthInter, params.maxTransformHierarchyDepthInter); \
866 DO_FIELD(DW5, PcmSampleBitDepthChromaMinus1, params.pcmSampleBitDepthChromaMinus1); \
867 DO_FIELD(DW5, PcmSampleBitDepthLumaMinus1, params.pcmSampleBitDepthLumaMinus1); \
868 DO_FIELD(DW5, BitDepthChromaMinus8, params.bitDepthChromaMinus8); \
869 DO_FIELD(DW5, BitDepthLumaMinus8, params.bitDepthLumaMinus8); \
870 DO_FIELD(DW6, LcuMaxBitsizeAllowed, params.lcuMaxBitsizeAllowed); \
871 DO_FIELD(DW6, Nonfirstpassflag, params.bNotFirstPass); \
872 DO_FIELD(DW6, LcuMaxBitSizeAllowedMsb2its, params.lcuMaxBitSizeAllowedMsb2its); \
873 DO_FIELD(DW6, LcumaxbitstatusenLcumaxsizereportmask, 0); \
874 DO_FIELD(DW6, FrameszoverstatusenFramebitratemaxreportmask, 0); \
875 DO_FIELD(DW6, FrameszunderstatusenFramebitrateminreportmask, 0); \
876 DO_FIELD(DW6, LoadSlicePointerFlag, 0); \
877 DO_FIELD(DW18, Minframesize, params.minframesize); \
878 DO_FIELD(DW18, Minframesizeunits, params.minframesizeunits); \
879 DO_FIELD(DW19, RdoqEnable, params.rdoqEnable); \
880 DO_FIELD(DW19, SseEnable, params.sseEnable); \
881 DO_FIELD(DW19, RhodomainRateControlEnable, params.rhodomainRateControlEnable); \
882 DO_FIELD(DW19, Rhodomainframelevelqp, params.rhodomainframelevelqp); \
883 DO_FIELD(DW19, FractionalQpAdjustmentEnable, params.fractionalQpAdjustmentEnable); \
884 DO_FIELD(DW19, FirstSliceSegmentInPicFlag, params.bDecodeInUse ? 0 : 1); \
885 DO_FIELD(DW19, PakDynamicSliceModeEnable, params.pakDynamicSliceModeEnable); \
886 DO_FIELD(DW19, SlicePicParameterSetId, params.slicePicParameterSetId); \
887 DO_FIELD(DW19, Nalunittypeflag, params.nalunittypeflag); \
888 DO_FIELD(DW19, NoOutputOfPriorPicsFlag, params.noOutputOfPriorPicsFlag); \
889 DO_FIELD(DW19, PartialFrameUpdateMode, params.partialFrameUpdateMode); \
890 DO_FIELD(DW19, TemporalMvPredDisable, params.temporalMvPredDisable); \
891 DO_FIELD(DW20, Intratucountbasedrdoqdisable, params.intratucountbasedrdoqdisable); \
892 DO_FIELD(DW21, SliceSizeThresholdInBytes, params.sliceSizeThresholdInBytes); \
893 DO_FIELD(DW22, TargetSliceSizeInBytes, params.targetSliceSizeInBytes); \
894 DO_FIELD(DW34, IntraBoundaryFilteringDisabledFlag, params.intraBoundaryFilteringDisabledFlag); \
895 DO_FIELD(DW34, MotionVectorResolutionControlIdc, params.motionVectorResolutionControlIdc); \
896 DO_FIELD(DW34, PpsCurrPicRefEnabledFlag, params.ppsCurrPicRefEnabledFlag); \
897 DO_FIELD(DW34, IbcMotionCompensationBufferReferenceIdc, params.ibcMotionCompensationBufferReferenceIdc); \
898 DO_FIELD(DW35, IbcConfiguration, params.ibcConfiguration); \
899 DO_FIELD(DW35, PaletteModeEnabledFlag, params.paletteModeEnabledFlag); \
900 DO_FIELD(DW35, MonochromePaletteFlag, 0); \
901 DO_FIELD(DW35, PaletteMaxSize, params.paletteMaxSize); \
902 DO_FIELD(DW35, DeltaPaletteMaxPredictorSize, params.deltaPaletteMaxPredictorSize); \
903 DO_FIELD(DW35, LumaBitDepthEntryMinus8, params.lumaBitDepthEntryMinus8); \
904 DO_FIELD(DW35, ChromaBitDepthEntryMinus8, params.chromaBitDepthEntryMinus8); \
905 DO_FIELD(DW37, Rdoqintratuthreshold, params.rdoqintratuthreshold); \
906 \
907 if (params.bDecodeInUse && params.pHevcExtPicParams) \
908 { \
909 auto hevcExtPicParams = params.pHevcExtPicParams; \
910 DO_FIELD(DW2, ChromaQpOffsetListEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.chroma_qp_offset_list_enabled_flag); \
911 DO_FIELD(DW2, DiffCuChromaQpOffsetDepth, hevcExtPicParams->diff_cu_chroma_qp_offset_depth); \
912 DO_FIELD(DW2, ChromaQpOffsetListLenMinus1, hevcExtPicParams->chroma_qp_offset_list_len_minus1); \
913 DO_FIELD(DW2, Log2SaoOffsetScaleLuma, hevcExtPicParams->log2_sao_offset_scale_luma); \
914 DO_FIELD(DW2, Log2SaoOffsetScaleChroma, hevcExtPicParams->log2_sao_offset_scale_chroma); \
915 DO_FIELD(DW3, CrossComponentPredictionEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.cross_component_prediction_enabled_flag); \
916 DO_FIELD(DW3, CabacBypassAlignmentEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.cabac_bypass_alignment_enabled_flag); \
917 DO_FIELD(DW3, PersistentRiceAdaptationEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.persistent_rice_adaptation_enabled_flag); \
918 DO_FIELD(DW3, IntraSmoothingDisabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.intra_smoothing_disabled_flag); \
919 DO_FIELD(DW3, ExplicitRdpcmEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.explicit_rdpcm_enabled_flag); \
920 DO_FIELD(DW3, ImplicitRdpcmEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.implicit_rdpcm_enabled_flag); \
921 DO_FIELD(DW3, TransformSkipContextEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.transform_skip_context_enabled_flag); \
922 DO_FIELD(DW3, TransformSkipRotationEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.transform_skip_rotation_enabled_flag); \
923 DO_FIELD(DW3, HighPrecisionOffsetsEnableFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.high_precision_offsets_enabled_flag); \
924 DO_FIELD(DW32, CbQpOffsetList0, hevcExtPicParams->cb_qp_offset_list[0]); \
925 DO_FIELD(DW32, CbQpOffsetList1, hevcExtPicParams->cb_qp_offset_list[1]); \
926 DO_FIELD(DW32, CbQpOffsetList2, hevcExtPicParams->cb_qp_offset_list[2]); \
927 DO_FIELD(DW32, CbQpOffsetList3, hevcExtPicParams->cb_qp_offset_list[3]); \
928 DO_FIELD(DW32, CbQpOffsetList4, hevcExtPicParams->cb_qp_offset_list[4]); \
929 DO_FIELD(DW32, CbQpOffsetList5, hevcExtPicParams->cb_qp_offset_list[5]); \
930 DO_FIELD(DW33, CrQpOffsetList0, hevcExtPicParams->cr_qp_offset_list[0]); \
931 DO_FIELD(DW33, CrQpOffsetList1, hevcExtPicParams->cr_qp_offset_list[1]); \
932 DO_FIELD(DW33, CrQpOffsetList2, hevcExtPicParams->cr_qp_offset_list[2]); \
933 DO_FIELD(DW33, CrQpOffsetList3, hevcExtPicParams->cr_qp_offset_list[3]); \
934 DO_FIELD(DW33, CrQpOffsetList4, hevcExtPicParams->cr_qp_offset_list[4]); \
935 DO_FIELD(DW33, CrQpOffsetList5, hevcExtPicParams->cr_qp_offset_list[5]); \
936 } \
937 \
938 if (params.bDecodeInUse && params.pHevcSccPicParams) \
939 { \
940 auto hevcSccPicParams = params.pHevcSccPicParams; \
941 DO_FIELD(DW34, PpsActCrQpOffsetPlus3, hevcSccPicParams->pps_act_cr_qp_offset_plus3); \
942 DO_FIELD(DW34, PpsActCbQpOffsetPlus5, hevcSccPicParams->pps_act_cb_qp_offset_plus5); \
943 DO_FIELD(DW34, PpsActYOffsetPlus5, hevcSccPicParams->pps_act_y_qp_offset_plus5); \
944 DO_FIELD(DW34, PpsSliceActQpOffsetsPresentFlag, hevcSccPicParams->PicSCCExtensionFlags.fields.pps_slice_act_qp_offsets_present_flag); \
945 DO_FIELD(DW34, ResidualAdaptiveColourTransformEnabledFlag, hevcSccPicParams->PicSCCExtensionFlags.fields.residual_adaptive_colour_transform_enabled_flag); \
946 DO_FIELD(DW34, DeblockingFilterOverrideEnabledFlag, params.deblockingFilterOverrideEnabled); \
947 DO_FIELD(DW34, PpsDeblockingFilterDisabledFlag, params.ppsDeblockingFilterDisabled); \
948 DO_FIELD(DW35, IbcMotionVectorErrorHandlingDisable, 0); \
949 } \
950 \
951 if (params.bDecodeInUse && params.requestCRC) \
952 { \
953 DO_FIELD(DW36, FrameCrcEnable, 1); \
954 DO_FIELD(DW36, FrameCrcType, 0); \
955 }
956
957 #include "mhw_hwcmd_process_cmdfields.h"
958 }
959
960 _MHW_SETCMD_OVERRIDE_DECL(HCP_SLICE_STATE)
961 {
962 _MHW_SETCMD_CALLBASE(HCP_SLICE_STATE);
963
964 #define DO_FIELDS() \
965 DO_FIELD(DW1, SlicestartctbxOrSliceStartLcuXEncoder, params.slicestartctbxOrSliceStartLcuXEncoder); \
966 DO_FIELD(DW1, SlicestartctbyOrSliceStartLcuYEncoder, params.slicestartctbyOrSliceStartLcuYEncoder); \
967 DO_FIELD(DW2, NextslicestartctbxOrNextSliceStartLcuXEncoder, params.nextslicestartctbxOrNextSliceStartLcuXEncoder); \
968 DO_FIELD(DW2, NextslicestartctbyOrNextSliceStartLcuYEncoder, params.nextslicestartctbyOrNextSliceStartLcuYEncoder); \
969 DO_FIELD(DW3, SliceType, params.sliceType); \
970 DO_FIELD(DW3, Lastsliceofpic, params.lastsliceofpic); \
971 DO_FIELD(DW3, SliceqpSignFlag, params.sliceqpSignFlag); \
972 DO_FIELD(DW3, DependentSliceFlag, params.dependentSliceFlag); \
973 DO_FIELD(DW3, SliceTemporalMvpEnableFlag, params.sliceTemporalMvpEnableFlag); \
974 DO_FIELD(DW3, Sliceqp, params.sliceqp); \
975 DO_FIELD(DW3, SliceCbQpOffset, params.sliceCbQpOffset); \
976 DO_FIELD(DW3, SliceCrQpOffset, params.sliceCrQpOffset); \
977 DO_FIELD(DW3, Intrareffetchdisable, params.intrareffetchdisable); \
978 DO_FIELD(DW3, Lastsliceoftile, params.lastSliceInTile); \
979 DO_FIELD(DW3, Lastsliceoftilecolumn, params.lastSliceInTileColumn); \
980 DO_FIELD(DW3, CuChromaQpOffsetEnabledFlag, params.cuChromaQpOffsetEnable); \
981 DO_FIELD(DW4, SliceHeaderDisableDeblockingFilterFlag, params.deblockingFilterDisable); \
982 DO_FIELD(DW4, SliceTcOffsetDiv2OrFinalTcOffsetDiv2Encoder, params.tcOffsetDiv2); \
983 DO_FIELD(DW4, SliceBetaOffsetDiv2OrFinalBetaOffsetDiv2Encoder, params.betaOffsetDiv2); \
984 DO_FIELD(DW4, SliceLoopFilterAcrossSlicesEnabledFlag, params.loopFilterAcrossSlicesEnabled); \
985 DO_FIELD(DW4, SliceSaoChromaFlag, params.saoChromaFlag); \
986 DO_FIELD(DW4, SliceSaoLumaFlag, params.saoLumaFlag); \
987 DO_FIELD(DW4, MvdL1ZeroFlag, params.mvdL1ZeroFlag); \
988 DO_FIELD(DW4, Islowdelay, params.isLowDelay); \
989 DO_FIELD(DW4, CollocatedFromL0Flag, params.collocatedFromL0Flag); \
990 DO_FIELD(DW4, Chromalog2Weightdenom, params.chromalog2Weightdenom); \
991 DO_FIELD(DW4, LumaLog2WeightDenom, params.lumaLog2WeightDenom); \
992 DO_FIELD(DW4, CabacInitFlag, params.cabacInitFlag); \
993 DO_FIELD(DW4, Maxmergeidx, params.maxmergeidx); \
994 DO_FIELD(DW4, Collocatedrefidx, params.collocatedrefidx); \
995 DO_FIELD(DW5, Sliceheaderlength, params.sliceheaderlength); \
996 DO_FIELD(DW6, Roundinter, params.roundinter); \
997 DO_FIELD(DW6, Roundintra, params.roundintra); \
998 DO_FIELD(DW7, Cabaczerowordinsertionenable, params.cabaczerowordinsertionenable); \
999 DO_FIELD(DW7, Emulationbytesliceinsertenable, params.emulationbytesliceinsertenable); \
1000 DO_FIELD(DW7, TailInsertionEnable, params.tailInsertionEnable); \
1001 DO_FIELD(DW7, SlicedataEnable, params.slicedataEnable); \
1002 DO_FIELD(DW7, HeaderInsertionEnable, params.headerInsertionEnable); \
1003 DO_FIELD(DW7, DependentSliceDueToTileSplit, params.bIsNotFirstTile); \
1004 DO_FIELD(DW8, IndirectPakBseDataStartOffsetWrite, params.indirectPakBseDataStartOffsetWrite); \
1005 DO_FIELD(DW9, TransformskipLambda, params.transformskiplambda); \
1006 DO_FIELD(DW10, TransformskipNumzerocoeffsFactor0, params.transformskipNumzerocoeffsFactor0); \
1007 DO_FIELD(DW10, TransformskipNumnonzerocoeffsFactor0, params.transformskipNumnonzerocoeffsFactor0); \
1008 DO_FIELD(DW10, TransformskipNumzerocoeffsFactor1, params.transformskipNumzerocoeffsFactor1); \
1009 DO_FIELD(DW10, TransformskipNumnonzerocoeffsFactor1, params.transformskipNumnonzerocoeffsFactor1); \
1010 DO_FIELD(DW11, Originalslicestartctbx, params.originalSliceStartCtbX); \
1011 DO_FIELD(DW11, Originalslicestartctby, params.originalSliceStartCtbY); \
1012 DO_FIELD(DW12, SliceActYQpOffset, params.sliceActYQpOffset); \
1013 DO_FIELD(DW12, SliceActCbQpOffset, params.sliceActCbQpOffset); \
1014 DO_FIELD(DW12, SliceActCrQpOffset, params.sliceActCrQpOffset); \
1015 DO_FIELD(DW12, UseIntegerMvFlag, params.useIntegerMvFlag);
1016
1017 #include "mhw_hwcmd_process_cmdfields.h"
1018 }
1019
1020 _MHW_SETCMD_OVERRIDE_DECL(HCP_IND_OBJ_BASE_ADDR_STATE)
1021 {
1022 _MHW_SETCMD_CALLBASE(HCP_IND_OBJ_BASE_ADDR_STATE);
1023
1024 MHW_RESOURCE_PARAMS resourceParams;
1025 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1026 resourceParams.dwLsbNum = MHW_VDBOX_HCP_UPPER_BOUND_STATE_SHIFT;
1027 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
1028
1029 if (params.bDecodeInUse)
1030 {
1031 MHW_MI_CHK_NULL(params.presDataBuffer);
1032
1033 InitMocsParams(resourceParams, &cmd.HcpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value, 1, 6);
1034
1035 resourceParams.presResource = params.presDataBuffer;
1036 resourceParams.dwOffset = params.dwDataOffset;
1037 resourceParams.pdwCmd = (cmd.HcpIndirectBitstreamObjectBaseAddress.DW0_1.Value);
1038 resourceParams.dwLocationInCmd = 1;
1039 resourceParams.dwSize = params.dwDataSize;
1040 resourceParams.bIsWritable = false;
1041
1042 // upper bound of the allocated resource will be set at 3 DW apart from address location
1043 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1044
1045 MHW_MI_CHK_STATUS(AddResourceToCmd(
1046 this->m_osItf,
1047 this->m_currentCmdBuf,
1048 &resourceParams));
1049
1050 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
1051 }
1052
1053 if (!params.bDecodeInUse)
1054 {
1055 if (params.presMvObjectBuffer)
1056 {
1057 resourceParams.presResource = params.presMvObjectBuffer;
1058 resourceParams.dwOffset = params.dwMvObjectOffset;
1059 resourceParams.pdwCmd = (cmd.DW6_7.Value);
1060 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW6_7);
1061 resourceParams.dwSize = MOS_ALIGN_CEIL(params.dwMvObjectSize, 0x1000);
1062 resourceParams.bIsWritable = false;
1063 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
1064
1065 InitMocsParams(resourceParams, &cmd.HcpIndirectCuObjectObjectMemoryAddressAttributes.DW0.Value, 1, 6);
1066
1067 MHW_MI_CHK_STATUS(AddResourceToCmd(
1068 this->m_osItf,
1069 this->m_currentCmdBuf,
1070 &resourceParams));
1071 }
1072
1073 if (params.presPakBaseObjectBuffer)
1074 {
1075 resourceParams.presResource = params.presPakBaseObjectBuffer;
1076 resourceParams.dwOffset = params.presPakBaseObjectBuffer->dwResourceOffset;
1077 resourceParams.pdwCmd = (cmd.DW9_10.Value);
1078 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW9_10);
1079 resourceParams.dwSize = MOS_ALIGN_FLOOR(params.dwPakBaseObjectSize, 0x1000);
1080 resourceParams.bIsWritable = true;
1081 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1082
1083 InitMocsParams(resourceParams, &cmd.HcpPakBseObjectAddressMemoryAddressAttributes.DW0.Value, 1, 6);
1084
1085 MHW_MI_CHK_STATUS(AddResourceToCmd(
1086 this->m_osItf,
1087 this->m_currentCmdBuf,
1088 &resourceParams));
1089
1090 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
1091 }
1092
1093 if (params.presCompressedHeaderBuffer)
1094 {
1095 resourceParams.presResource = params.presCompressedHeaderBuffer;
1096 resourceParams.dwOffset = 0;
1097 resourceParams.pdwCmd = (cmd.DW14_15.Value);
1098 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW14_15);
1099 resourceParams.dwSize = params.dwCompressedHeaderSize;
1100 resourceParams.bIsWritable = false;
1101
1102 InitMocsParams(resourceParams, &cmd.HcpVp9PakCompressedHeaderSyntaxStreaminMemoryAddressAttributes.DW0.Value, 1, 6);
1103
1104 MHW_MI_CHK_STATUS(AddResourceToCmd(
1105 this->m_osItf,
1106 this->m_currentCmdBuf,
1107 &resourceParams));
1108 }
1109
1110 if (params.presProbabilityCounterBuffer)
1111 {
1112 resourceParams.presResource = params.presProbabilityCounterBuffer;
1113 resourceParams.dwOffset = params.dwProbabilityCounterOffset;
1114 resourceParams.pdwCmd = (cmd.DW17_18.Value);
1115 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW17_18);
1116 resourceParams.dwSize = params.dwProbabilityCounterSize;
1117 resourceParams.bIsWritable = true;
1118
1119 InitMocsParams(resourceParams, &cmd.HcpVp9PakProbabilityCounterStreamoutMemoryAddressAttributes.DW0.Value, 1, 6);
1120
1121 MHW_MI_CHK_STATUS(AddResourceToCmd(
1122 this->m_osItf,
1123 this->m_currentCmdBuf,
1124 &resourceParams));
1125 }
1126
1127 if (params.presProbabilityDeltaBuffer)
1128 {
1129 resourceParams.presResource = params.presProbabilityDeltaBuffer;
1130 resourceParams.dwOffset = 0;
1131 resourceParams.pdwCmd = (cmd.DW20_21.Value);
1132 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW20_21);
1133 resourceParams.dwSize = params.dwProbabilityDeltaSize;
1134 resourceParams.bIsWritable = false;
1135
1136 InitMocsParams(resourceParams, &cmd.HcpVp9PakProbabilityDeltasStreaminMemoryAddressAttributes.DW0.Value, 1, 6);
1137
1138 MHW_MI_CHK_STATUS(AddResourceToCmd(
1139 this->m_osItf,
1140 this->m_currentCmdBuf,
1141 &resourceParams));
1142 }
1143
1144 if (params.presTileRecordBuffer)
1145 {
1146 resourceParams.presResource = params.presTileRecordBuffer;
1147 resourceParams.dwOffset = 0;
1148 resourceParams.pdwCmd = (cmd.DW23_24.Value);
1149 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW23_24);
1150 resourceParams.dwSize = params.dwTileRecordSize;
1151 resourceParams.bIsWritable = true;
1152
1153 InitMocsParams(resourceParams, &cmd.HcpVp9PakTileRecordStreamoutMemoryAddressAttributes.DW0.Value, 1, 6);
1154
1155 MHW_MI_CHK_STATUS(AddResourceToCmd(
1156 this->m_osItf,
1157 this->m_currentCmdBuf,
1158 &resourceParams));
1159 }
1160 else if (params.presPakTileSizeStasBuffer)
1161 {
1162 resourceParams.presResource = params.presPakTileSizeStasBuffer;
1163 resourceParams.dwOffset = params.dwPakTileSizeRecordOffset;
1164 resourceParams.pdwCmd = (cmd.DW23_24.Value);
1165 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW23_24);
1166 resourceParams.dwSize = params.dwPakTileSizeStasBufferSize;
1167 resourceParams.bIsWritable = WRITE_WA;
1168
1169 InitMocsParams(resourceParams, &cmd.HcpVp9PakTileRecordStreamoutMemoryAddressAttributes.DW0.Value, 1, 6);
1170
1171 MHW_MI_CHK_STATUS(AddResourceToCmd(
1172 this->m_osItf,
1173 this->m_currentCmdBuf,
1174 &resourceParams));
1175 }
1176 }
1177
1178 return MOS_STATUS_SUCCESS;
1179 }
1180
1181 _MHW_SETCMD_OVERRIDE_DECL(HCP_QM_STATE)
1182 {
1183 _MHW_SETCMD_CALLBASE(HCP_QM_STATE);
1184
1185 for (uint8_t i = 0; i < 16; i++)
1186 {
1187 cmd.Quantizermatrix[i] = params.quantizermatrix[i];
1188 }
1189
1190 cmd.DW1.PredictionType = params.predictionType;
1191 cmd.DW1.Sizeid = params.sizeid;
1192 cmd.DW1.ColorComponent = params.colorComponent;
1193 cmd.DW1.DcCoefficient = params.dcCoefficient;
1194
1195 return MOS_STATUS_SUCCESS;
1196 }
1197
1198 _MHW_SETCMD_OVERRIDE_DECL(HCP_BSD_OBJECT)
1199 {
1200 _MHW_SETCMD_CALLBASE(HCP_BSD_OBJECT);
1201
1202 #define DO_FIELDS() \
1203 DO_FIELD(DW1, IndirectBsdDataLength, params.bsdDataLength); \
1204 DO_FIELD(DW2, IndirectDataStartAddress, params.bsdDataStartOffset);
1205
1206 #include "mhw_hwcmd_process_cmdfields.h"
1207 }
1208
1209 _MHW_SETCMD_OVERRIDE_DECL(HCP_TILE_STATE)
1210 {
1211 _MHW_SETCMD_CALLBASE(HCP_TILE_STATE);
1212
1213 cmd.DW1.Numtilecolumnsminus1 = params.numTileColumnsMinus1;
1214 cmd.DW1.Numtilerowsminus1 = params.numTileRowsMinus1;
1215
1216 uint32_t column = params.numTileColumnsMinus1 + 1;
1217 uint32_t lastDwEleNum = column % 4;
1218 uint32_t count = column / 4;
1219
1220 for (uint8_t i = 0; i < 5; i++)
1221 {
1222 cmd.CtbColumnPositionOfTileColumn[i].DW0.Value = 0;
1223 }
1224
1225 for (uint8_t i = 0; i < 6; i++)
1226 {
1227 cmd.CtbRowPositionOfTileRow[i].DW0.Value = 0;
1228 }
1229
1230 cmd.CtbColumnPositionMsb.DW0.Value = 0;
1231 cmd.CtbColumnPositionMsb.DW1.Value = 0;
1232 cmd.CtbRowPositionMsb.DW0.Value = 0;
1233 cmd.CtbRowPositionMsb.DW1.Value = 0;
1234
1235 uint32_t colCumulativeValue = 0;
1236 uint32_t rowCumulativeValue = 0;
1237
1238 // Column Position
1239 for (uint32_t i = 0; i < count; i++)
1240 {
1241 uint32_t &CtbColumnMsbValue = ((i << 3) >> 5) == 0 ? cmd.CtbColumnPositionMsb.DW0.Value : cmd.CtbColumnPositionMsb.DW1.Value;
1242
1243 cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos0I = colCumulativeValue & 0xFF; // lower 8bits
1244 CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 0)); // MSB 2bits
1245 colCumulativeValue += params.pTileColWidth[4 * i];
1246
1247 cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos1I = colCumulativeValue & 0xFF; // lower 8bits
1248 CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 2)); // MSB 2bits
1249 colCumulativeValue += params.pTileColWidth[4 * i + 1];
1250
1251 cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos2I = colCumulativeValue & 0xFF; // lower 8bits
1252 CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 4)); // MSB 2bits
1253 colCumulativeValue += params.pTileColWidth[4 * i + 2];
1254
1255 cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos3I = colCumulativeValue & 0xFF; // lower 8bits
1256 CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 6)); // MSB 2bits
1257 colCumulativeValue += params.pTileColWidth[4 * i + 3];
1258 }
1259
1260 if (lastDwEleNum)
1261 {
1262 uint32_t i = count;
1263 uint32_t &CtbColumnMsbValue = ((i << 3) >> 5) == 0 ? cmd.CtbColumnPositionMsb.DW0.Value : cmd.CtbColumnPositionMsb.DW1.Value;
1264
1265 if (i < 5)
1266 {
1267 cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos0I = colCumulativeValue & 0xFF; // lower 8bits
1268 CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 0)); // MSB 2bits
1269
1270 if (lastDwEleNum > 1)
1271 {
1272 colCumulativeValue += params.pTileColWidth[4 * i];
1273 cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos1I = colCumulativeValue & 0xFF; //lower 8bits
1274 CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 2)); // MSB 2bits
1275
1276 if (lastDwEleNum > 2)
1277 {
1278 colCumulativeValue += params.pTileColWidth[4 * i + 1];
1279 cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos2I = colCumulativeValue & 0xFF; //lower 8bits
1280 CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 4)); // MSB 2bits
1281 }
1282 }
1283 }
1284 }
1285
1286 // Row Postion
1287 uint32_t row = params.numTileRowsMinus1 + 1;
1288 lastDwEleNum = row % 4;
1289 count = row / 4;
1290
1291 for (uint32_t i = 0; i < count; i++)
1292 {
1293 uint32_t &CtbRowMsbValue = ((i << 3) >> 5) == 0 ? cmd.CtbRowPositionMsb.DW0.Value : cmd.CtbRowPositionMsb.DW1.Value;
1294
1295 cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos0I = rowCumulativeValue & 0xFF; // lower 8bits
1296 CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 0)); // MSB 2bits
1297 rowCumulativeValue += params.pTileRowHeight[4 * i];
1298
1299 cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos1I = rowCumulativeValue & 0xFF; // lower 8bits
1300 CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 2)); // MSB 2bits
1301 rowCumulativeValue += params.pTileRowHeight[4 * i + 1];
1302
1303 cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos2I = rowCumulativeValue & 0xFF; // lower 8bits
1304 CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 4)); // MSB 2bits
1305 rowCumulativeValue += params.pTileRowHeight[4 * i + 2];
1306
1307 cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos3I = rowCumulativeValue & 0xFF; // lower 8bits
1308 CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 6)); // MSB 2bits
1309 rowCumulativeValue += params.pTileRowHeight[4 * i + 3];
1310 }
1311
1312 if (lastDwEleNum)
1313 {
1314 uint32_t i = count;
1315 uint32_t &CtbRowMsbValue = ((i << 3) >> 5) == 0 ? cmd.CtbRowPositionMsb.DW0.Value : cmd.CtbRowPositionMsb.DW1.Value;
1316
1317 if (i < 6)
1318 {
1319 cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos0I = rowCumulativeValue & 0xFF; // lower 8bits
1320 CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 0)); // MSB 2bits
1321
1322 if (lastDwEleNum > 1)
1323 {
1324 rowCumulativeValue += params.pTileRowHeight[4 * i];
1325 cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos1I = rowCumulativeValue & 0xFF; // lower 8bits
1326 CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 2)); // MSB 2bits
1327
1328 if (lastDwEleNum > 2)
1329 {
1330 rowCumulativeValue += params.pTileRowHeight[4 * i + 1];
1331 cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos2I = rowCumulativeValue & 0xFF; // lower 8bits
1332 CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 4)); // MSB 2bits
1333 }
1334 }
1335 }
1336 }
1337
1338 return MOS_STATUS_SUCCESS;
1339 }
1340
1341 _MHW_SETCMD_OVERRIDE_DECL(HCP_REF_IDX_STATE)
1342 {
1343 _MHW_SETCMD_CALLBASE(HCP_REF_IDX_STATE);
1344
1345 cmd.DW1.Refpiclistnum = params.ucList;
1346 cmd.DW1.NumRefIdxLRefpiclistnumActiveMinus1 = params.numRefIdxLRefpiclistnumActiveMinus1;
1347
1348 for (uint8_t i = 0; i < sizeof(params.fieldPicFlag) / sizeof(params.fieldPicFlag[0]); i++)
1349 {
1350 cmd.Entries[i].DW0.ListEntryLxReferencePictureFrameIdRefaddr07 = params.listEntryLxReferencePictureFrameIdRefaddr07[i];
1351 cmd.Entries[i].DW0.ReferencePictureTbValue = params.referencePictureTbValue[i];
1352 cmd.Entries[i].DW0.Longtermreference = params.longtermreference[i];
1353 cmd.Entries[i].DW0.FieldPicFlag = params.fieldPicFlag[i];
1354 cmd.Entries[i].DW0.BottomFieldFlag = params.bottomFieldFlag[i];
1355 }
1356
1357 if (params.bDecodeInUse && (!params.bDummyReference))
1358 {
1359 for (uint8_t i = (uint8_t)params.ucNumRefForList; i < 16; i++)
1360 {
1361 cmd.Entries[i].DW0.Value = 0x00;
1362 }
1363 }
1364
1365 return MOS_STATUS_SUCCESS;
1366 }
1367
1368 _MHW_SETCMD_OVERRIDE_DECL(HCP_WEIGHTOFFSET_STATE)
1369 {
1370 _MHW_SETCMD_CALLBASE(HCP_WEIGHTOFFSET_STATE);
1371
1372 uint8_t i = 0;
1373 uint8_t refIdx = 0;
1374
1375 cmd.DW1.Refpiclistnum = i = params.ucList;
1376
1377 // Luma
1378 for (refIdx = 0; refIdx < MAX_REF_FRAME_NUM; refIdx++)
1379 {
1380 cmd.Lumaoffsets[refIdx].DW0.DeltaLumaWeightLxI = params.LumaWeights[i][refIdx];
1381 cmd.Lumaoffsets[refIdx].DW0.LumaOffsetLxI = (char)(params.LumaOffsets[i][refIdx] & 0xFF); // lower 8bits
1382 cmd.Lumaoffsets[refIdx].DW0.LumaOffsetLxIMsbyte = (char)((params.LumaOffsets[i][refIdx] >> 8) & 0xFF); // MSB 8bits
1383 }
1384
1385 // Chroma
1386 for (refIdx = 0; refIdx < MAX_REF_FRAME_NUM; refIdx++)
1387 {
1388 // Cb
1389 cmd.Chromaoffsets[refIdx].DW0.DeltaChromaWeightLxI0 = params.ChromaWeights[i][refIdx][0];
1390 cmd.Chromaoffsets[refIdx].DW0.ChromaoffsetlxI0 = params.ChromaOffsets[i][refIdx][0] & 0xFF; // lower 8bits
1391
1392 // Cr
1393 cmd.Chromaoffsets[refIdx].DW0.DeltaChromaWeightLxI1 = params.ChromaWeights[i][refIdx][1];
1394 cmd.Chromaoffsets[refIdx].DW0.ChromaoffsetlxI1 = params.ChromaOffsets[i][refIdx][1] & 0xFF; // lower 8bits
1395 }
1396
1397 for (refIdx = 0; refIdx < MAX_REF_FRAME_NUM - 1; refIdx += 2) // MSB 8bits
1398 {
1399 cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI0Msbyte = (params.ChromaOffsets[i][refIdx][0] >> 8) & 0xFF;
1400 cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI10Msbyte = (params.ChromaOffsets[i][refIdx + 1][0] >> 8) & 0xFF;
1401 cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI1Msbyte = (params.ChromaOffsets[i][refIdx][1] >> 8) & 0xFF;
1402 cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI11Msbyte = (params.ChromaOffsets[i][refIdx + 1][1] >> 8) & 0xFF;
1403 }
1404
1405 // last one
1406 cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI0Msbyte = (params.ChromaOffsets[i][refIdx][0] >> 8) & 0xFF;
1407 cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI1Msbyte = (params.ChromaOffsets[i][refIdx][1] >> 8) & 0xFF;
1408
1409 return MOS_STATUS_SUCCESS;
1410 }
1411
1412 _MHW_SETCMD_OVERRIDE_DECL(HCP_PIPE_MODE_SELECT)
1413 {
1414 _MHW_SETCMD_CALLBASE(HCP_PIPE_MODE_SELECT);
1415
1416 if (params.setProtectionSettings)
1417 {
1418 MHW_CHK_STATUS_RETURN(params.setProtectionSettings(reinterpret_cast<uint32_t *>(&cmd)));
1419 }
1420
1421 #define DO_FIELDS() \
1422 DO_FIELD(DW1, AdvancedRateControlEnable, params.bAdvancedRateControlEnable); \
1423 DO_FIELD(DW1, CodecStandardSelect, params.codecStandardSelect); \
1424 DO_FIELD(DW1, PakPipelineStreamoutEnable, params.bStreamOutEnabled || params.bBRCEnabled || params.pakPiplnStrmoutEnabled); \
1425 DO_FIELD(DW1, DeblockerStreamoutEnable, params.bDeblockerStreamOutEnable); \
1426 DO_FIELD(DW1, VdencMode, params.bVdencEnabled); \
1427 DO_FIELD(DW1, RdoqEnabledFlag, params.bRdoqEnable); \
1428 DO_FIELD(DW1, PakFrameLevelStreamoutEnable, params.bStreamOutEnabled || params.pakFrmLvlStrmoutEnable); \
1429 DO_FIELD(DW1, PipeWorkingMode, params.pipeWorkMode); \
1430 DO_FIELD(DW1, MultiEngineMode, params.multiEngineMode); \
1431 DO_FIELD(DW1, TileBasedEngine, params.bTileBasedReplayMode); \
1432 DO_FIELD(DW1, Vp9DynamicScalingEnable, params.bDynamicScalingEnabled); \
1433 DO_FIELD(DW1, CodecSelect, params.codecSelect); \
1434 DO_FIELD(DW1, PrefetchDisable, params.prefetchDisable); \
1435 DO_FIELD(DW2, MediaSoftResetCounterPer1000Clocks, params.mediaSoftResetCounterPer1000Clocks); \
1436 DO_FIELD(DW6, PhaseIndicator, params.ucPhaseIndicator); \
1437 DO_FIELD(DW6, HevcSeparateTileProgramming, params.bHEVCSeparateTileProgramming);
1438
1439 #include "mhw_hwcmd_process_cmdfields.h"
1440 }
1441
1442 _MHW_SETCMD_OVERRIDE_DECL(HCP_PIPE_BUF_ADDR_STATE)
1443 {
1444 _MHW_SETCMD_CALLBASE(HCP_PIPE_BUF_ADDR_STATE);
1445
1446 MHW_RESOURCE_PARAMS resourceParams;
1447 MOS_SURFACE details;
1448
1449 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1450
1451 // 1. MHW_VDBOX_HCP_GENERAL_STATE_SHIFT(6) may not work with DecodedPicture
1452 // since it needs to be 4k aligned
1453 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
1454 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
1455
1456 // Decoded Picture
1457 cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.PreDeblockSurfMmcState) ? 1 : 0;
1458 cmd.DecodedPictureMemoryAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.PreDeblockSurfMmcState) ? 1 : 0;
1459 //cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(params->psPreDeblockSurface->TileType);
1460
1461 cmd.DecodedPictureMemoryAddressAttributes.DW0.TileMode = GetHwTileType(params.psPreDeblockSurface->TileType, params.psPreDeblockSurface->TileModeGMM, params.psPreDeblockSurface->bGMMTileEnabled);
1462
1463 resourceParams.presResource = &(params.psPreDeblockSurface->OsResource);
1464 resourceParams.dwOffset = params.psPreDeblockSurface->dwOffset;
1465 resourceParams.pdwCmd = (cmd.DecodedPicture.DW0_1.Value);
1466 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DecodedPicture);
1467 resourceParams.bIsWritable = true;
1468
1469 InitMocsParams(resourceParams, &cmd.DecodedPictureMemoryAddressAttributes.DW0.Value, 1, 6);
1470
1471 MHW_MI_CHK_STATUS(AddResourceToCmd(
1472 this->m_osItf,
1473 this->m_currentCmdBuf,
1474 &resourceParams));
1475
1476 // Deblocking Filter Line Buffer
1477 if (m_hevcDfRowStoreCache.enabled)
1478 {
1479 cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockingFilterLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1480 cmd.DeblockingFilterLineBuffer.DW0_1.BaseAddress = m_hevcDfRowStoreCache.dwAddress;
1481 }
1482 else if (m_vp9DfRowStoreCache.enabled)
1483 {
1484 cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockingFilterLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1485 cmd.DeblockingFilterLineBuffer.DW0_1.BaseAddress = m_vp9DfRowStoreCache.dwAddress;
1486 }
1487 else if (params.presMfdDeblockingFilterRowStoreScratchBuffer != nullptr)
1488 {
1489 resourceParams.presResource = params.presMfdDeblockingFilterRowStoreScratchBuffer;
1490 resourceParams.dwOffset = 0;
1491 resourceParams.pdwCmd = (cmd.DeblockingFilterLineBuffer.DW0_1.Value);
1492 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockingFilterLineBuffer);
1493 resourceParams.bIsWritable = true;
1494
1495 InitMocsParams(resourceParams, &cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1496 MHW_MI_CHK_STATUS(AddResourceToCmd(
1497 this->m_osItf,
1498 this->m_currentCmdBuf,
1499 &resourceParams));
1500 }
1501
1502 // Deblocking Filter Tile Line Buffer
1503 if (params.presDeblockingFilterTileRowStoreScratchBuffer != nullptr)
1504 {
1505 resourceParams.presResource = params.presDeblockingFilterTileRowStoreScratchBuffer;
1506 resourceParams.dwOffset = 0;
1507 resourceParams.pdwCmd = (cmd.DeblockingFilterTileLineBuffer.DW0_1.Value);
1508 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockingFilterTileLineBuffer);
1509 resourceParams.bIsWritable = true;
1510
1511 InitMocsParams(resourceParams, &cmd.DeblockingFilterTileLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1512
1513 MHW_MI_CHK_STATUS(AddResourceToCmd(
1514 this->m_osItf,
1515 this->m_currentCmdBuf,
1516 &resourceParams));
1517 }
1518
1519 // Deblocking Filter Tile Column Buffer
1520 if (params.presDeblockingFilterColumnRowStoreScratchBuffer != nullptr)
1521 {
1522 resourceParams.presResource = params.presDeblockingFilterColumnRowStoreScratchBuffer;
1523 resourceParams.dwOffset = 0;
1524 resourceParams.pdwCmd = (cmd.DeblockingFilterTileColumnBuffer.DW0_1.Value);
1525 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockingFilterTileColumnBuffer);
1526 resourceParams.bIsWritable = true;
1527
1528 InitMocsParams(resourceParams, &cmd.DeblockingFilterTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1529
1530 MHW_MI_CHK_STATUS(AddResourceToCmd(
1531 this->m_osItf,
1532 this->m_currentCmdBuf,
1533 &resourceParams));
1534 }
1535
1536 // Metadata Line Buffer
1537 if (m_hevcDatRowStoreCache.enabled)
1538 {
1539 cmd.MetadataLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.MetadataLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1540 cmd.MetadataLineBuffer.DW0_1.BaseAddress = m_hevcDatRowStoreCache.dwAddress;
1541 }
1542 else if (m_vp9DatRowStoreCache.enabled)
1543 {
1544 cmd.MetadataLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.MetadataLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1545 cmd.MetadataLineBuffer.DW0_1.BaseAddress = m_vp9DatRowStoreCache.dwAddress;
1546 }
1547 else if (params.presMetadataLineBuffer != nullptr)
1548 {
1549 resourceParams.presResource = params.presMetadataLineBuffer;
1550 resourceParams.dwOffset = 0;
1551 resourceParams.pdwCmd = (cmd.MetadataLineBuffer.DW0_1.Value);
1552 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MetadataLineBuffer);
1553 resourceParams.bIsWritable = true;
1554
1555 InitMocsParams(resourceParams, &cmd.MetadataLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1556
1557 MHW_MI_CHK_STATUS(AddResourceToCmd(
1558 this->m_osItf,
1559 this->m_currentCmdBuf,
1560 &resourceParams));
1561 }
1562
1563 // Metadata Tile Line Buffer
1564 if (params.presMetadataTileLineBuffer != nullptr)
1565 {
1566 resourceParams.presResource = params.presMetadataTileLineBuffer;
1567 resourceParams.dwOffset = 0;
1568 resourceParams.pdwCmd = (cmd.MetadataTileLineBuffer.DW0_1.Value);
1569 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MetadataTileLineBuffer);
1570 resourceParams.bIsWritable = true;
1571
1572 InitMocsParams(resourceParams, &cmd.MetadataTileLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1573
1574 MHW_MI_CHK_STATUS(AddResourceToCmd(
1575 this->m_osItf,
1576 this->m_currentCmdBuf,
1577 &resourceParams));
1578 }
1579
1580 // Metadata Tile Column Buffer
1581 if (params.presMetadataTileColumnBuffer != nullptr)
1582 {
1583 resourceParams.presResource = params.presMetadataTileColumnBuffer;
1584 resourceParams.dwOffset = 0;
1585 resourceParams.pdwCmd = (cmd.MetadataTileColumnBuffer.DW0_1.Value);
1586 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MetadataTileColumnBuffer);
1587 resourceParams.bIsWritable = true;
1588
1589 InitMocsParams(resourceParams, &cmd.MetadataTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1590
1591 MHW_MI_CHK_STATUS(AddResourceToCmd(
1592 this->m_osItf,
1593 this->m_currentCmdBuf,
1594 &resourceParams));
1595 }
1596
1597 // SAO Line Buffer
1598 if (m_hevcSaoRowStoreCache.enabled)
1599 {
1600 cmd.SaoLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.SaoLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1601 cmd.SaoLineBuffer.DW0_1.BaseAddress = m_hevcSaoRowStoreCache.dwAddress;
1602 }
1603 else if (params.presSaoLineBuffer != nullptr)
1604 {
1605 resourceParams.presResource = params.presSaoLineBuffer;
1606 resourceParams.dwOffset = 0;
1607 resourceParams.pdwCmd = (cmd.SaoLineBuffer.DW0_1.Value);
1608 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SaoLineBuffer);
1609 resourceParams.bIsWritable = true;
1610
1611 InitMocsParams(resourceParams, &cmd.SaoLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1612
1613 MHW_MI_CHK_STATUS(AddResourceToCmd(
1614 this->m_osItf,
1615 this->m_currentCmdBuf,
1616 &resourceParams));
1617 }
1618
1619 // SAO Tile Line Buffer
1620 if (params.presSaoTileLineBuffer != nullptr)
1621 {
1622 resourceParams.presResource = params.presSaoTileLineBuffer;
1623 resourceParams.dwOffset = 0;
1624 resourceParams.pdwCmd = (cmd.SaoTileLineBuffer.DW0_1.Value);
1625 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SaoTileLineBuffer);
1626 resourceParams.bIsWritable = true;
1627
1628 InitMocsParams(resourceParams, &cmd.SaoTileLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1629
1630 MHW_MI_CHK_STATUS(AddResourceToCmd(
1631 this->m_osItf,
1632 this->m_currentCmdBuf,
1633 &resourceParams));
1634 }
1635
1636 // SAO Tile Column Buffer
1637 if (params.presSaoTileColumnBuffer != nullptr)
1638 {
1639 resourceParams.presResource = params.presSaoTileColumnBuffer;
1640 resourceParams.dwOffset = 0;
1641 resourceParams.pdwCmd = (cmd.SaoTileColumnBuffer.DW0_1.Value);
1642 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SaoTileColumnBuffer);
1643 resourceParams.bIsWritable = true;
1644
1645 InitMocsParams(resourceParams, &cmd.SaoTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1646
1647 MHW_MI_CHK_STATUS(AddResourceToCmd(
1648 this->m_osItf,
1649 this->m_currentCmdBuf,
1650 &resourceParams));
1651 }
1652
1653 // Current Motion Vector Temporal Buffer
1654 if (params.presCurMvTempBuffer != nullptr)
1655 {
1656 resourceParams.presResource = params.presCurMvTempBuffer;
1657 resourceParams.dwOffset = 0;
1658 resourceParams.pdwCmd = (cmd.CurrentMotionVectorTemporalBuffer.DW0_1.Value);
1659 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CurrentMotionVectorTemporalBuffer);
1660 resourceParams.bIsWritable = true;
1661
1662 InitMocsParams(resourceParams, &cmd.CurrentMotionVectorTemporalBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1663
1664 MHW_MI_CHK_STATUS(AddResourceToCmd(
1665 this->m_osItf,
1666 this->m_currentCmdBuf,
1667 &resourceParams));
1668 }
1669
1670 bool firstRefPic = true;
1671 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
1672
1673 // NOTE: for both HEVC and VP9, set all the 8 ref pic addresses in HCP_PIPE_BUF_ADDR_STATE command to valid addresses for error concealment purpose
1674 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1675 {
1676 // Reference Picture Buffer
1677 if (params.presReferences[i] != nullptr)
1678 {
1679 MOS_ZeroMemory(&details, sizeof(details));
1680 details.Format = Format_Invalid;
1681 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.presReferences[i], &details));
1682
1683 if (firstRefPic)
1684 {
1685 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
1686 firstRefPic = false;
1687 }
1688
1689 resourceParams.presResource = params.presReferences[i];
1690 resourceParams.pdwCmd = (cmd.ReferencePictureBaseAddressRefaddr07[i].DW0_1.Value);
1691 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
1692 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ReferencePictureBaseAddressRefaddr07[i]);
1693 if (params.IBCRefIdxMask & (1 << i))
1694 {
1695 // Motion Compensation will use this picture to write and read IBC data
1696 resourceParams.bIsWritable = true;
1697 }
1698 else
1699 {
1700 resourceParams.bIsWritable = false;
1701 }
1702
1703 resourceParams.dwSharedMocsOffset = 53 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW53
1704
1705 InitMocsParams(resourceParams, &cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.Value, 1, 6);
1706
1707 MHW_MI_CHK_STATUS(AddResourceToCmd(
1708 this->m_osItf,
1709 this->m_currentCmdBuf,
1710 &resourceParams));
1711 }
1712 }
1713
1714 // Same MMC status for deblock and ref surfaces
1715 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable;
1716 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.CompressionType = cmd.DecodedPictureMemoryAddressAttributes.DW0.CompressionType;
1717
1718 // Reset dwSharedMocsOffset
1719 resourceParams.dwSharedMocsOffset = 0;
1720
1721 // Original Uncompressed Picture Source, Encoder only
1722 if (params.psRawSurface != nullptr)
1723 {
1724 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.RawSurfMmcState) ? 1 : 0;
1725 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.RawSurfMmcState) ? 1 : 0;
1726
1727 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.TileMode = GetHwTileType(params.psRawSurface->TileType, params.psRawSurface->TileModeGMM, params.psRawSurface->bGMMTileEnabled);
1728
1729 resourceParams.presResource = &params.psRawSurface->OsResource;
1730 resourceParams.dwOffset = params.psRawSurface->dwOffset;
1731 resourceParams.pdwCmd = (cmd.OriginalUncompressedPictureSource.DW0_1.Value);
1732 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(OriginalUncompressedPictureSource);
1733 resourceParams.bIsWritable = false;
1734
1735 InitMocsParams(resourceParams, &cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.Value, 1, 6);
1736
1737 MHW_MI_CHK_STATUS(AddResourceToCmd(
1738 this->m_osItf,
1739 this->m_currentCmdBuf,
1740 &resourceParams));
1741 }
1742
1743 // StreamOut Data Destination, Decoder only
1744 if (params.presStreamOutBuffer != nullptr)
1745 {
1746 resourceParams.presResource = params.presStreamOutBuffer;
1747 resourceParams.dwOffset = 0;
1748 resourceParams.pdwCmd = (cmd.StreamoutDataDestination.DW0_1.Value);
1749 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(StreamoutDataDestination);
1750 resourceParams.bIsWritable = true;
1751
1752 InitMocsParams(resourceParams, &cmd.StreamoutDataDestinationMemoryAddressAttributes.DW0.Value, 1, 6);
1753
1754 MHW_MI_CHK_STATUS(AddResourceToCmd(
1755 this->m_osItf,
1756 this->m_currentCmdBuf,
1757 &resourceParams));
1758 }
1759
1760 // Pak Cu Level Streamout Data
1761 if (params.presPakCuLevelStreamoutBuffer != nullptr)
1762 {
1763 resourceParams.presResource = params.presPakCuLevelStreamoutBuffer;
1764 resourceParams.dwOffset = 0;
1765 resourceParams.pdwCmd = (cmd.StreamoutDataDestination.DW0_1.Value);
1766 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(StreamoutDataDestination);
1767 resourceParams.bIsWritable = true;
1768
1769 InitMocsParams(resourceParams, &cmd.StreamoutDataDestinationMemoryAddressAttributes.DW0.Value, 1, 6);
1770
1771 MHW_MI_CHK_STATUS(AddResourceToCmd(
1772 this->m_osItf,
1773 this->m_currentCmdBuf,
1774 &resourceParams));
1775 }
1776
1777 // Decoded Picture Status / Error Buffer Base Address
1778 if (params.presLcuBaseAddressBuffer != nullptr)
1779 {
1780 resourceParams.presResource = params.presLcuBaseAddressBuffer;
1781 resourceParams.dwOffset = params.dwLcuStreamOutOffset;
1782 resourceParams.pdwCmd = (cmd.DecodedPictureStatusErrorBufferBaseAddressOrEncodedSliceSizeStreamoutBaseAddress.DW0_1.Value);
1783 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DecodedPictureStatusErrorBufferBaseAddressOrEncodedSliceSizeStreamoutBaseAddress);
1784 resourceParams.bIsWritable = true;
1785
1786 InitMocsParams(resourceParams, &cmd.DecodedPictureStatusErrorBufferBaseAddressMemoryAddressAttributes.DW0.Value, 1, 6);
1787
1788 MHW_MI_CHK_STATUS(AddResourceToCmd(
1789 this->m_osItf,
1790 this->m_currentCmdBuf,
1791 &resourceParams));
1792 }
1793
1794 // LCU ILDB StreamOut Buffer
1795 if (params.presLcuILDBStreamOutBuffer != nullptr)
1796 {
1797 resourceParams.presResource = params.presLcuILDBStreamOutBuffer;
1798 resourceParams.dwOffset = 0;
1799 resourceParams.pdwCmd = (cmd.LcuIldbStreamoutBuffer.DW0_1.Value);
1800 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LcuIldbStreamoutBuffer);
1801 resourceParams.bIsWritable = true;
1802
1803 InitMocsParams(resourceParams, &cmd.LcuIldbStreamoutBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1804
1805 MHW_MI_CHK_STATUS(AddResourceToCmd(
1806 this->m_osItf,
1807 this->m_currentCmdBuf,
1808 &resourceParams));
1809 }
1810
1811 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1812 {
1813 // Collocated Motion vector Temporal Buffer
1814 if (params.presColMvTempBuffer[i] != nullptr)
1815 {
1816 resourceParams.presResource = params.presColMvTempBuffer[i];
1817 resourceParams.dwOffset = 0;
1818 resourceParams.pdwCmd = (cmd.CollocatedMotionVectorTemporalBuffer07[i].DW0_1.Value);
1819 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CollocatedMotionVectorTemporalBuffer07[i]);
1820 resourceParams.bIsWritable = false;
1821
1822 resourceParams.dwSharedMocsOffset = 82 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW82
1823
1824 InitMocsParams(resourceParams, &cmd.CollocatedMotionVectorTemporalBuffer07MemoryAddressAttributes.DW0.Value, 1, 6);
1825
1826 MHW_MI_CHK_STATUS(AddResourceToCmd(
1827 this->m_osItf,
1828 this->m_currentCmdBuf,
1829 &resourceParams));
1830 }
1831 }
1832
1833 // Reset dwSharedMocsOffset
1834 resourceParams.dwSharedMocsOffset = 0;
1835
1836 // VP9 Probability Buffer
1837 if (params.presVp9ProbBuffer != nullptr)
1838 {
1839 resourceParams.presResource = params.presVp9ProbBuffer;
1840 resourceParams.dwOffset = 0;
1841 resourceParams.pdwCmd = (cmd.Vp9ProbabilityBufferReadWrite.DW0_1.Value);
1842 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9ProbabilityBufferReadWrite);
1843 resourceParams.bIsWritable = true;
1844
1845 resourceParams.dwSharedMocsOffset = 85 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW88
1846
1847 InitMocsParams(resourceParams, &cmd.Vp9ProbabilityBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6);
1848
1849 MHW_MI_CHK_STATUS(AddResourceToCmd(
1850 this->m_osItf,
1851 this->m_currentCmdBuf,
1852 &resourceParams));
1853 }
1854
1855 // Reset dwSharedMocsOffset
1856 resourceParams.dwSharedMocsOffset = 0;
1857
1858 // VP9 Segment Id Buffer
1859 if (params.presVp9SegmentIdBuffer != nullptr)
1860 {
1861 resourceParams.presResource = params.presVp9SegmentIdBuffer;
1862 resourceParams.dwOffset = 0;
1863 resourceParams.pdwCmd = (cmd.DW86_87.Value);
1864 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW86_87);
1865 resourceParams.bIsWritable = true;
1866
1867 resourceParams.dwSharedMocsOffset = 88 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW88
1868
1869 InitMocsParams(resourceParams, &cmd.Vp9SegmentIdBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6);
1870
1871 MHW_MI_CHK_STATUS(AddResourceToCmd(
1872 this->m_osItf,
1873 this->m_currentCmdBuf,
1874 &resourceParams));
1875 }
1876
1877 // Reset dwSharedMocsOffset
1878 resourceParams.dwSharedMocsOffset = 0;
1879
1880 // HVD Line Row Store Buffer
1881 if (m_vp9HvdRowStoreCache.enabled)
1882 {
1883 cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1884 cmd.Vp9HvdLineRowstoreBufferReadWrite.DW0_1.BaseAddress = m_vp9HvdRowStoreCache.dwAddress;
1885 }
1886 else if (params.presHvdLineRowStoreBuffer != nullptr)
1887 {
1888 resourceParams.presResource = params.presHvdLineRowStoreBuffer;
1889 resourceParams.dwOffset = 0;
1890 resourceParams.pdwCmd = (cmd.Vp9HvdLineRowstoreBufferReadWrite.DW0_1.Value);
1891 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9HvdLineRowstoreBufferReadWrite);
1892 resourceParams.bIsWritable = true;
1893
1894 InitMocsParams(resourceParams, &cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6);
1895
1896 MHW_MI_CHK_STATUS(AddResourceToCmd(
1897 this->m_osItf,
1898 this->m_currentCmdBuf,
1899 &resourceParams));
1900 }
1901
1902 // HVC Tile Row Store Buffer
1903 if (params.presHvdTileRowStoreBuffer != nullptr)
1904 {
1905 resourceParams.presResource = params.presHvdTileRowStoreBuffer;
1906 resourceParams.dwOffset = 0;
1907 resourceParams.pdwCmd = (cmd.Vp9HvdTileRowstoreBufferReadWrite.DW0_1.Value);
1908 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9HvdTileRowstoreBufferReadWrite);
1909 resourceParams.bIsWritable = true;
1910
1911 InitMocsParams(resourceParams, &cmd.Vp9HvdTileRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6);
1912
1913 MHW_MI_CHK_STATUS(AddResourceToCmd(
1914 this->m_osItf,
1915 this->m_currentCmdBuf,
1916 &resourceParams));
1917 }
1918
1919 // HEVC SAO row store buffer, HSAO
1920 if (m_hevcHSaoRowStoreCache.enabled)
1921 {
1922 cmd.SaoRowstoreBufferReadWriteMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.SaoRowstoreBufferReadWriteMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1923 cmd.DW95_96.SaoRowstoreBufferBaseAddress = (uint64_t)(m_hevcHSaoRowStoreCache.dwAddress) << 6;
1924 }
1925 else if (params.presSaoRowStoreBuffer != nullptr)
1926 {
1927 resourceParams.presResource = params.presSaoRowStoreBuffer;
1928 resourceParams.dwOffset = 0;
1929 resourceParams.pdwCmd = (cmd.DW95_96.Value);
1930 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW95_96);
1931 resourceParams.bIsWritable = true;
1932
1933 InitMocsParams(resourceParams, &cmd.SaoRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6);
1934
1935 MHW_MI_CHK_STATUS(AddResourceToCmd(
1936 this->m_osItf,
1937 this->m_currentCmdBuf,
1938 &resourceParams));
1939 }
1940
1941 // Frame Statistics Streamout Data Destination Buffer
1942 if (params.presFrameStatStreamOutBuffer != nullptr)
1943 {
1944 resourceParams.presResource = params.presFrameStatStreamOutBuffer;
1945 resourceParams.dwOffset = params.dwFrameStatStreamOutOffset;
1946 resourceParams.pdwCmd = (cmd.FrameStatisticsStreamoutDataDestinationBufferBaseAddress.DW0_1.Value);
1947 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(FrameStatisticsStreamoutDataDestinationBufferBaseAddress);
1948 resourceParams.bIsWritable = true;
1949
1950 InitMocsParams(resourceParams, &cmd.FrameStatisticsStreamoutDataDestinationBufferAttributesReadWrite.DW0.Value, 1, 6);
1951
1952 MHW_MI_CHK_STATUS(AddResourceToCmd(
1953 this->m_osItf,
1954 this->m_currentCmdBuf,
1955 &resourceParams));
1956 }
1957
1958 // SSE Source Pixel Row Store Buffer
1959 if (params.presSseSrcPixelRowStoreBuffer != nullptr)
1960 {
1961 resourceParams.presResource = params.presSseSrcPixelRowStoreBuffer;
1962 resourceParams.dwOffset = 0;
1963 resourceParams.pdwCmd = (cmd.SseSourcePixelRowstoreBufferBaseAddress.DW0_1.Value);
1964 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SseSourcePixelRowstoreBufferBaseAddress);
1965 resourceParams.bIsWritable = true;
1966
1967 InitMocsParams(resourceParams, &cmd.SseSourcePixelRowstoreBufferAttributesReadWrite.DW0.Value, 1, 6);
1968
1969 MHW_MI_CHK_STATUS(AddResourceToCmd(
1970 this->m_osItf,
1971 this->m_currentCmdBuf,
1972 &resourceParams));
1973 }
1974
1975 // Slice state stream out buffer
1976 if (params.presSliceStateStreamOutBuffer != nullptr)
1977 {
1978 resourceParams.presResource = params.presSliceStateStreamOutBuffer;
1979 resourceParams.dwOffset = 0;
1980 resourceParams.pdwCmd = (cmd.HcpScalabilitySliceStateBufferBaseAddress.DW0_1.Value);
1981 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(HcpScalabilitySliceStateBufferBaseAddress);
1982 resourceParams.bIsWritable = true;
1983
1984 InitMocsParams(resourceParams, &cmd.HcpScalabilitySliceStateBufferAttributesReadWrite.DW0.Value, 1, 6);
1985
1986 MHW_MI_CHK_STATUS(AddResourceToCmd(
1987 this->m_osItf,
1988 this->m_currentCmdBuf,
1989 &resourceParams));
1990 }
1991
1992 // CABAC Syntax stream out buffer
1993 if (params.presCABACSyntaxStreamOutBuffer != nullptr)
1994 {
1995 resourceParams.presResource = params.presCABACSyntaxStreamOutBuffer;
1996 resourceParams.dwOffset = 0;
1997 resourceParams.pdwCmd = (cmd.HcpScalabilityCabacDecodedSyntaxElementsBufferBaseAddress.DW0_1.Value);
1998 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(HcpScalabilityCabacDecodedSyntaxElementsBufferBaseAddress);
1999 resourceParams.bIsWritable = true;
2000
2001 InitMocsParams(resourceParams, &cmd.HcpScalabilityCabacDecodedSyntaxElementsBufferAttributesReadWrite.DW0.Value, 1, 6);
2002
2003 MHW_MI_CHK_STATUS(AddResourceToCmd(
2004 this->m_osItf,
2005 this->m_currentCmdBuf,
2006 &resourceParams));
2007 }
2008
2009 // MV Upper Right Col Store
2010 if (params.presMvUpRightColStoreBuffer != nullptr)
2011 {
2012 resourceParams.presResource = params.presMvUpRightColStoreBuffer;
2013 resourceParams.dwOffset = 0;
2014 resourceParams.pdwCmd = (cmd.MotionVectorUpperRightColumnStoreBufferBaseAddress.DW0_1.Value);
2015 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MotionVectorUpperRightColumnStoreBufferBaseAddress);
2016 resourceParams.bIsWritable = true;
2017
2018 InitMocsParams(resourceParams, &cmd.MotionVectorUpperRightColumnStoreBufferAttributesReadWrite.DW0.Value, 1, 6);
2019
2020 MHW_MI_CHK_STATUS(AddResourceToCmd(
2021 this->m_osItf,
2022 this->m_currentCmdBuf,
2023 &resourceParams));
2024 }
2025
2026 // IntraPred Upper Right Col Store
2027 if (params.presIntraPredUpRightColStoreBuffer != nullptr)
2028 {
2029 resourceParams.presResource = params.presIntraPredUpRightColStoreBuffer;
2030 resourceParams.dwOffset = 0;
2031 resourceParams.pdwCmd = (cmd.IntraPredictionUpperRightColumnStoreBufferBaseAddress.DW0_1.Value);
2032 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntraPredictionUpperRightColumnStoreBufferBaseAddress);
2033 resourceParams.bIsWritable = true;
2034
2035 InitMocsParams(resourceParams, &cmd.IntraPredictionUpperRightColumnStoreBufferAttributesReadWrite.DW0.Value, 1, 6);
2036
2037 MHW_MI_CHK_STATUS(AddResourceToCmd(
2038 this->m_osItf,
2039 this->m_currentCmdBuf,
2040 &resourceParams));
2041 }
2042
2043 // IntraPred Left Recon Col Store
2044 if (params.presIntraPredLeftReconColStoreBuffer != nullptr)
2045 {
2046 resourceParams.presResource = params.presIntraPredLeftReconColStoreBuffer;
2047 resourceParams.dwOffset = 0;
2048 resourceParams.pdwCmd = (cmd.IntraPredictionLeftReconColumnStoreBufferBaseAddress.DW0_1.Value);
2049 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntraPredictionLeftReconColumnStoreBufferBaseAddress);
2050 resourceParams.bIsWritable = true;
2051
2052 InitMocsParams(resourceParams, &cmd.IntraPredictionLeftReconColumnStoreBufferAttributesReadWrite.DW0.Value, 1, 6);
2053
2054 MHW_MI_CHK_STATUS(AddResourceToCmd(
2055 this->m_osItf,
2056 this->m_currentCmdBuf,
2057 &resourceParams));
2058 }
2059
2060 // CABAC Syntax Stream Out Buffer Max Address
2061 if (params.presCABACSyntaxStreamOutMaxAddr != nullptr)
2062 {
2063 resourceParams.presResource = params.presCABACSyntaxStreamOutMaxAddr;
2064 resourceParams.dwOffset = 0;
2065 resourceParams.pdwCmd = (cmd.HcpScalabilityCabacDecodedSyntaxElementsBufferMaxAddress.DW0_1.Value);
2066 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(HcpScalabilityCabacDecodedSyntaxElementsBufferMaxAddress);
2067 resourceParams.bIsWritable = true;
2068
2069 MHW_MI_CHK_STATUS(AddResourceToCmd(
2070 this->m_osItf,
2071 this->m_currentCmdBuf,
2072 &resourceParams));
2073 }
2074
2075 MOS_ZeroMemory(&details, sizeof(details));
2076 details.Format = Format_Invalid;
2077 MEDIA_WA_TABLE *m_waTable = this->m_osItf->pfnGetWaTable(this->m_osItf);
2078 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, &params.psPreDeblockSurface->OsResource, &details));
2079 cmd.DecodedPictureMemoryAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
2080
2081 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
2082 {
2083 // All Reference Picture Buffer share same memory address attribute
2084 // As Reference Surface attribute should be aligned with Recon surface
2085 // Reference surface tilemode info won't get from GMM but just eqaul to DecodedPicture
2086 if (params.presReferences[i] != nullptr)
2087 {
2088 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.TileMode = cmd.DecodedPictureMemoryAddressAttributes.DW0.TileMode;
2089 break;
2090 }
2091 }
2092
2093 if (params.psRawSurface != nullptr)
2094 {
2095 MOS_ZeroMemory(&details, sizeof(details));
2096 details.Format = Format_Invalid;
2097 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, &params.psRawSurface->OsResource, &details));
2098 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
2099 }
2100
2101 return MOS_STATUS_SUCCESS;
2102 }
2103
2104 _MHW_SETCMD_OVERRIDE_DECL(HCP_FQM_STATE)
2105 {
2106 _MHW_SETCMD_CALLBASE(HCP_FQM_STATE);
2107
2108 for (uint8_t i = 0; i < 32; i++)
2109 {
2110 cmd.Quantizermatrix[i] = params.quantizermatrix[i];
2111 }
2112
2113 cmd.DW1.IntraInter = params.intraInter;
2114 cmd.DW1.Sizeid = params.sizeid;
2115 cmd.DW1.ColorComponent = params.colorComponent;
2116 cmd.DW1.FqmDcValue1Dc = params.fqmDcValue1Dc;
2117
2118 return MOS_STATUS_SUCCESS;
2119 }
2120
2121 _MHW_SETCMD_OVERRIDE_DECL(HCP_PAK_INSERT_OBJECT)
2122 {
2123 _MHW_SETCMD_CALLBASE(HCP_PAK_INSERT_OBJECT);
2124
2125 uint32_t dwordsUsed = cmd.dwSize;
2126
2127 dwordsUsed += params.dwPadding;
2128 #define DO_FIELDS() \
2129 DO_FIELD(DW0, DwordLength, OP_LENGTH(dwordsUsed)); \
2130 DO_FIELD(DW1, Headerlengthexcludefrmsize, params.bHeaderLengthExcludeFrmSize); \
2131 DO_FIELD(DW1, EndofsliceflagLastdstdatainsertcommandflag, params.bEndOfSlice); \
2132 DO_FIELD(DW1, LastheaderflagLastsrcheaderdatainsertcommandflag, params.bLastHeader); \
2133 DO_FIELD(DW1, EmulationflagEmulationbytebitsinsertenable, params.bEmulationByteBitsInsert); \
2134 DO_FIELD(DW1, SkipemulbytecntSkipEmulationByteCount, params.uiSkipEmulationCheckCount); \
2135 DO_FIELD(DW1, SliceHeaderIndicator, params.bResetBitstreamStartingPos); \
2136 DO_FIELD(DW1, DatabitsinlastdwSrcdataendingbitinclusion50, params.dataBitsInLastDw); \
2137 DO_FIELD(DW1, DatabyteoffsetSrcdatastartingbyteoffset10, params.databyteoffset); \
2138 DO_FIELD(DW1, IndirectPayloadEnable, params.bIndirectPayloadEnable);
2139
2140 #include "mhw_hwcmd_process_cmdfields.h"
2141 }
2142
2143 _MHW_SETCMD_OVERRIDE_DECL(HCP_VP9_PIC_STATE)
2144 {
2145 _MHW_SETCMD_CALLBASE(HCP_VP9_PIC_STATE);
2146
2147 #define DO_FIELDS() \
2148 if (params.bDecodeInUse) \
2149 { \
2150 DO_FIELD(DW0, DwordLength, params.dWordLength); \
2151 } \
2152 DO_FIELD(DW1, FrameWidthInPixelsMinus1, params.frameWidthInPixelsMinus1); \
2153 DO_FIELD(DW1, FrameHeightInPixelsMinus1, params.frameHeightInPixelsMinus1); \
2154 DO_FIELD(DW2, FrameType, params.frameType); \
2155 DO_FIELD(DW2, AdaptProbabilitiesFlag, params.adaptProbabilitiesFlag); \
2156 DO_FIELD(DW2, IntraonlyFlag, params.intraOnlyFlag); \
2157 DO_FIELD(DW2, AllowHiPrecisionMv, params.allowHiPrecisionMv); \
2158 DO_FIELD(DW2, McompFilterType, params.mcompFilterType); \
2159 DO_FIELD(DW2, RefFrameSignBias02, params.refFrameSignBias02); \
2160 DO_FIELD(DW2, HybridPredictionMode, params.hybridPredictionMode); \
2161 DO_FIELD(DW2, SelectableTxMode, params.selectableTxMode); \
2162 DO_FIELD(DW2, UsePrevInFindMvReferences, params.usePrevInFindMvReferences); \
2163 DO_FIELD(DW2, LastFrameType, params.lastFrameType); \
2164 DO_FIELD(DW2, RefreshFrameContext, params.refreshFrameContext); \
2165 DO_FIELD(DW2, ErrorResilientMode, params.errorResilientMode); \
2166 DO_FIELD(DW2, FrameParallelDecodingMode, params.frameParallelDecodingMode); \
2167 DO_FIELD(DW2, FilterLevel, params.filterLevel); \
2168 DO_FIELD(DW2, SharpnessLevel, params.sharpnessLevel); \
2169 DO_FIELD(DW2, SegmentationEnabled, params.segmentationEnabled); \
2170 DO_FIELD(DW2, SegmentationUpdateMap, params.segmentationUpdateMap); \
2171 DO_FIELD(DW2, SegmentationTemporalUpdate, params.segmentationTemporalUpdate); \
2172 DO_FIELD(DW2, LosslessMode, params.losslessMode); \
2173 DO_FIELD(DW2, SegmentIdStreamoutEnable, params.segmentIdStreamOutEnable); \
2174 DO_FIELD(DW2, SegmentIdStreaminEnable, params.segmentIdStreamInEnable); \
2175 DO_FIELD(DW3, Log2TileColumn, params.log2TileColumn); \
2176 DO_FIELD(DW3, Log2TileRow, params.log2TileRow); \
2177 DO_FIELD(DW3, SseEnable, params.sseEnable); \
2178 DO_FIELD(DW3, ChromaSamplingFormat, params.chromaSamplingFormat); \
2179 DO_FIELD(DW3, Bitdepthminus8, params.bitdepthMinus8); \
2180 DO_FIELD(DW3, ProfileLevel, params.profileLevel); \
2181 DO_FIELD(DW4, VerticalScaleFactorForLast, params.verticalScaleFactorForLast); \
2182 DO_FIELD(DW4, HorizontalScaleFactorForLast, params.horizontalScaleFactorForLast); \
2183 DO_FIELD(DW5, VerticalScaleFactorForGolden, params.verticalScaleFactorForGolden); \
2184 DO_FIELD(DW5, HorizontalScaleFactorForGolden, params.horizontalScaleFactorForGolden); \
2185 DO_FIELD(DW6, VerticalScaleFactorForAltref, params.verticalScaleFactorForAltref); \
2186 DO_FIELD(DW6, HorizontalScaleFactorForAltref, params.horizontalScaleFactorForAltref); \
2187 DO_FIELD(DW7, LastFrameWidthInPixelsMinus1, params.lastFrameWidthInPixelsMinus1); \
2188 DO_FIELD(DW7, LastFrameHieghtInPixelsMinus1, params.lastFrameHeightInPixelsMinus1); \
2189 DO_FIELD(DW8, GoldenFrameWidthInPixelsMinus1, params.goldenFrameWidthInPixelsMinus1); \
2190 DO_FIELD(DW8, GoldenFrameHieghtInPixelsMinus1, params.goldenFrameHeightInPixelsMinus1); \
2191 DO_FIELD(DW9, AltrefFrameWidthInPixelsMinus1, params.altrefFrameWidthInPixelsMinus1); \
2192 DO_FIELD(DW9, AltrefFrameHieghtInPixelsMinus1, params.altrefFrameHeightInPixelsMinus1); \
2193 DO_FIELD(DW10, UncompressedHeaderLengthInBytes70, params.uncompressedHeaderLengthInBytes70); \
2194 DO_FIELD(DW10, FirstPartitionSizeInBytes150, params.firstPartitionSizeInBytes150); \
2195 DO_FIELD(DW13, BaseQIndexSameAsLumaAc, params.baseQIndexSameAsLumaAc); \
2196 DO_FIELD(DW13, HeaderInsertionEnable, params.headerInsertionEnable); \
2197 DO_FIELD(DW14, ChromaacQindexdelta, params.chromaAcQIndexDelta); \
2198 DO_FIELD(DW14, ChromadcQindexdelta, params.chromaDcQIndexDelta); \
2199 DO_FIELD(DW14, LumaDcQIndexDelta, params.lumaDcQIndexDelta); \
2200 DO_FIELD(DW15, LfRefDelta0, params.lfRefDelta0); \
2201 DO_FIELD(DW15, LfRefDelta1, params.lfRefDelta1); \
2202 DO_FIELD(DW15, LfRefDelta2, params.lfRefDelta2); \
2203 DO_FIELD(DW15, LfRefDelta3, params.lfRefDelta3); \
2204 DO_FIELD(DW16, LfModeDelta0, params.lfModeDelta0); \
2205 DO_FIELD(DW16, LfModeDelta1, params.lfModeDelta1); \
2206 DO_FIELD(DW17, Bitoffsetforlfrefdelta, params.bitOffsetForLfRefDelta); \
2207 DO_FIELD(DW17, Bitoffsetforlfmodedelta, params.bitOffsetForLfModeDelta); \
2208 DO_FIELD(DW18, Bitoffsetforqindex, params.bitOffsetForQIndex); \
2209 DO_FIELD(DW18, Bitoffsetforlflevel, params.bitOffsetForLfLevel); \
2210 DO_FIELD(DW19, VdencPakOnlyPass, params.vdencPakOnlyPass); \
2211 DO_FIELD(DW32, Bitoffsetforfirstpartitionsize, params.bitOffsetForFirstPartitionSize);
2212
2213 #include "mhw_hwcmd_process_cmdfields.h"
2214 }
2215
2216 _MHW_SETCMD_OVERRIDE_DECL(HCP_VP9_SEGMENT_STATE)
2217 {
2218 _MHW_SETCMD_CALLBASE(HCP_VP9_SEGMENT_STATE);
2219
2220 #define DO_FIELDS() \
2221 DO_FIELD(DW1, SegmentId, params.segmentId); \
2222 DO_FIELD(DW2, SegmentSkipped, params.segmentSkipped); \
2223 DO_FIELD(DW2, SegmentReference, params.segmentReference); \
2224 DO_FIELD(DW2, SegmentReferenceEnabled, params.segmentReferenceEnabled); \
2225 DO_FIELD(DW3, Filterlevelref0Mode0, params.filterLevelRef0Mode0); \
2226 DO_FIELD(DW3, Filterlevelref0Mode1, params.filterLevelRef0Mode1); \
2227 DO_FIELD(DW3, Filterlevelref1Mode0, params.filterLevelRef1Mode0); \
2228 DO_FIELD(DW3, Filterlevelref1Mode1, params.filterLevelRef1Mode1); \
2229 DO_FIELD(DW4, Filterlevelref2Mode0, params.filterLevelRef2Mode0); \
2230 DO_FIELD(DW4, Filterlevelref2Mode1, params.filterLevelRef2Mode1); \
2231 DO_FIELD(DW4, Filterlevelref3Mode0, params.filterLevelRef3Mode0); \
2232 DO_FIELD(DW4, Filterlevelref3Mode1, params.filterLevelRef3Mode1); \
2233 DO_FIELD(DW5, LumaDcQuantScaleDecodeModeOnly, params.lumaDcQuantScaleDecodeModeOnly); \
2234 DO_FIELD(DW5, LumaAcQuantScaleDecodeModeOnly, params.lumaAcQuantScaleDecodeModeOnly); \
2235 DO_FIELD(DW6, ChromaDcQuantScaleDecodeModeOnly, params.chromaDcQuantScaleDecodeModeOnly); \
2236 DO_FIELD(DW6, ChromaAcQuantScaleDecodeModeOnly, params.chromaAcQuantScaleDecodeModeOnly); \
2237 DO_FIELD(DW7, SegmentQindexDeltaEncodeModeOnly, params.segmentQindexDeltaEncodeModeOnly); \
2238 DO_FIELD(DW7, SegmentLfLevelDeltaEncodeModeOnly, params.segmentLfLevelDeltaEncodeModeOnly);
2239
2240 #include "mhw_hwcmd_process_cmdfields.h"
2241 }
2242
2243 _MHW_SETCMD_OVERRIDE_DECL(HEVC_VP9_RDOQ_STATE)
2244 {
2245 _MHW_SETCMD_CALLBASE(HEVC_VP9_RDOQ_STATE);
2246
2247 for (uint8_t i = 0; i < 32; i++)
2248 {
2249 cmd.Intralumalambda[i].DW0.Lambdavalue0 = params.lambdaTab[0][0][i * 2];
2250 cmd.Intralumalambda[i].DW0.Lambdavalue1 = params.lambdaTab[0][0][i * 2 + 1];
2251
2252 cmd.Intrachromalambda[i].DW0.Lambdavalue0 = params.lambdaTab[0][1][i * 2];
2253 cmd.Intrachromalambda[i].DW0.Lambdavalue1 = params.lambdaTab[0][1][i * 2 + 1];
2254
2255 cmd.Interlumalambda[i].DW0.Lambdavalue0 = params.lambdaTab[1][0][i * 2];
2256 cmd.Interlumalambda[i].DW0.Lambdavalue1 = params.lambdaTab[1][0][i * 2 + 1];
2257
2258 cmd.Interchromalambda[i].DW0.Lambdavalue0 = params.lambdaTab[1][1][i * 2];
2259 cmd.Interchromalambda[i].DW0.Lambdavalue1 = params.lambdaTab[1][1][i * 2 + 1];
2260 }
2261
2262 for (uint8_t i = 0; i < 6; i++)
2263 {
2264 cmd.Intralumalambda12bit[i].DW0.Lambdavalue0 = params.lambdaTab[0][0][i * 2 + 64];
2265 cmd.Intralumalambda12bit[i].DW0.Lambdavalue1 = params.lambdaTab[0][0][i * 2 + 1 + 64];
2266
2267 cmd.Intrachromalambda12bit[i].DW0.Lambdavalue0 = params.lambdaTab[0][1][i * 2 + 64];
2268 cmd.Intrachromalambda12bit[i].DW0.Lambdavalue1 = params.lambdaTab[0][1][i * 2 + 1 + 64];
2269
2270 cmd.Interlumalambda12bit[i].DW0.Lambdavalue0 = params.lambdaTab[1][0][i * 2 + 64];
2271 cmd.Interlumalambda12bit[i].DW0.Lambdavalue1 = params.lambdaTab[1][0][i * 2 + 1 + 64];
2272
2273 cmd.Interchromalambda12bit[i].DW0.Lambdavalue0 = params.lambdaTab[1][1][i * 2 + 64];
2274 cmd.Interchromalambda12bit[i].DW0.Lambdavalue1 = params.lambdaTab[1][1][i * 2 + 1 + 64];
2275 }
2276
2277 cmd.DW1.DisableHtqPerformanceFix0 = params.disableHtqPerformanceFix0;
2278 cmd.DW1.DisableHtqPerformanceFix1 = params.disableHtqPerformanceFix1;
2279
2280 return MOS_STATUS_SUCCESS;
2281 }
2282
2283 _MHW_SETCMD_OVERRIDE_DECL(HCP_TILE_CODING)
2284 {
2285 _MHW_SETCMD_CALLBASE(HCP_TILE_CODING);
2286
2287 #define DO_FIELDS() \
2288 DO_FIELD(DW1, NumberOfActiveBePipes, params.numberOfActiveBePipes); \
2289 DO_FIELD(DW1, NumOfTileColumnsInAFrame, params.numOfTileColumnsInFrame); \
2290 DO_FIELD(DW1, TileRowStoreSelect, params.tileRowStoreSelect); \
2291 DO_FIELD(DW1, TileColumnStoreSelect, params.tileColumnStoreSelect); \
2292 DO_FIELD(DW2, TileColumnPosition, params.tileStartLCUX); \
2293 DO_FIELD(DW2, TileRowPosition, params.tileStartLCUY); \
2294 DO_FIELD(DW2, Islasttileofcolumn, params.isLastTileofColumn); \
2295 DO_FIELD(DW2, Islasttileofrow, params.isLastTileofRow); \
2296 DO_FIELD(DW2, NonFirstPassTile, params.nonFirstPassTile); \
2297 DO_FIELD(DW3, Tileheightinmincbminus1, params.tileHeightInMinCbMinus1); \
2298 DO_FIELD(DW3, Tilewidthinmincbminus1, params.tileWidthInMinCbMinus1); \
2299 DO_FIELD(DW4, BitstreamByteOffset, params.bitstreamByteOffset); \
2300 DO_FIELD(DW4, BitstreamByteOffsetEnable, params.bitstreamByteOffsetEnable); \
2301 DO_FIELD(DW5, PakFrameStatisticsOffset, params.pakTileStatisticsOffset); \
2302 DO_FIELD(DW6, CuLevelStreamoutOffset, params.cuLevelStreamoutOffset); \
2303 DO_FIELD(DW7, SliceSizeStreamoutOffset, params.sliceSizeStreamoutOffset); \
2304 DO_FIELD(DW8, CuRecordOffset, params.cuRecordOffset); \
2305 DO_FIELD(DW9, SseRowstoreOffset, params.sseRowstoreOffset); \
2306 DO_FIELD(DW10, SaoRowstoreOffset, params.saoRowstoreOffset); \
2307 DO_FIELD(DW11, TileSizeStreamoutOffset, params.tileSizeStreamoutOffset); \
2308 DO_FIELD(DW12, Vp9ProbabilityCounterStreamoutOffset, params.vp9ProbabilityCounterStreamoutOffset);
2309
2310 #include "mhw_hwcmd_process_cmdfields.h"
2311 }
2312
2313 _MHW_SETCMD_OVERRIDE_DECL(HCP_PALETTE_INITIALIZER_STATE)
2314 {
2315 _MHW_SETCMD_CALLBASE(HCP_PALETTE_INITIALIZER_STATE);
2316
2317 cmd.DW1.ActivePaletteInitializerTableEntries = params.predictorPaletteSize;
2318
2319 uint32_t yentryIdx = 0;
2320 for (uint32_t i = 0; i < params.hevcSccPaletteSize; i += 3)
2321 {
2322 // First 64 color entries
2323 yentryIdx = i * 2 / 3;
2324 cmd.First64ColorEntries[i] = params.predictorPaletteEntries[0][yentryIdx]; // Y
2325 cmd.First64ColorEntries[i] |= ((uint32_t)params.predictorPaletteEntries[1][yentryIdx] << 16); // Cb
2326
2327 cmd.First64ColorEntries[i + 1] = params.predictorPaletteEntries[2][yentryIdx]; // Cr
2328 cmd.First64ColorEntries[i + 1] |= ((uint32_t)params.predictorPaletteEntries[0][yentryIdx + 1] << 16); // Y
2329
2330 cmd.First64ColorEntries[i + 2] = params.predictorPaletteEntries[1][yentryIdx + 1]; // Cb
2331 cmd.First64ColorEntries[i + 2] |= ((uint32_t)params.predictorPaletteEntries[2][yentryIdx + 1] << 16); // Cr
2332
2333 // Second 64 color entries
2334 yentryIdx += 64;
2335 cmd.Second64ColorEntries[i] = params.predictorPaletteEntries[0][yentryIdx]; // Y
2336 cmd.Second64ColorEntries[i] |= ((uint32_t)params.predictorPaletteEntries[1][yentryIdx] << 16); // Cb
2337
2338 cmd.Second64ColorEntries[i + 1] = params.predictorPaletteEntries[2][yentryIdx]; // Cr
2339 cmd.Second64ColorEntries[i + 1] |= ((uint32_t)params.predictorPaletteEntries[0][yentryIdx + 1] << 16); // Y
2340
2341 cmd.Second64ColorEntries[i + 2] = params.predictorPaletteEntries[1][yentryIdx + 1]; // Cb
2342 cmd.Second64ColorEntries[i + 2] |= ((uint32_t)params.predictorPaletteEntries[2][yentryIdx + 1] << 16); // Cr
2343 }
2344
2345 return MOS_STATUS_SUCCESS;
2346 }
2347 MEDIA_CLASS_DEFINE_END(mhw__vdbox__hcp__Impl)
2348 };
2349 } // namespace hcp
2350 } // namespace vdbox
2351 } // namespace mhw
2352
2353 #endif // __MHW_VDBOX_HCP_IMPL_H__