wrapper/libhevc-mirror
1
0
Fork 0
mirror of https://github.com/ittiam-systems/libhevc.git synced 2026-04-02 20:30:49 +07:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Decoder: add support for QP and block_type map export in library

Browse source 
Bug: 176469524

Test: hevcdec -c test.cfg
Test: atest -c android.mediav2.cts.CodecDecoderTest
Test: atest VtsHalMediaC2V1_0TargetVideoDecTest

Change-Id: I75aebd3c4121d3b8cb5a2a947f643abbff41810d
This commit is contained in:
Shivaansh Agrawal 2022-02-02 12:53:33 +05:30 • committed by Neelkamal Semwal
parent 104da7c893
commit f6dcd29208
11 changed files with 461 additions and 56 deletions
Download patch file Download diff file Expand all files Collapse all files

21
FrameInfo.md Executable file
View file

@ -0,0 +1,21 @@
## Frame Info exported from libHEVC
### Introduction
QP and CU type maps for H265 are defined for each 8x8 coding unit.
The QP values defined as unsigned 8-bit numbers can range from <1, 51> and CU type can be
INTER/INTRA/SKIP. HEVC defines them in ihevc_defs.h as PRED_MODE_INTER = 0, PRED_MODE_INTRA = 1
and PRED_MODE_SKIP = 2.
Set the “u4_frame_info_enable” flag to enable encoder/decoder to populate and return the qp values
and CU type data in its output structure ihevcd_cxa_video_decode_op_t via pu1_8x8_blk_qp_map and
pu1_8x8_blk_type_map.
### Mapping to the frame
Within a video sequence, CTUs of a fixed size (16x16, 32x32, or 64x64) can be further divided into
CUs of size as low as 8x8 pixels. A CU’s number of QP entries (each for 8x8 blocks) can range from
1 to 64. A frame with a resolution of WdxHt has a total of (align8(Wd) x align8(Ht)) / 64 entries
for QP and CU type map each. Qp and CU type values for each 8x8 block are stored in raster scan
order. Refer to ihevcd_cxa.h for details.
### Plugin/Application
The encoder/decoder keeps the QP and CU type map as a part of its output handle. The plugins can
access these data through the output structure.

38
decoder/ihevcd_api.c
View file

@ -438,6 +438,16 @@ static IV_API_CALL_STATUS_T api_check_struct_sanity(iv_obj_t *ps_handle,
return (IV_FAIL);
}
if(((codec_t *)(ps_handle->pv_codec_handle))->u1_enable_cu_info
&& !ps_ip->pu1_8x8_blk_qp_map && !ps_ip->pu1_8x8_blk_type_map)
{
ps_op->s_ivd_video_decode_op_t.u4_error_code |= 1
<< IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_video_decode_op_t.u4_error_code |=
IHEVCD_FRAME_INFO_OP_BUF_NULL;
return (IV_FAIL);
}
}
break;
@ -1196,6 +1206,11 @@ WORD32 ihevcd_allocate_static_bufs(iv_obj_t **pps_codec_obj,
ps_codec->i4_share_disp_buf = 0;
}
if (ps_create_ip->s_ivd_create_ip_t.u4_size == sizeof(ihevcd_cxa_create_ip_t))
{
ps_codec->u1_enable_cu_info = ps_create_ip->u4_enable_frame_info;
}
ps_codec->e_chroma_fmt = ps_create_ip->s_ivd_create_ip_t.e_output_format;
ps_codec->pf_aligned_alloc = pf_aligned_alloc;
@ -1906,7 +1921,7 @@ WORD32 ihevcd_allocate_dynamic_bufs(codec_t *ps_codec)
qp_const_flag_size /= 8;
/* QP changes at CU level - So store at 8x8 level */
num_8x8 = (ht * wd) / (MIN_CU_SIZE * MIN_CU_SIZE);
num_8x8 = (wd * ht) / (MIN_CU_SIZE * MIN_CU_SIZE);
qp_size = num_8x8;
/* To hold vertical boundary strength */
@ -2019,6 +2034,22 @@ WORD32 ihevcd_allocate_dynamic_bufs(codec_t *ps_codec)
memset(pv_buf, 0, size);
ps_codec->pv_tu_data = pv_buf;
/* CU info map to store qp and CU type at 8x8 level */
if(ps_codec->u1_enable_cu_info)
{
size = ((wd * ht) / (MIN_CU_SIZE * MIN_CU_SIZE)) * BUF_MGR_MAX_CNT;
pv_buf = ps_codec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
memset(pv_buf, 0, size);
ps_codec->pu1_qp_map_base = pv_buf;
pv_buf = ps_codec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
RETURN_IF((NULL == pv_buf), IV_FAIL);
memset(pv_buf, 0, size);
ps_codec->pu1_cu_type_map_base = pv_buf;
}
{
sps_t *ps_sps = (ps_codec->s_parse.ps_sps_base + ps_codec->i4_sps_id);
@ -2141,6 +2172,11 @@ WORD32 ihevcd_free_dynamic_bufs(codec_t *ps_codec)
ALIGNED_FREE(ps_codec, ps_codec->pv_mv_bank_buf_base);
ALIGNED_FREE(ps_codec, ps_codec->pu1_ref_pic_buf_base);
ALIGNED_FREE(ps_codec, ps_codec->pu1_cur_chroma_ref_buf);
if(ps_codec->u1_enable_cu_info)
{
ALIGNED_FREE(ps_codec, ps_codec->pu1_qp_map_base);
ALIGNED_FREE(ps_codec, ps_codec->pu1_cu_type_map_base);
}
ps_codec->u4_allocate_dynamic_done = 0;
return IV_SUCCESS;

87
decoder/ihevcd_cxa.h
View file

@ -129,6 +129,16 @@ typedef enum {
*/
IHEVCD_UNSUPPORTED_CHROMA_FMT_IDC,
/**
* Frame info output buffer null
*/
IHEVCD_FRAME_INFO_OP_BUF_NULL,
/**
* Frame info insufficient buffer
*/
IHEVCD_INSUFFICIENT_METADATA_BUFFER,
/**
* Generic failure
*/
@ -161,6 +171,11 @@ typedef struct {
typedef struct {
ivd_create_ip_t s_ivd_create_ip_t;
/**
* enable_frm_info
*/
UWORD32 u4_enable_frame_info;
}ihevcd_cxa_create_ip_t;
@ -178,8 +193,60 @@ typedef struct {
* ivd_video_decode_ip_t
*/
ivd_video_decode_ip_t s_ivd_video_decode_ip_t;
/**
* 8x8 block QP map
*/
UWORD8 *pu1_8x8_blk_qp_map;
/**
* 8x8 block type map
*/
UWORD8 *pu1_8x8_blk_type_map;
/**
* 8x8 block QP map size
*/
UWORD32 u4_8x8_blk_qp_map_size;
/**
* 8x8 block type map size
*/
UWORD32 u4_8x8_blk_type_map_size;
}ihevcd_cxa_video_decode_ip_t;
/*********************************************************************************/
/* QP and CU/Block type maps are defined for each 8x8 coding unit. */
/* QP can range from <1, 51> and block type can be INTER/INTRA/SKIP. */
/* */
/* A frame with a resolution of WdxHt has a total of */
/* (align8(Wd) x align8(Ht)) / 64 entries for QP and Block type map each. */
/* */
/* For example, for a frame of size 60x60 shown in the figure down, both */
/* maps (QP and Block type) have the same layout. */
/* Each block represents an 8x8 sub-block. Both width and height are aligned to */
/* next largest multiple of 8, 64 in this case. */
/* */
/* 0 8 16 24 32 40 48 56 64 */
/* 0 ------------------------------------------------ */
/* | 0th | 1st | 2nd | 3rd | 4th | 5th | 6th | 7th | */
/* 8 ------------------------------------------------ */
/* | 8th | 9th | 10th | - | - | - | - | - | */
/* 16 ------------------------------------------------ */
/* | - | - | - | - | - | - | - | - | */
/* 24 ------------------------------------------------ */
/* | - | - | - | - | - | - | - | - | */
/* 32 ------------------------------------------------ */
/* | - | - | - | - | - | - | - | - | */
/* 40 ------------------------------------------------ */
/* | - | - | - | - | - | - | - | - | */
/* 48 ------------------------------------------------ */
/* | - | - | - | - | - | - | - | - | */
/* 56 ------------------------------------------------ */
/* | - | - | - | - | - | - | - | - | */
/* 64 ------------------------------------------------ */
/* */
/*********************************************************************************/
typedef struct {
@ -187,6 +254,26 @@ typedef struct {
* ivd_video_decode_op_t
*/
ivd_video_decode_op_t s_ivd_video_decode_op_t;
/**
* 8x8 block QP map
*/
UWORD8 *pu1_8x8_blk_qp_map;
/**
* 8x8 block type map
*/
UWORD8 *pu1_8x8_blk_type_map;
/**
* 8x8 block QP map size
*/
UWORD32 u4_8x8_blk_qp_map_size;
/**
* 8x8 block type map size
*/
UWORD32 u4_8x8_blk_type_map_size;
}ihevcd_cxa_video_decode_op_t;

56
decoder/ihevcd_decode.c
View file

@ -363,6 +363,47 @@ static void ihevcd_fill_outargs(codec_t *ps_codec,
ps_codec->i4_flush_mode = 0;
}
if(ps_codec->u1_enable_cu_info && ps_dec_op->u4_output_present)
{
WORD32 info_map_dst_strd = ALIGN8(ps_codec->i4_wd) >> 3;
WORD32 info_map_src_strd = ALIGN64(ps_codec->i4_wd) >> 3;
WORD32 info_map_ht = ALIGN8(ps_codec->i4_ht);
UWORD32 info_map_size = (ALIGN8(ps_codec->i4_wd) * info_map_ht) >> 6;
WORD32 vert_8x8;
UWORD8 *pu1_out_qp_map, *pu1_qp_map;
UWORD8 *pu1_out_blk_type_map, *pu1_type_map;
if(ps_hevcd_dec_ip->pu1_8x8_blk_qp_map)
{
ps_hevcd_dec_op->pu1_8x8_blk_qp_map = ps_hevcd_dec_ip->pu1_8x8_blk_qp_map;
ps_hevcd_dec_op->u4_8x8_blk_qp_map_size = info_map_size;
pu1_out_qp_map = ps_hevcd_dec_op->pu1_8x8_blk_qp_map;
pu1_qp_map = ps_codec->as_buf_id_info_map[ps_codec->i4_disp_buf_id].pu1_qp_map;
for(vert_8x8 = 0; vert_8x8 < info_map_ht; vert_8x8++)
{
memcpy(pu1_out_qp_map, pu1_qp_map, info_map_dst_strd);
pu1_out_qp_map += info_map_dst_strd;
pu1_qp_map += info_map_src_strd;
}
}
if(ps_hevcd_dec_ip->pu1_8x8_blk_type_map)
{
ps_hevcd_dec_op->pu1_8x8_blk_type_map = ps_hevcd_dec_ip->pu1_8x8_blk_type_map;
ps_hevcd_dec_op->u4_8x8_blk_type_map_size = info_map_size;
pu1_out_blk_type_map = ps_hevcd_dec_op->pu1_8x8_blk_type_map;
pu1_type_map =
ps_codec->as_buf_id_info_map[ps_codec->i4_disp_buf_id].pu1_cu_type_map;
for(vert_8x8 = 0; vert_8x8 < info_map_ht; vert_8x8++)
{
memcpy(pu1_out_blk_type_map, pu1_type_map, info_map_dst_strd);
pu1_out_blk_type_map += info_map_dst_strd;
pu1_type_map += info_map_src_strd;
}
}
}
}
/**
@ -440,6 +481,21 @@ WORD32 ihevcd_decode(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op)
return IV_FAIL;
}
if(ps_codec->u1_enable_cu_info && ps_codec->i4_sps_done)
{
UWORD32 blk_qp_map_size = ps_hevcd_dec_ip->u4_8x8_blk_qp_map_size;
UWORD32 blk_type_map_size = ps_hevcd_dec_ip->u4_8x8_blk_type_map_size;
UWORD32 blk_8x8_map_size = (ALIGN8(ps_codec->i4_wd) * ALIGN8(ps_codec->i4_ht)) >> 6;
if ((ps_hevcd_dec_ip->pu1_8x8_blk_qp_map && blk_qp_map_size < blk_8x8_map_size) ||
(ps_hevcd_dec_ip->pu1_8x8_blk_type_map && blk_type_map_size < blk_8x8_map_size))
{
ps_dec_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_dec_op->u4_error_code |= IHEVCD_INSUFFICIENT_METADATA_BUFFER;
return IV_FAIL;
}
}
/* If reset flag is set, flush the existing buffers */
if(ps_codec->i4_reset_flag)
{

5
decoder/ihevcd_defs.h
View file

@ -102,6 +102,11 @@
*/
#define MAX_REF_CNT 32
/**
* Maximum number of CU info buffers
*/
#define MAX_CU_INFO_BUF_CNT MAX_REF_CNT
/*****************************************************************************/
/* Num cores releated defs */
/*****************************************************************************/

1
decoder/ihevcd_parse_headers.c
View file

@ -1943,6 +1943,7 @@ IHEVCD_ERROR_T ihevcd_parse_sps(codec_t *ps_codec)
ps_codec->i4_wd = ps_sps->i2_pic_width_in_luma_samples;
ps_codec->i4_ht = ps_sps->i2_pic_height_in_luma_samples;
ps_codec->u4_num_8x8_blks = ALIGN64(ps_codec->i4_wd) * ALIGN64(ps_codec->i4_ht) >> 6;
{
WORD32 ref_strd;

28
decoder/ihevcd_parse_slice.c
View file

@ -1851,6 +1851,7 @@ IHEVCD_ERROR_T ihevcd_parse_coding_quadtree(codec_t *ps_codec,
}
else
{
WORD32 qp = ps_codec->s_parse.u4_qp;
/* Set current group QP if current CU is aligned with the group */
{
WORD32 cu_pos_x = ps_codec->s_parse.s_cu.i4_pos_x << 3;
@ -1880,7 +1881,6 @@ IHEVCD_ERROR_T ihevcd_parse_coding_quadtree(codec_t *ps_codec,
WORD32 qpg_x;
WORD32 qpg_y;
WORD32 i, j;
WORD32 qp;
WORD32 cur_cu_offset;
tu_t *ps_tu = ps_codec->s_parse.ps_tu;
WORD32 cb_size = 1 << ps_codec->s_parse.s_cu.i4_log2_cb_size;
@ -1942,6 +1942,32 @@ IHEVCD_ERROR_T ihevcd_parse_coding_quadtree(codec_t *ps_codec,
}
}
/* Populate CU_info maps for current CU*/
if(ps_codec->u1_enable_cu_info)
{
WORD32 cu_info_map_stride = ALIGN64(ps_codec->i4_wd) >> 3;
UWORD8 num_8x8_blks = 1 << (log2_cb_size - 3);
WORD32 vert_8x8, horz_8x8;
UWORD8 *pu1_cur_cu_type_map =
ps_codec->as_buf_id_info_map[ps_codec->as_process[0].
i4_cur_pic_buf_id].pu1_cu_type_map;
UWORD8 *pu1_cur_qp_map =
ps_codec->as_buf_id_info_map[ps_codec->as_process[0].i4_cur_pic_buf_id].pu1_qp_map;
UWORD8 *pu1_cur_type_cu = pu1_cur_cu_type_map + (x0 >> 3) +
(y0 >> 3) * cu_info_map_stride;
UWORD8 *pu1_cur_qp_cu = pu1_cur_qp_map + (x0 >> 3) +
(y0 >> 3) * cu_info_map_stride;
for(vert_8x8 = 0; vert_8x8 < num_8x8_blks; vert_8x8++)
{
for(horz_8x8 = 0; horz_8x8 < num_8x8_blks; horz_8x8++)
{
pu1_cur_qp_cu[horz_8x8] = qp;
pu1_cur_type_cu[horz_8x8] = ps_codec->s_parse.s_cu.i4_pred_mode;
}
pu1_cur_qp_cu += cu_info_map_stride;
pu1_cur_type_cu += cu_info_map_stride;
}
}
}

41
decoder/ihevcd_structs.h
View file

@ -1556,6 +1556,22 @@ typedef struct
WORD32 i4_nctb;
}process_ctxt_t;
/**
* Reference mapping from pic_buf_id to pointers to corresponding qp_map and CU_type_map
*/
typedef struct
{
/**
* qp_map buffer
*/
UWORD8 *pu1_qp_map;
/**
* CU_type buffer
*/
UWORD8 *pu1_cu_type_map;
}ref_map_t;
typedef void (*pf_inter_pred)(void *,
void *,
WORD32,
@ -2005,6 +2021,31 @@ struct _codec_t
*/
UWORD32 u4_ts;
/**
* Enable CU_info
*/
UWORD8 u1_enable_cu_info;
/**
* Ref mapping from pic_buf_id to corresponding CU_info maps
*/
ref_map_t as_buf_id_info_map[MAX_CU_INFO_BUF_CNT];
/**
* Total no of 8x8 blocks in luma samples
*/
WORD32 u4_num_8x8_blks;
/**
* Pointer to base of qp_map buffer array
*/
UWORD8 *pu1_qp_map_base;
/**
* Pointer to base of CU_type_map buffer array
*/
UWORD8 *pu1_cu_type_map_base;
/**
* Pointer to base of Video parameter set structure array
*/

12
decoder/ihevcd_utils.c
View file

@ -1265,6 +1265,18 @@ IHEVCD_ERROR_T ihevcd_parse_pic_init(codec_t *ps_codec)
}
}
if(ps_codec->u1_enable_cu_info)
{
ps_codec->as_buf_id_info_map[cur_pic_buf_id].pu1_qp_map =
ps_codec->pu1_qp_map_base + (cur_pic_buf_id * ps_codec->u4_num_8x8_blks);
ps_codec->as_buf_id_info_map[cur_pic_buf_id].pu1_cu_type_map =
ps_codec->pu1_cu_type_map_base + (cur_pic_buf_id * ps_codec->u4_num_8x8_blks);
memset(ps_codec->as_buf_id_info_map[cur_pic_buf_id].pu1_qp_map,
0, ps_codec->u4_num_8x8_blks);
memset(ps_codec->as_buf_id_info_map[cur_pic_buf_id].pu1_qp_map,
0, ps_codec->u4_num_8x8_blks);
}
ps_codec->s_parse.s_deblk_ctxt.pu1_cur_pic_luma = pu1_cur_pic_luma;
ps_codec->s_parse.s_deblk_ctxt.pu1_cur_pic_chroma = pu1_cur_pic_chroma;

32
fuzzer/hevc_dec_fuzzer.cpp
View file

@ -111,8 +111,8 @@ Codec::~Codec() {}
void Codec::createCodec() {
IV_API_CALL_STATUS_T ret;
ihevcd_cxa_create_ip_t create_ip;
ihevcd_cxa_create_op_t create_op;
ihevcd_cxa_create_ip_t create_ip{};
ihevcd_cxa_create_op_t create_op{};
void *fxns = (void *)&ivd_api_function;
create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
@ -134,8 +134,8 @@ void Codec::createCodec() {
}
void Codec::deleteCodec() {
ivd_delete_ip_t delete_ip;
ivd_delete_op_t delete_op;
ivd_delete_ip_t delete_ip{};
ivd_delete_op_t delete_op{};
delete_ip.e_cmd = IVD_CMD_DELETE;
delete_ip.u4_size = sizeof(ivd_delete_ip_t);
@ -145,8 +145,8 @@ void Codec::deleteCodec() {
}
void Codec::resetCodec() {
ivd_ctl_reset_ip_t s_ctl_ip;
ivd_ctl_reset_op_t s_ctl_op;
ivd_ctl_reset_ip_t s_ctl_ip{};
ivd_ctl_reset_op_t s_ctl_op{};
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_RESET;
@ -157,8 +157,8 @@ void Codec::resetCodec() {
}
void Codec::setCores() {
ihevcd_cxa_ctl_set_num_cores_ip_t s_ctl_ip;
ihevcd_cxa_ctl_set_num_cores_op_t s_ctl_op;
ihevcd_cxa_ctl_set_num_cores_ip_t s_ctl_ip{};
ihevcd_cxa_ctl_set_num_cores_op_t s_ctl_op{};
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd =
@ -171,8 +171,8 @@ void Codec::setCores() {
}
void Codec::setParams(IVD_VIDEO_DECODE_MODE_T mode) {
ivd_ctl_set_config_ip_t s_ctl_ip;
ivd_ctl_set_config_op_t s_ctl_op;
ivd_ctl_set_config_ip_t s_ctl_ip{};
ivd_ctl_set_config_op_t s_ctl_op{};
s_ctl_ip.u4_disp_wd = 0;
s_ctl_ip.e_frm_skip_mode = IVD_SKIP_NONE;
@ -187,8 +187,8 @@ void Codec::setParams(IVD_VIDEO_DECODE_MODE_T mode) {
}
void Codec::setArchitecture(IVD_ARCH_T arch) {
ihevcd_cxa_ctl_set_processor_ip_t s_ctl_ip;
ihevcd_cxa_ctl_set_processor_op_t s_ctl_op;
ihevcd_cxa_ctl_set_processor_ip_t s_ctl_ip{};
ihevcd_cxa_ctl_set_processor_op_t s_ctl_op{};
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd =
@ -258,8 +258,8 @@ void Codec::decodeHeader(const uint8_t *data, size_t size) {
while (size > 0) {
IV_API_CALL_STATUS_T ret;
ivd_video_decode_ip_t dec_ip;
ivd_video_decode_op_t dec_op;
ivd_video_decode_ip_t dec_ip{};
ivd_video_decode_op_t dec_op{};
size_t bytes_consumed;
memset(&dec_ip, 0, sizeof(dec_ip));
@ -300,8 +300,8 @@ void Codec::decodeHeader(const uint8_t *data, size_t size) {
IV_API_CALL_STATUS_T Codec::decodeFrame(const uint8_t *data, size_t size,
size_t *bytesConsumed) {
IV_API_CALL_STATUS_T ret;
ivd_video_decode_ip_t dec_ip;
ivd_video_decode_op_t dec_op;
ivd_video_decode_ip_t dec_ip{};
ivd_video_decode_op_t dec_op{};
memset(&dec_ip, 0, sizeof(dec_ip));
memset(&dec_op, 0, sizeof(dec_op));

196
test/decoder/main.c
View file

@ -175,6 +175,7 @@ typedef struct
{
UWORD32 u4_piclen_flag;
UWORD32 u4_file_save_flag;
UWORD32 u4_frame_info_enable;
UWORD32 u4_chksum_save_flag;
UWORD32 u4_max_frm_ts;
IV_COLOR_FORMAT_T e_output_chroma_format;
@ -198,6 +199,8 @@ typedef struct
CHAR ac_piclen_fname[STRLENGTH];
CHAR ac_ip_fname[STRLENGTH];
CHAR ac_op_fname[STRLENGTH];
CHAR ac_qp_map_fname[STRLENGTH];
CHAR ac_blk_type_map_fname[STRLENGTH];
CHAR ac_op_chksum_fname[STRLENGTH];
ivd_out_bufdesc_t s_disp_buffers[MAX_DISP_BUFFERS];
iv_yuv_buf_t s_disp_frm_queue[MAX_DISP_BUFFERS];
@ -250,8 +253,11 @@ typedef enum
VERSION,
INPUT_FILE,
OUTPUT,
QP_MAP_FILE,
BLK_TYPE_MAP_FILE,
CHKSUM,
SAVE_OUTPUT,
SAVE_FRAME_INFO,
SAVE_CHKSUM,
CHROMA_FORMAT,
NUM_FRAMES,
@ -294,6 +300,10 @@ static const argument_t argument_mapping[] =
"Input file\n" },
{ "-o", "--output", OUTPUT,
"Output file\n" },
{ "--", "--qp_map_file", QP_MAP_FILE,
"QP map file\n\n" },
{ "--", "--blk_type_map_file", BLK_TYPE_MAP_FILE,
"Block Type Map file\n" },
{ "--", "--piclen", PICLEN,
"Flag to signal if the decoder has to use a file containing number of bytes in each picture to be fed in each call\n" },
{ "--", "--piclen_file", PICLEN_FILE,
@ -302,6 +312,8 @@ static const argument_t argument_mapping[] =
"Output MD5 Checksum file\n" },
{ "-s", "--save_output", SAVE_OUTPUT,
"Save Output file\n" },
{ "--", "--save_frame_info", SAVE_FRAME_INFO,
"Enable frame_info\n" },
{ "--", "--save_chksum", SAVE_CHKSUM,
"Save Check sum file\n" },
{ "--", "--chroma_format", CHROMA_FORMAT,
@ -866,12 +878,16 @@ void codec_exit(CHAR *pc_err_message)
/*****************************************************************************/
void dump_output(vid_dec_ctx_t *ps_app_ctx,
iv_yuv_buf_t *ps_disp_frm_buf,
ihevcd_cxa_video_decode_op_t *ps_hevcd_decode_op,
UWORD32 u4_disp_frm_id,
FILE *ps_op_file,
FILE *ps_qp_file,
FILE *ps_cu_type_file,
FILE *ps_op_chksum_file,
WORD32 i4_op_frm_ts,
UWORD32 file_save,
UWORD32 chksum_save)
UWORD32 chksum_save,
UWORD32 cu_info_save)
{
@ -918,9 +934,26 @@ void dump_output(vid_dec_ctx_t *ps_app_ctx,
release_disp_frame(ps_app_ctx->cocodec_obj, u4_disp_id);
if(0 == file_save && 0 == chksum_save)
if(0 == file_save && 0 == chksum_save && 0 == cu_info_save)
return;
if(0 != cu_info_save)
{
UWORD8 *buf;
if(ps_hevcd_decode_op->pu1_8x8_blk_qp_map && ps_qp_file)
{
buf = ps_hevcd_decode_op->pu1_8x8_blk_qp_map;
fwrite(buf, 1, ps_hevcd_decode_op->u4_8x8_blk_qp_map_size, ps_qp_file);
fflush(ps_qp_file);
}
if(ps_hevcd_decode_op->pu1_8x8_blk_type_map && ps_cu_type_file)
{
buf = ps_hevcd_decode_op->pu1_8x8_blk_type_map;
fwrite(buf, 1, ps_hevcd_decode_op->u4_8x8_blk_type_map_size, ps_cu_type_file);
fflush(ps_cu_type_file);
}
}
if(NULL == s_dump_disp_frm_buf.pv_y_buf)
return;
@ -1162,22 +1195,34 @@ void parse_argument(vid_dec_ctx_t *ps_app_ctx, CHAR *argument, CHAR *value)
case VERSION:
break;
case INPUT_FILE:
sscanf(value, "%s", ps_app_ctx->ac_ip_fname);
snprintf(value, STRLENGTH, "%s", ps_app_ctx->ac_ip_fname);
//input_passed = 1;
break;
case OUTPUT:
sscanf(value, "%s", ps_app_ctx->ac_op_fname);
snprintf(value, STRLENGTH, "%s", ps_app_ctx->ac_op_fname);
break;
case QP_MAP_FILE:
snprintf(value, STRLENGTH, "%s", ps_app_ctx->ac_qp_map_fname);
break;
case BLK_TYPE_MAP_FILE:
snprintf(value, STRLENGTH, "%s", ps_app_ctx->ac_blk_type_map_fname);
break;
case CHKSUM:
sscanf(value, "%s", ps_app_ctx->ac_op_chksum_fname);
snprintf(value, STRLENGTH, "%s", ps_app_ctx->ac_op_chksum_fname);
break;
case SAVE_OUTPUT:
sscanf(value, "%d", &ps_app_ctx->u4_file_save_flag);
break;
case SAVE_FRAME_INFO:
sscanf(value, "%d", &ps_app_ctx->u4_frame_info_enable);
break;
case SAVE_CHKSUM:
sscanf(value, "%d", &ps_app_ctx->u4_chksum_save_flag);
break;
@ -1287,7 +1332,7 @@ void parse_argument(vid_dec_ctx_t *ps_app_ctx, CHAR *argument, CHAR *value)
break;
case PICLEN_FILE:
sscanf(value, "%s", ps_app_ctx->ac_piclen_fname);
snprintf(value, STRLENGTH, "%s", ps_app_ctx->ac_piclen_fname);
break;
case INVALID:
@ -1596,6 +1641,10 @@ void flush_output(iv_obj_t *codec_obj,
UWORD8 *pu1_bs_buf,
UWORD32 *pu4_op_frm_ts,
FILE *ps_op_file,
FILE *ps_qp_file,
FILE *ps_cu_type_file,
UWORD8 *pu1_qp_map_buf,
UWORD8 *pu1_blk_type_map_buf,
FILE *ps_op_chksum_file,
UWORD32 u4_ip_frm_ts,
UWORD32 u4_bytes_remaining)
@ -1654,6 +1703,12 @@ void flush_output(iv_obj_t *codec_obj,
ps_out_buf->u4_num_bufs;
ps_video_decode_op->u4_size = sizeof(ihevcd_cxa_video_decode_op_t);
s_hevcd_video_decode_ip.pu1_8x8_blk_qp_map = pu1_qp_map_buf;
s_hevcd_video_decode_ip.pu1_8x8_blk_type_map = pu1_blk_type_map_buf;
s_hevcd_video_decode_ip.u4_8x8_blk_qp_map_size =
(ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
s_hevcd_video_decode_ip.u4_8x8_blk_type_map_size =
(ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
/*****************************************************************************/
/* API Call: Video Decode */
@ -1664,10 +1719,10 @@ void flush_output(iv_obj_t *codec_obj,
if(1 == ps_video_decode_op->u4_output_present)
{
dump_output(ps_app_ctx, &(ps_video_decode_op->s_disp_frm_buf),
ps_video_decode_op->u4_disp_buf_id, ps_op_file,
ps_op_chksum_file,
&s_hevcd_video_decode_op, ps_video_decode_op->u4_disp_buf_id,
ps_op_file, ps_qp_file, ps_cu_type_file, ps_op_chksum_file,
*pu4_op_frm_ts, ps_app_ctx->u4_file_save_flag,
ps_app_ctx->u4_chksum_save_flag);
ps_app_ctx->u4_chksum_save_flag, ps_app_ctx->u4_frame_info_enable);
(*pu4_op_frm_ts)++;
}
@ -1729,6 +1784,8 @@ int main(WORD32 argc, CHAR *argv[])
FILE *ps_piclen_file = NULL;
FILE *ps_ip_file = NULL;
FILE *ps_op_file = NULL;
FILE *ps_qp_file = NULL;
FILE *ps_cu_type_file = NULL;
FILE *ps_op_chksum_file = NULL;
WORD32 ret;
CHAR ac_error_str[STRLENGTH];
@ -1746,6 +1803,8 @@ int main(WORD32 argc, CHAR *argv[])
UWORD32 u4_ip_buf_len;
UWORD32 frm_cnt = 0;
WORD32 total_bytes_comsumed;
UWORD8 *pu1_qp_map_buf = NULL;
UWORD8 *pu1_blk_type_map_buf = NULL;
#ifdef PROFILE_ENABLE
UWORD32 u4_tot_cycles = 0;
@ -1819,6 +1878,7 @@ int main(WORD32 argc, CHAR *argv[])
s_app_ctx.display = 0;
s_app_ctx.full_screen = 0;
s_app_ctx.u4_piclen_flag = 0;
s_app_ctx.u4_frame_info_enable = 0;
s_app_ctx.fps = DEFAULT_FPS;
file_pos = 0;
total_bytes_comsumed = 0;
@ -1904,11 +1964,12 @@ int main(WORD32 argc, CHAR *argv[])
{
if(CONFIG == get_argument(argv[i]))
{
strcpy(ac_cfg_fname, argv[i + 1]);
strncpy(ac_cfg_fname, argv[i + 1], STRLENGTH);
ac_cfg_fname[STRLENGTH - 1] = '\0';
if((fp_cfg_file = fopen(ac_cfg_fname, "r")) == NULL)
{
sprintf(ac_error_str, "Could not open Configuration file %s",
ac_cfg_fname);
snprintf(ac_error_str, sizeof(ac_error_str),
"Could not open Configuration file %s", ac_cfg_fname);
codec_exit(ac_error_str);
}
read_cfg_file(&s_app_ctx, fp_cfg_file);
@ -1924,7 +1985,7 @@ int main(WORD32 argc, CHAR *argv[])
{
if((fp_cfg_file = fopen(ac_cfg_fname, "r")) == NULL)
{
sprintf(ac_error_str, "Could not open Configuration file %s",
snprintf(ac_error_str, sizeof(ac_error_str), "Could not open Configuration file %s",
ac_cfg_fname);
codec_exit(ac_error_str);
}
@ -1932,10 +1993,10 @@ int main(WORD32 argc, CHAR *argv[])
fclose(fp_cfg_file);
}
#else
sprintf(filename_with_path, "%s/%s", homedir, ac_cfg_fname);
snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", homedir, ac_cfg_fname);
if((fp_cfg_file = fopen(filename_with_path, "r")) == NULL)
{
sprintf(ac_error_str, "Could not open Configuration file %s",
snprintf(ac_error_str, sizeof(ac_error_str), "Could not open Configuration file %s",
ac_cfg_fname);
codec_exit(ac_error_str);
@ -1968,19 +2029,24 @@ int main(WORD32 argc, CHAR *argv[])
exit(-1);
}
if(1 == s_app_ctx.u4_frame_info_enable)
{
pu1_qp_map_buf = calloc(ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT >> 6, 1);
pu1_blk_type_map_buf = calloc(ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT >> 6, 1);
}
/***********************************************************************/
/* create the file object for input file */
/***********************************************************************/
#ifdef IOS
sprintf(filename_with_path, "%s/%s", homedir, s_app_ctx.ac_ip_fname);
snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", homedir, s_app_ctx.ac_ip_fname);
ps_ip_file = fopen(filename_with_path, "rb");
#else
ps_ip_file = fopen(s_app_ctx.ac_ip_fname, "rb");
#endif
if(NULL == ps_ip_file)
{
sprintf(ac_error_str, "Could not open input file %s",
snprintf(ac_error_str, sizeof(ac_error_str), "Could not open input file %s",
s_app_ctx.ac_ip_fname);
codec_exit(ac_error_str);
}
@ -1990,14 +2056,14 @@ int main(WORD32 argc, CHAR *argv[])
if(1 == s_app_ctx.u4_piclen_flag)
{
#ifdef IOS
sprintf(filename_with_path, "%s/%s", homedir, s_app_ctx.ac_piclen_fname);
snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", homedir, s_app_ctx.ac_piclen_fname);
ps_piclen_file = fopen(filename_with_path, "rb");
#else
ps_piclen_file = fopen(s_app_ctx.ac_piclen_fname, "rb");
#endif
if(NULL == ps_piclen_file)
{
sprintf(ac_error_str, "Could not open piclen file %s",
snprintf(ac_error_str, sizeof(ac_error_str), "Could not open piclen file %s",
s_app_ctx.ac_piclen_fname);
codec_exit(ac_error_str);
}
@ -2009,7 +2075,7 @@ int main(WORD32 argc, CHAR *argv[])
if(1 == s_app_ctx.u4_file_save_flag)
{
#ifdef IOS
sprintf(filename_with_path, "%s/%s", documentdir, s_app_ctx.ac_op_fname);
snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", documentdir, s_app_ctx.ac_op_fname);
ps_op_file = fopen(filename_with_path, "wb");
#else
ps_op_file = fopen(s_app_ctx.ac_op_fname, "wb");
@ -2017,26 +2083,52 @@ int main(WORD32 argc, CHAR *argv[])
if(NULL == ps_op_file)
{
sprintf(ac_error_str, "Could not open output file %s",
snprintf(ac_error_str, sizeof(ac_error_str), "Could not open output file %s",
s_app_ctx.ac_op_fname);
codec_exit(ac_error_str);
}
}
/***********************************************************************/
/* create the file object for cuinfo file */
/***********************************************************************/
if(1 == s_app_ctx.u4_frame_info_enable)
{
#ifdef IOS
snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", documentdir, s_app_ctx.ac_qp_map_fname);
ps_qp_file = fopen(filename_with_path, "wb");
snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", documentdir, s_app_ctx.ac_blk_type_map_fname);
ps_cu_type_file = fopen(filename_with_path, "wb");
#else
ps_qp_file = fopen(s_app_ctx.ac_qp_map_fname, "wb");
ps_cu_type_file = fopen(s_app_ctx.ac_blk_type_map_fname, "wb");
#endif
if(NULL == ps_qp_file)
{
snprintf(ac_error_str, sizeof(ac_error_str), "Could not open output file %s", s_app_ctx.ac_qp_map_fname);
}
if(NULL == ps_cu_type_file)
{
snprintf(ac_error_str, sizeof(ac_error_str), "Could not open output file %s", s_app_ctx.ac_blk_type_map_fname);
}
}
/***********************************************************************/
/* create the file object for check sum file */
/***********************************************************************/
if(1 == s_app_ctx.u4_chksum_save_flag)
{
#if IOS
sprintf(filename_with_path, "%s/%s", documentdir, s_app_ctx.ac_op_chksum_fname);
snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", documentdir, s_app_ctx.ac_op_chksum_fname);
ps_op_chksum_file = fopen(filename_with_path, "wb");
#else
ps_op_chksum_file = fopen(s_app_ctx.ac_op_chksum_fname, "wb");
#endif
if(NULL == ps_op_chksum_file)
{
sprintf(ac_error_str, "Could not open check sum file %s",
snprintf(ac_error_str, sizeof(ac_error_str), "Could not open check sum file %s",
s_app_ctx.ac_op_chksum_fname);
codec_exit(ac_error_str);
}
@ -2064,6 +2156,7 @@ int main(WORD32 argc, CHAR *argv[])
s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = NULL;
s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ihevcd_cxa_create_ip_t);
s_create_op.s_ivd_create_op_t.u4_size = sizeof(ihevcd_cxa_create_op_t);
s_create_ip.u4_enable_frame_info = s_app_ctx.u4_frame_info_enable;
@ -2132,10 +2225,10 @@ int main(WORD32 argc, CHAR *argv[])
}
flush_output(codec_obj, &s_app_ctx, ps_out_buf,
pu1_bs_buf, &u4_op_frm_ts,
ps_op_file, ps_op_chksum_file,
u4_ip_frm_ts, u4_bytes_remaining);
flush_output(codec_obj, &s_app_ctx, ps_out_buf, pu1_bs_buf, &u4_op_frm_ts,
ps_op_file, ps_qp_file, ps_cu_type_file,
pu1_qp_map_buf, pu1_blk_type_map_buf,
ps_op_chksum_file, u4_ip_frm_ts, u4_bytes_remaining);
/*****************************************************************************/
/* Decode header to get width and height and buffer sizes */
@ -2223,6 +2316,12 @@ int main(WORD32 argc, CHAR *argv[])
ps_video_decode_ip->u4_size = sizeof(ihevcd_cxa_video_decode_ip_t);
ps_video_decode_op->u4_size = sizeof(ihevcd_cxa_video_decode_op_t);
s_hevcd_video_decode_ip.pu1_8x8_blk_qp_map = pu1_qp_map_buf;
s_hevcd_video_decode_ip.pu1_8x8_blk_type_map = pu1_blk_type_map_buf;
s_hevcd_video_decode_ip.u4_8x8_blk_qp_map_size =
(ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
s_hevcd_video_decode_ip.u4_8x8_blk_type_map_size =
(ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
/*****************************************************************************/
/* API Call: Header Decode */
@ -2744,6 +2843,12 @@ int main(WORD32 argc, CHAR *argv[])
ps_out_buf->u4_num_bufs;
ps_video_decode_op->u4_size = sizeof(ihevcd_cxa_video_decode_op_t);
s_hevcd_video_decode_ip.pu1_8x8_blk_qp_map = pu1_qp_map_buf;
s_hevcd_video_decode_ip.pu1_8x8_blk_type_map = pu1_blk_type_map_buf;
s_hevcd_video_decode_ip.u4_8x8_blk_qp_map_size =
(ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
s_hevcd_video_decode_ip.u4_8x8_blk_type_map_size =
(ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
/* Get display buffer pointers */
if(1 == s_app_ctx.display)
@ -2826,10 +2931,10 @@ int main(WORD32 argc, CHAR *argv[])
ivd_ctl_reset_ip_t s_ctl_ip;
ivd_ctl_reset_op_t s_ctl_op;
flush_output(codec_obj, &s_app_ctx, ps_out_buf,
pu1_bs_buf, &u4_op_frm_ts,
ps_op_file, ps_op_chksum_file,
u4_ip_frm_ts, u4_bytes_remaining);
flush_output(codec_obj, &s_app_ctx, ps_out_buf, pu1_bs_buf, &u4_op_frm_ts,
ps_op_file, ps_qp_file, ps_cu_type_file,
pu1_qp_map_buf, pu1_blk_type_map_buf,
ps_op_chksum_file, u4_ip_frm_ts, u4_bytes_remaining);
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_RESET;
@ -2941,10 +3046,10 @@ int main(WORD32 argc, CHAR *argv[])
width = ps_video_decode_op->s_disp_frm_buf.u4_y_wd;
height = ps_video_decode_op->s_disp_frm_buf.u4_y_ht;
dump_output(&s_app_ctx, &(ps_video_decode_op->s_disp_frm_buf),
ps_video_decode_op->u4_disp_buf_id,
ps_op_file, ps_op_chksum_file,
&s_hevcd_video_decode_op, ps_video_decode_op->u4_disp_buf_id,
ps_op_file, ps_qp_file, ps_cu_type_file, ps_op_chksum_file,
u4_op_frm_ts, s_app_ctx.u4_file_save_flag,
s_app_ctx.u4_chksum_save_flag);
s_app_ctx.u4_chksum_save_flag, s_app_ctx.u4_frame_info_enable);
u4_op_frm_ts++;
}
@ -2963,10 +3068,11 @@ int main(WORD32 argc, CHAR *argv[])
/***********************************************************************/
/* To get the last decoded frames, call process with NULL input */
/***********************************************************************/
flush_output(codec_obj, &s_app_ctx, ps_out_buf,
pu1_bs_buf, &u4_op_frm_ts,
ps_op_file, ps_op_chksum_file,
u4_ip_frm_ts, u4_bytes_remaining);
flush_output(codec_obj, &s_app_ctx, ps_out_buf, pu1_bs_buf, &u4_op_frm_ts,
ps_op_file, ps_qp_file, ps_cu_type_file,
pu1_qp_map_buf, pu1_blk_type_map_buf,
ps_op_chksum_file, u4_ip_frm_ts, u4_bytes_remaining);
/* set disp_end flag */
s_app_ctx.quit = 1;
@ -3039,6 +3145,13 @@ int main(WORD32 argc, CHAR *argv[])
{
fclose(ps_op_chksum_file);
}
if(1 == s_app_ctx.u4_frame_info_enable)
{
if(NULL != ps_qp_file)
fclose(ps_qp_file);
if(NULL != ps_cu_type_file)
fclose(ps_cu_type_file);
}
}
@ -3054,6 +3167,13 @@ int main(WORD32 argc, CHAR *argv[])
free(ps_out_buf);
free(pu1_bs_buf);
if(1 == s_app_ctx.u4_frame_info_enable)
{
if(pu1_qp_map_buf)
free(pu1_qp_map_buf);
if(pu1_blk_type_map_buf)
free(pu1_blk_type_map_buf);
}
if(s_app_ctx.display_thread_handle)
free(s_app_ctx.display_thread_handle);