/*
|
* 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.
|
*/
|
|
#include <sys/inotify.h>
|
#include "mpi_enc.h"
|
#include "uvc_video.h"
|
#include "uvc_encode.h"
|
#include "uvc_log.h"
|
#include "../cJSON/cJSON.h"
|
#include "mpp_osd.h"
|
|
#if MJPEG_RGA_OSD_ENABLE
|
#include <rga/im2d.h>
|
#include <rga/rga.h>
|
#endif
|
|
#define TEST_MPP_SEI 0
|
|
void *thread_check_mpp_enc_chenge_loop(void *user);
|
|
static int mpp_enc_cfg_set(MpiEncTestData *p, bool init);
|
static int check_mpp_enc_cfg_file_init(MpiEncTestData *p);
|
static void mpp_enc_cfg_default(MpiEncTestData *p);
|
static int parse_check_mpp_enc_cfg(cJSON *root, MpiEncTestData *p, bool init);
|
static void dump_mpp_enc_cfg(MpiEncTestData *p);
|
static int read_mpp_enc_cfg_modify_file(MpiEncTestData *p, bool init);
|
static MPP_RET mpp_enc_bps_set(MpiEncTestData *p, RK_U32 bps);
|
static MPP_RET mpp_set_ref_param(MpiEncTestData *p, MpiEncGopMode gop_mode);
|
static MPP_RET mpp_enc_set_sei(MpiEncTestData *p, MppEncSeiMode mode);
|
static MPP_RET mpp_enc_send_sei(MpiEncTestData *p, MppMeta meta, char *sei_data);
|
#if TEST_MPP_SEI
|
static MPP_RET mpp_test_send_user_data(MpiEncTestData *p, MppFrame frame);
|
#endif
|
|
#if MPP_ENC_ROI_ENABLE
|
static int mpp_roi_config(MpiEncTestData *p, EncROIRegion *regions, int region_cnt);
|
static int mpp_roi_enable_set(MpiEncTestData *p, int enable);
|
static int mpp_roi_enable_get(MpiEncTestData *p);
|
#endif
|
|
#if MPP_ENC_OSD_ENABLE
|
extern int mpp_enc_gen_osd_plt(MpiEncTestData *p, uint32_t *ptl_data);
|
extern const RK_U32 u32DftARGB8888ColorTblUser[PALETTE_TABLE_LEN];
|
extern const RK_U32 u32DftARGB8888ColorTbl[PALETTE_TABLE_LEN];
|
extern int mpp_osd_bmp_to_ayuv_image(MpiEncTestData *p, osd_data_s *draw_data);
|
extern void mpp_osd_region_id_enable_set(MpiEncTestData *p, int region_id, int enable);
|
extern mpp_osd_region_id_enable_get(MpiEncTestData *p, int region_id);
|
extern void mpp_osd_enable_set(MpiEncTestData *p, bool enable);
|
extern bool mpp_osd_enable_get(MpiEncTestData *p);
|
extern MPP_RET mpp_osd_default_set(MpiEncTestData *p);
|
void mpp_osd_run(MpiEncTestData *p, int fd, MppFrame frame);
|
#if MJPEG_RGA_OSD_ENABLE || YUV_RGA_OSD_ENABLE
|
extern void mjpeg_rga_osd_process(MpiEncTestData *p, int id, int src_fd);
|
#endif
|
#endif
|
|
#if RK_MPP_MJPEG_FPS_CONTROL
|
extern void *mpp_mjpeg_fps_init(bool *enable, int mode, int fps, int width, int height);
|
extern void mpp_mjpeg_fps_deinit(void *fps_handle);
|
extern bool mpp_mjpeg_encode_data_set(void *fps_handle, void *data, size_t len);
|
#endif
|
|
#if 0
|
static OptionInfo mpi_enc_cmd[] =
|
{
|
{"i", "input_file", "input bitstream file"},
|
{"o", "output_file", "output bitstream file, "},
|
{"w", "width", "the width of input picture"},
|
{"h", "height", "the height of input picture"},
|
{"f", "format", "the format of input picture"},
|
{"t", "type", "output stream coding type"},
|
{"n", "max frame number", "max encoding frame number"},
|
{"d", "debug", "debug flag"},
|
};
|
#endif
|
static MppFrameFormat g_format = MPP_FMT_YUV420SP;
|
|
RK_S32 mpi_get_env_u32(const char *name, RK_U32 *value, RK_U32 default_value)
|
{
|
char *ptr = getenv(name);
|
if (NULL == ptr)
|
{
|
*value = default_value;
|
}
|
else
|
{
|
char *endptr;
|
int base = (ptr[0] == '0' && ptr[1] == 'x') ? (16) : (10);
|
*value = strtoul(ptr, &endptr, base);
|
if (ptr == endptr)
|
{
|
*value = default_value;
|
}
|
}
|
return 0;
|
}
|
|
static MPP_RET test_ctx_init(MpiEncTestData **data, MpiEncTestCmd *cmd)
|
{
|
MpiEncTestData *p = NULL;
|
MPP_RET ret = MPP_OK;
|
|
if (!data || !cmd)
|
{
|
LOG_ERROR("invalid input data %p cmd %p\n", data, cmd);
|
return MPP_ERR_NULL_PTR;
|
}
|
|
p = calloc(sizeof(MpiEncTestData), 1);
|
if (!p)
|
{
|
LOG_ERROR("create MpiEncTestData failed\n");
|
ret = MPP_ERR_MALLOC;
|
goto RET;
|
}
|
|
// get paramter from cmd
|
p->width = cmd->width;
|
p->height = cmd->height;
|
p->hor_stride = cmd->width;//MPP_ALIGN(cmd->width, 16);
|
p->ver_stride = cmd->height;//MPP_ALIGN(cmd->height, 16);
|
p->fmt = cmd->format;
|
p->type = cmd->type;
|
p->fps = cmd->fps;
|
if (cmd->type == MPP_VIDEO_CodingMJPEG)
|
cmd->num_frames = 1;
|
p->num_frames = cmd->num_frames;
|
// update resource parameter
|
if (p->fmt <= MPP_FMT_YUV420SP_VU)
|
p->frame_size = MPP_ALIGN(cmd->width, 16) * MPP_ALIGN(cmd->height, 16) * 2;
|
else if (p->fmt <= MPP_FMT_YUV422_UYVY)
|
{
|
// NOTE: yuyv and uyvy need to double stride
|
p->hor_stride *= 2;
|
p->frame_size = p->hor_stride * p->ver_stride;
|
}
|
else
|
p->frame_size = p->hor_stride * p->ver_stride * 4;
|
p->packet_size = p->frame_size;//p->width * p->height;
|
|
RET:
|
*data = p;
|
return ret;
|
}
|
|
static MPP_RET test_ctx_deinit(MpiEncTestData **data)
|
{
|
MpiEncTestData *p = NULL;
|
|
if (!data)
|
{
|
LOG_ERROR("invalid input data %p\n", data);
|
return MPP_ERR_NULL_PTR;
|
}
|
|
p = *data;
|
if (p)
|
{
|
if (p->fp_input)
|
{
|
fclose(p->fp_input);
|
p->fp_input = NULL;
|
}
|
if (p->fp_output)
|
{
|
fclose(p->fp_output);
|
p->fp_output = NULL;
|
}
|
free(p);
|
*data = NULL;
|
}
|
|
return MPP_OK;
|
}
|
|
//abandoned interface
|
static MPP_RET test_mpp_setup(MpiEncTestData *p)
|
{
|
MPP_RET ret;
|
MppApi *mpi;
|
MppCtx ctx;
|
MppEncCfg cfg;
|
MppEncRcMode rc_mode = MPP_ENC_RC_MODE_CBR;
|
|
if (NULL == p)
|
return MPP_ERR_NULL_PTR;
|
|
mpi_get_env_u32("enc_version", &p->enc_version, RK_MPP_VERSION_DEFAULT);
|
LOG_DEBUG("enc_version:%d,RK_MPP_USE_FULL_RANGE:%d\n",
|
p->enc_version, RK_MPP_USE_FULL_RANGE);
|
|
int need_full_range = 1;
|
char *full_range = getenv("ENABLE_FULL_RANGE");
|
if (full_range)
|
{
|
need_full_range = atoi(full_range);
|
LOG_DEBUG("mpp full_range use env setting:%d \n", need_full_range);
|
}
|
|
mpi = p->mpi;
|
ctx = p->ctx;
|
cfg = p->cfg;
|
|
/* setup default parameter */
|
if (p->fps_in_den == 0)
|
p->fps_in_den = 1;
|
if (p->fps_in_num == 0)
|
p->fps_in_num = 30;
|
if (p->fps_out_den == 0)
|
p->fps_out_den = 1;
|
if (p->fps_out_num == 0)
|
p->fps_out_num = 30;
|
p->gop = 60;
|
if (!p->bps)
|
p->bps = p->width * p->height / 8 * (p->fps_out_num / p->fps_out_den);
|
mpp_enc_cfg_set_s32(cfg, "prep:width", p->width);
|
mpp_enc_cfg_set_s32(cfg, "prep:height", p->height);
|
mpp_enc_cfg_set_s32(cfg, "prep:hor_stride", p->hor_stride);
|
mpp_enc_cfg_set_s32(cfg, "prep:ver_stride", p->ver_stride);
|
mpp_enc_cfg_set_s32(cfg, "prep:format", p->fmt);
|
|
mpp_enc_cfg_set_s32(cfg, "rc:mode", rc_mode);
|
switch (rc_mode)
|
{
|
case MPP_ENC_RC_MODE_FIXQP :
|
{
|
/* do not set bps on fix qp mode */
|
} break;
|
case MPP_ENC_RC_MODE_CBR :
|
{
|
/* CBR mode has narrow bound */
|
mpp_enc_cfg_set_s32(cfg, "rc:bps_target", p->bps);
|
mpp_enc_cfg_set_s32(cfg, "rc:bps_max", p->bps * 17 / 16);
|
mpp_enc_cfg_set_s32(cfg, "rc:bps_min", p->bps * 15 / 16);
|
}
|
break;
|
case MPP_ENC_RC_MODE_VBR :
|
{
|
/* CBR mode has wide bound */
|
mpp_enc_cfg_set_s32(cfg, "rc:bps_target", p->bps);
|
mpp_enc_cfg_set_s32(cfg, "rc:bps_max", p->bps * 17 / 16);
|
mpp_enc_cfg_set_s32(cfg, "rc:bps_min", p->bps * 1 / 16);
|
}
|
break;
|
default :
|
{
|
LOG_ERROR("unsupport encoder rc mode %d\n", rc_mode);
|
}
|
break;
|
}
|
|
/* fix input / output frame rate */
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_flex", p->fps_in_flex);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_num", p->fps_in_num);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_denorm", p->fps_in_den);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_flex", p->fps_out_flex);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_num", p->fps_out_num);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_denorm", p->fps_out_den);
|
mpp_enc_cfg_set_s32(cfg, "rc:gop", p->gop);
|
|
/* setup codec */
|
mpp_enc_cfg_set_s32(cfg, "codec:type", p->type);
|
switch (p->type)
|
{
|
case MPP_VIDEO_CodingAVC :
|
{
|
/*
|
* H.264 profile_idc parameter
|
* 66 - Baseline profile
|
* 77 - Main profile
|
* 100 - High profile
|
*/
|
mpp_enc_cfg_set_s32(cfg, "h264:profile", 100);
|
/*
|
* H.264 level_idc parameter
|
* 10 / 11 / 12 / 13 - qcif@15fps / cif@7.5fps / cif@15fps / cif@30fps
|
* 20 / 21 / 22 - cif@30fps / half-D1@@25fps / D1@12.5fps
|
* 30 / 31 / 32 - D1@25fps / 720p@30fps / 720p@60fps
|
* 40 / 41 / 42 - 1080p@30fps / 1080p@30fps / 1080p@60fps
|
* 50 / 51 / 52 - 4K@30fps
|
*/
|
mpp_enc_cfg_set_s32(cfg, "h264:level", 40);
|
mpp_enc_cfg_set_s32(cfg, "h264:cabac_en", 1);
|
mpp_enc_cfg_set_s32(cfg, "h264:cabac_idc", 0);
|
mpp_enc_cfg_set_s32(cfg, "h264:trans8x8", 1);
|
}
|
break;
|
case MPP_VIDEO_CodingMJPEG :
|
{
|
mpp_enc_cfg_set_s32(cfg, "jpeg:quant", 7);
|
}
|
break;
|
case MPP_VIDEO_CodingVP8 :
|
{
|
} break;
|
case MPP_VIDEO_CodingHEVC :
|
{
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_init", rc_mode == MPP_ENC_RC_MODE_FIXQP ? -1 : 26);
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_max", 51);
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_min", 10);
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_max_i", 46);
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_min_i", 24);
|
}
|
break;
|
default :
|
{
|
LOG_ERROR("unsupport encoder coding type %d\n", p->type);
|
}
|
break;
|
}
|
|
p->split_mode = MPP_ENC_SPLIT_NONE;
|
p->split_arg = 0;
|
|
if (p->split_mode)
|
{
|
LOG_DEBUG("split_mode %d split_arg %d\n", p->split_mode, p->split_arg);
|
mpp_enc_cfg_set_s32(cfg, "split:mode", p->split_mode);
|
mpp_enc_cfg_set_s32(cfg, "split:arg", p->split_arg);
|
}
|
|
#if RK_MPP_USE_FULL_RANGE
|
ret = mpp_enc_cfg_set_s32(cfg, "prep:range", MPP_FRAME_RANGE_JPEG);
|
#else
|
if (need_full_range)
|
ret = mpp_enc_cfg_set_s32(cfg, "prep:range", MPP_FRAME_RANGE_JPEG);
|
else
|
ret = mpp_enc_cfg_set_s32(cfg, "prep:range", MPP_FRAME_RANGE_UNSPECIFIED);
|
#endif
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set prep:range failed ret %d\n", ret);
|
goto RET;
|
}
|
|
ret = mpi->control(ctx, MPP_ENC_SET_CFG, cfg);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
|
/* optional */
|
p->sei_mode = MPP_ENC_SEI_MODE_DISABLE;
|
ret = mpi->control(ctx, MPP_ENC_SET_SEI_CFG, &p->sei_mode);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set sei cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
|
if (p->enc_version == 1 &&
|
(p->type == MPP_VIDEO_CodingAVC ||
|
p->type == MPP_VIDEO_CodingHEVC))
|
{
|
int header_mode = MPP_ENC_HEADER_MODE_EACH_IDR;
|
ret = mpi->control(ctx, MPP_ENC_SET_HEADER_MODE, &header_mode);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set codec cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
|
RET:
|
return ret;
|
}
|
|
MPP_RET mpp_mjpeg_simple_frc(MpiEncTestData *p, bool set_low)
|
{
|
MPP_RET ret = MPP_OK;
|
bool change = false;
|
RK_U32 last;
|
|
if (set_low)
|
{
|
#if MPP_ENC_MJPEG_FRC_USE_MPP
|
if (p->mjpeg_cfg.rc_mode != MPP_ENC_RC_MODE_FIXQP)
|
{
|
last = p->mjpeg_cfg.frc_bps;
|
p->mjpeg_cfg.frc_bps = (p->mjpeg_cfg.frc_bps > MJPEG_FRC_BPS_MIN ?
|
(p->mjpeg_cfg.frc_bps - MJPEG_FRC_BPS_PER_STEP) :
|
p->mjpeg_cfg.frc_bps);
|
if (p->mjpeg_cfg.frc_bps != last)
|
change = true;
|
}
|
#endif
|
if (p->mjpeg_cfg.rc_mode == MPP_ENC_RC_MODE_FIXQP)
|
{
|
if (!p->mjpeg_cfg.qfactor)
|
{
|
last = p->mjpeg_cfg.frc_quant;
|
p->mjpeg_cfg.frc_quant = (p->mjpeg_cfg.frc_quant > MJPEG_FRC_QUANT_MIN ?
|
(p->mjpeg_cfg.frc_quant - 1) :
|
p->mjpeg_cfg.frc_quant);
|
if (p->mjpeg_cfg.frc_quant != last)
|
change = true;
|
}
|
else
|
{
|
last = p->mjpeg_cfg.frc_qfactor;
|
p->mjpeg_cfg.frc_qfactor = (p->mjpeg_cfg.frc_qfactor > p->mjpeg_cfg.qfactor_frc_min ?
|
(p->mjpeg_cfg.frc_qfactor - 1) :
|
p->mjpeg_cfg.frc_qfactor);
|
if (p->mjpeg_cfg.frc_qfactor != last)
|
change = true;
|
}
|
}
|
}
|
else
|
{
|
#if MPP_ENC_MJPEG_FRC_USE_MPP
|
if (p->mjpeg_cfg.rc_mode != MPP_ENC_RC_MODE_FIXQP)
|
{
|
last = p->mjpeg_cfg.frc_bps;
|
p->mjpeg_cfg.frc_bps = (p->mjpeg_cfg.frc_bps < MJPEG_FRC_BPS_MAX ?
|
(p->mjpeg_cfg.frc_bps + MJPEG_FRC_BPS_PER_STEP) :
|
p->mjpeg_cfg.frc_bps);
|
if (p->mjpeg_cfg.frc_bps != last)
|
change = true;
|
}
|
#endif
|
if (p->mjpeg_cfg.rc_mode == MPP_ENC_RC_MODE_FIXQP)
|
{
|
if (!p->mjpeg_cfg.qfactor)
|
{
|
last = p->mjpeg_cfg.frc_quant;
|
p->mjpeg_cfg.frc_quant = (p->mjpeg_cfg.frc_quant < p->mjpeg_cfg.quant ?
|
(p->mjpeg_cfg.frc_quant + 1) :
|
p->mjpeg_cfg.frc_quant);
|
if (p->mjpeg_cfg.frc_quant != last)
|
change = true;
|
}
|
else
|
{
|
last = p->mjpeg_cfg.frc_qfactor;
|
p->mjpeg_cfg.frc_qfactor = (p->mjpeg_cfg.frc_qfactor < p->mjpeg_cfg.qfactor ?
|
(p->mjpeg_cfg.frc_qfactor + 1) :
|
p->mjpeg_cfg.frc_qfactor);
|
if (p->mjpeg_cfg.frc_qfactor != last)
|
change = true;
|
}
|
}
|
}
|
|
if (!change)
|
return ret;
|
#if MPP_ENC_MJPEG_FRC_USE_MPP
|
switch (p->mjpeg_cfg.rc_mode)
|
{
|
case MPP_ENC_RC_MODE_FIXQP :
|
{
|
/* do not set bps on fix qp mode */
|
}
|
break;
|
case MPP_ENC_RC_MODE_CBR :
|
{
|
/* CBR mode has narrow bound */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", p->mjpeg_cfg.frc_bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", p->mjpeg_cfg.frc_bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", p->mjpeg_cfg.frc_bps * 15 / 16);
|
LOG_INFO("frc_bps %s, change %d to %d\n", set_low ? "set down" : "set up", last, p->mjpeg_cfg.frc_bps);
|
}
|
break;
|
case MPP_ENC_RC_MODE_VBR :
|
{
|
/* CBR mode has wide bound */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", p->mjpeg_cfg.frc_bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", p->mjpeg_cfg.frc_bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", p->mjpeg_cfg.frc_bps * 1 / 16);
|
LOG_INFO("frc_bps %s, change %d to %d\n", set_low ? "set down" : "set up", last, p->mjpeg_cfg.frc_bps);
|
}
|
break;
|
default :
|
{
|
LOG_ERROR("unsupport encoder rc mode %d\n", p->mjpeg_cfg.rc_mode);
|
return MPP_NOK;
|
}
|
break;
|
}
|
#endif
|
if (p->mjpeg_cfg.rc_mode == MPP_ENC_RC_MODE_FIXQP)
|
{
|
if (!p->mjpeg_cfg.qfactor)
|
{
|
mpp_enc_cfg_set_s32(p->cfg, "jpeg:quant", p->mjpeg_cfg.frc_quant);
|
LOG_INFO("frc_quant %s, change %d to %d\n", set_low ? "set down" : "set up", last, p->mjpeg_cfg.frc_quant);
|
}
|
else
|
{
|
mpp_enc_cfg_set_s32(p->cfg, "jpeg:q_factor", p->mjpeg_cfg.frc_qfactor);
|
LOG_INFO("frc_qfactor %s, change %d to %d\n", set_low ? "set down" : "set up", last, p->mjpeg_cfg.frc_qfactor);
|
}
|
}
|
ret = p->mpi->control(p->ctx, MPP_ENC_SET_CFG, p->cfg);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set cfg failed ret %d\n", ret);
|
}
|
|
return ret;
|
}
|
|
bool mjpeg_is_high_solution(MpiEncTestData *p)
|
{
|
bool ret = false;
|
if (p->type != MPP_VIDEO_CodingMJPEG)
|
return ret;
|
if (!p->common_cfg.frc_fps) {
|
if ((p->height > 1440 && p->fps > 15) ||
|
(p->height > 1080 && p->fps > 25) ||
|
(p->height > 720 && p->fps > 30)) {
|
ret = true;
|
}
|
} else {//if need use frc_fps to control rate,do this
|
p->fps = p->common_cfg.frc_fps;
|
if ((p->height > 1440 && p->fps > 15) ||
|
(p->height > 1080 && p->fps > 25) ||
|
(p->height > 720 && p->fps > 30)) {//if need use frc_fps to control rate,do change here p->fps to p->common_cfg.frc_fps
|
ret = true;
|
}
|
}
|
return ret;
|
}
|
|
void mpp_try_count_set(MpiEncTestData *p)
|
{
|
if (p->common_cfg.frc_fps == 0)
|
p->common_cfg.frc_fps = p->fps;
|
p->common_cfg.try_count = p->common_cfg.frc_fps ?
|
(1000 / p->common_cfg.frc_fps / MPP_FRC_WAIT_TIME_MS + MPP_FRC_WAIT_COUNT_OFFSET) :
|
20 + MPP_FRC_WAIT_COUNT_OFFSET;
|
p->common_cfg.try_count = p->common_cfg.try_count > (p->common_cfg.enc_time / MPP_FRC_WAIT_TIME_MS) ?
|
(p->common_cfg.try_count - p->common_cfg.enc_time / MPP_FRC_WAIT_TIME_MS) :
|
MPP_FRC_WAIT_COUNT_MIN;
|
if (mjpeg_is_high_solution(p) == true)
|
p->common_cfg.try_count = (p->common_cfg.try_count - 1) <
|
MPP_MJPEG_HIGH_FPS_FRC_WAIT_COUNT_MIN ?
|
MPP_MJPEG_HIGH_FPS_FRC_WAIT_COUNT_MIN : p->common_cfg.try_count - 1;
|
else
|
p->common_cfg.try_count = p->common_cfg.try_count < MPP_FRC_WAIT_COUNT_MIN ?
|
MPP_FRC_WAIT_COUNT_MIN : p->common_cfg.try_count;
|
}
|
|
static MPP_RET mpp_enc_need_extra_buf(MpiEncTestData *p, MPP_ENC_INFO_DEF *info)
|
{
|
MPP_RET ret;
|
MppApi *mpi;
|
MppCtx ctx;
|
MppBuffer buf = NULL;
|
if (NULL == p)
|
return MPP_ERR_NULL_PTR;
|
#if 1
|
mpi = p->mpi;
|
ctx = p->ctx;
|
|
if (p->enc_version == 1)
|
{
|
//no need to get the sps/pps in addition
|
if (p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC) //force set idr when begin enc
|
{
|
if (p->h2645_frm_count < (p->common_cfg.force_idr_count * p->common_cfg.force_idr_period))
|
{
|
if ((p->h2645_frm_count % p->common_cfg.force_idr_period) == 0)
|
{
|
ret = mpi->control(ctx, MPP_ENC_SET_IDR_FRAME, NULL);
|
if (ret)
|
{
|
LOG_ERROR("mpi force idr frame control failed\n");
|
goto RET;
|
}
|
else
|
{
|
LOG_INFO("mpi force idr frame control ok, h2645_frm_count:%d\n", p->h2645_frm_count);
|
}
|
}
|
p->h2645_frm_count++;
|
}
|
}
|
}
|
else
|
{
|
if (p->type == MPP_VIDEO_CodingAVC)
|
{
|
MppPacket packet = NULL;
|
|
ret = mpi->control(ctx, MPP_ENC_GET_EXTRA_INFO, &packet);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc get extra info failed\n");
|
goto RET;
|
}
|
|
/* get and write sps/pps for H.264 */
|
if (packet)
|
{
|
void *ptr = mpp_packet_get_pos(packet);
|
size_t len = mpp_packet_get_length(packet);
|
|
if (p->fp_output)
|
fwrite(ptr, 1, len, p->fp_output);
|
|
packet = NULL;
|
}
|
}
|
}
|
|
do
|
{
|
MppFrame frame = NULL;
|
|
if (p->packet)
|
mpp_packet_deinit(&p->packet);
|
p->packet = NULL;
|
|
ret = mpp_frame_init(&frame);
|
if (ret)
|
{
|
LOG_ERROR("mpp_frame_init failed\n");
|
goto RET;
|
}
|
|
mpp_frame_set_width(frame, p->width);
|
mpp_frame_set_height(frame, p->height);
|
mpp_frame_set_hor_stride(frame, p->hor_stride);
|
mpp_frame_set_ver_stride(frame, p->ver_stride);
|
mpp_frame_set_fmt(frame, p->fmt);
|
#if 0
|
mpp_frame_set_buffer(frame, p->frm_buf);
|
#else
|
MppBufferInfo inputCommit;
|
memset(&inputCommit, 0, sizeof(inputCommit));
|
inputCommit.type = MPP_BUFFER_TYPE_ION;
|
inputCommit.size = info->size;
|
inputCommit.fd = info->fd;
|
ret = mpp_buffer_import(&buf, &inputCommit);
|
if (ret)
|
{
|
LOG_ERROR("import input picture buffer failed\n");
|
goto RET;
|
}
|
mpp_frame_set_buffer(frame, buf);
|
#endif
|
mpp_frame_set_eos(frame, p->frm_eos);
|
|
ret = mpi->encode_put_frame(ctx, frame);
|
if (ret)
|
{
|
LOG_ERROR("mpp encode put frame failed\n");
|
mpp_frame_deinit(&frame);
|
goto RET;
|
}
|
mpp_frame_deinit(&frame);
|
|
ret = mpi->encode_get_packet(ctx, &p->packet);
|
if (ret)
|
{
|
LOG_ERROR("mpp encode get packet failed\n");
|
goto RET;
|
}
|
|
if (p->packet)
|
{
|
// write packet to file here
|
void *ptr = mpp_packet_get_pos(p->packet);
|
size_t len = mpp_packet_get_length(p->packet);
|
|
p->pkt_eos = mpp_packet_get_eos(p->packet);
|
|
if (p->fp_output)
|
{
|
fwrite(ptr, 1, len, p->fp_output);
|
#if RK_MPP_DYNAMIC_DEBUG_ON
|
if (access(RK_MPP_DYNAMIC_DEBUG_OUT_CHECK, 0))
|
{
|
fclose(p->fp_output);
|
p->fp_output = NULL;
|
LOG_INFO("debug out file close\n");
|
}
|
}
|
else if (!access(RK_MPP_DYNAMIC_DEBUG_OUT_CHECK, 0))
|
{
|
p->fp_output = fopen(p->streamout_save_dir, "w+b");
|
if (p->fp_output)
|
{
|
fwrite(ptr, 1, len, p->fp_output);
|
LOG_INFO("debug out file open\n");
|
}
|
#endif
|
}
|
|
mpp_packet_deinit(&p->packet);
|
p->enc_data = ptr;
|
p->enc_len = len;
|
}
|
}
|
while (0);
|
#endif
|
|
RET:
|
|
if (buf)
|
{
|
mpp_buffer_put(buf);
|
buf = NULL;
|
}
|
return ret;
|
}
|
|
|
static MPP_RET test_mpp_run(MpiEncTestData *p, MPP_ENC_INFO_DEF *info)
|
{
|
#if RK_MPP_USE_ZERO_COPY
|
MPP_RET ret;
|
MppApi *mpi;
|
MppCtx ctx;
|
MppPacket packet = NULL;
|
MppFrame frame = NULL;
|
RK_S32 i;
|
MppBuffer buf = NULL;
|
MppBuffer pkt_buf_out = NULL;
|
int try_count = p->common_cfg.try_count;
|
bool get_ok = false;
|
int32_t use_time_us, now_time_us, last_time_us;
|
struct timespec now_tm = {0, 0};
|
bool in_init = false;
|
bool out_init = false;
|
|
if (NULL == p)
|
return MPP_ERR_NULL_PTR;
|
|
mpi = p->mpi;
|
ctx = p->ctx;
|
|
ret = mpp_frame_init(&frame);
|
if (ret)
|
{
|
printf("mpp_frame_init failed\n");
|
goto RET;
|
}
|
|
mpp_frame_set_width(frame, p->width);
|
mpp_frame_set_height(frame, p->height);
|
mpp_frame_set_hor_stride(frame, p->hor_stride);
|
mpp_frame_set_ver_stride(frame, p->ver_stride);
|
mpp_frame_set_fmt(frame, p->fmt);
|
|
MppTask task = NULL;
|
RK_S32 index = i++;
|
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
|
struct uvc_buffer *uvc_buf;
|
|
#if UVC_SEND_BUF_WHEN_ENC_READY
|
if (p->frame_count >= UVC_BUFFER_NUM)
|
#endif
|
{
|
while (try_count--)
|
{
|
if ((!uvc_get_user_run_state(uvc_enc.video_id) || !uvc_buffer_write_enable(uvc_enc.video_id)))
|
{
|
// LOG_ERROR("not get write buff,read too slow.%d,%d\n",
|
// uvc_get_user_run_state(uvc_enc.video_id),uvc_buffer_write_enable(uvc_enc.video_id));
|
// return ret;
|
usleep(MPP_FRC_WAIT_TIME_US);
|
}
|
else
|
{
|
get_ok = true;
|
break;
|
}
|
}
|
}
|
#if UVC_SEND_BUF_WHEN_ENC_READY
|
else
|
{
|
get_ok = true;
|
}
|
#endif
|
|
if (!get_ok)
|
{
|
p->loss_frm ++;
|
p->continuous_frm = 0;
|
#if RK_MPP_DYNAMIC_DEBUG_ON
|
if (access(RK_MPP_CLOSE_FRM_LOSS_DEBUG_CHECK, 0)) //no exist and output log
|
#endif
|
{
|
if (p->mjpeg_cfg.qfactor_frc_min < p->mjpeg_cfg.frc_qfactor)
|
LOG_ERROR("not get write buff,read too slow %d,%d.\"touch %s \" can close debug.\n",
|
p->loss_frm,
|
p->frc_up_frm_set,
|
RK_MPP_CLOSE_FRM_LOSS_DEBUG_CHECK);
|
}
|
if (p->loss_frm >= 5 && p->type == MPP_VIDEO_CodingMJPEG && p->common_cfg.frc_mode)
|
{
|
p->loss_frm = 0;
|
if (p->set_frc_low == false) // punishment mechanism
|
p->frc_up_frm_set = (p->frc_up_frm_set << 1) < MPP_FRC_UP_FRM_SET_MAX ?
|
p->frc_up_frm_set <<= 1 : MPP_FRC_UP_FRM_SET_MAX;
|
else //avoid shortterm rapid decline after recovery too slow
|
p->frc_up_frm_set = (p->frc_up_frm_set >> 1) > MPP_FRC_UP_FRM_SET_MIN ?
|
p->frc_up_frm_set >>= 1 : MPP_FRC_UP_FRM_SET_INIT;
|
p->set_frc_low = true;
|
mpp_mjpeg_simple_frc(p, true);
|
}
|
return ret;
|
}
|
else
|
{
|
p->continuous_frm ++;
|
if (p->continuous_frm > p->frc_up_frm_set)
|
{
|
p->continuous_frm = 0;
|
p->loss_frm = ((p->loss_frm > 0) ? (p->loss_frm - 1) : 0);
|
// done:can turn up the quant here when loss_frm = 0 or continuous_frm up to more high
|
if (p->loss_frm == 0 && p->type == MPP_VIDEO_CodingMJPEG && p->common_cfg.frc_mode == FRC_BOTH_UP_LOW)
|
{
|
p->loss_frm = 2;
|
if (p->set_frc_low == false) // reward mechanism
|
p->frc_up_frm_set = (p->frc_up_frm_set >> 1) > MPP_FRC_UP_FRM_SET_MIN ?
|
p->frc_up_frm_set >>= 1 : MPP_FRC_UP_FRM_SET_INIT;
|
p->set_frc_low = false;
|
mpp_mjpeg_simple_frc(p, false);
|
}
|
}
|
}
|
|
// uvc_user_lock();
|
uvc_buf = uvc_buffer_write_get(uvc_enc.video_id);
|
if (!uvc_buf || uvc_buf->abandon)
|
{
|
LOG_ERROR("uvc_buffer_write_get failed(buf: %p)\n", uvc_buf);
|
goto RET;
|
}
|
|
uvc_buf->pts = info->pts;
|
uvc_buf->seq = info->seq;
|
clock_gettime(CLOCK_MONOTONIC, &now_tm);
|
now_time_us = now_tm.tv_sec * 1000000LL + now_tm.tv_nsec / 1000; // us
|
|
#if UVC_DYNAMIC_DEBUG_USE_TIME
|
if (!access(UVC_DYNAMIC_DEBUG_USE_TIME_CHECK, 0))
|
{
|
use_time_us = now_time_us - uvc_buf->pts;
|
#if USE_RK_AISERVER
|
LOG_INFO("isp->aiserver->ipc->mpp_get_buf seq:%d latency time:%d us, %d ms\n", uvc_buf->seq, use_time_us, use_time_us / 1000);
|
#endif
|
#if USE_ROCKIT
|
LOG_INFO("isp->rockit->uvc->mpp_get_buf seq:%d latency time:%d us, %d ms\n", uvc_buf->seq, use_time_us, use_time_us / 1000);
|
#endif
|
#if USE_RKMEDIA
|
LOG_INFO("isp->rkmedia->uvc->mpp_get_buf seq:%d latency time:%d us, %d ms\n", uvc_buf->seq, use_time_us, use_time_us / 1000);
|
#endif
|
}
|
#endif
|
|
for (int i = 0; i < OUT_BUF_COUNT_MAX; i++) {
|
if (uvc_buf->fd == p->out_buff_info[i].buf_fd) {
|
out_init = true;
|
packet = p->out_buff_info[i].packet;
|
pkt_buf_out = p->out_buff_info[i].pkt_buf_out;
|
break;
|
}
|
}
|
if (out_init == false)
|
{
|
MppBufferInfo outputCommit;
|
outputCommit.type = MPP_BUFFER_TYPE_DRM;
|
outputCommit.size = uvc_buf->drm_buf_size;
|
outputCommit.fd = uvc_buf->fd;
|
|
ret = mpp_buffer_import(&pkt_buf_out, &outputCommit);
|
if (ret)
|
{
|
LOG_ERROR("import output picture buffer failed\n");
|
goto RET;
|
}
|
mpp_packet_init_with_buffer(&packet, pkt_buf_out);
|
for (int i = 0; i < OUT_BUF_COUNT_MAX; i++) {
|
if (p->out_buff_info[i].init == false) {
|
p->out_buff_info[i].init = true;
|
p->out_buff_info[i].buf_fd = uvc_buf->fd;
|
p->out_buff_info[i].packet = packet;
|
p->out_buff_info[i].pkt_buf_out = pkt_buf_out;
|
out_init = true;
|
break;
|
}
|
}
|
//LOG_INFO("new out put fd:%d\n", uvc_buf->fd);
|
}
|
|
#else
|
pkt_buf_out = p->pkt_buf;
|
mpp_packet_init_with_buffer(&packet, pkt_buf_out);
|
#endif
|
//mpp_packet_set_pos(packet, NULL);
|
mpp_packet_set_length(packet, 0);
|
|
#if 0
|
mpp_frame_set_buffer(frame, p->frm_buf);
|
#else
|
for (int i = 0; i < IN_BUF_COUNT_MAX; i++) {
|
if (info->fd == p->in_buff_info[i].buf_fd) {
|
in_init = true;
|
buf = p->in_buff_info[i].buf;
|
break;
|
}
|
}
|
|
if (in_init == false) {
|
MppBufferInfo inputCommit;
|
inputCommit.type = MPP_BUFFER_TYPE_ION;
|
inputCommit.size = info->size;
|
inputCommit.fd = info->fd;
|
ret = mpp_buffer_import(&buf, &inputCommit);
|
if (ret)
|
{
|
LOG_ERROR("import input picture buffer failed\n");
|
goto RET;
|
}
|
for (int i = 0; i < IN_BUF_COUNT_MAX; i++) {
|
if (p->in_buff_info[i].init == false) {
|
p->in_buff_info[i].init = true;
|
p->in_buff_info[i].buf_fd = info->fd;
|
p->in_buff_info[i].buf = buf;
|
p->in_buff_info[i].pkt_buf_out = pkt_buf_out;
|
in_init = true;
|
break;
|
}
|
}
|
//LOG_INFO("new in put fd:%d \n", info->fd);
|
}
|
mpp_frame_set_buffer(frame, buf);
|
#endif
|
if (p->enc_version == 1)
|
{
|
//no need to get the sps/pps in addition
|
if (p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC) //force set idr when begin enc
|
{
|
if (p->common_cfg.force_idr_count * p->common_cfg.force_idr_period) {
|
if (p->h2645_frm_count < (p->common_cfg.force_idr_count * p->common_cfg.force_idr_period))
|
{
|
if ((p->h2645_frm_count % p->common_cfg.force_idr_period) == 0)
|
{
|
LOG_INFO("mpi force idr frame control ok, h2645_frm_count:%d ,H264:%d\n",
|
p->h2645_frm_count, (p->type == MPP_VIDEO_CodingAVC));
|
}
|
p->h2645_frm_count++;
|
}
|
else if (p->h2645_frm_count == p->common_cfg.force_idr_count * p->common_cfg.force_idr_period)
|
{
|
if (p->type == MPP_VIDEO_CodingAVC)
|
{
|
p->h264_cfg.gop = p->h264_cfg.gop_normal;
|
mpp_enc_cfg_set_s32(p->cfg, "rc:gop", p->h264_cfg.gop);
|
mpp_enc_bps_set(p, p->h264_cfg.bps);
|
mpp_set_ref_param(p, p->h264_cfg.gop_mode);
|
}
|
else
|
{
|
p->h265_cfg.gop = p->h265_cfg.gop_normal;
|
mpp_enc_cfg_set_s32(p->cfg, "rc:gop", p->h265_cfg.gop);
|
mpp_enc_bps_set(p, p->h265_cfg.bps);
|
mpp_set_ref_param(p, p->h265_cfg.gop_mode);
|
}
|
ret = mpi->control(ctx, MPP_ENC_SET_CFG, p->cfg);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
p->h2645_frm_count++;
|
}
|
}
|
}
|
}
|
#if MPP_ENC_ROI_ENABLE
|
if (mpp_roi_enable_get(p)) {
|
MppMeta meta = NULL;
|
meta = mpp_frame_get_meta(frame);
|
mpp_meta_set_ptr(meta, KEY_ROI_DATA, (void*)&p->roi_cfg);
|
}
|
#endif
|
|
#if MPP_ENC_OSD_ENABLE
|
mpp_osd_run(p, info->fd, frame);
|
#endif
|
|
#if TEST_MPP_SEI
|
mpp_test_send_user_data(p, frame); // test sei
|
#endif
|
|
ret = mpi->poll(ctx, MPP_PORT_INPUT, MPP_POLL_BLOCK);
|
if (ret)
|
{
|
LOG_ERROR("mpp task input poll failed ret %d\n", ret);
|
goto RET;
|
}
|
|
ret = mpi->dequeue(ctx, MPP_PORT_INPUT, &task);
|
if (ret || NULL == task)
|
{
|
LOG_ERROR("mpp task input dequeue failed ret %d task %p\n", ret, task);
|
goto RET;
|
}
|
|
mpp_task_meta_set_frame(task, KEY_INPUT_FRAME, frame);
|
mpp_task_meta_set_packet(task, KEY_OUTPUT_PACKET, packet);
|
//800us+
|
|
ret = mpi->enqueue(ctx, MPP_PORT_INPUT, task);
|
if (ret)
|
{
|
LOG_ERROR("mpp task input enqueue failed\n");
|
goto RET;
|
}
|
//800us+
|
#if 1
|
ret = mpi->poll(ctx, MPP_PORT_OUTPUT, MPP_POLL_BLOCK);
|
if (ret)
|
{
|
LOG_ERROR("mpp task output poll failed ret %d\n", ret);
|
goto RET;
|
}//9028 us for 1080p
|
#else
|
do
|
{
|
ret = mpi->poll(ctx, MPP_PORT_OUTPUT, MPP_POLL_NON_BLOCK);
|
usleep(100);
|
}
|
while (ret);//8882 us for 1080p
|
#endif
|
|
ret = mpi->dequeue(ctx, MPP_PORT_OUTPUT, &task);
|
if (ret || NULL == task)
|
{
|
LOG_ERROR("mpp task output dequeue failed ret %d task %p\n", ret, task);
|
goto RET;
|
}
|
|
if (task)
|
{
|
MppFrame packet_out = NULL;
|
mpp_task_meta_get_packet(task, KEY_OUTPUT_PACKET, &packet_out);
|
assert(packet_out == packet);
|
if (packet)
|
{
|
// write packet to file here
|
size_t len = mpp_packet_get_length(packet);
|
#if RK_MPP_DYNAMIC_DEBUG_ON
|
if (!access(RK_MPP_OUT_LEN_DEBUG_CHECK, 0))
|
LOG_INFO("out_len=%d\n", len);
|
#endif
|
|
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
|
uvc_buf->size = len;
|
uvc_buf->frame_count = p->frame_count;
|
if (p->fps_ctr_enable == true) {
|
#if (RK_MPP_MJPEG_FPS_CONTROL && MJPEG_FPS_CONTROL_V2)
|
if (!mpp_mjpeg_encode_data_set(p->fps_handle, (void *)uvc_buf, len)) {
|
uvc_buffer_write_set(uvc_enc.video_id, uvc_buf);
|
LOG_WARN("mpp_mjpeg_encode_data_set fail, giveback the uvc_buf:%d\n", uvc_buf->fd);
|
//uvc_buffer_read_set(uvc_enc.video_id, uvc_buf);
|
}
|
#endif
|
} else {
|
uvc_buffer_read_set(uvc_enc.video_id, uvc_buf);
|
}
|
#else
|
void *ptr = mpp_packet_get_pos(packet);
|
#endif
|
if (p->fp_output)
|
{
|
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
|
fwrite(uvc_buf->buffer, 1, len, p->fp_output);
|
#else
|
fwrite(ptr, 1, len, p->fp_output);
|
#endif
|
#if RK_MPP_DYNAMIC_DEBUG_ON
|
if (access(RK_MPP_DYNAMIC_DEBUG_OUT_CHECK, 0))
|
{
|
fclose(p->fp_output);
|
p->fp_output = NULL;
|
LOG_INFO("debug out file close\n");
|
}
|
}
|
else if (!access(RK_MPP_DYNAMIC_DEBUG_OUT_CHECK, 0))
|
{
|
p->fp_output = fopen(p->streamout_save_dir, "w+b");
|
if (p->fp_output)
|
{
|
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
|
fwrite(uvc_buf->buffer, 1, len, p->fp_output);
|
#else
|
fwrite(ptr, 1, len, p->fp_output);
|
#endif
|
LOG_INFO("debug out file open\n");
|
}
|
#endif
|
}
|
#ifndef RK_MPP_USE_UVC_VIDEO_BUFFER
|
p->enc_data = ptr;
|
p->enc_len = len;
|
#endif
|
// mpp_packet_deinit(&packet);
|
clock_gettime(CLOCK_MONOTONIC, &now_tm);
|
last_time_us = now_time_us;
|
now_time_us = now_tm.tv_sec * 1000000LL + now_tm.tv_nsec / 1000; // us
|
use_time_us = now_time_us - uvc_buf->pts;
|
|
p->common_cfg.enc_time = (now_time_us - last_time_us) / 1000 +
|
(p->common_cfg.try_count - try_count) * MPP_FRC_WAIT_TIME_MS;
|
p->common_cfg.enc_time = p->common_cfg.enc_time > 80 ? 80 : p->common_cfg.enc_time < 2 ? 2 : p->common_cfg.enc_time;
|
mpp_try_count_set(p);
|
#if UVC_DYNAMIC_DEBUG_USE_TIME
|
if (!access(UVC_DYNAMIC_DEBUG_USE_TIME_CHECK, 0))
|
{
|
LOG_INFO("mpp_enc+getbuf time:%d ms, try_count:%d \n",
|
p->common_cfg.enc_time, p->common_cfg.try_count);
|
#if USE_RK_AISERVER
|
LOG_INFO("isp->aiserver->ipc->mpp_enc_ok latency time:%d us, %d ms\n",
|
use_time_us, use_time_us / 1000);
|
#endif
|
#if USE_ROCKIT
|
LOG_INFO("isp->rockit->uvc->mpp_enc_ok latency time:%d us, %d ms\n",
|
use_time_us, use_time_us / 1000);
|
#endif
|
#if USE_RKMEDIA
|
LOG_INFO("isp->rkmedia->uvc->mpp_enc_ok latency time:%d us, %d ms\n",
|
use_time_us, use_time_us / 1000);
|
#endif
|
}
|
#endif
|
}
|
//9175 us for 1080p
|
p->frame_count++;
|
}
|
/*
|
if(p->frame_count % 100 == 0) {
|
LOG_INFO("outlen=%d\n", uvc_buf->size);
|
}
|
*/
|
ret = mpi->enqueue(ctx, MPP_PORT_OUTPUT, task);
|
if (ret)
|
{
|
LOG_ERROR("mpp task output enqueue failed\n");
|
goto RET;
|
}//9195 us for 1080p
|
|
RET:
|
// uvc_user_unlock();
|
|
if (frame)
|
{
|
mpp_frame_deinit(&frame);
|
frame = NULL;
|
}
|
if (in_init == false)
|
{
|
if (buf)
|
{
|
mpp_buffer_put(buf);
|
buf = NULL;
|
}
|
}
|
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
|
if (out_init == false)
|
{
|
if (pkt_buf_out)
|
{
|
mpp_buffer_put(pkt_buf_out);
|
pkt_buf_out = NULL;
|
}
|
if (packet)
|
mpp_packet_deinit(&packet);
|
}
|
#endif
|
|
return ret;
|
#else
|
mpp_enc_need_extra_buf(p, info);
|
#endif
|
}
|
|
MPP_RET mpi_enc_test_init(MpiEncTestCmd *cmd, MpiEncTestData **data)
|
{
|
MPP_RET ret = MPP_OK;
|
MpiEncTestData *p = NULL;
|
|
LOG_DEBUG("mpi_enc_test start\n");
|
|
ret = test_ctx_init(&p, cmd);
|
if (ret)
|
{
|
LOG_ERROR("test data init failed ret %d\n", ret);
|
return ret;
|
}
|
*data = p;
|
|
#if 0
|
ret = mpp_buffer_get(NULL, &p->frm_buf, p->frame_size);
|
if (ret)
|
{
|
LOG_INFO("failed to get buffer for input frame ret %d\n", ret);
|
return ret;
|
}
|
#endif
|
|
LOG_INFO("mpi_enc_test encoder test start w %d h %d type %d\n",
|
p->width, p->height, p->type);
|
if (p->type != 0)
|
{
|
// encoder demo
|
ret = mpp_create(&p->ctx, &p->mpi);
|
if (ret)
|
{
|
LOG_ERROR("mpp_create failed ret %d\n", ret);
|
return ret;
|
}
|
|
ret = mpp_init(p->ctx, MPP_CTX_ENC, p->type);
|
if (ret)
|
{
|
LOG_ERROR("mpp_init failed ret %d\n", ret);
|
return ret;
|
}
|
ret = mpp_enc_cfg_init(&p->cfg);
|
if (ret)
|
{
|
LOG_ERROR("mpp_enc_cfg_init failed ret %d\n", ret);
|
return ret;
|
}
|
#if RK_MPP_USE_ZERO_COPY
|
#ifndef RK_MPP_USE_UVC_VIDEO_BUFFER
|
ret = mpp_buffer_group_get_internal(&p->pkt_grp, MPP_BUFFER_TYPE_DRM);
|
if (ret)
|
{
|
LOG_ERROR("failed to get buffer group for output packet ret %d\n", ret);
|
return ret;
|
}
|
p->packet_size = p->width * p->height;
|
|
ret = mpp_buffer_get(p->pkt_grp, &p->pkt_buf, p->packet_size);
|
if (ret)
|
{
|
LOG_ERROR("failed to get buffer for pkt_buf ret %d\n", ret);
|
return ret;
|
}
|
#else
|
#if MPP_ENC_OSD_ENABLE
|
ret = mpp_buffer_group_get_internal(&p->pkt_grp, MPP_BUFFER_TYPE_DRM);
|
if (ret)
|
{
|
LOG_ERROR("failed to get buffer group for output packet ret %d\n", ret);
|
return ret;
|
}
|
#endif
|
#endif
|
#endif
|
}
|
mpp_enc_cfg_default(p);
|
|
if (!check_mpp_enc_cfg_file_init(p))
|
LOG_DEBUG("check_mpp_enc_cfg_file ok\n");
|
ret = mpp_enc_cfg_set(p, true);
|
dump_mpp_enc_cfg(p);
|
if (ret)
|
{
|
LOG_ERROR("mpp_enc_cfg_set failed ret %d\n", ret);
|
return ret;
|
}
|
pthread_create(&p->check_cfg_change_hd, NULL, thread_check_mpp_enc_chenge_loop, p);
|
#if RK_MPP_MJPEG_FPS_CONTROL
|
if (mjpeg_is_high_solution(p) == true || p->mjpeg_cfg.enc_mode >= 2)
|
{
|
if (p->mjpeg_cfg.enc_mode == 0)
|
p->fps_ctr_enable = true;
|
p->fps_handle = mpp_mjpeg_fps_init(&p->fps_ctr_enable, p->mjpeg_cfg.enc_mode, p->fps, p->width, p->height);
|
}
|
#endif
|
|
mpi_get_env_u32("uvc_enc_out", &cmd->have_output, 0);
|
|
if (cmd->have_output || !access(RK_MPP_DYNAMIC_DEBUG_OUT_CHECK, 0))
|
{
|
p->fp_output = fopen(p->streamout_save_dir, "w+b");
|
if (NULL == p->fp_output)
|
{
|
LOG_ERROR("failed to open output file %s\n", p->streamout_save_dir);
|
}
|
LOG_DEBUG("debug out file open\n");
|
}
|
|
if (!access(RK_MPP_DYNAMIC_DEBUG_IN_CHECK, 0))
|
{
|
p->fp_input = fopen(p->streamin_save_dir, "w+b");
|
if (NULL == p->fp_input)
|
{
|
LOG_ERROR("failed to open in file %s\n", p->streamin_save_dir);
|
}
|
LOG_WARN("warnning:debug in file open, open it will lower the fps\n");
|
}
|
|
for (int i = 0; i < OUT_BUF_COUNT_MAX; i++) {
|
p->out_buff_info[i].init = false;
|
p->out_buff_info[i].buf_fd = -1;
|
}
|
for (int i = 0; i < IN_BUF_COUNT_MAX; i++) {
|
p->in_buff_info[i].init = false;
|
p->in_buff_info[i].buf_fd = -1;
|
}
|
|
p->yuv_rotation_drm_fd = -1;
|
p->yuv_rotation_fd = -1;
|
if ((p->type == 0 && p->common_cfg.rotation) || (p->type == MPP_VIDEO_CodingMJPEG && p->common_cfg.rotation == 2)) {
|
p->yuv_rotation_drm_fd = drm_open();
|
if (p->yuv_rotation_drm_fd < 0) {
|
LOG_ERROR("yuv_rotation_drm_fd open fail\n");
|
return MPP_NOK;
|
}
|
p->yuv_rotation_drm_size = p->width * p->height * 2;
|
ret = drm_alloc(p->yuv_rotation_drm_fd, p->yuv_rotation_drm_size, 16, &p->yuv_rotation_handle, 0);
|
if (ret)
|
{
|
LOG_ERROR("yuv_rotation drm_alloc fail\n");
|
return MPP_NOK;
|
}
|
ret = drm_handle_to_fd(p->yuv_rotation_drm_fd, p->yuv_rotation_handle, &p->yuv_rotation_fd, 0);
|
if (ret)
|
{
|
LOG_ERROR("yuv_rotation drm_handle_to_fd fail\n");
|
return MPP_NOK;
|
}
|
}
|
|
LOG_INFO("fps_ctr_enable:%d,roi:%d,enc_osd:%d,rga_osd:%d\n",
|
p->fps_ctr_enable, MPP_ENC_ROI_ENABLE,
|
MPP_ENC_OSD_ENABLE, MJPEG_RGA_OSD_ENABLE);
|
|
return ret;
|
}
|
|
MPP_RET mpi_enc_test_run(MpiEncTestData **data, MPP_ENC_INFO_DEF *info)
|
{
|
MPP_RET ret = MPP_OK;
|
MpiEncTestData *p = *data;
|
|
ret = test_mpp_run(p, info);
|
if (ret)
|
LOG_ERROR("test mpp run failed ret %d\n", ret);
|
return ret;
|
}
|
|
MPP_RET mpi_enc_inbuf_deinit(MpiEncTestData *data)
|
{
|
MpiEncTestData *p = data;
|
for (int i = 0; i < IN_BUF_COUNT_MAX; i++) {
|
if (p->in_buff_info[i].init) {
|
if (p->in_buff_info[i].buf)
|
{
|
mpp_buffer_put(p->in_buff_info[i].buf);
|
p->in_buff_info[i].buf = NULL;
|
p->in_buff_info[i].buf_fd = -1;
|
}
|
}
|
p->in_buff_info[i].init = false;
|
}
|
}
|
|
MPP_RET mpi_enc_test_deinit(MpiEncTestData **data)
|
{
|
MPP_RET ret = MPP_OK;
|
MpiEncTestData *p = *data;
|
|
#if RK_MPP_MJPEG_FPS_CONTROL
|
mpp_mjpeg_fps_deinit(p->fps_handle);
|
#endif
|
if (p->yuv_rotation_drm_fd >= 0) {
|
if (p->yuv_rotation_fd >= 0)
|
close(p->yuv_rotation_fd);
|
drm_free(p->yuv_rotation_drm_fd, p->yuv_rotation_handle);
|
drm_close(p->yuv_rotation_drm_fd);
|
}
|
|
for (int i = 0; i < OUT_BUF_COUNT_MAX; i++) {
|
if (p->out_buff_info[i].init) {
|
if (p->out_buff_info[i].packet)
|
mpp_packet_deinit(&p->out_buff_info[i].packet);
|
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
|
if (p->out_buff_info[i].pkt_buf_out)
|
{
|
mpp_buffer_put(p->out_buff_info[i].pkt_buf_out);
|
p->out_buff_info[i].pkt_buf_out = NULL;
|
}
|
#endif
|
p->out_buff_info[i].init = false;
|
}
|
}
|
mpi_enc_inbuf_deinit(p);
|
|
if (p->check_cfg_change_hd) {
|
pthread_cancel(p->check_cfg_change_hd);
|
pthread_join(p->check_cfg_change_hd, NULL);
|
}
|
if (p->cfg_notify_fd)
|
{
|
inotify_rm_watch(p->cfg_notify_fd, p->cfg_notify_wd);
|
close(p->cfg_notify_fd);
|
}
|
if (p->packet)
|
mpp_packet_deinit(&p->packet);
|
if (p->ctx) {
|
ret = p->mpi->reset(p->ctx);
|
if (ret)
|
{
|
LOG_ERROR("mpi->reset failed\n");
|
}
|
}
|
if (p->ctx)
|
{
|
mpp_destroy(p->ctx);
|
p->ctx = NULL;
|
}
|
if (p->cfg) {
|
mpp_enc_cfg_deinit(p->cfg);
|
p->cfg = NULL;
|
}
|
|
#if MPP_ENC_OSD_ENABLE
|
if (p->osd_idx_buf) {
|
mpp_buffer_put(p->osd_idx_buf);
|
p->osd_idx_buf = NULL;
|
}
|
|
if (p->osd_data.buf) {
|
LOG_DEBUG("MPP Encoder: free osd buff\n");
|
mpp_buffer_put(p->osd_data.buf);
|
p->osd_data.buf = NULL;
|
}
|
#if MJPEG_RGA_OSD_ENABLE || YUV_RGA_OSD_ENABLE
|
else if (p->rga_osd_drm_fd > 0 &&
|
((p->type == MPP_VIDEO_CodingMJPEG && MJPEG_RGA_OSD_ENABLE) ||
|
(p->type == 0 && YUV_RGA_OSD_ENABLE))) {
|
for (int i = 0; i < p->osd_count; i++) {
|
if (p->osd_cfg[i].set_ok) {
|
drm_unmap_buffer(p->osd_cfg[i].buffer, p->osd_cfg[i].drm_size);
|
if (p->osd_cfg[i].rga_osd_fd)
|
close(p->osd_cfg[i].rga_osd_fd);
|
if (p->rga_osd_drm_fd && p->osd_cfg[i].handle)
|
drm_free(p->rga_osd_drm_fd, p->osd_cfg[i].handle);
|
}
|
}
|
drm_close(p->rga_osd_drm_fd);
|
}
|
#endif
|
#endif
|
|
#if MPP_ENC_ROI_ENABLE
|
if (p->roi_cfg.regions) {
|
free(p->roi_cfg.regions);
|
p->roi_cfg.regions = NULL;
|
}
|
#endif
|
#if 0
|
if (p->frm_buf)
|
{
|
mpp_buffer_put(p->frm_buf);
|
p->frm_buf = NULL;
|
}
|
#endif
|
|
#if RK_MPP_USE_ZERO_COPY
|
#ifndef RK_MPP_USE_UVC_VIDEO_BUFFER
|
if (p->pkt_buf)
|
{
|
mpp_buffer_put(p->pkt_buf);
|
p->pkt_buf = NULL;
|
}
|
|
if (p->pkt_grp)
|
{
|
mpp_buffer_group_put(p->pkt_grp);
|
p->pkt_grp = NULL;
|
}
|
#endif
|
#else
|
#if MPP_ENC_OSD_ENABLE
|
if (p->pkt_grp)
|
{
|
mpp_buffer_group_put(p->pkt_grp);
|
p->pkt_grp = NULL;
|
}
|
#endif
|
#endif
|
|
if (MPP_OK == ret)
|
{
|
LOG_INFO("mpi_enc_test success \n");
|
//LOG_INFO("mpi_enc_test success total frame %d bps %lld\n",
|
// p->frame_count, (RK_U64)((p->stream_size * 8 * p->fps) / p->frame_count));
|
}
|
else
|
{
|
LOG_ERROR("mpi_enc_test failed ret %d\n", ret);
|
}
|
test_ctx_deinit(&p);
|
|
return ret;
|
}
|
|
void mpi_enc_cmd_config(MpiEncTestCmd *cmd, int width, int height, int fcc, int h265, unsigned int fps)
|
{
|
memset((void *)cmd, 0, sizeof(*cmd));
|
cmd->width = width;
|
cmd->height = height;
|
cmd->format = g_format;
|
cmd->fps = fps;
|
|
char *env_h265 = getenv("ENABLE_UVC_H265");
|
if (env_h265)
|
{
|
h265 = atoi(env_h265);
|
LOG_INFO("V4L2_PIX_FMT_H264 force use h265 ?:%d \n", h265);
|
}
|
if(!access(RK_MPP_ENABLE_UVC_H265, 0)) {
|
h265 = 1;
|
LOG_INFO("tmp: V4L2_PIX_FMT_H264 force use h265!!\n");
|
}
|
|
switch (fcc)
|
{
|
case V4L2_PIX_FMT_YUYV:
|
case V4L2_PIX_FMT_NV12:
|
LOG_DEBUG("%s: yuyv not need mpp encodec: %d\n", __func__, fcc);
|
break;
|
case V4L2_PIX_FMT_MJPEG:
|
cmd->type = MPP_VIDEO_CodingMJPEG;
|
break;
|
case V4L2_PIX_FMT_H264:
|
{
|
if (h265)
|
cmd->type = MPP_VIDEO_CodingHEVC;
|
else
|
cmd->type = MPP_VIDEO_CodingAVC;//MPP_VIDEO_CodingAVC;//MPP_VIDEO_CodingHEVC
|
break;
|
}
|
case V4L2_PIX_FMT_H265:
|
cmd->type = MPP_VIDEO_CodingHEVC;
|
break;
|
default:
|
LOG_WARN("%s: not support fcc: %d\n", __func__, fcc);
|
break;
|
}
|
|
}
|
|
void mpi_enc_cmd_config_mjpg(MpiEncTestCmd *cmd, int width, int height)
|
{
|
memset((void *)cmd, 0, sizeof(*cmd));
|
cmd->width = width;
|
cmd->height = height;
|
cmd->format = g_format;
|
cmd->type = MPP_VIDEO_CodingMJPEG;
|
}
|
|
void mpi_enc_cmd_config_h264(MpiEncTestCmd *cmd, int width, int height)
|
{
|
memset((void *)cmd, 0, sizeof(*cmd));
|
cmd->width = width;
|
cmd->height = height;
|
cmd->format = g_format;
|
cmd->type = MPP_VIDEO_CodingAVC;
|
}
|
void mpi_enc_set_format(MppFrameFormat format)
|
{
|
g_format = format;
|
}
|
int mpi_enc_get_h264_extra(MpiEncTestData *p, void *buffer, size_t *size)
|
{
|
MPP_RET ret;
|
MppApi *mpi;
|
MppCtx ctx;
|
if (NULL == p)
|
{
|
*size = 0;
|
return -1;
|
}
|
mpi = p->mpi;
|
ctx = p->ctx;
|
MppPacket packet = NULL;
|
ret = mpi->control(ctx, MPP_ENC_GET_EXTRA_INFO, &packet);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc get extra info failed\n");
|
*size = 0;
|
return -1;
|
}
|
if (packet)
|
{
|
void *ptr = mpp_packet_get_pos(packet);
|
size_t len = mpp_packet_get_length(packet);
|
LOG_INFO("%s: len = %d\n", __func__, len);
|
if (*size >= len)
|
{
|
memcpy(buffer, ptr, len);
|
*size = len;
|
}
|
else
|
{
|
LOG_INFO("%s: input buffer size = %d\n", __func__, *size);
|
*size = 0;
|
}
|
packet = NULL;
|
}
|
return 0;
|
}
|
|
static unsigned long get_file_size(const char *filename)
|
{
|
struct stat buf;
|
if (stat(filename, &buf) < 0)
|
return 0;
|
return (unsigned long)buf.st_size;
|
}
|
|
static void mpp_enc_cfg_default(MpiEncTestData *p)
|
{
|
if (NULL == p)
|
return;
|
#if MPP_ENC_ROI_ENABLE
|
p->roi_enable = 0;
|
#endif
|
//common set
|
p->common_cfg.fbc = false;
|
p->common_cfg.split_mode = 0;
|
p->common_cfg.split_arg = 0;
|
p->common_cfg.force_idr_count = RK_MPP_H264_FORCE_IDR_COUNT;
|
p->common_cfg.force_idr_period = RK_MPP_H264_FORCE_IDR_PERIOD;
|
p->common_cfg.frc_fps = p->fps; // use frame rate control
|
p->common_cfg.frc_mode = FRC_ONLY_LOW;
|
p->common_cfg.rotation = 0;
|
if (p->type == MPP_VIDEO_CodingMJPEG)
|
p->common_cfg.enc_time = p->width * p->height / 110000;
|
else
|
p->common_cfg.enc_time = p->width * p->height / 330000;
|
p->common_cfg.enc_time = p->common_cfg.enc_time > 80 ? 80 : p->common_cfg.enc_time < 2 ? 2 : p->common_cfg.enc_time;
|
|
//mjpeg set
|
p->mjpeg_cfg.quant = 7;
|
p->mjpeg_cfg.qfactor = 80; //default set this
|
p->mjpeg_cfg.range = MPP_FRAME_RANGE_JPEG; //default for full(only full)
|
p->mjpeg_cfg.qfactor_min = 1;
|
p->mjpeg_cfg.qfactor_max = 99;
|
p->mjpeg_cfg.framerate = 0; // use host set
|
p->mjpeg_cfg.gop = 30;
|
p->mjpeg_cfg.sei = MPP_ENC_SEI_MODE_DISABLE;
|
#if MPP_ENC_MJPEG_FRC_USE_MPP
|
p->mjpeg_cfg.rc_mode = MPP_ENC_RC_MODE_CBR;
|
#else
|
p->mjpeg_cfg.rc_mode = MPP_ENC_RC_MODE_FIXQP; // not use mpp frc here must be fixqp, do not modify this setting.
|
#endif
|
p->mjpeg_cfg.bps = p->width * p->height / 8 * p->mjpeg_cfg.framerate * 3 / 2; // 1080p 11Mbps
|
p->mjpeg_cfg.frc_qfactor = p->mjpeg_cfg.qfactor;
|
p->mjpeg_cfg.qfactor_frc_min = MJPEG_FRC_QFACTOR_MIN;
|
|
//h264 set
|
p->h264_cfg.gop = 60;
|
p->h264_cfg.rc_mode = MPP_ENC_RC_MODE_CBR;
|
p->h264_cfg.framerate = 0; // use host set
|
p->h264_cfg.range = MPP_FRAME_RANGE_JPEG; //default for full
|
p->h264_cfg.head_each_idr = true;
|
p->h264_cfg.sei = MPP_ENC_SEI_MODE_DISABLE;
|
p->h264_cfg.qp.init = 26;
|
p->h264_cfg.qp.max = 48;
|
p->h264_cfg.qp.min = 8;
|
p->h264_cfg.qp.step = 8;
|
p->h264_cfg.profile = MPP_ENC_CFG_H264_DEFAULT_PROFILE;
|
p->h264_cfg.cabac_en = 1;
|
p->h264_cfg.cabac_idc = 0;
|
p->h264_cfg.trans_8x8 = 1;
|
p->h264_cfg.level = MPP_ENC_CFG_H264_DEFAULT_LEVEL;
|
p->h264_cfg.bps = p->width * p->height / 8 * p->h264_cfg.framerate / 2;
|
p->h264_cfg.idr_bps = p->width * p->height / 8 * p->h264_cfg.framerate;
|
p->h264_cfg.vi_len = p->h264_cfg.gop / 2;
|
p->h264_cfg.gop_mode = GOP_MODE_NORMALP;
|
|
//h265 set
|
p->h265_cfg.gop = 60;
|
p->h265_cfg.rc_mode = MPP_ENC_RC_MODE_CBR;
|
p->h265_cfg.framerate = 0; // use host set
|
p->h265_cfg.range = MPP_FRAME_RANGE_JPEG; //default for full
|
p->h265_cfg.head_each_idr = true;
|
p->h265_cfg.sei = MPP_ENC_SEI_MODE_DISABLE;
|
p->h265_cfg.qp.init = 24;
|
p->h265_cfg.qp.max = 51;
|
p->h265_cfg.qp.min = 10;
|
p->h265_cfg.qp.step = 4;
|
p->h265_cfg.qp.max_i_qp = 46;
|
p->h265_cfg.qp.min_i_qp = 24;
|
p->h265_cfg.bps = p->width * p->height / 8 * p->h265_cfg.framerate / 2;
|
p->h265_cfg.idr_bps = p->width * p->height / 8 * p->h265_cfg.framerate;
|
p->h265_cfg.vi_len = p->h265_cfg.gop / 2;
|
p->h265_cfg.gop_mode = GOP_MODE_NORMALP;
|
|
#if MPP_ENC_OSD_ENABLE
|
p->osd_count = 0;
|
p->osd_plt_user = false;
|
p->osd_enable = false;
|
for (int i = 0; i < OSD_REGIONS_CNT; i++) {
|
p->osd_cfg[i].set_ok = false;
|
p->osd_cfg[i].enable = false;
|
p->osd_cfg[i].start_x = 0;
|
p->osd_cfg[i].start_y = 0;
|
}
|
#endif
|
}
|
|
static void dump_mpp_enc_cfg(MpiEncTestData *p)
|
{
|
|
#if MPP_ENC_ROI_ENABLE
|
LOG_DEBUG("### dump_mpp_enc_cfg for roi cfg:\n");
|
LOG_DEBUG("roi_enable=%d\n", p->roi_enable);
|
#endif
|
|
LOG_DEBUG("### dump_mpp_enc_cfg for common cfg:\n");
|
LOG_DEBUG("fbc=%d,split_mode=%d,split_arg=%d,force_idr_count=%d,force_idr_period=%d,frc_fps=%d\n"
|
"frc_mode=%d,enc_time=%d,try_count=%d,frc_use_mpp=%d,fps:%d\n"
|
"p->streamin_save_dir=%s,p->streamout_save_dir=%s,rotation=%d\n",
|
p->common_cfg.fbc, p->common_cfg.split_mode, p->common_cfg.split_arg,
|
p->common_cfg.force_idr_count, p->common_cfg.force_idr_period,
|
p->common_cfg.frc_fps, p->common_cfg.frc_mode,
|
p->common_cfg.enc_time, p->common_cfg.try_count,
|
MPP_ENC_MJPEG_FRC_USE_MPP, p->fps,
|
p->streamin_save_dir, p->streamout_save_dir,
|
p->common_cfg.rotation*90);
|
|
LOG_DEBUG("###dump_mpp_enc_cfg for mjpeg cfg:\n");
|
LOG_DEBUG("quant=%d,q_fator=%d,range=%d,q_min=%d,q_max=%d,gop=%d,rc_mode=%d \n"
|
"bps=%d,framerate=%d,enc_mode:%d sei:%d\n",
|
p->mjpeg_cfg.quant, p->mjpeg_cfg.qfactor, p->mjpeg_cfg.range,
|
p->mjpeg_cfg.qfactor_min, p->mjpeg_cfg.qfactor_max,
|
p->mjpeg_cfg.gop, p->mjpeg_cfg.rc_mode, p->mjpeg_cfg.bps,
|
p->mjpeg_cfg.framerate, p->mjpeg_cfg.enc_mode, p->mjpeg_cfg.sei);
|
|
LOG_DEBUG("### dump_mpp_enc_cfg for h264 cfg:\n");
|
LOG_DEBUG("gop=%d,rc_mode=%d,framerate=%d,range=%d,head_each_idr=%d \n"
|
"sei=%d,qp.init=%d,qp.max=%d,qp.min=%d,qp.step=%d,profile=%d \n"
|
"cabac_en=%d,cabac_idc=%d,trans_8x8=%d,level=%d,bps=%d idr_bps=%d \n"
|
"vi_len=%d,gop_mode=%d\n",
|
p->h264_cfg.gop, p->h264_cfg.rc_mode, p->h264_cfg.framerate,
|
p->h264_cfg.range, p->h264_cfg.head_each_idr,
|
p->h264_cfg.sei, p->h264_cfg.qp.init,
|
p->h264_cfg.qp.max, p->h264_cfg.qp.min,
|
p->h264_cfg.qp.step, p->h264_cfg.profile,
|
p->h264_cfg.cabac_en, p->h264_cfg.cabac_idc,
|
p->h264_cfg.trans_8x8, p->h264_cfg.level,
|
p->h264_cfg.bps, p->h264_cfg.idr_bps,
|
p->h264_cfg.vi_len, p->h264_cfg.gop_mode);
|
|
LOG_DEBUG("### dump_mpp_enc_cfg for h265 cfg:\n");
|
LOG_DEBUG("gop=%d,rc_mode=%d,framerate=%d,range=%d,head_each_idr=%d \n"
|
"sei=%d,qp.init=%d,qp.max=%d,qp.min=%d,qp.step=%d,max_i_qp=%d \n"
|
"min_i_qp=%d,bps=%d idr_bps=%d vi_len=%d,gop_mode=%d\n",
|
p->h265_cfg.gop, p->h265_cfg.rc_mode, p->h265_cfg.framerate,
|
p->h265_cfg.range, p->h265_cfg.head_each_idr,
|
p->h265_cfg.sei, p->h265_cfg.qp.init,
|
p->h265_cfg.qp.max, p->h265_cfg.qp.min,
|
p->h265_cfg.qp.step, p->h265_cfg.qp.max_i_qp,
|
p->h265_cfg.qp.min_i_qp, p->h265_cfg.bps, p->h265_cfg.idr_bps,
|
p->h265_cfg.vi_len, p->h265_cfg.gop_mode);
|
|
#if MPP_ENC_OSD_ENABLE
|
LOG_DEBUG("### dump_mpp_enc_cfg for osd cfg:\n");
|
LOG_DEBUG("osd_enable=%d, count=%d, osd_plt_user=%d\n",
|
p->osd_enable, p->osd_count, p->osd_plt_user);
|
for (int i = 0; i < OSD_REGIONS_CNT; i++) {
|
LOG_DEBUG("enable=%d, set_ok=%d, start_x=%d, start_y=%d, path=%s\n",
|
p->osd_cfg[i].enable, p->osd_cfg[i].set_ok,
|
p->osd_cfg[i].start_x, p->osd_cfg[i].start_y,
|
p->osd_cfg[i].image_path);
|
}
|
#endif
|
|
}
|
|
static int parse_check_mpp_enc_cfg(cJSON *root, MpiEncTestData *p, bool init)
|
{
|
int ret = 0;
|
RK_U32 fps;
|
|
if (NULL == p)
|
return -1;
|
|
LOG_DEBUG("parse_mpp_enc_cfg type: %d init:%d\n", p->type, init);
|
if (!init)
|
{
|
p->common_cfg.change = 0;
|
p->mjpeg_cfg.change = 0;
|
p->h264_cfg.change = 0;
|
p->h265_cfg.change = 0;
|
}
|
cJSON *child = cJSON_GetObjectItem(root, "mpp_enc_cfg");
|
if (!child)
|
{
|
LOG_ERROR("parse_mpp_enc_cfg mpp_enc_cfg err\n");
|
return -1;
|
}
|
cJSON *child_version = cJSON_GetObjectItem(child, "version");
|
if (child_version)
|
{
|
LOG_DEBUG("parse_mpp_enc_cfg version:%s\n", child_version->valuestring);
|
}
|
|
cJSON *child_common = cJSON_GetObjectItem(child, "common");
|
if (!child_common)
|
{
|
LOG_ERROR("parse_mpp_enc_cfg common err\n");
|
return -1;
|
}
|
else
|
{
|
cJSON *child_common_param = NULL;
|
if (init)
|
child_common_param = cJSON_GetObjectItem(child_common, "param_init");
|
else
|
child_common_param = cJSON_GetObjectItem(child_common, "param_change");
|
if (child_common_param)
|
{
|
cJSON *child_common_fbc = cJSON_GetObjectItem(child_common_param, "fbc");
|
if (child_common_fbc)
|
{
|
p->common_cfg.fbc = strstr(child_common_fbc->valuestring, "off") ? 0 : MPP_FRAME_FBC_AFBC_V1;
|
p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(0);
|
}
|
cJSON *child_common_split_mode = cJSON_GetObjectItem(child_common_param, "split_mode");
|
if (child_common_split_mode)
|
{
|
p->common_cfg.split_mode = strstr(child_common_split_mode->valuestring, "none") ? MPP_ENC_SPLIT_NONE :
|
strstr(child_common_split_mode->valuestring, "byte") ? MPP_ENC_SPLIT_BY_BYTE :
|
strstr(child_common_split_mode->valuestring, "ctu") ? MPP_ENC_SPLIT_BY_CTU : MPP_ENC_SPLIT_NONE;
|
p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(1);
|
}
|
cJSON *child_common_split_arg = cJSON_GetObjectItem(child_common_param, "split_arg");
|
if (child_common_split_arg)
|
{
|
p->common_cfg.split_arg = child_common_split_arg->valueint;
|
p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(2);
|
}
|
cJSON *child_common_idr_count = cJSON_GetObjectItem(child_common_param, "force_idr_count");
|
if (child_common_idr_count)
|
{
|
p->common_cfg.force_idr_count = child_common_idr_count->valueint;
|
p->common_cfg.force_idr_count = p->common_cfg.force_idr_count < 0 ? 0 :
|
p->common_cfg.force_idr_count > 100 ? 100 :
|
p->common_cfg.force_idr_count;
|
p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(3);
|
}
|
cJSON *child_common_idr_period = cJSON_GetObjectItem(child_common_param, "force_idr_period");
|
if (child_common_idr_period)
|
{
|
p->common_cfg.force_idr_period = child_common_idr_period->valueint;
|
p->common_cfg.force_idr_period = p->common_cfg.force_idr_period < 1 ? 1 :
|
p->common_cfg.force_idr_period > 100 ? 100 :
|
p->common_cfg.force_idr_period;
|
p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(4);
|
}
|
cJSON *child_common_frc_fps = cJSON_GetObjectItem(child_common_param, "frc_fps");
|
if (child_common_frc_fps)
|
{
|
p->common_cfg.frc_fps = child_common_frc_fps->valueint;
|
p->common_cfg.frc_fps = p->common_cfg.frc_fps < 0 ? 0 :
|
p->common_cfg.frc_fps > 100 ? 100 : p->common_cfg.frc_fps;
|
p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(5);
|
}
|
cJSON *child_common_frc_mode = cJSON_GetObjectItem(child_common_param, "frc_mode");
|
if (child_common_frc_mode)
|
{
|
p->common_cfg.frc_mode = child_common_frc_mode->valueint;
|
p->common_cfg.frc_mode = p->common_cfg.frc_mode < FRC_OFF ? FRC_OFF :
|
p->common_cfg.frc_mode > FRC_BOTH_UP_LOW ? FRC_BOTH_UP_LOW : p->common_cfg.frc_mode;
|
p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(6);
|
}
|
cJSON *child_common_rotation = cJSON_GetObjectItem(child_common_param, "rotation");
|
if (child_common_rotation)
|
{
|
switch (child_common_rotation->valueint) {
|
case 0:
|
p->common_cfg.rotation = 0;
|
break;
|
case 90:
|
p->common_cfg.rotation = 1;
|
break;
|
case 180:
|
p->common_cfg.rotation = 2;
|
break;
|
case 270:
|
p->common_cfg.rotation = 3;
|
break;
|
default:
|
LOG_WARN("rotation:%d not support\n", child_common_rotation->valueint);
|
p->common_cfg.rotation = 0;
|
break;
|
}
|
p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(7); //not support change after enc
|
}
|
cJSON *child_common_stream_save_dir = cJSON_GetObjectItem(child_common_param, "stream_save_dir");
|
if (child_common_stream_save_dir)
|
{
|
if (strlen(child_common_stream_save_dir->valuestring) >
|
(MPP_STREAM_SAVE_DIR_LEN - strlen(RK_MPP_DEBUG_OUT_FILE) - 1))
|
{
|
LOG_ERROR("stream_save_dir:%s, the name too long\n",
|
child_common_stream_save_dir->valuestring);
|
sprintf(p->streamin_save_dir,"/data%s",
|
RK_MPP_DEBUG_IN_FILE);
|
sprintf(p->streamout_save_dir,"/data%s",
|
RK_MPP_DEBUG_OUT_FILE);
|
}
|
else
|
{
|
sprintf(p->streamin_save_dir,"/%s%s",
|
child_common_stream_save_dir->valuestring,
|
RK_MPP_DEBUG_IN_FILE);
|
sprintf(p->streamout_save_dir,"/%s%s",
|
child_common_stream_save_dir->valuestring,
|
RK_MPP_DEBUG_OUT_FILE);
|
}
|
//p->common_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(7); //no need
|
}
|
else
|
{
|
sprintf(p->streamin_save_dir,"/data%s",
|
RK_MPP_DEBUG_IN_FILE);
|
sprintf(p->streamout_save_dir,"/data%s",
|
RK_MPP_DEBUG_OUT_FILE);
|
}
|
|
LOG_INFO("common_cfg.change:0x%x\n", p->common_cfg.change);
|
}
|
else
|
{
|
LOG_WARN("no find common param_init or param_change\n");
|
}
|
}
|
|
fps = (p->common_cfg.frc_fps ? p->common_cfg.frc_fps : p->fps);
|
switch (p->type)
|
{
|
case MPP_VIDEO_CodingMJPEG :
|
{
|
cJSON *child_mjpeg = cJSON_GetObjectItem(child, "mjpeg");
|
if (!child_mjpeg)
|
{
|
LOG_ERROR("parse_mpp_enc_cfg mjpeg err\n");
|
return -1;
|
}
|
else
|
{
|
cJSON *child_mjpeg_param = NULL;
|
if (init)
|
child_mjpeg_param = cJSON_GetObjectItem(child_mjpeg, "param_init");
|
else
|
child_mjpeg_param = cJSON_GetObjectItem(child_mjpeg, "param_change");
|
if (child_mjpeg_param)
|
{
|
cJSON *child_mjpeg_quant = cJSON_GetObjectItem(child_mjpeg_param, "quant");
|
if (child_mjpeg_quant)
|
{
|
p->mjpeg_cfg.quant = child_mjpeg_quant->valueint;
|
p->mjpeg_cfg.quant = p->mjpeg_cfg.quant < 1 ? 1 :
|
p->mjpeg_cfg.quant > 10 ? 10 :
|
p->mjpeg_cfg.quant;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(0);
|
}
|
cJSON *child_mjpeg_range = cJSON_GetObjectItem(child_mjpeg_param, "range");
|
if (child_mjpeg_range)
|
{
|
p->mjpeg_cfg.range = strstr(child_mjpeg_range->valuestring, "limit") ?
|
MPP_FRAME_RANGE_MPEG : MPP_FRAME_RANGE_JPEG;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(1);
|
}
|
|
char resolution_name[15] = "";
|
sprintf(resolution_name, "%d*%dp%d",p->width, p->height, fps);
|
cJSON *child_mjpeg_resolution_name = cJSON_GetObjectItem(child_mjpeg_param, resolution_name);
|
cJSON *child_mjpeg_qfactor = NULL;
|
cJSON *child_mjpeg_qfactor_frc_min = NULL;
|
if (child_mjpeg_resolution_name) {
|
child_mjpeg_qfactor = cJSON_GetObjectItem(child_mjpeg_resolution_name, "qfactor");
|
child_mjpeg_qfactor_frc_min = cJSON_GetObjectItem(child_mjpeg_resolution_name, "qfactor_frc_min");
|
} else {
|
child_mjpeg_qfactor = cJSON_GetObjectItem(child_mjpeg_param, "qfactor");
|
child_mjpeg_qfactor_frc_min = cJSON_GetObjectItem(child_mjpeg_param, "qfactor_frc_min");
|
}
|
if (child_mjpeg_qfactor)
|
{
|
p->mjpeg_cfg.qfactor = child_mjpeg_qfactor->valueint;
|
p->mjpeg_cfg.qfactor = p->mjpeg_cfg.qfactor < 0 ? 0 :
|
p->mjpeg_cfg.qfactor > 99 ? 99 :
|
p->mjpeg_cfg.qfactor;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(2);
|
}
|
if (child_mjpeg_qfactor_frc_min)
|
{
|
p->mjpeg_cfg.qfactor_frc_min = child_mjpeg_qfactor_frc_min->valueint;
|
p->mjpeg_cfg.qfactor_frc_min = p->mjpeg_cfg.qfactor_frc_min < 0 ? 0 :
|
p->mjpeg_cfg.qfactor_frc_min > p->mjpeg_cfg.qfactor ? p->mjpeg_cfg.qfactor :
|
p->mjpeg_cfg.qfactor_frc_min;
|
}
|
|
cJSON *child_mjpeg_qfactor_min = cJSON_GetObjectItem(child_mjpeg_param, "qfactor_min");
|
if (child_mjpeg_qfactor_min)
|
{
|
p->mjpeg_cfg.qfactor_min = child_mjpeg_qfactor_min->valueint;
|
p->mjpeg_cfg.qfactor_min = p->mjpeg_cfg.qfactor_min < 0 ? 0 :
|
p->mjpeg_cfg.qfactor_min > p->mjpeg_cfg.qfactor ? p->mjpeg_cfg.qfactor :
|
p->mjpeg_cfg.qfactor_min;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(3);
|
}
|
cJSON *child_mjpeg_qfactor_max = cJSON_GetObjectItem(child_mjpeg_param, "qfactor_max");
|
if (child_mjpeg_qfactor_max)
|
{
|
p->mjpeg_cfg.qfactor_max = child_mjpeg_qfactor_max->valueint;
|
p->mjpeg_cfg.qfactor_max = p->mjpeg_cfg.qfactor_max < p->mjpeg_cfg.qfactor ? p->mjpeg_cfg.qfactor :
|
p->mjpeg_cfg.qfactor_max > 99 ? 99 :
|
p->mjpeg_cfg.qfactor_max;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(4);
|
}
|
cJSON *child_mjpeg_gop = cJSON_GetObjectItem(child_mjpeg_param, "gop");
|
if (child_mjpeg_gop)
|
{
|
p->mjpeg_cfg.gop = child_mjpeg_gop->valueint;
|
p->mjpeg_cfg.gop = p->mjpeg_cfg.gop < 1 ? 1 :
|
p->mjpeg_cfg.gop > 100 ? 100 :
|
p->mjpeg_cfg.gop;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(5);
|
}
|
#if MPP_ENC_MJPEG_FRC_USE_MPP
|
cJSON *child_mjpeg_rc_mode = cJSON_GetObjectItem(child_mjpeg_param, "rc_mode");
|
if (child_mjpeg_rc_mode)
|
{
|
p->mjpeg_cfg.rc_mode = strstr(child_mjpeg_rc_mode->valuestring, "cbr") ? MPP_ENC_RC_MODE_CBR :
|
strstr(child_mjpeg_rc_mode->valuestring, "vbr") ? MPP_ENC_RC_MODE_VBR :
|
strstr(child_mjpeg_rc_mode->valuestring, "fixqp") ? MPP_ENC_RC_MODE_FIXQP : MPP_ENC_RC_MODE_CBR;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(6);
|
}
|
#endif
|
cJSON *child_mjpeg_bps = cJSON_GetObjectItem(child_mjpeg_param, "bps");
|
if (child_mjpeg_bps)
|
{
|
p->mjpeg_cfg.bps = child_mjpeg_bps->valueint;
|
p->mjpeg_cfg.bps = p->mjpeg_cfg.bps < MPP_ENC_CFG_MIN_BPS ? MPP_ENC_CFG_MIN_BPS :
|
p->mjpeg_cfg.bps > MPP_ENC_MJPEG_CFG_MAX_BPS ? MPP_ENC_MJPEG_CFG_MAX_BPS :
|
p->mjpeg_cfg.bps;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(7);
|
}
|
cJSON *child_mjpeg_framerate = cJSON_GetObjectItem(child_mjpeg_param, "framerate");
|
if (child_mjpeg_framerate)
|
{
|
p->mjpeg_cfg.framerate = child_mjpeg_framerate->valueint;
|
p->mjpeg_cfg.framerate = p->mjpeg_cfg.framerate < MPP_ENC_CFG_MIN_FPS ? MPP_ENC_CFG_MIN_FPS :
|
p->mjpeg_cfg.framerate > MPP_ENC_CFG_MAX_FPS ? MPP_ENC_CFG_MAX_FPS :
|
p->mjpeg_cfg.framerate;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(8);
|
}
|
cJSON *child_mjpeg_enc_mode = cJSON_GetObjectItem(child_mjpeg_param, "enc_mode");
|
if (child_mjpeg_enc_mode)
|
{
|
p->mjpeg_cfg.enc_mode = child_mjpeg_enc_mode->valueint;
|
p->mjpeg_cfg.enc_mode = p->mjpeg_cfg.enc_mode < 0 ? 0 :
|
p->mjpeg_cfg.enc_mode > 3 ? 3 :
|
p->mjpeg_cfg.enc_mode;
|
// p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(9); //not need.
|
}
|
cJSON *child_mjpeg_sei = cJSON_GetObjectItem(child_mjpeg_param, "sei");
|
if (child_mjpeg_sei)
|
{
|
p->mjpeg_cfg.sei = strstr(child_mjpeg_sei->valuestring, "SEQ") ? MPP_ENC_SEI_MODE_ONE_SEQ :
|
strstr(child_mjpeg_sei->valuestring, "FRAME") ? MPP_ENC_SEI_MODE_ONE_FRAME :
|
MPP_ENC_SEI_MODE_DISABLE;
|
p->mjpeg_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(11);
|
}
|
|
LOG_INFO("mjpeg_cfg.change:0x%x\n", p->mjpeg_cfg.change);
|
}
|
else
|
{
|
LOG_WARN("no find mjpeg param_init or param_change\n");
|
}
|
}
|
}
|
break;
|
case MPP_VIDEO_CodingAVC :
|
{
|
cJSON *child_h264 = cJSON_GetObjectItem(child, "h264");
|
if (!child_h264)
|
{
|
LOG_ERROR("parse_mpp_enc_cfg h264 err\n");
|
return -1;
|
}
|
else
|
{
|
cJSON *child_h264_param = NULL;
|
if (init)
|
child_h264_param = cJSON_GetObjectItem(child_h264, "param_init");
|
else
|
child_h264_param = cJSON_GetObjectItem(child_h264, "param_change");
|
if (child_h264_param)
|
{
|
cJSON *child_h264_gop = cJSON_GetObjectItem(child_h264_param, "gop");
|
if (child_h264_gop)
|
{
|
p->h264_cfg.gop = child_h264_gop->valueint;
|
p->h264_cfg.gop = p->h264_cfg.gop < 1 ? 1 :
|
p->h264_cfg.gop > 1000 ? 1000 :
|
p->h264_cfg.gop;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(0);
|
}
|
cJSON *child_h264_rc_mode = cJSON_GetObjectItem(child_h264_param, "rc_mode");
|
if (child_h264_rc_mode)
|
{
|
p->h264_cfg.rc_mode = strstr(child_h264_rc_mode->valuestring, "cbr") ? MPP_ENC_RC_MODE_CBR :
|
strstr(child_h264_rc_mode->valuestring, "avbr") ? MPP_ENC_RC_MODE_AVBR :
|
strstr(child_h264_rc_mode->valuestring, "vbr") ? MPP_ENC_RC_MODE_VBR :
|
strstr(child_h264_rc_mode->valuestring, "fixqp") ? MPP_ENC_RC_MODE_FIXQP : MPP_ENC_RC_MODE_CBR;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(1);
|
}
|
cJSON *child_h264_framerate = cJSON_GetObjectItem(child_h264_param, "framerate");
|
if (child_h264_framerate)
|
{
|
p->h264_cfg.framerate = child_h264_framerate->valueint;
|
p->h264_cfg.framerate = p->h264_cfg.framerate < MPP_ENC_CFG_MIN_FPS ? MPP_ENC_CFG_MIN_FPS :
|
p->h264_cfg.framerate > MPP_ENC_CFG_MAX_FPS ? MPP_ENC_CFG_MAX_FPS :
|
p->h264_cfg.framerate;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(2);
|
}
|
cJSON *child_h264_range = cJSON_GetObjectItem(child_h264_param, "range");
|
if (child_h264_range)
|
{
|
p->h264_cfg.range = strstr(child_h264_range->valuestring, "limit") ?
|
MPP_FRAME_RANGE_MPEG : MPP_FRAME_RANGE_JPEG;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(3);
|
}
|
cJSON *child_h264_head_each_idr = cJSON_GetObjectItem(child_h264_param, "head_each_idr");
|
if (child_h264_head_each_idr)
|
{
|
p->h264_cfg.head_each_idr = strstr(child_h264_head_each_idr->valuestring, "on") ?
|
MPP_ENC_HEADER_MODE_EACH_IDR : MPP_ENC_HEADER_MODE_DEFAULT;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(4);
|
}
|
cJSON *child_h264_sei = cJSON_GetObjectItem(child_h264_param, "sei");
|
if (child_h264_sei)
|
{
|
p->h264_cfg.sei = strstr(child_h264_sei->valuestring, "SEQ") ? MPP_ENC_SEI_MODE_ONE_SEQ :
|
strstr(child_h264_sei->valuestring, "FRAME") ? MPP_ENC_SEI_MODE_ONE_FRAME :
|
MPP_ENC_SEI_MODE_DISABLE;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(5);
|
}
|
cJSON *child_h264_qp_init = cJSON_GetObjectItem(child_h264_param, "qp_init");
|
if (child_h264_qp_init)
|
{
|
p->h264_cfg.qp.init = child_h264_qp_init->valueint;
|
p->h264_cfg.qp.init = p->h264_cfg.qp.init < 1 ? 1 :
|
p->h264_cfg.qp.init > 51 ? 51 :
|
p->h264_cfg.qp.init;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(6);
|
}
|
cJSON *child_h264_qp_max = cJSON_GetObjectItem(child_h264_param, "qp_max");
|
if (child_h264_qp_max)
|
{
|
p->h264_cfg.qp.max = child_h264_qp_max->valueint;
|
p->h264_cfg.qp.max = p->h264_cfg.qp.max < 8 ? 8 :
|
p->h264_cfg.qp.max > 51 ? 51 :
|
p->h264_cfg.qp.max;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(7);
|
}
|
cJSON *child_h264_qp_min = cJSON_GetObjectItem(child_h264_param, "qp_min");
|
if (child_h264_qp_min)
|
{
|
p->h264_cfg.qp.min = child_h264_qp_min->valueint;
|
p->h264_cfg.qp.min = p->h264_cfg.qp.min < 0 ? 0 :
|
p->h264_cfg.qp.min > 48 ? 48 :
|
p->h264_cfg.qp.min;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(8);
|
}
|
cJSON *child_h264_qp_step = cJSON_GetObjectItem(child_h264_param, "qp_step");
|
if (child_h264_qp_step)
|
{
|
p->h264_cfg.qp.step = child_h264_qp_step->valueint;
|
p->h264_cfg.qp.step = p->h264_cfg.qp.step < 1 ? 1 :
|
p->h264_cfg.qp.step > 51 ? 51 :
|
p->h264_cfg.qp.step;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(9);
|
}
|
cJSON *child_h264_profile = cJSON_GetObjectItem(child_h264_param, "profile");
|
if (child_h264_profile)
|
{
|
p->h264_cfg.profile = child_h264_profile->valueint;
|
if (p->h264_cfg.profile != 66 && p->h264_cfg.profile != 77 && p->h264_cfg.profile != 100)
|
{
|
LOG_WARN("set h264_cfg.profile err %d, set default to %d\n",
|
p->h264_cfg.profile, MPP_ENC_CFG_H264_DEFAULT_PROFILE);
|
p->h264_cfg.profile = MPP_ENC_CFG_H264_DEFAULT_PROFILE;
|
}
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(10);
|
}
|
cJSON *child_h264_cabac_en = cJSON_GetObjectItem(child_h264_param, "cabac_en");
|
if (child_h264_cabac_en)
|
{
|
p->h264_cfg.cabac_en = child_h264_cabac_en->valueint;
|
p->h264_cfg.cabac_en = p->h264_cfg.cabac_en < 0 ? 0 :
|
p->h264_cfg.cabac_en > 1 ? 1 :
|
p->h264_cfg.cabac_en;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(11);
|
}
|
cJSON *child_h264_cabac_idc = cJSON_GetObjectItem(child_h264_param, "cabac_idc");
|
if (child_h264_cabac_idc)
|
{
|
p->h264_cfg.cabac_idc = child_h264_cabac_idc->valueint;
|
p->h264_cfg.cabac_idc = p->h264_cfg.cabac_idc < 0 ? 0 :
|
p->h264_cfg.cabac_idc > 1 ? 1 :
|
p->h264_cfg.cabac_idc;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(12);
|
}
|
cJSON *child_h264_trans_8x8 = cJSON_GetObjectItem(child_h264_param, "trans_8x8");
|
if (child_h264_trans_8x8)
|
{
|
p->h264_cfg.trans_8x8 = child_h264_trans_8x8->valueint;
|
p->h264_cfg.trans_8x8 = p->h264_cfg.trans_8x8 < 0 ? 0 :
|
p->h264_cfg.trans_8x8 > 1 ? 1 :
|
p->h264_cfg.trans_8x8;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(13);
|
}
|
cJSON *child_h264_level = cJSON_GetObjectItem(child_h264_param, "level");
|
if (child_h264_level)
|
{
|
p->h264_cfg.level = child_h264_level->valueint;
|
if (!((p->h264_cfg.level >= 10 && p->h264_cfg.level <= 13) ||
|
(p->h264_cfg.level >= 20 && p->h264_cfg.level <= 22) ||
|
(p->h264_cfg.level >= 30 && p->h264_cfg.level <= 32) ||
|
(p->h264_cfg.level >= 40 && p->h264_cfg.level <= 42) ||
|
(p->h264_cfg.level >= 50 && p->h264_cfg.level <= 52)))
|
{
|
LOG_WARN("set h264_cfg.level err %d, set default to %d\n",
|
p->h264_cfg.level, MPP_ENC_CFG_H264_DEFAULT_LEVEL);
|
p->h264_cfg.level = MPP_ENC_CFG_H264_DEFAULT_LEVEL;
|
}
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(14);
|
}
|
char resolution_name[15] = "";
|
sprintf(resolution_name, "%d*%dp%d",p->width, p->height, fps);
|
cJSON *child_h264_bps = NULL;
|
cJSON *child_h264_force_idr_bps = NULL;
|
cJSON *child_h264_resolution_name = cJSON_GetObjectItem(child_h264_param, resolution_name);
|
if (child_h264_resolution_name) {
|
child_h264_bps = cJSON_GetObjectItem(child_h264_resolution_name, "bps");
|
child_h264_force_idr_bps = cJSON_GetObjectItem(child_h264_resolution_name, "force_idr_bps");
|
} else {
|
child_h264_bps = cJSON_GetObjectItem(child_h264_param, "bps");
|
child_h264_force_idr_bps = cJSON_GetObjectItem(child_h264_param, "force_idr_bps");
|
}
|
|
if (child_h264_bps)
|
{
|
p->h264_cfg.bps = child_h264_bps->valueint;
|
p->h264_cfg.bps = p->h264_cfg.bps < MPP_ENC_CFG_MIN_BPS ? MPP_ENC_CFG_MIN_BPS :
|
p->h264_cfg.bps > MPP_ENC_CFG_MAX_BPS ? MPP_ENC_CFG_MAX_BPS :
|
p->h264_cfg.bps;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(15);
|
}
|
if (child_h264_force_idr_bps)
|
{
|
p->h264_cfg.idr_bps = child_h264_force_idr_bps->valueint;
|
p->h264_cfg.idr_bps = p->h264_cfg.idr_bps < MPP_ENC_CFG_MIN_BPS ? MPP_ENC_CFG_MIN_BPS :
|
p->h264_cfg.idr_bps > MPP_ENC_CFG_MAX_BPS ? MPP_ENC_CFG_MAX_BPS :
|
p->h264_cfg.idr_bps;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(16);
|
}
|
cJSON *child_h264_vi_eln = cJSON_GetObjectItem(child_h264_param, "vi_len");
|
if (child_h264_vi_eln)
|
{
|
p->h264_cfg.vi_len = child_h264_vi_eln->valueint;
|
p->h264_cfg.vi_len = p->h264_cfg.vi_len < 0 ? 0 :
|
p->h264_cfg.vi_len;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(17);
|
}
|
cJSON *child_h264_gop_mode = cJSON_GetObjectItem(child_h264_param, "gop_mode");
|
if (child_h264_gop_mode)
|
{
|
p->h264_cfg.gop_mode = child_h264_gop_mode->valueint;
|
p->h264_cfg.gop_mode = p->h264_cfg.gop_mode < GOP_MODE_NORMALP ? GOP_MODE_NORMALP :
|
p->h264_cfg.gop_mode > GOP_MODE_SMARTP ? GOP_MODE_SMARTP :
|
p->h264_cfg.gop_mode;
|
p->h264_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(18);
|
}
|
|
LOG_INFO("h264_cfg.change:0x%x\n", p->h264_cfg.change);
|
}
|
else
|
{
|
LOG_WARN("no find h264 param_init or param_change\n");
|
}
|
}
|
}
|
break;
|
case MPP_VIDEO_CodingVP8 :
|
{
|
ret = -1;
|
}
|
break;
|
case MPP_VIDEO_CodingHEVC :
|
{
|
cJSON *child_h265 = cJSON_GetObjectItem(child, "h265");
|
if (!child_h265)
|
{
|
LOG_ERROR("parse_mpp_enc_cfg h265 err\n");
|
return -1;
|
}
|
else
|
{
|
cJSON *child_h265_param = NULL;
|
if (init)
|
child_h265_param = cJSON_GetObjectItem(child_h265, "param_init");
|
else
|
child_h265_param = cJSON_GetObjectItem(child_h265, "param_change");
|
if (child_h265_param)
|
{
|
cJSON *child_h265_gop = cJSON_GetObjectItem(child_h265_param, "gop");
|
if (child_h265_gop)
|
{
|
p->h265_cfg.gop = child_h265_gop->valueint;
|
p->h265_cfg.gop = p->h265_cfg.gop < 1 ? 1 :
|
p->h265_cfg.gop > 1000 ? 1000 :
|
p->h265_cfg.gop;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(0);
|
}
|
cJSON *child_h265_rc_mode = cJSON_GetObjectItem(child_h265_param, "rc_mode");
|
if (child_h265_rc_mode)
|
{
|
p->h265_cfg.rc_mode = strstr(child_h265_rc_mode->valuestring, "cbr") ? MPP_ENC_RC_MODE_CBR :
|
strstr(child_h265_rc_mode->valuestring, "avbr") ? MPP_ENC_RC_MODE_AVBR :
|
strstr(child_h265_rc_mode->valuestring, "vbr") ? MPP_ENC_RC_MODE_VBR :
|
strstr(child_h265_rc_mode->valuestring, "fixqp") ? MPP_ENC_RC_MODE_FIXQP : MPP_ENC_RC_MODE_CBR;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(1);
|
}
|
cJSON *child_h265_framerate = cJSON_GetObjectItem(child_h265_param, "framerate");
|
if (child_h265_framerate)
|
{
|
p->h265_cfg.framerate = child_h265_framerate->valueint;
|
p->h265_cfg.framerate = p->h265_cfg.framerate < MPP_ENC_CFG_MIN_FPS ? MPP_ENC_CFG_MIN_FPS :
|
p->h265_cfg.framerate > MPP_ENC_CFG_MAX_FPS ? MPP_ENC_CFG_MAX_FPS :
|
p->h265_cfg.framerate;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(2);
|
}
|
cJSON *child_h265_range = cJSON_GetObjectItem(child_h265_param, "range");
|
if (child_h265_range)
|
{
|
p->h265_cfg.range = strstr(child_h265_range->valuestring, "limit") ?
|
MPP_FRAME_RANGE_MPEG : MPP_FRAME_RANGE_JPEG;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(3);
|
}
|
cJSON *child_h265_head_each_idr = cJSON_GetObjectItem(child_h265_param, "head_each_idr");
|
if (child_h265_head_each_idr)
|
{
|
p->h265_cfg.head_each_idr = strstr(child_h265_head_each_idr->valuestring, "on") ?
|
MPP_ENC_HEADER_MODE_EACH_IDR : MPP_ENC_HEADER_MODE_DEFAULT;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(4);
|
}
|
cJSON *child_h265_sei = cJSON_GetObjectItem(child_h265_param, "sei");
|
if (child_h265_sei)
|
{
|
p->h265_cfg.sei = strstr(child_h265_sei->valuestring, "SEQ") ? MPP_ENC_SEI_MODE_ONE_SEQ :
|
strstr(child_h265_sei->valuestring, "FRAME") ? MPP_ENC_SEI_MODE_ONE_FRAME :
|
MPP_ENC_SEI_MODE_DISABLE;;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(5);
|
}
|
cJSON *child_h265_qp_init = cJSON_GetObjectItem(child_h265_param, "qp_init");
|
if (child_h265_qp_init)
|
{
|
p->h265_cfg.qp.init = child_h265_qp_init->valueint;
|
p->h265_cfg.qp.init = p->h265_cfg.qp.init < 1 ? 1 :
|
p->h265_cfg.qp.init > 51 ? 51 :
|
p->h265_cfg.qp.init;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(6);
|
}
|
cJSON *child_h265_qp_max = cJSON_GetObjectItem(child_h265_param, "qp_max");
|
if (child_h265_qp_max)
|
{
|
p->h265_cfg.qp.max = child_h265_qp_max->valueint;
|
p->h265_cfg.qp.max = p->h265_cfg.qp.max < 8 ? 8 :
|
p->h265_cfg.qp.max > 51 ? 51 :
|
p->h265_cfg.qp.max;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(7);
|
}
|
cJSON *child_h265_qp_min = cJSON_GetObjectItem(child_h265_param, "qp_min");
|
if (child_h265_qp_min)
|
{
|
p->h265_cfg.qp.min = child_h265_qp_min->valueint;
|
p->h265_cfg.qp.min = p->h265_cfg.qp.min < 0 ? 0 :
|
p->h265_cfg.qp.min > 48 ? 48 :
|
p->h265_cfg.qp.min;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(8);
|
}
|
cJSON *child_h265_qp_step = cJSON_GetObjectItem(child_h265_param, "qp_step");
|
if (child_h265_qp_step)
|
{
|
p->h265_cfg.qp.step = child_h265_qp_step->valueint;
|
p->h265_cfg.qp.step = p->h265_cfg.qp.step < 1 ? 1 :
|
p->h265_cfg.qp.step > 51 ? 51 :
|
p->h265_cfg.qp.step;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(9);
|
}
|
cJSON *child_h265_qp_max_i = cJSON_GetObjectItem(child_h265_param, "max_i_qp");
|
if (child_h265_qp_max_i)
|
{
|
p->h265_cfg.qp.max_i_qp = child_h265_qp_max_i->valueint;
|
p->h265_cfg.qp.max_i_qp = p->h265_cfg.qp.max_i_qp < 8 ? 8 :
|
p->h265_cfg.qp.max_i_qp > 51 ? 51 :
|
p->h265_cfg.qp.max_i_qp;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(10);
|
}
|
cJSON *child_h265_qp_min_i = cJSON_GetObjectItem(child_h265_param, "min_i_qp");
|
if (child_h265_qp_min_i)
|
{
|
p->h265_cfg.qp.min_i_qp = child_h265_qp_min_i->valueint;
|
p->h265_cfg.qp.min_i_qp = p->h265_cfg.qp.min_i_qp < 0 ? 0 :
|
p->h265_cfg.qp.min_i_qp > 48 ? 48 :
|
p->h265_cfg.qp.min_i_qp;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(11);
|
}
|
char resolution_name[15] = "";
|
sprintf(resolution_name, "%d*%dp%d",p->width, p->height, fps);
|
cJSON *child_h265_bps = NULL;
|
cJSON *child_h265_force_idr_bps = NULL;
|
cJSON *child_h265_resolution_name = cJSON_GetObjectItem(child_h265_param, resolution_name);
|
if (child_h265_resolution_name) {
|
child_h265_bps = cJSON_GetObjectItem(child_h265_resolution_name, "bps");
|
child_h265_force_idr_bps = cJSON_GetObjectItem(child_h265_resolution_name, "force_idr_bps");
|
} else {
|
child_h265_bps = cJSON_GetObjectItem(child_h265_param, "bps");
|
child_h265_force_idr_bps = cJSON_GetObjectItem(child_h265_param, "force_idr_bps");
|
}
|
|
if (child_h265_bps)
|
{
|
p->h265_cfg.bps = child_h265_bps->valueint;
|
p->h265_cfg.bps = p->h265_cfg.bps < MPP_ENC_CFG_MIN_BPS ? MPP_ENC_CFG_MIN_BPS :
|
p->h265_cfg.bps > MPP_ENC_CFG_MAX_BPS ? MPP_ENC_CFG_MAX_BPS :
|
p->h265_cfg.bps;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(12);
|
}
|
if (child_h265_force_idr_bps)
|
{
|
p->h265_cfg.idr_bps = child_h265_force_idr_bps->valueint;
|
p->h265_cfg.idr_bps = p->h265_cfg.idr_bps < MPP_ENC_CFG_MIN_BPS ? MPP_ENC_CFG_MIN_BPS :
|
p->h265_cfg.idr_bps > MPP_ENC_CFG_MAX_BPS ? MPP_ENC_CFG_MAX_BPS :
|
p->h265_cfg.idr_bps;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(13);
|
}
|
cJSON *child_h265_vi_eln = cJSON_GetObjectItem(child_h265_param, "vi_len");
|
if (child_h265_vi_eln)
|
{
|
p->h265_cfg.vi_len = child_h265_vi_eln->valueint;
|
p->h265_cfg.vi_len = p->h265_cfg.vi_len < 0 ? 0 :
|
p->h265_cfg.vi_len;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(14);
|
}
|
cJSON *child_h265_gop_mode = cJSON_GetObjectItem(child_h265_param, "gop_mode");
|
if (child_h265_gop_mode)
|
{
|
p->h265_cfg.gop_mode = child_h265_gop_mode->valueint;
|
p->h265_cfg.gop_mode = p->h265_cfg.gop_mode < GOP_MODE_NORMALP ? GOP_MODE_NORMALP :
|
p->h265_cfg.gop_mode > GOP_MODE_SMARTP ? GOP_MODE_SMARTP :
|
p->h265_cfg.gop_mode;
|
p->h265_cfg.change |= MPP_ENC_CFG_CHANGE_BIT(15);
|
}
|
|
LOG_INFO("h265_cfg.change:0x%x\n", p->h265_cfg.change);
|
}
|
else
|
{
|
LOG_WARN("no find h265 param_init or param_change\n");
|
}
|
}
|
}
|
break;
|
case 0:
|
break;
|
default :
|
{
|
LOG_ERROR("unsupport encoder coding type %d\n", p->type);
|
ret = -1;
|
}
|
break;
|
}
|
|
|
#if MPP_ENC_OSD_ENABLE
|
cJSON *child_osd = cJSON_GetObjectItem(child, "osd");
|
if (!child_osd)
|
{
|
LOG_INFO("no osd info\n");
|
}
|
else
|
{
|
cJSON *child_osd_enable = cJSON_GetObjectItem(child_osd, "enable");
|
if (child_osd_enable)
|
{
|
p->osd_enable = strstr(child_osd_enable->valuestring, "on") ?
|
true : false;
|
}
|
cJSON *child_osd_count = cJSON_GetObjectItem(child_osd, "count");
|
if (child_osd_count)
|
{
|
p->osd_count = child_osd_count->valueint;
|
p->osd_count = p->osd_count < 0 ? 0 :
|
p->osd_count > OSD_REGIONS_CNT ? OSD_REGIONS_CNT :
|
p->osd_count;
|
}
|
cJSON *child_osd_plt_user = cJSON_GetObjectItem(child_osd, "plt_user");
|
if (child_osd_plt_user)
|
{
|
p->osd_plt_user = child_osd_plt_user->valueint;
|
}
|
|
char osd_name[6] = "osd_0";
|
for (int i = 0; i < p->osd_count; i ++)
|
{
|
osd_name[4] = i + 48;
|
cJSON *child_osd_index = cJSON_GetObjectItem(child_osd, osd_name);
|
if (child_osd_index)
|
{
|
p->osd_cfg[i].set_ok = true;
|
cJSON *child_osd_index_type = cJSON_GetObjectItem(child_osd_index, "type");;
|
if (child_osd_index_type)
|
{
|
p->osd_cfg[i].type = strstr(child_osd_index_type->valuestring, "picture") ?
|
OSD_REGION_TYPE_PICTURE : OSD_REGION_TYPE_PICTURE;
|
}
|
cJSON *child_osd_index_enable = cJSON_GetObjectItem(child_osd_index, "enable");
|
if (child_osd_index_enable)
|
{
|
p->osd_cfg[i].enable = strstr(child_osd_index_enable->valuestring, "on") ?
|
true : false;
|
}
|
|
char resolution_name[10] = "";
|
sprintf(resolution_name, "%d*%d",p->width, p->height);
|
cJSON *child_osd_resolution_name = cJSON_GetObjectItem(child_osd_index, resolution_name);
|
if (!child_osd_resolution_name) {
|
child_osd_resolution_name = cJSON_GetObjectItem(child_osd_index, "common");
|
}
|
if (child_osd_resolution_name)
|
{
|
cJSON *child_osd_index_path = cJSON_GetObjectItem(child_osd_resolution_name, "path");
|
if (child_osd_index_path)
|
{
|
if (strlen(child_osd_index_path->valuestring) >
|
(MPP_ENC_OSD_IMAGE_PATH_LEN - 1))
|
{
|
LOG_ERROR("osd img path:%s, the name too long\n",
|
child_osd_index_path->valuestring);
|
p->osd_cfg[i].enable = false;
|
p->osd_cfg[i].set_ok = false;
|
}
|
else
|
{
|
sprintf(p->osd_cfg[i].image_path, "%s",
|
child_osd_index_path->valuestring);
|
}
|
}
|
cJSON *child_osd_index_start_x = cJSON_GetObjectItem(child_osd_resolution_name, "start_x");
|
if (child_osd_index_start_x)
|
{
|
p->osd_cfg[i].start_x = UPALIGNTO16((int)(child_osd_index_start_x->valuedouble * p->width));
|
}
|
cJSON *child_osd_index_start_y = cJSON_GetObjectItem(child_osd_resolution_name, "start_y");
|
if (child_osd_index_start_y)
|
{
|
p->osd_cfg[i].start_y = UPALIGNTO16((int)(child_osd_index_start_y->valuedouble * p->height));
|
}
|
}
|
else
|
{
|
LOG_INFO("no such resolution_name:%s && common path\n", resolution_name);
|
}
|
}
|
else
|
{
|
LOG_INFO("no such osd %s\n", osd_name);
|
}
|
}
|
}
|
#endif
|
|
return ret;
|
}
|
|
static MPP_RET mpp_enc_bps_set(MpiEncTestData *p, RK_U32 bps)
|
{
|
MPP_RET ret = MPP_OK;
|
|
switch (p->type)
|
{
|
case MPP_VIDEO_CodingMJPEG:
|
{
|
switch (p->mjpeg_cfg.rc_mode)
|
{
|
case MPP_ENC_RC_MODE_FIXQP :
|
{
|
/* do not set bps on fix qp mode */
|
} break;
|
case MPP_ENC_RC_MODE_CBR :
|
{
|
/* CBR mode has narrow bound */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", bps * 15 / 16);
|
p->mjpeg_cfg.frc_bps = bps;
|
}
|
break;
|
case MPP_ENC_RC_MODE_VBR :
|
{
|
/* CBR mode has wide bound */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", bps * 1 / 16);
|
p->mjpeg_cfg.frc_bps = bps;
|
}
|
break;
|
default :
|
{
|
LOG_ERROR("unsupport encoder rc mode %d\n", p->mjpeg_cfg.rc_mode);
|
}
|
break;
|
}
|
}
|
break;
|
case MPP_VIDEO_CodingAVC:
|
{
|
switch (p->h264_cfg.rc_mode)
|
{
|
case MPP_ENC_RC_MODE_FIXQP :
|
{
|
/* do not set bps on fix qp mode */
|
} break;
|
case MPP_ENC_RC_MODE_CBR :
|
{
|
/* CBR mode has narrow bound */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", bps * 15 / 16);
|
}
|
break;
|
case MPP_ENC_RC_MODE_VBR :
|
{
|
/* VBR mode has wide bound */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", bps * 1 / 16);
|
}
|
break;
|
case MPP_ENC_RC_MODE_AVBR :
|
{
|
/* AVBR mode min is mean the silence bps, do not too low */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", bps * 1 / 4);
|
}
|
break;
|
default :
|
{
|
LOG_ERROR("unsupport encoder rc mode %d\n", p->h264_cfg.rc_mode);
|
}
|
break;
|
}
|
}
|
break;
|
case MPP_VIDEO_CodingHEVC:
|
{
|
switch (p->h265_cfg.rc_mode)
|
{
|
case MPP_ENC_RC_MODE_FIXQP :
|
{
|
/* do not set bps on fix qp mode */
|
} break;
|
case MPP_ENC_RC_MODE_CBR :
|
{
|
/* CBR mode has narrow bound */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", bps * 15 / 16);
|
}
|
break;
|
case MPP_ENC_RC_MODE_VBR :
|
{
|
/* CBR mode has wide bound */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", bps * 1 / 16);
|
}
|
break;
|
case MPP_ENC_RC_MODE_AVBR :
|
{
|
/* AVBR mode min is mean the silence bps, do not too low */
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_target", bps);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_max", bps * 17 / 16);
|
mpp_enc_cfg_set_s32(p->cfg, "rc:bps_min", bps * 1 / 4);
|
}
|
break;
|
default :
|
{
|
LOG_ERROR("unsupport encoder rc mode %d\n", p->h265_cfg.rc_mode);
|
}
|
break;
|
}
|
}
|
break;
|
}
|
return ret;
|
}
|
|
static MPP_RET mpi_enc_gen_ref_cfg(MppEncRefCfg ref, MpiEncGopMode gop_mode)
|
{
|
MppEncRefLtFrmCfg lt_ref[4];
|
MppEncRefStFrmCfg st_ref[16];
|
RK_S32 lt_cnt = 0;
|
RK_S32 st_cnt = 0;
|
MPP_RET ret = MPP_OK;
|
|
memset(<_ref, 0, sizeof(lt_ref));
|
memset(&st_ref, 0, sizeof(st_ref));
|
|
switch (gop_mode) {
|
case GOP_MODE_TSVC4: {
|
// tsvc4
|
// /-> P1 /-> P3 /-> P5 /-> P7
|
// / / / /
|
// //--------> P2 //--------> P6
|
// // //
|
// ///---------------------> P4
|
// ///
|
// P0 ------------------------------------------------> P8
|
lt_cnt = 1;
|
|
/* set 8 frame lt-ref gap */
|
lt_ref[0].lt_idx = 0;
|
lt_ref[0].temporal_id = 0;
|
lt_ref[0].ref_mode = REF_TO_PREV_LT_REF;
|
lt_ref[0].lt_gap = 8;
|
lt_ref[0].lt_delay = 0;
|
|
st_cnt = 9;
|
/* set tsvc4 st-ref struct */
|
/* st 0 layer 0 - ref */
|
st_ref[0].is_non_ref = 0;
|
st_ref[0].temporal_id = 0;
|
st_ref[0].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[0].ref_arg = 0;
|
st_ref[0].repeat = 0;
|
/* st 1 layer 3 - non-ref */
|
st_ref[1].is_non_ref = 1;
|
st_ref[1].temporal_id = 3;
|
st_ref[1].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[1].ref_arg = 0;
|
st_ref[1].repeat = 0;
|
/* st 2 layer 2 - ref */
|
st_ref[2].is_non_ref = 0;
|
st_ref[2].temporal_id = 2;
|
st_ref[2].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[2].ref_arg = 0;
|
st_ref[2].repeat = 0;
|
/* st 3 layer 3 - non-ref */
|
st_ref[3].is_non_ref = 1;
|
st_ref[3].temporal_id = 3;
|
st_ref[3].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[3].ref_arg = 0;
|
st_ref[3].repeat = 0;
|
/* st 4 layer 1 - ref */
|
st_ref[4].is_non_ref = 0;
|
st_ref[4].temporal_id = 1;
|
st_ref[4].ref_mode = REF_TO_PREV_LT_REF;
|
st_ref[4].ref_arg = 0;
|
st_ref[4].repeat = 0;
|
/* st 5 layer 3 - non-ref */
|
st_ref[5].is_non_ref = 1;
|
st_ref[5].temporal_id = 3;
|
st_ref[5].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[5].ref_arg = 0;
|
st_ref[5].repeat = 0;
|
/* st 6 layer 2 - ref */
|
st_ref[6].is_non_ref = 0;
|
st_ref[6].temporal_id = 2;
|
st_ref[6].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[6].ref_arg = 0;
|
st_ref[6].repeat = 0;
|
/* st 7 layer 3 - non-ref */
|
st_ref[7].is_non_ref = 1;
|
st_ref[7].temporal_id = 3;
|
st_ref[7].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[7].ref_arg = 0;
|
st_ref[7].repeat = 0;
|
/* st 8 layer 0 - ref */
|
st_ref[8].is_non_ref = 0;
|
st_ref[8].temporal_id = 0;
|
st_ref[8].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[8].ref_arg = 0;
|
st_ref[8].repeat = 0;
|
} break;
|
case GOP_MODE_TSVC3: {
|
// tsvc3
|
// /-> P1 /-> P3
|
// / /
|
// //--------> P2
|
// //
|
// P0/---------------------> P4
|
lt_cnt = 0;
|
|
st_cnt = 5;
|
/* set tsvc4 st-ref struct */
|
/* st 0 layer 0 - ref */
|
st_ref[0].is_non_ref = 0;
|
st_ref[0].temporal_id = 0;
|
st_ref[0].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[0].ref_arg = 0;
|
st_ref[0].repeat = 0;
|
/* st 1 layer 2 - non-ref */
|
st_ref[1].is_non_ref = 1;
|
st_ref[1].temporal_id = 2;
|
st_ref[1].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[1].ref_arg = 0;
|
st_ref[1].repeat = 0;
|
/* st 2 layer 1 - ref */
|
st_ref[2].is_non_ref = 0;
|
st_ref[2].temporal_id = 1;
|
st_ref[2].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[2].ref_arg = 0;
|
st_ref[2].repeat = 0;
|
/* st 3 layer 2 - non-ref */
|
st_ref[3].is_non_ref = 1;
|
st_ref[3].temporal_id = 2;
|
st_ref[3].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[3].ref_arg = 0;
|
st_ref[3].repeat = 0;
|
/* st 4 layer 0 - ref */
|
st_ref[4].is_non_ref = 0;
|
st_ref[4].temporal_id = 0;
|
st_ref[4].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[4].ref_arg = 0;
|
st_ref[4].repeat = 0;
|
} break;
|
case GOP_MODE_TSVC2: {
|
// tsvc2
|
// /-> P1
|
// /
|
// P0--------> P2
|
lt_cnt = 0;
|
|
st_cnt = 3;
|
/* set tsvc4 st-ref struct */
|
/* st 0 layer 0 - ref */
|
st_ref[0].is_non_ref = 0;
|
st_ref[0].temporal_id = 0;
|
st_ref[0].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[0].ref_arg = 0;
|
st_ref[0].repeat = 0;
|
/* st 1 layer 2 - non-ref */
|
st_ref[1].is_non_ref = 1;
|
st_ref[1].temporal_id = 1;
|
st_ref[1].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[1].ref_arg = 0;
|
st_ref[1].repeat = 0;
|
/* st 2 layer 1 - ref */
|
st_ref[2].is_non_ref = 0;
|
st_ref[2].temporal_id = 0;
|
st_ref[2].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[2].ref_arg = 0;
|
st_ref[2].repeat = 0;
|
} break;
|
default : {
|
LOG_ERROR("unsupport gop mode %d\n", gop_mode);
|
return MPP_NOK;
|
} break;
|
}
|
|
if (lt_cnt || st_cnt) {
|
ret = mpp_enc_ref_cfg_set_cfg_cnt(ref, lt_cnt, st_cnt);
|
|
if (lt_cnt)
|
ret = mpp_enc_ref_cfg_add_lt_cfg(ref, lt_cnt, lt_ref);
|
|
if (st_cnt)
|
ret = mpp_enc_ref_cfg_add_st_cfg(ref, st_cnt, st_ref);
|
|
/* check and get dpb size */
|
ret = mpp_enc_ref_cfg_check(ref);
|
}
|
|
return ret;
|
}
|
|
static MPP_RET mpi_enc_gen_smart_gop_ref_cfg(MppEncRefCfg ref, RK_S32 gop_len, RK_S32 vi_len)
|
{
|
MppEncRefLtFrmCfg lt_ref[4];
|
MppEncRefStFrmCfg st_ref[16];
|
RK_S32 lt_cnt = 1;
|
RK_S32 st_cnt = 8;
|
RK_S32 pos = 0;
|
MPP_RET ret = MPP_OK;
|
|
memset(<_ref, 0, sizeof(lt_ref));
|
memset(&st_ref, 0, sizeof(st_ref));
|
|
ret = mpp_enc_ref_cfg_set_cfg_cnt(ref, lt_cnt, st_cnt);
|
|
/* set 8 frame lt-ref gap */
|
lt_ref[0].lt_idx = 0;
|
lt_ref[0].temporal_id = 0;
|
lt_ref[0].ref_mode = REF_TO_PREV_LT_REF;
|
lt_ref[0].lt_gap = gop_len;
|
lt_ref[0].lt_delay = 0;
|
|
ret = mpp_enc_ref_cfg_add_lt_cfg(ref, 1, lt_ref);
|
|
/* st 0 layer 0 - ref */
|
st_ref[pos].is_non_ref = 0;
|
st_ref[pos].temporal_id = 0;
|
st_ref[pos].ref_mode = REF_TO_PREV_INTRA;
|
st_ref[pos].ref_arg = 0;
|
st_ref[pos].repeat = 0;
|
pos++;
|
|
/* st 1 layer 1 - non-ref */
|
if (vi_len > 1) {
|
st_ref[pos].is_non_ref = 0;
|
st_ref[pos].temporal_id = 1;
|
st_ref[pos].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[pos].ref_arg = 0;
|
st_ref[pos].repeat = vi_len - 2;
|
//LOG_ERROR("pos:%d vi_len= %d gop_len=%d st_ref[pos].repeat=%d\n", pos, vi_len, gop_len, st_ref[pos].repeat);
|
pos++;
|
}
|
|
st_ref[pos].is_non_ref = 0;
|
st_ref[pos].temporal_id = 0;
|
st_ref[pos].ref_mode = REF_TO_PREV_INTRA;
|
st_ref[pos].ref_arg = 0;
|
st_ref[pos].repeat = 0;
|
pos++;
|
|
ret = mpp_enc_ref_cfg_add_st_cfg(ref, pos, st_ref);
|
|
/* check and get dpb size */
|
ret = mpp_enc_ref_cfg_check(ref);
|
|
return ret;
|
}
|
|
static MPP_RET mpp_set_ref_param(MpiEncTestData *p, MpiEncGopMode gop_mode)
|
{
|
MPP_RET ret = MPP_OK;
|
MppEncRefCfg ref = NULL;
|
MppApi *mpi = p->mpi;
|
MppCtx ctx = p->ctx;
|
|
if (p->type != MPP_VIDEO_CodingAVC && p->type != MPP_VIDEO_CodingHEVC) {
|
LOG_ERROR("MPP Encoder: encode:%d not support set ref param\n", p->type);
|
return ret;
|
}
|
|
RK_U32 gop_len = (p->type == MPP_VIDEO_CodingAVC ? p->h264_cfg.gop : p->h265_cfg.gop);
|
RK_U32 vi_len = (p->type == MPP_VIDEO_CodingAVC ? p->h264_cfg.vi_len : p->h265_cfg.vi_len);
|
|
if (gop_mode <= GOP_MODE_SMARTP && gop_mode > GOP_MODE_NORMALP) {
|
if (mpp_enc_ref_cfg_init(&ref)) {
|
LOG_ERROR("MPP Encoder: ref cfg init failed!\n");
|
goto RET;
|
}
|
if (gop_mode == GOP_MODE_SMARTP) {
|
if (mpi_enc_gen_smart_gop_ref_cfg(ref, gop_len, vi_len)) {
|
LOG_ERROR("MPP Encoder: ref cfg gen smart gop failed!\n");
|
goto RET;
|
}
|
} else { // tsvc for h264
|
if (p->type != MPP_VIDEO_CodingAVC) {
|
LOG_ERROR("MPP Encoder: encode:%d not support gop_mode:%d\n", p->type, gop_mode);
|
return ret;
|
}
|
|
if (mpi_enc_gen_ref_cfg(ref, gop_mode)) {
|
LOG_ERROR("MPP Encoder: ref cfg gen failed!\n");
|
goto RET;
|
}
|
|
}
|
ret = mpi->control(ctx, MPP_ENC_SET_REF_CFG, ref);
|
if (ret) {
|
LOG_ERROR("mpi control enc set ref cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
|
if (gop_mode == GOP_MODE_NORMALP || gop_mode == GOP_MODE_SMARTP) {
|
if (gop_mode == GOP_MODE_NORMALP)
|
ret = mpi->control(ctx, MPP_ENC_SET_REF_CFG, NULL);
|
ret |= mpp_enc_cfg_set_s32(p->cfg, "rc:gop", gop_len);
|
if (ret) {
|
LOG_ERROR("MPP Encoder: gop mode: cfg set s32 failed ret %d\n", ret);
|
goto RET;
|
}
|
if (mpi->control(ctx, MPP_ENC_SET_CFG, p->cfg) != 0) {
|
LOG_ERROR("MPP Encoder: change gop cfg failed!\n");
|
goto RET;
|
}
|
}
|
|
RET:
|
if (ref)
|
mpp_enc_ref_cfg_deinit(&ref);
|
return ret;
|
}
|
|
//cfg sei/change the sei cfg
|
static MPP_RET mpp_enc_set_sei(MpiEncTestData *p, MppEncSeiMode mode)
|
{
|
MPP_RET ret = MPP_NOK;
|
|
if (p->type == MPP_VIDEO_CodingAVC) {
|
p->h264_cfg.sei = mode;
|
} else if (p->type == MPP_VIDEO_CodingHEVC) {
|
p->h265_cfg.sei = mode;
|
} else if (p->type == MPP_VIDEO_CodingMJPEG) {
|
p->mjpeg_cfg.sei = mode;
|
} else {
|
LOG_ERROR("this type:%d not suppor set sei!\n", p->type);
|
return ret;
|
}
|
ret = p->mpi->control(p->ctx, MPP_ENC_SET_SEI_CFG, &mode);
|
if (ret) {
|
LOG_ERROR("mpi control enc set sei cfg failed ret %d\n", ret);
|
return ret;
|
}
|
LOG_ERROR("this type:%d set sei:%d!\n", p->type, mode);
|
|
return ret;
|
}
|
|
//send sei data, need call this func every frame
|
static MPP_RET mpp_enc_send_sei(MpiEncTestData *p, MppMeta meta, char *sei_data)
|
{
|
MPP_RET ret = MPP_NOK;
|
|
if ((p->type == MPP_VIDEO_CodingAVC && p->h264_cfg.sei) ||
|
(p->type == MPP_VIDEO_CodingHEVC && p->h265_cfg.sei) ||
|
(p->type == MPP_VIDEO_CodingMJPEG && p->mjpeg_cfg.sei)) {
|
p->user_data.pdata = sei_data;
|
p->user_data.len = strlen(sei_data) + 1;
|
LOG_ERROR("this type:%d set sei:%s!\n", p->type, p->user_data.pdata);
|
return mpp_meta_set_ptr(meta, KEY_USER_DATA, &p->user_data);
|
}
|
|
return ret;
|
}
|
|
#if TEST_MPP_SEI
|
static MPP_RET mpp_test_send_user_data(MpiEncTestData *p, MppFrame frame)
|
{
|
MppMeta meta = NULL;
|
meta = mpp_frame_get_meta(frame);
|
if (!access("/tmp/sei1", 0)) {
|
system("rm /tmp/sei1");
|
mpp_enc_set_sei(p, MPP_ENC_SEI_MODE_ONE_SEQ);
|
mpp_enc_send_sei(p, meta, "lxh-test-seq-123456");
|
} else if (!access("/tmp/sei2", 0)) {
|
//system("rm /tmp/sei2");
|
mpp_enc_set_sei(p, MPP_ENC_SEI_MODE_ONE_FRAME);
|
mpp_enc_send_sei(p, meta, "lxh-test-frame-123456");
|
}
|
if (!access("/tmp/sei3", 0)) {
|
system("rm /tmp/sei2");
|
system("rm /tmp/sei3");
|
mpp_enc_set_sei(p, MPP_ENC_SEI_MODE_DISABLE);
|
}
|
}
|
#endif
|
|
static MPP_RET mpp_enc_cfg_set(MpiEncTestData *p, bool init)
|
{
|
MPP_RET ret;
|
MppApi *mpi;
|
MppCtx ctx;
|
MppEncCfg cfg;
|
|
if (NULL == p)
|
return MPP_ERR_NULL_PTR;
|
if (p->type == 0) {
|
#if MPP_ENC_OSD_ENABLE
|
mpp_osd_default_set(p);
|
#endif
|
return MPP_OK;
|
}
|
|
mpi_get_env_u32("enc_version", &p->enc_version, RK_MPP_VERSION_DEFAULT);
|
|
char *full_range = getenv("ENABLE_FULL_RANGE");
|
if (full_range)
|
{
|
int need_full_range = atoi(full_range);
|
p->h264_cfg.range = need_full_range ? MPP_FRAME_RANGE_JPEG : MPP_FRAME_RANGE_MPEG;
|
p->h265_cfg.range = need_full_range ? MPP_FRAME_RANGE_JPEG : MPP_FRAME_RANGE_MPEG;
|
LOG_DEBUG("mpp full_range use env setting:%d \n", need_full_range);
|
}
|
|
mpi = p->mpi;
|
ctx = p->ctx;
|
cfg = p->cfg;
|
|
if (init)
|
{
|
mpp_enc_cfg_set_s32(cfg, "prep:width", p->width);
|
mpp_enc_cfg_set_s32(cfg, "prep:height", p->height);
|
mpp_enc_cfg_set_s32(cfg, "prep:hor_stride", p->hor_stride);
|
mpp_enc_cfg_set_s32(cfg, "prep:ver_stride", p->ver_stride);
|
if (!(p->type == MPP_VIDEO_CodingMJPEG && p->common_cfg.rotation == 2))
|
mpp_enc_cfg_set_s32(cfg, "prep:rotation", p->common_cfg.rotation);
|
}
|
if (init || (p->common_cfg.change & BIT(0)))
|
{
|
p->fmt |= p->common_cfg.fbc;
|
mpp_enc_cfg_set_s32(cfg, "prep:format", p->fmt);
|
}
|
|
if (p->common_cfg.split_mode && (init || (p->common_cfg.change & BIT(1))))
|
{
|
mpp_enc_cfg_set_u32(cfg, "split:mode", p->common_cfg.split_mode);
|
}
|
|
if (p->common_cfg.split_mode && (init || (p->common_cfg.change & BIT(2))))
|
{
|
mpp_enc_cfg_set_u32(cfg, "split:arg", p->common_cfg.split_arg);
|
}
|
if (init || (p->common_cfg.change & BIT(5)))
|
{
|
mpp_try_count_set(p);
|
}
|
|
p->frc_up_frm_set = MPP_FRC_UP_FRM_SET_INIT; // when continues_frm up to this num which can turn up the frame rate
|
|
mpp_enc_cfg_set_s32(cfg, "codec:type", p->type);
|
switch (p->type)
|
{
|
case MPP_VIDEO_CodingMJPEG :
|
{
|
if (!p->mjpeg_cfg.qfactor && (init || (p->mjpeg_cfg.change & BIT(0))))
|
{
|
mpp_enc_cfg_set_s32(cfg, "jpeg:quant", p->mjpeg_cfg.quant);
|
p->mjpeg_cfg.frc_quant = p->mjpeg_cfg.quant;
|
}
|
if (p->mjpeg_cfg.qfactor && (init || (p->mjpeg_cfg.change & BIT(2))))
|
{
|
mpp_enc_cfg_set_s32(cfg, "jpeg:q_factor", p->mjpeg_cfg.qfactor);
|
p->mjpeg_cfg.frc_qfactor = p->mjpeg_cfg.qfactor;
|
}
|
if (p->mjpeg_cfg.qfactor && (init || (p->mjpeg_cfg.change & BIT(3))))
|
mpp_enc_cfg_set_s32(cfg, "jpeg:qf_min", p->mjpeg_cfg.qfactor_min);
|
if (p->mjpeg_cfg.qfactor && (init || (p->mjpeg_cfg.change & BIT(4))))
|
mpp_enc_cfg_set_s32(cfg, "jpeg:qf_max", p->mjpeg_cfg.qfactor_max);
|
if (init || (p->mjpeg_cfg.change & BIT(5)))
|
mpp_enc_cfg_set_s32(cfg, "rc:gop", p->mjpeg_cfg.gop);
|
if (init || (p->mjpeg_cfg.change & BIT(6)))
|
mpp_enc_cfg_set_s32(cfg, "rc:mode", p->mjpeg_cfg.rc_mode);
|
if (init || (p->mjpeg_cfg.change & BIT(7)))
|
{
|
mpp_enc_bps_set(p, p->mjpeg_cfg.bps);
|
}
|
if (init || (p->mjpeg_cfg.change & BIT(8)))
|
{
|
/* setup default parameter */
|
if (p->mjpeg_cfg.framerate)
|
{
|
LOG_WARN("warnning!!!mjpeg_cfg fps set %d to %d, if not want to change fps "
|
"do not set framerate at file of mpp_enc_cfg.conf \n",
|
p->fps, p->mjpeg_cfg.framerate);
|
}
|
else
|
{
|
p->mjpeg_cfg.framerate = p->fps;
|
}
|
p->fps_in_den = 1;
|
p->fps_in_num = p->fps;
|
p->fps_out_den = 1;
|
p->fps_out_num = p->mjpeg_cfg.framerate;
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_flex", p->fps_in_flex);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_num", p->fps_in_num);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_denorm", p->fps_in_den);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_flex", p->fps_out_flex);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_num", p->fps_out_num);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_denorm", p->fps_out_den);
|
p->fps = p->mjpeg_cfg.framerate;
|
}
|
if (init || (p->mjpeg_cfg.change & BIT(11)))
|
{
|
ret = mpi->control(ctx, MPP_ENC_SET_SEI_CFG, &p->mjpeg_cfg.sei);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set sei cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
|
}
|
break;
|
case MPP_VIDEO_CodingAVC :
|
{
|
if (init || (p->h264_cfg.change & BIT(0)))
|
{
|
p->h264_cfg.gop_normal = p->h264_cfg.gop;
|
if (init && p->common_cfg.force_idr_count * p->common_cfg.force_idr_period)
|
{
|
mpp_enc_cfg_set_s32(cfg, "rc:gop", p->common_cfg.force_idr_period);
|
p->h264_cfg.gop = p->common_cfg.force_idr_period;
|
}
|
else
|
{
|
mpp_enc_cfg_set_s32(cfg, "rc:gop", p->h264_cfg.gop);
|
}
|
}
|
if (init || (p->h264_cfg.change & BIT(1)))
|
mpp_enc_cfg_set_s32(cfg, "rc:mode", p->h264_cfg.rc_mode);
|
if (init || (p->h264_cfg.change & BIT(2)))
|
{
|
if (p->h264_cfg.framerate)
|
{
|
LOG_WARN("warnning!!!h264_cfg fps set %d to %d, if not want to change fps "
|
"do not set framerate at file of mpp_enc_cfg.conf \n",
|
p->fps, p->h264_cfg.framerate);
|
}
|
else
|
{
|
p->h264_cfg.framerate = p->fps;
|
}
|
/* setup default parameter */
|
p->fps_in_den = 1;
|
p->fps_in_num = p->fps;
|
p->fps_out_den = 1;
|
p->fps_out_num = p->h264_cfg.framerate;
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_flex", p->fps_in_flex);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_num", p->fps_in_num);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_denorm", p->fps_in_den);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_flex", p->fps_out_flex);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_num", p->fps_out_num);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_denorm", p->fps_out_den);
|
p->fps = p->h264_cfg.framerate;
|
}
|
if (init || (p->h264_cfg.change & BIT(3)))
|
{
|
ret = mpp_enc_cfg_set_s32(cfg, "prep:range", p->h264_cfg.range);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set prep:range failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
|
if (init || (p->h264_cfg.change & BIT(4)))
|
{
|
ret = mpi->control(ctx, MPP_ENC_SET_HEADER_MODE, &p->h264_cfg.head_each_idr);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set codec cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
if (init || (p->h264_cfg.change & BIT(5)))
|
{
|
ret = mpi->control(ctx, MPP_ENC_SET_SEI_CFG, &p->h264_cfg.sei);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set sei cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
if (init || (p->h264_cfg.change & BIT(6)))
|
mpp_enc_cfg_set_s32(cfg, "h264:qp_init", p->h264_cfg.qp.init);
|
if (init || (p->h264_cfg.change & BIT(7)))
|
mpp_enc_cfg_set_s32(cfg, "h264:qp_max", p->h264_cfg.qp.max);
|
if (init || (p->h264_cfg.change & BIT(8)))
|
mpp_enc_cfg_set_s32(cfg, "h264:qp_min", p->h264_cfg.qp.min);
|
if (init || (p->h264_cfg.change & BIT(9)))
|
mpp_enc_cfg_set_s32(cfg, "h264:qp_step", p->h264_cfg.qp.step);
|
if (init || (p->h264_cfg.change & BIT(10)))
|
mpp_enc_cfg_set_s32(cfg, "h264:profile", p->h264_cfg.profile);
|
if (init || (p->h264_cfg.change & BIT(11)))
|
mpp_enc_cfg_set_s32(cfg, "h264:cabac_en", p->h264_cfg.cabac_en);
|
if (init || (p->h264_cfg.change & BIT(12)))
|
mpp_enc_cfg_set_s32(cfg, "h264:cabac_idc", p->h264_cfg.cabac_idc);
|
if (init || (p->h264_cfg.change & BIT(13)))
|
mpp_enc_cfg_set_s32(cfg, "h264:trans8x8", p->h264_cfg.trans_8x8);
|
if (init || (p->h264_cfg.change & BIT(14)))
|
mpp_enc_cfg_set_s32(cfg, "h264:level", p->h264_cfg.level);
|
|
if (init || (p->h264_cfg.change & BIT(15)))
|
{
|
if (init && p->h264_cfg.idr_bps)
|
{
|
mpp_enc_bps_set(p, p->h264_cfg.idr_bps);
|
}
|
else
|
{
|
mpp_enc_bps_set(p, p->h264_cfg.bps);
|
}
|
}
|
if (init || (p->h264_cfg.change & BIT(18)))
|
{
|
mpp_set_ref_param(p, p->h264_cfg.gop_mode);
|
}
|
|
}
|
break;
|
case MPP_VIDEO_CodingVP8 :
|
{
|
} break;
|
case MPP_VIDEO_CodingHEVC :
|
{
|
if (init || (p->h265_cfg.change & BIT(0)))
|
{
|
p->h265_cfg.gop_normal = p->h265_cfg.gop;
|
if (init && p->common_cfg.force_idr_count * p->common_cfg.force_idr_period)
|
{
|
mpp_enc_cfg_set_s32(cfg, "rc:gop", p->common_cfg.force_idr_period);
|
p->h265_cfg.gop = p->common_cfg.force_idr_period;
|
}
|
else
|
{
|
mpp_enc_cfg_set_s32(cfg, "rc:gop", p->h265_cfg.gop);
|
}
|
}
|
if (init || (p->h265_cfg.change & BIT(1)))
|
mpp_enc_cfg_set_s32(cfg, "rc:mode", p->h265_cfg.rc_mode);
|
if (init || (p->h265_cfg.change & BIT(2)))
|
{
|
if (p->h265_cfg.framerate)
|
{
|
LOG_WARN("warnning!!!h265_cfg fps set %d to %d, if not want to change fps "
|
"do not set framerate at file of mpp_enc_cfg.conf \n",
|
p->fps, p->h265_cfg.framerate);
|
}
|
else
|
{
|
p->h265_cfg.framerate = p->fps;
|
}
|
/* setup default parameter */
|
p->fps_in_den = 1;
|
p->fps_in_num = p->fps;
|
p->fps_out_den = 1;
|
p->fps_out_num = p->h265_cfg.framerate;
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_flex", p->fps_in_flex);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_num", p->fps_in_num);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_in_denorm", p->fps_in_den);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_flex", p->fps_out_flex);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_num", p->fps_out_num);
|
mpp_enc_cfg_set_s32(cfg, "rc:fps_out_denorm", p->fps_out_den);
|
p->fps = p->h265_cfg.framerate;
|
}
|
if (init || (p->h265_cfg.change & BIT(3)))
|
{
|
ret = mpp_enc_cfg_set_s32(cfg, "prep:range", p->h265_cfg.range);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set prep:range failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
if (init || (p->h265_cfg.change & BIT(4)))
|
{
|
ret = mpi->control(ctx, MPP_ENC_SET_HEADER_MODE, &p->h265_cfg.head_each_idr);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set codec cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
if (init || (p->h265_cfg.change & BIT(5)))
|
{
|
ret = mpi->control(ctx, MPP_ENC_SET_SEI_CFG, &p->h265_cfg.sei);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set sei cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
}
|
if (init || (p->h265_cfg.change & BIT(6)))
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_init", p->h265_cfg.qp.init);
|
if (init || (p->h265_cfg.change & BIT(7)))
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_max", p->h265_cfg.qp.max);
|
if (init || (p->h265_cfg.change & BIT(8)))
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_min", p->h265_cfg.qp.min);
|
if (init || (p->h265_cfg.change & BIT(9)))
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_step", p->h265_cfg.qp.step);
|
if (init || (p->h265_cfg.change & BIT(10)))
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_max_i", p->h265_cfg.qp.max_i_qp);
|
if (init || (p->h265_cfg.change & BIT(11)))
|
mpp_enc_cfg_set_s32(cfg, "h265:qp_min_i", p->h265_cfg.qp.min_i_qp);
|
if (init || (p->h265_cfg.change & BIT(12)))
|
{
|
if (init && p->h265_cfg.idr_bps)
|
{
|
mpp_enc_bps_set(p, p->h265_cfg.idr_bps);
|
}
|
else
|
{
|
mpp_enc_bps_set(p, p->h265_cfg.bps);
|
}
|
}
|
if (init || (p->h265_cfg.change & BIT(15)))
|
{
|
mpp_set_ref_param(p, p->h265_cfg.gop_mode);
|
}
|
|
}
|
break;
|
default :
|
{
|
LOG_ERROR("unsupport encoder coding type %d\n", p->type);
|
}
|
break;
|
}
|
ret = mpi->control(ctx, MPP_ENC_SET_CFG, cfg);
|
if (ret)
|
{
|
LOG_ERROR("mpi control enc set cfg failed ret %d\n", ret);
|
goto RET;
|
}
|
//mpp_set_ref_param(p, GOP_MODE_TSVC3); // for test tsvc
|
//mpp_set_ref_param(p, GOP_MODE_SMARTP); // for test smartp
|
|
#if MPP_ENC_ROI_ENABLE
|
mpp_env_get_u32("roi_enable", &p->roi_enable, 0);
|
#if 0 // test //
|
EncROIRegion *region = (EncROIRegion *)malloc(2 * sizeof(EncROIRegion));
|
/* calculated in pixels */
|
region[0].x = 0;
|
region[0].y = 0;
|
region[0].w = 640;
|
region[0].h = 360;
|
region[0].intra = 0; /* flag of forced intra macroblock */
|
region[0].quality = 1; /* qp of macroblock */
|
region[0].abs_qp_en = 1; /*absolute qp set*/
|
region[0].area_map_en = 1;
|
region[0].qp_area_idx = 0; /*the value more large and the priority more high*/
|
|
region[1].x = 1000;
|
region[1].y = 600;
|
region[1].w = 200;
|
region[1].h = 100;
|
region[1].intra = 0; /* flag of forced intra macroblock */
|
region[1].quality = 1; /* qp of macroblock */
|
region[1].abs_qp_en = 1;
|
region[1].area_map_en = 1;
|
region[1].qp_area_idx = 0;
|
|
mpp_roi_config(p, region, 2);
|
free(region);
|
#endif
|
#endif
|
#if MPP_ENC_OSD_ENABLE
|
ret = mpp_osd_default_set(p);
|
#endif
|
RET:
|
return ret;
|
}
|
|
static int read_mpp_enc_cfg_modify_file(MpiEncTestData *p, bool init)
|
{
|
int ret = -1;
|
unsigned long read_size = 0;
|
|
FILE *modify_fd = fopen(RK_MPP_ENC_CFG_MODIFY_PATH, "rb");
|
unsigned long size = get_file_size(RK_MPP_ENC_CFG_MODIFY_PATH);
|
LOG_DEBUG("get cfg size=%ld\n", size);
|
char *cfg = (char *)malloc(size);
|
while (read_size != size)
|
{
|
read_size += fread(cfg, 1, size - read_size, modify_fd);
|
}
|
//LOG_INFO("get cfg =%s read_size=%ld\n", cfg, read_size);
|
cJSON *root = cJSON_Parse(cfg);
|
if (root == NULL)
|
{
|
LOG_ERROR("the %s is broken\n", RK_MPP_ENC_CFG_MODIFY_PATH);
|
}
|
else
|
{
|
ret = parse_check_mpp_enc_cfg(root, p, init);
|
}
|
if (modify_fd)
|
fclose(modify_fd);
|
if (cfg)
|
free(cfg);
|
if (root)
|
cJSON_Delete(root);
|
|
return ret;
|
}
|
|
static int check_mpp_enc_cfg_file_init(MpiEncTestData *p)
|
{
|
int ret = -1;
|
char cmd[128] = {0};
|
if (NULL == p)
|
return -1;
|
|
if (!access(RK_MPP_ENC_CFG_MODIFY_PATH, F_OK))
|
{
|
ret = read_mpp_enc_cfg_modify_file(p, true);
|
}
|
|
if (ret)
|
{
|
if (!access(RK_MPP_ENC_CFG_ORIGINAL_PATH, F_OK))
|
{
|
sprintf(cmd, "cp %s %s", RK_MPP_ENC_CFG_ORIGINAL_PATH, RK_MPP_ENC_CFG_MODIFY_PATH);
|
system(cmd);
|
LOG_DEBUG("copy enc cfg file...\n");
|
ret = read_mpp_enc_cfg_modify_file(p, true);
|
}
|
else
|
{
|
LOG_ERROR("file :%s not exit!\n", RK_MPP_ENC_CFG_ORIGINAL_PATH);
|
ret = -1;
|
}
|
}
|
else
|
{
|
|
}
|
|
p->cfg_notify_fd = inotify_init();
|
return ret;
|
}
|
|
void *thread_check_mpp_enc_chenge_loop(void *user)
|
{
|
int ret = 0;
|
MPP_RET mpp_ret;
|
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, PTHREAD_CREATE_JOINABLE);
|
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
|
MpiEncTestData *p = (MpiEncTestData *)user;
|
int last_wd = 0;
|
unsigned char buf[1024] = {0};
|
struct inotify_event *event = NULL;
|
bool modify = false;
|
while (1)
|
{
|
last_wd = p->cfg_notify_wd;
|
p->cfg_notify_wd = inotify_add_watch(p->cfg_notify_fd, RK_MPP_ENC_CFG_MODIFY_PATH, IN_MODIFY | IN_DELETE_SELF);//IN_ALL_EVENTS);
|
modify = false;
|
if (p->cfg_notify_wd != -1)
|
{
|
if ((last_wd == -1 && p->cfg_notify_wd == 1))
|
{
|
modify = true;
|
}
|
else
|
{
|
fd_set fds;
|
FD_ZERO(&fds);
|
FD_SET(p->cfg_notify_fd, &fds);
|
|
if (select(p->cfg_notify_fd + 1, &fds, NULL, NULL, NULL) > 0)
|
{
|
int len, index = 0;
|
memset(buf, 0, sizeof(buf));
|
len = read(p->cfg_notify_fd, &buf, sizeof(buf));
|
|
while (len > 0 && index < len)
|
{
|
event = (struct inotify_event *)(buf + index);
|
if (event->mask == IN_MODIFY)
|
{
|
modify = true;
|
}
|
else if (event->mask == IN_DELETE_SELF)
|
{
|
p->cfg_notify_wd = -1;
|
}
|
|
index += sizeof(struct inotify_event) + event->len;
|
}
|
|
}
|
|
}
|
}
|
sleep(1);
|
if (modify)
|
{
|
LOG_INFO("the enc cfg file change or creat, do update.wd=%d,last_wd=%d\n", p->cfg_notify_wd, last_wd);
|
ret = read_mpp_enc_cfg_modify_file(p, false);
|
if (ret)
|
LOG_ERROR("error: the enc cfg file is broken.please check.\n");
|
else
|
{
|
mpp_ret = mpp_enc_cfg_set(p, false);
|
dump_mpp_enc_cfg(p);
|
if (mpp_ret)
|
{
|
LOG_ERROR("mpp_enc_cfg_set failed ret %d\n", mpp_ret);
|
}
|
}
|
}
|
|
inotify_rm_watch(p->cfg_notify_fd, p->cfg_notify_wd);
|
close(p->cfg_notify_fd);
|
p->cfg_notify_fd = inotify_init();
|
#if 0
|
if (p->cfg_notify_wd == IN_MODIFY || (last_wd == -1 && p->cfg_notify_wd == 1))
|
{
|
LOG_INFO("the enc cfg file change or creat, do update.wd=%d,last_wd=%d\n", p->cfg_notify_wd, last_wd);
|
ret = read_mpp_enc_cfg_modify_file(p, false);
|
if (ret)
|
LOG_ERROR("error: the enc cfg file is broken.please check.\n");
|
else
|
{
|
dump_mpp_enc_cfg(p);
|
mpp_ret = mpp_enc_cfg_set(p, false);
|
if (mpp_ret)
|
{
|
LOG_ERROR("mpp_enc_cfg_set failed ret %d\n", mpp_ret);
|
}
|
}
|
inotify_rm_watch(p->cfg_notify_fd, p->cfg_notify_wd);
|
close(p->cfg_notify_fd);
|
p->cfg_notify_fd = inotify_init();
|
}
|
sleep(1);
|
#endif
|
}
|
}
|
|
#if MPP_ENC_ROI_ENABLE
|
static int mpp_roi_enable_set(MpiEncTestData *p, int enable)
|
{
|
p->roi_enable = enable;
|
}
|
|
static int mpp_roi_enable_get(MpiEncTestData *p)
|
{
|
return p->roi_enable;
|
}
|
|
static int mpp_roi_config(MpiEncTestData *p, EncROIRegion *regions, int region_cnt)
|
{
|
if (!regions || region_cnt == 0) {
|
p->roi_number = 0;
|
if (p->roi_cfg.regions) {
|
free(p->roi_cfg.regions);
|
p->roi_cfg.regions = NULL;
|
}
|
LOG_INFO("disable roi function\n");
|
return 0;
|
}
|
int msize = region_cnt * sizeof(MppEncROIRegion);
|
MppEncROIRegion *region = (MppEncROIRegion *)malloc(msize);
|
if (!region) {
|
return -1;
|
}
|
for (int i = 0; i < region_cnt; i++) {
|
if ((regions[i].x % 16) || (regions[i].y % 16) ||
|
(regions[i].w % 16) || (regions[i].h % 16)) {
|
LOG_WARN("WARN: MPP Encoder: region parameter should be an integer multiple of 16\n");
|
LOG_WARN("WARN: MPP Encoder: reset region[%d] frome <%d,%d,%d,%d> to <%d,%d,%d,%d>\n",
|
i, regions[i].x, regions[i].y, regions[i].w, regions[i].h,
|
UPALIGNTO16(regions[i].x), UPALIGNTO16(regions[i].y),
|
UPALIGNTO16(regions[i].w), UPALIGNTO16(regions[i].h));
|
regions[i].x = UPALIGNTO16(regions[i].x);
|
regions[i].y = UPALIGNTO16(regions[i].y);
|
regions[i].w = UPALIGNTO16(regions[i].w);
|
regions[i].h = UPALIGNTO16(regions[i].h);
|
}
|
LOG_DEBUG("MPP Encoder: roi region[%d]:<%d,%d,%d,%d>\n",
|
i, regions[i].x, regions[i].y, regions[i].w, regions[i].h);
|
LOG_DEBUG("MPP Encoder: roi region[%d].intra=%d,\n", i, regions[i].intra);
|
LOG_DEBUG("MPP Encoder: roi region[%d].quality=%d,\n", i, regions[i].quality);
|
LOG_DEBUG("MPP Encoder: roi region[%d].abs_qp_en=%d,\n", i, regions[i].abs_qp_en);
|
LOG_DEBUG("MPP Encoder: roi region[%d].qp_area_idx=%d,\n", i, regions[i].qp_area_idx);
|
LOG_DEBUG("MPP Encoder: roi region[%d].area_map_en=%d,\n", i, regions[i].area_map_en);
|
assert(regions[i].x < 8192);
|
assert(regions[i].y < 8192);
|
assert(regions[i].w < 8192);
|
assert(regions[i].h < 8192);
|
assert(regions[i].x < 8192);
|
assert(regions[i].intra <= 1);
|
assert(regions[i].abs_qp_en <= 1);
|
assert(regions[i].qp_area_idx <= 7);
|
assert(regions[i].area_map_en <= 1);
|
VALUE_SCOPE_CHECK(regions[i].quality, -48, 51);
|
region[i].x = regions[i].x;
|
region[i].y = regions[i].y;
|
region[i].w = regions[i].w;
|
region[i].h = regions[i].h;
|
region[i].intra = regions[i].intra;
|
region[i].quality = regions[i].quality;
|
region[i].abs_qp_en = regions[i].abs_qp_en;
|
region[i].qp_area_idx = regions[i].qp_area_idx;
|
region[i].area_map_en = regions[i].area_map_en;
|
}
|
p->roi_cfg.number = region_cnt;
|
if (p->roi_cfg.regions)
|
free(p->roi_cfg.regions);
|
p->roi_cfg.regions = region;
|
//mpp_meta_set_ptr(meta, KEY_ROI_DATA, (void*)&p->roi_cfg);
|
return 0;
|
}
|
#endif
|
