pinebuds/apps/audioplayers/a2dp_decoder/a2dp_decoder_lhdc.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
#include "a2dp_decoder_internal.h"
#include "cmsis.h"
#include "hal_location.h"
#include "hal_timer.h"
#include "heap_api.h"
#include "plat_types.h"
#include <string.h>

typedef struct {
  uint16_t sequenceNumber;
  uint32_t timestamp;
  uint16_t curSubSequenceNumber;
  uint16_t totalSubSequenceNumber;
  uint8_t *buffer;
  uint32_t buffer_len;
} a2dp_audio_lhdc_decoder_frame_t;

#define LHDC_MTU_LIMITER (100)

#if defined(A2DP_LHDC_V3)
#define A2DP_LHDC_OUTPUT_FRAME_SAMPLES (256)
#else
#define A2DP_LHDC_OUTPUT_FRAME_SAMPLES (512)
#endif

#define A2DP_LHDC_DEFAULT_LATENCY (1)
#if defined(A2DP_LHDC_V3)
#define PACKET_BUFFER_LENGTH (2 * 1024)
#else
#define PACKET_BUFFER_LENGTH (4 * 1024)
#endif

#define LHDC_READBUF_SIZE (512)

#define A2DP_LHDC_HDR_F_MSK 0x80
#define A2DP_LHDC_HDR_S_MSK 0x40
#define A2DP_LHDC_HDR_L_MSK 0x20
#define A2DP_LHDC_HDR_FLAG_MSK                                                 \
  (A2DP_LHDC_HDR_F_MSK | A2DP_LHDC_HDR_S_MSK | A2DP_LHDC_HDR_L_MSK)

#define A2DP_LHDC_HDR_LATENCY_LOW 0x00
#define A2DP_LHDC_HDR_LATENCY_MID 0x01
#define A2DP_LHDC_HDR_LATENCY_HIGH 0x02
#define A2DP_LHDC_HDR_LATENCY_MASK                                             \
  (A2DP_LHDC_HDR_LATENCY_MID | A2DP_LHDC_HDR_LATENCY_HIGH)

#if defined(A2DP_LHDC_V3)
#define A2DP_LHDC_HDR_FRAME_NO_MASK 0xfc
#else
#define A2DP_LHDC_HDR_FRAME_NO_MASK 0x1c
#endif

typedef enum {
  ASM_PKT_WAT_STR,
  ASM_PKT_WAT_LST,
} ASM_PKT_STATUS;

typedef enum { VERSION_2 = 200, VERSION_3 = 300 } lhdc_ver_t;

/**
 * get lhdc frame header
 */

/**
    LHDC frame
*/
typedef struct _lhdc_frame_Info {
  uint32_t
      frame_len; // 该 frame 的长处，若是分离压缩，则表示单一声道的 frame 长度。
  uint32_t isSplit; // 是否为分离方式压缩
  uint32_t isLeft;  // 左声道 == true， 右声道 == false

} lhdc_frame_Info_t;

#ifdef A2DP_CP_ACCEL
struct A2DP_CP_LHDC_IN_FRM_INFO_T {
  uint16_t sequenceNumber;
  uint32_t timestamp;
  uint16_t curSubSequenceNumber;
  uint16_t totalSubSequenceNumber;
};

struct A2DP_CP_LHDC_OUT_FRM_INFO_T {
  struct A2DP_CP_LHDC_IN_FRM_INFO_T in_info;
  uint16_t frame_samples;
  uint16_t decoded_frames;
  uint16_t frame_idx;
  uint16_t pcm_len;
};
#endif

extern "C" {
typedef struct bes_bt_local_info_t {
  uint8_t bt_addr[BTIF_BD_ADDR_SIZE];
  const char *bt_name;
  uint8_t bt_len;
  uint8_t ble_addr[BTIF_BD_ADDR_SIZE];
  const char *ble_name;
  uint8_t ble_len;
} bes_bt_local_info;

typedef int (*LHDC_GET_BT_INFO)(bes_bt_local_info *bt_info);

void lhdcInit(uint32_t bitPerSample, uint32_t sampleRate,
              uint32_t scaleTo16Bits, lhdc_ver_t version);
// void lhdcInit(uint32_t bitPerSample, uint32_t sampleRate, uint32_t
// scaleTo16Bits);
#if defined(A2DP_LHDC_V3)
uint32_t lhdcPutData(uint8_t *pIn, uint32_t len);
#else
uint32_t lhdcPutData(uint8_t *pIn, int32_t len);
#endif
uint32_t lhdcDecodeProcess(uint8_t *pOutBuf);
void lhdcDestroy();
bool lhdcSetLicenseKeyTable(uint8_t *licTable, LHDC_GET_BT_INFO pFunc);
const char *getVersionCode();
bool larcIsEnabled();
}

static A2DP_AUDIO_CONTEXT_T *a2dp_audio_context_p = NULL;
static A2DP_AUDIO_DECODER_LASTFRAME_INFO_T a2dp_audio_lhdc_lastframe_info;
static A2DP_AUDIO_OUTPUT_CONFIG_T a2dp_audio_lhdc_output_config;
static uint16_t lhdc_mtu_limiter = LHDC_MTU_LIMITER;

static uint8_t serial_no;
static bool is_synced;
static ASM_PKT_STATUS asm_pkt_st;
static uint8_t packet_buffer[PACKET_BUFFER_LENGTH];
static uint32_t packet_buf_len = 0;
static uint32_t lhdc_total_frame_nb = 0;

#if defined(A2DP_LHDC_LARC)
static uint32_t lhdc_drop_frame = 0;
static uint32_t lhdc_last_time = 0;
static struct A2DP_CP_LHDC_IN_FRM_INFO_T last_frame_info;
// static uint16_t demo_frame_cnt = 0;
#endif

extern int bes_bt_local_info_get(bes_bt_local_info *local_info);

// Local API declare
void sav_lhdc_log_bytes_len(uint32_t bytes_len);

#define STATISTICS_UPDATE_INTERVAL 1000 // in ms
#define INTERVAL_TIMEBASE 1000          // in ms
typedef struct {
  uint32_t sum_bytes;
  uint32_t last_times; // in ms
  float last_avg_val;
  int32_t update_interval; // in ms
} LHDC_TRACFIC_STATISTICS;

LHDC_TRACFIC_STATISTICS statistic = {0, 0, 0, STATISTICS_UPDATE_INTERVAL};

void sav_lhdc_log_bytes_len(uint32_t bytes_len) {
  uint32_t time_current = GET_CURRENT_MS();
  float time_diff = time_current - statistic.last_times;
  statistic.sum_bytes += bytes_len;
  if (time_diff >= statistic.update_interval) {

    statistic.last_avg_val = ((float)(statistic.sum_bytes * 8) / 1000) /
                             (time_diff / INTERVAL_TIMEBASE);
    TRACE_A2DP_DECODER_I("Avarage rate about %d kbps",
                         (int)statistic.last_avg_val);

    statistic.sum_bytes = 0;
    statistic.last_times = time_current;
  }
}

#if defined(A2DP_LHDC_LARC) && defined(A2DP_LHDC_V3)
static void sav_lhdc_save_last_info(struct A2DP_CP_LHDC_IN_FRM_INFO_T *f_info) {

  memcpy(&last_frame_info, f_info, sizeof(struct A2DP_CP_LHDC_IN_FRM_INFO_T));
}

static void sav_lhdc_get_next_info(struct A2DP_CP_LHDC_IN_FRM_INFO_T *f_info) {
  f_info->timestamp = last_frame_info.timestamp;
  f_info->sequenceNumber = last_frame_info.sequenceNumber;
  f_info->totalSubSequenceNumber = last_frame_info.totalSubSequenceNumber;
  f_info->curSubSequenceNumber = last_frame_info.curSubSequenceNumber + 1;
  if (f_info->curSubSequenceNumber > last_frame_info.totalSubSequenceNumber) {
    f_info->curSubSequenceNumber = 1;
    f_info->timestamp =
        last_frame_info.timestamp + (A2DP_LHDC_OUTPUT_FRAME_SAMPLES *
                                     last_frame_info.totalSubSequenceNumber);
    f_info->sequenceNumber = last_frame_info.sequenceNumber + 1;
  }
}
#endif

static void *a2dp_audio_lhdc_frame_malloc(uint32_t packet_len) {
  a2dp_audio_lhdc_decoder_frame_t *decoder_frame_p = NULL;
  uint8_t *buffer = NULL;

  buffer = (uint8_t *)a2dp_audio_heap_malloc(packet_len);
  decoder_frame_p = (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_heap_malloc(
      sizeof(a2dp_audio_lhdc_decoder_frame_t));
  decoder_frame_p->buffer = buffer;
  decoder_frame_p->buffer_len = packet_len;
  return (void *)decoder_frame_p;
}

static void reset_lhdc_assmeble_packet(void) {
  is_synced = false;
  asm_pkt_st = ASM_PKT_WAT_STR;
  packet_buf_len = 0;
}

static void initial_lhdc_assemble_packet(bool splitFlg) {
  memset(packet_buffer, 0, PACKET_BUFFER_LENGTH);
  reset_lhdc_assmeble_packet();
  serial_no = 0xff;
}

/**
 * A2DP packet 组包
 */
#if defined(A2DP_LHDC_V3)
int assemble_lhdc_packet(uint8_t *input, uint32_t input_len, uint8_t **pLout,
                         uint32_t *pLlen) {
  uint8_t hdr = 0, seqno = 0xff;
  int ret = -1;
  uint32_t status = 0;

  hdr = (*input);
  input++;
  seqno = (*input);
  input++;
  input_len -= 2;

  // Check latency and update value when changed.
  status = hdr & A2DP_LHDC_HDR_LATENCY_MASK;

  // Get number of frame in packet.
  status = (hdr & A2DP_LHDC_HDR_FRAME_NO_MASK) >> 2;
  if (status <= 0) {
    TRACE_A2DP_DECODER_I("No any frame in packet.");
    return 0;
  }
  lhdc_total_frame_nb = status;
  if (seqno != serial_no) {
    TRACE_A2DP_DECODER_I("Packet lost! now(%d), expect(%d)", seqno, serial_no);
  }
  serial_no = seqno + 1;

  sav_lhdc_log_bytes_len(input_len);

  if (pLlen && pLout) {
    *pLlen = input_len;
    *pLout = input;
  }
  ret = lhdc_total_frame_nb;

  return ret;
}
#else
int assemble_lhdc_packet(uint8_t *input, uint32_t input_len, uint8_t **pLout,
                         uint32_t *pLlen) {
  uint8_t hdr = 0, seqno = 0xff;
  int ret = -1;
  // uint32_t status = 0;

  hdr = (*input);
  input++;
  seqno = (*input);
  input++;
  input_len -= 2;

  if (is_synced) {
    if (seqno != serial_no) {
      reset_lhdc_assmeble_packet();
      if ((hdr & A2DP_LHDC_HDR_FLAG_MSK) == 0 ||
          (hdr & A2DP_LHDC_HDR_S_MSK) != 0) {
        goto lhdc_start;
      } else
        TRACE_A2DP_DECODER_I("drop packet No. %u", seqno);
      return 0;
    }
    serial_no = seqno + 1;
  }

lhdc_start:
  switch (asm_pkt_st) {
  case ASM_PKT_WAT_STR: {
    if ((hdr & A2DP_LHDC_HDR_FLAG_MSK) == 0) {
      memcpy(&packet_buffer[0], input, input_len);
      if (pLlen && pLout) {
        *pLlen = input_len;
        *pLout = packet_buffer;
      }
      // TRACE_A2DP_DECODER_I("Single payload size = %d", *pLlen);
      asm_pkt_st = ASM_PKT_WAT_STR;
      packet_buf_len = 0; //= packet_buf_left_len = packet_buf_right_len = 0;
      lhdc_total_frame_nb = (hdr & A2DP_LHDC_HDR_FRAME_NO_MASK) >> 2;
      ;
      // TRACE_A2DP_DECODER_I("Single packet. total %d frames",
      // lhdc_total_frame_nb);
      ret = lhdc_total_frame_nb;
    } else if (hdr & A2DP_LHDC_HDR_S_MSK) {
      ret = 0;
      if (packet_buf_len + input_len >= PACKET_BUFFER_LENGTH) {
        packet_buf_len = 0;
        asm_pkt_st = ASM_PKT_WAT_STR;
        TRACE_A2DP_DECODER_I("ASM_PKT_WAT_STR:Frame buffer overflow!(%d)",
                             packet_buf_len);
        break;
      }
      memcpy(&packet_buffer, input, input_len);
      packet_buf_len = input_len;
      asm_pkt_st = ASM_PKT_WAT_LST;
      lhdc_total_frame_nb = (hdr & A2DP_LHDC_HDR_FRAME_NO_MASK) >> 2;
      // TRACE_A2DP_DECODER_I("start of multi packet.");
    } else
      ret = -1;

    if (ret >= 0) {
      if (!is_synced) {
        is_synced = true;
        serial_no = seqno + 1;
      }
    }
    break;
  }
  case ASM_PKT_WAT_LST: {
    if (packet_buf_len + input_len >= PACKET_BUFFER_LENGTH) {
      packet_buf_len = 0;
      asm_pkt_st = ASM_PKT_WAT_STR;
      TRACE_A2DP_DECODER_I("ASM_PKT_WAT_LST:Frame buffer overflow(%d)",
                           packet_buf_len);
      break;
    }
    memcpy(&packet_buffer[packet_buf_len], input, input_len);
    // TRACE_A2DP_DECODER_I("multi:payload size = %d", input_len);
    packet_buf_len += input_len;
    ret = 0;

    if (hdr & A2DP_LHDC_HDR_L_MSK) {

      if (pLlen && pLout) {
        *pLlen = packet_buf_len;
        *pLout = packet_buffer;
      }
      // TRACE_A2DP_DECODER_I("end of multi packet. total %d frames.",
      // lhdc_total_frame_nb);
      packet_buf_len = 0; // packet_buf_left_len = packet_buf_right_len = 0;
      ret = lhdc_total_frame_nb;
      asm_pkt_st = ASM_PKT_WAT_STR;
    }
    break;
  }
  default:
    ret = 0;
    break;
  }
  return ret;
}
#endif

static int parse_lhdc_info(uint8_t *in, lhdc_frame_Info_t *h) {
#define LHDC_HDR_LEN 4
  uint32_t hdr = 0;
  int ret = -1;
  memcpy(&hdr, in, LHDC_HDR_LEN);
  h->frame_len = (int)((hdr >> 8) & 0x1fff);
  h->isSplit = ((hdr & 0x00600000) == 0x00600000);
  h->isLeft = ((hdr & 0xf) == 0);

  if ((hdr & 0xff000000) != 0x4c000000) {
  } else {
    ret = 0;
  }
  return ret;
}

#ifdef A2DP_CP_ACCEL

extern "C" uint32_t get_in_cp_frame_cnt(void);
extern "C" unsigned int set_cp_reset_flag(uint8_t evt);
extern uint32_t app_bt_stream_get_dma_buffer_samples(void);

int a2dp_cp_lhdc_cp_decode(void);

TEXT_LHDC_LOC
static int a2dp_cp_lhdc_after_cache_underflow(void) {
  int ret = 0;
#ifdef A2DP_CP_ACCEL
  a2dp_cp_deinit();
  lhdcDestroy();
  ret = a2dp_cp_init(a2dp_cp_lhdc_cp_decode, CP_PROC_DELAY_2_FRAMES);
  ASSERT(ret == 0, "%s: a2dp_cp_init() failed: ret=%d", __func__, ret);
#endif
  return ret;
}

// uint32_t demoTimer = 0;
static int a2dp_cp_lhdc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes) {
  a2dp_audio_lhdc_decoder_frame_t *lhdc_decoder_frame_p = NULL;
  list_node_t *node = NULL;
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
  int ret, dec_ret;
  struct A2DP_CP_LHDC_IN_FRM_INFO_T in_info;
  struct A2DP_CP_LHDC_OUT_FRM_INFO_T *p_out_info;

  uint8_t *out;
  uint32_t out_len;
  uint32_t out_frame_len;
  uint32_t cp_buffer_frames_max = 0;

#if defined(A2DP_LHDC_LARC)
  // bool forceRecovery = false;
  bool larcEnabled = larcIsEnabled();
  uint32_t frame_number = 0;

  if (larcEnabled) {
    /* The LARC is enabled. */

    uint32_t time_diff = 0, time_now = GET_CURRENT_MS();

    if (lhdc_last_time == 0) {
      lhdc_last_time = time_now;
    }
    //   if (demoTimer == 0) {
    //     demoTimer = time_now;
    //   }
    time_diff = time_now - lhdc_last_time;
    lhdc_last_time = time_now;

    frame_number = (uint32_t)((float)time_diff /
                              ((A2DP_LHDC_OUTPUT_FRAME_SAMPLES * 1000) /
                               a2dp_audio_lhdc_output_config.sample_rate));

    TRACE_A2DP_DECODER_I(
        "%s:current total list len %d, need frames %d", __func__,
        a2dp_audio_list_length(list) + get_in_cp_frame_cnt(), frame_number);
    //   if (time_now - demoTimer >= (5 * 1000)) {
    //     forceRecovery = true;
    //     demoTimer = time_now;
    //     demo_frame_cnt = (a2dp_audio_lhdc_output_config.sample_rate * 120) /
    //     (A2DP_LHDC_OUTPUT_FRAME_SAMPLES * 1000);
    //   }
  }
#endif

  cp_buffer_frames_max = app_bt_stream_get_dma_buffer_samples() / 2;

  if (cp_buffer_frames_max % (a2dp_audio_lhdc_lastframe_info.frame_samples)) {
    cp_buffer_frames_max =
        cp_buffer_frames_max / (a2dp_audio_lhdc_lastframe_info.frame_samples) +
        1;
  } else {
    cp_buffer_frames_max =
        cp_buffer_frames_max / (a2dp_audio_lhdc_lastframe_info.frame_samples);
  }

  out_frame_len = sizeof(*p_out_info) + buffer_bytes;

  ret = a2dp_cp_decoder_init(out_frame_len, cp_buffer_frames_max * 8);
  if (ret) {
    TRACE_A2DP_DECODER_I("%s: a2dp_cp_decoder_init() failed: ret=%d", __func__,
                         ret);
    set_cp_reset_flag(true);
    return A2DP_DECODER_DECODE_ERROR;
  }

#if defined(A2DP_LHDC_LARC)
  uint32_t put_cnt = 0;
  uint32_t drop_cnt = 0;
  while (larcEnabled && ((a2dp_audio_list_length(list) < frame_number &&
                          get_in_cp_frame_cnt() == 0))) {
    sav_lhdc_get_next_info(&in_info);
    ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info), NULL, 0x55);
    if (ret) {
      // TRACE_A2DP_DECODER_I("%s  piff  !!!!!!ret: %d ",__func__, ret);
      break;
    }
    sav_lhdc_save_last_info(&in_info);
    lhdc_drop_frame++;
    frame_number--;
    // demo_frame_cnt--;
    put_cnt++;
  }
  // forceRecovery = false;
  TRACE_A2DP_DECODER_I("Recover %d frames", put_cnt);
  put_cnt = 0;
  drop_cnt = 0;
#endif
  while ((node = a2dp_audio_list_begin(list)) != NULL) {
    lhdc_decoder_frame_p =
        (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
    in_info.sequenceNumber = lhdc_decoder_frame_p->sequenceNumber;
    in_info.timestamp = lhdc_decoder_frame_p->timestamp;
    in_info.curSubSequenceNumber = lhdc_decoder_frame_p->curSubSequenceNumber;
    in_info.totalSubSequenceNumber =
        lhdc_decoder_frame_p->totalSubSequenceNumber;

#if defined(A2DP_LHDC_LARC)
    if (!lhdc_drop_frame) {
      ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info),
                                 lhdc_decoder_frame_p->buffer,
                                 lhdc_decoder_frame_p->buffer_len);
      if (ret) {
        // TRACE_A2DP_DECODER_I("%s  piff  !!!!!!ret: %d ",__func__, ret);
        break;
      }
      sav_lhdc_save_last_info(&in_info);
      put_cnt++;
    } else {
      lhdc_drop_frame--;
      drop_cnt++;
    }
#else
    ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info),
                               lhdc_decoder_frame_p->buffer,
                               lhdc_decoder_frame_p->buffer_len);
    if (ret) {
      // TRACE_A2DP_DECODER_I("%s  piff  !!!!!!ret: %d ",__func__, ret);
      break;
    }
#endif
    a2dp_audio_list_remove(list, lhdc_decoder_frame_p);
    node = a2dp_audio_list_begin(list);
  }
#if defined(A2DP_LHDC_LARC)
  TRACE_A2DP_DECODER_I("Put %d frames, drop %d frames", put_cnt, drop_cnt);
#endif

  ret = a2dp_cp_get_full_out_frame((void **)&out, &out_len);

  if (ret) {
    TRACE_A2DP_DECODER_I("%s %d cp find cache underflow", __func__, ret);
    TRACE_A2DP_DECODER_I("aud_list_len:%d. cp_get_in_frame:%d",
                         a2dp_audio_list_length(list), get_in_cp_frame_cnt());
    a2dp_cp_lhdc_after_cache_underflow();
    return A2DP_DECODER_CACHE_UNDERFLOW_ERROR;
  }

  if (out_len == 0) {
    memset(buffer, 0, buffer_bytes);
    a2dp_cp_consume_full_out_frame();
    TRACE_A2DP_DECODER_I("%s  olz!!!%d ", __func__, __LINE__);
    return A2DP_DECODER_NO_ERROR;
  }
  if (out_len != out_frame_len) {
    TRACE_A2DP_DECODER_I("%s: Bad out len %u (should be %u)", __func__, out_len,
                         out_frame_len);
    set_cp_reset_flag(true);
    return A2DP_DECODER_DECODE_ERROR;
  }
  p_out_info = (struct A2DP_CP_LHDC_OUT_FRM_INFO_T *)out;
  if (p_out_info->pcm_len) {
    a2dp_audio_lhdc_lastframe_info.sequenceNumber =
        p_out_info->in_info.sequenceNumber;
    a2dp_audio_lhdc_lastframe_info.timestamp = p_out_info->in_info.timestamp;
    a2dp_audio_lhdc_lastframe_info.curSubSequenceNumber =
        p_out_info->in_info.curSubSequenceNumber;
    a2dp_audio_lhdc_lastframe_info.totalSubSequenceNumber =
        p_out_info->in_info.totalSubSequenceNumber;
    a2dp_audio_lhdc_lastframe_info.frame_samples = p_out_info->frame_samples;
    a2dp_audio_lhdc_lastframe_info.decoded_frames += p_out_info->decoded_frames;
    a2dp_audio_lhdc_lastframe_info.undecode_frames =
        a2dp_audio_list_length(list) +
        a2dp_cp_get_in_frame_cnt_by_index(p_out_info->frame_idx) - 1;
    a2dp_audio_decoder_internal_lastframe_info_set(
        &a2dp_audio_lhdc_lastframe_info);

    TRACE_A2DP_DECODER_I(
        "lhdc_decoder seq:%d cursub:%d ttlsub:%d decoded:%d/%d",
        a2dp_audio_lhdc_lastframe_info.sequenceNumber,
        a2dp_audio_lhdc_lastframe_info.curSubSequenceNumber,
        a2dp_audio_lhdc_lastframe_info.totalSubSequenceNumber,
        a2dp_audio_lhdc_lastframe_info.decoded_frames,
        a2dp_audio_lhdc_lastframe_info.undecode_frames);
  }

  if (p_out_info->pcm_len == buffer_bytes) {
    memcpy(buffer, p_out_info + 1, p_out_info->pcm_len);
    dec_ret = A2DP_DECODER_NO_ERROR;
  } else {
    TRACE_A2DP_DECODER_I("%s  %d cp decoder error  !!!!!!", __func__, __LINE__);
    set_cp_reset_flag(true);
    return A2DP_DECODER_DECODE_ERROR;
  }

  ret = a2dp_cp_consume_full_out_frame();
  if (ret) {

    TRACE_A2DP_DECODER_I("%s: a2dp_cp_consume_full_out_frame() failed: ret=%d",
                         __func__, ret);
    set_cp_reset_flag(true);
    return A2DP_DECODER_DECODE_ERROR;
  }
  return dec_ret;
}

#ifdef __CP_EXCEPTION_TEST__
static bool _cp_assert = false;
int cp_assert(void) {
  _cp_assert = true;
  return 0;
}
#endif

#define LHDC_DECODED_FRAME_SIZE 1024

TEXT_LHDC_LOC
int a2dp_cp_lhdc_cp_decode(void) {
  int ret;
  enum CP_EMPTY_OUT_FRM_T out_frm_st;
  uint8_t *out;
  uint32_t out_len;
  uint8_t *dec_start;
  uint32_t dec_len;
  struct A2DP_CP_LHDC_IN_FRM_INFO_T *p_in_info;
  struct A2DP_CP_LHDC_OUT_FRM_INFO_T *p_out_info;
  uint8_t *in_buf;
  uint32_t in_len;

  int32_t dec_sum;
  uint32_t lhdc_out_len = 0;

#ifdef __CP_EXCEPTION_TEST__
  if (_cp_assert) {
    _cp_assert = false;
    *(int *)0 = 1;
    // ASSERT(0, "ASSERT  %s %d", __func__, __LINE__);
  }
#endif
  out_frm_st = a2dp_cp_get_emtpy_out_frame((void **)&out, &out_len);

  if (out_frm_st != CP_EMPTY_OUT_FRM_OK &&
      out_frm_st != CP_EMPTY_OUT_FRM_WORKING) {
    return out_frm_st;
  }
  ASSERT(out_len > sizeof(*p_out_info), "%s: Bad out_len %u (should > %u)",
         __func__, out_len, sizeof(*p_out_info));

  p_out_info = (struct A2DP_CP_LHDC_OUT_FRM_INFO_T *)out;
  if (out_frm_st == CP_EMPTY_OUT_FRM_OK) {
    p_out_info->pcm_len = 0;
    p_out_info->decoded_frames = 0;
  }

  ASSERT(out_len > sizeof(*p_out_info) + p_out_info->pcm_len,
         "%s: Bad out_len %u (should > %u + %u)", __func__, out_len,
         sizeof(*p_out_info), p_out_info->pcm_len);

  dec_start = (uint8_t *)(p_out_info + 1) + p_out_info->pcm_len;
  dec_len = out_len - (dec_start - (uint8_t *)out);

  dec_sum = 0;

  while (dec_sum < (int32_t)dec_len) {
    uint32_t lhdc_decode_temp = 0;

    ret = a2dp_cp_get_in_frame((void **)&in_buf, &in_len);

    if (ret) {
      TRACE_A2DP_DECODER_I("cp_get_int_frame fail, ret=%d", ret);
      return 4;
    }

    ASSERT(in_len > sizeof(*p_in_info), "%s: Bad in_len %u (should > %u)",
           __func__, in_len, sizeof(*p_in_info));

    p_in_info = (struct A2DP_CP_LHDC_IN_FRM_INFO_T *)in_buf;
    in_buf += sizeof(*p_in_info);
    in_len -= sizeof(*p_in_info);

#if defined(A2DP_LHDC_V3)
#if defined(A2DP_LHDC_LARC)
    if (in_len == 0x55 && larcIsEnabled()) {
      // TRACE_A2DP_DECODER_I("recover:sn(%d), tt(%d), csssn(%d), ttsssn(%d)",
      // p_in_info->sequenceNumber, p_in_info->timestamp,
      // p_in_info->curSubSequenceNumber, p_in_info->totalSubSequenceNumber);
      in_len = 0;
    }
#endif
    lhdcPutData(in_buf, in_len);
    // TRACE_A2DP_DECODER_I("%s:put length=%d, dec_len=%d", __func__, in_len,
    // dec_len);
#else
    lhdcPutData(in_buf, in_len);
#endif
    uint32_t loop_cnt = 0;
    do {
      // TRACE_A2DP_DECODER_I("loop %d , dec_start %p, dec_sum %d,
      // lhdc_decode_temp %d", loop_cnt, dec_start, dec_sum, lhdc_decode_temp);
      lhdc_out_len = lhdcDecodeProcess(dec_start + dec_sum + lhdc_decode_temp);
      if (lhdc_out_len > 0) {
        lhdc_decode_temp += lhdc_out_len;
        loop_cnt++;
      } else {
        // TRACE_A2DP_DECODER_I("decodeProcess error!!! ret=%d", lhdc_out_len);
        break;
      }
    } while (lhdc_decode_temp < dec_len && lhdc_decode_temp > 0);

    // TRACE_A2DP_DECODER_I("lhdc_cp_decode seq:%d len:%d err:%d",
    // p_in_info->sequenceNumber,
    //                                               dec_len - dec_sum,
    //                                               lhdc_out_len);

    // TRACE_A2DP_DECODER_I("%s:decode loop run times=%d, lhdc_decode_temp=%d",
    // __func__, loop_cnt, lhdc_decode_temp);
    dec_sum += lhdc_decode_temp;

    if ((lhdc_decode_temp % LHDC_DECODED_FRAME_SIZE)) {
      TRACE_A2DP_DECODER_I("error!!! dec_sum: %d decode_temp: %d", dec_sum,
                           lhdc_decode_temp);
      return -1;
    }

    ret = a2dp_cp_consume_in_frame();

    if (ret != 0) {
      TRACE_A2DP_DECODER_I("%s: a2dp_cp_consume_in_frame() failed: ret=%d",
                           __func__, ret);
    }
    ASSERT(ret == 0, "%s: a2dp_cp_consume_in_frame() failed: ret=%d", __func__,
           ret);

    memcpy(&p_out_info->in_info, p_in_info, sizeof(*p_in_info));
    p_out_info->decoded_frames++;
    p_out_info->frame_samples = A2DP_LHDC_OUTPUT_FRAME_SAMPLES;
    p_out_info->frame_idx = a2dp_cp_get_in_frame_index();
  }

  if ((dec_sum % LHDC_DECODED_FRAME_SIZE)) {
    TRACE_A2DP_DECODER_I("error!!! dec_sum:%d  != dec_len:%d", dec_sum,
                         dec_len);
    ASSERT(0, "%s", __func__);
  }

  p_out_info->pcm_len += dec_sum;

  if (out_len <= sizeof(*p_out_info) + p_out_info->pcm_len) {
    ret = a2dp_cp_consume_emtpy_out_frame();
    ASSERT(ret == 0, "%s: a2dp_cp_consume_emtpy_out_frame() failed: ret=%d",
           __func__, ret);
  }

  return 0;
}
#endif

#if 1
static int a2dp_audio_lhdc_list_checker(void) {
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
  list_node_t *node = NULL;
  a2dp_audio_lhdc_decoder_frame_t *lhdc_decoder_frame_p = NULL;
  int cnt = 0;

  do {
    lhdc_decoder_frame_p =
        (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_lhdc_frame_malloc(
            LHDC_READBUF_SIZE);
    if (lhdc_decoder_frame_p) {
      a2dp_audio_list_append(list, lhdc_decoder_frame_p);
    }
    cnt++;
  } while (lhdc_decoder_frame_p && cnt < LHDC_MTU_LIMITER);

  do {
    node = a2dp_audio_list_begin(list);
    if (node) {
      lhdc_decoder_frame_p =
          (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
      a2dp_audio_list_remove(list, lhdc_decoder_frame_p);
    }
  } while (node);

  TRACE_A2DP_DECODER_I("%s cnt:%d list:%d", __func__, cnt,
                       a2dp_audio_list_length(list));

  return 0;
}
#endif

int a2dp_audio_lhdc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes) {
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
  list_node_t *node = NULL;
  a2dp_audio_lhdc_decoder_frame_t *lhdc_decoder_frame_p = NULL;

  bool cache_underflow = false;
  int output_byte = 0;

  uint32_t lhdc_out_len = 0;

  node = a2dp_audio_list_begin(list);
  if (!node) {
    TRACE_A2DP_DECODER_I("lhdc_decode cache underflow");
    cache_underflow = true;
    goto exit;
  } else {
    lhdc_decoder_frame_p =
        (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
#if defined(A2DP_LHDC_V3)
    lhdcPutData(lhdc_decoder_frame_p->buffer, lhdc_decoder_frame_p->buffer_len);
#else
    lhdcPutData(lhdc_decoder_frame_p->buffer, lhdc_decoder_frame_p->buffer_len);
#endif
    do {
      lhdc_out_len = lhdcDecodeProcess(buffer + output_byte);
      if (lhdc_out_len > 0) {
        output_byte += lhdc_out_len;
      } else {
        break;
      }
    } while (output_byte < (int)buffer_bytes && output_byte > 0);

    if (output_byte != (int)buffer_bytes) {
      TRACE_A2DP_DECODER_I("[warning] lhdc_decode_frame output_byte:%d "
                           "lhdc_out_len:%d buffer_bytes:%d",
                           output_byte, lhdc_out_len, buffer_bytes);
      TRACE_A2DP_DECODER_I("[warning] lhdc_decode_frame frame_len:%d rtp "
                           "seq:%d timestamp:%d decoder_frame:%d/%d ",
                           lhdc_decoder_frame_p->buffer_len,
                           lhdc_decoder_frame_p->sequenceNumber,
                           lhdc_decoder_frame_p->timestamp,
                           lhdc_decoder_frame_p->curSubSequenceNumber,
                           lhdc_decoder_frame_p->totalSubSequenceNumber);
      output_byte = buffer_bytes;
      int32_t dump_byte = lhdc_decoder_frame_p->buffer_len;
      int32_t dump_offset = 0;
      while (1) {
        uint32_t dump_byte_output = 0;
        dump_byte_output = dump_byte > 32 ? 32 : dump_byte;
        DUMP8("%02x ", lhdc_decoder_frame_p->buffer + dump_offset,
              dump_byte_output);
        dump_offset += dump_byte_output;
        dump_byte -= dump_byte_output;
        if (dump_byte <= 0) {
          break;
        }
      }
      ASSERT(0, "%s", __func__);
    }

    a2dp_audio_lhdc_lastframe_info.sequenceNumber =
        lhdc_decoder_frame_p->sequenceNumber;
    a2dp_audio_lhdc_lastframe_info.timestamp = lhdc_decoder_frame_p->timestamp;
    a2dp_audio_lhdc_lastframe_info.curSubSequenceNumber =
        lhdc_decoder_frame_p->curSubSequenceNumber;
    a2dp_audio_lhdc_lastframe_info.totalSubSequenceNumber =
        lhdc_decoder_frame_p->totalSubSequenceNumber;
    a2dp_audio_lhdc_lastframe_info.frame_samples =
        A2DP_LHDC_OUTPUT_FRAME_SAMPLES;
    a2dp_audio_lhdc_lastframe_info.decoded_frames++;
    a2dp_audio_lhdc_lastframe_info.undecode_frames =
        a2dp_audio_list_length(list) - 1;
    a2dp_audio_decoder_internal_lastframe_info_set(
        &a2dp_audio_lhdc_lastframe_info);
    a2dp_audio_list_remove(list, lhdc_decoder_frame_p);
  }
exit:
  if (cache_underflow) {
    reset_lhdc_assmeble_packet();
    a2dp_audio_lhdc_lastframe_info.undecode_frames = 0;
    a2dp_audio_decoder_internal_lastframe_info_set(
        &a2dp_audio_lhdc_lastframe_info);
    output_byte = A2DP_DECODER_CACHE_UNDERFLOW_ERROR;
  }
  return output_byte;
}

int a2dp_audio_lhdc_decode_frame(uint8_t *buffer, uint32_t buffer_bytes) {
#ifdef A2DP_CP_ACCEL
  return a2dp_cp_lhdc_mcu_decode(buffer, buffer_bytes);
#else
  return a2dp_audio_lhdc_mcu_decode_frame(buffer, buffer_bytes);
#endif
}

int a2dp_audio_lhdc_preparse_packet(btif_media_header_t *header,
                                    uint8_t *buffer, uint32_t buffer_bytes) {
  a2dp_audio_lhdc_lastframe_info.sequenceNumber = header->sequenceNumber;
  a2dp_audio_lhdc_lastframe_info.timestamp = header->timestamp;
  a2dp_audio_lhdc_lastframe_info.curSubSequenceNumber = 0;
  a2dp_audio_lhdc_lastframe_info.totalSubSequenceNumber = 0;
  a2dp_audio_lhdc_lastframe_info.frame_samples = A2DP_LHDC_OUTPUT_FRAME_SAMPLES;
  a2dp_audio_lhdc_lastframe_info.list_samples = A2DP_LHDC_OUTPUT_FRAME_SAMPLES;
  a2dp_audio_lhdc_lastframe_info.decoded_frames = 0;
  a2dp_audio_lhdc_lastframe_info.undecode_frames = 0;
  a2dp_audio_decoder_internal_lastframe_info_set(
      &a2dp_audio_lhdc_lastframe_info);

  TRACE_A2DP_DECODER_I("%s seq:%d timestamp:%08x", __func__,
                       header->sequenceNumber, header->timestamp);

  return A2DP_DECODER_NO_ERROR;
}

void a2dp_audio_lhdc_free(void *packet) {
  a2dp_audio_lhdc_decoder_frame_t *decoder_frame_p =
      (a2dp_audio_lhdc_decoder_frame_t *)packet;
  a2dp_audio_heap_free(decoder_frame_p->buffer);
  a2dp_audio_heap_free(decoder_frame_p);
}

int a2dp_audio_lhdc_store_packet(btif_media_header_t *header, uint8_t *buffer,
                                 uint32_t buffer_bytes) {
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
  int nRet = A2DP_DECODER_NO_ERROR;
  uint32_t frame_num = 0;
  uint32_t frame_cnt = 0;
  uint32_t lSize = 0;
  uint8_t *lPTR = NULL;
  lhdc_frame_Info_t lhdc_frame_Info;
  uint32_t ptr_offset = 0;

  if ((frame_num = assemble_lhdc_packet(buffer, buffer_bytes, &lPTR, &lSize)) >
      0) {
    if (lPTR != NULL && lSize != 0) {
      ptr_offset = 0;
      // TRACE_A2DP_DECODER_I("%s: There are %d frames in packet", __func__,
      // frame_num);
      while (parse_lhdc_info(lPTR + ptr_offset, &lhdc_frame_Info) == 0 &&
             ptr_offset < lSize && frame_cnt < frame_num) {
        a2dp_audio_lhdc_decoder_frame_t *decoder_frame_p = NULL;
        if (!lhdc_frame_Info.frame_len) {
          DUMP8("%02x ", lPTR + ptr_offset, 32);
          ASSERT(0,
                 "lhdc_frame_Info error frame_len:%d offset:%d ptr:%08x/%08x",
                 lhdc_frame_Info.frame_len, ptr_offset, (uint32_t)buffer,
                 (uint32_t)lPTR);
        }
        ASSERT(lhdc_frame_Info.frame_len <= (lSize - ptr_offset),
               "%s frame_len:%d ptr_offset:%d buffer_bytes:%d", __func__,
               lhdc_frame_Info.frame_len, ptr_offset, lSize);
        uint32_t list_length = a2dp_audio_list_length(list);
        if (list_length < lhdc_mtu_limiter) {
          decoder_frame_p =
              (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_lhdc_frame_malloc(
                  lhdc_frame_Info.frame_len);
        } else {
          nRet = A2DP_DECODER_MTU_LIMTER_ERROR;
          break;
        }
        frame_cnt++;

        decoder_frame_p->sequenceNumber = header->sequenceNumber;
        decoder_frame_p->timestamp = header->timestamp;
        decoder_frame_p->curSubSequenceNumber = frame_cnt;
        decoder_frame_p->totalSubSequenceNumber = frame_num;
        memcpy(decoder_frame_p->buffer, lPTR + ptr_offset,
               lhdc_frame_Info.frame_len);
        decoder_frame_p->buffer_len = lhdc_frame_Info.frame_len;
        a2dp_audio_list_append(list, decoder_frame_p);

        ptr_offset += lhdc_frame_Info.frame_len;
#if 0
                TRACE_A2DP_DECODER_I("lhdc_store_packet save seq:%d timestamp:%d len:%d lSize:%d list_length:%d frame_len:%d Split:%d/%d",
                                                                                                             header->sequenceNumber,
                                                                                                             header->timestamp,
                                                                                                             buffer_bytes,
                                                                                                             lSize,
                                                                                                             list_length,
                                                                                                             lhdc_frame_Info.frame_len,
                                                                                                             lhdc_frame_Info.isSplit,
                                                                                                             lhdc_frame_Info.isLeft);
#endif
      }
    }
  } else {
    //        TRACE_A2DP_DECODER_I("lhdc_store_packet skip seq:%d timestamp:%d
    //        len:%d l:%d", header->sequenceNumber,
    //        header->timestamp,buffer_bytes, lSize);
  }

  return nRet;
}

int a2dp_audio_lhdc_discards_packet(uint32_t packets) {
#ifdef A2DP_CP_ACCEL
  a2dp_cp_reset_frame();
#endif

  int nRet = a2dp_audio_context_p->audio_decoder
                 .audio_decoder_synchronize_dest_packet_mut(
                     a2dp_audio_context_p->dest_packet_mut);

  reset_lhdc_assmeble_packet();

#if defined(A2DP_LHDC_LARC)
  lhdc_drop_frame = 0;
#endif
  return nRet;
}

static int a2dp_audio_lhdc_headframe_info_get(
    A2DP_AUDIO_HEADFRAME_INFO_T *headframe_info) {
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
  list_node_t *node = NULL;
  a2dp_audio_lhdc_decoder_frame_t *decoder_frame_p = NULL;

  if (a2dp_audio_list_length(list)) {
    node = a2dp_audio_list_begin(list);
    decoder_frame_p =
        (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
    headframe_info->sequenceNumber = decoder_frame_p->sequenceNumber;
    headframe_info->timestamp = decoder_frame_p->timestamp;
    headframe_info->curSubSequenceNumber = 0;
    headframe_info->totalSubSequenceNumber = 0;
  } else {
    memset(headframe_info, 0, sizeof(A2DP_AUDIO_HEADFRAME_INFO_T));
  }

  return A2DP_DECODER_NO_ERROR;
}

int a2dp_audio_lhdc_info_get(void *info) { return A2DP_DECODER_NO_ERROR; }

extern uint32_t __lhdc_license_start[];

int a2dp_audio_lhdc_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context) {
  TRACE_A2DP_DECODER_I("%s %s ch:%d freq:%d bits:%d", __func__,
                       getVersionCode(), config->num_channels,
                       config->sample_rate, config->bits_depth);

  uint8_t lhdc_license_key = 0;
  uint8_t *lhdc_license_data = (uint8_t *)__lhdc_license_start + 0x98;
  TRACE(5, "lhdc_license_data:%p, lhdc license %02x %02x %02x %02x",
        lhdc_license_data, lhdc_license_data[0], lhdc_license_data[1],
        lhdc_license_data[2], lhdc_license_data[3]);

  a2dp_audio_context_p = (A2DP_AUDIO_CONTEXT_T *)context;

  memset(&a2dp_audio_lhdc_lastframe_info, 0,
         sizeof(A2DP_AUDIO_DECODER_LASTFRAME_INFO_T));
  memcpy(&a2dp_audio_lhdc_output_config, config,
         sizeof(A2DP_AUDIO_OUTPUT_CONFIG_T));
  a2dp_audio_lhdc_lastframe_info.stream_info = a2dp_audio_lhdc_output_config;
  a2dp_audio_lhdc_lastframe_info.frame_samples = A2DP_LHDC_OUTPUT_FRAME_SAMPLES;
  a2dp_audio_lhdc_lastframe_info.list_samples = A2DP_LHDC_OUTPUT_FRAME_SAMPLES;
  a2dp_audio_decoder_internal_lastframe_info_set(
      &a2dp_audio_lhdc_lastframe_info);

  lhdc_license_key =
      lhdcSetLicenseKeyTable(lhdc_license_data, bes_bt_local_info_get);

  TRACE_A2DP_DECODER_I("lhdc_license_key:%d", lhdc_license_key);

#if defined(A2DP_LHDC_V3)
  lhdcInit(config->bits_depth, config->sample_rate, 0, VERSION_3);
#else
  lhdcInit(config->bits_depth, config->sample_rate, 0, VERSION_2);
#endif
  initial_lhdc_assemble_packet(false);

#ifdef A2DP_CP_ACCEL
  int ret;
  ret = a2dp_cp_init(a2dp_cp_lhdc_cp_decode, CP_PROC_DELAY_2_FRAMES);
  ASSERT(ret == 0, "%s: a2dp_cp_init() failed: ret=%d", __func__, ret);
#endif
  a2dp_audio_lhdc_list_checker();

#if defined(A2DP_LHDC_LARC)
  lhdc_last_time = 0;
  lhdc_drop_frame = 0;
#endif

  return A2DP_DECODER_NO_ERROR;
}

int a2dp_audio_lhdc_deinit(void) {
#ifdef A2DP_CP_ACCEL
  a2dp_cp_deinit();
#endif
  lhdcDestroy();
  return A2DP_DECODER_NO_ERROR;
}

int a2dp_audio_lhdc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info,
                                       uint32_t mask) {
  int nRet = A2DP_DECODER_SYNC_ERROR;
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
  list_node_t *node = NULL;
  int list_len;
  a2dp_audio_lhdc_decoder_frame_t *lhdc_decoder_frame;

#ifdef A2DP_CP_ACCEL
  a2dp_cp_reset_frame();
#endif

  list_len = a2dp_audio_list_length(list);

  for (uint16_t i = 0; i < list_len; i++) {
    node = a2dp_audio_list_begin(list);
    lhdc_decoder_frame =
        (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
    if (A2DP_AUDIO_SYNCFRAME_CHK(lhdc_decoder_frame->sequenceNumber ==
                                     sync_info->sequenceNumber,
                                 A2DP_AUDIO_SYNCFRAME_MASK_SEQ, mask) &&
        A2DP_AUDIO_SYNCFRAME_CHK(lhdc_decoder_frame->curSubSequenceNumber ==
                                     sync_info->curSubSequenceNumber,
                                 A2DP_AUDIO_SYNCFRAME_MASK_CURRSUBSEQ, mask) &&
        A2DP_AUDIO_SYNCFRAME_CHK(lhdc_decoder_frame->totalSubSequenceNumber ==
                                     sync_info->totalSubSequenceNumber,
                                 A2DP_AUDIO_SYNCFRAME_MASK_TOTALSUBSEQ, mask)) {
      nRet = A2DP_DECODER_NO_ERROR;
      break;
    }
    a2dp_audio_list_remove(list, lhdc_decoder_frame);
  }

  node = a2dp_audio_list_begin(list);
  if (node) {
    lhdc_decoder_frame =
        (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
    TRACE_A2DP_DECODER_I("%s nRet:%d SEQ:%d timestamp:%d %d/%d", __func__, nRet,
                         lhdc_decoder_frame->sequenceNumber,
                         lhdc_decoder_frame->timestamp,
                         lhdc_decoder_frame->curSubSequenceNumber,
                         lhdc_decoder_frame->totalSubSequenceNumber);
  } else {
    TRACE_A2DP_DECODER_I("%s nRet:%d", __func__, nRet);
  }

  return nRet;
}

int a2dp_audio_lhdc_synchronize_dest_packet_mut(uint16_t packet_mut) {
  list_node_t *node = NULL;
  uint32_t list_len = 0;
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
  a2dp_audio_lhdc_decoder_frame_t *lhdc_decoder_frame_p = NULL;

  list_len = a2dp_audio_list_length(list);
  if (list_len > packet_mut) {
    do {
      node = a2dp_audio_list_begin(list);
      lhdc_decoder_frame_p =
          (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
      a2dp_audio_list_remove(list, lhdc_decoder_frame_p);
    } while (a2dp_audio_list_length(list) > packet_mut);
  }

  TRACE_A2DP_DECODER_I("%s list:%d", __func__, a2dp_audio_list_length(list));
  return A2DP_DECODER_NO_ERROR;
}

int a2dp_audio_lhdc_convert_list_to_samples(uint32_t *samples) {
  uint32_t list_len = 0;
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;

  list_len = a2dp_audio_list_length(list);

  *samples = A2DP_LHDC_OUTPUT_FRAME_SAMPLES * list_len;

  TRACE_A2DP_DECODER_I("%s list:%d samples:%d", __func__, list_len, *samples);

  return A2DP_DECODER_NO_ERROR;
}

int a2dp_audio_lhdc_discards_samples(uint32_t samples) {
  int nRet = A2DP_DECODER_SYNC_ERROR;
  list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
  a2dp_audio_lhdc_decoder_frame_t *lhdc_decoder_frame_p = NULL;
  list_node_t *node = NULL;
  int need_remove_list = 0;
  uint32_t list_samples = 0;

  ASSERT(!(samples % A2DP_LHDC_OUTPUT_FRAME_SAMPLES), "%s samples err:%d",
         __func__, samples);

  a2dp_audio_lhdc_convert_list_to_samples(&list_samples);
  if (list_samples >= samples) {
    need_remove_list = samples / A2DP_LHDC_OUTPUT_FRAME_SAMPLES;
    for (int i = 0; i < need_remove_list; i++) {
      node = a2dp_audio_list_begin(list);
      lhdc_decoder_frame_p =
          (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
      a2dp_audio_list_remove(list, lhdc_decoder_frame_p);
    }
    nRet = A2DP_DECODER_NO_ERROR;

    node = a2dp_audio_list_begin(list);
    lhdc_decoder_frame_p =
        (a2dp_audio_lhdc_decoder_frame_t *)a2dp_audio_list_node(node);
    TRACE_A2DP_DECODER_I("%s discard %d sample cur seq:%d", __func__, samples,
                         lhdc_decoder_frame_p->sequenceNumber);
  }

  return nRet;
}

A2DP_AUDIO_DECODER_T a2dp_audio_lhdc_decoder_config = {
    {96000, 2, 24},
    1,
    a2dp_audio_lhdc_init,
    a2dp_audio_lhdc_deinit,
    a2dp_audio_lhdc_decode_frame,
    a2dp_audio_lhdc_preparse_packet,
    a2dp_audio_lhdc_store_packet,
    a2dp_audio_lhdc_discards_packet,
    a2dp_audio_lhdc_synchronize_packet,
    a2dp_audio_lhdc_synchronize_dest_packet_mut,
    a2dp_audio_lhdc_convert_list_to_samples,
    a2dp_audio_lhdc_discards_samples,
    a2dp_audio_lhdc_headframe_info_get,
    a2dp_audio_lhdc_info_get,
    a2dp_audio_lhdc_free,
};