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

[mpp_enc_cfg]: Add MppEncCfg control

Browse Source 
1. Add h264e process function.
1. Add h265e process function.
2. Add jpege process function.
2. Add vpu_api_legacy support.
3. Clear input MppEncCfgSet when MPP_ENC_SET_CFG is finished.

Change-Id: Ida1234c351483bd9f96a75bc77e90ca2d75ec38b
Signed-off-by: Herman Chen <herman.chen@rock-chips.com>
This commit is contained in:
Herman Chen
2020-05-13 16:23:35 +08:00
parent 8e00c203d7
commit 83e2724158
9 changed files with 705 additions and 512 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
inc/rk_mpi_cmd.h
View File

@@ -96,14 +96,14 @@ typedef enum {
MPP_ENC_CMD_BASE = CMD_MODULE_CODEC | CMD_CTX_ID_ENC,
/* basic encoder setup control */
MPP_ENC_SET_CFG, /* set MppEncCfgSet structure */
MPP_ENC_GET_CFG, /* get MppEncCfgSet structure */
MPP_ENC_SET_PREP_CFG, /* set MppEncPrepCfg structure */
MPP_ENC_GET_PREP_CFG, /* get MppEncPrepCfg structure */
MPP_ENC_SET_RC_CFG, /* set MppEncRcCfg structure */
MPP_ENC_GET_RC_CFG, /* get MppEncRcCfg structure */
MPP_ENC_SET_CODEC_CFG, /* set MppEncCodecCfg structure */
MPP_ENC_GET_CODEC_CFG, /* get MppEncCodecCfg structure */
MPP_ENC_SET_CFG, /* set MppEncCfg structure */
MPP_ENC_GET_CFG, /* get MppEncCfg structure */
MPP_ENC_SET_PREP_CFG, /* deprecated set MppEncPrepCfg structure, use MPP_ENC_SET_CFG instead */
MPP_ENC_GET_PREP_CFG, /* deprecated get MppEncPrepCfg structure, use MPP_ENC_GET_CFG instead */
MPP_ENC_SET_RC_CFG, /* deprecated set MppEncRcCfg structure, use MPP_ENC_SET_CFG instead */
MPP_ENC_GET_RC_CFG, /* deprecated get MppEncRcCfg structure, use MPP_ENC_GET_CFG instead */
MPP_ENC_SET_CODEC_CFG, /* deprecated set MppEncCodecCfg structure, use MPP_ENC_SET_CFG instead */
MPP_ENC_GET_CODEC_CFG, /* deprecated get MppEncCodecCfg structure, use MPP_ENC_GET_CFG instead */
/* runtime encoder setup control */
MPP_ENC_SET_IDR_FRAME, /* next frame will be encoded as intra frame */
MPP_ENC_SET_OSD_LEGACY_0, /* deprecated */

4
mpp/base/mpp_enc_cfg.cpp
View File

@@ -116,7 +116,7 @@ static const char *cfg_func_names[] = {
MPP_RET set_##base##_##name(MppEncCfgSet *cfg, in_type name) \
{ \
mpp_enc_cfg_dbg_func("enter\n"); \
if (cfg->field0.field1 != (in_type)name) { \
if (cfg->field0.field1 != (in_type)name || SET_##func_type == SET_PTR) { \
cfg->field0.field1 = (in_type)name; \
cfg->field0.change |= flag; \
} \
@@ -171,6 +171,8 @@ static const char *cfg_func_names[] = {
ENTRY(prep, color, S32, MppFrameColorSpace,MPP_ENC_PREP_CFG_CHANGE_FORMAT, prep, color) \
ENTRY(prep, rotation, S32, MppEncRotationCfg, MPP_ENC_PREP_CFG_CHANGE_ROTATION, prep, rotation) \
ENTRY(prep, mirroring, S32, RK_S32, MPP_ENC_PREP_CFG_CHANGE_MIRRORING, prep, mirroring) \
/* codec coding config */ \
ENTRY(codec, type, S32, MppCodingType, 0, codec, coding) \
/* h264 config */ \
ENTRY(h264, stream_type, S32, RK_S32, MPP_ENC_H264_CFG_STREAM_TYPE, codec.h264, stream_type) \
ENTRY(h264, profile, S32, RK_S32, MPP_ENC_H264_CFG_CHANGE_PROFILE, codec.h264, profile) \

119
mpp/codec/enc/h264/h264e_api_v2.c
View File

@@ -36,6 +36,7 @@
#include "rc.h"
#include "enc_impl_api.h"
#include "mpp_enc_cfg_impl.h"
RK_U32 h264e_debug = 0;
@@ -192,24 +193,14 @@ static MPP_RET h264e_deinit(void *ctx)
return MPP_OK;
}
static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
static MPP_RET h264e_proc_prep_cfg(MppEncPrepCfg *dst, MppEncPrepCfg *src)
{
MPP_RET ret = MPP_OK;
H264eCtx *p = (H264eCtx *)ctx;
h264e_dbg_func("enter ctx %p cmd %x param %p\n", ctx, cmd, param);
switch (cmd) {
case MPP_ENC_SET_CFG : {
} break;
case MPP_ENC_SET_PREP_CFG : {
MppEncPrepCfg *src = (MppEncPrepCfg *)param;
RK_U32 change = src->change;
mpp_assert(change);
if (change) {
MppEncPrepCfg *dst = &p->cfg->prep;
MppEncPrepCfg bak = p->cfg->prep;
MppEncPrepCfg bak = *dst;
if (change & MPP_ENC_PREP_CFG_CHANGE_FORMAT)
dst->format = src->format;
@@ -250,19 +241,23 @@ static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
if (ret) {
mpp_err_f("failed to accept new prep config\n");
*dst = bak;
break;
}
} else {
mpp_log_f("MPP_ENC_SET_PREP_CFG w:h [%d:%d] stride [%d:%d]\n",
dst->width, dst->height, dst->hor_stride, dst->ver_stride);
dst->width, dst->height,
dst->hor_stride, dst->ver_stride);
}
} break;
case MPP_ENC_SET_RC_CFG : {
MppEncRcCfg *src = (MppEncRcCfg *)param;
}
return ret;
}
static MPP_RET h264e_proc_rc_cfg(MppEncRcCfg *dst, MppEncRcCfg *src)
{
MPP_RET ret = MPP_OK;
RK_U32 change = src->change;
if (change) {
MppEncRcCfg *dst = &p->cfg->rc;
MppEncRcCfg bak = p->cfg->rc;
MppEncRcCfg bak = *dst;
if (change & MPP_ENC_RC_CFG_CHANGE_RC_MODE)
dst->rc_mode = src->rc_mode;
@@ -320,17 +315,19 @@ static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
if (ret) {
mpp_err_f("failed to accept new rc config\n");
*dst = bak;
break;
}
} else {
mpp_log_f("MPP_ENC_SET_RC_CFG bps %d [%d : %d] fps [%d:%d] gop %d\n",
dst->bps_target, dst->bps_min, dst->bps_max,
dst->fps_in_num, dst->fps_out_num, dst->gop);
}
} break;
case MPP_ENC_SET_CODEC_CFG : {
MppEncH264Cfg *src = &((MppEncCodecCfg *)param)->h264;
MppEncH264Cfg *dst = &p->cfg->codec.h264;
}
return ret;
}
static MPP_RET h264e_proc_h264_cfg(MppEncH264Cfg *dst, MppEncH264Cfg *src)
{
MPP_RET ret = MPP_OK;
RK_U32 change = src->change;
// TODO: do codec check first
@@ -385,17 +382,12 @@ static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
}
dst->change |= change;
} break;
case MPP_ENC_SET_SEI_CFG : {
} break;
case MPP_ENC_SET_IDR_FRAME : {
p->idr_request++;
} break;
case MPP_ENC_SET_OSD_DATA_CFG : {
} break;
case MPP_ENC_SET_SPLIT : {
MppEncSliceSplit *src = (MppEncSliceSplit *)param;
MppEncSliceSplit *dst = &p->cfg->split;
return ret;
}
static MPP_RET h264e_proc_split_cfg(MppEncSliceSplit *dst, MppEncSliceSplit *src)
{
MPP_RET ret = MPP_OK;
RK_U32 change = src->change;
if (change & MPP_ENC_SPLIT_CFG_CHANGE_MODE) {
@@ -407,6 +399,57 @@ static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
dst->split_arg = src->split_arg;
dst->change |= change;
return ret;
}
static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
{
MPP_RET ret = MPP_OK;
H264eCtx *p = (H264eCtx *)ctx;
MppEncCfgSet *cfg = p->cfg;
h264e_dbg_func("enter ctx %p cmd %x param %p\n", ctx, cmd, param);
switch (cmd) {
case MPP_ENC_SET_CFG : {
MppEncCfgImpl *impl = (MppEncCfgImpl *)param;
MppEncCfgSet *src = &impl->cfg;
if (src->prep.change) {
ret |= h264e_proc_prep_cfg(&cfg->prep, &src->prep);
src->prep.change = 0;
}
if (src->rc.change) {
ret |= h264e_proc_rc_cfg(&cfg->rc, &src->rc);
src->rc.change = 0;
}
if (src->codec.h264.change) {
ret |= h264e_proc_h264_cfg(&cfg->codec.h264, &src->codec.h264);
src->codec.h264.change = 0;
}
if (src->split.change) {
ret |= h264e_proc_split_cfg(&cfg->split, &src->split);
src->split.change = 0;
}
} break;
case MPP_ENC_SET_PREP_CFG : {
ret = h264e_proc_prep_cfg(&cfg->prep, param);
} break;
case MPP_ENC_SET_RC_CFG : {
ret = h264e_proc_rc_cfg(&cfg->rc, param);
} break;
case MPP_ENC_SET_CODEC_CFG : {
MppEncCodecCfg *codec = (MppEncCodecCfg *)param;
ret = h264e_proc_h264_cfg(&cfg->codec.h264, &codec->h264);
} break;
case MPP_ENC_SET_SEI_CFG : {
} break;
case MPP_ENC_SET_IDR_FRAME : {
p->idr_request++;
} break;
case MPP_ENC_SET_SPLIT : {
ret = h264e_proc_split_cfg(&cfg->split, param);
} break;
default:
mpp_err("No correspond cmd found, and can not config!");

254
mpp/codec/enc/h265/h265e_api_v2.c
View File

@@ -19,6 +19,10 @@
#include <string.h>
#include "mpp_env.h"
#include "mpp_mem.h"
#include "rc.h"
#include "mpp_enc_cfg_impl.h"
#include "h265e_api.h"
#include "h265e_slice.h"
@@ -26,8 +30,6 @@
#include "h265e_syntax_new.h"
#include "h265e_ps.h"
#include "h265e_header_gen.h"
#include "mpp_mem.h"
#include "rc.h"
extern RK_U32 h265e_debug;
@@ -342,34 +344,86 @@ static MPP_RET h265e_flush(void *ctx)
return MPP_OK;
}
static MPP_RET h265e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
static MPP_RET h265e_proc_prep_cfg(MppEncPrepCfg *dst, MppEncPrepCfg *src)
{
H265eCtx *p = (H265eCtx *)ctx;
MPP_RET ret = MPP_OK;
h265e_dbg_func("enter ctx %p cmd %08x\n", ctx, cmd);
switch (cmd) {
case MPP_ENC_SET_IDR_FRAME : {
p->syntax.idr_request = 1;
p->idr_request = 1;
} break;
case MPP_ENC_GET_EXTRA_INFO: {
MppPacket pkt_out = (MppPacket )param;
h265e_set_extra_info(p);
h265e_get_extra_info(p, pkt_out);
} break;
case MPP_ENC_SET_PREP_CFG : {
MppEncPrepCfg *src = (MppEncPrepCfg *)param;
MppEncPrepCfg *dst = &p->cfg->prep;
memcpy(dst, src, sizeof(MppEncPrepCfg));
} break;
case MPP_ENC_SET_CODEC_CFG: {
MppEncCodecCfg *cfg = (MppEncCodecCfg *)param;
MppEncH265Cfg *src = &cfg->h265;
MppEncH265Cfg *dst = &p->cfg->codec.h265;
RK_U32 change = cfg->h265.change;
return MPP_OK;
}
static MPP_RET h265e_proc_rc_cfg(MppEncRcCfg *dst, MppEncRcCfg *src)
{
MPP_RET ret = MPP_OK;
RK_U32 change = src->change;
if (change) {
MppEncRcCfg bak = *dst;
if (change & MPP_ENC_RC_CFG_CHANGE_RC_MODE)
dst->rc_mode = src->rc_mode;
if (change & MPP_ENC_RC_CFG_CHANGE_QUALITY)
dst->quality = src->quality;
if (change & MPP_ENC_RC_CFG_CHANGE_BPS) {
dst->bps_target = src->bps_target;
dst->bps_max = src->bps_max;
dst->bps_min = src->bps_min;
}
if (change & MPP_ENC_RC_CFG_CHANGE_FPS_IN) {
dst->fps_in_flex = src->fps_in_flex;
dst->fps_in_num = src->fps_in_num;
dst->fps_in_denorm = src->fps_in_denorm;
}
if (change & MPP_ENC_RC_CFG_CHANGE_FPS_OUT) {
dst->fps_out_flex = src->fps_out_flex;
dst->fps_out_num = src->fps_out_num;
dst->fps_out_denorm = src->fps_out_denorm;
}
if (change & MPP_ENC_RC_CFG_CHANGE_GOP)
dst->gop = src->gop;
// parameter checking
if (dst->rc_mode >= MPP_ENC_RC_MODE_BUTT) {
mpp_err("invalid rc mode %d should be RC_MODE_VBR or RC_MODE_CBR\n",
src->rc_mode);
ret = MPP_ERR_VALUE;
}
if (dst->quality >= MPP_ENC_RC_QUALITY_BUTT) {
mpp_err("invalid quality %d should be from QUALITY_WORST to QUALITY_BEST\n",
dst->quality);
ret = MPP_ERR_VALUE;
}
if (dst->rc_mode != MPP_ENC_RC_MODE_FIXQP) {
if ((dst->bps_target >= 100 * SZ_1M || dst->bps_target <= 1 * SZ_1K) ||
(dst->bps_max >= 100 * SZ_1M || dst->bps_max <= 1 * SZ_1K) ||
(dst->bps_min >= 100 * SZ_1M || dst->bps_min <= 1 * SZ_1K)) {
mpp_err("invalid bit per second %d [%d:%d] out of range 1K~100M\n",
dst->bps_target, dst->bps_min, dst->bps_max);
ret = MPP_ERR_VALUE;
}
}
dst->change |= change;
if (ret) {
mpp_err_f("failed to accept new rc config\n");
*dst = bak;
} else {
mpp_log_f("MPP_ENC_SET_RC_CFG bps %d [%d : %d] fps [%d:%d] gop %d\n",
dst->bps_target, dst->bps_min, dst->bps_max,
dst->fps_in_num, dst->fps_out_num, dst->gop);
}
}
return ret;
}
static MPP_RET h265e_proc_h265_cfg(MppEncH265Cfg *dst, MppEncH265Cfg *src)
{
RK_U32 change = src->change;
// TODO: do codec check first
if (change & MPP_ENC_H265_CFG_PROFILE_LEVEL_TILER_CHANGE) {
@@ -418,86 +472,81 @@ static MPP_RET h265e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
* When next encoding is trigger the change flag will be clear
*/
dst->change |= change;
return MPP_OK;
}
static MPP_RET h265e_proc_split_cfg(MppEncH265SliceCfg *dst, MppEncSliceSplit *src)
{
if (src->split_mode > MPP_ENC_SPLIT_NONE) {
dst->split_enable = 1;
dst->split_mode = 0;
if (src->split_mode == MPP_ENC_SPLIT_BY_CTU)
dst->split_mode = 1;
dst->slice_size = src->split_arg;
} else {
dst->split_enable = 0;
}
return MPP_OK;
}
static MPP_RET h265e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
{
H265eCtx *p = (H265eCtx *)ctx;
MppEncCfgSet *cfg = p->cfg;
MPP_RET ret = MPP_OK;
h265e_dbg_func("enter ctx %p cmd %08x\n", ctx, cmd);
switch (cmd) {
case MPP_ENC_SET_CFG : {
MppEncCfgImpl *impl = (MppEncCfgImpl *)param;
MppEncCfgSet *src = &impl->cfg;
if (src->prep.change) {
ret |= h265e_proc_prep_cfg(&cfg->prep, &src->prep);
src->prep.change = 0;
}
if (src->rc.change) {
ret |= h265e_proc_rc_cfg(&cfg->rc, &src->rc);
src->rc.change = 0;
}
if (src->codec.h265.change) {
ret |= h265e_proc_h265_cfg(&cfg->codec.h265, &src->codec.h265);
src->codec.h265.change = 0;
}
if (src->split.change) {
ret |= h265e_proc_split_cfg(&cfg->codec.h265.slice_cfg, &src->split);
src->split.change = 0;
}
} break;
case MPP_ENC_SET_IDR_FRAME : {
p->syntax.idr_request = 1;
p->idr_request = 1;
} break;
case MPP_ENC_GET_EXTRA_INFO: {
MppPacket pkt_out = (MppPacket )param;
h265e_set_extra_info(p);
h265e_get_extra_info(p, pkt_out);
} break;
case MPP_ENC_SET_PREP_CFG : {
ret = h265e_proc_prep_cfg(&cfg->prep, param);
} break;
case MPP_ENC_SET_CODEC_CFG: {
MppEncCodecCfg *codec = (MppEncCodecCfg *)param;
ret = h265e_proc_h265_cfg(&cfg->codec.h265, &codec->h265);
} break;
case MPP_ENC_SET_RC_CFG : {
MppEncRcCfg *src = (MppEncRcCfg *)param;
RK_U32 change = src->change;
if (change) {
MppEncRcCfg *dst = &p->cfg->rc;
MppEncRcCfg bak = p->cfg->rc;
if (change & MPP_ENC_RC_CFG_CHANGE_RC_MODE)
dst->rc_mode = src->rc_mode;
if (change & MPP_ENC_RC_CFG_CHANGE_QUALITY)
dst->quality = src->quality;
if (change & MPP_ENC_RC_CFG_CHANGE_BPS) {
dst->bps_target = src->bps_target;
dst->bps_max = src->bps_max;
dst->bps_min = src->bps_min;
}
if (change & MPP_ENC_RC_CFG_CHANGE_FPS_IN) {
dst->fps_in_flex = src->fps_in_flex;
dst->fps_in_num = src->fps_in_num;
dst->fps_in_denorm = src->fps_in_denorm;
}
if (change & MPP_ENC_RC_CFG_CHANGE_FPS_OUT) {
dst->fps_out_flex = src->fps_out_flex;
dst->fps_out_num = src->fps_out_num;
dst->fps_out_denorm = src->fps_out_denorm;
}
if (change & MPP_ENC_RC_CFG_CHANGE_GOP)
dst->gop = src->gop;
if (change & MPP_ENC_RC_CFG_CHANGE_SKIP_CNT)
dst->skip_cnt = src->skip_cnt;
// parameter checking
if (dst->rc_mode >= MPP_ENC_RC_MODE_BUTT) {
mpp_err("invalid rc mode %d should be RC_MODE_VBR or RC_MODE_CBR\n",
src->rc_mode);
ret = MPP_ERR_VALUE;
}
if (dst->quality >= MPP_ENC_RC_QUALITY_BUTT) {
mpp_err("invalid quality %d should be from QUALITY_WORST to QUALITY_BEST\n",
dst->quality);
ret = MPP_ERR_VALUE;
}
if (dst->rc_mode != MPP_ENC_RC_MODE_FIXQP) {
if ((dst->bps_target >= 100 * SZ_1M || dst->bps_target <= 1 * SZ_1K) ||
(dst->bps_max >= 100 * SZ_1M || dst->bps_max <= 1 * SZ_1K) ||
(dst->bps_min >= 100 * SZ_1M || dst->bps_min <= 1 * SZ_1K)) {
mpp_err("invalid bit per second %d [%d:%d] out of range 1K~100M\n",
dst->bps_target, dst->bps_min, dst->bps_max);
ret = MPP_ERR_VALUE;
}
}
dst->change |= change;
if (ret) {
mpp_err_f("failed to accept new rc config\n");
*dst = bak;
break;
}
mpp_log_f("MPP_ENC_SET_RC_CFG bps %d [%d : %d] fps [%d:%d] gop %d\n",
dst->bps_target, dst->bps_min, dst->bps_max,
dst->fps_in_num, dst->fps_out_num, dst->gop);
}
ret = h265e_proc_rc_cfg(&cfg->rc, param);
} break;
case MPP_ENC_SET_SEI_CFG: {
} break;
case MPP_ENC_SET_SPLIT : {
MppEncSliceSplit *src = (MppEncSliceSplit *)param;
MppEncH265SliceCfg *slice_cfg = &p->cfg->codec.h265.slice_cfg;
MppEncH265SliceCfg *slice_cfg = &cfg->codec.h265.slice_cfg;
if (src->split_mode > MPP_ENC_SPLIT_NONE) {
slice_cfg->split_enable = 1;
slice_cfg->split_mode = 0;
@@ -508,13 +557,10 @@ static MPP_RET h265e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
slice_cfg->split_enable = 0;
}
} break;
case MPP_ENC_SET_GOPREF: {
MppEncGopRef *ref = (MppEncGopRef *)param;
MppEncCfgSet *cfg = p->cfg;
memcpy(&cfg->gop_ref, ref , sizeof(*ref));
} break;
default:
mpp_err("No correspond %08x found, and can not config!\n", cmd);
ret = MPP_NOK;

95
mpp/codec/enc/jpeg/jpege_api_v2.c
View File

@@ -26,6 +26,7 @@
#include "jpege_debug.h"
#include "jpege_api.h"
#include "jpege_syntax.h"
#include "mpp_enc_cfg_impl.h"
typedef struct {
MppEncCfgSet *cfg;
@@ -66,28 +67,23 @@ static MPP_RET jpege_deinit_v2(void *ctx)
return MPP_OK;
}
static MPP_RET jpege_proc_cfg(void *ctx, MpiCmd cmd, void *param)
static MPP_RET jpege_proc_prep_cfg(MppEncPrepCfg *dst, MppEncPrepCfg *src)
{
JpegeCtx *p = (JpegeCtx *)ctx;
MppEncCfgSet *cfg = p->cfg;
MPP_RET ret = MPP_OK;
jpege_dbg_func("enter ctx %p cmd %x param %p\n", ctx, cmd, param);
switch (cmd) {
case MPP_ENC_SET_CFG : {
} break;
case MPP_ENC_SET_PREP_CFG : {
MppEncPrepCfg *src = (MppEncPrepCfg *)param;
RK_U32 change = src->change;
mpp_assert(change);
if (change) {
MppEncPrepCfg *dst = &cfg->prep;
MppEncPrepCfg bak = *dst;
if (change & MPP_ENC_PREP_CFG_CHANGE_FORMAT)
dst->format = src->format;
if (change & MPP_ENC_PREP_CFG_CHANGE_ROTATION)
dst->rotation = src->rotation;
/* jpeg encoder do not have mirring / denoise feature */
if (change & MPP_ENC_PREP_CFG_CHANGE_INPUT) {
if (dst->rotation == MPP_ENC_ROT_90 || dst->rotation == MPP_ENC_ROT_270) {
dst->width = src->height;
@@ -121,8 +117,11 @@ static MPP_RET jpege_proc_cfg(void *ctx, MpiCmd cmd, void *param)
ret = MPP_NOK;
}
dst->change |= change;
// parameter checking
if (dst->width > dst->hor_stride || dst->height > dst->ver_stride) {
mpp_err_f("invalid size w:h [%d:%d] stride [%d:%d]\n",
mpp_err("invalid size w:h [%d:%d] stride [%d:%d]\n",
dst->width, dst->height, dst->hor_stride, dst->ver_stride);
ret = MPP_ERR_VALUE;
}
@@ -134,25 +133,23 @@ static MPP_RET jpege_proc_cfg(void *ctx, MpiCmd cmd, void *param)
mpp_log_f("MPP_ENC_SET_PREP_CFG w:h [%d:%d] stride [%d:%d]\n",
dst->width, dst->height,
dst->hor_stride, dst->ver_stride);
}
}
dst->change = src->change;
return ret;
}
}
} break;
case MPP_ENC_SET_RC_CFG : {
MppEncRcCfg *src = (MppEncRcCfg *)param;
static MPP_RET jpege_proc_rc_cfg(MppEncRcCfg *dst, MppEncRcCfg *src)
{
MPP_RET ret = MPP_OK;
RK_U32 change = src->change;
if (change) {
MppEncRcCfg *dst = &cfg->rc;
MppEncRcCfg bak = *dst;
if (change & MPP_ENC_RC_CFG_CHANGE_RC_MODE)
dst->rc_mode = src->rc_mode;
if (change & MPP_ENC_RC_CFG_CHANGE_QUALITY)
dst->quality = src->quality;
if (change & MPP_ENC_RC_CFG_CHANGE_BPS) {
dst->bps_target = src->bps_target;
dst->bps_max = src->bps_max;
@@ -174,9 +171,6 @@ static MPP_RET jpege_proc_cfg(void *ctx, MpiCmd cmd, void *param)
if (change & MPP_ENC_RC_CFG_CHANGE_GOP)
dst->gop = src->gop;
if (change & MPP_ENC_RC_CFG_CHANGE_SKIP_CNT)
dst->skip_cnt = src->skip_cnt;
// parameter checking
if (dst->rc_mode >= MPP_ENC_RC_MODE_BUTT) {
mpp_err("invalid rc mode %d should be RC_MODE_VBR or RC_MODE_CBR\n",
@@ -209,14 +203,16 @@ static MPP_RET jpege_proc_cfg(void *ctx, MpiCmd cmd, void *param)
dst->fps_in_num, dst->fps_out_num, dst->gop);
}
}
} break;
case MPP_ENC_SET_CODEC_CFG : {
MppEncCodecCfg *codec = (MppEncCodecCfg *)param;
MppEncJpegCfg *src = &codec->jpeg;
return ret;
}
static MPP_RET jpege_proc_jpeg_cfg(MppEncJpegCfg *dst, MppEncJpegCfg *src)
{
MPP_RET ret = MPP_OK;
RK_U32 change = src->change;
if (change) {
MppEncJpegCfg *dst = &cfg->codec.jpeg;
MppEncJpegCfg bak = *dst;
if (change & MPP_ENC_JPEG_CFG_CHANGE_QP) {
@@ -238,6 +234,45 @@ static MPP_RET jpege_proc_cfg(void *ctx, MpiCmd cmd, void *param)
dst->change = src->change;
}
return ret;
}
static MPP_RET jpege_proc_cfg(void *ctx, MpiCmd cmd, void *param)
{
JpegeCtx *p = (JpegeCtx *)ctx;
MppEncCfgSet *cfg = p->cfg;
MPP_RET ret = MPP_OK;
jpege_dbg_func("enter ctx %p cmd %x param %p\n", ctx, cmd, param);
switch (cmd) {
case MPP_ENC_SET_CFG : {
MppEncCfgImpl *impl = (MppEncCfgImpl *)param;
MppEncCfgSet *src = &impl->cfg;
if (src->prep.change) {
ret |= jpege_proc_prep_cfg(&cfg->prep, &src->prep);
src->prep.change = 0;
}
if (src->rc.change) {
ret |= jpege_proc_rc_cfg(&cfg->rc, &src->rc);
src->rc.change = 0;
}
if (src->codec.jpeg.change) {
ret |= jpege_proc_jpeg_cfg(&cfg->codec.jpeg, &src->codec.jpeg);
src->codec.jpeg.change = 0;
}
} break;
case MPP_ENC_SET_PREP_CFG : {
ret = jpege_proc_prep_cfg(&cfg->prep, param);
} break;
case MPP_ENC_SET_RC_CFG : {
ret = jpege_proc_rc_cfg(&cfg->rc, param);
} break;
case MPP_ENC_SET_CODEC_CFG : {
MppEncCodecCfg *codec = (MppEncCodecCfg *)param;
ret = jpege_proc_jpeg_cfg(&cfg->codec.jpeg, &codec->jpeg);
} break;
case MPP_ENC_SET_IDR_FRAME :
case MPP_ENC_SET_OSD_PLT_CFG :

8
mpp/codec/mpp_enc.cpp
View File

@@ -27,6 +27,7 @@
#include "mpp.h"
#include "mpp_enc_debug.h"
#include "mpp_enc_cfg_impl.h"
#include "mpp_enc_impl.h"
#include "mpp_hal.h"
#include "hal_h264e_api.h"
@@ -601,9 +602,10 @@ MPP_RET mpp_enc_control(MppEnc ctx, MpiCmd cmd, void *param)
switch (cmd) {
case MPP_ENC_SET_CFG : {
MppEncRcCfg *rc = &enc->set.rc;
MppEncCfgImpl *cfg = (MppEncCfgImpl *)param;
enc_dbg_ctrl("set all config\n");
memcpy(&enc->set, param, sizeof(enc->set));
memcpy(&enc->set, &cfg->cfg, sizeof(enc->set));
if (rc->rc_mode == MPP_ENC_RC_MODE_VBR && rc->quality == MPP_ENC_RC_QUALITY_CQP)
rc->rc_mode = MPP_ENC_RC_MODE_FIXQP;
@@ -622,10 +624,10 @@ MPP_RET mpp_enc_control(MppEnc ctx, MpiCmd cmd, void *param)
ret = mpp_hal_control(enc->hal, MPP_ENC_SET_CODEC_CFG, &enc->set.codec);
} break;
case MPP_ENC_GET_CFG : {
MppEncCfgSet *p = (MppEncCfgSet *)param;
MppEncCfgImpl *p = (MppEncCfgImpl *)param;
enc_dbg_ctrl("get all config\n");
memcpy(p, &enc->cfg, sizeof(*p));
memcpy(&p->cfg, &enc->cfg, sizeof(enc->cfg));
} break;
case MPP_ENC_SET_PREP_CFG : {
enc_dbg_ctrl("set prep config\n");

5
mpp/codec/mpp_enc_v2.cpp
View File

@@ -27,6 +27,7 @@
#include "mpp.h"
#include "mpp_enc_debug.h"
#include "mpp_enc_cfg_impl.h"
#include "mpp_enc_impl.h"
#include "mpp_enc_hal.h"
#include "hal_h264e_api_v2.h"
@@ -1076,8 +1077,10 @@ MPP_RET mpp_enc_control_v2(MppEnc ctx, MpiCmd cmd, void *param)
switch (cmd) {
case MPP_ENC_GET_CFG : {
MppEncCfgImpl *p = (MppEncCfgImpl *)param;
enc_dbg_ctrl("get all config\n");
memcpy(param, &enc->cfg, sizeof(enc->cfg));
memcpy(&p->cfg, &enc->cfg, sizeof(enc->cfg));
} break;
case MPP_ENC_GET_PREP_CFG : {
enc_dbg_ctrl("get prep config\n");

94
mpp/legacy/vpu_api_legacy.cpp
View File

@@ -87,17 +87,11 @@ static MppFrameFormat vpu_pic_type_remap_to_mpp(EncInputPictureType type)
return ret;
}
static MPP_RET vpu_api_set_enc_cfg(MppCtx mpp_ctx, MppApi *mpi,
static MPP_RET vpu_api_set_enc_cfg(MppCtx mpp_ctx, MppApi *mpi, MppEncCfg enc_cfg,
MppCodingType coding, MppFrameFormat fmt,
EncParameter_t *cfg)
{
MPP_RET ret = MPP_OK;
MppEncCodecCfg codec;
MppEncPrepCfg prep;
MppEncRcCfg rc;
MppEncCodecCfg *codec_cfg = &codec;
MppEncPrepCfg *prep_cfg = &prep;
MppEncRcCfg *rc_cfg = &rc;
RK_S32 width = cfg->width;
RK_S32 height = cfg->height;
RK_S32 bps = cfg->bitRate;
@@ -125,6 +119,57 @@ static MPP_RET vpu_api_set_enc_cfg(MppCtx mpp_ctx, MppApi *mpi,
mpp_assert(height);
mpp_assert(qp);
mpp_enc_cfg_set_s32(enc_cfg, "prep:width", width);
mpp_enc_cfg_set_s32(enc_cfg, "prep:height", height);
mpp_enc_cfg_set_s32(enc_cfg, "prep:hor_stride", MPP_ALIGN(width, 16));
mpp_enc_cfg_set_s32(enc_cfg, "prep:ver_stride", MPP_ALIGN(height, 16));
mpp_enc_cfg_set_s32(enc_cfg, "prep:format", fmt);
mpp_enc_cfg_set_s32(enc_cfg, "rc:rc_mode", rc_mode ? MPP_ENC_RC_MODE_CBR : MPP_ENC_RC_MODE_FIXQP);
mpp_enc_cfg_set_s32(enc_cfg, "rc:bps_target", bps);
mpp_enc_cfg_set_s32(enc_cfg, "rc:bps_max", bps * 17 / 16);
mpp_enc_cfg_set_s32(enc_cfg, "rc:bps_min", bps * 17 / 16);
mpp_enc_cfg_set_s32(enc_cfg, "rc:fps_in_flex", 0);
mpp_enc_cfg_set_s32(enc_cfg, "rc:fps_in_num", fps_in);
mpp_enc_cfg_set_s32(enc_cfg, "rc:fps_in_denorm", 1);
mpp_enc_cfg_set_s32(enc_cfg, "rc:fps_out_flex", 0);
mpp_enc_cfg_set_s32(enc_cfg, "rc:fps_out_num", fps_out);
mpp_enc_cfg_set_s32(enc_cfg, "rc:fps_out_denorm", 1);
mpp_enc_cfg_set_s32(enc_cfg, "rc:gop", gop);
mpp_enc_cfg_set_s32(enc_cfg, "codec:type", coding);
switch (coding) {
case MPP_VIDEO_CodingAVC : {
mpp_enc_cfg_set_s32(enc_cfg, "h264:profile", profile);
mpp_enc_cfg_set_s32(enc_cfg, "h264:level", level);
mpp_enc_cfg_set_s32(enc_cfg, "h264:cabac_en", cabac_en);
mpp_enc_cfg_set_s32(enc_cfg, "h264:cabac_idc", 0);
mpp_enc_cfg_set_s32(enc_cfg, "h264:qp_init", rc_mode ? 0 : qp);
mpp_enc_cfg_set_s32(enc_cfg, "h264:qp_min", rc_mode ? 10 : qp);
mpp_enc_cfg_set_s32(enc_cfg, "h264:qp_max", rc_mode ? 51 : qp);
mpp_enc_cfg_set_s32(enc_cfg, "h264:qp_step", rc_mode ? 4 : 0);
} break;
case MPP_VIDEO_CodingMJPEG : {
mpp_enc_cfg_set_s32(enc_cfg, "jpeg:quant", qp);
} break;
default : {
mpp_err_f("support encoder coding type %d\n", coding);
} break;
}
ret = mpi->control(mpp_ctx, MPP_ENC_SET_CFG, enc_cfg);
if (ret) {
mpp_err("setup enc config failed ret %d\n", ret);
goto RET;
}
#if 0
MppEncCodecCfg codec;
MppEncPrepCfg prep;
MppEncRcCfg rc;
MppEncCodecCfg *codec_cfg = &codec;
MppEncPrepCfg *prep_cfg = &prep;
MppEncRcCfg *rc_cfg = &rc;
prep_cfg->change = MPP_ENC_PREP_CFG_CHANGE_INPUT |
MPP_ENC_PREP_CFG_CHANGE_FORMAT;
prep_cfg->width = width;
@@ -215,6 +260,7 @@ static MPP_RET vpu_api_set_enc_cfg(MppCtx mpp_ctx, MppApi *mpi,
ret = mpi->control(mpp_ctx, MPP_ENC_SET_CODEC_CFG, codec_cfg);
if (ret)
mpp_err("setup codec config failed ret %d\n", ret);
#endif
RET:
return ret;
}
@@ -294,13 +340,14 @@ VpuApiLegacy::VpuApiLegacy() :
format(MPP_FMT_YUV420P),
fd_input(-1),
fd_output(-1),
mEosSet(0)
mEosSet(0),
enc_cfg(NULL)
{
vpu_api_dbg_func("enter\n");
mpp_create(&mpp_ctx, &mpi);
memset(&enc_cfg, 0, sizeof(enc_cfg));
memset(&enc_param, 0, sizeof(enc_param));
vpu_api_dbg_func("leave\n");
}
@@ -308,12 +355,17 @@ VpuApiLegacy::~VpuApiLegacy()
{
vpu_api_dbg_func("enter\n");
mpp_destroy(mpp_ctx);
if (memGroup) {
mpp_buffer_group_put(memGroup);
memGroup = NULL;
}
mpp_destroy(mpp_ctx);
if (enc_cfg) {
mpp_enc_cfg_deinit(enc_cfg);
enc_cfg = NULL;
}
vpu_api_dbg_func("leave\n");
}
@@ -404,16 +456,24 @@ RK_S32 VpuApiLegacy::init(VpuCodecContext *ctx, RK_U8 *extraData, RK_U32 extra_s
if (memGroup == NULL) {
ret = mpp_buffer_group_get_internal(&memGroup, MPP_BUFFER_TYPE_ION);
if (MPP_OK != ret) {
mpp_err("memGroup mpp_buffer_group_get failed\n");
if (ret) {
mpp_err("memGroup mpp_buffer_group_get failed %d\n", ret);
return ret;
}
}
ret = mpp_enc_cfg_init(&enc_cfg);
if (ret) {
mpp_err("mpp_enc_cfg_init failed %d\n", ret);
mpp_buffer_group_put(memGroup);
memGroup = NULL;
return ret;
}
format = vpu_pic_type_remap_to_mpp((EncInputPictureType)param->format);
memcpy(&enc_cfg, param, sizeof(enc_cfg));
vpu_api_set_enc_cfg(mpp_ctx, mpi, coding, format, param);
memcpy(&enc_param, param, sizeof(enc_param));
vpu_api_set_enc_cfg(mpp_ctx, mpi, enc_cfg, coding, format, param);
mpi->control(mpp_ctx, MPP_ENC_GET_EXTRA_INFO, &pkt);
@@ -1368,11 +1428,11 @@ RK_S32 VpuApiLegacy::control(VpuCodecContext *ctx, VPU_API_CMD cmd, void *param)
case VPU_API_ENC_SETCFG : {
MppCodingType coding = (MppCodingType)ctx->videoCoding;
memcpy(&enc_cfg, param, sizeof(enc_cfg));
return vpu_api_set_enc_cfg(mpp_ctx, mpi, coding, format, &enc_cfg);
memcpy(&enc_param, param, sizeof(enc_param));
return vpu_api_set_enc_cfg(mpp_ctx, mpi, enc_cfg, coding, format, &enc_param);
} break;
case VPU_API_ENC_GETCFG : {
memcpy(param, &enc_cfg, sizeof(enc_cfg));
memcpy(param, &enc_param, sizeof(enc_param));
return 0;
} break;
case VPU_API_ENC_SETFORMAT : {

4
mpp/legacy/vpu_api_legacy.h
View File

@@ -21,6 +21,7 @@
#include "vpu_api.h"
#include "rk_mpi.h"
#include "rk_venc_cfg.h"
#define OMX_BUFFERFLAG_EOS 0x00000001
@@ -79,7 +80,8 @@ private:
RK_U32 mEosSet;
EncParameter_t enc_cfg;
EncParameter_t enc_param;
MppEncCfg enc_cfg;
};
#endif /*_VPU_API_H_*/