Debian Codegraph @

media_driver/agnostic/gen9/hw/vdbox/mhw_vdbox_hcp_g9_X.h

raw
1 /*
2 * Copyright (c) 2017-2018, 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_g9_X.h
24 //! \brief Defines functions for constructing Vdbox HCP commands on Gen9-based platforms
25 //!
26
27 #ifndef __MHW_VDBOX_HCP_G9_X_H__
28 #define __MHW_VDBOX_HCP_G9_X_H__
29
30 #include "mhw_vdbox_hcp_generic.h"
31 #include "mhw_mmio_g9.h"
32
33 // CU Record structure
34 struct EncodeHevcCuDataG9
35 {
36 //DW0
37 uint32_t cu_size : 2;
38 uint32_t cu_pred_mode : 1;
39 uint32_t cu_transquant_bypass_flag : 1;
40 uint32_t cu_part_mode : 3;
41 uint32_t Res_DW0_7 : 1;
42 uint32_t intra_chroma_mode : 3;
43 uint32_t Res_DW0_11_15 : 5;
44 uint32_t CU_QP : 6;
45 uint32_t Res_DW0_22_23 : 2;
46 uint32_t interpred_idc : 8;
47
48 //DW1
49 uint8_t intra_mode[4];
50
51 //DW2 and DW3
52 int16_t mvx_l0[4];
53
54 //DW4 and DW5
55 int16_t mvy_l0[4];
56
57 //DW6 and DW7
58 int16_t mvx_l1[4];
59
60 //DW8 and DW9
61 int16_t mvy_l1[4];
62
63 //DW10
64 uint32_t ref_idx_l0_PU1 : 4;
65 uint32_t ref_idx_l0_PU2 : 4;
66 uint32_t ref_idx_l0_PU3 : 4;
67 uint32_t ref_idx_l0_PU4 : 4;
68 uint32_t ref_idx_l1_PU1 : 4;
69 uint32_t ref_idx_l1_PU2 : 4;
70 uint32_t ref_idx_l1_PU3 : 4;
71 uint32_t ref_idx_l1_PU4 : 4;
72
73 //DW11
74 uint32_t tu_size : 32;
75
76 //DW12
77 uint32_t tu_xform_Yskip : 16;
78 uint32_t Res_DW12_16_27 : 12;
79 uint32_t tu_countm1 : 4;
80
81 //DW13
82 uint32_t tu_xform_Uskip : 16;
83 uint32_t tu_xform_Vskip : 16;
84
85 //DW14
86 uint32_t Res_DW14 : 32;
87
88 //DW15
89 uint32_t Res_DW15 : 32;
90
91 };
92
93 //! MHW Vdbox Hcp interface for Gen9
94 /*!
95 This class defines the Hcp command construction functions for Gen9 platforms as template
96 */
97 template <class THcpCmds>
98 class MhwVdboxHcpInterfaceG9 : public MhwVdboxHcpInterfaceGeneric<THcpCmds>
99 {
100 protected:
101
102 enum HEVC_QM_TYPES
103 {
104 HEVC_QM_4x4 = 0,
105 HEVC_QM_8x8 = 1,
106 HEVC_QM_16x16 = 2,
107 HEVC_QM_32x32 = 3
108 };
109
110 static const uint32_t m_veboxRgbHistogramSizePerSlice = 256 * 4;
111 static const uint32_t m_veboxNumRgbChannel = 3;
112 static const uint32_t m_veboxAceHistogramSizePerFramePerSlice = 256 * 4;
113 static const uint32_t m_veboxNumFramePreviousCurrent = 2;
114
115 static const uint32_t m_veboxMaxSlices = 2;
116 static const uint32_t m_veboxRgbHistogramSize = m_veboxRgbHistogramSizePerSlice * m_veboxNumRgbChannel * m_veboxMaxSlices;
117 static const uint32_t m_veboxLaceHistogram256BinPerBlock = 256 * 2;
118 static const uint32_t m_veboxStatisticsSize = 32 * 4;
119
120 //!
121 //! \brief Constructor
122 //!
123 MhwVdboxHcpInterfaceG9(
124 PMOS_INTERFACE osInterface,
125 MhwMiInterface *miInterface,
126 MhwCpInterface *cpInterface,
127 bool decodeInUse)
128 : MhwVdboxHcpInterfaceGeneric<THcpCmds>(osInterface, miInterface, cpInterface, decodeInUse)
129 {
130 MHW_FUNCTION_ENTER;
131
132 this->m_hevcEncCuRecordSize = sizeof(EncodeHevcCuDataG9);
133 InitMmioRegisters();
134 }
135
136 //!
137 //! \brief Destructor
138 //!
139 virtual ~MhwVdboxHcpInterfaceG9() { MHW_FUNCTION_ENTER; }
140
141 void InitMmioRegisters()
142 {
143 MmioRegistersHcp *mmioRegisters = &this->m_mmioRegisters[MHW_VDBOX_NODE_1];
144
145 mmioRegisters->hcpEncImageStatusMaskRegOffset = HCP_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT_G9;
146 mmioRegisters->hcpEncImageStatusCtrlRegOffset = HCP_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT_G9;
147 mmioRegisters->hcpEncBitstreamBytecountFrameRegOffset = HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT_G9;
148 mmioRegisters->hcpEncBitstreamSeBitcountFrameRegOffset = HCP_ENC_BIT_STREAM_SE_BIT_COUNT_FRAME_REG_OFFSET_INIT_G9;
149 mmioRegisters->hcpEncBitstreamBytecountFrameNoHeaderRegOffset = HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT_G9;
150 mmioRegisters->hcpEncQpStatusCountRegOffset = HCP_ENC_QP_STATUS_COUNT_REG_OFFSET_INIT_G9;
151 mmioRegisters->hcpEncSliceCountRegOffset = HCP_ENC_SLICE_COUNT_REG_OFFSET_INIT_G9;
152 mmioRegisters->hcpEncVdencModeTimerRegOffset = HCP_ENC_VDENC_MODE_TIMER_REG_OFFSET_INIT_G9;
153 mmioRegisters->hcpVp9EncBitstreamBytecountFrameRegOffset = HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT_G9;
154 mmioRegisters->hcpVp9EncBitstreamBytecountFrameNoHeaderRegOffset = HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT_G9;
155 mmioRegisters->hcpVp9EncImageStatusMaskRegOffset = HCP_VP9_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT_G9;
156 mmioRegisters->hcpVp9EncImageStatusCtrlRegOffset = HCP_VP9_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT_G9;
157 mmioRegisters->csEngineIdOffset = CS_ENGINE_ID_OFFSET_INIT_G9;
158 mmioRegisters->hcpDecStatusRegOffset = HCP_DEC_STATUS_REG_OFFSET_INIT_G9;
159 mmioRegisters->hcpCabacStatusRegOffset = HCP_CABAC_STATUS_REG_OFFSET_INIT_G9;
160
161 }
162
163 void InitRowstoreUserFeatureSettings(MOS_CONTEXT_HANDLE mosCtx)
164 {
165 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
166 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
167
168 userFeatureData.u32Data = 0;
169
170 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
171 #if (_DEBUG || _RELEASE_INTERNAL)
172 MOS_UserFeature_ReadValue_ID(
173 nullptr,
174 __MEDIA_USER_FEATURE_VALUE_ROWSTORE_CACHE_DISABLE_ID,
175 &userFeatureData,
176 mosCtx);
177 #endif // _DEBUG || _RELEASE_INTERNAL
178 this->m_rowstoreCachingSupported = userFeatureData.i32Data ? false : true;
179
180 if (this->m_rowstoreCachingSupported)
181 {
182 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
183 #if (_DEBUG || _RELEASE_INTERNAL)
184 MOS_UserFeature_ReadValue_ID(
185 nullptr,
186 __MEDIA_USER_FEATURE_VALUE_HEVCDATROWSTORECACHE_DISABLE_ID,
187 &userFeatureData,
188 mosCtx);
189 #endif // _DEBUG || _RELEASE_INTERNAL
190 this->m_hevcDatRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
191
192 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
193 #if (_DEBUG || _RELEASE_INTERNAL)
194 MOS_UserFeature_ReadValue_ID(
195 nullptr,
196 __MEDIA_USER_FEATURE_VALUE_HEVCDFROWSTORECACHE_DISABLE_ID,
197 &userFeatureData,
198 mosCtx);
199 #endif // _DEBUG || _RELEASE_INTERNAL
200 this->m_hevcDfRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
201
202 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
203 #if (_DEBUG || _RELEASE_INTERNAL)
204 MOS_UserFeature_ReadValue_ID(
205 nullptr,
206 __MEDIA_USER_FEATURE_VALUE_HEVCSAOROWSTORECACHE_DISABLE_ID,
207 &userFeatureData,
208 mosCtx);
209 #endif // _DEBUG || _RELEASE_INTERNAL
210 this->m_hevcSaoRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
211 }
212 }
213
214 MOS_STATUS GetRowstoreCachingAddrs(
215 PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
216 {
217 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
218
219 MHW_FUNCTION_ENTER;
220
221 MHW_MI_CHK_NULL(rowstoreParams);
222
223 if (this->m_hevcDatRowStoreCache.bSupported && (rowstoreParams->Mode == CODECHAL_DECODE_MODE_HEVCVLD))
224 {
225 this->m_hevcDatRowStoreCache.bEnabled = true;
226 if (rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_8K)
227 {
228 this->m_hevcDatRowStoreCache.dwAddress = HEVCDATROWSTORE_BASEADDRESS;
229 }
230 else
231 {
232 this->m_hevcDatRowStoreCache.dwAddress = 0;
233 this->m_hevcDatRowStoreCache.bEnabled = false;
234 }
235 }
236
237 if (this->m_hevcDfRowStoreCache.bSupported && (rowstoreParams->Mode == CODECHAL_DECODE_MODE_HEVCVLD))
238 {
239 this->m_hevcDfRowStoreCache.bEnabled = true;
240 if (rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_2K)
241 {
242 this->m_hevcDfRowStoreCache.dwAddress = HEVCDFROWSTORE_BASEADDRESS_PICWIDTH_LESS_THAN_OR_EQU_TO_2K;
243 }
244 else if ((rowstoreParams->dwPicWidth > MHW_VDBOX_PICWIDTH_2K) && (rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_4K))
245 {
246 if (rowstoreParams->ucBitDepthMinus8 == 0)
247 {
248 this->m_hevcDfRowStoreCache.dwAddress = HEVCDFROWSTORE_BASEADDRESS_PICWIDTH_BETWEEN_2K_AND_4K;
249 }
250 else
251 {
252 this->m_hevcDfRowStoreCache.dwAddress = 0;
253 this->m_hevcDfRowStoreCache.bEnabled = false;
254 }
255 }
256 else
257 {
258 this->m_hevcDfRowStoreCache.dwAddress = 0;
259 this->m_hevcDfRowStoreCache.bEnabled = false;
260 }
261 }
262
263 if (this->m_hevcSaoRowStoreCache.bSupported && (rowstoreParams->Mode == CODECHAL_DECODE_MODE_HEVCVLD))
264 {
265 this->m_hevcSaoRowStoreCache.bEnabled = true;
266 if (rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_2K)
267 {
268 if (rowstoreParams->ucBitDepthMinus8 == 0)
269 {
270 this->m_hevcSaoRowStoreCache.dwAddress = HEVCSAOROWSTORE_BASEADDRESS_PICWIDTH_LESS_THAN_OR_EQU_TO_2K;
271 }
272 else
273 {
274 this->m_hevcSaoRowStoreCache.dwAddress = 0;
275 this->m_hevcSaoRowStoreCache.bEnabled = false;
276 }
277 }
278 else
279 {
280 this->m_hevcSaoRowStoreCache.dwAddress = 0;
281 this->m_hevcSaoRowStoreCache.bEnabled = false;
282 }
283 }
284
285 if (this->m_vp9HvdRowStoreCache.bSupported && rowstoreParams->Mode == CODECHAL_DECODE_MODE_VP9VLD)
286 {
287 this->m_vp9HvdRowStoreCache.bEnabled = true;
288 if ((rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_8K && rowstoreParams->ucBitDepthMinus8 == 0) ||
289 (rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_2K && rowstoreParams->ucBitDepthMinus8 == 2))
290 {
291 this->m_vp9HvdRowStoreCache.dwAddress = VP9HVDROWSTORE_BASEADDRESS;
292 }
293 else
294 {
295 this->m_vp9HvdRowStoreCache.dwAddress = 0;
296 this->m_vp9HvdRowStoreCache.bEnabled = false;
297 }
298 }
299
300 if (this->m_vp9DfRowStoreCache.bSupported && rowstoreParams->Mode == CODECHAL_DECODE_MODE_VP9VLD)
301 {
302 this->m_vp9DfRowStoreCache.bEnabled = true;
303 if ((rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_2K && rowstoreParams->ucBitDepthMinus8 == 0) ||
304 (rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_1K && rowstoreParams->ucBitDepthMinus8 == 2))
305 {
306 this->m_vp9DfRowStoreCache.dwAddress = VP9DFROWSTORE_BASEADDRESS_PICWIDTH_LESS_THAN_OR_EQU_TO_2K;
307 }
308 else
309 {
310 this->m_vp9DfRowStoreCache.dwAddress = 0;
311 this->m_vp9DfRowStoreCache.bEnabled = false;
312 }
313 }
314
315 return eStatus;
316 }
317
318 MOS_STATUS GetHevcBufferSize(
319 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType,
320 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam)
321 {
322 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
323
324 MHW_FUNCTION_ENTER;
325
326 MHW_MI_CHK_NULL(hcpBufSizeParam);
327
328 uint32_t mvtSize = 0;
329 uint32_t mvtbSize = 0;
330 uint32_t bufferSize = 0;
331 uint8_t maxBitDepth = hcpBufSizeParam->ucMaxBitDepth;
332 uint32_t picWidth = hcpBufSizeParam->dwPicWidth;
333 uint32_t picHeight = hcpBufSizeParam->dwPicHeight;
334 uint32_t picHeightLCU = picHeight >> 4;//assume smallest LCU to get max height
335 uint32_t picWidthLCU = picWidth >> 4;
336 uint8_t shiftParam = (maxBitDepth == 10) ? 2 : 3;
337
338 switch (bufferType)
339 {
340 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE:
341 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE:
342 bufferSize = ((picWidth + 31) & 0xFFFFFFE0) >> shiftParam;
343 break;
344 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL:
345 bufferSize = ((picHeight + picHeightLCU * 6 + 31) & 0xFFFFFFE0) >> shiftParam;
346 break;
347 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE:
348 bufferSize = (((((picWidth + 15) >> 4) * 188 + picWidthLCU * 9 + 1023) >> 9) + 1) & (-2);
349 break;
350 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE:
351 bufferSize = (((((picWidth + 15) >> 4) * 172 + picWidthLCU * 9 + 1023) >> 9) + 1) & (-2);
352 break;
353 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL:
354 bufferSize = (((((picHeight + 15) >> 4) * 176 + picHeightLCU * 89 + 1023) >> 9) + 1) & (-2);
355 break;
356 case MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE:
357 bufferSize = (((((picWidth >> 1) + picWidthLCU * 3) + 15) & 0xFFFFFFF0) >> shiftParam);
358 break;
359 case MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE:
360 bufferSize = (((((picWidth >> 1) + picWidthLCU * 6) + 15) & 0xFFFFFFF0) >> shiftParam);
361 break;
362 case MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL:
363 bufferSize = (((((picHeight >> 1) + picHeightLCU * 6) + 15) & 0xFFFFFFF0) >> shiftParam);
364 break;
365 case MHW_VDBOX_HCP_INTERNAL_BUFFER_CURR_MV_TEMPORAL:
366 mvtSize = ((((picWidth + 63) >> 6)*(((picHeight + 15) >> 4)) + 1)&(-2));
367 mvtbSize = ((((picWidth + 31) >> 5)*(((picHeight + 31) >> 5)) + 1)&(-2));
368 bufferSize = MOS_MAX(mvtSize, mvtbSize);
369 break;
370 default:
371 eStatus = MOS_STATUS_INVALID_PARAMETER;
372 break;
373 }
374 hcpBufSizeParam->dwBufferSize = bufferSize * MHW_CACHELINE_SIZE;
375
376 return eStatus;
377 }
378
379 MOS_STATUS GetVp9BufferSize(
380 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType,
381 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam)
382
383 {
384 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
385
386 MHW_FUNCTION_ENTER;
387
388 MHW_MI_CHK_NULL(hcpBufSizeParam);
389
390 uint32_t bufferSize = 0;
391 uint32_t dblkRsbSizeMultiplier = 0;
392 uint32_t dblkCsbSizeMultiplier = 0;
393
394 uint8_t maxBitDepth = hcpBufSizeParam->ucMaxBitDepth;
395 uint32_t widthInSb = hcpBufSizeParam->dwPicWidth;
396 uint32_t heightInSb = hcpBufSizeParam->dwPicHeight;
397 HCP_CHROMA_FORMAT_IDC chromaFormat = (HCP_CHROMA_FORMAT_IDC)hcpBufSizeParam->ucChromaFormat;
398 uint32_t sizeScale = (maxBitDepth > 8) ? 2 : 1;
399
400 if (chromaFormat == HCP_CHROMA_FORMAT_YUV420)
401 {
402 dblkRsbSizeMultiplier = sizeScale * 18;
403 dblkCsbSizeMultiplier = sizeScale * 17;
404 }
405 else
406 {
407 eStatus = MOS_STATUS_INVALID_PARAMETER;
408 MHW_ASSERTMESSAGE("Format not supported.");
409 return eStatus;
410 }
411
412 switch (bufferType)
413 {
414 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE:
415 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE:
416 bufferSize = widthInSb * dblkRsbSizeMultiplier;
417 break;
418 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL:
419 bufferSize = heightInSb * dblkCsbSizeMultiplier;
420 break;
421 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE:
422 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE:
423 bufferSize = widthInSb * 5;
424 break;
425 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL:
426 bufferSize = heightInSb * 5;
427 break;
428 case MHW_VDBOX_HCP_INTERNAL_BUFFER_CURR_MV_TEMPORAL:
429 case MHW_VDBOX_HCP_INTERNAL_BUFFER_COLL_MV_TEMPORAL:
430 bufferSize = widthInSb * heightInSb * 9;
431 break;
432 case MHW_VDBOX_VP9_INTERNAL_BUFFER_SEGMENT_ID:
433 bufferSize = widthInSb * heightInSb;
434 break;
435 case MHW_VDBOX_VP9_INTERNAL_BUFFER_HVD_LINE:
436 case MHW_VDBOX_VP9_INTERNAL_BUFFER_HVD_TILE:
437 bufferSize = widthInSb;
438 break;
439 default:
440 eStatus = MOS_STATUS_INVALID_PARAMETER;
441 break;
442 }
443
444 hcpBufSizeParam->dwBufferSize = bufferSize * MHW_CACHELINE_SIZE;
445
446 return eStatus;
447 }
448
449 MOS_STATUS IsHevcBufferReallocNeeded(
450 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType,
451 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam)
452 {
453 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
454
455 MHW_FUNCTION_ENTER;
456
457 MHW_MI_CHK_NULL(reallocParam);
458
459 bool realloc = false;
460 uint32_t picWidth = reallocParam->dwPicWidth;
461 uint32_t picHeight = reallocParam->dwPicHeight;
462 uint32_t picWidthAlloced = reallocParam->dwPicWidthAlloced;
463 uint32_t picHeightAlloced = reallocParam->dwPicHeightAlloced;
464
465 switch (bufferType)
466 {
467 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE:
468 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE:
469 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE:
470 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE:
471 case MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE:
472 case MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE:
473 realloc = (picWidth > picWidthAlloced) ? true : false;
474 break;
475 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL:
476 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL:
477 case MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL:
478 realloc = (picHeight > picHeightAlloced) ? true : false;
479 break;
480 case MHW_VDBOX_HCP_INTERNAL_BUFFER_CURR_MV_TEMPORAL:
481 realloc = (picWidth > picWidthAlloced || picHeight > picHeightAlloced) ? true : false;
482 break;
483 default:
484 eStatus = MOS_STATUS_INVALID_PARAMETER;
485 break;
486 }
487 reallocParam->bNeedBiggerSize = realloc;
488
489 return eStatus;
490 }
491
492 MOS_STATUS IsVp9BufferReallocNeeded(
493 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType,
494 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam)
495 {
496 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
497
498 MHW_FUNCTION_ENTER;
499
500 MHW_MI_CHK_NULL(reallocParam);
501
502 bool realloc = false;
503 uint32_t widthInSb = reallocParam->dwPicWidth;
504 uint32_t heightInSb = reallocParam->dwPicHeight;
505 uint32_t picWidthInSbAlloced = reallocParam->dwPicWidthAlloced;
506 uint32_t picHeightInSbAlloced = reallocParam->dwPicHeightAlloced;
507
508 switch (bufferType)
509 {
510 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE:
511 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE:
512 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE:
513 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE:
514 case MHW_VDBOX_VP9_INTERNAL_BUFFER_HVD_LINE:
515 case MHW_VDBOX_VP9_INTERNAL_BUFFER_HVD_TILE:
516 realloc = (widthInSb > picWidthInSbAlloced) ? true : false;
517 break;
518 case MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL:
519 case MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL:
520 realloc = (heightInSb > picHeightInSbAlloced) ? true : false;
521 break;
522 case MHW_VDBOX_HCP_INTERNAL_BUFFER_CURR_MV_TEMPORAL:
523 case MHW_VDBOX_HCP_INTERNAL_BUFFER_COLL_MV_TEMPORAL:
524 case MHW_VDBOX_VP9_INTERNAL_BUFFER_SEGMENT_ID:
525 realloc = (heightInSb > picHeightInSbAlloced || widthInSb > picWidthInSbAlloced) ? true : false;
526 break;
527 default:
528 eStatus = MOS_STATUS_INVALID_PARAMETER;
529 break;
530 }
531
532 reallocParam->bNeedBiggerSize = realloc;
533
534 return eStatus;
535 }
536
537 MOS_STATUS AddHcpVp9PicStateCmd(
538 PMOS_COMMAND_BUFFER cmdBuffer,
539 PMHW_BATCH_BUFFER batchBuffer,
540 PMHW_VDBOX_VP9_PIC_STATE params)
541 {
542 return MOS_STATUS_PLATFORM_NOT_SUPPORTED;
543 }
544
545 MOS_STATUS AddHcpVp9PicStateEncCmd(
546 PMOS_COMMAND_BUFFER cmdBuffer,
547 PMHW_BATCH_BUFFER batchBuffer,
548 PMHW_VDBOX_VP9_ENCODE_PIC_STATE params)
549 {
550 return MOS_STATUS_PLATFORM_NOT_SUPPORTED;
551 }
552
553 MOS_STATUS AddHcpHevcVp9RdoqStateCmd(
554 PMOS_COMMAND_BUFFER cmdBuffer,
555 PMHW_VDBOX_HEVC_PIC_STATE params)
556 {
557 return MOS_STATUS_PLATFORM_NOT_SUPPORTED;
558 }
559
560 MOS_STATUS AddHcpPipeModeSelectCmd(
561 PMOS_COMMAND_BUFFER cmdBuffer,
562 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
563 {
564 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
565
566 MHW_FUNCTION_ENTER;
567
568 MHW_MI_CHK_NULL(this->m_osInterface);
569 MHW_MI_CHK_NULL(params);
570
571 typename THcpCmds::HCP_PIPE_MODE_SELECT_CMD cmd;
572
573 cmd.DW1.CodecStandardSelect = CodecHal_GetStandardFromMode(params->Mode) - CODECHAL_HCP_BASE;
574 cmd.DW1.DeblockerStreamoutEnable = params->bDeblockerStreamOutEnable;
575
576 if (this->m_decodeInUse)
577 {
578 cmd.DW1.CodecSelect = cmd.CODEC_SELECT_DECODE;
579 }
580 else
581 {
582 cmd.DW1.CodecSelect = cmd.CODEC_SELECT_ENCODE;
583 }
584
585 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
586
587 return eStatus;
588 }
589
590 MOS_STATUS AddHcpQmStateCmd(
591 PMOS_COMMAND_BUFFER cmdBuffer,
592 PMHW_VDBOX_QM_PARAMS params)
593 {
594 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
595
596 MHW_FUNCTION_ENTER;
597
598 MHW_MI_CHK_NULL(this->m_osInterface);
599 MHW_MI_CHK_NULL(cmdBuffer);
600 MHW_MI_CHK_NULL(params);
601
602 typename THcpCmds::HCP_QM_STATE_CMD cmd;
603
604 if (params->Standard == CODECHAL_HEVC)
605 {
606 uint8_t* qMatrix = nullptr;
607 MHW_MI_CHK_NULL(params->pHevcIqMatrix);
608
609 qMatrix = (uint8_t*)cmd.Quantizermatrix;
610
611 for (uint8_t sizeId = 0; sizeId < 4; sizeId++) // 4x4, 8x8, 16x16, 32x32
612 {
613 for (uint8_t predType = 0; predType < 2; predType++) // Intra, Inter
614 {
615 for (uint8_t color = 0; color < 3; color++) // Y, Cb, Cr
616 {
617 if ((sizeId == 3) && (color != 0))
618 break;
619
620 cmd.DW1.Sizeid = sizeId;
621 cmd.DW1.PredictionType = predType;
622 cmd.DW1.ColorComponent = color;
623 switch (sizeId)
624 {
625 case HEVC_QM_4x4:
626 case HEVC_QM_8x8:
627 default:
628 cmd.DW1.DcCoefficient = 0;
629 break;
630 case HEVC_QM_16x16:
631 cmd.DW1.DcCoefficient = params->pHevcIqMatrix->ListDC16x16[3 * predType + color];
632 break;
633 case HEVC_QM_32x32:
634 cmd.DW1.DcCoefficient = params->pHevcIqMatrix->ListDC32x32[predType];
635 break;
636 }
637
638 if (sizeId == HEVC_QM_4x4)
639 {
640 for (uint8_t i = 0; i < 4; i++)
641 {
642 for (uint8_t ii = 0; ii < 4; ii++)
643 {
644 qMatrix[4 * i + ii] = params->pHevcIqMatrix->List4x4[3 * predType + color][4 * i + ii];
645 }
646 }
647 }
648 else if (sizeId == HEVC_QM_8x8)
649 {
650 for (uint8_t i = 0; i < 8; i++)
651 {
652 for (uint8_t ii = 0; ii < 8; ii++)
653 {
654 qMatrix[8 * i + ii] = params->pHevcIqMatrix->List8x8[3 * predType + color][8 * i + ii];
655 }
656 }
657 }
658 else if (sizeId == HEVC_QM_16x16)
659 {
660 for (uint8_t i = 0; i < 8; i++)
661 {
662 for (uint8_t ii = 0; ii < 8; ii++)
663 {
664 qMatrix[8 * i + ii] = params->pHevcIqMatrix->List16x16[3 * predType + color][8 * i + ii];
665 }
666 }
667 }
668 else // 32x32
669 {
670 for (uint8_t i = 0; i < 8; i++)
671 {
672 for (uint8_t ii = 0; ii < 8; ii++)
673 {
674 qMatrix[8 * i + ii] = params->pHevcIqMatrix->List32x32[predType][8 * i + ii];
675 }
676 }
677 }
678
679 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
680 }
681 }
682 }
683 }
684 else
685 {
686 eStatus = MOS_STATUS_INVALID_PARAMETER;
687 }
688
689 return eStatus;
690 }
691
692 MOS_STATUS AddHcpPipeBufAddrCmd(
693 PMOS_COMMAND_BUFFER cmdBuffer,
694 PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)
695 {
696 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
697
698 MHW_FUNCTION_ENTER;
699
700 MHW_MI_CHK_NULL(this->m_osInterface);
701 MHW_MI_CHK_NULL(cmdBuffer);
702 MHW_MI_CHK_NULL(params);
703
704 MHW_RESOURCE_PARAMS resourceParams;
705 typename THcpCmds::HCP_PIPE_BUF_ADDR_STATE_CMD cmd;
706 bool firstRefPic = true;
707
708 #if (_DEBUG || _RELEASE_INTERNAL)
709 MOS_USER_FEATURE_VALUE_WRITE_DATA UserFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
710 UserFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED_ID;
711 if (this->m_hevcDatRowStoreCache.bEnabled ||
712 this->m_hevcDfRowStoreCache.bEnabled ||
713 this->m_hevcSaoRowStoreCache.bEnabled ||
714 this->m_vp9HvdRowStoreCache.bEnabled ||
715 this->m_vp9DfRowStoreCache.bEnabled)
716 {
717 UserFeatureWriteData.Value.i32Data = 1;
718 }
719 MOS_UserFeature_WriteValues_ID(nullptr, &UserFeatureWriteData, 1, this->m_osInterface->pOsContext);
720 #endif
721
722 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
723 resourceParams.dwLsbNum = MHW_VDBOX_HCP_DECODED_BUFFER_SHIFT;
724 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
725
726 // Decoded Picture
727 // Caching policy change if any of below modes are true
728 // Note for future dev: probably a good idea to add a macro for the below check
729 if (this->m_osInterface->osCpInterface->IsHMEnabled() ||
730 this->m_osInterface->osCpInterface->IsIDMEnabled() ||
731 this->m_osInterface->osCpInterface->IsSMEnabled())
732 {
733 cmd.DecodedPictureMemoryAddressAttributes.DW0.Value |= this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC_PARTIALENCSURFACE].Value;
734 }
735 else
736 {
737 cmd.DecodedPictureMemoryAddressAttributes.DW0.Value |=
738 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC].Value;
739 }
740
741 cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(params->psPreDeblockSurface->TileType);
742
743 // For HEVC 8bit/10bit mixed case, register App's RenderTarget for specific use case
744 if (params->presP010RTSurface != nullptr)
745 {
746 resourceParams.presResource = &(params->presP010RTSurface->OsResource);
747 resourceParams.dwOffset = params->presP010RTSurface->dwOffset;
748 resourceParams.pdwCmd = (cmd.DecodedPicture.DW0_1.Value);
749 resourceParams.dwLocationInCmd = 1;
750 resourceParams.bIsWritable = true;
751
752 if (this->m_osInterface->bAllowExtraPatchToSameLoc)
753 {
754 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
755 this->m_osInterface,
756 cmdBuffer,
757 &resourceParams));
758 }
759 else //if not allowed to patch another OsResource to same location in cmd, just register resource here
760 {
761 MHW_MI_CHK_STATUS(this->m_osInterface->pfnRegisterResource(
762 this->m_osInterface,
763 resourceParams.presResource,
764 resourceParams.bIsWritable,
765 resourceParams.bIsWritable));
766 }
767 }
768
769 resourceParams.presResource = &(params->psPreDeblockSurface->OsResource);
770 resourceParams.dwOffset = params->psPreDeblockSurface->dwOffset;
771 resourceParams.pdwCmd = (cmd.DecodedPicture.DW0_1.Value);
772 resourceParams.dwLocationInCmd = 1;
773 resourceParams.bIsWritable = true;
774
775 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
776 this->m_osInterface,
777 cmdBuffer,
778 &resourceParams));
779
780 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
781
782 // Deblocking Filter Line Buffer
783 if (this->m_hevcDfRowStoreCache.bEnabled)
784 {
785 cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
786 cmd.DeblockingFilterLineBuffer.DW0_1.Graphicsaddress476 = this->m_hevcDfRowStoreCache.dwAddress;
787 }
788 else if (this->m_vp9DfRowStoreCache.bEnabled)
789 {
790 cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
791 cmd.DeblockingFilterLineBuffer.DW0_1.Graphicsaddress476 = this->m_vp9DfRowStoreCache.dwAddress;
792 }
793 else if (params->presMfdDeblockingFilterRowStoreScratchBuffer != nullptr)
794 {
795 cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.Value |=
796 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
797
798 resourceParams.presResource = params->presMfdDeblockingFilterRowStoreScratchBuffer;
799 resourceParams.dwOffset = 0;
800 resourceParams.pdwCmd = (cmd.DeblockingFilterLineBuffer.DW0_1.Value);
801 resourceParams.dwLocationInCmd = 4;
802 resourceParams.bIsWritable = true;
803
804 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
805 this->m_osInterface,
806 cmdBuffer,
807 &resourceParams));
808 }
809
810 // Deblocking Filter Tile Line Buffer
811 if (params->presDeblockingFilterTileRowStoreScratchBuffer != nullptr)
812 {
813 cmd.DeblockingFilterTileLineBufferMemoryAddressAttributes.DW0.Value |=
814 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
815
816 resourceParams.presResource = params->presDeblockingFilterTileRowStoreScratchBuffer;
817 resourceParams.dwOffset = 0;
818 resourceParams.pdwCmd = (cmd.DeblockingFilterTileLineBuffer.DW0_1.Value);
819 resourceParams.dwLocationInCmd = 7;
820 resourceParams.bIsWritable = true;
821
822 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
823 this->m_osInterface,
824 cmdBuffer,
825 &resourceParams));
826 }
827
828 // Deblocking Filter Tile Column Buffer
829 if (params->presDeblockingFilterColumnRowStoreScratchBuffer != nullptr)
830 {
831 cmd.DeblockingFilterTileColumnBufferMemoryAddressAttributes.DW0.Value |=
832 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
833
834 resourceParams.presResource = params->presDeblockingFilterColumnRowStoreScratchBuffer;
835 resourceParams.dwOffset = 0;
836 resourceParams.pdwCmd = (cmd.DeblockingFilterTileColumnBuffer.DW0_1.Value);
837 resourceParams.dwLocationInCmd = 10;
838 resourceParams.bIsWritable = true;
839
840 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
841 this->m_osInterface,
842 cmdBuffer,
843 &resourceParams));
844 }
845
846 // Metadata Line Buffer
847 if (this->m_hevcDatRowStoreCache.bEnabled)
848 {
849 cmd.MetadataLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
850 cmd.MetadataLineBuffer.DW0_1.Graphicsaddress476 = this->m_hevcDatRowStoreCache.dwAddress;
851 }
852 else if (params->presMetadataLineBuffer != nullptr)
853 {
854 cmd.MetadataLineBufferMemoryAddressAttributes.DW0.Value |=
855 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MD_CODEC].Value;
856
857 resourceParams.presResource = params->presMetadataLineBuffer;
858 resourceParams.dwOffset = 0;
859 resourceParams.pdwCmd = cmd.MetadataLineBuffer.DW0_1.Value;
860 resourceParams.dwLocationInCmd = 13;
861 resourceParams.bIsWritable = true;
862
863 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
864 this->m_osInterface,
865 cmdBuffer,
866 &resourceParams));
867 }
868
869 // Metadata Tile Line Buffer
870 if (params->presMetadataTileLineBuffer != nullptr)
871 {
872 cmd.MetadataTileLineBufferMemoryAddressAttributes.DW0.Value |=
873 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MD_CODEC].Value;
874
875 resourceParams.presResource = params->presMetadataTileLineBuffer;
876 resourceParams.dwOffset = 0;
877 resourceParams.pdwCmd = (cmd.MetadataTileLineBuffer.DW0_1.Value);
878 resourceParams.dwLocationInCmd = 16;
879 resourceParams.bIsWritable = true;
880
881 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
882 this->m_osInterface,
883 cmdBuffer,
884 &resourceParams));
885 }
886
887 // Metadata Tile Column Buffer
888 if (params->presMetadataTileColumnBuffer != nullptr)
889 {
890 cmd.MetadataTileColumnBufferMemoryAddressAttributes.DW0.Value |=
891 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MD_CODEC].Value;
892
893 resourceParams.presResource = params->presMetadataTileColumnBuffer;
894 resourceParams.dwOffset = 0;
895 resourceParams.pdwCmd = (cmd.MetadataTileColumnBuffer.DW0_1.Value);
896 resourceParams.dwLocationInCmd = 19;
897 resourceParams.bIsWritable = true;
898
899 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
900 this->m_osInterface,
901 cmdBuffer,
902 &resourceParams));
903 }
904
905 // SAO Line Buffer
906 if (this->m_hevcSaoRowStoreCache.bEnabled)
907 {
908 cmd.SaoLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
909 cmd.SaoLineBuffer.DW0_1.Graphicsaddress476 = this->m_hevcSaoRowStoreCache.dwAddress;
910 }
911 else if (params->presSaoLineBuffer != nullptr)
912 {
913 cmd.SaoLineBufferMemoryAddressAttributes.DW0.Value |=
914 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_SAO_CODEC].Value;
915
916 resourceParams.presResource = params->presSaoLineBuffer;
917 resourceParams.dwOffset = 0;
918 resourceParams.pdwCmd = (cmd.SaoLineBuffer.DW0_1.Value);
919 resourceParams.dwLocationInCmd = 22;
920 resourceParams.bIsWritable = true;
921
922 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
923 this->m_osInterface,
924 cmdBuffer,
925 &resourceParams));
926 }
927
928 // SAO Tile Line Buffer
929 if (params->presSaoTileLineBuffer != nullptr)
930 {
931 cmd.SaoTileLineBufferMemoryAddressAttributes.DW0.Value |=
932 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_SAO_CODEC].Value;
933
934 resourceParams.presResource = params->presSaoTileLineBuffer;
935 resourceParams.dwOffset = 0;
936 resourceParams.pdwCmd = (cmd.SaoTileLineBuffer.DW0_1.Value);
937 resourceParams.dwLocationInCmd = 25;
938 resourceParams.bIsWritable = true;
939
940 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
941 this->m_osInterface,
942 cmdBuffer,
943 &resourceParams));
944 }
945
946 // SAO Tile Column Buffer
947 if (params->presSaoTileColumnBuffer != nullptr)
948 {
949 cmd.SaoTileColumnBufferMemoryAddressAttributes.DW0.Value |=
950 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_SAO_CODEC].Value;
951
952 resourceParams.presResource = params->presSaoTileColumnBuffer;
953 resourceParams.dwOffset = 0;
954 resourceParams.pdwCmd = (cmd.SaoTileColumnBuffer.DW0_1.Value);
955 resourceParams.dwLocationInCmd = 28;
956 resourceParams.bIsWritable = true;
957
958 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
959 this->m_osInterface,
960 cmdBuffer,
961 &resourceParams));
962 }
963
964 // Current Motion Vector Temporal Buffer
965 if (params->presCurMvTempBuffer != nullptr)
966 {
967 cmd.CurrentMotionVectorTemporalBufferMemoryAddressAttributes.DW0.Value |=
968 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MV_CODEC].Value;
969
970 resourceParams.presResource = params->presCurMvTempBuffer;
971 resourceParams.dwOffset = 0;
972 resourceParams.pdwCmd = (cmd.CurrentMotionVectorTemporalBuffer.DW0_1.Value);
973 resourceParams.dwLocationInCmd = 31;
974 resourceParams.bIsWritable = true;
975
976 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
977 this->m_osInterface,
978 cmdBuffer,
979 &resourceParams));
980 }
981
982 // Reference Picture Buffer
983 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.Value |=
984 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
985
986 // 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
987 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
988 {
989 if (params->presReferences[i] != nullptr)
990 {
991 MOS_SURFACE details;
992 MOS_ZeroMemory(&details, sizeof(details));
993 details.Format = Format_Invalid;
994 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presReferences[i], &details));
995
996 if (firstRefPic)
997 {
998 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
999 firstRefPic = false;
1000 }
1001
1002 resourceParams.presResource = params->presReferences[i];
1003 resourceParams.pdwCmd = (cmd.ReferencePictureBaseAddressRefaddr07[i].DW0_1.Value);
1004 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
1005 resourceParams.dwLocationInCmd = (i * 2) + 37; // * 2 to account for QW rather than DW
1006 resourceParams.bIsWritable = false;
1007
1008 resourceParams.dwSharedMocsOffset = 53 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW53
1009
1010 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1011 this->m_osInterface,
1012 cmdBuffer,
1013 &resourceParams));
1014 }
1015 }
1016
1017 // Reset dwSharedMocsOffset
1018 resourceParams.dwSharedMocsOffset = MOS_MFX_PIPE_BUF_ADDR;
1019
1020 // Original Uncompressed Picture Source, Encoder only
1021 if (params->psRawSurface != nullptr)
1022 {
1023 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.Value |=
1024 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
1025
1026 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(params->psRawSurface->TileType);
1027
1028 resourceParams.presResource = &params->psRawSurface->OsResource;
1029 resourceParams.dwOffset = params->psRawSurface->dwOffset;
1030 resourceParams.pdwCmd = (cmd.OriginalUncompressedPictureSource.DW0_1.Value);
1031 resourceParams.dwLocationInCmd = 54;
1032 resourceParams.bIsWritable = false;
1033
1034 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1035 this->m_osInterface,
1036 cmdBuffer,
1037 &resourceParams));
1038 }
1039
1040 // StreamOut Data Destination, Decoder only
1041 if (params->presStreamOutBuffer != nullptr)
1042 {
1043 cmd.StreamoutDataDestinationMemoryAddressAttributes.DW0.Value |=
1044 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
1045
1046 resourceParams.presResource = params->presStreamOutBuffer;
1047 resourceParams.dwOffset = 0;
1048 resourceParams.pdwCmd = (cmd.StreamoutDataDestination.DW0_1.Value);
1049 resourceParams.dwLocationInCmd = 57;
1050 resourceParams.bIsWritable = true;
1051
1052 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1053 this->m_osInterface,
1054 cmdBuffer,
1055 &resourceParams));
1056 }
1057
1058 // Decoded Picture Status / Error Buffer Base Address
1059 if (params->presLcuBaseAddressBuffer != nullptr)
1060 {
1061 cmd.DecodedPictureStatusErrorBufferBaseAddressMemoryAddressAttributes.DW0.Value |=
1062 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_STATUS_ERROR_CODEC].Value;
1063
1064 resourceParams.presResource = params->presLcuBaseAddressBuffer;
1065 resourceParams.dwOffset = 0;
1066 resourceParams.pdwCmd = (cmd.DecodedPictureStatusErrorBufferBaseAddressOrEncodedSliceSizeStreamoutBaseAddress.DW0_1.Value);
1067 resourceParams.dwLocationInCmd = 60;
1068 resourceParams.bIsWritable = true;
1069
1070 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1071 this->m_osInterface,
1072 cmdBuffer,
1073 &resourceParams));
1074 }
1075
1076 // LCU ILDB StreamOut Buffer
1077 if (params->presLcuILDBStreamOutBuffer != nullptr)
1078 {
1079 cmd.LcuIldbStreamoutBufferMemoryAddressAttributes.DW0.Value |=
1080 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_LCU_ILDB_STREAMOUT_CODEC].Value;
1081
1082 resourceParams.presResource = params->presLcuILDBStreamOutBuffer;
1083 resourceParams.dwOffset = 0;
1084 resourceParams.pdwCmd = (cmd.LcuIldbStreamoutBuffer.DW0_1.Value);
1085 resourceParams.dwLocationInCmd = 63;
1086 resourceParams.bIsWritable = true;
1087
1088 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1089 this->m_osInterface,
1090 cmdBuffer,
1091 &resourceParams));
1092 }
1093
1094 // Collocated Motion vector Temporal Buffer
1095 cmd.CollocatedMotionVectorTemporalBuffer07MemoryAddressAttributes.DW0.Value |=
1096 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MV_CODEC].Value;
1097
1098 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
1099 {
1100 if (params->presColMvTempBuffer[i] != nullptr)
1101 {
1102 resourceParams.presResource = params->presColMvTempBuffer[i];
1103 resourceParams.dwOffset = 0;
1104 resourceParams.pdwCmd = (cmd.CollocatedMotionVectorTemporalBuffer07[i].DW0_1.Value);
1105 resourceParams.dwLocationInCmd = (i * 2) + 66;
1106 resourceParams.bIsWritable = false;
1107
1108 resourceParams.dwSharedMocsOffset = 82 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW82
1109
1110 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1111 this->m_osInterface,
1112 cmdBuffer,
1113 &resourceParams));
1114 }
1115 }
1116
1117 // Reset dwSharedMocsOffset
1118 resourceParams.dwSharedMocsOffset = 0;
1119
1120 // VP9 Probability Buffer
1121 if (params->presVp9ProbBuffer != nullptr)
1122 {
1123 cmd.Vp9ProbabilityBufferReadWriteMemoryAddressAttributes.DW0.Value |=
1124 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VP9_PROBABILITY_BUFFER_CODEC].Value;
1125
1126 resourceParams.presResource = params->presVp9ProbBuffer;
1127 resourceParams.dwOffset = 0;
1128 resourceParams.pdwCmd = (cmd.Vp9ProbabilityBufferReadWrite.DW0_1.Value);
1129 resourceParams.dwLocationInCmd = 83;
1130 resourceParams.bIsWritable = true;
1131
1132 resourceParams.dwSharedMocsOffset = 85 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW88
1133
1134 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1135 this->m_osInterface,
1136 cmdBuffer,
1137 &resourceParams));
1138 }
1139
1140 // Reset dwSharedMocsOffset
1141 resourceParams.dwSharedMocsOffset = 0;
1142
1143 // VP9 Segment Id Buffer
1144 if (params->presVp9SegmentIdBuffer != nullptr)
1145 {
1146 cmd.Vp9SegmentIdBufferReadWriteMemoryAddressAttributes.DW0.Value |=
1147 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VP9_SEGMENT_ID_BUFFER_CODEC].Value;
1148
1149 resourceParams.presResource = params->presVp9SegmentIdBuffer;
1150 resourceParams.dwOffset = 0;
1151 resourceParams.pdwCmd = (cmd.DW86_87.Value);
1152 resourceParams.dwLocationInCmd = 86;
1153 resourceParams.bIsWritable = true;
1154
1155 resourceParams.dwSharedMocsOffset = 88 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW88
1156
1157 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1158 this->m_osInterface,
1159 cmdBuffer,
1160 &resourceParams));
1161 }
1162
1163 // Reset dwSharedMocsOffset
1164 resourceParams.dwSharedMocsOffset = 0;
1165
1166 // HVD Line Row Store Buffer
1167 if (this->m_vp9HvdRowStoreCache.bEnabled)
1168 {
1169 cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
1170 cmd.Vp9HvdLineRowstoreBufferReadWrite.DW0_1.Graphicsaddress476 = this->m_vp9HvdRowStoreCache.dwAddress;
1171 }
1172 else if (params->presHvdLineRowStoreBuffer != nullptr)
1173 {
1174 cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value |=
1175 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VP9_HVD_ROWSTORE_BUFFER_CODEC].Value;
1176
1177 resourceParams.presResource = params->presHvdLineRowStoreBuffer;
1178 resourceParams.dwOffset = 0;
1179 resourceParams.pdwCmd = (cmd.Vp9HvdLineRowstoreBufferReadWrite.DW0_1.Value);
1180 resourceParams.dwLocationInCmd = 89;
1181 resourceParams.bIsWritable = true;
1182
1183 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1184 this->m_osInterface,
1185 cmdBuffer,
1186 &resourceParams));
1187 }
1188
1189 // HVD Tile Row Store Buffer
1190 if (params->presHvdTileRowStoreBuffer != nullptr)
1191 {
1192 cmd.Vp9HvdTileRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value |=
1193 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VP9_HVD_ROWSTORE_BUFFER_CODEC].Value;
1194
1195 resourceParams.presResource = params->presHvdTileRowStoreBuffer;
1196 resourceParams.dwOffset = 0;
1197 resourceParams.pdwCmd = (cmd.Vp9HvdTileRowstoreBufferReadWrite.DW0_1.Value);
1198 resourceParams.dwLocationInCmd = 92;
1199 resourceParams.bIsWritable = true;
1200
1201 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1202 this->m_osInterface,
1203 cmdBuffer,
1204 &resourceParams));
1205 }
1206
1207 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1208
1209 return eStatus;
1210 }
1211
1212 MOS_STATUS AddHcpIndObjBaseAddrCmd(
1213 PMOS_COMMAND_BUFFER cmdBuffer,
1214 PMHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS params)
1215 {
1216 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;;
1217
1218 MHW_FUNCTION_ENTER;
1219
1220 MHW_MI_CHK_NULL(this->m_osInterface);
1221 MHW_MI_CHK_NULL(params);
1222
1223 MHW_RESOURCE_PARAMS resourceParams;
1224 typename THcpCmds::HCP_IND_OBJ_BASE_ADDR_STATE_CMD cmd;
1225
1226 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1227 resourceParams.dwLsbNum = MHW_VDBOX_HCP_UPPER_BOUND_STATE_SHIFT;
1228 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
1229
1230 // mode specific settings
1231 if (CodecHalIsDecodeModeVLD(params->Mode))
1232 {
1233 MHW_MI_CHK_NULL(params->presDataBuffer);
1234
1235 cmd.HcpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value |=
1236 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE].Value;
1237
1238 resourceParams.presResource = params->presDataBuffer;
1239 resourceParams.dwOffset = params->dwDataOffset;
1240 resourceParams.pdwCmd = (cmd.HcpIndirectBitstreamObjectBaseAddress.DW0_1.Value);
1241 resourceParams.dwLocationInCmd = 1;
1242 resourceParams.dwSize = params->dwDataSize;
1243 resourceParams.bIsWritable = false;
1244
1245 // upper bound of the allocated resource will be set at 3 DW apart from address location
1246 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1247
1248 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1249 this->m_osInterface,
1250 cmdBuffer,
1251 &resourceParams));
1252
1253 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
1254 }
1255
1256 // following is for encoder
1257 if (!this->m_decodeInUse)
1258 {
1259 if (params->presMvObjectBuffer)
1260 {
1261 cmd.HcpIndirectCuObjectObjectMemoryAddressAttributes.DW0.Value |=
1262 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC].Value;
1263
1264 resourceParams.presResource = params->presMvObjectBuffer;
1265 resourceParams.dwOffset = params->dwMvObjectOffset;
1266 resourceParams.pdwCmd = (cmd.DW6_7.Value);
1267 resourceParams.dwLocationInCmd = 6;
1268 resourceParams.dwSize = MOS_ALIGN_CEIL(params->dwMvObjectSize, 0x1000);
1269 resourceParams.bIsWritable = false;
1270
1271 // no upper bound for indirect CU object
1272 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
1273
1274 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1275 this->m_osInterface,
1276 cmdBuffer,
1277 &resourceParams));
1278 }
1279
1280 if (params->presPakBaseObjectBuffer)
1281 {
1282 cmd.HcpPakBseObjectAddressMemoryAddressAttributes.DW0.Value |=
1283 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC].Value;
1284
1285 resourceParams.presResource = params->presPakBaseObjectBuffer;
1286 resourceParams.dwOffset = 0;
1287 resourceParams.pdwCmd = (cmd.DW9_10.Value);
1288 resourceParams.dwLocationInCmd = 9;
1289 resourceParams.dwSize = MOS_ALIGN_CEIL(params->dwPakBaseObjectSize, 0x1000);
1290 resourceParams.bIsWritable = true;
1291
1292 // upper bound of the allocated resource will be set at 3 DW apart from address location
1293 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1294
1295 MHW_MI_CHK_STATUS(this->pfnAddResourceToCmd(
1296 this->m_osInterface,
1297 cmdBuffer,
1298 &resourceParams));
1299 }
1300 }
1301
1302 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1303
1304 return eStatus;
1305 }
1306
1307 MOS_STATUS AddHcpFqmStateCmd(
1308 PMOS_COMMAND_BUFFER cmdBuffer,
1309 PMHW_VDBOX_QM_PARAMS params)
1310 {
1311 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1312
1313 MHW_FUNCTION_ENTER;
1314
1315 MHW_MI_CHK_NULL(this->m_osInterface);
1316 MHW_MI_CHK_NULL(cmdBuffer);
1317 MHW_MI_CHK_NULL(params);
1318
1319 typename THcpCmds::HCP_FQM_STATE_CMD cmd;
1320
1321 if (params->Standard == CODECHAL_HEVC)
1322 {
1323 MHW_MI_CHK_NULL(params->pHevcIqMatrix);
1324
1325 auto iqMatrix = params->pHevcIqMatrix;
1326 uint16_t *fqMatrix = (uint16_t*)cmd.Quantizermatrix;
1327
1328 /* 4x4 */
1329 for (uint8_t i = 0; i < 32; i++)
1330 {
1331 cmd.Quantizermatrix[i] = 0;
1332 }
1333 for (uint8_t intraInter = 0; intraInter <= 1; intraInter++)
1334 {
1335 cmd.DW1.IntraInter = intraInter;
1336 cmd.DW1.Sizeid = 0;
1337 cmd.DW1.ColorComponent = 0;
1338
1339 for (uint8_t i = 0; i < 16; i++)
1340 {
1341 fqMatrix[i] =
1342 GetReciprocalScalingValue(iqMatrix->List4x4[3 * intraInter][i]);
1343 }
1344
1345 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1346 }
1347
1348 /* 8x8, 16x16 and 32x32 */
1349 for (uint8_t i = 0; i < 32; i++)
1350 {
1351 cmd.Quantizermatrix[i] = 0;
1352 }
1353 for (uint8_t intraInter = 0; intraInter <= 1; intraInter++)
1354 {
1355 cmd.DW1.IntraInter = intraInter;
1356 cmd.DW1.Sizeid = 1;
1357 cmd.DW1.ColorComponent = 0;
1358
1359 for (uint8_t i = 0; i < 64; i++)
1360 {
1361 fqMatrix[i] =
1362 GetReciprocalScalingValue(iqMatrix->List8x8[3 * intraInter][i]);
1363 }
1364
1365 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1366 }
1367
1368 /* 16x16 DC */
1369 for (uint8_t i = 0; i < 32; i++)
1370 {
1371 cmd.Quantizermatrix[i] = 0;
1372 }
1373 for (uint8_t intraInter = 0; intraInter <= 1; intraInter++)
1374 {
1375 cmd.DW1.IntraInter = intraInter;
1376 cmd.DW1.Sizeid = 2;
1377 cmd.DW1.ColorComponent = 0;
1378 cmd.DW1.FqmDcValue1Dc = GetReciprocalScalingValue(iqMatrix->ListDC16x16[3 * intraInter]);
1379
1380 for (uint8_t i = 0; i < 64; i++)
1381 {
1382 fqMatrix[i] =
1383 GetReciprocalScalingValue(iqMatrix->List16x16[3 * intraInter][i]);
1384 }
1385
1386 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1387 }
1388
1389 /* 32x32 DC */
1390 for (uint8_t i = 0; i < 32; i++)
1391 {
1392 cmd.Quantizermatrix[i] = 0;
1393 }
1394 for (uint8_t intraInter = 0; intraInter <= 1; intraInter++)
1395 {
1396 cmd.DW1.IntraInter = intraInter;
1397 cmd.DW1.Sizeid = 3;
1398 cmd.DW1.ColorComponent = 0;
1399 cmd.DW1.FqmDcValue1Dc = GetReciprocalScalingValue(iqMatrix->ListDC32x32[intraInter]);
1400
1401 for (uint8_t i = 0; i < 64; i++)
1402 {
1403 fqMatrix[i] =
1404 GetReciprocalScalingValue(iqMatrix->List32x32[intraInter][i]);
1405 }
1406
1407 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1408 }
1409 }
1410 else
1411 {
1412 eStatus = MOS_STATUS_INVALID_PARAMETER;
1413 }
1414
1415 return eStatus;
1416 }
1417
1418 MOS_STATUS AddHcpEncodePicStateCmd(
1419 PMOS_COMMAND_BUFFER cmdBuffer,
1420 PMHW_VDBOX_HEVC_PIC_STATE params)
1421 {
1422 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1423
1424 MHW_FUNCTION_ENTER;
1425
1426 MHW_MI_CHK_NULL(this->m_osInterface);
1427 MHW_MI_CHK_NULL(params);
1428 MHW_MI_CHK_NULL(params->pHevcEncSeqParams);
1429 MHW_MI_CHK_NULL(params->pHevcEncPicParams);
1430
1431 typename THcpCmds::HCP_PIC_STATE_CMD cmd;
1432
1433 auto hevcSeqParams = params->pHevcEncSeqParams;
1434 auto hevcPicParams = params->pHevcEncPicParams;
1435
1436 cmd.DW1.Framewidthinmincbminus1 = hevcSeqParams->wFrameWidthInMinCbMinus1;
1437 cmd.DW1.Frameheightinmincbminus1 = hevcSeqParams->wFrameHeightInMinCbMinus1;
1438
1439 cmd.DW2.Mincusize = hevcSeqParams->log2_min_coding_block_size_minus3;
1440 cmd.DW2.CtbsizeLcusize = hevcSeqParams->log2_max_coding_block_size_minus3;
1441 cmd.DW2.Maxtusize = hevcSeqParams->log2_max_transform_block_size_minus2;
1442 cmd.DW2.Mintusize = hevcSeqParams->log2_min_transform_block_size_minus2;
1443 cmd.DW2.Minpcmsize = 0;
1444 cmd.DW2.Maxpcmsize = 0;
1445
1446 cmd.DW3.Colpicisi = 0; // MBZ
1447 cmd.DW3.Curpicisi = 0; // MBZ
1448
1449 cmd.DW4.SampleAdaptiveOffsetEnabledFlag = 0;
1450 cmd.DW4.PcmEnabledFlag = 0;
1451 cmd.DW4.CuQpDeltaEnabledFlag = hevcPicParams->cu_qp_delta_enabled_flag;
1452 cmd.DW4.DiffCuQpDeltaDepthOrNamedAsMaxDqpDepth = hevcPicParams->diff_cu_qp_delta_depth;
1453 cmd.DW4.PcmLoopFilterDisableFlag = 1;
1454 cmd.DW4.ConstrainedIntraPredFlag = 0;
1455 cmd.DW4.Log2ParallelMergeLevelMinus2 = 0;
1456 cmd.DW4.SignDataHidingFlag = 0;
1457 cmd.DW4.TilesEnabledFlag = 0;
1458 cmd.DW4.WeightedPredFlag = hevcPicParams->weighted_pred_flag;
1459 cmd.DW4.WeightedBipredFlag = hevcPicParams->weighted_bipred_flag;
1460 cmd.DW4.Fieldpic = 0;
1461 cmd.DW4.Bottomfield = 0;
1462 cmd.DW4.TransformSkipEnabledFlag = hevcPicParams->transform_skip_enabled_flag;
1463 cmd.DW4.AmpEnabledFlag = hevcSeqParams->amp_enabled_flag;
1464 cmd.DW4.Reserved152 = hevcPicParams->LcuMaxBitsizeAllowed > 0;
1465 cmd.DW4.TransquantBypassEnableFlag = hevcPicParams->transquant_bypass_enabled_flag;
1466 cmd.DW4.StrongIntraSmoothingEnableFlag = hevcSeqParams->strong_intra_smoothing_enable_flag;
1467
1468 cmd.DW5.PicCbQpOffset = hevcPicParams->pps_cb_qp_offset & 0x1f;
1469 cmd.DW5.PicCrQpOffset = hevcPicParams->pps_cr_qp_offset & 0x1f;
1470 cmd.DW5.MaxTransformHierarchyDepthIntraOrNamedAsTuMaxDepthIntra = hevcSeqParams->max_transform_hierarchy_depth_intra;
1471 cmd.DW5.MaxTransformHierarchyDepthInterOrNamedAsTuMaxDepthInter = hevcSeqParams->max_transform_hierarchy_depth_inter;
1472 cmd.DW5.PcmSampleBitDepthChromaMinus1 = 7;
1473 cmd.DW5.PcmSampleBitDepthLumaMinus1 = 7;
1474
1475 cmd.DW6.LcumaxbitstatusenLcumaxsizereportmask = 1;
1476 cmd.DW6.FrameszoverstatusenFramebitratemaxreportmask = 1;
1477 cmd.DW6.FrameszunderstatusenFramebitrateminreportmask = 1;
1478
1479 cmd.DW6.LcuMaxBitsizeAllowed = hevcPicParams->LcuMaxBitsizeAllowed;
1480 if (params->maxFrameSize && params->currPass)
1481 {
1482 cmd.DW6.Nonfirstpassflag = 1;
1483 }
1484 else
1485 {
1486 cmd.DW6.Nonfirstpassflag = 0;
1487 }
1488
1489 // Set this to max value
1490 cmd.DW7.Framebitratemax = (1 << 14) - 1;
1491
1492 // Set this to Kilo Byte (=1) - Framebitratemax is in units of 4KBytes
1493 cmd.DW7.Framebitratemaxunit = 1;
1494
1495 // Set this to min available value
1496 cmd.DW8.Framebitratemin = 0;
1497
1498 // Set this to Kilo Byte (=1) - Framebitratemin is in units of 4KBytes
1499 cmd.DW8.Framebitrateminunit = 1;
1500
1501 // Set frame bitrate max and min delta to 0
1502 cmd.DW9.Framebitratemindelta = 0;
1503 cmd.DW9.Framebitratemaxdelta = 0;
1504
1505 cmd.DW10_11.Framedeltaqpmax = 0;
1506 cmd.DW12_13.Framedeltaqpmin = 0;
1507
1508 // Set frame delta QP max and min range array as [0, 1, 2, 4, 8, 16, 32, 255]
1509 // Delta QP range = [Framebitratemaxdelta*(FramedeltaQpmaxrange[n]>>5), Framebitratemaxdelta*(FramedeltaQpmaxrange[n]>>5)]
1510 cmd.DW14_15.Value[0] =
1511 cmd.DW16_17.Value[0] = (4 << 24) | (2 << 16) | (1 << 8);
1512 cmd.DW14_15.Value[1] =
1513 cmd.DW16_17.Value[1] = (255 << 24) | (32 << 16) | (16 << 8) | 8;
1514
1515 // Add for multiple pass
1516 if (params->maxFrameSize > 0 && params->deltaQp)
1517 {
1518 uint8_t hevcMaxPassNum = 8;
1519
1520 // When current pass is less than the max number of pass, set the delta QP.
1521 if (params->currPass < hevcMaxPassNum)
1522 {
1523 cmd.DW10_11.Value[0] = (params->deltaQp[params->currPass] << 24) | (params->deltaQp[params->currPass] << 16) |
1524 (params->deltaQp[params->currPass] << 8) | params->deltaQp[params->currPass];
1525 cmd.DW10_11.Value[1] = (params->deltaQp[params->currPass] << 24) | (params->deltaQp[params->currPass] << 16) |
1526 (params->deltaQp[params->currPass] << 8) | params->deltaQp[params->currPass];
1527 }
1528
1529 // If the calculated value of max frame size exceeded 14 bits, need set the unit as 4K byte. Else, set the unit as 32 byte.
1530 if (params->maxFrameSize >= (0x1 << 14) * 32)
1531 {
1532 cmd.DW7.Framebitratemaxunit = 1;
1533 cmd.DW7.Framebitratemax = params->maxFrameSize >> 12;
1534 cmd.DW9.Framebitratemaxdelta = params->maxFrameSize >> 13;
1535 }
1536 else
1537 {
1538 cmd.DW7.Framebitratemaxunit = 0;
1539 cmd.DW7.Framebitratemax = params->maxFrameSize >> 5;
1540 cmd.DW9.Framebitratemaxdelta = params->maxFrameSize >> 6;
1541 }
1542 }
1543
1544 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1545
1546 return eStatus;
1547 }
1548
1549 MOS_STATUS AddHcpEncodeSliceStateCmd(
1550 PMOS_COMMAND_BUFFER cmdBuffer,
1551 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
1552 {
1553 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1554
1555 MHW_FUNCTION_ENTER;
1556
1557 MHW_MI_CHK_NULL(hevcSliceState);
1558
1559 typename THcpCmds::HCP_SLICE_STATE_CMD cmd;
1560
1561 auto hevcSliceParams = hevcSliceState->pEncodeHevcSliceParams;
1562 auto hevcPicParams = hevcSliceState->pEncodeHevcPicParams;
1563 auto hevcSeqParams = hevcSliceState->pEncodeHevcSeqParams;
1564
1565 uint32_t ctbSize = 1 << (hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
1566 uint32_t widthInPix = (1 << (hevcSeqParams->log2_min_coding_block_size_minus3 + 3)) *
1567 (hevcSeqParams->wFrameWidthInMinCbMinus1 + 1);
1568 uint32_t widthInCtb = (widthInPix / ctbSize) +
1569 ((widthInPix % ctbSize) ? 1 : 0); // round up
1570
1571 uint32_t ctbAddr = hevcSliceParams->slice_segment_address;
1572
1573 cmd.DW1.SlicestartctbxOrSliceStartLcuXEncoder = ctbAddr % widthInCtb;
1574 cmd.DW1.SlicestartctbyOrSliceStartLcuYEncoder = ctbAddr / widthInCtb;
1575
1576 ctbAddr = hevcSliceParams->slice_segment_address + hevcSliceParams->NumLCUsInSlice;
1577 cmd.DW2.NextslicestartctbxOrNextSliceStartLcuXEncoder = ctbAddr % widthInCtb;
1578 cmd.DW2.NextslicestartctbyOrNextSliceStartLcuYEncoder = ctbAddr / widthInCtb;
1579
1580 cmd.DW3.SliceType = hevcSliceParams->slice_type;
1581 cmd.DW3.Lastsliceofpic = hevcSliceState->bLastSlice;
1582 cmd.DW3.DependentSliceFlag = hevcSliceParams->dependent_slice_segment_flag;
1583 cmd.DW3.SliceTemporalMvpEnableFlag = hevcSliceParams->slice_temporal_mvp_enable_flag;
1584 cmd.DW3.Sliceqp = hevcSliceParams->slice_qp_delta + hevcPicParams->QpY;
1585 cmd.DW3.SliceCbQpOffset = hevcSliceParams->slice_cb_qp_offset;
1586 cmd.DW3.SliceCrQpOffset = hevcSliceParams->slice_cr_qp_offset;
1587
1588 cmd.DW4.SliceHeaderDisableDeblockingFilterFlag = hevcSliceParams->slice_deblocking_filter_disable_flag;
1589 cmd.DW4.SliceTcOffsetDiv2OrFinalTcOffsetDiv2Encoder = hevcSliceParams->tc_offset_div2;
1590 cmd.DW4.SliceBetaOffsetDiv2OrFinalBetaOffsetDiv2Encoder = hevcSliceParams->beta_offset_div2;
1591 cmd.DW4.SliceLoopFilterAcrossSlicesEnabledFlag = 0;
1592 cmd.DW4.SliceSaoChromaFlag = 0;
1593 cmd.DW4.SliceSaoLumaFlag = 0;
1594 cmd.DW4.MvdL1ZeroFlag = 0;
1595 cmd.DW4.Islowdelay = hevcSliceState->bIsLowDelay;
1596 cmd.DW4.CollocatedFromL0Flag = hevcSliceParams->collocated_from_l0_flag;
1597 cmd.DW4.Chromalog2Weightdenom = hevcSliceParams->luma_log2_weight_denom + hevcSliceParams->delta_chroma_log2_weight_denom;
1598 cmd.DW4.LumaLog2WeightDenom = hevcSliceParams->luma_log2_weight_denom;
1599 cmd.DW4.CabacInitFlag = hevcSliceParams->cabac_init_flag;
1600 cmd.DW4.Maxmergeidx = hevcSliceParams->MaxNumMergeCand - 1;
1601
1602 if (cmd.DW3.SliceTemporalMvpEnableFlag)
1603 {
1604 if (cmd.DW3.SliceType == MhwVdboxHcpInterface::hevcSliceI)
1605 {
1606 cmd.DW4.Collocatedrefidx = 0;
1607 }
1608 else
1609 {
1610 // need to check with Ce for DDI issues
1611 uint8_t collocatedFromL0Flag = cmd.DW4.CollocatedFromL0Flag;
1612
1613 uint8_t collocatedRefIndex = hevcPicParams->CollocatedRefPicIndex;
1614 MHW_ASSERT(collocatedRefIndex < CODEC_MAX_NUM_REF_FRAME_HEVC);
1615
1616 uint8_t collocatedFrameIdx = hevcSliceState->pRefIdxMapping[collocatedRefIndex];
1617 MHW_ASSERT(collocatedRefIndex < CODEC_MAX_NUM_REF_FRAME_HEVC);
1618
1619 cmd.DW4.Collocatedrefidx = collocatedFrameIdx;
1620 }
1621 }
1622 else
1623 {
1624 cmd.DW4.Collocatedrefidx = 0;
1625 }
1626
1627 cmd.DW5.Sliceheaderlength = 0;
1628
1629 if(!hevcPicParams->bUsedAsRef && hevcPicParams->CodingType != I_TYPE)
1630 {
1631 // non reference B frame
1632 cmd.DW6.Roundinter = 0;
1633 cmd.DW6.Roundintra = 8;
1634 }
1635 else
1636 {
1637 //Other frames
1638 cmd.DW6.Roundinter = 5;
1639 cmd.DW6.Roundintra = 11;
1640 }
1641
1642 cmd.DW7.Cabaczerowordinsertionenable = 1;
1643 cmd.DW7.Emulationbytesliceinsertenable = 1;
1644 cmd.DW7.HeaderInsertionEnable = 1;
1645 cmd.DW7.TailInsertionEnable =
1646 (hevcPicParams->bLastPicInSeq || hevcPicParams->bLastPicInStream) && hevcSliceState->bLastSlice;
1647 cmd.DW7.SlicedataEnable = 1;
1648
1649 cmd.DW8.IndirectPakBseDataStartOffsetWrite = hevcSliceState->dwHeaderBytesInserted;
1650
1651 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, hevcSliceState->pBatchBufferForPakSlices, &cmd, cmd.byteSize));
1652
1653 return eStatus;
1654 }
1655
1656 MOS_STATUS AddHcpPakInsertObject(
1657 PMOS_COMMAND_BUFFER cmdBuffer,
1658 PMHW_VDBOX_PAK_INSERT_PARAMS params)
1659 {
1660 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1661
1662 MHW_FUNCTION_ENTER;
1663
1664 MHW_MI_CHK_NULL(params);
1665
1666 if (cmdBuffer == nullptr && params->pBatchBufferForPakSlices == nullptr)
1667 {
1668 MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
1669 }
1670
1671 typename THcpCmds::HCP_PAK_INSERT_OBJECT_CMD cmd;
1672 uint32_t dwordsUsed = cmd.dwSize;
1673
1674 if (params->bLastPicInSeq && params->bLastPicInStream)
1675 {
1676 uint32_t dwPadding[3];
1677
1678 dwordsUsed += sizeof(dwPadding) / sizeof(dwPadding[0]);
1679
1680 cmd.DW0.DwordLength = OP_LENGTH(dwordsUsed);
1681 cmd.DW1.Headerlengthexcludefrmsize = 0;
1682 cmd.DW1.EndofsliceflagLastdstdatainsertcommandflag = 1;
1683 cmd.DW1.LastheaderflagLastsrcheaderdatainsertcommandflag = 1;
1684 cmd.DW1.EmulationflagEmulationbytebitsinsertenable = 0;
1685 cmd.DW1.SkipemulbytecntSkipEmulationByteCount = 0;
1686 cmd.DW1.DatabitsinlastdwSrcdataendingbitinclusion50 = 16;
1687 cmd.DW1.DatabyteoffsetSrcdatastartingbyteoffset10 = 0;
1688 cmd.DW1.IndirectPayloadEnable = 0;
1689
1690 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, params->pBatchBufferForPakSlices, &cmd, cmd.byteSize));
1691
1692 dwPadding[0] = (uint32_t)((1 << 16) | ((HEVC_NAL_UT_EOS << 1) << 24));
1693 dwPadding[1] = (1L | (1L << 24));
1694 dwPadding[2] = (HEVC_NAL_UT_EOB << 1) | (1L << 8);
1695 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, params->pBatchBufferForPakSlices, &dwPadding[0], sizeof(dwPadding)));
1696 }
1697 else if (params->bLastPicInSeq || params->bLastPicInStream)
1698 {
1699 uint32_t dwLastPicInSeqData[2], dwLastPicInStreamData[2];
1700
1701 dwordsUsed += params->bLastPicInSeq * 2 + params->bLastPicInStream * 2;
1702
1703 cmd.DW0.DwordLength = OP_LENGTH(dwordsUsed);
1704 cmd.DW1.Headerlengthexcludefrmsize = 0;
1705 cmd.DW1.EndofsliceflagLastdstdatainsertcommandflag = 1;
1706 cmd.DW1.LastheaderflagLastsrcheaderdatainsertcommandflag = 1;
1707 cmd.DW1.EmulationflagEmulationbytebitsinsertenable = 0;
1708 cmd.DW1.SkipemulbytecntSkipEmulationByteCount = 0;
1709 cmd.DW1.DatabitsinlastdwSrcdataendingbitinclusion50 = 8;
1710 cmd.DW1.DatabyteoffsetSrcdatastartingbyteoffset10 = 0;
1711 cmd.DW1.IndirectPayloadEnable = 0;
1712
1713 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, params->pBatchBufferForPakSlices, &cmd, cmd.byteSize));
1714
1715 if (params->bLastPicInSeq)
1716 {
1717 dwLastPicInSeqData[0] = (uint32_t)((1 << 16) | ((HEVC_NAL_UT_EOS << 1) << 24));
1718 dwLastPicInSeqData[1] = 1; // nuh_temporal_id_plus1
1719 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, params->pBatchBufferForPakSlices, &dwLastPicInSeqData[0], sizeof(dwLastPicInSeqData)));
1720 }
1721
1722 if (params->bLastPicInStream)
1723 {
1724 dwLastPicInStreamData[0] = (uint32_t)((1 << 16) | ((HEVC_NAL_UT_EOB << 1) << 24));
1725 dwLastPicInStreamData[1] = 1; // nuh_temporal_id_plus1
1726 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, params->pBatchBufferForPakSlices, &dwLastPicInStreamData[0], sizeof(dwLastPicInStreamData)));
1727 }
1728 }
1729 else
1730 {
1731 uint32_t byteSize = (params->dwBitSize + 7) >> 3;
1732 uint32_t dataBitsInLastDw = params->dwBitSize % 32;
1733 if (dataBitsInLastDw == 0)
1734 {
1735 dataBitsInLastDw = 32;
1736 }
1737
1738 dwordsUsed += (MOS_ALIGN_CEIL(byteSize, sizeof(uint32_t))) / sizeof(uint32_t);
1739 cmd.DW0.DwordLength = OP_LENGTH(dwordsUsed);
1740 cmd.DW1.Headerlengthexcludefrmsize = 0;
1741 cmd.DW1.EndofsliceflagLastdstdatainsertcommandflag = params->bEndOfSlice;
1742 cmd.DW1.LastheaderflagLastsrcheaderdatainsertcommandflag = params->bLastHeader;
1743 cmd.DW1.EmulationflagEmulationbytebitsinsertenable = params->bEmulationByteBitsInsert;
1744 cmd.DW1.SkipemulbytecntSkipEmulationByteCount = params->uiSkipEmulationCheckCount;
1745 cmd.DW1.DatabitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
1746 cmd.DW1.DatabyteoffsetSrcdatastartingbyteoffset10 = 0;
1747 cmd.DW1.IndirectPayloadEnable = 0;
1748
1749 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, params->pBatchBufferForPakSlices, &cmd, cmd.byteSize));
1750
1751 if (byteSize)
1752 {
1753 MHW_MI_CHK_NULL(params->pBsBuffer);
1754 MHW_MI_CHK_NULL(params->pBsBuffer->pBase);
1755 uint8_t *data = (uint8_t*)(params->pBsBuffer->pBase + params->dwOffset);
1756 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, params->pBatchBufferForPakSlices, data, byteSize));
1757 }
1758 }
1759
1760 return eStatus;
1761 }
1762
1763
1764 MOS_STATUS AddHcpHevcPicBrcBuffer(
1765 PMOS_RESOURCE hcpImgStates,
1766 PMHW_VDBOX_HEVC_PIC_STATE hevcPicState)
1767 {
1768 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1769
1770 MHW_FUNCTION_ENTER;
1771
1772 MHW_MI_CHK_NULL(hcpImgStates);
1773
1774 MOS_COMMAND_BUFFER constructedCmdBuf;
1775 typename THcpCmds::HCP_PIC_STATE_CMD cmd;
1776 uint32_t* insertion = nullptr;
1777 MOS_LOCK_PARAMS lockFlags;
1778 this->m_brcNumPakPasses = hevcPicState->brcNumPakPasses;
1779
1780 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
1781 lockFlags.WriteOnly = 1;
1782 uint8_t *data = (uint8_t*)this->m_osInterface->pfnLockResource(this->m_osInterface, hcpImgStates, &lockFlags);
1783 MHW_MI_CHK_NULL(data);
1784
1785 constructedCmdBuf.pCmdBase = (uint32_t *)data;
1786 constructedCmdBuf.pCmdPtr = (uint32_t *)data;
1787 constructedCmdBuf.iOffset = 0;
1788 constructedCmdBuf.iRemaining = BRC_IMG_STATE_SIZE_PER_PASS * (this->m_brcNumPakPasses);
1789
1790 MHW_MI_CHK_STATUS(this->AddHcpPicStateCmd(&constructedCmdBuf, hevcPicState));
1791
1792 cmd = *(typename THcpCmds::HCP_PIC_STATE_CMD *)data;
1793
1794 for (uint32_t i = 0; i < this->m_brcNumPakPasses; i++)
1795 {
1796 if (i == 0)
1797 {
1798 cmd.DW6.Nonfirstpassflag = false;
1799 }
1800 else
1801 {
1802 cmd.DW6.Nonfirstpassflag = true;
1803 }
1804
1805 cmd.DW6.FrameszoverstatusenFramebitratemaxreportmask = true;
1806 cmd.DW6.FrameszunderstatusenFramebitrateminreportmask = true;
1807 cmd.DW6.LcumaxbitstatusenLcumaxsizereportmask = false; // BRC update kernel does not consider if there is any LCU whose size is too big
1808
1809 *(typename THcpCmds::HCP_PIC_STATE_CMD *)data = cmd;
1810
1811 /* add batch buffer end insertion flag */
1812 insertion = (uint32_t*)(data + THcpCmds::HCP_PIC_STATE_CMD::byteSize);
1813 *insertion = 0x05000000;
1814
1815 data += BRC_IMG_STATE_SIZE_PER_PASS;
1816 }
1817
1818 MHW_MI_CHK_STATUS(this->m_osInterface->pfnUnlockResource(this->m_osInterface, hcpImgStates));
1819
1820 return eStatus;
1821 }
1822
1823 MOS_STATUS GetOsResLaceOrAceOrRgbHistogramBufferSize(
1824 uint32_t width,
1825 uint32_t height,
1826 uint32_t *size)
1827 {
1828 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1829
1830 *size = this->m_veboxRgbHistogramSize;
1831
1832 uint32_t sizeLace = MOS_ROUNDUP_DIVIDE(height, 64) *
1833 MOS_ROUNDUP_DIVIDE(width, 64) *
1834 this->m_veboxLaceHistogram256BinPerBlock;
1835
1836 uint32_t sizeNoLace = m_veboxAceHistogramSizePerFramePerSlice *
1837 this->m_veboxNumFramePreviousCurrent *
1838 this->m_veboxMaxSlices;
1839
1840 *size += MOS_MAX(sizeLace, sizeNoLace);
1841
1842 return eStatus;
1843 }
1844
1845 MOS_STATUS GetOsResStatisticsOutputBufferSize(
1846 uint32_t width,
1847 uint32_t height,
1848 uint32_t *size)
1849 {
1850 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1851
1852 width = MOS_ALIGN_CEIL(width, 64);
1853 height = MOS_ROUNDUP_DIVIDE(height, 4) + MOS_ROUNDUP_DIVIDE(this->m_veboxStatisticsSize * sizeof(uint32_t), width);
1854 *size = width * height;
1855
1856 return eStatus;
1857 }
1858
1859 public:
1860 inline uint32_t GetHcpHevcVp9RdoqStateCommandSize()
1861 {
1862 return THcpCmds::HEVC_VP9_RDOQ_STATE_CMD::byteSize;
1863 }
1864 };
1865
1866 #endif