| /* |
| * 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_mpeg2.cpp |
| //! \brief Defines class for DDI media mpeg2 encode. |
| //! |
| |
| #include "media_libva_encoder.h" |
| #include "media_libva_util.h" |
| #include "media_ddi_encode_mpeg2.h" |
| #include "media_ddi_encode_const.h" |
| #include "media_ddi_factory.h" |
| |
| extern template class MediaDdiFactoryNoArg<DdiEncodeBase>; |
| static bool isEncodeMpeg2Registered = |
| MediaDdiFactoryNoArg<DdiEncodeBase>::RegisterCodec<DdiEncodeMpeg2>(ENCODE_ID_MPEG2); |
| |
| DdiEncodeMpeg2::~DdiEncodeMpeg2() |
| { |
| RemoveUserData(); |
| |
| MOS_FreeMemory(m_encodeCtx->pSeqParams); |
| m_encodeCtx->pSeqParams = nullptr; |
| |
| MOS_FreeMemory(m_encodeCtx->pPicParams); |
| m_encodeCtx->pPicParams = nullptr; |
| |
| if (nullptr != m_encodeCtx->ppNALUnitParams) |
| { |
| // Allocate one contiguous memory for the NALUnitParams buffers |
| // only need to free one time |
| MOS_FreeMemory(m_encodeCtx->ppNALUnitParams[0]); |
| m_encodeCtx->ppNALUnitParams[0] = nullptr; |
| |
| MOS_FreeMemory(m_encodeCtx->ppNALUnitParams); |
| m_encodeCtx->ppNALUnitParams = nullptr; |
| } |
| |
| MOS_FreeMemory(m_encodeCtx->pVuiParams); |
| m_encodeCtx->pVuiParams = nullptr; |
| |
| MOS_FreeMemory(m_encodeCtx->pSliceParams); |
| m_encodeCtx->pSliceParams = nullptr; |
| |
| MOS_FreeMemory(m_encodeCtx->pEncodeStatusReport); |
| m_encodeCtx->pEncodeStatusReport = nullptr; |
| |
| MOS_FreeMemory(m_encodeCtx->pSEIFromApp); |
| m_encodeCtx->pSEIFromApp = nullptr; |
| |
| MOS_FreeMemory(m_encodeCtx->pSliceHeaderData); |
| m_encodeCtx->pSliceHeaderData = nullptr; |
| |
| if (m_encodeCtx->pbsBuffer) |
| { |
| MOS_FreeMemory(m_encodeCtx->pbsBuffer->pBase); |
| m_encodeCtx->pbsBuffer->pBase = nullptr; |
| |
| MOS_FreeMemory(m_encodeCtx->pbsBuffer); |
| m_encodeCtx->pbsBuffer = nullptr; |
| } |
| MOS_FreeMemory(m_encodeCtx->pQmatrixParams); |
| m_encodeCtx->pQmatrixParams = nullptr; |
| } |
| |
| VAStatus DdiEncodeMpeg2::ContextInitialize( |
| CodechalSetting *codecHalSettings) |
| { |
| DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx.", VA_STATUS_ERROR_INVALID_CONTEXT); |
| DDI_CHK_NULL(m_encodeCtx->pCpDdiInterface, "nullptr m_encodeCtx->pCpDdiInterface.", VA_STATUS_ERROR_INVALID_CONTEXT); |
| DDI_CHK_NULL(codecHalSettings, "nullptr codecHalSettings.", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| codecHalSettings->codecFunction = CODECHAL_FUNCTION_ENC_PAK; |
| codecHalSettings->width = m_encodeCtx->dwFrameWidth; |
| codecHalSettings->height = m_encodeCtx->dwFrameHeight; |
| codecHalSettings->mode = m_encodeCtx->wModeType; |
| codecHalSettings->standard = CODECHAL_MPEG2; |
| |
| m_encodeCtx->pSeqParams = (void *)MOS_AllocAndZeroMemory(sizeof(CodecEncodeMpeg2SequenceParams)); |
| DDI_CHK_NULL(m_encodeCtx->pSeqParams, "nullptr m_encodeCtx->pSeqParams.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| m_encodeCtx->pPicParams = (void *)MOS_AllocAndZeroMemory(sizeof(CodecEncodeMpeg2PictureParams)); |
| DDI_CHK_NULL(m_encodeCtx->pPicParams, "nullptr m_encodeCtx->pPicParams.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| m_encodeCtx->pQmatrixParams = (void *)MOS_AllocAndZeroMemory(sizeof(CodecEncodeMpeg2QmatixParams)); |
| DDI_CHK_NULL(m_encodeCtx->pQmatrixParams, "nullptr m_encodeCtx->pQmatrixParams.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| m_encodeCtx->pVuiParams = (void *)MOS_AllocAndZeroMemory(sizeof(CodecEncodeMpeg2VuiParams)); |
| DDI_CHK_NULL(m_encodeCtx->pVuiParams, "nullptr m_encodeCtx->pVuiParams.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| // Allocate SliceParams |
| // slice params num should equal to the mbHeight //attention !!! zxf |
| m_encodeCtx->pSliceParams = (void *)MOS_AllocAndZeroMemory((m_encodeCtx->dwFrameHeight >> 4) * sizeof(CodecEncodeMpeg2SliceParmas)); |
| DDI_CHK_NULL(m_encodeCtx->pSliceParams, "nullptr m_encodeCtx->pSliceParams.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| // Allocate Encode Status Report |
| m_encodeCtx->pEncodeStatusReport = (void *)MOS_AllocAndZeroMemory(CODECHAL_ENCODE_STATUS_NUM * sizeof(EncodeStatusReport)); |
| DDI_CHK_NULL(m_encodeCtx->pEncodeStatusReport, "nullptr m_encodeCtx->pEncodeStatusReport.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| // Allocate SEI structure |
| m_encodeCtx->pSEIFromApp = (CodechalEncodeSeiData *)MOS_AllocAndZeroMemory(sizeof(CodechalEncodeSeiData)); |
| DDI_CHK_NULL(m_encodeCtx->pSEIFromApp, "nullptr m_encodeCtx->pSEIFromApp.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| m_encodeCtx->pSliceHeaderData = (CODEC_ENCODER_SLCDATA *)MOS_AllocAndZeroMemory(m_encodeCtx->wPicHeightInMB * |
| sizeof(CODEC_ENCODER_SLCDATA)); |
| DDI_CHK_NULL(m_encodeCtx->pSliceHeaderData, "nullptr m_encodeCtx->pSliceHeaderData.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| // Create the bit stream buffer to hold the packed headers from application |
| m_encodeCtx->pbsBuffer = (BSBuffer *)MOS_AllocAndZeroMemory(sizeof(BSBuffer)); |
| DDI_CHK_NULL(m_encodeCtx->pbsBuffer, "nullptr m_encodeCtx->pbsBuffer.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| m_encodeCtx->pbsBuffer->pBase = (uint8_t *)MOS_AllocAndZeroMemory(m_encodeCtx->wPicHeightInMB * PACKED_HEADER_SIZE_PER_ROW); |
| DDI_CHK_NULL(m_encodeCtx->pbsBuffer->pBase, "nullptr m_encodeCtx->pbsBuffer->pBase.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| m_encodeCtx->pbsBuffer->BufferSize = m_encodeCtx->wPicHeightInMB * PACKED_HEADER_SIZE_PER_ROW; |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| VAStatus DdiEncodeMpeg2::RenderPicture( |
| VADriverContextP ctx, |
| VAContextID context, |
| VABufferID *buffers, |
| int32_t numBuffers) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| |
| DDI_FUNCTION_ENTER(); |
| |
| DDI_CHK_NULL(ctx, "nullptr context", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| DDI_MEDIA_CONTEXT *mediaCtx = DdiMedia_GetMediaContext(ctx); |
| DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| for (int32_t i = 0; i < numBuffers; i++) |
| { |
| DDI_MEDIA_BUFFER *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; |
| } |
| uint32_t dataSize = buf->iSize; |
| // can use internal function instead of DdiMedia_MapBuffer here? |
| void *data = nullptr; |
| 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); |
| DDI_CHK_STATUS( |
| AddToStatusReportQueue((void *)m_encodeCtx->resBitstreamBuffer.bo), |
| VA_STATUS_ERROR_INVALID_BUFFER); |
| break; |
| |
| case VAEncSliceParameterBufferType: |
| { |
| uint32_t numSlices = buf->uiNumElements; |
| DDI_CHK_STATUS(ParseSlcParams(mediaCtx, data, numSlices), VA_STATUS_ERROR_INVALID_BUFFER); |
| } |
| break; |
| |
| case VAEncPackedHeaderParameterBufferType: |
| vaStatus = ParsePackedHeaderParams(data); |
| 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; |
| |
| default: |
| DDI_ASSERTMESSAGE("not supported buffer type."); |
| break; |
| } |
| DdiMedia_UnmapBuffer(ctx, buffers[i]); |
| } |
| |
| DDI_FUNCTION_EXIT(vaStatus); |
| return vaStatus; |
| } |
| |
| VAStatus DdiEncodeMpeg2::EncodeInCodecHal( |
| uint32_t numSlices) |
| { |
| DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(m_encodeCtx->pMediaCtx, "nullptr m_encodeCtx->pMediaCtx", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(m_encodeCtx->pCodecHal, "nullptr m_encodeCtx->pCodecHal", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| EncoderParams encodeParams; |
| MOS_ZeroMemory(&encodeParams, sizeof(EncoderParams)); |
| |
| if (m_encodeCtx->bVdencActive == true) |
| { |
| encodeParams.ExecCodecFunction = CODECHAL_FUNCTION_ENC_VDENC_PAK; |
| } |
| else |
| { |
| encodeParams.ExecCodecFunction = CODECHAL_FUNCTION_ENC_PAK; |
| } |
| |
| DDI_CODEC_RENDER_TARGET_TABLE *rtTbl = &(m_encodeCtx->RTtbl); |
| |
| // Raw Surface |
| MOS_SURFACE rawSurface; |
| MOS_ZeroMemory(&rawSurface, sizeof(MOS_SURFACE)); |
| rawSurface.Format = Format_NV12; |
| rawSurface.dwOffset = 0; |
| DdiMedia_MediaSurfaceToMosResource(rtTbl->pCurrentRT, &(rawSurface.OsResource)); |
| |
| // Recon Surface |
| MOS_SURFACE reconSurface; |
| MOS_ZeroMemory(&reconSurface, sizeof(MOS_SURFACE)); |
| reconSurface.Format = Format_NV12; |
| reconSurface.dwOffset = 0; |
| DdiMedia_MediaSurfaceToMosResource(rtTbl->pCurrentReconTarget, &(reconSurface.OsResource)); |
| |
| //clear registered recon/ref surface flags |
| DDI_CHK_RET(ClearRefList(&m_encodeCtx->RTtbl, false), "ClearRefList failed!"); |
| |
| // Bitstream surface |
| MOS_RESOURCE bitstreamSurface; |
| MOS_ZeroMemory(&bitstreamSurface, sizeof(MOS_RESOURCE)); |
| bitstreamSurface = m_encodeCtx->resBitstreamBuffer; // in render picture |
| bitstreamSurface.Format = Format_Buffer; |
| |
| encodeParams.psRawSurface = &rawSurface; |
| encodeParams.psReconSurface = &reconSurface; |
| encodeParams.presBitstreamBuffer = &bitstreamSurface; |
| |
| MOS_SURFACE mbQpSurface; |
| if (m_encodeCtx->bMBQpEnable) |
| { |
| MOS_ZeroMemory(&mbQpSurface, sizeof(MOS_SURFACE)); |
| mbQpSurface.Format = Format_Buffer_2D; |
| mbQpSurface.dwOffset = 0; |
| mbQpSurface.OsResource = m_encodeCtx->resMBQpBuffer; |
| encodeParams.psMbQpDataSurface = &mbQpSurface; |
| encodeParams.bMbQpDataEnabled = true; |
| } |
| |
| encodeParams.bMbDisableSkipMapEnabled = m_encodeCtx->bMbDisableSkipMapEnabled; |
| |
| MOS_SURFACE disableSkipMapSurface; |
| if (encodeParams.bMbDisableSkipMapEnabled) |
| { |
| MOS_ZeroMemory(&disableSkipMapSurface, sizeof(MOS_SURFACE)); |
| disableSkipMapSurface.Format = Format_Buffer; |
| disableSkipMapSurface.dwOffset = 0; |
| disableSkipMapSurface.OsResource = m_encodeCtx->resPerMBSkipMapBuffer; |
| encodeParams.psMbDisableSkipMapSurface = &disableSkipMapSurface; |
| } |
| |
| encodeParams.pMpeg2UserDataListHead = m_userDataListHead; |
| |
| CodecEncodeMpeg2SequenceParams *mpeg2Sps = (CodecEncodeMpeg2SequenceParams *)m_encodeCtx->pSeqParams; |
| mpeg2Sps->m_targetUsage = m_encodeCtx->targetUsage; |
| |
| encodeParams.pSeqParams = m_encodeCtx->pSeqParams; |
| encodeParams.pVuiParams = m_encodeCtx->pVuiParams; |
| encodeParams.pPicParams = m_encodeCtx->pPicParams; |
| encodeParams.pSliceParams = m_encodeCtx->pSliceParams; |
| |
| // 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; |
| |
| CODEC_AVC_IQ_MATRIX_PARAMS iqMatrixParams; |
| MOS_STATUS 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; |
| |
| // 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; |
| |
| 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; |
| } |
| |
| // parse quant matrix extension from app |
| VAStatus DdiEncodeMpeg2::Qmatrix(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); |
| |
| VAIQMatrixBufferMPEG2 *qMatrix = (VAQMatrixBufferMPEG2 *)ptr; |
| |
| CodecEncodeMpeg2QmatixParams *mpeg2QParams = (CodecEncodeMpeg2QmatixParams *)m_encodeCtx->pQmatrixParams; |
| DDI_CHK_NULL(mpeg2QParams, "nullptr mpeg2QParams", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| mpeg2QParams->m_newQmatrix[0] = qMatrix->load_intra_quantiser_matrix; |
| mpeg2QParams->m_newQmatrix[1] = qMatrix->load_non_intra_quantiser_matrix; |
| mpeg2QParams->m_newQmatrix[2] = qMatrix->load_chroma_intra_quantiser_matrix; |
| mpeg2QParams->m_newQmatrix[3] = qMatrix->load_chroma_non_intra_quantiser_matrix; |
| |
| if (mpeg2QParams->m_newQmatrix[0]) |
| { |
| for (uint8_t idx = 0; idx < 64; idx++) |
| { |
| mpeg2QParams->m_qmatrix[0][CODEC_AVC_Qmatrix_scan_8x8[idx]] = qMatrix->intra_quantiser_matrix[idx]; |
| } |
| } |
| if (mpeg2QParams->m_newQmatrix[1]) |
| { |
| for (uint8_t idx = 0; idx < 64; idx++) |
| { |
| mpeg2QParams->m_qmatrix[1][CODEC_AVC_Qmatrix_scan_8x8[idx]] = qMatrix->non_intra_quantiser_matrix[idx]; |
| } |
| } |
| if (mpeg2QParams->m_newQmatrix[2]) |
| { |
| for (uint8_t idx = 0; idx < 64; idx++) |
| { |
| mpeg2QParams->m_qmatrix[2][CODEC_AVC_Qmatrix_scan_8x8[idx]] = qMatrix->chroma_intra_quantiser_matrix[idx]; |
| } |
| } |
| if (mpeg2QParams->m_newQmatrix[3]) |
| { |
| for (uint8_t idx = 0; idx < 64; idx++) |
| { |
| mpeg2QParams->m_qmatrix[3][CODEC_AVC_Qmatrix_scan_8x8[idx]] = qMatrix->chroma_non_intra_quantiser_matrix[idx]; |
| } |
| } |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| // reset the parameters before each frame |
| VAStatus DdiEncodeMpeg2::ResetAtFrameLevel() |
| { |
| DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| // Assume there is only one SPS parameter |
| CodecEncodeMpeg2SequenceParams *mpeg2SeqParams = (CodecEncodeMpeg2SequenceParams *)(m_encodeCtx->pSeqParams); |
| DDI_CHK_NULL(mpeg2SeqParams, "nullptr mpeg2SeqParams", VA_STATUS_ERROR_INVALID_PARAMETER); |
| mpeg2SeqParams->m_resetBRC = false; |
| |
| m_encodeCtx->dwNumSlices = 0x0; |
| m_encodeCtx->indexNALUnit = 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; |
| m_encodeCtx->bNewVuiData = false; |
| m_encodeCtx->bMBQpEnable = false; |
| |
| RemoveUserData(); |
| |
| // clear the packed header information |
| if (nullptr != m_encodeCtx->ppNALUnitParams) |
| { |
| MOS_ZeroMemory(m_encodeCtx->ppNALUnitParams[0], sizeof(CODECHAL_NAL_UNIT_PARAMS) * CODEC_ENCODE_MPEG2_MAX_NAL_TYPE); |
| } |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| // parse mepg2 sequence parameters from app |
| VAStatus DdiEncodeMpeg2::ParseSeqParams(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); |
| |
| VAEncSequenceParameterBufferMPEG2 *seqParams = (VAEncSequenceParameterBufferMPEG2 *)ptr; |
| |
| CodecEncodeMpeg2SequenceParams *mpeg2Sps = (CodecEncodeMpeg2SequenceParams *)m_encodeCtx->pSeqParams; |
| |
| CodecEncodeMpeg2PictureParams *halMpeg2PPS = (CodecEncodeMpeg2PictureParams *)m_encodeCtx->pPicParams; |
| DDI_CHK_NULL(mpeg2Sps, "nullptr mpeg2Sps", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(halMpeg2PPS, "nullptr halMpeg2PPS", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| MOS_ZeroMemory(mpeg2Sps, sizeof(CodecEncodeMpeg2SequenceParams)); |
| |
| mpeg2Sps->m_frameWidth = seqParams->picture_width; |
| mpeg2Sps->m_frameHeight = seqParams->picture_height; |
| mpeg2Sps->m_profile = seqParams->sequence_extension.bits.profile_and_level_indication & 0x70; |
| mpeg2Sps->m_level = seqParams->sequence_extension.bits.profile_and_level_indication & 0x0f; |
| mpeg2Sps->m_chromaFormat = seqParams->sequence_extension.bits.chroma_format; |
| mpeg2Sps->m_lowDelay = seqParams->sequence_extension.bits.low_delay; |
| mpeg2Sps->m_noAcceleratorSPSInsertion = false; |
| mpeg2Sps->m_progressiveSequence = seqParams->sequence_extension.bits.progressive_sequence; |
| mpeg2Sps->m_rateControlMethod = VARC2HalRC(m_encodeCtx->uiRCMethod); |
| mpeg2Sps->m_resetBRC = false; // if reset the brc each i frame |
| mpeg2Sps->m_bitrate = seqParams->bits_per_second; |
| mpeg2Sps->m_vbvBufferSize = seqParams->vbv_buffer_size; |
| //set Initial vbv buffer fullness to half of vbv buffer size in byte |
| mpeg2Sps->m_initVBVBufferFullnessInBit = seqParams->vbv_buffer_size * (CODEC_ENCODE_MPEG2_VBV_BUFFER_SIZE_UNITS >> 1); |
| mpeg2Sps->m_maxBitRate = mpeg2Sps->m_bitrate; |
| mpeg2Sps->m_minBitRate = mpeg2Sps->m_bitrate; |
| |
| if ((m_encodeCtx->uiRCMethod == VA_RC_CBR) && (seqParams->vbv_buffer_size > 0)) |
| { |
| //set maxframe size to half of vbv buffer size in byte, in codechal, this value will set the minimum value between this value and picture_with * picture_height |
| mpeg2Sps->m_userMaxFrameSize = seqParams->vbv_buffer_size * (CODEC_ENCODE_MPEG2_VBV_BUFFER_SIZE_UNITS >> 4); |
| } |
| else |
| { |
| mpeg2Sps->m_userMaxFrameSize = seqParams->picture_width * seqParams->picture_height * 3 / 2; |
| } |
| |
| mpeg2Sps->m_aspectRatio = seqParams->aspect_ratio_information; |
| mpeg2Sps->m_frameRateExtD = seqParams->sequence_extension.bits.frame_rate_extension_d; |
| mpeg2Sps->m_frameRateExtN = seqParams->sequence_extension.bits.frame_rate_extension_n; |
| if(seqParams->frame_rate <= 0.0) |
| { |
| DDI_NORMALMESSAGE("invalidate frame rate code, set it to default 30"); |
| seqParams->frame_rate = 30; |
| } |
| mpeg2Sps->m_frameRateCode = (uint32_t)CalculateFramerateCode(seqParams->frame_rate, mpeg2Sps->m_frameRateExtD, mpeg2Sps->m_frameRateExtN); |
| |
| halMpeg2PPS->m_gopPicSize = seqParams->intra_period; |
| halMpeg2PPS->m_gopRefDist = seqParams->ip_period; |
| m_timeCode = seqParams->gop_header.bits.time_code; |
| m_newTimeCode = true; |
| halMpeg2PPS->m_gopOptFlag = seqParams->gop_header.bits.closed_gop; |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| // parse mepg2 picture prarameters from app |
| VAStatus DdiEncodeMpeg2::ParsePicParams( |
| DDI_MEDIA_CONTEXT *mediaCtx, |
| void *ptr) |
| { |
| DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| DDI_CODEC_RENDER_TARGET_TABLE *rtTbl = &(m_encodeCtx->RTtbl); |
| |
| VAEncPictureParameterBufferMPEG2 *picParams = (VAEncPictureParameterBufferMPEG2 *)ptr; |
| |
| CodecEncodeMpeg2PictureParams *mpeg2PicParams = (CodecEncodeMpeg2PictureParams *)(m_encodeCtx->pPicParams); |
| DDI_CHK_NULL(mpeg2PicParams, "nullptr mpeg2PicParams", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| CodecEncodeMpeg2SequenceParams *mpeg2SeqParams = (CodecEncodeMpeg2SequenceParams *)(m_encodeCtx->pSeqParams); |
| DDI_CHK_NULL(mpeg2SeqParams, "nullptr mpeg2SeqParams", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| float frameRate = 0; |
| if ((mpeg2SeqParams->m_frameRateCode > 0) && (mpeg2SeqParams->m_frameRateCode < (sizeof(frameRateTable) / sizeof(frameRateTable[0])))) |
| { |
| //calculate real frame rate from frame_rate_code, frame_rate_extension_n and frame_rate_extension_d |
| frameRate = frameRateTable[mpeg2SeqParams->m_frameRateCode - 1].value * (mpeg2SeqParams->m_frameRateExtN + 1) / (mpeg2SeqParams->m_frameRateExtD + 1); |
| } |
| else |
| { |
| //frame_rate_code is invalid, set frame_rate to 30 defaultly. |
| frameRate = 30.0; |
| } |
| |
| uint32_t frameRateRounded = (uint32_t)(frameRate * 100 + 50) / 100; |
| |
| mpeg2PicParams->m_lastPicInStream = picParams->last_picture; |
| mpeg2PicParams->m_pictureCodingType = picParams->picture_type == VAEncPictureTypeIntra ? I_TYPE : (picParams->picture_type == VAEncPictureTypePredictive ? P_TYPE : B_TYPE); |
| mpeg2PicParams->m_interleavedFieldBFF = !picParams->picture_coding_extension.bits.top_field_first; |
| mpeg2PicParams->m_fieldCodingFlag = false; |
| mpeg2PicParams->m_fieldFrameCodingFlag = (!mpeg2SeqParams->m_progressiveSequence) && (!picParams->picture_coding_extension.bits.progressive_frame); |
| mpeg2PicParams->m_pic4MVallowed = 1; |
| mpeg2PicParams->m_fcode00 = picParams->f_code[0][0]; |
| mpeg2PicParams->m_fcode01 = picParams->f_code[0][1]; |
| mpeg2PicParams->m_fcode10 = picParams->f_code[1][0]; |
| mpeg2PicParams->m_fcode11 = picParams->f_code[1][1]; |
| mpeg2PicParams->m_intraDCprecision = picParams->picture_coding_extension.bits.intra_dc_precision; |
| mpeg2PicParams->m_concealmentMotionVectors = picParams->picture_coding_extension.bits.concealment_motion_vectors; |
| mpeg2PicParams->m_qscaleType = picParams->picture_coding_extension.bits.q_scale_type; //determin quantiser_scale with scale code |
| |
| mpeg2PicParams->m_intraVlcFormat = picParams->picture_coding_extension.bits.intra_vlc_format; |
| mpeg2PicParams->m_alternateScan = picParams->picture_coding_extension.bits.alternate_scan; |
| mpeg2PicParams->m_framePredFrameDCT = picParams->picture_coding_extension.bits.frame_pred_frame_dct; |
| |
| mpeg2PicParams->m_progressiveField = picParams->picture_coding_extension.bits.progressive_frame; |
| mpeg2PicParams->m_repeatFirstField = picParams->picture_coding_extension.bits.repeat_first_field; |
| mpeg2PicParams->m_compositeDisplayFlag = picParams->picture_coding_extension.bits.composite_display_flag; |
| mpeg2PicParams->m_temporalReference = picParams->temporal_reference; |
| mpeg2PicParams->m_vbvDelay = picParams->vbv_delay; |
| |
| if (mpeg2PicParams->m_compositeDisplayFlag == 1) |
| { |
| mpeg2PicParams->m_vaxis = picParams->composite_display.bits.v_axis; |
| mpeg2PicParams->m_fieldSequence = picParams->composite_display.bits.field_sequence; |
| mpeg2PicParams->m_subCarrier = picParams->composite_display.bits.sub_carrier; |
| mpeg2PicParams->m_burstAmplitude = picParams->composite_display.bits.burst_amplitude; |
| mpeg2PicParams->m_subCarrierPhase = picParams->composite_display.bits.sub_carrier_phase; |
| } |
| if ( picParams->reconstructed_picture == VA_INVALID_SURFACE) |
| { |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| auto recon = DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, picParams->reconstructed_picture); |
| DDI_CHK_RET(RegisterRTSurfaces(&m_encodeCtx->RTtbl, recon),"RegisterRTSurfaces failed!"); |
| |
| mpeg2PicParams->m_currReconstructedPic.FrameIdx = GetRenderTargetID(rtTbl, recon); |
| mpeg2PicParams->m_currReconstructedPic.PicFlags = PICTURE_FRAME; |
| |
| // be attention , that codec hal use this value to manager the reference list |
| mpeg2PicParams->m_currOriginalPic.FrameIdx = GetRenderTargetID(rtTbl, recon); |
| mpeg2PicParams->m_currOriginalPic.PicFlags = mpeg2PicParams->m_currReconstructedPic.PicFlags; |
| |
| if (DDI_CODEC_INVALID_FRAME_INDEX != picParams->forward_reference_picture) |
| { |
| auto fwRef = DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, picParams->forward_reference_picture); |
| UpdateRegisteredRTSurfaceFlag(&m_encodeCtx->RTtbl,fwRef); |
| mpeg2PicParams->m_refFrameList[0].FrameIdx = GetRenderTargetID(rtTbl, fwRef); |
| mpeg2PicParams->m_refFrameList[0].PicFlags = PICTURE_FRAME; |
| } |
| else |
| { |
| mpeg2PicParams->m_refFrameList[0].FrameIdx = (uint8_t)DDI_CODEC_INVALID_FRAME_INDEX; |
| mpeg2PicParams->m_refFrameList[0].PicFlags = PICTURE_INVALID; |
| } |
| if (DDI_CODEC_INVALID_FRAME_INDEX != picParams->backward_reference_picture) |
| { |
| auto bwRef = DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, picParams->backward_reference_picture); |
| UpdateRegisteredRTSurfaceFlag(&m_encodeCtx->RTtbl,bwRef); |
| mpeg2PicParams->m_refFrameList[1].FrameIdx = GetRenderTargetID(rtTbl, bwRef); |
| mpeg2PicParams->m_refFrameList[1].PicFlags = PICTURE_FRAME; |
| } |
| else |
| { |
| mpeg2PicParams->m_refFrameList[1].FrameIdx = (uint8_t)DDI_CODEC_INVALID_FRAME_INDEX; |
| mpeg2PicParams->m_refFrameList[1].PicFlags = PICTURE_INVALID; |
| } |
| if (mpeg2PicParams->m_pictureCodingType == I_TYPE) |
| { |
| mpeg2PicParams->m_newGop = true; |
| } |
| else |
| { |
| mpeg2PicParams->m_newGop = false; |
| } |
| rtTbl->pCurrentReconTarget = recon;; |
| |
| DDI_MEDIA_BUFFER *buf = DdiMedia_GetBufferFromVABufferID(mediaCtx, picParams->coded_buf); |
| |
| DDI_CHK_NULL(buf, "nullptr buf", VA_STATUS_ERROR_INVALID_PARAMETER); |
| RemoveFromStatusReportQueue(buf); |
| DdiMedia_MediaBufferToMosResource(buf, &(m_encodeCtx->resBitstreamBuffer)); |
| mpeg2PicParams->m_numSlice = 0; |
| |
| //According to MPEG2 spec, GOP header time_code include 6 fields and the ranges of values are Hour (0~23), Minute(0~59), Marker bit(always 1), Second (0~59), Picuture (0~59), Drop_frame flag( 0 or 1). |
| //split timecode to element |
| uint32_t timeCode = m_timeCode; |
| |
| uint32_t timeCodeDropframe = (timeCode >> 24) & 0x1; |
| |
| uint32_t timeCodeHr = (timeCode >> 19) & 0x1f; |
| |
| uint32_t timeCodeMin = (timeCode >> 13) & 0x3f; |
| |
| uint32_t timeCodeMarkerBit = 0x1; |
| |
| uint32_t timeCodeSec = (timeCode >> 6) & 0x3f; |
| |
| uint32_t timeCodePic = (timeCode)&0x3f; |
| //update each timecode element when parsing new picparams |
| if (false == m_newTimeCode) |
| { |
| timeCodePic++; |
| if (timeCodePic >= frameRateRounded) |
| { |
| timeCodePic = 0; |
| timeCodeSec++; |
| } |
| if (timeCodeSec > maxTimeCodeSec) |
| { |
| timeCodeSec = 0; |
| timeCodeMin++; |
| } |
| if (timeCodeMin > maxTimeCodeMin) |
| { |
| timeCodeMin = 0; |
| timeCodeHr++; |
| } |
| if (timeCodeHr > maxTimeCodeHr) |
| { |
| timeCodeHr = 0; |
| } |
| } |
| else |
| { |
| m_newTimeCode = false; |
| } |
| |
| //fill all updated elements back to timecode in the format used by codechal |
| mpeg2PicParams->m_timeCode = ((timeCodePic & 0x3f) | |
| ((timeCodeSec & 0x3f) << 6) | |
| ((timeCodeMarkerBit & 1) << 12) | |
| ((timeCodeMin & 0x3f) << 13) | |
| ((timeCodeHr & 0x1f) << 19) | |
| (timeCodeDropframe & 1) << 24); |
| |
| m_timeCode = mpeg2PicParams->m_timeCode; |
| mpeg2PicParams->m_skipFrameFlag = 0; |
| mpeg2PicParams->m_numSkipFrames = 0; |
| mpeg2PicParams->m_sizeSkipFrames = 0; |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| // parse mpeg2 slice parameters from app |
| VAStatus DdiEncodeMpeg2::ParseSlcParams( |
| DDI_MEDIA_CONTEXT *mediaCtx, |
| void *ptr, |
| uint32_t numSlices) |
| { |
| DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| VAEncSliceParameterBufferMPEG2 *vaEncSlcParamsMPEG2 = (VAEncSliceParameterBufferMPEG2 *)ptr; |
| |
| CodecEncodeMpeg2SliceParmas *mpeg2SlcParams = (CodecEncodeMpeg2SliceParmas *)m_encodeCtx->pSliceParams; |
| |
| CodecEncodeMpeg2PictureParams *mpeg2PicParams = (CodecEncodeMpeg2PictureParams *)(m_encodeCtx->pPicParams); |
| DDI_CHK_NULL(mpeg2SlcParams, "nullptr mpeg2SlcParams", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(mpeg2PicParams, "nullptr mpeg2PicParams", VA_STATUS_ERROR_INVALID_PARAMETER); |
| |
| // Move to a free MPEG2Slice parameter buffer |
| uint8_t numOfSlices = m_encodeCtx->dwNumSlices; |
| mpeg2SlcParams += numOfSlices; |
| |
| //attention memory area protection |
| MOS_ZeroMemory(mpeg2SlcParams, sizeof(CodecEncodeMpeg2SliceParmas) * numSlices); |
| |
| CodecEncodeMpeg2SequenceParams *mpeg2Sps = (CodecEncodeMpeg2SequenceParams *)m_encodeCtx->pSeqParams; |
| auto picWidthInMb = CODECHAL_GET_WIDTH_IN_MACROBLOCKS(mpeg2Sps->m_frameWidth); |
| |
| for (uint32_t slcCount = 0; slcCount < numSlices; slcCount++) |
| { |
| mpeg2SlcParams->m_numMbsForSlice = vaEncSlcParamsMPEG2->num_macroblocks; |
| mpeg2SlcParams->m_firstMbX = (vaEncSlcParamsMPEG2->macroblock_address % picWidthInMb); |
| mpeg2SlcParams->m_firstMbY = vaEncSlcParamsMPEG2->macroblock_address / picWidthInMb; |
| mpeg2SlcParams->m_intraSlice = vaEncSlcParamsMPEG2->is_intra_slice; |
| mpeg2SlcParams->m_quantiserScaleCode = vaEncSlcParamsMPEG2->quantiser_scale_code; |
| mpeg2SlcParams++; |
| vaEncSlcParamsMPEG2++; |
| } |
| m_encodeCtx->dwNumSlices += numSlices; |
| mpeg2PicParams->m_numSlice = m_encodeCtx->dwNumSlices; |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| // Since sequence header and picture header will be packed in codechal, we don't support packed header from application |
| VAStatus DdiEncodeMpeg2::ParsePackedHeaderParams(void *ptr) |
| { |
| DDI_CHK_NULL(ptr, "invalid paked header pointer", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(m_encodeCtx, "invalid encode context", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| VAEncPackedHeaderParameterBuffer *packedHeaderParamBuf = (VAEncPackedHeaderParameterBuffer *)ptr; |
| if (packedHeaderParamBuf->type != VAEncPackedHeaderRawData) |
| { |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| |
| CodecEncodeMpeg2UserDataList *userDataNode = (CodecEncodeMpeg2UserDataList *)MOS_AllocAndZeroMemory(sizeof(CodecEncodeMpeg2UserDataList)); |
| DDI_CHK_NULL(userDataNode, "nullptr userDataNode.", VA_STATUS_ERROR_ALLOCATION_FAILED); |
| |
| if (nullptr == m_userDataListHead) |
| { |
| m_userDataListHead = userDataNode; |
| m_userDataListTail = nullptr; |
| } |
| if (m_userDataListTail) |
| { |
| CodecEncodeMpeg2UserDataList *userDataListTail = (CodecEncodeMpeg2UserDataList *)m_userDataListTail; |
| userDataListTail->m_nextItem = userDataNode; |
| } |
| m_userDataListTail = userDataNode; |
| |
| uint32_t size = (packedHeaderParamBuf->bit_length + 7) >> 3; |
| userDataNode->m_userData = MOS_AllocAndZeroMemory(size); |
| if (nullptr == userDataNode->m_userData) |
| { |
| MOS_FreeMemory(userDataNode); |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| userDataNode->m_userDataSize = size; |
| |
| return VA_STATUS_SUCCESS; |
| } |
| // Since sequence header and picture header will be packed in codechal, we don't support packed header from application |
| VAStatus DdiEncodeMpeg2::ParsePackedHeaderData(void *ptr) |
| { |
| DDI_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER); |
| DDI_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| CodecEncodeMpeg2UserDataList *userDataListTail = (CodecEncodeMpeg2UserDataList *)m_userDataListTail; |
| if (userDataListTail && userDataListTail->m_userDataSize) |
| { |
| MOS_SecureMemcpy( |
| userDataListTail->m_userData, |
| userDataListTail->m_userDataSize, |
| ptr, |
| userDataListTail->m_userDataSize); |
| return VA_STATUS_SUCCESS; |
| } |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| |
| // it should be named DdiMpeg2Encode_ParseMiscParamVBV, because HRD is used by AVC, VBV is used by MPEG2 |
| void DdiEncodeMpeg2::ParseMiscParamVBV(void *data) |
| { |
| VAEncMiscParameterHRD *vaEncMiscParamHRD = (VAEncMiscParameterHRD *)data; |
| |
| CodecEncodeMpeg2SequenceParams *mpeg2SeqParams = (CodecEncodeMpeg2SequenceParams *)m_encodeCtx->pSeqParams; |
| |
| mpeg2SeqParams->m_vbvBufferSize = vaEncMiscParamHRD->buffer_size / CODEC_ENCODE_MPEG2_VBV_BUFFER_SIZE_UNITS; |
| mpeg2SeqParams->m_initVBVBufferFullnessInBit = vaEncMiscParamHRD->initial_buffer_fullness; |
| //mpeg2SeqParams->m_rateControlMethod = RATECONTROL_CBR; |
| } |
| |
| // Parse the frame rate paramters from app |
| void DdiEncodeMpeg2::ParseMiscParamFR(void *data) |
| { |
| CodecEncodeMpeg2SequenceParams *mpeg2SeqParams = (CodecEncodeMpeg2SequenceParams *)(m_encodeCtx->pSeqParams); |
| |
| VAEncMiscParameterFrameRate *vaencMiscParamFR = (VAEncMiscParameterFrameRate *)data; |
| |
| float frameRate = (float)(vaencMiscParamFR->framerate & 0xffff); |
| uint32_t denominator = (vaencMiscParamFR->framerate >> 16) & 0xffff; |
| if(denominator == 0) |
| { |
| denominator = 1; |
| } |
| frameRate = frameRate / denominator; |
| if(frameRate <= 0.0) |
| { |
| DDI_NORMALMESSAGE("invalidate frame rate code, set it to default 30"); |
| frameRate = 30; |
| } |
| mpeg2SeqParams->m_frameRateCode = (uint32_t)CalculateFramerateCode(frameRate, |
| mpeg2SeqParams->m_frameRateExtD, |
| mpeg2SeqParams->m_frameRateExtN); |
| } |
| |
| // Parse rate control related information from app |
| void DdiEncodeMpeg2::ParseMiscParamRC(void *data) |
| { |
| VAEncMiscParameterRateControl *vaEncMiscParamRC = (VAEncMiscParameterRateControl *)data; |
| |
| CodecEncodeMpeg2SequenceParams *mpeg2SeqParams = (CodecEncodeMpeg2SequenceParams *)(m_encodeCtx->pSeqParams); |
| |
| mpeg2SeqParams->m_bitrate = MOS_ROUNDUP_DIVIDE(vaEncMiscParamRC->bits_per_second, CODECHAL_ENCODE_BRC_KBPS); |
| |
| if (VA_RC_CQP == m_encodeCtx->uiRCMethod) |
| { |
| mpeg2SeqParams->m_rateControlMethod = (RATECONTROL_CBR | RATECONTROL_VBR); |
| } |
| |
| if (VA_RC_CBR == m_encodeCtx->uiRCMethod) |
| { |
| mpeg2SeqParams->m_maxBitRate = mpeg2SeqParams->m_bitrate; |
| mpeg2SeqParams->m_minBitRate = mpeg2SeqParams->m_bitrate; |
| mpeg2SeqParams->m_rateControlMethod = RATECONTROL_CBR; |
| } |
| else |
| { |
| mpeg2SeqParams->m_maxBitRate = mpeg2SeqParams->m_bitrate; |
| if (vaEncMiscParamRC->target_percentage > 50) |
| { |
| mpeg2SeqParams->m_minBitRate = mpeg2SeqParams->m_bitrate * (2 * vaEncMiscParamRC->target_percentage - 100) / 100; |
| } |
| else |
| { |
| mpeg2SeqParams->m_minBitRate = 0; |
| } |
| |
| mpeg2SeqParams->m_bitrate = mpeg2SeqParams->m_bitrate * vaEncMiscParamRC->target_percentage / 100; |
| mpeg2SeqParams->m_rateControlMethod = RATECONTROL_VBR; |
| |
| if ((m_encodeCtx->uiTargetBitRate != mpeg2SeqParams->m_bitrate) || |
| (m_encodeCtx->uiMaxBitRate != mpeg2SeqParams->m_maxBitRate)) |
| { |
| mpeg2SeqParams->m_resetBRC = 0x1; |
| m_encodeCtx->uiTargetBitRate = mpeg2SeqParams->m_bitrate; |
| m_encodeCtx->uiMaxBitRate = mpeg2SeqParams->m_maxBitRate; |
| } |
| } |
| } |
| |
| // Parse some other parameters, now there are no Private data from APP |
| void DdiEncodeMpeg2::ParseMiscParamEncQuality(void *data) |
| { |
| VAEncMiscParameterEncQuality *vaEncMiscParamEncQuality = (VAEncMiscParameterEncQuality *)data; |
| |
| CodecEncodeMpeg2SequenceParams *mpeg2SeqParams = (CodecEncodeMpeg2SequenceParams *)(m_encodeCtx->pSeqParams); |
| |
| mpeg2SeqParams->m_forcePanicModeControl = 1; |
| mpeg2SeqParams->m_panicModeDisable = (uint8_t)vaEncMiscParamEncQuality->PanicModeDisable; |
| |
| } |
| |
| void DdiEncodeMpeg2::ParseMiscParamEncQualityLevel(void *data) |
| { |
| VAEncMiscParameterBufferQualityLevel *vaMiscParamQualityLevel = (VAEncMiscParameterBufferQualityLevel*) data; |
| m_encodeCtx->targetUsage= vaMiscParamQualityLevel->quality_level; |
| // check TU, correct to default if wrong |
| if ((m_encodeCtx->targetUsage > TARGETUSAGE_BEST_SPEED) || |
| (0 == m_encodeCtx->targetUsage)) |
| { |
| m_encodeCtx->targetUsage = TARGETUSAGE_RT_SPEED; |
| DDI_ASSERTMESSAGE("Target usage from application is not correct, should be in [0,7]!\n"); |
| } |
| } |
| |
| void DdiEncodeMpeg2::ParseMiscParamMaxFrame(void *data) |
| { |
| if (nullptr == m_encodeCtx || nullptr == data) |
| { |
| DDI_ASSERTMESSAGE("invalidate input parameters."); |
| return; |
| } |
| |
| CodecEncodeMpeg2SequenceParams *mpeg2SeqParams = (CodecEncodeMpeg2SequenceParams *)(m_encodeCtx->pSeqParams); |
| |
| VAEncMiscParameterBufferMaxFrameSize *maxFrameSize = (VAEncMiscParameterBufferMaxFrameSize *)data; |
| |
| mpeg2SeqParams->m_userMaxFrameSize = maxFrameSize->max_frame_size; |
| } |
| |
| void DdiEncodeMpeg2::ParseMiscParamTypeExtension(void *data) |
| { |
| if (nullptr == m_encodeCtx || nullptr == data) |
| { |
| DDI_ASSERTMESSAGE("invalidate input parameters."); |
| return; |
| } |
| |
| CodecEncodeMpeg2VuiParams *mpeg2VuiParams = (CodecEncodeMpeg2VuiParams *)(m_encodeCtx->pVuiParams); |
| |
| VAEncMiscParameterExtensionDataSeqDisplayMPEG2 *displayExt = (VAEncMiscParameterExtensionDataSeqDisplayMPEG2 *)data; |
| |
| if (displayExt->extension_start_code_identifier != Mpeg2sequenceDisplayExtension) |
| { |
| return; |
| } |
| |
| m_encodeCtx->bNewVuiData = true; |
| mpeg2VuiParams->m_videoFormat = displayExt->video_format; |
| mpeg2VuiParams->m_colourDescription = displayExt->colour_description; |
| mpeg2VuiParams->m_colourPrimaries = displayExt->colour_primaries; |
| mpeg2VuiParams->m_transferCharacteristics = displayExt->transfer_characteristics; |
| mpeg2VuiParams->m_matrixCoefficients = displayExt->matrix_coefficients; |
| mpeg2VuiParams->m_displayHorizontalSize = displayExt->display_horizontal_size; |
| mpeg2VuiParams->m_displayVerticalSize = displayExt->display_vertical_size; |
| } |
| |
| // parse VAEncMiscParameterSkipFrame to PCODEC_MPEG2_ENCODE_PIC_PARAMS |
| void DdiEncodeMpeg2::ParseMiscParamSkipFrame(void *data) |
| { |
| if (nullptr == m_encodeCtx || nullptr == data) |
| { |
| DDI_ASSERTMESSAGE("invalidate input parameters."); |
| return; |
| } |
| |
| // Assume only one PPS here, modify when enable multiple PPS support |
| CodecEncodeMpeg2PictureParams *mpeg2PicParams = (CodecEncodeMpeg2PictureParams *)(m_encodeCtx->pPicParams); |
| |
| VAEncMiscParameterSkipFrame *vaEncMiscParamSkipFrame = (VAEncMiscParameterSkipFrame *)data; |
| |
| if (nullptr == mpeg2PicParams) |
| { |
| DDI_ASSERTMESSAGE("invalidate mpeg2 picture header."); |
| return; |
| } |
| //MPEG2 only support normal skip frame |
| if (FRAME_SKIP_NORMAL < mpeg2PicParams->m_skipFrameFlag) |
| { |
| DDI_ASSERTMESSAGE("invalidate input parameters, skip_frame_flag should equal to 0 or 1."); |
| return; |
| } |
| |
| // populate skipped frame params from DDI |
| mpeg2PicParams->m_skipFrameFlag = vaEncMiscParamSkipFrame->skip_frame_flag; |
| mpeg2PicParams->m_numSkipFrames = vaEncMiscParamSkipFrame->num_skip_frames; |
| mpeg2PicParams->m_sizeSkipFrames = vaEncMiscParamSkipFrame->size_skip_frames; |
| } |
| |
| // Parse Misc Params |
| VAStatus DdiEncodeMpeg2::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); |
| |
| switch ((int32_t)(miscParamBuf->type)) |
| { |
| case VAEncMiscParameterTypeHRD: |
| { |
| ParseMiscParamVBV((void *)miscParamBuf->data); |
| break; |
| } |
| case VAEncMiscParameterTypeFrameRate: |
| { |
| ParseMiscParamFR((void *)miscParamBuf->data); |
| break; |
| } |
| case VAEncMiscParameterTypeRateControl: |
| { |
| ParseMiscParamRC((void *)miscParamBuf->data); |
| break; |
| } |
| case VAEncMiscParameterTypeEncQuality: |
| { |
| ParseMiscParamEncQuality((void *)miscParamBuf->data); |
| break; |
| } |
| case VAEncMiscParameterTypeMaxFrameSize: |
| { |
| ParseMiscParamMaxFrame((void *)miscParamBuf->data); |
| break; |
| } |
| case VAEncMiscParameterTypeExtensionData: |
| { |
| ParseMiscParamTypeExtension((void *)miscParamBuf->data); |
| break; |
| } |
| case VAEncMiscParameterTypeSkipFrame: |
| { |
| ParseMiscParamSkipFrame((void *)miscParamBuf->data); |
| break; |
| } |
| case VAEncMiscParameterTypeQualityLevel: |
| { |
| ParseMiscParamEncQualityLevel((void *)miscParamBuf->data); |
| break; |
| } |
| |
| default: |
| { |
| DDI_ASSERTMESSAGE("DDI: unsupported misc parameter type."); |
| return VA_STATUS_ERROR_FLAG_NOT_SUPPORTED; |
| } |
| } |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| // get framerate code from frame rate value; |
| // frame_rate = frame_rate_value * (frame_rate_extension_n + 1) (frame_rate_extension_d + 1) |
| uint32_t DdiEncodeMpeg2::CalculateFramerateCode( |
| float frameRate, |
| uint8_t frameRateExtD, |
| uint8_t frameRateExtN) |
| { |
| if (frameRate <= 0.0) |
| { |
| return 0; |
| } |
| |
| float frameRateValue = frameRate * (frameRateExtD + 1) / (frameRateExtN + 1); |
| |
| uint32_t delta = 0xffffffff; |
| uint32_t frameRateCode = 0; |
| for (uint32_t i = 0; i < sizeof(frameRateTable) / sizeof(frameRateTable[0]); i++) |
| { |
| float tempResidual = frameRateTable[i].value - frameRateValue; |
| tempResidual = tempResidual < 0 ? -tempResidual : tempResidual; |
| |
| uint32_t residual = (uint32_t)(tempResidual * 1000); |
| if (residual < delta) |
| { |
| delta = residual; |
| frameRateCode = frameRateTable[i].code; |
| } |
| } |
| // if the gap from spec and custom requirement is too huge, error will be report |
| if (delta > 1000) |
| { |
| return 0; |
| } |
| else |
| { |
| return frameRateCode; |
| } |
| } |
| |
| VAStatus DdiEncodeMpeg2::RemoveUserData() |
| { |
| DDI_CHK_NULL(m_encodeCtx, "invalid encode context", VA_STATUS_ERROR_INVALID_CONTEXT); |
| |
| if (m_userDataListHead) |
| { |
| CodecEncodeMpeg2UserDataList *cur = nullptr; |
| CodecEncodeMpeg2UserDataList *next = nullptr; |
| for (cur = (CodecEncodeMpeg2UserDataList *)m_userDataListHead; cur != nullptr; cur = next) |
| { |
| next = cur->m_nextItem; |
| MOS_FreeMemory(cur->m_userData); |
| MOS_FreeMemory(cur); |
| } |
| m_userDataListHead = nullptr; |
| m_userDataListTail = nullptr; |
| } |
| return VA_STATUS_SUCCESS; |
| } |
| |
| uint32_t DdiEncodeMpeg2::getSliceParameterBufferSize() |
| { |
| return sizeof(VAEncSliceParameterBufferMPEG2); |
| } |
| |
| uint32_t DdiEncodeMpeg2::getSequenceParameterBufferSize() |
| { |
| return sizeof(VAEncSequenceParameterBufferMPEG2); |
| } |
| |
| uint32_t DdiEncodeMpeg2::getPictureParameterBufferSize() |
| { |
| return sizeof(VAEncPictureParameterBufferMPEG2); |
| } |
| |
| uint32_t DdiEncodeMpeg2::getQMatrixBufferSize() |
| { |
| return sizeof(VAIQMatrixBufferMPEG2); |
| } |
