1221 lines
40 KiB
C++
1221 lines
40 KiB
C++
/***************************************************************************
|
||
*
|
||
* 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,
|
||
};
|