package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-04 16:52:40 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[h264e]: pass mpp_cfg to internal H.264 encoder and fix errors in mpi_enc_test

Browse Source 
git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@1101 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
ChenHengming
2016-07-26 12:29:08 +00:00
parent 5fc681b42c
commit 16b22667c6
8 changed files with 197 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
inc/rk_mpi.h
View File

@@ -147,9 +147,13 @@ typedef struct MppEncConfig_t {
* 0 - fix qp mode * 0 - fix qp mode
* 1 - constant bit rate mode (CBR) * 1 - constant bit rate mode (CBR)
* 2 - variable bit rate mode (VBR) * 2 - variable bit rate mode (VBR)
* skip_cnt - max continuous frame skip count
* 0 - frame skip is not allow
* bps - target bit rate, unit: bit per second * bps - target bit rate, unit: bit per second
* fps_in - input frame rate, unit: frame per second * fps_in - input frame rate, unit: frame per second
* if 0 then default set to 30
* fps_out - output frame rate, unit: frame per second * fps_out - output frame rate, unit: frame per second
* if 0 then default set to fps_in
* qp - constant qp for fix qp mode * qp - constant qp for fix qp mode
* initial qp for CBR / VBR * initial qp for CBR / VBR
* gop - gap between Intra frame * gop - gap between Intra frame
@@ -160,6 +164,7 @@ typedef struct MppEncConfig_t {
* etc... * etc...
*/ */
RK_S32 rc_mode; RK_S32 rc_mode;
RK_S32 skip_cnt;
RK_S32 bps; RK_S32 bps;
RK_S32 fps_in; RK_S32 fps_in;
RK_S32 fps_out; RK_S32 fps_out;

4
mpp/codec/enc/h264/include/h264encapi.h
View File

@@ -143,7 +143,6 @@ typedef struct {
* defined by timeIncrement of encoded pictures, * defined by timeIncrement of encoded pictures,
* [1..frameRateNum] */ * [1..frameRateNum] */
H264EncComplexityLevel complexityLevel; /* For compatibility */ H264EncComplexityLevel complexityLevel; /* For compatibility */
RK_U32 intraPicRate; // intra period
RK_U32 enable_cabac; RK_U32 enable_cabac;
RK_U32 transform8x8_mode; RK_U32 transform8x8_mode;
RK_U32 pic_init_qp; RK_U32 pic_init_qp;
@@ -151,7 +150,6 @@ typedef struct {
RK_U32 pic_luma_height; RK_U32 pic_luma_height;
RK_U32 pic_luma_width; RK_U32 pic_luma_width;
H264EncPictureFormat input_image_format; H264EncPictureFormat input_image_format;
RK_U32 keyframe_max_interval;
RK_U32 second_chroma_qp_index_offset; RK_U32 second_chroma_qp_index_offset;
RK_U32 pps_id; RK_U32 pps_id;
} H264EncConfig; } H264EncConfig;
@@ -196,6 +194,8 @@ typedef struct {
u32 pictureRc; /* Adjust QP between pictures, [0,1] */ u32 pictureRc; /* Adjust QP between pictures, [0,1] */
u32 mbRc; /* Adjust QP inside picture, [0,1] */ u32 mbRc; /* Adjust QP inside picture, [0,1] */
u32 pictureSkip; /* Allow rate control to skip pictures, [0,1] */ u32 pictureSkip; /* Allow rate control to skip pictures, [0,1] */
u32 intraPicRate; /* intra period */
u32 keyframe_max_interval;
i32 qpHdr; /* QP for next encoded picture, [-1..51] i32 qpHdr; /* QP for next encoded picture, [-1..51]
* -1 = Let rate control calculate initial QP * -1 = Let rate control calculate initial QP
* This QP is used for all pictures if * This QP is used for all pictures if

147
mpp/codec/enc/h264/src/h264e_api.c
View File

@@ -157,15 +157,11 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
switch (cmd) { switch (cmd) {
case SET_ENC_CFG : { case SET_ENC_CFG : {
const H264EncConfig *encCfg = (const H264EncConfig *)param; const H264EncConfig *encCfg = (const H264EncConfig *)param;
pEncInst->h264EncCfg.intraPicRate = encCfg->intraPicRate;
pEncInst->intraPeriodCnt = encCfg->intraPicRate;
H264EncInst encoderOpen = (H264EncInst)ctx; H264EncInst encoderOpen = (H264EncInst)ctx;
H264EncRateCtrl oriRcCfg;
H264EncCodingCtrl oriCodingCfg; H264EncCodingCtrl oriCodingCfg;
H264EncPreProcessingCfg oriPreProcCfg; H264EncPreProcessingCfg oriPreProcCfg;
H264EncRet ret/* = MPP_OK*/; // TODO modify by lance 2016.05.19 H264EncRet ret = MPP_OK;
h264e_control_debug_enter(); h264e_control_debug_enter();
@@ -174,59 +170,6 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
return -1; return -1;
} }
/* Encoder setup: rate control */
if ((ret = H264EncGetRateCtrl(encoderOpen, &oriRcCfg)) != H264ENC_OK) {
mpp_err("H264EncGetRateCtrl() failed, ret %d.", ret);
h264e_deinit((void*)encoderOpen);
return -1;
} else {
h264e_control_log("Get rate control: qp %2d [%2d, %2d] %8d bps "
"pic %d mb %d skip %d hrd %d\n cpbSize %d gopLen %d "
"intraQpDelta %2d\n",
oriRcCfg.qpHdr, oriRcCfg.qpMin, oriRcCfg.qpMax, oriRcCfg.bitPerSecond,
oriRcCfg.pictureRc, oriRcCfg.mbRc, oriRcCfg.pictureSkip, oriRcCfg.hrd,
oriRcCfg.hrdCpbSize, oriRcCfg.gopLen, oriRcCfg.intraQpDelta);
// will be replaced modify by lance 2016.05.20
// ------------
oriRcCfg.qpHdr = 26;
oriRcCfg.qpMin = 18;
oriRcCfg.qpMax = 40;
oriRcCfg.pictureSkip = 0;
oriRcCfg.pictureRc = 0;
oriRcCfg.mbRc = 0;
oriRcCfg.bitPerSecond = 8 * SZ_1M;
oriRcCfg.hrd = 0;
oriRcCfg.hrdCpbSize = 30000000;
oriRcCfg.gopLen = 30;
oriRcCfg.intraQpDelta = 4;
oriRcCfg.fixedIntraQp = 0;
oriRcCfg.mbQpAdjustment = 0;
if ((ret = H264EncSetRateCtrl(encoderOpen, &oriRcCfg)) != H264ENC_OK) {
mpp_err("H264EncSetRateCtrl() failed, ret %d.", ret);
h264e_deinit((void*)encoderOpen);
return -1;
}
// ------------
// TODO modify by lance 2016.05.20
// will use in future
/*mpp_log("Set rate control: qp %2d [%2d, %2d] %8d bps "
"pic %d mb %d skip %d hrd %d\n"
" cpbSize %d gopLen %d intraQpDelta %2d "
"fixedIntraQp %2d mbQpAdjustment %d\n",
encRcCfg->qpHdr, encRcCfg->qpMin, encRcCfg->qpMax, encRcCfg->bitPerSecond,
encRcCfg->pictureRc, encRcCfg->mbRc, encRcCfg->pictureSkip, encRcCfg->hrd,
encRcCfg->hrdCpbSize, encRcCfg->gopLen, encRcCfg->intraQpDelta,
encRcCfg->fixedIntraQp, encRcCfg->mbQpAdjustment);
if ((ret = H264EncSetRateCtrl(encoderOpen, encRcCfg)) != H264ENC_OK) {
mpp_err("H264EncSetRateCtrl() failed, ret %d.", ret);
h264e_deinit((void*)encoderOpen);
return -1;
}*/
}
/* Encoder setup: coding control */ /* Encoder setup: coding control */
if ((ret = H264EncGetCodingCtrl(encoderOpen, &oriCodingCfg)) != H264ENC_OK) { if ((ret = H264EncGetCodingCtrl(encoderOpen, &oriCodingCfg)) != H264ENC_OK) {
mpp_err("H264EncGetCodingCtrl() failed, ret %d.", ret); mpp_err("H264EncGetCodingCtrl() failed, ret %d.", ret);
@@ -248,22 +191,6 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
h264e_deinit((void*)encoderOpen); h264e_deinit((void*)encoderOpen);
return -1; return -1;
} }
// ------------
// TODO modify by lance 2016.05.20
// will use in future
/*mpp_log("Set coding control: SEI %d Slice %5d deblocking %d "
"constrained intra %d video range %d\n"
" cabac %d cabac initial idc %d Adaptive 8x8 transform %d\n",
encCodingCfg->seiMessages, encCodingCfg->sliceSize,
encCodingCfg->disableDeblockingFilter,
encCodingCfg->constrainedIntraPrediction, encCodingCfg->videoFullRange, encCodingCfg->enableCabac,
encCodingCfg->cabacInitIdc, encCodingCfg->transform8x8Mode );
if ((ret = H264EncSetCodingCtrl(encoderOpen, encCodingCfg)) != H264ENC_OK) {
mpp_err("H264EncSetCodingCtrl() failed, ret %d.", ret);
h264e_deinit((void*)encoderOpen);
return -1;
}*/
} }
/* PreP setup */ /* PreP setup */
@@ -294,25 +221,12 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
oriPreProcCfg.colorConversion.coeffE = 35000; oriPreProcCfg.colorConversion.coeffE = 35000;
oriPreProcCfg.colorConversion.coeffF = 38000; oriPreProcCfg.colorConversion.coeffF = 38000;
} }
if ((ret = H264EncSetPreProcessing(encoderOpen, &oriPreProcCfg)) != H264ENC_OK) { if ((ret = H264EncSetPreProcessing(encoderOpen, &oriPreProcCfg)) != H264ENC_OK) {
mpp_err("H264EncSetPreProcessing() failed.", ret); mpp_err("H264EncSetPreProcessing() failed.", ret);
h264e_deinit((void*)encoderOpen); h264e_deinit((void*)encoderOpen);
return -1; return -1;
} }
// ----------------
// TODO modify by lance 2016.05.20
// will use in future
/*mpp_log("Set PreP: input %4dx%d : offset %4dx%d : format %d : rotation %d "
": stab %d : cc %d\n",
encPreProcCfg->origWidth, encPreProcCfg->origHeight, encPreProcCfg->xOffset,
encPreProcCfg->yOffset, encPreProcCfg->inputType, encPreProcCfg->rotation,
encPreProcCfg->videoStabilization, encPreProcCfg->colorConversion.type);
if ((ret = H264EncSetPreProcessing(encoderOpen, encPreProcCfg)) != H264ENC_OK) {
mpp_err("H264EncSetPreProcessing() failed.", ret);
h264e_deinit((void*)encoderOpen);
return -1;
}*/
} }
// add by lance 2016.06.16 // add by lance 2016.06.16
@@ -326,6 +240,63 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
h264e_control_debug_leave(); h264e_control_debug_leave();
} break;
case SET_ENC_RC_CFG : {
const H264EncRateCtrl *encCfg = (const H264EncRateCtrl *)param;
H264EncInst encoder = (H264EncInst)ctx;
H264EncRateCtrl oriRcCfg;
H264EncRet ret = MPP_OK;
mpp_assert(pEncInst);
pEncInst->h264EncCfg.intraPicRate = encCfg->intraPicRate;
pEncInst->intraPeriodCnt = encCfg->intraPicRate;
/* Encoder setup: rate control */
if ((ret = H264EncGetRateCtrl(encoder, &oriRcCfg)) != H264ENC_OK) {
mpp_err("H264EncGetRateCtrl() failed, ret %d.", ret);
return -1;
} else {
h264e_control_log("Get rate control: qp %2d [%2d, %2d] bps %8d\n",
oriRcCfg.qpHdr, oriRcCfg.qpMin, oriRcCfg.qpMax, oriRcCfg.bitPerSecond);
h264e_control_log("pic %d mb %d skip %d hrd %d cpbSize %d gopLen %d\n",
oriRcCfg.pictureRc, oriRcCfg.mbRc, oriRcCfg.pictureSkip, oriRcCfg.hrd,
oriRcCfg.hrdCpbSize, oriRcCfg.gopLen);
// will be replaced modify by lance 2016.05.20
// ------------
if (encCfg->qpHdr)
oriRcCfg.qpHdr = encCfg->qpHdr;
if (encCfg->qpMin)
oriRcCfg.qpMin = encCfg->qpMin;
if (encCfg->qpMax)
oriRcCfg.qpMax = encCfg->qpMax;
oriRcCfg.pictureSkip = encCfg->pictureSkip;
oriRcCfg.pictureRc = encCfg->pictureRc;
oriRcCfg.mbRc = encCfg->mbRc;
oriRcCfg.bitPerSecond = encCfg->bitPerSecond;
oriRcCfg.hrd = encCfg->hrd;
oriRcCfg.hrdCpbSize = encCfg->hrdCpbSize;
oriRcCfg.gopLen = encCfg->gopLen;
oriRcCfg.intraQpDelta = encCfg->intraQpDelta;
oriRcCfg.fixedIntraQp = encCfg->fixedIntraQp;
oriRcCfg.mbQpAdjustment = encCfg->mbQpAdjustment;
h264e_control_log("Set rate control: qp %2d [%2d, %2d] bps %8d\n",
oriRcCfg.qpHdr, oriRcCfg.qpMin, oriRcCfg.qpMax, oriRcCfg.bitPerSecond);
h264e_control_log("pic %d mb %d skip %d hrd %d cpbSize %d gopLen %d\n",
oriRcCfg.pictureRc, oriRcCfg.mbRc, oriRcCfg.pictureSkip, oriRcCfg.hrd,
oriRcCfg.hrdCpbSize, oriRcCfg.gopLen);
if ((ret = H264EncSetRateCtrl(encoder, &oriRcCfg)) != H264ENC_OK) {
mpp_err("H264EncSetRateCtrl() failed, ret %d.", ret);
return -1;
}
}
} break; } break;
case GET_OUTPUT_STREAM_SIZE: case GET_OUTPUT_STREAM_SIZE:
*((RK_U32*)param) = getOutputStreamSize(pEncInst); *((RK_U32*)param) = getOutputStreamSize(pEncInst);

1
mpp/codec/inc/encoder_codec_api.h
View File

@@ -27,6 +27,7 @@
// config cmd // config cmd
typedef enum EncCfgCmd_t { typedef enum EncCfgCmd_t {
SET_ENC_CFG, SET_ENC_CFG,
SET_ENC_RC_CFG,
GET_OUTPUT_STREAM_SIZE, GET_OUTPUT_STREAM_SIZE,
} EncCfgCmd; } EncCfgCmd;

3
mpp/codec/inc/mpp_enc.h
View File

@@ -36,7 +36,8 @@ struct MppEnc_t {
RK_U32 reset_flag; RK_U32 reset_flag;
void *mpp; void *mpp;
H264EncConfig encCfg; H264EncConfig enc_cfg;
H264EncRateCtrl enc_rc_cfg;
h264e_control_extra_info_cfg extra_info_cfg; h264e_control_extra_info_cfg extra_info_cfg;
h264e_control_extra_info extra_info; h264e_control_extra_info extra_info;
}; };

125
mpp/codec/mpp_enc.cpp
View File

@@ -20,9 +20,9 @@
#include "mpp_log.h" #include "mpp_log.h"
#include "mpp_mem.h" #include "mpp_mem.h"
#include "mpp_common.h"
#include "mpp.h" #include "mpp.h"
#include "mpp_enc.h"
#include "mpp_frame_impl.h" #include "mpp_frame_impl.h"
#include "mpp_packet.h" #include "mpp_packet.h"
#include "mpp_packet_impl.h" #include "mpp_packet_impl.h"
@@ -103,8 +103,8 @@ void *mpp_enc_control_thread(void *data)
* if there is available buffer in the input frame do encoding * if there is available buffer in the input frame do encoding
*/ */
if (NULL == packet) { if (NULL == packet) {
RK_U32 width = enc->encCfg.width; RK_U32 width = enc->enc_cfg.width;
RK_U32 height = enc->encCfg.height; RK_U32 height = enc->enc_cfg.height;
RK_U32 size = width * height; RK_U32 size = width * height;
MppBuffer buffer = NULL; MppBuffer buffer = NULL;
@@ -242,21 +242,25 @@ void *mpp_enc_hal_thread(void *data)
return NULL; return NULL;
} }
static MPP_RET mpp_extra_info_generate(h264e_control_extra_info_cfg *info, const H264EncConfig *encCfg) static MPP_RET mpp_extra_info_generate(MppEnc *enc)
{ {
info->chroma_qp_index_offset = encCfg->chroma_qp_index_offset; h264e_control_extra_info_cfg *info = &enc->extra_info_cfg;
info->enable_cabac = encCfg->enable_cabac; H264EncConfig *enc_cfg = &enc->enc_cfg;
info->pic_init_qp = encCfg->pic_init_qp; H264EncRateCtrl *enc_rc_cfg = &enc->enc_rc_cfg;
info->pic_luma_height = encCfg->height;
info->pic_luma_width = encCfg->width;
info->transform8x8_mode = encCfg->transform8x8_mode;
info->input_image_format = encCfg->input_image_format; info->chroma_qp_index_offset = enc_cfg->chroma_qp_index_offset;
info->profile_idc = encCfg->profile; info->enable_cabac = enc_cfg->enable_cabac;
info->level_idc = encCfg->level; info->pic_init_qp = enc_cfg->pic_init_qp;
info->keyframe_max_interval = encCfg->keyframe_max_interval; info->pic_luma_height = enc_cfg->height;
info->second_chroma_qp_index_offset = encCfg->second_chroma_qp_index_offset; info->pic_luma_width = enc_cfg->width;
info->pps_id = encCfg->pps_id; info->transform8x8_mode = enc_cfg->transform8x8_mode;
info->input_image_format = enc_cfg->input_image_format;
info->profile_idc = enc_cfg->profile;
info->level_idc = enc_cfg->level;
info->keyframe_max_interval = enc_rc_cfg->keyframe_max_interval;
info->second_chroma_qp_index_offset = enc_cfg->second_chroma_qp_index_offset;
info->pps_id = enc_cfg->pps_id;
return MPP_OK; return MPP_OK;
} }
@@ -402,51 +406,85 @@ MPP_RET mpp_enc_control(MppEnc *enc, MpiCmd cmd, void *param)
} }
// TODO // TODO
MppEncConfig *mpp_cfg = (MppEncConfig*)param; MppEncConfig *mpp_cfg = (MppEncConfig*)param;
H264EncConfig *encCfg = &(enc->encCfg); H264EncConfig *enc_cfg = &(enc->enc_cfg);
H264EncRateCtrl *enc_rc_cfg = &(enc->enc_rc_cfg);
switch (cmd) { switch (cmd) {
case MPP_ENC_SET_CFG: case MPP_ENC_SET_CFG:
//H264ENC_NAL_UNIT_STREAM; // decide whether stream start with start code,e.g."00 00 00 01" //H264ENC_NAL_UNIT_STREAM; // decide whether stream start with start code,e.g."00 00 00 01"
encCfg->streamType = H264ENC_BYTE_STREAM; enc_cfg->streamType = H264ENC_BYTE_STREAM;
encCfg->frameRateDenom = 1; enc_cfg->frameRateDenom = 1;
if (mpp_cfg->profile) if (mpp_cfg->profile)
encCfg->profile = (h264e_profile)mpp_cfg->profile; enc_cfg->profile = (h264e_profile)mpp_cfg->profile;
else else
encCfg->profile = H264_PROFILE_BASELINE; enc_cfg->profile = H264_PROFILE_BASELINE;
if (mpp_cfg->level) if (mpp_cfg->level)
encCfg->level = (H264EncLevel)mpp_cfg->level; enc_cfg->level = (H264EncLevel)mpp_cfg->level;
else else
encCfg->level = H264ENC_LEVEL_4_0; enc_cfg->level = H264ENC_LEVEL_4_0;
if (mpp_cfg->width && mpp_cfg->height) { if (mpp_cfg->width && mpp_cfg->height) {
encCfg->width = mpp_cfg->width; enc_cfg->width = mpp_cfg->width;
encCfg->height = mpp_cfg->height; enc_cfg->height = mpp_cfg->height;
} else } else
mpp_err("width %d height %d is not available\n", mpp_cfg->width, mpp_cfg->height); mpp_err("width %d height %d is not available\n", mpp_cfg->width, mpp_cfg->height);
if (mpp_cfg->fps_in) if (mpp_cfg->fps_in)
encCfg->frameRateNum = mpp_cfg->fps_in; enc_cfg->frameRateNum = mpp_cfg->fps_in;
else else
encCfg->frameRateNum = 30; enc_cfg->frameRateNum = 30;
if (mpp_cfg->gop > 0)
encCfg->intraPicRate = mpp_cfg->gop;
else
encCfg->intraPicRate = 30;
if (mpp_cfg->cabac_en) if (mpp_cfg->cabac_en)
encCfg->enable_cabac = mpp_cfg->cabac_en; enc_cfg->enable_cabac = mpp_cfg->cabac_en;
else else
encCfg->enable_cabac = 0; enc_cfg->enable_cabac = 0;
encCfg->transform8x8_mode = (encCfg->profile >= H264_PROFILE_HIGH) ? (1) : (0); enc_cfg->transform8x8_mode = (enc_cfg->profile >= H264_PROFILE_HIGH) ? (1) : (0);
encCfg->chroma_qp_index_offset = 2; // TODO enc_cfg->chroma_qp_index_offset = 2;
encCfg->pic_init_qp = mpp_cfg->qp; // TODO enc_cfg->pic_init_qp = mpp_cfg->qp;
encCfg->keyframe_max_interval = 150; // TODO enc_cfg->second_chroma_qp_index_offset = 2;
encCfg->second_chroma_qp_index_offset = 2; // TODO enc_cfg->pps_id = 0;
encCfg->pps_id = 0; enc_cfg->input_image_format = H264ENC_YUV420_SEMIPLANAR;
encCfg->input_image_format = H264ENC_YUV420_SEMIPLANAR;
controller_config(enc->controller, SET_ENC_CFG, (void *)encCfg); controller_config(enc->controller, SET_ENC_CFG, (void *)enc_cfg);
mpp_extra_info_generate(&(enc->extra_info_cfg), &(enc->encCfg)); if (mpp_cfg->rc_mode) {
/* VBR / CBR mode */
RK_S32 max_qp = MPP_MAX(mpp_cfg->qp + 6, 48);
RK_S32 min_qp = MPP_MIN(mpp_cfg->qp - 6, 16);
enc_rc_cfg->pictureRc = 1;
enc_rc_cfg->mbRc = 1;
enc_rc_cfg->qpHdr = mpp_cfg->qp;
enc_rc_cfg->qpMax = max_qp;
enc_rc_cfg->qpMin = min_qp;
enc_rc_cfg->hrd = 1;
enc_rc_cfg->intraQpDelta = 3;
} else {
/* CQP mode */
enc_rc_cfg->pictureRc = 0;
enc_rc_cfg->mbRc = 0;
enc_rc_cfg->qpHdr = mpp_cfg->qp;
enc_rc_cfg->qpMax = mpp_cfg->qp;
enc_rc_cfg->qpMin = mpp_cfg->qp;
enc_rc_cfg->hrd = 0;
enc_rc_cfg->intraQpDelta = 0;
}
enc_rc_cfg->pictureSkip = mpp_cfg->skip_cnt;
if (mpp_cfg->gop > 0)
enc_rc_cfg->intraPicRate = mpp_cfg->gop;
else
enc_rc_cfg->intraPicRate = 30;
enc_rc_cfg->keyframe_max_interval = 150;
enc_rc_cfg->bitPerSecond = mpp_cfg->bps;
enc_rc_cfg->gopLen = mpp_cfg->gop;
enc_rc_cfg->fixedIntraQp = 0;
enc_rc_cfg->mbQpAdjustment = 3;
enc_rc_cfg->hrdCpbSize = mpp_cfg->bps / 8;
controller_config(enc->controller, SET_ENC_RC_CFG, (void *)enc_rc_cfg);
mpp_extra_info_generate(enc);
mpp_hal_control(enc->hal, MPP_ENC_SET_EXTRA_INFO, (void*)(&(enc->extra_info_cfg))); mpp_hal_control(enc->hal, MPP_ENC_SET_EXTRA_INFO, (void*)(&(enc->extra_info_cfg)));
mpp_hal_control(enc->hal, MPP_ENC_GET_EXTRA_INFO, (void*)(&(enc->extra_info))); mpp_hal_control(enc->hal, MPP_ENC_GET_EXTRA_INFO, (void*)(&(enc->extra_info)));
@@ -458,3 +496,4 @@ MPP_RET mpp_enc_control(MppEnc *enc, MpiCmd cmd, void *param)
return MPP_OK; return MPP_OK;
} }

1
mpp/legacy/vpu_api_legacy.cpp
View File

@@ -170,6 +170,7 @@ RK_S32 VpuApiLegacy::init(VpuCodecContext *ctx, RK_U8 *extraData, RK_U32 extra_s
mpp_cfg.height = param->height; mpp_cfg.height = param->height;
mpp_cfg.format = param->format; mpp_cfg.format = param->format;
mpp_cfg.rc_mode = param->rc_mode; mpp_cfg.rc_mode = param->rc_mode;
mpp_cfg.skip_cnt = 0;
mpp_cfg.bps = param->bitRate; mpp_cfg.bps = param->bitRate;
mpp_cfg.fps_in = param->framerate; mpp_cfg.fps_in = param->framerate;
if (param->framerateout) if (param->framerateout)

55
test/mpi_enc_test.c
View File

@@ -30,6 +30,8 @@
#include "utils.h" #include "utils.h"
#include "vpu_api.h"
#define MPI_ENC_IO_COUNT (4) #define MPI_ENC_IO_COUNT (4)
#define MAX_FILE_NAME_LENGTH 256 #define MAX_FILE_NAME_LENGTH 256
@@ -50,7 +52,7 @@ static OptionInfo mpi_enc_cmd[] = {
{"o", "output_file", "output bitstream file, "}, {"o", "output_file", "output bitstream file, "},
{"w", "width", "the width of input bitstream"}, {"w", "width", "the width of input bitstream"},
{"h", "height", "the height of input bitstream"}, {"h", "height", "the height of input bitstream"},
{"f", "type", "input stream coding type"}, {"t", "type", "input stream coding type"},
{"d", "debug", "debug flag"}, {"d", "debug", "debug flag"},
}; };
@@ -65,6 +67,7 @@ int mpi_enc_test(MpiEncTestCmd *cmd)
// base flow context // base flow context
MppCtx ctx = NULL; MppCtx ctx = NULL;
MppApi *mpi = NULL; MppApi *mpi = NULL;
MppEncConfig mpp_cfg;
// input / output // input / output
RK_S32 i; RK_S32 i;
@@ -87,6 +90,7 @@ int mpi_enc_test(MpiEncTestCmd *cmd)
size_t packet_size = width * height; /* NOTE: packet buffer may overflow */ size_t packet_size = width * height; /* NOTE: packet buffer may overflow */
size_t read_size = 0; size_t read_size = 0;
RK_U32 frame_count = 0; RK_U32 frame_count = 0;
RK_U64 stream_size = 0;
mpp_log("mpi_enc_test start\n"); mpp_log("mpi_enc_test start\n");
@@ -148,6 +152,28 @@ int mpi_enc_test(MpiEncTestCmd *cmd)
goto MPP_TEST_OUT; goto MPP_TEST_OUT;
} }
memset(&mpp_cfg, 0, sizeof(mpp_cfg));
mpp_cfg.width = width;
mpp_cfg.height = height;
mpp_cfg.format = VPU_H264ENC_YUV420_PLANAR;
mpp_cfg.rc_mode = 1;
mpp_cfg.skip_cnt = 0;
mpp_cfg.bps = SZ_4M * 8;
mpp_cfg.fps_in = 30;
mpp_cfg.fps_out = 30;
mpp_cfg.qp = 24;
mpp_cfg.gop = 60;
mpp_cfg.profile = 100;
mpp_cfg.level = 41;
mpp_cfg.cabac_en = 1;
ret = mpi->control(ctx, MPP_ENC_SET_CFG, &mpp_cfg);
if (MPP_OK != ret) {
mpp_err("mpi control failed\n");
goto MPP_TEST_OUT;
}
ret = mpp_frame_init(&frame); ret = mpp_frame_init(&frame);
if (MPP_OK != ret) { if (MPP_OK != ret) {
mpp_err("mpp_frame_init failed\n"); mpp_err("mpp_frame_init failed\n");
@@ -191,8 +217,15 @@ int mpi_enc_test(MpiEncTestCmd *cmd)
if (task == NULL) { if (task == NULL) {
mpp_log("mpi dequeue from MPP_PORT_INPUT fail, task equal with NULL!"); mpp_log("mpi dequeue from MPP_PORT_INPUT fail, task equal with NULL!");
usleep(3000); usleep(3000);
} else } else {
MppFrame frame_out = NULL;
mpp_task_meta_get_frame (task, MPP_META_KEY_INPUT_FRM, &frame_out);
if (frame_out)
mpp_assert(frame_out == frame);
break; break;
}
} while (1); } while (1);
@@ -215,22 +248,23 @@ int mpi_enc_test(MpiEncTestCmd *cmd)
} }
if (task) { if (task) {
MppFrame frame_out = NULL;
MppFrame packet_out = NULL; MppFrame packet_out = NULL;
mpp_task_meta_get_frame (task, MPP_META_KEY_INPUT_FRM, &frame_out);
mpp_task_meta_get_packet(task, MPP_META_KEY_OUTPUT_PKT, &packet_out); mpp_task_meta_get_packet(task, MPP_META_KEY_OUTPUT_PKT, &packet_out);
mpp_assert(packet_out == packet); mpp_assert(packet_out == packet);
mpp_assert(frame_out == frame);
if (packet) { if (packet) {
// write packet to file here // write packet to file here
// void *ptr = mpp_packet_get_pos(packet); void *ptr = mpp_packet_get_pos(packet);
// size_t len = mpp_packet_get_length(packet); size_t len = mpp_packet_get_length(packet);
// fwrite(ptr, 1, len, fp_output);
if (fp_output)
fwrite(ptr, 1, len, fp_output);
mpp_packet_deinit(&packet); mpp_packet_deinit(&packet);
mpp_log_f("encoded frame %d size %d\n", frame_count, len);
stream_size += len;
} }
mpp_log_f("encoded frame %d\n", frame_count);
frame_count++; frame_count++;
ret = mpi->enqueue(ctx, MPP_PORT_OUTPUT, task); ret = mpi->enqueue(ctx, MPP_PORT_OUTPUT, task);
@@ -294,7 +328,8 @@ MPP_TEST_OUT:
} }
if (MPP_OK == ret) if (MPP_OK == ret)
mpp_log("mpi_enc_test success\n"); mpp_log("mpi_enc_test success total frame %d bps %lld\n",
frame_count, (RK_U64)((stream_size * 8) / (frame_count / mpp_cfg.fps_out)));
else else
mpp_err("mpi_enc_test failed ret %d\n", ret); mpp_err("mpi_enc_test failed ret %d\n", ret);