/* Copyright Statement:
 *
 * This software/firmware and related documentation ("MediaTek Software") are
 * protected under relevant copyright laws. The information contained herein
 * is confidential and proprietary to MediaTek Inc. and/or its licensors.
 * Without the prior written permission of MediaTek inc. and/or its licensors,
 * any reproduction, modification, use or disclosure of MediaTek Software,
 * and information contained herein, in whole or in part, shall be strictly
 * prohibited.
* *
* * MediaTek Inc. (C) 2016. All rights reserved.
* *
* * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
* * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
* * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
* * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
* * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* * NONINFRINGEMENT.
* * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
* * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
* * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO
* * SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER
* * EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN
* * FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK SOFTWARE.
* * MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES
* * MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR
* * OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
* * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED
* * HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK
* * SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE
* * PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
* *
* * The following software/firmware and/or related documentation ("MediaTek Software")
* * have been modified by MediaTek Inc. All revisions are subject to any receiver's
* * applicable license agreements with MediaTek Inc.
* */

// System header files
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/time.h>
#include <errno.h>
#include <dlfcn.h>
#include <stddef.h>
#include "dual_audio_api.h"


// Local header files.
#if defined(MTK_DUAL_AUDIO) && (MTK_DUAL_AUDIO == TRUE)

static const dualaudio_interface_t *g_dualaudio_interface = NULL;

bool dual_audio_library_load() {
  LOG_DEBUG("dual_audio_library_load into");
  void *bluetooth_handle = NULL;

  bluetooth_handle = dlopen("libdualaudio.so", RTLD_LAZY);
  if (!bluetooth_handle)
  {
      LOG_ERROR("libdualaudio.so open fail(%s)", dlerror());
      return false;
  }
  g_dualaudio_interface = (dualaudio_interface_t *)dlsym(bluetooth_handle, "dualaudioInterface");

  if (NULL == g_dualaudio_interface)
  {
      LOG_ERROR("Failed to get dualaudio interface");
      return false;
  }

  return true;
}

void a2dp_get_user_ajust_LR_channel(void) {
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_get_user_ajust_LR_channel();
}

void dump_left_right_channel_data_file_init(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->dump_left_right_channel_data_file_init();
}

void dump_left_right_channel_data_file_deinit(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->dump_left_right_channel_data_file_deinit();
}

void a2dp_get_user_want_delay_time(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_get_user_want_delay_time();
}

void a2dp_suspend_drop_data_queue(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_suspend_drop_data_queue();
}

void btif_a2dp_source_dual_audio_enqueue_data(BT_HDR* p_buf, BT_HDR* p_buf2){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_a2dp_source_dual_audio_enqueue_data(p_buf, p_buf2);
}

void a2dp_lr_channel_handle_data_for_dual_audio(BT_HDR* p_buf2, int16_t* input,  int num_bytes, uint16_t &output_len, uint8_t* output){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_lr_channel_handle_data_for_dual_audio(p_buf2, input, num_bytes, output_len, output);
}

void a2dp_sameaudio_handle_data_for_dual_audio(BT_HDR* p_buf2, int16_t* input, int num_bytes, uint16_t &output_len, uint8_t* output){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_sameaudio_handle_data_for_dual_audio(p_buf2, input, num_bytes, output_len, output);
}

void bta_av_data_to_l2cap(tBTA_AV_SCB* p_scb, int i){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_data_to_l2cap(p_scb, i);
}

void bta_av_link_distribution(uint8_t *bta_av_queue_num){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_link_distribution(bta_av_queue_num);
}

void bta_av_old_data_handle(tBTA_AV_SCB* p_scb, BT_HDR* p_pkt){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_old_data_handle(p_scb, p_pkt);
}

void bta_av_dup_audio_handle_for_dual_audio(tBTA_AV_SCB* p_scb, BT_HDR* p_buf){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_dup_audio_handle_for_dual_audio(p_scb, p_buf);
}

bool l2cu_check_condition_for_dual_audio(uint8_t* dc){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->l2cu_check_condition_for_dual_audio(dc);
  return false;
}

bool l2cu_can_allocate_lcb_for_dual_audio(tL2C_CB &l2cb){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->l2cu_can_allocate_lcb_for_dual_audio(l2cb);
  return false;
}

void avdt_ccb_ajust_SBC_codec(tAVDT_CCB_EVT* p_data){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->avdt_ccb_ajust_SBC_codec(p_data);
}

void a2dp_sbc_encoder_update_for_dual_audio(SBC_ENC_PARAMS* p_encoder_params){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_sbc_encoder_update_for_dual_audio(p_encoder_params);
}

void a2dp_sbc_encoder_update_for_LR_channel_mode(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_sbc_encoder_update_for_LR_channel_mode();
}

void SBC_Encoder_Init_for_dual_audio(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->SBC_Encoder_Init_for_dual_audio();
}

void btif_a2dp_get_audio_config_for_dual_audio(btav_a2dp_codec_config_t &codec_config, btav_a2dp_codec_config_t &codec_capability){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_a2dp_get_audio_config_for_dual_audio(codec_config, codec_capability);
}

void bta_av_str_opened_for_dual_audio(tBTA_AV_SCB* p_scb){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_str_opened_for_dual_audio(p_scb);
}

void bta_av_str_opend_handle_for_dual_audio(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_str_opend_handle_for_dual_audio();
}

void bta_av_str_stopped_for_dual_audio(tBTA_AV_SCB* p_scb){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_str_stopped_for_dual_audio(p_scb);
}

void bta_av_start_ok_for_dual_audio(tBTA_AV_SCB* p_scb){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_start_ok_for_dual_audio(p_scb);
}

void bta_av_start_ok_for_dual_audio2(tBTA_AV_SCB* p_scb){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_start_ok_for_dual_audio2(p_scb);
}

void bta_av_str_closed_for_dual_audio(tBTA_AV_SCB* p_scb){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_str_closed_for_dual_audio(p_scb);
}

void bta_av_suspend_cfm_for_dual_audio(tBTA_AV_SCB* p_scb){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_suspend_cfm_for_dual_audio(p_scb);
}

void bta_av_api_enable_for_dual_audio(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->bta_av_api_enable_for_dual_audio();
}

void a2dp_sbc_buffer_handle_for_dual_audio(SBC_ENC_PARAMS* p_encoder_params){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_sbc_buffer_handle_for_dual_audio(p_encoder_params);
}

void avdt_ccb_hdl_discover_cmd_for_dual_audio(AvdtpScb* p_scb,  tAVDT_SEP_INFO *sep_info, tAVDT_CCB_EVT* p_data){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->avdt_ccb_hdl_discover_cmd_for_dual_audio(p_scb, sep_info, p_data);
}

void btif_a2dp_set_audio_config_for_dual_audio(btav_a2dp_codec_config_t &codec_config){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_a2dp_set_audio_config_for_dual_audio(codec_config);
}

void updateEffectiveMtu_for_dual_audio(int mtu){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->updateEffectiveMtu_for_dual_audio(mtu);
}

bool btif_a2dp_source_setup_codec_delayed_for_dual_audio(A2dpCodecConfig* a2dp_codec_config, const RawAddress& peer_address){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_a2dp_source_setup_codec_delayed_for_dual_audio(a2dp_codec_config, peer_address);
  return false;
}

bool SetActivePeer_for_audio_audio(RawAddress& active_peer_, const RawAddress& peer_address, std::promise<void> peer_ready_promise){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->SetActivePeer_for_audio_audio(active_peer_, peer_address, std::move(peer_ready_promise));
  return false;
}

void btif_closing_state_process_stop_event(uint32_t event){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_closing_state_process_stop_event(event);
}

void btif_closing_state_onenter(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_closing_state_onenter();
}

void btif_started_state_process_close_event(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_started_state_process_close_event();
}

void btif_opened_state_process_close_event(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_opened_state_process_close_event();
}

void btif_opened_state_process_start_event(const RawAddress& peer_address){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_opened_state_process_start_event(peer_address);
}

bool btif_idle_state_onenter(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_idle_state_onenter();
  return false;
}

bool btif_idle_state_onenter2(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_idle_state_onenter2();
  return false;
}

bool btif_av_stream_started_ready_for_dual_audio(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_av_stream_started_ready_for_dual_audio();
  return false;
}

bool btif_av_stream_ready_for_dual_audio(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_av_stream_ready_for_dual_audio();
  return false;
}

void btif_started_state_process_stop_event(tBTA_AV_SUSPEND* p_av_suspend, const RawAddress& peer_address){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_started_state_process_stop_event(p_av_suspend, peer_address);
}

void btif_started_state_process_stop_suspend_event(uint32_t event){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->btif_started_state_process_stop_suspend_event(event);
}

void updateEncoderUserConfig_for_dual_audio(const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->updateEncoderUserConfig_for_dual_audio(p_peer_params);
}

void a2dp_sbc_get_num_frame_iteration_for_dual_audio(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_sbc_get_num_frame_iteration_for_dual_audio();
}

void a2dp_sbc_get_num_frame_iteration_for_dual_audio2(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->a2dp_sbc_get_num_frame_iteration_for_dual_audio2();
}

void dual_audio_init(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->dual_audio_init();
}

void dual_audio_deinit(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->dual_audio_deinit();
}

bt_a2dp_dual_mode_type_t getDualModeType(void){
  if (g_dualaudio_interface != NULL)
    return g_dualaudio_interface->getDualModeType();
  return BT_A2DP_DUAL_MODE_NORMAL_TYPE;
}
#endif