/* * Copyright (c) 2017, 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 media_ddi_encode_fei_avc.cpp //! \brief Implements class for DDI media avc fei encode //! #include "media_libva.h" #include "media_libva_encoder.h" #include "media_libva_util.h" #include "hwinfo_linux.h" #include "media_ddi_encode_base.h" #include "media_ddi_encode_fei_avc.h" #include "media_ddi_encode_const.h" #include "media_ddi_factory.h" static const uint8_t feiMaxPassesNum = 4; extern template class MediaDdiFactoryNoArg; static bool isEncodeAvcFeiRegistered = MediaDdiFactoryNoArg::RegisterCodec(ENCODE_ID_AVCFEI); DdiEncodeAvcFei::~DdiEncodeAvcFei() { if (nullptr == m_encodeCtx) { return; } MOS_FreeMemory(m_encodeCtx->pFeiPicParams); m_encodeCtx->pFeiPicParams = nullptr; MOS_FreeMemory(m_encodeCtx->pPreEncParams); m_encodeCtx->pPreEncParams = nullptr; MOS_FreeMemory(iqMatrixParams); iqMatrixParams = nullptr; MOS_FreeMemory(iqWeightScaleLists); iqWeightScaleLists = nullptr; } VAStatus DdiEncodeAvcFei::ContextInitialize(CodechalSetting * codecHalSettings) { VAStatus status = DdiEncodeAvc::ContextInitialize(codecHalSettings); if (VA_STATUS_SUCCESS != status) { return status; } codecHalSettings->codecFunction = m_encodeCtx->codecFunction; m_encodeCtx->pFeiPicParams = (void *)MOS_AllocAndZeroMemory(CODEC_AVC_MAX_PPS_NUM * sizeof(CodecEncodeAvcFeiPicParams)); DDI_CHK_NULL(m_encodeCtx->pFeiPicParams, "nullptr m_encodeCtx->pFeiPicParams", VA_STATUS_ERROR_ALLOCATION_FAILED); m_encodeCtx->pPreEncParams = (void *)MOS_AllocAndZeroMemory(CODEC_AVC_MAX_PPS_NUM * sizeof(FeiPreEncParams)); DDI_CHK_NULL(m_encodeCtx->pPreEncParams, "nullptr m_encodeCtx->pPreEncParams", VA_STATUS_ERROR_ALLOCATION_FAILED); iqMatrixParams = (PCODEC_AVC_IQ_MATRIX_PARAMS)MOS_AllocAndZeroMemory(sizeof(CODEC_AVC_IQ_MATRIX_PARAMS)); DDI_CHK_NULL(iqMatrixParams, "nullptr iqMatrixParams", VA_STATUS_ERROR_ALLOCATION_FAILED); iqWeightScaleLists = (PCODEC_AVC_ENCODE_IQ_WEIGTHSCALE_LISTS)MOS_AllocAndZeroMemory(sizeof(CODEC_AVC_ENCODE_IQ_WEIGTHSCALE_LISTS)); DDI_CHK_NULL(iqWeightScaleLists, "nullptr iqWeightScaleLists", VA_STATUS_ERROR_ALLOCATION_FAILED); return VA_STATUS_SUCCESS; } VAStatus DdiEncodeAvcFei::EncodeInCodecHal(uint32_t numSlices) { uint8_t ppsIdx, spsIdx; PCODEC_AVC_ENCODE_PIC_PARAMS picParams; DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_CONTEXT); DDI_CHK_NULL(m_encodeCtx->pCodecHal, "nullptr m_encodeCtx->pCodecHal", VA_STATUS_ERROR_INVALID_CONTEXT); DDI_CHK_NULL(m_encodeCtx->pMediaCtx, "nullptr m_encodeCtx->pMediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT); CodecEncodeAvcFeiPicParams *feiPicParams = (CodecEncodeAvcFeiPicParams *)(m_encodeCtx->pFeiPicParams); FeiPreEncParams *preEncParams = (FeiPreEncParams*)(m_encodeCtx->pPreEncParams); DDI_CODEC_RENDER_TARGET_TABLE *rtTbl = &(m_encodeCtx->RTtbl); MOS_STATUS status; EncoderParams *encodeParams = &m_encodeCtx->EncodeParams; MOS_ZeroMemory(encodeParams, sizeof(EncoderParams)); if ((feiPicParams != nullptr) && CodecHalIsFeiEncode(m_encodeCtx->codecFunction)) { encodeParams->ExecCodecFunction = m_encodeCtx->codecFunction; } else if (m_encodeCtx->codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC) { encodeParams->ExecCodecFunction = m_encodeCtx->codecFunction; } else { encodeParams->ExecCodecFunction = CODECHAL_FUNCTION_ENC_PAK; } // Raw Surface PMOS_SURFACE rawSurface = &encodeParams->rawSurface; rawSurface->Format = Format_NV12; rawSurface->dwOffset = 0; DdiMedia_MediaSurfaceToMosResource(rtTbl->pCurrentRT, &(rawSurface->OsResource)); if (m_encodeCtx->codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC) { if (rtTbl->pRT[preEncParams->CurrOriginalPicture.FrameIdx] != rtTbl->pCurrentRT) { DDI_ASSERTMESSAGE("PREENC CurrOriginalPicture.FrameIdx != pCurrentRT"); } rawSurface->dwWidth = rawSurface->OsResource.iWidth; rawSurface->dwHeight = rawSurface->OsResource.iHeight; rawSurface->dwPitch = rawSurface->OsResource.iPitch; rawSurface->TileType = rawSurface->OsResource.TileType; rawSurface->TileModeGMM = rawSurface->OsResource.TileModeGMM; rawSurface->bGMMTileEnabled = rawSurface->OsResource.bGMMTileEnabled; preEncParams->psCurrOriginalSurface = rawSurface; encodeParams->pPreEncParams = m_encodeCtx->pPreEncParams; DDI_CHK_RET(ClearRefList(&m_encodeCtx->RTtbl, false), "ClearRefList failed!"); } else { // Recon Surface PMOS_SURFACE reconSurface = &encodeParams->reconSurface; reconSurface->Format = Format_NV12; reconSurface->dwOffset = 0; DdiMedia_MediaSurfaceToMosResource(rtTbl->pCurrentReconTarget, &(reconSurface->OsResource)); // Bitstream surface PMOS_RESOURCE bitstreamSurface = &encodeParams->resBitstreamBuffer; *bitstreamSurface = m_encodeCtx->resBitstreamBuffer; // in render picture bitstreamSurface->Format = Format_Buffer; encodeParams->psRawSurface = &encodeParams->rawSurface; encodeParams->psReconSurface = &encodeParams->reconSurface; encodeParams->presBitstreamBuffer = &encodeParams->resBitstreamBuffer; PMOS_SURFACE mbQpSurface = &encodeParams->mbQpSurface; if (m_encodeCtx->bMBQpEnable) { mbQpSurface->Format = Format_Buffer_2D; mbQpSurface->dwOffset = 0; mbQpSurface->OsResource = m_encodeCtx->resMBQpBuffer; encodeParams->psMbQpDataSurface = &encodeParams->mbQpSurface; encodeParams->bMbQpDataEnabled = true; } PMOS_SURFACE disableSkipMapSurface = &encodeParams->disableSkipMapSurface; encodeParams->bMbDisableSkipMapEnabled = m_encodeCtx->bMbDisableSkipMapEnabled; if (encodeParams->bMbDisableSkipMapEnabled) { disableSkipMapSurface->Format = Format_Buffer; disableSkipMapSurface->dwOffset = 0; disableSkipMapSurface->OsResource = m_encodeCtx->resPerMBSkipMapBuffer; encodeParams->psMbDisableSkipMapSurface = &encodeParams->disableSkipMapSurface; } // correct some params if (CODECHAL_ENCODE_MODE_AVC == m_encodeCtx->wModeType) { PCODEC_AVC_ENCODE_SEQUENCE_PARAMS seqParams; CODECHAL_ENCODE_AVC_VUI_PARAMS *vuiParam; vuiParam = (CODECHAL_ENCODE_AVC_VUI_PARAMS *)m_encodeCtx->pVuiParams; seqParams = (PCODEC_AVC_ENCODE_SEQUENCE_PARAMS)(m_encodeCtx->pSeqParams); if (VA_RC_CQP == m_encodeCtx->uiRCMethod) { vuiParam->bit_rate_value_minus1[0] = 0; vuiParam->cpb_size_value_minus1[0] = 0; seqParams->TargetBitRate = 0; seqParams->MaxBitRate = 0; seqParams->MinBitRate = 0; seqParams->InitVBVBufferFullnessInBit = 0; seqParams->VBVBufferSizeInBit = 0; } encodeParams->uiSlcStructCaps = CODECHAL_SLICE_STRUCT_ARBITRARYMBSLICE; } ppsIdx = ((PCODEC_AVC_ENCODE_SLICE_PARAMS)(m_encodeCtx->pSliceParams))->pic_parameter_set_id; picParams = (PCODEC_AVC_ENCODE_PIC_PARAMS)m_encodeCtx->pPicParams + ppsIdx; spsIdx = picParams->seq_parameter_set_id; encodeParams->pSeqParams = (PCODEC_AVC_ENCODE_SEQUENCE_PARAMS)m_encodeCtx->pSeqParams + spsIdx; encodeParams->pPicParams = picParams; encodeParams->pVuiParams = m_encodeCtx->pVuiParams; encodeParams->pSliceParams = m_encodeCtx->pSliceParams; encodeParams->pAVCQCParams = m_qcParams; encodeParams->pAVCRoundingParams = m_roundingParams; // Sequence data encodeParams->bNewSeq = m_encodeCtx->bNewSeq; // VUI encodeParams->bNewVuiData = m_encodeCtx->bNewVuiData; // Slice level data encodeParams->dwNumSlices = numSlices; // IQmatrix params encodeParams->bNewQmatrixData = m_encodeCtx->bNewQmatrixData; encodeParams->bPicQuant = m_encodeCtx->bPicQuant; encodeParams->ppNALUnitParams = m_encodeCtx->ppNALUnitParams; encodeParams->pSeiData = m_encodeCtx->pSEIFromApp; encodeParams->pSeiParamBuffer = m_encodeCtx->pSEIFromApp->pSEIBuffer; encodeParams->dwSEIDataOffset = 0; status = MOS_SecureMemcpy(&iqMatrixParams->ScalingList4x4, 6 * 16 * sizeof(uint8_t), &m_scalingLists4x4, 6 * 16 * sizeof(uint8_t)); if (MOS_STATUS_SUCCESS != status) { DDI_ASSERTMESSAGE("DDI:Failed to copy scaling list 4x4!"); return VA_STATUS_ERROR_INVALID_PARAMETER; } status = MOS_SecureMemcpy(&iqMatrixParams->ScalingList8x8, 2 * 64 * sizeof(uint8_t), &m_scalingLists8x8, 2 * 64 * sizeof(uint8_t)); if (MOS_STATUS_SUCCESS != status) { DDI_ASSERTMESSAGE("DDI:Failed to copy scaling list 8x8!"); return VA_STATUS_ERROR_INVALID_PARAMETER; } encodeParams->pIQMatrixBuffer = iqMatrixParams; status = MOS_SecureMemcpy(&iqWeightScaleLists->WeightScale4x4, (CODEC_AVC_WEIGHT_SCALE_4x4 * sizeof(uint32_t)), &m_weightScale4x4, (CODEC_AVC_WEIGHT_SCALE_4x4 * sizeof(uint32_t))); if (MOS_STATUS_SUCCESS != status) { DDI_ASSERTMESSAGE("DDI:Failed to copy weight scale list 4x4!"); return VA_STATUS_ERROR_INVALID_PARAMETER; } status = MOS_SecureMemcpy(&iqWeightScaleLists->WeightScale8x8, (CODEC_AVC_WEIGHT_SCALE_8x8 * sizeof(uint32_t)), &m_weightScale8x8, (CODEC_AVC_WEIGHT_SCALE_8x8 * sizeof(uint32_t))); if (MOS_STATUS_SUCCESS != status) { DDI_ASSERTMESSAGE("DDI:Failed to copy weight scale list 8x8!"); return VA_STATUS_ERROR_INVALID_PARAMETER; } encodeParams->pIQWeightScaleLists = iqWeightScaleLists; // whether driver need to pack slice header if (true == m_encodeCtx->bHavePackedSliceHdr) { encodeParams->bAcceleratorHeaderPackingCaps = false; } else { encodeParams->bAcceleratorHeaderPackingCaps = true; } encodeParams->pBSBuffer = m_encodeCtx->pbsBuffer; encodeParams->pSlcHeaderData = (void *)m_encodeCtx->pSliceHeaderData; encodeParams->pFeiPicParams = (CodecEncodeAvcFeiPicParams *)(m_encodeCtx->pFeiPicParams); //clear registered recon/ref surface flags DDI_CHK_RET(ClearRefList(&m_encodeCtx->RTtbl, true), "ClearRefList failed!"); } CodechalEncoderState *encoder = dynamic_cast(m_encodeCtx->pCodecHal); DDI_CHK_NULL(encoder, "nullptr Codechal encode", VA_STATUS_ERROR_INVALID_PARAMETER); if (!encoder->m_mfeEnabled) { status = m_encodeCtx->pCodecHal->Execute(encodeParams); if (MOS_STATUS_SUCCESS != status) { DDI_ASSERTMESSAGE("DDI:Failed in Codechal!"); return VA_STATUS_ERROR_ENCODING_ERROR; } } return VA_STATUS_SUCCESS; } VAStatus DdiEncodeAvcFei::ResetAtFrameLevel() { DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER); DDI_CHK_NULL(m_encodeCtx->pFeiPicParams, "nullptr m_encodeCtx->pFeiPicParams", VA_STATUS_ERROR_INVALID_PARAMETER); DDI_CHK_NULL(m_encodeCtx->pPreEncParams, "nullptr m_encodeCtx->pPreEncParams", VA_STATUS_ERROR_INVALID_PARAMETER); // Assume there is only one SPS parameter PCODEC_AVC_ENCODE_SEQUENCE_PARAMS seqParams = (PCODEC_AVC_ENCODE_SEQUENCE_PARAMS)(m_encodeCtx->pSeqParams); seqParams->bInitBRC = 0x0; seqParams->bResetBRC = 0x0; CodecEncodeAvcFeiPicParams *feiPicParams = (CodecEncodeAvcFeiPicParams *)(m_encodeCtx->pFeiPicParams); FeiPreEncParams *preEncParams = (FeiPreEncParams*)(m_encodeCtx->pPreEncParams); m_encodeCtx->dwNumSlices = 0x0; m_encodeCtx->indexNALUnit = 0x0; m_encodeCtx->uiSliceHeaderCnt = 0x0; // reset bsbuffer every frame m_encodeCtx->pbsBuffer->pCurrent = m_encodeCtx->pbsBuffer->pBase; m_encodeCtx->pbsBuffer->SliceOffset = 0x0; m_encodeCtx->pbsBuffer->BitOffset = 0x0; m_encodeCtx->pbsBuffer->BitSize = 0x0; // clear the packed header information if (nullptr != m_encodeCtx->ppNALUnitParams) { MOS_ZeroMemory(m_encodeCtx->ppNALUnitParams[0], sizeof(CODECHAL_NAL_UNIT_PARAMS) * CODECHAL_ENCODE_AVC_MAX_NAL_TYPE); } m_encodeCtx->bHavePackedSliceHdr = false; m_encodeCtx->bLastPackedHdrIsSlice = false; m_encodeCtx->bMbDisableSkipMapEnabled = false; m_encodeCtx->bMBQpEnable = false; if (nullptr != m_roundingParams) { MOS_ZeroMemory(m_roundingParams, sizeof(CODECHAL_ENCODE_AVC_ROUNDING_PARAMS)); } if (CodecHalIsFeiEncode(m_encodeCtx->codecFunction) && m_encodeCtx->codecFunction != CODECHAL_FUNCTION_FEI_PRE_ENC) { m_encodeCtx->codecFunction = CODECHAL_FUNCTION_FEI_ENC_PAK; feiPicParams->NumMVPredictorsL0 = 0; // number of MV Predictors L0 provided, max is 4 feiPicParams->NumMVPredictorsL1 = 0; // number of MV Predictors L1 provided, max is 2 feiPicParams->SearchPath = 0; // search path, default is 0, 0 and 2 mean full search, 1 means diamond search feiPicParams->LenSP = 57; // max number of SUs per reference which is evaluated by the predetermined SUs, range is [1, 63] feiPicParams->SubMBPartMask = 0x77; // the bit-mask for disabling sub-partition, bit 0 16x16, bit 1 16x8, bit 2 8x16 ... default value is 1110111b feiPicParams->IntraPartMask = 0; // luma intra partition mask bits, bit 0 16x16, bit 1 8x8, bit 2 4x4 feiPicParams->MultiPredL0 = false; // true neighbor MV will be used as predictori for L0, false will not. feiPicParams->MultiPredL1 = false; // true neighbor MV will be used as predictori for L0, false will not. feiPicParams->SubPelMode = 3; // half/quater pixels mode, 00b integer mode search, 01b half mode search, 11b quater mode search feiPicParams->InterSAD = 2; feiPicParams->IntraSAD = 2; feiPicParams->DistortionType = 0; // output distortion type, 0 raw distortion without cost, 1 distortion with cost feiPicParams->RepartitionCheckEnable = false; // true, enables the additional calls on Fraction & Bidirectional Refinement feiPicParams->AdaptiveSearch = true; // whether adaptive searching is enabled for IME feiPicParams->MVPredictorEnable = false; // if enable MV Predictor input feiPicParams->bMBQp = false; // if enable MB per QP input feiPicParams->bPerMBInput = false; // if enable per MB control/special input feiPicParams->bMBSizeCtrl = false; // if enable MB size control when enabled per MB special input feiPicParams->RefWidth = 48; feiPicParams->RefHeight = 40; feiPicParams->SearchWindow = 0; feiPicParams->DistortionEnable = false; feiPicParams->MbCodeMvEnable = false; } if (m_encodeCtx->codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC) { preEncParams->dwNumPastReferences = 1; // Number of past reference frame preEncParams->dwNumFutureReferences = 0; // Number of future reference frame MOS_ZeroMemory(&(preEncParams->CurrOriginalPicture), sizeof(CODEC_PICTURE)); MOS_ZeroMemory(&(preEncParams->PastRefPicture), sizeof(CODEC_PICTURE)); MOS_ZeroMemory(&(preEncParams->FutureRefPicture), sizeof(CODEC_PICTURE)); preEncParams->dwFrameQp = 25; // Frame level QP preEncParams->dwLenSP = 57; // max number of SUs per reference which is evaluated by the predetermined SUs, range is [1, 63] preEncParams->dwSearchPath = 0; // search path, default is 0, 0 and 2 mean full search, 1 means diamond search preEncParams->dwSubMBPartMask = 0x77; // the bit-mask for disabling sub-partition, bit 0 16x16, bit 1 16x8, bit 2 8x16 ... default value is 1110111b preEncParams->dwIntraPartMask = 0; preEncParams->dwSubPelMode = 3; // half/quater pixels mode, 00b integer mode search, 01b half mode search, 11b quater mode search preEncParams->dwInterSAD = 2; preEncParams->dwIntraSAD = 2; preEncParams->bAdaptiveSearch = 1; // whether adaptive searching is enabled for IME preEncParams->dwMVPredictorCtrl = 0; // MV predictor control, 0, disable, 1, enabled for past reference, 2, enabled for future reference, 3 enabled for both preEncParams->bMBQp = false; // if enable MB per QP input preEncParams->bFTEnable = false; // if use provided QP (frame level QP and per MB QP) and obtained MV to judge the number of non zero coefficients preEncParams->dwRefWidth = 48; preEncParams->dwRefHeight = 40; preEncParams->dwSearchWindow = 0; // defines predefined search windows, 0, disable // 1, Tiny 4 SUs 24x24 windows // 2, small 9 SUs 28x28 windows // 3, diamond 16 SUs 48x40 windows // 4, large diamon 32SUs 48x40 windows // 5, exhaustive 48SUs 48x40 windows preEncParams->bDisableMVOutput = false; // if disable MV output buffer preEncParams->bDisableStatisticsOutput = false; // if disable Statisticts output buffer preEncParams->bEnable8x8Statistics = false; // if enable, generate block8x8 average and variance output } return VA_STATUS_SUCCESS; } VAStatus DdiEncodeAvcFei::RenderPicture( VADriverContextP ctx, VAContextID context, VABufferID *buffers, int32_t numBuffers) { DDI_FUNCTION_ENTER(); DDI_CHK_NULL(ctx, "nullptr context in vpgEncodeRenderPicture!", VA_STATUS_ERROR_INVALID_CONTEXT); PDDI_MEDIA_CONTEXT mediaCtx = DdiMedia_GetMediaContext(ctx); DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT); // assume the VAContextID is encoder ID DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_CONTEXT); uint32_t numSlices = 0; VAStatus vaStatus = VA_STATUS_SUCCESS; DDI_MEDIA_BUFFER *buf; void *data; uint32_t dataSize; for (int32_t i = 0; i < numBuffers; i++) { buf = DdiMedia_GetBufferFromVABufferID(mediaCtx, buffers[i]); DDI_CHK_NULL(buf, "Invalid buffer.", VA_STATUS_ERROR_INVALID_BUFFER); if (buf->uiType == VAEncMacroblockDisableSkipMapBufferType) { DdiMedia_MediaBufferToMosResource(buf, &(m_encodeCtx->resPerMBSkipMapBuffer)); m_encodeCtx->bMbDisableSkipMapEnabled = true; continue; } dataSize = buf->iSize; // can use internal function instead of DdiMedia_MapBuffer here? DdiMedia_MapBuffer(ctx, buffers[i], &data); DDI_CHK_NULL(data, "nullptr data", VA_STATUS_ERROR_INVALID_BUFFER); switch (buf->uiType) { case VAIQMatrixBufferType: case VAQMatrixBufferType: DDI_CHK_STATUS(Qmatrix(data), VA_STATUS_ERROR_INVALID_BUFFER); break; case VAEncSequenceParameterBufferType: DDI_CHK_STATUS(ParseSeqParams(data), VA_STATUS_ERROR_INVALID_BUFFER); m_encodeCtx->bNewSeq = true; break; case VAEncPictureParameterBufferType: DDI_CHK_STATUS(ParsePicParams(mediaCtx, data), VA_STATUS_ERROR_INVALID_BUFFER); // it should use pFeiPicParams->function, but it may be still not set here yet if (m_encodeCtx->codecFunction == CODECHAL_FUNCTION_FEI_ENC) break; DDI_CHK_STATUS( AddToStatusReportQueue((void *)m_encodeCtx->resBitstreamBuffer.bo), VA_STATUS_ERROR_INVALID_BUFFER); break; case VAEncSliceParameterBufferType: numSlices = buf->uiNumElements; DDI_CHK_STATUS(ParseSlcParams(mediaCtx, data, numSlices), VA_STATUS_ERROR_INVALID_BUFFER); break; case VAEncPackedHeaderParameterBufferType: DDI_CHK_STATUS(ParsePackedHeaderParams(data), VA_STATUS_ERROR_INVALID_BUFFER); break; case VAEncPackedHeaderDataBufferType: vaStatus = ParsePackedHeaderData(data); break; case VAEncMiscParameterBufferType: DDI_CHK_STATUS(ParseMiscParams(data), VA_STATUS_ERROR_INVALID_BUFFER); break; case VAEncQPBufferType: DdiMedia_MediaBufferToMosResource(buf, &m_encodeCtx->resMBQpBuffer); m_encodeCtx->bMBQpEnable = true; break; case VAStatsStatisticsParameterBufferType: DDI_CHK_STATUS(ParseStatsParams(mediaCtx, data), VA_STATUS_ERROR_INVALID_BUFFER); break; case VAEncFEIMBControlBufferType: case VAEncFEIMVPredictorBufferType: case VAEncFEIMVBufferType: case VAEncFEIMBCodeBufferType: case VAEncFEIDistortionBufferType: case VAStatsMVPredictorBufferType: case VAStatsStatisticsBufferType: case VAStatsStatisticsBottomFieldBufferType: case VAStatsMVBufferType: { // handled in VAEncMiscParameterBufferType/VAEncMiscParameterTypeFEIFrameControlIntel case by vaBufferID break; } default: DDI_ASSERTMESSAGE("not supported buffer type in vpgEncodeRenderPicture."); // vaStatus = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE; break; } DdiMedia_UnmapBuffer(ctx, buffers[i]); } DDI_FUNCTION_EXIT(vaStatus); return vaStatus; } VAStatus DdiEncodeAvcFei::ParseMiscParamFeiPic(void *data) { DDI_CHK_NULL(data, "nullptr data", VA_STATUS_ERROR_INVALID_PARAMETER); CodecEncodeAvcFeiPicParams *feiPicParams = (CodecEncodeAvcFeiPicParams *)(m_encodeCtx->pFeiPicParams); DDI_CHK_NULL(feiPicParams, "nullptr feiPicParams", VA_STATUS_ERROR_INVALID_PARAMETER); VAEncMiscParameterFEIFrameControlH264 *vaEncMiscParamFeiPic = (VAEncMiscParameterFEIFrameControlH264*)data; m_encodeCtx->codecFunction = CODECHAL_FUNCTION_INVALID; if (vaEncMiscParamFeiPic->function & VA_FEI_FUNCTION_ENC_PAK) m_encodeCtx->codecFunction = CODECHAL_FUNCTION_FEI_ENC_PAK; if (vaEncMiscParamFeiPic->function == VA_FEI_FUNCTION_ENC) m_encodeCtx->codecFunction = CODECHAL_FUNCTION_FEI_ENC; if (vaEncMiscParamFeiPic->function == VA_FEI_FUNCTION_PAK) m_encodeCtx->codecFunction = CODECHAL_FUNCTION_FEI_PAK; feiPicParams->NumMVPredictorsL0 = vaEncMiscParamFeiPic->num_mv_predictors_l0; feiPicParams->NumMVPredictorsL1 = vaEncMiscParamFeiPic->num_mv_predictors_l1; feiPicParams->SearchPath = vaEncMiscParamFeiPic->search_path; feiPicParams->LenSP = vaEncMiscParamFeiPic->len_sp; feiPicParams->SubMBPartMask = vaEncMiscParamFeiPic->sub_mb_part_mask; feiPicParams->IntraPartMask = vaEncMiscParamFeiPic->intra_part_mask; feiPicParams->MultiPredL0 = vaEncMiscParamFeiPic->multi_pred_l0; feiPicParams->MultiPredL1 = vaEncMiscParamFeiPic->multi_pred_l1; feiPicParams->SubPelMode = vaEncMiscParamFeiPic->sub_pel_mode; feiPicParams->InterSAD = vaEncMiscParamFeiPic->inter_sad; feiPicParams->IntraSAD = vaEncMiscParamFeiPic->intra_sad; feiPicParams->DistortionType = vaEncMiscParamFeiPic->distortion_type; feiPicParams->RepartitionCheckEnable = vaEncMiscParamFeiPic->repartition_check_enable; feiPicParams->AdaptiveSearch = vaEncMiscParamFeiPic->adaptive_search; feiPicParams->MVPredictorEnable = vaEncMiscParamFeiPic->mv_predictor_enable; feiPicParams->bMBQp = vaEncMiscParamFeiPic->mb_qp; feiPicParams->bPerMBInput = vaEncMiscParamFeiPic->mb_input; feiPicParams->bMBSizeCtrl = vaEncMiscParamFeiPic->mb_size_ctrl; feiPicParams->RefWidth = vaEncMiscParamFeiPic->ref_width; feiPicParams->RefHeight = vaEncMiscParamFeiPic->ref_height; feiPicParams->SearchWindow = vaEncMiscParamFeiPic->search_window; DDI_MEDIA_BUFFER *mediaBuffer; VAStatus status = VA_STATUS_SUCCESS; if (feiPicParams->bPerMBInput) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(m_encodeCtx->pMediaCtx, vaEncMiscParamFeiPic->mb_ctrl); DDI_CHK_NULL(mediaBuffer, "nullptr mediaBuffer", VA_STATUS_ERROR_INVALID_PARAMETER); DdiMedia_MediaBufferToMosResource(mediaBuffer, &(feiPicParams->resMBCtrl)); } if (feiPicParams->MVPredictorEnable == 1) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(m_encodeCtx->pMediaCtx, vaEncMiscParamFeiPic->mv_predictor); DDI_CHK_NULL(mediaBuffer, "nullptr mediaBuffer", VA_STATUS_ERROR_INVALID_PARAMETER); DdiMedia_MediaBufferToMosResource(mediaBuffer, &(feiPicParams->resMVPredictor)); } else if ((feiPicParams->NumMVPredictorsL0 != 0) || (feiPicParams->NumMVPredictorsL1 != 0)) { DDI_ASSERTMESSAGE("feiPicParams->NumMVPredictorsL0 and NumMVPredictorsL1 should be set to 0 when feiPicParams->MVPredictorEnable is false!"); status = VA_STATUS_ERROR_INVALID_PARAMETER; } if (feiPicParams->bMBQp) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(m_encodeCtx->pMediaCtx, vaEncMiscParamFeiPic->qp); DDI_CHK_NULL(mediaBuffer, "nullptr mediaBuffer", VA_STATUS_ERROR_INVALID_PARAMETER); DdiMedia_MediaBufferToMosResource(mediaBuffer, &(feiPicParams->resMBQp)); } feiPicParams->MbCodeMvEnable = false; if (vaEncMiscParamFeiPic->mv_data != VA_INVALID_ID) { feiPicParams->MbCodeMvEnable = true; mediaBuffer = DdiMedia_GetBufferFromVABufferID(m_encodeCtx->pMediaCtx, vaEncMiscParamFeiPic->mv_data); DDI_CHK_NULL(mediaBuffer, "nullptr mediaBuffer", VA_STATUS_ERROR_INVALID_PARAMETER); DdiMedia_MediaBufferToMosResource(mediaBuffer, &(feiPicParams->resMVData)); if (m_encodeCtx->codecFunction == CODECHAL_FUNCTION_FEI_ENC) { RemoveFromEncStatusReportQueue(mediaBuffer, FEI_ENC_BUFFER_TYPE_MVDATA); if (VA_STATUS_SUCCESS != AddToEncStatusReportQueue((void *)(feiPicParams->resMVData.bo), FEI_ENC_BUFFER_TYPE_MVDATA)) { DDI_ASSERTMESSAGE("feiPicParams->resMVData is invalid for FEI ENC only"); status = VA_STATUS_ERROR_INVALID_PARAMETER; } } } if (vaEncMiscParamFeiPic->mb_code_data != VA_INVALID_ID) { if (feiPicParams->MbCodeMvEnable == false) { DDI_ASSERTMESSAGE("MV data and MB Code should be enabled or disabled together!"); status = MOS_STATUS_INVALID_PARAMETER; } mediaBuffer = DdiMedia_GetBufferFromVABufferID(m_encodeCtx->pMediaCtx, vaEncMiscParamFeiPic->mb_code_data); DDI_CHK_NULL(mediaBuffer, "nullptr mediaBuffer", VA_STATUS_ERROR_INVALID_PARAMETER); DdiMedia_MediaBufferToMosResource(mediaBuffer, &(feiPicParams->resMBCode)); if (m_encodeCtx->codecFunction == CODECHAL_FUNCTION_FEI_ENC) { RemoveFromEncStatusReportQueue(mediaBuffer, FEI_ENC_BUFFER_TYPE_MBCODE); if (MOS_STATUS_SUCCESS != AddToEncStatusReportQueue((void *)(feiPicParams->resMBCode.bo), FEI_ENC_BUFFER_TYPE_MBCODE)) { DDI_ASSERTMESSAGE("feiPicParams->resMBCode is invalid for FEI ENC only"); status = VA_STATUS_ERROR_INVALID_PARAMETER; } } } if (vaEncMiscParamFeiPic->distortion != VA_INVALID_ID) { feiPicParams->DistortionEnable = true; mediaBuffer = DdiMedia_GetBufferFromVABufferID(m_encodeCtx->pMediaCtx, vaEncMiscParamFeiPic->distortion); DDI_CHK_NULL(mediaBuffer, "nullptr mediaBuffer", VA_STATUS_ERROR_INVALID_PARAMETER); DdiMedia_MediaBufferToMosResource(mediaBuffer, &(feiPicParams->resDistortion)); if (m_encodeCtx->codecFunction == CODECHAL_FUNCTION_FEI_ENC) { RemoveFromEncStatusReportQueue(mediaBuffer, FEI_ENC_BUFFER_TYPE_DISTORTION); if (MOS_STATUS_SUCCESS != AddToEncStatusReportQueue((void *)(feiPicParams->resDistortion.bo), FEI_ENC_BUFFER_TYPE_DISTORTION)) { DDI_ASSERTMESSAGE("feiPicParams->resDistortion is invalid for FEI ENC only"); status = VA_STATUS_ERROR_INVALID_PARAMETER; } } } if (m_encodeCtx->codecFunction == CODECHAL_FUNCTION_FEI_ENC) { AddToEncStatusReportQueueUpdatePos(); } //add for mutlple pass pak feiPicParams->dwMaxFrameSize = vaEncMiscParamFeiPic->max_frame_size; if (feiPicParams->dwMaxFrameSize) { feiPicParams->dwNumPasses = vaEncMiscParamFeiPic->num_passes; if ((feiPicParams->dwNumPasses == 0) || (feiPicParams->dwNumPasses > feiMaxPassesNum)) { return VA_STATUS_ERROR_INVALID_PARAMETER; } if (feiPicParams->pDeltaQp != nullptr) { MOS_FreeMemory(feiPicParams->pDeltaQp); } feiPicParams->pDeltaQp = (uint8_t *)MOS_AllocAndZeroMemory(sizeof(uint8_t) * feiPicParams->dwNumPasses); if (!feiPicParams->pDeltaQp) { return VA_STATUS_ERROR_INVALID_PARAMETER; } if (MOS_STATUS_SUCCESS != MOS_SecureMemcpy(feiPicParams->pDeltaQp, feiPicParams->dwNumPasses, vaEncMiscParamFeiPic->delta_qp, feiPicParams->dwNumPasses)) { status = VA_STATUS_ERROR_INVALID_PARAMETER; } } return status; } VAStatus DdiEncodeAvcFei::AddToEncStatusReportQueue( void *encBuf, DDI_ENCODE_FEI_ENC_BUFFER_TYPE typeIdx) { DDI_CHK_NULL(encBuf, "nullptr encBuf", VA_STATUS_ERROR_INVALID_PARAMETER); CodecEncodeAvcFeiPicParams *feiPicParams = (CodecEncodeAvcFeiPicParams *)(m_encodeCtx->pFeiPicParams); DDI_CHK_NULL(feiPicParams, "nullptr feiPicParams", VA_STATUS_ERROR_INVALID_PARAMETER); if (m_encodeCtx->codecFunction != CODECHAL_FUNCTION_FEI_ENC) { DDI_ASSERTMESSAGE("ENC output buffers status checking is not allowed for non-FEI_ENC case! ."); return VA_STATUS_ERROR_INVALID_PARAMETER; } if ((typeIdx < 0) || (typeIdx >= FEI_ENC_BUFFER_TYPE_MAX)) { DDI_ASSERTMESSAGE("ENC output buffers status checking, gets invalid buffer type index! ."); return VA_STATUS_ERROR_INVALID_PARAMETER; } int32_t idx = m_encodeCtx->statusReportBuf.ulHeadPosition; m_encodeCtx->statusReportBuf.encInfos[idx].pEncBuf[typeIdx] = encBuf; m_encodeCtx->statusReportBuf.encInfos[idx].uiStatus = 0; m_encodeCtx->statusReportBuf.encInfos[idx].uiBuffers++; return VA_STATUS_SUCCESS; } VAStatus DdiEncodeAvcFei::AddToEncStatusReportQueueUpdatePos() { CodecEncodeAvcFeiPicParams *feiPicParams = (CodecEncodeAvcFeiPicParams *)(m_encodeCtx->pFeiPicParams); DDI_CHK_NULL(feiPicParams, "nullptr feiPicParams", VA_STATUS_ERROR_INVALID_PARAMETER); if (m_encodeCtx->codecFunction != CODECHAL_FUNCTION_FEI_ENC) { DDI_ASSERTMESSAGE("ENC output buffers status checking is not allowed for non-FEI_ENC case! ."); return VA_STATUS_ERROR_INVALID_PARAMETER; } int32_t i = m_encodeCtx->statusReportBuf.ulHeadPosition; if ((m_encodeCtx->statusReportBuf.encInfos[i].uiBuffers == (feiPicParams->MbCodeMvEnable * 2 + feiPicParams->DistortionEnable)) && m_encodeCtx->statusReportBuf.encInfos[i].uiBuffers != 0) { m_encodeCtx->statusReportBuf.ulHeadPosition = (m_encodeCtx->statusReportBuf.ulHeadPosition + 1) % DDI_ENCODE_MAX_STATUS_REPORT_BUFFER; } return VA_STATUS_SUCCESS; } VAStatus DdiEncodeAvcFei::AddToPreEncStatusReportQueue( void *preEncBuf, DDI_ENCODE_PRE_ENC_BUFFER_TYPE typeIdx) { DDI_CHK_NULL(preEncBuf, "nullptr preEncBuf", VA_STATUS_ERROR_INVALID_PARAMETER); if (m_encodeCtx->codecFunction != CODECHAL_FUNCTION_FEI_PRE_ENC) { DDI_ASSERTMESSAGE("PRE ENC output buffers status checking is not allowed for non-PRE_ENC case! ."); return VA_STATUS_ERROR_INVALID_PARAMETER; } if ((typeIdx < 0) || (typeIdx >= PRE_ENC_BUFFER_TYPE_MAX)) { DDI_ASSERTMESSAGE("PRE ENC output buffers status checking, gets invalid buffer type index! ."); return VA_STATUS_ERROR_INVALID_PARAMETER; } int32_t i = m_encodeCtx->statusReportBuf.ulHeadPosition; m_encodeCtx->statusReportBuf.preencInfos[i].pPreEncBuf[typeIdx] = preEncBuf; m_encodeCtx->statusReportBuf.preencInfos[i].uiStatus = 0; m_encodeCtx->statusReportBuf.preencInfos[i].uiBuffers++; return VA_STATUS_SUCCESS; } VAStatus DdiEncodeAvcFei::AddToPreEncStatusReportQueueUpdatePos() { FeiPreEncParams *preEncParams = (FeiPreEncParams*)(m_encodeCtx->pPreEncParams); DDI_CHK_NULL(preEncParams, "nullptr preEncParams", VA_STATUS_ERROR_INVALID_PARAMETER); if (m_encodeCtx->codecFunction != CODECHAL_FUNCTION_FEI_PRE_ENC) { DDI_ASSERTMESSAGE("PRE ENC output buffers status checking is not allowed for non-PRE_ENC case! ."); return VA_STATUS_ERROR_INVALID_PARAMETER; } uint32_t numBuffers = (!preEncParams->bInterlaced) ? (2 - preEncParams->bDisableMVOutput - preEncParams->bDisableStatisticsOutput) : (3 - preEncParams->bDisableMVOutput - 2 * preEncParams->bDisableStatisticsOutput); int32_t i = m_encodeCtx->statusReportBuf.ulHeadPosition; if ((m_encodeCtx->statusReportBuf.preencInfos[i].uiBuffers == numBuffers) && m_encodeCtx->statusReportBuf.preencInfos[i].uiBuffers != 0) { m_encodeCtx->statusReportBuf.ulHeadPosition = (m_encodeCtx->statusReportBuf.ulHeadPosition + 1) % DDI_ENCODE_MAX_STATUS_REPORT_BUFFER; } return VA_STATUS_SUCCESS; } VAStatus DdiEncodeAvcFei::ParseMiscParams(void *ptr) { DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER); DDI_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER); VAEncMiscParameterBuffer *miscParamBuf = (VAEncMiscParameterBuffer *)ptr; DDI_CHK_NULL(miscParamBuf->data, "nullptr miscParamBuf->data", VA_STATUS_ERROR_INVALID_PARAMETER); VAStatus status = MOS_STATUS_SUCCESS; switch ((int32_t)(miscParamBuf->type)) { case VAEncMiscParameterTypeHRD: status = ParseMiscParamHRD((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeFrameRate: status = ParseMiscParamFR((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeRateControl: status = ParseMiscParamRC((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeEncQuality: status = ParseMiscParamEncQuality((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeQuantization: status = ParseMiscParamQuantization((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeRIR: status = ParseMiscParameterRIR((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeSkipFrame: status = ParseMiscParamSkipFrame((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeMaxFrameSize: status = ParseMiscParamMaxFrameSize((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeQualityLevel: status = ParseMiscParamQualityLevel((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeMaxSliceSize: status = ParseMiscParamMaxSliceSize((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeROI: status = ParseMiscParamROI((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeFEIFrameControl: status = ParseMiscParamFeiPic((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeDirtyRect: status = ParseMiscParamDirtyROI((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeCustomRoundingControl: status = ParseMiscParamRounding((void *)miscParamBuf->data); break; case VAEncMiscParameterTypeSubMbPartPel: status = ParseMiscParamSubMbPartPel((void *)miscParamBuf->data); break; default: DDI_ASSERTMESSAGE("unsupported misc parameter type."); status = VA_STATUS_ERROR_INVALID_PARAMETER; break; } return status; } VAStatus DdiEncodeAvcFei::ParseStatsParams(PDDI_MEDIA_CONTEXT mediaCtx, void *ptr) { if ((nullptr == ptr) || (nullptr == m_encodeCtx)) { DDI_ASSERTMESSAGE("invalidate input parameters"); return VA_STATUS_ERROR_INVALID_PARAMETER; } VAStatsStatisticsParameterH264 *statsParams = (VAStatsStatisticsParameterH264 *)ptr; FeiPreEncParams *preEncParams = (FeiPreEncParams*)(m_encodeCtx->pPreEncParams); DDI_CODEC_RENDER_TARGET_TABLE *rtTbl = &(m_encodeCtx->RTtbl); preEncParams->dwNumPastReferences = statsParams->stats_params.num_past_references; preEncParams->dwNumFutureReferences = statsParams->stats_params.num_future_references; preEncParams->dwFrameQp = statsParams->frame_qp; preEncParams->dwLenSP = statsParams->len_sp; preEncParams->dwSearchPath = statsParams->search_path; preEncParams->dwSubMBPartMask = statsParams->sub_mb_part_mask; preEncParams->dwIntraPartMask = statsParams->intra_part_mask; preEncParams->dwSubPelMode = statsParams->sub_pel_mode; preEncParams->dwInterSAD = statsParams->inter_sad; preEncParams->dwIntraSAD = statsParams->intra_sad; preEncParams->bAdaptiveSearch = statsParams->adaptive_search; preEncParams->dwMVPredictorCtrl = statsParams->mv_predictor_ctrl; preEncParams->bMBQp = statsParams->mb_qp; preEncParams->bFTEnable = statsParams->ft_enable; preEncParams->dwRefWidth = statsParams->ref_width; preEncParams->dwRefHeight = statsParams->ref_height; preEncParams->dwSearchWindow = statsParams->search_window; preEncParams->bDisableMVOutput = statsParams->disable_mv_output; preEncParams->bDisableStatisticsOutput = statsParams->disable_statistics_output; preEncParams->bEnable8x8Statistics = statsParams->enable_8x8_statistics; preEncParams->bInputUpdated = false; preEncParams->bCurPicUpdated = false; preEncParams->bPastRefUpdated = false; preEncParams->bFutureRefUpdated = false; preEncParams->bPastRefStatsNeeded = false; preEncParams->bFutureRefStatsNeeded = false; if (statsParams->stats_params.input.picture_id == VA_INVALID_ID) { DDI_ASSERTMESSAGE("invalidate input parameters, current picture id is invalidate"); return VA_STATUS_ERROR_INVALID_PARAMETER; } if ((statsParams->stats_params.input.flags & VA_PICTURE_STATS_CONTENT_UPDATED) != 0) { preEncParams->bCurPicUpdated = true; } CODEC_PICTURE_FLAG picFlags = ((statsParams->stats_params.input.flags & 0xF) == VA_PICTURE_STATS_PROGRESSIVE) ? PICTURE_FRAME : (((statsParams->stats_params.input.flags & 0xF) == VA_PICTURE_STATS_TOP_FIELD) ? PICTURE_TOP_FIELD : (((statsParams->stats_params.input.flags & 0xF) == VA_PICTURE_STATS_BOTTOM_FIELD) ? PICTURE_BOTTOM_FIELD : PICTURE_INVALID)); preEncParams->bInterlaced = (picFlags == PICTURE_TOP_FIELD || picFlags == PICTURE_BOTTOM_FIELD); DDI_MEDIA_SURFACE *currentSurface = DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, statsParams->stats_params.input.picture_id); if (nullptr == currentSurface) { DDI_ASSERTMESSAGE("invalidate current ref surface"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DDI_CHK_RET(RegisterRTSurfaces(&m_encodeCtx->RTtbl, currentSurface), "RegisterRTSurfaces failed!"); preEncParams->CurrOriginalPicture.FrameIdx = (uint8_t)GetRenderTargetID(rtTbl, currentSurface); preEncParams->CurrOriginalPicture.PicFlags = picFlags; DDI_MEDIA_BUFFER *mediaBuffer; if ((preEncParams->dwNumPastReferences == 1) && (statsParams->stats_params.past_references[0].picture_id != VA_INVALID_ID)) { if ((statsParams->stats_params.past_references->flags & VA_PICTURE_STATS_CONTENT_UPDATED) != 0) { preEncParams->bPastRefUpdated = true; } DDI_MEDIA_SURFACE *pastRefSurface = (DDI_MEDIA_SURFACE *)DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, statsParams->stats_params.past_references->picture_id); if (nullptr == pastRefSurface) { DDI_ASSERTMESSAGE("invalidate Future ref surface"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DDI_CHK_RET(RegisterRTSurfaces(&m_encodeCtx->RTtbl, pastRefSurface), "RegisterRTSurfaces failed!"); preEncParams->PastRefPicture.FrameIdx = (uint8_t)GetRenderTargetID(rtTbl, pastRefSurface); picFlags = ((statsParams->stats_params.past_references->flags & 0xF) == VA_PICTURE_STATS_PROGRESSIVE) ? PICTURE_FRAME : (((statsParams->stats_params.past_references->flags & 0xF) == VA_PICTURE_STATS_TOP_FIELD) ? PICTURE_TOP_FIELD : (((statsParams->stats_params.past_references->flags & 0xF) == VA_PICTURE_STATS_BOTTOM_FIELD) ? PICTURE_BOTTOM_FIELD : PICTURE_INVALID)); preEncParams->PastRefPicture.PicFlags = picFlags; DdiMedia_MediaSurfaceToMosResource(pastRefSurface, &(preEncParams->sPastRefSurface.OsResource)); preEncParams->sPastRefSurface.dwWidth = preEncParams->sPastRefSurface.OsResource.iWidth; preEncParams->sPastRefSurface.dwHeight = preEncParams->sPastRefSurface.OsResource.iHeight; preEncParams->sPastRefSurface.dwPitch = preEncParams->sPastRefSurface.OsResource.iPitch; preEncParams->sPastRefSurface.TileType = preEncParams->sPastRefSurface.OsResource.TileType; preEncParams->sPastRefSurface.TileModeGMM = preEncParams->sPastRefSurface.OsResource.TileModeGMM; preEncParams->sPastRefSurface.bGMMTileEnabled = preEncParams->sPastRefSurface.OsResource.bGMMTileEnabled; preEncParams->bPastRefStatsNeeded = false; if (statsParams->stats_params.past_ref_stat_buf) { if (!preEncParams->bDisableStatisticsOutput) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, *(statsParams->stats_params.past_ref_stat_buf)); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate statistics output media buffer for Past ref"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->sPastRefStatsBuffer)); if (picFlags == PICTURE_TOP_FIELD || picFlags == PICTURE_BOTTOM_FIELD) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, *(statsParams->stats_params.past_ref_stat_buf + 1)); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate statistics output media buffer for Past bottom field ref"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->sPastRefStatsBotFieldBuffer)); } preEncParams->bPastRefStatsNeeded = true; } else preEncParams->bPastRefStatsNeeded = false; } } else { preEncParams->PastRefPicture.FrameIdx = (uint8_t)DDI_CODEC_INVALID_FRAME_INDEX; preEncParams->PastRefPicture.PicFlags = PICTURE_INVALID; } if ((preEncParams->dwNumFutureReferences == 1) && (statsParams->stats_params.future_references[0].picture_id != VA_INVALID_ID)) { if ((statsParams->stats_params.future_references->flags & VA_PICTURE_STATS_CONTENT_UPDATED) != 0) { preEncParams->bFutureRefUpdated = true; } DDI_MEDIA_SURFACE *futureRefSurface = (DDI_MEDIA_SURFACE *)DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, statsParams->stats_params.future_references->picture_id); if (nullptr == futureRefSurface) { DDI_ASSERTMESSAGE("invalidate Future ref surface"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DDI_CHK_RET(RegisterRTSurfaces(&m_encodeCtx->RTtbl, futureRefSurface), "RegisterRTSurfaces failed!"); preEncParams->FutureRefPicture.FrameIdx = (uint8_t)GetRenderTargetID(rtTbl, futureRefSurface); picFlags = ((statsParams->stats_params.future_references->flags & 0xF) == VA_PICTURE_STATS_PROGRESSIVE) ? PICTURE_FRAME : (((statsParams->stats_params.future_references->flags & 0xF) == VA_PICTURE_STATS_TOP_FIELD) ? PICTURE_TOP_FIELD : (((statsParams->stats_params.future_references->flags & 0xF) == VA_PICTURE_STATS_BOTTOM_FIELD) ? PICTURE_BOTTOM_FIELD : PICTURE_INVALID)); preEncParams->FutureRefPicture.PicFlags = picFlags; DdiMedia_MediaSurfaceToMosResource(futureRefSurface, &(preEncParams->sFutureRefSurface.OsResource)); preEncParams->sFutureRefSurface.dwWidth = preEncParams->sFutureRefSurface.OsResource.iWidth; preEncParams->sFutureRefSurface.dwHeight = preEncParams->sFutureRefSurface.OsResource.iHeight; preEncParams->sFutureRefSurface.dwPitch = preEncParams->sFutureRefSurface.OsResource.iPitch; preEncParams->sFutureRefSurface.TileType = preEncParams->sFutureRefSurface.OsResource.TileType; preEncParams->bFutureRefStatsNeeded = false; if (!preEncParams->bDisableStatisticsOutput) { if (statsParams->stats_params.future_ref_stat_buf) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, *(statsParams->stats_params.future_ref_stat_buf)); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate statistics output media buffer for Future ref"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->sFutureRefStatsBuffer)); if (picFlags == PICTURE_TOP_FIELD || picFlags == PICTURE_BOTTOM_FIELD) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, *(statsParams->stats_params.future_ref_stat_buf + 1)); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate statistics output media buffer for Future ref"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->sFutureRefStatsBotFieldBuffer)); } preEncParams->bFutureRefStatsNeeded = true; } else preEncParams->bFutureRefStatsNeeded = false; } } else { preEncParams->FutureRefPicture.FrameIdx = (uint8_t)DDI_CODEC_INVALID_FRAME_INDEX; preEncParams->FutureRefPicture.PicFlags = PICTURE_INVALID; } if (preEncParams->dwMVPredictorCtrl) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, statsParams->stats_params.mv_predictor); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate mv_predictor media buffer"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->resMvPredBuffer)); } if (preEncParams->bMBQp) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, statsParams->stats_params.qp); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate qp media buffer"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->resMbQpBuffer)); } uint32_t i = 0; if (!preEncParams->bDisableMVOutput) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, statsParams->stats_params.outputs[i++]); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate mv output media buffer"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->resMvBuffer)); RemoveFromPreEncStatusReportQueue(mediaBuffer, PRE_ENC_BUFFER_TYPE_MVDATA); if (VA_STATUS_SUCCESS != AddToPreEncStatusReportQueue((void *)(preEncParams->resMvBuffer.bo), PRE_ENC_BUFFER_TYPE_MVDATA)) { DDI_ASSERTMESSAGE("preEncParams->resMvBuffer is invalid for PREENC only"); return VA_STATUS_ERROR_INVALID_PARAMETER; } } if (!preEncParams->bDisableStatisticsOutput) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, statsParams->stats_params.outputs[i++]); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate statistics output media buffer"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->resStatsBuffer)); RemoveFromPreEncStatusReportQueue(mediaBuffer, PRE_ENC_BUFFER_TYPE_STATS); if (VA_STATUS_SUCCESS != AddToPreEncStatusReportQueue((void *)(preEncParams->resStatsBuffer.bo), PRE_ENC_BUFFER_TYPE_STATS)) { DDI_ASSERTMESSAGE("preEncParams->resStatsBuffer is invalid for PREENC only"); return VA_STATUS_ERROR_INVALID_PARAMETER; } if (preEncParams->bInterlaced) { mediaBuffer = DdiMedia_GetBufferFromVABufferID(mediaCtx, statsParams->stats_params.outputs[i++]); if (nullptr == mediaBuffer) { DDI_ASSERTMESSAGE("invalidate statistics output media bottom field buffer, must provide bottom field statistics buffer for both top and bottom field PreENC"); return VA_STATUS_ERROR_INVALID_PARAMETER; } DdiMedia_MediaBufferToMosResource(mediaBuffer, &(preEncParams->resStatsBotFieldBuffer)); RemoveFromPreEncStatusReportQueue(mediaBuffer, PRE_ENC_BUFFER_TYPE_STATS_BOT); if (VA_STATUS_SUCCESS != AddToPreEncStatusReportQueue((void *)(preEncParams->resStatsBotFieldBuffer.bo), PRE_ENC_BUFFER_TYPE_STATS_BOT)) { DDI_ASSERTMESSAGE("preEncParams->resStatsBotFieldBuffer is invalid for PREENC only"); return VA_STATUS_ERROR_INVALID_PARAMETER; } } } AddToPreEncStatusReportQueueUpdatePos(); return VA_STATUS_SUCCESS; }