1869 lines
60 KiB
C
Executable File
1869 lines
60 KiB
C
Executable File
/*
|
|
* 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;
|
|
}
|