/* * Copyright (c) 2021-2023, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file mhw_vdbox_hcp_impl.h //! \brief MHW VDBOX HCP interface common base //! \details //! #ifndef __MHW_VDBOX_HCP_IMPL_H__ #define __MHW_VDBOX_HCP_IMPL_H__ #include "mhw_vdbox_hcp_itf.h" #include "mhw_impl.h" #include "mhw_vdbox_hcp_def.h" #define MHW_HCP_WORST_CASE_LCU_CU_TU_INFO (26 * MHW_CACHELINE_SIZE) // 18+4+4 #define MHW_HCP_WORST_CASE_LCU_CU_TU_INFO_REXT (35 * MHW_CACHELINE_SIZE) // 27+4+4 #define MHW_HCP_WORST_CASE_CU_TU_INFO (4 * MHW_CACHELINE_SIZE) // 2+1+1 #define MHW_HCP_WORST_CASE_CU_TU_INFO_REXT (6 * MHW_CACHELINE_SIZE) // 4+1+1 namespace mhw { namespace vdbox { namespace hcp { static constexpr uint32_t WATCHDOG_COUNT_CTRL_OFFSET_INIT = 0x1C0178; static constexpr uint32_t WATCHDOG_COUNT_THRESTHOLD_OFFSET_INIT = 0x1C017C; static constexpr uint32_t HCP_DEBUG_FE_STREAM_OUT_SIZE_REG_OFFSET_INIT = 0x1C2828; static constexpr uint32_t HCP_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT = 0x1C28B8; static constexpr uint32_t HCP_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT = 0x1C28BC; static constexpr uint32_t HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT = 0x1C28A0; static constexpr uint32_t HCP_ENC_BIT_STREAM_SE_BIT_COUNT_FRAME_REG_OFFSET_INIT = 0x1C28A8; static constexpr uint32_t HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT = 0x1C28A4; static constexpr uint32_t HCP_ENC_QP_STATUS_COUNT_REG_OFFSET_INIT = 0x1C28C0; static constexpr uint32_t HCP_ENC_SLICE_COUNT_REG_OFFSET_INIT = 0x1C28C8; static constexpr uint32_t HCP_ENC_VDENC_MODE_TIMER_REG_OFFSET_INIT = 0x1C28DC; static constexpr uint32_t HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT = 0x1C28E0; static constexpr uint32_t HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT = 0x1C28E4; static constexpr uint32_t HCP_VP9_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT = 0x1C28F0; static constexpr uint32_t HCP_VP9_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT = 0x1C28F4; static constexpr uint32_t CS_ENGINE_ID_OFFSET_INIT = 0x1C008C; static constexpr uint32_t HCP_DEC_STATUS_REG_OFFSET_INIT = 0x1C2800; static constexpr uint32_t HCP_CABAC_STATUS_REG_OFFSET_INIT = 0x1C2804; static constexpr uint32_t HCP_FRAME_CRC_REG_OFFSET_INIT = 0x1C2920; static constexpr uint32_t HCP_COMMAND_COUNTER_REG_OFFSET_INIT = 0x1C2820; static constexpr uint32_t HCP_COMMAND_COUNTER_OVERRIDE_REG_OFFSET_INIT = 0x1C2824; static constexpr uint32_t MEMORY_ADDRESS_ATTRIBUTES_MOCS_CLEAN_MASK = 0xFFFFFF81; template class Impl : public Itf, public mhw::Impl { _HCP_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL); public: MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override { MHW_FUNCTION_ENTER; MHW_CHK_NULL_RETURN(settings); size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS); return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size); } MOS_STATUS GetHcpBufSize(const HcpBufferSizePar &par, uint32_t &size) override { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; uint8_t bitDepthMultFactor = 0; uint32_t mvtSize = 0; uint32_t mvtbSize = 0; uint32_t bufferSize = 0; uint32_t rowStoreSzLCU = 0; uint32_t colStoreSzLCU = 0; double dbFormatMultFactor = 0; uint8_t maxBitDepth = par.ucMaxBitDepth; uint32_t lcusize = 1 << par.dwCtbLog2SizeY; uint32_t maxFrameSize = par.dwMaxFrameSize; // HEVC decoder has WA here, change to lcusize when the WA is removed uint32_t widthInCtb = MOS_ROUNDUP_DIVIDE(par.dwPicWidth, 16); uint32_t heightInCtb = MOS_ROUNDUP_DIVIDE(par.dwPicHeight, 16); uint32_t numBaseUnitsInLCU = 1 << (par.dwCtbLog2SizeY - 2); //size in number of 4x4 in the LCU per column HCP_CHROMA_FORMAT_IDC chromaFormat = (HCP_CHROMA_FORMAT_IDC)par.ucChromaFormat; switch (par.bufferType) { case HCP_INTERNAL_BUFFER_TYPE::DBLK_LINE: dbFormatMultFactor = (chromaFormat == HCP_CHROMA_FORMAT_YUV444) ? 1.5 : 1; bitDepthMultFactor = (maxBitDepth > 8) ? 2 : 1; rowStoreSzLCU = (uint32_t)(((2 * numBaseUnitsInLCU * dbFormatMultFactor * 128 * bitDepthMultFactor) + 511) / 512); bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb; break; case HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_LINE: dbFormatMultFactor = (chromaFormat == HCP_CHROMA_FORMAT_YUV444) ? 1.5 : 1; bitDepthMultFactor = (maxBitDepth > 8) ? 2 : 1; rowStoreSzLCU = (uint32_t)(((2 * numBaseUnitsInLCU * dbFormatMultFactor * 128 * bitDepthMultFactor) + 511) / 512); bufferSize = 2 * rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb; break; case HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_COL: dbFormatMultFactor = (chromaFormat == HCP_CHROMA_FORMAT_YUV420) ? 1 : 1.5; bitDepthMultFactor = (maxBitDepth > 8) ? 2 : 1; colStoreSzLCU = (uint32_t)(((2 * numBaseUnitsInLCU * dbFormatMultFactor * 128 * bitDepthMultFactor + 3 * 128 * bitDepthMultFactor) + 511) / 512); bufferSize = 2 * colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb; break; case HCP_INTERNAL_BUFFER_TYPE::MV_UP_RT_COL: colStoreSzLCU = 1; bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb; break; case HCP_INTERNAL_BUFFER_TYPE::META_LINE: rowStoreSzLCU = (par.dwCtbLog2SizeY == 6) ? 2 : 1; bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb; break; case HCP_INTERNAL_BUFFER_TYPE::META_TILE_LINE: rowStoreSzLCU = (par.dwCtbLog2SizeY == 6) ? 4 : 2; bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb; break; case HCP_INTERNAL_BUFFER_TYPE::META_TILE_COL: colStoreSzLCU = (par.dwCtbLog2SizeY == 6) ? 4 : 2; bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb; break; case HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_UP_RIGHT_COL: { uint32_t colStoreSizeLCU[2][3]; //[bitdepth 8/10 or 12][LCU 16/32/64] if (chromaFormat == HCP_CHROMA_FORMAT_YUV420) { colStoreSizeLCU[0][0] = 1; colStoreSizeLCU[0][1] = 1; colStoreSizeLCU[0][2] = 1; colStoreSizeLCU[1][0] = 1; colStoreSizeLCU[1][1] = 2; colStoreSizeLCU[1][2] = 2; } else if (chromaFormat == HCP_CHROMA_FORMAT_YUV422) { colStoreSizeLCU[0][0] = 1; colStoreSizeLCU[0][1] = 1; colStoreSizeLCU[0][2] = 1; colStoreSizeLCU[1][0] = 1; colStoreSizeLCU[1][1] = 2; colStoreSizeLCU[1][2] = 2; } else { colStoreSizeLCU[0][0] = 1; colStoreSizeLCU[0][1] = 2; colStoreSizeLCU[0][2] = 2; colStoreSizeLCU[1][0] = 2; colStoreSizeLCU[1][1] = 3; colStoreSizeLCU[1][2] = 3; } colStoreSzLCU = colStoreSizeLCU[(maxBitDepth == 8) ? 0 : 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0]; bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb; break; } case HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_LFT_RECON_COL: { uint32_t colStoreSizeLCU[2][3]; //[bitdepth 8/10 or 12][LCU 16/32/64] if (chromaFormat == HCP_CHROMA_FORMAT_YUV420) { colStoreSizeLCU[0][0] = 1; colStoreSizeLCU[0][1] = 2; colStoreSizeLCU[0][2] = 2; colStoreSizeLCU[1][0] = 1; colStoreSizeLCU[1][1] = 2; colStoreSizeLCU[1][2] = 4; } else if (chromaFormat == HCP_CHROMA_FORMAT_YUV422) { colStoreSizeLCU[0][0] = 1; colStoreSizeLCU[0][1] = 2; colStoreSizeLCU[0][2] = 3; colStoreSizeLCU[1][0] = 2; colStoreSizeLCU[1][1] = 3; colStoreSizeLCU[1][2] = 6; } else { colStoreSizeLCU[0][0] = 1; colStoreSizeLCU[0][1] = 2; colStoreSizeLCU[0][2] = 3; colStoreSizeLCU[1][0] = 2; colStoreSizeLCU[1][1] = 3; colStoreSizeLCU[1][2] = 6; } colStoreSzLCU = colStoreSizeLCU[(maxBitDepth == 8) ? 0 : 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0]; bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb; break; } case HCP_INTERNAL_BUFFER_TYPE::SAO_LINE: { uint32_t uiRowStoreSizeLCU[2][3]; //[bitdepth 8 or10/12][LCU 16/32/64] if (chromaFormat == HCP_CHROMA_FORMAT_YUV420 || chromaFormat == HCP_CHROMA_FORMAT_YUV422) { uiRowStoreSizeLCU[0][0] = 2; uiRowStoreSizeLCU[0][1] = 3; uiRowStoreSizeLCU[0][2] = 5; uiRowStoreSizeLCU[1][0] = 2; uiRowStoreSizeLCU[1][1] = 4; uiRowStoreSizeLCU[1][2] = 6; } else { uiRowStoreSizeLCU[0][0] = 3; uiRowStoreSizeLCU[0][1] = 4; uiRowStoreSizeLCU[0][2] = 7; uiRowStoreSizeLCU[1][0] = 3; uiRowStoreSizeLCU[1][1] = 5; uiRowStoreSizeLCU[1][2] = 8; } rowStoreSzLCU = uiRowStoreSizeLCU[(maxBitDepth < 12) ? 0 : 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0]; bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb; break; } case HCP_INTERNAL_BUFFER_TYPE::SAO_TILE_LINE: { uint32_t uiRowStoreSizeLCU[2][3]; //[bitdepth 8 or 10/12][LCU 16/32/64] if (chromaFormat == HCP_CHROMA_FORMAT_YUV420 || chromaFormat == HCP_CHROMA_FORMAT_YUV422) { uiRowStoreSizeLCU[0][0] = 4; uiRowStoreSizeLCU[0][1] = 6; uiRowStoreSizeLCU[0][2] = 10; uiRowStoreSizeLCU[1][0] = 4; uiRowStoreSizeLCU[1][1] = 8; uiRowStoreSizeLCU[1][2] = 12; } else { uiRowStoreSizeLCU[0][0] = 6; uiRowStoreSizeLCU[0][1] = 8; uiRowStoreSizeLCU[0][2] = 14; uiRowStoreSizeLCU[1][0] = 6; uiRowStoreSizeLCU[1][1] = 10; uiRowStoreSizeLCU[1][2] = 16; } rowStoreSzLCU = uiRowStoreSizeLCU[(maxBitDepth < 12) ? 0 : 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0]; bufferSize = rowStoreSzLCU * MHW_CACHELINE_SIZE * widthInCtb; break; } case HCP_INTERNAL_BUFFER_TYPE::SAO_TILE_COL: { // [chroma_format_idc][lcu_size] = [420/422/444][lcu16/lcu32/lcu64] uint32_t formatMultFactorTab[3][3] = {{8, 10, 18}, {10, 14, 24}, {10, 14, 24}}; uint32_t formatMultFactor; if (chromaFormat == HCP_CHROMA_FORMAT_MONOCHROME) { eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_ASSERTMESSAGE("invalid input chroma format.\n"); return eStatus; } formatMultFactor = formatMultFactorTab[chromaFormat - 1][par.dwCtbLog2SizeY > 3 ? par.dwCtbLog2SizeY - 4 : 0]; colStoreSzLCU = formatMultFactor; bufferSize = colStoreSzLCU * MHW_CACHELINE_SIZE * heightInCtb; break; } case HCP_INTERNAL_BUFFER_TYPE::HSAO_RS: { uint32_t maxTileColumn = MOS_ROUNDUP_DIVIDE(par.dwPicWidth, 128); bufferSize = MOS_ALIGN_CEIL(widthInCtb + 3 * maxTileColumn, 4) * 16; break; } //Add HSSE here case HCP_INTERNAL_BUFFER_TYPE::CURR_MV_TEMPORAL: mvtSize = ((((par.dwPicWidth + 63) >> 6) * (((par.dwPicHeight + 15) >> 4)) + 1) & (-2)); mvtbSize = ((((par.dwPicWidth + 31) >> 5) * (((par.dwPicHeight + 31) >> 5)) + 1) & (-2)); bufferSize = MOS_MAX(mvtSize, mvtbSize) * MHW_CACHELINE_SIZE; break; case HCP_INTERNAL_BUFFER_TYPE::CABAC_STREAMOUT: //From sas, cabac stream out buffer size = //(#LCU) in picture * (Worst case LCU_CU_TU_info) + 1 byte aligned per LCU + Bitstream Size * 3 if ((chromaFormat == HCP_CHROMA_FORMAT_YUV420) && (maxBitDepth == 8)) { bufferSize = widthInCtb * heightInCtb * MHW_HCP_WORST_CASE_CU_TU_INFO + widthInCtb * heightInCtb + maxFrameSize * 3; } else { bufferSize = widthInCtb * heightInCtb * MHW_HCP_WORST_CASE_CU_TU_INFO_REXT + widthInCtb * heightInCtb + maxFrameSize * 3; } bufferSize = MOS_ALIGN_CEIL(bufferSize, MHW_CACHELINE_SIZE); break; default: eStatus = MOS_STATUS_INVALID_PARAMETER; break; } size = bufferSize; return eStatus; } MOS_STATUS GetVP9BufSize(const HcpBufferSizePar &par, uint32_t &size) override { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; uint32_t bufferSize = 0; uint32_t dblkRsbSizeMultiplier = 0; uint32_t dblkCsbSizeMultiplier = 0; uint32_t intraPredMultiplier = 0; uint8_t maxBitDepth = par.ucMaxBitDepth; uint32_t widthInSb = par.dwPicWidth; uint32_t heightInSb = par.dwPicHeight; uint32_t widthInMinCb = widthInSb * 64 / 8; //using smallest cb to get max width uint32_t heightInMinCb = heightInSb * 64 / 8; HCP_CHROMA_FORMAT_IDC chromaFormat = (HCP_CHROMA_FORMAT_IDC)par.ucChromaFormat; uint32_t maxFrameSize = par.dwMaxFrameSize; if (chromaFormat == HCP_CHROMA_FORMAT_YUV420) { dblkRsbSizeMultiplier = (maxBitDepth > 8) ? 36 : 18; dblkCsbSizeMultiplier = (maxBitDepth > 8) ? 34 : 17; intraPredMultiplier = (maxBitDepth > 8) ? 4 : 2; } else if (chromaFormat == HCP_CHROMA_FORMAT_YUV444) { dblkRsbSizeMultiplier = (maxBitDepth > 8) ? 54 : 27; dblkCsbSizeMultiplier = (maxBitDepth > 8) ? 50 : 25; intraPredMultiplier = (maxBitDepth > 8) ? 6 : 3; } else { eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_ASSERTMESSAGE("Format not supported."); return eStatus; } switch (par.bufferType) { case HCP_INTERNAL_BUFFER_TYPE::DBLK_LINE: case HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_LINE: bufferSize = widthInSb * dblkRsbSizeMultiplier * MHW_CACHELINE_SIZE; break; case HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_COL: bufferSize = heightInSb * dblkCsbSizeMultiplier * MHW_CACHELINE_SIZE; break; case HCP_INTERNAL_BUFFER_TYPE::META_LINE: case HCP_INTERNAL_BUFFER_TYPE::META_TILE_LINE: bufferSize = widthInSb * 5 * MHW_CACHELINE_SIZE; break; case HCP_INTERNAL_BUFFER_TYPE::META_TILE_COL: bufferSize = heightInSb * 5 * MHW_CACHELINE_SIZE; break; case HCP_INTERNAL_BUFFER_TYPE::CURR_MV_TEMPORAL: case HCP_INTERNAL_BUFFER_TYPE::COLL_MV_TEMPORAL: bufferSize = widthInSb * heightInSb * 9 * MHW_CACHELINE_SIZE; break; case HCP_INTERNAL_BUFFER_TYPE::SEGMENT_ID: bufferSize = widthInSb * heightInSb * MHW_CACHELINE_SIZE; break; case HCP_INTERNAL_BUFFER_TYPE::HVD_LINE: case HCP_INTERNAL_BUFFER_TYPE::HVD_TILE: bufferSize = widthInSb * MHW_CACHELINE_SIZE; break; // scalable mode specific buffers case HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_UP_RIGHT_COL: case HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_LFT_RECON_COL: bufferSize = intraPredMultiplier * heightInSb * MHW_CACHELINE_SIZE; break; case HCP_INTERNAL_BUFFER_TYPE::CABAC_STREAMOUT: // From sas, cabac stream out buffer size = // (#LCU) in picture * (Worst case LCU_CU_TU_info) + 1 byte aligned per LCU + Bitstream Size * 3 if ((chromaFormat == HCP_CHROMA_FORMAT_YUV420) && (maxBitDepth == 8)) { bufferSize = widthInMinCb * heightInMinCb * MHW_HCP_WORST_CASE_CU_TU_INFO + widthInMinCb * heightInMinCb + maxFrameSize * 3; } else { bufferSize = widthInMinCb * heightInMinCb * MHW_HCP_WORST_CASE_CU_TU_INFO_REXT + widthInMinCb * heightInMinCb + maxFrameSize * 3; } bufferSize = MOS_ALIGN_CEIL(bufferSize, MHW_CACHELINE_SIZE); break; default: eStatus = MOS_STATUS_INVALID_PARAMETER; break; } size = bufferSize; return eStatus; } const HcpMmioRegisters *GetMmioRegisters(const MHW_VDBOX_NODE_IND index) const override { MHW_FUNCTION_ENTER; if (index < MHW_VDBOX_NODE_MAX) { return &m_mmioRegisters[index]; } else { MHW_ASSERT("index is out of range!"); return &m_mmioRegisters[MHW_VDBOX_NODE_1]; } } uint32_t GetEncCuRecordSize() override { return 8 * sizeof(uint32_t); } uint32_t GetHcpPakObjSize() override { return 8; } MOS_STATUS SetRowstoreCachingOffsets(const HcpVdboxRowStorePar &rowstoreParams) override { MHW_FUNCTION_ENTER; bool is8bit = rowstoreParams.ucBitDepthMinus8 == 0; bool is10bit = rowstoreParams.ucBitDepthMinus8 == 1 || rowstoreParams.ucBitDepthMinus8 == 2; bool is12bit = rowstoreParams.ucBitDepthMinus8 > 2; bool isLcu32or64 = rowstoreParams.ucLCUSize == 32 || rowstoreParams.ucLCUSize == 64; bool isGt2k = rowstoreParams.dwPicWidth > 2048; bool isGt4k = rowstoreParams.dwPicWidth > 4096; bool isGt8k = rowstoreParams.dwPicWidth > 8192; uint32_t index = 0; //HCP pipe for both HEVC decoder and HEVC encoder if (rowstoreParams.Mode == CODECHAL_DECODE_MODE_HEVCVLD || rowstoreParams.Mode == CODECHAL_ENCODE_MODE_HEVC) { constexpr bool RowStoreCacheEnableHEVC[16][5] = { { 1, 1, 1, 0, 1 }, { 1, 1, 1, 1, 1 }, { 1, 1, 0, 0, 0 }, { 1, 1, 0, 1, 0 }, { 1, 1, 1, 1, 1 }, { 1, 1, 0, 0, 1 }, { 1, 1, 1, 0, 0 }, { 1, 0, 1, 0, 1 }, { 1, 1, 1, 0, 0 }, { 1, 0, 1, 0, 1 }, { 1, 1, 1, 1, 1 }, { 1, 1, 0, 1, 1 }, { 1, 1, 1, 1, 1 }, { 1, 0, 1, 1, 1 }, { 1, 1, 1, 1, 1 }, { 1, 0, 1, 1, 1 } }; constexpr uint32_t RowStoreCacheAddrHEVC[16][5] = { { 0, 256, 1280, 0, 2048 }, { 0, 256, 1280, 1824, 1792 }, { 0, 512, 0, 0, 0 }, { 0, 256, 0, 2304, 0 }, { 0, 256, 1024, 0, 1792 }, { 0, 512, 0, 0, 2048 }, { 0, 256, 1792, 0, 0 }, { 0, 0, 512, 0, 2048 }, { 0, 256, 1792, 0, 0 }, { 0, 0, 256, 0, 1792 }, { 0, 256, 1024, 1568, 1536 }, { 0, 512, 0, 2112, 2048 }, { 0, 256, 1792, 2336, 2304 }, { 0, 0, 512, 1600, 1536 }, { 0, 128, 1664, 2336, 2304 }, { 0, 0, 256, 1600, 1536 } }; m_hevcDatRowStoreCache.enabled = false; m_hevcDatRowStoreCache.dwAddress = 0; m_hevcDfRowStoreCache.enabled = false; m_hevcDfRowStoreCache.dwAddress = 0; m_hevcSaoRowStoreCache.enabled = false; m_hevcSaoRowStoreCache.dwAddress = 0; m_hevcHSaoRowStoreCache.enabled = false; m_hevcHSaoRowStoreCache.dwAddress = 0; if (isGt8k) { return MOS_STATUS_SUCCESS; } if ((rowstoreParams.ucChromaFormat == HCP_CHROMA_FORMAT_YUV420) || (rowstoreParams.ucChromaFormat == HCP_CHROMA_FORMAT_YUV422)) { index = 2 * isGt4k + isLcu32or64; } else if (rowstoreParams.ucChromaFormat == HCP_CHROMA_FORMAT_YUV444) { uint32_t subidx = is12bit ? 2 : (is10bit ? 1 : 0); index = 4 + 6 * isLcu32or64 + 2 * subidx + isGt4k; } else { return MOS_STATUS_SUCCESS; } if (m_hevcDatRowStoreCache.supported) { m_hevcDatRowStoreCache.enabled = RowStoreCacheEnableHEVC[index][0]; m_hevcDatRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][0]; } if (m_hevcDfRowStoreCache.supported) { m_hevcDfRowStoreCache.enabled = RowStoreCacheEnableHEVC[index][1]; m_hevcDfRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][1]; } if (m_hevcSaoRowStoreCache.supported) { m_hevcSaoRowStoreCache.enabled = RowStoreCacheEnableHEVC[index][2]; m_hevcSaoRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][2]; } if (m_hevcHSaoRowStoreCache.supported) { m_hevcHSaoRowStoreCache.enabled = RowStoreCacheEnableHEVC[index][4]; m_hevcHSaoRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][4]; } } if (rowstoreParams.Mode == CODECHAL_DECODE_MODE_VP9VLD || rowstoreParams.Mode == CODECHAL_ENCODE_MODE_VP9) { constexpr bool RowStoreCacheEnableVP9[13][4] = { { 1, 1, 1, 1 }, { 0, 0, 1, 1 }, { 1, 0, 1, 1 }, { 1, 1, 0, 1 }, { 1, 1, 1, 1 }, { 0, 0, 1, 1 }, { 0, 0, 1, 0 }, { 1, 1, 0, 1 }, { 1, 1, 1, 1 }, { 1, 1, 0, 1 }, { 1, 1, 1, 1 }, { 1, 1, 0, 1 }, { 1, 1, 0, 1 } }; constexpr uint32_t RowStoreCacheAddrVP9[13][4] = { { 0, 64, 384, 1536, }, { 0, 0, 0, 2304, }, { 0, 0, 64, 2368, }, { 0, 128, 0, 768, }, { 0, 64, 384, 1536, }, { 0, 0, 0, 2304, }, { 0, 0, 0, 0, }, { 0, 128, 0, 768, }, { 0, 64, 384, 2112, }, { 0, 128, 0, 768, }, { 0, 32, 192, 1920, }, { 0, 128, 0, 768, }, { 0, 128, 0, 768, } }; m_vp9HvdRowStoreCache.enabled = false; m_vp9HvdRowStoreCache.dwAddress = 0; m_vp9DatRowStoreCache.enabled = false; m_vp9DatRowStoreCache.dwAddress = 0; m_vp9DfRowStoreCache.enabled = false; m_vp9DfRowStoreCache.dwAddress = 0; if (isGt8k) { return MOS_STATUS_SUCCESS; } if ((rowstoreParams.ucChromaFormat >= HCP_CHROMA_FORMAT_YUV420) && (rowstoreParams.ucChromaFormat <= HCP_CHROMA_FORMAT_YUV444)) { index = 4 * (rowstoreParams.ucChromaFormat - HCP_CHROMA_FORMAT_YUV420) + 2 * (!is8bit) + isGt4k; } else { return MOS_STATUS_SUCCESS; } if (rowstoreParams.ucChromaFormat == HCP_CHROMA_FORMAT_YUV444 && !is8bit) { index += isGt2k; } if (m_vp9HvdRowStoreCache.supported) { m_vp9HvdRowStoreCache.enabled = RowStoreCacheEnableVP9[index][0]; m_vp9HvdRowStoreCache.dwAddress = RowStoreCacheAddrVP9[index][0]; } if (m_vp9DatRowStoreCache.supported) { m_vp9DatRowStoreCache.enabled = RowStoreCacheEnableVP9[index][1]; m_vp9DatRowStoreCache.dwAddress = RowStoreCacheAddrVP9[index][1]; } if (m_vp9DfRowStoreCache.supported) { m_vp9DfRowStoreCache.enabled = RowStoreCacheEnableVP9[index][2]; m_vp9DfRowStoreCache.dwAddress = RowStoreCacheAddrVP9[index][2]; } } return MOS_STATUS_SUCCESS; } bool IsRowStoreCachingSupported() override { return m_rowstoreCachingSupported; } uint32_t GetPakHWTileSizeRecordSize() override { return m_pakHWTileSizeRecordSize; } MOS_STATUS GetHcpStateCommandSize( uint32_t mode, uint32_t *commandsSize, uint32_t *patchListSize, PMHW_VDBOX_STATE_CMDSIZE_PARAMS params) override { // Just return success here, please implement logic in platform sepecific impl class. return MOS_STATUS_SUCCESS; } MOS_STATUS GetHcpPrimitiveCommandSize( uint32_t mode, uint32_t *commandsSize, uint32_t *patchListSize, bool modeSpecific) override { // Just return success here, please implement logic in platform sepecific impl class. return MOS_STATUS_SUCCESS; } private: bool m_rowstoreCachingSupported = false; uint32_t m_pakHWTileSizeRecordSize = sizeof(HCPPakHWTileSizeRecord); virtual MOS_STATUS InitRowstoreUserFeatureSettings() { MHW_FUNCTION_ENTER; bool rowstoreCachingDisableDefaultValue = false; if (m_osItf->bSimIsActive) { // Disable RowStore Cache on simulation by default rowstoreCachingDisableDefaultValue = true; } else { rowstoreCachingDisableDefaultValue = false; } m_rowstoreCachingSupported = !rowstoreCachingDisableDefaultValue; #if (_DEBUG || _RELEASE_INTERNAL) auto userSettingPtr = m_osItf->pfnGetUserSettingInstance(m_osItf); { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "Disable RowStore Cache", MediaUserSetting::Group::Device, rowstoreCachingDisableDefaultValue, true); m_rowstoreCachingSupported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL if (m_rowstoreCachingSupported) { m_hevcDatRowStoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableHevcDatRowStoreCache", MediaUserSetting::Group::Device); m_hevcDatRowStoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL m_hevcDfRowStoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableHevcDfRowStoreCache", MediaUserSetting::Group::Device); m_hevcDfRowStoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL m_hevcSaoRowStoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableHevcSaoRowStoreCache", MediaUserSetting::Group::Device); m_hevcSaoRowStoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL m_hevcHSaoRowStoreCache.supported = m_hevcSaoRowStoreCache.supported; m_vp9HvdRowStoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableVp9HvdRowStoreCache", MediaUserSetting::Group::Device); m_vp9HvdRowStoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL m_vp9DatRowStoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableVp9DatRowStoreCache", MediaUserSetting::Group::Device); m_vp9DatRowStoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL m_vp9DfRowStoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableVp9DfRowStoreCache", MediaUserSetting::Group::Device); m_vp9DfRowStoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL } return MOS_STATUS_SUCCESS; } void InitMmioRegisters() { MHW_FUNCTION_ENTER; HcpMmioRegisters *mmioRegisters = &m_mmioRegisters[MHW_VDBOX_NODE_1]; mmioRegisters->watchdogCountCtrlOffset = WATCHDOG_COUNT_CTRL_OFFSET_INIT; mmioRegisters->watchdogCountThresholdOffset = WATCHDOG_COUNT_THRESTHOLD_OFFSET_INIT; mmioRegisters->hcpDebugFEStreamOutSizeRegOffset = HCP_DEBUG_FE_STREAM_OUT_SIZE_REG_OFFSET_INIT; mmioRegisters->hcpEncImageStatusMaskRegOffset = HCP_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT; mmioRegisters->hcpEncImageStatusCtrlRegOffset = HCP_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT; mmioRegisters->hcpEncBitstreamBytecountFrameRegOffset = HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT; mmioRegisters->hcpEncBitstreamSeBitcountFrameRegOffset = HCP_ENC_BIT_STREAM_SE_BIT_COUNT_FRAME_REG_OFFSET_INIT; mmioRegisters->hcpEncBitstreamBytecountFrameNoHeaderRegOffset = HCP_ENC_BIT_STREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT; mmioRegisters->hcpEncQpStatusCountRegOffset = HCP_ENC_QP_STATUS_COUNT_REG_OFFSET_INIT; mmioRegisters->hcpEncSliceCountRegOffset = HCP_ENC_SLICE_COUNT_REG_OFFSET_INIT; mmioRegisters->hcpEncVdencModeTimerRegOffset = HCP_ENC_VDENC_MODE_TIMER_REG_OFFSET_INIT; mmioRegisters->hcpVp9EncBitstreamBytecountFrameRegOffset = HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_REG_OFFSET_INIT; mmioRegisters->hcpVp9EncBitstreamBytecountFrameNoHeaderRegOffset = HCP_VP9_ENC_BITSTREAM_BYTE_COUNT_FRAME_NO_HEADER_REG_OFFSET_INIT; mmioRegisters->hcpVp9EncImageStatusMaskRegOffset = HCP_VP9_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT; mmioRegisters->hcpVp9EncImageStatusCtrlRegOffset = HCP_VP9_ENC_IMAGE_STATUS_CTRL_REG_OFFSET_INIT; mmioRegisters->csEngineIdOffset = CS_ENGINE_ID_OFFSET_INIT; mmioRegisters->hcpDecStatusRegOffset = HCP_DEC_STATUS_REG_OFFSET_INIT; mmioRegisters->hcpCabacStatusRegOffset = HCP_CABAC_STATUS_REG_OFFSET_INIT; mmioRegisters->hcpFrameCrcRegOffset = HCP_FRAME_CRC_REG_OFFSET_INIT; m_mmioRegisters[MHW_VDBOX_NODE_2] = m_mmioRegisters[MHW_VDBOX_NODE_1]; } protected: using base_t = Itf; HcpMmioRegisters m_mmioRegisters[MHW_VDBOX_NODE_MAX] = {}; //!< hcp mmio registers vdbox::RowStoreCache m_hevcDatRowStoreCache = {}; vdbox::RowStoreCache m_hevcDfRowStoreCache = {}; vdbox::RowStoreCache m_hevcSaoRowStoreCache = {}; vdbox::RowStoreCache m_hevcHSaoRowStoreCache = {}; vdbox::RowStoreCache m_vp9HvdRowStoreCache = {}; vdbox::RowStoreCache m_vp9DfRowStoreCache = {}; vdbox::RowStoreCache m_vp9DatRowStoreCache = {}; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {}; Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf) { MHW_FUNCTION_ENTER; InitRowstoreUserFeatureSettings(); InitMmioRegisters(); } virtual ~Impl() { MHW_FUNCTION_ENTER; #if (_DEBUG || _RELEASE_INTERNAL) if (m_hevcDatRowStoreCache.enabled || m_hevcDfRowStoreCache.enabled || m_hevcSaoRowStoreCache.enabled || m_hevcHSaoRowStoreCache.enabled || m_vp9HvdRowStoreCache.enabled || m_vp9DatRowStoreCache.enabled || m_vp9DfRowStoreCache.enabled) { // Report rowstore cache usage status to regkey ReportUserSettingForDebug( m_userSettingPtr, __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED, 1, MediaUserSetting::Group::Device); } #endif } _MHW_SETCMD_OVERRIDE_DECL(HCP_SURFACE_STATE) { _MHW_SETCMD_CALLBASE(HCP_SURFACE_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, SurfaceId, params.surfaceStateId); \ DO_FIELD(DW1, SurfacePitchMinus1, params.surfacePitchMinus1); \ DO_FIELD(DW2, SurfaceFormat, static_cast(params.surfaceFormat)); \ DO_FIELD(DW2, YOffsetForUCbInPixel, params.yOffsetForUCbInPixel); \ DO_FIELD(DW3, YOffsetForVCr, params.yOffsetForVCr); \ DO_FIELD(DW3, DefaultAlphaValue, params.defaultAlphaValue); \ DO_FIELD(DW4, MemoryCompressionEnable, params.refsMmcEnable & (~params.mmcSkipMask)); \ DO_FIELD(DW4, CompressionType, params.refsMmcType); \ DO_FIELD(DW4, CompressionFormat, params.dwCompressionFormat); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HCP_PIC_STATE) { _MHW_SETCMD_CALLBASE(HCP_PIC_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, Framewidthinmincbminus1, params.framewidthinmincbminus1); \ DO_FIELD(DW1, PakTransformSkipEnable, (params.bDecodeInUse ? false : params.transformSkipEnabled)); \ DO_FIELD(DW1, Frameheightinmincbminus1, params.frameheightinmincbminus1); \ DO_FIELD(DW2, Mincusize, params.mincusize); \ DO_FIELD(DW2, CtbsizeLcusize, params.ctbsizeLcusize); \ DO_FIELD(DW2, Maxtusize, params.maxtusize); \ DO_FIELD(DW2, Mintusize, params.mintusize); \ DO_FIELD(DW2, ChromaSubsampling, params.chromaSubsampling); \ DO_FIELD(DW2, Minpcmsize, params.minpcmsize); \ DO_FIELD(DW2, Maxpcmsize, params.maxpcmsize); \ DO_FIELD(DW3, Colpicisi, 0); \ DO_FIELD(DW3, Curpicisi, 0); \ DO_FIELD(DW3, Log2Maxtransformskipsize, params.log2Maxtransformskipsize); \ DO_FIELD(DW4, SampleAdaptiveOffsetEnabledFlag, params.sampleAdaptiveOffsetEnabled); \ DO_FIELD(DW4, PcmEnabledFlag, params.pcmEnabledFlag); \ DO_FIELD(DW4, CuQpDeltaEnabledFlag, params.cuQpDeltaEnabledFlag); \ DO_FIELD(DW4, DiffCuQpDeltaDepthOrNamedAsMaxDqpDepth, params.diffCuQpDeltaDepth); \ DO_FIELD(DW4, PcmLoopFilterDisableFlag, params.pcmLoopFilterDisableFlag); \ DO_FIELD(DW4, ConstrainedIntraPredFlag, params.constrainedIntraPredFlag); \ DO_FIELD(DW4, Log2ParallelMergeLevelMinus2, params.log2ParallelMergeLevelMinus2); \ DO_FIELD(DW4, SignDataHidingFlag, params.signDataHidingFlag); \ DO_FIELD(DW4, EntropyCodingSyncEnabledFlag, params.entropyCodingSyncEnabled); \ DO_FIELD(DW4, WeightedPredFlag, params.weightedPredFlag); \ DO_FIELD(DW4, WeightedBipredFlag, params.weightedBipredFlag); \ DO_FIELD(DW4, Fieldpic, params.fieldpic); \ DO_FIELD(DW4, Bottomfield, params.bottomfield); \ DO_FIELD(DW4, AmpEnabledFlag, params.ampEnabledFlag); \ DO_FIELD(DW4, TransquantBypassEnableFlag, params.transquantBypassEnableFlag); \ DO_FIELD(DW4, StrongIntraSmoothingEnableFlag, params.strongIntraSmoothingEnableFlag); \ DO_FIELD(DW4, CuPacketStructure, 0); \ DO_FIELD(DW4, TransformSkipEnabledFlag, params.transformSkipEnabled); \ DO_FIELD(DW4, TilesEnabledFlag, params.tilesEnabledFlag); \ DO_FIELD(DW4, LoopFilterAcrossTilesEnabledFlag, params.loopFilterAcrossTilesEnabled); \ DO_FIELD(DW5, PicCbQpOffset, params.picCbQpOffset); \ DO_FIELD(DW5, PicCrQpOffset, params.picCrQpOffset); \ DO_FIELD(DW5, MaxTransformHierarchyDepthIntraOrNamedAsTuMaxDepthIntra, params.maxTransformHierarchyDepthIntra); \ DO_FIELD(DW5, MaxTransformHierarchyDepthInterOrNamedAsTuMaxDepthInter, params.maxTransformHierarchyDepthInter); \ DO_FIELD(DW5, PcmSampleBitDepthChromaMinus1, params.pcmSampleBitDepthChromaMinus1); \ DO_FIELD(DW5, PcmSampleBitDepthLumaMinus1, params.pcmSampleBitDepthLumaMinus1); \ DO_FIELD(DW5, BitDepthChromaMinus8, params.bitDepthChromaMinus8); \ DO_FIELD(DW5, BitDepthLumaMinus8, params.bitDepthLumaMinus8); \ DO_FIELD(DW6, LcuMaxBitsizeAllowed, params.lcuMaxBitsizeAllowed); \ DO_FIELD(DW6, Nonfirstpassflag, params.bNotFirstPass); \ DO_FIELD(DW6, LcuMaxBitSizeAllowedMsb2its, params.lcuMaxBitSizeAllowedMsb2its); \ DO_FIELD(DW6, LcumaxbitstatusenLcumaxsizereportmask, 0); \ DO_FIELD(DW6, FrameszoverstatusenFramebitratemaxreportmask, 0); \ DO_FIELD(DW6, FrameszunderstatusenFramebitrateminreportmask, 0); \ DO_FIELD(DW6, LoadSlicePointerFlag, 0); \ DO_FIELD(DW18, Minframesize, params.minframesize); \ DO_FIELD(DW18, Minframesizeunits, params.minframesizeunits); \ DO_FIELD(DW19, RdoqEnable, params.rdoqEnable); \ DO_FIELD(DW19, SseEnable, params.sseEnable); \ DO_FIELD(DW19, RhodomainRateControlEnable, params.rhodomainRateControlEnable); \ DO_FIELD(DW19, Rhodomainframelevelqp, params.rhodomainframelevelqp); \ DO_FIELD(DW19, FractionalQpAdjustmentEnable, params.fractionalQpAdjustmentEnable); \ DO_FIELD(DW19, FirstSliceSegmentInPicFlag, params.bDecodeInUse ? 0 : 1); \ DO_FIELD(DW19, PakDynamicSliceModeEnable, params.pakDynamicSliceModeEnable); \ DO_FIELD(DW19, SlicePicParameterSetId, params.slicePicParameterSetId); \ DO_FIELD(DW19, Nalunittypeflag, params.nalunittypeflag); \ DO_FIELD(DW19, NoOutputOfPriorPicsFlag, params.noOutputOfPriorPicsFlag); \ DO_FIELD(DW19, PartialFrameUpdateMode, params.partialFrameUpdateMode); \ DO_FIELD(DW19, TemporalMvPredDisable, params.temporalMvPredDisable); \ DO_FIELD(DW20, Intratucountbasedrdoqdisable, params.intratucountbasedrdoqdisable); \ DO_FIELD(DW21, SliceSizeThresholdInBytes, params.sliceSizeThresholdInBytes); \ DO_FIELD(DW22, TargetSliceSizeInBytes, params.targetSliceSizeInBytes); \ DO_FIELD(DW34, IntraBoundaryFilteringDisabledFlag, params.intraBoundaryFilteringDisabledFlag); \ DO_FIELD(DW34, MotionVectorResolutionControlIdc, params.motionVectorResolutionControlIdc); \ DO_FIELD(DW34, PpsCurrPicRefEnabledFlag, params.ppsCurrPicRefEnabledFlag); \ DO_FIELD(DW34, IbcMotionCompensationBufferReferenceIdc, params.ibcMotionCompensationBufferReferenceIdc); \ DO_FIELD(DW35, IbcConfiguration, params.ibcConfiguration); \ DO_FIELD(DW35, PaletteModeEnabledFlag, params.paletteModeEnabledFlag); \ DO_FIELD(DW35, MonochromePaletteFlag, 0); \ DO_FIELD(DW35, PaletteMaxSize, params.paletteMaxSize); \ DO_FIELD(DW35, DeltaPaletteMaxPredictorSize, params.deltaPaletteMaxPredictorSize); \ DO_FIELD(DW35, LumaBitDepthEntryMinus8, params.lumaBitDepthEntryMinus8); \ DO_FIELD(DW35, ChromaBitDepthEntryMinus8, params.chromaBitDepthEntryMinus8); \ DO_FIELD(DW37, Rdoqintratuthreshold, params.rdoqintratuthreshold); \ \ if (params.bDecodeInUse && params.pHevcExtPicParams) \ { \ auto hevcExtPicParams = params.pHevcExtPicParams; \ DO_FIELD(DW2, ChromaQpOffsetListEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.chroma_qp_offset_list_enabled_flag); \ DO_FIELD(DW2, DiffCuChromaQpOffsetDepth, hevcExtPicParams->diff_cu_chroma_qp_offset_depth); \ DO_FIELD(DW2, ChromaQpOffsetListLenMinus1, hevcExtPicParams->chroma_qp_offset_list_len_minus1); \ DO_FIELD(DW2, Log2SaoOffsetScaleLuma, hevcExtPicParams->log2_sao_offset_scale_luma); \ DO_FIELD(DW2, Log2SaoOffsetScaleChroma, hevcExtPicParams->log2_sao_offset_scale_chroma); \ DO_FIELD(DW3, CrossComponentPredictionEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.cross_component_prediction_enabled_flag); \ DO_FIELD(DW3, CabacBypassAlignmentEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.cabac_bypass_alignment_enabled_flag); \ DO_FIELD(DW3, PersistentRiceAdaptationEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.persistent_rice_adaptation_enabled_flag); \ DO_FIELD(DW3, IntraSmoothingDisabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.intra_smoothing_disabled_flag); \ DO_FIELD(DW3, ExplicitRdpcmEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.explicit_rdpcm_enabled_flag); \ DO_FIELD(DW3, ImplicitRdpcmEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.implicit_rdpcm_enabled_flag); \ DO_FIELD(DW3, TransformSkipContextEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.transform_skip_context_enabled_flag); \ DO_FIELD(DW3, TransformSkipRotationEnabledFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.transform_skip_rotation_enabled_flag); \ DO_FIELD(DW3, HighPrecisionOffsetsEnableFlag, hevcExtPicParams->PicRangeExtensionFlags.fields.high_precision_offsets_enabled_flag); \ DO_FIELD(DW32, CbQpOffsetList0, hevcExtPicParams->cb_qp_offset_list[0]); \ DO_FIELD(DW32, CbQpOffsetList1, hevcExtPicParams->cb_qp_offset_list[1]); \ DO_FIELD(DW32, CbQpOffsetList2, hevcExtPicParams->cb_qp_offset_list[2]); \ DO_FIELD(DW32, CbQpOffsetList3, hevcExtPicParams->cb_qp_offset_list[3]); \ DO_FIELD(DW32, CbQpOffsetList4, hevcExtPicParams->cb_qp_offset_list[4]); \ DO_FIELD(DW32, CbQpOffsetList5, hevcExtPicParams->cb_qp_offset_list[5]); \ DO_FIELD(DW33, CrQpOffsetList0, hevcExtPicParams->cr_qp_offset_list[0]); \ DO_FIELD(DW33, CrQpOffsetList1, hevcExtPicParams->cr_qp_offset_list[1]); \ DO_FIELD(DW33, CrQpOffsetList2, hevcExtPicParams->cr_qp_offset_list[2]); \ DO_FIELD(DW33, CrQpOffsetList3, hevcExtPicParams->cr_qp_offset_list[3]); \ DO_FIELD(DW33, CrQpOffsetList4, hevcExtPicParams->cr_qp_offset_list[4]); \ DO_FIELD(DW33, CrQpOffsetList5, hevcExtPicParams->cr_qp_offset_list[5]); \ } \ \ if (params.bDecodeInUse && params.pHevcSccPicParams) \ { \ auto hevcSccPicParams = params.pHevcSccPicParams; \ DO_FIELD(DW34, PpsActCrQpOffsetPlus3, hevcSccPicParams->pps_act_cr_qp_offset_plus3); \ DO_FIELD(DW34, PpsActCbQpOffsetPlus5, hevcSccPicParams->pps_act_cb_qp_offset_plus5); \ DO_FIELD(DW34, PpsActYOffsetPlus5, hevcSccPicParams->pps_act_y_qp_offset_plus5); \ DO_FIELD(DW34, PpsSliceActQpOffsetsPresentFlag, hevcSccPicParams->PicSCCExtensionFlags.fields.pps_slice_act_qp_offsets_present_flag); \ DO_FIELD(DW34, ResidualAdaptiveColourTransformEnabledFlag, hevcSccPicParams->PicSCCExtensionFlags.fields.residual_adaptive_colour_transform_enabled_flag); \ DO_FIELD(DW34, DeblockingFilterOverrideEnabledFlag, params.deblockingFilterOverrideEnabled); \ DO_FIELD(DW34, PpsDeblockingFilterDisabledFlag, params.ppsDeblockingFilterDisabled); \ DO_FIELD(DW35, IbcMotionVectorErrorHandlingDisable, 0); \ } \ \ if (params.bDecodeInUse && params.requestCRC) \ { \ DO_FIELD(DW36, FrameCrcEnable, 1); \ DO_FIELD(DW36, FrameCrcType, 0); \ } #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HCP_SLICE_STATE) { _MHW_SETCMD_CALLBASE(HCP_SLICE_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, SlicestartctbxOrSliceStartLcuXEncoder, params.slicestartctbxOrSliceStartLcuXEncoder); \ DO_FIELD(DW1, SlicestartctbyOrSliceStartLcuYEncoder, params.slicestartctbyOrSliceStartLcuYEncoder); \ DO_FIELD(DW2, NextslicestartctbxOrNextSliceStartLcuXEncoder, params.nextslicestartctbxOrNextSliceStartLcuXEncoder); \ DO_FIELD(DW2, NextslicestartctbyOrNextSliceStartLcuYEncoder, params.nextslicestartctbyOrNextSliceStartLcuYEncoder); \ DO_FIELD(DW3, SliceType, params.sliceType); \ DO_FIELD(DW3, Lastsliceofpic, params.lastsliceofpic); \ DO_FIELD(DW3, SliceqpSignFlag, params.sliceqpSignFlag); \ DO_FIELD(DW3, DependentSliceFlag, params.dependentSliceFlag); \ DO_FIELD(DW3, SliceTemporalMvpEnableFlag, params.sliceTemporalMvpEnableFlag); \ DO_FIELD(DW3, Sliceqp, params.sliceqp); \ DO_FIELD(DW3, SliceCbQpOffset, params.sliceCbQpOffset); \ DO_FIELD(DW3, SliceCrQpOffset, params.sliceCrQpOffset); \ DO_FIELD(DW3, Intrareffetchdisable, params.intrareffetchdisable); \ DO_FIELD(DW3, Lastsliceoftile, params.lastSliceInTile); \ DO_FIELD(DW3, Lastsliceoftilecolumn, params.lastSliceInTileColumn); \ DO_FIELD(DW3, CuChromaQpOffsetEnabledFlag, params.cuChromaQpOffsetEnable); \ DO_FIELD(DW4, SliceHeaderDisableDeblockingFilterFlag, params.deblockingFilterDisable); \ DO_FIELD(DW4, SliceTcOffsetDiv2OrFinalTcOffsetDiv2Encoder, params.tcOffsetDiv2); \ DO_FIELD(DW4, SliceBetaOffsetDiv2OrFinalBetaOffsetDiv2Encoder, params.betaOffsetDiv2); \ DO_FIELD(DW4, SliceLoopFilterAcrossSlicesEnabledFlag, params.loopFilterAcrossSlicesEnabled); \ DO_FIELD(DW4, SliceSaoChromaFlag, params.saoChromaFlag); \ DO_FIELD(DW4, SliceSaoLumaFlag, params.saoLumaFlag); \ DO_FIELD(DW4, MvdL1ZeroFlag, params.mvdL1ZeroFlag); \ DO_FIELD(DW4, Islowdelay, params.isLowDelay); \ DO_FIELD(DW4, CollocatedFromL0Flag, params.collocatedFromL0Flag); \ DO_FIELD(DW4, Chromalog2Weightdenom, params.chromalog2Weightdenom); \ DO_FIELD(DW4, LumaLog2WeightDenom, params.lumaLog2WeightDenom); \ DO_FIELD(DW4, CabacInitFlag, params.cabacInitFlag); \ DO_FIELD(DW4, Maxmergeidx, params.maxmergeidx); \ DO_FIELD(DW4, Collocatedrefidx, params.collocatedrefidx); \ DO_FIELD(DW5, Sliceheaderlength, params.sliceheaderlength); \ DO_FIELD(DW6, Roundinter, params.roundinter); \ DO_FIELD(DW6, Roundintra, params.roundintra); \ DO_FIELD(DW7, Cabaczerowordinsertionenable, params.cabaczerowordinsertionenable); \ DO_FIELD(DW7, Emulationbytesliceinsertenable, params.emulationbytesliceinsertenable); \ DO_FIELD(DW7, TailInsertionEnable, params.tailInsertionEnable); \ DO_FIELD(DW7, SlicedataEnable, params.slicedataEnable); \ DO_FIELD(DW7, HeaderInsertionEnable, params.headerInsertionEnable); \ DO_FIELD(DW7, DependentSliceDueToTileSplit, params.bIsNotFirstTile); \ DO_FIELD(DW8, IndirectPakBseDataStartOffsetWrite, params.indirectPakBseDataStartOffsetWrite); \ DO_FIELD(DW9, TransformskipLambda, params.transformskiplambda); \ DO_FIELD(DW10, TransformskipNumzerocoeffsFactor0, params.transformskipNumzerocoeffsFactor0); \ DO_FIELD(DW10, TransformskipNumnonzerocoeffsFactor0, params.transformskipNumnonzerocoeffsFactor0); \ DO_FIELD(DW10, TransformskipNumzerocoeffsFactor1, params.transformskipNumzerocoeffsFactor1); \ DO_FIELD(DW10, TransformskipNumnonzerocoeffsFactor1, params.transformskipNumnonzerocoeffsFactor1); \ DO_FIELD(DW11, Originalslicestartctbx, params.originalSliceStartCtbX); \ DO_FIELD(DW11, Originalslicestartctby, params.originalSliceStartCtbY); \ DO_FIELD(DW12, SliceActYQpOffset, params.sliceActYQpOffset); \ DO_FIELD(DW12, SliceActCbQpOffset, params.sliceActCbQpOffset); \ DO_FIELD(DW12, SliceActCrQpOffset, params.sliceActCrQpOffset); \ DO_FIELD(DW12, UseIntegerMvFlag, params.useIntegerMvFlag); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HCP_IND_OBJ_BASE_ADDR_STATE) { _MHW_SETCMD_CALLBASE(HCP_IND_OBJ_BASE_ADDR_STATE); MHW_RESOURCE_PARAMS resourceParams; MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); resourceParams.dwLsbNum = MHW_VDBOX_HCP_UPPER_BOUND_STATE_SHIFT; resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR; if (params.bDecodeInUse) { MHW_MI_CHK_NULL(params.presDataBuffer); InitMocsParams(resourceParams, &cmd.HcpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value, 1, 6); resourceParams.presResource = params.presDataBuffer; resourceParams.dwOffset = params.dwDataOffset; resourceParams.pdwCmd = (cmd.HcpIndirectBitstreamObjectBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = 1; resourceParams.dwSize = params.dwDataSize; resourceParams.bIsWritable = false; // upper bound of the allocated resource will be set at 3 DW apart from address location resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; } if (!params.bDecodeInUse) { if (params.presMvObjectBuffer) { resourceParams.presResource = params.presMvObjectBuffer; resourceParams.dwOffset = params.dwMvObjectOffset; resourceParams.pdwCmd = (cmd.DW6_7.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW6_7); resourceParams.dwSize = MOS_ALIGN_CEIL(params.dwMvObjectSize, 0x1000); resourceParams.bIsWritable = false; resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; InitMocsParams(resourceParams, &cmd.HcpIndirectCuObjectObjectMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } if (params.presPakBaseObjectBuffer) { resourceParams.presResource = params.presPakBaseObjectBuffer; resourceParams.dwOffset = params.presPakBaseObjectBuffer->dwResourceOffset; resourceParams.pdwCmd = (cmd.DW9_10.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW9_10); resourceParams.dwSize = MOS_ALIGN_FLOOR(params.dwPakBaseObjectSize, 0x1000); resourceParams.bIsWritable = true; resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; InitMocsParams(resourceParams, &cmd.HcpPakBseObjectAddressMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; } if (params.presCompressedHeaderBuffer) { resourceParams.presResource = params.presCompressedHeaderBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.DW14_15.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW14_15); resourceParams.dwSize = params.dwCompressedHeaderSize; resourceParams.bIsWritable = false; InitMocsParams(resourceParams, &cmd.HcpVp9PakCompressedHeaderSyntaxStreaminMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } if (params.presProbabilityCounterBuffer) { resourceParams.presResource = params.presProbabilityCounterBuffer; resourceParams.dwOffset = params.dwProbabilityCounterOffset; resourceParams.pdwCmd = (cmd.DW17_18.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW17_18); resourceParams.dwSize = params.dwProbabilityCounterSize; resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.HcpVp9PakProbabilityCounterStreamoutMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } if (params.presProbabilityDeltaBuffer) { resourceParams.presResource = params.presProbabilityDeltaBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.DW20_21.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW20_21); resourceParams.dwSize = params.dwProbabilityDeltaSize; resourceParams.bIsWritable = false; InitMocsParams(resourceParams, &cmd.HcpVp9PakProbabilityDeltasStreaminMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } if (params.presTileRecordBuffer) { resourceParams.presResource = params.presTileRecordBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.DW23_24.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW23_24); resourceParams.dwSize = params.dwTileRecordSize; resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.HcpVp9PakTileRecordStreamoutMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } else if (params.presPakTileSizeStasBuffer) { resourceParams.presResource = params.presPakTileSizeStasBuffer; resourceParams.dwOffset = params.dwPakTileSizeRecordOffset; resourceParams.pdwCmd = (cmd.DW23_24.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW23_24); resourceParams.dwSize = params.dwPakTileSizeStasBufferSize; resourceParams.bIsWritable = WRITE_WA; InitMocsParams(resourceParams, &cmd.HcpVp9PakTileRecordStreamoutMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(HCP_QM_STATE) { _MHW_SETCMD_CALLBASE(HCP_QM_STATE); for (uint8_t i = 0; i < 16; i++) { cmd.Quantizermatrix[i] = params.quantizermatrix[i]; } cmd.DW1.PredictionType = params.predictionType; cmd.DW1.Sizeid = params.sizeid; cmd.DW1.ColorComponent = params.colorComponent; cmd.DW1.DcCoefficient = params.dcCoefficient; return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(HCP_BSD_OBJECT) { _MHW_SETCMD_CALLBASE(HCP_BSD_OBJECT); #define DO_FIELDS() \ DO_FIELD(DW1, IndirectBsdDataLength, params.bsdDataLength); \ DO_FIELD(DW2, IndirectDataStartAddress, params.bsdDataStartOffset); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HCP_TILE_STATE) { _MHW_SETCMD_CALLBASE(HCP_TILE_STATE); cmd.DW1.Numtilecolumnsminus1 = params.numTileColumnsMinus1; cmd.DW1.Numtilerowsminus1 = params.numTileRowsMinus1; uint32_t column = params.numTileColumnsMinus1 + 1; uint32_t lastDwEleNum = column % 4; uint32_t count = column / 4; for (uint8_t i = 0; i < 5; i++) { cmd.CtbColumnPositionOfTileColumn[i].DW0.Value = 0; } for (uint8_t i = 0; i < 6; i++) { cmd.CtbRowPositionOfTileRow[i].DW0.Value = 0; } cmd.CtbColumnPositionMsb.DW0.Value = 0; cmd.CtbColumnPositionMsb.DW1.Value = 0; cmd.CtbRowPositionMsb.DW0.Value = 0; cmd.CtbRowPositionMsb.DW1.Value = 0; uint32_t colCumulativeValue = 0; uint32_t rowCumulativeValue = 0; // Column Position for (uint32_t i = 0; i < count; i++) { uint32_t &CtbColumnMsbValue = ((i << 3) >> 5) == 0 ? cmd.CtbColumnPositionMsb.DW0.Value : cmd.CtbColumnPositionMsb.DW1.Value; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos0I = colCumulativeValue & 0xFF; // lower 8bits CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 0)); // MSB 2bits colCumulativeValue += params.pTileColWidth[4 * i]; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos1I = colCumulativeValue & 0xFF; // lower 8bits CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 2)); // MSB 2bits colCumulativeValue += params.pTileColWidth[4 * i + 1]; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos2I = colCumulativeValue & 0xFF; // lower 8bits CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 4)); // MSB 2bits colCumulativeValue += params.pTileColWidth[4 * i + 2]; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos3I = colCumulativeValue & 0xFF; // lower 8bits CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 6)); // MSB 2bits colCumulativeValue += params.pTileColWidth[4 * i + 3]; } if (lastDwEleNum) { uint32_t i = count; uint32_t &CtbColumnMsbValue = ((i << 3) >> 5) == 0 ? cmd.CtbColumnPositionMsb.DW0.Value : cmd.CtbColumnPositionMsb.DW1.Value; if (i < 5) { cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos0I = colCumulativeValue & 0xFF; // lower 8bits CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 0)); // MSB 2bits if (lastDwEleNum > 1) { colCumulativeValue += params.pTileColWidth[4 * i]; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos1I = colCumulativeValue & 0xFF; //lower 8bits CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 2)); // MSB 2bits if (lastDwEleNum > 2) { colCumulativeValue += params.pTileColWidth[4 * i + 1]; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos2I = colCumulativeValue & 0xFF; //lower 8bits CtbColumnMsbValue = CtbColumnMsbValue | (((colCumulativeValue >> 8) & 0x3) << ((i * 8) + 4)); // MSB 2bits } } } } // Row Postion uint32_t row = params.numTileRowsMinus1 + 1; lastDwEleNum = row % 4; count = row / 4; for (uint32_t i = 0; i < count; i++) { uint32_t &CtbRowMsbValue = ((i << 3) >> 5) == 0 ? cmd.CtbRowPositionMsb.DW0.Value : cmd.CtbRowPositionMsb.DW1.Value; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos0I = rowCumulativeValue & 0xFF; // lower 8bits CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 0)); // MSB 2bits rowCumulativeValue += params.pTileRowHeight[4 * i]; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos1I = rowCumulativeValue & 0xFF; // lower 8bits CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 2)); // MSB 2bits rowCumulativeValue += params.pTileRowHeight[4 * i + 1]; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos2I = rowCumulativeValue & 0xFF; // lower 8bits CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 4)); // MSB 2bits rowCumulativeValue += params.pTileRowHeight[4 * i + 2]; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos3I = rowCumulativeValue & 0xFF; // lower 8bits CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 6)); // MSB 2bits rowCumulativeValue += params.pTileRowHeight[4 * i + 3]; } if (lastDwEleNum) { uint32_t i = count; uint32_t &CtbRowMsbValue = ((i << 3) >> 5) == 0 ? cmd.CtbRowPositionMsb.DW0.Value : cmd.CtbRowPositionMsb.DW1.Value; if (i < 6) { cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos0I = rowCumulativeValue & 0xFF; // lower 8bits CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 0)); // MSB 2bits if (lastDwEleNum > 1) { rowCumulativeValue += params.pTileRowHeight[4 * i]; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos1I = rowCumulativeValue & 0xFF; // lower 8bits CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 2)); // MSB 2bits if (lastDwEleNum > 2) { rowCumulativeValue += params.pTileRowHeight[4 * i + 1]; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos2I = rowCumulativeValue & 0xFF; // lower 8bits CtbRowMsbValue = CtbRowMsbValue | (((rowCumulativeValue >> 8) & 0x3) << ((i * 8) + 4)); // MSB 2bits } } } } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(HCP_REF_IDX_STATE) { _MHW_SETCMD_CALLBASE(HCP_REF_IDX_STATE); cmd.DW1.Refpiclistnum = params.ucList; cmd.DW1.NumRefIdxLRefpiclistnumActiveMinus1 = params.numRefIdxLRefpiclistnumActiveMinus1; for (uint8_t i = 0; i < sizeof(params.fieldPicFlag) / sizeof(params.fieldPicFlag[0]); i++) { cmd.Entries[i].DW0.ListEntryLxReferencePictureFrameIdRefaddr07 = params.listEntryLxReferencePictureFrameIdRefaddr07[i]; cmd.Entries[i].DW0.ReferencePictureTbValue = params.referencePictureTbValue[i]; cmd.Entries[i].DW0.Longtermreference = params.longtermreference[i]; cmd.Entries[i].DW0.FieldPicFlag = params.fieldPicFlag[i]; cmd.Entries[i].DW0.BottomFieldFlag = params.bottomFieldFlag[i]; } if (params.bDecodeInUse && (!params.bDummyReference)) { for (uint8_t i = (uint8_t)params.ucNumRefForList; i < 16; i++) { cmd.Entries[i].DW0.Value = 0x00; } } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(HCP_WEIGHTOFFSET_STATE) { _MHW_SETCMD_CALLBASE(HCP_WEIGHTOFFSET_STATE); uint8_t i = 0; uint8_t refIdx = 0; cmd.DW1.Refpiclistnum = i = params.ucList; // Luma for (refIdx = 0; refIdx < MAX_REF_FRAME_NUM; refIdx++) { cmd.Lumaoffsets[refIdx].DW0.DeltaLumaWeightLxI = params.LumaWeights[i][refIdx]; cmd.Lumaoffsets[refIdx].DW0.LumaOffsetLxI = (char)(params.LumaOffsets[i][refIdx] & 0xFF); // lower 8bits cmd.Lumaoffsets[refIdx].DW0.LumaOffsetLxIMsbyte = (char)((params.LumaOffsets[i][refIdx] >> 8) & 0xFF); // MSB 8bits } // Chroma for (refIdx = 0; refIdx < MAX_REF_FRAME_NUM; refIdx++) { // Cb cmd.Chromaoffsets[refIdx].DW0.DeltaChromaWeightLxI0 = params.ChromaWeights[i][refIdx][0]; cmd.Chromaoffsets[refIdx].DW0.ChromaoffsetlxI0 = params.ChromaOffsets[i][refIdx][0] & 0xFF; // lower 8bits // Cr cmd.Chromaoffsets[refIdx].DW0.DeltaChromaWeightLxI1 = params.ChromaWeights[i][refIdx][1]; cmd.Chromaoffsets[refIdx].DW0.ChromaoffsetlxI1 = params.ChromaOffsets[i][refIdx][1] & 0xFF; // lower 8bits } for (refIdx = 0; refIdx < MAX_REF_FRAME_NUM - 1; refIdx += 2) // MSB 8bits { cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI0Msbyte = (params.ChromaOffsets[i][refIdx][0] >> 8) & 0xFF; cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI10Msbyte = (params.ChromaOffsets[i][refIdx + 1][0] >> 8) & 0xFF; cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI1Msbyte = (params.ChromaOffsets[i][refIdx][1] >> 8) & 0xFF; cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI11Msbyte = (params.ChromaOffsets[i][refIdx + 1][1] >> 8) & 0xFF; } // last one cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI0Msbyte = (params.ChromaOffsets[i][refIdx][0] >> 8) & 0xFF; cmd.Chromaoffsetsext[refIdx >> 1].DW0.ChromaoffsetlxI1Msbyte = (params.ChromaOffsets[i][refIdx][1] >> 8) & 0xFF; return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(HCP_PIPE_MODE_SELECT) { _MHW_SETCMD_CALLBASE(HCP_PIPE_MODE_SELECT); if (params.setProtectionSettings) { MHW_CHK_STATUS_RETURN(params.setProtectionSettings(reinterpret_cast(&cmd))); } #define DO_FIELDS() \ DO_FIELD(DW1, AdvancedRateControlEnable, params.bAdvancedRateControlEnable); \ DO_FIELD(DW1, CodecStandardSelect, params.codecStandardSelect); \ DO_FIELD(DW1, PakPipelineStreamoutEnable, params.bStreamOutEnabled || params.bBRCEnabled || params.pakPiplnStrmoutEnabled); \ DO_FIELD(DW1, DeblockerStreamoutEnable, params.bDeblockerStreamOutEnable); \ DO_FIELD(DW1, VdencMode, params.bVdencEnabled); \ DO_FIELD(DW1, RdoqEnabledFlag, params.bRdoqEnable); \ DO_FIELD(DW1, PakFrameLevelStreamoutEnable, params.bStreamOutEnabled || params.pakFrmLvlStrmoutEnable); \ DO_FIELD(DW1, PipeWorkingMode, params.pipeWorkMode); \ DO_FIELD(DW1, MultiEngineMode, params.multiEngineMode); \ DO_FIELD(DW1, TileBasedEngine, params.bTileBasedReplayMode); \ DO_FIELD(DW1, Vp9DynamicScalingEnable, params.bDynamicScalingEnabled); \ DO_FIELD(DW1, CodecSelect, params.codecSelect); \ DO_FIELD(DW1, PrefetchDisable, params.prefetchDisable); \ DO_FIELD(DW2, MediaSoftResetCounterPer1000Clocks, params.mediaSoftResetCounterPer1000Clocks); \ DO_FIELD(DW6, PhaseIndicator, params.ucPhaseIndicator); \ DO_FIELD(DW6, HevcSeparateTileProgramming, params.bHEVCSeparateTileProgramming); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HCP_PIPE_BUF_ADDR_STATE) { _MHW_SETCMD_CALLBASE(HCP_PIPE_BUF_ADDR_STATE); MHW_RESOURCE_PARAMS resourceParams; MOS_SURFACE details; MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); // 1. MHW_VDBOX_HCP_GENERAL_STATE_SHIFT(6) may not work with DecodedPicture // since it needs to be 4k aligned resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT; resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR; // Decoded Picture cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.PreDeblockSurfMmcState) ? 1 : 0; cmd.DecodedPictureMemoryAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.PreDeblockSurfMmcState) ? 1 : 0; //cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(params->psPreDeblockSurface->TileType); cmd.DecodedPictureMemoryAddressAttributes.DW0.TileMode = GetHwTileType(params.psPreDeblockSurface->TileType, params.psPreDeblockSurface->TileModeGMM, params.psPreDeblockSurface->bGMMTileEnabled); resourceParams.presResource = &(params.psPreDeblockSurface->OsResource); resourceParams.dwOffset = params.psPreDeblockSurface->dwOffset; resourceParams.pdwCmd = (cmd.DecodedPicture.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DecodedPicture); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.DecodedPictureMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); // Deblocking Filter Line Buffer if (m_hevcDfRowStoreCache.enabled) { cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockingFilterLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1; cmd.DeblockingFilterLineBuffer.DW0_1.BaseAddress = m_hevcDfRowStoreCache.dwAddress; } else if (m_vp9DfRowStoreCache.enabled) { cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockingFilterLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1; cmd.DeblockingFilterLineBuffer.DW0_1.BaseAddress = m_vp9DfRowStoreCache.dwAddress; } else if (params.presMfdDeblockingFilterRowStoreScratchBuffer != nullptr) { resourceParams.presResource = params.presMfdDeblockingFilterRowStoreScratchBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.DeblockingFilterLineBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockingFilterLineBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Deblocking Filter Tile Line Buffer if (params.presDeblockingFilterTileRowStoreScratchBuffer != nullptr) { resourceParams.presResource = params.presDeblockingFilterTileRowStoreScratchBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.DeblockingFilterTileLineBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockingFilterTileLineBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.DeblockingFilterTileLineBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Deblocking Filter Tile Column Buffer if (params.presDeblockingFilterColumnRowStoreScratchBuffer != nullptr) { resourceParams.presResource = params.presDeblockingFilterColumnRowStoreScratchBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.DeblockingFilterTileColumnBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockingFilterTileColumnBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.DeblockingFilterTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Metadata Line Buffer if (m_hevcDatRowStoreCache.enabled) { cmd.MetadataLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.MetadataLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1; cmd.MetadataLineBuffer.DW0_1.BaseAddress = m_hevcDatRowStoreCache.dwAddress; } else if (m_vp9DatRowStoreCache.enabled) { cmd.MetadataLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.MetadataLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1; cmd.MetadataLineBuffer.DW0_1.BaseAddress = m_vp9DatRowStoreCache.dwAddress; } else if (params.presMetadataLineBuffer != nullptr) { resourceParams.presResource = params.presMetadataLineBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.MetadataLineBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MetadataLineBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.MetadataLineBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Metadata Tile Line Buffer if (params.presMetadataTileLineBuffer != nullptr) { resourceParams.presResource = params.presMetadataTileLineBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.MetadataTileLineBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MetadataTileLineBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.MetadataTileLineBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Metadata Tile Column Buffer if (params.presMetadataTileColumnBuffer != nullptr) { resourceParams.presResource = params.presMetadataTileColumnBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.MetadataTileColumnBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MetadataTileColumnBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.MetadataTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // SAO Line Buffer if (m_hevcSaoRowStoreCache.enabled) { cmd.SaoLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.SaoLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1; cmd.SaoLineBuffer.DW0_1.BaseAddress = m_hevcSaoRowStoreCache.dwAddress; } else if (params.presSaoLineBuffer != nullptr) { resourceParams.presResource = params.presSaoLineBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.SaoLineBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SaoLineBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.SaoLineBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // SAO Tile Line Buffer if (params.presSaoTileLineBuffer != nullptr) { resourceParams.presResource = params.presSaoTileLineBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.SaoTileLineBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SaoTileLineBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.SaoTileLineBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // SAO Tile Column Buffer if (params.presSaoTileColumnBuffer != nullptr) { resourceParams.presResource = params.presSaoTileColumnBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.SaoTileColumnBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SaoTileColumnBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.SaoTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Current Motion Vector Temporal Buffer if (params.presCurMvTempBuffer != nullptr) { resourceParams.presResource = params.presCurMvTempBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.CurrentMotionVectorTemporalBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CurrentMotionVectorTemporalBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.CurrentMotionVectorTemporalBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } bool firstRefPic = true; MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED; // 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 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++) { // Reference Picture Buffer if (params.presReferences[i] != nullptr) { MOS_ZeroMemory(&details, sizeof(details)); details.Format = Format_Invalid; MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.presReferences[i], &details)); if (firstRefPic) { cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled); firstRefPic = false; } resourceParams.presResource = params.presReferences[i]; resourceParams.pdwCmd = (cmd.ReferencePictureBaseAddressRefaddr07[i].DW0_1.Value); resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset; resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ReferencePictureBaseAddressRefaddr07[i]); if (params.IBCRefIdxMask & (1 << i)) { // Motion Compensation will use this picture to write and read IBC data resourceParams.bIsWritable = true; } else { resourceParams.bIsWritable = false; } resourceParams.dwSharedMocsOffset = 53 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW53 InitMocsParams(resourceParams, &cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } } // Same MMC status for deblock and ref surfaces cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable; cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.CompressionType = cmd.DecodedPictureMemoryAddressAttributes.DW0.CompressionType; // Reset dwSharedMocsOffset resourceParams.dwSharedMocsOffset = 0; // Original Uncompressed Picture Source, Encoder only if (params.psRawSurface != nullptr) { cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.RawSurfMmcState) ? 1 : 0; cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.RawSurfMmcState) ? 1 : 0; cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.TileMode = GetHwTileType(params.psRawSurface->TileType, params.psRawSurface->TileModeGMM, params.psRawSurface->bGMMTileEnabled); resourceParams.presResource = ¶ms.psRawSurface->OsResource; resourceParams.dwOffset = params.psRawSurface->dwOffset; resourceParams.pdwCmd = (cmd.OriginalUncompressedPictureSource.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(OriginalUncompressedPictureSource); resourceParams.bIsWritable = false; InitMocsParams(resourceParams, &cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // StreamOut Data Destination, Decoder only if (params.presStreamOutBuffer != nullptr) { resourceParams.presResource = params.presStreamOutBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.StreamoutDataDestination.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(StreamoutDataDestination); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.StreamoutDataDestinationMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Pak Cu Level Streamout Data if (params.presPakCuLevelStreamoutBuffer != nullptr) { resourceParams.presResource = params.presPakCuLevelStreamoutBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.StreamoutDataDestination.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(StreamoutDataDestination); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.StreamoutDataDestinationMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Decoded Picture Status / Error Buffer Base Address if (params.presLcuBaseAddressBuffer != nullptr) { resourceParams.presResource = params.presLcuBaseAddressBuffer; resourceParams.dwOffset = params.dwLcuStreamOutOffset; resourceParams.pdwCmd = (cmd.DecodedPictureStatusErrorBufferBaseAddressOrEncodedSliceSizeStreamoutBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DecodedPictureStatusErrorBufferBaseAddressOrEncodedSliceSizeStreamoutBaseAddress); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.DecodedPictureStatusErrorBufferBaseAddressMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // LCU ILDB StreamOut Buffer if (params.presLcuILDBStreamOutBuffer != nullptr) { resourceParams.presResource = params.presLcuILDBStreamOutBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.LcuIldbStreamoutBuffer.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LcuIldbStreamoutBuffer); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.LcuIldbStreamoutBufferMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++) { // Collocated Motion vector Temporal Buffer if (params.presColMvTempBuffer[i] != nullptr) { resourceParams.presResource = params.presColMvTempBuffer[i]; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.CollocatedMotionVectorTemporalBuffer07[i].DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CollocatedMotionVectorTemporalBuffer07[i]); resourceParams.bIsWritable = false; resourceParams.dwSharedMocsOffset = 82 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW82 InitMocsParams(resourceParams, &cmd.CollocatedMotionVectorTemporalBuffer07MemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } } // Reset dwSharedMocsOffset resourceParams.dwSharedMocsOffset = 0; // VP9 Probability Buffer if (params.presVp9ProbBuffer != nullptr) { resourceParams.presResource = params.presVp9ProbBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.Vp9ProbabilityBufferReadWrite.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9ProbabilityBufferReadWrite); resourceParams.bIsWritable = true; resourceParams.dwSharedMocsOffset = 85 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW88 InitMocsParams(resourceParams, &cmd.Vp9ProbabilityBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Reset dwSharedMocsOffset resourceParams.dwSharedMocsOffset = 0; // VP9 Segment Id Buffer if (params.presVp9SegmentIdBuffer != nullptr) { resourceParams.presResource = params.presVp9SegmentIdBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.DW86_87.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW86_87); resourceParams.bIsWritable = true; resourceParams.dwSharedMocsOffset = 88 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW88 InitMocsParams(resourceParams, &cmd.Vp9SegmentIdBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Reset dwSharedMocsOffset resourceParams.dwSharedMocsOffset = 0; // HVD Line Row Store Buffer if (m_vp9HvdRowStoreCache.enabled) { cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1; cmd.Vp9HvdLineRowstoreBufferReadWrite.DW0_1.BaseAddress = m_vp9HvdRowStoreCache.dwAddress; } else if (params.presHvdLineRowStoreBuffer != nullptr) { resourceParams.presResource = params.presHvdLineRowStoreBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.Vp9HvdLineRowstoreBufferReadWrite.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9HvdLineRowstoreBufferReadWrite); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // HVC Tile Row Store Buffer if (params.presHvdTileRowStoreBuffer != nullptr) { resourceParams.presResource = params.presHvdTileRowStoreBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.Vp9HvdTileRowstoreBufferReadWrite.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9HvdTileRowstoreBufferReadWrite); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.Vp9HvdTileRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // HEVC SAO row store buffer, HSAO if (m_hevcHSaoRowStoreCache.enabled) { cmd.SaoRowstoreBufferReadWriteMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.SaoRowstoreBufferReadWriteMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1; cmd.DW95_96.SaoRowstoreBufferBaseAddress = (uint64_t)(m_hevcHSaoRowStoreCache.dwAddress) << 6; } else if (params.presSaoRowStoreBuffer != nullptr) { resourceParams.presResource = params.presSaoRowStoreBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.DW95_96.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW95_96); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.SaoRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Frame Statistics Streamout Data Destination Buffer if (params.presFrameStatStreamOutBuffer != nullptr) { resourceParams.presResource = params.presFrameStatStreamOutBuffer; resourceParams.dwOffset = params.dwFrameStatStreamOutOffset; resourceParams.pdwCmd = (cmd.FrameStatisticsStreamoutDataDestinationBufferBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(FrameStatisticsStreamoutDataDestinationBufferBaseAddress); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.FrameStatisticsStreamoutDataDestinationBufferAttributesReadWrite.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // SSE Source Pixel Row Store Buffer if (params.presSseSrcPixelRowStoreBuffer != nullptr) { resourceParams.presResource = params.presSseSrcPixelRowStoreBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.SseSourcePixelRowstoreBufferBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SseSourcePixelRowstoreBufferBaseAddress); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.SseSourcePixelRowstoreBufferAttributesReadWrite.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // Slice state stream out buffer if (params.presSliceStateStreamOutBuffer != nullptr) { resourceParams.presResource = params.presSliceStateStreamOutBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.HcpScalabilitySliceStateBufferBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(HcpScalabilitySliceStateBufferBaseAddress); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.HcpScalabilitySliceStateBufferAttributesReadWrite.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // CABAC Syntax stream out buffer if (params.presCABACSyntaxStreamOutBuffer != nullptr) { resourceParams.presResource = params.presCABACSyntaxStreamOutBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.HcpScalabilityCabacDecodedSyntaxElementsBufferBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(HcpScalabilityCabacDecodedSyntaxElementsBufferBaseAddress); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.HcpScalabilityCabacDecodedSyntaxElementsBufferAttributesReadWrite.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // MV Upper Right Col Store if (params.presMvUpRightColStoreBuffer != nullptr) { resourceParams.presResource = params.presMvUpRightColStoreBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.MotionVectorUpperRightColumnStoreBufferBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(MotionVectorUpperRightColumnStoreBufferBaseAddress); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.MotionVectorUpperRightColumnStoreBufferAttributesReadWrite.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // IntraPred Upper Right Col Store if (params.presIntraPredUpRightColStoreBuffer != nullptr) { resourceParams.presResource = params.presIntraPredUpRightColStoreBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.IntraPredictionUpperRightColumnStoreBufferBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntraPredictionUpperRightColumnStoreBufferBaseAddress); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.IntraPredictionUpperRightColumnStoreBufferAttributesReadWrite.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // IntraPred Left Recon Col Store if (params.presIntraPredLeftReconColStoreBuffer != nullptr) { resourceParams.presResource = params.presIntraPredLeftReconColStoreBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.IntraPredictionLeftReconColumnStoreBufferBaseAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntraPredictionLeftReconColumnStoreBufferBaseAddress); resourceParams.bIsWritable = true; InitMocsParams(resourceParams, &cmd.IntraPredictionLeftReconColumnStoreBufferAttributesReadWrite.DW0.Value, 1, 6); MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } // CABAC Syntax Stream Out Buffer Max Address if (params.presCABACSyntaxStreamOutMaxAddr != nullptr) { resourceParams.presResource = params.presCABACSyntaxStreamOutMaxAddr; resourceParams.dwOffset = 0; resourceParams.pdwCmd = (cmd.HcpScalabilityCabacDecodedSyntaxElementsBufferMaxAddress.DW0_1.Value); resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(HcpScalabilityCabacDecodedSyntaxElementsBufferMaxAddress); resourceParams.bIsWritable = true; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } MOS_ZeroMemory(&details, sizeof(details)); details.Format = Format_Invalid; MEDIA_WA_TABLE *m_waTable = this->m_osItf->pfnGetWaTable(this->m_osItf); MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, ¶ms.psPreDeblockSurface->OsResource, &details)); cmd.DecodedPictureMemoryAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled); for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++) { // All Reference Picture Buffer share same memory address attribute // As Reference Surface attribute should be aligned with Recon surface // Reference surface tilemode info won't get from GMM but just eqaul to DecodedPicture if (params.presReferences[i] != nullptr) { cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.TileMode = cmd.DecodedPictureMemoryAddressAttributes.DW0.TileMode; break; } } if (params.psRawSurface != nullptr) { MOS_ZeroMemory(&details, sizeof(details)); details.Format = Format_Invalid; MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, ¶ms.psRawSurface->OsResource, &details)); cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled); } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(HCP_FQM_STATE) { _MHW_SETCMD_CALLBASE(HCP_FQM_STATE); for (uint8_t i = 0; i < 32; i++) { cmd.Quantizermatrix[i] = params.quantizermatrix[i]; } cmd.DW1.IntraInter = params.intraInter; cmd.DW1.Sizeid = params.sizeid; cmd.DW1.ColorComponent = params.colorComponent; cmd.DW1.FqmDcValue1Dc = params.fqmDcValue1Dc; return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(HCP_PAK_INSERT_OBJECT) { _MHW_SETCMD_CALLBASE(HCP_PAK_INSERT_OBJECT); uint32_t dwordsUsed = cmd.dwSize; dwordsUsed += params.dwPadding; #define DO_FIELDS() \ DO_FIELD(DW0, DwordLength, OP_LENGTH(dwordsUsed)); \ DO_FIELD(DW1, Headerlengthexcludefrmsize, params.bHeaderLengthExcludeFrmSize); \ DO_FIELD(DW1, EndofsliceflagLastdstdatainsertcommandflag, params.bEndOfSlice); \ DO_FIELD(DW1, LastheaderflagLastsrcheaderdatainsertcommandflag, params.bLastHeader); \ DO_FIELD(DW1, EmulationflagEmulationbytebitsinsertenable, params.bEmulationByteBitsInsert); \ DO_FIELD(DW1, SkipemulbytecntSkipEmulationByteCount, params.uiSkipEmulationCheckCount); \ DO_FIELD(DW1, SliceHeaderIndicator, params.bResetBitstreamStartingPos); \ DO_FIELD(DW1, DatabitsinlastdwSrcdataendingbitinclusion50, params.dataBitsInLastDw); \ DO_FIELD(DW1, DatabyteoffsetSrcdatastartingbyteoffset10, params.databyteoffset); \ DO_FIELD(DW1, IndirectPayloadEnable, params.bIndirectPayloadEnable); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HCP_VP9_PIC_STATE) { _MHW_SETCMD_CALLBASE(HCP_VP9_PIC_STATE); #define DO_FIELDS() \ if (params.bDecodeInUse) \ { \ DO_FIELD(DW0, DwordLength, params.dWordLength); \ } \ DO_FIELD(DW1, FrameWidthInPixelsMinus1, params.frameWidthInPixelsMinus1); \ DO_FIELD(DW1, FrameHeightInPixelsMinus1, params.frameHeightInPixelsMinus1); \ DO_FIELD(DW2, FrameType, params.frameType); \ DO_FIELD(DW2, AdaptProbabilitiesFlag, params.adaptProbabilitiesFlag); \ DO_FIELD(DW2, IntraonlyFlag, params.intraOnlyFlag); \ DO_FIELD(DW2, AllowHiPrecisionMv, params.allowHiPrecisionMv); \ DO_FIELD(DW2, McompFilterType, params.mcompFilterType); \ DO_FIELD(DW2, RefFrameSignBias02, params.refFrameSignBias02); \ DO_FIELD(DW2, HybridPredictionMode, params.hybridPredictionMode); \ DO_FIELD(DW2, SelectableTxMode, params.selectableTxMode); \ DO_FIELD(DW2, UsePrevInFindMvReferences, params.usePrevInFindMvReferences); \ DO_FIELD(DW2, LastFrameType, params.lastFrameType); \ DO_FIELD(DW2, RefreshFrameContext, params.refreshFrameContext); \ DO_FIELD(DW2, ErrorResilientMode, params.errorResilientMode); \ DO_FIELD(DW2, FrameParallelDecodingMode, params.frameParallelDecodingMode); \ DO_FIELD(DW2, FilterLevel, params.filterLevel); \ DO_FIELD(DW2, SharpnessLevel, params.sharpnessLevel); \ DO_FIELD(DW2, SegmentationEnabled, params.segmentationEnabled); \ DO_FIELD(DW2, SegmentationUpdateMap, params.segmentationUpdateMap); \ DO_FIELD(DW2, SegmentationTemporalUpdate, params.segmentationTemporalUpdate); \ DO_FIELD(DW2, LosslessMode, params.losslessMode); \ DO_FIELD(DW2, SegmentIdStreamoutEnable, params.segmentIdStreamOutEnable); \ DO_FIELD(DW2, SegmentIdStreaminEnable, params.segmentIdStreamInEnable); \ DO_FIELD(DW3, Log2TileColumn, params.log2TileColumn); \ DO_FIELD(DW3, Log2TileRow, params.log2TileRow); \ DO_FIELD(DW3, SseEnable, params.sseEnable); \ DO_FIELD(DW3, ChromaSamplingFormat, params.chromaSamplingFormat); \ DO_FIELD(DW3, Bitdepthminus8, params.bitdepthMinus8); \ DO_FIELD(DW3, ProfileLevel, params.profileLevel); \ DO_FIELD(DW4, VerticalScaleFactorForLast, params.verticalScaleFactorForLast); \ DO_FIELD(DW4, HorizontalScaleFactorForLast, params.horizontalScaleFactorForLast); \ DO_FIELD(DW5, VerticalScaleFactorForGolden, params.verticalScaleFactorForGolden); \ DO_FIELD(DW5, HorizontalScaleFactorForGolden, params.horizontalScaleFactorForGolden); \ DO_FIELD(DW6, VerticalScaleFactorForAltref, params.verticalScaleFactorForAltref); \ DO_FIELD(DW6, HorizontalScaleFactorForAltref, params.horizontalScaleFactorForAltref); \ DO_FIELD(DW7, LastFrameWidthInPixelsMinus1, params.lastFrameWidthInPixelsMinus1); \ DO_FIELD(DW7, LastFrameHieghtInPixelsMinus1, params.lastFrameHeightInPixelsMinus1); \ DO_FIELD(DW8, GoldenFrameWidthInPixelsMinus1, params.goldenFrameWidthInPixelsMinus1); \ DO_FIELD(DW8, GoldenFrameHieghtInPixelsMinus1, params.goldenFrameHeightInPixelsMinus1); \ DO_FIELD(DW9, AltrefFrameWidthInPixelsMinus1, params.altrefFrameWidthInPixelsMinus1); \ DO_FIELD(DW9, AltrefFrameHieghtInPixelsMinus1, params.altrefFrameHeightInPixelsMinus1); \ DO_FIELD(DW10, UncompressedHeaderLengthInBytes70, params.uncompressedHeaderLengthInBytes70); \ DO_FIELD(DW10, FirstPartitionSizeInBytes150, params.firstPartitionSizeInBytes150); \ DO_FIELD(DW13, BaseQIndexSameAsLumaAc, params.baseQIndexSameAsLumaAc); \ DO_FIELD(DW13, HeaderInsertionEnable, params.headerInsertionEnable); \ DO_FIELD(DW14, ChromaacQindexdelta, params.chromaAcQIndexDelta); \ DO_FIELD(DW14, ChromadcQindexdelta, params.chromaDcQIndexDelta); \ DO_FIELD(DW14, LumaDcQIndexDelta, params.lumaDcQIndexDelta); \ DO_FIELD(DW15, LfRefDelta0, params.lfRefDelta0); \ DO_FIELD(DW15, LfRefDelta1, params.lfRefDelta1); \ DO_FIELD(DW15, LfRefDelta2, params.lfRefDelta2); \ DO_FIELD(DW15, LfRefDelta3, params.lfRefDelta3); \ DO_FIELD(DW16, LfModeDelta0, params.lfModeDelta0); \ DO_FIELD(DW16, LfModeDelta1, params.lfModeDelta1); \ DO_FIELD(DW17, Bitoffsetforlfrefdelta, params.bitOffsetForLfRefDelta); \ DO_FIELD(DW17, Bitoffsetforlfmodedelta, params.bitOffsetForLfModeDelta); \ DO_FIELD(DW18, Bitoffsetforqindex, params.bitOffsetForQIndex); \ DO_FIELD(DW18, Bitoffsetforlflevel, params.bitOffsetForLfLevel); \ DO_FIELD(DW19, VdencPakOnlyPass, params.vdencPakOnlyPass); \ DO_FIELD(DW32, Bitoffsetforfirstpartitionsize, params.bitOffsetForFirstPartitionSize); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HCP_VP9_SEGMENT_STATE) { _MHW_SETCMD_CALLBASE(HCP_VP9_SEGMENT_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, SegmentId, params.segmentId); \ DO_FIELD(DW2, SegmentSkipped, params.segmentSkipped); \ DO_FIELD(DW2, SegmentReference, params.segmentReference); \ DO_FIELD(DW2, SegmentReferenceEnabled, params.segmentReferenceEnabled); \ DO_FIELD(DW3, Filterlevelref0Mode0, params.filterLevelRef0Mode0); \ DO_FIELD(DW3, Filterlevelref0Mode1, params.filterLevelRef0Mode1); \ DO_FIELD(DW3, Filterlevelref1Mode0, params.filterLevelRef1Mode0); \ DO_FIELD(DW3, Filterlevelref1Mode1, params.filterLevelRef1Mode1); \ DO_FIELD(DW4, Filterlevelref2Mode0, params.filterLevelRef2Mode0); \ DO_FIELD(DW4, Filterlevelref2Mode1, params.filterLevelRef2Mode1); \ DO_FIELD(DW4, Filterlevelref3Mode0, params.filterLevelRef3Mode0); \ DO_FIELD(DW4, Filterlevelref3Mode1, params.filterLevelRef3Mode1); \ DO_FIELD(DW5, LumaDcQuantScaleDecodeModeOnly, params.lumaDcQuantScaleDecodeModeOnly); \ DO_FIELD(DW5, LumaAcQuantScaleDecodeModeOnly, params.lumaAcQuantScaleDecodeModeOnly); \ DO_FIELD(DW6, ChromaDcQuantScaleDecodeModeOnly, params.chromaDcQuantScaleDecodeModeOnly); \ DO_FIELD(DW6, ChromaAcQuantScaleDecodeModeOnly, params.chromaAcQuantScaleDecodeModeOnly); \ DO_FIELD(DW7, SegmentQindexDeltaEncodeModeOnly, params.segmentQindexDeltaEncodeModeOnly); \ DO_FIELD(DW7, SegmentLfLevelDeltaEncodeModeOnly, params.segmentLfLevelDeltaEncodeModeOnly); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HEVC_VP9_RDOQ_STATE) { _MHW_SETCMD_CALLBASE(HEVC_VP9_RDOQ_STATE); for (uint8_t i = 0; i < 32; i++) { cmd.Intralumalambda[i].DW0.Lambdavalue0 = params.lambdaTab[0][0][i * 2]; cmd.Intralumalambda[i].DW0.Lambdavalue1 = params.lambdaTab[0][0][i * 2 + 1]; cmd.Intrachromalambda[i].DW0.Lambdavalue0 = params.lambdaTab[0][1][i * 2]; cmd.Intrachromalambda[i].DW0.Lambdavalue1 = params.lambdaTab[0][1][i * 2 + 1]; cmd.Interlumalambda[i].DW0.Lambdavalue0 = params.lambdaTab[1][0][i * 2]; cmd.Interlumalambda[i].DW0.Lambdavalue1 = params.lambdaTab[1][0][i * 2 + 1]; cmd.Interchromalambda[i].DW0.Lambdavalue0 = params.lambdaTab[1][1][i * 2]; cmd.Interchromalambda[i].DW0.Lambdavalue1 = params.lambdaTab[1][1][i * 2 + 1]; } for (uint8_t i = 0; i < 6; i++) { cmd.Intralumalambda12bit[i].DW0.Lambdavalue0 = params.lambdaTab[0][0][i * 2 + 64]; cmd.Intralumalambda12bit[i].DW0.Lambdavalue1 = params.lambdaTab[0][0][i * 2 + 1 + 64]; cmd.Intrachromalambda12bit[i].DW0.Lambdavalue0 = params.lambdaTab[0][1][i * 2 + 64]; cmd.Intrachromalambda12bit[i].DW0.Lambdavalue1 = params.lambdaTab[0][1][i * 2 + 1 + 64]; cmd.Interlumalambda12bit[i].DW0.Lambdavalue0 = params.lambdaTab[1][0][i * 2 + 64]; cmd.Interlumalambda12bit[i].DW0.Lambdavalue1 = params.lambdaTab[1][0][i * 2 + 1 + 64]; cmd.Interchromalambda12bit[i].DW0.Lambdavalue0 = params.lambdaTab[1][1][i * 2 + 64]; cmd.Interchromalambda12bit[i].DW0.Lambdavalue1 = params.lambdaTab[1][1][i * 2 + 1 + 64]; } cmd.DW1.DisableHtqPerformanceFix0 = params.disableHtqPerformanceFix0; cmd.DW1.DisableHtqPerformanceFix1 = params.disableHtqPerformanceFix1; return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(HCP_TILE_CODING) { _MHW_SETCMD_CALLBASE(HCP_TILE_CODING); #define DO_FIELDS() \ DO_FIELD(DW1, NumberOfActiveBePipes, params.numberOfActiveBePipes); \ DO_FIELD(DW1, NumOfTileColumnsInAFrame, params.numOfTileColumnsInFrame); \ DO_FIELD(DW1, TileRowStoreSelect, params.tileRowStoreSelect); \ DO_FIELD(DW1, TileColumnStoreSelect, params.tileColumnStoreSelect); \ DO_FIELD(DW2, TileColumnPosition, params.tileStartLCUX); \ DO_FIELD(DW2, TileRowPosition, params.tileStartLCUY); \ DO_FIELD(DW2, Islasttileofcolumn, params.isLastTileofColumn); \ DO_FIELD(DW2, Islasttileofrow, params.isLastTileofRow); \ DO_FIELD(DW2, NonFirstPassTile, params.nonFirstPassTile); \ DO_FIELD(DW3, Tileheightinmincbminus1, params.tileHeightInMinCbMinus1); \ DO_FIELD(DW3, Tilewidthinmincbminus1, params.tileWidthInMinCbMinus1); \ DO_FIELD(DW4, BitstreamByteOffset, params.bitstreamByteOffset); \ DO_FIELD(DW4, BitstreamByteOffsetEnable, params.bitstreamByteOffsetEnable); \ DO_FIELD(DW5, PakFrameStatisticsOffset, params.pakTileStatisticsOffset); \ DO_FIELD(DW6, CuLevelStreamoutOffset, params.cuLevelStreamoutOffset); \ DO_FIELD(DW7, SliceSizeStreamoutOffset, params.sliceSizeStreamoutOffset); \ DO_FIELD(DW8, CuRecordOffset, params.cuRecordOffset); \ DO_FIELD(DW9, SseRowstoreOffset, params.sseRowstoreOffset); \ DO_FIELD(DW10, SaoRowstoreOffset, params.saoRowstoreOffset); \ DO_FIELD(DW11, TileSizeStreamoutOffset, params.tileSizeStreamoutOffset); \ DO_FIELD(DW12, Vp9ProbabilityCounterStreamoutOffset, params.vp9ProbabilityCounterStreamoutOffset); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(HCP_PALETTE_INITIALIZER_STATE) { _MHW_SETCMD_CALLBASE(HCP_PALETTE_INITIALIZER_STATE); cmd.DW1.ActivePaletteInitializerTableEntries = params.predictorPaletteSize; uint32_t yentryIdx = 0; for (uint32_t i = 0; i < params.hevcSccPaletteSize; i += 3) { // First 64 color entries yentryIdx = i * 2 / 3; cmd.First64ColorEntries[i] = params.predictorPaletteEntries[0][yentryIdx]; // Y cmd.First64ColorEntries[i] |= ((uint32_t)params.predictorPaletteEntries[1][yentryIdx] << 16); // Cb cmd.First64ColorEntries[i + 1] = params.predictorPaletteEntries[2][yentryIdx]; // Cr cmd.First64ColorEntries[i + 1] |= ((uint32_t)params.predictorPaletteEntries[0][yentryIdx + 1] << 16); // Y cmd.First64ColorEntries[i + 2] = params.predictorPaletteEntries[1][yentryIdx + 1]; // Cb cmd.First64ColorEntries[i + 2] |= ((uint32_t)params.predictorPaletteEntries[2][yentryIdx + 1] << 16); // Cr // Second 64 color entries yentryIdx += 64; cmd.Second64ColorEntries[i] = params.predictorPaletteEntries[0][yentryIdx]; // Y cmd.Second64ColorEntries[i] |= ((uint32_t)params.predictorPaletteEntries[1][yentryIdx] << 16); // Cb cmd.Second64ColorEntries[i + 1] = params.predictorPaletteEntries[2][yentryIdx]; // Cr cmd.Second64ColorEntries[i + 1] |= ((uint32_t)params.predictorPaletteEntries[0][yentryIdx + 1] << 16); // Y cmd.Second64ColorEntries[i + 2] = params.predictorPaletteEntries[1][yentryIdx + 1]; // Cb cmd.Second64ColorEntries[i + 2] |= ((uint32_t)params.predictorPaletteEntries[2][yentryIdx + 1] << 16); // Cr } return MOS_STATUS_SUCCESS; } MEDIA_CLASS_DEFINE_END(mhw__vdbox__hcp__Impl) }; } // namespace hcp } // namespace vdbox } // namespace mhw #endif // __MHW_VDBOX_HCP_IMPL_H__