/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2009-2019. All rights reserved.
 * Description: Defines avplay adapter api
 * Author: Hisilicon
 * Create: 2009-12-21
 * History:
 */
#ifndef __AVPLAY_ADAPTER_H__
#define __AVPLAY_ADAPTER_H__

#include "mpi_avplay_ext.h"
#include "mpi_sync_ext.h"
#include "mpi_demux_ext.h"
#include "drv_video_ext.h"
#include "avplay_context.h"
#include "drv_ioctl_avplay.h"

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif

td_u32 avplay_adp_get_video_packing_user_type(td_u32 drv_type);
td_u32 avplay_adp_get_video_packing_drv_type(td_u32 user_type);
td_u32 avplay_adp_get_video_codec_user_type(td_u32 drv_type);
td_u32 avplay_adp_get_video_bitdepth_user_type(td_u32 bit_depth); /* u32 to uapi_pixel_bit_depth */

td_s32 avplay_adp_open_decoder(td_handle *decoder, td_bool is_vid, const avplay_com_ctx *com);
td_s32 avplay_adp_open_dmx_band(td_handle *dmx_band, td_u32 dmx_id);
td_s32 avplay_adp_open_demux(td_handle *dmx, td_bool is_vid, td_bool secure, const avplay_com_ctx *com);
td_s32 avplay_adp_open_multi_aud_dmx(avplay_aud_ctx *aud, td_u32 aud_cnt, td_bool first);
td_s32 avplay_adp_close_decoder(td_handle *decoder, td_bool is_vid);
td_s32 avplay_adp_close_dmx_band(td_handle *dmx_band);
td_s32 avplay_adp_close_demux(td_handle *demux, td_handle *pid_ch);
td_s32 avplay_adp_close_multi_aud_dmx(avplay_aud_ctx *aud, td_bool close_first);

td_s32 avplay_adp_config_dmx(td_handle dmx, uapi_vcodec_type vcodec_type);
td_s32 avplay_adp_ctrl_dmx_index(td_handle dmx, td_bool is_start);
td_s32 avplay_adp_start_dmx(const avplay_context *ctx, td_bool is_vid);
td_s32 avplay_adp_stop_dmx(avplay_context *ctx, td_bool is_vid);
td_s32 avplay_adp_discard_dmx_es(td_handle avplay, td_handle dmx, td_bool is_vid, dmx_buffer *buf_info);

td_s32 avplay_adp_malloc_es_buffer(avplay_vid_ctx *vid, const uapi_avplay_attr *attr);
td_s32 avplay_adp_free_es_buffer(avplay_vid_ctx *vid, const uapi_avplay_attr *attr);
td_s32 avplay_adp_malloc_user_data(avplay_vid_ctx *vid);
td_s32 avplay_adp_free_user_data(avplay_vid_ctx *vid);
td_s32 avplay_adp_malloc_frm_buffer(avplay_vid_ctx *vid, const avplay_resolution_param *param);
td_s32 avplay_adp_free_frm_buffer(avplay_vid_ctx *vid, td_mem_handle_t frm_fd, td_bool destroy);

td_s32 avplay_adp_set_pid(td_handle dmx_band, td_handle dmx, td_u32 pid, td_handle *pid_ch);
td_s32 avplay_adp_set_ad_balance(const avplay_aud_ctx *aud,  td_s16 balance);
td_s32 avplay_adp_set_adec_attr(td_handle adec,
    td_u32 es_buf_size, td_u32 out_buf_num, const uapi_audio_decode_attr *attr);
td_s32 avplay_adp_get_adec_attr(td_handle adec, uapi_audio_decode_attr *attr);
td_s32 avplay_adp_set_ad_adec_attr(td_handle adec, td_handle ad_adec);
td_s32 avplay_adp_set_track_attr(td_handle track, const uapi_audio_decode_attr *attr);
td_s32 avplay_adp_check_acodec_support(uapi_acodec_id codec_id, td_bool *support);
td_s32 avplay_adp_set_vdec_attr(const avplay_vid_ctx *vid, const avplay_vdec_attr *v_attr);
td_s32 avplay_adp_set_dolbyvision_attr(td_handle vdec, td_bool is_el, const uapi_avplay_dolby_hdr_attr *attr);
td_s32 avplay_adp_reopen_vdec(avplay_vid_ctx *vid);
td_s32 avplay_adp_set_framerate(td_handle vdec, const uapi_avplay_frame_rate_param *framerate);
td_s32 avplay_adp_get_framerate(td_handle vdec, uapi_avplay_frame_rate_param *framerate);
td_s32 avplay_adp_set_vpeek(td_handle vdec, const avplay_peek_frame_info *peek);

td_s32 avplay_adp_set_vcodec_mode(td_handle vdec, uapi_vdec_work_mode mode);
td_s32 avplay_adp_decode_vid_iframe(td_handle vdec, const uapi_avplay_iframe_info *in, ext_drv_video_frame *out);
td_s32 avplay_adp_release_vid_iframe(td_handle vdec, const ext_drv_video_frame *in);
td_s32 avplay_adp_send_vid_iframe(td_handle window, td_handle vdec, ext_drv_video_frame *frame);
td_s32 avplay_adp_release_vid_frame(td_handle vdec, ext_vdec_frame *vdec_frame, td_bool is_close_fence);
td_s32 avplay_adp_start_vid(avplay_vid_ctx *vid, const avplay_com_ctx *com, td_bool only_flush);
td_s32 avplay_adp_stop_vid(avplay_vid_ctx *vid, avplay_com_ctx *com, td_bool only_flush, uapi_avplay_stop_mode mode);
td_s32 avplay_adp_start_adec_ao(avplay_aud_ctx *aud);
td_s32 avplay_adp_stop_adec_ao(const avplay_aud_ctx *aud);
td_s32 avplay_adp_start_aud(avplay_aud_ctx *aud, const avplay_com_ctx *com, td_bool only_flush);
td_s32 avplay_adp_stop_aud(const avplay_aud_ctx *aud, const avplay_com_ctx *com, td_bool only_flush);
td_s32 avplay_adp_open_pcr(avplay_com_ctx *com, td_u32 pid);
td_s32 avplay_adp_close_pcr(avplay_com_ctx *com);
td_s32 avplay_adp_set_vid_eos(const avplay_vid_ctx *vid);
td_s32 avplay_adp_set_aud_eos(const avplay_aud_ctx *aud);

td_s32 avplay_adp_freeze_vid(avplay_vid_ctx *vid);
td_s32 avplay_adp_unfreeze_vid(avplay_vid_ctx *vid);
td_s32 avplay_adp_pause_vid(const avplay_vid_ctx *vid);
td_s32 avplay_adp_pause_aud(const avplay_aud_ctx *aud);

td_s32 avplay_adp_vid_tplay(const avplay_vid_ctx *vid_ctx, const uapi_avplay_tplay_opt *speed);
td_s32 avplay_adp_aud_tplay(const avplay_aud_ctx *aud_ctx, const uapi_avplay_tplay_opt *speed);
td_s32 avplay_adp_resume(const avplay_context *ctx, uapi_avplay_media_chan chn, td_bool is_resume_sync);
td_s32 avplay_adp_get_vid_buf(avplay_vid_ctx *vid, td_u32 req_len, avplay_vid_buf *buf);
td_s32 avplay_adp_put_vid_buf(avplay_vid_ctx *vid, const avplay_vid_buf *buf);
td_s32 avplay_adp_get_aud_buf(td_handle handle, avplay_aud_mode mode, td_bool is_ad,
                              td_u32 req_len, ext_stream_buf *buf);
td_s32 avplay_adp_put_aud_buf(td_handle handle, avplay_aud_mode mode, td_bool is_ad,
                              const ext_stream_buf *buf, td_s64 pts);

td_s32 avplay_adp_get_vid_feature(td_handle vdec, uapi_video_stream_info *feature);
td_s32 avplay_adp_get_aud_feature(td_handle handle, td_bool is_track, uapi_audio_stream_info *feature);
td_s32 avplay_adp_vdec_register_event(td_handle vdec, const avplay_com_ctx *com);
td_s32 avplay_adp_vdec_read_user_data(td_handle vdec, uapi_video_userdata_type *type, uapi_video_userdata *data);
td_s32 avplay_adp_vdec_acq_user_data(const avplay_vid_ctx *vid, uapi_video_userdata_type type,
    uapi_video_userdata *data);
td_s32 avplay_adp_vdec_rls_user_data(const avplay_vid_ctx *vid, uapi_video_userdata_type type,
                                     const uapi_video_userdata *data);
td_void avplay_adp_hdrinfo_drv_to_user(ext_drv_hdr_type drv_hdr_type, const ext_drv_color_descript *drv_color,
                                       const ext_drv_hdr_metadata *drv_hdr_info, uapi_hdr_info *usr_hdr_info);
td_void avplay_adp_hdrinfo_user_to_drv(const uapi_hdr_info *usr_hdr_info, ext_drv_hdr_type *drv_hdr_type,
                                       ext_drv_color_descript *drv_color, ext_drv_hdr_metadata *drv_hdr_info);

td_s32 avplay_adp_frminfo_drv_to_user(const ext_drv_video_frame *drv_frame, uapi_video_frame_info *user_frame);
td_s32 avplay_adp_frminfo_user_to_drv(const uapi_video_frame_info *user_frame, ext_drv_video_frame *drv_frame);

td_bool avplay_adp_is_ts_live_play(const avplay_com_ctx *com);
td_bool avplay_adp_is_support_random_stream(const avplay_vid_ctx *vid);
td_s32 avplay_adp_vdec_cmd(td_handle vdec, td_u32 cmd, void *param, td_u32 param_size);
td_s32 avplay_adp_vid_invoke(const avplay_vid_ctx *vid_ctx, uapi_avplay_codec_cmd_param *cmd);
td_u32 avplay_adp_sync_result_drv_to_user(td_u32 sync_result);
td_u32 avplay_adp_sync_result_user_to_drv(td_u32 sync_result);
td_u32 avplay_adp_pts_chan_drv_to_user(td_u32 pts_chan);

td_s32 avplay_adp_get_vdec_capability(uapi_vcodec_type type, uapi_vdec_output_capability *capability);
td_s32 avplay_adp_set_low_delay_sync_mode(avplay_context *ctx, ext_mpi_sync_ref_mode ref_mode);

td_s32 avplay_adp_set_hdr_strategy_info(const avplay_context *ctx, td_bool is_reset);

#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif

#endif