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