C++程序
|
3559行
|
151.06 KB
/******************************************************************************
*
* Copyright (C) 2015 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
*/
/*****************************************************************************/
/* */
/* File Name : decoder_api_main.c */
/* */
/* Description : Functions which recieve the API call from user */
/* */
/* List of Functions : <List the functions defined in this file> */
/* */
/* Issues / Problems : None */
/* */
/* Revision History : */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 30 05 2007 Rajneesh Creation */
/* */
/*****************************************************************************/
/*****************************************************************************/
/* File Includes */
/*****************************************************************************/
/* System include files */
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
/* User include files */
#include "iv_datatypedef.h"
#include "iv.h"
#include "ivd.h"
#include "ithread.h"
#include "impeg2_job_queue.h"
#include "impeg2_macros.h"
#include "impeg2_buf_mgr.h"
#include "impeg2_disp_mgr.h"
#include "impeg2_defs.h"
#include "impeg2_platform_macros.h"
#include "impeg2_inter_pred.h"
#include "impeg2_idct.h"
#include "impeg2_format_conv.h"
#include "impeg2_mem_func.h"
#include "impeg2d.h"
#include "impeg2d_api.h"
#include "impeg2d_bitstream.h"
#include "impeg2d_debug.h"
#include "impeg2d_structs.h"
#include "impeg2d_mc.h"
#include "impeg2d_pic_proc.h"
#include "impeg2d_deinterlace.h"
#define NUM_FRAMES_LIMIT_ENABLED 0
#ifdef LOGO_EN
#include "impeg2_ittiam_logo.h"
#define INSERT_LOGO(buf_y, buf_u, buf_v, stride, x_pos, y_pos, yuv_fmt,disp_wd,disp_ht) impeg2_insert_logo(buf_y, buf_u, buf_v, stride, x_pos, y_pos, yuv_fmt,disp_wd,disp_ht);
#else
#define INSERT_LOGO(buf_y, buf_u, buf_v, stride, x_pos, y_pos, yuv_fmt,disp_wd,disp_ht)
#endif
#if NUM_FRAMES_LIMIT_ENABLED
#define NUM_FRAMES_LIMIT 10000
#else
#define NUM_FRAMES_LIMIT 0x7FFFFFFF
#endif
#define CODEC_NAME "MPEG2VDEC"
#define CODEC_RELEASE_TYPE "eval"
#define CODEC_RELEASE_VER "01.00"
#define CODEC_VENDOR "ITTIAM"
#ifdef __ANDROID__
#define VERSION(version_string, codec_name, codec_release_type, codec_release_ver, codec_vendor) \
strcpy(version_string,"@(#)Id:"); \
strcat(version_string,codec_name); \
strcat(version_string,"_"); \
strcat(version_string,codec_release_type); \
strcat(version_string," Ver:"); \
strcat(version_string,codec_release_ver); \
strcat(version_string," Released by "); \
strcat(version_string,codec_vendor);
#else
#define VERSION(version_string, codec_name, codec_release_type, codec_release_ver, codec_vendor) \
strcpy(version_string,"@(#)Id:"); \
strcat(version_string,codec_name); \
strcat(version_string,"_"); \
strcat(version_string,codec_release_type); \
strcat(version_string," Ver:"); \
strcat(version_string,codec_release_ver); \
strcat(version_string," Released by "); \
strcat(version_string,codec_vendor); \
strcat(version_string," Build: "); \
strcat(version_string,__DATE__); \
strcat(version_string," @ "); \
strcat(version_string,__TIME__);
#endif
#define MIN_OUT_BUFS_420 3
#define MIN_OUT_BUFS_422ILE 1
#define MIN_OUT_BUFS_RGB565 1
#define MIN_OUT_BUFS_420SP 2
void impeg2d_init_arch(void *pv_codec);
void impeg2d_init_function_ptr(void *pv_codec);
UWORD32 impeg2d_get_outbuf_size(WORD32 pic_wd,UWORD32 pic_ht, WORD32 u1_chroma_format,UWORD32 *p_buf_size);
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_rel_display_frame */
/* */
/* Description : Release displ buffers that will be shared between decoder */
/* and application */
/* Inputs : Error message */
/* Globals : None */
/* Processing : Just prints error message to console */
/* Outputs : Error mesage to the console */
/* Returns : None */
/* */
/* Issues : <List any issues or problems with this function> */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 27 05 2006 Sankar Creation */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_rel_display_frame(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
ivd_rel_display_frame_ip_t *dec_rel_disp_ip;
ivd_rel_display_frame_op_t *dec_rel_disp_op;
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
dec_rel_disp_ip = (ivd_rel_display_frame_ip_t *)pv_api_ip;
dec_rel_disp_op = (ivd_rel_display_frame_op_t *)pv_api_op;
dec_rel_disp_op->u4_error_code = 0;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
/* If not in shared disp buf mode, return */
if(0 == ps_dec_state->u4_share_disp_buf)
return IV_SUCCESS;
if(NULL == ps_dec_state->pv_pic_buf_mg)
return IV_SUCCESS;
impeg2_buf_mgr_release(ps_dec_state->pv_pic_buf_mg, dec_rel_disp_ip->u4_disp_buf_id, BUF_MGR_DISP);
return IV_SUCCESS;
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_set_display_frame */
/* */
/* Description : Sets display buffers that will be shared between decoder */
/* and application */
/* Inputs : Error message */
/* Globals : None */
/* Processing : Just prints error message to console */
/* Outputs : Error mesage to the console */
/* Returns : None */
/* */
/* Issues : <List any issues or problems with this function> */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 27 05 2006 Sankar Creation */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_set_display_frame(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
ivd_set_display_frame_ip_t *dec_disp_ip;
ivd_set_display_frame_op_t *dec_disp_op;
UWORD32 i;
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
UWORD32 u4_num_disp_bufs;
UWORD32 u4_disp_buf_size[3];
UWORD32 num_bufs;
dec_disp_ip = (ivd_set_display_frame_ip_t *)pv_api_ip;
dec_disp_op = (ivd_set_display_frame_op_t *)pv_api_op;
dec_disp_op->u4_error_code = 0;
u4_num_disp_bufs = dec_disp_ip->num_disp_bufs;
if(u4_num_disp_bufs > BUF_MGR_MAX_CNT)
u4_num_disp_bufs = BUF_MGR_MAX_CNT;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
num_bufs = dec_disp_ip->s_disp_buffer[0].u4_num_bufs;
if(ps_dec_state->u4_share_disp_buf)
{
pic_buf_t *ps_pic_buf;
ps_pic_buf = (pic_buf_t *)ps_dec_state->pv_pic_buf_base;
/* Get the sizes of the first buffer structure. Compare this with the
* rest to make sure all the buffers are of the same size.
*/
u4_disp_buf_size[0] =
dec_disp_ip->s_disp_buffer[0].u4_min_out_buf_size[0];
u4_disp_buf_size[1] =
dec_disp_ip->s_disp_buffer[0].u4_min_out_buf_size[1];
u4_disp_buf_size[2] =
dec_disp_ip->s_disp_buffer[0].u4_min_out_buf_size[2];
for(i = 0; i < u4_num_disp_bufs; i++)
{
/* Verify all buffer structures have the same sized buffers as the
* first buffer structure*/
if ((dec_disp_ip->s_disp_buffer[i].u4_min_out_buf_size[0]
!= u4_disp_buf_size[0])
|| (dec_disp_ip->s_disp_buffer[i].u4_min_out_buf_size[1]
!= u4_disp_buf_size[1])
|| (dec_disp_ip->s_disp_buffer[i].u4_min_out_buf_size[2]
!= u4_disp_buf_size[2]))
{
return IV_FAIL;
}
/* Verify all buffer structures have the same number of
* buffers (e.g. y, u, v) */
if (dec_disp_ip->s_disp_buffer[i].u4_num_bufs != num_bufs)
{
return IV_FAIL;
}
ps_pic_buf->pu1_y = dec_disp_ip->s_disp_buffer[i].pu1_bufs[0];
if(IV_YUV_420P == ps_dec_state->i4_chromaFormat)
{
ps_pic_buf->pu1_u = dec_disp_ip->s_disp_buffer[i].pu1_bufs[1];
ps_pic_buf->pu1_v = dec_disp_ip->s_disp_buffer[i].pu1_bufs[2];
}
else
{
ps_pic_buf->pu1_u = ps_dec_state->pu1_chroma_ref_buf[i];
ps_pic_buf->pu1_v = ps_dec_state->pu1_chroma_ref_buf[i] +
((ps_dec_state->u2_create_max_width * ps_dec_state->u2_create_max_height) >> 2);
}
ps_pic_buf->i4_buf_id = i;
ps_pic_buf->u1_used_as_ref = 0;
ps_pic_buf->u4_ts = 0;
impeg2_buf_mgr_add(ps_dec_state->pv_pic_buf_mg, ps_pic_buf, i);
impeg2_buf_mgr_set_status(ps_dec_state->pv_pic_buf_mg, i, BUF_MGR_DISP);
ps_pic_buf++;
}
}
memcpy(&(ps_dec_state->as_disp_buffers[0]),
&(dec_disp_ip->s_disp_buffer),
u4_num_disp_bufs * sizeof(ivd_out_bufdesc_t));
return IV_SUCCESS;
}
IV_API_CALL_STATUS_T impeg2d_api_set_num_cores(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
impeg2d_ctl_set_num_cores_ip_t *ps_ip;
impeg2d_ctl_set_num_cores_op_t *ps_op;
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
ps_ip = (impeg2d_ctl_set_num_cores_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_set_num_cores_op_t *)pv_api_op;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
if(ps_ip->u4_num_cores > 0)
{
WORD32 i;
for(i = 0; i < MAX_THREADS; i++)
ps_dec_state_multi_core->ps_dec_state[i]->i4_num_cores = ps_ip->u4_num_cores;
}
else
{
ps_dec_state->i4_num_cores = 1;
}
ps_op->u4_error_code = IV_SUCCESS;
return IV_SUCCESS;
}
IV_API_CALL_STATUS_T impeg2d_api_get_seq_info(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
impeg2d_ctl_get_seq_info_ip_t *ps_ip;
impeg2d_ctl_get_seq_info_op_t *ps_op;
dec_state_t *ps_codec;
dec_state_multi_core_t *ps_dec_state_multi_core;
ps_ip = (impeg2d_ctl_get_seq_info_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_get_seq_info_op_t *)pv_api_op;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
ps_codec = ps_dec_state_multi_core->ps_dec_state[0];
UNUSED(ps_ip);
if(ps_codec->u2_header_done == 1)
{
ps_op->u1_aspect_ratio_information = ps_codec->u2_aspect_ratio_info;
ps_op->u1_frame_rate_code = ps_codec->u2_frame_rate_code;
ps_op->u1_frame_rate_extension_n = ps_codec->u2_frame_rate_extension_n;
ps_op->u1_frame_rate_extension_d = ps_codec->u2_frame_rate_extension_d;
if(ps_codec->u1_seq_disp_extn_present == 1)
{
ps_op->u1_video_format = ps_codec->u1_video_format;
ps_op->u1_colour_primaries = ps_codec->u1_colour_primaries;
ps_op->u1_transfer_characteristics = ps_codec->u1_transfer_characteristics;
ps_op->u1_matrix_coefficients = ps_codec->u1_matrix_coefficients;
ps_op->u2_display_horizontal_size = ps_codec->u2_display_horizontal_size;
ps_op->u2_display_vertical_size = ps_codec->u2_display_vertical_size;
}
else
{
ps_op->u1_video_format = 5;
ps_op->u1_colour_primaries = 2;
ps_op->u1_transfer_characteristics = 2;
ps_op->u1_matrix_coefficients = 2;
ps_op->u2_display_horizontal_size = ps_codec->u2_horizontal_size;
ps_op->u2_display_vertical_size = ps_codec->u2_vertical_size;
}
ps_op->u4_error_code = IV_SUCCESS;
return IV_SUCCESS;
}
else
{
ps_op->u4_error_code = IV_FAIL;
return IV_FAIL;
}
}
/**
*******************************************************************************
*
* @brief
* Sets Processor type
*
* @par Description:
* Sets Processor type
*
* @param[in] ps_codec_obj
* Pointer to codec object at API level
*
* @param[in] pv_api_ip
* Pointer to input argument structure
*
* @param[out] pv_api_op
* Pointer to output argument structure
*
* @returns Status
*
* @remarks
*
*
*******************************************************************************
*/
IV_API_CALL_STATUS_T impeg2d_set_processor(iv_obj_t *ps_codec_obj,
void *pv_api_ip,
void *pv_api_op)
{
impeg2d_ctl_set_processor_ip_t *ps_ip;
impeg2d_ctl_set_processor_op_t *ps_op;
dec_state_t *ps_codec;
dec_state_multi_core_t *ps_dec_state_multi_core;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_codec_obj->pv_codec_handle);
ps_codec = ps_dec_state_multi_core->ps_dec_state[0];
ps_ip = (impeg2d_ctl_set_processor_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_set_processor_op_t *)pv_api_op;
ps_codec->e_processor_arch = (IVD_ARCH_T)ps_ip->u4_arch;
ps_codec->e_processor_soc = (IVD_SOC_T)ps_ip->u4_soc;
impeg2d_init_function_ptr(ps_codec);
ps_op->u4_error_code = 0;
return IV_SUCCESS;
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_fill_mem_rec */
/* */
/* Description : */
/* Inputs : */
/* Globals : */
/* Processing : */
/* Outputs : */
/* Returns : */
/* */
/* Issues : */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 17 09 2007 Rajendra C Y Draft */
/* */
/*****************************************************************************/
void impeg2d_fill_mem_rec(impeg2d_fill_mem_rec_ip_t *ps_ip,
impeg2d_fill_mem_rec_op_t *ps_op)
{
UWORD32 u4_i;
UWORD8 u1_no_rec = 0;
UWORD32 max_frm_width,max_frm_height,max_frm_size;
iv_mem_rec_t *ps_mem_rec = ps_ip->s_ivd_fill_mem_rec_ip_t.pv_mem_rec_location;
WORD32 i4_num_threads;
WORD32 i4_share_disp_buf, i4_chroma_format;
WORD32 i4_chroma_size;
UWORD32 u4_deinterlace;
UNUSED(u4_deinterlace);
max_frm_width = ALIGN16(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_max_frm_wd);
/* In error clips with field prediction, the mv may incorrectly refer to
* the last MB row, causing an out of bounds read access. Allocating 8 extra
* rows to handle this. Adding another extra row to handle half_y prediction.
*/
max_frm_height = ALIGN32(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_max_frm_ht) + 9;
max_frm_size = (max_frm_width * max_frm_height * 3) >> 1;/* 420 P */
i4_chroma_size = max_frm_width * max_frm_height / 4;
if(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_size > offsetof(impeg2d_fill_mem_rec_ip_t, u4_share_disp_buf))
{
#ifndef LOGO_EN
i4_share_disp_buf = ps_ip->u4_share_disp_buf;
#else
i4_share_disp_buf = 0;
#endif
}
else
{
i4_share_disp_buf = 0;
}
if(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_size > offsetof(impeg2d_fill_mem_rec_ip_t, e_output_format))
{
i4_chroma_format = ps_ip->e_output_format;
}
else
{
i4_chroma_format = -1;
}
if(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_size > offsetof(impeg2d_fill_mem_rec_ip_t, u4_deinterlace))
{
u4_deinterlace = ps_ip->u4_deinterlace;
}
else
{
u4_deinterlace = 0;
}
if( (i4_chroma_format != IV_YUV_420P) &&
(i4_chroma_format != IV_YUV_420SP_UV) &&
(i4_chroma_format != IV_YUV_420SP_VU))
{
i4_share_disp_buf = 0;
}
/* Disable deinterlacer in shared mode */
if(i4_share_disp_buf)
{
u4_deinterlace = 0;
}
/*************************************************************************/
/* Fill the memory requirement XDM Handle */
/*************************************************************************/
/* ! */
ps_mem_rec->u4_mem_alignment = 128 /* 128 byte alignment*/;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = sizeof(iv_obj_t);
ps_mem_rec++;
u1_no_rec++;
{
/*************************************************************************/
/* Fill the memory requirement for threads context */
/*************************************************************************/
/* ! */
ps_mem_rec->u4_mem_alignment = 128 /* 128 byte alignment*/;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = sizeof(dec_state_multi_core_t);
ps_mem_rec++;
u1_no_rec++;
}
for(i4_num_threads = 0; i4_num_threads < MAX_THREADS; i4_num_threads++)
{
/*************************************************************************/
/* Fill the memory requirement for MPEG2 Decoder Context */
/*************************************************************************/
/* ! */
ps_mem_rec->u4_mem_alignment = 128 /* 128 byte alignment*/;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = sizeof(dec_state_t);
ps_mem_rec++;
u1_no_rec++;
/* To store thread handle */
ps_mem_rec->u4_mem_alignment = 128 /* 128 byte alignment*/;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = ithread_get_handle_size();
ps_mem_rec++;
u1_no_rec++;
/*************************************************************************/
/* Fill the memory requirement for Motion Compensation Buffers */
/*************************************************************************/
ps_mem_rec->u4_mem_alignment = 128 /* 128 byte alignment*/;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_SCRATCH_MEM;
/* for mc_fw_buf.pu1_y */
ps_mem_rec->u4_mem_size = MB_LUMA_MEM_SIZE;
/* for mc_fw_buf.pu1_u */
ps_mem_rec->u4_mem_size += MB_CHROMA_MEM_SIZE;
/* for mc_fw_buf.pu1_v */
ps_mem_rec->u4_mem_size += MB_CHROMA_MEM_SIZE;
/* for mc_bk_buf.pu1_y */
ps_mem_rec->u4_mem_size += MB_LUMA_MEM_SIZE;
/* for mc_bk_buf.pu1_u */
ps_mem_rec->u4_mem_size += MB_CHROMA_MEM_SIZE;
/* for mc_bk_buf.pu1_v */
ps_mem_rec->u4_mem_size += MB_CHROMA_MEM_SIZE;
/* for mc_buf.pu1_y */
ps_mem_rec->u4_mem_size += MB_LUMA_MEM_SIZE;
/* for mc_buf.pu1_u */
ps_mem_rec->u4_mem_size += MB_CHROMA_MEM_SIZE;
/* for mc_buf.pu1_v */
ps_mem_rec->u4_mem_size += MB_CHROMA_MEM_SIZE;
ps_mem_rec++;
u1_no_rec++;
/*************************************************************************/
/* Fill the memory requirement Stack Context */
/*************************************************************************/
/* ! */
ps_mem_rec->u4_mem_alignment = 128 /* 128 byte alignment*/;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = 392;
ps_mem_rec++;
u1_no_rec++;
}
{
/*************************************************************************/
/* Fill the memory requirement for Picture Buffer Manager */
/*************************************************************************/
/* ! */
ps_mem_rec->u4_mem_alignment = 128 /* 128 byte alignment*/;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = sizeof(buf_mgr_t) + sizeof(pic_buf_t) * BUF_MGR_MAX_CNT;
ps_mem_rec++;
u1_no_rec++;
}
/*************************************************************************/
/* Internal Frame Buffers */
/*************************************************************************/
/* ! */
{
for(u4_i = 0; u4_i < NUM_INT_FRAME_BUFFERS; u4_i++)
{
/* ! */
ps_mem_rec->u4_mem_alignment = 128 /* 128 byte alignment*/;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
if(0 == i4_share_disp_buf)
ps_mem_rec->u4_mem_size = max_frm_size;
else if(IV_YUV_420P != i4_chroma_format)
{
/* If color format is not 420P and it is shared, then allocate for chroma */
ps_mem_rec->u4_mem_size = i4_chroma_size * 2;
}
else
ps_mem_rec->u4_mem_size = 64;
ps_mem_rec++;
u1_no_rec++;
}
}
ps_mem_rec->u4_mem_alignment = 128;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = MAX_BITSTREAM_BUFFER_SIZE + MIN_BUFFER_BYTES_AT_EOS;
ps_mem_rec++;
u1_no_rec++;
{
WORD32 i4_job_queue_size;
WORD32 i4_num_jobs;
/* One job per row of MBs */
i4_num_jobs = max_frm_height >> 4;
/* One format convert/frame copy job per row of MBs for non-shared mode*/
i4_num_jobs += max_frm_height >> 4;
i4_job_queue_size = impeg2_jobq_ctxt_size();
i4_job_queue_size += i4_num_jobs * sizeof(job_t);
ps_mem_rec->u4_mem_size = i4_job_queue_size;
ps_mem_rec->u4_mem_alignment = 128;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec++;
u1_no_rec++;
}
ps_mem_rec->u4_mem_alignment = 128;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = impeg2d_deint_ctxt_size();
ps_mem_rec++;
u1_no_rec++;
ps_mem_rec->u4_mem_alignment = 128;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
if(IV_YUV_420P != i4_chroma_format)
ps_mem_rec->u4_mem_size = max_frm_size;
else
ps_mem_rec->u4_mem_size = 64;
ps_mem_rec++;
u1_no_rec++;
ps_mem_rec->u4_mem_alignment = 128;
ps_mem_rec->e_mem_type = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
ps_mem_rec->u4_mem_size = sizeof(iv_mem_rec_t) * (NUM_MEM_RECORDS);
ps_mem_rec++;
u1_no_rec++;
ps_op->s_ivd_fill_mem_rec_op_t.u4_num_mem_rec_filled = u1_no_rec;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code = 0;
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_get_version */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 22 10 2008 100356 Draft */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_get_version(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
char au1_version_string[512];
impeg2d_ctl_getversioninfo_ip_t *ps_ip;
impeg2d_ctl_getversioninfo_op_t *ps_op;
UNUSED(ps_dechdl);
ps_ip = (impeg2d_ctl_getversioninfo_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_getversioninfo_op_t *)pv_api_op;
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code = IV_SUCCESS;
VERSION(au1_version_string, CODEC_NAME, CODEC_RELEASE_TYPE, CODEC_RELEASE_VER,
CODEC_VENDOR);
if((WORD32)ps_ip->s_ivd_ctl_getversioninfo_ip_t.u4_version_buffer_size <= 0)
{
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code = IV_FAIL;
return (IV_FAIL);
}
if(ps_ip->s_ivd_ctl_getversioninfo_ip_t.u4_version_buffer_size
>= (strlen(au1_version_string) + 1))
{
memcpy(ps_ip->s_ivd_ctl_getversioninfo_ip_t.pv_version_buffer,
au1_version_string, (strlen(au1_version_string) + 1));
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code = IV_SUCCESS;
}
else
{
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code = IV_FAIL;
}
return (IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_get_buf_info */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 22 10 2008 100356 Draft */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_get_buf_info(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
impeg2d_ctl_getbufinfo_ip_t *ps_ctl_bufinfo_ip =
(impeg2d_ctl_getbufinfo_ip_t *)pv_api_ip;
impeg2d_ctl_getbufinfo_op_t *ps_ctl_bufinfo_op =
(impeg2d_ctl_getbufinfo_op_t *)pv_api_op;
UWORD32 u4_i, u4_stride, u4_height;
UNUSED(ps_ctl_bufinfo_ip);
ps_dec_state_multi_core =
(dec_state_multi_core_t *)(ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_in_bufs = 1;
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs = 1;
for(u4_i = 0; u4_i < IVD_VIDDEC_MAX_IO_BUFFERS; u4_i++)
{
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_in_buf_size[u4_i] =
0;
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[u4_i] =
0;
}
for(u4_i = 0;
u4_i < ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_in_bufs;
u4_i++)
{
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_in_buf_size[u4_i] =
MAX_BITSTREAM_BUFFER_SIZE;
}
if (0 == ps_dec_state->u4_frm_buf_stride)
{
if (1 == ps_dec_state->u2_header_done)
{
u4_stride = ps_dec_state->u2_horizontal_size;
}
else
{
u4_stride = ps_dec_state->u2_create_max_width;
}
}
else
{
u4_stride = ps_dec_state->u4_frm_buf_stride;
}
u4_stride = ALIGN16(u4_stride);
u4_height = ALIGN32(ps_dec_state->u2_frame_height) + 9;
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs =
impeg2d_get_outbuf_size(
u4_stride,
u4_height,
ps_dec_state->i4_chromaFormat,
&ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[0]);
if (0 == ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs)
{
//Invalid chroma format; Error code may be updated, verify in testing if needed
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code =
IVD_INIT_DEC_COL_FMT_NOT_SUPPORTED;
return IV_FAIL;
}
/* Adding initialization for 2 uninitialized values */
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_num_disp_bufs = 1;
if(ps_dec_state->u4_share_disp_buf)
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_num_disp_bufs =
NUM_INT_FRAME_BUFFERS;
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_size = MAX_FRM_SIZE;
ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code = IV_SUCCESS;
return (IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_set_flush_mode */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 08 06 2009 100356 RAVI */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_set_flush_mode(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
impeg2d_ctl_flush_op_t *ps_ctl_dec_op =
(impeg2d_ctl_flush_op_t*)pv_api_op;
UNUSED(pv_api_ip);
ps_dec_state_multi_core =
(dec_state_multi_core_t *)(ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
ps_dec_state->u1_flushfrm = 1;
ps_ctl_dec_op->s_ivd_ctl_flush_op_t.u4_size =
sizeof(impeg2d_ctl_flush_op_t);
ps_ctl_dec_op->s_ivd_ctl_flush_op_t.u4_error_code = IV_SUCCESS;
return (IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_set_default */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 08 06 2009 100356 RAVI */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_set_default(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
impeg2d_ctl_set_config_op_t *ps_ctl_dec_op =
(impeg2d_ctl_set_config_op_t *)pv_api_op;
UNUSED(pv_api_ip);
ps_ctl_dec_op->s_ivd_ctl_set_config_op_t.u4_error_code = IV_SUCCESS;
ps_ctl_dec_op->s_ivd_ctl_set_config_op_t.u4_size =
sizeof(impeg2d_ctl_set_config_op_t);
ps_dec_state_multi_core =
(dec_state_multi_core_t *)(ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
ps_dec_state->u1_flushfrm = 0;
ps_dec_state->u2_decode_header = 1;
if (1 == ps_dec_state->u2_header_done)
{
ps_dec_state->u4_frm_buf_stride = ps_dec_state->u2_frame_width;
}
ps_ctl_dec_op->s_ivd_ctl_set_config_op_t.u4_error_code = IV_SUCCESS;
return (IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_reset */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 08 06 2009 100356 RAVI */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_reset(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
UNUSED(pv_api_ip);
impeg2d_ctl_reset_op_t *s_ctl_reset_op = (impeg2d_ctl_reset_op_t *)pv_api_op;
WORD32 i4_num_threads;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
if(ps_dec_state_multi_core != NULL)
{
impeg2_buf_mgr_reset(ps_dec_state->pv_pic_buf_mg);
/* Display buffer manager init behaves like a reset
* as it doesn't need to preserve picture buffer addresses
* like buffer manager */
impeg2_disp_mgr_init(&ps_dec_state->s_disp_mgr);
for(i4_num_threads = 0; i4_num_threads < MAX_THREADS; i4_num_threads++)
{
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[i4_num_threads];
/* --------------------------------------------------------------------- */
/* Initializations */
ps_dec_state->u2_header_done = 0; /* Header decoding not done */
ps_dec_state->u4_frm_buf_stride = 0;
ps_dec_state->i4_pic_count = 0;
ps_dec_state->u2_is_mpeg2 = 0;
ps_dec_state->aps_ref_pics[0] = NULL;
ps_dec_state->aps_ref_pics[1] = NULL;
ps_dec_state->ps_deint_pic = NULL;
}
}
else
{
s_ctl_reset_op->s_ivd_ctl_reset_op_t.u4_error_code =
IMPEG2D_INIT_NOT_DONE;
}
return(IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_set_params */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 08 06 2009 100356 RAVI */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_set_params(iv_obj_t *ps_dechdl,void *pv_api_ip,void *pv_api_op)
{
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
impeg2d_ctl_set_config_ip_t *ps_ctl_dec_ip = (impeg2d_ctl_set_config_ip_t *)pv_api_ip;
impeg2d_ctl_set_config_op_t *ps_ctl_dec_op = (impeg2d_ctl_set_config_op_t *)pv_api_op;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
if((ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.e_vid_dec_mode != IVD_DECODE_HEADER) && (ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.e_vid_dec_mode != IVD_DECODE_FRAME))
{
ps_ctl_dec_op->s_ivd_ctl_set_config_op_t.u4_error_code = IV_FAIL;
return(IV_FAIL);
}
if((ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.e_frm_out_mode != IVD_DISPLAY_FRAME_OUT) && (ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.e_frm_out_mode != IVD_DECODE_FRAME_OUT))
{
ps_ctl_dec_op->s_ivd_ctl_set_config_op_t.u4_error_code = IV_FAIL;
return(IV_FAIL);
}
if( (WORD32) ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.e_frm_skip_mode < IVD_SKIP_NONE)
{
ps_ctl_dec_op->s_ivd_ctl_set_config_op_t.u4_error_code = IV_FAIL;
return(IV_FAIL);
}
if(ps_dec_state->u2_header_done == 1)
{
if(((WORD32)ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.u4_disp_wd < 0) ||
((ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.u4_disp_wd != 0) && (ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.u4_disp_wd < ps_dec_state->u2_frame_width)))
{
ps_ctl_dec_op->s_ivd_ctl_set_config_op_t.u4_error_code = IV_FAIL;
return(IV_FAIL);
}
}
ps_dec_state->u2_decode_header = (UWORD8)ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.e_vid_dec_mode;
if(ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.u4_disp_wd != 0)
{
ps_dec_state->u4_frm_buf_stride = ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.u4_disp_wd;
}
else
{
if(ps_dec_state->u2_header_done == 1)
{
ps_dec_state->u4_frm_buf_stride = ps_dec_state->u2_frame_width;
}
else
{
ps_dec_state->u4_frm_buf_stride = 0;
}
}
if(ps_ctl_dec_ip->s_ivd_ctl_set_config_ip_t.e_vid_dec_mode == IVD_DECODE_FRAME)
{
ps_dec_state->u1_flushfrm = 0;
}
ps_ctl_dec_op->s_ivd_ctl_set_config_op_t.u4_error_code = IV_SUCCESS;
return(IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_get_status */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 08 06 2009 100356 RAVI */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_get_status(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
UWORD32 u4_i,u4_stride,u4_height;
impeg2d_ctl_getstatus_ip_t *ps_ctl_dec_ip = (impeg2d_ctl_getstatus_ip_t *)pv_api_ip;
impeg2d_ctl_getstatus_op_t *ps_ctl_dec_op = (impeg2d_ctl_getstatus_op_t *)pv_api_op;
UNUSED(ps_ctl_dec_ip);
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_size = sizeof(impeg2d_ctl_getstatus_op_t);
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_num_disp_bufs = 1;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_pic_ht = ps_dec_state->u2_frame_height;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_pic_wd = ps_dec_state->u2_frame_width;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_frame_rate = ps_dec_state->u2_framePeriod;
if(ps_dec_state->u2_progressive_sequence == 1)
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.e_content_type = IV_PROGRESSIVE ;
else
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.e_content_type = IV_INTERLACED;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.e_output_chroma_format = (IV_COLOR_FORMAT_T)ps_dec_state->i4_chromaFormat;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_num_in_bufs = 1;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_num_out_bufs = 1;
if(ps_dec_state->i4_chromaFormat == IV_YUV_420P)
{
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_num_out_bufs = MIN_OUT_BUFS_420;
}
else if(ps_dec_state->i4_chromaFormat == IV_YUV_422ILE)
{
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_num_out_bufs = MIN_OUT_BUFS_422ILE;
}
else if(ps_dec_state->i4_chromaFormat == IV_RGB_565)
{
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_num_out_bufs = MIN_OUT_BUFS_RGB565;
}
else
{
//Invalid chroma format; Error code may be updated, verify in testing if needed
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_error_code = IVD_INIT_DEC_COL_FMT_NOT_SUPPORTED;
return IV_FAIL;
}
memset(&ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_in_buf_size[0],0,(sizeof(UWORD32)*IVD_VIDDEC_MAX_IO_BUFFERS));
memset(&ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[0],0,(sizeof(UWORD32)*IVD_VIDDEC_MAX_IO_BUFFERS));
for(u4_i = 0; u4_i < ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_num_in_bufs; u4_i++)
{
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_in_buf_size[u4_i] = MAX_BITSTREAM_BUFFER_SIZE;
}
u4_stride = ps_dec_state->u4_frm_buf_stride;
u4_height = ((ps_dec_state->u2_frame_height + 15) >> 4) << 4;
if(ps_dec_state->i4_chromaFormat == IV_YUV_420P)
{
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[0] = (u4_stride * u4_height);
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[1] = (u4_stride * u4_height)>>2 ;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[2] = (u4_stride * u4_height)>>2;
}
else if((ps_dec_state->i4_chromaFormat == IV_YUV_420SP_UV) || (ps_dec_state->i4_chromaFormat == IV_YUV_420SP_VU))
{
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[0] = (u4_stride * u4_height);
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[1] = (u4_stride * u4_height)>>1 ;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[2] = 0;
}
else if(ps_dec_state->i4_chromaFormat == IV_YUV_422ILE)
{
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[0] = (u4_stride * u4_height)*2;
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[1] = ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_min_out_buf_size[2] = 0;
}
ps_ctl_dec_op->s_ivd_ctl_getstatus_op_t.u4_error_code = IV_SUCCESS;
return(IV_SUCCESS);
}
/**
*******************************************************************************
*
* @brief
* Gets frame dimensions/offsets
*
* @par Description:
* Gets frame buffer chararacteristics such a x & y offsets display and
* buffer dimensions
*
* @param[in] ps_codec_obj
* Pointer to codec object at API level
*
* @param[in] pv_api_ip
* Pointer to input argument structure
*
* @param[out] pv_api_op
* Pointer to output argument structure
*
* @returns Status
*
* @remarks
*
*
*******************************************************************************
*/
IV_API_CALL_STATUS_T impeg2d_get_frame_dimensions(iv_obj_t *ps_codec_obj,
void *pv_api_ip,
void *pv_api_op)
{
impeg2d_ctl_get_frame_dimensions_ip_t *ps_ip;
impeg2d_ctl_get_frame_dimensions_op_t *ps_op;
WORD32 disp_wd, disp_ht, buffer_wd, buffer_ht, x_offset, y_offset;
dec_state_t *ps_codec;
dec_state_multi_core_t *ps_dec_state_multi_core;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_codec_obj->pv_codec_handle);
ps_codec = ps_dec_state_multi_core->ps_dec_state[0];
ps_ip = (impeg2d_ctl_get_frame_dimensions_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_get_frame_dimensions_op_t *)pv_api_op;
UNUSED(ps_ip);
if(ps_codec->u2_header_done)
{
disp_wd = ps_codec->u2_horizontal_size;
disp_ht = ps_codec->u2_vertical_size;
if(0 == ps_codec->u4_share_disp_buf)
{
buffer_wd = disp_wd;
buffer_ht = disp_ht;
}
else
{
buffer_wd = ps_codec->u2_frame_width;
buffer_ht = ps_codec->u2_frame_height;
}
}
else
{
disp_wd = ps_codec->u2_create_max_width;
disp_ht = ps_codec->u2_create_max_height;
if(0 == ps_codec->u4_share_disp_buf)
{
buffer_wd = disp_wd;
buffer_ht = disp_ht;
}
else
{
buffer_wd = ALIGN16(disp_wd);
buffer_ht = ALIGN16(disp_ht);
}
}
if(ps_codec->u2_frame_width > buffer_wd)
buffer_wd = ps_codec->u2_frame_width;
x_offset = 0;
y_offset = 0;
ps_op->u4_disp_wd[0] = disp_wd;
ps_op->u4_disp_ht[0] = disp_ht;
ps_op->u4_buffer_wd[0] = buffer_wd;
ps_op->u4_buffer_ht[0] = buffer_ht;
ps_op->u4_x_offset[0] = x_offset;
ps_op->u4_y_offset[0] = y_offset;
ps_op->u4_disp_wd[1] = ps_op->u4_disp_wd[2] = ((ps_op->u4_disp_wd[0] + 1)
>> 1);
ps_op->u4_disp_ht[1] = ps_op->u4_disp_ht[2] = ((ps_op->u4_disp_ht[0] + 1)
>> 1);
ps_op->u4_buffer_wd[1] = ps_op->u4_buffer_wd[2] = (ps_op->u4_buffer_wd[0]
>> 1);
ps_op->u4_buffer_ht[1] = ps_op->u4_buffer_ht[2] = (ps_op->u4_buffer_ht[0]
>> 1);
ps_op->u4_x_offset[1] = ps_op->u4_x_offset[2] = (ps_op->u4_x_offset[0]
>> 1);
ps_op->u4_y_offset[1] = ps_op->u4_y_offset[2] = (ps_op->u4_y_offset[0]
>> 1);
if((ps_codec->i4_chromaFormat == IV_YUV_420SP_UV)
|| (ps_codec->i4_chromaFormat == IV_YUV_420SP_VU))
{
ps_op->u4_disp_wd[2] = 0;
ps_op->u4_disp_ht[2] = 0;
ps_op->u4_buffer_wd[2] = 0;
ps_op->u4_buffer_ht[2] = 0;
ps_op->u4_x_offset[2] = 0;
ps_op->u4_y_offset[2] = 0;
ps_op->u4_disp_wd[1] <<= 1;
ps_op->u4_buffer_wd[1] <<= 1;
ps_op->u4_x_offset[1] <<= 1;
}
return IV_SUCCESS;
}
IV_API_CALL_STATUS_T impeg2d_api_function (iv_obj_t *ps_dechdl, void *pv_api_ip,void *pv_api_op)
{
WORD32 i4_cmd;
IV_API_CALL_STATUS_T u4_error_code;
UWORD32 *pu4_api_ip;
u4_error_code = impeg2d_api_check_struct_sanity(ps_dechdl,pv_api_ip,pv_api_op);
if(IV_SUCCESS != u4_error_code)
{
return u4_error_code;
}
pu4_api_ip = (UWORD32 *)pv_api_ip;
i4_cmd = *(pu4_api_ip + 1);
switch(i4_cmd)
{
case IV_CMD_GET_NUM_MEM_REC:
u4_error_code = impeg2d_api_num_mem_rec((void *)pv_api_ip,(void *)pv_api_op);
break;
case IV_CMD_FILL_NUM_MEM_REC:
u4_error_code = impeg2d_api_fill_mem_rec((void *)pv_api_ip,(void *)pv_api_op);
break;
case IV_CMD_INIT:
u4_error_code = impeg2d_api_init(ps_dechdl,(void *)pv_api_ip,(void *)pv_api_op);
break;
case IVD_CMD_SET_DISPLAY_FRAME:
u4_error_code = impeg2d_api_set_display_frame(ps_dechdl,(void *)pv_api_ip,(void *)pv_api_op);
break;
case IVD_CMD_REL_DISPLAY_FRAME:
u4_error_code = impeg2d_api_rel_display_frame(ps_dechdl,(void *)pv_api_ip,(void *)pv_api_op);
break;
case IVD_CMD_VIDEO_DECODE:
u4_error_code = impeg2d_api_entity(ps_dechdl, (void *)pv_api_ip,(void *)pv_api_op);
break;
case IV_CMD_RETRIEVE_MEMREC:
u4_error_code = impeg2d_api_retrieve_mem_rec(ps_dechdl,(void *)pv_api_ip,(void *)pv_api_op);
break;
case IVD_CMD_VIDEO_CTL:
u4_error_code = impeg2d_api_ctl(ps_dechdl,(void *)pv_api_ip,(void *)pv_api_op);
break;
default:
break;
}
return(u4_error_code);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_num_mem_rec */
/* */
/* Description : The function get the number mem records library needs */
/* Inputs : Error message */
/* Globals : None */
/* Processing : Just prints error message to console */
/* Outputs : Error mesage to the console */
/* Returns : None */
/* */
/* Issues : <List any issues or problems with this function> */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 23 09 2010 Hamsalekha Creation */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_num_mem_rec(void *pv_api_ip,void *pv_api_op)
{
/* To Query No of Memory Records */
impeg2d_num_mem_rec_ip_t *ps_query_mem_rec_ip;
impeg2d_num_mem_rec_op_t *ps_query_mem_rec_op;
ps_query_mem_rec_ip = (impeg2d_num_mem_rec_ip_t *)pv_api_ip;
ps_query_mem_rec_op = (impeg2d_num_mem_rec_op_t *)pv_api_op;
UNUSED(ps_query_mem_rec_ip);
ps_query_mem_rec_op->s_ivd_num_mem_rec_op_t.u4_size = sizeof(impeg2d_num_mem_rec_op_t);
ps_query_mem_rec_op->s_ivd_num_mem_rec_op_t.u4_num_mem_rec = (UWORD32)NUM_MEM_RECORDS;
ps_query_mem_rec_op->s_ivd_num_mem_rec_op_t.u4_error_code = IV_SUCCESS;
return(IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_fill_mem_rec */
/* */
/* Description : Thsi functions fills details of each mem record lib needs*/
/* Inputs : Error message */
/* Globals : None */
/* Processing : Just prints error message to console */
/* Outputs : Error mesage to the console */
/* Returns : None */
/* */
/* Issues : <List any issues or problems with this function> */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 23 09 2010 Hamsalekha Creation */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_fill_mem_rec(void *pv_api_ip,void *pv_api_op)
{
impeg2d_fill_mem_rec_ip_t *ps_mem_q_ip;
impeg2d_fill_mem_rec_op_t *ps_mem_q_op;
ps_mem_q_ip = pv_api_ip;
ps_mem_q_op = pv_api_op;
impeg2d_fill_mem_rec((impeg2d_fill_mem_rec_ip_t *)ps_mem_q_ip,
(impeg2d_fill_mem_rec_op_t *)ps_mem_q_op);
return(IV_SUCCESS);
}
UWORD32 impeg2d_get_outbuf_size(WORD32 pic_wd,UWORD32 pic_ht, WORD32 u1_chroma_format,UWORD32 *p_buf_size)
{
UWORD32 u4_min_num_out_bufs = 0;
if(u1_chroma_format == IV_YUV_420P)
u4_min_num_out_bufs = MIN_OUT_BUFS_420;
else if(u1_chroma_format == IV_YUV_422ILE)
u4_min_num_out_bufs = MIN_OUT_BUFS_422ILE;
else if(u1_chroma_format == IV_RGB_565)
u4_min_num_out_bufs = MIN_OUT_BUFS_RGB565;
else if((u1_chroma_format == IV_YUV_420SP_UV)
|| (u1_chroma_format == IV_YUV_420SP_VU))
u4_min_num_out_bufs = MIN_OUT_BUFS_420SP;
if(u1_chroma_format == IV_YUV_420P)
{
p_buf_size[0] = (pic_wd * pic_ht);
p_buf_size[1] = (pic_wd * pic_ht)
>> 2;
p_buf_size[2] = (pic_wd * pic_ht)
>> 2;
}
else if(u1_chroma_format == IV_YUV_422ILE)
{
p_buf_size[0] = (pic_wd * pic_ht)
* 2;
p_buf_size[1] =
p_buf_size[2] = 0;
}
else if(u1_chroma_format == IV_RGB_565)
{
p_buf_size[0] = (pic_wd * pic_ht)
* 2;
p_buf_size[1] =
p_buf_size[2] = 0;
}
else if((u1_chroma_format == IV_YUV_420SP_UV)
|| (u1_chroma_format == IV_YUV_420SP_VU))
{
p_buf_size[0] = (pic_wd * pic_ht);
p_buf_size[1] = (pic_wd * pic_ht)
>> 1;
p_buf_size[2] = 0;
}
return u4_min_num_out_bufs;
}
WORD32 check_app_out_buf_size(dec_state_t *ps_dec)
{
UWORD32 au4_min_out_buf_size[IVD_VIDDEC_MAX_IO_BUFFERS];
UWORD32 u4_min_num_out_bufs, i;
UWORD32 pic_wd, pic_ht;
pic_wd = ps_dec->u2_horizontal_size;
pic_ht = ps_dec->u2_vertical_size;
if(ps_dec->u4_frm_buf_stride > pic_wd)
pic_wd = ps_dec->u4_frm_buf_stride;
u4_min_num_out_bufs = impeg2d_get_outbuf_size(pic_wd, pic_ht, ps_dec->i4_chromaFormat, &au4_min_out_buf_size[0]);
if (0 == ps_dec->u4_share_disp_buf)
{
if(ps_dec->ps_out_buf->u4_num_bufs < u4_min_num_out_bufs)
{
return IV_FAIL;
}
for (i = 0 ; i < u4_min_num_out_bufs; i++)
{
if(ps_dec->ps_out_buf->u4_min_out_buf_size[i] < au4_min_out_buf_size[i])
return (IV_FAIL);
}
}
else
{
if(ps_dec->as_disp_buffers[0].u4_num_bufs < u4_min_num_out_bufs)
return IV_FAIL;
for (i = 0 ; i < u4_min_num_out_bufs; i++)
{
/* We need to check only with the disp_buffer[0], because we have
* already ensured that all the buffers are of the same size in
* impeg2d_api_set_display_frame.
*/
if(ps_dec->as_disp_buffers[0].u4_min_out_buf_size[i] <
au4_min_out_buf_size[i])
return (IV_FAIL);
}
}
return(IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_init */
/* */
/* Description : */
/* Inputs : */
/* Globals : */
/* Processing : */
/* Outputs : */
/* Returns : */
/* */
/* Issues : */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 17 09 2007 Rajendra C Y Draft */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_init(iv_obj_t *ps_dechdl,
void *ps_ip,
void *ps_op)
{
UWORD32 i;
void *pv;
UWORD32 u4_size;
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
UWORD32 u4_num_mem_rec;
iv_mem_rec_t *ps_mem_rec ;
iv_mem_rec_t *ps_frm_buf;
iv_obj_t *ps_dec_handle;
WORD32 i4_max_wd, i4_max_ht;
impeg2d_init_ip_t *ps_dec_init_ip;
impeg2d_init_op_t *ps_dec_init_op;
WORD32 i4_num_threads;
UWORD32 u4_share_disp_buf, u4_chroma_format;
UWORD32 u4_deinterlace;
ps_dec_init_ip = (impeg2d_init_ip_t *)ps_ip;
ps_dec_init_op = (impeg2d_init_op_t *)ps_op;
i4_max_wd = ALIGN16(ps_dec_init_ip->s_ivd_init_ip_t.u4_frm_max_wd);
i4_max_ht = ALIGN16(ps_dec_init_ip->s_ivd_init_ip_t.u4_frm_max_ht);
if(ps_dec_init_ip->s_ivd_init_ip_t.u4_size > offsetof(impeg2d_init_ip_t, u4_share_disp_buf))
{
#ifndef LOGO_EN
u4_share_disp_buf = ps_dec_init_ip->u4_share_disp_buf;
#else
u4_share_disp_buf = 0;
#endif
}
else
{
u4_share_disp_buf = 0;
}
u4_chroma_format = ps_dec_init_ip->s_ivd_init_ip_t.e_output_format;
if(ps_dec_init_ip->s_ivd_init_ip_t.u4_size > offsetof(impeg2d_init_ip_t, u4_deinterlace))
{
u4_deinterlace = ps_dec_init_ip->u4_deinterlace;
}
else
{
u4_deinterlace = 0;
}
if( (u4_chroma_format != IV_YUV_420P) &&
(u4_chroma_format != IV_YUV_420SP_UV) &&
(u4_chroma_format != IV_YUV_420SP_VU))
{
u4_share_disp_buf = 0;
}
/* Disable deinterlacer in shared mode */
if(u4_share_disp_buf)
{
u4_deinterlace = 0;
}
ps_mem_rec = ps_dec_init_ip->s_ivd_init_ip_t.pv_mem_rec_location;
ps_mem_rec ++;
ps_dec_init_op->s_ivd_init_op_t.u4_size = sizeof(impeg2d_init_op_t);
/* Except memTab[0], all other memTabs are initialized to zero */
for(i = 1; i < ps_dec_init_ip->s_ivd_init_ip_t.u4_num_mem_rec; i++)
{
memset(ps_mem_rec->pv_base,0,ps_mem_rec->u4_mem_size);
ps_mem_rec++;
}
/* Reinitializing memTab[0] memory base address */
ps_mem_rec = ps_dec_init_ip->s_ivd_init_ip_t.pv_mem_rec_location;
/* memTab[0] is for codec Handle,redundant currently not being used */
ps_dec_handle = ps_mem_rec->pv_base;
u4_num_mem_rec = 1;
ps_mem_rec++;
/* decoder handle */
ps_dec_state_multi_core = ps_mem_rec->pv_base;
u4_num_mem_rec++;
ps_mem_rec++;
{
ps_dec_handle->pv_codec_handle = (void *)ps_dec_state_multi_core; /* Initializing codec context */
ps_dechdl->pv_codec_handle = (void *)ps_dec_state_multi_core;
ps_dechdl->pv_fxns = (void *)impeg2d_api_function;
}
for(i4_num_threads = 0; i4_num_threads < MAX_THREADS; i4_num_threads++)
{
/*************************************************************************/
/* For MPEG2 Decoder Context */
/*************************************************************************/
ps_dec_state = ps_mem_rec->pv_base;
ps_dec_state_multi_core->ps_dec_state[i4_num_threads] = ps_dec_state;
ps_dec_state->ps_dec_state_multi_core = ps_dec_state_multi_core;
ps_dec_state->i4_num_cores = 1;
/* @ */ /* Used for storing MemRecords */
u4_num_mem_rec++;
ps_mem_rec++;
/* Thread handle */
ps_dec_state->pv_codec_thread_handle = ps_mem_rec->pv_base;
u4_num_mem_rec++;
ps_mem_rec++;
/*************************************************************************/
/* For Motion Compensation Buffers */
/*************************************************************************/
pv = ps_mem_rec->pv_base;
/* for mc_fw_buf.pu1_y */
ps_dec_state->s_mc_fw_buf.pu1_y = pv;
pv = (void *)((UWORD8 *)pv + MB_LUMA_MEM_SIZE);
u4_size = sizeof(UWORD8) * MB_LUMA_MEM_SIZE;
/* for mc_fw_buf.pu1_u */
ps_dec_state->s_mc_fw_buf.pu1_u = pv;
pv = (void *)((UWORD8 *)pv + MB_CHROMA_MEM_SIZE);
u4_size += sizeof(UWORD8) * MB_CHROMA_MEM_SIZE;
/* for mc_fw_buf.pu1_v */
ps_dec_state->s_mc_fw_buf.pu1_v = pv;
pv = (void *)((UWORD8 *)pv + MB_CHROMA_MEM_SIZE);
u4_size += sizeof(UWORD8) * MB_CHROMA_MEM_SIZE;
/* for mc_bk_buf.pu1_y */
ps_dec_state->s_mc_bk_buf.pu1_y = pv;
pv = (void *)((UWORD8 *)pv + MB_LUMA_MEM_SIZE);
u4_size += sizeof(UWORD8) * MB_LUMA_MEM_SIZE;
/* for mc_bk_buf.pu1_u */
ps_dec_state->s_mc_bk_buf.pu1_u = pv;
pv = (void *)((UWORD8 *)pv + MB_CHROMA_MEM_SIZE);
u4_size += sizeof(UWORD8) * MB_CHROMA_MEM_SIZE;
/* for mc_bk_buf.pu1_v */
ps_dec_state->s_mc_bk_buf.pu1_v = pv;
pv = (void *)((UWORD8 *)pv + MB_CHROMA_MEM_SIZE);
u4_size += sizeof(UWORD8) * MB_CHROMA_MEM_SIZE;
/* for mc_buf.pu1_y */
ps_dec_state->s_mc_buf.pu1_y = pv;
pv = (void *)((UWORD8 *)pv + MB_LUMA_MEM_SIZE);
u4_size += sizeof(UWORD8) * MB_LUMA_MEM_SIZE;
/* for mc_buf.pu1_u */
ps_dec_state->s_mc_buf.pu1_u = pv;
pv = (void *)((UWORD8 *)pv + MB_CHROMA_MEM_SIZE);
u4_size += sizeof(UWORD8) * MB_CHROMA_MEM_SIZE;
/* for mc_buf.pu1_v */
ps_dec_state->s_mc_buf.pu1_v = pv;
u4_size += sizeof(UWORD8) * MB_CHROMA_MEM_SIZE;
u4_num_mem_rec++;
ps_mem_rec++;
ps_dec_state->pv_pic_buf_mg = 0;
/*************************************************************************/
/* For saving stack context to support global error handling */
/*************************************************************************/
ps_dec_state->pv_stack_cntxt = ps_mem_rec->pv_base;
u4_num_mem_rec++;
ps_mem_rec++;
}
/*************************************************************************/
/* For Picture Buffer Manager */
/*************************************************************************/
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
ps_dec_state->pv_pic_buf_mg = ps_mem_rec->pv_base;
ps_dec_state->pv_pic_buf_base = (UWORD8 *)ps_mem_rec->pv_base + sizeof(buf_mgr_t);
u4_num_mem_rec++;
ps_mem_rec++;
for(i4_num_threads = 0; i4_num_threads < MAX_THREADS; i4_num_threads++)
{
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[i4_num_threads];
/* --------------------------------------------------------------------- */
/* Initializations */
ps_dec_state->u2_header_done = 0; /* Header decoding not done */
{
UWORD32 u4_max_frm_width,u4_max_frm_height;
u4_max_frm_width = ALIGN16(ps_dec_init_ip->s_ivd_init_ip_t.u4_frm_max_wd);
u4_max_frm_height = ALIGN16(ps_dec_init_ip->s_ivd_init_ip_t.u4_frm_max_ht);
ps_dec_state->u2_create_max_width = u4_max_frm_width;
ps_dec_state->u2_create_max_height = u4_max_frm_height;
ps_dec_state->i4_chromaFormat = ps_dec_init_ip->s_ivd_init_ip_t.e_output_format;
ps_dec_state->u4_frm_buf_stride = 0 ;
ps_dec_state->u2_frame_width = u4_max_frm_width;
ps_dec_state->u2_picture_width = u4_max_frm_width;
ps_dec_state->u2_horizontal_size = u4_max_frm_width;
ps_dec_state->u2_frame_height = u4_max_frm_height;
ps_dec_state->u2_vertical_size = u4_max_frm_height;
ps_dec_state->u4_share_disp_buf = u4_share_disp_buf;
ps_dec_state->u4_deinterlace = u4_deinterlace;
ps_dec_state->ps_deint_pic = NULL;
}
}
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
if((ps_dec_state->i4_chromaFormat == IV_YUV_422ILE)
&&((ps_dec_state->u2_vertical_size & 0x1) != 0))
{
//printf("Error! Height should be multiple of 2 if Chroma format is 422ILE\n");
ps_dec_init_op->s_ivd_init_op_t.u4_error_code = IMPEG2D_INIT_CHROMA_FORMAT_HEIGHT_ERROR;
return(IV_FAIL);
}
/* --------------------------------------------------------------------- */
/* ! */
// picture buffer manager initialization will be done only for first thread
impeg2_disp_mgr_init(&ps_dec_state->s_disp_mgr);
impeg2_buf_mgr_init((buf_mgr_t *)ps_dec_state->pv_pic_buf_mg);
/*************************************************************************/
/* Internal Frame Buffers */
/*************************************************************************/
/* Set first frame to grey */
{
ps_frm_buf = ps_mem_rec;
memset(ps_frm_buf->pv_base, 128, ps_frm_buf->u4_mem_size);
ps_frm_buf++;
}
if(0 == ps_dec_state->u4_share_disp_buf)
{
pic_buf_t *ps_pic_buf;
ps_pic_buf = (pic_buf_t *)ps_dec_state->pv_pic_buf_base;
for(i = 0; i < NUM_INT_FRAME_BUFFERS; i++)
{
UWORD8 *pu1_buf;
pu1_buf = ps_mem_rec->pv_base;
ps_pic_buf->pu1_y = pu1_buf;
pu1_buf += i4_max_ht * i4_max_wd;
ps_pic_buf->pu1_u = pu1_buf;
pu1_buf += i4_max_ht * i4_max_wd >> 2;
ps_pic_buf->pu1_v = pu1_buf;
pu1_buf += i4_max_ht * i4_max_wd >> 2;
ps_pic_buf->i4_buf_id = i;
ps_pic_buf->u1_used_as_ref = 0;
ps_pic_buf->u4_ts = 0;
impeg2_buf_mgr_add(ps_dec_state->pv_pic_buf_mg, ps_pic_buf, i);
ps_mem_rec++;
ps_pic_buf++;
}
u4_num_mem_rec += NUM_INT_FRAME_BUFFERS;
}
else if (ps_dec_state->i4_chromaFormat != IV_YUV_420P)
{
for(i = 0; i < NUM_INT_FRAME_BUFFERS; i++)
{
ps_dec_state->pu1_chroma_ref_buf[i] = ps_mem_rec->pv_base;
ps_mem_rec++;
}
u4_num_mem_rec += NUM_INT_FRAME_BUFFERS;
}
else
{
ps_mem_rec+=NUM_INT_FRAME_BUFFERS;
u4_num_mem_rec += NUM_INT_FRAME_BUFFERS;
}
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
ps_dec_state->pu1_input_buffer = ps_mem_rec->pv_base;
u4_num_mem_rec++;
ps_mem_rec++;
ps_dec_state->pv_jobq_buf = ps_mem_rec->pv_base;
ps_dec_state->i4_jobq_buf_size = ps_mem_rec->u4_mem_size;
u4_num_mem_rec++;
ps_mem_rec++;
if(u4_num_mem_rec > ps_dec_init_ip->s_ivd_init_ip_t.u4_num_mem_rec)
{
ps_dec_init_op->s_ivd_init_op_t.u4_error_code = IMPEG2D_INIT_NUM_MEM_REC_NOT_SUFFICIENT;
return(IV_FAIL);
}
ps_dec_state->u1_flushfrm = 0;
ps_dec_state->u1_flushcnt = 0;
ps_dec_state->pv_jobq = impeg2_jobq_init(ps_dec_state->pv_jobq_buf, ps_dec_state->i4_jobq_buf_size);
ps_dec_state->pv_deinterlacer_ctxt = ps_mem_rec->pv_base;
u4_num_mem_rec++;
ps_mem_rec++;
ps_dec_state->pu1_deint_fmt_buf = ps_mem_rec->pv_base;
u4_num_mem_rec++;
ps_mem_rec++;
/*************************************************************************/
/* Last MemTab is used for storing TabRecords */
/*************************************************************************/
ps_dec_state->pv_memTab = (void *)ps_mem_rec->pv_base;
memcpy(ps_mem_rec->pv_base,ps_dec_init_ip->s_ivd_init_ip_t.pv_mem_rec_location, ps_mem_rec->u4_mem_size);
/* Updating in Decoder Context with memRecords */
u4_num_mem_rec++;
ps_mem_rec++;
ps_dec_state->u4_num_mem_records = u4_num_mem_rec;
ps_dec_state->u4_num_frames_decoded = 0;
ps_dec_state->aps_ref_pics[0] = NULL;
ps_dec_state->aps_ref_pics[1] = NULL;
ps_dec_init_op->s_ivd_init_op_t.u4_error_code = IV_SUCCESS;
impeg2d_init_arch(ps_dec_state);
impeg2d_init_function_ptr(ps_dec_state);
return(IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_retrieve_mem_rec */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 22 10 2008 100356 Draft */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_retrieve_mem_rec(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
UWORD32 u4_i;
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
iv_mem_rec_t *ps_mem_rec;
iv_mem_rec_t *ps_temp_rec;
impeg2d_retrieve_mem_rec_ip_t *ps_retr_mem_rec_ip;
impeg2d_retrieve_mem_rec_op_t *ps_retr_mem_rec_op;
ps_retr_mem_rec_ip = (impeg2d_retrieve_mem_rec_ip_t *)pv_api_ip;
ps_retr_mem_rec_op = (impeg2d_retrieve_mem_rec_op_t *)pv_api_op;
ps_mem_rec = ps_retr_mem_rec_ip->s_ivd_retrieve_mem_rec_ip_t.pv_mem_rec_location;
ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
ps_temp_rec = ps_dec_state->pv_memTab;
for(u4_i = 0; u4_i < (ps_dec_state->u4_num_mem_records);u4_i++)
{
ps_mem_rec[u4_i].u4_mem_size = ps_temp_rec[u4_i].u4_mem_size;
ps_mem_rec[u4_i].u4_mem_alignment = ps_temp_rec[u4_i].u4_mem_alignment;
ps_mem_rec[u4_i].e_mem_type = ps_temp_rec[u4_i].e_mem_type;
ps_mem_rec[u4_i].pv_base = ps_temp_rec[u4_i].pv_base;
}
ps_retr_mem_rec_op->s_ivd_retrieve_mem_rec_op_t.u4_error_code = IV_SUCCESS;
ps_retr_mem_rec_op->s_ivd_retrieve_mem_rec_op_t.u4_num_mem_rec_filled = ps_dec_state->u4_num_mem_records;
impeg2_jobq_deinit(ps_dec_state->pv_jobq);
IMPEG2D_PRINT_STATISTICS();
return(IV_SUCCESS);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_ctl */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 22 10 2008 100356 Draft */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_ctl(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
WORD32 i4_sub_cmd;
UWORD32 *pu4_api_ip;
IV_API_CALL_STATUS_T u4_error_code;
pu4_api_ip = (UWORD32 *)pv_api_ip;
i4_sub_cmd = *(pu4_api_ip + 2);
switch(i4_sub_cmd)
{
case IVD_CMD_CTL_GETPARAMS:
u4_error_code = impeg2d_api_get_status(ps_dechdl, (void *)pv_api_ip,
(void *)pv_api_op);
break;
case IVD_CMD_CTL_SETPARAMS:
u4_error_code = impeg2d_api_set_params(ps_dechdl, (void *)pv_api_ip,
(void *)pv_api_op);
break;
case IVD_CMD_CTL_RESET:
u4_error_code = impeg2d_api_reset(ps_dechdl, (void *)pv_api_ip,
(void *)pv_api_op);
break;
case IVD_CMD_CTL_SETDEFAULT:
u4_error_code = impeg2d_api_set_default(ps_dechdl,
(void *)pv_api_ip,
(void *)pv_api_op);
break;
case IVD_CMD_CTL_FLUSH:
u4_error_code = impeg2d_api_set_flush_mode(ps_dechdl,
(void *)pv_api_ip,
(void *)pv_api_op);
break;
case IVD_CMD_CTL_GETBUFINFO:
u4_error_code = impeg2d_api_get_buf_info(ps_dechdl,
(void *)pv_api_ip,
(void *)pv_api_op);
break;
case IVD_CMD_CTL_GETVERSION:
u4_error_code = impeg2d_api_get_version(ps_dechdl, (void *)pv_api_ip,
(void *)pv_api_op);
break;
case IMPEG2D_CMD_CTL_SET_NUM_CORES:
u4_error_code = impeg2d_api_set_num_cores(ps_dechdl,
(void *)pv_api_ip,
(void *)pv_api_op);
break;
case IMPEG2D_CMD_CTL_GET_BUFFER_DIMENSIONS:
u4_error_code = impeg2d_get_frame_dimensions(ps_dechdl,
(void *)pv_api_ip,
(void *)pv_api_op);
break;
case IMPEG2D_CMD_CTL_GET_SEQ_INFO:
u4_error_code = impeg2d_api_get_seq_info(ps_dechdl,
(void *)pv_api_ip,
(void *)pv_api_op);
break;
case IMPEG2D_CMD_CTL_SET_PROCESSOR:
u4_error_code = impeg2d_set_processor(ps_dechdl, (void *)pv_api_ip,
(void *)pv_api_op);
break;
default:
u4_error_code = IV_FAIL;
break;
}
return (u4_error_code);
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_check_struct_sanity */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 22 10 2008 100356 Draft */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_check_struct_sanity(iv_obj_t *ps_handle,
void *pv_api_ip,
void *pv_api_op)
{
WORD32 i4_cmd;
UWORD32 *pu4_api_ip;
UWORD32 *pu4_api_op;
WORD32 i,j;
if(NULL == pv_api_op)
return(IV_FAIL);
if(NULL == pv_api_ip)
return(IV_FAIL);
pu4_api_ip = (UWORD32 *)pv_api_ip;
pu4_api_op = (UWORD32 *)pv_api_op;
i4_cmd = (IVD_API_COMMAND_TYPE_T)*(pu4_api_ip + 1);
/* error checks on handle */
switch(i4_cmd)
{
case IV_CMD_GET_NUM_MEM_REC:
case IV_CMD_FILL_NUM_MEM_REC:
break;
case IV_CMD_INIT:
if(ps_handle == NULL)
{
*(pu4_api_op + 1) |= 1 << IVD_UNSUPPORTEDPARAM;
*(pu4_api_op + 1) |= IVD_HANDLE_NULL;
return IV_FAIL;
}
if(ps_handle->u4_size != sizeof(iv_obj_t))
{
*(pu4_api_op + 1) |= 1 << IVD_UNSUPPORTEDPARAM;
*(pu4_api_op + 1) |= IVD_HANDLE_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
break;
case IVD_CMD_GET_DISPLAY_FRAME:
case IVD_CMD_VIDEO_DECODE:
case IV_CMD_RETRIEVE_MEMREC:
case IVD_CMD_SET_DISPLAY_FRAME:
case IVD_CMD_REL_DISPLAY_FRAME:
case IVD_CMD_VIDEO_CTL:
{
if(ps_handle == NULL)
{
*(pu4_api_op + 1) |= 1 << IVD_UNSUPPORTEDPARAM;
*(pu4_api_op + 1) |= IVD_HANDLE_NULL;
return IV_FAIL;
}
if(ps_handle->u4_size != sizeof(iv_obj_t))
{
*(pu4_api_op + 1) |= 1 << IVD_UNSUPPORTEDPARAM;
*(pu4_api_op + 1) |= IVD_HANDLE_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_handle->pv_fxns != impeg2d_api_function)
{
*(pu4_api_op + 1) |= 1 << IVD_UNSUPPORTEDPARAM;
*(pu4_api_op + 1) |= IVD_INVALID_HANDLE_NULL;
return IV_FAIL;
}
if(ps_handle->pv_codec_handle == NULL)
{
*(pu4_api_op + 1) |= 1 << IVD_UNSUPPORTEDPARAM;
*(pu4_api_op + 1) |= IVD_INVALID_HANDLE_NULL;
return IV_FAIL;
}
}
break;
default:
*(pu4_api_op + 1) |= 1 << IVD_UNSUPPORTEDPARAM;
*(pu4_api_op + 1) |= IVD_INVALID_API_CMD;
return IV_FAIL;
}
switch(i4_cmd)
{
case IV_CMD_GET_NUM_MEM_REC:
{
impeg2d_num_mem_rec_ip_t *ps_ip = (impeg2d_num_mem_rec_ip_t *)pv_api_ip;
impeg2d_num_mem_rec_op_t *ps_op = (impeg2d_num_mem_rec_op_t *)pv_api_op;
ps_op->s_ivd_num_mem_rec_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_num_mem_rec_ip_t.u4_size != sizeof(impeg2d_num_mem_rec_ip_t))
{
ps_op->s_ivd_num_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_num_mem_rec_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_op->s_ivd_num_mem_rec_op_t.u4_size != sizeof(impeg2d_num_mem_rec_op_t))
{
ps_op->s_ivd_num_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_num_mem_rec_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
}
break;
case IV_CMD_FILL_NUM_MEM_REC:
{
impeg2d_fill_mem_rec_ip_t *ps_ip = (impeg2d_fill_mem_rec_ip_t *)pv_api_ip;
impeg2d_fill_mem_rec_op_t *ps_op = (impeg2d_fill_mem_rec_op_t *)pv_api_op;
iv_mem_rec_t *ps_mem_rec;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_size != sizeof(impeg2d_fill_mem_rec_ip_t))
{
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_op->s_ivd_fill_mem_rec_op_t.u4_size != sizeof(impeg2d_fill_mem_rec_op_t))
{
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_max_frm_wd < MIN_WIDTH)
{
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= IVD_REQUESTED_WIDTH_NOT_SUPPPORTED;
return(IV_FAIL);
}
if(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_max_frm_wd > MAX_WIDTH)
{
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= IVD_REQUESTED_WIDTH_NOT_SUPPPORTED;
return(IV_FAIL);
}
if(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_max_frm_ht < MIN_HEIGHT)
{
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= IVD_REQUESTED_HEIGHT_NOT_SUPPPORTED;
return(IV_FAIL);
}
if(ps_ip->s_ivd_fill_mem_rec_ip_t.u4_max_frm_ht > MAX_HEIGHT)
{
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= IVD_REQUESTED_HEIGHT_NOT_SUPPPORTED;
return(IV_FAIL);
}
if(NULL == ps_ip->s_ivd_fill_mem_rec_ip_t.pv_mem_rec_location)
{
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= IVD_NUM_REC_NOT_SUFFICIENT;
return(IV_FAIL);
}
/* check memrecords sizes are correct */
ps_mem_rec = ps_ip->s_ivd_fill_mem_rec_ip_t.pv_mem_rec_location;
for(i=0;i<NUM_MEM_RECORDS;i++)
{
if(ps_mem_rec[i].u4_size != sizeof(iv_mem_rec_t))
{
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code |= IVD_MEM_REC_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
}
break;
case IV_CMD_INIT:
{
impeg2d_init_ip_t *ps_ip = (impeg2d_init_ip_t *)pv_api_ip;
impeg2d_init_op_t *ps_op = (impeg2d_init_op_t *)pv_api_op;
iv_mem_rec_t *ps_mem_rec;
UWORD32 u4_tot_num_mem_recs;
ps_op->s_ivd_init_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_init_ip_t.u4_size != sizeof(impeg2d_init_ip_t))
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_op->s_ivd_init_op_t.u4_size != sizeof(impeg2d_init_op_t))
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
u4_tot_num_mem_recs = NUM_MEM_RECORDS;
if(ps_ip->s_ivd_init_ip_t.u4_num_mem_rec > u4_tot_num_mem_recs)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_NOT_SUFFICIENT;
return(IV_FAIL);
}
if(ps_ip->s_ivd_init_ip_t.u4_frm_max_wd < MIN_WIDTH)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_WIDTH_NOT_SUPPPORTED;
return(IV_FAIL);
}
if(ps_ip->s_ivd_init_ip_t.u4_frm_max_wd > MAX_WIDTH)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_WIDTH_NOT_SUPPPORTED;
return(IV_FAIL);
}
if(ps_ip->s_ivd_init_ip_t.u4_frm_max_ht < MIN_HEIGHT)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_HEIGHT_NOT_SUPPPORTED;
return(IV_FAIL);
}
if(ps_ip->s_ivd_init_ip_t.u4_frm_max_ht > MAX_HEIGHT)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_HEIGHT_NOT_SUPPPORTED;
return(IV_FAIL);
}
if(NULL == ps_ip->s_ivd_init_ip_t.pv_mem_rec_location)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_NUM_REC_NOT_SUFFICIENT;
return(IV_FAIL);
}
if((ps_ip->s_ivd_init_ip_t.e_output_format != IV_YUV_420P) &&
(ps_ip->s_ivd_init_ip_t.e_output_format != IV_YUV_422ILE)&&(ps_ip->s_ivd_init_ip_t.e_output_format != IV_YUV_420SP_UV)&&(ps_ip->s_ivd_init_ip_t.e_output_format != IV_YUV_420SP_VU))
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_COL_FMT_NOT_SUPPORTED;
return(IV_FAIL);
}
/* verify number of mem records */
if(ps_ip->s_ivd_init_ip_t.u4_num_mem_rec < NUM_MEM_RECORDS)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_NOT_SUFFICIENT;
return IV_FAIL;
}
ps_mem_rec = ps_ip->s_ivd_init_ip_t.pv_mem_rec_location;
/* verify wether first memrecord is handle or not */
/*
if(ps_mem_rec->pv_base != ps_handle)
{
// indicate the incorrect handle error
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INVALID_HANDLE;
return IV_FAIL;
}
*/
/* check memrecords sizes are correct */
for(i=0;i < (WORD32)ps_ip->s_ivd_init_ip_t.u4_num_mem_rec ; i++)
{
if(ps_mem_rec[i].u4_size != sizeof(iv_mem_rec_t))
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_MEM_REC_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
/* verify memtabs for overlapping regions */
{
UWORD8 *pau1_start[NUM_MEM_RECORDS];
UWORD8 *pau1_end[NUM_MEM_RECORDS];
pau1_start[0] = (UWORD8 *)(ps_mem_rec[0].pv_base);
pau1_end[0] = (UWORD8 *)(ps_mem_rec[0].pv_base) + ps_mem_rec[0].u4_mem_size - 1;
for(i = 1; i < (WORD32)ps_ip->s_ivd_init_ip_t.u4_num_mem_rec; i++)
{
/* This array is populated to check memtab overlapp */
pau1_start[i] = (UWORD8 *)(ps_mem_rec[i].pv_base);
pau1_end[i] = (UWORD8 *)(ps_mem_rec[i].pv_base) + ps_mem_rec[i].u4_mem_size - 1;
for(j = 0; j < i; j++)
{
if((pau1_start[i] >= pau1_start[j]) && (pau1_start[i] <= pau1_end[j]))
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_OVERLAP_ERR;
return IV_FAIL;
}
if((pau1_end[i] >= pau1_start[j]) && (pau1_end[i] <= pau1_end[j]))
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_OVERLAP_ERR;
return IV_FAIL;
}
if((pau1_start[i] < pau1_start[j]) && (pau1_end[i] > pau1_end[j]))
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_OVERLAP_ERR;
return IV_FAIL;
}
}
}
}
{
iv_mem_rec_t as_mem_rec_ittiam_api[NUM_MEM_RECORDS];
impeg2d_fill_mem_rec_ip_t s_fill_mem_rec_ip;
impeg2d_fill_mem_rec_op_t s_fill_mem_rec_op;
IV_API_CALL_STATUS_T e_status;
WORD32 i4_num_memrec;
{
iv_num_mem_rec_ip_t s_no_of_mem_rec_query_ip;
iv_num_mem_rec_op_t s_no_of_mem_rec_query_op;
s_no_of_mem_rec_query_ip.u4_size = sizeof(iv_num_mem_rec_ip_t);
s_no_of_mem_rec_query_op.u4_size = sizeof(iv_num_mem_rec_op_t);
s_no_of_mem_rec_query_ip.e_cmd = IV_CMD_GET_NUM_MEM_REC;
impeg2d_api_function(NULL,
(void *)&s_no_of_mem_rec_query_ip,
(void *)&s_no_of_mem_rec_query_op);
i4_num_memrec = s_no_of_mem_rec_query_op.u4_num_mem_rec;
}
/* initialize mem records array with sizes */
for(i = 0; i < i4_num_memrec; i++)
{
as_mem_rec_ittiam_api[i].u4_size = sizeof(iv_mem_rec_t);
}
s_fill_mem_rec_ip.s_ivd_fill_mem_rec_ip_t.u4_size = sizeof(impeg2d_fill_mem_rec_ip_t);
s_fill_mem_rec_ip.s_ivd_fill_mem_rec_ip_t.e_cmd = IV_CMD_FILL_NUM_MEM_REC;
s_fill_mem_rec_ip.s_ivd_fill_mem_rec_ip_t.u4_max_frm_wd = ps_ip->s_ivd_init_ip_t.u4_frm_max_wd;
s_fill_mem_rec_ip.s_ivd_fill_mem_rec_ip_t.u4_max_frm_ht = ps_ip->s_ivd_init_ip_t.u4_frm_max_ht;
s_fill_mem_rec_ip.s_ivd_fill_mem_rec_ip_t.pv_mem_rec_location = as_mem_rec_ittiam_api;
s_fill_mem_rec_ip.u4_share_disp_buf = ps_ip->u4_share_disp_buf;
s_fill_mem_rec_ip.e_output_format = ps_ip->s_ivd_init_ip_t.e_output_format;
s_fill_mem_rec_op.s_ivd_fill_mem_rec_op_t.u4_size = sizeof(impeg2d_fill_mem_rec_op_t);
e_status = impeg2d_api_function(NULL,
(void *)&s_fill_mem_rec_ip,
(void *)&s_fill_mem_rec_op);
if(IV_FAIL == e_status)
{
ps_op->s_ivd_init_op_t.u4_error_code = s_fill_mem_rec_op.s_ivd_fill_mem_rec_op_t.u4_error_code;
return(IV_FAIL);
}
for(i = 0; i < i4_num_memrec; i ++)
{
if(ps_mem_rec[i].pv_base == NULL)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_BASE_NULL;
return IV_FAIL;
}
#ifdef CHECK_ALIGN
if((UWORD32)(ps_mem_rec[i].pv_base) & (ps_mem_rec[i].u4_mem_alignment - 1))
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_ALIGNMENT_ERR;
return IV_FAIL;
}
#endif //CHECK_ALIGN
if(ps_mem_rec[i].u4_mem_alignment != as_mem_rec_ittiam_api[i].u4_mem_alignment)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_ALIGNMENT_ERR;
return IV_FAIL;
}
if(ps_mem_rec[i].u4_mem_size < as_mem_rec_ittiam_api[i].u4_mem_size)
{
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_INSUFFICIENT_SIZE;
return IV_FAIL;
}
if(ps_mem_rec[i].e_mem_type != as_mem_rec_ittiam_api[i].e_mem_type)
{
if (IV_EXTERNAL_CACHEABLE_SCRATCH_MEM == as_mem_rec_ittiam_api[i].e_mem_type)
{
if (IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM == ps_mem_rec[i].e_mem_type)
{
continue;
}
}
ps_op->s_ivd_init_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_init_op_t.u4_error_code |= IVD_INIT_DEC_MEM_REC_INCORRECT_TYPE;
return IV_FAIL;
}
}
}
}
break;
case IVD_CMD_GET_DISPLAY_FRAME:
{
impeg2d_get_display_frame_ip_t *ps_ip = (impeg2d_get_display_frame_ip_t *)pv_api_ip;
impeg2d_get_display_frame_op_t *ps_op = (impeg2d_get_display_frame_op_t *)pv_api_op;
ps_op->s_ivd_get_display_frame_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_get_display_frame_ip_t.u4_size != sizeof(impeg2d_get_display_frame_ip_t))
{
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_op->s_ivd_get_display_frame_op_t.u4_size != sizeof(impeg2d_get_display_frame_op_t))
{
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_ip->s_ivd_get_display_frame_ip_t.s_out_buffer.u4_num_bufs == 0)
{
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= IVD_DISP_FRM_ZERO_OP_BUFS;
return IV_FAIL;
}
for(i = 0; i< (WORD32)ps_ip->s_ivd_get_display_frame_ip_t.s_out_buffer.u4_num_bufs;i++)
{
if(ps_ip->s_ivd_get_display_frame_ip_t.s_out_buffer.pu1_bufs[i] == NULL)
{
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= IVD_DISP_FRM_OP_BUF_NULL;
return IV_FAIL;
}
if(ps_ip->s_ivd_get_display_frame_ip_t.s_out_buffer.u4_min_out_buf_size[i] == 0)
{
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= IVD_DISP_FRM_ZERO_OP_BUF_SIZE;
return IV_FAIL;
}
/*
if(ps_ip->s_ivd_get_display_frame_ip_t.s_out_buffer.u4_min_out_buf_size[i] == 0)
{
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_get_display_frame_op_t.u4_error_code |= IVD_DISP_FRM_ZERO_OP_BUF_SIZE;
return IV_FAIL;
}
*/
}
}
break;
case IVD_CMD_REL_DISPLAY_FRAME:
{
impeg2d_rel_display_frame_ip_t *ps_ip = (impeg2d_rel_display_frame_ip_t *)pv_api_ip;
impeg2d_rel_display_frame_op_t *ps_op = (impeg2d_rel_display_frame_op_t *)pv_api_op;
ps_op->s_ivd_rel_display_frame_op_t.u4_error_code = 0;
if ((ps_ip->s_ivd_rel_display_frame_ip_t.u4_size != sizeof(impeg2d_rel_display_frame_ip_t))
&& (ps_ip->s_ivd_rel_display_frame_ip_t.u4_size != sizeof(ivd_rel_display_frame_ip_t)))
{
ps_op->s_ivd_rel_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_rel_display_frame_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if((ps_op->s_ivd_rel_display_frame_op_t.u4_size != sizeof(impeg2d_rel_display_frame_op_t)) &&
(ps_op->s_ivd_rel_display_frame_op_t.u4_size != sizeof(ivd_rel_display_frame_op_t)))
{
ps_op->s_ivd_rel_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_rel_display_frame_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
}
break;
case IVD_CMD_SET_DISPLAY_FRAME:
{
impeg2d_set_display_frame_ip_t *ps_ip = (impeg2d_set_display_frame_ip_t *)pv_api_ip;
impeg2d_set_display_frame_op_t *ps_op = (impeg2d_set_display_frame_op_t *)pv_api_op;
UWORD32 j, i;
ps_op->s_ivd_set_display_frame_op_t.u4_error_code = 0;
if ((ps_ip->s_ivd_set_display_frame_ip_t.u4_size != sizeof(impeg2d_set_display_frame_ip_t))
&& (ps_ip->s_ivd_set_display_frame_ip_t.u4_size != sizeof(ivd_set_display_frame_ip_t)))
{
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if((ps_op->s_ivd_set_display_frame_op_t.u4_size != sizeof(impeg2d_set_display_frame_op_t)) &&
(ps_op->s_ivd_set_display_frame_op_t.u4_size != sizeof(ivd_set_display_frame_op_t)))
{
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_ip->s_ivd_set_display_frame_ip_t.num_disp_bufs == 0)
{
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= IVD_DISP_FRM_ZERO_OP_BUFS;
return IV_FAIL;
}
for(j = 0; j < ps_ip->s_ivd_set_display_frame_ip_t.num_disp_bufs; j++)
{
if(ps_ip->s_ivd_set_display_frame_ip_t.s_disp_buffer[j].u4_num_bufs == 0)
{
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= IVD_DISP_FRM_ZERO_OP_BUFS;
return IV_FAIL;
}
for(i=0;i< ps_ip->s_ivd_set_display_frame_ip_t.s_disp_buffer[j].u4_num_bufs;i++)
{
if(ps_ip->s_ivd_set_display_frame_ip_t.s_disp_buffer[j].pu1_bufs[i] == NULL)
{
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= IVD_DISP_FRM_OP_BUF_NULL;
return IV_FAIL;
}
if(ps_ip->s_ivd_set_display_frame_ip_t.s_disp_buffer[j].u4_min_out_buf_size[i] == 0)
{
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_set_display_frame_op_t.u4_error_code |= IVD_DISP_FRM_ZERO_OP_BUF_SIZE;
return IV_FAIL;
}
}
}
}
break;
case IVD_CMD_VIDEO_DECODE:
{
impeg2d_video_decode_ip_t *ps_ip = (impeg2d_video_decode_ip_t *)pv_api_ip;
impeg2d_video_decode_op_t *ps_op = (impeg2d_video_decode_op_t *)pv_api_op;
ps_op->s_ivd_video_decode_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_video_decode_ip_t.u4_size != sizeof(impeg2d_video_decode_ip_t))
{
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 |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_op->s_ivd_video_decode_op_t.u4_size != sizeof(impeg2d_video_decode_op_t))
{
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 |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
}
break;
case IV_CMD_RETRIEVE_MEMREC:
{
impeg2d_retrieve_mem_rec_ip_t *ps_ip = (impeg2d_retrieve_mem_rec_ip_t *)pv_api_ip;
impeg2d_retrieve_mem_rec_op_t *ps_op = (impeg2d_retrieve_mem_rec_op_t *)pv_api_op;
iv_mem_rec_t *ps_mem_rec;
ps_op->s_ivd_retrieve_mem_rec_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_retrieve_mem_rec_ip_t.u4_size != sizeof(impeg2d_retrieve_mem_rec_ip_t))
{
ps_op->s_ivd_retrieve_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_retrieve_mem_rec_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
if(ps_op->s_ivd_retrieve_mem_rec_op_t.u4_size != sizeof(impeg2d_retrieve_mem_rec_op_t))
{
ps_op->s_ivd_retrieve_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_retrieve_mem_rec_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return(IV_FAIL);
}
ps_mem_rec = ps_ip->s_ivd_retrieve_mem_rec_ip_t.pv_mem_rec_location;
/* check memrecords sizes are correct */
for(i=0;i < NUM_MEM_RECORDS ; i++)
{
if(ps_mem_rec[i].u4_size != sizeof(iv_mem_rec_t))
{
ps_op->s_ivd_retrieve_mem_rec_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_retrieve_mem_rec_op_t.u4_error_code |= IVD_MEM_REC_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
}
break;
case IVD_CMD_VIDEO_CTL:
{
UWORD32 *pu4_ptr_cmd;
UWORD32 u4_sub_command;
pu4_ptr_cmd = (UWORD32 *)pv_api_ip;
pu4_ptr_cmd += 2;
u4_sub_command = *pu4_ptr_cmd;
switch(u4_sub_command)
{
case IVD_CMD_CTL_SETPARAMS:
{
impeg2d_ctl_set_config_ip_t *ps_ip;
impeg2d_ctl_set_config_op_t *ps_op;
ps_ip = (impeg2d_ctl_set_config_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_set_config_op_t *)pv_api_op;
ps_op->s_ivd_ctl_set_config_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_ctl_set_config_ip_t.u4_size != sizeof(impeg2d_ctl_set_config_ip_t))
{
ps_op->s_ivd_ctl_set_config_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_set_config_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
case IVD_CMD_CTL_SETDEFAULT:
{
impeg2d_ctl_set_config_op_t *ps_op;
ps_op = (impeg2d_ctl_set_config_op_t *)pv_api_op;
ps_op->s_ivd_ctl_set_config_op_t.u4_error_code = 0;
if(ps_op->s_ivd_ctl_set_config_op_t.u4_size != sizeof(impeg2d_ctl_set_config_op_t))
{
ps_op->s_ivd_ctl_set_config_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_set_config_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
break;
case IVD_CMD_CTL_GETPARAMS:
{
impeg2d_ctl_getstatus_ip_t *ps_ip;
impeg2d_ctl_getstatus_op_t *ps_op;
ps_ip = (impeg2d_ctl_getstatus_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_getstatus_op_t *)pv_api_op;
ps_op->s_ivd_ctl_getstatus_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_ctl_getstatus_ip_t.u4_size != sizeof(impeg2d_ctl_getstatus_ip_t))
{
ps_op->s_ivd_ctl_getstatus_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_getstatus_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->s_ivd_ctl_getstatus_op_t.u4_size != sizeof(impeg2d_ctl_getstatus_op_t))
{
ps_op->s_ivd_ctl_getstatus_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_getstatus_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
break;
case IVD_CMD_CTL_GETBUFINFO:
{
impeg2d_ctl_getbufinfo_ip_t *ps_ip;
impeg2d_ctl_getbufinfo_op_t *ps_op;
ps_ip = (impeg2d_ctl_getbufinfo_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_getbufinfo_op_t *)pv_api_op;
ps_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_ctl_getbufinfo_ip_t.u4_size != sizeof(impeg2d_ctl_getbufinfo_ip_t))
{
ps_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->s_ivd_ctl_getbufinfo_op_t.u4_size != sizeof(impeg2d_ctl_getbufinfo_op_t))
{
ps_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
break;
case IVD_CMD_CTL_GETVERSION:
{
impeg2d_ctl_getversioninfo_ip_t *ps_ip;
impeg2d_ctl_getversioninfo_op_t *ps_op;
ps_ip = (impeg2d_ctl_getversioninfo_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_getversioninfo_op_t *)pv_api_op;
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_ctl_getversioninfo_ip_t.u4_size != sizeof(impeg2d_ctl_getversioninfo_ip_t))
{
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->s_ivd_ctl_getversioninfo_op_t.u4_size != sizeof(impeg2d_ctl_getversioninfo_op_t))
{
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_getversioninfo_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
break;
case IVD_CMD_CTL_FLUSH:
{
impeg2d_ctl_flush_ip_t *ps_ip;
impeg2d_ctl_flush_op_t *ps_op;
ps_ip = (impeg2d_ctl_flush_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_flush_op_t *)pv_api_op;
ps_op->s_ivd_ctl_flush_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_ctl_flush_ip_t.u4_size != sizeof(impeg2d_ctl_flush_ip_t))
{
ps_op->s_ivd_ctl_flush_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_flush_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->s_ivd_ctl_flush_op_t.u4_size != sizeof(impeg2d_ctl_flush_op_t))
{
ps_op->s_ivd_ctl_flush_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_flush_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
break;
case IVD_CMD_CTL_RESET:
{
impeg2d_ctl_reset_ip_t *ps_ip;
impeg2d_ctl_reset_op_t *ps_op;
ps_ip = (impeg2d_ctl_reset_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_reset_op_t *)pv_api_op;
ps_op->s_ivd_ctl_reset_op_t.u4_error_code = 0;
if(ps_ip->s_ivd_ctl_reset_ip_t.u4_size != sizeof(impeg2d_ctl_reset_ip_t))
{
ps_op->s_ivd_ctl_reset_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_reset_op_t.u4_error_code |= IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->s_ivd_ctl_reset_op_t.u4_size != sizeof(impeg2d_ctl_reset_op_t))
{
ps_op->s_ivd_ctl_reset_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->s_ivd_ctl_reset_op_t.u4_error_code |= IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
}
break;
case IMPEG2D_CMD_CTL_GET_BUFFER_DIMENSIONS:
{
impeg2d_ctl_get_frame_dimensions_ip_t *ps_ip;
impeg2d_ctl_get_frame_dimensions_op_t *ps_op;
ps_ip =
(impeg2d_ctl_get_frame_dimensions_ip_t *)pv_api_ip;
ps_op =
(impeg2d_ctl_get_frame_dimensions_op_t *)pv_api_op;
if(ps_ip->u4_size
!= sizeof(impeg2d_ctl_get_frame_dimensions_ip_t))
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->u4_error_code |=
IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->u4_size
!= sizeof(impeg2d_ctl_get_frame_dimensions_op_t))
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->u4_error_code |=
IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
break;
}
case IMPEG2D_CMD_CTL_GET_SEQ_INFO:
{
impeg2d_ctl_get_seq_info_ip_t *ps_ip;
impeg2d_ctl_get_seq_info_op_t *ps_op;
ps_ip =
(impeg2d_ctl_get_seq_info_ip_t *)pv_api_ip;
ps_op =
(impeg2d_ctl_get_seq_info_op_t *)pv_api_op;
if(ps_ip->u4_size
!= sizeof(impeg2d_ctl_get_seq_info_ip_t))
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->u4_error_code |=
IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->u4_size
!= sizeof(impeg2d_ctl_get_seq_info_op_t))
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->u4_error_code |=
IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
break;
}
case IMPEG2D_CMD_CTL_SET_NUM_CORES:
{
impeg2d_ctl_set_num_cores_ip_t *ps_ip;
impeg2d_ctl_set_num_cores_op_t *ps_op;
ps_ip = (impeg2d_ctl_set_num_cores_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_set_num_cores_op_t *)pv_api_op;
if(ps_ip->u4_size
!= sizeof(impeg2d_ctl_set_num_cores_ip_t))
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->u4_error_code |=
IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->u4_size
!= sizeof(impeg2d_ctl_set_num_cores_op_t))
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->u4_error_code |=
IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
#ifdef MULTICORE
if((ps_ip->u4_num_cores < 1) || (ps_ip->u4_num_cores > MAX_THREADS))
#else
if(ps_ip->u4_num_cores != 1)
#endif
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
return IV_FAIL;
}
break;
}
case IMPEG2D_CMD_CTL_SET_PROCESSOR:
{
impeg2d_ctl_set_processor_ip_t *ps_ip;
impeg2d_ctl_set_processor_op_t *ps_op;
ps_ip = (impeg2d_ctl_set_processor_ip_t *)pv_api_ip;
ps_op = (impeg2d_ctl_set_processor_op_t *)pv_api_op;
if(ps_ip->u4_size
!= sizeof(impeg2d_ctl_set_processor_ip_t))
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->u4_error_code |=
IVD_IP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
if(ps_op->u4_size
!= sizeof(impeg2d_ctl_set_processor_op_t))
{
ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_op->u4_error_code |=
IVD_OP_API_STRUCT_SIZE_INCORRECT;
return IV_FAIL;
}
break;
}
default:
break;
}
}
break;
default:
{ *(pu4_api_op + 1) |= 1 << IVD_UNSUPPORTEDPARAM;
*(pu4_api_op + 1) |= IVD_UNSUPPORTED_API_CMD;
return IV_FAIL;
}
}
return IV_SUCCESS;
}
/*****************************************************************************/
/* */
/* Function Name : impeg2d_api_entity */
/* */
/* Description : */
/* */
/* Inputs : */
/* Globals : <Does it use any global variables?> */
/* Outputs : */
/* Returns : void */
/* */
/* Issues : none */
/* */
/* Revision History: */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 22 10 2008 100356 Draft */
/* */
/*****************************************************************************/
IV_API_CALL_STATUS_T impeg2d_api_entity(iv_obj_t *ps_dechdl,
void *pv_api_ip,
void *pv_api_op)
{
iv_obj_t *ps_dec_handle;
dec_state_t *ps_dec_state;
dec_state_multi_core_t *ps_dec_state_multi_core;
impeg2d_video_decode_ip_t *ps_dec_ip;
impeg2d_video_decode_op_t *ps_dec_op;
WORD32 bytes_remaining;
pic_buf_t *ps_disp_pic;
ps_dec_ip = (impeg2d_video_decode_ip_t *)pv_api_ip;
ps_dec_op = (impeg2d_video_decode_op_t *)pv_api_op;
memset(ps_dec_op,0,sizeof(impeg2d_video_decode_op_t));
ps_dec_op->s_ivd_video_decode_op_t.u4_size = sizeof(impeg2d_video_decode_op_t);
ps_dec_op->s_ivd_video_decode_op_t.u4_output_present = 0;
bytes_remaining = ps_dec_ip->s_ivd_video_decode_ip_t.u4_num_Bytes;
ps_dec_handle = (iv_obj_t *)ps_dechdl;
if(ps_dechdl == NULL)
{
return(IV_FAIL);
}
ps_dec_state_multi_core = ps_dec_handle->pv_codec_handle;
ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
ps_dec_state->ps_disp_frm_buf = &(ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf);
if(0 == ps_dec_state->u4_share_disp_buf)
{
ps_dec_state->ps_disp_frm_buf->pv_y_buf = ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[0];
ps_dec_state->ps_disp_frm_buf->pv_u_buf = ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[1];
ps_dec_state->ps_disp_frm_buf->pv_v_buf = ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[2];
}
ps_dec_state->ps_disp_pic = NULL;
ps_dec_state->i4_frame_decoded = 0;
/*rest bytes consumed */
ps_dec_op->s_ivd_video_decode_op_t.u4_num_bytes_consumed = 0;
ps_dec_op->s_ivd_video_decode_op_t.u4_error_code = IV_SUCCESS;
if((ps_dec_ip->s_ivd_video_decode_ip_t.pv_stream_buffer == NULL)&&(ps_dec_state->u1_flushfrm==0))
{
ps_dec_op->s_ivd_video_decode_op_t.u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
ps_dec_op->s_ivd_video_decode_op_t.u4_error_code |= IVD_DEC_FRM_BS_BUF_NULL;
return IV_FAIL;
}
if (ps_dec_state->u4_num_frames_decoded > NUM_FRAMES_LIMIT)
{
ps_dec_op->s_ivd_video_decode_op_t.u4_error_code = IMPEG2D_SAMPLE_VERSION_LIMIT_ERR;
return(IV_FAIL);
}
if(((0 == ps_dec_state->u2_header_done) || (ps_dec_state->u2_decode_header == 1)) && (ps_dec_state->u1_flushfrm == 0))
{
impeg2d_dec_hdr(ps_dec_state,ps_dec_ip ,ps_dec_op);
bytes_remaining -= ps_dec_op->s_ivd_video_decode_op_t.u4_num_bytes_consumed;
}
if((1 != ps_dec_state->u2_decode_header) &&
(((bytes_remaining > 0) && (1 == ps_dec_state->u2_header_done)) || ps_dec_state->u1_flushfrm))
{
if(ps_dec_state->u1_flushfrm)
{
if(ps_dec_state->aps_ref_pics[1] != NULL)
{
impeg2_disp_mgr_add(&ps_dec_state->s_disp_mgr, ps_dec_state->aps_ref_pics[1], ps_dec_state->aps_ref_pics[1]->i4_buf_id);
impeg2_buf_mgr_release(ps_dec_state->pv_pic_buf_mg, ps_dec_state->aps_ref_pics[1]->i4_buf_id, BUF_MGR_REF);
impeg2_buf_mgr_release(ps_dec_state->pv_pic_buf_mg, ps_dec_state->aps_ref_pics[0]->i4_buf_id, BUF_MGR_REF);
ps_dec_state->aps_ref_pics[1] = NULL;
ps_dec_state->aps_ref_pics[0] = NULL;
}
else if(ps_dec_state->aps_ref_pics[0] != NULL)
{
impeg2_disp_mgr_add(&ps_dec_state->s_disp_mgr, ps_dec_state->aps_ref_pics[0], ps_dec_state->aps_ref_pics[0]->i4_buf_id);
impeg2_buf_mgr_release(ps_dec_state->pv_pic_buf_mg, ps_dec_state->aps_ref_pics[0]->i4_buf_id, BUF_MGR_REF);
ps_dec_state->aps_ref_pics[0] = NULL;
}
ps_dec_ip->s_ivd_video_decode_ip_t.u4_size = sizeof(impeg2d_video_decode_ip_t);
ps_dec_op->s_ivd_video_decode_op_t.u4_size = sizeof(impeg2d_video_decode_op_t);
ps_disp_pic = impeg2_disp_mgr_get(&ps_dec_state->s_disp_mgr, &ps_dec_state->i4_disp_buf_id);
ps_dec_state->ps_disp_pic = ps_disp_pic;
if(ps_disp_pic == NULL)
{
ps_dec_op->s_ivd_video_decode_op_t.u4_output_present = 0;
}
else
{
WORD32 fmt_conv;
if(0 == ps_dec_state->u4_share_disp_buf)
{
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.pv_y_buf = ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[0];
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.pv_u_buf = ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[1];
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.pv_v_buf = ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[2];
fmt_conv = 1;
}
else
{
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.pv_y_buf = ps_disp_pic->pu1_y;
if(IV_YUV_420P == ps_dec_state->i4_chromaFormat)
{
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.pv_u_buf = ps_disp_pic->pu1_u;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.pv_v_buf = ps_disp_pic->pu1_v;
fmt_conv = 0;
}
else
{
UWORD8 *pu1_buf;
pu1_buf = ps_dec_state->as_disp_buffers[ps_disp_pic->i4_buf_id].pu1_bufs[1];
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.pv_u_buf = pu1_buf;
pu1_buf = ps_dec_state->as_disp_buffers[ps_disp_pic->i4_buf_id].pu1_bufs[2];
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.pv_v_buf = pu1_buf;
fmt_conv = 1;
}
}
if(fmt_conv == 1)
{
iv_yuv_buf_t *ps_dst;
ps_dst = &(ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf);
if(ps_dec_state->u4_deinterlace && (0 == ps_dec_state->u2_progressive_frame))
{
impeg2d_deinterlace(ps_dec_state,
ps_disp_pic,
ps_dst,
0,
ps_dec_state->u2_vertical_size);
}
else
{
impeg2d_format_convert(ps_dec_state,
ps_disp_pic,
ps_dst,
0,
ps_dec_state->u2_vertical_size);
}
}
if(ps_dec_state->u4_deinterlace)
{
if(ps_dec_state->ps_deint_pic)
{
impeg2_buf_mgr_release(ps_dec_state->pv_pic_buf_mg,
ps_dec_state->ps_deint_pic->i4_buf_id,
MPEG2_BUF_MGR_DEINT);
}
ps_dec_state->ps_deint_pic = ps_disp_pic;
}
if(0 == ps_dec_state->u4_share_disp_buf)
impeg2_buf_mgr_release(ps_dec_state->pv_pic_buf_mg, ps_disp_pic->i4_buf_id, BUF_MGR_DISP);
ps_dec_op->s_ivd_video_decode_op_t.u4_pic_ht = ps_dec_state->u2_vertical_size;
ps_dec_op->s_ivd_video_decode_op_t.u4_pic_wd = ps_dec_state->u2_horizontal_size;
ps_dec_op->s_ivd_video_decode_op_t.u4_output_present = 1;
ps_dec_op->s_ivd_video_decode_op_t.u4_disp_buf_id = ps_disp_pic->i4_buf_id;
ps_dec_op->s_ivd_video_decode_op_t.u4_ts = ps_disp_pic->u4_ts;
ps_dec_op->s_ivd_video_decode_op_t.e_output_format = (IV_COLOR_FORMAT_T)ps_dec_state->i4_chromaFormat;
ps_dec_op->s_ivd_video_decode_op_t.u4_is_ref_flag = (B_PIC != ps_dec_state->e_pic_type);
ps_dec_op->s_ivd_video_decode_op_t.u4_progressive_frame_flag = IV_PROGRESSIVE;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_y_wd = ps_dec_state->u2_horizontal_size;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_y_strd = ps_dec_state->u4_frm_buf_stride;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_y_ht = ps_dec_state->u2_vertical_size;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_wd = ps_dec_state->u2_horizontal_size >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_strd = ps_dec_state->u4_frm_buf_stride >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_ht = ps_dec_state->u2_vertical_size >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_wd = ps_dec_state->u2_horizontal_size >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_strd = ps_dec_state->u4_frm_buf_stride >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_ht = ps_dec_state->u2_vertical_size >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_size = sizeof(ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf);
switch(ps_dec_state->i4_chromaFormat)
{
case IV_YUV_420SP_UV:
case IV_YUV_420SP_VU:
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_wd = ps_dec_state->u2_horizontal_size;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_strd = ps_dec_state->u4_frm_buf_stride;
break;
case IV_YUV_422ILE:
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_wd = 0;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_ht = 0;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_wd = 0;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_ht = 0;
break;
default:
break;
}
}
if(ps_dec_op->s_ivd_video_decode_op_t.u4_output_present)
{
if(1 == ps_dec_op->s_ivd_video_decode_op_t.u4_output_present)
{
INSERT_LOGO(ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[0],
ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[1],
ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[2],
ps_dec_state->u4_frm_buf_stride,
ps_dec_state->u2_horizontal_size,
ps_dec_state->u2_vertical_size,
ps_dec_state->i4_chromaFormat,
ps_dec_state->u2_horizontal_size,
ps_dec_state->u2_vertical_size);
}
return(IV_SUCCESS);
}
else
{
ps_dec_state->u1_flushfrm = 0;
return(IV_FAIL);
}
}
else if(ps_dec_state->u1_flushfrm==0)
{
ps_dec_ip->s_ivd_video_decode_ip_t.u4_size = sizeof(impeg2d_video_decode_ip_t);
ps_dec_op->s_ivd_video_decode_op_t.u4_size = sizeof(impeg2d_video_decode_op_t);
if(ps_dec_ip->s_ivd_video_decode_ip_t.u4_num_Bytes < 4)
{
ps_dec_op->s_ivd_video_decode_op_t.u4_num_bytes_consumed = ps_dec_ip->s_ivd_video_decode_ip_t.u4_num_Bytes;
return(IV_FAIL);
}
if(1 == ps_dec_state->u4_share_disp_buf)
{
if(0 == impeg2_buf_mgr_check_free(ps_dec_state->pv_pic_buf_mg))
{
ps_dec_op->s_ivd_video_decode_op_t.u4_error_code =
(IMPEG2D_ERROR_CODES_T)IVD_DEC_REF_BUF_NULL;
return IV_FAIL;
}
}
ps_dec_op->s_ivd_video_decode_op_t.e_output_format = (IV_COLOR_FORMAT_T)ps_dec_state->i4_chromaFormat;
ps_dec_op->s_ivd_video_decode_op_t.u4_is_ref_flag = (B_PIC != ps_dec_state->e_pic_type);
ps_dec_op->s_ivd_video_decode_op_t.u4_progressive_frame_flag = IV_PROGRESSIVE;
if (0 == ps_dec_state->u4_frm_buf_stride)
{
ps_dec_state->u4_frm_buf_stride = (ps_dec_state->u2_horizontal_size);
}
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_y_wd = ps_dec_state->u2_horizontal_size;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_y_strd = ps_dec_state->u4_frm_buf_stride;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_y_ht = ps_dec_state->u2_vertical_size;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_wd = ps_dec_state->u2_horizontal_size >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_strd = ps_dec_state->u4_frm_buf_stride >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_ht = ps_dec_state->u2_vertical_size >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_wd = ps_dec_state->u2_horizontal_size >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_strd = ps_dec_state->u4_frm_buf_stride >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_ht = ps_dec_state->u2_vertical_size >> 1;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_size = sizeof(ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf);
switch(ps_dec_state->i4_chromaFormat)
{
case IV_YUV_420SP_UV:
case IV_YUV_420SP_VU:
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_wd = ps_dec_state->u2_horizontal_size;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_strd = ps_dec_state->u4_frm_buf_stride;
break;
case IV_YUV_422ILE:
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_wd = 0;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_u_ht = 0;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_wd = 0;
ps_dec_op->s_ivd_video_decode_op_t.s_disp_frm_buf.u4_v_ht = 0;
break;
default:
break;
}
if( ps_dec_state->u1_flushfrm == 0)
{
ps_dec_state->u1_flushcnt = 0;
ps_dec_state->ps_out_buf = &ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer;
if (IV_SUCCESS != check_app_out_buf_size(ps_dec_state))
{
ps_dec_op->s_ivd_video_decode_op_t.u4_error_code = IVD_DISP_FRM_ZERO_OP_BUF_SIZE;
return IV_FAIL;
}
/*************************************************************************/
/* Frame Decode */
/*************************************************************************/
ps_dec_state->u4_inp_ts = ps_dec_ip->s_ivd_video_decode_ip_t.u4_ts;
impeg2d_dec_frm(ps_dec_state,ps_dec_ip,ps_dec_op);
if (IVD_ERROR_NONE ==
ps_dec_op->s_ivd_video_decode_op_t.u4_error_code)
{
if(ps_dec_state->u1_first_frame_done == 0)
{
ps_dec_state->u1_first_frame_done = 1;
}
if(ps_dec_state->ps_disp_pic)
{
ps_dec_op->s_ivd_video_decode_op_t.u4_output_present = 1;
switch(ps_dec_state->ps_disp_pic->e_pic_type)
{
case I_PIC :
ps_dec_op->s_ivd_video_decode_op_t.e_pic_type = IV_I_FRAME;
break;
case P_PIC:
ps_dec_op->s_ivd_video_decode_op_t.e_pic_type = IV_P_FRAME;
break;
case B_PIC:
ps_dec_op->s_ivd_video_decode_op_t.e_pic_type = IV_B_FRAME;
break;
case D_PIC:
ps_dec_op->s_ivd_video_decode_op_t.e_pic_type = IV_I_FRAME;
break;
default :
ps_dec_op->s_ivd_video_decode_op_t.e_pic_type = IV_FRAMETYPE_DEFAULT;
break;
}
}
else
{
ps_dec_op->s_ivd_video_decode_op_t.u4_output_present = 0;
ps_dec_op->s_ivd_video_decode_op_t.e_pic_type = IV_NA_FRAME;
}
ps_dec_state->u4_num_frames_decoded++;
}
}
else
{
ps_dec_state->u1_flushcnt++;
}
}
if(ps_dec_state->ps_disp_pic)
{
ps_dec_op->s_ivd_video_decode_op_t.u4_disp_buf_id = ps_dec_state->ps_disp_pic->i4_buf_id;
ps_dec_op->s_ivd_video_decode_op_t.u4_ts = ps_dec_state->ps_disp_pic->u4_ts;
if(0 == ps_dec_state->u4_share_disp_buf)
{
impeg2_buf_mgr_release(ps_dec_state->pv_pic_buf_mg, ps_dec_state->ps_disp_pic->i4_buf_id, BUF_MGR_DISP);
}
}
if(ps_dec_state->u4_deinterlace)
{
if(ps_dec_state->ps_deint_pic)
{
impeg2_buf_mgr_release(ps_dec_state->pv_pic_buf_mg,
ps_dec_state->ps_deint_pic->i4_buf_id,
MPEG2_BUF_MGR_DEINT);
}
ps_dec_state->ps_deint_pic = ps_dec_state->ps_disp_pic;
}
if(1 == ps_dec_op->s_ivd_video_decode_op_t.u4_output_present)
{
INSERT_LOGO(ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[0],
ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[1],
ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer.pu1_bufs[2],
ps_dec_state->u4_frm_buf_stride,
ps_dec_state->u2_horizontal_size,
ps_dec_state->u2_vertical_size,
ps_dec_state->i4_chromaFormat,
ps_dec_state->u2_horizontal_size,
ps_dec_state->u2_vertical_size);
}
}
ps_dec_op->s_ivd_video_decode_op_t.u4_progressive_frame_flag = 1;
ps_dec_op->s_ivd_video_decode_op_t.e4_fld_type = ps_dec_state->s_disp_op.e4_fld_type;
if(ps_dec_op->s_ivd_video_decode_op_t.u4_error_code)
return IV_FAIL;
else
return IV_SUCCESS;
}