package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-06 01:26:49 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[gop_ref]: Remove gop_ref

Browse Source 
New reference frame config interface will be added.

Change-Id: I5766cefde12237561bbc20c905e47ed2d3e90011
Signed-off-by: Herman Chen <herman.chen@rock-chips.com>
This commit is contained in:
Herman Chen
2020-05-26 11:22:57 +08:00
parent 1b345c8cda
commit 6a6521ed13
13 changed files with 28 additions and 741 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
inc/rk_venc_cmd.h
View File

@@ -1001,79 +1001,6 @@ typedef struct MppEncSliceSplit_t {
RK_U32 split_arg; RK_U32 split_arg;
} MppEncSliceSplit; } MppEncSliceSplit;
typedef enum MppEncRefMode_e {
GopRefModeRockchip,
GopRefModeHisilicon,
GopRefModeButt,
} MppEncRefMode;
#define MAX_GOP_REF_LEN 16
#define GOP_REF_SIZE (MAX_GOP_REF_LEN+1)
#define MAX_TEMPORAL_LAYER 4
typedef struct MppGopRefInfo_t {
RK_S32 temporal_id;
RK_S32 ref_idx;
RK_S32 is_non_ref;
RK_S32 is_lt_ref;
RK_S32 lt_idx;
} MppGopRefInfo;
typedef enum MppEncGopRefChange_e {
/* change on gop_cfg_enable flag */
MPP_ENC_GOPREF_ENABLE = (1 << 0),
/* change on lt_ref_interval and max_lt_ref_cnt for long-term reference loop */
MPP_ENC_GOPREF_LT_LOOP = (1 << 1),
/* change on ref_gop_len and gop_info for short-term reference gop config */
MPP_ENC_GOPREF_ST_GOP = (1 << 2),
/* change on layer_rc_enable and layer_weight for layer rate control config */
MPP_ENC_GOPREF_LAYER_RC = (1 << 3),
MPP_ENC_GOPREF_CHANGE_ALL = (0xFFFFFFFF),
} MppEncGopRefChange;
typedef struct MppEncGopRef_t {
RK_U32 change;
/*
* Enable flag for gop reference configuration
* 0 - Default reference mode I P P P ...
* 1 - Customized reference configuration
*/
RK_U32 gop_cfg_enable;
/*
* Long-term reference frame interval is used for error recovery
*
* When lt_ref_interval is zero the long-term frame mode is indicated by
* gop_info configuration.
* When lt_ref_interval is non-zero (usually 2~3 second interval) then
* the long-term reference can be used for error recovery.
*/
RK_S32 lt_ref_interval;
/*
* Max long-term reference frame index plus 1 indicated the max number of
* long-term reference frame.
*
* When zero there is no long-term refernce frame.
* When larger than zero the max long-term reference frame index is
* max_lt_ref_cnt - 1.
* The max long-term reference frame index should NOT larger than
* max_num_ref_frames in sps and should NOT over the limit in gop_info.
*/
RK_S32 max_lt_ref_cnt;
/* Reference frame gop (vgop) config */
RK_S32 ref_gop_len;
MppGopRefInfo gop_info[GOP_REF_SIZE];
/* temporal layer rate control config (max 4 layer) */
RK_S32 layer_rc_enable;
RK_S32 layer_weight[MAX_TEMPORAL_LAYER];
} MppEncGopRef;
/** /**
* @brief Mpp ROI parameter * @brief Mpp ROI parameter
* Region configure define a rectangle as ROI * Region configure define a rectangle as ROI

138
mpp/codec/enc/h264/h264e_dpb.c
View File

@@ -152,7 +152,6 @@ MPP_RET h264e_dpb_copy(H264eDpb *dst, H264eDpb *src)
MPP_RET h264e_dpb_set_cfg(H264eDpb *dpb, MppEncCfgSet* cfg, SynH264eSps *sps) MPP_RET h264e_dpb_set_cfg(H264eDpb *dpb, MppEncCfgSet* cfg, SynH264eSps *sps)
{ {
MPP_RET ret = MPP_OK; MPP_RET ret = MPP_OK;
RK_S32 i;
h264e_dbg_dpb("enter %p\n", dpb); h264e_dbg_dpb("enter %p\n", dpb);
@@ -190,128 +189,35 @@ MPP_RET h264e_dpb_set_cfg(H264eDpb *dpb, MppEncCfgSet* cfg, SynH264eSps *sps)
dpb->idr_gop_idx = 0; dpb->idr_gop_idx = 0;
dpb->idr_gop_len = cfg->rc.gop; dpb->idr_gop_len = cfg->rc.gop;
/* 3. setup gop ref hierarchy (vgop) */
MppEncGopRef *ref = &cfg->gop_ref;
dpb->mode = 0; dpb->mode = 0;
if (!ref->gop_cfg_enable) { /* set default dpb info */
/* set default dpb info */ EncFrmStatus *info = &dpb->ref_inf[0];
EncFrmStatus *info = &dpb->ref_inf[0];
info[0].is_intra = 1; info[0].is_intra = 1;
info[0].is_idr = 1; info[0].is_idr = 1;
info[0].is_non_ref = 0; info[0].is_non_ref = 0;
info[0].is_lt_ref = 0; info[0].is_lt_ref = 0;
info[0].lt_idx = -1; info[0].lt_idx = -1;
info[0].temporal_id = 0; info[0].temporal_id = 0;
info[0].ref_dist = -1; info[0].ref_dist = -1;
info[1].is_intra = 0; info[1].is_intra = 0;
info[1].is_idr = 0; info[1].is_idr = 0;
info[1].is_non_ref = 0; info[1].is_non_ref = 0;
info[1].is_lt_ref = 0; info[1].is_lt_ref = 0;
info[1].lt_idx = -1; info[1].lt_idx = -1;
info[1].temporal_id = 0; info[1].temporal_id = 0;
info[1].ref_dist = -1; info[1].ref_dist = -1;
dpb->ref_cnt[0] = 2; dpb->ref_cnt[0] = 2;
dpb->ref_cnt[1] = 2; dpb->ref_cnt[1] = 2;
dpb->ref_dist[0] = -1; dpb->ref_dist[0] = -1;
dpb->ref_dist[1] = -1; dpb->ref_dist[1] = -1;
dpb->st_gop_len = 1; dpb->st_gop_len = 1;
dpb->lt_gop_len = 0; dpb->lt_gop_len = 0;
goto GOP_CFG_DONE;
}
memset(dpb->ref_inf, 0, sizeof(dpb->ref_inf));
memset(dpb->ref_sta, 0, sizeof(dpb->ref_sta));
memset(dpb->ref_cnt, 0, sizeof(dpb->ref_cnt));
memset(dpb->ref_dist, 0, sizeof(dpb->ref_dist));
RK_S32 st_gop_len = ref->ref_gop_len;
RK_S32 lt_gop_len = ref->lt_ref_interval;
RK_S32 max_layer_id = 0;
dpb->st_gop_len = st_gop_len;
dpb->lt_gop_len = lt_gop_len;
if (ref->max_lt_ref_cnt)
dpb->max_lt_idx = ref->max_lt_ref_cnt - 1;
else
dpb->max_lt_idx = 0;
h264e_dbg_dpb("st_gop_len %d lt_gop_len %d max_lt_idx_plus_1 %d\n",
dpb->st_gop_len, dpb->lt_gop_len,
dpb->max_lt_idx);
if (st_gop_len)
dpb->mode |= H264E_ST_GOP_FLAG;
if (lt_gop_len) {
dpb->mode |= H264E_LT_GOP_FLAG;
mpp_assert(ref->max_lt_ref_cnt > 0);
}
RK_S32 max_lt_ref_idx = -1;
for (i = 0; i < st_gop_len + 1; i++) {
MppGopRefInfo *info = &ref->gop_info[i];
RK_S32 is_non_ref = info->is_non_ref;
RK_S32 is_lt_ref = info->is_lt_ref;
RK_S32 temporal_id = info->temporal_id;
RK_S32 lt_idx = info->lt_idx;
RK_S32 ref_idx = info->ref_idx;
dpb->ref_inf[i].is_intra = (i == 0) ? (1) : (0);
dpb->ref_inf[i].is_idr = dpb->ref_inf[i].is_intra;
dpb->ref_inf[i].is_non_ref = is_non_ref;
dpb->ref_inf[i].is_lt_ref = is_lt_ref;
dpb->ref_inf[i].lt_idx = lt_idx;
dpb->ref_inf[i].temporal_id = temporal_id;
dpb->ref_inf[i].ref_dist = ref_idx - i;
dpb->ref_dist[i] = ref_idx - i;
if (!is_non_ref) {
dpb->ref_sta[i] |= REF_BY_RECN(i);
dpb->ref_cnt[i]++;
}
if (max_layer_id < temporal_id)
max_layer_id = temporal_id;
if (is_lt_ref) {
if (lt_idx > max_lt_ref_idx) {
max_lt_ref_idx = lt_idx;
h264e_dbg_dpb("curr %d update lt_idx to %d\n",
i, max_lt_ref_idx);
if (max_lt_ref_idx > dpb->max_lt_idx) {
mpp_err("mismatch max_lt_ref_idx_p1 %d vs %d\n",
max_lt_ref_idx, dpb->max_lt_idx);
}
}
dpb->mode |= H264E_ST_GOP_WITH_LT_REF;
if (lt_gop_len)
mpp_err_f("Can NOT use both lt_ref_interval and gop_info lt_ref at the same time!\n ");
}
// update the reference frame status and counter only once
if (ref_idx == i)
continue;
mpp_assert(!dpb->ref_inf[ref_idx].is_non_ref);
dpb->ref_sta[ref_idx] |= REF_BY_REFR(i);
dpb->ref_cnt[ref_idx]++;
h264e_dbg_dpb("refr %d ref_status 0x%03x count %d\n",
ref_idx, dpb->ref_sta[ref_idx], dpb->ref_cnt[ref_idx]);
}
GOP_CFG_DONE:
h264e_dbg_dpb("leave %p\n", dpb); h264e_dbg_dpb("leave %p\n", dpb);
return ret; return ret;

7
mpp/codec/enc/h264/h264e_sps.c
View File

@@ -63,7 +63,6 @@ MPP_RET h264e_sps_update(SynH264eSps *sps, MppEncCfgSet *cfg, MppDeviceId dev)
MppEncPrepCfg *prep = &cfg->prep; MppEncPrepCfg *prep = &cfg->prep;
MppEncRcCfg *rc = &cfg->rc; MppEncRcCfg *rc = &cfg->rc;
MppEncH264Cfg *h264 = &cfg->codec.h264; MppEncH264Cfg *h264 = &cfg->codec.h264;
MppEncGopRef *ref = &cfg->gop_ref;
RK_S32 gop = rc->gop; RK_S32 gop = rc->gop;
RK_S32 width = prep->width; RK_S32 width = prep->width;
RK_S32 height = prep->height; RK_S32 height = prep->height;
@@ -126,12 +125,6 @@ MPP_RET h264e_sps_update(SynH264eSps *sps, MppEncCfgSet *cfg, MppDeviceId dev)
sps->log2_max_frame_num_minus4 = 12; sps->log2_max_frame_num_minus4 = 12;
} }
// NOTE: when tsvc mode enabled poc type should be zero.
if (ref->gop_cfg_enable) {
sps->pic_order_cnt_type = 0;
sps->log2_max_frame_num_minus4 = 12;
}
// max one reference frame // max one reference frame
sps->num_ref_frames = 1; sps->num_ref_frames = 1;
// on tsvc mode we need more reference frame // on tsvc mode we need more reference frame

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

@@ -191,7 +191,6 @@ static MPP_RET h265e_gen_hdr(void *ctx, MppPacket pkt)
h265e_dbg_func("enter ctx %p\n", ctx); h265e_dbg_func("enter ctx %p\n", ctx);
h265e_dpb_set_cfg(&p->dpbcfg, p->cfg);
h265e_set_extra_info(p); h265e_set_extra_info(p);
h265e_get_extra_info(p, pkt); h265e_get_extra_info(p, pkt);
@@ -558,10 +557,6 @@ static MPP_RET h265e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
slice_cfg->split_enable = 0; slice_cfg->split_enable = 0;
} }
} break; } break;
case MPP_ENC_SET_GOPREF: {
MppEncGopRef *ref = (MppEncGopRef *)param;
memcpy(&cfg->gop_ref, ref , sizeof(*ref));
} break;
default: default:
mpp_err("No correspond %08x found, and can not config!\n", cmd); mpp_err("No correspond %08x found, and can not config!\n", cmd);
ret = MPP_NOK; ret = MPP_NOK;

35
mpp/codec/enc/h265/h265e_dpb.c
View File

@@ -232,41 +232,6 @@ void h265e_dpb_samrt_set_ref_list(H265eRpsList *RpsList, H265eReferencePictureSe
h265e_dbg_func("leave\n"); h265e_dbg_func("leave\n");
} }
MPP_RET h265e_dpb_set_cfg(H265eDpbCfg *dpb_cfg, MppEncCfgSet* cfg)
{
MppEncGopRef *ref = &cfg->gop_ref;
/*setup gop ref hierarchy (vgop) */
if (!ref->gop_cfg_enable) {
dpb_cfg->vgop_size = 1;
return MPP_OK;
}
RK_S32 i = 0;
RK_S32 st_gop_len = ref->ref_gop_len;
dpb_cfg->nLongTerm = 1;
dpb_cfg->vgop_size = st_gop_len;
dpb_cfg->vi_gop_len = 0;
for (i = 0; i < st_gop_len + 1; i++) {
MppGopRefInfo *info = &ref->gop_info[i];
RK_S32 is_non_ref = info->is_non_ref;
RK_S32 is_lt_ref = info->is_lt_ref;
RK_S32 temporal_id = info->temporal_id;
RK_S32 lt_idx = info->lt_idx;
RK_S32 ref_idx = info->ref_idx;
dpb_cfg->ref_inf[i].is_intra = (i == 0) ? (1) : (0);
dpb_cfg->ref_inf[i].is_non_ref = is_non_ref;
dpb_cfg->ref_inf[i].is_lt_ref = is_lt_ref;
dpb_cfg->ref_inf[i].lt_idx = lt_idx;
dpb_cfg->ref_inf[i].temporal_id = temporal_id;
dpb_cfg->ref_inf[i].ref_dist = ref_idx - i;
dpb_cfg->nDeltaPocIdx[i] = ref_idx - i;
}
return MPP_OK;
}
/* get buffer at init */ /* get buffer at init */
MPP_RET h265e_dpb_init_curr(H265eDpb *dpb, H265eDpbFrm *frm) MPP_RET h265e_dpb_init_curr(H265eDpb *dpb, H265eDpbFrm *frm)
{ {

1
mpp/codec/enc/h265/h265e_dpb.h
View File

@@ -189,7 +189,6 @@ MPP_RET h265e_dpb_get_curr(H265eDpb *dpb);
H265eDpbFrm *h265e_dpb_get_refr(H265eDpbFrm *frm); H265eDpbFrm *h265e_dpb_get_refr(H265eDpbFrm *frm);
void h265e_dpb_build_list(H265eDpb *dpb); void h265e_dpb_build_list(H265eDpb *dpb);
MppBuffer h265e_dpb_frm_get_buf(H265eDpbFrm *frm, RK_S32 index); MppBuffer h265e_dpb_frm_get_buf(H265eDpbFrm *frm, RK_S32 index);
MPP_RET h265e_dpb_set_cfg(H265eDpbCfg *dpb_cfg, MppEncCfgSet* cfg);
MPP_RET h265e_dpb_bakup(H265eDpb *dpb, H265eDpb *dpb_bak); MPP_RET h265e_dpb_bakup(H265eDpb *dpb, H265eDpb *dpb_bak);
MPP_RET h265e_dpb_recover(H265eDpb *dpb, H265eDpb *dpb_bak); MPP_RET h265e_dpb_recover(H265eDpb *dpb, H265eDpb *dpb_bak);

23
mpp/codec/mpp_enc_v2.cpp
View File

@@ -408,7 +408,6 @@ static const char *name_of_rc_mode[] = {
static void set_rc_cfg(RcCfg *cfg, MppEncCfgSet *cfg_set) static void set_rc_cfg(RcCfg *cfg, MppEncCfgSet *cfg_set)
{ {
MppEncRcCfg *rc = &cfg_set->rc; MppEncRcCfg *rc = &cfg_set->rc;
MppEncGopRef *ref = &cfg_set->gop_ref;
MppEncPrepCfg *prep = &cfg_set->prep; MppEncPrepCfg *prep = &cfg_set->prep;
MppEncCodecCfg *codec = &cfg_set->codec; MppEncCodecCfg *codec = &cfg_set->codec;
@@ -443,7 +442,7 @@ static void set_rc_cfg(RcCfg *cfg, MppEncCfgSet *cfg_set)
cfg->bps_min = rc->bps_min; cfg->bps_min = rc->bps_min;
cfg->stat_times = 3; cfg->stat_times = 3;
cfg->vgop = (ref->gop_cfg_enable) ? (ref->ref_gop_len) : (0); cfg->vgop = 0;
/* quality configure */ /* quality configure */
switch (codec->coding) { switch (codec->coding) {
@@ -474,18 +473,10 @@ static void set_rc_cfg(RcCfg *cfg, MppEncCfgSet *cfg_set)
} break; } break;
} }
if (ref->layer_rc_enable) { cfg->layer_bit_prop[0] = 256;
RK_S32 i; cfg->layer_bit_prop[1] = 0;
cfg->layer_bit_prop[2] = 0;
for (i = 0; i < MAX_TEMPORAL_LAYER; i++) { cfg->layer_bit_prop[3] = 0;
cfg->layer_bit_prop[i] = ref->layer_weight[i];
}
} else {
cfg->layer_bit_prop[0] = 256;
cfg->layer_bit_prop[1] = 0;
cfg->layer_bit_prop[2] = 0;
cfg->layer_bit_prop[3] = 0;
}
cfg->max_reencode_times = rc->max_reenc_times; cfg->max_reencode_times = rc->max_reenc_times;
@@ -508,7 +499,6 @@ void *mpp_enc_thread(void *data)
MppThread *thd_enc = enc->thread_enc; MppThread *thd_enc = enc->thread_enc;
MppEncCfgSet *cfg = &enc->cfg; MppEncCfgSet *cfg = &enc->cfg;
MppEncRcCfg *rc_cfg = &cfg->rc; MppEncRcCfg *rc_cfg = &cfg->rc;
MppEncGopRef *ref_cfg = &cfg->gop_ref;
MppEncPrepCfg *prep_cfg = &cfg->prep; MppEncPrepCfg *prep_cfg = &cfg->prep;
EncRcTask *rc_task = &enc->rc_task; EncRcTask *rc_task = &enc->rc_task;
EncFrmStatus *frm = &rc_task->frm; EncFrmStatus *frm = &rc_task->frm;
@@ -635,7 +625,7 @@ void *mpp_enc_thread(void *data)
goto TASK_RETURN; goto TASK_RETURN;
// 7. check and update rate control config // 7. check and update rate control config
if (rc_cfg->change || ref_cfg->change || prep_cfg->change) { if (rc_cfg->change || prep_cfg->change) {
RcCfg usr_cfg; RcCfg usr_cfg;
enc_dbg_detail("rc update cfg start\n"); enc_dbg_detail("rc update cfg start\n");
@@ -643,7 +633,6 @@ void *mpp_enc_thread(void *data)
set_rc_cfg(&usr_cfg, cfg); set_rc_cfg(&usr_cfg, cfg);
ret = rc_update_usr_cfg(enc->rc_ctx, &usr_cfg); ret = rc_update_usr_cfg(enc->rc_ctx, &usr_cfg);
rc_cfg->change = 0; rc_cfg->change = 0;
ref_cfg->change = 0;
prep_cfg->change = 0; prep_cfg->change = 0;
enc_dbg_detail("rc update cfg done\n"); enc_dbg_detail("rc update cfg done\n");

135
mpp/hal/vpu/h264e/hal_h264e_vepu1_v2.c
View File

@@ -624,142 +624,7 @@ static MPP_RET hal_h264e_vepu1_wait_v2(void *hal, HalEncTask *task)
} }
h264e_vepu1_get_mbrc(hw_mbrc, &ctx->regs_get); h264e_vepu1_get_mbrc(hw_mbrc, &ctx->regs_get);
h264e_vepu_mbrc_update(ctx->rc_ctx, hw_mbrc); h264e_vepu_mbrc_update(ctx->rc_ctx, hw_mbrc);
/* On TSVC case modify AVC stream to TSVC stream */
MppEncCfgSet *cfg = ctx->cfg;
H264eSlice *slice = ctx->slice;
MppEncGopRef *ref = &cfg->gop_ref;
MppEncH264Cfg *h264 = &cfg->codec.h264;
if (h264->svc || ref->gop_cfg_enable) {
H264eSlice hw_slice;
MppBuffer buf = task->output;
RK_U8 *p = mpp_buffer_get_ptr(buf);
RK_U32 len = hw_mbrc->out_strm_size;
RK_S32 size = mpp_buffer_get_size(buf);
RK_S32 hw_len_bit = 0;
RK_S32 sw_len_bit = 0;
RK_S32 hw_len_byte = 0;
RK_S32 sw_len_byte = 0;
RK_S32 diff_size = 0;
RK_S32 tail_0bit = 0;
RK_U8 tail_byte = 0;
RK_U8 tail_tmp = 0;
RK_U8 *dst_buf = NULL;
RK_S32 buf_size;
RK_S32 prefix_bit = 0;
RK_S32 prefix_byte = 0;
RK_S32 more_buf = 0;
while (len > ctx->buf_size - 16) {
ctx->buf_size *= 2;
more_buf = 1;
}
if (more_buf) {
MPP_FREE(ctx->src_buf);
MPP_FREE(ctx->dst_buf);
ctx->src_buf = mpp_malloc(RK_U8, ctx->buf_size);
ctx->dst_buf = mpp_malloc(RK_U8, ctx->buf_size);
}
memset(ctx->dst_buf, 0, ctx->buf_size);
dst_buf = ctx->dst_buf;
buf_size = ctx->buf_size;
// copy hw stream to stream buffer first
memcpy(ctx->src_buf, p, len);
// prepare hw_slice with some current setup
memcpy(&hw_slice, slice, sizeof(hw_slice));
// set hw_slice to vepu1 default hardware config
hw_slice.max_num_ref_frames = 1;
hw_slice.pic_order_cnt_type = 2;
hw_slice.log2_max_frame_num = 16;
hw_slice.log2_max_poc_lsb = 16;
hw_len_bit = h264e_slice_read(&hw_slice, ctx->src_buf, size);
if (h264->svc) {
H264ePrefixNal prefix;
prefix.idr_flag = slice->idr_flag;
prefix.nal_ref_idc = slice->nal_reference_idc;
prefix.priority_id = 0;
prefix.no_inter_layer_pred_flag = 1;
prefix.dependency_id = 0;
prefix.quality_id = 0;
prefix.temporal_id = task->temporal_id;
prefix.use_ref_base_pic_flag = 0;
prefix.discardable_flag = 0;
prefix.output_flag = 1;
prefix_bit = h264e_slice_write_prefix_nal_unit_svc(&prefix, dst_buf, buf_size);
prefix_byte = prefix_bit /= 8;
h264e_dbg_slice("prefix_len %d\n", prefix_byte);
dst_buf += prefix_byte;
buf_size -= prefix_byte;
}
// write new header to header buffer
sw_len_bit = h264e_slice_write(slice, dst_buf, buf_size);
h264e_slice_read(slice, dst_buf, size);
hw_len_byte = (hw_len_bit + 7) / 8;
sw_len_byte = (sw_len_bit + 7) / 8;
tail_byte = ctx->src_buf[len - 1];
tail_tmp = tail_byte;
while (!(tail_tmp & 1) && tail_0bit < 8) {
tail_tmp >>= 1;
tail_0bit++;
}
h264e_dbg_slice("tail_byte %02x bit %d\n", tail_byte, tail_0bit);
mpp_assert(tail_0bit < 8);
// move the reset slice data from src buffer to dst buffer
diff_size = h264e_slice_move(dst_buf, ctx->src_buf,
sw_len_bit, hw_len_bit, len);
h264e_dbg_slice("tail 0x%02x %d hw_len_bit %d sw_len_bit %d len %d hw_len_byte %d sw_len_byte %d diff %d\n",
tail_byte, tail_0bit, hw_len_bit, sw_len_bit, len, hw_len_byte, sw_len_byte, diff_size);
if (slice->entropy_coding_mode) {
memcpy(dst_buf + sw_len_byte, ctx->src_buf + hw_len_byte,
len - hw_len_byte);
len += prefix_byte;
memcpy(p, ctx->dst_buf, len - hw_len_byte + sw_len_byte);
// clear the tail data
if (sw_len_byte < hw_len_byte)
memset(p + len - hw_len_byte + sw_len_byte, 0, hw_len_byte - sw_len_byte);
len = len - hw_len_byte + sw_len_byte;
} else {
RK_S32 hdr_diff_bit = sw_len_bit - hw_len_bit;
RK_S32 bit_len = len * 8 - tail_0bit + hdr_diff_bit;
RK_S32 new_len = (bit_len + diff_size * 8 + 7) / 8;
dst_buf[new_len] = 0;
h264e_dbg_slice("frm %d len %d bit hw %d sw %d byte hw %d sw %d diff %d -> %d\n",
ctx->frms->seq_idx, len, hw_len_bit, sw_len_bit,
hw_len_byte, sw_len_byte, diff_size, new_len);
new_len += prefix_byte;
memcpy(p, ctx->dst_buf, new_len);
p[new_len] = 0;
len = new_len;
}
hw_mbrc->out_strm_size = len;
}
task->hw_length += ctx->hw_mbrc.out_strm_size; task->hw_length += ctx->hw_mbrc.out_strm_size;
hal_h264e_dbg_func("leave %p\n", hal); hal_h264e_dbg_func("leave %p\n", hal);

135
mpp/hal/vpu/h264e/hal_h264e_vepu2_v2.c
View File

@@ -651,142 +651,7 @@ static MPP_RET hal_h264e_vepu2_wait_v2(void *hal, HalEncTask *task)
} }
h264e_vepu2_get_mbrc(hw_mbrc, &ctx->regs_get); h264e_vepu2_get_mbrc(hw_mbrc, &ctx->regs_get);
h264e_vepu_mbrc_update(ctx->rc_ctx, hw_mbrc); h264e_vepu_mbrc_update(ctx->rc_ctx, hw_mbrc);
/* On TSVC case modify AVC stream to TSVC stream */
MppEncCfgSet *cfg = ctx->cfg;
H264eSlice *slice = ctx->slice;
MppEncGopRef *ref = &cfg->gop_ref;
MppEncH264Cfg *h264 = &cfg->codec.h264;
if (h264->svc || ref->gop_cfg_enable) {
H264eSlice hw_slice;
MppBuffer buf = task->output;
RK_U8 *p = mpp_buffer_get_ptr(buf);
RK_U32 len = hw_mbrc->out_strm_size;
RK_S32 size = mpp_buffer_get_size(buf);
RK_S32 hw_len_bit = 0;
RK_S32 sw_len_bit = 0;
RK_S32 hw_len_byte = 0;
RK_S32 sw_len_byte = 0;
RK_S32 diff_size = 0;
RK_S32 tail_0bit = 0;
RK_U8 tail_byte = 0;
RK_U8 tail_tmp = 0;
RK_U8 *dst_buf = NULL;
RK_S32 buf_size;
RK_S32 prefix_bit = 0;
RK_S32 prefix_byte = 0;
RK_S32 more_buf = 0;
while (len > ctx->buf_size - 16) {
ctx->buf_size *= 2;
more_buf = 1;
}
if (more_buf) {
MPP_FREE(ctx->src_buf);
MPP_FREE(ctx->dst_buf);
ctx->src_buf = mpp_malloc(RK_U8, ctx->buf_size);
ctx->dst_buf = mpp_malloc(RK_U8, ctx->buf_size);
}
memset(ctx->dst_buf, 0, ctx->buf_size);
dst_buf = ctx->dst_buf;
buf_size = ctx->buf_size;
// copy hw stream to stream buffer first
memcpy(ctx->src_buf, p, len);
// prepare hw_slice with some current setup
memcpy(&hw_slice, slice, sizeof(hw_slice));
// set hw_slice to vepu2 default hardware config
hw_slice.max_num_ref_frames = 1;
hw_slice.pic_order_cnt_type = 2;
hw_slice.log2_max_frame_num = 16;
hw_slice.log2_max_poc_lsb = 16;
hw_len_bit = h264e_slice_read(&hw_slice, ctx->src_buf, size);
if (h264->svc) {
H264ePrefixNal prefix;
prefix.idr_flag = slice->idr_flag;
prefix.nal_ref_idc = slice->nal_reference_idc;
prefix.priority_id = 0;
prefix.no_inter_layer_pred_flag = 1;
prefix.dependency_id = 0;
prefix.quality_id = 0;
prefix.temporal_id = task->temporal_id;
prefix.use_ref_base_pic_flag = 0;
prefix.discardable_flag = 0;
prefix.output_flag = 1;
prefix_bit = h264e_slice_write_prefix_nal_unit_svc(&prefix, dst_buf, buf_size);
prefix_byte = prefix_bit /= 8;
h264e_dbg_slice("prefix_len %d\n", prefix_byte);
dst_buf += prefix_byte;
buf_size -= prefix_byte;
}
// write new header to header buffer
sw_len_bit = h264e_slice_write(slice, dst_buf, buf_size);
h264e_slice_read(slice, dst_buf, size);
hw_len_byte = (hw_len_bit + 7) / 8;
sw_len_byte = (sw_len_bit + 7) / 8;
tail_byte = ctx->src_buf[len - 1];
tail_tmp = tail_byte;
while (!(tail_tmp & 1) && tail_0bit < 8) {
tail_tmp >>= 1;
tail_0bit++;
}
h264e_dbg_slice("tail_byte %02x bit %d\n", tail_byte, tail_0bit);
mpp_assert(tail_0bit < 8);
// move the reset slice data from src buffer to dst buffer
diff_size = h264e_slice_move(dst_buf, ctx->src_buf,
sw_len_bit, hw_len_bit, len);
h264e_dbg_slice("tail 0x%02x %d hw_len_bit %d sw_len_bit %d len %d hw_len_byte %d sw_len_byte %d diff %d\n",
tail_byte, tail_0bit, hw_len_bit, sw_len_bit, len, hw_len_byte, sw_len_byte, diff_size);
if (slice->entropy_coding_mode) {
memcpy(dst_buf + sw_len_byte, ctx->src_buf + hw_len_byte,
len - hw_len_byte);
len += prefix_byte;
memcpy(p, ctx->dst_buf, len - hw_len_byte + sw_len_byte);
// clear the tail data
if (sw_len_byte < hw_len_byte)
memset(p + len - hw_len_byte + sw_len_byte, 0, hw_len_byte - sw_len_byte);
len = len - hw_len_byte + sw_len_byte;
} else {
RK_S32 hdr_diff_bit = sw_len_bit - hw_len_bit;
RK_S32 bit_len = len * 8 - tail_0bit + hdr_diff_bit;
RK_S32 new_len = (bit_len + diff_size * 8 + 7) / 8;
dst_buf[new_len] = 0;
h264e_dbg_slice("frm %d len %d bit hw %d sw %d byte hw %d sw %d diff %d -> %d\n",
ctx->frms->seq_idx, len, hw_len_bit, sw_len_bit,
hw_len_byte, sw_len_byte, diff_size, new_len);
new_len += prefix_byte;
memcpy(p, ctx->dst_buf, new_len);
p[new_len] = 0;
len = new_len;
}
hw_mbrc->out_strm_size = len;
}
task->hw_length += ctx->hw_mbrc.out_strm_size; task->hw_length += ctx->hw_mbrc.out_strm_size;
hal_h264e_dbg_func("leave %p\n", hal); hal_h264e_dbg_func("leave %p\n", hal);

1
mpp/inc/mpp_enc_cfg.h
View File

@@ -36,7 +36,6 @@ typedef struct MppEncCfgSet_t {
MppEncCodecCfg codec; MppEncCodecCfg codec;
MppEncSliceSplit split; MppEncSliceSplit split;
MppEncGopRef gop_ref;
MppEncROICfg roi; MppEncROICfg roi;
MppEncOSDPltCfg plt_cfg; MppEncOSDPltCfg plt_cfg;
MppEncOSDPlt plt_data; MppEncOSDPlt plt_data;

43
test/mpi_enc_test.c
View File

@@ -103,7 +103,6 @@ typedef struct {
RK_S32 fps_out_num; RK_S32 fps_out_num;
RK_S32 bps; RK_S32 bps;
RK_S32 gop_mode; RK_S32 gop_mode;
MppEncGopRef ref;
} MpiEncTestData; } MpiEncTestData;
MPP_RET test_ctx_init(MpiEncTestData **data, MpiEncTestArgs *cmd) MPP_RET test_ctx_init(MpiEncTestData **data, MpiEncTestArgs *cmd)
@@ -410,19 +409,6 @@ MPP_RET test_mpp_setup_legacy(MpiEncTestData *p)
goto RET; goto RET;
} }
if (p->gop_mode && p->gop_mode < 4) {
mpi_enc_gen_gop_ref(&p->ref, p->gop_mode);
mpp_log_f("MPP_ENC_SET_GOPREF start gop mode %d\n", p->gop_mode);
ret = mpi->control(ctx, MPP_ENC_SET_GOPREF, &p->ref);
mpp_log_f("MPP_ENC_SET_GOPREF done ret %d\n", ret);
if (ret) {
mpp_err("mpi control enc set sei cfg failed ret %d\n", ret);
goto RET;
}
}
if (p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC) { if (p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC) {
p->header_mode = MPP_ENC_HEADER_MODE_EACH_IDR; p->header_mode = MPP_ENC_HEADER_MODE_EACH_IDR;
ret = mpi->control(ctx, MPP_ENC_SET_HEADER_MODE, &p->header_mode); ret = mpi->control(ctx, MPP_ENC_SET_HEADER_MODE, &p->header_mode);
@@ -592,19 +578,6 @@ MPP_RET test_mpp_enc_cfg_setup(MpiEncTestData *p)
goto RET; goto RET;
} }
if (p->gop_mode && p->gop_mode < 4) {
mpi_enc_gen_gop_ref(&p->ref, p->gop_mode);
mpp_log_f("MPP_ENC_SET_GOPREF start gop mode %d\n", p->gop_mode);
ret = mpi->control(ctx, MPP_ENC_SET_GOPREF, &p->ref);
mpp_log_f("MPP_ENC_SET_GOPREF done ret %d\n", ret);
if (ret) {
mpp_err("mpi control enc set sei cfg failed ret %d\n", ret);
goto RET;
}
}
if (p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC) { if (p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC) {
p->header_mode = MPP_ENC_HEADER_MODE_EACH_IDR; p->header_mode = MPP_ENC_HEADER_MODE_EACH_IDR;
ret = mpi->control(ctx, MPP_ENC_SET_HEADER_MODE, &p->header_mode); ret = mpi->control(ctx, MPP_ENC_SET_HEADER_MODE, &p->header_mode);
@@ -703,23 +676,7 @@ MPP_RET test_mpp_run(MpiEncTestData *p)
mpp_frame_set_ver_stride(frame, p->ver_stride); mpp_frame_set_ver_stride(frame, p->ver_stride);
mpp_frame_set_fmt(frame, p->fmt); mpp_frame_set_fmt(frame, p->fmt);
mpp_frame_set_eos(frame, p->frm_eos); mpp_frame_set_eos(frame, p->frm_eos);
if (p->ref.max_lt_ref_cnt) {
// force idr as reference every 15 frames
//RK_S32 quotient = p->frame_count / 15;
RK_S32 remainder = p->frame_count % 15;
if (p->frame_count && remainder == 0) {
MppMeta meta = mpp_frame_get_meta(frame);
static RK_S32 lt_ref_idx = 0;
mpp_log("force lt_ref %d\n", lt_ref_idx);
mpp_meta_set_s32(meta, KEY_LONG_REF_IDX, lt_ref_idx);
lt_ref_idx++;
if (lt_ref_idx >= p->ref.max_lt_ref_cnt)
lt_ref_idx = 0;
} else
mpp_frame_set_meta(frame, NULL);
}
if (p->fp_input && feof(p->fp_input)) if (p->fp_input && feof(p->fp_input))
mpp_frame_set_buffer(frame, NULL); mpp_frame_set_buffer(frame, NULL);
else else

172
utils/mpi_enc_utils.c
View File

@@ -265,178 +265,6 @@ MPP_RET mpi_enc_test_cmd_put(MpiEncTestArgs* cmd)
return MPP_OK; return MPP_OK;
} }
MPP_RET mpi_enc_gen_gop_ref(MppEncGopRef *ref, RK_S32 gop_mode)
{
ref->change = 0;
ref->gop_cfg_enable = 0;
/* error gop and tsvc config */
if (gop_mode < 0 || gop_mode > 3)
return MPP_NOK;
// no tsvc config
if (gop_mode == 0)
return MPP_OK;
ref->change = 1;
ref->gop_cfg_enable = 1;
// default no LTR
ref->lt_ref_interval = 0;
ref->max_lt_ref_cnt = 0;
// rockchip tsvc config
MppGopRefInfo *gop = &ref->gop_info[0];
if (gop_mode == 3) {
// tsvc4
// /-> P1 /-> P3 /-> P5 /-> P7
// / / / /
// //--------> P2 //--------> P6
// // //
// ///---------------------> P4
// ///
// P0 ------------------------------------------------> P8
ref->ref_gop_len = 8;
ref->layer_weight[0] = 800;
ref->layer_weight[1] = 400;
ref->layer_weight[2] = 400;
ref->layer_weight[3] = 400;
gop[0].temporal_id = 0;
gop[0].ref_idx = 0;
gop[0].is_non_ref = 0;
gop[0].is_lt_ref = 1;
gop[0].lt_idx = 0;
gop[1].temporal_id = 3;
gop[1].ref_idx = 0;
gop[1].is_non_ref = 1;
gop[1].is_lt_ref = 0;
gop[1].lt_idx = 0;
gop[2].temporal_id = 2;
gop[2].ref_idx = 0;
gop[2].is_non_ref = 0;
gop[2].is_lt_ref = 0;
gop[2].lt_idx = 0;
gop[3].temporal_id = 3;
gop[3].ref_idx = 2;
gop[3].is_non_ref = 1;
gop[3].is_lt_ref = 0;
gop[3].lt_idx = 0;
gop[4].temporal_id = 1;
gop[4].ref_idx = 0;
gop[4].is_non_ref = 0;
gop[4].is_lt_ref = 0;
gop[4].lt_idx = 0;
gop[5].temporal_id = 3;
gop[5].ref_idx = 4;
gop[5].is_non_ref = 1;
gop[5].is_lt_ref = 0;
gop[5].lt_idx = 0;
gop[6].temporal_id = 2;
gop[6].ref_idx = 4;
gop[6].is_non_ref = 0;
gop[6].is_lt_ref = 0;
gop[6].lt_idx = 0;
gop[7].temporal_id = 3;
gop[7].ref_idx = 6;
gop[7].is_non_ref = 1;
gop[7].is_lt_ref = 0;
gop[7].lt_idx = 0;
gop[8].temporal_id = 0;
gop[8].ref_idx = 0;
gop[8].is_non_ref = 0;
gop[8].is_lt_ref = 1;
gop[8].lt_idx = 0;
ref->max_lt_ref_cnt = 1;
} else if (gop_mode == 2) {
// tsvc3
// /-> P1 /-> P3
// / /
// //--------> P2
// //
// P0/---------------------> P4
ref->ref_gop_len = 4;
ref->layer_weight[0] = 1000;
ref->layer_weight[1] = 500;
ref->layer_weight[2] = 500;
ref->layer_weight[3] = 0;
gop[0].temporal_id = 0;
gop[0].ref_idx = 0;
gop[0].is_non_ref = 0;
gop[0].is_lt_ref = 0;
gop[0].lt_idx = 0;
gop[1].temporal_id = 2;
gop[1].ref_idx = 0;
gop[1].is_non_ref = 1;
gop[1].is_lt_ref = 0;
gop[1].lt_idx = 0;
gop[2].temporal_id = 1;
gop[2].ref_idx = 0;
gop[2].is_non_ref = 0;
gop[2].is_lt_ref = 0;
gop[2].lt_idx = 0;
gop[3].temporal_id = 2;
gop[3].ref_idx = 2;
gop[3].is_non_ref = 1;
gop[3].is_lt_ref = 0;
gop[3].lt_idx = 0;
gop[4].temporal_id = 0;
gop[4].ref_idx = 0;
gop[4].is_non_ref = 0;
gop[4].is_lt_ref = 0;
gop[4].lt_idx = 0;
// set to lt_ref interval with looping LTR idx
ref->lt_ref_interval = 10;
ref->max_lt_ref_cnt = 3;
} else if (gop_mode == 1) {
// tsvc2
// /-> P1
// /
// P0--------> P2
ref->ref_gop_len = 2;
ref->layer_weight[0] = 1400;
ref->layer_weight[1] = 600;
ref->layer_weight[2] = 0;
ref->layer_weight[3] = 0;
gop[0].temporal_id = 0;
gop[0].ref_idx = 0;
gop[0].is_non_ref = 0;
gop[0].is_lt_ref = 0;
gop[0].lt_idx = 0;
gop[1].temporal_id = 1;
gop[1].ref_idx = 0;
gop[1].is_non_ref = 1;
gop[1].is_lt_ref = 0;
gop[1].lt_idx = 0;
gop[2].temporal_id = 0;
gop[2].ref_idx = 0;
gop[2].is_non_ref = 0;
gop[2].is_lt_ref = 0;
gop[2].lt_idx = 0;
}
return MPP_OK;
}
MPP_RET mpi_enc_gen_osd_data(MppEncOSDData *osd_data, MppBuffer osd_buf, RK_U32 frame_cnt) MPP_RET mpi_enc_gen_osd_data(MppEncOSDData *osd_data, MppBuffer osd_buf, RK_U32 frame_cnt)
{ {
RK_U32 k = 0; RK_U32 k = 0;

1
utils/mpi_enc_utils.h
View File

@@ -53,7 +53,6 @@ typedef struct MpiEncTestArgs_t {
extern "C" { extern "C" {
#endif #endif
MPP_RET mpi_enc_gen_gop_ref(MppEncGopRef *ref, RK_S32 gop_mode);
MPP_RET mpi_enc_gen_osd_data(MppEncOSDData *osd_data, MppBuffer osd_buf, RK_U32 frame_cnt); MPP_RET mpi_enc_gen_osd_data(MppEncOSDData *osd_data, MppBuffer osd_buf, RK_U32 frame_cnt);
MPP_RET mpi_enc_gen_osd_plt(MppEncOSDPlt *osd_plt, RK_U32 *table); MPP_RET mpi_enc_gen_osd_plt(MppEncOSDPlt *osd_plt, RK_U32 *table);