a2dp_decoder.cpp

/***************************************************************************
 *
 * Copyright 2015-2019 BES.
 * All rights reserved. All unpublished rights reserved.
 *
 * No part of this work may be used or reproduced in any form or by any
 * means, or stored in a database or retrieval system, without prior written
 * permission of BES.
 *
 * Use of this work is governed by a license granted by BES.
 * This work contains confidential and proprietary information of
 * BES. which is protected by copyright, trade secret,
 * trademark and other intellectual property rights.
 *
 ****************************************************************************/
// Standard C Included Files
#define __STDC_LIMIT_MACROS
#include "a2dp_decoder.h"
#include "a2dp_decoder_internal.h"
#include "app_audio.h"
#include "app_bt.h"
#include "app_bt_media_manager.h"
#include "audioflinger.h"
#include "avdtp_api.h"
#include "bt_drv_reg_op.h"
#include "cmsis.h"
#include "cmsis_os.h"
#include "codec_sbc.h"
#include "hal_location.h"
#include "hal_timer.h"
#include "heap_api.h"
#include "plat_types.h"
#include <string.h>
#if defined(IBRT)
#include "app_ibrt_if.h"
#include "app_tws_ctrl_thread.h"
#include "app_tws_ibrt_audio_analysis.h"
#include "app_tws_ibrt_audio_sync.h"
#include "app_tws_ibrt_cmd_handler.h"
#include "bt_drv_interface.h"
#include "btapp.h"
#endif
#include "audio_prompt_sbc.h"
#include "crc32.h"

#ifndef A2DP_AUDIO_MEMPOOL_SIZE
#if defined(A2DP_LDAC_ON)
#define A2DP_AUDIO_LDAC_MEMPOOL_SIZE (76 * 1024)
#endif
#define A2DP_AUDIO_MEMPOOL_SIZE (72 * 1024)
#endif
#define A2DP_AUDIO_WAIT_TIMEOUT_MS (500)
#define A2DP_AUDIO_MUTE_FRAME_CNT_AFTER_NO_CACHE (25)
#define A2DP_AUDIO_SKIP_FRAME_LIMIT_AFTER_NO_CACHE (50)

#define A2DP_AUDIO_REFILL_AFTER_NO_CACHE (1)

#ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__
#define A2DP_AUDIO_SYNC_INTERVAL (25)
#else
#define A2DP_AUDIO_SYNC_INTERVAL (1000)
#endif

#define A2DP_AUDIO_LATENCY_LOW_FACTOR (1.0f)
#define A2DP_AUDIO_LATENCY_HIGH_FACTOR (1.6f)
#define A2DP_AUDIO_LATENCY_MORE_FACTOR (1.2f)

#define A2DP_AUDIO_SYNC_FACTOR_REFERENCE (1.0f)
#define A2DP_AUDIO_SYNC_FACTOR_FAST_LIMIT (0.00015f)
#define A2DP_AUDIO_SYNC_FACTOR_SLOW_LIMIT (-0.00035f)
#define A2DP_AUDIO_SYNC_FACTOR_NEED_FAST_CACHE (-0.001f)

#define A2DP_AUDIO_UNDERFLOW_CAUSE_AUDIO_RETRIGGER (1)

extern A2DP_AUDIO_DECODER_T a2dp_audio_sbc_decoder_config;
#if defined(A2DP_AAC_ON)
extern A2DP_AUDIO_DECODER_T a2dp_audio_aac_lc_decoder_config;
#endif
#if defined(A2DP_LHDC_ON)
extern A2DP_AUDIO_DECODER_T a2dp_audio_lhdc_decoder_config;
#endif

#if defined(A2DP_LDAC_ON)
extern A2DP_AUDIO_DECODER_T a2dp_audio_ldac_decoder_config;
#endif

#if defined(A2DP_SCALABLE_ON)
extern A2DP_AUDIO_DECODER_T a2dp_audio_scalable_decoder_config;
#endif

osSemaphoreDef(audio_buffer_semaphore);
osMutexDef(audio_buffer_mutex);
osMutexDef(audio_status_mutex);
osMutexDef(audio_stop_mutex);

#ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__
//#define A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT (1)

#define A2DP_AUDIO_SYNC_FIX_DIFF_INTERVAL (640)
#define A2DP_AUDIO_SYNC_FIX_DIFF_FAST_LIMIT (0.003f)
#define A2DP_AUDIO_SYNC_FIX_DIFF_SLOW_LIMIT (-0.003f)

extern uint32_t app_bt_stream_get_dma_buffer_samples(void);
static int a2dp_audio_sync_fix_diff_proc(uint32_t tick);
static int a2dp_audio_sync_fix_diff_stop(uint32_t tick);
static int32_t a2dp_audio_sync_fix_diff_reset(void);
static int32_t a2dp_audio_sync_fix_diff_start(uint32_t tick);

typedef enum {
  A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_IDLE,
  A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_START,
  A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_STOP,
} A2DP_AUDIO_SYNC_FIX_DIFF_STATUS;

typedef struct {
  int32_t tick;
  A2DP_AUDIO_SYNC_FIX_DIFF_STATUS status;
} A2DP_AUDIO_SYNC_FIX_DIFF_T;

static A2DP_AUDIO_SYNC_FIX_DIFF_T a2dp_audio_sync_fix_diff;
#endif

A2DP_AUDIO_CONTEXT_T a2dp_audio_context;

static heap_handle_t a2dp_audio_heap;

static A2DP_AUDIO_LASTFRAME_INFO_T a2dp_audio_lastframe_info;

static A2DP_AUDIO_DETECT_NEXT_PACKET_CALLBACK
    a2dp_audio_detect_next_packet_callback = NULL;
static A2DP_AUDIO_DETECT_NEXT_PACKET_CALLBACK a2dp_audio_store_packet_callback =
    NULL;

static float a2dp_audio_latency_factor = A2DP_AUDIO_LATENCY_LOW_FACTOR;
static float sync_tune_dest_ratio = 1.0f;

static uint32_t store_packet_history_loctime = 0;

static uint32_t check_sum_seed = 0;

static int a2dp_audio_internal_lastframe_info_ptr_get(
    A2DP_AUDIO_LASTFRAME_INFO_T **lastframe_info);

float a2dp_audio_get_sample_reference(void);
int8_t a2dp_audio_get_current_buf_size(void);

void a2dp_audio_heap_init(void *begin_addr, uint32_t size) {
  a2dp_audio_heap = heap_register(begin_addr, size);
}

void *a2dp_audio_heap_malloc(uint32_t size) {
  void *ptr = heap_malloc(a2dp_audio_heap, size);
  ASSERT_A2DP_DECODER(ptr, "%s size:%d", __func__, size);
  return ptr;
}

void *a2dp_audio_heap_cmalloc(uint32_t size) {
  void *ptr = heap_malloc(a2dp_audio_heap, size);
  ASSERT_A2DP_DECODER(ptr, "%s size:%d", __func__, size);
  memset(ptr, 0, size);
  return ptr;
}

void *a2dp_audio_heap_realloc(void *rmem, uint32_t newsize) {
  void *ptr = heap_realloc(a2dp_audio_heap, rmem, newsize);
  ASSERT_A2DP_DECODER(ptr, "%s rmem:%p size:%d", __func__, rmem, newsize);
  return ptr;
}

void a2dp_audio_heap_free(void *rmem) {
  ASSERT_A2DP_DECODER(rmem, "%s rmem:%p", __func__, rmem);
  heap_free(a2dp_audio_heap, rmem);
}

void a2dp_audio_heap_info(size_t *total, size_t *used, size_t *max_used) {
  multi_heap_info_t info;
  heap_get_info(a2dp_audio_heap, &info);

  if (total != NULL)
    *total = info.total_bytes;

  if (used != NULL)
    *used = info.total_allocated_bytes;

  if (max_used != NULL)
    *max_used = info.total_bytes - info.minimum_free_bytes;
}

int inline a2dp_audio_semaphore_init(void) {
  if (a2dp_audio_context.audio_semaphore.semaphore == NULL) {
    a2dp_audio_context.audio_semaphore.semaphore =
        osSemaphoreCreate(osSemaphore(audio_buffer_semaphore), 0);
  }
  a2dp_audio_context.audio_semaphore.enalbe = false;
  return 0;
}

int inline a2dp_audio_buffer_mutex_init(void) {
  if (a2dp_audio_context.audio_buffer_mutex == NULL) {
    a2dp_audio_context.audio_buffer_mutex =
        osMutexCreate((osMutex(audio_buffer_mutex)));
  }
  return 0;
}

int inline a2dp_audio_buffer_mutex_lock(void) {
  osMutexWait((osMutexId)a2dp_audio_context.audio_buffer_mutex, osWaitForever);
  return 0;
}

int inline a2dp_audio_buffer_mutex_unlock(void) {
  osMutexRelease((osMutexId)a2dp_audio_context.audio_buffer_mutex);
  return 0;
}

int inline a2dp_audio_status_mutex_init(void) {
  if (a2dp_audio_context.audio_status_mutex == NULL) {
    a2dp_audio_context.audio_status_mutex =
        osMutexCreate((osMutex(audio_status_mutex)));
  }
  return 0;
}

int inline a2dp_audio_status_mutex_lock(void) {
  osMutexWait((osMutexId)a2dp_audio_context.audio_status_mutex, osWaitForever);
  return 0;
}

int inline a2dp_audio_status_mutex_unlock(void) {
  osMutexRelease((osMutexId)a2dp_audio_context.audio_status_mutex);
  return 0;
}

int inline a2dp_audio_semaphore_wait(uint32_t timeout_ms) {
  osSemaphoreId semaphore_id =
      (osSemaphoreId)a2dp_audio_context.audio_semaphore.semaphore;

  a2dp_audio_buffer_mutex_lock();
  a2dp_audio_context.audio_semaphore.enalbe = true;
  a2dp_audio_buffer_mutex_unlock();

  int32_t nRet = osSemaphoreWait(semaphore_id, timeout_ms);
  if ((0 == nRet) || (-1 == nRet)) {
    TRACE_A2DP_DECODER_W("%s wait timerout", __func__);
    return -1;
  }
  return 0;
}

int inline a2dp_audio_semaphore_release(void) {
  bool enalbe = false;

  a2dp_audio_buffer_mutex_lock();
  if (a2dp_audio_context.audio_semaphore.enalbe) {
    a2dp_audio_context.audio_semaphore.enalbe = false;
    enalbe = true;
  }
  a2dp_audio_buffer_mutex_unlock();

  if (enalbe) {
    osSemaphoreId semaphore_id =
        (osSemaphoreId)a2dp_audio_context.audio_semaphore.semaphore;
    osSemaphoreRelease(semaphore_id);
  }
  return 0;
}

list_node_t *a2dp_audio_list_begin(const list_t *list) {
  a2dp_audio_buffer_mutex_lock();
  list_node_t *node = list_begin(list);
  a2dp_audio_buffer_mutex_unlock();
  return node;
}

list_node_t *a2dp_audio_list_end(const list_t *list) {
  a2dp_audio_buffer_mutex_lock();
  list_node_t *node = list_end(list);
  a2dp_audio_buffer_mutex_unlock();
  return node;
}

uint32_t a2dp_audio_list_length(const list_t *list) {
  a2dp_audio_buffer_mutex_lock();
  uint32_t length = list_length(list);
  a2dp_audio_buffer_mutex_unlock();
  return length;
}

void *a2dp_audio_list_node(const list_node_t *node) {
  a2dp_audio_buffer_mutex_lock();
  void *data = list_node(node);
  a2dp_audio_buffer_mutex_unlock();
  return data;
}

list_node_t *a2dp_audio_list_next(const list_node_t *node) {
  a2dp_audio_buffer_mutex_lock();
  list_node_t *next = list_next(node);
  a2dp_audio_buffer_mutex_unlock();
  return next;
}

bool a2dp_audio_list_remove(list_t *list, void *data) {
  a2dp_audio_buffer_mutex_lock();
  bool nRet = list_remove(list, data);
  a2dp_audio_buffer_mutex_unlock();
  return nRet;
}

bool a2dp_audio_list_append(list_t *list, void *data) {
  a2dp_audio_buffer_mutex_lock();
  bool nRet = list_append(list, data);
  a2dp_audio_buffer_mutex_unlock();
  return nRet;
}

void a2dp_audio_list_clear(list_t *list) {
  a2dp_audio_buffer_mutex_lock();
  list_clear(list);
  a2dp_audio_buffer_mutex_unlock();
}

void a2dp_audio_list_free(list_t *list) {
  a2dp_audio_buffer_mutex_lock();
  list_free(list);
  a2dp_audio_buffer_mutex_unlock();
}

list_t *a2dp_audio_list_new(list_free_cb callback, list_mempool_zmalloc zmalloc,
                            list_mempool_free free) {
  a2dp_audio_buffer_mutex_lock();
  list_t *list = list_new(callback, zmalloc, free);
  a2dp_audio_buffer_mutex_unlock();
  return list;
}

uint32_t a2dp_audio_get_passed(uint32_t curr_ticks, uint32_t prev_ticks,
                               uint32_t max_ticks) {
  if (curr_ticks < prev_ticks)
    return ((max_ticks - prev_ticks + 1) + curr_ticks);
  else
    return (curr_ticks - prev_ticks);
}

#ifdef A2DP_CP_ACCEL
extern "C" uint32_t get_in_cp_frame_cnt(void);
extern "C" uint32_t get_in_cp_frame_delay(void);
#else
static uint32_t get_in_cp_frame_cnt(void) { return 0; }

static uint32_t get_in_cp_frame_delay(void) { return 0; }
#endif

int inline a2dp_audio_set_status(
    enum A2DP_AUDIO_DECODER_STATUS decoder_status) {
  a2dp_audio_status_mutex_lock();
  a2dp_audio_context.audio_decoder_status = decoder_status;
  a2dp_audio_status_mutex_unlock();

  return 0;
}

enum A2DP_AUDIO_DECODER_STATUS inline a2dp_audio_get_status(void) {
  enum A2DP_AUDIO_DECODER_STATUS decoder_status;
  a2dp_audio_status_mutex_lock();
  decoder_status = a2dp_audio_context.audio_decoder_status;
  a2dp_audio_status_mutex_unlock();

  return decoder_status;
}

int inline a2dp_audio_set_store_packet_status(
    enum A2DP_AUDIO_DECODER_STORE_PACKET_STATUS store_packet_status) {
  a2dp_audio_status_mutex_lock();
  a2dp_audio_context.store_packet_status = store_packet_status;
  a2dp_audio_status_mutex_unlock();

  return 0;
}

enum A2DP_AUDIO_DECODER_STORE_PACKET_STATUS inline a2dp_audio_get_store_packet_status(
    void) {
  enum A2DP_AUDIO_DECODER_STORE_PACKET_STATUS store_packet_status;
  a2dp_audio_status_mutex_lock();
  store_packet_status = a2dp_audio_context.store_packet_status;
  a2dp_audio_status_mutex_unlock();

  return store_packet_status;
}

int inline a2dp_audio_set_playback_status(
    enum A2DP_AUDIO_DECODER_PLAYBACK_STATUS playback_status) {
  a2dp_audio_status_mutex_lock();
  a2dp_audio_context.playback_status = playback_status;
  a2dp_audio_status_mutex_unlock();

  return 0;
}

enum A2DP_AUDIO_DECODER_PLAYBACK_STATUS inline a2dp_audio_get_playback_status(
    void) {
  enum A2DP_AUDIO_DECODER_PLAYBACK_STATUS playback_status;
  a2dp_audio_status_mutex_lock();
  playback_status = a2dp_audio_context.playback_status;
  a2dp_audio_status_mutex_unlock();

  return playback_status;
}

static void a2dp_decoder_info_checker(void) {
  //    app_bt_start_custom_function_in_app_thread(0, 0,
  //    (uint32_t)bt_drv_reg_op_bt_info_checker);
}

int a2dp_audio_sync_pid_config(void) {
  A2DP_AUDIO_SYNC_T *audio_sync = &a2dp_audio_context.audio_sync;
  A2DP_AUDIO_SYNC_PID_T *pid = &audio_sync->pid;

  pid->proportiongain = 0.4f;
  pid->integralgain = 0.1f;
  pid->derivativegain = 0.6f;

  return 0;
}

int a2dp_audio_sync_reset_data(void) {
  A2DP_AUDIO_SYNC_T *audio_sync = &a2dp_audio_context.audio_sync;

  a2dp_audio_status_mutex_lock();
  audio_sync->tick = 0;
  audio_sync->cnt = 0;
  a2dp_audio_sync_pid_config();
#ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__
  a2dp_audio_sync_fix_diff_reset();
#endif
  a2dp_audio_status_mutex_unlock();

  TRACE_A2DP_DECODER_I("[SYNC]reset_data");
  return 0;
}

int a2dp_audio_sync_init(double ratio) {
#ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__
  a2dp_audio_sync_fix_diff_reset();
#endif
  a2dp_audio_sync_reset_data();
  a2dp_audio_sync_tune_sample_rate(ratio);
  sync_tune_dest_ratio = (float)ratio;
  return 0;
}

int a2dp_audio_sync_tune_sample_rate(double ratio) {
  float resample_rate_ratio;
  bool need_tune = false;

  a2dp_audio_status_mutex_lock();
  if (a2dp_audio_context.output_cfg.factor_reference != (float)ratio) {
    a2dp_audio_context.output_cfg.factor_reference = (float)ratio;
    resample_rate_ratio = (float)(ratio - (double)1.0);
    need_tune = true;
  }
  // a2dp_audio_status_mutex_unlock();

  if (need_tune) {
    app_audio_manager_tune_samplerate_ratio(AUD_STREAM_PLAYBACK,
                                            resample_rate_ratio);
    TRACE_A2DP_DECODER_I("[SYNC] ppb:%d ratio:%08d",
                         (int32_t)(resample_rate_ratio * 10000000),
                         (int32_t)(ratio * 10000000));
  }
  a2dp_audio_status_mutex_unlock();

  return 0;
}

int a2dp_audio_sync_direct_tune_sample_rate(double ratio) {
  float resample_rate_ratio;
  bool need_tune = false;

  a2dp_audio_status_mutex_lock();
  if (a2dp_audio_context.output_cfg.factor_reference != (float)ratio) {
    a2dp_audio_context.output_cfg.factor_reference = (float)ratio;
    resample_rate_ratio = (float)(ratio - (double)1.0);
    need_tune = true;
  }

  if (need_tune) {
    af_codec_direct_tune(AUD_STREAM_PLAYBACK, resample_rate_ratio);

    TRACE_A2DP_DECODER_I("[SYNC] ppb:%d ratio:%08d",
                         (int32_t)(resample_rate_ratio * 10000000),
                         (int32_t)(ratio * 10000000));
  }
  a2dp_audio_status_mutex_unlock();

  return 0;
}

bool a2dp_audio_sync_tune_onprocess(void) {
  bool nRet = false;
  ;
  if (a2dp_audio_context.output_cfg.factor_reference != sync_tune_dest_ratio) {
    nRet = true;
  }
  return nRet;
}

int a2dp_audio_sync_tune(float ratio) {
  int nRet = 0;
  if (sync_tune_dest_ratio == ratio) {
    goto exit;
  }
  sync_tune_dest_ratio = ratio;
#if defined(IBRT)
  if (app_ibrt_ui_is_profile_exchanged()) {
    if (app_tws_ibrt_mobile_link_connected()) {
      APP_TWS_IBRT_AUDIO_SYNC_TUNE_T sync_tune;
      sync_tune.factor_reference = ratio;
      if (!app_tws_ibrt_audio_sync_tune_need_skip()) {
        tws_ctrl_send_cmd(APP_TWS_CMD_SYNC_TUNE, (uint8_t *)&sync_tune,
                          sizeof(APP_TWS_IBRT_AUDIO_SYNC_TUNE_T));
      } else {
        a2dp_audio_sync_tune_cancel();
        nRet = -1;
      }
    }
  } else {
    a2dp_audio_sync_tune_sample_rate(ratio);
  }
#else
  a2dp_audio_sync_tune_sample_rate(ratio);
#endif
exit:
  return nRet;
}

int a2dp_audio_sync_tune_cancel(void) {
  sync_tune_dest_ratio = a2dp_audio_context.output_cfg.factor_reference;
  return 0;
}

float a2dp_audio_sync_pid_calc(A2DP_AUDIO_SYNC_PID_T *pid, float diff) {
  float increment;
  float pError, dError, iError;

  pid->error[0] = diff;
  pError = pid->error[0] - pid->error[1];
  iError = pid->error[0];
  dError = pid->error[0] - 2 * pid->error[1] + pid->error[2];

  increment = pid->proportiongain * pError + pid->integralgain * iError +
              pid->derivativegain * dError;

  pid->error[2] = pid->error[1];
  pid->error[1] = pid->error[0];

  pid->result += increment;

  return pid->result;
}

#ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__
static int a2dp_audio_sync_fix_diff_proc(uint32_t tick) {
  if (a2dp_audio_sync_fix_diff.status ==
      A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_START) {
    if (a2dp_audio_sync_fix_diff.tick > 0) {
      a2dp_audio_sync_fix_diff.tick--;
    } else {
      a2dp_audio_sync_fix_diff_stop(0);
    }
  }
  return 0;
}

static int32_t a2dp_audio_sync_fix_diff_start(uint32_t tick) {
  TRACE_A2DP_DECODER_I("[SYNC] fix diff start");

  a2dp_audio_sync_fix_diff.status = A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_START;
  a2dp_audio_sync_fix_diff.tick = tick;
  return 0;
}

static int a2dp_audio_sync_fix_diff_stop(uint32_t tick) {
  TRACE_A2DP_DECODER_I("[SYNC] fix diff stop");

  a2dp_audio_sync_fix_diff.status = A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_STOP;
  a2dp_audio_sync_fix_diff.tick = 0;

  return 0;
}

static int32_t a2dp_audio_sync_fix_diff_reset(void) {
  TRACE_A2DP_DECODER_I("[SYNC] fix diff reset");

  a2dp_audio_sync_fix_diff.status = A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_IDLE;
  a2dp_audio_sync_fix_diff.tick = 0;

  return 0;
}

static A2DP_AUDIO_SYNC_FIX_DIFF_STATUS
a2dp_audio_sync_fix_diff_status_get(void) {
  return a2dp_audio_sync_fix_diff.status;
}

int a2dp_audio_sync_handler(uint8_t *buffer, uint32_t buffer_bytes) {
  A2DP_AUDIO_LASTFRAME_INFO_T *lastframe_info = NULL;
  A2DP_AUDIO_SYNC_T *audio_sync = &a2dp_audio_context.audio_sync;
  float diff_mtu = 0;
  bool need_tune = false;
  bool force_slow = false;

#if defined(IBRT)
  if (!app_tws_ibrt_mobile_link_connected()) {
    return -1;
  }
#endif
  if (a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info) < 0) {
    return -1;
  }

  a2dp_audio_sync_fix_diff_proc(audio_sync->tick);
  if (a2dp_audio_sync_fix_diff_status_get() ==
      A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_STOP) {
#if defined(IBRT)
    if (!app_tws_ibrt_audio_sync_tune_onprocess() &&
        !a2dp_audio_sync_tune_onprocess()
#else
    if (!a2dp_audio_sync_tune_onprocess()
#endif
    ) {
      int sync_tune_result = 0;
      if (a2dp_audio_context.output_cfg.factor_reference !=
          a2dp_audio_context.init_factor_reference) {
        sync_tune_result =
            a2dp_audio_sync_tune(a2dp_audio_context.init_factor_reference);
      }
      if (!sync_tune_result) {
        a2dp_audio_sync_fix_diff_reset();
#ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT
        TRACE_A2DP_DECODER_I("[SYNC] tune ratio normal %f mut:%5.3f->%d",
                             (double)a2dp_audio_context.init_factor_reference,
                             (double)a2dp_audio_context.average_packet_mut,
                             a2dp_audio_context.dest_packet_mut);
#else
        TRACE_A2DP_DECODER_I(
            "[SYNC] tune ratio normal %d mut:%d->%d",
            (int32_t)(a2dp_audio_context.init_factor_reference * 10000000),
            (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f),
            a2dp_audio_context.dest_packet_mut);
#endif
      } else {
        TRACE_A2DP_DECODER_I("[SYNC] tune ratio normal busy");
      }

    } else {
#ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT
      TRACE_A2DP_DECODER_I("[SYNC] tune ratio busy %f mut:%5.3f->%d",
                           (double)a2dp_audio_context.init_factor_reference,
                           (double)a2dp_audio_context.average_packet_mut,
                           a2dp_audio_context.dest_packet_mut);
#else
      TRACE_A2DP_DECODER_I(
          "[SYNC] tune ratio busy %d mut:%d->%d",
          (int32_t)(a2dp_audio_context.init_factor_reference * 10000000),
          (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f),
          a2dp_audio_context.dest_packet_mut);
#endif
    }
    goto exit;
  }

  if (audio_sync->tick % A2DP_AUDIO_SYNC_INTERVAL == 0) {
    diff_mtu = a2dp_audio_context.average_packet_mut -
               (float)a2dp_audio_context.dest_packet_mut;
    if (ABS(diff_mtu) < 0.6f) {
#ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT
      TRACE_A2DP_DECODER_I("[SYNC] skip mut:%5.3f", (double)diff_mtu);
#else
      TRACE_A2DP_DECODER_I("[SYNC] skip mut:0.%d", (int32_t)(diff_mtu * 10));
#endif
      goto exit;
    } else if (diff_mtu / a2dp_audio_context.dest_packet_mut < -0.2f) {
      float curr_ratio = a2dp_audio_context.output_cfg.factor_reference;
      float ref_ratio = a2dp_audio_context.init_factor_reference;
      if (curr_ratio != (ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_SLOW_LIMIT)) {
#ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT
        TRACE_A2DP_DECODER_I("[SYNC] force slow mut:%5.3f", (double)diff_mtu);
#else
        TRACE_A2DP_DECODER_I("[SYNC] force slow mut:0.%d",
                             (int32_t)(diff_mtu * 10));
#endif
        force_slow = true;
      }
    }
    if (a2dp_audio_sync_fix_diff_status_get() ==
            A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_IDLE ||
        force_slow) {
      uint32_t dma_buffer_samples, samples, dma_interval;
      double ratio = 1.0, limit_ratio = 1.0;
      float sampleRate, ref_ratio, curr_ratio;
      float ref_us = 0;
      float dest_us = 0;
      float sample_us = 0;

      dma_buffer_samples = app_bt_stream_get_dma_buffer_samples() / 2;
      dma_interval = A2DP_AUDIO_SYNC_FIX_DIFF_INTERVAL;

      ref_ratio = a2dp_audio_context.init_factor_reference;
      curr_ratio = a2dp_audio_context.output_cfg.factor_reference;

      samples = dma_interval * dma_buffer_samples;
      sampleRate = lastframe_info->stream_info.sample_rate * ref_ratio;

      sample_us = 1e6 / sampleRate;
      ref_us = sample_us * (float)samples;
      dest_us = sample_us * (float)(lastframe_info->frame_samples * diff_mtu);
      ratio = ref_us / (ref_us - dest_us) * curr_ratio;

      if (ratio > (double)(ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_FAST_LIMIT)) {
        limit_ratio = ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_FAST_LIMIT;
      } else if (ratio <
                 double(ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_SLOW_LIMIT)) {
        limit_ratio = ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_SLOW_LIMIT;
      } else {
        limit_ratio = ratio;
      }
      TRACE_A2DP_DECODER_I(
          "[SYNC] sampleRate:%d ref_ratio:%d samples:%d %d->%d",
          (int32_t)sampleRate, (int32_t)(ref_ratio * 10000000), samples,
          (int32_t)ref_us, (int32_t)dest_us);
      need_tune = true;
#if defined(IBRT)
      if (!app_tws_ibrt_audio_sync_tune_onprocess() &&
          !a2dp_audio_sync_tune_onprocess() &&
#else
      if (!a2dp_audio_sync_tune_onprocess() &&
#endif
          need_tune) {
        if (!a2dp_audio_sync_tune((float)limit_ratio)) {
          a2dp_audio_sync_fix_diff_start(dma_interval);
#ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT
          TRACE_A2DP_DECODER_I("[SYNC] tune ratio %f  mut:%5.3f->%d",
                               limit_ratio,
                               (double)a2dp_audio_context.average_packet_mut,
                               a2dp_audio_context.dest_packet_mut);
#else
          TRACE_A2DP_DECODER_I(
              "[SYNC] tune ratio %d  mut:%d->%d",
              (int32_t)(limit_ratio * 10000000),
              (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f),
              a2dp_audio_context.dest_packet_mut);
#endif
        } else {
          TRACE_A2DP_DECODER_I("[SYNC] tune ratio busy");
        }
      }
    } else {
      TRACE_A2DP_DECODER_I(
          "[SYNC] avg_mut:%d dest_mtu:%d",
          (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f),
          a2dp_audio_context.dest_packet_mut);
    }
  } else {
  }
exit:
  audio_sync->tick++;
  return 0;
}
#else
int a2dp_audio_sync_handler(uint8_t *buffer, uint32_t buffer_bytes) {
  A2DP_AUDIO_LASTFRAME_INFO_T *lastframe_info = NULL;
  A2DP_AUDIO_SYNC_T *audio_sync = &a2dp_audio_context.audio_sync;
  float dest_pid_result = .0f;
  float diff_mtu = 0;
  int32_t frame_mtu = 0;
  int32_t total_mtu = 0;
  float diff_factor = 0;

#if defined(IBRT)
  if (!app_tws_ibrt_mobile_link_connected()) {
    return -1;
  }
#endif
  if (a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info) < 0) {
    return -1;
  }

  if (audio_sync->tick++ % A2DP_AUDIO_SYNC_INTERVAL == 0) {
    list_t *list = a2dp_audio_context.audio_datapath.input_raw_packet_list;
    A2DP_AUDIO_SYNC_PID_T *pid = &audio_sync->pid;
    // valid limter 0x80000
    if (audio_sync->cnt < 0x80000) {
      audio_sync->cnt += A2DP_AUDIO_SYNC_INTERVAL;
    }
    frame_mtu = lastframe_info->stream_info.frame_samples /
                lastframe_info->frame_samples;
    total_mtu = audio_sync->cnt * frame_mtu;
    diff_mtu = a2dp_audio_context.average_packet_mut -
               (float)a2dp_audio_context.dest_packet_mut;
#if 1
    TRACE_A2DP_DECODER_I(
        "[SYNC] sample:%d/%d diff:%d/%d/%d/%d curr:%d",
        lastframe_info->frame_samples,
        lastframe_info->stream_info.frame_samples, (int32_t)(diff_mtu + 0.5f),
        (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f),
        a2dp_audio_context.dest_packet_mut, total_mtu,
        a2dp_audio_list_length(list) + get_in_cp_frame_cnt());
#else
    TRACE_A2DP_DECODER_I(
        "[SYNC] diff:%10.9f/%10.9f frame_mut:%d dest:%d total:%d curr:%d",
        (double)diff_mtu, (double)a2dp_audio_context.average_packet_mut,
        frame_mtu, a2dp_audio_context.dest_packet_mut, total_mtu,
        a2dp_audio_list_length(list));
    TRACE_A2DP_DECODER_I("[SYNC] try tune:%d, %10.9f %10.9f",
                         diff_mtu != 0.f && audio_sync->tick != 1
                             ? ABS(diff_mtu) > ((float)frame_mtu * 0.2f)
                             : 0,
                         (double)ABS(diff_mtu),
                         (double)((float)frame_mtu * 0.2f));
#endif
    // TRACE(2,"audio_sync tune %d/%d tick",
    // app_tws_ibrt_audio_sync_tune_onprocess(),
    // a2dp_audio_sync_tune_onprocess(), audio_sync->tick);

#if defined(IBRT)
    if ((!app_tws_ibrt_audio_sync_tune_onprocess() &&
         !a2dp_audio_sync_tune_onprocess()) &&
#else
    if (!a2dp_audio_sync_tune_onprocess() &&
#endif
        diff_mtu != 0.f && audio_sync->tick != 1 &&
        ((ABS(diff_mtu) > ((float)frame_mtu * 0.25f) && diff_mtu > 0) ||
         (ABS(diff_mtu) > ((float)frame_mtu * 0.1f) && diff_mtu < 0))) {
      diff_factor = diff_mtu / a2dp_audio_context.average_packet_mut;
      if (a2dp_audio_sync_pid_calc(pid, diff_factor)) {
        dest_pid_result =
            a2dp_audio_context.output_cfg.factor_reference + pid->result;

        if (dest_pid_result > (A2DP_AUDIO_SYNC_FACTOR_REFERENCE +
                               A2DP_AUDIO_SYNC_FACTOR_FAST_LIMIT)) {
          dest_pid_result = A2DP_AUDIO_SYNC_FACTOR_REFERENCE +
                            A2DP_AUDIO_SYNC_FACTOR_FAST_LIMIT;
        } else if (dest_pid_result < (A2DP_AUDIO_SYNC_FACTOR_REFERENCE +
                                      A2DP_AUDIO_SYNC_FACTOR_SLOW_LIMIT)) {
          dest_pid_result = A2DP_AUDIO_SYNC_FACTOR_REFERENCE +
                            A2DP_AUDIO_SYNC_FACTOR_SLOW_LIMIT;
        }

        if (a2dp_audio_context.output_cfg.factor_reference != dest_pid_result) {
          if (!a2dp_audio_sync_tune(dest_pid_result)) {
            audio_sync->cnt = 0;
          }
          TRACE_A2DP_DECODER_I(
              "[SYNC] tune diff_factor:%10.9f pid:%10.9f tune:%10.9f",
              (double)diff_factor, (double)pid->result,
              (double)dest_pid_result);
        } else {
          TRACE_A2DP_DECODER_I("[SYNC] tune skip same");
        }
      }
    } else {
      /*
                  TRACE_A2DP_DECODER_I("[SYNC] tune busy skip proc:%d/%d mtu:%d
         tick:%d >0:%d <0:%d tick:%d", app_tws_ibrt_audio_sync_tune_onprocess(),
                                                      a2dp_audio_sync_tune_onprocess(),
                                                      diff_mtu != 0.f,
                                                      audio_sync->tick != 1,
                                                      (ABS(diff_mtu) >
         ((float)frame_mtu * 0.25f) && diff_mtu > 0), (ABS(diff_mtu) >
         ((float)frame_mtu * 0.1f) && diff_mtu < 0), audio_sync->tick);
      */
    }
  } else {
    bool need_tune = false;
    if (lastframe_info->undecode_min_frames * 10 <=
        a2dp_audio_context.dest_packet_mut * 10 / 3) {
      dest_pid_result = a2dp_audio_context.init_factor_reference +
                        A2DP_AUDIO_SYNC_FACTOR_NEED_FAST_CACHE;
      need_tune = true;
    } else if (lastframe_info->undecode_min_frames * 10 <=
               a2dp_audio_context.dest_packet_mut * 20 / 3) {
      dest_pid_result = a2dp_audio_context.init_factor_reference +
                        A2DP_AUDIO_SYNC_FACTOR_SLOW_LIMIT;
      need_tune = true;
    }
#if defined(IBRT)
    if (!app_tws_ibrt_audio_sync_tune_onprocess() &&
        !a2dp_audio_sync_tune_onprocess() &&
#else
    if (!a2dp_audio_sync_tune_onprocess() &&
#endif

        need_tune) {
      if (a2dp_audio_context.output_cfg.factor_reference != dest_pid_result) {
        a2dp_audio_sync_reset_data();
        a2dp_audio_sync_tune(dest_pid_result);
        TRACE_A2DP_DECODER_I("[SYNC] tune ratio force slow %d/%d->%d",
                             lastframe_info->undecode_min_frames,
                             lastframe_info->undecode_max_frames,
                             a2dp_audio_context.dest_packet_mut);
      }
    }
  }
  return 0;
}
#endif

#if A2DP_DECODER_HISTORY_SEQ_SAVE
static int a2dp_audio_reset_history_seq(void) {
  a2dp_audio_status_mutex_lock();
  for (uint8_t i = 0; i < A2DP_DECODER_HISTORY_SEQ_SAVE; i++) {
    a2dp_audio_context.historySeq[i] = 0;
#ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE
    a2dp_audio_context.historyLoctime[i] = 0;
#endif
#ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE
    a2dp_audio_context.historyChecksum[i] = 0;
#endif
  }
  a2dp_audio_context.historySeq_idx = 0;
  a2dp_audio_status_mutex_unlock();

  return 0;
}

static int a2dp_audio_save_history_seq(btif_media_header_t *header,
                                       unsigned char *buf, unsigned int len) {
  uint16_t historySeqPre = 0;
  uint8_t historySeq_idx = 0;

  a2dp_audio_status_mutex_lock();
  historySeq_idx = a2dp_audio_context.historySeq_idx;
  if (historySeq_idx) {
    historySeq_idx = (historySeq_idx - 1) % A2DP_DECODER_HISTORY_SEQ_SAVE;
    historySeqPre = a2dp_audio_context.historySeq[historySeq_idx];
    if ((header->sequenceNumber - historySeqPre) != 1) {
      TRACE_A2DP_DECODER_W("[INPUT] SEQ ERR %d/%d", historySeqPre,
                           header->sequenceNumber);
      a2dp_audio_show_history_seq();
    }
  }
  historySeq_idx =
      a2dp_audio_context.historySeq_idx % A2DP_DECODER_HISTORY_SEQ_SAVE;
  a2dp_audio_context.historySeq[historySeq_idx] = header->sequenceNumber;
#ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE
  a2dp_audio_context.historyLoctime[historySeq_idx] = hal_fast_sys_timer_get();
#endif
#ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE
  a2dp_audio_context.historyChecksum[historySeq_idx] = crc32(0, buf, len);
#endif
  a2dp_audio_context.historySeq_idx++;
  a2dp_audio_status_mutex_unlock();

  return 0;
}

int a2dp_audio_show_history_seq(void) {
  uint8_t i = 0, j = 1;
  uint16_t reordHistorySeq[A2DP_DECODER_HISTORY_SEQ_SAVE];
#ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE
  int32_t diff_max_idx = 0;
  int32_t diff_max_ms = 0;
  int64_t diff_avg_ms = 0;
  int32_t diff_avg_cnt = 0;
  uint32_t historyLoctime[A2DP_DECODER_HISTORY_SEQ_SAVE];
#endif
#ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE
  uint32_t historyChecksum[A2DP_DECODER_HISTORY_SEQ_SAVE];
#endif

  a2dp_audio_status_mutex_lock();
  for (i = 0; i < A2DP_DECODER_HISTORY_SEQ_SAVE; i++) {
    reordHistorySeq[i] = a2dp_audio_context.historySeq[i];
#ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE
    historyLoctime[i] = a2dp_audio_context.historyLoctime[i];
#endif
#ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE
    historyChecksum[i] = a2dp_audio_context.historyChecksum[i];
#endif
  }

  for (i = 0; i < A2DP_DECODER_HISTORY_SEQ_SAVE - 1; i++) {
    for (j = 0; j < A2DP_DECODER_HISTORY_SEQ_SAVE - 1 - i; j++) {
      if (reordHistorySeq[j] > reordHistorySeq[j + 1]) {
        uint16_t temp_seq = reordHistorySeq[j];
        reordHistorySeq[j] = reordHistorySeq[j + 1];
        reordHistorySeq[j + 1] = temp_seq;
#ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE
        uint32_t temp_Loctime = historyLoctime[j];
        historyLoctime[j] = historyLoctime[j + 1];
        historyLoctime[j + 1] = temp_Loctime;
#endif
#ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE
        uint32_t temp_Checksum = historyChecksum[j];
        historyChecksum[j] = historyChecksum[j + 1];
        historyChecksum[j + 1] = temp_Checksum;
#endif
      }
    }
  }
#ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE
  for (i = 0, j = 1; i < A2DP_DECODER_HISTORY_SEQ_SAVE - 1; i++, j++) {
    int32_t tmp_ms = historyLoctime[j] - historyLoctime[i];
    diff_avg_ms += tmp_ms;
    diff_avg_cnt++;
    if (tmp_ms > diff_max_ms) {
      diff_max_ms = tmp_ms;
      diff_max_idx = i;
    }
    if (tmp_ms > (int32_t)MS_TO_FAST_TICKS(50)) {
      TRACE_A2DP_DECODER_I("[INPUT] > 30ms seq:%d diff:%d :%d / %d",
                           reordHistorySeq[i], FAST_TICKS_TO_MS(tmp_ms),
                           historyLoctime[i], historyLoctime[j]);
    }
  }
  diff_avg_ms /= diff_avg_cnt;
  TRACE_A2DP_DECODER_I("[INPUT] max_diff:%dms idx:%d avg:%dus",
                       FAST_TICKS_TO_MS(diff_max_ms), diff_max_idx,
                       FAST_TICKS_TO_US(diff_avg_ms));
#endif
//    DUMP16("%d ", reordHistorySeq, A2DP_DECODER_HISTORY_SEQ_SAVE);
#ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE
  DUMP32("%x ", historyLoctime, A2DP_DECODER_HISTORY_SEQ_SAVE);
#endif
#ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE
  DUMP32("%x ", historyChecksum, A2DP_DECODER_HISTORY_SEQ_SAVE);
#endif
  a2dp_audio_status_mutex_unlock();

  return 0;
}

#endif

/*
1,  2^1
3,  2^2
7,  2^3
15, 2^4
31, 2^5
*/
#define AUDIO_ALPHA_PRAMS_1 (3)
#define AUDIO_ALPHA_PRAMS_2 (4)

static inline float a2dp_audio_alpha_filter(float y, float x) {
  if (y) {
    y = ((AUDIO_ALPHA_PRAMS_1 * y) + x) / AUDIO_ALPHA_PRAMS_2;
  } else {
    y = x;
  }
  return y;
}

static void inline a2dp_audio_convert_16bit_to_24bit(int32_t *out, int16_t *in,
                                                     int len) {
  for (int i = len - 1; i >= 0; i--) {
    out[i] = ((int32_t)in[i] << 8);
  }
}

static void inline a2dp_audio_channel_select(
    A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel, uint8_t *buffer,
    uint32_t buffer_bytes) {
  uint32_t samples;
  uint32_t i;

  ASSERT_A2DP_DECODER(a2dp_audio_context.output_cfg.num_channels == 2,
                      "%s num_channels:%d", __func__,
                      a2dp_audio_context.output_cfg.num_channels);

  if (a2dp_audio_context.output_cfg.bits_depth == 24) {
    int32_t *buf_l_p = (int32_t *)buffer;
    int32_t *buf_r_p = (int32_t *)buffer + 1;

    samples = buffer_bytes / 4 / 2;
    switch (chnl_sel) {
    case A2DP_AUDIO_CHANNEL_SELECT_LRMERGE:
      for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) {
        int32_t tmp_sample = (*buf_l_p + *buf_r_p) >> 1;
        *buf_l_p = tmp_sample;
        *buf_r_p = tmp_sample;
      }
      break;
    case A2DP_AUDIO_CHANNEL_SELECT_LCHNL:
      for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) {
        *buf_r_p = *buf_l_p;
      }
      break;
    case A2DP_AUDIO_CHANNEL_SELECT_RCHNL:
      for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) {
        *buf_l_p = *buf_r_p;
      }
      break;
    case A2DP_AUDIO_CHANNEL_SELECT_STEREO:
    default:
      break;
    }
  } else {
    int16_t *buf_l_p = (int16_t *)buffer;
    int16_t *buf_r_p = (int16_t *)buffer + 1;

    samples = buffer_bytes / 2 / 2;
    switch (chnl_sel) {
    case A2DP_AUDIO_CHANNEL_SELECT_LRMERGE:
      for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) {
        int16_t tmp_sample = ((int32_t)*buf_l_p + (int32_t)*buf_r_p) >> 1;
        *buf_l_p = tmp_sample;
        *buf_r_p = tmp_sample;
      }
      break;
    case A2DP_AUDIO_CHANNEL_SELECT_LCHNL:
      for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) {
        *buf_r_p = *buf_l_p;
      }
      break;
    case A2DP_AUDIO_CHANNEL_SELECT_RCHNL:
      for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) {
        *buf_l_p = *buf_r_p;
      }
      break;
    case A2DP_AUDIO_CHANNEL_SELECT_STEREO:
    default:
      break;
    }
  }
}

#ifdef A2DP_CP_ACCEL
extern "C" bool is_cp_need_reset(void);
extern uint32_t app_bt_stream_get_dma_buffer_samples(void);

static uint32_t get_cp_frame_mtus(A2DP_AUDIO_LASTFRAME_INFO_T *info) {
  uint32_t cp_frame_mtus = app_bt_stream_get_dma_buffer_samples() / 2;
  if (cp_frame_mtus % (info->frame_samples)) {
    cp_frame_mtus = cp_frame_mtus / (info->frame_samples) + 1;
  } else {
    cp_frame_mtus = cp_frame_mtus / (info->frame_samples);
  }

  TRACE_A2DP_DECODER_I("[CP] cp_frame_mtus:%d", cp_frame_mtus);

  return cp_frame_mtus;
}

#else
bool is_cp_need_reset(void) { return false; }

#endif

#define A2DP_AUDIO_SYSFREQ_BOOST_RESUME_CNT (20)
uint32_t a2dp_audio_sysfreq_cnt = UINT32_MAX;
uint32_t a2dp_audio_sysfreq_dest_boost_cnt = 0;
APP_SYSFREQ_FREQ_T a2dp_audio_sysfreq_normalfreq = APP_SYSFREQ_52M;

int a2dp_audio_sysfreq_boost_init(uint32_t normalfreq) {
  a2dp_audio_sysfreq_cnt = UINT32_MAX;
  a2dp_audio_sysfreq_dest_boost_cnt = 0;
  a2dp_audio_sysfreq_normalfreq = (APP_SYSFREQ_FREQ_T)normalfreq;
  TRACE_A2DP_DECODER_I("[BOOST] freq:%d", normalfreq);
  return 0;
}

int a2dp_audio_sysfreq_boost_start(uint32_t boost_cnt) {
  enum APP_SYSFREQ_FREQ_T sysfreq = APP_SYSFREQ_104M;

  a2dp_audio_sysfreq_cnt = 0;
  a2dp_audio_sysfreq_dest_boost_cnt = boost_cnt;
  if (a2dp_audio_sysfreq_normalfreq >= APP_SYSFREQ_52M) {
    sysfreq = APP_SYSFREQ_104M;
  } else {
    sysfreq = APP_SYSFREQ_52M;
  }
  TRACE_A2DP_DECODER_I("[BOOST] freq:%d cnt:%d", sysfreq, boost_cnt);
  app_sysfreq_req(APP_SYSFREQ_USER_BT_A2DP, sysfreq);
  return 0;
}

static int a2dp_audio_sysfreq_boost_porc(void) {
  if (a2dp_audio_sysfreq_cnt == UINT32_MAX) {
    // do nothing
  } else if (a2dp_audio_sysfreq_cnt >= a2dp_audio_sysfreq_dest_boost_cnt) {
    a2dp_audio_sysfreq_cnt = UINT32_MAX;
    TRACE_A2DP_DECODER_I("[BOOST] freq:%d", a2dp_audio_sysfreq_normalfreq);
    app_sysfreq_req(APP_SYSFREQ_USER_BT_A2DP, a2dp_audio_sysfreq_normalfreq);
  } else {
    a2dp_audio_sysfreq_cnt++;
  }
  return 0;
}

int a2dp_audio_sysfreq_boost_running(void) {
  return a2dp_audio_sysfreq_cnt == UINT32_MAX ? 0 : 1;
}

int a2dp_audio_store_packet_checker_start(void) {
  store_packet_history_loctime = 0;
  return 0;
}

int a2dp_audio_store_packet_checker(btif_media_header_t *header) {
  bool show_info = false;
  uint32_t fast_sys_tick = hal_fast_sys_timer_get();
  int32_t tmp_ms = 0;

  if (store_packet_history_loctime) {
    tmp_ms = fast_sys_tick - store_packet_history_loctime;
    if (tmp_ms > (int32_t)MS_TO_FAST_TICKS(50)) {
      show_info = true;
    }
  }

  if (show_info) {
    // TRACE_A2DP_DECODER_I("[INPUT] >50ms seq:%d diff:%d",
    // header->sequenceNumber, FAST_TICKS_TO_MS(tmp_ms));
    a2dp_decoder_info_checker();
  }

  store_packet_history_loctime = fast_sys_tick;

  if (a2dp_audio_context.historySeq_idx &&
      ((a2dp_audio_context.historySeq_idx - 1) %
           A2DP_DECODER_HISTORY_SEQ_SAVE ==
       0)) {
    a2dp_audio_show_history_seq();
  }

  return 0;
}
//#define DECODER_ERR_TEST
int a2dp_audio_store_packet(btif_media_header_t *header, unsigned char *buf,
                            unsigned int len) {
  int nRet = A2DP_DECODER_NO_ERROR;

  if (a2dp_audio_get_status() ==
      A2DP_AUDIO_DECODER_STATUS_NULL) { // if mem deinit , drop data
    return nRet;
  }
  a2dp_audio_status_mutex_lock();

#ifdef DECODER_ERR_TEST
  static uint16_t cnt = 0;
  static uint16_t limit = 500;
  cnt++;
  if (cnt % limit == 0) {
    cnt = 0;
    limit = rand() % 500;
    uint16_t len2 = rand() % len;
    memset(buf + len - len2, 0, len2);
    TRACE_A2DP_DECODER_I("[INPUT] Fill Err!!!! seq:%d", header->sequenceNumber);
  }
#endif
#if A2DP_DECODER_HISTORY_SEQ_SAVE
  a2dp_audio_save_history_seq(header, buf, len);
#endif
  a2dp_audio_set_store_packet_status(
      A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_BUSY);
  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    a2dp_audio_store_packet_checker(header);
    if (a2dp_audio_context.need_detect_first_packet) {
      a2dp_audio_context.need_detect_first_packet = false;
      a2dp_audio_context.audio_decoder.audio_decoder_preparse_packet(header,
                                                                     buf, len);
    }

    if (a2dp_audio_detect_next_packet_callback) {
      a2dp_audio_detect_next_packet_callback(header, buf, len);
    }

    nRet = a2dp_audio_context.audio_decoder.audio_decoder_store_packet(
        header, buf, len);
#if defined(IBRT)
    if (is_cp_need_reset()) {
      TRACE_A2DP_DECODER_I("[CP] find cp error need restart");
      app_ibrt_if_force_audio_retrigger();
    }
    if (nRet == A2DP_DECODER_MTU_LIMTER_ERROR) {
      if (app_tws_ibrt_mobile_link_connected()) {
        // try again
        // a2dp_audio_semaphore_wait(A2DP_AUDIO_WAIT_TIMEOUT_MS);
        nRet = a2dp_audio_context.audio_decoder.audio_decoder_store_packet(
            header, buf, len);
      }
      if (nRet == A2DP_DECODER_MTU_LIMTER_ERROR) {
        int dest_discards_samples = 0;
        ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
        if (p_ibrt_ctrl == NULL) {
          return A2DP_DECODER_NOT_SUPPORT;
        }
        if (app_tws_ibrt_mobile_link_connected()) {
          bt_syn_trig_checker(p_ibrt_ctrl->mobile_conhandle);
        } else if (app_tws_ibrt_slave_ibrt_link_connected()) {
          bt_syn_trig_checker(p_ibrt_ctrl->ibrt_conhandle);
        }
        dest_discards_samples = app_bt_stream_get_dma_buffer_samples() / 2;
        a2dp_audio_discards_samples(dest_discards_samples * 2);
        a2dp_audio_context.audio_decoder.audio_decoder_store_packet(header, buf,
                                                                    len);
        TRACE_A2DP_DECODER_I("[INPUT] MTU_LIMTER so discards_packet");
      }
    }
#else
    if (is_cp_need_reset()) {
      TRACE_A2DP_DECODER_I("[CP] find cp error need restart");
      app_audio_decode_err_force_trigger();
    }

    if (nRet == A2DP_DECODER_MTU_LIMTER_ERROR) {
      a2dp_audio_synchronize_dest_packet_mut(
          a2dp_audio_context.dest_packet_mut);
      a2dp_audio_context.audio_decoder.audio_decoder_store_packet(header, buf,
                                                                  len);
      TRACE_A2DP_DECODER_W("[INPUT] MTU_LIMTER so discards_packet");
    }
#endif
  } else {
    TRACE(2, "[INPUT] skip packet status:%d", a2dp_audio_get_status());
  }

  if (a2dp_audio_store_packet_callback) {
    a2dp_audio_store_packet_callback(header, buf, len);
  }

  a2dp_audio_set_store_packet_status(
      A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_IDLE);
  a2dp_audio_status_mutex_unlock();
  return 0;
}

uint32_t a2dp_audio_playback_handler(uint8_t *buffer, uint32_t buffer_bytes) {
  uint32_t len = buffer_bytes;
  int nRet = A2DP_DECODER_NO_ERROR;
  A2DP_AUDIO_LASTFRAME_INFO_T *lastframe_info = NULL;
  list_t *list = a2dp_audio_context.audio_datapath.input_raw_packet_list;

  a2dp_audio_set_playback_status(A2DP_AUDIO_DECODER_PLAYBACK_STATUS_BUSY);
  if (a2dp_audio_get_status() != A2DP_AUDIO_DECODER_STATUS_START) {
    TRACE_A2DP_DECODER_W("[PLAYBACK] skip handler status:%d",
                         a2dp_audio_get_status());
    goto exit;
  }

  a2dp_audio_sysfreq_boost_porc();
  if (a2dp_audio_context.average_packet_mut == 0) {
    A2DP_AUDIO_HEADFRAME_INFO_T headframe_info;
    a2dp_audio_decoder_headframe_info_get(&headframe_info);
    a2dp_audio_context.average_packet_mut = a2dp_audio_list_length(list);
    TRACE_A2DP_DECODER_I(
        "[PLAYBACK] init average_packet_mut:%d seq:%d",
        (uint16_t)(a2dp_audio_context.average_packet_mut + 0.5f),
        headframe_info.sequenceNumber);
  } else {
    if (!a2dp_audio_refill_packet()) {
      uint16_t packet_mut = 0;
      if (!a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info)) {
        packet_mut = a2dp_audio_list_length(list) + get_in_cp_frame_cnt() +
                     get_in_cp_frame_delay() * (lastframe_info->frame_samples /
                                                lastframe_info->list_samples);
        a2dp_audio_context.average_packet_mut = a2dp_audio_alpha_filter(
            (float)a2dp_audio_context.average_packet_mut, (float)packet_mut);
        a2dp_audio_sync_handler(buffer, buffer_bytes);
      }
    }
  }
#if defined(A2DP_AUDIO_REFILL_AFTER_NO_CACHE)
  if (a2dp_audio_context.skip_frame_cnt_after_no_cache) {
#if defined(A2DP_CP_ACCEL)
    uint32_t cp_delay_mtus = get_in_cp_frame_delay();
    cp_delay_mtus *= get_cp_frame_mtus(&a2dp_audio_lastframe_info);
    if (a2dp_audio_list_length(list) >=
        (a2dp_audio_context.dest_packet_mut - cp_delay_mtus)) {
      a2dp_audio_context.skip_frame_cnt_after_no_cache = 0;
    }
#else
    if (a2dp_audio_list_length(list) >= a2dp_audio_context.dest_packet_mut) {
      a2dp_audio_context.skip_frame_cnt_after_no_cache = 0;
    }
#endif

    memset(buffer, 0, buffer_bytes);
    TRACE_A2DP_DECODER_I("[PLAYBACK] decode refill skip_cnt:%d, list:%d",
                         a2dp_audio_context.skip_frame_cnt_after_no_cache,
                         a2dp_audio_list_length(list));
    a2dp_decoder_info_checker();
    if (a2dp_audio_context.skip_frame_cnt_after_no_cache > 0) {
      a2dp_audio_context.skip_frame_cnt_after_no_cache--;
    } else {
      a2dp_audio_context.mute_frame_cnt_after_no_cache =
          A2DP_AUDIO_MUTE_FRAME_CNT_AFTER_NO_CACHE;
    }
  } else
#endif
  {
    if (a2dp_audio_context.output_cfg.bits_depth == 24 &&
        16 == bt_sbc_player_get_sample_bit()) {

      len = len / (sizeof(int32_t) / sizeof(int16_t));

      nRet = a2dp_audio_context.audio_decoder.audio_decoder_decode_frame(buffer,
                                                                         len);
      if (nRet < 0 || a2dp_audio_context.mute_frame_cnt_after_no_cache) {
        TRACE_A2DP_DECODER_I("[PLAYBACK] decode failed nRet=%d mute_cnt:%d",
                             nRet,
                             a2dp_audio_context.mute_frame_cnt_after_no_cache);
        a2dp_decoder_info_checker();
        // mute frame
        memset(buffer, 0, len);
      }
      a2dp_audio_convert_16bit_to_24bit((int32_t *)buffer, (int16_t *)buffer,
                                        len / sizeof(int16_t));

      // Restore len to 24-bit sample buffer length
      len = len * (sizeof(int32_t) / sizeof(int16_t));

    } else if (a2dp_audio_context.output_cfg.bits_depth ==
               a2dp_audio_context.audio_decoder.stream_info.bits_depth) {

      nRet = a2dp_audio_context.audio_decoder.audio_decoder_decode_frame(buffer,
                                                                         len);
      if (nRet < 0 || a2dp_audio_context.mute_frame_cnt_after_no_cache) {
        // mute frame
        TRACE_A2DP_DECODER_I("[PLAYBACK] decode failed nRet=%d mute_cnt:%d",
                             nRet,
                             a2dp_audio_context.mute_frame_cnt_after_no_cache);
        a2dp_decoder_info_checker();
        memset(buffer, 0, len);
      }
    }
    a2dp_audio_channel_select(a2dp_audio_context.chnl_sel, buffer,
                              buffer_bytes);
  }
  a2dp_audio_semaphore_release();

  if (nRet == A2DP_DECODER_CACHE_UNDERFLOW_ERROR) {
    if (a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info) < 0) {
      goto exit;
    }
    TRACE(2, "CACHE_UNDERFLOW lastseq:%d ftick:%d",
          lastframe_info->sequenceNumber, hal_fast_sys_timer_get());
    a2dp_audio_show_history_seq();
    uint32_t mute_frames = A2DP_AUDIO_MUTE_FRAME_CNT_AFTER_NO_CACHE;
    uint32_t skip_frames =
        A2DP_AUDIO_SKIP_FRAME_LIMIT_AFTER_NO_CACHE - get_in_cp_frame_delay();
    a2dp_audio_context.mute_frame_cnt_after_no_cache =
        (uint32_t)((float)mute_frames * a2dp_audio_latency_factor_get());
    a2dp_audio_context.skip_frame_cnt_after_no_cache =
        (uint32_t)((float)skip_frames * a2dp_audio_latency_factor_get());

    a2dp_audio_context.average_packet_mut = 0;
    a2dp_audio_sync_reset_data();
#if defined(IBRT)

    a2dp_audio_sync_tune_sample_rate(
        app_tws_ibrt_audio_sync_config_factor_reference_get());
#else
    a2dp_audio_sync_tune_sample_rate(a2dp_audio_context.init_factor_reference);
#endif
    a2dp_decoder_info_checker();
  } else {
    if (a2dp_audio_context.mute_frame_cnt_after_no_cache > 0) {
      a2dp_audio_context.mute_frame_cnt_after_no_cache--;
      a2dp_audio_context.average_packet_mut = 0;
      if (a2dp_audio_context.mute_frame_cnt_after_no_cache >= 1) {
        a2dp_audio_synchronize_dest_packet_mut(
            a2dp_audio_context.dest_packet_mut);
      }
    }
  }
  if (!a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info)) {
    lastframe_info->stream_info.factor_reference =
        a2dp_audio_context.output_cfg.factor_reference;
    lastframe_info->average_frames =
        (uint32_t)(a2dp_audio_context.average_packet_mut + 0.5f);
  }
exit:
  a2dp_audio_set_playback_status(A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE);
#if defined(IBRT)
  if (nRet == A2DP_DECODER_CACHE_UNDERFLOW_ERROR) {
#if defined(A2DP_AUDIO_UNDERFLOW_CAUSE_AUDIO_RETRIGGER)
    bool force_audio_retrigger = true;
#else
    bool force_audio_retrigger = false;
#endif
    if (a2dp_audio_latency_factor_get() == A2DP_AUDIO_LATENCY_LOW_FACTOR &&
        app_tws_ibrt_mobile_link_connected()) {
      a2dp_audio_latency_factor_sethigh();
      if (app_tws_ibrt_tws_link_connected() &&
          app_ibrt_ui_is_profile_exchanged()) {
        float latency_factor = a2dp_audio_latency_factor_get();
        tws_ctrl_send_cmd(APP_TWS_CMD_SET_LATENCYFACTOR,
                          (uint8_t *)&latency_factor, sizeof(latency_factor));
        force_audio_retrigger = true;
      }
    }
    if (force_audio_retrigger && !a2dp_audio_context.underflow_onporcess) {
      a2dp_audio_context.underflow_onporcess = true;
      app_ibrt_if_force_audio_retrigger();
    }
  }
#else
  if (nRet == A2DP_DECODER_CACHE_UNDERFLOW_ERROR) {
    app_audio_decode_err_force_trigger();
  }
#endif
  return len;
}

static void a2dp_audio_packet_free(void *packet) {
  if (a2dp_audio_context.audio_decoder.audio_decoder_packet_free) {
    a2dp_audio_context.audio_decoder.audio_decoder_packet_free(packet);
  } else {
    a2dp_audio_heap_free(packet);
  }
}

void a2dp_audio_clear_input_raw_packet_list(void) {
  // just clean the packet list to start receive ai data again
  if (a2dp_audio_context.audio_datapath.input_raw_packet_list)
    a2dp_audio_list_clear(
        a2dp_audio_context.audio_datapath.input_raw_packet_list);
}

int a2dp_audio_init(uint32_t sysfreq, A2DP_AUDIO_CODEC_TYPE codec_type,
                    A2DP_AUDIO_OUTPUT_CONFIG_T *config,
                    A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel,
                    uint16_t dest_packet_mut) {
  uint8_t *heap_buff = NULL;
  uint32_t heap_size = 0;
  double ratio = 0;

  A2DP_AUDIO_OUTPUT_CONFIG_T decoder_output_config;
  TRACE_A2DP_DECODER_I("[INIT] freq:%d codec:%d chnl:%d", sysfreq, codec_type,
                       chnl_sel);
  TRACE_A2DP_DECODER_I("[INIT] out:%d-%d-%d smp:%d dest:%d",
                       config->sample_rate, config->num_channels,
                       config->bits_depth, config->frame_samples,
                       dest_packet_mut);
  a2dp_audio_sysfreq_boost_init(sysfreq);
  a2dp_audio_sysfreq_boost_start(A2DP_AUDIO_SYSFREQ_BOOST_RESUME_CNT);
  a2dp_audio_semaphore_init();
  a2dp_audio_buffer_mutex_init();
  a2dp_audio_status_mutex_init();

  a2dp_audio_status_mutex_lock();

  a2dp_audio_detect_next_packet_callback_register(NULL);
  a2dp_audio_detect_store_packet_callback_register(NULL);

#if defined(A2DP_LDAC_ON)
  if (bt_sbc_player_get_codec_type() == BTIF_AVDTP_CODEC_TYPE_NON_A2DP) {
    heap_size = A2DP_AUDIO_LDAC_MEMPOOL_SIZE;
  } else
#endif
  {
    heap_size = A2DP_AUDIO_MEMPOOL_SIZE;
  }
  app_audio_mempool_get_buff(&heap_buff, heap_size);
  ASSERT_A2DP_DECODER(heap_buff, "%s size:%d", __func__, heap_size);
  a2dp_audio_heap_init(heap_buff, heap_size);

  memset(&a2dp_audio_lastframe_info, 0, sizeof(A2DP_AUDIO_LASTFRAME_INFO_T));

  a2dp_audio_context.audio_datapath.input_raw_packet_list = a2dp_audio_list_new(
      a2dp_audio_packet_free, (list_mempool_zmalloc)a2dp_audio_heap_cmalloc,
      (list_mempool_free)a2dp_audio_heap_free);

  a2dp_audio_context.audio_datapath.output_pcm_packet_list =
      a2dp_audio_list_new(a2dp_audio_packet_free,
                          (list_mempool_zmalloc)a2dp_audio_heap_cmalloc,
                          (list_mempool_free)a2dp_audio_heap_free);

  memcpy(&(a2dp_audio_context.output_cfg), config,
         sizeof(A2DP_AUDIO_OUTPUT_CONFIG_T));
  ratio = a2dp_audio_context.output_cfg.factor_reference;
  a2dp_audio_context.output_cfg.factor_reference = 0;

  a2dp_audio_context.init_factor_reference = config->factor_reference;
  a2dp_audio_context.chnl_sel = chnl_sel;
  a2dp_audio_context.dest_packet_mut = dest_packet_mut;
  a2dp_audio_context.average_packet_mut = 0;

  switch (codec_type) {
  case A2DP_AUDIO_CODEC_TYPE_SBC:
    decoder_output_config.sample_rate = config->sample_rate;
    decoder_output_config.num_channels = 2;
    decoder_output_config.bits_depth = 16;
    decoder_output_config.frame_samples = config->frame_samples;
    decoder_output_config.factor_reference = 1.0f;
    memcpy(&(a2dp_audio_context.audio_decoder), &a2dp_audio_sbc_decoder_config,
           sizeof(A2DP_AUDIO_DECODER_T));
    break;
#if defined(A2DP_AAC_ON)
  case A2DP_AUDIO_CODEC_TYPE_MPEG2_4_AAC:
    decoder_output_config.sample_rate = config->sample_rate;
    decoder_output_config.num_channels = 2;
    decoder_output_config.bits_depth = 16;
    decoder_output_config.frame_samples = config->frame_samples;
    decoder_output_config.factor_reference = 1.0f;
    memcpy(&(a2dp_audio_context.audio_decoder),
           &a2dp_audio_aac_lc_decoder_config, sizeof(A2DP_AUDIO_DECODER_T));
    break;
#endif
#if defined(A2DP_SCALABLE_ON)
  case A2DP_AUDIO_CODEC_TYPE_SCALABL:
    decoder_output_config.sample_rate = config->sample_rate;
    decoder_output_config.num_channels = 2;
    decoder_output_config.bits_depth = config->curr_bits;
    decoder_output_config.frame_samples = config->frame_samples;
    decoder_output_config.factor_reference = 1.0f;
    memcpy(&(a2dp_audio_context.audio_decoder),
           &a2dp_audio_scalable_decoder_config, sizeof(A2DP_AUDIO_DECODER_T));
    break;
#endif
#if defined(A2DP_LHDC_ON)
  case A2DP_AUDIO_CODEC_TYPE_LHDC:
    decoder_output_config.sample_rate = config->sample_rate;
    decoder_output_config.num_channels = 2;
    decoder_output_config.bits_depth = config->curr_bits;
    decoder_output_config.frame_samples = config->frame_samples;
    decoder_output_config.factor_reference = 1.0f;
    memcpy(&(a2dp_audio_context.audio_decoder), &a2dp_audio_lhdc_decoder_config,
           sizeof(A2DP_AUDIO_DECODER_T));
    break;
#endif
#if defined(A2DP_LDAC_ON)
  case A2DP_AUDIO_CODEC_TYPE_LDAC:
    decoder_output_config.sample_rate = config->sample_rate;
    decoder_output_config.num_channels = 2;
    decoder_output_config.bits_depth = config->curr_bits;
    decoder_output_config.frame_samples = config->frame_samples;
    decoder_output_config.factor_reference = 1.0f;
    memcpy(&(a2dp_audio_context.audio_decoder), &a2dp_audio_ldac_decoder_config,
           sizeof(A2DP_AUDIO_DECODER_T));
    break;
#endif
  default:
    ASSERT_A2DP_DECODER(0, "%s invalid codec_type:%d", __func__, codec_type);
    break;
  }

  a2dp_audio_context.audio_decoder.audio_decoder_init(
      &decoder_output_config, (void *)&a2dp_audio_context);
  a2dp_audio_context.need_detect_first_packet = true;
  a2dp_audio_context.underflow_onporcess = false;
  a2dp_audio_context.skip_frame_cnt_after_no_cache = 0;
  a2dp_audio_context.mute_frame_cnt_after_no_cache = 0;

  a2dp_audio_context.audio_decoder_status = A2DP_AUDIO_DECODER_STATUS_READY;

  a2dp_audio_context.store_packet_status =
      A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_IDLE;
  a2dp_audio_context.playback_status = A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE;

  a2dp_audio_sync_init(ratio);

#if A2DP_DECODER_HISTORY_SEQ_SAVE
  a2dp_audio_reset_history_seq();
#endif
  a2dp_audio_store_packet_checker_start();

  a2dp_audio_status_mutex_unlock();

  return 0;
}

int a2dp_audio_deinit(void) {
  TRACE_A2DP_DECODER_I("[DEINIT]");

  a2dp_audio_status_mutex_lock();

  a2dp_audio_detect_next_packet_callback_register(NULL);
  a2dp_audio_detect_store_packet_callback_register(NULL);

  a2dp_audio_context.audio_decoder.audio_decoder_deinit();
  memset(&(a2dp_audio_context.audio_decoder), 0, sizeof(A2DP_AUDIO_DECODER_T));
  memset(&(a2dp_audio_context.output_cfg), 0,
         sizeof(A2DP_AUDIO_OUTPUT_CONFIG_T));
  a2dp_audio_list_clear(
      a2dp_audio_context.audio_datapath.input_raw_packet_list);
  a2dp_audio_list_free(a2dp_audio_context.audio_datapath.input_raw_packet_list);
  a2dp_audio_context.audio_datapath.input_raw_packet_list = NULL;
  a2dp_audio_list_clear(
      a2dp_audio_context.audio_datapath.output_pcm_packet_list);
  a2dp_audio_list_free(
      a2dp_audio_context.audio_datapath.output_pcm_packet_list);
  a2dp_audio_context.audio_datapath.output_pcm_packet_list = NULL;

  size_t total = 0, used = 0, max_used = 0;
  a2dp_audio_heap_info(&total, &used, &max_used);
  TRACE_A2DP_DECODER_I(
      "[DEINIT] heap info: total - %d, used - %d, max_used - %d.", total, used,
      max_used);
  // ASSERT_A2DP_DECODER(used == 0, "[%s] used != 0", __func__);

  a2dp_audio_set_store_packet_status(
      A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_IDLE);
  a2dp_audio_set_playback_status(A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE);
  a2dp_audio_set_status(A2DP_AUDIO_DECODER_STATUS_NULL);
#if A2DP_DECODER_HISTORY_SEQ_SAVE
  a2dp_audio_reset_history_seq();
#endif
  a2dp_audio_status_mutex_unlock();

  return 0;
}

int a2dp_audio_stop(void) {
  TRACE_A2DP_DECODER_I("[STOP]");
  int cnt = 0;

  a2dp_audio_set_status(A2DP_AUDIO_DECODER_STATUS_STOP);
  a2dp_audio_semaphore_release();

  cnt = 50;
  do {
    if (a2dp_audio_get_playback_status() ==
        A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE) {
      TRACE_A2DP_DECODER_I("[DEINIT]PLAYBACK_STATUS_IDLE cnt:%d", cnt);
      break;
    } else {
      osThreadYield();
    }
  } while (--cnt > 0);
  cnt = 50;
  do {
    if (a2dp_audio_get_store_packet_status() ==
        A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_IDLE) {
      TRACE_A2DP_DECODER_I("[DEINIT] STORE_PACKET_STATUS_IDLE cnt:%d", cnt);
      break;
    } else {
      osThreadYield();
    }
  } while (--cnt > 0);

  return 0;
}

int a2dp_audio_start(void) {
  TRACE_A2DP_DECODER_I("[START]");
  a2dp_audio_status_mutex_lock();
  a2dp_audio_set_status(A2DP_AUDIO_DECODER_STATUS_START);
  a2dp_audio_status_mutex_unlock();
  return 0;
}

int a2dp_audio_detect_next_packet_callback_register(
    A2DP_AUDIO_DETECT_NEXT_PACKET_CALLBACK callback) {
  a2dp_audio_status_mutex_lock();
  a2dp_audio_detect_next_packet_callback = callback;
  a2dp_audio_status_mutex_unlock();

  return 0;
}

int a2dp_audio_detect_store_packet_callback_register(
    A2DP_AUDIO_DETECT_NEXT_PACKET_CALLBACK callback) {
  a2dp_audio_status_mutex_lock();
  a2dp_audio_store_packet_callback = callback;
  a2dp_audio_status_mutex_unlock();

  return 0;
}

int a2dp_audio_detect_first_packet(void) {
  a2dp_audio_status_mutex_lock();
  a2dp_audio_context.need_detect_first_packet = true;
  a2dp_audio_status_mutex_unlock();
  return 0;
}

int a2dp_audio_detect_first_packet_clear(void) {
  a2dp_audio_status_mutex_lock();
  a2dp_audio_context.need_detect_first_packet = false;
  a2dp_audio_status_mutex_unlock();
  return 0;
}

int a2dp_audio_discards_packet(uint32_t packets) {
  int nRet = 0;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    a2dp_audio_status_mutex_lock();
    nRet =
        a2dp_audio_context.audio_decoder.audio_decoder_discards_packet(packets);
    a2dp_audio_status_mutex_unlock();
  } else {
    nRet = -1;
  }

  return nRet;
}

int a2dp_audio_synchronize_dest_packet_mut(uint32_t mtu) {
  int nRet = 0;
  int cnt = 50;
  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    do {
      if (a2dp_audio_get_playback_status() ==
          A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE) {
        nRet = a2dp_audio_context.audio_decoder
                   .audio_decoder_synchronize_dest_packet_mut(mtu);
        break;
      } else {
        osThreadYield();
      }
    } while (--cnt > 0);
  } else {
    nRet = -1;
  }

  return nRet;
}

int a2dp_audio_discards_samples(uint32_t samples) {
  return a2dp_audio_context.audio_decoder.a2dp_audio_discards_samples(samples);
}

int a2dp_audio_convert_list_to_samples(uint32_t *samples) {
  return a2dp_audio_context.audio_decoder.a2dp_audio_convert_list_to_samples(
      samples);
}

int a2dp_audio_get_packet_samples(void) {
  A2DP_AUDIO_LASTFRAME_INFO_T lastframe_info;
  uint32_t packet_samples = 0;
  uint16_t totalSubSequenceNumber = 1;

  a2dp_audio_lastframe_info_get(&lastframe_info);

  if (lastframe_info.totalSubSequenceNumber) {
    totalSubSequenceNumber = lastframe_info.totalSubSequenceNumber;
  }

  packet_samples = totalSubSequenceNumber * lastframe_info.frame_samples;

  return packet_samples;
}

static int a2dp_audio_internal_lastframe_info_ptr_get(
    A2DP_AUDIO_LASTFRAME_INFO_T **lastframe_info) {
  int nRet = 0;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    *lastframe_info = &a2dp_audio_lastframe_info;
  } else {
    *lastframe_info = NULL;
    nRet = -1;
  }

  return nRet;
}

int a2dp_audio_lastframe_info_get(A2DP_AUDIO_LASTFRAME_INFO_T *lastframe_info) {
  int nRet = 0;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    a2dp_audio_buffer_mutex_lock();
    memcpy(lastframe_info, &a2dp_audio_lastframe_info,
           sizeof(A2DP_AUDIO_LASTFRAME_INFO_T));
    a2dp_audio_buffer_mutex_unlock();
  } else {
    memset(lastframe_info, 0, sizeof(A2DP_AUDIO_LASTFRAME_INFO_T));
    nRet = -1;
  }

  return nRet;
}

int a2dp_audio_decoder_internal_check_sum_reset(void) {
  check_sum_seed = 0;
  return 0;
}

uint32_t a2dp_audio_decoder_internal_check_sum_generate(const uint8_t *buf,
                                                        uint32_t len) {
#if A2DP_DECODER_CHECKER
  check_sum_seed = crc32(check_sum_seed, buf, len);
#else
  check_sum_seed = 0;
#endif
  return check_sum_seed;
}

int a2dp_audio_lastframe_info_reset_undecodeframe(void) {
  int nRet = 0;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    a2dp_audio_buffer_mutex_lock();
    a2dp_audio_lastframe_info.undecode_frames = 0;
    a2dp_audio_lastframe_info.undecode_max_frames = 0;
    a2dp_audio_lastframe_info.undecode_min_frames = 0xffff;
    a2dp_audio_decoder_internal_check_sum_reset();
    a2dp_audio_lastframe_info.check_sum = 0;
    a2dp_audio_buffer_mutex_unlock();
  } else {
    nRet = -1;
  }

  return nRet;
}

int a2dp_audio_decoder_internal_lastframe_info_set(
    A2DP_AUDIO_DECODER_LASTFRAME_INFO_T *lastframe_info) {
  a2dp_audio_buffer_mutex_lock();
  a2dp_audio_lastframe_info.sequenceNumber = lastframe_info->sequenceNumber;
  a2dp_audio_lastframe_info.timestamp = lastframe_info->timestamp;
  a2dp_audio_lastframe_info.curSubSequenceNumber =
      lastframe_info->curSubSequenceNumber;
  a2dp_audio_lastframe_info.totalSubSequenceNumber =
      lastframe_info->totalSubSequenceNumber;
  a2dp_audio_lastframe_info.frame_samples = lastframe_info->frame_samples;
  a2dp_audio_lastframe_info.list_samples = lastframe_info->list_samples;
  a2dp_audio_lastframe_info.decoded_frames = lastframe_info->decoded_frames;
  a2dp_audio_lastframe_info.undecode_frames = lastframe_info->undecode_frames;

  a2dp_audio_lastframe_info.undecode_max_frames =
      MAX(a2dp_audio_lastframe_info.undecode_frames,
          a2dp_audio_lastframe_info.undecode_max_frames);
  a2dp_audio_lastframe_info.undecode_min_frames =
      MIN(a2dp_audio_lastframe_info.undecode_frames,
          a2dp_audio_lastframe_info.undecode_min_frames);

  a2dp_audio_lastframe_info.stream_info = lastframe_info->stream_info;
  a2dp_audio_lastframe_info.check_sum = lastframe_info->check_sum;
  a2dp_audio_buffer_mutex_unlock();

  return 0;
}

int a2dp_audio_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info,
                                  uint32_t mask) {
  int nRet = 0;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    a2dp_audio_status_mutex_lock();
    nRet = a2dp_audio_context.audio_decoder.audio_decoder_synchronize_packet(
        sync_info, mask);
    if (nRet == A2DP_DECODER_NOT_SUPPORT) {
      // can't support synchronize packet, so return fake val;
      nRet = A2DP_DECODER_NO_ERROR;
    }
    a2dp_audio_status_mutex_unlock();
  } else {
    nRet = -1;
  }

  return nRet;
}

int a2dp_audio_decoder_headframe_info_get(
    A2DP_AUDIO_HEADFRAME_INFO_T *headframe_info) {
  int nRet = 0;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    nRet = a2dp_audio_context.audio_decoder.audio_decoder_headframe_info_get(
        headframe_info);
  } else {
    memset(headframe_info, 0, sizeof(A2DP_AUDIO_HEADFRAME_INFO_T));
    nRet = -1;
  }

  return nRet;
}

int a2dp_audio_refill_packet(void) {
  int refill_cnt = 0;

#if defined(A2DP_AUDIO_REFILL_AFTER_NO_CACHE)
  refill_cnt += a2dp_audio_context.skip_frame_cnt_after_no_cache;
#endif
  refill_cnt += a2dp_audio_context.mute_frame_cnt_after_no_cache;

  return refill_cnt;
}

bool a2dp_audio_auto_synchronize_support(void) {
  bool nRet = 0;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    a2dp_audio_buffer_mutex_lock();
    nRet = a2dp_audio_context.audio_decoder.auto_synchronize_support > 0
               ? true
               : false;
    a2dp_audio_buffer_mutex_unlock();
  } else {
    nRet = 0;
  }

  return nRet;
}

A2DP_AUDIO_OUTPUT_CONFIG_T *a2dp_audio_get_output_config(void) {
  A2DP_AUDIO_OUTPUT_CONFIG_T *output_config = NULL;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    a2dp_audio_buffer_mutex_lock();
    output_config = &a2dp_audio_context.output_cfg;
    a2dp_audio_buffer_mutex_unlock();
  } else {
    output_config = NULL;
  }

  return output_config;
}

int a2dp_audio_latency_factor_setlow(void) {
  a2dp_audio_latency_factor = A2DP_AUDIO_LATENCY_LOW_FACTOR;
  return 0;
}

int a2dp_audio_latency_factor_sethigh(void) {
  a2dp_audio_latency_factor = A2DP_AUDIO_LATENCY_HIGH_FACTOR;
  return 0;
}

float a2dp_audio_latency_factor_get(void) { return a2dp_audio_latency_factor; }

int a2dp_audio_latency_factor_set(float factor) {
  a2dp_audio_latency_factor = factor;
  return 0;
}

int a2dp_audio_latency_factor_status_get(
    A2DP_AUDIO_LATENCY_STATUS_E *latency_status, float *more_latency_factor) {
  if (a2dp_audio_latency_factor == A2DP_AUDIO_LATENCY_HIGH_FACTOR) {
    *latency_status = A2DP_AUDIO_LATENCY_STATUS_HIGH;
    *more_latency_factor = A2DP_AUDIO_LATENCY_MORE_FACTOR;
  } else {
    *latency_status = A2DP_AUDIO_LATENCY_STATUS_LOW;
    *more_latency_factor = 1.0f;
  }
  return 0;
}

int a2dp_audio_frame_delay_get(void) { return get_in_cp_frame_delay(); }

int a2dp_audio_dest_packet_mut_get(void) {
  return a2dp_audio_context.dest_packet_mut;
}

int a2dp_audio_set_channel_select(A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel) {
  int nRet = A2DP_DECODER_NO_ERROR;

  if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) {
    a2dp_audio_context.chnl_sel = chnl_sel;
    if (a2dp_audio_context.audio_decoder.audio_decoder_channel_select) {
      nRet = a2dp_audio_context.audio_decoder.audio_decoder_channel_select(
          chnl_sel);
    }
  }

  return nRet;
}

float a2dp_audio_get_sample_reference(void) {
  TRACE(1, "a2dp_audio_get_sample_reference:%d",
        (int32_t)(a2dp_audio_context.output_cfg.factor_reference * 10000000));
  return a2dp_audio_context.output_cfg.factor_reference;
}

int8_t a2dp_audio_get_current_buf_size(void) {
  TRACE(1, "a2dp_audio_get_current_buf_size:%d",
        (int8_t)(a2dp_audio_context.average_packet_mut + 0.5f));
  return (int8_t)(a2dp_audio_context.average_packet_mut + 0.5f);
}