mirror of
https://github.com/nyanmisaka/mpp.git
synced 2025-10-06 01:26:49 +08:00
c2069f3345
Add MppEncRef/MppEncRefs module MppEncRefs is for mpp encoder coded picture buffer (CPB) management. MppEncRefs will gnerate reference buffer status EncCpbStatus for each encoder to implement its own process. Change-Id: I5f85a0f46dc6bc40954b0393ba52ad4008565643 Signed-off-by: Herman Chen <herman.chen@rock-chips.com>
428 lines
12 KiB
C++
428 lines
12 KiB
C++
/*
|
|
* Copyright 2015 Rockchip Electronics Co. LTD
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define MODULE_TAG "mpp_enc_ref"
|
|
|
|
#include <string.h>
|
|
|
|
#include "mpp_env.h"
|
|
#include "mpp_log.h"
|
|
#include "mpp_mem.h"
|
|
#include "mpp_time.h"
|
|
|
|
#include "mpp_rc_defs.h"
|
|
#include "mpp_enc_ref.h"
|
|
#include "mpp_enc_refs.h"
|
|
|
|
#define setup_mpp_enc_ref_cfg(ref) \
|
|
((MppEncRefCfgImpl*)ref)->name = module_name;
|
|
|
|
static const char *module_name = MODULE_TAG;
|
|
|
|
MPP_RET _check_is_mpp_enc_ref_cfg(const char *func, void *ref)
|
|
{
|
|
if (NULL == ref) {
|
|
mpp_err("%s input ref check NULL failed\n", func);
|
|
return MPP_NOK;
|
|
}
|
|
|
|
if (((MppEncRefCfgImpl*)(ref))->name != module_name) {
|
|
mpp_err("%s input ref check %p %p failed\n", func, ((MppEncRefCfgImpl*)(ref))->name);
|
|
return MPP_NOK;
|
|
}
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_init(MppEncRefCfg *ref)
|
|
{
|
|
if (NULL == ref) {
|
|
mpp_err_f("invalid NULL input ref_cfg\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
MppEncRefCfgImpl *p = mpp_calloc(MppEncRefCfgImpl, 1);
|
|
*ref = p;
|
|
if (NULL == p) {
|
|
mpp_err_f("malloc failed\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
mpp_env_get_u32("enc_ref_cfg_debug", &p->debug, 0);
|
|
|
|
setup_mpp_enc_ref_cfg(p);
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_deinit(MppEncRefCfg *ref)
|
|
{
|
|
if (!ref || check_is_mpp_enc_ref_cfg(*ref)) {
|
|
mpp_err_f("input %p check failed\n", ref);
|
|
return MPP_ERR_VALUE;
|
|
}
|
|
|
|
MppEncRefCfgImpl *p = (MppEncRefCfgImpl *)(*ref);
|
|
MPP_FREE(p->lt_cfg);
|
|
MPP_FREE(p->st_cfg);
|
|
MPP_FREE(p);
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_reset(MppEncRefCfg ref)
|
|
{
|
|
if (check_is_mpp_enc_ref_cfg(ref))
|
|
return MPP_ERR_VALUE;
|
|
|
|
MppEncRefCfgImpl *p = (MppEncRefCfgImpl *)ref;
|
|
MPP_FREE(p->lt_cfg);
|
|
MPP_FREE(p->st_cfg);
|
|
memset(p, 0, sizeof(*p));
|
|
setup_mpp_enc_ref_cfg(p);
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_set_cfg_cnt(MppEncRefCfg ref, RK_S32 lt_cnt, RK_S32 st_cnt)
|
|
{
|
|
if (check_is_mpp_enc_ref_cfg(ref))
|
|
return MPP_ERR_NULL_PTR;
|
|
|
|
MppEncRefCfgImpl *p = (MppEncRefCfgImpl *)ref;
|
|
MppEncRefLtFrmCfg *lt_cfg = p->lt_cfg;
|
|
MppEncRefStFrmCfg *st_cfg = p->st_cfg;;
|
|
|
|
if (lt_cfg || st_cfg) {
|
|
mpp_err_f("do call reset before setup new cnout\n");
|
|
MPP_FREE(lt_cfg);
|
|
MPP_FREE(st_cfg);
|
|
}
|
|
|
|
if (lt_cnt) {
|
|
lt_cfg = mpp_calloc(MppEncRefLtFrmCfg, lt_cnt);
|
|
if (NULL == lt_cfg)
|
|
mpp_log_f("failed to create %d lt ref cfg\n", lt_cnt);
|
|
}
|
|
|
|
if (st_cnt) {
|
|
st_cfg = mpp_calloc(MppEncRefStFrmCfg, st_cnt);
|
|
if (NULL == st_cfg)
|
|
mpp_log_f("failed to create %d st ref cfg\n", lt_cnt);
|
|
}
|
|
|
|
p->max_lt_cfg = lt_cnt;
|
|
p->max_st_cfg = st_cnt;
|
|
p->lt_cfg_cnt = 0;
|
|
p->st_cfg_cnt = 0;
|
|
p->lt_cfg = lt_cfg;
|
|
p->st_cfg = st_cfg;
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_add_lt_cfg(MppEncRefCfg ref, RK_S32 cnt, MppEncRefLtFrmCfg *frm)
|
|
{
|
|
if (check_is_mpp_enc_ref_cfg(ref))
|
|
return MPP_ERR_VALUE;
|
|
|
|
MppEncRefCfgImpl *p = (MppEncRefCfgImpl *)ref;
|
|
|
|
if (p->debug)
|
|
mpp_log("ref %p add lt %d cfg idx %d tid %d gap %d delay %d ref mode %x\n",
|
|
ref, p->lt_cfg_cnt, frm->lt_idx, frm->temporal_id,
|
|
frm->lt_gap, frm->lt_delay, frm->ref_mode);
|
|
|
|
memcpy(&p->lt_cfg[p->lt_cfg_cnt], frm, sizeof(*frm) * cnt);
|
|
p->lt_cfg_cnt += cnt;
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_add_st_cfg(MppEncRefCfg ref, RK_S32 cnt, MppEncRefStFrmCfg *frm)
|
|
{
|
|
if (check_is_mpp_enc_ref_cfg(ref)) {
|
|
mpp_err_f("input %p check failed\n", ref);
|
|
return MPP_ERR_VALUE;
|
|
}
|
|
|
|
MppEncRefCfgImpl *p = (MppEncRefCfgImpl *)ref;
|
|
|
|
if (p->debug)
|
|
mpp_log("ref %p add lt %d cfg non %d tid %d gap repeat %d ref mode %x arg %d\n",
|
|
ref, p->st_cfg_cnt, frm->is_non_ref, frm->temporal_id,
|
|
frm->repeat, frm->ref_mode, frm->ref_arg);
|
|
|
|
memcpy(&p->st_cfg[p->st_cfg_cnt], frm, sizeof(*frm) * cnt);
|
|
p->st_cfg_cnt += cnt;
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_check(MppEncRefCfg ref)
|
|
{
|
|
if (check_is_mpp_enc_ref_cfg(ref))
|
|
return MPP_ERR_VALUE;
|
|
|
|
MppEncRefCfgImpl *p = (MppEncRefCfgImpl *)ref;
|
|
RK_S32 lt_cfg_cnt = p->lt_cfg_cnt;
|
|
RK_S32 st_cfg_cnt = p->st_cfg_cnt;
|
|
RK_S32 max_lt_ref_cnt = 0;
|
|
RK_S32 max_lt_ref_idx = 0;
|
|
RK_S32 lt_idx_used_mask = 0;
|
|
RK_S32 lt_dryrun_length = 0;
|
|
RK_S32 max_st_ref_cnt = 0;
|
|
RK_S32 max_st_tid = 0;
|
|
RK_S32 st_tid_used_mask = 0;
|
|
RK_S32 st_dryrun_length = 0;
|
|
RK_S32 ready = 1;
|
|
|
|
/* parse and check gop config for encoder */
|
|
if (lt_cfg_cnt) {
|
|
RK_S32 pos = 0;
|
|
MppEncRefLtFrmCfg *cfg = p->lt_cfg;
|
|
|
|
for (pos = 0; pos < lt_cfg_cnt; pos++, cfg++) {
|
|
MppEncRefMode ref_mode = cfg->ref_mode;
|
|
RK_S32 temporal_id = cfg->temporal_id;
|
|
RK_S32 lt_idx = cfg->lt_idx;
|
|
RK_U32 lt_idx_mask = 1 << lt_idx;
|
|
|
|
/* check lt idx */
|
|
if (lt_idx >= MPP_ENC_MAX_LT_REF_NUM) {
|
|
mpp_err_f("ref cfg %p lt cfg %d with invalid lt_idx %d larger than MPP_ENC_MAX_LT_REF_NUM\n",
|
|
ref, pos, lt_idx);
|
|
ready = 0;
|
|
}
|
|
|
|
if (lt_idx_used_mask & lt_idx_mask) {
|
|
mpp_err_f("ref cfg %p lt cfg %d with redefined lt_idx %d config\n",
|
|
ref, pos, lt_idx);
|
|
ready = 0;
|
|
}
|
|
|
|
if (!(lt_idx_used_mask & lt_idx_mask)) {
|
|
lt_idx_used_mask |= lt_idx_mask;
|
|
max_lt_ref_cnt++;
|
|
}
|
|
|
|
if (lt_idx > max_lt_ref_idx)
|
|
max_lt_ref_idx = lt_idx;
|
|
|
|
/* check temporal id */
|
|
if (temporal_id != 0) {
|
|
mpp_err_f("ref cfg %p lt cfg %d with invalid temporal_id %d is non-zero\n",
|
|
ref, pos, temporal_id);
|
|
ready = 0;
|
|
}
|
|
|
|
/* check gop mode */
|
|
if (!REF_MODE_IS_GLOBAL(ref_mode) && !REF_MODE_IS_LT_MODE(ref_mode)) {
|
|
mpp_err_f("ref cfg %p lt cfg %d with invalid ref mode %x\n",
|
|
ref, pos, ref_mode);
|
|
ready = 0;
|
|
}
|
|
|
|
/* if check failed just quit */
|
|
if (!ready)
|
|
break;
|
|
|
|
if (cfg->lt_gap && (cfg->lt_gap + cfg->lt_delay > lt_dryrun_length))
|
|
lt_dryrun_length = cfg->lt_gap + cfg->lt_delay;
|
|
}
|
|
}
|
|
|
|
/* check st-ref config */
|
|
if (ready && st_cfg_cnt) {
|
|
RK_S32 pos = 0;
|
|
MppEncRefStFrmCfg *cfg = p->st_cfg;
|
|
|
|
for (pos = 0; pos < st_cfg_cnt; pos++, cfg++) {
|
|
MppEncRefMode ref_mode = cfg->ref_mode;
|
|
RK_S32 temporal_id = cfg->temporal_id;
|
|
RK_U32 tid_mask = 1 << temporal_id;
|
|
|
|
/* check temporal_id */
|
|
if (temporal_id > MPP_ENC_MAX_TEMPORAL_LAYER_NUM - 1) {
|
|
mpp_err_f("ref cfg %p st cfg %d with invalid temporal_id %d larger than MPP_ENC_MAX_TEMPORAL_LAYER_NUM\n",
|
|
ref, pos, temporal_id);
|
|
ready = 0;
|
|
}
|
|
|
|
/* check gop mode */
|
|
if (!REF_MODE_IS_GLOBAL(ref_mode) && !REF_MODE_IS_ST_MODE(ref_mode)) {
|
|
mpp_err_f("ref cfg %p st cfg %d with invalid ref mode %x\n",
|
|
ref, pos, ref_mode);
|
|
ready = 0;
|
|
}
|
|
|
|
/* constrain on head and tail frame */
|
|
if (pos == 0 || (pos == lt_cfg_cnt - 1)) {
|
|
if (cfg->is_non_ref) {
|
|
mpp_err_f("ref cfg %p st cfg %d with invalid non-ref frame on head/tail frame\n",
|
|
ref, pos);
|
|
ready = 0;
|
|
}
|
|
|
|
if (temporal_id > 0) {
|
|
mpp_err_f("ref cfg %p st cfg %d with invalid non-zero temporal id %d on head/tail frame\n",
|
|
ref, pos, temporal_id);
|
|
ready = 0;
|
|
}
|
|
}
|
|
|
|
if (!ready)
|
|
break;
|
|
|
|
if (!cfg->is_non_ref && !(st_tid_used_mask & tid_mask)) {
|
|
max_st_ref_cnt++;
|
|
st_tid_used_mask |= tid_mask;
|
|
}
|
|
|
|
if (temporal_id > max_st_tid)
|
|
max_st_tid = temporal_id;
|
|
|
|
st_dryrun_length++;
|
|
st_dryrun_length += cfg->repeat;
|
|
}
|
|
}
|
|
|
|
if (ready) {
|
|
MppEncCpbInfo *cpb_info = &p->cpb_info;
|
|
MppEncRefs refs = NULL;
|
|
MPP_RET ret = MPP_OK;
|
|
|
|
cpb_info->dpb_size = 0;
|
|
cpb_info->max_lt_cnt = max_lt_ref_cnt;
|
|
cpb_info->max_st_cnt = max_st_ref_cnt;
|
|
cpb_info->max_lt_idx = max_lt_ref_idx;
|
|
cpb_info->max_st_tid = max_st_tid;
|
|
cpb_info->lt_gop = lt_dryrun_length;
|
|
cpb_info->st_gop = st_dryrun_length - 1;
|
|
|
|
ret = mpp_enc_refs_init(&refs, NULL);
|
|
ready = (ret) ? 0 : (ready);
|
|
ret = mpp_enc_refs_set_cfg(refs, ref);
|
|
ready = (ret) ? 0 : (ready);
|
|
ret = mpp_enc_refs_dryrun(refs);
|
|
ready = (ret) ? 0 : (ready);
|
|
|
|
/* update dpb size */
|
|
ret = mpp_enc_refs_get_cpb_info(refs, cpb_info);
|
|
ready = (ret) ? 0 : (ready);
|
|
|
|
ret = mpp_enc_refs_deinit(&refs);
|
|
ready = (ret) ? 0 : (ready);
|
|
} else {
|
|
mpp_err_f("check ref cfg %p failed\n", ref);
|
|
}
|
|
p->ready = ready;
|
|
|
|
return ready ? MPP_OK : MPP_NOK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_show(MppEncRefCfg ref)
|
|
{
|
|
if (check_is_mpp_enc_ref_cfg(ref))
|
|
return MPP_ERR_VALUE;
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_enc_ref_cfg_copy(MppEncRefCfg dst, MppEncRefCfg src)
|
|
{
|
|
if (check_is_mpp_enc_ref_cfg(dst) || check_is_mpp_enc_ref_cfg(src))
|
|
return MPP_ERR_VALUE;
|
|
|
|
MPP_RET ret = MPP_OK;
|
|
MppEncRefCfgImpl *d = (MppEncRefCfgImpl *)dst;
|
|
MppEncRefCfgImpl *s = (MppEncRefCfgImpl *)src;
|
|
RK_S32 max_lt_cfg = s->max_lt_cfg;
|
|
RK_S32 max_st_cfg = s->max_st_cfg;
|
|
|
|
/* step 1 - free cfg in dst */
|
|
MPP_FREE(d->lt_cfg);
|
|
MPP_FREE(d->st_cfg);
|
|
|
|
/* step 2 - copy contex from src */
|
|
memcpy(d, s, sizeof(*d));
|
|
|
|
/* step 3 - create new storage and copy lt/st cfg */
|
|
if (max_lt_cfg) {
|
|
MppEncRefLtFrmCfg *lt_cfg = mpp_calloc(MppEncRefLtFrmCfg, max_lt_cfg);
|
|
|
|
if (NULL == lt_cfg) {
|
|
mpp_log_f("failed to create %d lt ref cfg\n", max_lt_cfg);
|
|
ret = MPP_NOK;
|
|
} else
|
|
memcpy(lt_cfg, s->lt_cfg, sizeof(lt_cfg[0]) * s->max_lt_cfg);
|
|
|
|
d->lt_cfg = lt_cfg;
|
|
}
|
|
|
|
if (max_st_cfg) {
|
|
MppEncRefStFrmCfg *st_cfg = mpp_calloc(MppEncRefStFrmCfg, max_st_cfg);
|
|
|
|
if (NULL == st_cfg) {
|
|
mpp_log_f("failed to create %d st ref cfg\n", max_st_cfg);
|
|
ret = MPP_NOK;
|
|
} else
|
|
memcpy(st_cfg, s->st_cfg, sizeof(st_cfg[0]) * s->max_st_cfg);
|
|
|
|
d->st_cfg = st_cfg;
|
|
}
|
|
|
|
if (ret)
|
|
mpp_enc_ref_cfg_reset(dst);
|
|
|
|
return ret;
|
|
}
|
|
|
|
MppEncCpbInfo *mpp_enc_ref_cfg_get_cpb_info(MppEncRefCfg ref)
|
|
{
|
|
if (check_is_mpp_enc_ref_cfg(ref))
|
|
return NULL;
|
|
|
|
MppEncRefCfgImpl *p = (MppEncRefCfgImpl *)ref;
|
|
return &p->cpb_info;
|
|
}
|
|
|
|
static MppEncRefStFrmCfg default_st_ref_cfg = {
|
|
.is_non_ref = 0,
|
|
.temporal_id = 0,
|
|
.ref_mode = REF_TO_PREV_REF_FRM,
|
|
.ref_arg = 0,
|
|
.repeat = 0,
|
|
};
|
|
|
|
static const MppEncRefCfgImpl default_ref_cfg = {
|
|
.name = module_name,
|
|
.ready = 1,
|
|
.debug = 0,
|
|
.max_lt_cfg = 0,
|
|
.max_st_cfg = 1,
|
|
.lt_cfg_cnt = 0,
|
|
.st_cfg_cnt = 1,
|
|
.lt_cfg = NULL,
|
|
.st_cfg = &default_st_ref_cfg,
|
|
.cpb_info = { 1, 0, 1, 0, 0, 0, 0 },
|
|
};
|
|
|
|
MppEncRefCfg mpp_enc_ref_default(void)
|
|
{
|
|
return (MppEncRefCfg)&default_ref_cfg;
|
|
}
|