/* * Copyright (c) 2014-2018, 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_generic.h //! \brief MHW interface for constructing HCP commands for the Vdbox engine //! \details Impelements shared Vdbox HCP command construction functions across all platforms as templates //! #ifndef _MHW_VDBOX_HCP_GENERIC_H_ #define _MHW_VDBOX_HCP_GENERIC_H_ #include "mhw_vdbox_hcp_interface.h" #include "mhw_cp_interface.h" //! MHW Vdbox Hcp generic interface /*! This class defines the shared Hcp command construction functions across all platforms as templates */ template class MhwVdboxHcpInterfaceGeneric : public MhwVdboxHcpInterface { protected: static const uint32_t m_vp9ScalingFactor = (1 << 14); static const uint32_t m_rawUVPlaneAlignment = 4; //! starting Gen9 the alignment is relaxed to 4x instead of 16x static const uint32_t m_reconUVPlaneAlignment = 8; static const uint32_t m_uvPlaneAlignmentLegacy = 8; //! starting Gen9 the alignment is relaxed to 4x instead of 16x //! //! \brief Constructor //! MhwVdboxHcpInterfaceGeneric( PMOS_INTERFACE osInterface, MhwMiInterface *miInterface, MhwCpInterface *cpInterface, bool decodeInUse) : MhwVdboxHcpInterface(osInterface, miInterface, cpInterface, decodeInUse) { MHW_FUNCTION_ENTER; } //! //! \brief Destructor //! virtual ~MhwVdboxHcpInterfaceGeneric() {} MOS_STATUS AddHcpDecodeSurfaceStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_SURFACE_PARAMS params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(m_osInterface); MHW_MI_CHK_NULL(params); MHW_ASSERT(params->Mode != CODECHAL_UNSUPPORTED_MODE); MHW_MI_CHK_NULL(params->psSurface); typename THcpCmds::HCP_SURFACE_STATE_CMD cmd; uint32_t uvPlaneAlignment = m_uvPlaneAlignmentLegacy; cmd.DW1.SurfaceId = params->ucSurfaceStateId; cmd.DW1.SurfacePitchMinus1 = params->psSurface->dwPitch - 1; if (params->ucSurfaceStateId == CODECHAL_HCP_SRC_SURFACE_ID) { uvPlaneAlignment = params->dwUVPlaneAlignment ? params->dwUVPlaneAlignment : m_rawUVPlaneAlignment; } else { uvPlaneAlignment = params->dwUVPlaneAlignment ? params->dwUVPlaneAlignment : m_reconUVPlaneAlignment; } cmd.DW2.YOffsetForUCbInPixel = MOS_ALIGN_CEIL(params->psSurface->UPlaneOffset.iYOffset, uvPlaneAlignment); MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpEncodeSurfaceStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_SURFACE_PARAMS params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(m_osInterface); MHW_MI_CHK_NULL(params); MHW_ASSERT(params->Mode != CODECHAL_UNSUPPORTED_MODE); MHW_MI_CHK_NULL(params->psSurface); typename THcpCmds::HCP_SURFACE_STATE_CMD cmd; cmd.DW1.SurfaceId = params->ucSurfaceStateId; cmd.DW1.SurfacePitchMinus1 = params->psSurface->dwPitch - 1; /* Handling of reconstructed surface is different for Y410 & AYUV formats */ if ((params->ucSurfaceStateId != CODECHAL_HCP_SRC_SURFACE_ID) && (params->psSurface->Format == Format_Y410)) cmd.DW1.SurfacePitchMinus1 = params->psSurface->dwPitch / 2 - 1; if ((params->ucSurfaceStateId != CODECHAL_HCP_SRC_SURFACE_ID) && (params->psSurface->Format == Format_AYUV)) cmd.DW1.SurfacePitchMinus1 = params->psSurface->dwPitch / 4 - 1; cmd.DW2.YOffsetForUCbInPixel = params->psSurface->UPlaneOffset.iYOffset; MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpIndObjBaseAddrCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(m_osInterface); MHW_MI_CHK_NULL(params); MHW_RESOURCE_PARAMS resourceParams; typename THcpCmds::HCP_IND_OBJ_BASE_ADDR_STATE_CMD cmd; MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); resourceParams.dwLsbNum = MHW_VDBOX_HCP_UPPER_BOUND_STATE_SHIFT; resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR; // mode specific settings if (CodecHalIsDecodeModeVLD(params->Mode)) { MHW_MI_CHK_NULL(params->presDataBuffer); cmd.HcpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value |= m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE].Value; 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(pfnAddResourceToCmd( m_osInterface, cmdBuffer, &resourceParams)); } MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpQmStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_QM_PARAMS params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(m_osInterface); MHW_MI_CHK_NULL(cmdBuffer); MHW_MI_CHK_NULL(params); if (params->Standard == CODECHAL_HEVC) { typename THcpCmds::HCP_QM_STATE_CMD cmd; uint8_t* qMatrix = nullptr; MHW_MI_CHK_NULL(params->pHevcIqMatrix); qMatrix = (uint8_t*)cmd.Quantizermatrix; for (uint8_t sizeId = 0; sizeId < 4; sizeId++) // 4x4, 8x8, 16x16, 32x32 { for (uint8_t predType = 0; predType < 2; predType++) // Intra, Inter { for (uint8_t color = 0; color < 3; color++) // Y, Cb, Cr { if ((sizeId == 3) && (color != 0)) break; cmd.DW1.Sizeid = sizeId; cmd.DW1.PredictionType = predType; cmd.DW1.ColorComponent = color; switch (sizeId) { case cmd.SIZEID_4X4: case cmd.SIZEID_8X8: default: cmd.DW1.DcCoefficient = 0; break; case cmd.SIZEID_16X16: cmd.DW1.DcCoefficient = params->pHevcIqMatrix->ListDC16x16[3 * predType + color]; break; case cmd.SIZEID_32X32: cmd.DW1.DcCoefficient = params->pHevcIqMatrix->ListDC32x32[predType]; break; } if (sizeId == cmd.SIZEID_4X4) { for (uint8_t i = 0; i < 4; i++) { for (uint8_t ii = 0; ii < 4; ii++) { qMatrix[4 * i + ii] = params->pHevcIqMatrix->List4x4[3 * predType + color][4 * i + ii]; } } } else if (sizeId == cmd.SIZEID_8X8) { for (uint8_t i = 0; i < 8; i++) { for (uint8_t ii = 0; ii < 8; ii++) { qMatrix[8 * i + ii] = params->pHevcIqMatrix->List8x8[3 * predType + color][8 * i + ii]; } } } else if (sizeId == cmd.SIZEID_16X16) { for (uint8_t i = 0; i < 8; i++) { for (uint8_t ii = 0; ii < 8; ii++) { qMatrix[8 * i + ii] = params->pHevcIqMatrix->List16x16[3 * predType + color][8 * i + ii]; } } } else // 32x32 { for (uint8_t i = 0; i < 8; i++) { for (uint8_t ii = 0; ii < 8; ii++) { qMatrix[8 * i + ii] = params->pHevcIqMatrix->List32x32[predType][8 * i + ii]; } } } MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize)); } } } } else { eStatus = MOS_STATUS_INVALID_PARAMETER; } return eStatus; } MOS_STATUS AddHcpDecodePicStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_HEVC_PIC_STATE params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(m_osInterface); MHW_MI_CHK_NULL(params); MHW_MI_CHK_NULL(params->pHevcPicParams); typename THcpCmds::HCP_PIC_STATE_CMD cmd; auto hevcPicParams = params->pHevcPicParams; cmd.DW1.Framewidthinmincbminus1 = hevcPicParams->PicWidthInMinCbsY - 1; cmd.DW1.Frameheightinmincbminus1 = hevcPicParams->PicHeightInMinCbsY - 1; cmd.DW2.Mincusize = (hevcPicParams->log2_min_luma_coding_block_size_minus3) & 0x3; cmd.DW2.CtbsizeLcusize = (hevcPicParams->log2_diff_max_min_luma_coding_block_size + hevcPicParams->log2_min_luma_coding_block_size_minus3) & 0x3; cmd.DW2.Maxtusize = (hevcPicParams->log2_diff_max_min_transform_block_size + hevcPicParams->log2_min_transform_block_size_minus2) & 0x3; cmd.DW2.Mintusize = (hevcPicParams->log2_min_transform_block_size_minus2) & 0x3; cmd.DW2.Minpcmsize = (hevcPicParams->log2_min_pcm_luma_coding_block_size_minus3) & 0x3; cmd.DW2.Maxpcmsize = (hevcPicParams->log2_diff_max_min_pcm_luma_coding_block_size + hevcPicParams->log2_min_pcm_luma_coding_block_size_minus3) & 0x3; // As per HW requirement, CurPicIsI and ColPicIsI should be set to either both correct or both zero // Since driver doesn't know Collocated_Ref_Idx for SF, and cannot get accurate CurPicIsI for both LF/SF // Have to make ColPicIsI = CurPicIsI = 0 for both LF/SF cmd.DW3.Colpicisi = 0; cmd.DW3.Curpicisi = 0; cmd.DW4.SampleAdaptiveOffsetEnabledFlag = hevcPicParams->sample_adaptive_offset_enabled_flag; cmd.DW4.PcmEnabledFlag = hevcPicParams->pcm_enabled_flag; cmd.DW4.CuQpDeltaEnabledFlag = hevcPicParams->cu_qp_delta_enabled_flag; cmd.DW4.DiffCuQpDeltaDepthOrNamedAsMaxDqpDepth = hevcPicParams->diff_cu_qp_delta_depth; cmd.DW4.PcmLoopFilterDisableFlag = hevcPicParams->pcm_loop_filter_disabled_flag; cmd.DW4.ConstrainedIntraPredFlag = hevcPicParams->constrained_intra_pred_flag; cmd.DW4.Log2ParallelMergeLevelMinus2 = hevcPicParams->log2_parallel_merge_level_minus2; cmd.DW4.SignDataHidingFlag = hevcPicParams->sign_data_hiding_enabled_flag; cmd.DW4.LoopFilterAcrossTilesEnabledFlag = hevcPicParams->loop_filter_across_tiles_enabled_flag; cmd.DW4.EntropyCodingSyncEnabledFlag = hevcPicParams->entropy_coding_sync_enabled_flag; cmd.DW4.TilesEnabledFlag = hevcPicParams->tiles_enabled_flag; cmd.DW4.WeightedPredFlag = hevcPicParams->weighted_pred_flag; cmd.DW4.WeightedBipredFlag = hevcPicParams->weighted_bipred_flag; cmd.DW4.Fieldpic = (hevcPicParams->RefFieldPicFlag >> 15) & 0x01; cmd.DW4.Bottomfield = ((hevcPicParams->RefBottomFieldFlag >> 15) & 0x01) ? 0 : 1; cmd.DW4.TransformSkipEnabledFlag = hevcPicParams->transform_skip_enabled_flag; cmd.DW4.AmpEnabledFlag = hevcPicParams->amp_enabled_flag; cmd.DW4.TransquantBypassEnableFlag = hevcPicParams->transquant_bypass_enabled_flag; cmd.DW4.StrongIntraSmoothingEnableFlag = hevcPicParams->strong_intra_smoothing_enabled_flag; cmd.DW5.PicCbQpOffset = hevcPicParams->pps_cb_qp_offset & 0x1f; cmd.DW5.PicCrQpOffset = hevcPicParams->pps_cr_qp_offset & 0x1f; cmd.DW5.MaxTransformHierarchyDepthIntraOrNamedAsTuMaxDepthIntra = hevcPicParams->max_transform_hierarchy_depth_intra & 0x7; cmd.DW5.MaxTransformHierarchyDepthInterOrNamedAsTuMaxDepthInter = hevcPicParams->max_transform_hierarchy_depth_inter & 0x7; cmd.DW5.PcmSampleBitDepthChromaMinus1 = hevcPicParams->pcm_sample_bit_depth_chroma_minus1; cmd.DW5.PcmSampleBitDepthLumaMinus1 = hevcPicParams->pcm_sample_bit_depth_luma_minus1; MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpBsdObjectCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_HCP_BSD_PARAMS params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(m_osInterface); typename THcpCmds::HCP_BSD_OBJECT_CMD cmd; cmd.DW1.IndirectBsdDataLength = params->dwBsdDataLength; cmd.DW2.IndirectDataStartAddress = params->dwBsdDataStartOffset; MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd))); return eStatus; } MOS_STATUS AddHcpTileStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_HEVC_TILE_STATE params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; typename THcpCmds::HCP_TILE_STATE_CMD cmd; MHW_MI_CHK_NULL(m_osInterface); MHW_MI_CHK_NULL(params); MHW_MI_CHK_NULL(params->pTileColWidth); MHW_MI_CHK_NULL(params->pTileRowHeight); auto hevcPicParams = params->pHevcPicParams; uint32_t colCumulativeValue = 0; uint32_t rowCumulativeValue = 0; MHW_ASSERT(hevcPicParams->num_tile_rows_minus1 < HEVC_NUM_MAX_TILE_ROW); MHW_ASSERT(hevcPicParams->num_tile_columns_minus1 < HEVC_NUM_MAX_TILE_COLUMN); cmd.DW1.Numtilecolumnsminus1 = hevcPicParams->num_tile_columns_minus1; cmd.DW1.Numtilerowsminus1 = hevcPicParams->num_tile_rows_minus1; for (uint8_t i = 0; i < 5; i++) { cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos0I = colCumulativeValue; if ((4 * i) == hevcPicParams->num_tile_columns_minus1) { break; } colCumulativeValue += params->pTileColWidth[4 * i]; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos1I = colCumulativeValue; if ((4 * i + 1) == hevcPicParams->num_tile_columns_minus1) { break; } colCumulativeValue += params->pTileColWidth[4 * i + 1]; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos2I = colCumulativeValue; if ((4 * i + 2) == hevcPicParams->num_tile_columns_minus1) { break; } colCumulativeValue += params->pTileColWidth[4 * i + 2]; cmd.CtbColumnPositionOfTileColumn[i].DW0.Ctbpos3I = colCumulativeValue; if ((4 * i + 3) == hevcPicParams->num_tile_columns_minus1) { break; } colCumulativeValue += params->pTileColWidth[4 * i + 3]; } for (uint8_t i = 0; i < 5; i++) { cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos0I = rowCumulativeValue; if ((4 * i) == hevcPicParams->num_tile_rows_minus1) { break; } rowCumulativeValue += params->pTileRowHeight[4 * i]; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos1I = rowCumulativeValue; if ((4 * i + 1) == hevcPicParams->num_tile_rows_minus1) { break; } rowCumulativeValue += params->pTileRowHeight[4 * i + 1]; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos2I = rowCumulativeValue; if ((4 * i + 2) == hevcPicParams->num_tile_rows_minus1) { break; } rowCumulativeValue += params->pTileRowHeight[4 * i + 2]; cmd.CtbRowPositionOfTileRow[i].DW0.Ctbpos3I = rowCumulativeValue; if ((4 * i + 3) == hevcPicParams->num_tile_rows_minus1) { break; } rowCumulativeValue += params->pTileRowHeight[4 * i + 3]; } if (hevcPicParams->num_tile_rows_minus1 == 20) { cmd.CtbRowPositionOfTileRow[5].DW0.Ctbpos0I = rowCumulativeValue; } if (hevcPicParams->num_tile_rows_minus1 == 21) { cmd.CtbRowPositionOfTileRow[5].DW0.Ctbpos0I = rowCumulativeValue; rowCumulativeValue += params->pTileRowHeight[20]; cmd.CtbRowPositionOfTileRow[5].DW0.Ctbpos1I = rowCumulativeValue; } MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpRefIdxStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_BATCH_BUFFER batchBuffer, PMHW_VDBOX_HEVC_REF_IDX_PARAMS params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(params); typename THcpCmds::HCP_REF_IDX_STATE_CMD cmd; // Need to add an empty HCP_REF_IDX_STATE_CMD for dummy reference on I-Frame // ucNumRefForList could be 0 for encode if (!params->bDummyReference) { MHW_ASSERT(params->CurrPic.FrameIdx != 0x7F); cmd.DW1.Refpiclistnum = params->ucList; cmd.DW1.NumRefIdxLRefpiclistnumActiveMinus1 = params->ucNumRefForList - 1; for (uint8_t i = 0; i < params->ucNumRefForList; i++) { uint8_t refFrameIDx = params->RefPicList[params->ucList][i].FrameIdx; if (refFrameIDx < CODEC_MAX_NUM_REF_FRAME_HEVC) { MHW_ASSERT(*(params->pRefIdxMapping + refFrameIDx) >= 0); cmd.Entries[i].DW0.ListEntryLxReferencePictureFrameIdRefaddr07 = *(params->pRefIdxMapping + refFrameIDx); int32_t pocDiff = params->poc_curr_pic - params->poc_list[refFrameIDx]; cmd.Entries[i].DW0.ReferencePictureTbValue = CodecHal_Clip3(-128, 127, pocDiff); CODEC_REF_LIST** refList = (CODEC_REF_LIST**)params->hevcRefList; cmd.Entries[i].DW0.Longtermreference = CodecHal_PictureIsLongTermRef(refList[params->CurrPic.FrameIdx]->RefList[refFrameIDx]); cmd.Entries[i].DW0.FieldPicFlag = (params->RefFieldPicFlag >> refFrameIDx) & 0x01; cmd.Entries[i].DW0.BottomFieldFlag = ((params->RefBottomFieldFlag >> refFrameIDx) & 0x01) ? 0 : 1; } else { cmd.Entries[i].DW0.ListEntryLxReferencePictureFrameIdRefaddr07 = 0; cmd.Entries[i].DW0.ReferencePictureTbValue = 0; cmd.Entries[i].DW0.Longtermreference = false; cmd.Entries[i].DW0.FieldPicFlag = 0; cmd.Entries[i].DW0.BottomFieldFlag = 0; } } for (uint8_t i = (uint8_t)params->ucNumRefForList; i < 16; i++) { cmd.Entries[i].DW0.Value = 0x00; } } if (cmdBuffer == nullptr && batchBuffer == nullptr) { MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to."); return MOS_STATUS_INVALID_PARAMETER; } MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpWeightOffsetStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_BATCH_BUFFER batchBuffer, PMHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS params) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(params); typename THcpCmds::HCP_WEIGHTOFFSET_STATE_CMD cmd; uint8_t i = 0; cmd.DW1.Refpiclistnum = i = params->ucList; // Luma for (uint8_t refIdx = 0; refIdx < CODEC_MAX_NUM_REF_FRAME_HEVC; refIdx++) { cmd.Lumaoffsets[refIdx].DW0.DeltaLumaWeightLxI = params->LumaWeights[i][refIdx]; cmd.Lumaoffsets[refIdx].DW0.LumaOffsetLxI = params->LumaOffsets[i][refIdx]; } // Chroma for (uint8_t refIdx = 0; refIdx < CODEC_MAX_NUM_REF_FRAME_HEVC; refIdx++) { cmd.Chromaoffsets[refIdx].DW0.DeltaChromaWeightLxI0 = params->ChromaWeights[i][refIdx][0]; cmd.Chromaoffsets[refIdx].DW0.ChromaoffsetlxI0 = params->ChromaOffsets[i][refIdx][0]; cmd.Chromaoffsets[refIdx].DW0.DeltaChromaWeightLxI1 = params->ChromaWeights[i][refIdx][1]; cmd.Chromaoffsets[refIdx].DW0.ChromaoffsetlxI1 = params->ChromaOffsets[i][refIdx][1]; } //cmd.DW2[15] and cmd.DW18[15] not be used if (cmdBuffer == nullptr && batchBuffer == nullptr) { MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to."); return MOS_STATUS_INVALID_PARAMETER; } MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpDecodeSliceStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(m_osInterface); MHW_MI_CHK_NULL(hevcSliceState); typename THcpCmds::HCP_SLICE_STATE_CMD cmd; auto hevcSliceParams = hevcSliceState->pHevcSliceParams; auto hevcPicParams = hevcSliceState->pHevcPicParams; uint32_t ctbSize = 1 << (hevcPicParams->log2_diff_max_min_luma_coding_block_size + hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3); uint32_t widthInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicWidthInMinCbsY); uint32_t widthInCtb = MOS_ROUNDUP_DIVIDE(widthInPix, ctbSize); // It is a hardware requirement that the first HCP_SLICE_STATE of the workload starts at LCU X,Y = 0,0. // If first slice doesn't starts from (0,0), that means this is error bitstream. if (hevcSliceState->dwSliceIndex == 0) { cmd.DW1.SlicestartctbxOrSliceStartLcuXEncoder = 0; cmd.DW1.SlicestartctbyOrSliceStartLcuYEncoder = 0; } else { cmd.DW1.SlicestartctbxOrSliceStartLcuXEncoder = hevcSliceParams->slice_segment_address % widthInCtb; cmd.DW1.SlicestartctbyOrSliceStartLcuYEncoder = hevcSliceParams->slice_segment_address / widthInCtb; } if (hevcSliceState->bLastSlice) { cmd.DW2.NextslicestartctbxOrNextSliceStartLcuXEncoder = 0; cmd.DW2.NextslicestartctbyOrNextSliceStartLcuYEncoder = 0; } else { cmd.DW2.NextslicestartctbxOrNextSliceStartLcuXEncoder = (hevcSliceParams + 1)->slice_segment_address % widthInCtb; cmd.DW2.NextslicestartctbyOrNextSliceStartLcuYEncoder = (hevcSliceParams + 1)->slice_segment_address / widthInCtb; } cmd.DW3.SliceType = hevcSliceParams->LongSliceFlags.fields.slice_type; cmd.DW3.Lastsliceofpic = hevcSliceState->bLastSlice; cmd.DW3.DependentSliceFlag = hevcSliceParams->LongSliceFlags.fields.dependent_slice_segment_flag; cmd.DW3.SliceTemporalMvpEnableFlag = hevcSliceParams->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag; cmd.DW3.SliceCbQpOffset = hevcSliceParams->slice_cb_qp_offset; cmd.DW3.SliceCrQpOffset = hevcSliceParams->slice_cr_qp_offset; cmd.DW4.SliceHeaderDisableDeblockingFilterFlag = hevcSliceParams->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag; cmd.DW4.SliceTcOffsetDiv2OrFinalTcOffsetDiv2Encoder = hevcSliceParams->slice_tc_offset_div2; cmd.DW4.SliceBetaOffsetDiv2OrFinalBetaOffsetDiv2Encoder = hevcSliceParams->slice_beta_offset_div2; cmd.DW4.SliceLoopFilterAcrossSlicesEnabledFlag = hevcSliceParams->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag; cmd.DW4.SliceSaoChromaFlag = hevcSliceParams->LongSliceFlags.fields.slice_sao_chroma_flag; cmd.DW4.SliceSaoLumaFlag = hevcSliceParams->LongSliceFlags.fields.slice_sao_luma_flag; cmd.DW4.MvdL1ZeroFlag = hevcSliceParams->LongSliceFlags.fields.mvd_l1_zero_flag; uint8_t isLowDelay = 1; if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_I_SLICE) { isLowDelay = 0; } else { for (uint8_t i = 0; i < hevcSliceParams->num_ref_idx_l0_active_minus1 + 1; i++) { uint8_t refFrameID = hevcSliceParams->RefPicList[0][i].FrameIdx; if (hevcPicParams->PicOrderCntValList[refFrameID] > hevcPicParams->CurrPicOrderCntVal) { isLowDelay = 0; break; } } if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_B_SLICE) { for (uint8_t i = 0; i < hevcSliceParams->num_ref_idx_l1_active_minus1 + 1; i++) { uint8_t refFrameID = hevcSliceParams->RefPicList[1][i].FrameIdx; if (hevcPicParams->PicOrderCntValList[refFrameID] > hevcPicParams->CurrPicOrderCntVal) { isLowDelay = 0; break; } } } } cmd.DW4.Islowdelay = isLowDelay & 0x1; cmd.DW4.CollocatedFromL0Flag = hevcSliceParams->LongSliceFlags.fields.collocated_from_l0_flag; cmd.DW4.Chromalog2Weightdenom = hevcSliceParams->luma_log2_weight_denom + hevcSliceParams->delta_chroma_log2_weight_denom; cmd.DW4.LumaLog2WeightDenom = hevcSliceParams->luma_log2_weight_denom; cmd.DW4.CabacInitFlag = hevcSliceParams->LongSliceFlags.fields.cabac_init_flag; cmd.DW4.Maxmergeidx = 5 - hevcSliceParams->five_minus_max_num_merge_cand - 1; uint8_t collocatedRefIndex, collocatedFrameIdx, collocatedFromL0Flag; if (hevcSliceParams->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag == 1) { //Get Collocated Picture POC collocatedRefIndex = hevcSliceParams->collocated_ref_idx; collocatedFrameIdx = 0; collocatedFromL0Flag = hevcSliceParams->LongSliceFlags.fields.collocated_from_l0_flag; if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_P_SLICE) { collocatedFrameIdx = hevcSliceParams->RefPicList[0][collocatedRefIndex].FrameIdx; } else if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_B_SLICE) { collocatedFrameIdx = hevcSliceParams->RefPicList[!collocatedFromL0Flag][collocatedRefIndex].FrameIdx; } if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_I_SLICE) { cmd.DW4.Collocatedrefidx = 0; } else { MHW_CHK_COND(*(hevcSliceState->pRefIdxMapping + collocatedFrameIdx) < 0, "Invalid parameter"); cmd.DW4.Collocatedrefidx = *(hevcSliceState->pRefIdxMapping + collocatedFrameIdx); } } else { cmd.DW4.Collocatedrefidx = 0; } static uint8_t ucFirstInterSliceCollocatedFrameIdx; static uint8_t ucFirstInterSliceCollocatedFromL0Flag; static bool bFinishFirstInterSlice; //Need to save the first interSlice collocatedRefIdx value to use on subsequent intra slices //this is a HW requrement as collcoated ref fetching from memory may not be complete yet if (hevcSliceState->dwSliceIndex == 0) { ucFirstInterSliceCollocatedFrameIdx = 0; ucFirstInterSliceCollocatedFromL0Flag = 0; bFinishFirstInterSlice = false; } if ((!bFinishFirstInterSlice) && (hevcSliceParams->LongSliceFlags.fields.slice_type != cmd.SLICE_TYPE_I_SLICE) && (hevcSliceParams->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag == 1)) { ucFirstInterSliceCollocatedFrameIdx = cmd.DW4.Collocatedrefidx; ucFirstInterSliceCollocatedFromL0Flag = cmd.DW4.CollocatedFromL0Flag; bFinishFirstInterSlice = true; } if (bFinishFirstInterSlice && ((hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_I_SLICE) || (hevcSliceParams->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag == 0))) { cmd.DW4.Collocatedrefidx = ucFirstInterSliceCollocatedFrameIdx; cmd.DW4.CollocatedFromL0Flag = ucFirstInterSliceCollocatedFromL0Flag; } cmd.DW5.Sliceheaderlength = hevcSliceParams->ByteOffsetToSliceData; MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpEncodeSliceStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(cmdBuffer); MHW_MI_CHK_NULL(m_osInterface); MHW_MI_CHK_NULL(hevcSliceState); typename THcpCmds::HCP_SLICE_STATE_CMD cmd; auto hevcSliceParams = hevcSliceState->pHevcSliceParams; auto hevcPicParams = hevcSliceState->pHevcPicParams; uint32_t ctbSize = 1 << (hevcPicParams->log2_diff_max_min_luma_coding_block_size + hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3); uint32_t widthInPix = (1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3)) * (hevcPicParams->PicWidthInMinCbsY); uint32_t widthInCtb = MOS_ROUNDUP_DIVIDE(widthInPix, ctbSize); // It is a hardware requirement that the first HCP_SLICE_STATE of the workload starts at LCU X,Y = 0,0. // If first slice doesn't starts from (0,0), that means this is error bitstream. if (hevcSliceState->dwSliceIndex == 0) { cmd.DW1.SlicestartctbxOrSliceStartLcuXEncoder = 0; cmd.DW1.SlicestartctbyOrSliceStartLcuYEncoder = 0; } else { cmd.DW1.SlicestartctbxOrSliceStartLcuXEncoder = hevcSliceParams->slice_segment_address % widthInCtb; cmd.DW1.SlicestartctbyOrSliceStartLcuYEncoder = hevcSliceParams->slice_segment_address / widthInCtb; } if (hevcSliceState->bLastSlice) { cmd.DW2.NextslicestartctbxOrNextSliceStartLcuXEncoder = 0; cmd.DW2.NextslicestartctbyOrNextSliceStartLcuYEncoder = 0; } else { cmd.DW2.NextslicestartctbxOrNextSliceStartLcuXEncoder = (hevcSliceParams + 1)->slice_segment_address % widthInCtb; cmd.DW2.NextslicestartctbyOrNextSliceStartLcuYEncoder = (hevcSliceParams + 1)->slice_segment_address / widthInCtb; } cmd.DW3.SliceType = hevcSliceParams->LongSliceFlags.fields.slice_type; cmd.DW3.Lastsliceofpic = hevcSliceState->bLastSlice; cmd.DW3.DependentSliceFlag = hevcSliceParams->LongSliceFlags.fields.dependent_slice_segment_flag; cmd.DW3.SliceTemporalMvpEnableFlag = hevcSliceParams->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag; cmd.DW3.Sliceqp = hevcSliceParams->slice_qp_delta + hevcPicParams->init_qp_minus26 + 26; cmd.DW3.SliceCbQpOffset = hevcSliceParams->slice_cb_qp_offset; cmd.DW3.SliceCrQpOffset = hevcSliceParams->slice_cr_qp_offset; cmd.DW4.SliceHeaderDisableDeblockingFilterFlag = hevcSliceParams->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag; cmd.DW4.SliceTcOffsetDiv2OrFinalTcOffsetDiv2Encoder = hevcSliceParams->slice_tc_offset_div2; cmd.DW4.SliceBetaOffsetDiv2OrFinalBetaOffsetDiv2Encoder = hevcSliceParams->slice_beta_offset_div2; cmd.DW4.SliceLoopFilterAcrossSlicesEnabledFlag = hevcSliceParams->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag; cmd.DW4.SliceSaoChromaFlag = hevcSliceParams->LongSliceFlags.fields.slice_sao_chroma_flag; cmd.DW4.SliceSaoLumaFlag = hevcSliceParams->LongSliceFlags.fields.slice_sao_luma_flag; cmd.DW4.MvdL1ZeroFlag = hevcSliceParams->LongSliceFlags.fields.mvd_l1_zero_flag; uint32_t numNegativePic = 0; uint32_t numPositivePic = 0; if (hevcSliceParams->LongSliceFlags.fields.slice_type != cmd.SLICE_TYPE_I_SLICE) { for (uint8_t i = 0; i < hevcSliceParams->num_ref_idx_l0_active_minus1 + 1; i++) { uint8_t refFrameID = hevcSliceParams->RefPicList[0][i].FrameIdx; int32_t pocDiff = hevcPicParams->CurrPicOrderCntVal - hevcPicParams->PicOrderCntValList[refFrameID]; if (pocDiff > 0) { numNegativePic++; } } } else { numNegativePic = 0; } if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_B_SLICE) { for (uint8_t i = 0; i < hevcSliceParams->num_ref_idx_l1_active_minus1 + 1; i++) { uint8_t refFrameID = hevcSliceParams->RefPicList[1][i].FrameIdx; int32_t pocDiff = hevcPicParams->CurrPicOrderCntVal - hevcPicParams->PicOrderCntValList[refFrameID]; if (pocDiff < 0) { numPositivePic++; } } } else { numPositivePic = 0; } if ((numNegativePic == (hevcSliceParams->num_ref_idx_l0_active_minus1 + 1)) && (numPositivePic == 0)) { cmd.DW4.Islowdelay = 1; } else { cmd.DW4.Islowdelay = 0; } cmd.DW4.CollocatedFromL0Flag = hevcSliceParams->LongSliceFlags.fields.collocated_from_l0_flag; cmd.DW4.Chromalog2Weightdenom = (hevcPicParams->weighted_pred_flag || hevcPicParams->weighted_bipred_flag) ? (hevcSliceParams->luma_log2_weight_denom + hevcSliceParams->delta_chroma_log2_weight_denom) : 0; cmd.DW4.LumaLog2WeightDenom = (hevcPicParams->weighted_pred_flag || hevcPicParams->weighted_bipred_flag) ? hevcSliceParams->luma_log2_weight_denom : 0; cmd.DW4.CabacInitFlag = hevcSliceParams->LongSliceFlags.fields.cabac_init_flag; cmd.DW4.Maxmergeidx = 5 - hevcSliceParams->five_minus_max_num_merge_cand - 1; uint8_t collocatedRefIndex, collocatedFrameIdx, collocatedFromL0Flag; if (hevcSliceParams->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag == 1) { //Get Collocated Picture POC collocatedRefIndex = hevcSliceParams->collocated_ref_idx; collocatedFrameIdx = 0; collocatedFromL0Flag = hevcSliceParams->LongSliceFlags.fields.collocated_from_l0_flag; if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_P_SLICE) { collocatedFrameIdx = hevcSliceParams->RefPicList[0][collocatedRefIndex].FrameIdx; } else if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_B_SLICE) { collocatedFrameIdx = hevcSliceParams->RefPicList[!collocatedFromL0Flag][collocatedRefIndex].FrameIdx; } if (hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_I_SLICE) { cmd.DW4.Collocatedrefidx = 0; } else { MHW_CHK_COND(*(hevcSliceState->pRefIdxMapping + collocatedFrameIdx) < 0, "Invalid parameter"); cmd.DW4.Collocatedrefidx = *(hevcSliceState->pRefIdxMapping + collocatedFrameIdx); } } else { cmd.DW4.Collocatedrefidx = 0; } static uint8_t ucFirstInterSliceCollocatedFrameIdx; static uint8_t ucFirstInterSliceCollocatedFromL0Flag; static bool bFinishFirstInterSlice; //Need to save the first interSlice collocatedRefIdx value to use on subsequent intra slices //this is a HW requrement as collcoated ref fetching from memory may not be complete yet if (hevcSliceState->dwSliceIndex == 0) { ucFirstInterSliceCollocatedFrameIdx = 0; ucFirstInterSliceCollocatedFromL0Flag = 0; bFinishFirstInterSlice = false; } if ((!bFinishFirstInterSlice) && (hevcSliceParams->LongSliceFlags.fields.slice_type != cmd.SLICE_TYPE_I_SLICE) && (hevcSliceParams->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag == 1)) { ucFirstInterSliceCollocatedFrameIdx = cmd.DW4.Collocatedrefidx; ucFirstInterSliceCollocatedFromL0Flag = cmd.DW4.CollocatedFromL0Flag; bFinishFirstInterSlice = true; } if (bFinishFirstInterSlice && ((hevcSliceParams->LongSliceFlags.fields.slice_type == cmd.SLICE_TYPE_I_SLICE) || (hevcSliceParams->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag == 0))) { cmd.DW4.Collocatedrefidx = ucFirstInterSliceCollocatedFrameIdx; cmd.DW4.CollocatedFromL0Flag = ucFirstInterSliceCollocatedFromL0Flag; } cmd.DW5.Sliceheaderlength = hevcSliceParams->ByteOffsetToSliceData; MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize)); return eStatus; } MOS_STATUS AddHcpDecodeProtectStateCmd( PMOS_COMMAND_BUFFER cmdBuffer, PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(hevcSliceState); MHW_CP_SLICE_INFO_PARAMS sliceInfoParam; sliceInfoParam.presDataBuffer = hevcSliceState->presDataBuffer; sliceInfoParam.dwSliceIndex = hevcSliceState->dwSliceIndex; sliceInfoParam.dwTotalBytesConsumed = 0; sliceInfoParam.bLastPass = hevcSliceState->bLastSlice; sliceInfoParam.dwDataStartOffset[0] = hevcSliceState->pHevcSliceParams->slice_data_offset + hevcSliceState->dwOffset; sliceInfoParam.dwDataStartOffset[1] = hevcSliceState->pHevcSliceParams->slice_data_offset + hevcSliceState->dwOffset; sliceInfoParam.dwDataLength[0] = hevcSliceState->pHevcSliceParams->slice_data_size; sliceInfoParam.dwDataLength[1] = hevcSliceState->pHevcSliceParams->slice_data_size; MHW_MI_CHK_STATUS(m_cpInterface->SetHcpProtectionState( true, cmdBuffer, nullptr, &sliceInfoParam)); return eStatus; } }; #endif