BPI/BPI-CM9-Linux
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
3428a94f6b57d8d41235a742c5b29defce11fc93
BPI-CM9-Linux/aml-comp/hardware/amlogic/libencoder/multiEnc/vpuapi/product.c
T

1145 lines
35 KiB
C
Raw Normal View History

Import complete source tree
2026-08-13 11:28:40 +08:00
/*
* Copyright (c) 2019 Amlogic, Inc. All rights reserved.
*
* This source code is subject to the terms and conditions defined in below
* which is part of this source code package.
*
* Description:
*/
// Copyright (C) 2019 Amlogic, Inc. All rights reserved.
//
// All information contained herein is Amlogic confidential.
//
// This software is provided to you pursuant to Software License
// Agreement (SLA) with Amlogic Inc ("Amlogic"). This software may be
// used only in accordance with the terms of this agreement.
//
// Redistribution and use in source and binary forms, with or without
// modification is strictly prohibited without prior written permission
// from Amlogic.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "product.h"
#include "enc_driver.h"
#include "vdi_osal.h"
VpuAttr g_VpuCoreAttributes[MAX_NUM_VPU_CORE];
static Int32 s_ProductIds[MAX_NUM_VPU_CORE] = {
PRODUCT_ID_NONE,
};
typedef struct FrameBufInfoStruct {
Uint32 unitSizeHorLuma;
Uint32 sizeLuma;
Uint32 sizeChroma;
BOOL fieldMap;
} FrameBufInfo;
Uint32 ProductVpuScan(Uint32 coreIdx)
{
Uint32 i, productId;
Uint32 foundProducts = 0;
/* Already scanned */
if (s_ProductIds[coreIdx] != PRODUCT_ID_NONE)
return 1;
for (i=0; i<MAX_NUM_VPU_CORE; i++) {
productId = VpVpuGetProductId(i);
if (productId != PRODUCT_ID_NONE) {
s_ProductIds[i] = productId;
foundProducts++;
}
}
return (foundProducts >= 1);
}
Int32 ProductVpuGetId(Uint32 coreIdx)
{
return s_ProductIds[coreIdx];
}
RetCode ProductVpuGetVersion(
Uint32 coreIdx,
Uint32* versionInfo,
Uint32* revision
)
{
Int32 productId = s_ProductIds[coreIdx];
RetCode ret = RETCODE_SUCCESS;
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
ret = Vp5VpuGetVersion(coreIdx, versionInfo, revision);
break;
default:
ret = RETCODE_NOT_FOUND_VPU_DEVICE;
}
return ret;
}
RetCode ProductVpuGetProductInfo(
Uint32 coreIdx,
VpuAttr* attr
)
{
Int32 productId;
RetCode ret = RETCODE_SUCCESS;
if (coreIdx >= MAX_NUM_VPU_CORE)
return RETCODE_INVALID_PARAM;
if (attr == NULL)
return RETCODE_INVALID_PARAM;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
osal_memcpy((void*)attr, (void*)&g_VpuCoreAttributes[coreIdx], sizeof(VpuAttr));
break;
default:
ret = RETCODE_NOT_FOUND_VPU_DEVICE;
}
return ret;
}
RetCode ProductVpuInit(Uint32 coreIdx, void* firmware, Uint32 size)
{
RetCode ret = RETCODE_SUCCESS;
int productId;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
ret = Vp5VpuInit(coreIdx, firmware, size);
break;
default:
ret = RETCODE_NOT_FOUND_VPU_DEVICE;
}
return ret;
}
RetCode ProductVpuReInit(Uint32 coreIdx, void* firmware, Uint32 size)
{
RetCode ret = RETCODE_SUCCESS;
int productId;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
ret = Vp5VpuReInit(coreIdx, firmware, size);
break;
default:
ret = RETCODE_NOT_FOUND_VPU_DEVICE;
}
return ret;
}
Uint32 ProductVpuIsInit(Uint32 coreIdx)
{
Uint32 pc = 0;
int productId;
productId = s_ProductIds[coreIdx];
if (productId == PRODUCT_ID_NONE) {
ProductVpuScan(coreIdx);
productId = s_ProductIds[coreIdx];
}
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
pc = Vp5VpuIsInit(coreIdx);
break;
}
return pc;
}
Int32 ProductVpuIsBusy(Uint32 coreIdx)
{
Int32 busy;
int productId;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
busy = Vp5VpuIsBusy(coreIdx);
break;
default:
busy = 0;
break;
}
return busy;
}
Int32 ProductVpuWaitInterrupt(CodecInst *instance, Int32 timeout)
{
int productId;
int flag = -1;
productId = s_ProductIds[instance->coreIdx];
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
flag = Vp5VpuWaitInterrupt(instance, timeout, FALSE);
break;
default:
flag = -1;
break;
}
return flag;
}
RetCode ProductVpuReset(Uint32 coreIdx, SWResetMode resetMode)
{
int productId;
RetCode ret = RETCODE_SUCCESS;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
ret = Vp5VpuReset(coreIdx, resetMode);
break;
default:
ret = RETCODE_NOT_FOUND_VPU_DEVICE;
break;
}
return ret;
}
RetCode ProductVpuSleepWake(Uint32 coreIdx, int iSleepWake, const Uint16* code, Uint32 size)
{
int productId;
RetCode ret = RETCODE_NOT_FOUND_VPU_DEVICE;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
ret = Vp5VpuSleepWake(coreIdx, iSleepWake, (void*)code, size);
break;
}
return ret;
}
RetCode ProductVpuClearInterrupt(Uint32 coreIdx, Uint32 flags)
{
int productId;
RetCode ret = RETCODE_NOT_FOUND_VPU_DEVICE;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
ret = Vp5VpuClearInterrupt(coreIdx, flags);
break;
}
return ret;
}
RetCode ProductVpuEncUpdateBitstreamBuffer(CodecInst* instance, Int32 size)
{
Int32 productId;
Uint32 coreIdx;
RetCode ret = RETCODE_SUCCESS;
BOOL updateNewbsBuf = (BOOL)(size == 0);
coreIdx = instance->coreIdx;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_521:
ret = Vp5VpuEncUpdateBS(instance, updateNewbsBuf);
break;
default:
ret = RETCODE_NOT_FOUND_VPU_DEVICE;
}
return ret;
}
RetCode ProductVpuEncGetRdWrPtr(CodecInst* instance, PhysicalAddress* rdPtr, PhysicalAddress* wrPtr)
{
Int32 productId;
Uint32 coreIdx;
EncInfo* pEncInfo;
RetCode ret = RETCODE_SUCCESS;
pEncInfo = VPU_HANDLE_TO_ENCINFO(instance);
coreIdx = instance->coreIdx;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_521:
ret = Vp5VpuEncGetRdWrPtr(instance, rdPtr, wrPtr);
if (ret != RETCODE_SUCCESS) {
*rdPtr = pEncInfo->streamRdPtr;
*wrPtr = pEncInfo->streamWrPtr;
}
else {
pEncInfo->streamRdPtr = *rdPtr;
pEncInfo->streamWrPtr = *wrPtr;
}
break;
default:
*wrPtr = pEncInfo->streamWrPtr;
*rdPtr = pEncInfo->streamRdPtr;
break;
}
return ret;
}
RetCode ProductVpuEncBuildUpOpenParam(CodecInst* pCodec, EncOpenParam* param)
{
Int32 productId;
Uint32 coreIdx;
RetCode ret = RETCODE_NOT_SUPPORTED_FEATURE;
coreIdx = pCodec->coreIdx;
productId = s_ProductIds[coreIdx];
switch (productId) {
case PRODUCT_ID_521:
ret = Vp5VpuBuildUpEncParam(pCodec, param);
break;
default:
ret = RETCODE_NOT_SUPPORTED_FEATURE;
}
return ret;
}
/**
* \param stride stride of framebuffer in pixel.
*/
RetCode ProductVpuAllocateFramebuffer(
CodecInst* inst, FrameBuffer* fbArr, TiledMapType mapType, Int32 num,
Int32 stride, Int32 height, FrameBufferFormat format,
BOOL cbcrInterleave, BOOL nv21, Int32 endian,
vpu_buffer_t* vb, Int32 gdiIndex,
FramebufferAllocType fbType)
{
Int32 i;
vpu_buffer_t vbFrame;
FrameBufInfo fbInfo;
DecInfo* pDecInfo = &inst->CodecInfo->decInfo;
EncInfo* pEncInfo = &inst->CodecInfo->encInfo;
// Variables for TILED_FRAME/FILED_MB_RASTER
Uint32 sizeLuma;
Uint32 sizeChroma;
RetCode ret = RETCODE_SUCCESS;
osal_memset((void*)&vbFrame, 0x00, sizeof(vpu_buffer_t));
osal_memset((void*)&fbInfo, 0x00, sizeof(FrameBufInfo));
DRAMConfig* bufferConfig = NULL;
sizeLuma = CalcLumaSize(inst, inst->productId, stride, height, format, cbcrInterleave, mapType, bufferConfig);
sizeChroma = CalcChromaSize(inst, inst->productId, stride, height, format, cbcrInterleave, mapType, bufferConfig);
// Framebuffer common informations
for (i=0; i<num; i++) {
if (fbArr[i].updateFbInfo == TRUE ) {
fbArr[i].updateFbInfo = FALSE;
fbArr[i].myIndex = i+gdiIndex;
fbArr[i].stride = stride;
fbArr[i].height = height;
fbArr[i].mapType = mapType;
fbArr[i].format = format;
fbArr[i].cbcrInterleave = (mapType >= COMPRESSED_FRAME_MAP ? TRUE : cbcrInterleave);
fbArr[i].nv21 = nv21;
fbArr[i].endian = (mapType >= COMPRESSED_FRAME_MAP ? VDI_128BIT_LITTLE_ENDIAN : endian);
fbArr[i].lumaBitDepth = pDecInfo->initialInfo.lumaBitdepth;
fbArr[i].chromaBitDepth = pDecInfo->initialInfo.chromaBitdepth;
fbArr[i].bufYSize = sizeLuma;
if ( cbcrInterleave == TRUE ) {
fbArr[i].bufCbSize = sizeChroma*2;
fbArr[i].bufCrSize = 0;
}
else {
fbArr[i].bufCbSize = sizeChroma;
fbArr[i].bufCrSize = sizeChroma;
}
fbArr[i].sourceLBurstEn = FALSE;
if(inst->codecMode == W_HEVC_ENC || inst->codecMode == W_SVAC_ENC || inst->codecMode == W_AVC_ENC) {
fbArr[i].endian = (mapType >= COMPRESSED_FRAME_MAP ? VDI_128BIT_LITTLE_ENDIAN : endian);
fbArr[i].lumaBitDepth = pEncInfo->openParam.EncStdParam.vpParam.internalBitDepth;
fbArr[i].chromaBitDepth = pEncInfo->openParam.EncStdParam.vpParam.internalBitDepth;
}
}
}
switch (mapType) {
case LINEAR_FRAME_MAP:
case LINEAR_FIELD_MAP:
case COMPRESSED_FRAME_MAP:
ret = UpdateFrameBufferAddr(mapType, fbArr, num, sizeLuma, sizeChroma);
//if (ret != RETCODE_SUCCESS)
//break;
break;
default:
/* Tiled map */
VLOG(ERR, "shall not reach Tile map vb %p fbType %d \n",vb, fbType);
break;
}
for (i=0; i<num; i++) {
if(inst->codecMode == W_HEVC_ENC || inst->codecMode == W_SVAC_ENC || inst->codecMode == W_AVC_ENC) {
if (gdiIndex != 0) { // FB_TYPE_PPU
APIDPRINT("SOURCE FB[%02d] Y(0x%08x), Cb(0x%08x), Cr(0x%08x)\n", i, fbArr[i].bufY, fbArr[i].bufCb, fbArr[i].bufCr);
}
}
}
return ret;
}
RetCode ProductVpuRegisterFramebuffer(CodecInst* instance)
{
RetCode ret = RETCODE_FAILURE;
FrameBuffer* fb;
Int32 gdiIndex = 0;
EncInfo* pEncInfo = &instance->CodecInfo->encInfo;
switch (instance->productId) {
default:
{
// ENCODER
if (pEncInfo->mapType < COMPRESSED_FRAME_MAP)
return RETCODE_NOT_SUPPORTED_FEATURE;
fb = pEncInfo->frameBufPool;
if (instance->codecMode == W_SVAC_ENC && pEncInfo->openParam.EncStdParam.vpParam.svcEnable == TRUE) { // for BL
gdiIndex = pEncInfo->numFrameBuffers;
ret = Vp5VpuEncRegisterFramebuffer(instance, &fb[gdiIndex], COMPRESSED_FRAME_MAP_SVAC_SVC_BL, pEncInfo->numFrameBuffers);
if (ret != RETCODE_SUCCESS)
break;
}
gdiIndex = 0; // for EL
ret = Vp5VpuEncRegisterFramebuffer(instance, &fb[gdiIndex], COMPRESSED_FRAME_MAP, pEncInfo->numFrameBuffers);
if (ret != RETCODE_SUCCESS)
return ret;
}
break;
}
return ret;
}
Int32 ProductCalculateFrameBufSize(CodecInst* inst, Int32 productId, Int32 stride, Int32 height, TiledMapType mapType, FrameBufferFormat format, BOOL interleave, DRAMConfig* pDramCfg)
{
Int32 size_dpb_lum, size_dpb_chr, size_dpb_all;
size_dpb_lum = CalcLumaSize(inst, productId, stride, height, format, interleave, mapType, pDramCfg);
size_dpb_chr = CalcChromaSize(inst, productId, stride, height, format, interleave, mapType, pDramCfg);
if (mapType < COMPRESSED_FRAME_MAP)
size_dpb_all = size_dpb_lum + size_dpb_chr*2;
else
size_dpb_all = size_dpb_lum + size_dpb_chr;
return size_dpb_all;
}
Int32 ProductCalculateAuxBufferSize(AUX_BUF_TYPE type, CodStd codStd, Int32 width, Int32 height)
{
Int32 size = 0;
switch (type) {
case AUX_BUF_TYPE_MVCOL:
if (codStd == STD_AVC || codStd == STD_VC1 || codStd == STD_MPEG4 || codStd == STD_H263 || codStd == STD_RV || codStd == STD_AVS ) {
size = VPU_ALIGN32(width)*VPU_ALIGN32(height);
size = (size*3)/2;
size = (size+4)/5;
size = ((size+7)/8)*8;
}
else if (codStd == STD_HEVC) {
size = VP5_DEC_HEVC_MVCOL_BUF_SIZE(width, height);
}
else if (codStd == STD_VP9) {
size = VP5_DEC_VP9_MVCOL_BUF_SIZE(width, height);
}
else if (codStd == STD_AVS2) {
size = VP5_DEC_AVS2_MVCOL_BUF_SIZE(width, height);
}
else {
size = 0;
}
break;
case AUX_BUF_TYPE_FBC_Y_OFFSET:
size = VP5_FBC_LUMA_TABLE_SIZE(width, height);
break;
case AUX_BUF_TYPE_FBC_C_OFFSET:
size = VP5_FBC_CHROMA_TABLE_SIZE(width, height);
break;
}
return size;
}
RetCode ProductVpuGetBandwidth(CodecInst* instance, VPUBWData* data)
{
if (data == 0) {
return RETCODE_INVALID_PARAM;
}
if (instance->productId < PRODUCT_ID_512)
return RETCODE_INVALID_COMMAND;
return Vp5VpuGetBwReport(instance, data);
}
RetCode ProductVpuGetDebugInfo(CodecInst* instance, VPUDebugInfo* info)
{
if (info == 0) {
return RETCODE_INVALID_PARAM;
}
if (instance->productId < PRODUCT_ID_512)
return RETCODE_INVALID_COMMAND;
return Vp5VpuGetDebugInfo(instance, info);
}
/************************************************************************/
/* ENCODER */
/************************************************************************/
RetCode ProductVpuGetSrcBufFlag(CodecInst* instance, Uint32* flag)
{
if (instance->productId < PRODUCT_ID_521)
return RETCODE_INVALID_COMMAND;
return Vp5VpuGetSrcBufFlag(instance, flag);
}
RetCode ProductCheckEncOpenParam(EncOpenParam* pop)
{
Int32 coreIdx;
Int32 picWidth;
Int32 picHeight;
Int32 productId;
VpuAttr* pAttr;
if (pop == 0)
return RETCODE_INVALID_PARAM;
if (pop->coreIdx >= MAX_NUM_VPU_CORE)
return RETCODE_INVALID_PARAM;
coreIdx = pop->coreIdx;
picWidth = pop->picWidth;
picHeight = pop->picHeight;
productId = s_ProductIds[coreIdx];
pAttr = &g_VpuCoreAttributes[coreIdx];
if ( pop->bitstreamFormat == STD_AVC && pop->srcBitDepth == 10 && pAttr->supportAVC10bitEnc != TRUE )
return RETCODE_NOT_SUPPORTED_FEATURE;
if ( pop->bitstreamFormat == STD_HEVC && pop->srcBitDepth == 10 && pAttr->supportHEVC10bitEnc != TRUE )
return RETCODE_NOT_SUPPORTED_FEATURE;
if ((pAttr->supportEncoders&(1<<pop->bitstreamFormat)) == 0)
return RETCODE_NOT_SUPPORTED_FEATURE;
if (pop->ringBufferEnable == TRUE) {
if (pop->bitstreamBuffer % 8) {
return RETCODE_INVALID_PARAM;
}
if (productId == PRODUCT_ID_521) {
if (pop->bitstreamBuffer % 16)
return RETCODE_INVALID_PARAM;
}
if (productId == PRODUCT_ID_521) {
if (pop->bitstreamBufferSize < (1024*64)) {
return RETCODE_INVALID_PARAM;
}
}
if (pop->bitstreamBufferSize % 1024 || pop->bitstreamBufferSize < 1024)
return RETCODE_INVALID_PARAM;
}
if (pop->frameRateInfo == 0)
return RETCODE_INVALID_PARAM;
if (pop->bitstreamFormat == STD_AVC) {
if (productId == PRODUCT_ID_980) {
if (pop->bitRate > 524288 || pop->bitRate < 0)
return RETCODE_INVALID_PARAM;
}
}
else if (pop->bitstreamFormat == STD_HEVC || pop->bitstreamFormat == STD_SVAC) {
if ( productId == PRODUCT_ID_521) {
if (pop->bitRate > 700000000 || pop->bitRate < 0)
return RETCODE_INVALID_PARAM;
}
}
else {
if (pop->bitRate > 32767 || pop->bitRate < 0)
return RETCODE_INVALID_PARAM;
}
if (pop->frameSkipDisable != 0 && pop->frameSkipDisable != 1)
return RETCODE_INVALID_PARAM;
if (pop->sliceMode.sliceMode != 0 && pop->sliceMode.sliceMode != 1)
return RETCODE_INVALID_PARAM;
if (pop->sliceMode.sliceMode == 1) {
if (pop->sliceMode.sliceSizeMode != 0 && pop->sliceMode.sliceSizeMode != 1) {
return RETCODE_INVALID_PARAM;
}
if (pop->sliceMode.sliceSizeMode == 1 && pop->sliceMode.sliceSize == 0 ) {
return RETCODE_INVALID_PARAM;
}
}
if (pop->intraRefreshNum < 0)
return RETCODE_INVALID_PARAM;
if (pop->MEUseZeroPmv != 0 && pop->MEUseZeroPmv != 1)
return RETCODE_INVALID_PARAM;
if (pop->intraCostWeight < 0 || pop->intraCostWeight >= 65535)
return RETCODE_INVALID_PARAM;
if (productId == PRODUCT_ID_980) {
if (pop->MESearchRangeX < 0 || pop->MESearchRangeX > 4) {
return RETCODE_INVALID_PARAM;
}
if (pop->MESearchRangeY < 0 || pop->MESearchRangeY > 3) {
return RETCODE_INVALID_PARAM;
}
}
else {
if (pop->MESearchRange < 0 || pop->MESearchRange >= 4)
return RETCODE_INVALID_PARAM;
}
if (pop->bitstreamFormat == STD_MPEG4) {
EncMp4Param * param = &pop->EncStdParam.mp4Param;
if (param->mp4DataPartitionEnable != 0 && param->mp4DataPartitionEnable != 1) {
return RETCODE_INVALID_PARAM;
}
if (param->mp4DataPartitionEnable == 1) {
if (param->mp4ReversibleVlcEnable != 0 && param->mp4ReversibleVlcEnable != 1) {
return RETCODE_INVALID_PARAM;
}
}
if (param->mp4IntraDcVlcThr < 0 || 7 < param->mp4IntraDcVlcThr) {
return RETCODE_INVALID_PARAM;
}
if (picWidth < MIN_ENC_PIC_WIDTH || picWidth > MAX_ENC_PIC_WIDTH ) {
return RETCODE_INVALID_PARAM;
}
if (picHeight < MIN_ENC_PIC_HEIGHT) {
return RETCODE_INVALID_PARAM;
}
}
else if (pop->bitstreamFormat == STD_H263) {
EncH263Param * param = &pop->EncStdParam.h263Param;
Uint32 frameRateInc, frameRateRes;
if (param->h263AnnexJEnable != 0 && param->h263AnnexJEnable != 1) {
return RETCODE_INVALID_PARAM;
}
if (param->h263AnnexKEnable != 0 && param->h263AnnexKEnable != 1) {
return RETCODE_INVALID_PARAM;
}
if (param->h263AnnexTEnable != 0 && param->h263AnnexTEnable != 1) {
return RETCODE_INVALID_PARAM;
}
if (picWidth < MIN_ENC_PIC_WIDTH || picWidth > MAX_ENC_PIC_WIDTH ) {
return RETCODE_INVALID_PARAM;
}
if (picHeight < MIN_ENC_PIC_HEIGHT) {
return RETCODE_INVALID_PARAM;
}
frameRateInc = ((pop->frameRateInfo>>16) &0xFFFF) + 1;
frameRateRes = pop->frameRateInfo & 0xFFFF;
if ((frameRateRes/frameRateInc) <15) {
return RETCODE_INVALID_PARAM;
}
}
else if (pop->bitstreamFormat == STD_AVC && productId != PRODUCT_ID_521) {
EncAvcParam* param = &pop->EncStdParam.avcParam;
if (param->constrainedIntraPredFlag != 0 && param->constrainedIntraPredFlag != 1)
return RETCODE_INVALID_PARAM;
if (param->disableDeblk != 0 && param->disableDeblk != 1 && param->disableDeblk != 2)
return RETCODE_INVALID_PARAM;
if (param->deblkFilterOffsetAlpha < -6 || 6 < param->deblkFilterOffsetAlpha)
return RETCODE_INVALID_PARAM;
if (param->deblkFilterOffsetBeta < -6 || 6 < param->deblkFilterOffsetBeta)
return RETCODE_INVALID_PARAM;
if (param->chromaQpOffset < -12 || 12 < param->chromaQpOffset)
return RETCODE_INVALID_PARAM;
if (param->audEnable != 0 && param->audEnable != 1)
return RETCODE_INVALID_PARAM;
if (param->frameCroppingFlag != 0 &&param->frameCroppingFlag != 1)
return RETCODE_INVALID_PARAM;
if (param->frameCropLeft & 0x01 || param->frameCropRight & 0x01 ||
param->frameCropTop & 0x01 || param->frameCropBottom & 0x01) {
return RETCODE_INVALID_PARAM;
}
if (picWidth < MIN_ENC_PIC_WIDTH || picWidth > MAX_ENC_PIC_WIDTH )
return RETCODE_INVALID_PARAM;
if (picHeight < MIN_ENC_PIC_HEIGHT)
return RETCODE_INVALID_PARAM;
}
else if (pop->bitstreamFormat == STD_HEVC || pop->bitstreamFormat == STD_SVAC || (pop->bitstreamFormat == STD_AVC && productId == PRODUCT_ID_521)) {
EncVpParam* param = &pop->EncStdParam.vpParam;
if (param->svcEnable == TRUE && pop->bitstreamFormat != STD_SVAC)
return RETCODE_INVALID_PARAM;
if (picWidth < VP_MIN_ENC_PIC_WIDTH || picWidth > VP_MAX_ENC_PIC_WIDTH)
return RETCODE_INVALID_PARAM;
if (picHeight < VP_MIN_ENC_PIC_HEIGHT || picHeight > VP_MAX_ENC_PIC_HEIGHT)
return RETCODE_INVALID_PARAM;
if (pop->bitstreamFormat == STD_HEVC) { // only for HEVC condition
if (param->profile != HEVC_PROFILE_MAIN && param->profile != HEVC_PROFILE_MAIN10 && param->profile != HEVC_PROFILE_STILLPICTURE)
return RETCODE_INVALID_PARAM;
if (param->internalBitDepth > 8 && param->profile == HEVC_PROFILE_MAIN)
return RETCODE_INVALID_PARAM;
}
if (param->internalBitDepth != 8 && param->internalBitDepth != 10)
return RETCODE_INVALID_PARAM;
if (param->internalBitDepth > 8 && param->profile == HEVC_PROFILE_MAIN)
return RETCODE_INVALID_PARAM;
if (pop->bitstreamFormat == STD_SVAC && param->svcEnable == TRUE && param->svcMode == 1) {
// only low delay encoding supported when svc enable.
if (param->gopPresetIdx == PRESET_IDX_IBPBP || param->gopPresetIdx == PRESET_IDX_IBBBP || param->gopPresetIdx == PRESET_IDX_RA_IB)
return RETCODE_INVALID_PARAM;
}
if (param->decodingRefreshType < 0 || param->decodingRefreshType > 2)
return RETCODE_INVALID_PARAM;
if (param->gopPresetIdx == PRESET_IDX_CUSTOM_GOP) {
if ( param->gopParam.customGopSize < 1 || param->gopParam.customGopSize > MAX_GOP_NUM)
return RETCODE_INVALID_PARAM;
}
if (pop->bitstreamFormat == STD_AVC) {
if (param->customLambdaEnable == 1)
return RETCODE_INVALID_PARAM;
}
if (param->constIntraPredFlag != 1 && param->constIntraPredFlag != 0)
return RETCODE_INVALID_PARAM;
if (param->intraRefreshMode < 0 || param->intraRefreshMode > 4)
return RETCODE_INVALID_PARAM;
if (pop->bitstreamFormat == STD_HEVC) {
if (param->independSliceMode < 0 || param->independSliceMode > 1)
return RETCODE_INVALID_PARAM;
if (param->independSliceMode != 0) {
if (param->dependSliceMode < 0 || param->dependSliceMode > 2)
return RETCODE_INVALID_PARAM;
}
}
if (param->useRecommendEncParam < 0 || param->useRecommendEncParam > 3)
return RETCODE_INVALID_PARAM;
if (param->useRecommendEncParam == 0 || param->useRecommendEncParam == 2 || param->useRecommendEncParam == 3) {
if (param->intraNxNEnable != 1 && param->intraNxNEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->skipIntraTrans != 1 && param->skipIntraTrans != 0)
return RETCODE_INVALID_PARAM;
if (param->scalingListEnable != 1 && param->scalingListEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->tmvpEnable != 1 && param->tmvpEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->wppEnable != 1 && param->wppEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->useRecommendEncParam != 3) { // in FAST mode (recommendEncParam==3), maxNumMerge value will be decided in FW
if (param->maxNumMerge < 0 || param->maxNumMerge > 3)
return RETCODE_INVALID_PARAM;
}
if (param->disableDeblk != 1 && param->disableDeblk != 0)
return RETCODE_INVALID_PARAM;
if (param->disableDeblk == 0 || param->saoEnable != 0) {
if (param->lfCrossSliceBoundaryEnable != 1 && param->lfCrossSliceBoundaryEnable != 0)
return RETCODE_INVALID_PARAM;
}
if (param->disableDeblk == 0) {
if (param->betaOffsetDiv2 < -6 || param->betaOffsetDiv2 > 6)
return RETCODE_INVALID_PARAM;
if (param->tcOffsetDiv2 < -6 || param->tcOffsetDiv2 > 6)
return RETCODE_INVALID_PARAM;
}
}
if (param->losslessEnable != 1 && param->losslessEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->intraQP < 0 || param->intraQP > 63)
return RETCODE_INVALID_PARAM;
if (pop->bitstreamFormat == STD_SVAC && param->internalBitDepth != 8) {
if (param->intraQP < 1 || param->intraQP > 63)
return RETCODE_INVALID_PARAM;
}
if (pop->rcEnable != 1 && pop->rcEnable != 0)
return RETCODE_INVALID_PARAM;
if (pop->rcEnable == 1) {
if (param->minQpI < 0 || param->minQpI > 63)
return RETCODE_INVALID_PARAM;
if (param->maxQpI < 0 || param->maxQpI > 63)
return RETCODE_INVALID_PARAM;
if (param->minQpP < 0 || param->minQpP > 63)
return RETCODE_INVALID_PARAM;
if (param->maxQpP < 0 || param->maxQpP > 63)
return RETCODE_INVALID_PARAM;
if (param->minQpB < 0 || param->minQpB > 63)
return RETCODE_INVALID_PARAM;
if (param->maxQpB < 0 || param->maxQpB > 63)
return RETCODE_INVALID_PARAM;
if (pop->bitstreamFormat == STD_SVAC && param->internalBitDepth != 8) {
if (param->minQpI < 1 || param->minQpI > 63)
return RETCODE_INVALID_PARAM;
if (param->maxQpI < 1 || param->maxQpI > 63)
return RETCODE_INVALID_PARAM;
if (param->minQpP < 1 || param->minQpP > 63)
return RETCODE_INVALID_PARAM;
if (param->maxQpP < 1 || param->maxQpP > 63)
return RETCODE_INVALID_PARAM;
if (param->minQpB < 1 || param->minQpB > 63)
return RETCODE_INVALID_PARAM;
if (param->maxQpB < 1 || param->maxQpB > 63)
return RETCODE_INVALID_PARAM;
}
if (param->cuLevelRCEnable != 1 && param->cuLevelRCEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->hvsQPEnable != 1 && param->hvsQPEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->hvsQPEnable) {
if (param->hvsMaxDeltaQp < 0 || param->hvsMaxDeltaQp > 51)
return RETCODE_INVALID_PARAM;
}
if (param->bitAllocMode < 0 || param->bitAllocMode > 2)
return RETCODE_INVALID_PARAM;
if (pop->vbvBufferSize < 10 || pop->vbvBufferSize > 3000 )
return RETCODE_INVALID_PARAM;
}
// packed format & cbcrInterleave & nv12 can't be set at the same time.
if (pop->packedFormat == 1 && pop->cbcrInterleave == 1)
return RETCODE_INVALID_PARAM;
if (pop->packedFormat == 1 && pop->nv21 == 1)
return RETCODE_INVALID_PARAM;
// check valid for common param
if (CheckEncCommonParamValid(pop) == RETCODE_FAILURE)
return RETCODE_INVALID_PARAM;
// check valid for RC param
if (CheckEncRcParamValid(pop) == RETCODE_FAILURE)
return RETCODE_INVALID_PARAM;
if (param->gopPresetIdx == PRESET_IDX_CUSTOM_GOP) {
if (CheckEncCustomGopParamValid(pop) == RETCODE_FAILURE)
return RETCODE_INVALID_COMMAND;
}
if (param->chromaCbQpOffset < -12 || param->chromaCbQpOffset > 12)
return RETCODE_INVALID_PARAM;
if (param->chromaCrQpOffset < -12 || param->chromaCrQpOffset > 12)
return RETCODE_INVALID_PARAM;
if (param->intraRefreshMode == 3 && param-> intraRefreshArg == 0)
return RETCODE_INVALID_PARAM;
if (pop->bitstreamFormat == STD_HEVC) {
if (param->nrYEnable != 1 && param->nrYEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->nrCbEnable != 1 && param->nrCbEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->nrCrEnable != 1 && param->nrCrEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->nrNoiseEstEnable != 1 && param->nrNoiseEstEnable != 0)
return RETCODE_INVALID_PARAM;
if (param->nrNoiseSigmaY > 255)
return RETCODE_INVALID_PARAM;
if (param->nrNoiseSigmaCb > 255)
return RETCODE_INVALID_PARAM;
if (param->nrNoiseSigmaCr > 255)
return RETCODE_INVALID_PARAM;
if (param->nrIntraWeightY > 31)
return RETCODE_INVALID_PARAM;
if (param->nrIntraWeightCb > 31)
return RETCODE_INVALID_PARAM;
if (param->nrIntraWeightCr > 31)
return RETCODE_INVALID_PARAM;
if (param->nrInterWeightY > 31)
return RETCODE_INVALID_PARAM;
if (param->nrInterWeightCb > 31)
return RETCODE_INVALID_PARAM;
if (param->nrInterWeightCr > 31)
return RETCODE_INVALID_PARAM;
if((param->nrYEnable == 1 || param->nrCbEnable == 1 || param->nrCrEnable == 1) && (param->losslessEnable == 1))
return RETCODE_INVALID_PARAM;
}
if (pop->bitstreamFormat == STD_SVAC) {
// set parameters that not used for SVAC encoder to default value (=0)
param->decodingRefreshType = 0;
param->customMDEnable = 0;
param->customLambdaEnable = 0;
param->maxNumMerge = 0;
if (param->chromaAcQpOffset < -3 || param->chromaAcQpOffset> 3)
return RETCODE_INVALID_PARAM;
if (param->chromaDcQpOffset < -3 || param->chromaDcQpOffset> 3)
return RETCODE_INVALID_PARAM;
if (param->lumaDcQpOffset < -3 || param->lumaDcQpOffset> 3)
return RETCODE_INVALID_PARAM;
}
}
if (pop->linear2TiledEnable == TRUE) {
if (pop->linear2TiledMode != FF_FRAME && pop->linear2TiledMode != FF_FIELD )
return RETCODE_INVALID_PARAM;
}
return RETCODE_SUCCESS;
}
RetCode ProductVpuEncFiniSeq(CodecInst* instance)
{
RetCode ret = RETCODE_NOT_FOUND_VPU_DEVICE;
switch (instance->productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_511:
ret = RETCODE_NOT_SUPPORTED_FEATURE;
break;
case PRODUCT_ID_521:
ret = Vp5VpuEncFiniSeq(instance);
break;
}
return ret;
}
RetCode ProductVpuEncSetup(CodecInst* instance)
{
RetCode ret = RETCODE_NOT_FOUND_VPU_DEVICE;
switch (instance->productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_521:
case PRODUCT_ID_511:
ret = RETCODE_NOT_SUPPORTED_FEATURE;
break;
}
return ret;
}
RetCode ProductVpuEncode(CodecInst* instance, EncParam* param)
{
RetCode ret = RETCODE_NOT_FOUND_VPU_DEVICE;
switch (instance->productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_511:
ret = RETCODE_NOT_SUPPORTED_FEATURE;
break;
case PRODUCT_ID_521:
ret = Vp5VpuEncode(instance, param);
break;
default:
break;
}
return ret;
}
RetCode ProductVpuEncGetResult(CodecInst* instance, EncOutputInfo* result)
{
RetCode ret = RETCODE_NOT_FOUND_VPU_DEVICE;
switch (instance->productId) {
case PRODUCT_ID_512:
case PRODUCT_ID_515:
case PRODUCT_ID_511:
ret = RETCODE_NOT_SUPPORTED_FEATURE;
break;
case PRODUCT_ID_521:
ret = Vp5VpuEncGetResult(instance, result);
break;
}
return ret;
}
RetCode ProductVpuEncGiveCommand(CodecInst* instance, CodecCommand cmd, void* param)
{
RetCode ret = RETCODE_NOT_SUPPORTED_FEATURE;
switch (instance->productId) {
default:
ret = Vp5VpuEncGiveCommand(instance, cmd, param);
break;
}
return ret;
}
RetCode ProductVpuEncInitSeq(CodecInst* instance)
{
int productId;
RetCode ret = RETCODE_NOT_FOUND_VPU_DEVICE;
productId = instance->productId;
switch (productId) {
case PRODUCT_ID_521:
ret = Vp5VpuEncInitSeq(instance);
break;
default:
break;
}
return ret;
}
RetCode ProductVpuEncGetSeqInfo(CodecInst* instance, EncInitialInfo* info)
{
int productId;
RetCode ret = RETCODE_NOT_FOUND_VPU_DEVICE;
productId = instance->productId;
switch (productId) {
case PRODUCT_ID_521:
ret = Vp5VpuEncGetSeqInfo(instance, info);
break;
default:
break;
}
return ret;
}
Reference in New Issue Copy Permalink