/*************************************************************************** * * 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 "cmsis.h" #include "plat_types.h" #include #include "heap_api.h" #include "hal_location.h" #include "a2dp_decoder_internal.h" #include "btapp.h" #include"ldacBT.h" typedef struct { uint16_t sequenceNumber; uint32_t timestamp; uint32_t frame_samples; uint16_t curSubSequenceNumber; uint16_t totalSubSequenceNumber; uint8_t *buffer; uint32_t buffer_len; } a2dp_audio_ldac_decoder_frame_t; #ifndef LDAC_MTU_LIMITER #define LDAC_MTU_LIMITER (200) #endif #define DECODE_LDAC_PCM_FRAME_LENGTH (256*4*2*2) #define LDAC_LIST_SAMPLES (256) static A2DP_AUDIO_CONTEXT_T *a2dp_audio_context_p = NULL; static A2DP_AUDIO_DECODER_LASTFRAME_INFO_T a2dp_audio_ldac_lastframe_info; static uint16_t ldac_mtu_limiter = LDAC_MTU_LIMITER; //static btif_media_header_t ldac_header_parser_header_prev = {0,}; //static bool ldac_header_parser_ready = false; //static bool ldac_chnl_mode_mono = false; HANDLE_LDAC_BT LdacDecHandle = NULL; //static uint8_t *ldac_mempoll = NULL; heap_handle_t ldac_memhandle = NULL; static uint32_t l2cap_frame_samples = LDAC_LIST_SAMPLES; /* Convert LDAC Error Code to string */ #define CASE_RETURN_STR(const) case const: return #const; static const char * ldac_ErrCode2Str( int ErrCode ) { switch(ErrCode) { CASE_RETURN_STR(LDACBT_ERR_NONE); CASE_RETURN_STR(LDACBT_ERR_NON_FATAL); CASE_RETURN_STR(LDACBT_ERR_BIT_ALLOCATION); CASE_RETURN_STR(LDACBT_ERR_NOT_IMPLEMENTED); CASE_RETURN_STR(LDACBT_ERR_NON_FATAL_ENCODE); CASE_RETURN_STR(LDACBT_ERR_FATAL); CASE_RETURN_STR(LDACBT_ERR_SYNTAX_BAND); CASE_RETURN_STR(LDACBT_ERR_SYNTAX_GRAD_A); CASE_RETURN_STR(LDACBT_ERR_SYNTAX_GRAD_B); CASE_RETURN_STR(LDACBT_ERR_SYNTAX_GRAD_C); CASE_RETURN_STR(LDACBT_ERR_SYNTAX_GRAD_D); CASE_RETURN_STR(LDACBT_ERR_SYNTAX_GRAD_E); CASE_RETURN_STR(LDACBT_ERR_SYNTAX_IDSF); CASE_RETURN_STR(LDACBT_ERR_SYNTAX_SPEC); CASE_RETURN_STR(LDACBT_ERR_BIT_PACKING); CASE_RETURN_STR(LDACBT_ERR_ALLOC_MEMORY); CASE_RETURN_STR(LDACBT_ERR_FATAL_HANDLE); CASE_RETURN_STR(LDACBT_ERR_ILL_SYNCWORD); CASE_RETURN_STR(LDACBT_ERR_ILL_SMPL_FORMAT); CASE_RETURN_STR(LDACBT_ERR_ILL_PARAM); CASE_RETURN_STR(LDACBT_ERR_ASSERT_SAMPLING_FREQ); CASE_RETURN_STR(LDACBT_ERR_ASSERT_SUP_SAMPLING_FREQ); CASE_RETURN_STR(LDACBT_ERR_CHECK_SAMPLING_FREQ); CASE_RETURN_STR(LDACBT_ERR_ASSERT_CHANNEL_CONFIG); CASE_RETURN_STR(LDACBT_ERR_CHECK_CHANNEL_CONFIG); CASE_RETURN_STR(LDACBT_ERR_ASSERT_FRAME_LENGTH); CASE_RETURN_STR(LDACBT_ERR_ASSERT_SUP_FRAME_LENGTH); CASE_RETURN_STR(LDACBT_ERR_ASSERT_FRAME_STATUS); CASE_RETURN_STR(LDACBT_ERR_ASSERT_NSHIFT); CASE_RETURN_STR(LDACBT_ERR_ASSERT_CHANNEL_MODE); CASE_RETURN_STR(LDACBT_ERR_ENC_INIT_ALLOC); CASE_RETURN_STR(LDACBT_ERR_ENC_ILL_GRADMODE); CASE_RETURN_STR(LDACBT_ERR_ENC_ILL_GRADPAR_A); CASE_RETURN_STR(LDACBT_ERR_ENC_ILL_GRADPAR_B); CASE_RETURN_STR(LDACBT_ERR_ENC_ILL_GRADPAR_C); CASE_RETURN_STR(LDACBT_ERR_ENC_ILL_GRADPAR_D); CASE_RETURN_STR(LDACBT_ERR_ENC_ILL_NBANDS); CASE_RETURN_STR(LDACBT_ERR_PACK_BLOCK_FAILED); CASE_RETURN_STR(LDACBT_ERR_DEC_INIT_ALLOC); CASE_RETURN_STR(LDACBT_ERR_INPUT_BUFFER_SIZE); CASE_RETURN_STR(LDACBT_ERR_UNPACK_BLOCK_FAILED); CASE_RETURN_STR(LDACBT_ERR_UNPACK_BLOCK_ALIGN); CASE_RETURN_STR(LDACBT_ERR_UNPACK_FRAME_ALIGN); CASE_RETURN_STR(LDACBT_ERR_FRAME_LENGTH_OVER); CASE_RETURN_STR(LDACBT_ERR_FRAME_ALIGN_OVER); CASE_RETURN_STR(LDACBT_ERR_ALTER_EQMID_LIMITED); CASE_RETURN_STR(LDACBT_ERR_ILL_EQMID); CASE_RETURN_STR(LDACBT_ERR_ILL_SAMPLING_FREQ); CASE_RETURN_STR(LDACBT_ERR_ILL_NUM_CHANNEL); CASE_RETURN_STR(LDACBT_ERR_ILL_MTU_SIZE); CASE_RETURN_STR(LDACBT_ERR_HANDLE_NOT_INIT); default: return "unknown-error-code"; } } char a_ErrorCodeStr[128]; const char * get_error_code_string( int error_code ) { int errApi, errHdl, errBlk; errApi = LDACBT_API_ERR( error_code ); errHdl = LDACBT_HANDLE_ERR( error_code ); errBlk = LDACBT_BLOCK_ERR( error_code ); a_ErrorCodeStr[0] = '\0'; strcat( a_ErrorCodeStr, "API:" ); strcat( a_ErrorCodeStr, ldac_ErrCode2Str( errApi ) ); strcat( a_ErrorCodeStr, " Handle:" ); strcat( a_ErrorCodeStr, ldac_ErrCode2Str( errHdl ) ); strcat( a_ErrorCodeStr, " Block:" ); strcat( a_ErrorCodeStr, ldac_ErrCode2Str( errBlk ) ); return a_ErrorCodeStr; } #define LDAC_FRAME_LEN_INDEX_106 106 #define LDAC_FRAME_LEN_INDEX_128 128 #define LDAC_FRAME_LEN_INDEX_160 160 #define LDAC_FRAME_LEN_INDEX_216 216 #define LDAC_FRAME_LEN_INDEX_326 326 #define LDAC_FRAME_LEN_INDEX_161 161 static uint8_t get_ldac_frame_num_by_rawdata(uint8_t *buffer, uint32_t buffer_bytes) { uint32_t frame_len = 0; uint32_t frame_len_with_head = 0; uint16_t data1 = 0; uint16_t data2 = 0; uint8_t frame_cnt = 0; for(uint32_t i=0; i> 2 & 0xFFFF)); //TRACE("#frame len:%d",frame_len); //for ldac head frame_len_with_head = frame_len + 4; } return frame_cnt; } #define LDAC_READBUF_SIZE 1024 /* pick something big enough to hold a bunch of frames */ /** * Decode LDAC data... */ //#include "os_tcb.h" extern const char * get_error_code_string( int error_code ); #define DCODE_LDAC_PCM_FRAME_LENGTH 10224 *2 int check_ldac_header(uint8_t *buffer,uint32_t buff_len) { int channel_mode =0; int sample_rate=0; int ret=0; if(buff_len <2) ret=-1; sample_rate=bt_get_ladc_sample_rate(); channel_mode=bt_ldac_player_get_channelmode(); //TRACE(3,"%s,%d,%d",__func__,sample_rate,channel_mode); uint32_t i=0; unsigned char sync2 = 0; unsigned char cci = 0; switch(channel_mode) { case LDACBT_CHANNEL_MODE_MONO: cci = LDAC_CCI_MONO; break; case LDACBT_CHANNEL_MODE_DUAL_CHANNEL: cci = LDAC_CCI_DUAL_CHANNEL; break; case LDACBT_CHANNEL_MODE_STEREO: default: cci = LDAC_CCI_STEREO; break; } if(sample_rate == 1*44100) { sync2 = (0 << 5) | (cci << 3); } else if(sample_rate == 1*48000) { sync2 = (1 << 5) | (cci << 3); } else if(sample_rate == 2*44100) { sync2 = (2 << 5) | (cci << 3); } else if(sample_rate == 2*48000) { sync2 = (3 << 5) | (cci << 3); } else { TRACE(0,"sample rate not surpoort !"); ret=-2; return ret; } for(i=0; i=buff_len) { TRACE(0,"no find ldac header "); ret=-3; } return ret; } #ifdef A2DP_CP_ACCEL struct A2DP_CP_LDAC_IN_FRM_INFO_T { uint16_t sequenceNumber; uint32_t timestamp; uint16_t curSubSequenceNumber; uint16_t totalSubSequenceNumber; }; struct A2DP_CP_LDAC_OUT_FRM_INFO_T { struct A2DP_CP_LDAC_IN_FRM_INFO_T in_info; uint16_t frame_samples; uint16_t decoded_frames; uint16_t frame_idx; uint16_t pcm_len; }; 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_ldac_cp_decode(void); TEXT_LDAC_LOC static int a2dp_cp_ldac_after_cache_underflow(void) { TRACE(1,"%s", __func__); int ret = 0; a2dp_cp_deinit(); ret = a2dp_cp_init(a2dp_cp_ldac_cp_decode, CP_PROC_DELAY_2_FRAMES); ASSERT(ret == 0, "%s: a2dp_cp_init() failed: ret=%d", __func__, ret); return ret; } static int a2dp_cp_ldac_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes) { a2dp_audio_ldac_decoder_frame_t *ldac_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_LDAC_IN_FRM_INFO_T in_info; struct A2DP_CP_LDAC_OUT_FRM_INFO_T *p_out_info; uint8_t *out; uint32_t out_len; uint32_t out_frame_len; // uint8_t count=0; uint32_t cp_buffer_frames_max = 0; if((buffer_bytes < DECODE_LDAC_PCM_FRAME_LENGTH && (LDACBT_CHANNEL_MODE_MONO != bt_ldac_player_get_channelmode())) || (buffer_bytes < DECODE_LDAC_PCM_FRAME_LENGTH/2 && (LDACBT_CHANNEL_MODE_MONO == bt_ldac_player_get_channelmode()))) { TRACE(1,"ldac_decode pcm_len = %d \n", buffer_bytes); return A2DP_DECODER_NO_ERROR; } if(!LdacDecHandle) { TRACE(0,"ldac decode not ready"); return A2DP_DECODER_NO_ERROR; } cp_buffer_frames_max = app_bt_stream_get_dma_buffer_samples()/2; if (cp_buffer_frames_max %(a2dp_audio_ldac_lastframe_info.frame_samples) ) { cp_buffer_frames_max = cp_buffer_frames_max /(a2dp_audio_ldac_lastframe_info.frame_samples) +1 ; } else { cp_buffer_frames_max = cp_buffer_frames_max /(a2dp_audio_ldac_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(2,"%s: a2dp_cp_decoder_init() failed: ret=%d", __func__, ret); set_cp_reset_flag(true); return A2DP_DECODER_DECODE_ERROR; } while ((node = a2dp_audio_list_begin(list)) != NULL) { ldac_decoder_frame_p = (a2dp_audio_ldac_decoder_frame_t *)a2dp_audio_list_node(node); in_info.sequenceNumber = ldac_decoder_frame_p->sequenceNumber; in_info.timestamp = ldac_decoder_frame_p->timestamp; in_info.curSubSequenceNumber = ldac_decoder_frame_p->curSubSequenceNumber; in_info.totalSubSequenceNumber = ldac_decoder_frame_p->totalSubSequenceNumber; ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info), ldac_decoder_frame_p->buffer, ldac_decoder_frame_p->buffer_len); if (ret) { //TRACE(2,"%s piff !!!!!!ret: %d ",__func__, ret); break; } // count++; // TRACE(2,"%s count !!!!!!: %d ",__func__,count); //TRACE(3,"put seq:%d %d %d",in_info.sequenceNumber,in_info.curSubSequenceNumber,in_info.totalSubSequenceNumber); a2dp_audio_list_remove(list, ldac_decoder_frame_p); } ret = a2dp_cp_get_full_out_frame((void **)&out, &out_len); if (ret) { TRACE(0,"%s %d cp find cache underflow",__func__, __LINE__); TRACE(2,"aud_list_len:%d. cp_get_in_frame:%d", a2dp_audio_list_length(list), get_in_cp_frame_cnt()); a2dp_cp_ldac_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(1,"%s olz!!!",__func__); return A2DP_DECODER_NO_ERROR; } if (out_len != out_frame_len) { TRACE(3,"%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_LDAC_OUT_FRM_INFO_T *)out; if (p_out_info->pcm_len) { a2dp_audio_ldac_lastframe_info.sequenceNumber = p_out_info->in_info.sequenceNumber; a2dp_audio_ldac_lastframe_info.timestamp = p_out_info->in_info.timestamp; a2dp_audio_ldac_lastframe_info.curSubSequenceNumber = p_out_info->in_info.curSubSequenceNumber; a2dp_audio_ldac_lastframe_info.totalSubSequenceNumber = p_out_info->in_info.totalSubSequenceNumber; a2dp_audio_ldac_lastframe_info.frame_samples = p_out_info->frame_samples; a2dp_audio_ldac_lastframe_info.decoded_frames += p_out_info->decoded_frames; a2dp_audio_ldac_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_ldac_lastframe_info); } 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(2,"%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(2,"%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; } TEXT_LDAC_LOC int a2dp_cp_ldac_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_LDAC_IN_FRM_INFO_T *p_in_info; struct A2DP_CP_LDAC_OUT_FRM_INFO_T *p_out_info; uint8_t *in_buf; uint32_t in_len; int32_t dec_sum; int used_bytes=0; int wrote_bytes=0; 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_LDAC_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) { ret = a2dp_cp_get_in_frame((void **)&in_buf, &in_len); if (ret) { TRACE(1,"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_LDAC_IN_FRM_INFO_T *)in_buf; in_buf += sizeof(*p_in_info); in_len -= sizeof(*p_in_info); //TRACE(2,"decode:seq %d %d %d", p_in_info->sequenceNumber, p_in_info->curSubSequenceNumber,p_in_info->totalSubSequenceNumber); if(in_buf[0] != 0xaa) { TRACE(2,"decode:seq %d %d", p_in_info->sequenceNumber, p_in_info->curSubSequenceNumber); DUMP8("%x ",in_buf,30); } ret = ldacBT_decode(LdacDecHandle, in_buf, dec_start+dec_sum, LDACBT_SMPL_FMT_S16, in_len, &used_bytes, &wrote_bytes); //TRACE("%s wb:%d bb:%d pb:%d",__func__,wrote_bytes,dec_len,dec_sum); dec_sum += wrote_bytes; if(ret !=0) { TRACE(1,"ldac decode error %d",ret); TRACE(1,"LdacDecHandle error_code:%d",ldacBT_get_error_code(LdacDecHandle)); ret=A2DP_DECODER_DECODE_ERROR; return -1; } ret = a2dp_cp_consume_in_frame(); if (ret != 0) { TRACE(2,"%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 = 256; p_out_info->frame_idx = a2dp_cp_get_in_frame_index(); } if ( dec_sum != (int32_t)dec_len ) { TRACE(2,"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 int a2dp_audio_ldac_mcu_decode_frame(uint8_t *buffer,uint32_t buffer_bytes) { list_node_t *node=NULL; uint8_t *temp_buf_ptr1=NULL; uint8_t *temp_buf_ptr2=NULL; uint16_t pcm_output_bytes; uint32_t lock; a2dp_audio_ldac_decoder_frame_t *ldac_decoder_frame_p=NULL; int used_bytes=0; int wrote_bytes=0; bool cache_underflow=false; int output_count = 0; int result=0; if((buffer_bytes < DECODE_LDAC_PCM_FRAME_LENGTH && (LDACBT_CHANNEL_MODE_MONO != bt_ldac_player_get_channelmode())) || (buffer_bytes < DECODE_LDAC_PCM_FRAME_LENGTH/2 && (LDACBT_CHANNEL_MODE_MONO == bt_ldac_player_get_channelmode()))) { TRACE(1,"ldac_decode pcm_len = %d \n", buffer_bytes); return A2DP_DECODER_NO_ERROR; } if(!LdacDecHandle) { TRACE(0,"ldac decode not ready"); return A2DP_DECODER_NO_ERROR; } list_t *list=a2dp_audio_context_p->audio_datapath.input_raw_packet_list; //TRACE("jtx~~"); for(pcm_output_bytes=0; pcm_output_bytesbuffer; temp_buf_ptr2=buffer+wrote_bytes*output_count; if(temp_buf_ptr1[0] != 0xaa) { TRACE(2,"decode:seq %d %d",ldac_decoder_frame_p->sequenceNumber,ldac_decoder_frame_p->curSubSequenceNumber); DUMP8("%x ",temp_buf_ptr1,30); } lock = int_lock(); result = ldacBT_decode(LdacDecHandle,temp_buf_ptr1,temp_buf_ptr2, LDACBT_SMPL_FMT_S16, ldac_decoder_frame_p->buffer_len, &used_bytes, &wrote_bytes); output_count++; int_unlock(lock); // TRACE("%s wb:%d bb:%d pb:%d",__func__,wrote_bytes,buffer_bytes,pcm_output_bytes); // DUMP8("%x ",temp_buf_ptr2,10); if(result !=0) { output_count=0; TRACE(4,"%s wb:%d bb:%d pb:%d",__func__,wrote_bytes,buffer_bytes,pcm_output_bytes); TRACE(2,"decode:seq %d %d",ldac_decoder_frame_p->sequenceNumber,ldac_decoder_frame_p->curSubSequenceNumber); DUMP8("%x ",temp_buf_ptr1,10); TRACE(1,"ldac decode error %d",result); result=A2DP_DECODER_DECODE_ERROR; goto exit; } } a2dp_audio_ldac_lastframe_info.sequenceNumber=ldac_decoder_frame_p->sequenceNumber; a2dp_audio_ldac_lastframe_info.timestamp=ldac_decoder_frame_p->timestamp; a2dp_audio_ldac_lastframe_info.curSubSequenceNumber = ldac_decoder_frame_p->curSubSequenceNumber; a2dp_audio_ldac_lastframe_info.totalSubSequenceNumber = ldac_decoder_frame_p->totalSubSequenceNumber; a2dp_audio_ldac_lastframe_info.frame_samples =ldac_decoder_frame_p->frame_samples ; a2dp_audio_ldac_lastframe_info.decoded_frames++; a2dp_audio_ldac_lastframe_info.undecode_frames = a2dp_audio_list_length(list)-1; a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_ldac_lastframe_info); a2dp_audio_list_remove(list, ldac_decoder_frame_p); } exit: if(cache_underflow) { a2dp_audio_ldac_lastframe_info.undecode_frames = 0; a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_ldac_lastframe_info); result = A2DP_DECODER_CACHE_UNDERFLOW_ERROR; } return result; } int a2dp_audio_ldac_decode_frame(uint8_t *buffer, uint32_t buffer_bytes) { int ret = 0; if (bt_ldac_player_get_channelmode() == LDACBT_CHANNEL_MODE_MONO) { #ifdef A2DP_CP_ACCEL ret = a2dp_cp_ldac_mcu_decode(buffer, buffer_bytes / sizeof(int16_t)); #else ret = a2dp_audio_ldac_mcu_decode_frame(buffer, buffer_bytes / sizeof(int16_t)); #endif int16_t *out_int16 = (int16_t *)buffer; int16_t wrote_samples = buffer_bytes / sizeof(int16_t); for (int32_t i = wrote_samples - 1; i >= 0; i--) { out_int16[2 * i + 1] = out_int16[i]; out_int16[2 * i] = out_int16[i]; } }else #ifdef A2DP_CP_ACCEL ret = a2dp_cp_ldac_mcu_decode(buffer, buffer_bytes); #else ret = a2dp_audio_ldac_mcu_decode_frame(buffer, buffer_bytes); #endif return ret; } int a2dp_audio_ldac_preparse_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes) { a2dp_audio_ldac_lastframe_info.sequenceNumber = header->sequenceNumber; a2dp_audio_ldac_lastframe_info.timestamp = header->timestamp; a2dp_audio_ldac_lastframe_info.curSubSequenceNumber = 0; a2dp_audio_ldac_lastframe_info.totalSubSequenceNumber = 0; a2dp_audio_ldac_lastframe_info.frame_samples = LDAC_LIST_SAMPLES; a2dp_audio_ldac_lastframe_info.list_samples = LDAC_LIST_SAMPLES; a2dp_audio_ldac_lastframe_info.decoded_frames = 0; a2dp_audio_ldac_lastframe_info.undecode_frames = 0; a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_ldac_lastframe_info); TRACE(4,"%s seq:%d timestamp:%d frame samples:%d", __func__, header->sequenceNumber, header->timestamp, a2dp_audio_ldac_lastframe_info.frame_samples); return A2DP_DECODER_NO_ERROR; } static void *a2dp_audio_ldac_frame_malloc(uint32_t packet_len) { a2dp_audio_ldac_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_ldac_decoder_frame_t *)a2dp_audio_heap_malloc(sizeof(a2dp_audio_ldac_decoder_frame_t)); decoder_frame_p->buffer = buffer; decoder_frame_p->buffer_len = packet_len; return (void *)decoder_frame_p; } void a2dp_audio_ldac_free(void *packet) { a2dp_audio_ldac_decoder_frame_t *decoder_frame_p = (a2dp_audio_ldac_decoder_frame_t *)packet; a2dp_audio_heap_free(decoder_frame_p->buffer); a2dp_audio_heap_free(decoder_frame_p); } int a2dp_audio_ldac_header_parser(btif_media_header_t *header,uint32_t frame_num) { return 0; } int a2dp_audio_ldac_store_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes) { int nRet = A2DP_DECODER_NOT_SUPPORT; int check_header_status=0; uint32_t frame_cnt = 0; uint32_t frame_num = 0; uint32_t frame_len = 0; uint32_t frame_len_with_head = 0; uint16_t data1 = 0; uint16_t data2 = 0; buffer++; buffer_bytes--; list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list; // TRACE("buffer:%x %x %x %x %x %x %x",buffer[0],buffer[1],buffer[2],buffer[3],buffer[4],buffer[5],buffer[6]); //TRACE(1,"buffer:%x",buffer[2]); data1 = (uint16_t)(buffer[1]&0x07); data2 = (uint16_t)buffer[2]; frame_len = ((data1<< 6 &0xFFFF) | (data2 >> 2 & 0xFFFF)); //TRACE("#frame len:%d",frame_len); frame_num = get_ldac_frame_num_by_rawdata(buffer, buffer_bytes); if ((a2dp_audio_list_length(list)+frame_num) < ldac_mtu_limiter) { for(uint32_t i=0; i> 2 & 0xFFFF)); //TRACE("#frame len:%d",frame_len); // frame_num = get_ldac_frame_num(frame_len); // if (!frame_num) // { // TRACE(1,"ERROR LDAC FRAME !!! frame_num:%d", frame_num); // DUMP8("%02x ", buffer, 4); // return A2DP_DECODER_DECODE_ERROR; // } //for ldac head frame_len_with_head =frame_len+4; //TRACE(2,"frame len:%d num:%d %d",frame_len,frame_num,a2dp_audio_list_length(list)); l2cap_frame_samples=256*frame_num; //TRACE("i %d buffer bytes:%d",i,buffer_bytes); check_header_status=check_ldac_header(buffer+i,frame_len_with_head); if(!check_header_status) { a2dp_audio_ldac_decoder_frame_t *ldac_decoder_frame_p=(a2dp_audio_ldac_decoder_frame_t *)a2dp_audio_ldac_frame_malloc(frame_len_with_head); ldac_decoder_frame_p->sequenceNumber=header->sequenceNumber; ldac_decoder_frame_p->curSubSequenceNumber=frame_cnt; ldac_decoder_frame_p->totalSubSequenceNumber=frame_num; ldac_decoder_frame_p->timestamp=header->timestamp; ldac_decoder_frame_p->buffer_len=frame_len_with_head; ldac_decoder_frame_p->frame_samples=256; memcpy(ldac_decoder_frame_p->buffer,buffer+i,frame_len_with_head); //TRACE(5,"seq:%d len:%d i:%d buffer bytes:%d data:%x",header->sequenceNumber, frame_len,i,buffer_bytes,ldac_decoder_frame_p->buffer[0]); //TRACE(5,"store seq:%d %d %d",header->sequenceNumber,ldac_decoder_frame_p->curSubSequenceNumber,ldac_decoder_frame_p->totalSubSequenceNumber); a2dp_audio_list_append(list, ldac_decoder_frame_p); } else { TRACE(1,"ERROR LDAC FRAME ret:%d",check_header_status); DUMP8("%02x ",buffer+i, 6); break; } nRet = A2DP_DECODER_NO_ERROR; } } else { #if 0 a2dp_audio_ldac_decoder_frame_t *ldac_decoder_frame_p = NULL; do { ldac_decoder_frame_p = (a2dp_audio_ldac_decoder_frame_t *)a2dp_audio_list_back(list); TRACE(3,"remov seq:%d %d %d",ldac_decoder_frame_p->sequenceNumber,ldac_decoder_frame_p->curSubSequenceNumber,ldac_decoder_frame_p->totalSubSequenceNumber); a2dp_audio_list_remove(list, ldac_decoder_frame_p); } while(ldac_decoder_frame_p->curSubSequenceNumber!=0); #endif TRACE(3,"%s list full current list_len step1:%d buff_len:%d", __func__, a2dp_audio_list_length(list), buffer_bytes); nRet = A2DP_DECODER_MTU_LIMTER_ERROR; } return nRet; } int a2dp_audio_ldac_discards_packet(uint32_t packets) { int nRet = A2DP_DECODER_MEMORY_ERROR; list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list; list_node_t *node = NULL; a2dp_audio_ldac_decoder_frame_t *ldac_decoder_frame_p = NULL; #ifdef A2DP_CP_ACCEL a2dp_cp_reset_frame(); #endif if (packets <= a2dp_audio_list_length(list)) { for (uint8_t i=0; iaudio_datapath.input_raw_packet_list; list_node_t *node = NULL; a2dp_audio_ldac_decoder_frame_t *ldac_decoder_frame_p = NULL; int cnt = 0; do { //TRACE(1,"cnt:%d",cnt); ldac_decoder_frame_p = (a2dp_audio_ldac_decoder_frame_t *)a2dp_audio_ldac_frame_malloc(216+4); if (ldac_decoder_frame_p) { a2dp_audio_list_append(list, ldac_decoder_frame_p); } cnt++; } while(ldac_decoder_frame_p && cnt < LDAC_MTU_LIMITER); do { node = a2dp_audio_list_begin(list); if (node) { ldac_decoder_frame_p = (a2dp_audio_ldac_decoder_frame_t *)a2dp_audio_list_node(node); a2dp_audio_list_remove(list, ldac_decoder_frame_p); } } while(node); TRACE(3,"%s cnt:%d list:%d", __func__, cnt, a2dp_audio_list_length(list)); return 0; } int a2dp_audio_ldac_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context) { TRACE(1,"%s", __func__); a2dp_audio_context_p = (A2DP_AUDIO_CONTEXT_T *)context; memset(&a2dp_audio_ldac_lastframe_info, 0, sizeof(A2DP_AUDIO_DECODER_LASTFRAME_INFO_T)); a2dp_audio_ldac_lastframe_info.stream_info = *config; a2dp_audio_ldac_lastframe_info.frame_samples= 256; a2dp_audio_ldac_lastframe_info.list_samples = 256; a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_ldac_lastframe_info); ASSERT(a2dp_audio_context_p->dest_packet_mut < LDAC_MTU_LIMITER, "%s MTU OVERFLOW:%u/%u", __func__, a2dp_audio_context_p->dest_packet_mut, LDAC_MTU_LIMITER); #ifdef A2DP_CP_ACCEL int ret; ret = a2dp_cp_init(a2dp_cp_ldac_cp_decode, CP_PROC_DELAY_2_FRAMES); ASSERT(ret == 0, "%s: a2dp_cp_init() failed: ret=%d", __func__, ret); #endif a2dp_audio_ldac_decoder_init(); a2dp_audio_ldac_list_checker(); return A2DP_DECODER_NO_ERROR; } int a2dp_audio_ldac_deinit(void) { #ifdef A2DP_CP_ACCEL a2dp_cp_deinit(); #endif a2dp_audio_ldac_decoder_deinit(); return A2DP_DECODER_NO_ERROR; } int a2dp_audio_ldac_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_ldac_decoder_frame_t *ldac_decoder_frame_p = NULL; list_len = a2dp_audio_list_length(list); for (uint16_t i=0; isequenceNumber == sync_info->sequenceNumber, A2DP_AUDIO_SYNCFRAME_MASK_SEQ, mask)&& // A2DP_AUDIO_SYNCFRAME_CHK(ldac_decoder_frame_p->timestamp == sync_info->timestamp, A2DP_AUDIO_SYNCFRAME_MASK_TIMESTAMP, mask)) if(A2DP_AUDIO_SYNCFRAME_CHK(ldac_decoder_frame_p->sequenceNumber == sync_info->sequenceNumber, A2DP_AUDIO_SYNCFRAME_MASK_SEQ, mask)&& A2DP_AUDIO_SYNCFRAME_CHK(ldac_decoder_frame_p->curSubSequenceNumber == sync_info->curSubSequenceNumber, A2DP_AUDIO_SYNCFRAME_MASK_CURRSUBSEQ, mask)&& A2DP_AUDIO_SYNCFRAME_CHK(ldac_decoder_frame_p->totalSubSequenceNumber == sync_info->totalSubSequenceNumber,A2DP_AUDIO_SYNCFRAME_MASK_TOTALSUBSEQ,mask)) { nRet = A2DP_DECODER_NO_ERROR; break; } a2dp_audio_list_remove(list, ldac_decoder_frame_p); } node = a2dp_audio_list_begin(list); if (node) { ldac_decoder_frame_p = (a2dp_audio_ldac_decoder_frame_t *)a2dp_audio_list_node(node); TRACE(4,"%s nRet:%d SEQ:%d timestamp:%d", __func__, nRet, ldac_decoder_frame_p->sequenceNumber, ldac_decoder_frame_p->timestamp); } else { TRACE(2,"%s nRet:%d", __func__, nRet); // TRACE(5,"nRet:%d SEQ:%d timestamp:%d sync %d/%d", nRet, ldac_decoder_frame_p->sequenceNumber, ldac_decoder_frame_p->timestamp,sync_info->sequenceNumber,sync_info->timestamp); } return nRet; } int a2dp_audio_ldac_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_ldac_decoder_frame_t *ldac_decoder_frame_p = NULL; list_len = a2dp_audio_list_length(list); if (list_len > packet_mut) { do { node = a2dp_audio_list_begin(list); ldac_decoder_frame_p = (a2dp_audio_ldac_decoder_frame_t *)a2dp_audio_list_node(node); a2dp_audio_list_remove(list, ldac_decoder_frame_p); } while(a2dp_audio_list_length(list) > packet_mut); } TRACE(2,"%s list:%d", __func__, a2dp_audio_list_length(list)); return A2DP_DECODER_NO_ERROR; } static int a2dp_audio_ldac_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_ldac_decoder_frame_t *decoder_frame_p = NULL; if (a2dp_audio_list_length(list)) { node = a2dp_audio_list_begin(list); decoder_frame_p = (a2dp_audio_ldac_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 = decoder_frame_p->curSubSequenceNumber; headframe_info->totalSubSequenceNumber = decoder_frame_p->totalSubSequenceNumber; } else { memset(headframe_info, 0, sizeof(A2DP_AUDIO_HEADFRAME_INFO_T)); } return A2DP_DECODER_NO_ERROR; } int a2dp_audio_ldac_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 = LDAC_LIST_SAMPLES*list_len; TRACE(3, "%s list:%d samples:%d", __func__, list_len, *samples); return A2DP_DECODER_NO_ERROR; } int a2dp_audio_ldac_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_ldac_decoder_frame_t *ldac_decoder_frame = NULL; list_node_t *node = NULL; int need_remove_list = 0; uint32_t list_samples = 0; ASSERT(!(samples%LDAC_LIST_SAMPLES), "%s samples err:%d", __func__, samples); a2dp_audio_ldac_convert_list_to_samples(&list_samples); if (list_samples >= samples) { need_remove_list = samples/LDAC_LIST_SAMPLES; for (int i=0; isequenceNumber,ldac_decoder_frame->curSubSequenceNumber,ldac_decoder_frame->totalSubSequenceNumber); a2dp_audio_list_remove(list, ldac_decoder_frame); } nRet = A2DP_DECODER_NO_ERROR; } return nRet; } A2DP_AUDIO_DECODER_T a2dp_audio_ldac_decoder_config = { {96000, 2, 16}, 0, a2dp_audio_ldac_init, a2dp_audio_ldac_deinit, a2dp_audio_ldac_decode_frame, a2dp_audio_ldac_preparse_packet, a2dp_audio_ldac_store_packet, a2dp_audio_ldac_discards_packet, a2dp_audio_ldac_synchronize_packet, a2dp_audio_ldac_synchronize_dest_packet_mut, a2dp_audio_ldac_convert_list_to_samples, a2dp_audio_ldac_discards_samples, a2dp_audio_ldac_headframe_info_get, a2dp_audio_ldac_info_get, a2dp_audio_ldac_free, };