netease
/
SmartAudio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
SmartAudio/package/allwinner/tina_multimedia/libcedarc/demo/vencoderDemo/EncoderTest.c

1869 lines
60 KiB
C
Raw Permalink Normal View History

merge tinav3.06 code
2018-12-13 10:48:25 +00:00
/*
* Copyright (c) 2008-2016 Allwinner Technology Co. Ltd.
* All rights reserved.
*
* File : EncoderTest.c
* Description : EncoderTest
* History :
*
*/
#include "log.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "vencoder.h"
#include <sys/time.h>
#include <time.h>
#include <memoryAdapter.h>
#include <math.h>
#define DEMO_FILE_NAME_LEN 256
#define USE_H265_ENC
#define ROI_NUM 4
#define NO_READ_WRITE 0
//#define YU12_NV12
//#define USE_AFBC_INPUT
//#define YU12_NV21
//#define VBR
//#define USE_SVC
//#define USE_VIDEO_SIGNAL
//#define USE_ASPECT_RATIO
//#define USE_SUPER_FRAME
//#define GET_MB_INFO
//#define SET_MB_INFO
//#define SET_SMART
#define ALIGN_XXB(y, x) (((x) + ((y)-1)) & ~((y)-1))
#define my_printf() logd("func:%s, line:%d\n", __func__, __LINE__)
extern int gettimeofday(struct timeval *tv, struct timezone *tz);
static long long GetNowUs()
{
struct timeval now;
gettimeofday(&now, NULL);
return now.tv_sec * 1000000 + now.tv_usec;
}
long long time1=0;
long long time2=0;
long long time3=0;
typedef struct {
char intput_file[256];
char output_file[256];
char reference_file[256];
int compare_flag;
int compare_result;
unsigned int encode_frame_num;
unsigned int encode_format;
unsigned int src_size;
unsigned int dst_size;
unsigned int src_width;
unsigned int src_height;
unsigned int dst_width;
unsigned int dst_height;
int bit_rate;
int frame_rate;
int maxKeyFrame;
}encode_param_t;
typedef enum {
INPUT,
HELP,
ENCODE_FRAME_NUM,
ENCODE_FORMAT,
OUTPUT,
SRC_SIZE,
DST_SIZE,
COMPARE_FILE,
BIT_RATE,
INVALID
}ARGUMENT_T;
typedef struct {
char Short[8];
char Name[128];
ARGUMENT_T argument;
char Description[512];
}argument_t;
static const argument_t ArgumentMapping[] =
{
{ "-h", "--help", HELP,
"Print this help" },
{ "-i", "--input", INPUT,
"Input file path" },
{ "-n", "--encode_frame_num", ENCODE_FRAME_NUM,
"After encoder n frames, encoder stop" },
{ "-f", "--encode_format", ENCODE_FORMAT,
"0:h264 encoder, 1:jpeg_encoder, 3:h265 encoder" },
{ "-o", "--output", OUTPUT,
"output file path" },
{ "-s", "--srcsize", SRC_SIZE,
"src_size,can be 2160,1080,720,480,288" },
{ "-d", "--dstsize", DST_SIZE,
"dst_size,can be 2160,1080,720,480,288" },
{ "-c", "--compare", COMPARE_FILE,
"compare file:reference file path" },
{ "-b", "--bitrate", BIT_RATE,
"bitRate:kbps" },
};
typedef struct {
unsigned int width;
unsigned int height;
unsigned int width_aligh16;
unsigned int height_aligh16;
unsigned char* argb_addr;
unsigned int size;
}BitMapInfoS;
typedef struct {
EXIFInfo exifinfo;
int quality;
int jpeg_mode;
VencJpegVideoSignal vs;
int jpeg_biteRate;
int jpeg_frameRate;
VencBitRateRange bitRateRange;
VencOverlayInfoS sOverlayInfo;
}jpeg_func_t;
typedef struct {
VencHeaderData sps_pps_data;
VencH264Param h264Param;
VencMBModeCtrl h264MBMode;
VencMBInfo MBInfo;
VencH264FixQP fixQP;
VencSuperFrameConfig sSuperFrameCfg;
VencH264SVCSkip SVCSkip; // set SVC and skip_frame
VencH264AspectRatio sAspectRatio;
VencH264VideoSignal sVideoSignal;
VencCyclicIntraRefresh sIntraRefresh;
VencROIConfig sRoiConfig[ROI_NUM];
VeProcSet sVeProcInfo;
VencOverlayInfoS sOverlayInfo;
VencSmartFun sH264Smart;
}h264_func_t;
typedef struct {
VencH265Param h265Param;
VencH265GopStruct h265Gop;
VencHVS h265Hvs;
VencH265TendRatioCoef h265Trc;
VencSmartFun h265Smart;
VencMBModeCtrl h265MBMode;
VencMBInfo MBInfo;
VencH264FixQP fixQP;
VencSuperFrameConfig sSuperFrameCfg;
VencH264SVCSkip SVCSkip; // set SVC and skip_frame
VencH264AspectRatio sAspectRatio;
VencH264VideoSignal sVideoSignal;
VencCyclicIntraRefresh sIntraRefresh;
VencROIConfig sRoiConfig[ROI_NUM];
VencAlterFrameRateInfo sAlterFrameRateInfo;
int h265_rc_frame_total;
VeProcSet sVeProcInfo;
VencOverlayInfoS sOverlayInfo;
}h265_func_t;
jpeg_func_t jpeg_func;
h264_func_t h264_func;
h265_func_t h265_func;
BitMapInfoS bit_map_info[13] = {0};
int yu12_nv12(unsigned int width, unsigned int height, unsigned char *addr_uv,
unsigned char *addr_tmp_uv)
{
unsigned int i, chroma_bytes;
unsigned char *u_addr = NULL;
unsigned char *v_addr = NULL;
unsigned char *tmp_addr = NULL;
chroma_bytes = width*height/4;
u_addr = addr_uv;
v_addr = addr_uv + chroma_bytes;
tmp_addr = addr_tmp_uv;
for(i=0; i<chroma_bytes; i++)
{
*(tmp_addr++) = *(u_addr++);
*(tmp_addr++) = *(v_addr++);
}
memcpy(addr_uv, addr_tmp_uv, chroma_bytes*2);
return 0;
}
int yu12_nv21(unsigned int width, unsigned int height, unsigned char *addr_uv,
unsigned char *addr_tmp_uv)
{
unsigned int i, chroma_bytes;
unsigned char *u_addr = NULL;
unsigned char *v_addr = NULL;
unsigned char *tmp_addr = NULL;
chroma_bytes = width*height/4;
u_addr = addr_uv;
v_addr = addr_uv + chroma_bytes;
tmp_addr = addr_tmp_uv;
for(i=0; i<chroma_bytes; i++)
{
*(tmp_addr++) = *(v_addr++);
*(tmp_addr++) = *(u_addr++);
}
memcpy(addr_uv, addr_tmp_uv, chroma_bytes*2);
return 0;
}
ARGUMENT_T GetArgument(char *name)
{
int i = 0;
int num = sizeof(ArgumentMapping) / sizeof(argument_t);
while(i < num)
{
if((0 == strcmp(ArgumentMapping[i].Name, name)) ||
((0 == strcmp(ArgumentMapping[i].Short, name)) &&
(0 != strcmp(ArgumentMapping[i].Short, "--"))))
{
return ArgumentMapping[i].argument;
}
i++;
}
return INVALID;
}
static void PrintDemoUsage(void)
{
int i = 0;
int num = sizeof(ArgumentMapping) / sizeof(argument_t);
printf("Usage:");
while(i < num)
{
printf("%s %-32s %s", ArgumentMapping[i].Short, ArgumentMapping[i].Name,
ArgumentMapping[i].Description);
printf("\n");
i++;
}
}
void ParseArgument(encode_param_t *encode_param, char *argument, char *value)
{
ARGUMENT_T arg;
arg = GetArgument(argument);
switch(arg)
{
case HELP:
PrintDemoUsage();
exit(-1);
case INPUT:
memset(encode_param->intput_file, 0, sizeof(encode_param->intput_file));
sscanf(value, "%255s", encode_param->intput_file);
logd(" get input file: %s ", encode_param->intput_file);
break;
case ENCODE_FRAME_NUM:
sscanf(value, "%32u", &encode_param->encode_frame_num);
break;
case ENCODE_FORMAT:
sscanf(value, "%32u", &encode_param->encode_format);
break;
case OUTPUT:
memset(encode_param->output_file, 0, sizeof(encode_param->output_file));
sscanf(value, "%255s", encode_param->output_file);
logd(" get output file: %s ", encode_param->output_file);
break;
case SRC_SIZE:
sscanf(value, "%32u", &encode_param->src_size);
logd(" get src_size: %dp ", encode_param->src_size);
if(encode_param->src_size == 1080)
{
encode_param->src_width = 1920;
encode_param->src_height = 1080;
}
else if(encode_param->src_size == 720)
{
encode_param->src_width = 1280;
encode_param->src_height = 720;
}
else if(encode_param->src_size == 480)
{
encode_param->src_width = 640;
encode_param->src_height = 480;
}
else if(encode_param->src_size == 2160)
{
encode_param->src_width = 3840;
encode_param->src_height = 2160;
}
else if(encode_param->src_size == 288)
{
encode_param->src_width = 352;
encode_param->src_height = 288;
}
else
{
encode_param->src_width = 1280;
encode_param->src_height = 720;
logw("encoder demo only support the size 1080p,720p,480p, \
now use the default size 720p\n");
}
break;
case DST_SIZE:
sscanf(value, "%32u", &encode_param->dst_size);
logd(" get dst_size: %dp ", encode_param->dst_size);
if(encode_param->dst_size == 1080)
{
encode_param->dst_width = 1920;
encode_param->dst_height = 1080;
}
else if(encode_param->dst_size == 720)
{
encode_param->dst_width = 1280;
encode_param->dst_height = 720;
}
else if(encode_param->dst_size == 480)
{
encode_param->dst_width = 640;
encode_param->dst_height = 480;
}
else if(encode_param->dst_size == 2160)
{
encode_param->dst_width = 3840;
encode_param->dst_height = 2160;
}
else if(encode_param->dst_size == 288)
{
encode_param->dst_width = 352;
encode_param->dst_height = 288;
}
else
{
encode_param->dst_width = 1280;
encode_param->dst_height = 720;
logw("encoder demo only support the size 1080p,720p,480p,\
now use the default size 720p\n");
}
break;
case COMPARE_FILE:
memset(encode_param->reference_file, 0, sizeof(encode_param->reference_file));
sscanf(value, "%255s", encode_param->reference_file);
encode_param->compare_flag = 1;
logd(" get reference file: %s ", encode_param->reference_file);
break;
case BIT_RATE:
sscanf(value, "%32d", &encode_param->bit_rate);
logd(" bit rate: %d ", encode_param->bit_rate);
break;
case INVALID:
default:
logd("unknowed argument : %s", argument);
break;
}
}
int SeekPrefixNAL(char* begin)
{
unsigned int i;
char* pchar = begin;
char isPrefixNAL = 1;
char NAL[4] = {0x00, 0x00, 0x00, 0x01};
if(!pchar)
{
return -1;
}
for(i=0; i<4; i++)
{
if(pchar[i] != NAL[i])
{
isPrefixNAL = 0;
break;
}
}
if(isPrefixNAL == 1)
{
isPrefixNAL = 0;
char PrefixNAL[3] = {0x6e, 0x4e, 0x0e};
for(i=0; i<3; i++)
{
if(pchar[4] == PrefixNAL[i])
{
isPrefixNAL = 1;
break;
}
}
}
// read temporal_id
if(isPrefixNAL == 1)
{
char TemporalID = pchar[7];
TemporalID >>= 5;
return TemporalID;
}
return -1;
}
void init_jpeg_exif(EXIFInfo *exifinfo)
{
exifinfo->ThumbWidth = 640;
exifinfo->ThumbHeight = 480;
strcpy((char*)exifinfo->CameraMake, "allwinner make test");
strcpy((char*)exifinfo->CameraModel, "allwinner model test");
strcpy((char*)exifinfo->DateTime, "2014:02:21 10:54:05");
strcpy((char*)exifinfo->gpsProcessingMethod, "allwinner gps");
exifinfo->Orientation = 0;
exifinfo->ExposureTime.num = 2;
exifinfo->ExposureTime.den = 1000;
exifinfo->FNumber.num = 20;
exifinfo->FNumber.den = 10;
exifinfo->ISOSpeed = 50;
exifinfo->ExposureBiasValue.num= -4;
exifinfo->ExposureBiasValue.den= 1;
exifinfo->MeteringMode = 1;
exifinfo->FlashUsed = 0;
exifinfo->FocalLength.num = 1400;
exifinfo->FocalLength.den = 100;
exifinfo->DigitalZoomRatio.num = 4;
exifinfo->DigitalZoomRatio.den = 1;
exifinfo->WhiteBalance = 1;
exifinfo->ExposureMode = 1;
exifinfo->enableGpsInfo = 1;
exifinfo->gps_latitude = 23.2368;
exifinfo->gps_longitude = 24.3244;
exifinfo->gps_altitude = 1234.5;
exifinfo->gps_timestamp = (long)time(NULL);
strcpy((char*)exifinfo->CameraSerialNum, "123456789");
strcpy((char*)exifinfo->ImageName, "exif-name-test");
strcpy((char*)exifinfo->ImageDescription, "exif-descriptor-test");
}
void init_h265_gop(VencH265GopStruct *h265Gop)
{
h265Gop->gop_size = 8;
h265Gop->intra_period = 16;
h265Gop->use_lt_ref_flag = 1;
if(h265Gop->use_lt_ref_flag)
{
h265Gop->max_num_ref_pics = 2;
h265Gop->num_ref_idx_l0_default_active = 2;
h265Gop->num_ref_idx_l1_default_active = 2;
h265Gop->use_sps_rps_flag = 0;
}
else
{
h265Gop->max_num_ref_pics = 1;
h265Gop->num_ref_idx_l0_default_active = 1;
h265Gop->num_ref_idx_l1_default_active = 1;
h265Gop->use_sps_rps_flag = 1;
}
//1:user config the reference info; 0:encoder config the reference info
h265Gop->custom_rps_flag = 0;
if(1 == h265Gop->custom_rps_flag)
{
int pos = 0;
for (pos = 0; pos < h265Gop->gop_size; pos++)
{
h265Gop->ref_str[pos].slice_type = H265_P_SLICE;
h265Gop->ref_str[pos].poc = pos + 1;
h265Gop->ref_str[pos].qp_offset = 0;
h265Gop->ref_str[pos].tc_offset_div2 = 0;
h265Gop->ref_str[pos].beta_offset_div2 = 0;
h265Gop->ref_str[pos].num_ref_pics = 2;
h265Gop->ref_str[pos].reference_pics[0] = -1;
h265Gop->ref_str[pos].reference_pics[1] = -(pos + 1);
h265Gop->ref_str[pos].discard_pics[0] = -2;
h265Gop->ref_str[pos].lt_ref_flag = 1;
h265Gop->ref_str[pos].lt_ref_poc = 0;
h265Gop->ref_str[pos].predict = 1;
h265Gop->ref_str[pos].delta_rps_idx = 1;
h265Gop->ref_str[pos].delta_rps = -1;
h265Gop->ref_str[pos].num_ref_idcs = 3;
h265Gop->ref_str[pos].reference_idcs[0][0] = REF_IDC_DISCARD;
h265Gop->ref_str[pos].reference_idcs[0][1] = REF_IDC_CURRENT_USE;
h265Gop->ref_str[pos].reference_idcs[0][2] = REF_IDC_LONG_TERM;
}
h265Gop->ref_str[0].num_ref_pics = 1;
h265Gop->ref_str[0].reference_pics[1] = -1;
h265Gop->ref_str[0].discard_pics[1] = -(h265Gop->gop_size + 1);
h265Gop->ref_str[0].lt_ref_flag = 0;
h265Gop->ref_str[0].predict = 0;
h265Gop->ref_str[0].num_ref_idcs = 3;
h265Gop->ref_str[0].reference_idcs[0][1] = REF_IDC_CURRENT_USE;
h265Gop->ref_str[0].reference_idcs[0][2] = REF_IDC_DISCARD;
h265Gop->ref_str[1].num_ref_idcs = 2;
h265Gop->ref_str[1].reference_idcs[0][0] = REF_IDC_CURRENT_USE;
h265Gop->ref_str[1].reference_idcs[0][1] = REF_IDC_LONG_TERM;
h265Gop->ref_str[h265Gop->gop_size].slice_type = H265_IDR_SLICE;
h265Gop->ref_str[h265Gop->gop_size].poc = 0;
h265Gop->ref_str[h265Gop->gop_size].predict = 0;
if (h265Gop->use_lt_ref_flag)
{
h265Gop->ref_str[h265Gop->gop_size + 1].num_ref_pics = 1;
h265Gop->ref_str[h265Gop->gop_size + 1].reference_pics[0] = -1;
h265Gop->ref_str[h265Gop->gop_size + 1].delta_rps_idx = 1;
h265Gop->ref_str[h265Gop->gop_size + 1].delta_rps = -1;
h265Gop->ref_str[h265Gop->gop_size + 1].num_ref_idcs = 1;
h265Gop->ref_str[h265Gop->gop_size + 1].reference_idcs[0][0] = REF_IDC_CURRENT_USE;
}
}
}
void init_mb_mode(VencMBModeCtrl *pMBMode, encode_param_t *encode_param)
{
unsigned int mb_num;
unsigned int j;
mb_num = (ALIGN_XXB(16, encode_param->dst_width) >> 4)
* (ALIGN_XXB(16, encode_param->dst_height) >> 4);
pMBMode->p_info = malloc(sizeof(VencMBModeCtrlInfo) * mb_num);
pMBMode->mode_ctrl_en = 1;
for (j = 0; j < mb_num / 2; j++)
{
pMBMode->p_info[j].mb_en = 1;
pMBMode->p_info[j].mb_skip_flag = 0;
pMBMode->p_info[j].mb_qp = 22;
}
for (; j < mb_num; j++)
{
pMBMode->p_info[j].mb_en = 1;
pMBMode->p_info[j].mb_skip_flag = 0;
pMBMode->p_info[j].mb_qp = 32;
}
}
void init_mb_info(VencMBInfo *MBInfo, encode_param_t *encode_param)
{
if(encode_param->encode_format == VENC_CODEC_H265)
{
MBInfo->num_mb = (ALIGN_XXB(32, encode_param->dst_width) *
ALIGN_XXB(32, encode_param->dst_height)) >> 10;
}
else
{
MBInfo->num_mb = (ALIGN_XXB(16, encode_param->dst_width) *
ALIGN_XXB(16, encode_param->dst_height)) >> 8;
}
MBInfo->p_para = (VencMBInfoPara *)malloc(sizeof(VencMBInfoPara) * MBInfo->num_mb);
if(MBInfo->p_para == NULL)
{
loge("malloc MBInfo->p_para error\n");
return;
}
logv("mb_num:%d, mb_info_queue_addr:%p\n", MBInfo->num_mb, MBInfo->p_para);
}
void init_fix_qp(VencH264FixQP *fixQP)
{
fixQP->bEnable = 1;
fixQP->nIQp = 35;
fixQP->nPQp = 35;
}
void init_super_frame_cfg(VencSuperFrameConfig *sSuperFrameCfg)
{
sSuperFrameCfg->eSuperFrameMode = VENC_SUPERFRAME_NONE;
sSuperFrameCfg->nMaxIFrameBits = 30000*8;
sSuperFrameCfg->nMaxPFrameBits = 15000*8;
}
void init_svc_skip(VencH264SVCSkip *SVCSkip)
{
SVCSkip->nTemporalSVC = T_LAYER_4;
switch(SVCSkip->nTemporalSVC)
{
case T_LAYER_4:
SVCSkip->nSkipFrame = SKIP_8;
break;
case T_LAYER_3:
SVCSkip->nSkipFrame = SKIP_4;
break;
case T_LAYER_2:
SVCSkip->nSkipFrame = SKIP_2;
break;
default:
SVCSkip->nSkipFrame = NO_SKIP;
break;
}
}
void init_aspect_ratio(VencH264AspectRatio *sAspectRatio)
{
sAspectRatio->aspect_ratio_idc = 255;
sAspectRatio->sar_width = 4;
sAspectRatio->sar_height = 3;
}
void init_video_signal(VencH264VideoSignal *sVideoSignal)
{
sVideoSignal->video_format = 5;
sVideoSignal->src_colour_primaries = 0;
sVideoSignal->dst_colour_primaries = 1;
}
void init_intra_refresh(VencCyclicIntraRefresh *sIntraRefresh)
{
sIntraRefresh->bEnable = 1;
sIntraRefresh->nBlockNumber = 10;
}
void init_roi(VencROIConfig *sRoiConfig)
{
sRoiConfig[0].bEnable = 1;
sRoiConfig[0].index = 0;
sRoiConfig[0].nQPoffset = 10;
sRoiConfig[0].sRect.nLeft = 0;
sRoiConfig[0].sRect.nTop = 0;
sRoiConfig[0].sRect.nWidth = 1280;
sRoiConfig[0].sRect.nHeight = 320;
sRoiConfig[1].bEnable = 1;
sRoiConfig[1].index = 1;
sRoiConfig[1].nQPoffset = 10;
sRoiConfig[1].sRect.nLeft = 320;
sRoiConfig[1].sRect.nTop = 180;
sRoiConfig[1].sRect.nWidth = 320;
sRoiConfig[1].sRect.nHeight = 180;
sRoiConfig[2].bEnable = 1;
sRoiConfig[2].index = 2;
sRoiConfig[2].nQPoffset = 10;
sRoiConfig[2].sRect.nLeft = 320;
sRoiConfig[2].sRect.nTop = 180;
sRoiConfig[2].sRect.nWidth = 320;
sRoiConfig[2].sRect.nHeight = 180;
sRoiConfig[3].bEnable = 1;
sRoiConfig[3].index = 3;
sRoiConfig[3].nQPoffset = 10;
sRoiConfig[3].sRect.nLeft = 320;
sRoiConfig[3].sRect.nTop = 180;
sRoiConfig[3].sRect.nWidth = 320;
sRoiConfig[3].sRect.nHeight = 180;
}
void init_alter_frame_rate_info(VencAlterFrameRateInfo *pAlterFrameRateInfo)
{
memset(pAlterFrameRateInfo, 0 , sizeof(VencAlterFrameRateInfo));
pAlterFrameRateInfo->bEnable = 1;
pAlterFrameRateInfo->bUseUserSetRoiInfo = 1;
pAlterFrameRateInfo->sRoiBgFrameRate.nSrcFrameRate = 25;
pAlterFrameRateInfo->sRoiBgFrameRate.nDstFrameRate = 5;
pAlterFrameRateInfo->roi_param[0].bEnable = 1;
pAlterFrameRateInfo->roi_param[0].index = 0;
pAlterFrameRateInfo->roi_param[0].nQPoffset = 10;
pAlterFrameRateInfo->roi_param[0].roi_abs_flag = 1;
pAlterFrameRateInfo->roi_param[0].sRect.nLeft = 0;
pAlterFrameRateInfo->roi_param[0].sRect.nTop = 0;
pAlterFrameRateInfo->roi_param[0].sRect.nWidth = 320;
pAlterFrameRateInfo->roi_param[0].sRect.nHeight = 320;
pAlterFrameRateInfo->roi_param[1].bEnable = 1;
pAlterFrameRateInfo->roi_param[1].index = 0;
pAlterFrameRateInfo->roi_param[1].nQPoffset = 10;
pAlterFrameRateInfo->roi_param[1].roi_abs_flag = 1;
pAlterFrameRateInfo->roi_param[1].sRect.nLeft = 320;
pAlterFrameRateInfo->roi_param[1].sRect.nTop = 320;
pAlterFrameRateInfo->roi_param[1].sRect.nWidth = 320;
pAlterFrameRateInfo->roi_param[1].sRect.nHeight = 320;
}
void init_enc_proc_info(VeProcSet *ve_proc_set)
{
ve_proc_set->bProcEnable = 1;
ve_proc_set->nProcFreq = 3;
}
void init_overlay_info(VencOverlayInfoS *pOverlayInfo)
{
int i;
unsigned char num_bitMap = 13;
BitMapInfoS* pBitMapInfo;
unsigned int time_id_list[19];
unsigned int start_mb_x;
unsigned int start_mb_y;
memset(pOverlayInfo, 0, sizeof(VencOverlayInfoS));
#if 0
char filename[64];
int ret;
for(i = 0; i < num_bitMap; i++)
{
FILE* icon_hdle = NULL;
int width = 0;
int height = 0;
sprintf(filename, "%s%d.bmp", "/mnt/libcedarc/bitmap/icon_720p_",i);
icon_hdle = fopen(filename, "r");
if (icon_hdle == NULL) {
printf("get wartermark %s error\n", filename);
return;
}
//get watermark picture size
fseek(icon_hdle, 18, SEEK_SET);
fread(&width, 1, 4, icon_hdle);
fread(&height, 1, 4, icon_hdle);
fseek(icon_hdle, 54, SEEK_SET);
bit_map_info[i].argb_addr = NULL;
bit_map_info[i].width = 0;
bit_map_info[i].height = 0;
bit_map_info[i].width = width;
bit_map_info[i].height = height*(-1);
bit_map_info[i].width_aligh16 = ALIGN_XXB(16, bit_map_info[i].width);
bit_map_info[i].height_aligh16 = ALIGN_XXB(16, bit_map_info[i].height);
if(bit_map_info[i].argb_addr == NULL) {
bit_map_info[i].argb_addr =
(unsigned char*)malloc(bit_map_info[i].width_aligh16*bit_map_info[i].height_aligh16*4);
if(bit_map_info[i].argb_addr == NULL)
{
loge("malloc bit_map_info[%d].argb_addr fail\n", i);
return;
}
}
logd("bitMap[%d] size[%d,%d], size_align16[%d, %d], argb_addr:%p\n", i,
bit_map_info[i].width,
bit_map_info[i].height,
bit_map_info[i].width_aligh16,
bit_map_info[i].height_aligh16,
bit_map_info[i].argb_addr);
ret = fread(bit_map_info[i].argb_addr, 1,
bit_map_info[i].width*bit_map_info[i].height*4, icon_hdle);
if(ret != bit_map_info[i].width*bit_map_info[i].height*4)
loge("read bitMap[%d] error, ret value:%d\n", i, ret);
bit_map_info[i].size = bit_map_info[i].width_aligh16 * bit_map_info[i].height_aligh16 * 4;
if (icon_hdle) {
fclose(icon_hdle);
icon_hdle = NULL;
}
}
//time 2017-04-27 18:28:26
time_id_list[0] = 2;
time_id_list[1] = 0;
time_id_list[2] = 1;
time_id_list[3] = 7;
time_id_list[4] = 11;
time_id_list[5] = 0;
time_id_list[6] = 4;
time_id_list[7] = 11;
time_id_list[8] = 2;
time_id_list[9] = 7;
time_id_list[10] = 10;
time_id_list[11] = 1;
time_id_list[12] = 8;
time_id_list[13] = 12;
time_id_list[14] = 2;
time_id_list[15] = 8;
time_id_list[16] = 12;
time_id_list[17] = 2;
time_id_list[18] = 6;
logd("pOverlayInfo:%p\n", pOverlayInfo);
pOverlayInfo->blk_num = 19;
#else
FILE* icon_hdle = NULL;
int width = 96;
int height = 48;
memset(time_id_list, 0 ,sizeof(time_id_list));
icon_hdle = fopen("/mnt/libcedarc/data_argb.dat", "r");
if (icon_hdle == NULL) {
printf("get icon_hdle error\n");
return;
}
for(i = 0; i < num_bitMap; i++)
{
bit_map_info[i].argb_addr = NULL;
bit_map_info[i].width = width;
bit_map_info[i].height = height;
bit_map_info[i].width_aligh16 = ALIGN_XXB(16, bit_map_info[i].width);
bit_map_info[i].height_aligh16 = ALIGN_XXB(16, bit_map_info[i].height);
if(bit_map_info[i].argb_addr == NULL) {
bit_map_info[i].argb_addr =
(unsigned char*)malloc(bit_map_info[i].width_aligh16*bit_map_info[i].height_aligh16*4);
if(bit_map_info[i].argb_addr == NULL)
{
loge("malloc bit_map_info[%d].argb_addr fail\n", i);
if (icon_hdle) {
fclose(icon_hdle);
icon_hdle = NULL;
}
return;
}
}
logv("bitMap[%d] size[%d,%d], size_align16[%d, %d], argb_addr:%p\n", i,
bit_map_info[i].width,
bit_map_info[i].height,
bit_map_info[i].width_aligh16,
bit_map_info[i].height_aligh16,
bit_map_info[i].argb_addr);
int ret;
ret = fread(bit_map_info[i].argb_addr, 1,
bit_map_info[i].width*bit_map_info[i].height*4, icon_hdle);
if(ret != bit_map_info[i].width*bit_map_info[i].height*4)
loge("read bitMap[%d] error, ret value:%d\n", i, ret);
bit_map_info[i].size
= bit_map_info[i].width_aligh16 * bit_map_info[i].height_aligh16 * 4;
}
if (icon_hdle) {
fclose(icon_hdle);
icon_hdle = NULL;
}
#endif
pOverlayInfo->argb_type = VENC_OVERLAY_ARGB8888;
pOverlayInfo->blk_num = 12;
logd("blk_num:%d, argb_type:%d\n", pOverlayInfo->blk_num, pOverlayInfo->argb_type);
start_mb_x = 0;
start_mb_y = 0;
for(i=0; i<pOverlayInfo->blk_num; i++)
{
//id = time_id_list[i];
//pBitMapInfo = &bit_map_info[id];
pBitMapInfo = &bit_map_info[i];
pOverlayInfo->overlayHeaderList[i].start_mb_x = start_mb_x;
pOverlayInfo->overlayHeaderList[i].start_mb_y = start_mb_y;
pOverlayInfo->overlayHeaderList[i].end_mb_x = start_mb_x
+ (pBitMapInfo->width_aligh16 / 16 - 1);
pOverlayInfo->overlayHeaderList[i].end_mb_y = start_mb_y
+ (pBitMapInfo->height_aligh16 / 16 -1);
pOverlayInfo->overlayHeaderList[i].extra_alpha_flag = 0;
pOverlayInfo->overlayHeaderList[i].extra_alpha = 8;
if(i%3 == 0)
pOverlayInfo->overlayHeaderList[i].overlay_type = LUMA_REVERSE_OVERLAY;
else if(i%2 == 0 && i!=0)
pOverlayInfo->overlayHeaderList[i].overlay_type = COVER_OVERLAY;
else
pOverlayInfo->overlayHeaderList[i].overlay_type = NORMAL_OVERLAY;
if(pOverlayInfo->overlayHeaderList[i].overlay_type == COVER_OVERLAY)
{
pOverlayInfo->overlayHeaderList[i].cover_yuv.cover_y = 0xa0;
pOverlayInfo->overlayHeaderList[i].cover_yuv.cover_u = 0xa0;
pOverlayInfo->overlayHeaderList[i].cover_yuv.cover_v = 0xa0;
}
pOverlayInfo->overlayHeaderList[i].overlay_blk_addr = pBitMapInfo->argb_addr;
pOverlayInfo->overlayHeaderList[i].bitmap_size = pBitMapInfo->size;
logv("blk_%d[%d], start_mb[%d,%d], end_mb[%d,%d],extra_alpha_flag:%d, extra_alpha:%d\n",
i,
time_id_list[i],
pOverlayInfo->overlayHeaderList[i].start_mb_x,
pOverlayInfo->overlayHeaderList[i].start_mb_y,
pOverlayInfo->overlayHeaderList[i].end_mb_x,
pOverlayInfo->overlayHeaderList[i].end_mb_y,
pOverlayInfo->overlayHeaderList[i].extra_alpha_flag,
pOverlayInfo->overlayHeaderList[i].extra_alpha);
logv("overlay_type:%d, cover_yuv[%d,%d,%d], overlay_blk_addr:%p, bitmap_size:%d\n",
pOverlayInfo->overlayHeaderList[i].overlay_type,
pOverlayInfo->overlayHeaderList[i].cover_yuv.cover_y,
pOverlayInfo->overlayHeaderList[i].cover_yuv.cover_u,
pOverlayInfo->overlayHeaderList[i].cover_yuv.cover_v,
pOverlayInfo->overlayHeaderList[i].overlay_blk_addr,
pOverlayInfo->overlayHeaderList[i].bitmap_size);
//if(i != 5)
{
start_mb_x += pBitMapInfo->width_aligh16 / 16;
start_mb_y += pBitMapInfo->height_aligh16 / 16;
}
}
return;
}
void init_jpeg_rate_ctrl(jpeg_func_t *jpeg_func)
{
jpeg_func->jpeg_biteRate = 12*1024*1024;
jpeg_func->jpeg_frameRate = 30;
jpeg_func->bitRateRange.bitRateMax = 14*1024*1024;
jpeg_func->bitRateRange.bitRateMin = 10*1024*1024;
}
int initH264Func(h264_func_t *h264_func, encode_param_t *encode_param)
{
memset(h264_func, 0, sizeof(h264_func_t));
//init h264Param
h264_func->h264Param.bEntropyCodingCABAC = 1;
h264_func->h264Param.nBitrate = encode_param->bit_rate;
h264_func->h264Param.nFramerate = encode_param->frame_rate;
h264_func->h264Param.nCodingMode = VENC_FRAME_CODING;
h264_func->h264Param.nMaxKeyInterval = encode_param->maxKeyFrame;
h264_func->h264Param.sProfileLevel.nProfile = VENC_H264ProfileHigh;
h264_func->h264Param.sProfileLevel.nLevel = VENC_H264Level51;
h264_func->h264Param.sQPRange.nMinqp = 10;
h264_func->h264Param.sQPRange.nMaxqp = 50;
h264_func->h264Param.bLongRefEnable = 1;
h264_func->h264Param.nLongRefPoc = 0;
#if 1
h264_func->sH264Smart.img_bin_en = 1;
h264_func->sH264Smart.img_bin_th = 27;
h264_func->sH264Smart.shift_bits = 2;
h264_func->sH264Smart.smart_fun_en = 1;
#endif
//init VencMBModeCtrl
init_mb_mode(&h264_func->h264MBMode, encode_param);
//init VencMBInfo
init_mb_info(&h264_func->MBInfo, encode_param);
//init VencH264FixQP
init_fix_qp(&h264_func->fixQP);
//init VencSuperFrameConfig
init_super_frame_cfg(&h264_func->sSuperFrameCfg);
//init VencH264SVCSkip
init_svc_skip(&h264_func->SVCSkip);
//init VencH264AspectRatio
init_aspect_ratio(&h264_func->sAspectRatio);
//init VencH264AspectRatio
init_video_signal(&h264_func->sVideoSignal);
//init CyclicIntraRefresh
init_intra_refresh(&h264_func->sIntraRefresh);
//init VencROIConfig
init_roi(h264_func->sRoiConfig);
//init proc info
init_enc_proc_info(&h264_func->sVeProcInfo);
//init VencOverlayConfig
init_overlay_info(&h264_func->sOverlayInfo);
return 0;
}
int initH265Func(h265_func_t *h265_func, encode_param_t *encode_param)
{
memset(h265_func, 0, sizeof(h264_func_t));
//init h265Param
h265_func->h265Param.nBitrate = encode_param->bit_rate;
h265_func->h265Param.nFramerate = encode_param->frame_rate;
h265_func->h265Param.sProfileLevel.nProfile = VENC_H265ProfileMain;
h265_func->h265Param.sProfileLevel.nLevel = VENC_H265Level41;
h265_func->h265Param.sQPRange.nMaxqp = 52;
h265_func->h265Param.sQPRange.nMinqp = 10;
h265_func->h265Param.nQPInit = 30;
h265_func->h265Param.idr_period = 30;
h265_func->h265Param.nGopSize = h265_func->h265Param.idr_period;
h265_func->h265Param.nIntraPeriod = h265_func->h265Param.idr_period;
h265_func->h265Param.bLongTermRef = 1;
#if 1
h265_func->h265Hvs.hvs_en = 1;
h265_func->h265Hvs.th_dir = 24;
h265_func->h265Hvs.th_coef_shift = 4;
h265_func->h265Trc.inter_tend = 63;
h265_func->h265Trc.skip_tend = 3;
h265_func->h265Trc.merge_tend = 0;
h265_func->h265Smart.img_bin_en = 1;
h265_func->h265Smart.img_bin_th = 27;
h265_func->h265Smart.shift_bits = 2;
h265_func->h265Smart.smart_fun_en = 1;
#endif
h265_func->h265_rc_frame_total = 20*h265_func->h265Param.nGopSize;
//init H265Gop
init_h265_gop(&h265_func->h265Gop);
//init VencMBModeCtrl
init_mb_mode(&h265_func->h265MBMode, encode_param);
//init VencMBInfo
init_mb_info(&h265_func->MBInfo, encode_param);
//init VencH264FixQP
init_fix_qp(&h265_func->fixQP);
//init VencSuperFrameConfig
init_super_frame_cfg(&h265_func->sSuperFrameCfg);
//init VencH264SVCSkip
init_svc_skip(&h265_func->SVCSkip);
//init VencH264AspectRatio
init_aspect_ratio(&h265_func->sAspectRatio);
//init VencH264AspectRatio
init_video_signal(&h265_func->sVideoSignal);
//init CyclicIntraRefresh
init_intra_refresh(&h265_func->sIntraRefresh);
//init VencROIConfig
init_roi(h265_func->sRoiConfig);
//init alter frameRate info
init_alter_frame_rate_info(&h265_func->sAlterFrameRateInfo);
//init proc info
init_enc_proc_info(&h265_func->sVeProcInfo);
//init VencOverlayConfig
init_overlay_info(&h265_func->sOverlayInfo);
return 0;
}
int initJpegFunc(jpeg_func_t *jpeg_func, encode_param_t *encode_param)
{
memset(jpeg_func, 0, sizeof(jpeg_func_t));
jpeg_func->quality = 95;
if(encode_param->encode_frame_num > 1)
jpeg_func->jpeg_mode = 1;
else
jpeg_func->jpeg_mode = 0;
if(0 == jpeg_func->jpeg_mode)
init_jpeg_exif(&jpeg_func->exifinfo);
else if(1 == jpeg_func->jpeg_mode)
init_jpeg_rate_ctrl(jpeg_func);
else
{
loge("encoder do not support the jpeg_mode:%d\n", jpeg_func->jpeg_mode);
return -1;
}
//init VencOverlayConfig
init_overlay_info(&jpeg_func->sOverlayInfo);
return 0;
}
int setEncParam(VideoEncoder *pVideoEnc ,encode_param_t *encode_param)
{
int result = 0;
if(encode_param->encode_format == VENC_CODEC_JPEG)
{
result = initJpegFunc(&jpeg_func, encode_param);
if(result)
{
loge("initJpegFunc error, return \n");
return -1;
}
if(1 == jpeg_func.jpeg_mode)
{
VideoEncSetParameter(pVideoEnc, VENC_IndexParamJpegEncMode, &jpeg_func.jpeg_mode);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamBitrate, &jpeg_func.jpeg_biteRate);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamFramerate, &jpeg_func.jpeg_frameRate);
VideoEncSetParameter(pVideoEnc,
VENC_IndexParamSetBitRateRange, &jpeg_func.bitRateRange);
}
else
{
unsigned int vbv_size = 4*1024*1024;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSetVbvSize, &vbv_size);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamJpegQuality, &jpeg_func.quality);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamJpegExifInfo, &jpeg_func.exifinfo);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSetOverlay, &jpeg_func.sOverlayInfo);
}
}
else if(encode_param->encode_format == VENC_CODEC_H264)
{
result = initH264Func(&h264_func, encode_param);
if(result)
{
loge("initH264Func error, return \n");
return -1;
}
unsigned int vbv_size = 12*1024*1024;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamH264Param, &h264_func.h264Param);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSetVbvSize, &vbv_size);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamH264FixQP, &h264_func.fixQP);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamSetOverlay, &h264_func.sOverlayInfo);
#ifdef GET_MB_INFO
VideoEncSetParameter(pVideoEnc, VENC_IndexParamMBInfoOutput, &h264_func.MBInfo);
#endif
#if 0
unsigned char value = 1;
//set the specify func
VideoEncSetParameter(pVideoEnc, VENC_IndexParamH264SVCSkip, &h264_func.SVCSkip);
value = 0;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamIfilter, &value);
value = 0; //degree
VideoEncSetParameter(pVideoEnc, VENC_IndexParamRotation, &value);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamH264FixQP, &h264_func.fixQP);
VideoEncSetParameter(pVideoEnc,
VENC_IndexParamH264CyclicIntraRefresh, &h264_func.sIntraRefresh);
value = 720/4;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSliceHeight, &value);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamROIConfig, &h264_func.sRoiConfig[0]);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamROIConfig, &h264_func.sRoiConfig[1]);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamROIConfig, &h264_func.sRoiConfig[2]);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamROIConfig, &h264_func.sRoiConfig[3]);
value = 0;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSetPSkip, &value);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamH264AspectRatio, &h264_func.sAspectRatio);
value = 0;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamFastEnc, &value);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamH264VideoSignal, &h264_func.sVideoSignal);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSuperFrameConfig, &h264_func.sSuperFrameCfg);
#endif
}
else if(encode_param->encode_format == VENC_CODEC_H265)
{
result = initH265Func(&h265_func, encode_param);
if(result)
{
loge("initH265Func error, return \n");
return -1;
}
unsigned int vbv_size = 12*1024*1024;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSetVbvSize, &vbv_size);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamH265Param, &h265_func.h265Param);
unsigned int value = 1;
//VideoEncSetParameter(pVideoEnc,
//VENC_IndexParamAlterFrame, &h265_func.sAlterFrameRateInfo);
VideoEncSetParameter(pVideoEnc, VENC_IndexParamChannelNum, &value);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamProcSet, &h265_func.sVeProcInfo);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamSetOverlay, &h265_func.sOverlayInfo);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamVirtualIFrame, &encode_param->frame_rate);
//value = 0;
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamPFrameIntraEn, &value);
//value = 1;
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamEncodeTimeEn, &value);
//VideoEncSetParameter(pVideoEnc,
//VENC_IndexParamH265ToalFramesNum, &h265_func.h265_rc_frame_total);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamH265Gop, &h265_func.h265Gop);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamROIConfig, &h265_func.sRoiConfig[0]);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamH264FixQP, &h265_func.fixQP);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamH265HVS, &h265_func.h265Hvs);
//VideoEncSetParameter(pVideoEnc, VENC_IndexParamH265TendRatioCoef, &h265_func.h265Trc);
#ifdef GET_MB_INFO
VideoEncSetParameter(pVideoEnc, VENC_IndexParamMBInfoOutput, &h265_func.MBInfo);
#endif
}
return 0;
}
void setMbMode(VideoEncoder *pVideoEnc, encode_param_t *encode_param)
{
if(encode_param->encode_format == VENC_CODEC_H264 && h264_func.h264MBMode.mode_ctrl_en)
{
VideoEncSetParameter(pVideoEnc, VENC_IndexParamMBModeCtrl, &h264_func.h264MBMode);
}
else if(encode_param->encode_format == VENC_CODEC_H265 && h265_func.h265MBMode.mode_ctrl_en)
{
VideoEncSetParameter(pVideoEnc, VENC_IndexParamMBModeCtrl, &h265_func.h265MBMode);
}
else
return;
}
void getMbMinfo(VideoEncoder *pVideoEnc, encode_param_t *encode_param)
{
#if 0
VencMBInfo *pMBInfo;
if(encode_param->encode_format == VENC_CODEC_H264 && h264_func.h264MBMode.mode_ctrl_en)
{
pMBInfo = &h264_func.MBInfo;
}
else if(encode_param->encode_format == VENC_CODEC_H265 && h265_func.h265MBMode.mode_ctrl_en)
{
pMBInfo = &h265_func.MBInfo;
}
else
return;
int i;
for(i = 0; i < pMBInfo->num_mb; i++)
{
logd("No.%d MB: mad=%d, qp=%d, sse=%d, psnr=%f\n",i,pMBInfo->p_para[i].mb_mad,
pMBInfo->p_para[i].mb_qp, pMBInfo->p_para[i].mb_sse, pMBInfo->p_para[i].mb_psnr);
}
#endif
}
void releaseMb(encode_param_t *encode_param)
{
VencMBInfo *pMBInfo;
VencMBModeCtrl *pMBMode;
if(encode_param->encode_format == VENC_CODEC_H264 && h264_func.h264MBMode.mode_ctrl_en)
{
pMBInfo = &h264_func.MBInfo;
pMBMode = &h264_func.h264MBMode;
}
else if(encode_param->encode_format == VENC_CODEC_H265 && h265_func.h265MBMode.mode_ctrl_en)
{
pMBInfo = &h264_func.MBInfo;
pMBMode = &h265_func.h265MBMode;
}
else
return;
if(pMBInfo->p_para)
free(pMBInfo->p_para);
if(pMBMode->p_info)
free(pMBMode->p_info);
}
int main(int argc, char** argv)
{
VencBaseConfig baseConfig;
VencAllocateBufferParam bufferParam;
VideoEncoder* pVideoEnc = NULL;
VencInputBuffer inputBuffer;
VencOutputBuffer outputBuffer;
VencHeaderData sps_pps_data;
unsigned char *uv_tmp_buffer = NULL;
unsigned int afbc_header_size;
int result = 0;
int i = 0;
long long pts = 0;
unsigned char yu12_nv12_flag = 0;
unsigned char yu12_nv21_flag = 0;
FILE *in_file = NULL;
FILE *out_file = NULL;
FILE *reference_file = NULL;
char *input_path = NULL;
char *output_path = NULL;
char *reference_path = NULL;
unsigned char *reference_buffer = NULL;
VencMBSumInfo sMbSumInfo;
memset(&sMbSumInfo, 0, sizeof(VencMBSumInfo));
unsigned long long sum_sse = 0;
unsigned long long min_sse = 0;
unsigned long long max_sse = 0;
unsigned long long avr_sse = 0;
unsigned int min_sse_frame = 0;
unsigned int max_sse_frame = 0;
/******** begin set the default encode param ********/
encode_param_t encode_param;
memset(&encode_param, 0, sizeof(encode_param));
encode_param.src_width = 1024;
encode_param.src_height = 1024;
encode_param.dst_width = 1024;
encode_param.dst_height = 1024;
encode_param.bit_rate = 20*1024*1024;
encode_param.frame_rate = 30;
encode_param.maxKeyFrame = 30;
encode_param.encode_format = VENC_CODEC_H265;
encode_param.encode_frame_num = 200;
strcpy((char*)encode_param.intput_file, "/data/camera/720p-30zhen.yuv");
strcpy((char*)encode_param.output_file, "/data/camera/720p.264");
strcpy((char*)encode_param.reference_file, "/mnt/bsp_ve_test/reference_data/reference.jpg");
if(encode_param.dst_width == 3840)
encode_param.bit_rate = 20*1024*1024;
else if(encode_param.dst_width == 1920)
encode_param.bit_rate = 10*1024*1024;
else if(encode_param.dst_width ==1280)
encode_param.bit_rate = 6*1024*1024;//6*1024*1024;
else if(encode_param.dst_width == 640)
encode_param.bit_rate = 2*1024*1024;
else if(encode_param.dst_width == 288)
encode_param.bit_rate = 1*1024*1024;
else
encode_param.bit_rate = 4*1024*1024;
/******** end set the default encode param ********/
/******** begin parse the config paramter ********/
if(argc >= 2)
{
for(i = 1; i < (int)argc; i += 2)
{
ParseArgument(&encode_param, argv[i], argv[i + 1]);
}
}
else
{
printf(" we need more arguments ");
PrintDemoUsage();
return 0;
}
/******** end parse the config paramter ********/
/******** begin open input , output and reference file ********/
input_path = encode_param.intput_file;
output_path = encode_param.output_file;
in_file = fopen(input_path, "r");
if(in_file == NULL)
{
loge("open in_file fail\n");
return -1;
}
out_file = fopen(output_path, "wb");
if(out_file == NULL)
{
loge("open out_file fail\n");
fclose(in_file);
return -1;
}
if(encode_param.compare_flag)
{
reference_path = encode_param.reference_file;
reference_file = fopen(reference_path, "r");
if(reference_file == NULL)
{
loge("open reference_file fail\n");
goto out;
}
reference_buffer = (unsigned char*)malloc(1*1024*1024);
if(reference_buffer == NULL)
{
loge("malloc reference_buffer error\n");
goto out;
}
}
/******** end open input , output and reference file ********/
/******** begin set baseConfig param********/
memset(&baseConfig, 0 ,sizeof(VencBaseConfig));
memset(&bufferParam, 0 ,sizeof(VencAllocateBufferParam));
baseConfig.memops = MemAdapterGetOpsS();
if (baseConfig.memops == NULL)
{
printf("MemAdapterGetOpsS failed\n");
goto out;
}
CdcMemOpen(baseConfig.memops);
baseConfig.nInputWidth= encode_param.src_width;
baseConfig.nInputHeight = encode_param.src_height;
baseConfig.nStride = encode_param.src_width;
baseConfig.nDstWidth = encode_param.dst_width;
baseConfig.nDstHeight = encode_param.dst_height;
/*
* the format of yuv file is yuv420p, but the old ic only support the yuv420sp,
* so use the func yu12_nv12() to config all the format.
*/
baseConfig.eInputFormat = VENC_PIXEL_YUV420P;
if(baseConfig.eInputFormat == VENC_PIXEL_YUV420P)
{
#ifdef YU12_NV12
baseConfig.eInputFormat = VENC_PIXEL_YUV420SP;
yu12_nv12_flag = 1;
#endif
#ifdef YU12_NV21
baseConfig.eInputFormat = VENC_PIXEL_YVU420SP;
yu12_nv21_flag = 1;
#endif
}
bufferParam.nSizeY = baseConfig.nInputWidth*baseConfig.nInputHeight;
bufferParam.nSizeC = baseConfig.nInputWidth*baseConfig.nInputHeight/2;
bufferParam.nBufferNum = 1;
#ifdef USE_AFBC_INPUT
afbc_header_size = ((baseConfig.nInputWidth +127)>>7)*((baseConfig.nInputHeight+31)>>5)*96;
logd("size_y:%x, size_c:%x, afbc_header:%x\n",
bufferParam.nSizeY,
bufferParam.nSizeC,
afbc_header_size);
bufferParam.nSizeY += afbc_header_size + bufferParam.nSizeC;
bufferParam.nSizeC = 0;
logd("afbc buffer size:%x\n", bufferParam.nSizeY);
baseConfig.eInputFormat = VENC_PIXEL_AFBC_AW;
#endif
/******** end set baseConfig param********/
//create encoder
logd("encode_param.encode_format:%d\n", encode_param.encode_format);
pVideoEnc = VideoEncCreate(encode_param.encode_format);
//set enc parameter
result = setEncParam(pVideoEnc ,&encode_param);
if(result)
{
loge("setEncParam error, return");
goto out;
}
VideoEncInit(pVideoEnc, &baseConfig);
if(encode_param.encode_format == VENC_CODEC_H264 || \
encode_param.encode_format == VENC_CODEC_H265)
{
unsigned int head_num = 0;
if(encode_param.encode_format == VENC_CODEC_H264)
{
VideoEncGetParameter(pVideoEnc, VENC_IndexParamH264SPSPPS, &sps_pps_data);
unsigned char value = 1;
//VideoEncGetParameter(pVideoEnc, VENC_IndexParamAllParams, &value);
}
else if(encode_param.encode_format == VENC_CODEC_H265)
{
VideoEncGetParameter(pVideoEnc, VENC_IndexParamH265Header, &sps_pps_data);
unsigned char value = 1;
//VideoEncGetParameter(pVideoEnc, VENC_IndexParamAllParams, &value);
}
fwrite(sps_pps_data.pBuffer, 1, sps_pps_data.nLength, out_file);
logd("sps_pps_data.nLength: %d", sps_pps_data.nLength);
//for(head_num=0; head_num<sps_pps_data.nLength; head_num++)
//logd("the sps_pps :%02x\n", *(sps_pps_data.pBuffer+head_num));
if(encode_param.compare_flag)
{
result = fread(reference_buffer, 1, sps_pps_data.nLength, reference_file);
if(result != sps_pps_data.nLength)
{
loge("read reference_file sps info error\n");
goto out;
}
for(i=0; i<sps_pps_data.nLength; i++)
{
if(sps_pps_data.pBuffer[i] != reference_buffer[i])
{
loge("the sps %d byte is not same, ref[%02x], cur[%02x]\n",
i,
reference_buffer[i],
sps_pps_data.pBuffer[i]);
goto out;
}
}
}
}
AllocInputBuffer(pVideoEnc, &bufferParam);
if(yu12_nv12_flag || yu12_nv21_flag)
{
uv_tmp_buffer = (unsigned char*)malloc(baseConfig.nInputWidth*baseConfig.nInputHeight/2);
if(uv_tmp_buffer == NULL)
{
loge("malloc uv_tmp_buffer fail\n");
goto out;
}
}
#ifdef USE_SVC
// used for throw frame test with SVC
int TemporalLayer = -1;
char p9bytes[9] = {0};
#endif
unsigned int testNumber = 0;
while(testNumber < encode_param.encode_frame_num)
{
GetOneAllocInputBuffer(pVideoEnc, &inputBuffer);
{
#if NO_READ_WRITE
if(testNumber == 0)
#endif
{
#ifdef USE_AFBC_INPUT
unsigned int size1, size2;
size1 = fread(inputBuffer.pAddrVirY, 1, bufferParam.nSizeY, in_file);
if(size1!= bufferParam.nSizeY)
{
fseek(in_file, 0L, SEEK_SET);
size1 = fread(inputBuffer.pAddrVirY, 1, bufferParam.nSizeY, in_file);
}
#else
unsigned int size1, size2;
size1 = fread(inputBuffer.pAddrVirY, 1,
baseConfig.nInputWidth*baseConfig.nInputHeight, in_file);
size2 = fread(inputBuffer.pAddrVirC, 1,
baseConfig.nInputWidth*baseConfig.nInputHeight/2, in_file);
if((size1!= baseConfig.nInputWidth*baseConfig.nInputHeight)
|| (size2!= baseConfig.nInputWidth*baseConfig.nInputHeight/2))
{
fseek(in_file, 0L, SEEK_SET);
size1 = fread(inputBuffer.pAddrVirY, 1,
baseConfig.nInputWidth*baseConfig.nInputHeight, in_file);
size2 = fread(inputBuffer.pAddrVirC, 1,
baseConfig.nInputWidth*baseConfig.nInputHeight/2, in_file);
}
if(yu12_nv12_flag)
{
yu12_nv12(baseConfig.nInputWidth, baseConfig.nInputHeight,
inputBuffer.pAddrVirC, uv_tmp_buffer);
}
else if(yu12_nv21_flag)
{
yu12_nv21(baseConfig.nInputWidth, baseConfig.nInputHeight,
inputBuffer.pAddrVirC, uv_tmp_buffer);
}
#endif
}
}
inputBuffer.bEnableCorp = 0;
inputBuffer.sCropInfo.nLeft = 240;
inputBuffer.sCropInfo.nTop = 240;
inputBuffer.sCropInfo.nWidth = 240;
inputBuffer.sCropInfo.nHeight = 240;
FlushCacheAllocInputBuffer(pVideoEnc, &inputBuffer);
pts += 1*1000/encode_param.frame_rate;
inputBuffer.nPts = pts;
AddOneInputBuffer(pVideoEnc, &inputBuffer);
#ifdef SET_MB_INFO
setMbMode(pVideoEnc, &encode_param);
#endif
#ifdef SET_SMART
if(testNumber == 0)
{
if(encode_param.encode_format == VENC_CODEC_H264)
{
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSmartFuntion, &h264_func.sH264Smart);
}
else if(encode_param.encode_format == VENC_CODEC_H265)
{
VideoEncSetParameter(pVideoEnc, VENC_IndexParamSmartFuntion, &h265_func.h265Smart);
}
}
#endif
#ifdef VBR
unsigned int bitRate = 50*1024*1024;
if(testNumber == 0)
{
VideoEncSetParameter(pVideoEnc, VENC_IndexParamBitrate, &bitRate);
}
if(testNumber == 90)
{
bitRate = 80*1024*1024;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamBitrate, &bitRate);
}
else if(testNumber == 180)
{
bitRate = 50*1024*1024;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamBitrate, &bitRate);
}
else if(testNumber == 250)
{
bitRate = 80*1024*1024;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamBitrate, &bitRate);
}
else if(testNumber == 1500)
{
bitRate = 50*1024*1024;
VideoEncSetParameter(pVideoEnc, VENC_IndexParamBitrate, &bitRate);
}
#endif
time1 = GetNowUs();
VideoEncodeOneFrame(pVideoEnc);
time2 = GetNowUs();
logv("encode frame %d use time is %lldus..\n",testNumber,(time2-time1));
logv("\n");
logv("\n");
time3 += time2-time1;
#ifdef GET_MB_INFO
getMbMinfo(pVideoEnc, &encode_param);
if(encode_param.encode_format == VENC_CODEC_H264)
{
VideoEncGetParameter(pVideoEnc, VENC_IndexParamMBSumInfoOutput, &sMbSumInfo);
}
else if(encode_param.encode_format == VENC_CODEC_H265)
{
VideoEncGetParameter(pVideoEnc, VENC_IndexParamMBSumInfoOutput, &sMbSumInfo);
}
avr_sse += sMbSumInfo.sum_sse;
sum_sse = avr_sse;
if(testNumber == 0)
{
min_sse = sMbSumInfo.sum_sse;
max_sse = sMbSumInfo.sum_sse;
}
else
{
if(sMbSumInfo.sum_sse < min_sse)
{
min_sse = sMbSumInfo.sum_sse;
min_sse_frame = testNumber;
}
else if(sMbSumInfo.sum_sse > max_sse)
{
max_sse = sMbSumInfo.sum_sse;
max_sse_frame = testNumber;
}
}
if(testNumber == (encode_param.encode_frame_num - 1))
{
double min_psnr, max_psnr, avr_psnr;
unsigned pic_size = encode_param.dst_width * encode_param.dst_height;
avr_sse /= encode_param.encode_frame_num;
max_psnr = 10.0 * log10(255.0 * 255.0 * 1024 / (1.0 * min_sse / pic_size));
min_psnr = 10.0 * log10(255.0 * 255.0 * 1024 / (1.0 * max_sse / pic_size));
avr_psnr = 10.0 * log10(255.0 * 255.0 * 1024 / (1.0 * avr_sse / pic_size));
logd("frame[%d] get min_psnr:%f, frame[%d] get max_psnr:%f, average_psnr:%f\n",
max_sse_frame,
min_psnr,
min_sse_frame,
max_psnr,
avr_psnr);
}
#endif
#if 0
VencEncodeTimeS sEncTime;
VideoEncGetParameter(pVideoEnc, VENC_IndexParamGetEncodeTime, &sEncTime);
logd("frame:%d, enc_time:%d, max_enc_time:%d, max_enc_time_frame:%d, avr_enc_time:%d",
sEncTime.frame_num, sEncTime.curr_enc_time, sEncTime.max_enc_time,
sEncTime.max_enc_time_frame_num,sEncTime.avr_enc_time);
logd("empty_time:%d, max_empty_time:%d, max_empty_time_frame:%d, avr_empty_time:%d\n",
sEncTime.curr_empty_time, sEncTime.max_empty_time,
sEncTime.max_empty_time_frame_num,sEncTime.avr_empty_time);
#endif
AlreadyUsedInputBuffer(pVideoEnc,&inputBuffer);
ReturnOneAllocInputBuffer(pVideoEnc, &inputBuffer);
result = GetOneBitstreamFrame(pVideoEnc, &outputBuffer);
#ifdef USE_SUPER_FRAME
if((sSuperFrameCfg.eSuperFrameMode==VENC_SUPERFRAME_DISCARD) && (result==-1))
{
logd("VENC_SUPERFRAME_DISCARD: discard frame %d\n",testNumber);
continue;
}
#endif
if(result == -1)
{
goto out;
}
#ifdef USE_SVC
// used for throw frame test with SVC
memcpy(p9bytes, outputBuffer.pData0, 9);
TemporalLayer = SeekPrefixNAL(p9bytes);
switch(TemporalLayer)
{
case 3:
case 2:
case 1:
logv("just write the PrefixNAL\n");
fwrite(outputBuffer.pData0, 1, 9, out_file);
break;
default:
logv("\nTemporalLayer=%d, testNumber=%d\n", TemporalLayer, testNumber);
fwrite(outputBuffer.pData0, 1, outputBuffer.nSize0, out_file);
//fwrite(outputBuffer.pData0+9, 1, outputBuffer.nSize0-9, out_file);
if(outputBuffer.nSize1)
{
fwrite(outputBuffer.pData1, 1, outputBuffer.nSize1, out_file);
}
break;
}
#else
#if NO_READ_WRITE
#else
fwrite(outputBuffer.pData0, 1, outputBuffer.nSize0, out_file);
if(outputBuffer.nSize1)
{
fwrite(outputBuffer.pData1, 1, outputBuffer.nSize1, out_file);
}
#endif
#endif
if(encode_param.compare_flag)
{
result = fread(reference_buffer, 1, outputBuffer.nSize0, reference_file);
if(result != outputBuffer.nSize0)
{
loge("read reference_file error\n");
goto out;
}
for(i=0; i<outputBuffer.nSize0; i++)
{
if(outputBuffer.pData0[i] != reference_buffer[i])
{
loge("the %d frame's ref_data_%d[%02x] and cur_data_%d[%02x] is not same\n",
testNumber,
i,
reference_buffer[i],
i,
outputBuffer.pData0[i]);
goto out;
}
}
result = fread(reference_buffer, 1, outputBuffer.nSize1, reference_file);
if(result != outputBuffer.nSize1)
{
loge("read reference_file error\n");
goto out;
}
for(i=0; i<outputBuffer.nSize1; i++)
{
if((outputBuffer.pData1)[i] != reference_buffer[i])
{
loge("the %d frame's data1 %d byte is not same\n", testNumber, i);
goto out;
}
}
}
FreeOneBitStreamFrame(pVideoEnc, &outputBuffer);
testNumber++;
}
if(encode_param.compare_flag)
{
encode_param.compare_result = 1;
logd("the compare result is ok\n");
}
logd("the average encode time is %lldus...\n",time3/testNumber);
if(pVideoEnc)
{
VideoEncDestroy(pVideoEnc);
}
pVideoEnc = NULL;
printf("output file is saved:%s\n",encode_param.output_file);
out:
if(out_file)
fclose(out_file);
if(in_file)
fclose(in_file);
if(uv_tmp_buffer)
free(uv_tmp_buffer);
if(baseConfig.memops)
{
CdcMemClose(baseConfig.memops);
}
releaseMb(&encode_param);
if(encode_param.compare_flag)
{
if(reference_buffer)
free(reference_buffer);
if(reference_file)
fclose(reference_file);
if(encode_param.compare_result)
{
logd("****************************************\n");
logd("the compare result is ok\n");
logd("the compare result is ok\n");
logd("the compare result is ok\n");
logd("****************************************\n");
}
else
{
logd("****************************************\n");
logd("the compare result is fail\n");
logd("the compare result is fail\n");
logd("the compare result is fail\n");
logd("****************************************\n");
return -1;
}
}
unsigned int bit_map_num;
for(bit_map_num=0; bit_map_num++; i<13)
{
if(bit_map_info[bit_map_num].argb_addr)
free(bit_map_info[bit_map_num].argb_addr);
}
return 0;
}