/*************************************************************************** * * 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.h" #include "a2dp_decoder_internal.h" #include "app_audio.h" #include "app_bt.h" #include "app_bt_media_manager.h" #include "audioflinger.h" #include "avdtp_api.h" #include "bt_drv_reg_op.h" #include "cmsis.h" #include "cmsis_os.h" #include "codec_sbc.h" #include "hal_location.h" #include "hal_timer.h" #include "heap_api.h" #include "plat_types.h" #include #if defined(IBRT) #include "app_ibrt_if.h" #include "app_tws_ctrl_thread.h" #include "app_tws_ibrt_audio_analysis.h" #include "app_tws_ibrt_audio_sync.h" #include "app_tws_ibrt_cmd_handler.h" #include "bt_drv_interface.h" #include "btapp.h" #endif #include "audio_prompt_sbc.h" #include "crc32.h" #ifndef A2DP_AUDIO_MEMPOOL_SIZE #if defined(A2DP_LDAC_ON) #define A2DP_AUDIO_LDAC_MEMPOOL_SIZE (76 * 1024) #endif #define A2DP_AUDIO_MEMPOOL_SIZE (72 * 1024) #endif #define A2DP_AUDIO_WAIT_TIMEOUT_MS (500) #define A2DP_AUDIO_MUTE_FRAME_CNT_AFTER_NO_CACHE (25) #define A2DP_AUDIO_SKIP_FRAME_LIMIT_AFTER_NO_CACHE (50) #define A2DP_AUDIO_REFILL_AFTER_NO_CACHE (1) #ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__ #define A2DP_AUDIO_SYNC_INTERVAL (25) #else #define A2DP_AUDIO_SYNC_INTERVAL (1000) #endif #define A2DP_AUDIO_LATENCY_LOW_FACTOR (1.0f) #define A2DP_AUDIO_LATENCY_HIGH_FACTOR (1.6f) #define A2DP_AUDIO_LATENCY_MORE_FACTOR (1.2f) #define A2DP_AUDIO_SYNC_FACTOR_REFERENCE (1.0f) #define A2DP_AUDIO_SYNC_FACTOR_FAST_LIMIT (0.00015f) #define A2DP_AUDIO_SYNC_FACTOR_SLOW_LIMIT (-0.00035f) #define A2DP_AUDIO_SYNC_FACTOR_NEED_FAST_CACHE (-0.001f) #define A2DP_AUDIO_UNDERFLOW_CAUSE_AUDIO_RETRIGGER (1) extern A2DP_AUDIO_DECODER_T a2dp_audio_sbc_decoder_config; #if defined(A2DP_AAC_ON) extern A2DP_AUDIO_DECODER_T a2dp_audio_aac_lc_decoder_config; #endif #if defined(A2DP_LHDC_ON) extern A2DP_AUDIO_DECODER_T a2dp_audio_lhdc_decoder_config; #endif #if defined(A2DP_LDAC_ON) extern A2DP_AUDIO_DECODER_T a2dp_audio_ldac_decoder_config; #endif #if defined(A2DP_SCALABLE_ON) extern A2DP_AUDIO_DECODER_T a2dp_audio_scalable_decoder_config; #endif osSemaphoreDef(audio_buffer_semaphore); osMutexDef(audio_buffer_mutex); osMutexDef(audio_status_mutex); osMutexDef(audio_stop_mutex); #ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__ //#define A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT (1) #define A2DP_AUDIO_SYNC_FIX_DIFF_INTERVAL (640) #define A2DP_AUDIO_SYNC_FIX_DIFF_FAST_LIMIT (0.003f) #define A2DP_AUDIO_SYNC_FIX_DIFF_SLOW_LIMIT (-0.003f) extern uint32_t app_bt_stream_get_dma_buffer_samples(void); static int a2dp_audio_sync_fix_diff_proc(uint32_t tick); static int a2dp_audio_sync_fix_diff_stop(uint32_t tick); static int32_t a2dp_audio_sync_fix_diff_reset(void); static int32_t a2dp_audio_sync_fix_diff_start(uint32_t tick); typedef enum { A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_IDLE, A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_START, A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_STOP, } A2DP_AUDIO_SYNC_FIX_DIFF_STATUS; typedef struct { int32_t tick; A2DP_AUDIO_SYNC_FIX_DIFF_STATUS status; } A2DP_AUDIO_SYNC_FIX_DIFF_T; static A2DP_AUDIO_SYNC_FIX_DIFF_T a2dp_audio_sync_fix_diff; #endif A2DP_AUDIO_CONTEXT_T a2dp_audio_context; static heap_handle_t a2dp_audio_heap; static A2DP_AUDIO_LASTFRAME_INFO_T a2dp_audio_lastframe_info; static A2DP_AUDIO_DETECT_NEXT_PACKET_CALLBACK a2dp_audio_detect_next_packet_callback = NULL; static A2DP_AUDIO_DETECT_NEXT_PACKET_CALLBACK a2dp_audio_store_packet_callback = NULL; static float a2dp_audio_latency_factor = A2DP_AUDIO_LATENCY_LOW_FACTOR; static float sync_tune_dest_ratio = 1.0f; static uint32_t store_packet_history_loctime = 0; static uint32_t check_sum_seed = 0; static int a2dp_audio_internal_lastframe_info_ptr_get( A2DP_AUDIO_LASTFRAME_INFO_T **lastframe_info); float a2dp_audio_get_sample_reference(void); int8_t a2dp_audio_get_current_buf_size(void); void a2dp_audio_heap_init(void *begin_addr, uint32_t size) { a2dp_audio_heap = heap_register(begin_addr, size); } void *a2dp_audio_heap_malloc(uint32_t size) { void *ptr = heap_malloc(a2dp_audio_heap, size); ASSERT_A2DP_DECODER(ptr, "%s size:%d", __func__, size); return ptr; } void *a2dp_audio_heap_cmalloc(uint32_t size) { void *ptr = heap_malloc(a2dp_audio_heap, size); ASSERT_A2DP_DECODER(ptr, "%s size:%d", __func__, size); memset(ptr, 0, size); return ptr; } void *a2dp_audio_heap_realloc(void *rmem, uint32_t newsize) { void *ptr = heap_realloc(a2dp_audio_heap, rmem, newsize); ASSERT_A2DP_DECODER(ptr, "%s rmem:%p size:%d", __func__, rmem, newsize); return ptr; } void a2dp_audio_heap_free(void *rmem) { ASSERT_A2DP_DECODER(rmem, "%s rmem:%p", __func__, rmem); heap_free(a2dp_audio_heap, rmem); } void a2dp_audio_heap_info(size_t *total, size_t *used, size_t *max_used) { multi_heap_info_t info; heap_get_info(a2dp_audio_heap, &info); if (total != NULL) *total = info.total_bytes; if (used != NULL) *used = info.total_allocated_bytes; if (max_used != NULL) *max_used = info.total_bytes - info.minimum_free_bytes; } int inline a2dp_audio_semaphore_init(void) { if (a2dp_audio_context.audio_semaphore.semaphore == NULL) { a2dp_audio_context.audio_semaphore.semaphore = osSemaphoreCreate(osSemaphore(audio_buffer_semaphore), 0); } a2dp_audio_context.audio_semaphore.enalbe = false; return 0; } int inline a2dp_audio_buffer_mutex_init(void) { if (a2dp_audio_context.audio_buffer_mutex == NULL) { a2dp_audio_context.audio_buffer_mutex = osMutexCreate((osMutex(audio_buffer_mutex))); } return 0; } int inline a2dp_audio_buffer_mutex_lock(void) { osMutexWait((osMutexId)a2dp_audio_context.audio_buffer_mutex, osWaitForever); return 0; } int inline a2dp_audio_buffer_mutex_unlock(void) { osMutexRelease((osMutexId)a2dp_audio_context.audio_buffer_mutex); return 0; } int inline a2dp_audio_status_mutex_init(void) { if (a2dp_audio_context.audio_status_mutex == NULL) { a2dp_audio_context.audio_status_mutex = osMutexCreate((osMutex(audio_status_mutex))); } return 0; } int inline a2dp_audio_status_mutex_lock(void) { osMutexWait((osMutexId)a2dp_audio_context.audio_status_mutex, osWaitForever); return 0; } int inline a2dp_audio_status_mutex_unlock(void) { osMutexRelease((osMutexId)a2dp_audio_context.audio_status_mutex); return 0; } int inline a2dp_audio_semaphore_wait(uint32_t timeout_ms) { osSemaphoreId semaphore_id = (osSemaphoreId)a2dp_audio_context.audio_semaphore.semaphore; a2dp_audio_buffer_mutex_lock(); a2dp_audio_context.audio_semaphore.enalbe = true; a2dp_audio_buffer_mutex_unlock(); int32_t nRet = osSemaphoreWait(semaphore_id, timeout_ms); if ((0 == nRet) || (-1 == nRet)) { TRACE_A2DP_DECODER_W("%s wait timerout", __func__); return -1; } return 0; } int inline a2dp_audio_semaphore_release(void) { bool enalbe = false; a2dp_audio_buffer_mutex_lock(); if (a2dp_audio_context.audio_semaphore.enalbe) { a2dp_audio_context.audio_semaphore.enalbe = false; enalbe = true; } a2dp_audio_buffer_mutex_unlock(); if (enalbe) { osSemaphoreId semaphore_id = (osSemaphoreId)a2dp_audio_context.audio_semaphore.semaphore; osSemaphoreRelease(semaphore_id); } return 0; } list_node_t *a2dp_audio_list_begin(const list_t *list) { a2dp_audio_buffer_mutex_lock(); list_node_t *node = list_begin(list); a2dp_audio_buffer_mutex_unlock(); return node; } list_node_t *a2dp_audio_list_end(const list_t *list) { a2dp_audio_buffer_mutex_lock(); list_node_t *node = list_end(list); a2dp_audio_buffer_mutex_unlock(); return node; } uint32_t a2dp_audio_list_length(const list_t *list) { a2dp_audio_buffer_mutex_lock(); uint32_t length = list_length(list); a2dp_audio_buffer_mutex_unlock(); return length; } void *a2dp_audio_list_node(const list_node_t *node) { a2dp_audio_buffer_mutex_lock(); void *data = list_node(node); a2dp_audio_buffer_mutex_unlock(); return data; } list_node_t *a2dp_audio_list_next(const list_node_t *node) { a2dp_audio_buffer_mutex_lock(); list_node_t *next = list_next(node); a2dp_audio_buffer_mutex_unlock(); return next; } bool a2dp_audio_list_remove(list_t *list, void *data) { a2dp_audio_buffer_mutex_lock(); bool nRet = list_remove(list, data); a2dp_audio_buffer_mutex_unlock(); return nRet; } bool a2dp_audio_list_append(list_t *list, void *data) { a2dp_audio_buffer_mutex_lock(); bool nRet = list_append(list, data); a2dp_audio_buffer_mutex_unlock(); return nRet; } void a2dp_audio_list_clear(list_t *list) { a2dp_audio_buffer_mutex_lock(); list_clear(list); a2dp_audio_buffer_mutex_unlock(); } void a2dp_audio_list_free(list_t *list) { a2dp_audio_buffer_mutex_lock(); list_free(list); a2dp_audio_buffer_mutex_unlock(); } list_t *a2dp_audio_list_new(list_free_cb callback, list_mempool_zmalloc zmalloc, list_mempool_free free) { a2dp_audio_buffer_mutex_lock(); list_t *list = list_new(callback, zmalloc, free); a2dp_audio_buffer_mutex_unlock(); return list; } uint32_t a2dp_audio_get_passed(uint32_t curr_ticks, uint32_t prev_ticks, uint32_t max_ticks) { if (curr_ticks < prev_ticks) return ((max_ticks - prev_ticks + 1) + curr_ticks); else return (curr_ticks - prev_ticks); } #ifdef A2DP_CP_ACCEL extern "C" uint32_t get_in_cp_frame_cnt(void); extern "C" uint32_t get_in_cp_frame_delay(void); #else static uint32_t get_in_cp_frame_cnt(void) { return 0; } static uint32_t get_in_cp_frame_delay(void) { return 0; } #endif int inline a2dp_audio_set_status( enum A2DP_AUDIO_DECODER_STATUS decoder_status) { a2dp_audio_status_mutex_lock(); a2dp_audio_context.audio_decoder_status = decoder_status; a2dp_audio_status_mutex_unlock(); return 0; } enum A2DP_AUDIO_DECODER_STATUS inline a2dp_audio_get_status(void) { enum A2DP_AUDIO_DECODER_STATUS decoder_status; a2dp_audio_status_mutex_lock(); decoder_status = a2dp_audio_context.audio_decoder_status; a2dp_audio_status_mutex_unlock(); return decoder_status; } int inline a2dp_audio_set_store_packet_status( enum A2DP_AUDIO_DECODER_STORE_PACKET_STATUS store_packet_status) { a2dp_audio_status_mutex_lock(); a2dp_audio_context.store_packet_status = store_packet_status; a2dp_audio_status_mutex_unlock(); return 0; } enum A2DP_AUDIO_DECODER_STORE_PACKET_STATUS inline a2dp_audio_get_store_packet_status( void) { enum A2DP_AUDIO_DECODER_STORE_PACKET_STATUS store_packet_status; a2dp_audio_status_mutex_lock(); store_packet_status = a2dp_audio_context.store_packet_status; a2dp_audio_status_mutex_unlock(); return store_packet_status; } int inline a2dp_audio_set_playback_status( enum A2DP_AUDIO_DECODER_PLAYBACK_STATUS playback_status) { a2dp_audio_status_mutex_lock(); a2dp_audio_context.playback_status = playback_status; a2dp_audio_status_mutex_unlock(); return 0; } enum A2DP_AUDIO_DECODER_PLAYBACK_STATUS inline a2dp_audio_get_playback_status( void) { enum A2DP_AUDIO_DECODER_PLAYBACK_STATUS playback_status; a2dp_audio_status_mutex_lock(); playback_status = a2dp_audio_context.playback_status; a2dp_audio_status_mutex_unlock(); return playback_status; } static void a2dp_decoder_info_checker(void) { // app_bt_start_custom_function_in_app_thread(0, 0, // (uint32_t)bt_drv_reg_op_bt_info_checker); } int a2dp_audio_sync_pid_config(void) { A2DP_AUDIO_SYNC_T *audio_sync = &a2dp_audio_context.audio_sync; A2DP_AUDIO_SYNC_PID_T *pid = &audio_sync->pid; pid->proportiongain = 0.4f; pid->integralgain = 0.1f; pid->derivativegain = 0.6f; return 0; } int a2dp_audio_sync_reset_data(void) { A2DP_AUDIO_SYNC_T *audio_sync = &a2dp_audio_context.audio_sync; a2dp_audio_status_mutex_lock(); audio_sync->tick = 0; audio_sync->cnt = 0; a2dp_audio_sync_pid_config(); #ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__ a2dp_audio_sync_fix_diff_reset(); #endif a2dp_audio_status_mutex_unlock(); TRACE_A2DP_DECODER_I("[SYNC]reset_data"); return 0; } int a2dp_audio_sync_init(double ratio) { #ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__ a2dp_audio_sync_fix_diff_reset(); #endif a2dp_audio_sync_reset_data(); a2dp_audio_sync_tune_sample_rate(ratio); sync_tune_dest_ratio = (float)ratio; return 0; } int a2dp_audio_sync_tune_sample_rate(double ratio) { float resample_rate_ratio; bool need_tune = false; a2dp_audio_status_mutex_lock(); if (a2dp_audio_context.output_cfg.factor_reference != (float)ratio) { a2dp_audio_context.output_cfg.factor_reference = (float)ratio; resample_rate_ratio = (float)(ratio - (double)1.0); need_tune = true; } // a2dp_audio_status_mutex_unlock(); if (need_tune) { app_audio_manager_tune_samplerate_ratio(AUD_STREAM_PLAYBACK, resample_rate_ratio); TRACE_A2DP_DECODER_I("[SYNC] ppb:%d ratio:%08d", (int32_t)(resample_rate_ratio * 10000000), (int32_t)(ratio * 10000000)); } a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_sync_direct_tune_sample_rate(double ratio) { float resample_rate_ratio; bool need_tune = false; a2dp_audio_status_mutex_lock(); if (a2dp_audio_context.output_cfg.factor_reference != (float)ratio) { a2dp_audio_context.output_cfg.factor_reference = (float)ratio; resample_rate_ratio = (float)(ratio - (double)1.0); need_tune = true; } if (need_tune) { af_codec_direct_tune(AUD_STREAM_PLAYBACK, resample_rate_ratio); TRACE_A2DP_DECODER_I("[SYNC] ppb:%d ratio:%08d", (int32_t)(resample_rate_ratio * 10000000), (int32_t)(ratio * 10000000)); } a2dp_audio_status_mutex_unlock(); return 0; } bool a2dp_audio_sync_tune_onprocess(void) { bool nRet = false; ; if (a2dp_audio_context.output_cfg.factor_reference != sync_tune_dest_ratio) { nRet = true; } return nRet; } int a2dp_audio_sync_tune(float ratio) { int nRet = 0; if (sync_tune_dest_ratio == ratio) { goto exit; } sync_tune_dest_ratio = ratio; #if defined(IBRT) if (app_ibrt_ui_is_profile_exchanged()) { if (app_tws_ibrt_mobile_link_connected()) { APP_TWS_IBRT_AUDIO_SYNC_TUNE_T sync_tune; sync_tune.factor_reference = ratio; if (!app_tws_ibrt_audio_sync_tune_need_skip()) { tws_ctrl_send_cmd(APP_TWS_CMD_SYNC_TUNE, (uint8_t *)&sync_tune, sizeof(APP_TWS_IBRT_AUDIO_SYNC_TUNE_T)); } else { a2dp_audio_sync_tune_cancel(); nRet = -1; } } } else { a2dp_audio_sync_tune_sample_rate(ratio); } #else a2dp_audio_sync_tune_sample_rate(ratio); #endif exit: return nRet; } int a2dp_audio_sync_tune_cancel(void) { sync_tune_dest_ratio = a2dp_audio_context.output_cfg.factor_reference; return 0; } float a2dp_audio_sync_pid_calc(A2DP_AUDIO_SYNC_PID_T *pid, float diff) { float increment; float pError, dError, iError; pid->error[0] = diff; pError = pid->error[0] - pid->error[1]; iError = pid->error[0]; dError = pid->error[0] - 2 * pid->error[1] + pid->error[2]; increment = pid->proportiongain * pError + pid->integralgain * iError + pid->derivativegain * dError; pid->error[2] = pid->error[1]; pid->error[1] = pid->error[0]; pid->result += increment; return pid->result; } #ifdef __A2DP_AUDIO_SYNC_FIX_DIFF_NOPID__ static int a2dp_audio_sync_fix_diff_proc(uint32_t tick) { if (a2dp_audio_sync_fix_diff.status == A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_START) { if (a2dp_audio_sync_fix_diff.tick > 0) { a2dp_audio_sync_fix_diff.tick--; } else { a2dp_audio_sync_fix_diff_stop(0); } } return 0; } static int32_t a2dp_audio_sync_fix_diff_start(uint32_t tick) { TRACE_A2DP_DECODER_I("[SYNC] fix diff start"); a2dp_audio_sync_fix_diff.status = A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_START; a2dp_audio_sync_fix_diff.tick = tick; return 0; } static int a2dp_audio_sync_fix_diff_stop(uint32_t tick) { TRACE_A2DP_DECODER_I("[SYNC] fix diff stop"); a2dp_audio_sync_fix_diff.status = A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_STOP; a2dp_audio_sync_fix_diff.tick = 0; return 0; } static int32_t a2dp_audio_sync_fix_diff_reset(void) { TRACE_A2DP_DECODER_I("[SYNC] fix diff reset"); a2dp_audio_sync_fix_diff.status = A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_IDLE; a2dp_audio_sync_fix_diff.tick = 0; return 0; } static A2DP_AUDIO_SYNC_FIX_DIFF_STATUS a2dp_audio_sync_fix_diff_status_get(void) { return a2dp_audio_sync_fix_diff.status; } int a2dp_audio_sync_handler(uint8_t *buffer, uint32_t buffer_bytes) { A2DP_AUDIO_LASTFRAME_INFO_T *lastframe_info = NULL; A2DP_AUDIO_SYNC_T *audio_sync = &a2dp_audio_context.audio_sync; float diff_mtu = 0; bool need_tune = false; bool force_slow = false; #if defined(IBRT) if (!app_tws_ibrt_mobile_link_connected()) { return -1; } #endif if (a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info) < 0) { return -1; } a2dp_audio_sync_fix_diff_proc(audio_sync->tick); if (a2dp_audio_sync_fix_diff_status_get() == A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_STOP) { #if defined(IBRT) if (!app_tws_ibrt_audio_sync_tune_onprocess() && !a2dp_audio_sync_tune_onprocess() #else if (!a2dp_audio_sync_tune_onprocess() #endif ) { int sync_tune_result = 0; if (a2dp_audio_context.output_cfg.factor_reference != a2dp_audio_context.init_factor_reference) { sync_tune_result = a2dp_audio_sync_tune(a2dp_audio_context.init_factor_reference); } if (!sync_tune_result) { a2dp_audio_sync_fix_diff_reset(); #ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT TRACE_A2DP_DECODER_I("[SYNC] tune ratio normal %f mut:%5.3f->%d", (double)a2dp_audio_context.init_factor_reference, (double)a2dp_audio_context.average_packet_mut, a2dp_audio_context.dest_packet_mut); #else TRACE_A2DP_DECODER_I( "[SYNC] tune ratio normal %d mut:%d->%d", (int32_t)(a2dp_audio_context.init_factor_reference * 10000000), (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f), a2dp_audio_context.dest_packet_mut); #endif } else { TRACE_A2DP_DECODER_I("[SYNC] tune ratio normal busy"); } } else { #ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT TRACE_A2DP_DECODER_I("[SYNC] tune ratio busy %f mut:%5.3f->%d", (double)a2dp_audio_context.init_factor_reference, (double)a2dp_audio_context.average_packet_mut, a2dp_audio_context.dest_packet_mut); #else TRACE_A2DP_DECODER_I( "[SYNC] tune ratio busy %d mut:%d->%d", (int32_t)(a2dp_audio_context.init_factor_reference * 10000000), (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f), a2dp_audio_context.dest_packet_mut); #endif } goto exit; } if (audio_sync->tick % A2DP_AUDIO_SYNC_INTERVAL == 0) { diff_mtu = a2dp_audio_context.average_packet_mut - (float)a2dp_audio_context.dest_packet_mut; if (ABS(diff_mtu) < 0.6f) { #ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT TRACE_A2DP_DECODER_I("[SYNC] skip mut:%5.3f", (double)diff_mtu); #else TRACE_A2DP_DECODER_I("[SYNC] skip mut:0.%d", (int32_t)(diff_mtu * 10)); #endif goto exit; } else if (diff_mtu / a2dp_audio_context.dest_packet_mut < -0.2f) { float curr_ratio = a2dp_audio_context.output_cfg.factor_reference; float ref_ratio = a2dp_audio_context.init_factor_reference; if (curr_ratio != (ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_SLOW_LIMIT)) { #ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT TRACE_A2DP_DECODER_I("[SYNC] force slow mut:%5.3f", (double)diff_mtu); #else TRACE_A2DP_DECODER_I("[SYNC] force slow mut:0.%d", (int32_t)(diff_mtu * 10)); #endif force_slow = true; } } if (a2dp_audio_sync_fix_diff_status_get() == A2DP_AUDIO_SYNC_FIX_DIFF_STATUS_IDLE || force_slow) { uint32_t dma_buffer_samples, samples, dma_interval; double ratio = 1.0, limit_ratio = 1.0; float sampleRate, ref_ratio, curr_ratio; float ref_us = 0; float dest_us = 0; float sample_us = 0; dma_buffer_samples = app_bt_stream_get_dma_buffer_samples() / 2; dma_interval = A2DP_AUDIO_SYNC_FIX_DIFF_INTERVAL; ref_ratio = a2dp_audio_context.init_factor_reference; curr_ratio = a2dp_audio_context.output_cfg.factor_reference; samples = dma_interval * dma_buffer_samples; sampleRate = lastframe_info->stream_info.sample_rate * ref_ratio; sample_us = 1e6 / sampleRate; ref_us = sample_us * (float)samples; dest_us = sample_us * (float)(lastframe_info->frame_samples * diff_mtu); ratio = ref_us / (ref_us - dest_us) * curr_ratio; if (ratio > (double)(ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_FAST_LIMIT)) { limit_ratio = ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_FAST_LIMIT; } else if (ratio < double(ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_SLOW_LIMIT)) { limit_ratio = ref_ratio + A2DP_AUDIO_SYNC_FIX_DIFF_SLOW_LIMIT; } else { limit_ratio = ratio; } TRACE_A2DP_DECODER_I( "[SYNC] sampleRate:%d ref_ratio:%d samples:%d %d->%d", (int32_t)sampleRate, (int32_t)(ref_ratio * 10000000), samples, (int32_t)ref_us, (int32_t)dest_us); need_tune = true; #if defined(IBRT) if (!app_tws_ibrt_audio_sync_tune_onprocess() && !a2dp_audio_sync_tune_onprocess() && #else if (!a2dp_audio_sync_tune_onprocess() && #endif need_tune) { if (!a2dp_audio_sync_tune((float)limit_ratio)) { a2dp_audio_sync_fix_diff_start(dma_interval); #ifdef A2DP_AUDIO_SYNC_FIX_DIFF_INTERVA_PRINT_FLOAT TRACE_A2DP_DECODER_I("[SYNC] tune ratio %f mut:%5.3f->%d", limit_ratio, (double)a2dp_audio_context.average_packet_mut, a2dp_audio_context.dest_packet_mut); #else TRACE_A2DP_DECODER_I( "[SYNC] tune ratio %d mut:%d->%d", (int32_t)(limit_ratio * 10000000), (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f), a2dp_audio_context.dest_packet_mut); #endif } else { TRACE_A2DP_DECODER_I("[SYNC] tune ratio busy"); } } } else { TRACE_A2DP_DECODER_I( "[SYNC] avg_mut:%d dest_mtu:%d", (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f), a2dp_audio_context.dest_packet_mut); } } else { } exit: audio_sync->tick++; return 0; } #else int a2dp_audio_sync_handler(uint8_t *buffer, uint32_t buffer_bytes) { A2DP_AUDIO_LASTFRAME_INFO_T *lastframe_info = NULL; A2DP_AUDIO_SYNC_T *audio_sync = &a2dp_audio_context.audio_sync; float dest_pid_result = .0f; float diff_mtu = 0; int32_t frame_mtu = 0; int32_t total_mtu = 0; float diff_factor = 0; #if defined(IBRT) if (!app_tws_ibrt_mobile_link_connected()) { return -1; } #endif if (a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info) < 0) { return -1; } if (audio_sync->tick++ % A2DP_AUDIO_SYNC_INTERVAL == 0) { list_t *list = a2dp_audio_context.audio_datapath.input_raw_packet_list; A2DP_AUDIO_SYNC_PID_T *pid = &audio_sync->pid; // valid limter 0x80000 if (audio_sync->cnt < 0x80000) { audio_sync->cnt += A2DP_AUDIO_SYNC_INTERVAL; } frame_mtu = lastframe_info->stream_info.frame_samples / lastframe_info->frame_samples; total_mtu = audio_sync->cnt * frame_mtu; diff_mtu = a2dp_audio_context.average_packet_mut - (float)a2dp_audio_context.dest_packet_mut; #if 1 TRACE_A2DP_DECODER_I( "[SYNC] sample:%d/%d diff:%d/%d/%d/%d curr:%d", lastframe_info->frame_samples, lastframe_info->stream_info.frame_samples, (int32_t)(diff_mtu + 0.5f), (int32_t)(a2dp_audio_context.average_packet_mut + 0.5f), a2dp_audio_context.dest_packet_mut, total_mtu, a2dp_audio_list_length(list) + get_in_cp_frame_cnt()); #else TRACE_A2DP_DECODER_I( "[SYNC] diff:%10.9f/%10.9f frame_mut:%d dest:%d total:%d curr:%d", (double)diff_mtu, (double)a2dp_audio_context.average_packet_mut, frame_mtu, a2dp_audio_context.dest_packet_mut, total_mtu, a2dp_audio_list_length(list)); TRACE_A2DP_DECODER_I("[SYNC] try tune:%d, %10.9f %10.9f", diff_mtu != 0.f && audio_sync->tick != 1 ? ABS(diff_mtu) > ((float)frame_mtu * 0.2f) : 0, (double)ABS(diff_mtu), (double)((float)frame_mtu * 0.2f)); #endif // TRACE(2,"audio_sync tune %d/%d tick", // app_tws_ibrt_audio_sync_tune_onprocess(), // a2dp_audio_sync_tune_onprocess(), audio_sync->tick); #if defined(IBRT) if ((!app_tws_ibrt_audio_sync_tune_onprocess() && !a2dp_audio_sync_tune_onprocess()) && #else if (!a2dp_audio_sync_tune_onprocess() && #endif diff_mtu != 0.f && audio_sync->tick != 1 && ((ABS(diff_mtu) > ((float)frame_mtu * 0.25f) && diff_mtu > 0) || (ABS(diff_mtu) > ((float)frame_mtu * 0.1f) && diff_mtu < 0))) { diff_factor = diff_mtu / a2dp_audio_context.average_packet_mut; if (a2dp_audio_sync_pid_calc(pid, diff_factor)) { dest_pid_result = a2dp_audio_context.output_cfg.factor_reference + pid->result; if (dest_pid_result > (A2DP_AUDIO_SYNC_FACTOR_REFERENCE + A2DP_AUDIO_SYNC_FACTOR_FAST_LIMIT)) { dest_pid_result = A2DP_AUDIO_SYNC_FACTOR_REFERENCE + A2DP_AUDIO_SYNC_FACTOR_FAST_LIMIT; } else if (dest_pid_result < (A2DP_AUDIO_SYNC_FACTOR_REFERENCE + A2DP_AUDIO_SYNC_FACTOR_SLOW_LIMIT)) { dest_pid_result = A2DP_AUDIO_SYNC_FACTOR_REFERENCE + A2DP_AUDIO_SYNC_FACTOR_SLOW_LIMIT; } if (a2dp_audio_context.output_cfg.factor_reference != dest_pid_result) { if (!a2dp_audio_sync_tune(dest_pid_result)) { audio_sync->cnt = 0; } TRACE_A2DP_DECODER_I( "[SYNC] tune diff_factor:%10.9f pid:%10.9f tune:%10.9f", (double)diff_factor, (double)pid->result, (double)dest_pid_result); } else { TRACE_A2DP_DECODER_I("[SYNC] tune skip same"); } } } else { /* TRACE_A2DP_DECODER_I("[SYNC] tune busy skip proc:%d/%d mtu:%d tick:%d >0:%d <0:%d tick:%d", app_tws_ibrt_audio_sync_tune_onprocess(), a2dp_audio_sync_tune_onprocess(), diff_mtu != 0.f, audio_sync->tick != 1, (ABS(diff_mtu) > ((float)frame_mtu * 0.25f) && diff_mtu > 0), (ABS(diff_mtu) > ((float)frame_mtu * 0.1f) && diff_mtu < 0), audio_sync->tick); */ } } else { bool need_tune = false; if (lastframe_info->undecode_min_frames * 10 <= a2dp_audio_context.dest_packet_mut * 10 / 3) { dest_pid_result = a2dp_audio_context.init_factor_reference + A2DP_AUDIO_SYNC_FACTOR_NEED_FAST_CACHE; need_tune = true; } else if (lastframe_info->undecode_min_frames * 10 <= a2dp_audio_context.dest_packet_mut * 20 / 3) { dest_pid_result = a2dp_audio_context.init_factor_reference + A2DP_AUDIO_SYNC_FACTOR_SLOW_LIMIT; need_tune = true; } #if defined(IBRT) if (!app_tws_ibrt_audio_sync_tune_onprocess() && !a2dp_audio_sync_tune_onprocess() && #else if (!a2dp_audio_sync_tune_onprocess() && #endif need_tune) { if (a2dp_audio_context.output_cfg.factor_reference != dest_pid_result) { a2dp_audio_sync_reset_data(); a2dp_audio_sync_tune(dest_pid_result); TRACE_A2DP_DECODER_I("[SYNC] tune ratio force slow %d/%d->%d", lastframe_info->undecode_min_frames, lastframe_info->undecode_max_frames, a2dp_audio_context.dest_packet_mut); } } } return 0; } #endif #if A2DP_DECODER_HISTORY_SEQ_SAVE static int a2dp_audio_reset_history_seq(void) { a2dp_audio_status_mutex_lock(); for (uint8_t i = 0; i < A2DP_DECODER_HISTORY_SEQ_SAVE; i++) { a2dp_audio_context.historySeq[i] = 0; #ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE a2dp_audio_context.historyLoctime[i] = 0; #endif #ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE a2dp_audio_context.historyChecksum[i] = 0; #endif } a2dp_audio_context.historySeq_idx = 0; a2dp_audio_status_mutex_unlock(); return 0; } static int a2dp_audio_save_history_seq(btif_media_header_t *header, unsigned char *buf, unsigned int len) { uint16_t historySeqPre = 0; uint8_t historySeq_idx = 0; a2dp_audio_status_mutex_lock(); historySeq_idx = a2dp_audio_context.historySeq_idx; if (historySeq_idx) { historySeq_idx = (historySeq_idx - 1) % A2DP_DECODER_HISTORY_SEQ_SAVE; historySeqPre = a2dp_audio_context.historySeq[historySeq_idx]; if ((header->sequenceNumber - historySeqPre) != 1) { TRACE_A2DP_DECODER_W("[INPUT] SEQ ERR %d/%d", historySeqPre, header->sequenceNumber); a2dp_audio_show_history_seq(); } } historySeq_idx = a2dp_audio_context.historySeq_idx % A2DP_DECODER_HISTORY_SEQ_SAVE; a2dp_audio_context.historySeq[historySeq_idx] = header->sequenceNumber; #ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE a2dp_audio_context.historyLoctime[historySeq_idx] = hal_fast_sys_timer_get(); #endif #ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE a2dp_audio_context.historyChecksum[historySeq_idx] = crc32(0, buf, len); #endif a2dp_audio_context.historySeq_idx++; a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_show_history_seq(void) { uint8_t i = 0, j = 1; uint16_t reordHistorySeq[A2DP_DECODER_HISTORY_SEQ_SAVE]; #ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE int32_t diff_max_idx = 0; int32_t diff_max_ms = 0; int64_t diff_avg_ms = 0; int32_t diff_avg_cnt = 0; uint32_t historyLoctime[A2DP_DECODER_HISTORY_SEQ_SAVE]; #endif #ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE uint32_t historyChecksum[A2DP_DECODER_HISTORY_SEQ_SAVE]; #endif a2dp_audio_status_mutex_lock(); for (i = 0; i < A2DP_DECODER_HISTORY_SEQ_SAVE; i++) { reordHistorySeq[i] = a2dp_audio_context.historySeq[i]; #ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE historyLoctime[i] = a2dp_audio_context.historyLoctime[i]; #endif #ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE historyChecksum[i] = a2dp_audio_context.historyChecksum[i]; #endif } for (i = 0; i < A2DP_DECODER_HISTORY_SEQ_SAVE - 1; i++) { for (j = 0; j < A2DP_DECODER_HISTORY_SEQ_SAVE - 1 - i; j++) { if (reordHistorySeq[j] > reordHistorySeq[j + 1]) { uint16_t temp_seq = reordHistorySeq[j]; reordHistorySeq[j] = reordHistorySeq[j + 1]; reordHistorySeq[j + 1] = temp_seq; #ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE uint32_t temp_Loctime = historyLoctime[j]; historyLoctime[j] = historyLoctime[j + 1]; historyLoctime[j + 1] = temp_Loctime; #endif #ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE uint32_t temp_Checksum = historyChecksum[j]; historyChecksum[j] = historyChecksum[j + 1]; historyChecksum[j + 1] = temp_Checksum; #endif } } } #ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE for (i = 0, j = 1; i < A2DP_DECODER_HISTORY_SEQ_SAVE - 1; i++, j++) { int32_t tmp_ms = historyLoctime[j] - historyLoctime[i]; diff_avg_ms += tmp_ms; diff_avg_cnt++; if (tmp_ms > diff_max_ms) { diff_max_ms = tmp_ms; diff_max_idx = i; } if (tmp_ms > (int32_t)MS_TO_FAST_TICKS(50)) { TRACE_A2DP_DECODER_I("[INPUT] > 30ms seq:%d diff:%d :%d / %d", reordHistorySeq[i], FAST_TICKS_TO_MS(tmp_ms), historyLoctime[i], historyLoctime[j]); } } diff_avg_ms /= diff_avg_cnt; TRACE_A2DP_DECODER_I("[INPUT] max_diff:%dms idx:%d avg:%dus", FAST_TICKS_TO_MS(diff_max_ms), diff_max_idx, FAST_TICKS_TO_US(diff_avg_ms)); #endif // DUMP16("%d ", reordHistorySeq, A2DP_DECODER_HISTORY_SEQ_SAVE); #ifdef A2DP_DECODER_HISTORY_LOCTIME_SAVE DUMP32("%x ", historyLoctime, A2DP_DECODER_HISTORY_SEQ_SAVE); #endif #ifdef A2DP_DECODER_HISTORY_CHECK_SUM_SAVE DUMP32("%x ", historyChecksum, A2DP_DECODER_HISTORY_SEQ_SAVE); #endif a2dp_audio_status_mutex_unlock(); return 0; } #endif /* 1, 2^1 3, 2^2 7, 2^3 15, 2^4 31, 2^5 */ #define AUDIO_ALPHA_PRAMS_1 (3) #define AUDIO_ALPHA_PRAMS_2 (4) static inline float a2dp_audio_alpha_filter(float y, float x) { if (y) { y = ((AUDIO_ALPHA_PRAMS_1 * y) + x) / AUDIO_ALPHA_PRAMS_2; } else { y = x; } return y; } static void inline a2dp_audio_convert_16bit_to_24bit(int32_t *out, int16_t *in, int len) { for (int i = len - 1; i >= 0; i--) { out[i] = ((int32_t)in[i] << 8); } } static void inline a2dp_audio_channel_select( A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel, uint8_t *buffer, uint32_t buffer_bytes) { uint32_t samples; uint32_t i; ASSERT_A2DP_DECODER(a2dp_audio_context.output_cfg.num_channels == 2, "%s num_channels:%d", __func__, a2dp_audio_context.output_cfg.num_channels); if (a2dp_audio_context.output_cfg.bits_depth == 24) { int32_t *buf_l_p = (int32_t *)buffer; int32_t *buf_r_p = (int32_t *)buffer + 1; samples = buffer_bytes / 4 / 2; switch (chnl_sel) { case A2DP_AUDIO_CHANNEL_SELECT_LRMERGE: for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) { int32_t tmp_sample = (*buf_l_p + *buf_r_p) >> 1; *buf_l_p = tmp_sample; *buf_r_p = tmp_sample; } break; case A2DP_AUDIO_CHANNEL_SELECT_LCHNL: for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) { *buf_r_p = *buf_l_p; } break; case A2DP_AUDIO_CHANNEL_SELECT_RCHNL: for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) { *buf_l_p = *buf_r_p; } break; case A2DP_AUDIO_CHANNEL_SELECT_STEREO: default: break; } } else { int16_t *buf_l_p = (int16_t *)buffer; int16_t *buf_r_p = (int16_t *)buffer + 1; samples = buffer_bytes / 2 / 2; switch (chnl_sel) { case A2DP_AUDIO_CHANNEL_SELECT_LRMERGE: for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) { int16_t tmp_sample = ((int32_t)*buf_l_p + (int32_t)*buf_r_p) >> 1; *buf_l_p = tmp_sample; *buf_r_p = tmp_sample; } break; case A2DP_AUDIO_CHANNEL_SELECT_LCHNL: for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) { *buf_r_p = *buf_l_p; } break; case A2DP_AUDIO_CHANNEL_SELECT_RCHNL: for (i = 0; i < samples; i++, buf_l_p += 2, buf_r_p += 2) { *buf_l_p = *buf_r_p; } break; case A2DP_AUDIO_CHANNEL_SELECT_STEREO: default: break; } } } #ifdef A2DP_CP_ACCEL extern "C" bool is_cp_need_reset(void); extern uint32_t app_bt_stream_get_dma_buffer_samples(void); static uint32_t get_cp_frame_mtus(A2DP_AUDIO_LASTFRAME_INFO_T *info) { uint32_t cp_frame_mtus = app_bt_stream_get_dma_buffer_samples() / 2; if (cp_frame_mtus % (info->frame_samples)) { cp_frame_mtus = cp_frame_mtus / (info->frame_samples) + 1; } else { cp_frame_mtus = cp_frame_mtus / (info->frame_samples); } TRACE_A2DP_DECODER_I("[CP] cp_frame_mtus:%d", cp_frame_mtus); return cp_frame_mtus; } #else bool is_cp_need_reset(void) { return false; } #endif #define A2DP_AUDIO_SYSFREQ_BOOST_RESUME_CNT (20) uint32_t a2dp_audio_sysfreq_cnt = UINT32_MAX; uint32_t a2dp_audio_sysfreq_dest_boost_cnt = 0; APP_SYSFREQ_FREQ_T a2dp_audio_sysfreq_normalfreq = APP_SYSFREQ_52M; int a2dp_audio_sysfreq_boost_init(uint32_t normalfreq) { a2dp_audio_sysfreq_cnt = UINT32_MAX; a2dp_audio_sysfreq_dest_boost_cnt = 0; a2dp_audio_sysfreq_normalfreq = (APP_SYSFREQ_FREQ_T)normalfreq; TRACE_A2DP_DECODER_I("[BOOST] freq:%d", normalfreq); return 0; } int a2dp_audio_sysfreq_boost_start(uint32_t boost_cnt) { enum APP_SYSFREQ_FREQ_T sysfreq = APP_SYSFREQ_104M; a2dp_audio_sysfreq_cnt = 0; a2dp_audio_sysfreq_dest_boost_cnt = boost_cnt; if (a2dp_audio_sysfreq_normalfreq >= APP_SYSFREQ_52M) { sysfreq = APP_SYSFREQ_104M; } else { sysfreq = APP_SYSFREQ_52M; } TRACE_A2DP_DECODER_I("[BOOST] freq:%d cnt:%d", sysfreq, boost_cnt); app_sysfreq_req(APP_SYSFREQ_USER_BT_A2DP, sysfreq); return 0; } static int a2dp_audio_sysfreq_boost_porc(void) { if (a2dp_audio_sysfreq_cnt == UINT32_MAX) { // do nothing } else if (a2dp_audio_sysfreq_cnt >= a2dp_audio_sysfreq_dest_boost_cnt) { a2dp_audio_sysfreq_cnt = UINT32_MAX; TRACE_A2DP_DECODER_I("[BOOST] freq:%d", a2dp_audio_sysfreq_normalfreq); app_sysfreq_req(APP_SYSFREQ_USER_BT_A2DP, a2dp_audio_sysfreq_normalfreq); } else { a2dp_audio_sysfreq_cnt++; } return 0; } int a2dp_audio_sysfreq_boost_running(void) { return a2dp_audio_sysfreq_cnt == UINT32_MAX ? 0 : 1; } int a2dp_audio_store_packet_checker_start(void) { store_packet_history_loctime = 0; return 0; } int a2dp_audio_store_packet_checker(btif_media_header_t *header) { bool show_info = false; uint32_t fast_sys_tick = hal_fast_sys_timer_get(); int32_t tmp_ms = 0; if (store_packet_history_loctime) { tmp_ms = fast_sys_tick - store_packet_history_loctime; if (tmp_ms > (int32_t)MS_TO_FAST_TICKS(50)) { show_info = true; } } if (show_info) { // TRACE_A2DP_DECODER_I("[INPUT] >50ms seq:%d diff:%d", // header->sequenceNumber, FAST_TICKS_TO_MS(tmp_ms)); a2dp_decoder_info_checker(); } store_packet_history_loctime = fast_sys_tick; if (a2dp_audio_context.historySeq_idx && ((a2dp_audio_context.historySeq_idx - 1) % A2DP_DECODER_HISTORY_SEQ_SAVE == 0)) { a2dp_audio_show_history_seq(); } return 0; } //#define DECODER_ERR_TEST int a2dp_audio_store_packet(btif_media_header_t *header, unsigned char *buf, unsigned int len) { int nRet = A2DP_DECODER_NO_ERROR; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_NULL) { // if mem deinit , drop data return nRet; } a2dp_audio_status_mutex_lock(); #ifdef DECODER_ERR_TEST static uint16_t cnt = 0; static uint16_t limit = 500; cnt++; if (cnt % limit == 0) { cnt = 0; limit = rand() % 500; uint16_t len2 = rand() % len; memset(buf + len - len2, 0, len2); TRACE_A2DP_DECODER_I("[INPUT] Fill Err!!!! seq:%d", header->sequenceNumber); } #endif #if A2DP_DECODER_HISTORY_SEQ_SAVE a2dp_audio_save_history_seq(header, buf, len); #endif a2dp_audio_set_store_packet_status( A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_BUSY); if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { a2dp_audio_store_packet_checker(header); if (a2dp_audio_context.need_detect_first_packet) { a2dp_audio_context.need_detect_first_packet = false; a2dp_audio_context.audio_decoder.audio_decoder_preparse_packet(header, buf, len); } if (a2dp_audio_detect_next_packet_callback) { a2dp_audio_detect_next_packet_callback(header, buf, len); } nRet = a2dp_audio_context.audio_decoder.audio_decoder_store_packet( header, buf, len); #if defined(IBRT) if (is_cp_need_reset()) { TRACE_A2DP_DECODER_I("[CP] find cp error need restart"); app_ibrt_if_force_audio_retrigger(); } if (nRet == A2DP_DECODER_MTU_LIMTER_ERROR) { if (app_tws_ibrt_mobile_link_connected()) { // try again // a2dp_audio_semaphore_wait(A2DP_AUDIO_WAIT_TIMEOUT_MS); nRet = a2dp_audio_context.audio_decoder.audio_decoder_store_packet( header, buf, len); } if (nRet == A2DP_DECODER_MTU_LIMTER_ERROR) { int dest_discards_samples = 0; ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx(); if (p_ibrt_ctrl == NULL) { return A2DP_DECODER_NOT_SUPPORT; } if (app_tws_ibrt_mobile_link_connected()) { bt_syn_trig_checker(p_ibrt_ctrl->mobile_conhandle); } else if (app_tws_ibrt_slave_ibrt_link_connected()) { bt_syn_trig_checker(p_ibrt_ctrl->ibrt_conhandle); } dest_discards_samples = app_bt_stream_get_dma_buffer_samples() / 2; a2dp_audio_discards_samples(dest_discards_samples * 2); a2dp_audio_context.audio_decoder.audio_decoder_store_packet(header, buf, len); TRACE_A2DP_DECODER_I("[INPUT] MTU_LIMTER so discards_packet"); } } #else if (is_cp_need_reset()) { TRACE_A2DP_DECODER_I("[CP] find cp error need restart"); app_audio_decode_err_force_trigger(); } if (nRet == A2DP_DECODER_MTU_LIMTER_ERROR) { a2dp_audio_synchronize_dest_packet_mut( a2dp_audio_context.dest_packet_mut); a2dp_audio_context.audio_decoder.audio_decoder_store_packet(header, buf, len); TRACE_A2DP_DECODER_W("[INPUT] MTU_LIMTER so discards_packet"); } #endif } else { TRACE(2, "[INPUT] skip packet status:%d", a2dp_audio_get_status()); } if (a2dp_audio_store_packet_callback) { a2dp_audio_store_packet_callback(header, buf, len); } a2dp_audio_set_store_packet_status( A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_IDLE); a2dp_audio_status_mutex_unlock(); return 0; } uint32_t a2dp_audio_playback_handler(uint8_t *buffer, uint32_t buffer_bytes) { uint32_t len = buffer_bytes; int nRet = A2DP_DECODER_NO_ERROR; A2DP_AUDIO_LASTFRAME_INFO_T *lastframe_info = NULL; list_t *list = a2dp_audio_context.audio_datapath.input_raw_packet_list; a2dp_audio_set_playback_status(A2DP_AUDIO_DECODER_PLAYBACK_STATUS_BUSY); if (a2dp_audio_get_status() != A2DP_AUDIO_DECODER_STATUS_START) { TRACE_A2DP_DECODER_W("[PLAYBACK] skip handler status:%d", a2dp_audio_get_status()); goto exit; } a2dp_audio_sysfreq_boost_porc(); if (a2dp_audio_context.average_packet_mut == 0) { A2DP_AUDIO_HEADFRAME_INFO_T headframe_info; a2dp_audio_decoder_headframe_info_get(&headframe_info); a2dp_audio_context.average_packet_mut = a2dp_audio_list_length(list); TRACE_A2DP_DECODER_I( "[PLAYBACK] init average_packet_mut:%d seq:%d", (uint16_t)(a2dp_audio_context.average_packet_mut + 0.5f), headframe_info.sequenceNumber); } else { if (!a2dp_audio_refill_packet()) { uint16_t packet_mut = 0; if (!a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info)) { packet_mut = a2dp_audio_list_length(list) + get_in_cp_frame_cnt() + get_in_cp_frame_delay() * (lastframe_info->frame_samples / lastframe_info->list_samples); a2dp_audio_context.average_packet_mut = a2dp_audio_alpha_filter( (float)a2dp_audio_context.average_packet_mut, (float)packet_mut); a2dp_audio_sync_handler(buffer, buffer_bytes); } } } #if defined(A2DP_AUDIO_REFILL_AFTER_NO_CACHE) if (a2dp_audio_context.skip_frame_cnt_after_no_cache) { #if defined(A2DP_CP_ACCEL) uint32_t cp_delay_mtus = get_in_cp_frame_delay(); cp_delay_mtus *= get_cp_frame_mtus(&a2dp_audio_lastframe_info); if (a2dp_audio_list_length(list) >= (a2dp_audio_context.dest_packet_mut - cp_delay_mtus)) { a2dp_audio_context.skip_frame_cnt_after_no_cache = 0; } #else if (a2dp_audio_list_length(list) >= a2dp_audio_context.dest_packet_mut) { a2dp_audio_context.skip_frame_cnt_after_no_cache = 0; } #endif memset(buffer, 0, buffer_bytes); TRACE_A2DP_DECODER_I("[PLAYBACK] decode refill skip_cnt:%d, list:%d", a2dp_audio_context.skip_frame_cnt_after_no_cache, a2dp_audio_list_length(list)); a2dp_decoder_info_checker(); if (a2dp_audio_context.skip_frame_cnt_after_no_cache > 0) { a2dp_audio_context.skip_frame_cnt_after_no_cache--; } else { a2dp_audio_context.mute_frame_cnt_after_no_cache = A2DP_AUDIO_MUTE_FRAME_CNT_AFTER_NO_CACHE; } } else #endif { if (a2dp_audio_context.output_cfg.bits_depth == 24 && 16 == bt_sbc_player_get_sample_bit()) { len = len / (sizeof(int32_t) / sizeof(int16_t)); nRet = a2dp_audio_context.audio_decoder.audio_decoder_decode_frame(buffer, len); if (nRet < 0 || a2dp_audio_context.mute_frame_cnt_after_no_cache) { TRACE_A2DP_DECODER_I("[PLAYBACK] decode failed nRet=%d mute_cnt:%d", nRet, a2dp_audio_context.mute_frame_cnt_after_no_cache); a2dp_decoder_info_checker(); // mute frame memset(buffer, 0, len); } a2dp_audio_convert_16bit_to_24bit((int32_t *)buffer, (int16_t *)buffer, len / sizeof(int16_t)); // Restore len to 24-bit sample buffer length len = len * (sizeof(int32_t) / sizeof(int16_t)); } else if (a2dp_audio_context.output_cfg.bits_depth == a2dp_audio_context.audio_decoder.stream_info.bits_depth) { nRet = a2dp_audio_context.audio_decoder.audio_decoder_decode_frame(buffer, len); if (nRet < 0 || a2dp_audio_context.mute_frame_cnt_after_no_cache) { // mute frame TRACE_A2DP_DECODER_I("[PLAYBACK] decode failed nRet=%d mute_cnt:%d", nRet, a2dp_audio_context.mute_frame_cnt_after_no_cache); a2dp_decoder_info_checker(); memset(buffer, 0, len); } } a2dp_audio_channel_select(a2dp_audio_context.chnl_sel, buffer, buffer_bytes); } a2dp_audio_semaphore_release(); if (nRet == A2DP_DECODER_CACHE_UNDERFLOW_ERROR) { if (a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info) < 0) { goto exit; } TRACE(2, "CACHE_UNDERFLOW lastseq:%d ftick:%d", lastframe_info->sequenceNumber, hal_fast_sys_timer_get()); a2dp_audio_show_history_seq(); uint32_t mute_frames = A2DP_AUDIO_MUTE_FRAME_CNT_AFTER_NO_CACHE; uint32_t skip_frames = A2DP_AUDIO_SKIP_FRAME_LIMIT_AFTER_NO_CACHE - get_in_cp_frame_delay(); a2dp_audio_context.mute_frame_cnt_after_no_cache = (uint32_t)((float)mute_frames * a2dp_audio_latency_factor_get()); a2dp_audio_context.skip_frame_cnt_after_no_cache = (uint32_t)((float)skip_frames * a2dp_audio_latency_factor_get()); a2dp_audio_context.average_packet_mut = 0; a2dp_audio_sync_reset_data(); #if defined(IBRT) a2dp_audio_sync_tune_sample_rate( app_tws_ibrt_audio_sync_config_factor_reference_get()); #else a2dp_audio_sync_tune_sample_rate(a2dp_audio_context.init_factor_reference); #endif a2dp_decoder_info_checker(); } else { if (a2dp_audio_context.mute_frame_cnt_after_no_cache > 0) { a2dp_audio_context.mute_frame_cnt_after_no_cache--; a2dp_audio_context.average_packet_mut = 0; if (a2dp_audio_context.mute_frame_cnt_after_no_cache >= 1) { a2dp_audio_synchronize_dest_packet_mut( a2dp_audio_context.dest_packet_mut); } } } if (!a2dp_audio_internal_lastframe_info_ptr_get(&lastframe_info)) { lastframe_info->stream_info.factor_reference = a2dp_audio_context.output_cfg.factor_reference; lastframe_info->average_frames = (uint32_t)(a2dp_audio_context.average_packet_mut + 0.5f); } exit: a2dp_audio_set_playback_status(A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE); #if defined(IBRT) if (nRet == A2DP_DECODER_CACHE_UNDERFLOW_ERROR) { #if defined(A2DP_AUDIO_UNDERFLOW_CAUSE_AUDIO_RETRIGGER) bool force_audio_retrigger = true; #else bool force_audio_retrigger = false; #endif if (a2dp_audio_latency_factor_get() == A2DP_AUDIO_LATENCY_LOW_FACTOR && app_tws_ibrt_mobile_link_connected()) { a2dp_audio_latency_factor_sethigh(); if (app_tws_ibrt_tws_link_connected() && app_ibrt_ui_is_profile_exchanged()) { float latency_factor = a2dp_audio_latency_factor_get(); tws_ctrl_send_cmd(APP_TWS_CMD_SET_LATENCYFACTOR, (uint8_t *)&latency_factor, sizeof(latency_factor)); force_audio_retrigger = true; } } if (force_audio_retrigger && !a2dp_audio_context.underflow_onporcess) { a2dp_audio_context.underflow_onporcess = true; app_ibrt_if_force_audio_retrigger(); } } #else if (nRet == A2DP_DECODER_CACHE_UNDERFLOW_ERROR) { app_audio_decode_err_force_trigger(); } #endif return len; } static void a2dp_audio_packet_free(void *packet) { if (a2dp_audio_context.audio_decoder.audio_decoder_packet_free) { a2dp_audio_context.audio_decoder.audio_decoder_packet_free(packet); } else { a2dp_audio_heap_free(packet); } } void a2dp_audio_clear_input_raw_packet_list(void) { // just clean the packet list to start receive ai data again if (a2dp_audio_context.audio_datapath.input_raw_packet_list) a2dp_audio_list_clear( a2dp_audio_context.audio_datapath.input_raw_packet_list); } int a2dp_audio_init(uint32_t sysfreq, A2DP_AUDIO_CODEC_TYPE codec_type, A2DP_AUDIO_OUTPUT_CONFIG_T *config, A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel, uint16_t dest_packet_mut) { uint8_t *heap_buff = NULL; uint32_t heap_size = 0; double ratio = 0; A2DP_AUDIO_OUTPUT_CONFIG_T decoder_output_config; TRACE_A2DP_DECODER_I("[INIT] freq:%d codec:%d chnl:%d", sysfreq, codec_type, chnl_sel); TRACE_A2DP_DECODER_I("[INIT] out:%d-%d-%d smp:%d dest:%d", config->sample_rate, config->num_channels, config->bits_depth, config->frame_samples, dest_packet_mut); a2dp_audio_sysfreq_boost_init(sysfreq); a2dp_audio_sysfreq_boost_start(A2DP_AUDIO_SYSFREQ_BOOST_RESUME_CNT); a2dp_audio_semaphore_init(); a2dp_audio_buffer_mutex_init(); a2dp_audio_status_mutex_init(); a2dp_audio_status_mutex_lock(); a2dp_audio_detect_next_packet_callback_register(NULL); a2dp_audio_detect_store_packet_callback_register(NULL); #if defined(A2DP_LDAC_ON) if (bt_sbc_player_get_codec_type() == BTIF_AVDTP_CODEC_TYPE_NON_A2DP) { heap_size = A2DP_AUDIO_LDAC_MEMPOOL_SIZE; } else #endif { heap_size = A2DP_AUDIO_MEMPOOL_SIZE; } app_audio_mempool_get_buff(&heap_buff, heap_size); ASSERT_A2DP_DECODER(heap_buff, "%s size:%d", __func__, heap_size); a2dp_audio_heap_init(heap_buff, heap_size); memset(&a2dp_audio_lastframe_info, 0, sizeof(A2DP_AUDIO_LASTFRAME_INFO_T)); a2dp_audio_context.audio_datapath.input_raw_packet_list = a2dp_audio_list_new( a2dp_audio_packet_free, (list_mempool_zmalloc)a2dp_audio_heap_cmalloc, (list_mempool_free)a2dp_audio_heap_free); a2dp_audio_context.audio_datapath.output_pcm_packet_list = a2dp_audio_list_new(a2dp_audio_packet_free, (list_mempool_zmalloc)a2dp_audio_heap_cmalloc, (list_mempool_free)a2dp_audio_heap_free); memcpy(&(a2dp_audio_context.output_cfg), config, sizeof(A2DP_AUDIO_OUTPUT_CONFIG_T)); ratio = a2dp_audio_context.output_cfg.factor_reference; a2dp_audio_context.output_cfg.factor_reference = 0; a2dp_audio_context.init_factor_reference = config->factor_reference; a2dp_audio_context.chnl_sel = chnl_sel; a2dp_audio_context.dest_packet_mut = dest_packet_mut; a2dp_audio_context.average_packet_mut = 0; switch (codec_type) { case A2DP_AUDIO_CODEC_TYPE_SBC: decoder_output_config.sample_rate = config->sample_rate; decoder_output_config.num_channels = 2; decoder_output_config.bits_depth = 16; decoder_output_config.frame_samples = config->frame_samples; decoder_output_config.factor_reference = 1.0f; memcpy(&(a2dp_audio_context.audio_decoder), &a2dp_audio_sbc_decoder_config, sizeof(A2DP_AUDIO_DECODER_T)); break; #if defined(A2DP_AAC_ON) case A2DP_AUDIO_CODEC_TYPE_MPEG2_4_AAC: decoder_output_config.sample_rate = config->sample_rate; decoder_output_config.num_channels = 2; decoder_output_config.bits_depth = 16; decoder_output_config.frame_samples = config->frame_samples; decoder_output_config.factor_reference = 1.0f; memcpy(&(a2dp_audio_context.audio_decoder), &a2dp_audio_aac_lc_decoder_config, sizeof(A2DP_AUDIO_DECODER_T)); break; #endif #if defined(A2DP_SCALABLE_ON) case A2DP_AUDIO_CODEC_TYPE_SCALABL: decoder_output_config.sample_rate = config->sample_rate; decoder_output_config.num_channels = 2; decoder_output_config.bits_depth = config->curr_bits; decoder_output_config.frame_samples = config->frame_samples; decoder_output_config.factor_reference = 1.0f; memcpy(&(a2dp_audio_context.audio_decoder), &a2dp_audio_scalable_decoder_config, sizeof(A2DP_AUDIO_DECODER_T)); break; #endif #if defined(A2DP_LHDC_ON) case A2DP_AUDIO_CODEC_TYPE_LHDC: decoder_output_config.sample_rate = config->sample_rate; decoder_output_config.num_channels = 2; decoder_output_config.bits_depth = config->curr_bits; decoder_output_config.frame_samples = config->frame_samples; decoder_output_config.factor_reference = 1.0f; memcpy(&(a2dp_audio_context.audio_decoder), &a2dp_audio_lhdc_decoder_config, sizeof(A2DP_AUDIO_DECODER_T)); break; #endif #if defined(A2DP_LDAC_ON) case A2DP_AUDIO_CODEC_TYPE_LDAC: decoder_output_config.sample_rate = config->sample_rate; decoder_output_config.num_channels = 2; decoder_output_config.bits_depth = config->curr_bits; decoder_output_config.frame_samples = config->frame_samples; decoder_output_config.factor_reference = 1.0f; memcpy(&(a2dp_audio_context.audio_decoder), &a2dp_audio_ldac_decoder_config, sizeof(A2DP_AUDIO_DECODER_T)); break; #endif default: ASSERT_A2DP_DECODER(0, "%s invalid codec_type:%d", __func__, codec_type); break; } a2dp_audio_context.audio_decoder.audio_decoder_init( &decoder_output_config, (void *)&a2dp_audio_context); a2dp_audio_context.need_detect_first_packet = true; a2dp_audio_context.underflow_onporcess = false; a2dp_audio_context.skip_frame_cnt_after_no_cache = 0; a2dp_audio_context.mute_frame_cnt_after_no_cache = 0; a2dp_audio_context.audio_decoder_status = A2DP_AUDIO_DECODER_STATUS_READY; a2dp_audio_context.store_packet_status = A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_IDLE; a2dp_audio_context.playback_status = A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE; a2dp_audio_sync_init(ratio); #if A2DP_DECODER_HISTORY_SEQ_SAVE a2dp_audio_reset_history_seq(); #endif a2dp_audio_store_packet_checker_start(); a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_deinit(void) { TRACE_A2DP_DECODER_I("[DEINIT]"); a2dp_audio_status_mutex_lock(); a2dp_audio_detect_next_packet_callback_register(NULL); a2dp_audio_detect_store_packet_callback_register(NULL); a2dp_audio_context.audio_decoder.audio_decoder_deinit(); memset(&(a2dp_audio_context.audio_decoder), 0, sizeof(A2DP_AUDIO_DECODER_T)); memset(&(a2dp_audio_context.output_cfg), 0, sizeof(A2DP_AUDIO_OUTPUT_CONFIG_T)); a2dp_audio_list_clear( a2dp_audio_context.audio_datapath.input_raw_packet_list); a2dp_audio_list_free(a2dp_audio_context.audio_datapath.input_raw_packet_list); a2dp_audio_context.audio_datapath.input_raw_packet_list = NULL; a2dp_audio_list_clear( a2dp_audio_context.audio_datapath.output_pcm_packet_list); a2dp_audio_list_free( a2dp_audio_context.audio_datapath.output_pcm_packet_list); a2dp_audio_context.audio_datapath.output_pcm_packet_list = NULL; size_t total = 0, used = 0, max_used = 0; a2dp_audio_heap_info(&total, &used, &max_used); TRACE_A2DP_DECODER_I( "[DEINIT] heap info: total - %d, used - %d, max_used - %d.", total, used, max_used); // ASSERT_A2DP_DECODER(used == 0, "[%s] used != 0", __func__); a2dp_audio_set_store_packet_status( A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_IDLE); a2dp_audio_set_playback_status(A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE); a2dp_audio_set_status(A2DP_AUDIO_DECODER_STATUS_NULL); #if A2DP_DECODER_HISTORY_SEQ_SAVE a2dp_audio_reset_history_seq(); #endif a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_stop(void) { TRACE_A2DP_DECODER_I("[STOP]"); int cnt = 0; a2dp_audio_set_status(A2DP_AUDIO_DECODER_STATUS_STOP); a2dp_audio_semaphore_release(); cnt = 50; do { if (a2dp_audio_get_playback_status() == A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE) { TRACE_A2DP_DECODER_I("[DEINIT]PLAYBACK_STATUS_IDLE cnt:%d", cnt); break; } else { osThreadYield(); } } while (--cnt > 0); cnt = 50; do { if (a2dp_audio_get_store_packet_status() == A2DP_AUDIO_DECODER_STORE_PACKET_STATUS_IDLE) { TRACE_A2DP_DECODER_I("[DEINIT] STORE_PACKET_STATUS_IDLE cnt:%d", cnt); break; } else { osThreadYield(); } } while (--cnt > 0); return 0; } int a2dp_audio_start(void) { TRACE_A2DP_DECODER_I("[START]"); a2dp_audio_status_mutex_lock(); a2dp_audio_set_status(A2DP_AUDIO_DECODER_STATUS_START); a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_detect_next_packet_callback_register( A2DP_AUDIO_DETECT_NEXT_PACKET_CALLBACK callback) { a2dp_audio_status_mutex_lock(); a2dp_audio_detect_next_packet_callback = callback; a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_detect_store_packet_callback_register( A2DP_AUDIO_DETECT_NEXT_PACKET_CALLBACK callback) { a2dp_audio_status_mutex_lock(); a2dp_audio_store_packet_callback = callback; a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_detect_first_packet(void) { a2dp_audio_status_mutex_lock(); a2dp_audio_context.need_detect_first_packet = true; a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_detect_first_packet_clear(void) { a2dp_audio_status_mutex_lock(); a2dp_audio_context.need_detect_first_packet = false; a2dp_audio_status_mutex_unlock(); return 0; } int a2dp_audio_discards_packet(uint32_t packets) { int nRet = 0; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { a2dp_audio_status_mutex_lock(); nRet = a2dp_audio_context.audio_decoder.audio_decoder_discards_packet(packets); a2dp_audio_status_mutex_unlock(); } else { nRet = -1; } return nRet; } int a2dp_audio_synchronize_dest_packet_mut(uint32_t mtu) { int nRet = 0; int cnt = 50; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { do { if (a2dp_audio_get_playback_status() == A2DP_AUDIO_DECODER_PLAYBACK_STATUS_IDLE) { nRet = a2dp_audio_context.audio_decoder .audio_decoder_synchronize_dest_packet_mut(mtu); break; } else { osThreadYield(); } } while (--cnt > 0); } else { nRet = -1; } return nRet; } int a2dp_audio_discards_samples(uint32_t samples) { return a2dp_audio_context.audio_decoder.a2dp_audio_discards_samples(samples); } int a2dp_audio_convert_list_to_samples(uint32_t *samples) { return a2dp_audio_context.audio_decoder.a2dp_audio_convert_list_to_samples( samples); } int a2dp_audio_get_packet_samples(void) { A2DP_AUDIO_LASTFRAME_INFO_T lastframe_info; uint32_t packet_samples = 0; uint16_t totalSubSequenceNumber = 1; a2dp_audio_lastframe_info_get(&lastframe_info); if (lastframe_info.totalSubSequenceNumber) { totalSubSequenceNumber = lastframe_info.totalSubSequenceNumber; } packet_samples = totalSubSequenceNumber * lastframe_info.frame_samples; return packet_samples; } static int a2dp_audio_internal_lastframe_info_ptr_get( A2DP_AUDIO_LASTFRAME_INFO_T **lastframe_info) { int nRet = 0; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { *lastframe_info = &a2dp_audio_lastframe_info; } else { *lastframe_info = NULL; nRet = -1; } return nRet; } int a2dp_audio_lastframe_info_get(A2DP_AUDIO_LASTFRAME_INFO_T *lastframe_info) { int nRet = 0; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { a2dp_audio_buffer_mutex_lock(); memcpy(lastframe_info, &a2dp_audio_lastframe_info, sizeof(A2DP_AUDIO_LASTFRAME_INFO_T)); a2dp_audio_buffer_mutex_unlock(); } else { memset(lastframe_info, 0, sizeof(A2DP_AUDIO_LASTFRAME_INFO_T)); nRet = -1; } return nRet; } int a2dp_audio_decoder_internal_check_sum_reset(void) { check_sum_seed = 0; return 0; } uint32_t a2dp_audio_decoder_internal_check_sum_generate(const uint8_t *buf, uint32_t len) { #if A2DP_DECODER_CHECKER check_sum_seed = crc32(check_sum_seed, buf, len); #else check_sum_seed = 0; #endif return check_sum_seed; } int a2dp_audio_lastframe_info_reset_undecodeframe(void) { int nRet = 0; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { a2dp_audio_buffer_mutex_lock(); a2dp_audio_lastframe_info.undecode_frames = 0; a2dp_audio_lastframe_info.undecode_max_frames = 0; a2dp_audio_lastframe_info.undecode_min_frames = 0xffff; a2dp_audio_decoder_internal_check_sum_reset(); a2dp_audio_lastframe_info.check_sum = 0; a2dp_audio_buffer_mutex_unlock(); } else { nRet = -1; } return nRet; } int a2dp_audio_decoder_internal_lastframe_info_set( A2DP_AUDIO_DECODER_LASTFRAME_INFO_T *lastframe_info) { a2dp_audio_buffer_mutex_lock(); a2dp_audio_lastframe_info.sequenceNumber = lastframe_info->sequenceNumber; a2dp_audio_lastframe_info.timestamp = lastframe_info->timestamp; a2dp_audio_lastframe_info.curSubSequenceNumber = lastframe_info->curSubSequenceNumber; a2dp_audio_lastframe_info.totalSubSequenceNumber = lastframe_info->totalSubSequenceNumber; a2dp_audio_lastframe_info.frame_samples = lastframe_info->frame_samples; a2dp_audio_lastframe_info.list_samples = lastframe_info->list_samples; a2dp_audio_lastframe_info.decoded_frames = lastframe_info->decoded_frames; a2dp_audio_lastframe_info.undecode_frames = lastframe_info->undecode_frames; a2dp_audio_lastframe_info.undecode_max_frames = MAX(a2dp_audio_lastframe_info.undecode_frames, a2dp_audio_lastframe_info.undecode_max_frames); a2dp_audio_lastframe_info.undecode_min_frames = MIN(a2dp_audio_lastframe_info.undecode_frames, a2dp_audio_lastframe_info.undecode_min_frames); a2dp_audio_lastframe_info.stream_info = lastframe_info->stream_info; a2dp_audio_lastframe_info.check_sum = lastframe_info->check_sum; a2dp_audio_buffer_mutex_unlock(); return 0; } int a2dp_audio_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info, uint32_t mask) { int nRet = 0; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { a2dp_audio_status_mutex_lock(); nRet = a2dp_audio_context.audio_decoder.audio_decoder_synchronize_packet( sync_info, mask); if (nRet == A2DP_DECODER_NOT_SUPPORT) { // can't support synchronize packet, so return fake val; nRet = A2DP_DECODER_NO_ERROR; } a2dp_audio_status_mutex_unlock(); } else { nRet = -1; } return nRet; } int a2dp_audio_decoder_headframe_info_get( A2DP_AUDIO_HEADFRAME_INFO_T *headframe_info) { int nRet = 0; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { nRet = a2dp_audio_context.audio_decoder.audio_decoder_headframe_info_get( headframe_info); } else { memset(headframe_info, 0, sizeof(A2DP_AUDIO_HEADFRAME_INFO_T)); nRet = -1; } return nRet; } int a2dp_audio_refill_packet(void) { int refill_cnt = 0; #if defined(A2DP_AUDIO_REFILL_AFTER_NO_CACHE) refill_cnt += a2dp_audio_context.skip_frame_cnt_after_no_cache; #endif refill_cnt += a2dp_audio_context.mute_frame_cnt_after_no_cache; return refill_cnt; } bool a2dp_audio_auto_synchronize_support(void) { bool nRet = 0; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { a2dp_audio_buffer_mutex_lock(); nRet = a2dp_audio_context.audio_decoder.auto_synchronize_support > 0 ? true : false; a2dp_audio_buffer_mutex_unlock(); } else { nRet = 0; } return nRet; } A2DP_AUDIO_OUTPUT_CONFIG_T *a2dp_audio_get_output_config(void) { A2DP_AUDIO_OUTPUT_CONFIG_T *output_config = NULL; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { a2dp_audio_buffer_mutex_lock(); output_config = &a2dp_audio_context.output_cfg; a2dp_audio_buffer_mutex_unlock(); } else { output_config = NULL; } return output_config; } int a2dp_audio_latency_factor_setlow(void) { a2dp_audio_latency_factor = A2DP_AUDIO_LATENCY_LOW_FACTOR; return 0; } int a2dp_audio_latency_factor_sethigh(void) { a2dp_audio_latency_factor = A2DP_AUDIO_LATENCY_HIGH_FACTOR; return 0; } float a2dp_audio_latency_factor_get(void) { return a2dp_audio_latency_factor; } int a2dp_audio_latency_factor_set(float factor) { a2dp_audio_latency_factor = factor; return 0; } int a2dp_audio_latency_factor_status_get( A2DP_AUDIO_LATENCY_STATUS_E *latency_status, float *more_latency_factor) { if (a2dp_audio_latency_factor == A2DP_AUDIO_LATENCY_HIGH_FACTOR) { *latency_status = A2DP_AUDIO_LATENCY_STATUS_HIGH; *more_latency_factor = A2DP_AUDIO_LATENCY_MORE_FACTOR; } else { *latency_status = A2DP_AUDIO_LATENCY_STATUS_LOW; *more_latency_factor = 1.0f; } return 0; } int a2dp_audio_frame_delay_get(void) { return get_in_cp_frame_delay(); } int a2dp_audio_dest_packet_mut_get(void) { return a2dp_audio_context.dest_packet_mut; } int a2dp_audio_set_channel_select(A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel) { int nRet = A2DP_DECODER_NO_ERROR; if (a2dp_audio_get_status() == A2DP_AUDIO_DECODER_STATUS_START) { a2dp_audio_context.chnl_sel = chnl_sel; if (a2dp_audio_context.audio_decoder.audio_decoder_channel_select) { nRet = a2dp_audio_context.audio_decoder.audio_decoder_channel_select( chnl_sel); } } return nRet; } float a2dp_audio_get_sample_reference(void) { TRACE(1, "a2dp_audio_get_sample_reference:%d", (int32_t)(a2dp_audio_context.output_cfg.factor_reference * 10000000)); return a2dp_audio_context.output_cfg.factor_reference; } int8_t a2dp_audio_get_current_buf_size(void) { TRACE(1, "a2dp_audio_get_current_buf_size:%d", (int8_t)(a2dp_audio_context.average_packet_mut + 0.5f)); return (int8_t)(a2dp_audio_context.average_packet_mut + 0.5f); }