werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
06ee9615ad
unplugged-system/external/libavc/test/mvcdec/main.c

1545 lines
47 KiB
C
Raw Normal View History

Initial commit: AOSP 14 with modifications for Unplugged OS
2025-10-06 13:59:42 +00:00
/******************************************************************************
*
* Copyright (C) 2021 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*****************************************************************************
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/time.h>
#include "ih264_typedefs.h"
#include "iv.h"
#include "ivd.h"
#include "imvcd.h"
#include "ih264_debug.h"
#include "ih264d.h"
#include "ithread.h"
/* Constants */
#define DEFAULT_NON_DEGRADE_INTERVAL 4
#define MAX_DISP_BUFFERS 64
#define STRLENGTH 1000
#define PEAK_WINDOW_SIZE 8
#define DEFAULT_COLOR_FORMAT IV_YUV_420P
#define DEFAULT_NUM_CORES 1
#define MAX_ARG_SHORTNAME_LENGTH 4
#define MAX_ARG_NAME_LENGTH 128
#define MAX_ARG_DESC_LENGTH 512
#define MAX_NUM_VIEWS 6
#undef PROFILE_ENABLE
/* Macro functions */
#ifdef PROFILE_ENABLE
#define GETTIME(timer) gettimeofday(timer, NULL);
#define ELAPSEDTIME(s_start_timer, s_end_timer, s_elapsed_time, frequency) \
s_elapsed_time = ((s_end_timer.tv_sec - s_start_timer.tv_sec) * 1000000) + \
(s_end_timer.tv_usec - s_start_timer.tv_usec);
#else
#define GETTIME(timer)
#define ELAPSEDTIME(s_start_timer, s_end_timer, s_elapsed_time, frequency)
#endif
/* Typedefs */
typedef enum ARGUMENT_T
{
INVALID,
HELP,
INPUT_FILE,
OUTPUT,
CHKSUM,
SAVE_OUTPUT,
SAVE_CHKSUM,
NUM_FRAMES,
NUM_CORES,
DISABLE_DEBLOCK_LEVEL,
LOOPBACK,
CONFIG,
DEGRADE_TYPE,
DEGRADE_PICS,
ARCH
} ARGUMENT_T;
typedef enum COMPONENT_TYPES_T
{
Y = 0,
UV = 1,
U = 1,
V = 2,
NUM_SP_COMPONENTS = 2,
NUM_COMPONENTS = 3
} COMPONENT_TYPES_T;
#ifdef PROFILE_ENABLE
typedef struct timeval TIMER;
#else
typedef WORD32 TIMER;
#endif
typedef struct mvc_app_files_t
{
UWORD8 au1_ip_fname[STRLENGTH];
UWORD8 au1_op_fname[STRLENGTH];
UWORD8 au1_op_chksum_fname[STRLENGTH];
UWORD32 au4_disp_frm_id_queue[MAX_DISP_BUFFERS];
} mvc_app_files_t;
typedef struct mvc_dec_ctx_t
{
mvc_app_files_t s_mvc_app_files;
imvcd_get_buf_info_op_t s_disp_buf_props;
iv_yuv_buf_t as_view_disp_bufs[MAX_NUM_VIEWS];
iv_obj_t *ps_codec_obj;
IV_COLOR_FORMAT_T e_output_chroma_format;
IVD_ARCH_T e_arch;
IVD_SOC_T e_soc;
UWORD32 u4_max_frm_ts;
UWORD32 u4_disable_dblk_level;
WORD32 i4_degrade_type;
WORD32 i4_degrade_pics;
UWORD32 u4_num_cores;
UWORD32 u4_disp_delay;
UWORD32 u4_fps;
UWORD32 u4_pic_wd;
UWORD32 u4_pic_ht;
UWORD32 u4_loopback;
UWORD32 u4_file_save_flag;
UWORD32 u4_chksum_save_flag;
UWORD8 u1_quit;
} mvc_dec_ctx_t;
typedef struct argument_t
{
UWORD8 au1_argument_shortname[MAX_ARG_SHORTNAME_LENGTH];
UWORD8 au1_argument_name[MAX_ARG_NAME_LENGTH];
ARGUMENT_T e_argument;
UWORD8 au1_description[MAX_ARG_DESC_LENGTH];
} argument_t;
/* Function declarations */
#ifndef MD5_DISABLE
void calc_md5_cksum(UWORD8 *pu1_inbuf, UWORD32 u4_stride, UWORD32 u4_width, UWORD32 u4_height,
UWORD8 *pu1_cksum_p);
#else
#define calc_md5_cksum(a, b, c, d, e)
#endif
static inline void *mvcd_aligned_malloc(void *pv_ctxt, WORD32 alignment, WORD32 i4_size)
{
void *buf = NULL;
(void) pv_ctxt;
if(0 != posix_memalign(&buf, alignment, i4_size))
{
return NULL;
}
return buf;
}
static inline void mvcd_aligned_free(void *pv_ctxt, void *pv_buf)
{
(void) pv_ctxt;
free(pv_buf);
return;
}
static const argument_t argument_mapping[] = {
{"-h", "--help", HELP, "Print this help\n"},
{"-c", "--config", CONFIG, "config file (Default: test.cfg)\n"},
{"-i", "--input", INPUT_FILE, "Input file\n"},
{"-o", "--output", OUTPUT, "Output file\n"},
{"--", "--chksum", CHKSUM, "Output MD5 Checksum file\n"},
{"-s", "--save_output", SAVE_OUTPUT, "Save Output file\n"},
{"--", "--save_chksum", SAVE_CHKSUM, "Save Check sum file\n"},
{"-n", "--num_frames", NUM_FRAMES, "Number of frames to be decoded\n"},
{"--", "--num_cores", NUM_CORES, "Number of cores to be used\n"},
{"--", "--disable_deblock_level", DISABLE_DEBLOCK_LEVEL,
"Disable deblocking level : 0 to 4 - 0 Enable deblocking 4 Disable "
"deblocking completely\n"},
{"--", "--u4_loopback", LOOPBACK, "Enable playback in a loop\n"},
{"--", "--degrade_type", DEGRADE_TYPE,
"Degrade type : 0: No degrade 0th bit set : Disable SAO 1st bit set : "
"Disable deblocking 2nd bit set : Faster inter prediction filters 3rd bit "
"set : Fastest inter prediction filters\n"},
{"--", "--degrade_pics", DEGRADE_PICS,
"Degrade pics : 0 : No degrade 1 : Only on non-reference frames 2 : Do "
"not degrade every 4th or key frames 3 : All non-key frames 4 : All "
"frames\n"},
{"--", "--arch", ARCH,
"Set Architecture. Supported values - ARM_A9Q, ARMV8_GENERIC, "
"X86_GENERIC, X86_SSE4 \n"},
};
#if ANDROID_NDK
/*****************************************************************************/
/* */
/* Function Name : raise */
/* */
/* Description : Needed as a workaround when the application is built in */
/* Android NDK. This is an exception to be called for divide*/
/* by zero error */
/* */
/* Inputs : a */
/* Globals : */
/* Processing : None */
/* */
/* Outputs : */
/* Returns : */
/* */
/* Issues : */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes */
/* 07 09 2012 100189 Initial Version */
/* */
/*****************************************************************************/
static int raise(int a)
{
printf("Divide by zero\n");
return 0;
}
#endif
static void mvcd_print_usage(void)
{
WORD32 i = 0;
WORD32 num_entries = sizeof(argument_mapping) / sizeof(argument_t);
printf("\nUsage:\n");
while(i < num_entries)
{
printf("%-32s\t %s", argument_mapping[i].au1_argument_name,
argument_mapping[i].au1_description);
i++;
}
}
static ARGUMENT_T mvcd_get_argument(char *name)
{
WORD32 i = 0;
WORD32 num_entries = sizeof(argument_mapping) / sizeof(argument_t);
while(i < num_entries)
{
if((0 == strcmp((char *) argument_mapping[i].au1_argument_name, name)) ||
((0 == strcmp((char *) argument_mapping[i].au1_argument_shortname, name)) &&
(0 != strcmp((char *) argument_mapping[i].au1_argument_shortname, "--"))))
{
return argument_mapping[i].e_argument;
}
i++;
}
return INVALID;
}
static void mvcd_exit(UWORD8 *pu1_err_message)
{
printf("%s\n", pu1_err_message);
exit(-1);
}
static void mvcd_parse_argument(mvc_dec_ctx_t *ps_app_ctx, char *argument, char *value)
{
ARGUMENT_T arg;
arg = mvcd_get_argument((char *) argument);
switch(arg)
{
case HELP:
{
mvcd_print_usage();
exit(-1);
}
case INPUT_FILE:
{
sscanf(value, "%s", ps_app_ctx->s_mvc_app_files.au1_ip_fname);
break;
}
case OUTPUT:
{
sscanf(value, "%s", ps_app_ctx->s_mvc_app_files.au1_op_fname);
break;
}
case CHKSUM:
{
sscanf(value, "%s", ps_app_ctx->s_mvc_app_files.au1_op_chksum_fname);
break;
}
case SAVE_OUTPUT:
{
sscanf(value, "%u", &ps_app_ctx->u4_file_save_flag);
break;
}
case SAVE_CHKSUM:
{
sscanf(value, "%u", &ps_app_ctx->u4_chksum_save_flag);
break;
}
case NUM_FRAMES:
{
sscanf(value, "%u", &ps_app_ctx->u4_max_frm_ts);
break;
}
case NUM_CORES:
{
sscanf(value, "%u", &ps_app_ctx->u4_num_cores);
break;
}
case DEGRADE_PICS:
{
sscanf(value, "%d", &ps_app_ctx->i4_degrade_pics);
break;
}
case DEGRADE_TYPE:
{
sscanf(value, "%d", &ps_app_ctx->i4_degrade_type);
break;
}
case LOOPBACK:
{
sscanf(value, "%u", &ps_app_ctx->u4_loopback);
break;
}
case ARCH:
{
if((strcmp(value, "ARM_A9Q")) == 0)
{
ps_app_ctx->e_arch = ARCH_ARM_A9Q;
}
else if((strcmp(value, "X86_GENERIC")) == 0)
{
ps_app_ctx->e_arch = ARCH_X86_GENERIC;
}
else if((strcmp(value, "X86_SSSE3")) == 0)
{
ps_app_ctx->e_arch = ARCH_X86_SSSE3;
}
else if((strcmp(value, "X86_SSE42")) == 0)
{
ps_app_ctx->e_arch = ARCH_X86_SSE42;
}
else if((strcmp(value, "ARMV8_GENERIC")) == 0)
{
ps_app_ctx->e_arch = ARCH_ARMV8_GENERIC;
}
else
{
printf("\nInvalid Arch. Setting it to ARCH_ARMV8_GENERIC\n");
ps_app_ctx->e_arch = ARCH_ARMV8_GENERIC;
}
break;
}
case DISABLE_DEBLOCK_LEVEL:
{
sscanf(value, "%u", &ps_app_ctx->u4_disable_dblk_level);
break;
}
default:
{
printf("Ignoring argument : %s\n", argument);
break;
}
}
}
static void mvcd_read_cfg_file(mvc_dec_ctx_t *ps_app_ctx, FILE *ps_cfg_file)
{
char line[STRLENGTH];
char description[STRLENGTH];
char value[STRLENGTH];
char argument[STRLENGTH];
void *ret;
while(0 == feof(ps_cfg_file))
{
line[0] = '\0';
ret = fgets(line, STRLENGTH, ps_cfg_file);
if(NULL == ret) break;
argument[0] = '\0';
/* Reading Input File Name */
sscanf(line, "%s %s %s", argument, value, description);
if(argument[0] == '\0') continue;
mvcd_parse_argument(ps_app_ctx, argument, value);
}
}
static void mvcd_get_view_file_name(const UWORD8 *pu1_default_name, UWORD8 *pu1_view_file_name,
UWORD16 u2_view_id)
{
CHAR *apc_sub_str[2];
CHAR ac_string[STRLENGTH];
const CHAR ac_delimiters[] = ".";
strcpy(ac_string, (char *) pu1_default_name);
apc_sub_str[0] = strtok(ac_string, ac_delimiters);
apc_sub_str[1] = strtok(NULL, ac_delimiters);
ASSERT(NULL == strtok(NULL, ac_delimiters));
ASSERT((strlen(apc_sub_str[0]) + strlen(apc_sub_str[1]) + 3) < STRLENGTH);
sprintf((char *) pu1_view_file_name, "%s_%d.%s", apc_sub_str[0], u2_view_id, apc_sub_str[1]);
}
static IV_API_CALL_STATUS_T mvcd_in_buf_alloc(mvc_dec_ctx_t *ps_app_ctxt, UWORD8 **ppu1_bs_buf)
{
ppu1_bs_buf[0] =
(UWORD8 *) malloc(ps_app_ctxt->s_disp_buf_props.s_ivd_op.u4_min_in_buf_size[0]);
if(ppu1_bs_buf[0] == NULL)
{
return IV_FAIL;
}
return IV_SUCCESS;
}
static IV_API_CALL_STATUS_T mvcd_in_buf_free(UWORD8 *pu1_bs_buf)
{
free(pu1_bs_buf);
return IV_SUCCESS;
}
static IV_API_CALL_STATUS_T mvcd_out_buf_alloc(mvc_dec_ctx_t *ps_app_ctxt, ivd_out_bufdesc_t *ps_out_buf)
{
UWORD32 i;
UWORD16 u2_num_views = ps_app_ctxt->s_disp_buf_props.s_mvc_buf_info.u2_num_views;
if(ps_app_ctxt->s_disp_buf_props.s_ivd_op.u4_min_num_out_bufs < (NUM_COMPONENTS * u2_num_views))
{
return IV_FAIL;
}
ps_out_buf->u4_num_bufs = ps_app_ctxt->s_disp_buf_props.s_ivd_op.u4_min_num_out_bufs;
for(i = 0; i < ps_out_buf->u4_num_bufs; i++)
{
ps_out_buf->u4_min_out_buf_size[i] =
ps_app_ctxt->s_disp_buf_props.s_ivd_op.u4_min_out_buf_size[i];
ps_out_buf->pu1_bufs[i] =
(UWORD8 *) malloc(ps_app_ctxt->s_disp_buf_props.s_ivd_op.u4_min_out_buf_size[i]);
if(ps_out_buf->pu1_bufs[i] == NULL)
{
return IV_FAIL;
}
}
return IV_SUCCESS;
}
static IV_API_CALL_STATUS_T mvcd_out_buf_free(ivd_out_bufdesc_t *ps_out_buf)
{
UWORD32 i;
for(i = 0; i < ps_out_buf->u4_num_bufs; i++)
{
free(ps_out_buf->pu1_bufs[i]);
}
return IV_SUCCESS;
}
static void mvcd_output_write_stall(UWORD8 *au1_fname, UWORD32 u4_cur_frm_idx)
{
FILE *fp_fast_file = NULL;
const UWORD8 threshold = 64;
char past_fname[1000];
if(u4_cur_frm_idx >= threshold)
{
sprintf(past_fname, (char *) au1_fname, u4_cur_frm_idx - threshold);
do
{
fp_fast_file = fopen(past_fname, "rb");
if(fp_fast_file != NULL)
{
fclose(fp_fast_file);
/* Wait until the resource is released by a third party app*/
ithread_sleep(5000);
}
else
{
break;
}
} while(1);
}
}
static IV_API_CALL_STATUS_T mvcd_create_decoder(mvc_dec_ctx_t *ps_app_ctxt)
{
imvcd_create_ip_t s_create_ip;
imvcd_create_op_t s_create_op;
IV_API_CALL_STATUS_T ret;
s_create_ip.s_ivd_ip.e_cmd = IVD_CMD_CREATE;
s_create_ip.s_ivd_ip.e_output_format = ps_app_ctxt->e_output_chroma_format;
s_create_ip.s_ivd_ip.pf_aligned_alloc = mvcd_aligned_malloc;
s_create_ip.s_ivd_ip.pf_aligned_free = mvcd_aligned_free;
s_create_ip.s_ivd_ip.u4_share_disp_buf = 0;
s_create_ip.s_ivd_ip.pv_mem_ctxt = NULL;
s_create_ip.s_ivd_ip.u4_size = sizeof(s_create_ip.s_ivd_ip);
s_create_op.s_ivd_op.u4_size = sizeof(s_create_op.s_ivd_op);
ret = imvcd_api_function(NULL, &s_create_ip, &s_create_op);
if(ret != IV_SUCCESS)
{
return ret;
}
ps_app_ctxt->ps_codec_obj = (iv_obj_t *) s_create_op.s_ivd_op.pv_handle;
return IV_SUCCESS;
}
static IV_API_CALL_STATUS_T mvcd_set_decode_mode(mvc_dec_ctx_t *ps_app_ctxt,
IVD_VIDEO_DECODE_MODE_T e_decode_mode)
{
imvcd_set_config_ip_t s_ctl_ip;
imvcd_set_config_op_t s_ctl_op;
s_ctl_ip.s_ivd_ip.u4_size = sizeof(s_ctl_ip.s_ivd_ip);
s_ctl_op.s_ivd_op.u4_size = sizeof(s_ctl_op.s_ivd_op);
s_ctl_ip.s_ivd_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.s_ivd_ip.e_sub_cmd = (WORD32) IVD_CMD_CTL_SETPARAMS;
s_ctl_ip.s_ivd_ip.e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
s_ctl_ip.s_ivd_ip.e_frm_skip_mode = IVD_SKIP_NONE;
s_ctl_ip.s_ivd_ip.e_vid_dec_mode = e_decode_mode;
return imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_ctl_ip, &s_ctl_op);
}
static IV_API_CALL_STATUS_T mvcd_set_num_cores(mvc_dec_ctx_t *ps_app_ctxt)
{
imvcd_set_num_cores_ip_t s_ctl_ip;
imvcd_set_num_cores_op_t s_ctl_op;
s_ctl_ip.u4_size = sizeof(s_ctl_ip);
s_ctl_op.u4_size = sizeof(s_ctl_op);
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = (WORD32) IMVCD_CTL_SET_NUM_CORES;
s_ctl_ip.u4_num_cores = ps_app_ctxt->u4_num_cores;
return imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_ctl_ip, &s_ctl_op);
}
static IV_API_CALL_STATUS_T mvcd_set_arch(mvc_dec_ctx_t *ps_app_ctxt)
{
imvcd_set_arch_ip_t s_ctl_ip;
imvcd_set_arch_op_t s_ctl_op;
s_ctl_ip.u4_size = sizeof(s_ctl_ip);
s_ctl_op.u4_size = sizeof(s_ctl_op);
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = (WORD32) IMVCD_CTL_SET_PROCESSOR;
s_ctl_ip.e_arch = ps_app_ctxt->e_arch;
s_ctl_ip.e_soc = ps_app_ctxt->e_soc;
return imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_ctl_ip, &s_ctl_op);
}
static IV_API_CALL_STATUS_T mvcd_dump_output(mvc_dec_ctx_t *ps_app_ctxt,
iv_yuv_buf_t *ps_view_disp_bufs, FILE **pps_op_file,
FILE **pps_op_chksum_file, UWORD16 u2_num_views)
{
UWORD32 i, j;
UWORD32 u4_file_save = ps_app_ctxt->u4_file_save_flag;
UWORD32 u4_chksum_save = ps_app_ctxt->u4_chksum_save_flag;
if(!u4_file_save && !u4_chksum_save)
{
return IV_SUCCESS;
}
if(NULL == ps_view_disp_bufs->pv_y_buf)
{
return IV_FAIL;
}
for(i = 0; i < u2_num_views; i++)
{
iv_yuv_buf_t *ps_view_buf = &ps_view_disp_bufs[i];
if(ps_app_ctxt->e_output_chroma_format == IV_YUV_420P)
{
if(u4_file_save)
{
UWORD8 *pu1_buf = (UWORD8 *) ps_view_buf->pv_y_buf;
UWORD16 u2_width = ps_view_buf->u4_y_wd;
UWORD16 u2_height = ps_view_buf->u4_y_ht;
for(j = 0; j < u2_height; j++)
{
fwrite(pu1_buf, 1, u2_width, pps_op_file[i]);
pu1_buf += ps_view_buf->u4_y_strd;
}
pu1_buf = (UWORD8 *) ps_view_buf->pv_u_buf;
u2_width = ps_view_buf->u4_u_wd;
u2_height = ps_view_buf->u4_u_ht;
for(j = 0; j < u2_height; j++)
{
fwrite(pu1_buf, 1, u2_width, pps_op_file[i]);
pu1_buf += ps_view_buf->u4_u_strd;
}
pu1_buf = (UWORD8 *) ps_view_buf->pv_v_buf;
u2_width = ps_view_buf->u4_v_wd;
u2_height = ps_view_buf->u4_v_ht;
for(j = 0; j < u2_height; j++)
{
fwrite(pu1_buf, 1, u2_width, pps_op_file[i]);
pu1_buf += ps_view_buf->u4_v_strd;
}
}
#ifndef MD5_DISABLE
if(u4_chksum_save)
{
UWORD8 au1_cksum[16];
UWORD8 *pu1_buf = (UWORD8 *) ps_view_buf->pv_y_buf;
UWORD16 u2_width = ps_view_buf->u4_y_wd;
UWORD16 u2_height = ps_view_buf->u4_y_ht;
calc_md5_cksum(pu1_buf, ps_view_buf->u4_y_strd, u2_width, u2_height, au1_cksum);
fwrite(au1_cksum, sizeof(UWORD8), 16, pps_op_chksum_file[i]);
pu1_buf = (UWORD8 *) ps_view_buf->pv_u_buf;
u2_width = ps_view_buf->u4_u_wd;
u2_height = ps_view_buf->u4_u_ht;
calc_md5_cksum(pu1_buf, ps_view_buf->u4_u_strd, u2_width, u2_height, au1_cksum);
fwrite(au1_cksum, sizeof(UWORD8), 16, pps_op_chksum_file[i]);
pu1_buf = (UWORD8 *) ps_view_buf->pv_v_buf;
u2_width = ps_view_buf->u4_v_wd;
u2_height = ps_view_buf->u4_v_ht;
calc_md5_cksum(pu1_buf, ps_view_buf->u4_v_strd, u2_width, u2_height, au1_cksum);
fwrite(au1_cksum, sizeof(UWORD8), 16, pps_op_chksum_file[i]);
}
#endif
}
else
{
return IV_FAIL;
}
fflush(pps_op_file[i]);
fflush(pps_op_chksum_file[i]);
}
return IV_SUCCESS;
}
static IV_API_CALL_STATUS_T mvcd_flush(mvc_dec_ctx_t *ps_app_ctxt, ivd_out_bufdesc_t *ps_out_buf,
FILE **pps_op_file, FILE **pps_op_chksum_file, UWORD8 *pu1_bs_buf,
UWORD32 *pu4_op_frm_ts, UWORD32 u4_ip_frm_ts,
UWORD32 u4_bytes_remaining, UWORD16 u2_num_views)
{
IV_API_CALL_STATUS_T ret = IV_SUCCESS;
do
{
imvcd_flush_dec_ip_t s_ctl_ip;
imvcd_flush_dec_op_t s_ctl_op;
if(*(pu4_op_frm_ts) >= u4_ip_frm_ts)
{
break;
}
s_ctl_ip.s_ivd_ip.u4_size = sizeof(s_ctl_ip.s_ivd_ip);
s_ctl_op.s_ivd_op.u4_size = sizeof(s_ctl_op.s_ivd_op);
s_ctl_ip.s_ivd_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.s_ivd_ip.e_sub_cmd = (WORD32) IVD_CMD_CTL_FLUSH;
ret = imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_ctl_ip, &s_ctl_op);
if(IV_SUCCESS == ret)
{
imvcd_video_decode_ip_t s_video_decode_ip;
imvcd_video_decode_op_t s_video_decode_op;
s_video_decode_ip.s_ivd_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
s_video_decode_ip.s_ivd_ip.u4_ts = u4_ip_frm_ts;
s_video_decode_ip.s_ivd_ip.pv_stream_buffer = pu1_bs_buf;
s_video_decode_ip.s_ivd_ip.u4_num_Bytes = u4_bytes_remaining;
s_video_decode_ip.s_ivd_ip.s_out_buffer = ps_out_buf[0];
s_video_decode_op.ps_view_disp_bufs = ps_app_ctxt->as_view_disp_bufs;
s_video_decode_ip.s_ivd_ip.u4_size = sizeof(s_video_decode_ip.s_ivd_ip);
s_video_decode_op.s_ivd_op.u4_size = sizeof(s_video_decode_op.s_ivd_op);
ret = imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_video_decode_ip,
&s_video_decode_op);
if(1 == s_video_decode_op.s_ivd_op.u4_output_present)
{
ret = mvcd_dump_output(ps_app_ctxt, s_video_decode_op.ps_view_disp_bufs,
pps_op_file, pps_op_chksum_file, u2_num_views);
(*pu4_op_frm_ts)++;
}
else
{
break;
}
}
} while(IV_SUCCESS == ret);
return ret;
}
static IV_API_CALL_STATUS_T mvcd_decode_header(mvc_dec_ctx_t *ps_app_ctxt, ivd_out_bufdesc_t *ps_out_buf,
FILE *ps_ip_file, IVD_ERROR_CODES_T *pe_error_code,
UWORD32 *pu4_num_bytes_dec, UWORD32 u4_ip_frm_ts)
{
IV_API_CALL_STATUS_T ret;
UWORD32 u4_ip_buf_len;
UWORD8 *pu1_bs_buf;
imvcd_video_decode_ip_t s_video_decode_ip = {0};
imvcd_video_decode_op_t s_video_decode_op = {0};
UWORD32 u4_file_pos = 0;
UWORD32 u4_num_bytes_dec = 0;
ret = mvcd_set_decode_mode(ps_app_ctxt, IVD_DECODE_HEADER);
if(ret != IV_SUCCESS)
{
pe_error_code[0] = IVD_INIT_DEC_FAILED;
return ret;
}
/* Allocate input buffer for header */
u4_ip_buf_len = 256 * 1024;
pu1_bs_buf = (UWORD8 *) malloc(u4_ip_buf_len);
if(pu1_bs_buf == NULL)
{
pe_error_code[0] = IVD_MEM_ALLOC_FAILED;
return IV_FAIL;
}
do
{
WORD32 u4_numbytes;
UWORD32 u4_bytes_remaining;
fseek(ps_ip_file, u4_file_pos, SEEK_SET);
u4_numbytes = u4_ip_buf_len;
u4_bytes_remaining = fread(pu1_bs_buf, sizeof(UWORD8), u4_numbytes, ps_ip_file);
if(0 == u4_bytes_remaining)
{
pe_error_code[0] = IVD_UNEXPECTED_END_OF_STREAM;
return IV_FAIL;
}
s_video_decode_ip.s_ivd_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
s_video_decode_ip.s_ivd_ip.u4_ts = u4_ip_frm_ts;
s_video_decode_ip.s_ivd_ip.pv_stream_buffer = pu1_bs_buf;
s_video_decode_ip.s_ivd_ip.u4_num_Bytes = u4_bytes_remaining;
s_video_decode_ip.s_ivd_ip.s_out_buffer = ps_out_buf[0];
s_video_decode_op.ps_view_disp_bufs = ps_app_ctxt->as_view_disp_bufs;
s_video_decode_ip.s_ivd_ip.u4_size = sizeof(s_video_decode_ip.s_ivd_ip);
s_video_decode_op.s_ivd_op.u4_size = sizeof(s_video_decode_op.s_ivd_op);
ret = imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_video_decode_ip, &s_video_decode_op);
if(ret != IV_SUCCESS)
{
pe_error_code[0] = s_video_decode_op.s_ivd_op.u4_error_code;
return ret;
}
u4_num_bytes_dec += s_video_decode_op.s_ivd_op.u4_num_bytes_consumed;
#ifndef PROFILE_ENABLE
printf("%d\n", s_video_decode_op.s_ivd_op.u4_num_bytes_consumed);
#endif
} while(ret != IV_SUCCESS);
ps_app_ctxt->u4_pic_wd = s_video_decode_op.s_ivd_op.u4_pic_wd;
ps_app_ctxt->u4_pic_ht = s_video_decode_op.s_ivd_op.u4_pic_ht;
pu4_num_bytes_dec[0] = u4_num_bytes_dec;
pe_error_code[0] = IVD_ERROR_NONE;
free(pu1_bs_buf);
return IV_SUCCESS;
}
static IV_API_CALL_STATUS_T mvcd_get_buf_info(mvc_dec_ctx_t *ps_app_ctxt)
{
imvcd_get_buf_info_ip_t s_ctl_ip;
imvcd_get_buf_info_op_t s_ctl_op;
IV_API_CALL_STATUS_T e_retval;
s_ctl_ip.s_ivd_ip.u4_size = sizeof(s_ctl_ip.s_ivd_ip);
s_ctl_op.s_ivd_op.u4_size = sizeof(s_ctl_op.s_ivd_op);
s_ctl_ip.s_ivd_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.s_ivd_ip.e_sub_cmd = (WORD32) IVD_CMD_CTL_GETBUFINFO;
e_retval = imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_ctl_ip, &s_ctl_op);
ps_app_ctxt->s_disp_buf_props = s_ctl_op;
return e_retval;
}
static IV_API_CALL_STATUS_T mvcd_set_degrade_type(mvc_dec_ctx_t *ps_app_ctxt)
{
imvcd_set_degrade_mode_ip_t s_ctl_ip;
imvcd_set_degrade_mode_op_t s_ctl_op;
s_ctl_ip.u4_size = sizeof(s_ctl_ip);
s_ctl_op.u4_size = sizeof(s_ctl_op);
s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
s_ctl_ip.e_sub_cmd = (WORD32) IMVCD_CTL_DEGRADE;
s_ctl_ip.i4_degrade_type = ps_app_ctxt->i4_degrade_type;
s_ctl_ip.i4_degrade_pics = ps_app_ctxt->i4_degrade_pics;
s_ctl_ip.i4_nondegrade_interval = DEFAULT_NON_DEGRADE_INTERVAL;
return imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_ctl_ip, &s_ctl_op);
}
static IV_API_CALL_STATUS_T mvcd_decode_frame(mvc_dec_ctx_t *ps_app_ctxt, ivd_out_bufdesc_t *ps_out_buf,
FILE *ps_ip_file, FILE **pps_op_file,
FILE **pps_op_chksum_file, UWORD8 *pu1_bs_buf,
IVD_ERROR_CODES_T *pe_error_code,
UWORD32 *pu4_num_bytes_consumed, UWORD32 *pu4_file_pos,
UWORD32 *pu4_ip_frm_ts, UWORD32 *pu4_op_frm_ts,
UWORD32 u4_ip_buf_len)
{
imvcd_video_decode_ip_t s_video_decode_ip;
imvcd_video_decode_op_t s_video_decode_op;
#ifdef PROFILE_ENABLE
TIMER s_start_timer;
TIMER s_end_timer;
#ifdef WINDOWS_TIMER
TIMER frequency;
#endif
UWORD32 au4_peak_window[PEAK_WINDOW_SIZE];
UWORD32 s_elapsed_time;
#endif
UWORD32 u4_max_op_frm_ts;
UWORD32 u4_bytes_remaining;
UWORD32 u4_numbytes;
IV_API_CALL_STATUS_T ret;
UWORD32 u4_num_bytes_dec = 0;
UWORD16 u2_num_views = ps_app_ctxt->s_disp_buf_props.s_mvc_buf_info.u2_num_views;
#ifdef PROFILE_ENABLE
UWORD32 u4_frm_cnt = 0;
UWORD32 u4_tot_cycles = 0;
UWORD32 u4_tot_fmt_cycles = 0;
UWORD32 u4_peak_window_idx = 0;
UWORD32 u4_peak_avg_max = 0;
#endif
#ifdef PROFILE_ENABLE
memset(au4_peak_window, 0, sizeof(WORD32) * PEAK_WINDOW_SIZE);
#ifdef WINDOWS_TIMER
QueryPerformanceFrequency(&frequency);
#endif
#endif
/*************************************************************************/
/* Set the decoder in frame decode mode. It was set in header decode */
/* mode earlier */
/*************************************************************************/
ret = mvcd_set_decode_mode(ps_app_ctxt, IVD_DECODE_FRAME);
if(IV_SUCCESS != ret)
{
pe_error_code[0] = IVD_INIT_DEC_FAILED;
return ret;
}
/*************************************************************************/
/* If required disable deblocking and sao at given level */
/*************************************************************************/
ret = mvcd_set_degrade_type(ps_app_ctxt);
if(IV_SUCCESS != ret)
{
pe_error_code[0] = IVD_INIT_DEC_FAILED;
return ret;
}
u4_max_op_frm_ts = ps_app_ctxt->u4_max_frm_ts + ps_app_ctxt->u4_disp_delay;
if(u4_max_op_frm_ts < ps_app_ctxt->u4_disp_delay)
{
/* clip as overflow has occured*/
u4_max_op_frm_ts = UINT32_MAX;
}
if(IV_SUCCESS != ret)
{
pe_error_code[0] = IVD_INIT_DEC_FAILED;
return ret;
}
while(pu4_op_frm_ts[0] < u4_max_op_frm_ts)
{
fseek(ps_ip_file, pu4_file_pos[0], SEEK_SET);
u4_numbytes = u4_ip_buf_len;
u4_bytes_remaining = fread(pu1_bs_buf, sizeof(UWORD8), u4_numbytes, ps_ip_file);
if(0 == u4_bytes_remaining)
{
if(ps_app_ctxt->u4_loopback)
{
pu4_file_pos[0] = 0;
fseek(ps_ip_file, pu4_file_pos[0], SEEK_SET);
u4_numbytes = u4_ip_buf_len;
u4_bytes_remaining = fread(pu1_bs_buf, sizeof(UWORD8), u4_numbytes, ps_ip_file);
}
else
{
break;
}
}
s_video_decode_ip.s_ivd_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
s_video_decode_ip.s_ivd_ip.u4_ts = pu4_ip_frm_ts[0];
s_video_decode_ip.s_ivd_ip.pv_stream_buffer = pu1_bs_buf;
s_video_decode_ip.s_ivd_ip.u4_num_Bytes = u4_bytes_remaining;
s_video_decode_ip.s_ivd_ip.s_out_buffer = ps_out_buf[0];
s_video_decode_op.ps_view_disp_bufs = ps_app_ctxt->as_view_disp_bufs;
s_video_decode_ip.s_ivd_ip.u4_size = sizeof(s_video_decode_ip.s_ivd_ip);
s_video_decode_op.s_ivd_op.u4_size = sizeof(s_video_decode_op.s_ivd_op);
/****************/
/* Video Decode */
/****************/
GETTIME(&s_start_timer);
ret = imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_video_decode_ip, &s_video_decode_op);
GETTIME(&s_end_timer);
ELAPSEDTIME(s_start_timer, s_end_timer, s_elapsed_time, frequency);
#ifdef PROFILE_ENABLE
{
UWORD32 peak_avg, id;
u4_tot_cycles += s_elapsed_time;
au4_peak_window[u4_peak_window_idx++] = s_elapsed_time;
if(u4_peak_window_idx == PEAK_WINDOW_SIZE)
{
u4_peak_window_idx = 0;
}
peak_avg = 0;
for(id = 0; id < PEAK_WINDOW_SIZE; id++)
{
peak_avg += au4_peak_window[id];
}
peak_avg /= PEAK_WINDOW_SIZE;
if(peak_avg > u4_peak_avg_max) u4_peak_avg_max = peak_avg;
u4_frm_cnt++;
printf(
"FrameNum: %4d TimeTaken(microsec): %6d AvgTime: %6d "
"PeakAvgTimeMax: "
"%6d Output: %2d NumBytes: %6d \n",
u4_frm_cnt, s_elapsed_time, u4_tot_cycles / u4_frm_cnt, u4_peak_avg_max,
s_video_decode_op.s_ivd_op.u4_output_present,
s_video_decode_op.s_ivd_op.u4_num_bytes_consumed);
}
#else
printf("%d\n", s_video_decode_op.s_ivd_op.u4_num_bytes_consumed);
#endif
if(ret != IV_SUCCESS)
{
pe_error_code[0] = s_video_decode_op.s_ivd_op.u4_error_code;
return ret;
}
u4_num_bytes_dec = s_video_decode_op.s_ivd_op.u4_num_bytes_consumed;
pu4_file_pos[0] += u4_num_bytes_dec;
pu4_num_bytes_consumed[0] += u4_num_bytes_dec;
pu4_ip_frm_ts[0]++;
if(s_video_decode_op.s_ivd_op.u4_output_present)
{
char cur_fname[1000];
char *extn = NULL;
/* The objective is to dump the decoded frames into separate files
* instead of dumping all the frames in one common file. Also, the
* number of dumped frames at any given instance of time cannot exceed
* 'frame_memory'
*/
if(ps_app_ctxt->u4_file_save_flag)
{
/* Locate the position of extension yuv */
extn = strstr((char *) ps_app_ctxt->s_mvc_app_files.au1_op_fname, "%d");
if(extn != NULL)
{
mvcd_output_write_stall(ps_app_ctxt->s_mvc_app_files.au1_op_fname,
pu4_op_frm_ts[0]);
sprintf(cur_fname, (char *) ps_app_ctxt->s_mvc_app_files.au1_op_fname,
pu4_op_frm_ts[0]);
pps_op_file[0] = fopen(cur_fname, "wb");
if(NULL == pps_op_file[0])
{
pe_error_code[0] = IVD_MEM_ALLOC_FAILED;
return IV_FAIL;
}
}
}
if(u2_num_views > 1)
{
if(s_video_decode_op.ps_view_disp_bufs[0].u4_y_wd !=
s_video_decode_op.ps_view_disp_bufs[1].u4_y_wd)
{
pe_error_code[0] = IVD_MEM_ALLOC_FAILED;
return IV_FAIL;
}
if(s_video_decode_op.ps_view_disp_bufs[0].u4_y_ht !=
s_video_decode_op.ps_view_disp_bufs[1].u4_y_ht)
{
pe_error_code[0] = IVD_MEM_ALLOC_FAILED;
return IV_FAIL;
}
}
mvcd_dump_output(ps_app_ctxt, s_video_decode_op.ps_view_disp_bufs, pps_op_file,
pps_op_chksum_file, u2_num_views);
pu4_op_frm_ts[0]++;
}
else if((s_video_decode_op.s_ivd_op.u4_error_code >> IVD_FATALERROR) & 1)
{
pe_error_code[0] = s_video_decode_op.s_ivd_op.u4_error_code;
return IV_FAIL;
}
}
#ifdef PROFILE_ENABLE
printf("Summary\n");
printf("Input filename : %s\n", ps_app_ctxt->s_mvc_app_files.au1_ip_fname);
printf("Output Width : %-4d\n", ps_app_ctxt->u4_pic_wd);
printf("Output Height : %-4d\n", ps_app_ctxt->u4_pic_ht);
if(u4_frm_cnt)
{
double avg = u4_tot_cycles / u4_frm_cnt;
double bytes_avg = pu4_num_bytes_consumed[0] / u4_frm_cnt;
double bitrate = (bytes_avg * 8 * ps_app_ctxt->u4_fps) / 1000000;
printf("Bitrate @ %2d u4_fps(mbps) : %-6.2f\n", ps_app_ctxt->u4_fps, bitrate);
printf("Average decode time(micro sec) : %-6d\n", (WORD32) avg);
printf("Avg Peak decode time(%2d frames) : %-6d\n", PEAK_WINDOW_SIZE,
(WORD32) u4_peak_avg_max);
avg = (u4_tot_cycles + u4_tot_fmt_cycles) * 1.0 / u4_frm_cnt;
printf("FPS achieved (with format conv) : %-3.2f\n", 1000000 / avg);
}
#endif
return IV_SUCCESS;
}
static IV_API_CALL_STATUS_T mvcd_delete_decoder(mvc_dec_ctx_t *ps_app_ctxt)
{
imvcd_delete_ip_t s_delete_ip;
imvcd_delete_op_t s_delete_op;
s_delete_ip.s_ivd_ip.e_cmd = IVD_CMD_DELETE;
s_delete_ip.s_ivd_ip.u4_size = sizeof(s_delete_ip.s_ivd_ip);
s_delete_op.s_ivd_op.u4_size = sizeof(s_delete_op.s_ivd_op);
return imvcd_api_function(ps_app_ctxt->ps_codec_obj, &s_delete_ip, &s_delete_op);
}
int main(WORD32 argc, char *argv[])
{
mvc_dec_ctx_t s_app_ctxt;
ivd_out_bufdesc_t s_out_buf;
IV_API_CALL_STATUS_T ret;
IVD_ERROR_CODES_T e_error_code;
UWORD8 au1_cfg_fname[STRLENGTH];
UWORD8 au1_error_str[STRLENGTH];
UWORD32 i;
UWORD32 u4_ip_buf_len;
UWORD32 u4_total_bytes_consumed;
UWORD8 au1_view_file_names[STRLENGTH];
UWORD16 u2_num_views;
UWORD32 u4_num_header_bytes;
FILE *ps_cfg_file = NULL;
FILE *ps_ip_file = NULL;
FILE *aps_op_file[MAX_NUM_VIEWS] = {NULL};
FILE *aps_op_chksum_file[MAX_NUM_VIEWS] = {NULL};
UWORD8 *pu1_bs_buf = NULL;
UWORD32 u4_file_pos = 0;
UWORD32 u4_ip_frm_ts = 0, u4_op_frm_ts = 0;
UWORD32 u4_bytes_remaining = 0;
/* Usage */
if(argc < 2)
{
mvcd_print_usage();
exit(-1);
}
else if(argc == 2)
{
strcpy((char *) au1_cfg_fname, argv[1]);
}
/***********************************************************************/
/* Initialize Application parameters */
/***********************************************************************/
strcpy((char *) s_app_ctxt.s_mvc_app_files.au1_ip_fname, "\0");
s_app_ctxt.u4_disp_delay = 0;
s_app_ctxt.u4_max_frm_ts = 100;
s_app_ctxt.u4_loopback = 0;
u4_file_pos = 0;
u4_total_bytes_consumed = 0;
u4_ip_frm_ts = 0;
u4_op_frm_ts = 0;
s_app_ctxt.u4_num_cores = DEFAULT_NUM_CORES;
s_app_ctxt.i4_degrade_type = 0;
s_app_ctxt.i4_degrade_pics = 0;
s_app_ctxt.e_arch = ARCH_X86_SSE42;
s_app_ctxt.e_soc = SOC_GENERIC;
s_app_ctxt.u1_quit = 0;
s_app_ctxt.u4_disable_dblk_level = 0;
s_app_ctxt.u4_file_save_flag = 0;
s_app_ctxt.u4_chksum_save_flag = 0;
s_app_ctxt.e_output_chroma_format = DEFAULT_COLOR_FORMAT;
/*************************************************************************/
/* Parse arguments */
/*************************************************************************/
/* Read command line arguments */
if(argc > 2)
{
for(i = 1; i < (UWORD32) argc; i += 2)
{
if(CONFIG == mvcd_get_argument(argv[i]))
{
strcpy((char *) au1_cfg_fname, argv[i + 1]);
if((ps_cfg_file = fopen((char *) au1_cfg_fname, "r")) == NULL)
{
sprintf((char *) au1_error_str, "Could not open Configuration file %s",
au1_cfg_fname);
mvcd_exit(au1_error_str);
}
mvcd_read_cfg_file(&s_app_ctxt, ps_cfg_file);
fclose(ps_cfg_file);
}
else
{
mvcd_parse_argument(&s_app_ctxt, argv[i], argv[i + 1]);
}
}
}
else
{
if((ps_cfg_file = fopen((char *) au1_cfg_fname, "r")) == NULL)
{
sprintf((char *) au1_error_str, "Could not open Configuration file %s", au1_cfg_fname);
mvcd_exit(au1_error_str);
}
mvcd_read_cfg_file(&s_app_ctxt, ps_cfg_file);
fclose(ps_cfg_file);
}
if(strcmp((char *) s_app_ctxt.s_mvc_app_files.au1_ip_fname, "\0") == 0)
{
printf("\nNo input file given for decoding\n");
exit(-1);
}
/***********************************************************************/
/* create the file object for input file */
/***********************************************************************/
ps_ip_file = fopen((char *) s_app_ctxt.s_mvc_app_files.au1_ip_fname, "rb");
if(NULL == ps_ip_file)
{
sprintf((char *) au1_error_str, "Could not open input file %s",
s_app_ctxt.s_mvc_app_files.au1_ip_fname);
mvcd_exit(au1_error_str);
}
/***********************************************************************/
/* create the file object for output file */
/***********************************************************************/
/* If the filename does not contain %d, then output will be dumped to
a single file and it is opened here */
if((1 == s_app_ctxt.u4_file_save_flag) &&
(strstr((char *) s_app_ctxt.s_mvc_app_files.au1_op_fname, "%d") == NULL))
{
mvcd_get_view_file_name(s_app_ctxt.s_mvc_app_files.au1_op_fname, au1_view_file_names, 0);
aps_op_file[0] = fopen((char *) au1_view_file_names, "wb");
if(NULL == aps_op_file[0])
{
const CHAR au1_explanatory_string[] = "Could not open output file ";
UWORD8 au1_error_str[STRLENGTH + sizeof(au1_explanatory_string) + 1];
sprintf((char *) au1_error_str, "%s%s", au1_explanatory_string, au1_view_file_names);
mvcd_exit(au1_error_str);
}
}
/***********************************************************************/
/* create the file object for check sum file */
/***********************************************************************/
if((1 == s_app_ctxt.u4_chksum_save_flag) &&
(strstr((char *) s_app_ctxt.s_mvc_app_files.au1_op_chksum_fname, "%d") == NULL))
{
mvcd_get_view_file_name(s_app_ctxt.s_mvc_app_files.au1_op_chksum_fname, au1_view_file_names,
0);
aps_op_chksum_file[0] = fopen((char *) au1_view_file_names, "wb");
if(NULL == aps_op_chksum_file[0])
{
const CHAR au1_explanatory_string[] = "Could not open check sum file ";
UWORD8 au1_error_str[STRLENGTH + sizeof(au1_explanatory_string) + 1];
sprintf((char *) au1_error_str, "%s%s", au1_explanatory_string, au1_view_file_names);
mvcd_exit(au1_error_str);
}
}
/***************************/
/* Create decoder instance */
/***************************/
ret = mvcd_create_decoder(&s_app_ctxt);
if(ret != IV_SUCCESS)
{
sprintf((char *) au1_error_str, "Error in Create %8x\n", ret);
mvcd_exit(au1_error_str);
}
/**************/
/* set params */
/**************/
ret = mvcd_set_decode_mode(&s_app_ctxt, IVD_DECODE_HEADER);
if(ret != IV_SUCCESS)
{
sprintf((char *) au1_error_str, "\nError in Dec mode");
mvcd_exit(au1_error_str);
}
/*************************************************************************/
/* set num of cores */
/*************************************************************************/
ret = mvcd_set_num_cores(&s_app_ctxt);
if(ret != IV_SUCCESS)
{
sprintf((char *) au1_error_str, "\nError in setting number of cores");
mvcd_exit(au1_error_str);
}
/*************************************************************************/
/* set processsor */
/*************************************************************************/
ret = mvcd_set_arch(&s_app_ctxt);
if(ret != IV_SUCCESS)
{
sprintf((char *) au1_error_str, "\nError in setting Processor type");
mvcd_exit(au1_error_str);
}
/*****************/
/* Header Decode */
/*****************/
ret = mvcd_decode_header(&s_app_ctxt, &s_out_buf, ps_ip_file, &e_error_code,
&u4_num_header_bytes, u4_ip_frm_ts);
if(ret != IV_SUCCESS)
{
sprintf((char *) au1_error_str, "Error in header decode 0x%x\n", e_error_code);
mvcd_exit(au1_error_str);
}
u4_file_pos += u4_num_header_bytes;
u4_total_bytes_consumed += u4_num_header_bytes;
/****************/
/* Get buf info */
/****************/
ret = mvcd_get_buf_info(&s_app_ctxt);
if(ret != IV_SUCCESS)
{
sprintf((char *) au1_error_str, "Error in Get Buf Info %x",
s_app_ctxt.s_disp_buf_props.s_ivd_op.u4_error_code);
mvcd_exit(au1_error_str);
}
u2_num_views = s_app_ctxt.s_disp_buf_props.s_mvc_buf_info.u2_num_views;
ASSERT(u2_num_views <= MAX_NUM_VIEWS);
ret = mvcd_out_buf_alloc(&s_app_ctxt, &s_out_buf);
if(IV_SUCCESS != ret)
{
sprintf((char *) au1_error_str, "Error in Out buf alloc\n");
mvcd_exit(au1_error_str);
}
/***************************************************************************/
/* create the file object for output file for other views(if present) */
/***************************************************************************/
for(i = 1; i < u2_num_views; i++)
{
if((1 == s_app_ctxt.u4_file_save_flag) &&
(strstr((char *) s_app_ctxt.s_mvc_app_files.au1_op_fname, "%d") == NULL))
{
mvcd_get_view_file_name(s_app_ctxt.s_mvc_app_files.au1_op_fname, au1_view_file_names,
i);
aps_op_file[i] = fopen((char *) au1_view_file_names, "wb");
if(NULL == aps_op_file[i])
{
const UWORD8 au1_explanatory_string[] = "Could not open output file ";
UWORD8 au1_error_str[STRLENGTH + sizeof(au1_explanatory_string) + 1];
sprintf((char *) au1_error_str, "%s%s", au1_explanatory_string,
au1_view_file_names);
mvcd_exit(au1_error_str);
}
}
if((1 == s_app_ctxt.u4_chksum_save_flag) &&
(strstr((char *) s_app_ctxt.s_mvc_app_files.au1_op_chksum_fname, "%d") == NULL))
{
mvcd_get_view_file_name(s_app_ctxt.s_mvc_app_files.au1_op_chksum_fname,
au1_view_file_names, i);
aps_op_chksum_file[i] = fopen((char *) au1_view_file_names, "wb");
if(NULL == aps_op_chksum_file[i])
{
const UWORD8 au1_explanatory_string[] = "Could not open check sum file ";
UWORD8 au1_error_str[STRLENGTH + sizeof(au1_explanatory_string) + 1];
sprintf((char *) au1_error_str, "%s%s", au1_explanatory_string,
au1_view_file_names);
mvcd_exit(au1_error_str);
}
}
}
u4_ip_buf_len = s_app_ctxt.s_disp_buf_props.s_ivd_op.u4_min_in_buf_size[0];
ret = mvcd_in_buf_alloc(&s_app_ctxt, &pu1_bs_buf);
if(IV_SUCCESS != ret)
{
sprintf((char *) au1_error_str, "Error in In buf alloc\n");
mvcd_exit(au1_error_str);
}
ret = mvcd_decode_frame(&s_app_ctxt, &s_out_buf, ps_ip_file, aps_op_file, aps_op_chksum_file,
pu1_bs_buf, &e_error_code, &u4_total_bytes_consumed, &u4_file_pos,
&u4_ip_frm_ts, &u4_op_frm_ts, u4_ip_buf_len);
if(ret != IV_SUCCESS)
{
sprintf((char *) au1_error_str, "Error in Frame decode 0x%x\n", e_error_code);
mvcd_exit(au1_error_str);
}
/***********************************************************************/
/* To get the last decoded frames, call process with NULL input */
/***********************************************************************/
ret = mvcd_flush(&s_app_ctxt, &s_out_buf, aps_op_file, aps_op_chksum_file, pu1_bs_buf,
&u4_op_frm_ts, u4_ip_frm_ts, u4_bytes_remaining, u2_num_views);
if(ret != IV_SUCCESS)
{
sprintf((char *) au1_error_str, "\nError in Setting the decoder in flush mode");
mvcd_exit(au1_error_str);
}
s_app_ctxt.u1_quit = 1;
ret = mvcd_delete_decoder(&s_app_ctxt);
if(IV_SUCCESS != ret)
{
sprintf((char *) au1_error_str, "Error in Codec delete");
mvcd_exit(au1_error_str);
}
/***********************************************************************/
/* Close all the files and free all the memory */
/***********************************************************************/
fclose(ps_ip_file);
for(i = 0; i < u2_num_views; i++)
{
if(aps_op_file[i])
{
fclose(aps_op_file[i]);
}
if(aps_op_chksum_file[i])
{
fclose(aps_op_chksum_file[i]);
}
}
mvcd_in_buf_free(pu1_bs_buf);
mvcd_out_buf_free(&s_out_buf);
return (0);
}
Reference in New Issue Copy Permalink