/*
|
* 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_refs"
|
|
#include <string.h>
|
|
#include "mpp_env.h"
|
#include "mpp_mem.h"
|
#include "mpp_debug.h"
|
#include "mpp_common.h"
|
|
#include "mpp_enc_ref.h"
|
#include "mpp_enc_refs.h"
|
|
#define MAX_CPB_ST_FRM 16
|
#define MAX_CPB_LT_FRM 16
|
#define MAX_CPB_TID_FRM 16
|
#define MAX_CPB_LT_IDX 16
|
#define MAX_CPB_FRM ((MAX_CPB_ST_FRM) + (MAX_CPB_LT_FRM))
|
|
#define MPP_ENC_REFS_DBG_FUNC (0x00000001)
|
#define MPP_ENC_REFS_DBG_FLOW (0x00000002)
|
#define MPP_ENC_REFS_DBG_FRM (0x00000004)
|
#define MPP_ENC_REFS_DBG_SIZE (0x00000008)
|
|
#define enc_refs_dbg_func(fmt, ...) _mpp_dbg_f(enc_refs_debug, MPP_ENC_REFS_DBG_FUNC, fmt, ## __VA_ARGS__)
|
#define enc_refs_dbg_flow(fmt, ...) _mpp_dbg_f(enc_refs_debug, MPP_ENC_REFS_DBG_FLOW, fmt, ## __VA_ARGS__)
|
#define enc_refs_dbg_frm(fmt, ...) _mpp_dbg(enc_refs_debug, MPP_ENC_REFS_DBG_FRM, fmt, ## __VA_ARGS__)
|
#define enc_refs_dbg_size(fmt, ...) _mpp_dbg(enc_refs_debug, MPP_ENC_REFS_DBG_SIZE, fmt, ## __VA_ARGS__)
|
|
#define ENC_REFS_REF_CFG_CHANGED (0x00000001)
|
#define ENC_REFS_USR_CFG_CHANGED (0x00000002)
|
#define ENC_REFS_IGOP_CHANGED (0x00000004)
|
|
typedef struct RefsCnt_t {
|
RK_S32 delay;
|
RK_S32 delay_cnt;
|
RK_S32 len;
|
RK_S32 cnt;
|
RK_S32 idx;
|
|
RK_S32 lt_idx;
|
RK_S32 tid;
|
MppEncRefMode ref_mode;
|
RK_S32 ref_arg;
|
} RefsCnt;
|
|
typedef struct EncVirtualCpb_t {
|
MppEncCpbInfo info;
|
|
/*
|
* max 32 reference slot for frame searching
|
* (max 16 lt + max 16 st)
|
* st_slot 0 ~ 15
|
* lt_slot 16 ~ 31
|
*/
|
EncFrmStatus cpb_refs[MAX_CPB_FRM];
|
|
/* max 32 reference mode */
|
EncFrmStatus mode_refs[MAX_CPB_FRM];
|
|
/*
|
* reference mode storage with args
|
* st + tid - max 16
|
* lt + idx - max 16
|
*/
|
EncFrmStatus st_tid_refs[MAX_CPB_TID_FRM];
|
EncFrmStatus lt_idx_refs[MAX_CPB_LT_IDX];
|
|
/* long-term counter */
|
/* lt ref will have multiple counters */
|
RefsCnt lt_cnter[MAX_CPB_LT_IDX];
|
|
/* max two list and each list as two frames */
|
EncFrmStatus list0[2];
|
EncFrmStatus list1[2];
|
/* frame kept in cpb */
|
EncFrmStatus cpb_st[2];
|
|
/* runtime record */
|
RK_S32 frm_idx; /* overall frame index */
|
RK_S32 seq_idx; /* sequence index in one gop */
|
RK_S32 seq_cnt;
|
RK_S32 st_cfg_pos;
|
RK_S32 st_cfg_repeat_pos;
|
} EncVirtualCpb;
|
|
typedef struct MppEncRefsImpl_t {
|
RK_U32 changed;
|
MppEncRefCfgImpl *ref_cfg;
|
MppEncRefFrmUsrCfg usr_cfg;
|
RK_S32 igop;
|
|
RK_S32 hdr_need_update;
|
|
EncVirtualCpb cpb;
|
EncVirtualCpb cpb_stash;
|
} MppEncRefsImpl;
|
|
RK_U32 enc_refs_debug = 0;
|
|
void _dump_frm(EncFrmStatus *frm, const char *func, RK_S32 line)
|
{
|
if (!frm->valid)
|
return ;
|
|
if (frm->is_non_ref) {
|
mpp_log("%s:%d valid %d frm %d %s tid %d non-ref -> [%x:%d]\n",
|
func, line, frm->valid, frm->seq_idx,
|
frm->is_intra ? "intra" : "inter",
|
frm->temporal_id, frm->ref_mode, frm->ref_arg);
|
} else if (frm->is_lt_ref) {
|
mpp_log("%s:%d valid %d frm %d %s tid %d lt-ref -> [%x:%d] lt_idx %d\n",
|
func, line, frm->valid, frm->seq_idx,
|
frm->is_intra ? "intra" : "inter",
|
frm->temporal_id, frm->ref_mode, frm->ref_arg,
|
frm->lt_idx);
|
} else {
|
mpp_log("%s:%d valid %d frm %d %s tid %d st-ref -> [%x:%d]\n",
|
func, line, frm->valid, frm->seq_idx,
|
frm->is_intra ? "intra" : "inter",
|
frm->temporal_id, frm->ref_mode, frm->ref_arg);
|
}
|
}
|
|
#define dump_cpb(cpb) _dump_cpb(cpb, __FUNCTION__, __LINE__)
|
|
void _dump_cpb(EncVirtualCpb *cpb, const char *func, RK_S32 line)
|
{
|
MppEncCpbInfo *info = &cpb->info;
|
RK_S32 i;
|
|
mpp_log("%s:%d cpb %p status:\n", func, line, cpb);
|
mpp_log("cpb info: dpb_size %d max_lt/st cnt [%d:%d] \n",
|
info->dpb_size, info->max_lt_cnt, info->max_st_cnt);
|
mpp_log("cpb info: max_lt_idx %d max_st_tid %d\n",
|
info->max_lt_idx, info->max_st_tid);
|
mpp_log("cpb info: lt_gop %d st_gop %d\n",
|
info->lt_gop, info->st_gop);
|
|
mpp_log("cpb cpb_refs:\n");
|
for (i = 0; i < MAX_CPB_FRM; i++)
|
dump_frm(&cpb->cpb_refs[i]);
|
|
mpp_log("cpb mode_refs:\n");
|
for (i = 0; i < MAX_CPB_FRM; i++)
|
dump_frm(&cpb->mode_refs[i]);
|
|
mpp_log("cpb st_tid_refs:\n");
|
for (i = 0; i < MAX_CPB_TID_FRM; i++)
|
dump_frm(&cpb->st_tid_refs[i]);
|
|
mpp_log("cpb lt_idx_refs:\n");
|
for (i = 0; i < MAX_CPB_LT_IDX; i++)
|
dump_frm(&cpb->lt_idx_refs[i]);
|
|
mpp_log("cpb runtime: frm_idx %d seq_idx %d seq_cnt %d st_cfg [%d:%d]\n",
|
cpb->frm_idx, cpb->seq_idx, cpb->seq_cnt,
|
cpb->st_cfg_pos, cpb->st_cfg_repeat_pos);
|
}
|
|
MPP_RET mpp_enc_refs_init(MppEncRefs *refs)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = mpp_calloc(MppEncRefsImpl, 1);
|
*refs = p;
|
if (NULL == p) {
|
mpp_err_f("create refs_impl failed\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
|
mpp_env_get_u32("enc_refs_debug", &enc_refs_debug, 0);
|
|
enc_refs_dbg_func("leave %p\n", p);
|
return MPP_OK;
|
}
|
|
MPP_RET mpp_enc_refs_deinit(MppEncRefs *refs)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)(*refs);
|
MPP_FREE(p);
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
|
MPP_RET mpp_enc_refs_set_cfg(MppEncRefs refs, MppEncRefCfg ref_cfg)
|
{
|
if (NULL == refs || (ref_cfg && check_is_mpp_enc_ref_cfg(ref_cfg))) {
|
mpp_err_f("invalid input refs %p ref_cfg %p\n", refs, ref_cfg);
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p cfg %p\n", refs, ref_cfg);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
EncVirtualCpb *cpb = &p->cpb;
|
MppEncRefCfgImpl *cfg = NULL;
|
|
if (NULL == ref_cfg)
|
ref_cfg = mpp_enc_ref_default();
|
|
cfg = (MppEncRefCfgImpl *)ref_cfg;
|
|
p->ref_cfg = cfg;
|
p->changed |= ENC_REFS_REF_CFG_CHANGED;
|
p->hdr_need_update = 0;
|
|
/* clear cpb on setup new cfg */
|
if (!cfg->keep_cpb) {
|
memset(cpb, 0, sizeof(*cpb));
|
p->hdr_need_update = 1;
|
}
|
|
if (cfg->lt_cfg_cnt) {
|
RK_S32 i;
|
|
mpp_assert(cfg->lt_cfg_cnt < MAX_CPB_LT_FRM);
|
|
for (i = 0; i < cfg->lt_cfg_cnt; i++) {
|
RefsCnt *lt_cnt = &cpb->lt_cnter[i];
|
MppEncRefLtFrmCfg *lt_cfg = &cfg->lt_cfg[i];
|
|
lt_cnt->delay = lt_cfg->lt_delay;
|
lt_cnt->delay_cnt = lt_cfg->lt_delay;
|
lt_cnt->len = lt_cfg->lt_gap;
|
lt_cnt->lt_idx = lt_cfg->lt_idx;
|
lt_cnt->tid = lt_cfg->temporal_id;
|
lt_cnt->ref_mode = lt_cfg->ref_mode;
|
lt_cnt->ref_arg = lt_cfg->ref_arg;
|
}
|
}
|
|
MppEncCpbInfo *info = &cpb->info;
|
|
if (info->dpb_size && info->dpb_size < cfg->cpb_info.dpb_size)
|
p->hdr_need_update = 1;
|
|
memcpy(info, &cfg->cpb_info, sizeof(cfg->cpb_info));
|
|
enc_refs_dbg_flow("ref_cfg cpb size: lt %d st %d max lt_idx %d tid %d\n",
|
info->max_lt_cnt, info->max_st_cnt,
|
info->max_lt_idx, info->max_st_tid);
|
|
enc_refs_dbg_func("leave %p cfg %p\n", refs, ref_cfg);
|
return MPP_OK;
|
}
|
|
static void cleanup_cpb_refs(EncVirtualCpb *cpb)
|
{
|
RK_U32 i;
|
|
memset(cpb->cpb_refs, 0, sizeof(cpb->cpb_refs));
|
memset(cpb->mode_refs, 0, sizeof(cpb->mode_refs));
|
memset(cpb->st_tid_refs, 0, sizeof(cpb->st_tid_refs));
|
memset(cpb->lt_idx_refs, 0, sizeof(cpb->lt_idx_refs));
|
memset(cpb->list0, 0, sizeof(cpb->list0));
|
memset(cpb->list1, 0, sizeof(cpb->list1));
|
memset(cpb->cpb_st, 0, sizeof(cpb->cpb_st));
|
|
cpb->seq_idx = 0;
|
cpb->seq_cnt++;
|
cpb->st_cfg_pos = 0;
|
cpb->st_cfg_repeat_pos = 0;
|
|
for (i = 0; i < MPP_ARRAY_ELEMS(cpb->lt_cnter); i++) {
|
RefsCnt *lt_cnt = &cpb->lt_cnter[i];
|
|
lt_cnt->delay_cnt = lt_cnt->delay;
|
lt_cnt->cnt = 0;
|
lt_cnt->idx = 0;
|
}
|
}
|
|
static void set_st_cfg_to_frm(EncFrmStatus *frm, RK_S32 seq_idx,
|
MppEncRefStFrmCfg *st_cfg)
|
{
|
memset(frm, 0, sizeof(*frm));
|
|
frm->seq_idx = seq_idx;
|
frm->valid = 1;
|
frm->is_idr = (seq_idx == 0);
|
frm->is_intra = frm->is_idr;
|
frm->is_non_ref = st_cfg->is_non_ref;
|
frm->is_lt_ref = 0;
|
frm->temporal_id = st_cfg->temporal_id;
|
frm->ref_mode = st_cfg->ref_mode;
|
frm->ref_arg = st_cfg->ref_arg;
|
|
if (enc_refs_debug & MPP_ENC_REFS_DBG_FRM)
|
dump_frm(frm);
|
}
|
|
static void set_lt_cfg_to_frm(EncFrmStatus *frm, RefsCnt *lt_cfg)
|
{
|
frm->is_non_ref = 0;
|
frm->is_lt_ref = 1;
|
frm->temporal_id = lt_cfg->tid;
|
frm->lt_idx = lt_cfg->lt_idx;
|
|
if (lt_cfg->ref_mode != REF_TO_ST_REF_SETUP) {
|
frm->ref_mode = lt_cfg->ref_mode;
|
frm->ref_arg = lt_cfg->ref_arg;
|
}
|
|
if (enc_refs_debug & MPP_ENC_REFS_DBG_FRM)
|
dump_frm(frm);
|
}
|
|
static EncFrmStatus *get_ref_from_cpb(EncVirtualCpb *cpb, EncFrmStatus *frm)
|
{
|
MppEncRefMode ref_mode = frm->ref_mode;
|
RK_S32 ref_arg = frm->ref_arg;
|
|
if (frm->is_intra)
|
return NULL;
|
|
EncFrmStatus *ref = NULL;
|
|
/* step 3.1 find seq_idx by mode and arg */
|
switch (ref_mode) {
|
case REF_TO_PREV_REF_FRM :
|
case REF_TO_PREV_ST_REF :
|
case REF_TO_PREV_LT_REF :
|
case REF_TO_PREV_INTRA : {
|
ref = &cpb->mode_refs[ref_mode];
|
} break;
|
case REF_TO_TEMPORAL_LAYER : {
|
ref = &cpb->st_tid_refs[ref_arg];
|
} break;
|
case REF_TO_LT_REF_IDX : {
|
ref = &cpb->lt_idx_refs[ref_arg];
|
} break;
|
case REF_TO_ST_PREV_N_REF : {
|
ref = &cpb->cpb_refs[ref_arg];
|
} break;
|
case REF_TO_ST_REF_SETUP :
|
default : {
|
mpp_err_f("frm %d not supported ref mode 0x%x\n", frm->seq_idx, ref_mode);
|
} break;
|
}
|
|
if (ref) {
|
if (ref->valid)
|
enc_refs_dbg_flow("frm %d ref mode %d arg %d -> seq %d %s idx %d\n",
|
frm->seq_idx, ref_mode, ref_arg, ref->seq_idx,
|
ref->is_lt_ref ? "lt" : "st",
|
ref->is_lt_ref ? ref->lt_idx : 0);
|
else
|
mpp_err_f("frm %d found mode %d arg %d -> ref %d but it is invalid\n",
|
frm->seq_idx, ref_mode, ref_arg, ref->seq_idx);
|
} else {
|
ref = NULL;
|
}
|
|
return ref;
|
}
|
|
static RK_S32 check_ref_cpb_pos(EncVirtualCpb *cpb, EncFrmStatus *frm)
|
{
|
RK_S32 seq_idx = frm->seq_idx;
|
RK_S32 found = 0;
|
RK_S32 pos = -1;
|
|
if (!frm->valid || frm->is_non_ref) {
|
enc_refs_dbg_flow("frm %d is not valid ref frm\n", seq_idx);
|
return pos;
|
}
|
|
if (frm->is_lt_ref) {
|
/* find same lt_idx */
|
for (pos = 0; pos < MAX_CPB_LT_FRM; pos++) {
|
RK_S32 cpb_idx = pos + MAX_CPB_ST_FRM;
|
EncFrmStatus *cpb_ref = &cpb->cpb_refs[cpb_idx];
|
|
if (cpb_ref->valid && cpb_ref->lt_idx == frm->lt_idx) {
|
pos = cpb_idx;
|
found = 1;
|
break;
|
}
|
}
|
} else {
|
/* search seq_idx in cpb to check the st cpb size */
|
for (pos = 0; pos < MAX_CPB_ST_FRM; pos++) {
|
EncFrmStatus *cpb_ref = &cpb->cpb_refs[pos];
|
|
enc_refs_dbg_flow("matching ref %d at pos %d %d\n",
|
seq_idx, pos, cpb_ref->seq_idx);
|
|
if (cpb_ref->valid && cpb_ref->seq_idx == seq_idx) {
|
enc_refs_dbg_flow("found ref %d at pos %d\n", seq_idx, pos);
|
found = 1;
|
break;
|
}
|
}
|
}
|
|
if (!found) {
|
mpp_err_f("frm %d can NOT be found in st refs!!\n", seq_idx);
|
pos = -1;
|
dump_cpb(cpb);
|
}
|
|
return pos;
|
}
|
|
static void save_cpb_status(EncVirtualCpb *cpb, EncFrmStatus *refs)
|
{
|
EncFrmStatus *ref = &cpb->cpb_refs[MAX_CPB_ST_FRM];
|
MppEncCpbInfo *info = &cpb->info;
|
RK_S32 dpb_size = info->dpb_size;
|
RK_S32 lt_ref_cnt = 0;
|
RK_S32 st_ref_cnt = 0;
|
RK_S32 ref_cnt = 0;
|
RK_S32 i;
|
|
/* save lt ref */
|
for (i = 0; i < info->max_lt_cnt; i++, ref++) {
|
if (!ref->valid || ref->is_non_ref || !ref->is_lt_ref)
|
continue;
|
|
mpp_assert(!ref->is_non_ref);
|
mpp_assert(ref->is_lt_ref);
|
mpp_assert(ref->lt_idx >= 0);
|
|
enc_refs_dbg_flow("save lt ref %d to slot %d\n", ref->seq_idx, ref_cnt);
|
refs[ref_cnt++].val = ref->val;
|
lt_ref_cnt++;
|
}
|
|
ref = &cpb->cpb_refs[0];
|
/* save st ref */
|
if (ref_cnt < dpb_size) {
|
RK_S32 max_st_cnt = info->max_st_cnt;
|
|
if (max_st_cnt < dpb_size - ref_cnt)
|
max_st_cnt = dpb_size - ref_cnt;
|
|
for (i = 0; i < max_st_cnt; i++, ref++) {
|
if (!ref->valid || ref->is_non_ref || ref->is_lt_ref)
|
continue;
|
|
mpp_assert(!ref->is_non_ref);
|
mpp_assert(!ref->is_lt_ref);
|
mpp_assert(ref->temporal_id >= 0);
|
|
enc_refs_dbg_flow("save st ref %d to slot %d\n", ref->seq_idx, ref_cnt);
|
refs[ref_cnt++].val = ref->val;
|
st_ref_cnt++;
|
}
|
}
|
|
enc_refs_dbg_flow("save ref total %d lt %d st %d\n", ref_cnt, lt_ref_cnt, st_ref_cnt);
|
if (enc_refs_debug & MPP_ENC_REFS_DBG_FLOW)
|
for (i = 0; i < ref_cnt; i++)
|
dump_frm(&refs[i]);
|
}
|
|
static void store_ref_to_cpb(EncVirtualCpb *cpb, EncFrmStatus *frm)
|
{
|
RK_S32 seq_idx = frm->seq_idx;
|
RK_S32 lt_idx = frm->lt_idx;
|
RK_S32 tid = frm->temporal_id;
|
RK_S32 i;
|
|
mpp_assert(frm->valid);
|
mpp_assert(lt_idx < MAX_CPB_LT_IDX);
|
mpp_assert(tid < MAX_CPB_LT_FRM);
|
|
/* non-ref do not save to cpb */
|
if (frm->is_non_ref)
|
return ;
|
|
if (frm->is_intra)
|
cpb->mode_refs[REF_TO_PREV_INTRA].val = frm->val;
|
|
if (frm->is_lt_ref) {
|
cpb->lt_idx_refs[lt_idx].val = frm->val;
|
cpb->st_tid_refs[tid].val = frm->val;
|
cpb->mode_refs[REF_TO_PREV_REF_FRM].val = frm->val;
|
cpb->mode_refs[REF_TO_PREV_LT_REF].val = frm->val;
|
|
RK_S32 found = 0;
|
EncFrmStatus *cpb_ref = NULL;
|
|
/* find same lt_idx and replace */
|
for (i = 0; i < MAX_CPB_LT_FRM; i++) {
|
RK_S32 cpb_idx = i + MAX_CPB_ST_FRM;
|
cpb_ref = &cpb->cpb_refs[cpb_idx];
|
|
if (!cpb_ref->valid) {
|
found = 1;
|
break;
|
} else {
|
if (cpb_ref->lt_idx == lt_idx) {
|
found = 2;
|
break;
|
}
|
}
|
}
|
|
if (found) {
|
cpb_ref->val = frm->val;
|
enc_refs_dbg_flow("frm %d with lt idx %d %s to pos %d\n",
|
seq_idx, lt_idx, (found == 1) ? "add" : "replace", i);
|
} else {
|
mpp_err_f("frm %d with lt idx %d found no place to add or relace\n",
|
seq_idx, lt_idx);
|
}
|
} else {
|
/* do normal st sliding window */
|
cpb->st_tid_refs[tid].val = frm->val;
|
cpb->mode_refs[REF_TO_PREV_REF_FRM].val = frm->val;
|
cpb->mode_refs[REF_TO_PREV_ST_REF].val = frm->val;
|
|
for (i = MAX_CPB_ST_FRM - 1; i > 0; i--)
|
cpb->cpb_refs[i].val = cpb->cpb_refs[i - 1].val;
|
|
cpb->cpb_refs[0].val = frm->val;
|
|
// TODO: Add prev intra valid check?
|
}
|
|
enc_refs_dbg_flow("dumping cpb refs status start\n");
|
if (enc_refs_debug & MPP_ENC_REFS_DBG_FLOW)
|
for (i = 0; i < MAX_CPB_FRM; i++)
|
if (cpb->cpb_refs[i].valid)
|
dump_frm(&cpb->cpb_refs[i]);
|
|
enc_refs_dbg_flow("dumping cpb refs status done\n");
|
}
|
|
MPP_RET mpp_enc_refs_dryrun(MppEncRefs refs)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
MppEncRefCfgImpl *cfg = p->ref_cfg;
|
MppEncRefStFrmCfg *st_cfg = cfg->st_cfg;
|
EncVirtualCpb *cpb = &p->cpb;
|
MppEncCpbInfo *info = &cpb->info;
|
RK_S32 lt_cfg_cnt = cfg->lt_cfg_cnt;
|
RK_S32 st_cfg_cnt = cfg->st_cfg_cnt;
|
RK_S32 cpb_st_used_size = 0;
|
RK_S32 seq_idx = 0;
|
RK_S32 st_idx;
|
|
if (cfg->ready)
|
goto DONE;
|
|
cleanup_cpb_refs(cpb);
|
|
enc_refs_dbg_flow("dryrun start: lt_cfg %d st_cfg %d\n",
|
lt_cfg_cnt, st_cfg_cnt);
|
|
for (st_idx = 0; st_idx < st_cfg_cnt; st_idx++, st_cfg++) {
|
EncFrmStatus frm;
|
RK_S32 repeat = (st_cfg->repeat) ? st_cfg->repeat : 1;
|
|
while (repeat-- > 0) {
|
/* step 1. updated by st_cfg */
|
set_st_cfg_to_frm(&frm, seq_idx++, st_cfg);
|
|
/* step 2. updated by lt_cfg */
|
RefsCnt *lt_cfg = &cpb->lt_cnter[0];
|
RK_S32 set_to_lt = 0;
|
RK_S32 i;
|
|
for (i = 0; i < lt_cfg_cnt; i++, lt_cfg++) {
|
if (lt_cfg->delay_cnt) {
|
lt_cfg->delay_cnt--;
|
continue;
|
}
|
|
if (!set_to_lt) {
|
if (!lt_cfg->cnt) {
|
set_lt_cfg_to_frm(&frm, lt_cfg);
|
set_to_lt = 1;
|
}
|
}
|
|
lt_cfg->cnt++;
|
if (lt_cfg->cnt >= lt_cfg->len) {
|
if (lt_cfg->len) {
|
/* when there is loop len loop lt_cfg */
|
lt_cfg->cnt = 0;
|
lt_cfg->idx++;
|
} else {
|
/* else just set lt_cfg once */
|
lt_cfg->cnt = 1;
|
lt_cfg->idx = 1;
|
}
|
}
|
}
|
|
/* step 3. try find ref by the ref_mode and update used cpb size */
|
EncFrmStatus *ref = get_ref_from_cpb(cpb, &frm);
|
|
if (ref) {
|
RK_S32 cpb_pos = check_ref_cpb_pos(cpb, ref);
|
|
if (cpb_pos < MAX_CPB_ST_FRM) {
|
if (cpb_st_used_size < cpb_pos + 1) {
|
cpb_st_used_size = cpb_pos + 1;
|
enc_refs_dbg_flow("cpb_st_used_size update to %d\n", cpb_st_used_size);
|
}
|
}
|
}
|
|
/* step 4. store frame according to status */
|
store_ref_to_cpb(cpb, &frm);
|
}
|
}
|
|
cleanup_cpb_refs(cpb);
|
info->max_st_cnt = cpb_st_used_size ? cpb_st_used_size : 1;
|
|
DONE:
|
info->dpb_size = info->max_lt_cnt + info->max_st_cnt;
|
|
enc_refs_dbg_size("dryrun success: cpb size %d\n", info->dpb_size);
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
|
MPP_RET mpp_enc_refs_set_usr_cfg(MppEncRefs refs, MppEncRefFrmUsrCfg *cfg)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
memcpy(&p->usr_cfg, cfg, sizeof(p->usr_cfg));
|
if (cfg->force_flag)
|
p->changed |= ENC_REFS_USR_CFG_CHANGED;
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
|
MPP_RET mpp_enc_refs_set_rc_igop(MppEncRefs refs, RK_S32 igop)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
|
if (p->igop != igop) {
|
p->igop = igop;
|
p->changed |= ENC_REFS_IGOP_CHANGED;
|
}
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
|
RK_S32 mpp_enc_refs_update_hdr(MppEncRefs refs)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return 0;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
RK_S32 hdr_need_update = p->hdr_need_update;
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return hdr_need_update;
|
}
|
|
MPP_RET mpp_enc_refs_get_cpb_info(MppEncRefs refs, MppEncCpbInfo *info)
|
{
|
if (NULL == refs || NULL == info) {
|
mpp_err_f("invalid input refs %p info %p\n", refs, info);
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
memcpy(info, &p->cpb.info, sizeof(*info));
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
|
static RK_S32 get_cpb_st_cfg_pos(EncVirtualCpb *cpb, MppEncRefCfgImpl *cfg)
|
{
|
RK_S32 st_cfg_pos = cpb->st_cfg_pos;
|
RK_S32 st_cfg_cnt = cfg->st_cfg_cnt;
|
|
/* NOTE: second loop will start from 1 */
|
if (st_cfg_pos >= st_cfg_cnt)
|
st_cfg_pos = (st_cfg_cnt > 1) ? (1) : (0);
|
|
return st_cfg_pos;
|
}
|
|
MPP_RET mpp_enc_refs_get_cpb(MppEncRefs refs, EncCpbStatus *status)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
MppEncRefCfgImpl *cfg = p->ref_cfg;
|
EncVirtualCpb *cpb = &p->cpb;
|
MppEncRefStFrmCfg *st_cfg = NULL;
|
MppEncRefFrmUsrCfg *usr_cfg = &p->usr_cfg;
|
EncFrmStatus *frm = &status->curr;
|
EncFrmStatus *ref = &status->refr;
|
RefsCnt *lt_cfg = cpb->lt_cnter;
|
RK_S32 set_to_lt = 0;
|
RK_S32 cleanup_cpb = 0;
|
RK_S32 prev_frm_is_pass1 = frm->save_pass1;
|
RK_S32 i;
|
|
/* step 1. check igop from cfg_set and force idr for usr_cfg */
|
if (p->changed & ENC_REFS_IGOP_CHANGED)
|
cleanup_cpb = 1;
|
|
if (p->igop && cpb->seq_idx >= p->igop)
|
cleanup_cpb = 1;
|
|
if (usr_cfg->force_flag & ENC_FORCE_IDR) {
|
usr_cfg->force_flag &= (~ENC_FORCE_IDR);
|
cleanup_cpb = 1;
|
}
|
|
if (cleanup_cpb) {
|
/* update seq_idx for igop loop and force idr */
|
cleanup_cpb_refs(cpb);
|
} else if (p->changed & ENC_REFS_REF_CFG_CHANGED) {
|
cpb->st_cfg_pos = 0;
|
cpb->st_cfg_repeat_pos = 0;
|
}
|
|
p->changed = 0;
|
|
cpb->frm_idx++;
|
cpb->st_cfg_pos = get_cpb_st_cfg_pos(cpb, cfg);
|
st_cfg = &cfg->st_cfg[cpb->st_cfg_pos];
|
/* step 2. updated by st_cfg */
|
set_st_cfg_to_frm(frm, cpb->seq_idx++, st_cfg);
|
|
lt_cfg = p->cpb.lt_cnter;
|
|
/* step 3. updated by lt_cfg */
|
for (i = 0; i < cfg->lt_cfg_cnt; i++, lt_cfg++) {
|
if (lt_cfg->delay_cnt) {
|
lt_cfg->delay_cnt--;
|
continue;
|
}
|
|
if (!set_to_lt) {
|
if (!lt_cfg->cnt) {
|
set_lt_cfg_to_frm(frm, lt_cfg);
|
set_to_lt = 1;
|
}
|
}
|
|
lt_cfg->cnt++;
|
if (lt_cfg->cnt >= lt_cfg->len) {
|
if (lt_cfg->len) {
|
/* when there is loop len loop lt_cfg */
|
lt_cfg->cnt = 0;
|
lt_cfg->idx++;
|
} else {
|
/* else just set lt_cfg once */
|
lt_cfg->cnt = 1;
|
lt_cfg->idx = 1;
|
}
|
}
|
}
|
|
/* step 4. process force flags and force ref_mode */
|
if (usr_cfg->force_flag & ENC_FORCE_LT_REF_IDX) {
|
frm->is_non_ref = 0;
|
frm->is_lt_ref = 1;
|
frm->lt_idx = usr_cfg->force_lt_idx;
|
if (frm->is_idr && frm->lt_idx) {
|
frm->lt_idx = 0;
|
mpp_err_f("can not set IDR to ltr with non-zero index\n");
|
}
|
/* lt_ref will be forced to tid 0 */
|
frm->temporal_id = 0;
|
|
/* reset st_cfg to next loop */
|
cpb->st_cfg_repeat_pos = 0;
|
cpb->st_cfg_pos = 0;
|
usr_cfg->force_flag &= ~ENC_FORCE_LT_REF_IDX;
|
}
|
|
if (usr_cfg->force_flag & ENC_FORCE_REF_MODE) {
|
frm->ref_mode = usr_cfg->force_ref_mode;
|
frm->ref_arg = usr_cfg->force_ref_arg;
|
|
usr_cfg->force_flag &= ~ENC_FORCE_REF_MODE;
|
}
|
|
if (usr_cfg->force_flag & ENC_FORCE_PSKIP) {
|
frm->is_non_ref = 1;
|
|
usr_cfg->force_flag &= ~ENC_FORCE_PSKIP;
|
}
|
|
frm->non_recn = frm->is_non_ref || (p->igop == 1);
|
|
/* update st_cfg for st_cfg loop */
|
cpb->st_cfg_repeat_pos++;
|
if (cpb->st_cfg_repeat_pos > st_cfg->repeat) {
|
cpb->st_cfg_repeat_pos = 0;
|
cpb->st_cfg_pos++;
|
}
|
|
/* step 4. try find ref by the ref_mode */
|
EncFrmStatus *ref_found = get_ref_from_cpb(&p->cpb, frm);
|
if (ref_found) {
|
RK_S32 cpb_idx = check_ref_cpb_pos(&p->cpb, ref_found);
|
|
mpp_assert(cpb_idx >= 0);
|
cpb->list0[0].val = ref->val;
|
ref->val = ref_found->val;
|
} else
|
ref->val = 0;
|
|
/* step 5. check use previous pass one frame as input */
|
if (prev_frm_is_pass1)
|
frm->use_pass1 = 1;
|
|
if (enc_refs_debug & MPP_ENC_REFS_DBG_FRM) {
|
mpp_log_f("frm status:\n");
|
dump_frm(frm);
|
mpp_log_f("ref status:\n");
|
dump_frm(ref);
|
}
|
|
/* step 5. generate cpb init */
|
memset(status->init, 0, sizeof(status->init));
|
save_cpb_status(&p->cpb, status->init);
|
// TODO: cpb_init must be the same to cpb_final
|
|
/* step 6. store frame according to status */
|
store_ref_to_cpb(&p->cpb, frm);
|
|
/* step 7. generate cpb final */
|
memset(status->final, 0, sizeof(status->final));
|
save_cpb_status(&p->cpb, status->final);
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
|
RK_S32 mpp_enc_refs_next_frm_is_intra(MppEncRefs refs)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
EncVirtualCpb *cpb = &p->cpb;
|
MppEncRefFrmUsrCfg *usr_cfg = &p->usr_cfg;
|
RK_S32 is_intra = 0;
|
|
if (p->changed & ENC_REFS_IGOP_CHANGED)
|
is_intra = 1;
|
|
if (p->igop && cpb->seq_idx >= p->igop)
|
is_intra = 1;
|
|
if (usr_cfg->force_flag & ENC_FORCE_IDR)
|
is_intra = 1;
|
|
if (!cpb->frm_idx)
|
is_intra = 0;
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
|
return is_intra;
|
}
|
|
MPP_RET mpp_enc_refs_get_cpb_pass1(MppEncRefs refs, EncCpbStatus *status)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
EncVirtualCpb *cpb = &p->cpb;
|
EncFrmStatus *frm = &status->curr;
|
EncFrmStatus *ref = &status->refr;
|
|
frm->valid = 1;
|
frm->save_pass1 = 1;
|
frm->is_non_ref = 1;
|
frm->is_lt_ref = 0;
|
frm->temporal_id = 0;
|
frm->ref_mode = REF_TO_PREV_REF_FRM;
|
frm->ref_arg = 0;
|
frm->non_recn = 0;
|
|
/* step 4. try find ref by the ref_mode */
|
EncFrmStatus *ref_found = get_ref_from_cpb(cpb, frm);
|
if (ref_found) {
|
RK_S32 cpb_idx = check_ref_cpb_pos(cpb, ref_found);
|
|
mpp_assert(cpb_idx >= 0);
|
cpb->list0[0].val = ref->val;
|
ref->val = ref_found->val;
|
} else
|
ref->val = 0;
|
|
if (enc_refs_debug & MPP_ENC_REFS_DBG_FRM) {
|
mpp_log_f("frm status:\n");
|
dump_frm(frm);
|
mpp_log_f("ref status:\n");
|
dump_frm(ref);
|
}
|
|
/* step 5. generate cpb init */
|
memset(status->init, 0, sizeof(status->init));
|
save_cpb_status(cpb, status->init);
|
// TODO: cpb_init must be the same to cpb_final
|
|
/* step 6. store frame according to status */
|
store_ref_to_cpb(cpb, frm);
|
|
/* step 7. generate cpb final */
|
memset(status->final, 0, sizeof(status->final));
|
save_cpb_status(cpb, status->final);
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
MPP_RET mpp_enc_refs_stash(MppEncRefs refs)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
memcpy(&p->cpb_stash, &p->cpb, sizeof(p->cpb_stash));
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
|
MPP_RET mpp_enc_refs_rollback(MppEncRefs refs)
|
{
|
if (NULL == refs) {
|
mpp_err_f("invalid NULL input refs\n");
|
return MPP_ERR_VALUE;
|
}
|
|
enc_refs_dbg_func("enter %p\n", refs);
|
|
MppEncRefsImpl *p = (MppEncRefsImpl *)refs;
|
memcpy(&p->cpb, &p->cpb_stash, sizeof(p->cpb));
|
|
enc_refs_dbg_func("leave %p\n", refs);
|
return MPP_OK;
|
}
|
