zhangzhaopeng
/
sdk-hwV1.3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
sdk-hwV1.3/external/eyesee-mpp/middleware/sun8iw21/media/LIBRARY/libcedarc/base/CdcConfigParamParser.c

821 lines
29 KiB
C
Raw Blame History

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include "CdcConfigParamParser.h"
#include "cdc_log.h"
#define BUF_SIZE 1024
extern void ve_param_set_res(VideoEncoder* pVideoEnc, VencParamFromFiles *p_ve_param);
extern void ve_param_set_pxl_format(VideoEncoder* pVideoEnc, VencParamFromFiles *p_ve_param);
const static struct {
int val;
const char *str;
} VENC_FMT_CONVERSION [] = {
{0, "VENC_PIXEL_YUV420SP" },
{1, "VENC_PIXEL_YVU420SP" },
{2, "VENC_PIXEL_YUV420P" },
{3, "VENC_PIXEL_YVU420P" },
{4, "VENC_PIXEL_YUV422SP" },
{5, "VENC_PIXEL_YVU422SP" },
{6, "VENC_PIXEL_YUV422P" },
{7, "VENC_PIXEL_YVU422P" },
{8, "VENC_PIXEL_YUYV422" },
{9, "VENC_PIXEL_UYVY422" },
{10, "VENC_PIXEL_YVYU422" },
{11, "VENC_PIXEL_VYUY422" },
{12, "VENC_PIXEL_ARGB" },
{13, "VENC_PIXEL_RGBA" },
{14, "VENC_PIXEL_ABGR" },
{15, "VENC_PIXEL_BGRA" },
{16, "VENC_PIXEL_TILE_32X32" },
{17, "VENC_PIXEL_TILE_128X32"},
{18, "VENC_PIXEL_AFBC_AW" },
{19, "VENC_PIXEL_LBC_AW" },
};
static int str2enum (const char *str)
{
for (unsigned j = 0; j < sizeof (VENC_FMT_CONVERSION)/sizeof (VENC_FMT_CONVERSION[0]);++j)
if (!strcmp (str, VENC_FMT_CONVERSION[j].str))
return VENC_FMT_CONVERSION[j].val;
logv("no such enum ofr VENC_PIXEL_FMT");
return -1;
}
static int parse_frame_rate_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "value") == 0)
{
ve_param->fps = strtol(attr[i + 1], NULL, 0);
logd("frame_rate: %d", ve_param->fps);
}
return 0;
}
static int parse_bit_rate_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "value") == 0)
{
ve_param->bit_rate = strtol(attr[i + 1], NULL, 0);
logd("bit_rate: %d", ve_param->bit_rate);
}
return 0;
}
static int parse_vbv_size_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "value") == 0)
{
ve_param->vbv_size = strtol(attr[i + 1], NULL, 0);
logd("vbv_size: %d", ve_param->vbv_size);
}
return 0;
}
static int parse_pixel_format_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "pxl_format") == 0)
{
ve_param->eInputFormat = str2enum(attr[i + 1]);
logd("pxl_format: %d", ve_param->eInputFormat);
}
else if (strcmp(attr[i], "out_pxl_format") == 0)
{
ve_param->eOutputFormat = strtol(attr[i + 1], NULL, 0);
logd("out_pxl_format: %d", ve_param->eOutputFormat);
}
return 0;
}
static int parse_resolution_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "src_width") == 0)
{
ve_param->nInputWidth = strtol(attr[i + 1], NULL, 0);
logd("src_width: %d", ve_param->nInputWidth);
}
else if (strcmp(attr[i], "src_height") == 0)
{
ve_param->nInputHeight = strtol(attr[i + 1], NULL, 0);
logd("src_height: %d", ve_param->nInputHeight);
}
else if (strcmp(attr[i], "dst_width") == 0) {
ve_param->nDstWidth = strtol(attr[i + 1], NULL, 0);
logd("dst_width: %d", ve_param->nDstWidth);
}
else if (strcmp(attr[i], "dst_height") == 0) {
ve_param->nDstHeight = strtol(attr[i + 1], NULL, 0);
logd("dst_height: %d", ve_param->nDstHeight);
}
return 0;
}
static int parse_qp_range_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "i_qp_min") == 0)
{
ve_param->qp_range.nMinqp = strtol(attr[i + 1], NULL, 0);
logd("i_qp_min: %d", ve_param->qp_range.nMinqp);
}
else if (strcmp(attr[i], "i_qp_max") == 0)
{
ve_param->qp_range.nMaxqp = strtol(attr[i + 1], NULL, 0);
logd("i_qp_max: %d", ve_param->qp_range.nMaxqp);
}
else if (strcmp(attr[i], "p_qp_min") == 0)
{
ve_param->qp_range.nMinPqp = strtol(attr[i + 1], NULL, 0);
logd("p_qp_min: %d", ve_param->qp_range.nMinPqp);
}
else if (strcmp(attr[i], "p_qp_max") == 0)
{
ve_param->qp_range.nMaxPqp = strtol(attr[i + 1], NULL, 0);
logd("p_qp_max: %d", ve_param->qp_range.nMaxPqp);
}
else if (strcmp(attr[i], "qp_init") == 0)
{
ve_param->qp_range.nQpInit = strtol(attr[i + 1], NULL, 0);
logd("qp_init: %d", ve_param->qp_range.nQpInit);
}
else if (strcmp(attr[i], "mb_qp_limit") == 0)
{
ve_param->qp_range.bEnMbQpLimit = strtol(attr[i + 1], NULL, 0);
logd("mb_qp_limit: %d", ve_param->qp_range.bEnMbQpLimit);
}
return 0;
}
static int parse_fix_qp_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "u8_en_fix_qp") == 0)
{
ve_param->fixQP.bEnable = strtol(attr[i + 1], NULL, 0);
logd("u8_en_fix_qp: %d", ve_param->fixQP.bEnable);
}
else if (strcmp(attr[i], "s32_fix_i_qp") == 0)
{
ve_param->fixQP.nIQp = strtol(attr[i + 1], NULL, 0);
logd("s32_fix_i_qp: %d", ve_param->fixQP.nIQp);
}
else if (strcmp(attr[i], "s32_fix_p_qp") == 0)
{
ve_param->fixQP.nPQp = strtol(attr[i + 1], NULL, 0);
logd("s32_fix_p_qp: %d", ve_param->fixQP.nPQp);
}
return 0;
}
static int parse_vbr_param_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "s32_quality") == 0)
{
ve_param->sVbrParam.nQuality = strtol(attr[i + 1], NULL, 0);
logd("nQuality: %d", ve_param->sVbrParam.nQuality);
}
else if (strcmp(attr[i], "s32_p_bits_coef") == 0)
{
ve_param->sVbrParam.nPFrmBitsCoef = strtol(attr[i + 1], NULL, 0);
logd("nPFrmBitsCoef: %d", ve_param->sVbrParam.nPFrmBitsCoef);
}
else if (strcmp(attr[i], "s32_i_bits_coef") == 0)
{
ve_param->sVbrParam.nIFrmBitsCoef = strtol(attr[i + 1], NULL, 0);
logd("nIFrmBitsCoef: %d", ve_param->sVbrParam.nIFrmBitsCoef);
}
return 0;
}
static int parse_h264_video_timing_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "u8_timing_info_present_flag") == 0)
{
//ve_param->mH264VideoTiming. = strtol(attr[i + 1], NULL, 0);
//if (ve_param->fps != 0xffff) logd("vbv_size: %d", ve_param->vbv_size);
//logd("struct not this mem %s: %ld", attr[i], strtol(attr[i + 1], NULL, 0));
}
else if (strcmp(attr[i], "u8_fixed_frame_rate_flag") == 0)
{
ve_param->mH264VideoTiming.fixed_frame_rate_flag = strtol(attr[i + 1], NULL, 0);
logd("fixed_frame_rate_flag: %d", ve_param->mH264VideoTiming.fixed_frame_rate_flag);
}
else if (strcmp(attr[i], "u32_num_units_in_tick") == 0)
{
ve_param->mH264VideoTiming.num_units_in_tick = strtol(attr[i + 1], NULL, 0);
logd("num_units_in_tick: %ld", ve_param->mH264VideoTiming.num_units_in_tick);
}
else if (strcmp(attr[i], "u32_time_scale") == 0)
{
ve_param->mH264VideoTiming.time_scale = strtol(attr[i + 1], NULL, 0);
logd("time_scale: %ld", ve_param->mH264VideoTiming.time_scale);
}
return 0;
}
static int parse_h265_video_timing_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "u32_timing_info_present_flag") == 0)
{
ve_param->mH265VideoTiming.timing_info_present_flag = strtol(attr[i + 1], NULL, 0);
logd("timing_info_present_flag: %d", ve_param->mH265VideoTiming.timing_info_present_flag);
}
else if (strcmp(attr[i], "u32_h265_num_units_in_tick") == 0)
{
ve_param->mH265VideoTiming.num_units_in_tick = strtol(attr[i + 1], NULL, 0);
logd("u32_h265_num_units_in_tick: %d", ve_param->mH265VideoTiming.num_units_in_tick);
}
else if (strcmp(attr[i], "u32_h265_time_scale") == 0)
{
ve_param->mH265VideoTiming.time_scale = strtol(attr[i + 1], NULL, 0);
logd("u32_h265_time_scale: %d", ve_param->mH265VideoTiming.time_scale);
}
else if (strcmp(attr[i], "num_ticks_poc_diff_one_minus1") == 0)
{
ve_param->mH265VideoTiming.num_ticks_poc_diff_one = strtol(attr[i + 1], NULL, 0);
logd("num_ticks_poc_diff_one: %d", ve_param->mH265VideoTiming.num_ticks_poc_diff_one);
}
return 0;
}
static int parse_region_d3d_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "u8_en_region_d3d") == 0)
{
ve_param->mRegionD3DParam.en_region_d3d = strtol(attr[i + 1], NULL, 0);
logd("en_region_d3d: %d", ve_param->mRegionD3DParam.en_region_d3d);
}
else if (strcmp(attr[i], "u8_dis_default_para") == 0)
{
ve_param->mRegionD3DParam.dis_default_para = strtol(attr[i + 1], NULL, 0);
logd("dis_default_para: %d", ve_param->mRegionD3DParam.dis_default_para);
}
else if (strcmp(attr[i], "s32_result_num") == 0)
{
ve_param->mRegionD3DParam.result_num = strtol(attr[i + 1], NULL, 0);
logd("result_num: %d", ve_param->mRegionD3DParam.result_num);
}
else if (strcmp(attr[i], "s32_hor_region_num") == 0)
{
ve_param->mRegionD3DParam.hor_region_num = strtol(attr[i + 1], NULL, 0);
logd("hor_region_num: %d", ve_param->mRegionD3DParam.hor_region_num);
}
else if (strcmp(attr[i], "s32_ver_region_num") == 0)
{
ve_param->mRegionD3DParam.ver_region_num = strtol(attr[i + 1], NULL, 0);
logd("ver_region_num: %d", ve_param->mRegionD3DParam.ver_region_num);
}
else if (strcmp(attr[i], "s32_hor_expand_num") == 0)
{
ve_param->mRegionD3DParam.hor_expand_num = strtol(attr[i + 1], NULL, 0);
logd("hor_expand_num: %d", ve_param->mRegionD3DParam.hor_expand_num);
}
else if (strcmp(attr[i], "s32_ver_expand_num") == 0)
{
ve_param->mRegionD3DParam.ver_expand_num = strtol(attr[i + 1], NULL, 0);
logd("ver_expand_num: %d", ve_param->mRegionD3DParam.ver_expand_num);
}
else if (strcmp(attr[i], "u8_motion_coef_3") == 0)
{
ve_param->mRegionD3DParam.motion_coef[3] = strtol(attr[i + 1], NULL, 0);
logd("motion_coef[3]: %d", ve_param->mRegionD3DParam.motion_coef[3]);
}
else if (strcmp(attr[i], "u8_motion_coef_2") == 0)
{
ve_param->mRegionD3DParam.motion_coef[2] = strtol(attr[i + 1], NULL, 0);
logd("motion_coef[2]: %d", ve_param->mRegionD3DParam.motion_coef[2]);
}
else if (strcmp(attr[i], "u8_motion_coef_1") == 0)
{
ve_param->mRegionD3DParam.motion_coef[1] = strtol(attr[i + 1], NULL, 0);
logd("motion_coef[1]: %d", ve_param->mRegionD3DParam.motion_coef[1]);
}
else if (strcmp(attr[i], "u8_motion_coef_0") == 0)
{
ve_param->mRegionD3DParam.motion_coef[0] = strtol(attr[i + 1], NULL, 0);
logd("motion_coef[0]: %d", ve_param->mRegionD3DParam.motion_coef[0]);
}
else if (strcmp(attr[i], "f32_zero_mv_rate_th_2") == 0)
{
ve_param->mRegionD3DParam.zero_mv_rate_th[2] = strtof(attr[i + 1], NULL);
logd("zero_mv_rate_th[2]: %f", ve_param->mRegionD3DParam.zero_mv_rate_th[2]);
}
else if (strcmp(attr[i], "f32_zero_mv_rate_th_1") == 0)
{
ve_param->mRegionD3DParam.zero_mv_rate_th[1] = strtof(attr[i + 1], NULL);
logd("zero_mv_rate_th[1]: %f", ve_param->mRegionD3DParam.zero_mv_rate_th[1]);
}
else if (strcmp(attr[i], "f32_zero_mv_rate_th_0") == 0)
{
ve_param->mRegionD3DParam.zero_mv_rate_th[0] = strtof(attr[i + 1], NULL);
logd("zero_mv_rate_th[0]: %f", ve_param->mRegionD3DParam.zero_mv_rate_th[0]);
}
else if (strcmp(attr[i], "u8_static_coef_2") == 0)
{
ve_param->mRegionD3DParam.static_coef[2] = strtol(attr[i + 1], NULL, 0);
logd("static_coef[2]: %d", ve_param->mRegionD3DParam.static_coef[2]);
}
else if (strcmp(attr[i], "u8_static_coef_1") == 0)
{
ve_param->mRegionD3DParam.static_coef[1] = strtol(attr[i + 1], NULL, 0);
logd("static_coef[1]: %d", ve_param->mRegionD3DParam.static_coef[1]);
}
else if (strcmp(attr[i], "u8_static_coef_0") == 0)
{
ve_param->mRegionD3DParam.static_coef[0] = strtol(attr[i + 1], NULL, 0);
logd("static_coef[0]: %d", ve_param->mRegionD3DParam.static_coef[0]);
}
else if (strcmp(attr[i], "u8_chroma_offset") == 0)
{
ve_param->mRegionD3DParam.chroma_offset = strtol(attr[i + 1], NULL, 0);
logd("chroma_offset: %d", ve_param->mRegionD3DParam.chroma_offset);
}
else if (strcmp(attr[i], "s32_lv_weak_th_8") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[8] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[8]: %d", ve_param->mRegionD3DParam.lv_weak_th[8]);
}
else if (strcmp(attr[i], "s32_lv_weak_th_7") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[7] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[7]: %d", ve_param->mRegionD3DParam.lv_weak_th[7]);
}
else if (strcmp(attr[i], "s32_lv_weak_th_6") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[6] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[6]: %d", ve_param->mRegionD3DParam.lv_weak_th[6]);
}
else if (strcmp(attr[i], "s32_lv_weak_th_5") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[5] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[5]: %d", ve_param->mRegionD3DParam.lv_weak_th[5]);
}
else if (strcmp(attr[i], "s32_lv_weak_th_4") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[4] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[4]: %d", ve_param->mRegionD3DParam.lv_weak_th[4]);
}
else if (strcmp(attr[i], "s32_lv_weak_th_3") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[3] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[3]: %d", ve_param->mRegionD3DParam.lv_weak_th[3]);
}
else if (strcmp(attr[i], "s32_lv_weak_th_2") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[2] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[2]: %d", ve_param->mRegionD3DParam.lv_weak_th[2]);
}
else if (strcmp(attr[i], "s32_lv_weak_th_1") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[1] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[1]: %d", ve_param->mRegionD3DParam.lv_weak_th[1]);
}
else if (strcmp(attr[i], "s32_lv_weak_th_0") == 0)
{
ve_param->mRegionD3DParam.lv_weak_th[0] = strtol(attr[i + 1], NULL, 0);
logd("lv_weak_th[0]: %d", ve_param->mRegionD3DParam.lv_weak_th[0]);
}
return 0;
}
static int parse_3d_filter_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "u8_d3d_en") == 0)
{
ve_param->m3DfilterParam.enable_3d_filter = strtol(attr[i + 1], NULL, 0);
logd("enable_3d_filter: %d", ve_param->m3DfilterParam.enable_3d_filter);
}
else if (strcmp(attr[i], "u8_d3d_max_mv_th") == 0)
{
ve_param->m3DfilterParam.max_mv_th = strtol(attr[i + 1], NULL, 0);
logd("max_mv_th: %d", ve_param->m3DfilterParam.max_mv_th);
}
else if (strcmp(attr[i], "u8_d3d_max_mad_th") == 0)
{
ve_param->m3DfilterParam.max_mad_th = strtol(attr[i + 1], NULL, 0);
logd("max_mad_th: %d", ve_param->m3DfilterParam.max_mad_th);
}
else if (strcmp(attr[i], "u8_d3d_pix_level_en") == 0)
{
ve_param->m3DfilterParam.adjust_pix_level_enable = strtol(attr[i + 1], NULL, 0);
logd("adjust_pix_level_enable: %d", ve_param->m3DfilterParam.adjust_pix_level_enable);
}
else if (strcmp(attr[i], "u8_d3d_pix_diff_th") == 0)
{
ve_param->m3DfilterParam.max_pix_diff_th = strtol(attr[i + 1], NULL, 0);
logd("max_pix_diff_th: %d", ve_param->m3DfilterParam.max_pix_diff_th);
}
else if (strcmp(attr[i], "u8_d3d_smooth_en") == 0)
{
ve_param->m3DfilterParam.smooth_filter_enable = strtol(attr[i + 1], NULL, 0);
logd("smooth_filter_enable: %d", ve_param->m3DfilterParam.smooth_filter_enable);
}
else if (strcmp(attr[i], "u8_min_coef") == 0)
{
ve_param->m3DfilterParam.min_coef = strtol(attr[i + 1], NULL, 0);
logd("min_coef: %d", ve_param->m3DfilterParam.min_coef);
}
else if (strcmp(attr[i], "u8_max_coef") == 0)
{
ve_param->m3DfilterParam.max_coef = strtol(attr[i + 1], NULL, 0);
logd("max_coef: %d", ve_param->m3DfilterParam.max_coef);
}
return 0;
}
static int parse_2d_filter_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "u8_d2d_en") == 0)
{
ve_param->m2DfilterParam.enable_2d_filter = strtol(attr[i + 1], NULL, 0);
logd("enable_2d_filter: %d", ve_param->m2DfilterParam.enable_2d_filter);
}
else if (strcmp(attr[i], "u8_d2d_strength_uv") == 0)
{
ve_param->m2DfilterParam.filter_strength_uv = strtol(attr[i + 1], NULL, 0);
logd("filter_strength_uv: %d", ve_param->m2DfilterParam.filter_strength_uv);
}
else if (strcmp(attr[i], "u8_d2d_strength_y") == 0)
{
ve_param->m2DfilterParam.filter_strength_y = strtol(attr[i + 1], NULL, 0);
logd("filter_strength_y: %d", ve_param->m2DfilterParam.filter_strength_y);
}
else if (strcmp(attr[i], "u8_d2d_th_uv") == 0)
{
ve_param->m2DfilterParam.filter_th_uv = strtol(attr[i + 1], NULL, 0);
logd("filter_th_uv: %d", ve_param->m2DfilterParam.filter_th_uv);
}
else if (strcmp(attr[i], "u8_d2d_th_y") == 0)
{
ve_param->m2DfilterParam.filter_th_y = strtol(attr[i + 1], NULL, 0);
logd("filter_th_y: %d", ve_param->m2DfilterParam.filter_th_y);
}
return 0;
}
static int parse_target_bits_clip_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "u8_bits_clip_dis_default") == 0)
{
ve_param->bits_clip_param.dis_default_para = strtol(attr[i + 1], NULL, 0);
logd("dis_default_para: %d", ve_param->bits_clip_param.dis_default_para);
}
else if (strcmp(attr[i], "s32_bits_clip_mode") == 0)
{
ve_param->bits_clip_param.mode = strtol(attr[i + 1], NULL, 0);
logd("s32_bits_clip_mode: %d", ve_param->bits_clip_param.mode);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_0_0") == 0)
{
ve_param->bits_clip_param.coef_th[0][0] = strtof(attr[i + 1], NULL);
logd("coef_th[0][0]: %f", ve_param->bits_clip_param.coef_th[0][0]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_0_1") == 0)
{
ve_param->bits_clip_param.coef_th[0][1] = strtof(attr[i + 1], NULL);
logd("coef_th[0][1]: %f", ve_param->bits_clip_param.coef_th[0][1]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_1_0") == 0)
{
ve_param->bits_clip_param.coef_th[1][0] = strtof(attr[i + 1], NULL);
logd("coef_th[1][0]: %f", ve_param->bits_clip_param.coef_th[1][0]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_1_1") == 0)
{
ve_param->bits_clip_param.coef_th[1][1] = strtof(attr[i + 1], NULL);
logd("coef_th[1][1]: %f", ve_param->bits_clip_param.coef_th[1][1]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_2_0") == 0)
{
ve_param->bits_clip_param.coef_th[2][0] = strtof(attr[i + 1], NULL);
logd("coef_th[2][0]: %f", ve_param->bits_clip_param.coef_th[2][0]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_2_1") == 0)
{
ve_param->bits_clip_param.coef_th[2][1] = strtof(attr[i + 1], NULL);
logd("coef_th[2][1]: %f", ve_param->bits_clip_param.coef_th[2][1]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_3_0") == 0)
{
ve_param->bits_clip_param.coef_th[3][0] = strtof(attr[i + 1], NULL);
logd("coef_th[3][0]: %f", ve_param->bits_clip_param.coef_th[3][0]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_3_1") == 0)
{
ve_param->bits_clip_param.coef_th[3][1] = strtof(attr[i + 1], NULL);
logd("coef_th[3][1]: %f", ve_param->bits_clip_param.coef_th[3][1]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_4_0") == 0)
{
ve_param->bits_clip_param.coef_th[4][0] = strtof(attr[i + 1], NULL);
logd("coef_th[4][0]: %f", ve_param->bits_clip_param.coef_th[4][0]);
}
else if (strcmp(attr[i], "f32_bits_clip_coef_4_1") == 0)
{
ve_param->bits_clip_param.coef_th[4][1] = strtof(attr[i + 1], NULL);
logd("coef_th[4][1]: %f", ve_param->bits_clip_param.coef_th[4][1]);
}
else if (strcmp(attr[i], "u8_bits_clip_gop_ratio_en") == 0)
{
ve_param->bits_clip_param.en_gop_clip = strtol(attr[i + 1], NULL, 0);
logd("en_gop_clip: %d", ve_param->bits_clip_param.en_gop_clip);
}
else if (strcmp(attr[i], "f32_bits_clip_gop_ratio_th_0") == 0)
{
ve_param->bits_clip_param.gop_bit_ratio_th[0] = strtof(attr[i + 1], NULL);
logd("gop_bit_ratio_th[0]: %f", ve_param->bits_clip_param.gop_bit_ratio_th[0]);
}
else if (strcmp(attr[i], "f32_bits_clip_gop_ratio_th_1") == 0)
{
ve_param->bits_clip_param.gop_bit_ratio_th[1] = strtof(attr[i + 1], NULL);
logd("gop_bit_ratio_th[1]: %f", ve_param->bits_clip_param.gop_bit_ratio_th[1]);
}
else if (strcmp(attr[i], "f32_bits_clip_gop_ratio_th_2") == 0)
{
ve_param->bits_clip_param.gop_bit_ratio_th[2] = strtof(attr[i + 1], NULL);
logd("gop_bit_ratio_th[2]: %f", ve_param->bits_clip_param.gop_bit_ratio_th[2]);
}
return 0;
}
static int parse_force_conf_win_param(VencParamFromFiles *ve_param, const XML_Char **attr, int i)
{
if (strcmp(attr[i], "u8_en_force_conf") == 0)
{
ve_param->conf_win.en_force_conf = strtol(attr[i + 1], NULL, 0);
logd("u8_en_force_conf: %d", ve_param->conf_win.en_force_conf);
}
else if (strcmp(attr[i], "u32_lefet_offset") == 0)
{
ve_param->conf_win.left_offset = strtol(attr[i + 1], NULL, 0);
logd("left_offset: %d", ve_param->conf_win.left_offset);
}
else if (strcmp(attr[i], "u32_right_offset") == 0)
{
ve_param->conf_win.right_offset = strtol(attr[i + 1], NULL, 0);
logd("right_offset: %d", ve_param->conf_win.right_offset);
}
else if (strcmp(attr[i], "u32_top_offset") == 0)
{
ve_param->conf_win.top_offset = strtol(attr[i + 1], NULL, 0);
logd("top_offset: %d", ve_param->conf_win.top_offset);
}
else if (strcmp(attr[i], "u32_bottom_offset") == 0)
{
ve_param->conf_win.bottom_offset = strtol(attr[i + 1], NULL, 0);
logd("bottom_offset: %d", ve_param->conf_win.bottom_offset);
}
return 0;
}
static void end_parse_tag(void *data, const XML_Char *tag_name)
{
VencParamFromFiles *ve_param = (VencParamFromFiles*)data;
if (strcmp(tag_name, "static") == 0 && ve_param->is_static)
ve_param->parsingStatic = 0;
else if (strcmp(tag_name, "dynamic") == 0 && !ve_param->is_static)
ve_param->parsingDynamic = 0;
}
static int check_status(const XML_Char *name, const XML_Char *value)
{
if (strcmp(name, "status") == 0 && strcmp(value, "off") == 0) {
return 0;
}
return 1;
}
static void start_parse_tag(void *data, const XML_Char *tag_name,
const XML_Char **attr)
{
VencParamFromFiles *ve_param = (VencParamFromFiles*)data;
VideoEncoder* pVideoEnc = (VideoEncoder*)ve_param->pVideoEnc;
static int output_index = 0;
if (strcmp(tag_name, "static") == 0 && ve_param->is_static) {
ve_param->parsingStatic = 1;
}
else if (strcmp(tag_name, "dynamic") == 0 && !ve_param->is_static) {
ve_param->parsingDynamic = 1;
}
if (ve_param->parsingStatic && ve_param->is_static) {
if (check_status(attr[0], attr[1]) == 0)
return ;
if (strcmp(tag_name, "frame_rate") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_frame_rate_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamFramerate, &ve_param->fps);
}
else if (strcmp(tag_name, "bit_rate") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_bit_rate_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamBitrate, &ve_param->bit_rate);
}
else if (strcmp(tag_name, "vbv_size") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_vbv_size_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamSetVbvSize, &ve_param->vbv_size);
}
else if (strcmp(tag_name, "pixel_format") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_pixel_format_param(ve_param, attr, i);
}
ve_param_set_pxl_format(ve_param->pVideoEnc, ve_param);
}
else if (strcmp(tag_name, "resolution") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_resolution_param(ve_param, attr, i);
}
ve_param_set_res(ve_param->pVideoEnc, ve_param);
}
else if (strcmp(tag_name, "qp_range") == 0) {
if (ve_param->codecType == VENC_CODEC_JPEG)
return ;
for (unsigned int i = 0; attr[i]; i += 2) {
parse_qp_range_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamH264QPRange, &ve_param->qp_range);
}
}
else if (ve_param->parsingDynamic && !ve_param->is_static) {
if (check_status(attr[0], attr[1]) == 0)
return ;
if (strcmp(tag_name, "frame_rate") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_frame_rate_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamFramerate, &ve_param->fps);
return ;
}
else if (strcmp(tag_name, "bit_rate") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_bit_rate_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamBitrate, &ve_param->bit_rate);
return ;
}
if (ve_param->codecType == VENC_CODEC_JPEG) {
if (strcmp(tag_name, "s32_jpeg_quality") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
if (strcmp(attr[i], "value") == 0)
{
ve_param->jpeg_quality = strtol(attr[i + 1], NULL, 0);
logd("jpeg_quality: %d", ve_param->jpeg_quality);
}
}
VencSetParameter(pVideoEnc, VENC_IndexParamJpegQuality, &ve_param->jpeg_quality);
}
}
if (ve_param->codecType != VENC_CODEC_JPEG) {
if (strcmp(tag_name, "force_conf_win") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_force_conf_win_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamForceConfWin, &ve_param->conf_win);
}
else if (strcmp(tag_name, "qp_range") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_qp_range_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamH264QPRange, &ve_param->qp_range);
}
else if (strcmp(tag_name, "fix_qp") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_fix_qp_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamH264FixQP, &ve_param->fixQP);
}
else if (strcmp(tag_name, "target_bits_clip") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_target_bits_clip_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamTargetBitsClipParam, &ve_param->bits_clip_param);
}
else if (strcmp(tag_name, "vbr_param") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_vbr_param_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamSetVbrParam, &ve_param->sVbrParam);
}
else if (strcmp(tag_name, "d2d_filter") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_2d_filter_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParam2DFilter, &ve_param->m2DfilterParam);
}
else if (strcmp(tag_name, "d3d_filter") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_3d_filter_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParam3DFilterNew, &ve_param->m3DfilterParam);
}
else if (strcmp(tag_name, "region_d3d") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
parse_region_d3d_param(ve_param, attr, i);
}
VencSetParameter(pVideoEnc, VENC_IndexParamRegionD3DParam, &ve_param->mRegionD3DParam);
}
else if (strcmp(tag_name, "mb_rc_level") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
if (strcmp(attr[i], "value") == 0)
{
ve_param->mb_rc_level = strtol(attr[i + 1], NULL, 0);
logd("mb_rc_level: %d", ve_param->mb_rc_level);
}
}
VencSetParameter(pVideoEnc, VENC_IndexParamEnIFrmMbRcMoveStatus, &ve_param->mb_rc_level);
}
else if (strcmp(tag_name, "f32_weak_text_th") == 0) {
for (unsigned int i = 0; attr[i]; i += 2) {
if (strcmp(attr[i], "f32_weak_text_th") == 0)
{
ve_param->weak_text_th = strtof(attr[i + 1], NULL);
logd("weak_text_th: %f", ve_param->weak_text_th);
}
}
VencSetParameter(pVideoEnc, VENC_IndexParamWeakTextTh, &ve_param->weak_text_th);
}
else if (strcmp(tag_name, "h264_video_timing") == 0) {
if (ve_param->codecType != VENC_CODEC_H264 && ve_param->codecType != VENC_CODEC_H264_VER2) {
return ;
}
for (unsigned int i = 0; attr[i]; i += 2) {
parse_h264_video_timing_param(ve_param, attr, i);
}
if (ve_param->mH264VideoTiming.time_scale == 0)
ve_param->mH264VideoTiming.time_scale = ve_param->mH264VideoTiming.num_units_in_tick*ve_param->fps*2;
VencSetParameter(pVideoEnc, VENC_IndexParamH264VideoTiming, &ve_param->mH264VideoTiming);
}
else if (strcmp(tag_name, "h265_video_timing") == 0) {
if (ve_param->codecType != VENC_CODEC_H265) {
return ;
}
for (unsigned int i = 0; attr[i]; i += 2) {
parse_h265_video_timing_param(ve_param, attr, i);
}
if (ve_param->mH265VideoTiming.time_scale == 0)
ve_param->mH265VideoTiming.time_scale = ve_param->mH265VideoTiming.num_units_in_tick*ve_param->fps*2;
VencSetParameter(pVideoEnc, VENC_IndexParamH265Timing, &ve_param->mH265VideoTiming);
}
}
}
}
int ParserCreateAndParse(XML_Parser parser, VencParamFromFiles *p_ve_param, FILE *xml_file)
{
void *buf;
int bytes_read;
parser = XML_ParserCreate(NULL);
if (!parser) {
loge("Failed to create XML parser");
return -1;
}
XML_SetUserData(parser, p_ve_param);
XML_SetElementHandler(parser, start_parse_tag, end_parse_tag);
for (;;) {
buf = XML_GetBuffer(parser, BUF_SIZE);
if (buf == NULL) {
XML_ParserFree(parser);
return -1;
}
bytes_read = fread(buf, 1, BUF_SIZE, xml_file);
if (bytes_read < 0) {
XML_ParserFree(parser);
return -1;
}
if (XML_ParseBuffer(parser, bytes_read,
bytes_read == 0) == XML_STATUS_ERROR) {
loge("Error in demo config xml file");
XML_ParserFree(parser);
return -1;
}
if (bytes_read == 0)
break;
}
XML_ParserFree(parser);
return 0;
}
#ifdef __cplusplus
}
#endif /* __cplusplus */
Reference in New Issue View Git Blame Copy Permalink