From 8c13cd93b0626c150d79e37ded02b838be22670e Mon Sep 17 00:00:00 2001 From: Hongjin Li Date: Mon, 24 Jan 2022 14:23:56 +0800 Subject: [PATCH] [mpi_enc_test]: add slt testcase slt verify file: mpi_enc_test -w 4096 -h 2304 -t 7 -slt enc_xxx.verify -n 5 mpi_dec_test -i -t 7 -slt dec_xxx.verify -n 5 Change-Id: I528fcd8d1adf8821c1555790cd8482108f219fdc Signed-off-by: Hongjin Li --- test/mpi_dec_test.c | 27 ++++++++ test/mpi_enc_test.c | 17 +++++ utils/mpi_dec_utils.c | 23 +++++++ utils/mpi_dec_utils.h | 1 + utils/mpi_enc_utils.c | 21 +++++++ utils/mpi_enc_utils.h | 1 + utils/utils.c | 142 ++++++++++++++++++++++++++++++++++-------- utils/utils.h | 3 +- 8 files changed, 208 insertions(+), 27 deletions(-) diff --git a/test/mpi_dec_test.c b/test/mpi_dec_test.c index 1770e22c..db54aa9a 100644 --- a/test/mpi_dec_test.c +++ b/test/mpi_dec_test.c @@ -55,6 +55,8 @@ typedef struct { float frame_rate; RK_S64 elapsed_time; RK_S64 delay; + FILE *fp_verify; + FrmCrc checkcrc; } MpiDecLoopData; static int dec_simple(MpiDecLoopData *data) @@ -68,6 +70,7 @@ static int dec_simple(MpiDecLoopData *data) MppPacket packet = data->packet; FileBufSlot *slot = NULL; RK_U32 quiet = data->quiet; + FrmCrc *checkcrc = &data->checkcrc; // when packet size is valid read the input binary file ret = reader_read(cmd->reader, &slot); @@ -274,6 +277,11 @@ static int dec_simple(MpiDecLoopData *data) if (data->fp_output && !err_info) dump_mpp_frame_to_file(frame, data->fp_output); + if (data->fp_verify) { + calc_frm_crc(frame, checkcrc); + write_frm_crc(data->fp_verify, checkcrc); + } + fps_calc_inc(cmd->fps); } frm_eos = mpp_frame_get_eos(frame); @@ -341,6 +349,7 @@ static int dec_advanced(MpiDecLoopData *data) MppTask task = NULL; RK_U32 quiet = data->quiet; FileBufSlot *slot = NULL; + FrmCrc *checkcrc = &data->checkcrc; ret = reader_index_read(cmd->reader, 0, &slot); mpp_assert(ret == MPP_OK); @@ -406,6 +415,11 @@ static int dec_advanced(MpiDecLoopData *data) if (data->fp_output) dump_mpp_frame_to_file(frame, data->fp_output); + if (data->fp_verify) { + calc_frm_crc(frame, checkcrc); + write_frm_crc(data->fp_verify, checkcrc); + } + mpp_log_q(quiet, "%p decoded frame %d\n", ctx, data->frame_count); data->frame_count++; @@ -472,6 +486,10 @@ void *thread_decode(void *arg) MppApi *mpi = data->mpi; RK_S64 t_s, t_e; + memset(&data->checkcrc, 0, sizeof(data->checkcrc)); + data->checkcrc.luma.sum = mpp_malloc(RK_ULONG, 512); + data->checkcrc.chroma.sum = mpp_malloc(RK_ULONG, 512); + t_s = mpp_time(); if (cmd->simple) { @@ -501,6 +519,9 @@ void *thread_decode(void *arg) data->frame_count, (RK_S64)(data->elapsed_time / 1000), (RK_S32)(data->delay / 1000), data->frame_rate); + MPP_FREE(data->checkcrc.luma.sum); + MPP_FREE(data->checkcrc.chroma.sum); + return NULL; } @@ -544,6 +565,12 @@ int dec_decode(MpiDecTestCmd *cmd) } } + if (cmd->file_slt) { + data.fp_verify = fopen(cmd->file_slt, "wt"); + if (!data.fp_verify) + mpp_err("failed to open verify file %s\n", cmd->file_slt); + } + if (cmd->simple) { ret = mpp_packet_init(&packet, NULL, 0); if (ret) { diff --git a/test/mpi_enc_test.c b/test/mpi_enc_test.c index d5513d55..368f2cee 100644 --- a/test/mpi_enc_test.c +++ b/test/mpi_enc_test.c @@ -53,6 +53,7 @@ typedef struct { // src and dst FILE *fp_input; FILE *fp_output; + FILE *fp_verify; /* encoder config set */ MppEncCfg cfg; @@ -196,6 +197,10 @@ MPP_RET test_ctx_init(MpiEncMultiCtxInfo *info) } } + p->fp_verify = fopen(cmd->file_slt, "wt"); + if (!p->fp_verify) + mpp_err("failed to open verify file %s\n", cmd->file_slt); + // update resource parameter switch (p->fmt & MPP_FRAME_FMT_MASK) { case MPP_FMT_YUV420SP: @@ -489,8 +494,12 @@ MPP_RET test_mpp_run(MpiEncMultiCtxInfo *info) RK_U32 quiet = cmd->quiet; RK_S32 chn = info->chn; RK_U32 cap_num = 0; + DataCrc checkcrc; MPP_RET ret = MPP_OK; + memset(&checkcrc, 0, sizeof(checkcrc)); + checkcrc.sum = mpp_malloc(RK_ULONG, 512); + if (p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC) { MppPacket packet = NULL; @@ -716,6 +725,12 @@ MPP_RET test_mpp_run(MpiEncMultiCtxInfo *info) if (p->fp_output) fwrite(ptr, 1, len, p->fp_output); + if (p->fp_verify && !p->pkt_eos) { + calc_data_crc((RK_U8 *)ptr, (RK_U32)len, &checkcrc); + mpp_log("p->frame_count=%d, len=%d\n", p->frame_count, len); + write_data_crc(p->fp_verify, &checkcrc); + } + log_len += snprintf(log_buf + log_len, log_size - log_len, "encoded frame %-4d", p->frame_count); @@ -778,6 +793,8 @@ MPP_RET test_mpp_run(MpiEncMultiCtxInfo *info) break; } RET: + MPP_FREE(checkcrc.sum); + return ret; } diff --git a/utils/mpi_dec_utils.c b/utils/mpi_dec_utils.c index f0369ffd..a8086f6f 100644 --- a/utils/mpi_dec_utils.c +++ b/utils/mpi_dec_utils.c @@ -86,6 +86,7 @@ OptionInfo mpi_dec_cmd[] = { {"n", "frame_number", "max output frame number"}, {"s", "instance_nb", "number of instances"}, {"v", "trace", "q - quiet f - show fps"}, + {"c", "verify_file", "verify file for slt check"}, {NULL}, }; @@ -573,6 +574,24 @@ RK_S32 mpi_dec_opt_v(void *ctx, const char *next) return 0; } +RK_S32 mpi_dec_opt_slt(void *ctx, const char *next) +{ + MpiDecTestCmd *cmd = (MpiDecTestCmd *)ctx; + + if (next) { + size_t len = strnlen(next, MAX_FILE_NAME_LENGTH); + if (len) { + cmd->file_slt = mpp_calloc(char, len + 1); + strncpy(cmd->file_slt, next, len); + + return 1; + } + } + + mpp_err("input slt verify file is invalid\n"); + return 0; +} + RK_S32 mpi_dec_opt_help(void *ctx, const char *next) { (void)ctx; @@ -591,6 +610,7 @@ static MppOptInfo dec_opts[] = { {"n", "frame_number", "max output frame number", mpi_dec_opt_n}, {"s", "instance_nb", "number of instances", mpi_dec_opt_s}, {"v", "trace option", "q - quiet f - show fps", mpi_dec_opt_v}, + {"slt", "slt file", "slt verify data file", mpi_dec_opt_slt}, {"help", "help", "show help", mpi_dec_opt_help}, }; @@ -695,6 +715,8 @@ RK_S32 mpi_dec_test_cmd_deinit(MpiDecTestCmd* cmd) cmd->reader = NULL; } + MPP_FREE(cmd->file_slt); + if (cmd->fps) { fps_calc_deinit(cmd->fps); cmd->fps = NULL; @@ -715,4 +737,5 @@ void mpi_dec_test_cmd_options(MpiDecTestCmd* cmd) mpp_log("height : %4d\n", cmd->height); mpp_log("type : %4d\n", cmd->type); mpp_log("max frames : %4d\n", cmd->frame_num); + mpp_log("verify : %s\n", cmd->file_slt); } diff --git a/utils/mpi_dec_utils.h b/utils/mpi_dec_utils.h index 702a24de..975a8536 100644 --- a/utils/mpi_dec_utils.h +++ b/utils/mpi_dec_utils.h @@ -63,6 +63,7 @@ typedef struct MpiDecTestCmd_t { /* runtime log flag */ RK_U32 quiet; RK_U32 trace_fps; + char *file_slt; } MpiDecTestCmd; extern OptionInfo mpi_dec_cmd[]; diff --git a/utils/mpi_enc_utils.c b/utils/mpi_enc_utils.c index ecdd4790..2ab7c324 100644 --- a/utils/mpi_enc_utils.c +++ b/utils/mpi_enc_utils.c @@ -418,6 +418,24 @@ RK_S32 mpi_enc_opt_ini(void *ctx, const char *next) return 0; } +RK_S32 mpi_enc_opt_slt(void *ctx, const char *next) +{ + MpiEncTestArgs *cmd = (MpiEncTestArgs *)ctx; + + if (next) { + size_t len = strnlen(next, MAX_FILE_NAME_LENGTH); + if (len) { + cmd->file_slt = mpp_calloc(char, len + 1); + strncpy(cmd->file_slt, next, len); + + return 1; + } + } + + mpp_err("input slt verify file is invalid\n"); + return 0; +} + RK_S32 mpi_enc_opt_help(void *ctx, const char *next) { (void)ctx; @@ -443,6 +461,7 @@ static MppOptInfo enc_opts[] = { {"v", "trace option", "q - quiet f - show fps", mpi_enc_opt_v}, {"l", "loop count", "loop encoding times for each frame", mpi_enc_opt_l}, {"ini", "ini file", "encoder extra ini config file", mpi_enc_opt_ini}, + {"slt", "slt file", "slt verify data file", mpi_enc_opt_slt}, }; static RK_U32 enc_opt_cnt = MPP_ARRAY_ELEMS(enc_opts); @@ -578,6 +597,7 @@ MPP_RET mpi_enc_test_cmd_put(MpiEncTestArgs* cmd) MPP_FREE(cmd->file_input); MPP_FREE(cmd->file_output); MPP_FREE(cmd->file_cfg); + MPP_FREE(cmd->file_slt); MPP_FREE(cmd); return MPP_OK; @@ -932,6 +952,7 @@ MPP_RET mpi_enc_test_cmd_show_opt(MpiEncTestArgs* cmd) mpp_log("height : %d\n", cmd->height); mpp_log("format : %d\n", cmd->format); mpp_log("type : %d\n", cmd->type); + mpp_log("verify : %s\n", cmd->file_slt); return MPP_OK; } diff --git a/utils/mpi_enc_utils.h b/utils/mpi_enc_utils.h index 39c32a03..d0986fe8 100644 --- a/utils/mpi_enc_utils.h +++ b/utils/mpi_enc_utils.h @@ -66,6 +66,7 @@ typedef struct MpiEncTestArgs_t { FpsCalc fps; RK_U32 psnr_en; RK_U32 ssim_en; + char *file_slt; } MpiEncTestArgs; #ifdef __cplusplus diff --git a/utils/utils.c b/utils/utils.c index 7e66ddd7..e8fb637e 100644 --- a/utils/utils.c +++ b/utils/utils.c @@ -26,6 +26,10 @@ #include "mpp_common.h" #include "utils.h" +#define MAX_HALF_WORD_SUM_CNT \ + ((RK_ULONG)((0-1) / ((1UL << ((__SIZEOF_POINTER__ * 8) / 2)) - 1))) +#define CAL_BYTE (__SIZEOF_POINTER__ >> 1) + void _show_options(int count, OptionInfo *options) { int i; @@ -187,17 +191,45 @@ void dump_mpp_frame_to_file(MppFrame frame, FILE *fp) } } +void wide_bit_sum(RK_U8 *data, RK_U32 len, RK_ULONG *sum) +{ + RK_U8 *data8 = NULL; + RK_U32 loop; + data8 = data; +#if __WORDSIZE == 32 + RK_U16 *data_rk = NULL; + data_rk = (RK_U16 *)data; +#elif __WORDSIZE == 64 + RK_U32 *data_rk = NULL; + data_rk = (RK_U32 *)data; +#endif + + for (loop = 0; loop < len / CAL_BYTE; loop++) { + *sum += data_rk[loop]; + } + for (loop = len / CAL_BYTE * CAL_BYTE; loop < len; loop++) { + *sum += data8[loop]; + } + + return; +} + void calc_data_crc(RK_U8 *dat, RK_U32 len, DataCrc *crc) { - RK_U32 i = 0; + RK_ULONG data_grp_byte_cnt = MAX_HALF_WORD_SUM_CNT * CAL_BYTE; + RK_U32 i = 0, grp_loop = 0; RK_U8 *dat8 = NULL; RK_U32 *dat32 = NULL; - RK_U32 sum = 0, xor = 0; + RK_U32 xor = 0; /*calc sum */ - dat8 = dat; - for (i = 0; i < len; i++) - sum += dat8[i]; + crc->sum_cnt = (len + data_grp_byte_cnt - 1) / data_grp_byte_cnt; + for (grp_loop = 0; grp_loop < len / data_grp_byte_cnt; grp_loop++) { + wide_bit_sum(&dat[grp_loop * data_grp_byte_cnt], data_grp_byte_cnt, &crc->sum[grp_loop]); + } + if (len % data_grp_byte_cnt) { + wide_bit_sum(&dat[grp_loop * data_grp_byte_cnt], len % data_grp_byte_cnt, &crc->sum[grp_loop]); + } /*calc xor */ dat32 = (RK_U32 *)dat; @@ -213,23 +245,34 @@ void calc_data_crc(RK_U8 *dat, RK_U32 len, DataCrc *crc) } crc->len = len; - crc->sum = sum; crc->vor = xor; } void write_data_crc(FILE *fp, DataCrc *crc) { + RK_U32 loop = 0; + if (fp) { - fprintf(fp, "%d, %08x, %08x\n", crc->len, crc->sum, crc->vor); + fprintf(fp, "%08d,", crc->len); + for (loop = 0; loop < crc->sum_cnt; loop++) { + fprintf(fp, " %lx,", crc->sum[loop]); + } + fprintf(fp, " %08x\n", crc->vor); fflush(fp); } } void read_data_crc(FILE *fp, DataCrc *crc) { + RK_U32 loop = 0; + if (fp) { RK_S32 ret = 0; - ret = fscanf(fp, "%d, %08x, %08x\n", &crc->len, &crc->sum, &crc->vor); + ret = fscanf(fp, "%8d", &crc->len); + for (loop = 0; loop < crc->sum_cnt; loop++) { + ret |= fscanf(fp, "%lx", &crc->sum[loop]); + } + ret |= fscanf(fp, "%08x", &crc->vor); if (ret == EOF) mpp_err_f("unexpected EOF found\n"); } @@ -237,64 +280,111 @@ void read_data_crc(FILE *fp, DataCrc *crc) void calc_frm_crc(MppFrame frame, FrmCrc *crc) { + RK_ULONG data_grp_byte_cnt = MAX_HALF_WORD_SUM_CNT * CAL_BYTE; + RK_U32 grp_line_cnt = 0; + RK_U32 grp_cnt = 0; + RK_U32 y = 0, x = 0; RK_U8 *dat8 = NULL; RK_U32 *dat32 = NULL; - RK_U32 sum = 0, xor = 0; + RK_U32 xor = 0; RK_U32 width = mpp_frame_get_width(frame); RK_U32 height = mpp_frame_get_height(frame); RK_U32 stride = mpp_frame_get_hor_stride(frame); RK_U8 *buf = (RK_U8 *)mpp_buffer_get_ptr(mpp_frame_get_buffer(frame)); - /* luma */ - dat8 = buf; - for (y = 0; y < height; y++) - for (x = 0; x < width; x++) - sum += dat8[y * stride + x]; + grp_line_cnt = data_grp_byte_cnt / ((width + CAL_BYTE - 1) / CAL_BYTE * CAL_BYTE); + /* luma */ + grp_cnt = (height + grp_line_cnt - 1) / grp_line_cnt; + crc->luma.sum_cnt = grp_cnt; + + dat8 = buf; + for (y = 0; y < height / grp_line_cnt * grp_line_cnt; y++) { + wide_bit_sum(&dat8[y * stride], width, &crc->luma.sum[y / grp_line_cnt]); + } + if (height % grp_line_cnt) { + for (y = height / grp_line_cnt * grp_line_cnt; y < height; y++) { + wide_bit_sum(&dat8[y * stride], width, &crc->luma.sum[y / grp_line_cnt]); + } + } + + dat8 = buf; for (y = 0; y < height; y++) { dat32 = (RK_U32 *)&dat8[y * stride]; for (x = 0; x < width / 4; x++) xor ^= dat32[x]; } crc->luma.len = height * width; - crc->luma.sum = sum; crc->luma.vor = xor; /* chroma */ - dat8 = buf + height * stride; - for (y = 0; y < height / 2; y++) - for (x = 0; x < width; x++) - sum += dat8[y * stride + x]; + grp_cnt = (height / 2 + grp_line_cnt - 1) / grp_line_cnt; + crc->chroma.sum_cnt = grp_cnt; + dat8 = buf + height * stride; + for (y = 0; y < height / 2 / grp_line_cnt * grp_line_cnt; y++) { + wide_bit_sum(&dat8[y * stride], width, &crc->chroma.sum[y / grp_line_cnt]); + } + if (height / 2 % grp_line_cnt) { + for (y = height / 2 / grp_line_cnt * grp_line_cnt; y < height / 2; y++) { + wide_bit_sum(&dat8[y * stride], width, &crc->chroma.sum[y / grp_line_cnt]); + } + } + + dat8 = buf + height * stride; for (y = 0; y < height / 2; y++) { dat32 = (RK_U32 *)&dat8[y * stride]; for (x = 0; x < width / 4; x++) xor ^= dat32[x]; } crc->chroma.len = height * width / 2; - crc->chroma.sum = sum; crc->chroma.vor = xor; } void write_frm_crc(FILE *fp, FrmCrc *crc) { + RK_U32 loop = 0; + if (fp) { - fprintf(fp, "%d, %08x, %08x, %d, %08x, %08x\n", - crc->luma.len, crc->luma.sum, crc->luma.vor, - crc->chroma.len, crc->chroma.sum, crc->chroma.vor); + // luma + fprintf(fp, "%d,", crc->luma.len); + for (loop = 0; loop < crc->luma.sum_cnt; loop++) { + fprintf(fp, " %lx,", crc->luma.sum[loop]); + } + fprintf(fp, " %08x,", crc->luma.vor); + + // chroma + fprintf(fp, " %d,", crc->chroma.len); + for (loop = 0; loop < crc->chroma.sum_cnt; loop++) { + fprintf(fp, " %lx,", crc->chroma.sum[loop]); + } + fprintf(fp, " %08x\n", crc->chroma.vor); + fflush(fp); } } void read_frm_crc(FILE *fp, FrmCrc *crc) { + RK_U32 loop = 0; + if (fp) { RK_S32 ret = 0; - ret = fscanf(fp, "%d, %08x, %08x, %d, %08x, %08x\n", - &crc->luma.len, &crc->luma.sum, &crc->luma.vor, - &crc->chroma.len, &crc->chroma.sum, &crc->chroma.vor); + // luma + ret = fscanf(fp, "%d", &crc->luma.len); + for (loop = 0; loop < crc->luma.sum_cnt; loop++) { + ret |= fscanf(fp, "%lx", &crc->luma.sum[loop]); + } + ret |= fscanf(fp, "%08x", &crc->luma.vor); + + // chroma + ret |= fscanf(fp, "%d", &crc->chroma.len); + for (loop = 0; loop < crc->chroma.sum_cnt; loop++) { + ret |= fscanf(fp, "%lx", &crc->chroma.sum[loop]); + } + ret |= fscanf(fp, "%08x", &crc->chroma.vor); if (ret == EOF) mpp_err_f("unexpected EOF found\n"); } diff --git a/utils/utils.h b/utils/utils.h index 8321231c..a642f844 100644 --- a/utils/utils.h +++ b/utils/utils.h @@ -30,7 +30,8 @@ typedef struct OptionInfo_t { typedef struct data_crc_t { RK_U32 len; - RK_U32 sum; + RK_U32 sum_cnt; + RK_ULONG *sum; RK_U32 vor; // value of the xor } DataCrc;