Merge pull request #33 from pine64/developer-comforts

Developer comforts part 1

.clang-format

@@ -0,0 +1 @@
+BasedOnStyle: LLVM

.github/workflows/build-firmware.yml

@@ -0,0 +1,17 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build-firmware:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/pine64/openpinebuds:latest-sdk
+    steps:
+      - name: Build the main firmware
+        run: cd /usr/src/ && ./build.sh || cat /usr/src/log.txt
+
+      - name: Archive produced firmware
+        uses: actions/upload-artifact@v3
+        with:
+          path: /usr/src/out/open_source/open_source.bin

Dockerfile

@@ -31,6 +31,7 @@ RUN apt-get update \
     bzip2 \
     curl \
     ffmpeg \
+    clang-format \ 
     git \
     make \
     tar \

Makefile

@@ -1037,7 +1037,32 @@ endif
 
 PHONY += FORCE
 FORCE: ;
+### Formatting
+ALL_SOURCE = $(shell find . \( -type f \( -name '*.c' -o -name '*.cpp' \) \) )
+
+
+style:
+	@for src in $(ALL_SOURCE) $(ALL_INCLUDES); do \
+		echo "Formatting $$src..." ; \
+		clang-format -i "$$src" ; \
+	done
+	@echo "Done"
+
+check-style:
+	@for src in $(ALL_SOURCE) $(ALL_INCLUDES) ; do \
+		var=`clang-format "$$src" | diff "$$src" - | wc -l` ; \
+		if [ $$var -ne 0 ] ; then \
+			echo "$$src does not respect the coding style (diff: $$var lines)" ; \
+			clang-format "$$src" | diff "$$src" -; \
+			exit 1 ; \
+		fi ; \
+	done
+	@echo "Style check passed"
+  
+
+PHONY += style check-style
 
 # Declare the contents of the .PHONY variable as phony.  We keep that
 # information in a variable so we can use it in if_changed and friends.
 .PHONY: $(PHONY)
+

apps/anc/inc/anc_wnr.h

@@ -17,13 +17,13 @@
 #define __ANC_WNR_H__
 
 // #include "plat_types.h"
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef enum
+typedef enum {
-{
   ANC_WNR_OPEN_MODE_STANDALONE = 0,
   ANC_WNR_OPEN_MODE_CONFIGURE,
 
@@ -32,8 +32,7 @@ typedef enum
 
 void anc_release_gain(void);
 
-typedef enum
+typedef enum {
-{
   APP_WNR_NOTIFY_DETECT_RESULT,
   APP_WNR_REQUEST_DETECT_RESULT,
   APP_WNR_RESPONSE_DETECT_RESULT,

apps/anc/src/anc_assist.c

@@ -1,6 +1,5 @@
 
 
-
 /***************************************************************************
  *
  * Copyright 2015-2019 BES.
@@ -17,32 +16,26 @@
  *
  ****************************************************************************/
 #include "anc_assist.h"
-#include "hal_trace.h"
+#include "anc_assist_algo.h"
+#include "anc_process.h"
 #include "arm_math.h"
 #include "audio_dump.h"
-#include "speech_cfg.h"
-#include "anc_process.h"
 #include "audioflinger.h"
-#include "anc_assist_algo.h"
-#include "hal_codec.h"
-#include "audioflinger.h"
-#include "hal_timer.h"
 #include "hal_aud.h"
+#include "hal_codec.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
+#include "speech_cfg.h"
+#include "speech_memory.h"
+#include "speech_ssat.h"
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "hal_aud.h"
-#include "anc_process.h"
-#include "anc_assist_algo.h"
-#include "speech_memory.h"
-#include "speech_ssat.h"
-
 
 #if defined(ANC_ASSIST_NOISE_ADAPTIVE_ENABLED)
 #include "main_classify.h"
 #endif
 
-
 static void _close_mic_anc_assist();
 static void _open_mic_anc_assist();
 #define _SAMPLE_RATE (16000)
@@ -72,14 +65,19 @@ int MIC_MAP = 0;
 #define _PLAY_SAMPLE_RATE (8000)
 #define _PLAY_FRAME_LEN (80)
 #define AF_PLAY_STREAM_BUFF_SIZE (_PLAY_FRAME_LEN * SAMPLE_BYTES * 1 * 2)
-static uint8_t __attribute__((aligned(4))) af_play_stream_buff[AF_PLAY_STREAM_BUFF_SIZE];
+static uint8_t __attribute__((aligned(4)))
+af_play_stream_buff[AF_PLAY_STREAM_BUFF_SIZE];
 #endif
 
 #if defined(ANC_ASSIST_NOISE_ADAPTIVE_ENABLED)
 ClassifyState *NoiseClassify_st = NULL;
 #endif
 
-#if defined(ANC_ASSIST_PILOT_ENABLED) || defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) || defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED) || defined(ANC_ASSIST_NOISE_ADAPTIVE_ENABLED)
+#if defined(ANC_ASSIST_PILOT_ENABLED) || defined(ANC_ASSIST_HESS_ENABLED) ||   \
+    defined(ANC_ASSIST_PNC_ENABLED) ||                                         \
+    defined(ANC_ASSIST_DEHOWLING_ENABLED) ||                                   \
+    defined(ANC_ASSIST_WNR_ENABLED) ||                                         \
+    defined(ANC_ASSIST_NOISE_ADAPTIVE_ENABLED)
 
 extern const struct_anc_cfg *anc_coef_list_48k[1];
 void anc_assist_change_curve(int curve_id) {
@@ -87,14 +85,11 @@ void anc_assist_change_curve(int curve_id){
   anc_set_cfg(anc_coef_list_48k[0], ANC_FEEDFORWARD, ANC_GAIN_NO_DELAY);
   anc_set_cfg(anc_coef_list_48k[0], ANC_FEEDBACK, ANC_GAIN_NO_DELAY);
 }
-bool audio_engine_tt_is_on(){
+bool audio_engine_tt_is_on() { return 1; }
-    return 1;
-}
-
-
 
 #define _tgt_ff_gain (512)
-void anc_assist_set_anc_gain(float gain_ch_l, float gain_ch_r,enum ANC_TYPE_T anc_type){
+void anc_assist_set_anc_gain(float gain_ch_l, float gain_ch_r,
+                             enum ANC_TYPE_T anc_type) {
 
   TRACE(2, "[%s] set anc gain %d", __func__, (int)(100 * gain_ch_l));
   uint32_t tgt_ff_gain_l, tgt_ff_gain_r;
@@ -109,24 +104,22 @@ static LeakageDetectionState * pilot_st = NULL;
 
 #endif
 
-
+#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) ||     \
-#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) || defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED)
+    defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED)
 static ANCAssistMultiState *anc_assist_multi_st = NULL;
 #endif
 
-
-
 ANC_ASSIST_MODE_T g_anc_assist_mode = ANC_ASSIST_MODE_QTY;
 void anc_assist_open(ANC_ASSIST_MODE_T mode) {
   g_anc_assist_mode = mode;
 
-
   // normal init
 #if defined(ANC_ASSIST_PILOT_ENABLED)
   pilot_st = LeakageDetection_create(160, 0);
 #endif
 
-#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) || defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED)
+#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) ||     \
+    defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED)
   anc_assist_multi_st = ANCAssistMulti_create(_SAMPLE_RATE, _FRAME_LEN, 128);
 #endif
 
@@ -136,36 +129,27 @@ void anc_assist_open(ANC_ASSIST_MODE_T mode){
 
   // audio_dump_init(160,sizeof(short),3);
 
-
   if (mode == ANC_ASSIST_MODE_QTY) {
     return;
-    }
+  } else {
-    else{
     if (mode == ANC_ASSIST_STANDALONE || mode == ANC_ASSIST_MUSIC) {
       _open_mic_anc_assist();
     }
     if (mode == ANC_ASSIST_PHONE_8K) {
       // normal init 8k
-        }
+    } else if (mode == ANC_ASSIST_PHONE_16K) {
-        else if(mode == ANC_ASSIST_PHONE_16K){
       // normal init 16k
     }
-        
   }
-
-
-
 }
 
-
-
-
 void anc_assist_close() {
 
 #if defined(ANC_ASSIST_PILOT_ENABLED)
   LeakageDetection_destroy(pilot_st);
 #endif
-#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) || defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED)
+#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) ||     \
+    defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED)
   ANCAssistMulti_destroy(anc_assist_multi_st);
 #endif
 
@@ -177,29 +161,25 @@ void anc_assist_close(){
 
   if (g_anc_assist_mode == ANC_ASSIST_MODE_QTY) {
     return;
-    }
+  } else {
-    else{
+    if (g_anc_assist_mode == ANC_ASSIST_STANDALONE ||
-        if(g_anc_assist_mode == ANC_ASSIST_STANDALONE || g_anc_assist_mode == ANC_ASSIST_MUSIC ){
+        g_anc_assist_mode == ANC_ASSIST_MUSIC) {
       _close_mic_anc_assist();
     }
     if (g_anc_assist_mode == ANC_ASSIST_PHONE_8K) {
       // normal init 8k
-        }
+    } else if (g_anc_assist_mode == ANC_ASSIST_PHONE_16K) {
-        else if(g_anc_assist_mode == ANC_ASSIST_PHONE_16K){
       // normal init 16k
     }
-        
   }
-
 }
 
-
 extern ASSIST_PCM_T ref_buf_data[80];
 void anc_assist_process(uint8_t *buf, int len) {
 
-
   int32_t frame_len = len / SAMPLE_BYTES / MIC_NUM;
-	ASSERT(frame_len == _FRAME_LEN, "[%s] frame len(%d) is invalid.", __func__, frame_len);
+  ASSERT(frame_len == _FRAME_LEN, "[%s] frame len(%d) is invalid.", __func__,
+         frame_len);
   ASSIST_PCM_T *pcm_buf = (ASSIST_PCM_T *)buf;
 
   ASSIST_PCM_T *mic1 = (ASSIST_PCM_T *)af_stream_mic1;
@@ -221,7 +201,8 @@ void anc_assist_process(uint8_t * buf, int len){
   LeakageDetection_process(pilot_st, AF_ANC_OFF, mic3, ref_buf_data, frame_len);
 #endif
 
-#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) || defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED)
+#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_PNC_ENABLED) ||     \
+    defined(ANC_ASSIST_DEHOWLING_ENABLED) || defined(ANC_ASSIST_WNR_ENABLED)
   ANCAssistMulti_process(anc_assist_multi_st, mic1, mic2, mic3, frame_len);
 #endif
 
@@ -238,35 +219,13 @@ void anc_assist_process(uint8_t * buf, int len){
 
   // wnr
 
-
   // pnc
 
-
   // hess
 
-
-
   // pilot adpt
-
-
-
-
 }
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 static uint32_t anc_assist_callback(uint8_t *buf, uint32_t len) {
 #ifdef TEST_MIPS
   start_ticks = hal_fast_sys_timer_get();
@@ -278,25 +237,22 @@ static uint32_t anc_assist_callback(uint8_t *buf, uint32_t len){
   used_mips = (end_ticks - start_ticks) * 1000 / (start_ticks - pre_ticks);
   TRACE(2, "[%s] Usage: %d in a thousand (MIPS).", __func__, used_mips);
   // wnr_ticks = start_ticks;
-		//TRACE(2,"[%s] WNR frame takes %d ms.", __func__, FAST_TICKS_TO_MS((start_ticks - pre_ticks)*100));
+  // TRACE(2,"[%s] WNR frame takes %d ms.", __func__,
+  // FAST_TICKS_TO_MS((start_ticks - pre_ticks)*100));
   pre_ticks = start_ticks;
 #endif
   return 0;
 }
 
-
 #if defined(ANC_ASSIST_PILOT_ENABLED)
 static uint32_t anc_assist_playback_callback(uint8_t *buf, uint32_t len) {
   get_pilot_data(buf, len);
   // TRACE(2,"playing data %d",len);
   return 0;
-
 }
 #endif
 
-
+static void _open_mic_anc_assist(void) {
-static void _open_mic_anc_assist(void)
-{
 
   int anc_assist_mic_num = 0;
 
@@ -304,76 +260,65 @@ static void _open_mic_anc_assist(void)
   anc_assist_mic_num = anc_assist_mic_num | ANC_ASSIST_FB_MIC;
 #endif
 
-#if defined(ANC_ASSIST_HESS_ENABLED) || defined(ANC_ASSIST_NOISE_ADAPTIVE_ENABLED)
+#if defined(ANC_ASSIST_HESS_ENABLED) ||                                        \
+    defined(ANC_ASSIST_NOISE_ADAPTIVE_ENABLED)
   anc_assist_mic_num = anc_assist_mic_num | ANC_ASSIST_FF1_MIC;
 #endif
 
 #if defined(ANC_ASSIST_PNC_ENABLED)
-    anc_assist_mic_num = anc_assist_mic_num | ANC_ASSIST_FF1_MIC | ANC_ASSIST_FB_MIC;
+  anc_assist_mic_num =
+      anc_assist_mic_num | ANC_ASSIST_FF1_MIC | ANC_ASSIST_FB_MIC;
 #endif
 
 #if defined(ANC_ASSIST_DEHOWLING_ENABLED)
-    anc_assist_mic_num = anc_assist_mic_num | ANC_ASSIST_FF1_MIC | ANC_ASSIST_FB_MIC;
+  anc_assist_mic_num =
+      anc_assist_mic_num | ANC_ASSIST_FF1_MIC | ANC_ASSIST_FB_MIC;
 #endif
 
 #if defined(ANC_ASSIST_WNR_ENABLED)
-    anc_assist_mic_num = anc_assist_mic_num | ANC_ASSIST_FF1_MIC | ANC_ASSIST_FF2_MIC;
+  anc_assist_mic_num =
+      anc_assist_mic_num | ANC_ASSIST_FF1_MIC | ANC_ASSIST_FF2_MIC;
 #endif
 
   switch (anc_assist_mic_num) {
-        case(0):
+  case (0): {
-        {
     TRACE(2, "[%s] no mic is used", __func__);
     return;
-        }
+  } break;
-        break;
+  case (1): {
-        case(1):
-        {
     TRACE(2, "[%s] use fb mic only", __func__);
     MIC_NUM = 3;
     MIC_MAP = AUD_INPUT_PATH_AF_ANC;
 
-        }
+  } break;
-        break;
+  case (4): {
-        case(4):
-        {
     TRACE(2, "[%s] use ff mic only", __func__);
     MIC_NUM = 3;
     MIC_MAP = AUD_INPUT_PATH_ANC_WNR;
 
-        }
+  } break;
-        break;
+  case (5): {
-        case(5):
-        {
     TRACE(2, "[%s] use ff mic and fb mic", __func__);
     MIC_NUM = 3;
     MIC_MAP = AUD_INPUT_PATH_ANC_WNR;
 
-        }
+  } break;
-        break;
+  case (6): {
-        case(6):
-        {
     TRACE(2, "[%s] use ff1 mic and ff2 mic", __func__);
     MIC_NUM = 2;
     MIC_MAP = AUD_INPUT_PATH_AF_ANC;
 
-        }
+  } break;
-        break;
+  case (7): {
-        case(7):
-        {
     TRACE(2, "[%s] use ff1 mic and ff2 mic and fb mic", __func__);
     MIC_NUM = 2;
     MIC_MAP = AUD_INPUT_PATH_AF_ANC;
 
-        }
+  } break;
-        break;
 
-        default:
+  default: {
-        {
     TRACE(2, "[%s] invalid mic order is used", __func__);
-        }
+  } break;
-        break;
-
   }
 
   MIC_NUM = 3;
@@ -392,21 +337,22 @@ static void _open_mic_anc_assist(void)
   stream_cfg.handler = anc_assist_callback;
   stream_cfg.data_size = _FRAME_LEN * SAMPLE_BYTES * 2 * MIC_NUM;
   stream_cfg.data_ptr = af_stream_buff;
-	ASSERT(stream_cfg.channel_num == MIC_NUM, "[%s] channel number(%d) is invalid.", __func__, stream_cfg.channel_num);
+  ASSERT(stream_cfg.channel_num == MIC_NUM,
-    TRACE(2,"[%s] sample_rate:%d, data_size:%d", __func__, stream_cfg.sample_rate, stream_cfg.data_size);
+         "[%s] channel number(%d) is invalid.", __func__,
+         stream_cfg.channel_num);
+  TRACE(2, "[%s] sample_rate:%d, data_size:%d", __func__,
+        stream_cfg.sample_rate, stream_cfg.data_size);
   TRACE(2, "[%s] af_stream_buff = %p", __func__, af_stream_buff);
 
   af_stream_open(ANC_ADPT_STREAM_ID, AUD_STREAM_CAPTURE, &stream_cfg);
   af_stream_start(ANC_ADPT_STREAM_ID, AUD_STREAM_CAPTURE);
 
-
 #if defined(ANC_ASSIST_PILOT_ENABLED)
   // struct AF_STREAM_CONFIG_T stream_cfg;
   TRACE(1, "[%s] set play ...", __func__);
 
   memset(&stream_cfg, 0, sizeof(stream_cfg));
 
-
   stream_cfg.bits = (enum AUD_BITS_T)_SAMPLE_BITS;
   stream_cfg.channel_num = AUD_CHANNEL_NUM_1;
   stream_cfg.sample_rate = (enum AUD_SAMPRATE_T)_PLAY_SAMPLE_RATE;
@@ -419,26 +365,18 @@ static void _open_mic_anc_assist(void)
   stream_cfg.data_ptr = af_play_stream_buff;
   stream_cfg.data_size = sizeof(af_play_stream_buff);
 
-
   af_stream_open(ANC_ADPT_STREAM_ID, AUD_STREAM_PLAYBACK, &stream_cfg);
   af_stream_start(ANC_ADPT_STREAM_ID, AUD_STREAM_PLAYBACK);
 #endif
 }
 
-
-
-
-
-
-
-
-
 static void _close_mic_anc_assist() {
   TRACE(1, "[%s] ...", __func__);
 
   af_stream_stop(ANC_ADPT_STREAM_ID, AUD_STREAM_CAPTURE);
   af_stream_close(ANC_ADPT_STREAM_ID, AUD_STREAM_CAPTURE);
-    if(g_anc_assist_mode == ANC_ASSIST_STANDALONE || g_anc_assist_mode == ANC_ASSIST_MUSIC ){
+  if (g_anc_assist_mode == ANC_ASSIST_STANDALONE ||
+      g_anc_assist_mode == ANC_ASSIST_MUSIC) {
     // close capture
   }
   // destroy

apps/anc/src/peak_detector.c

@@ -13,8 +13,8 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "math.h"
 #include "peak_detector.h"
+#include "math.h"
 
 // #define PKD_FACTOR_UP   (0.6)
 // #define PKD_FACTOR_DOWN (2.0)
@@ -31,49 +31,47 @@ static float pkd_reduce_rate = 1.0f;
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 
 // Depend on codec_dac_vol
-// const float pkd_vol_multiple[18] = {0.089125, 0.0, 0.005623, 0.007943, 0.011220, 0.015849, 0.022387, 0.031623, 0.044668, 0.063096, 0.089125, 0.125893, 0.177828, 0.251189, 0.354813, 0.501187, 0.707946, 1.000000};
+// const float pkd_vol_multiple[18] = {0.089125, 0.0, 0.005623, 0.007943,
+// 0.011220, 0.015849, 0.022387, 0.031623, 0.044668, 0.063096, 0.089125,
+// 0.125893, 0.177828, 0.251189, 0.354813, 0.501187, 0.707946, 1.000000};
 
 // static uint32_t test_num = 0;
 
 // int app_bt_stream_local_volume_get(void);
 
 // y = 20log(x)
-static inline float convert_multiple_to_db(float multiple)
+static inline float convert_multiple_to_db(float multiple) {
-{
   return 20 * (float)log10(multiple);
 }
 
 // x = 10^(y/20)
-static  inline float convert_db_to_multiple(float db)
+static inline float convert_db_to_multiple(float db) {
-{
   return (float)pow(10, db / 20);
 }
 
-void peak_detector_init(void)
+void peak_detector_init(void) {
-{
   pkd_alphaR = 0.0f;
   pkd_alphaA = 0.0f;
   pkd_factor1 = 0.0f;
   pkd_factor2 = 0.0f;
   pkd_reduce_rate = 1.0f;
-    // TRACE(3,"[%s] pkd_alphaR = %f, pkd_alphaA = %f", __func__, (double)pkd_alphaR, (double)pkd_alphaA);
+  // TRACE(3,"[%s] pkd_alphaR = %f, pkd_alphaA = %f", __func__,
+  // (double)pkd_alphaR, (double)pkd_alphaA);
 }
 
-void peak_detector_setup(PEAK_DETECTOR_CFG_T *cfg)
+void peak_detector_setup(PEAK_DETECTOR_CFG_T *cfg) {
-{
   pkd_samp_bits = cfg->bits;
   pkd_alphaR = (float)exp(-1 / (cfg->factor_down * cfg->fs));
   pkd_alphaA = (float)exp(-1 / (cfg->factor_up * cfg->fs));
   pkd_reduce_rate = convert_db_to_multiple(cfg->reduce_dB);
 }
 
-static void peak_detector_run_16bits(int16_t *buf, uint32_t len, float vol_multiple)
+static void peak_detector_run_16bits(int16_t *buf, uint32_t len,
-{
+                                     float vol_multiple) {
   float normal_rate = 1.0;
   float tgt_rate = 1.0;
 
-    for(uint32_t i = 0; i < len; i++)
+  for (uint32_t i = 0; i < len; i++) {
-    {   
     pkd_factor1 = Max(buf[i], pkd_alphaR * pkd_factor1);
     pkd_factor2 = pkd_alphaA * pkd_factor2 + (1 - pkd_alphaA) * pkd_factor1;
 
@@ -81,8 +79,7 @@ static void peak_detector_run_16bits(int16_t *buf, uint32_t len, float vol_multi
 
     tgt_rate = pkd_reduce_rate / normal_rate / vol_multiple;
 
-        if(tgt_rate > 1.0)
+    if (tgt_rate > 1.0) {
-        {
       tgt_rate = 1.0;
     }
 
@@ -108,11 +105,14 @@ static void peak_detector_run_16bits(int16_t *buf, uint32_t len, float vol_multi
   // {
   //  test_num = 0;
   //  TRACE(0,"START>>>");
-    //  TRACE(2,"vol_level = %d, pkd_vol_multiple = %f", vol_level, pkd_vol_multiple[vol_level]);
+  //  TRACE(2,"vol_level = %d, pkd_vol_multiple = %f", vol_level,
-    //  TRACE(3,"buf = %d, pkd_alphaR = %f, pkd_alphaA = %f", buf[len-1], pkd_alphaR, pkd_alphaA);
+  //  pkd_vol_multiple[vol_level]); TRACE(3,"buf = %d, pkd_alphaR = %f,
-    //  TRACE(4,"pkd_factor1 = %f, pkd_factor2 = %f, normal_rate = %f, tgt_rate = %f", pkd_factor1, pkd_factor2, normal_rate, tgt_rate);
+  //  pkd_alphaA = %f", buf[len-1], pkd_alphaR, pkd_alphaA);
-    //  TRACE(0,"END<<<");
+  //  TRACE(4,"pkd_factor1 = %f, pkd_factor2 = %f, normal_rate = %f, tgt_rate =
-    //  // TRACE(7,"[%s] buf = %d, pkd_alphaR = %f, pkd_alphaA = %f, pkd_factor1 = %f, pkd_factor2 = %f, normal_rate = %f", __func__, buf[len-1], pkd_alphaR, pkd_alphaA, pkd_factor1, pkd_factor2, (1.0 - pkd_factor2/32768));
+  //  %f", pkd_factor1, pkd_factor2, normal_rate, tgt_rate); TRACE(0,"END<<<");
+  //  // TRACE(7,"[%s] buf = %d, pkd_alphaR = %f, pkd_alphaA = %f, pkd_factor1 =
+  //  %f, pkd_factor2 = %f, normal_rate = %f", __func__, buf[len-1], pkd_alphaR,
+  //  pkd_alphaA, pkd_factor1, pkd_factor2, (1.0 - pkd_factor2/32768));
   // }
 
 #if 0
@@ -139,13 +139,12 @@ static void peak_detector_run_16bits(int16_t *buf, uint32_t len, float vol_multi
 #endif
 }
 
-static void peak_detector_run_24bits(int32_t *buf, uint32_t len, float vol_multiple)
+static void peak_detector_run_24bits(int32_t *buf, uint32_t len,
-{
+                                     float vol_multiple) {
   float normal_rate = 1.0;
   float tgt_rate = 1.0;
 
-    for(uint32_t i = 0; i < len; i++)
+  for (uint32_t i = 0; i < len; i++) {
-    {   
     pkd_factor1 = Max(buf[i], pkd_alphaR * pkd_factor1);
     pkd_factor2 = pkd_alphaA * pkd_factor2 + (1 - pkd_alphaA) * pkd_factor1;
 
@@ -153,8 +152,7 @@ static void peak_detector_run_24bits(int32_t *buf, uint32_t len, float vol_multi
 
     tgt_rate = pkd_reduce_rate / normal_rate / vol_multiple;
 
-        if(tgt_rate > 1.0)
+    if (tgt_rate > 1.0) {
-        {
       tgt_rate = 1.0;
     }
 
@@ -177,8 +175,7 @@ static void peak_detector_run_24bits(int32_t *buf, uint32_t len, float vol_multi
   }
 }
 
-void peak_detector_run(uint8_t *buf, uint32_t len, float vol_multiple)
+void peak_detector_run(uint8_t *buf, uint32_t len, float vol_multiple) {
-{
   // int vol_level = 0;
 
   if (pkd_samp_bits <= AUD_BITS_16) {
@@ -193,4 +190,3 @@ void peak_detector_run(uint8_t *buf, uint32_t len, float vol_multiple)
 
   // vol_level = app_bt_stream_local_volume_get();
 }
-

apps/apptester/app_audtest.cpp

@@ -13,20 +13,20 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_thread.h"
 #include "cmsis_os.h"
 #include "hal_trace.h"
-#include "app_thread.h"
 
-#include "hal_timer.h"
 #include "app_audtest_pattern.h"
+#include "hal_timer.h"
 
-#include "hal_aud.h"
+#include "app_utils.h"
-#include "audioflinger.h"
 #include "audiobuffer.h"
+#include "audioflinger.h"
+#include "eq_export.h"
+#include "hal_aud.h"
 #include "stdbool.h"
 #include <string.h>
-#include "eq_export.h"
-#include "app_utils.h"
 
 #if defined(APP_TEST_AUDIO) && defined(ANC_APP)
 #include "anc_usb_app.h"
@@ -66,53 +66,42 @@ static uint8_t ALIGNED4 app_test_recv_buff[USB_AUDIO_RECV_BUFF_SIZE];
 static uint8_t ALIGNED4 app_test_send_buff[USB_AUDIO_SEND_BUFF_SIZE];
 #endif
 
-uint32_t pcm_1ksin_more_data(uint8_t *buf, uint32_t len)
+uint32_t pcm_1ksin_more_data(uint8_t *buf, uint32_t len) {
-{
   static uint32_t nextPbufIdx = 0;
   uint32_t remain_size = len;
   uint32_t curr_size = 0;
-    static uint32_t pcm_preIrqTime = 0;;
+  static uint32_t pcm_preIrqTime = 0;
+  ;
   uint32_t stime = 0;
 
-
   stime = hal_sys_timer_get();
-    TRACE(3,"pcm_1ksin_more_data irqDur:%d readbuff:0x%08x %d\n ", TICKS_TO_MS(stime - pcm_preIrqTime), buf, len);
+  TRACE(3, "pcm_1ksin_more_data irqDur:%d readbuff:0x%08x %d\n ",
+        TICKS_TO_MS(stime - pcm_preIrqTime), buf, len);
   pcm_preIrqTime = stime;
 
   //  TRACE(2,"[pcm_1ksin_more_data] len=%d nextBuf:%d\n", len, nextPbufIdx);
-    if (remain_size > sizeof(sinwave))
+  if (remain_size > sizeof(sinwave)) {
-    {
     do {
-            if (nextPbufIdx)
+      if (nextPbufIdx) {
-            {
         curr_size = sizeof(sinwave) - nextPbufIdx;
         memcpy(buf, &sinwave[nextPbufIdx / 2], curr_size);
         remain_size -= curr_size;
         nextPbufIdx = 0;
-            }
+      } else if (remain_size > sizeof(sinwave)) {
-            else if (remain_size>sizeof(sinwave))
-            {
         memcpy(buf + curr_size, sinwave, sizeof(sinwave));
         curr_size += sizeof(sinwave);
         remain_size -= sizeof(sinwave);
-            }
+      } else {
-            else
-            {
         memcpy(buf + curr_size, sinwave, remain_size);
         nextPbufIdx = remain_size;
         remain_size = 0;
       }
     } while (remain_size);
-    }
+  } else {
-    else
+    if ((sizeof(sinwave) - nextPbufIdx) >= len) {
-    {
-        if ((sizeof(sinwave) - nextPbufIdx) >= len)
-        {
       memcpy(buf, &sinwave[nextPbufIdx / 2], len);
       nextPbufIdx += len;
-        }
+    } else {
-        else
-        {
       curr_size = sizeof(sinwave) - nextPbufIdx;
       memcpy(buf, &sinwave[nextPbufIdx / 2], curr_size);
       nextPbufIdx = len - curr_size;
@@ -123,14 +112,12 @@ uint32_t pcm_1ksin_more_data(uint8_t *buf, uint32_t len)
   return 0;
 }
 
-uint32_t pcm_mute_more_data(uint8_t *buf, uint32_t len)
+uint32_t pcm_mute_more_data(uint8_t *buf, uint32_t len) {
-{
   memset(buf, 0, len);
   return 0;
 }
 
-void da_output_sin1k(bool  on)
+void da_output_sin1k(bool on) {
-{
   static bool isRun = false;
   struct AF_STREAM_CONFIG_T stream_cfg;
   memset(&stream_cfg, 0, sizeof(stream_cfg));
@@ -160,21 +147,16 @@ void da_output_sin1k(bool  on)
     af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
     af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
   }
-
 }
 
-void da_tester(uint8_t on)
+void da_tester(uint8_t on) { da_output_sin1k(on); }
-{
-	da_output_sin1k(on);
-}
 
 extern int voicecvsd_audio_init(void);
 extern uint32_t voicecvsd_audio_more_data(uint8_t *buf, uint32_t len);
 extern int get_voicecvsd_buffer_size(void);
 extern int store_voice_pcm2cvsd(unsigned char *buf, unsigned int len);
 
-static uint32_t pcm_data_capture(uint8_t *buf, uint32_t len)
+static uint32_t pcm_data_capture(uint8_t *buf, uint32_t len) {
-{
   uint32_t stime, etime;
   static uint32_t preIrqTime = 0;
 
@@ -182,26 +164,26 @@ static uint32_t pcm_data_capture(uint8_t *buf, uint32_t len)
   //  audio_buffer_set_stereo2mono_16bits(buf, len, 1);
   audio_buffer_set(buf, len);
   etime = hal_sys_timer_get();
-    TRACE(4,"%s irqDur:%d fsSpend:%d, Len:%d", __func__, TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
+  TRACE(4, "%s irqDur:%d fsSpend:%d, Len:%d", __func__,
+        TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
   preIrqTime = stime;
   return 0;
 }
 
-static uint32_t pcm_data_playback(uint8_t *buf, uint32_t len)
+static uint32_t pcm_data_playback(uint8_t *buf, uint32_t len) {
-{
   uint32_t stime, etime;
   static uint32_t preIrqTime = 0;
   stime = hal_sys_timer_get();
   //  audio_buffer_get_mono2stereo_16bits(buf, len);
   audio_buffer_get(buf, len);
   etime = hal_sys_timer_get();
-    TRACE(4,"%s irqDur:%d fsSpend:%d, Len:%d", __func__, TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
+  TRACE(4, "%s irqDur:%d fsSpend:%d, Len:%d", __func__,
+        TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
   preIrqTime = stime;
   return 0;
 }
 
-uint32_t pcm_cvsd_data_capture(uint8_t *buf, uint32_t len)
+uint32_t pcm_cvsd_data_capture(uint8_t *buf, uint32_t len) {
-{
   uint32_t stime, etime;
   static uint32_t preIrqTime = 0;
 
@@ -211,13 +193,13 @@ uint32_t pcm_cvsd_data_capture(uint8_t *buf, uint32_t len)
   audio_stereo2mono_16bits(0, (uint16_t *)buf, (uint16_t *)buf, len);
   store_voice_pcm2cvsd(buf, len);
   etime = hal_sys_timer_get();
-    TRACE(4,"%s exit irqDur:%d fsSpend:%d, add:%d", __func__, TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
+  TRACE(4, "%s exit irqDur:%d fsSpend:%d, add:%d", __func__,
+        TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
   preIrqTime = stime;
   return 0;
 }
 
-uint32_t pcm_cvsd_data_playback(uint8_t *buf, uint32_t len)
+uint32_t pcm_cvsd_data_playback(uint8_t *buf, uint32_t len) {
-{
   int n;
   uint32_t stime, etime;
   static uint32_t preIrqTime = 0;
@@ -228,13 +210,14 @@ uint32_t pcm_cvsd_data_playback(uint8_t *buf, uint32_t len)
   voicecvsd_audio_more_data(buf, len);
   n = get_voicecvsd_buffer_size();
   etime = hal_sys_timer_get();
-    TRACE(5,"%s exit irqDur:%d fsSpend:%d, get:%d remain:%d", __func__, TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len, n);
+  TRACE(5, "%s exit irqDur:%d fsSpend:%d, get:%d remain:%d", __func__,
+        TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len, n);
   preIrqTime = stime;
   return 0;
 }
 
-void adc_looptester(bool on, enum AUD_IO_PATH_T input_path, enum AUD_SAMPRATE_T sample_rate)
+void adc_looptester(bool on, enum AUD_IO_PATH_T input_path,
-{
+                    enum AUD_SAMPRATE_T sample_rate) {
   struct AF_STREAM_CONFIG_T stream_cfg;
 
   static bool isRun = false;
@@ -280,11 +263,11 @@ void adc_looptester(bool on, enum AUD_IO_PATH_T input_path, enum AUD_SAMPRATE_T
 }
 
 #if defined(APP_TEST_AUDIO) && defined(ANC_APP)
-void app_anc_usb_init(void)
+void app_anc_usb_init(void) {
-{
   app_sysfreq_req(APP_SYSFREQ_USER_APP_0, APP_SYSFREQ_52M);
 
-    anc_usb_app_init(AUD_INPUT_PATH_MAINMIC, AUD_SAMPRATE_96000, AUD_SAMPRATE_192000);
+  anc_usb_app_init(AUD_INPUT_PATH_MAINMIC, AUD_SAMPRATE_96000,
+                   AUD_SAMPRATE_192000);
 
   struct USB_AUDIO_BUF_CFG cfg;
 
@@ -300,8 +283,8 @@ void app_anc_usb_init(void)
 
   usb_audio_app_init(&cfg);
 
-    //dualadc_audio_app_init(app_test_playback_buff, USB_AUDIO_PLAYBACK_BUFF_SIZE,
+  // dualadc_audio_app_init(app_test_playback_buff,
-        //app_test_capture_buff, USB_AUDIO_CAPTURE_BUFF_SIZE);
+  // USB_AUDIO_PLAYBACK_BUFF_SIZE, app_test_capture_buff,
+  // USB_AUDIO_CAPTURE_BUFF_SIZE);
 }
 #endif
-

apps/apptester/audiobuffer.c

@@ -13,11 +13,10 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "audiobuffer.h"
 #include "cmsis_os.h"
 #include "cqueue.h"
 #include "string.h"
-#include "audiobuffer.h"
-
 
 #ifndef _AUDIO_NO_THREAD_
 static osMutexId g_audio_queue_mutex_id = NULL;
@@ -25,36 +24,36 @@ osMutexDef(g_audio_queue_mutex);
 #endif
 
 static CQueue audio_queue;
-static unsigned char audio_queue_buf[AUDIO_BUFFER_FRAME_SIZE*AUDIO_BUFFER_FRAME_NUM];
+static unsigned char
+    audio_queue_buf[AUDIO_BUFFER_FRAME_SIZE * AUDIO_BUFFER_FRAME_NUM];
 
-void audio_mono2stereo_16bits(uint16_t *dst_buf, uint16_t *src_buf, uint32_t src_len)
+void audio_mono2stereo_16bits(uint16_t *dst_buf, uint16_t *src_buf,
-{
+                              uint32_t src_len) {
   uint32_t i = 0;
   for (i = 0; i < src_len; ++i) {
     dst_buf[i * 2 + 0] = dst_buf[i * 2 + 1] = src_buf[i];
   }
 }
 
-void audio_stereo2mono_16bits(uint8_t chnlsel, uint16_t *dst_buf, uint16_t *src_buf, uint32_t src_len)
+void audio_stereo2mono_16bits(uint8_t chnlsel, uint16_t *dst_buf,
-{
+                              uint16_t *src_buf, uint32_t src_len) {
   uint32_t i = 0;
   for (i = 0; i < src_len; i += 2) {
     dst_buf[i / 2] = src_buf[i + chnlsel];
   }
 }
 
-void audio_buffer_init(void)
+void audio_buffer_init(void) {
-{
 #ifndef _AUDIO_NO_THREAD_
   if (g_audio_queue_mutex_id == NULL)
     g_audio_queue_mutex_id = osMutexCreate((osMutex(g_audio_queue_mutex)));
 #endif
-	InitCQueue(&audio_queue, sizeof(audio_queue_buf), (unsigned char *)&audio_queue_buf);
+  InitCQueue(&audio_queue, sizeof(audio_queue_buf),
+             (unsigned char *)&audio_queue_buf);
   memset(&audio_queue_buf, 0x00, sizeof(audio_queue_buf));
 }
 
-int audio_buffer_length(void)
+int audio_buffer_length(void) {
-{
   int len;
 #ifndef _AUDIO_NO_THREAD_
   osMutexWait(g_audio_queue_mutex_id, osWaitForever);
@@ -66,8 +65,7 @@ int audio_buffer_length(void)
   return len;
 }
 
-int audio_buffer_set(uint8_t *buff, uint16_t len)
+int audio_buffer_set(uint8_t *buff, uint16_t len) {
-{
   int status;
 
 #ifndef _AUDIO_NO_THREAD_
@@ -80,8 +78,7 @@ int audio_buffer_set(uint8_t *buff, uint16_t len)
   return status;
 }
 
-int audio_buffer_get(uint8_t *buff, uint16_t len)
+int audio_buffer_get(uint8_t *buff, uint16_t len) {
-{
   uint8_t *e1 = NULL, *e2 = NULL;
   unsigned int len1 = 0, len2 = 0;
   int status;
@@ -104,14 +101,15 @@ int audio_buffer_get(uint8_t *buff, uint16_t len)
   return status;
 }
 
-int audio_buffer_set_stereo2mono_16bits(uint8_t *buff, uint16_t len, uint8_t chnlsel)
+int audio_buffer_set_stereo2mono_16bits(uint8_t *buff, uint16_t len,
-{
+                                        uint8_t chnlsel) {
   int status;
 
 #ifndef _AUDIO_NO_THREAD_
   osMutexWait(g_audio_queue_mutex_id, osWaitForever);
 #endif
-		audio_stereo2mono_16bits(chnlsel, (uint16_t *)buff, (uint16_t *)buff, len>>1);
+  audio_stereo2mono_16bits(chnlsel, (uint16_t *)buff, (uint16_t *)buff,
+                           len >> 1);
   status = EnCQueue(&audio_queue, buff, len >> 1);
 #ifndef _AUDIO_NO_THREAD_
   osMutexRelease(g_audio_queue_mutex_id);
@@ -119,8 +117,7 @@ int audio_buffer_set_stereo2mono_16bits(uint8_t *buff, uint16_t len, uint8_t chn
   return status;
 }
 
-int audio_buffer_get_mono2stereo_16bits(uint8_t *buff, uint16_t len)
+int audio_buffer_get_mono2stereo_16bits(uint8_t *buff, uint16_t len) {
-{
   uint8_t *e1 = NULL, *e2 = NULL;
   unsigned int len1 = 0, len2 = 0;
   int status;
@@ -131,7 +128,8 @@ int audio_buffer_get_mono2stereo_16bits(uint8_t *buff, uint16_t len)
   status = PeekCQueue(&audio_queue, len >> 1, &e1, &len1, &e2, &len2);
   if (len >> 1 == len1 + len2) {
     audio_mono2stereo_16bits((uint16_t *)buff, (uint16_t *)e1, len1 >> 1);
-		audio_mono2stereo_16bits((uint16_t *)(buff+(len1<<1)), (uint16_t *)e2, len2>>1);
+    audio_mono2stereo_16bits((uint16_t *)(buff + (len1 << 1)), (uint16_t *)e2,
+                             len2 >> 1);
     DeCQueue(&audio_queue, 0, len1);
     DeCQueue(&audio_queue, 0, len2);
     status = len;

apps/audioplayers/a2dp_decoder/a2dp_decoder_aac_lc.cpp

@@ -14,19 +14,19 @@
  *
  ****************************************************************************/
 // Standard C Included Files
+#include "a2dp_decoder_internal.h"
 #include "cmsis.h"
-#include "plat_types.h"
+#include "cmsis_os.h"
-#include <string.h>
-#include "heap_api.h"
 #include "hal_location.h"
 #include "hal_timer.h"
-#include "a2dp_decoder_internal.h"
+#include "heap_api.h"
-#include "cmsis_os.h"
+#include "plat_types.h"
+#include <string.h>
 
 #if defined(A2DP_AAC_ON)
-#include "heap_api.h"
 #include "aacdecoder_lib.h"
 #include "aacenc_lib.h"
+#include "heap_api.h"
 
 #ifndef AAC_MTU_LIMITER
 #define AAC_MTU_LIMITER (32) /*must <= 23*/
@@ -59,30 +59,32 @@ static A2DP_AUDIO_DECODER_LASTFRAME_INFO_T a2dp_audio_aac_lastframe_info;
 static uint16_t aac_mtu_limiter = AAC_MTU_LIMITER;
 
 static a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_reorder_p = NULL;
-static a2dp_audio_aac_decoder_frame_t aac_decoder_last_valid_frame = {0,};
+static a2dp_audio_aac_decoder_frame_t aac_decoder_last_valid_frame = {
+    0,
+};
 static bool aac_decoder_last_valid_frame_ready = false;
 
-static void *a2dp_audio_aac_lc_frame_malloc(uint32_t packet_len)
+static void *a2dp_audio_aac_lc_frame_malloc(uint32_t packet_len) {
-{
   a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p = NULL;
   uint8_t *aac_buffer = NULL;
 
   aac_buffer = (uint8_t *)a2dp_audio_heap_malloc(AAC_READBUF_SIZE);
-    aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_heap_malloc(sizeof(a2dp_audio_aac_decoder_frame_t));
+  aac_decoder_frame_p =
+      (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_heap_malloc(
+          sizeof(a2dp_audio_aac_decoder_frame_t));
   aac_decoder_frame_p->aac_buffer = aac_buffer;
   aac_decoder_frame_p->aac_buffer_len = packet_len;
   return (void *)aac_decoder_frame_p;
 }
 
-static void a2dp_audio_aac_lc_free(void *packet)
+static void a2dp_audio_aac_lc_free(void *packet) {
-{
+  a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p =
-    a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)packet;
+      (a2dp_audio_aac_decoder_frame_t *)packet;
   a2dp_audio_heap_free(aac_decoder_frame_p->aac_buffer);
   a2dp_audio_heap_free(aac_decoder_frame_p);
 }
 
-static void a2dp_audio_aac_lc_decoder_init(void)
+static void a2dp_audio_aac_lc_decoder_init(void) {
-{
   if (aacDec_handle == NULL) {
     TRANSPORT_TYPE transportFmt = TT_MP4_LATM_MCP1;
 
@@ -95,16 +97,14 @@ static void a2dp_audio_aac_lc_decoder_init(void)
   }
 }
 
-static void a2dp_audio_aac_lc_decoder_deinit(void)
+static void a2dp_audio_aac_lc_decoder_deinit(void) {
-{
   if (aacDec_handle) {
     aacDecoder_Close(aacDec_handle);
     aacDec_handle = NULL;
   }
 }
 
-static void a2dp_audio_aac_lc_decoder_reinit(void)
+static void a2dp_audio_aac_lc_decoder_reinit(void) {
-{
   if (aacDec_handle) {
     a2dp_audio_aac_lc_decoder_deinit();
   }
@@ -133,16 +133,14 @@ extern uint32_t app_bt_stream_get_dma_buffer_samples(void);
 
 int a2dp_cp_aac_lc_cp_decode(void);
 
-static int TEXT_AAC_LOC a2dp_cp_aac_lc_after_cache_underflow(void)
+static int TEXT_AAC_LOC a2dp_cp_aac_lc_after_cache_underflow(void) {
-{
 #ifdef A2DP_CP_ACCEL
   cp_codec_reset = true;
 #endif
   return 0;
 }
 
-static int a2dp_cp_aac_lc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
+static int a2dp_cp_aac_lc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes) {
-{
   a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p = NULL;
   list_node_t *node = NULL;
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
@@ -154,13 +152,15 @@ static int a2dp_cp_aac_lc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
   uint32_t out_frame_len;
   uint32_t check_sum = 0;
 
-
   uint32_t cp_buffer_frames_max = 0;
   cp_buffer_frames_max = app_bt_stream_get_dma_buffer_samples() / 2;
   if (cp_buffer_frames_max % (a2dp_audio_aac_lastframe_info.frame_samples)) {
-        cp_buffer_frames_max =  cp_buffer_frames_max /(a2dp_audio_aac_lastframe_info.frame_samples) +1  ;
+    cp_buffer_frames_max =
+        cp_buffer_frames_max / (a2dp_audio_aac_lastframe_info.frame_samples) +
+        1;
   } else {
-        cp_buffer_frames_max =  cp_buffer_frames_max /(a2dp_audio_aac_lastframe_info.frame_samples) ;
+    cp_buffer_frames_max =
+        cp_buffer_frames_max / (a2dp_audio_aac_lastframe_info.frame_samples);
   }
 
   out_frame_len = sizeof(*p_out_info) + buffer_bytes;
@@ -172,23 +172,28 @@ static int a2dp_cp_aac_lc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
     return A2DP_DECODER_DECODE_ERROR;
   }
   while ((node = a2dp_audio_list_begin(list)) != NULL) {
-        aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+    aac_decoder_frame_p =
+        (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
 
     in_info.sequenceNumber = aac_decoder_frame_p->sequenceNumber;
     in_info.timestamp = aac_decoder_frame_p->timestamp;
 
-        ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info), aac_decoder_frame_p->aac_buffer, aac_decoder_frame_p->aac_buffer_len);
+    ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info),
+                               aac_decoder_frame_p->aac_buffer,
+                               aac_decoder_frame_p->aac_buffer_len);
     if (ret) {
       TRACE_A2DP_DECODER_D("[MCU][AAC] piff !!!!!!ret: %d ", ret);
       break;
     }
-        check_sum = a2dp_audio_decoder_internal_check_sum_generate(aac_decoder_frame_p->aac_buffer, aac_decoder_frame_p->aac_buffer_len);
+    check_sum = a2dp_audio_decoder_internal_check_sum_generate(
+        aac_decoder_frame_p->aac_buffer, aac_decoder_frame_p->aac_buffer_len);
     a2dp_audio_list_remove(list, aac_decoder_frame_p);
   }
   ret = a2dp_cp_get_full_out_frame((void **)&out, &out_len);
   if (ret) {
     if (!get_in_cp_frame_cnt()) {
-            TRACE_A2DP_DECODER_I("[MCU][AAC] cp cache underflow list:%d in_cp:%d",a2dp_audio_list_length(list), get_in_cp_frame_cnt());
+      TRACE_A2DP_DECODER_I("[MCU][AAC] cp cache underflow list:%d in_cp:%d",
+                           a2dp_audio_list_length(list), get_in_cp_frame_cnt());
       return A2DP_DECODER_CACHE_UNDERFLOW_ERROR;
     }
     if (!a2dp_audio_sysfreq_boost_running()) {
@@ -197,7 +202,8 @@ static int a2dp_cp_aac_lc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
     osDelay(12);
     ret = a2dp_cp_get_full_out_frame((void **)&out, &out_len);
     if (ret) {
-            TRACE_A2DP_DECODER_I("[MCU][AAC] cp cache underflow list:%d in_cp:%d",a2dp_audio_list_length(list), get_in_cp_frame_cnt());
+      TRACE_A2DP_DECODER_I("[MCU][AAC] cp cache underflow list:%d in_cp:%d",
+                           a2dp_audio_list_length(list), get_in_cp_frame_cnt());
       a2dp_cp_aac_lc_after_cache_underflow();
       return A2DP_DECODER_CACHE_UNDERFLOW_ERROR;
     }
@@ -210,22 +216,27 @@ static int a2dp_cp_aac_lc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
     return A2DP_DECODER_NO_ERROR;
   }
   if (out_len != out_frame_len) {
-        TRACE_A2DP_DECODER_I("[MCU][AAC] Bad out len %u (should be %u)", out_len, out_frame_len);
+    TRACE_A2DP_DECODER_I("[MCU][AAC] Bad out len %u (should be %u)", out_len,
+                         out_frame_len);
     set_cp_reset_flag(true);
     return A2DP_DECODER_DECODE_ERROR;
   }
   p_out_info = (struct A2DP_CP_AAC_LC_OUT_FRM_INFO_T *)out;
   if (p_out_info->pcm_len) {
-        a2dp_audio_aac_lastframe_info.sequenceNumber = p_out_info->in_info.sequenceNumber;
+    a2dp_audio_aac_lastframe_info.sequenceNumber =
+        p_out_info->in_info.sequenceNumber;
     a2dp_audio_aac_lastframe_info.timestamp = p_out_info->in_info.timestamp;
     a2dp_audio_aac_lastframe_info.curSubSequenceNumber = 0;
     a2dp_audio_aac_lastframe_info.totalSubSequenceNumber = 0;
     a2dp_audio_aac_lastframe_info.frame_samples = p_out_info->frame_samples;
     a2dp_audio_aac_lastframe_info.decoded_frames += p_out_info->decoded_frames;
     a2dp_audio_aac_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_list_length(list) +
-        a2dp_audio_aac_lastframe_info.check_sum= check_sum?check_sum:a2dp_audio_aac_lastframe_info.check_sum;
+        a2dp_cp_get_in_frame_cnt_by_index(p_out_info->frame_idx) - 1;
-        a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_aac_lastframe_info);
+    a2dp_audio_aac_lastframe_info.check_sum =
+        check_sum ? check_sum : a2dp_audio_aac_lastframe_info.check_sum;
+    a2dp_audio_decoder_internal_lastframe_info_set(
+        &a2dp_audio_aac_lastframe_info);
   }
 
   if (p_out_info->pcm_len == buffer_bytes) {
@@ -240,26 +251,24 @@ static int a2dp_cp_aac_lc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
   ret = a2dp_cp_consume_full_out_frame();
   if (ret) {
 
-        TRACE_A2DP_DECODER_I("[MCU][AAC] cp consume_full_out_frame() failed: ret=%d", ret);
+    TRACE_A2DP_DECODER_I(
+        "[MCU][AAC] cp consume_full_out_frame() failed: ret=%d", 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)
+int cp_assert(void) {
-{
   _cp_assert = true;
   return 0;
 }
 #endif
 
 TEXT_AAC_LOC
-int a2dp_cp_aac_lc_cp_decode(void)
+int a2dp_cp_aac_lc_cp_decode(void) {
-{
   int ret;
   enum CP_EMPTY_OUT_FRM_T out_frm_st;
   uint8_t *out;
@@ -290,17 +299,22 @@ int a2dp_cp_aac_lc_cp_decode(void)
   }
 #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) {
+  if (out_frm_st != CP_EMPTY_OUT_FRM_OK &&
+      out_frm_st != CP_EMPTY_OUT_FRM_WORKING) {
     return 1;
   }
-    ASSERT_A2DP_DECODER(out_len > sizeof(*p_out_info), "%s: Bad out_len %u (should > %u)", __func__, out_len, sizeof(*p_out_info));
+  ASSERT_A2DP_DECODER(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_AAC_LC_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_A2DP_DECODER(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);
+  ASSERT_A2DP_DECODER(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);
@@ -322,7 +336,9 @@ int a2dp_cp_aac_lc_cp_decode(void)
     if (ret) {
       return 4;
     }
-        ASSERT_A2DP_DECODER(in_len > sizeof(*p_in_info), "[CP][AAC] Bad in_len %u (should > %u)", in_len, sizeof(*p_in_info));
+    ASSERT_A2DP_DECODER(in_len > sizeof(*p_in_info),
+                        "[CP][AAC] Bad in_len %u (should > %u)", in_len,
+                        sizeof(*p_in_info));
 
     p_in_info = (struct A2DP_CP_AAC_LC_IN_FRM_INFO_T *)in_buf;
     if (need_refill) {
@@ -344,7 +360,8 @@ int a2dp_cp_aac_lc_cp_decode(void)
 
     bufferSize = aac_maxreadBytes;
     bytesValid = aac_maxreadBytes;
-        decoder_err = aacDecoder_Fill(aacDec_handle, &in_buf, &bufferSize, &bytesValid);
+    decoder_err =
+        aacDecoder_Fill(aacDec_handle, &in_buf, &bufferSize, &bytesValid);
     if (decoder_err != AAC_DEC_OK) {
       TRACE_A2DP_DECODER_W("[CP][AAC] decoder_Fill failed:0x%x", decoder_err);
       // if aac failed reopen it again
@@ -357,19 +374,23 @@ int a2dp_cp_aac_lc_cp_decode(void)
     }
 
     /* decode one AAC frame */
-        decoder_err = aacDecoder_DecodeFrame(aacDec_handle, (short *)(dec_start + dec_sum), (dec_len - dec_sum) / 2, 0 /* flags */);
+    decoder_err =
-        TRACE_A2DP_DECODER_D("[CP][AAC] decoder seq:%d len:%d err:%x", p_in_info->sequenceNumber,
+        aacDecoder_DecodeFrame(aacDec_handle, (short *)(dec_start + dec_sum),
-                                                                (dec_len - dec_sum),
+                               (dec_len - dec_sum) / 2, 0 /* flags */);
+    TRACE_A2DP_DECODER_D("[CP][AAC] decoder seq:%d len:%d err:%x",
+                         p_in_info->sequenceNumber, (dec_len - dec_sum),
                          decoder_err);
     if (decoder_err != AAC_DEC_OK) {
-            TRACE_A2DP_DECODER_W("[CP][AAC] aac_lc_decode failed:0x%x seq:%d", decoder_err, p_in_info->sequenceNumber);
+      TRACE_A2DP_DECODER_W("[CP][AAC] aac_lc_decode failed:0x%x seq:%d",
+                           decoder_err, p_in_info->sequenceNumber);
       // if aac failed reopen it again
       a2dp_audio_aac_lc_decoder_reinit();
       TRACE_A2DP_DECODER_I("[CP][AAC]aac_lc_decode reinin codec \n");
       if (!need_refill) {
         need_refill = true;
         ret = a2dp_cp_consume_in_frame();
-                ASSERT(ret == 0, "%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);
         continue;
       } else {
         need_refill = false;
@@ -385,8 +406,11 @@ int a2dp_cp_aac_lc_cp_decode(void)
       goto end_decode;
     }
 
-        bufferSize = stream_info->frameSize * stream_info->numChannels * 2;//sizeof(pcm_buffer[0]);
+    bufferSize = stream_info->frameSize * stream_info->numChannels *
-        ASSERT_A2DP_DECODER(AAC_OUTPUT_FRAME_SAMPLES == bufferSize/4, "aac_lc_decode output mismatch samples:%d", bufferSize/4);
+                 2; // sizeof(pcm_buffer[0]);
+    ASSERT_A2DP_DECODER(AAC_OUTPUT_FRAME_SAMPLES == bufferSize / 4,
+                        "aac_lc_decode output mismatch samples:%d",
+                        bufferSize / 4);
 
     dec_sum += bufferSize;
 
@@ -396,10 +420,12 @@ end_decode:
     p_out_info->frame_samples = AAC_OUTPUT_FRAME_SAMPLES;
     p_out_info->frame_idx = a2dp_cp_get_in_frame_index();
     if (need_refill) {
-            TRACE_A2DP_DECODER_W("[CP][AAC] resume refill seq:%d", p_in_info->sequenceNumber);
+      TRACE_A2DP_DECODER_W("[CP][AAC] resume refill seq:%d",
+                           p_in_info->sequenceNumber);
     } else {
       ret = a2dp_cp_consume_in_frame();
-            ASSERT_A2DP_DECODER(ret == 0, "[CP][AAC] a2dp_cp_consume_in_frame() failed: ret=%d", ret);
+      ASSERT_A2DP_DECODER(
+          ret == 0, "[CP][AAC] a2dp_cp_consume_in_frame() failed: ret=%d", ret);
     }
   }
 
@@ -407,22 +433,24 @@ end_decode:
 
   if (error || out_len <= sizeof(*p_out_info) + p_out_info->pcm_len) {
     ret = a2dp_cp_consume_emtpy_out_frame();
-        ASSERT_A2DP_DECODER(ret == 0, "[CP][AAC] a2dp_cp_consume_emtpy_out_frame() failed: ret=%d", ret);
+    ASSERT_A2DP_DECODER(
+        ret == 0, "[CP][AAC] a2dp_cp_consume_emtpy_out_frame() failed: ret=%d",
+        ret);
   }
 
   return error;
 }
 #endif
 
-static int a2dp_audio_aac_lc_list_checker(void)
+static int a2dp_audio_aac_lc_list_checker(void) {
-{
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
   list_node_t *node = NULL;
   a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p = NULL;
   int cnt = 0;
 
   do {
-        aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(0);
+    aac_decoder_frame_p =
+        (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(0);
     if (aac_decoder_frame_p) {
       a2dp_audio_list_append(list, aac_decoder_frame_p);
     }
@@ -431,21 +459,22 @@ static int a2dp_audio_aac_lc_list_checker(void)
 
   do {
     if ((node = a2dp_audio_list_begin(list)) != NULL) {
-            aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+      aac_decoder_frame_p =
+          (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
       a2dp_audio_list_remove(list, aac_decoder_frame_p);
     }
   } while (node);
 
-    TRACE_A2DP_DECODER_I("[AAC][INIT] cnt:%d list:%d",  cnt, a2dp_audio_list_length(list));
+  TRACE_A2DP_DECODER_I("[AAC][INIT] cnt:%d list:%d", cnt,
+                       a2dp_audio_list_length(list));
 
   return 0;
 }
 
-int a2dp_audio_aac_lc_channel_select(A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel)
+int a2dp_audio_aac_lc_channel_select(A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel) {
-{   
+  AAC_DECODER_CHANNEL_SELECT_E aac_decoder_channel_select =
-    AAC_DECODER_CHANNEL_SELECT_E aac_decoder_channel_select = AAC_DECODER_CHANNEL_SELECT_SELECT_STEREO;
+      AAC_DECODER_CHANNEL_SELECT_SELECT_STEREO;
-    switch(chnl_sel)
+  switch (chnl_sel) {
-    {
   case A2DP_AUDIO_CHANNEL_SELECT_STEREO:
     aac_decoder_channel_select = AAC_DECODER_CHANNEL_SELECT_SELECT_STEREO;
     break;
@@ -465,19 +494,22 @@ int a2dp_audio_aac_lc_channel_select(A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel)
   return 0;
 }
 
-int a2dp_audio_aac_lc_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context)
+int a2dp_audio_aac_lc_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context) {
-{
   TRACE_A2DP_DECODER_I("[AAC] init");
 
   a2dp_audio_context_p = (A2DP_AUDIO_CONTEXT_T *)context;
 
-    memset(&a2dp_audio_aac_lastframe_info, 0, sizeof(A2DP_AUDIO_DECODER_LASTFRAME_INFO_T));
+  memset(&a2dp_audio_aac_lastframe_info, 0,
+         sizeof(A2DP_AUDIO_DECODER_LASTFRAME_INFO_T));
   a2dp_audio_aac_lastframe_info.stream_info = *config;
   a2dp_audio_aac_lastframe_info.frame_samples = AAC_OUTPUT_FRAME_SAMPLES;
   a2dp_audio_aac_lastframe_info.list_samples = AAC_OUTPUT_FRAME_SAMPLES;
-    a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_aac_lastframe_info);
+  a2dp_audio_decoder_internal_lastframe_info_set(
+      &a2dp_audio_aac_lastframe_info);
 
-    ASSERT_A2DP_DECODER(a2dp_audio_context_p->dest_packet_mut < AAC_MTU_LIMITER, "%s MTU OVERFLOW:%u/%u", __func__, a2dp_audio_context_p->dest_packet_mut, AAC_MTU_LIMITER);
+  ASSERT_A2DP_DECODER(a2dp_audio_context_p->dest_packet_mut < AAC_MTU_LIMITER,
+                      "%s MTU OVERFLOW:%u/%u", __func__,
+                      a2dp_audio_context_p->dest_packet_mut, AAC_MTU_LIMITER);
 
   aac_mempoll = (uint8_t *)a2dp_audio_heap_malloc(AAC_MEMPOOL_SIZE);
   ASSERT_A2DP_DECODER(aac_mempoll, "aac_mempoll = NULL");
@@ -488,7 +520,8 @@ int a2dp_audio_aac_lc_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context)
 
   cp_codec_reset = true;
   ret = a2dp_cp_init(a2dp_cp_aac_lc_cp_decode, CP_PROC_DELAY_2_FRAMES);
-    ASSERT_A2DP_DECODER(ret == 0, "%s: a2dp_cp_init() failed: ret=%d", __func__, ret);
+  ASSERT_A2DP_DECODER(ret == 0, "%s: a2dp_cp_init() failed: ret=%d", __func__,
+                      ret);
 #else
   a2dp_audio_aac_lc_decoder_init();
 #endif
@@ -500,9 +533,7 @@ int a2dp_audio_aac_lc_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context)
   return A2DP_DECODER_NO_ERROR;
 }
 
-
+int a2dp_audio_aac_lc_deinit(void) {
-int a2dp_audio_aac_lc_deinit(void)
-{
 #ifdef A2DP_CP_ACCEL
   a2dp_cp_deinit();
 #endif
@@ -511,14 +542,14 @@ int a2dp_audio_aac_lc_deinit(void)
   size_t total = 0, used = 0, max_used = 0;
   heap_memory_info(aac_memhandle, &total, &used, &max_used);
   a2dp_audio_heap_free(aac_mempoll);
-    TRACE_A2DP_DECODER_I("[AAC] deinit MEM: total - %d, used - %d, max_used - %d.",
+  TRACE_A2DP_DECODER_I(
-        total, used, max_used);
+      "[AAC] deinit MEM: total - %d, used - %d, max_used - %d.", total, used,
+      max_used);
 
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_aac_lc_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_aac_decoder_frame_t *aac_decoder_frame_p = NULL;
@@ -546,7 +577,8 @@ int a2dp_audio_aac_lc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
     cache_underflow = true;
     goto exit;
   } else {
-        aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+    aac_decoder_frame_p =
+        (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
 
     if (aac_decoder_frame_p->aac_buffer_len < 64)
       aac_maxreadBytes = 64;
@@ -561,9 +593,12 @@ int a2dp_audio_aac_lc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
 
     bufferSize = aac_maxreadBytes;
     bytesValid = aac_maxreadBytes;
-        decoder_err = aacDecoder_Fill(aacDec_handle, &(aac_decoder_frame_p->aac_buffer), &bufferSize, &bytesValid);
+    decoder_err =
+        aacDecoder_Fill(aacDec_handle, &(aac_decoder_frame_p->aac_buffer),
+                        &bufferSize, &bytesValid);
     if (decoder_err != AAC_DEC_OK) {
-            TRACE_A2DP_DECODER_W("[MCU][AAC] aacDecoder_Fill failed:0x%x", decoder_err);
+      TRACE_A2DP_DECODER_W("[MCU][AAC] aacDecoder_Fill failed:0x%x",
+                           decoder_err);
       // if aac failed reopen it again
       if (is_aacDecoder_Close(aacDec_handle)) {
         a2dp_audio_aac_lc_decoder_reinit();
@@ -573,10 +608,11 @@ int a2dp_audio_aac_lc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
     }
 
     /* decode one AAC frame */
-        decoder_err = aacDecoder_DecodeFrame(aacDec_handle, (short *)buffer, buffer_bytes/2, 0 /* flags */);
+    decoder_err = aacDecoder_DecodeFrame(aacDec_handle, (short *)buffer,
-        TRACE_A2DP_DECODER_D("[MCU][AAC] decoder seq:%d len:%d err:%x", aac_decoder_frame_p->sequenceNumber,
+                                         buffer_bytes / 2, 0 /* flags */);
-                                                                aac_decoder_frame_p->aac_buffer_len,
+    TRACE_A2DP_DECODER_D("[MCU][AAC] decoder seq:%d len:%d err:%x",
-                                                                decoder_err);
+                         aac_decoder_frame_p->sequenceNumber,
+                         aac_decoder_frame_p->aac_buffer_len, decoder_err);
     if (decoder_err != AAC_DEC_OK) {
       TRACE_A2DP_DECODER_W("[MCU][AAC]aac_lc_decode failed:0x%x", decoder_err);
       // if aac failed reopen it again
@@ -593,32 +629,41 @@ int a2dp_audio_aac_lc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
       goto end_decode;
     }
 
-        output_byte = stream_info->frameSize * stream_info->numChannels * 2;//sizeof(pcm_buffer[0]);
+    output_byte = stream_info->frameSize * stream_info->numChannels *
-        ASSERT_A2DP_DECODER(AAC_OUTPUT_FRAME_SAMPLES == output_byte/4, "aac_lc_decode output mismatch samples:%d", output_byte/4);
+                  2; // sizeof(pcm_buffer[0]);
+    ASSERT_A2DP_DECODER(AAC_OUTPUT_FRAME_SAMPLES == output_byte / 4,
+                        "aac_lc_decode output mismatch samples:%d",
+                        output_byte / 4);
   end_decode:
-        a2dp_audio_aac_lastframe_info.sequenceNumber = aac_decoder_frame_p->sequenceNumber;
+    a2dp_audio_aac_lastframe_info.sequenceNumber =
+        aac_decoder_frame_p->sequenceNumber;
     a2dp_audio_aac_lastframe_info.timestamp = aac_decoder_frame_p->timestamp;
     a2dp_audio_aac_lastframe_info.curSubSequenceNumber = 0;
     a2dp_audio_aac_lastframe_info.totalSubSequenceNumber = 0;
     a2dp_audio_aac_lastframe_info.frame_samples = AAC_OUTPUT_FRAME_SAMPLES;
     a2dp_audio_aac_lastframe_info.decoded_frames++;
-        a2dp_audio_aac_lastframe_info.undecode_frames = a2dp_audio_list_length(list)-1;
+    a2dp_audio_aac_lastframe_info.undecode_frames =
-        a2dp_audio_aac_lastframe_info.check_sum= a2dp_audio_decoder_internal_check_sum_generate(aac_decoder_frame_p->aac_buffer, aac_decoder_frame_p->aac_buffer_len);
+        a2dp_audio_list_length(list) - 1;
-        a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_aac_lastframe_info);
+    a2dp_audio_aac_lastframe_info.check_sum =
+        a2dp_audio_decoder_internal_check_sum_generate(
+            aac_decoder_frame_p->aac_buffer,
+            aac_decoder_frame_p->aac_buffer_len);
+    a2dp_audio_decoder_internal_lastframe_info_set(
+        &a2dp_audio_aac_lastframe_info);
     a2dp_audio_list_remove(list, aac_decoder_frame_p);
   }
 exit:
   if (cache_underflow) {
     a2dp_audio_aac_lastframe_info.undecode_frames = 0;
     a2dp_audio_aac_lastframe_info.check_sum = 0;
-        a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_aac_lastframe_info);
+    a2dp_audio_decoder_internal_lastframe_info_set(
+        &a2dp_audio_aac_lastframe_info);
     output_byte = A2DP_DECODER_CACHE_UNDERFLOW_ERROR;
   }
   return output_byte;
 }
 
-int a2dp_audio_aac_lc_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_aac_lc_decode_frame(uint8_t *buffer, uint32_t buffer_bytes) {
-{
 #ifdef A2DP_CP_ACCEL
   return a2dp_cp_aac_lc_mcu_decode(buffer, buffer_bytes);
 #else
@@ -626,8 +671,8 @@ int a2dp_audio_aac_lc_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
 #endif
 }
 
-int a2dp_audio_aac_lc_preparse_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_aac_lc_preparse_packet(btif_media_header_t *header,
-{
+                                      uint8_t *buffer, uint32_t buffer_bytes) {
   a2dp_audio_aac_lastframe_info.sequenceNumber = header->sequenceNumber;
   a2dp_audio_aac_lastframe_info.timestamp = header->timestamp;
   a2dp_audio_aac_lastframe_info.curSubSequenceNumber = 0;
@@ -637,15 +682,16 @@ int a2dp_audio_aac_lc_preparse_packet(btif_media_header_t * header, uint8_t *buf
   a2dp_audio_aac_lastframe_info.decoded_frames = 0;
   a2dp_audio_aac_lastframe_info.undecode_frames = 0;
   a2dp_audio_aac_lastframe_info.check_sum = 0;
-    a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_aac_lastframe_info);
+  a2dp_audio_decoder_internal_lastframe_info_set(
+      &a2dp_audio_aac_lastframe_info);
 
-    TRACE_A2DP_DECODER_I("[AAC][PRE] seq:%d timestamp:%08x", header->sequenceNumber, header->timestamp);
+  TRACE_A2DP_DECODER_I("[AAC][PRE] seq:%d timestamp:%08x",
+                       header->sequenceNumber, header->timestamp);
 
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_reorder_init(void)
+int a2dp_audio_aac_lc_reorder_init(void) {
-{
   aac_decoder_frame_reorder_p = NULL;
   aac_decoder_last_valid_frame_ready = false;
   aac_decoder_last_valid_frame.sequenceNumber = 0;
@@ -656,8 +702,7 @@ int a2dp_audio_aac_lc_reorder_init(void)
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_reorder_deinit(void)
+int a2dp_audio_aac_lc_reorder_deinit(void) {
-{
   aac_decoder_frame_reorder_p = NULL;
   aac_decoder_last_valid_frame_ready = false;
   aac_decoder_last_valid_frame.sequenceNumber = 0;
@@ -667,9 +712,9 @@ int a2dp_audio_aac_lc_reorder_deinit(void)
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_reorder_store_packet(a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p, 
+int a2dp_audio_aac_lc_reorder_store_packet(
-                                                              btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+    a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p,
-{
+    btif_media_header_t *header, uint8_t *buffer, uint32_t buffer_bytes) {
   aac_decoder_frame_p->sequenceNumber = header->sequenceNumber;
   aac_decoder_frame_p->timestamp = header->timestamp;
   memcpy(aac_decoder_frame_p->aac_buffer, buffer, buffer_bytes);
@@ -677,32 +722,38 @@ int a2dp_audio_aac_lc_reorder_store_packet(a2dp_audio_aac_decoder_frame_t *aac_d
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_reorder_proc(a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p, 
+int a2dp_audio_aac_lc_reorder_proc(
-                                                        btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+    a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p,
-{
+    btif_media_header_t *header, uint8_t *buffer, uint32_t buffer_bytes) {
   uint8_t *dest_buf = NULL;
   if ((aac_decoder_frame_p->aac_buffer_len + buffer_bytes) > AAC_READBUF_SIZE) {
     return A2DP_DECODER_NO_ERROR;
   }
-    TRACE_A2DP_DECODER_W("[AAC][INPUT][REORDER] proc enter seq:%d len:%d", aac_decoder_frame_p->sequenceNumber, aac_decoder_frame_p->aac_buffer_len);
+  TRACE_A2DP_DECODER_W("[AAC][INPUT][REORDER] proc enter seq:%d len:%d",
-    dest_buf = &aac_decoder_frame_p->aac_buffer[aac_decoder_frame_p->aac_buffer_len];
+                       aac_decoder_frame_p->sequenceNumber,
+                       aac_decoder_frame_p->aac_buffer_len);
+  dest_buf =
+      &aac_decoder_frame_p->aac_buffer[aac_decoder_frame_p->aac_buffer_len];
   memcpy(dest_buf, buffer, buffer_bytes);
   aac_decoder_frame_p->aac_buffer_len += buffer_bytes;
-    TRACE_A2DP_DECODER_W("[AAC][INPUT][REORDER] proc exit seq:%d len:%d", aac_decoder_frame_p->sequenceNumber, aac_decoder_frame_p->aac_buffer_len);
+  TRACE_A2DP_DECODER_W("[AAC][INPUT][REORDER] proc exit seq:%d len:%d",
+                       aac_decoder_frame_p->sequenceNumber,
+                       aac_decoder_frame_p->aac_buffer_len);
 
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_packet_recover_save_last(a2dp_audio_aac_decoder_frame_t *aac_decoder_frame)
+int a2dp_audio_aac_lc_packet_recover_save_last(
-{
+    a2dp_audio_aac_decoder_frame_t *aac_decoder_frame) {
   aac_decoder_last_valid_frame_ready = true;
-    aac_decoder_last_valid_frame.sequenceNumber = aac_decoder_frame->sequenceNumber;
+  aac_decoder_last_valid_frame.sequenceNumber =
+      aac_decoder_frame->sequenceNumber;
   aac_decoder_last_valid_frame.timestamp = aac_decoder_frame->timestamp;
   return 0;
 }
 
-int a2dp_audio_aac_lc_packet_recover_find_missing(a2dp_audio_aac_decoder_frame_t *aac_decoder_frame)
+int a2dp_audio_aac_lc_packet_recover_find_missing(
-{
+    a2dp_audio_aac_decoder_frame_t *aac_decoder_frame) {
   uint16_t diff_seq = 0;
   uint32_t diff_timestamp = 0;
   uint32_t diff = 0;
@@ -713,24 +764,36 @@ int a2dp_audio_aac_lc_packet_recover_find_missing(a2dp_audio_aac_decoder_frame_t
     return need_recover_pkt;
   }
 
-    diff_seq = a2dp_audio_get_passed(aac_decoder_frame->sequenceNumber, aac_decoder_last_valid_frame.sequenceNumber, UINT16_MAX);
+  diff_seq = a2dp_audio_get_passed(aac_decoder_frame->sequenceNumber,
-    diff_timestamp = a2dp_audio_get_passed(aac_decoder_frame->timestamp, aac_decoder_last_valid_frame.timestamp, UINT32_MAX);
+                                   aac_decoder_last_valid_frame.sequenceNumber,
+                                   UINT16_MAX);
+  diff_timestamp =
+      a2dp_audio_get_passed(aac_decoder_frame->timestamp,
+                            aac_decoder_last_valid_frame.timestamp, UINT32_MAX);
 
   if (diff_seq > 1) {
-        TRACE_A2DP_DECODER_W("[AAC][INPUT][PLC] seq:%d/%d stmp:%d/%d", aac_decoder_frame->sequenceNumber, aac_decoder_last_valid_frame.sequenceNumber,
+    TRACE_A2DP_DECODER_W("[AAC][INPUT][PLC] seq:%d/%d stmp:%d/%d",
-                                                                                  aac_decoder_frame->timestamp, aac_decoder_last_valid_frame.timestamp);
+                         aac_decoder_frame->sequenceNumber,
+                         aac_decoder_last_valid_frame.sequenceNumber,
+                         aac_decoder_frame->timestamp,
+                         aac_decoder_last_valid_frame.timestamp);
     diff = diff_timestamp / diff_seq;
     if (diff % AAC_OUTPUT_FRAME_SAMPLES == 0) {
       tmp_pkt_cnt = diff_timestamp / AAC_OUTPUT_FRAME_SAMPLES;
     } else {
-            tmp_pkt_cnt = (float)diff_timestamp/
+      tmp_pkt_cnt =
-            ((1000.f/(float)a2dp_audio_context_p->output_cfg.sample_rate)*(float)AAC_OUTPUT_FRAME_SAMPLES);
+          (float)diff_timestamp /
+          ((1000.f / (float)a2dp_audio_context_p->output_cfg.sample_rate) *
+           (float)AAC_OUTPUT_FRAME_SAMPLES);
     }
     need_recover_pkt = (uint32_t)(tmp_pkt_cnt + 0.5f);
-        TRACE_A2DP_DECODER_W("[AAC][INPUT][PLC] diff_seq:%d diff_stmp:%d diff:%d missing:%d", diff_seq, diff_timestamp, diff, need_recover_pkt);
+    TRACE_A2DP_DECODER_W(
+        "[AAC][INPUT][PLC] diff_seq:%d diff_stmp:%d diff:%d missing:%d",
+        diff_seq, diff_timestamp, diff, need_recover_pkt);
     if (need_recover_pkt == diff_seq) {
       need_recover_pkt--;
-            TRACE_A2DP_DECODER_W("[AAC][INPUT][PLC] need_recover_pkt seq:%d", need_recover_pkt);
+      TRACE_A2DP_DECODER_W("[AAC][INPUT][PLC] need_recover_pkt seq:%d",
+                           need_recover_pkt);
     } else {
       need_recover_pkt = 0;
     }
@@ -738,17 +801,22 @@ int a2dp_audio_aac_lc_packet_recover_find_missing(a2dp_audio_aac_decoder_frame_t
   return need_recover_pkt;
 }
 
-int a2dp_audio_aac_lc_packet_recover_proc(a2dp_audio_aac_decoder_frame_t *aac_decoder_frame)
+int a2dp_audio_aac_lc_packet_recover_proc(
-{
+    a2dp_audio_aac_decoder_frame_t *aac_decoder_frame) {
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
   int missing_pkt_cnt = 0;
-    missing_pkt_cnt = a2dp_audio_aac_lc_packet_recover_find_missing(aac_decoder_frame);
+  missing_pkt_cnt =
-    if (missing_pkt_cnt <= 4 && a2dp_audio_list_length(list) + missing_pkt_cnt < aac_mtu_limiter){
+      a2dp_audio_aac_lc_packet_recover_find_missing(aac_decoder_frame);
+  if (missing_pkt_cnt <= 4 &&
+      a2dp_audio_list_length(list) + missing_pkt_cnt < aac_mtu_limiter) {
     for (uint8_t i = 0; i < missing_pkt_cnt; i++) {
-            a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(aac_decoder_frame->aac_buffer_len);
+      a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p =
+          (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(
+              aac_decoder_frame->aac_buffer_len);
       aac_decoder_frame_p->sequenceNumber = UINT16_MAX;
       aac_decoder_frame_p->timestamp = UINT32_MAX;
-            memcpy(aac_decoder_frame_p->aac_buffer, aac_decoder_frame->aac_buffer, aac_decoder_frame->aac_buffer_len);
+      memcpy(aac_decoder_frame_p->aac_buffer, aac_decoder_frame->aac_buffer,
+             aac_decoder_frame->aac_buffer_len);
       aac_decoder_frame_p->aac_buffer_len = aac_decoder_frame->aac_buffer_len;
       a2dp_audio_list_append(list, aac_decoder_frame_p);
     }
@@ -757,8 +825,8 @@ int a2dp_audio_aac_lc_packet_recover_proc(a2dp_audio_aac_decoder_frame_t *aac_de
   return A2DP_DECODER_NO_ERROR;
 }
 
-int inline a2dp_audio_aac_lc_packet_append(a2dp_audio_aac_decoder_frame_t *aac_decoder_frame)
+int inline a2dp_audio_aac_lc_packet_append(
-{
+    a2dp_audio_aac_decoder_frame_t *aac_decoder_frame) {
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
   a2dp_audio_aac_lc_packet_recover_proc(aac_decoder_frame);
   a2dp_audio_aac_lc_packet_recover_save_last(aac_decoder_frame);
@@ -767,8 +835,8 @@ int inline a2dp_audio_aac_lc_packet_append(a2dp_audio_aac_decoder_frame_t *aac_d
 }
 
 #if 1
-int a2dp_audio_aac_lc_store_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_aac_lc_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;
   a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p = NULL;
@@ -776,35 +844,45 @@ int a2dp_audio_aac_lc_store_packet(btif_media_header_t * header, uint8_t *buffer
   if (a2dp_audio_list_length(list) < aac_mtu_limiter &&
       buffer_bytes <= AAC_READBUF_SIZE) {
     if (aac_decoder_frame_reorder_p == NULL) {
-            aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(buffer_bytes);
+      aac_decoder_frame_p =
+          (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(
+              buffer_bytes);
       aac_decoder_frame_reorder_p = aac_decoder_frame_p;
-            TRACE_A2DP_DECODER_W("[AAC][INPUT][REORDER] start seq:%d len:%d", header->sequenceNumber, buffer_bytes);
+      TRACE_A2DP_DECODER_W("[AAC][INPUT][REORDER] start seq:%d len:%d",
-            a2dp_audio_aac_lc_reorder_store_packet(aac_decoder_frame_p, header, buffer, buffer_bytes);
+                           header->sequenceNumber, buffer_bytes);
+      a2dp_audio_aac_lc_reorder_store_packet(aac_decoder_frame_p, header,
+                                             buffer, buffer_bytes);
     } else {
       if (aac_decoder_frame_reorder_p->aac_buffer[0] == buffer[0] &&
           aac_decoder_frame_reorder_p->aac_buffer[1] == buffer[1]) {
         a2dp_audio_aac_lc_packet_append(aac_decoder_frame_reorder_p);
-                aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(buffer_bytes);
+        aac_decoder_frame_p =
+            (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(
+                buffer_bytes);
         aac_decoder_frame_reorder_p = aac_decoder_frame_p;
-                a2dp_audio_aac_lc_reorder_store_packet(aac_decoder_frame_p, header, buffer, buffer_bytes);
+        a2dp_audio_aac_lc_reorder_store_packet(aac_decoder_frame_p, header,
+                                               buffer, buffer_bytes);
       } else {
         aac_decoder_frame_p = aac_decoder_frame_reorder_p;
-                a2dp_audio_aac_lc_reorder_proc(aac_decoder_frame_p, header, buffer, buffer_bytes);
+        a2dp_audio_aac_lc_reorder_proc(aac_decoder_frame_p, header, buffer,
+                                       buffer_bytes);
         a2dp_audio_aac_lc_packet_append(aac_decoder_frame_p);
         aac_decoder_frame_reorder_p = NULL;
       }
     }
     nRet = A2DP_DECODER_NO_ERROR;
   } else {
-        TRACE_A2DP_DECODER_W("[AAC][INPUT] list full current list_len:%d buff_len:%d", a2dp_audio_list_length(list), buffer_bytes);
+    TRACE_A2DP_DECODER_W(
+        "[AAC][INPUT] list full current list_len:%d buff_len:%d",
+        a2dp_audio_list_length(list), buffer_bytes);
     nRet = A2DP_DECODER_MTU_LIMTER_ERROR;
   }
 
   return nRet;
 }
 #else
-int a2dp_audio_aac_lc_store_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_aac_lc_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;
 
@@ -814,8 +892,11 @@ int a2dp_audio_aac_lc_store_packet(btif_media_header_t * header, uint8_t *buffer
 
   if (a2dp_audio_list_length(list) < aac_mtu_limiter &&
       buffer_bytes <= AAC_READBUF_SIZE) {
-        a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(buffer_bytes);
+    a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p =
-        TRACE_A2DP_DECODER_D("[AAC][INPUT]seq:%d len:%d", header->sequenceNumber, buffer_bytes);
+        (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_aac_lc_frame_malloc(
+            buffer_bytes);
+    TRACE_A2DP_DECODER_D("[AAC][INPUT]seq:%d len:%d", header->sequenceNumber,
+                         buffer_bytes);
     aac_decoder_frame_p->sequenceNumber = header->sequenceNumber;
     aac_decoder_frame_p->timestamp = header->timestamp;
     memcpy(aac_decoder_frame_p->aac_buffer, buffer, buffer_bytes);
@@ -824,7 +905,9 @@ int a2dp_audio_aac_lc_store_packet(btif_media_header_t * header, uint8_t *buffer
     a2dp_audio_list_append(list, aac_decoder_frame_p);
     nRet = A2DP_DECODER_NO_ERROR;
   } else {
-        TRACE_A2DP_DECODER_I("[AAC][INPUT] list full current list_len:%d buff_len:%d", a2dp_audio_list_length(list), buffer_bytes);
+    TRACE_A2DP_DECODER_I(
+        "[AAC][INPUT] list full current list_len:%d buff_len:%d",
+        a2dp_audio_list_length(list), buffer_bytes);
     nRet = A2DP_DECODER_MTU_LIMTER_ERROR;
   }
 
@@ -832,8 +915,7 @@ int a2dp_audio_aac_lc_store_packet(btif_media_header_t * header, uint8_t *buffer
 }
 #endif
 
-int a2dp_audio_aac_lc_discards_packet(uint32_t packets)
+int a2dp_audio_aac_lc_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;
@@ -846,7 +928,8 @@ int a2dp_audio_aac_lc_discards_packet(uint32_t packets)
   if (packets <= a2dp_audio_list_length(list)) {
     for (uint8_t i = 0; i < packets; i++) {
       if ((node = a2dp_audio_list_begin(list)) != NULL) {
-                aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+        aac_decoder_frame_p =
+            (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, aac_decoder_frame_p);
       }
     }
@@ -857,14 +940,16 @@ int a2dp_audio_aac_lc_discards_packet(uint32_t packets)
   return nRet;
 }
 
-int a2dp_audio_aac_lc_headframe_info_get(A2DP_AUDIO_HEADFRAME_INFO_T* headframe_info)
+int a2dp_audio_aac_lc_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_aac_decoder_frame_t *aac_decoder_frame = NULL;
 
-    if (a2dp_audio_list_length(list) && ((node = a2dp_audio_list_begin(list)) != NULL)){
+  if (a2dp_audio_list_length(list) &&
-        aac_decoder_frame = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+      ((node = a2dp_audio_list_begin(list)) != NULL)) {
+    aac_decoder_frame =
+        (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
     headframe_info->sequenceNumber = aac_decoder_frame->sequenceNumber;
     headframe_info->timestamp = aac_decoder_frame->timestamp;
     headframe_info->curSubSequenceNumber = 0;
@@ -876,13 +961,10 @@ int a2dp_audio_aac_lc_headframe_info_get(A2DP_AUDIO_HEADFRAME_INFO_T* headframe_
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_info_get(void *info)
+int a2dp_audio_aac_lc_info_get(void *info) { return A2DP_DECODER_NO_ERROR; }
-{
-    return A2DP_DECODER_NO_ERROR;
-}
 
-int a2dp_audio_aac_lc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info, uint32_t mask)
+int a2dp_audio_aac_lc_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;
@@ -898,11 +980,18 @@ int a2dp_audio_aac_lc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info,
   for (uint16_t i = 0; i < list_len; i++) {
     node = a2dp_audio_list_begin(list);
     if (node) {
-            aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+      aac_decoder_frame_p =
-            TRACE_A2DP_DECODER_D("[synchronize_packet]%d/%d %x/%x", aac_decoder_frame_p->sequenceNumber, sync_info->sequenceNumber,
+          (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+      TRACE_A2DP_DECODER_D(
+          "[synchronize_packet]%d/%d %x/%x",
+          aac_decoder_frame_p->sequenceNumber, sync_info->sequenceNumber,
           aac_decoder_frame_p->timestamp, sync_info->timestamp);
-            if (A2DP_AUDIO_SYNCFRAME_CHK(aac_decoder_frame_p->sequenceNumber  == sync_info->sequenceNumber, A2DP_AUDIO_SYNCFRAME_MASK_SEQ,       mask)&&
+      if (A2DP_AUDIO_SYNCFRAME_CHK(aac_decoder_frame_p->sequenceNumber ==
-                A2DP_AUDIO_SYNCFRAME_CHK(aac_decoder_frame_p->timestamp       == sync_info->timestamp,      A2DP_AUDIO_SYNCFRAME_MASK_TIMESTAMP, mask)){
+                                       sync_info->sequenceNumber,
+                                   A2DP_AUDIO_SYNCFRAME_MASK_SEQ, mask) &&
+          A2DP_AUDIO_SYNCFRAME_CHK(aac_decoder_frame_p->timestamp ==
+                                       sync_info->timestamp,
+                                   A2DP_AUDIO_SYNCFRAME_MASK_TIMESTAMP, mask)) {
         nRet = A2DP_DECODER_NO_ERROR;
         break;
       }
@@ -912,8 +1001,11 @@ int a2dp_audio_aac_lc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info,
 
   node = a2dp_audio_list_begin(list);
   if (node) {
-        aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+    aac_decoder_frame_p =
-        TRACE_A2DP_DECODER_I("[MCU][SYNC][AAC] sync pkt nRet:%d SEQ:%d timestamp:%d", nRet, aac_decoder_frame_p->sequenceNumber, aac_decoder_frame_p->timestamp);
+        (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+    TRACE_A2DP_DECODER_I(
+        "[MCU][SYNC][AAC] sync pkt nRet:%d SEQ:%d timestamp:%d", nRet,
+        aac_decoder_frame_p->sequenceNumber, aac_decoder_frame_p->timestamp);
   } else {
     TRACE_A2DP_DECODER_I("[MCU][SYNC][AAC] sync pkt nRet:%d", nRet);
   }
@@ -921,8 +1013,7 @@ int a2dp_audio_aac_lc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info,
   return nRet;
 }
 
-int a2dp_audio_aac_lc_synchronize_dest_packet_mut(uint16_t packet_mut)
+int a2dp_audio_aac_lc_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;
@@ -933,7 +1024,8 @@ int a2dp_audio_aac_lc_synchronize_dest_packet_mut(uint16_t packet_mut)
     do {
       node = a2dp_audio_list_begin(list);
       if (node) {
-                aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+        aac_decoder_frame_p =
+            (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, aac_decoder_frame_p);
       }
     } while (a2dp_audio_list_length(list) > packet_mut);
@@ -946,32 +1038,33 @@ int a2dp_audio_aac_lc_synchronize_dest_packet_mut(uint16_t packet_mut)
     }
   }
 
-    TRACE_A2DP_DECODER_I("[MCU][SYNC][AAC] dest pkt list:%d", a2dp_audio_list_length(list));
+  TRACE_A2DP_DECODER_I("[MCU][SYNC][AAC] dest pkt list:%d",
+                       a2dp_audio_list_length(list));
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_convert_list_to_samples(uint32_t *samples)
+int a2dp_audio_aac_lc_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 = AAC_OUTPUT_FRAME_SAMPLES * list_len;
 
-    TRACE_A2DP_DECODER_I("AUD][DECODER][MCU][AAC] list:%d samples:%d", list_len, *samples);
+  TRACE_A2DP_DECODER_I("AUD][DECODER][MCU][AAC] list:%d samples:%d", list_len,
+                       *samples);
 
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_aac_lc_discards_samples(uint32_t samples)
+int a2dp_audio_aac_lc_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_aac_decoder_frame_t *aac_decoder_frame_p = NULL;
   list_node_t *node = NULL;
   int need_remove_list = 0;
   uint32_t list_samples = 0;
-    ASSERT_A2DP_DECODER(!(samples%AAC_OUTPUT_FRAME_SAMPLES), "%s samples err:%d", __func__, samples);
+  ASSERT_A2DP_DECODER(!(samples % AAC_OUTPUT_FRAME_SAMPLES),
+                      "%s samples err:%d", __func__, samples);
 
   a2dp_audio_aac_lc_convert_list_to_samples(&list_samples);
   if (list_samples >= samples) {
@@ -979,7 +1072,8 @@ int a2dp_audio_aac_lc_discards_samples(uint32_t samples)
     for (int i = 0; i < need_remove_list; i++) {
       node = a2dp_audio_list_begin(list);
       if (node) {
-                aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
+        aac_decoder_frame_p =
+            (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, aac_decoder_frame_p);
       }
     }
@@ -1008,5 +1102,7 @@ A2DP_AUDIO_DECODER_T a2dp_audio_aac_lc_decoder_config = {
     a2dp_audio_aac_lc_channel_select,
 };
 #else
-A2DP_AUDIO_DECODER_T a2dp_audio_aac_lc_decoder_config = {0,} ;
+A2DP_AUDIO_DECODER_T a2dp_audio_aac_lc_decoder_config = {
+    0,
+};
 #endif

apps/audioplayers/a2dp_decoder/a2dp_decoder_cp.c

@@ -15,8 +15,8 @@
  ****************************************************************************/
 #ifdef A2DP_CP_ACCEL
 
-#include "a2dp_decoder_internal.h"
 #include "a2dp_decoder_cp.h"
+#include "a2dp_decoder_internal.h"
 #include "cp_accel.h"
 #include "hal_location.h"
 #include "hal_timer.h"
@@ -82,28 +82,21 @@ static enum CP_PROC_DELAY_T proc_delay;
 static bool cp_need_reset;
 
 CP_TEXT_SRAM_LOC
-unsigned int set_cp_reset_flag(uint8_t evt)
+unsigned int set_cp_reset_flag(uint8_t evt) {
-{
   cp_need_reset = true;
   return 0;
 }
 
-bool is_cp_need_reset(void)
+bool is_cp_need_reset(void) {
-{
   bool ret = cp_need_reset;
   cp_need_reset = false;
   return ret;
 }
 
-bool is_cp_init_done(void)
+bool is_cp_init_done(void) { return cp_accel_init_done(); }
-{
-    return cp_accel_init_done();
-}
-
 
 CP_TEXT_SRAM_LOC
-static void reset_frame_info(void)
+static void reset_frame_info(void) {
-{
   uint32_t idle_cnt;
   int i;
 
@@ -132,8 +125,7 @@ static void reset_frame_info(void)
 }
 
 CP_TEXT_SRAM_LOC
-static unsigned int cp_a2dp_main(uint8_t event)
+static unsigned int cp_a2dp_main(uint8_t event) {
-{
   int ret;
 #ifdef A2DP_TRACE_CP_DEC_TIME
   uint32_t stime;
@@ -154,7 +146,9 @@ static unsigned int cp_a2dp_main(uint8_t event)
 
 #ifdef A2DP_TRACE_CP_DEC_TIME
       etime = hal_fast_sys_timer_get();
-            TRACE_A2DP_DECODER_I("cp_decode: %5u us in %5u us", FAST_TICKS_TO_US(etime - stime), FAST_TICKS_TO_US(etime - cp_last_dec_time));
+      TRACE_A2DP_DECODER_I("cp_decode: %5u us in %5u us",
+                           FAST_TICKS_TO_US(etime - stime),
+                           FAST_TICKS_TO_US(etime - cp_last_dec_time));
       cp_last_dec_time = etime;
 #endif
     } while (ret == 0);
@@ -170,9 +164,9 @@ static unsigned int cp_a2dp_main(uint8_t event)
   return 0;
 }
 
-static struct cp_task_desc TASK_DESC_A2DP = {CP_ACCEL_STATE_CLOSED, cp_a2dp_main, NULL, NULL, set_cp_reset_flag};
+static struct cp_task_desc TASK_DESC_A2DP = {
-int a2dp_cp_init(A2DP_CP_DECODE_T decode_func, enum CP_PROC_DELAY_T delay)
+    CP_ACCEL_STATE_CLOSED, cp_a2dp_main, NULL, NULL, set_cp_reset_flag};
-{
+int a2dp_cp_init(A2DP_CP_DECODE_T decode_func, enum CP_PROC_DELAY_T delay) {
   if (delay >= CP_PROC_DELAY_QTY) {
     return 1;
   }
@@ -183,7 +177,8 @@ int a2dp_cp_init(A2DP_CP_DECODE_T decode_func, enum CP_PROC_DELAY_T delay)
   cp_last_dec_time = hal_fast_sys_timer_get();
 #endif
 
-    norflash_api_flush_disable(NORFLASH_API_USER_CP,(uint32_t)cp_accel_init_done);
+  norflash_api_flush_disable(NORFLASH_API_USER_CP,
+                             (uint32_t)cp_accel_init_done);
   cp_accel_open(CP_TASK_A2DP_DECODE, &TASK_DESC_A2DP);
   while (cp_accel_init_done() == false) {
     hal_sys_timer_delay_us(100);
@@ -191,16 +186,14 @@ int a2dp_cp_init(A2DP_CP_DECODE_T decode_func, enum CP_PROC_DELAY_T delay)
   norflash_api_flush_enable(NORFLASH_API_USER_CP);
   return 0;
 }
-int a2dp_cp_deinit(void)
+int a2dp_cp_deinit(void) {
-{
   cp_accel_close(CP_TASK_A2DP_DECODE);
 
   return 0;
 }
 
 SRAM_TEXT_LOC
-int a2dp_cp_decoder_init(uint32_t out_frame_len, uint8_t max_frames)
+int a2dp_cp_decoder_init(uint32_t out_frame_len, uint8_t max_frames) {
-{
   uint32_t i;
   max_buffer_frames = max_frames;
   if (!mcu_dec_inited) {
@@ -250,8 +243,7 @@ int a2dp_cp_decoder_init(uint32_t out_frame_len, uint8_t max_frames)
 }
 
 CP_TEXT_SRAM_LOC
-static uint32_t get_in_frame_cnt(uint32_t in_widx, uint32_t in_ridx)
+static uint32_t get_in_frame_cnt(uint32_t in_widx, uint32_t in_ridx) {
-{
   uint32_t cnt;
 
   if (in_widx >= in_ridx) {
@@ -263,19 +255,14 @@ static uint32_t get_in_frame_cnt(uint32_t in_widx, uint32_t in_ridx)
   return cnt;
 }
 
-uint32_t get_in_cp_frame_cnt(void)
+uint32_t get_in_cp_frame_cnt(void) {
-{
   return get_in_frame_cnt(cp_in_widx, cp_in_ridx);
 }
 
-uint32_t get_in_cp_frame_delay(void)
+uint32_t get_in_cp_frame_delay(void) { return proc_delay; }
-{
-    return proc_delay;
-}
 
 SRAM_TEXT_LOC
-static uint32_t get_in_frame_free_cnt(uint32_t in_widx, uint32_t in_ridx)
+static uint32_t get_in_frame_free_cnt(uint32_t in_widx, uint32_t in_ridx) {
-{
   uint32_t free_cnt;
 
   if (in_widx >= in_ridx) {
@@ -289,8 +276,8 @@ static uint32_t get_in_frame_free_cnt(uint32_t in_widx, uint32_t in_ridx)
 }
 
 SRAM_TEXT_LOC
-int a2dp_cp_put_in_frame(const void *buf1, uint32_t len1, const  void *buf2, uint32_t len2)
+int a2dp_cp_put_in_frame(const void *buf1, uint32_t len1, const void *buf2,
-{
+                         uint32_t len2) {
   uint16_t free_cnt;
   uint16_t in_widx;
   uint16_t in_ridx;
@@ -380,8 +367,7 @@ int a2dp_cp_put_in_frame(const void *buf1, uint32_t len1, const  void *buf2, uin
 }
 
 CP_TEXT_SRAM_LOC
-int a2dp_cp_get_in_frame(void **p_buf, uint32_t *p_len)
+int a2dp_cp_get_in_frame(void **p_buf, uint32_t *p_len) {
-{
   uint16_t in_widx;
   uint16_t in_ridx;
   uint32_t in_rpos;
@@ -410,8 +396,7 @@ int a2dp_cp_get_in_frame(void **p_buf, uint32_t *p_len)
 }
 
 CP_TEXT_SRAM_LOC
-int a2dp_cp_consume_in_frame(void)
+int a2dp_cp_consume_in_frame(void) {
-{
   uint16_t in_widx;
   uint16_t in_ridx;
 
@@ -436,20 +421,15 @@ int a2dp_cp_consume_in_frame(void)
 }
 
 CP_TEXT_SRAM_LOC
-uint32_t a2dp_cp_get_in_frame_index(void)
+uint32_t a2dp_cp_get_in_frame_index(void) { return cp_in_ridx; }
-{
-    return cp_in_ridx;
-}
 
 SRAM_TEXT_LOC
-uint32_t a2dp_cp_get_in_frame_cnt_by_index(uint32_t ridx)
+uint32_t a2dp_cp_get_in_frame_cnt_by_index(uint32_t ridx) {
-{
   return get_in_frame_cnt(cp_in_widx, ridx);
 }
 
 SRAM_TEXT_LOC
-void a2dp_cp_reset_frame(void)
+void a2dp_cp_reset_frame(void) {
-{
 #ifdef A2DP_TRACE_CP_ACCEL
   TRACE_A2DP_DECODER_I("%s: Reset frames", __func__);
 #endif
@@ -461,14 +441,11 @@ void a2dp_cp_reset_frame(void)
 }
 
 SRAM_TEXT_LOC
-bool a2dp_cp_get_frame_reset_status(void)
+bool a2dp_cp_get_frame_reset_status(void) { return reset_frames; }
-{
-    return reset_frames;
-}
 
 CP_TEXT_SRAM_LOC
-enum CP_EMPTY_OUT_FRM_T a2dp_cp_get_emtpy_out_frame(void **p_buf, uint32_t *p_len)
+enum CP_EMPTY_OUT_FRM_T a2dp_cp_get_emtpy_out_frame(void **p_buf,
-{
+                                                    uint32_t *p_len) {
   enum CP_EMPTY_OUT_FRM_T ret;
   uint8_t out_widx;
   uint32_t out_wpos;
@@ -505,8 +482,7 @@ enum CP_EMPTY_OUT_FRM_T a2dp_cp_get_emtpy_out_frame(void **p_buf, uint32_t *p_le
 }
 
 CP_TEXT_SRAM_LOC
-int a2dp_cp_consume_emtpy_out_frame(void)
+int a2dp_cp_consume_emtpy_out_frame(void) {
-{
   uint8_t out_widx;
 
   if (reset_frames) {
@@ -535,8 +511,7 @@ int a2dp_cp_consume_emtpy_out_frame(void)
 }
 
 SRAM_TEXT_LOC
-int a2dp_cp_get_full_out_frame(void **p_buf, uint32_t *p_len)
+int a2dp_cp_get_full_out_frame(void **p_buf, uint32_t *p_len) {
-{
   uint8_t out_ridx;
   uint32_t out_rpos;
   enum CP_DEC_STATE_T state;
@@ -550,7 +525,8 @@ int a2dp_cp_get_full_out_frame(void **p_buf, uint32_t *p_len)
 
   if (state != CP_DEC_STATE_DONE && state != CP_DEC_STATE_INIT_DONE) {
     // Notify CP to work again
-        cp_accel_send_event_mcu2cp(CP_BUILD_ID(CP_TASK_A2DP_DECODE, CP_EVENT_A2DP_DECODE));
+    cp_accel_send_event_mcu2cp(
+        CP_BUILD_ID(CP_TASK_A2DP_DECODE, CP_EVENT_A2DP_DECODE));
     if (state == CP_DEC_STATE_WORKING) {
       return CP_EMPTY_OUT_FRM_WORKING;
     } else {
@@ -580,8 +556,7 @@ int a2dp_cp_get_full_out_frame(void **p_buf, uint32_t *p_len)
 }
 
 SRAM_TEXT_LOC
-int a2dp_cp_consume_full_out_frame(void)
+int a2dp_cp_consume_full_out_frame(void) {
-{
   uint8_t out_ridx;
   enum CP_DEC_STATE_T state;
 
@@ -609,10 +584,10 @@ int a2dp_cp_consume_full_out_frame(void)
   cp_out_ridx = out_ridx;
 
   // Notify CP to work again
-    cp_accel_send_event_mcu2cp(CP_BUILD_ID(CP_TASK_A2DP_DECODE, CP_EVENT_A2DP_DECODE));
+  cp_accel_send_event_mcu2cp(
+      CP_BUILD_ID(CP_TASK_A2DP_DECODE, CP_EVENT_A2DP_DECODE));
 
   return 0;
 }
 
 #endif
-

apps/audioplayers/a2dp_decoder/a2dp_decoder_example.cpp

@@ -14,12 +14,12 @@
  *
  ****************************************************************************/
 // Standard C Included Files
+#include "a2dp_decoder_internal.h"
 #include "cmsis.h"
+#include "hal_location.h"
+#include "heap_api.h"
 #include "plat_types.h"
 #include <string.h>
-#include "heap_api.h"
-#include "hal_location.h"
-#include "a2dp_decoder_internal.h"
 
 static A2DP_AUDIO_CONTEXT_T *a2dp_audio_context_p = NULL;
 static A2DP_AUDIO_DECODER_LASTFRAME_INFO_T a2dp_audio_ldac_example_info;
@@ -32,41 +32,41 @@ typedef struct {
   uint32_t buffer_len;
 } a2dp_audio_example_decoder_frame_t;
 
-
+int a2dp_audio_example_decode_frame(uint8_t *buffer, uint32_t buffer_bytes) {
-int a2dp_audio_example_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
-{
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_example_preparse_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_example_preparse_packet(btif_media_header_t *header,
-{
+                                       uint8_t *buffer, uint32_t buffer_bytes) {
   return A2DP_DECODER_NO_ERROR;
 }
 
-
+static void *a2dp_audio_example_frame_malloc(uint32_t packet_len) {
-static void *a2dp_audio_example_frame_malloc(uint32_t packet_len)
-{
   a2dp_audio_example_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_example_decoder_frame_t *)a2dp_audio_heap_malloc(sizeof(a2dp_audio_example_decoder_frame_t));
+  decoder_frame_p =
+      (a2dp_audio_example_decoder_frame_t *)a2dp_audio_heap_malloc(
+          sizeof(a2dp_audio_example_decoder_frame_t));
   decoder_frame_p->buffer = buffer;
   decoder_frame_p->buffer_len = packet_len;
   return (void *)decoder_frame_p;
 }
 
-void a2dp_audio_example_free(void *packet)
+void a2dp_audio_example_free(void *packet) {
-{
+  a2dp_audio_example_decoder_frame_t *decoder_frame_p =
-    a2dp_audio_example_decoder_frame_t *decoder_frame_p = (a2dp_audio_example_decoder_frame_t *)packet; 
+      (a2dp_audio_example_decoder_frame_t *)packet;
   a2dp_audio_heap_free(decoder_frame_p->buffer);
   a2dp_audio_heap_free(decoder_frame_p);
 }
 
-int a2dp_audio_example_store_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_example_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;
-    a2dp_audio_example_decoder_frame_t *decoder_frame_p = (a2dp_audio_example_decoder_frame_t *)a2dp_audio_example_frame_malloc(buffer_bytes);
+  a2dp_audio_example_decoder_frame_t *decoder_frame_p =
+      (a2dp_audio_example_decoder_frame_t *)a2dp_audio_example_frame_malloc(
+          buffer_bytes);
 
   decoder_frame_p->sequenceNumber = header->sequenceNumber;
   decoder_frame_p->timestamp = header->timestamp;
@@ -77,45 +77,38 @@ int a2dp_audio_example_store_packet(btif_media_header_t * header, uint8_t *buffe
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_example_discards_packet(uint32_t packets)
+int a2dp_audio_example_discards_packet(uint32_t packets) {
-{
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_example_headframe_info_get(A2DP_AUDIO_HEADFRAME_INFO_T* headframe_info)
+int a2dp_audio_example_headframe_info_get(
-{
+    A2DP_AUDIO_HEADFRAME_INFO_T *headframe_info) {
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_example_info_get(void *info)
+int a2dp_audio_example_info_get(void *info) { return A2DP_DECODER_NO_ERROR; }
-{
-    return A2DP_DECODER_NO_ERROR;
-}
 
-int a2dp_audio_example_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context)
+int a2dp_audio_example_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context) {
-{
   TRACE_A2DP_DECODER_D("%s", __func__);
   a2dp_audio_context_p = (A2DP_AUDIO_CONTEXT_T *)context;
 
-    memset(&a2dp_audio_ldac_example_info, 0, sizeof(A2DP_AUDIO_DECODER_LASTFRAME_INFO_T));    
+  memset(&a2dp_audio_ldac_example_info, 0,
-    memcpy(&a2dp_audio_example_output_config, config, sizeof(A2DP_AUDIO_OUTPUT_CONFIG_T));
+         sizeof(A2DP_AUDIO_DECODER_LASTFRAME_INFO_T));
+  memcpy(&a2dp_audio_example_output_config, config,
+         sizeof(A2DP_AUDIO_OUTPUT_CONFIG_T));
   a2dp_audio_ldac_example_info.stream_info = &a2dp_audio_example_output_config;
 
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_example_deinit(void)
+int a2dp_audio_example_deinit(void) { return A2DP_DECODER_NO_ERROR; }
-{
+
+int a2dp_audio_example_synchronize_packet(
+    A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info, uint32_t mask) {
   return A2DP_DECODER_NO_ERROR;
 }
 
-int  a2dp_audio_example_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info, uint32_t mask)
+int a2dp_audio_example_synchronize_dest_packet_mut(uint16_t packet_mut) {
-{
-    return A2DP_DECODER_NO_ERROR;
-}
-
-int a2dp_audio_example_synchronize_dest_packet_mut(uint16_t packet_mut)
-{
   return A2DP_DECODER_NO_ERROR;
 }
 
@@ -134,4 +127,3 @@ A2DP_AUDIO_DECODER_T a2dp_audio_example_decoder_config = {
     a2dp_audio_example_info_get,
     a2dp_audio_example_free,
 };
-

apps/audioplayers/a2dp_decoder/a2dp_decoder_sbc.cpp

@@ -14,15 +14,15 @@
  *
  ****************************************************************************/
 // Standard C Included Files
+#include "a2dp_decoder_internal.h"
 #include "cmsis.h"
+#include "cmsis_os.h"
+#include "codec_sbc.h"
+#include "hal_location.h"
+#include "hal_timer.h"
+#include "heap_api.h"
 #include "plat_types.h"
 #include <string.h>
-#include "heap_api.h"
-#include "hal_location.h"
-#include "codec_sbc.h"
-#include "a2dp_decoder_internal.h"
-#include "hal_timer.h"
-#include "cmsis_os.h"
 
 #ifndef SBC_MTU_LIMITER
 #define SBC_MTU_LIMITER (250) /*must <= 332*/
@@ -55,33 +55,35 @@ static A2DP_AUDIO_DECODER_LASTFRAME_INFO_T a2dp_audio_sbc_lastframe_info;
 
 static uint16_t sbc_mtu_limiter = SBC_MTU_LIMITER;
 
-static btif_media_header_t sbc_decoder_last_valid_frame = {0,};
+static btif_media_header_t sbc_decoder_last_valid_frame = {
+    0,
+};
 static bool sbc_decoder_last_valid_frame_ready = false;
 static bool sbc_chnl_mode_mono = false;
 
 static int a2dp_audio_sbc_header_parser_init(void);
 
-static void *a2dp_audio_sbc_subframe_malloc(uint32_t sbc_len)
+static void *a2dp_audio_sbc_subframe_malloc(uint32_t sbc_len) {
-{
   a2dp_audio_sbc_decoder_frame_t *sbc_decoder_frame_p = NULL;
   uint8_t *sbc_buffer = NULL;
 
   sbc_buffer = (uint8_t *)a2dp_audio_heap_malloc(sbc_len);
-    sbc_decoder_frame_p = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_heap_malloc(sizeof(a2dp_audio_sbc_decoder_frame_t));
+  sbc_decoder_frame_p =
+      (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_heap_malloc(
+          sizeof(a2dp_audio_sbc_decoder_frame_t));
   sbc_decoder_frame_p->sbc_buffer = sbc_buffer;
   sbc_decoder_frame_p->sbc_buffer_len = sbc_len;
   return (void *)sbc_decoder_frame_p;
 }
 
-static void a2dp_audio_sbc_subframe_free(void *packet)
+static void a2dp_audio_sbc_subframe_free(void *packet) {
-{
+  a2dp_audio_sbc_decoder_frame_t *sbc_decoder_frame_p =
-    a2dp_audio_sbc_decoder_frame_t *sbc_decoder_frame_p = (a2dp_audio_sbc_decoder_frame_t *)packet;
+      (a2dp_audio_sbc_decoder_frame_t *)packet;
   a2dp_audio_heap_free(sbc_decoder_frame_p->sbc_buffer);
   a2dp_audio_heap_free(sbc_decoder_frame_p);
 }
 
-static void sbc_codec_init(void)
+static void sbc_codec_init(void) {
-{
   btif_sbc_init_decoder(a2dp_audio_sbc_decoder.sbc_decoder);
   a2dp_audio_sbc_decoder.sbc_decoder->maxPcmLen = SBC_PCMLEN_DEFAULT;
   a2dp_audio_sbc_decoder.pcm_data->data = NULL;
@@ -112,16 +114,14 @@ int a2dp_cp_sbc_cp_decode(void);
 
 extern uint32_t app_bt_stream_get_dma_buffer_samples(void);
 
-static int TEXT_SBC_LOC a2dp_cp_sbc_after_cache_underflow(void)
+static int TEXT_SBC_LOC a2dp_cp_sbc_after_cache_underflow(void) {
-{
 #ifdef A2DP_CP_ACCEL
   cp_codec_reset = true;
 #endif
   return 0;
 }
 
-static int a2dp_cp_sbc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
+static int a2dp_cp_sbc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes) {
-{
   a2dp_audio_sbc_decoder_frame_t *sbc_decoder_frame = NULL;
   list_node_t *node = NULL;
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
@@ -136,9 +136,12 @@ static int a2dp_cp_sbc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
 
   cp_buffer_frames_max = app_bt_stream_get_dma_buffer_samples() / 2;
   if (cp_buffer_frames_max % (a2dp_audio_sbc_lastframe_info.frame_samples)) {
-        cp_buffer_frames_max =  cp_buffer_frames_max /(a2dp_audio_sbc_lastframe_info.frame_samples) +1  ;
+    cp_buffer_frames_max =
+        cp_buffer_frames_max / (a2dp_audio_sbc_lastframe_info.frame_samples) +
+        1;
   } else {
-        cp_buffer_frames_max =  cp_buffer_frames_max /(a2dp_audio_sbc_lastframe_info.frame_samples) ;
+    cp_buffer_frames_max =
+        cp_buffer_frames_max / (a2dp_audio_sbc_lastframe_info.frame_samples);
   }
 
   out_frame_len = sizeof(*p_out_info) + buffer_bytes;
@@ -149,26 +152,31 @@ static int a2dp_cp_sbc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
     return A2DP_DECODER_DECODE_ERROR;
   }
   while ((node = a2dp_audio_list_begin(list)) != NULL) {
-        sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+    sbc_decoder_frame =
+        (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
 
     in_info.sequenceNumber = sbc_decoder_frame->sequenceNumber;
     in_info.timestamp = sbc_decoder_frame->timestamp;
     in_info.curSubSequenceNumber = sbc_decoder_frame->curSubSequenceNumber;
     in_info.totalSubSequenceNumber = sbc_decoder_frame->totalSubSequenceNumber;
 
-        ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info), sbc_decoder_frame->sbc_buffer, sbc_decoder_frame->sbc_buffer_len);
+    ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info),
+                               sbc_decoder_frame->sbc_buffer,
+                               sbc_decoder_frame->sbc_buffer_len);
     if (ret) {
       TRACE_A2DP_DECODER_D("[MCU][SBC] piff !!!!!!ret: %d ", ret);
       break;
     }
-        check_sum = a2dp_audio_decoder_internal_check_sum_generate(sbc_decoder_frame->sbc_buffer, sbc_decoder_frame->sbc_buffer_len);
+    check_sum = a2dp_audio_decoder_internal_check_sum_generate(
+        sbc_decoder_frame->sbc_buffer, sbc_decoder_frame->sbc_buffer_len);
     a2dp_audio_list_remove(list, sbc_decoder_frame);
   }
 
   ret = a2dp_cp_get_full_out_frame((void **)&out, &out_len);
   if (ret) {
     if (!get_in_cp_frame_cnt()) {
-            TRACE_A2DP_DECODER_I("[MCU][SBC] cp cache underflow list:%d in_cp:%d",a2dp_audio_list_length(list), get_in_cp_frame_cnt());
+      TRACE_A2DP_DECODER_I("[MCU][SBC] cp cache underflow list:%d in_cp:%d",
+                           a2dp_audio_list_length(list), get_in_cp_frame_cnt());
       return A2DP_DECODER_CACHE_UNDERFLOW_ERROR;
     }
     if (!a2dp_audio_sysfreq_boost_running()) {
@@ -177,7 +185,8 @@ static int a2dp_cp_sbc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
     osDelay(8);
     ret = a2dp_cp_get_full_out_frame((void **)&out, &out_len);
     if (ret) {
-            TRACE_A2DP_DECODER_I("[MCU][SBC] cp cache underflow list:%d in_cp:%d",a2dp_audio_list_length(list), get_in_cp_frame_cnt());
+      TRACE_A2DP_DECODER_I("[MCU][SBC] cp cache underflow list:%d in_cp:%d",
+                           a2dp_audio_list_length(list), get_in_cp_frame_cnt());
       a2dp_cp_sbc_after_cache_underflow();
       return A2DP_DECODER_CACHE_UNDERFLOW_ERROR;
     }
@@ -190,56 +199,61 @@ static int a2dp_cp_sbc_mcu_decode(uint8_t *buffer, uint32_t buffer_bytes)
     return A2DP_DECODER_NO_ERROR;
   }
   if (out_len != out_frame_len) {
-         TRACE_A2DP_DECODER_I("[MCU][SBC] Bad out len %u (should be %u)", out_len, out_frame_len);
+    TRACE_A2DP_DECODER_I("[MCU][SBC] Bad out len %u (should be %u)", out_len,
+                         out_frame_len);
     set_cp_reset_flag(true);
     return A2DP_DECODER_DECODE_ERROR;
   }
   p_out_info = (struct A2DP_CP_SBC_OUT_FRM_INFO_T *)out;
   if (p_out_info->pcm_len) {
-        a2dp_audio_sbc_lastframe_info.sequenceNumber = p_out_info->in_info.sequenceNumber;
+    a2dp_audio_sbc_lastframe_info.sequenceNumber =
+        p_out_info->in_info.sequenceNumber;
     a2dp_audio_sbc_lastframe_info.timestamp = p_out_info->in_info.timestamp;
-        a2dp_audio_sbc_lastframe_info.curSubSequenceNumber = p_out_info->in_info.curSubSequenceNumber;
+    a2dp_audio_sbc_lastframe_info.curSubSequenceNumber =
-        a2dp_audio_sbc_lastframe_info.totalSubSequenceNumber = p_out_info->in_info.totalSubSequenceNumber;
+        p_out_info->in_info.curSubSequenceNumber;
+    a2dp_audio_sbc_lastframe_info.totalSubSequenceNumber =
+        p_out_info->in_info.totalSubSequenceNumber;
     a2dp_audio_sbc_lastframe_info.frame_samples = p_out_info->frame_samples;
     a2dp_audio_sbc_lastframe_info.decoded_frames += p_out_info->decoded_frames;
     a2dp_audio_sbc_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_list_length(list) +
-        a2dp_audio_sbc_lastframe_info.check_sum= check_sum?check_sum:a2dp_audio_sbc_lastframe_info.check_sum;
+        a2dp_cp_get_in_frame_cnt_by_index(p_out_info->frame_idx) - 1;
-        a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_sbc_lastframe_info);
+    a2dp_audio_sbc_lastframe_info.check_sum =
+        check_sum ? check_sum : a2dp_audio_sbc_lastframe_info.check_sum;
+    a2dp_audio_decoder_internal_lastframe_info_set(
+        &a2dp_audio_sbc_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_A2DP_DECODER_I("[MCU][SBC] line:%d cp decoder error  !!!!!!", __LINE__);
+    TRACE_A2DP_DECODER_I("[MCU][SBC] line:%d cp decoder error  !!!!!!",
+                         __LINE__);
     set_cp_reset_flag(true);
     return A2DP_DECODER_DECODE_ERROR;
   }
 
   ret = a2dp_cp_consume_full_out_frame();
   if (ret) {
-        TRACE_A2DP_DECODER_I("[MCU][SBC] cp_consume_full_out_frame failed: ret=%d",  ret);
+    TRACE_A2DP_DECODER_I("[MCU][SBC] cp_consume_full_out_frame failed: ret=%d",
+                         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_sbc(void)
+int cp_assert_sbc(void) {
-{
   _cp_assert = true;
   return 0;
 }
 #endif
 
-
 TEXT_SBC_LOC
-int a2dp_cp_sbc_cp_decode(void)
+int a2dp_cp_sbc_cp_decode(void) {
-{
   int ret = 0;
   enum CP_EMPTY_OUT_FRM_T out_frm_st;
   uint8_t *out = NULL;
@@ -262,7 +276,6 @@ int a2dp_cp_sbc_cp_decode(void)
     sbc_codec_init();
   }
 
-
 #ifdef __CP_EXCEPTION_TEST__
   if (_cp_assert) {
     _cp_assert = false;
@@ -275,18 +288,23 @@ int a2dp_cp_sbc_cp_decode(void)
   pcm_data = a2dp_audio_sbc_decoder.pcm_data;
 
   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) {
+  if (out_frm_st != CP_EMPTY_OUT_FRM_OK &&
+      out_frm_st != CP_EMPTY_OUT_FRM_WORKING) {
     return 1;
   }
 
-    ASSERT_A2DP_DECODER(out_len > sizeof(*p_out_info), "[CP][SBC] Bad out_len %u (should > %u)", out_len, sizeof(*p_out_info));
+  ASSERT_A2DP_DECODER(out_len > sizeof(*p_out_info),
+                      "[CP][SBC] Bad out_len %u (should > %u)", out_len,
+                      sizeof(*p_out_info));
 
   p_out_info = (struct A2DP_CP_SBC_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_A2DP_DECODER(out_len > sizeof(*p_out_info) + p_out_info->pcm_len, "[CP][SBC] Bad out_len %u (should > %u + %u)", out_len, sizeof(*p_out_info), p_out_info->pcm_len);
+  ASSERT_A2DP_DECODER(out_len > sizeof(*p_out_info) + p_out_info->pcm_len,
+                      "[CP][SBC] Bad out_len %u (should > %u + %u)", 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);
@@ -301,25 +319,25 @@ int a2dp_cp_sbc_cp_decode(void)
       p_out_info->pcm_len += pcm_data->dataLen;
       return 4;
     }
-        ASSERT_A2DP_DECODER(in_len > sizeof(*p_in_info), "%s: Bad in_len %u (should > %u)", __func__, in_len, sizeof(*p_in_info));
+    ASSERT_A2DP_DECODER(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_SBC_IN_FRM_INFO_T *)in_buf;
     in_buf += sizeof(*p_in_info);
     in_len -= sizeof(*p_in_info);
 
-        decoder_err = btif_sbc_decode_frames(sbc_decoder, in_buf, in_len,
+    decoder_err =
-                                    &bytes_parsed,
+        btif_sbc_decode_frames(sbc_decoder, in_buf, in_len, &bytes_parsed,
-                                    pcm_data,
+                               pcm_data, dec_len, sbc_subbands_gain);
-                                    dec_len,
+    switch (decoder_err) {
-                                    sbc_subbands_gain);
-        switch (decoder_err)
-        {
     case BT_STS_SUCCESS:
     case BT_STS_CONTINUE:
       break;
     case BT_STS_NO_RESOURCES:
       error = 1;
-                ASSERT_A2DP_DECODER(0, "sbc_decode BT_STS_NO_RESOURCES pcm has no more buffer, i think can't reach here");
+      ASSERT_A2DP_DECODER(0, "sbc_decode BT_STS_NO_RESOURCES pcm has no more "
+                             "buffer, i think can't reach here");
       break;
     case BT_STS_FAILED:
     default:
@@ -334,29 +352,34 @@ int a2dp_cp_sbc_cp_decode(void)
     p_out_info->frame_idx = a2dp_cp_get_in_frame_index();
 
     ret = a2dp_cp_consume_in_frame();
-        ASSERT_A2DP_DECODER(ret == 0, "%s: a2dp_cp_consume_in_frame() failed: ret=%d", __func__, ret);
+    ASSERT_A2DP_DECODER(ret == 0,
+                        "%s: a2dp_cp_consume_in_frame() failed: ret=%d",
+                        __func__, ret);
   }
 
   p_out_info->pcm_len += pcm_data->dataLen;
 
   if (error || out_len <= sizeof(*p_out_info) + p_out_info->pcm_len) {
     ret = a2dp_cp_consume_emtpy_out_frame();
-        ASSERT_A2DP_DECODER(ret == 0, "%s: a2dp_cp_consume_emtpy_out_frame() failed: ret=%d", __func__, ret);
+    ASSERT_A2DP_DECODER(ret == 0,
+                        "%s: a2dp_cp_consume_emtpy_out_frame() failed: ret=%d",
+                        __func__, ret);
   }
 
   return error;
 }
 #endif
 
-static int a2dp_audio_sbc_list_checker(void)
+static int a2dp_audio_sbc_list_checker(void) {
-{
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
   list_node_t *node = NULL;
   a2dp_audio_sbc_decoder_frame_t *sbc_decoder_frame = NULL;
   int cnt = 0;
 
   do {
-        sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_sbc_subframe_malloc(SBC_LIST_SAMPLES);
+    sbc_decoder_frame =
+        (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_sbc_subframe_malloc(
+            SBC_LIST_SAMPLES);
     if (sbc_decoder_frame) {
       a2dp_audio_list_append(list, sbc_decoder_frame);
     }
@@ -366,39 +389,49 @@ static int a2dp_audio_sbc_list_checker(void)
   do {
     node = a2dp_audio_list_begin(list);
     if (node) {
-            sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+      sbc_decoder_frame =
+          (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
       a2dp_audio_list_remove(list, sbc_decoder_frame);
     }
   } while (node);
 
-    TRACE_A2DP_DECODER_I("[SBC][INIT] cnt:%d list:%d", cnt, a2dp_audio_list_length(list));
+  TRACE_A2DP_DECODER_I("[SBC][INIT] cnt:%d list:%d", cnt,
+                       a2dp_audio_list_length(list));
 
   return 0;
 }
 
-int a2dp_audio_sbc_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context)
+int a2dp_audio_sbc_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context) {
-{
   TRACE_A2DP_DECODER_I("[SBC][INIT]");
 
   a2dp_audio_context_p = (A2DP_AUDIO_CONTEXT_T *)context;
 
   a2dp_audio_sbc_header_parser_init();
-    memset(&a2dp_audio_sbc_lastframe_info, 0, sizeof(A2DP_AUDIO_DECODER_LASTFRAME_INFO_T));
+  memset(&a2dp_audio_sbc_lastframe_info, 0,
+         sizeof(A2DP_AUDIO_DECODER_LASTFRAME_INFO_T));
   a2dp_audio_sbc_lastframe_info.stream_info = *config;
   a2dp_audio_sbc_lastframe_info.frame_samples = SBC_LIST_SAMPLES;
   a2dp_audio_sbc_lastframe_info.list_samples = SBC_LIST_SAMPLES;
-    a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_sbc_lastframe_info);
+  a2dp_audio_decoder_internal_lastframe_info_set(
+      &a2dp_audio_sbc_lastframe_info);
 
-    ASSERT_A2DP_DECODER(a2dp_audio_context_p->dest_packet_mut < SBC_MTU_LIMITER, "%s MTU OVERFLOW:%u/%u", __func__, a2dp_audio_context_p->dest_packet_mut, SBC_MTU_LIMITER);
+  ASSERT_A2DP_DECODER(a2dp_audio_context_p->dest_packet_mut < SBC_MTU_LIMITER,
+                      "%s MTU OVERFLOW:%u/%u", __func__,
+                      a2dp_audio_context_p->dest_packet_mut, SBC_MTU_LIMITER);
 
-    a2dp_audio_sbc_decoder.sbc_decoder = (btif_sbc_decoder_t *)a2dp_audio_heap_malloc(sizeof(btif_sbc_decoder_t));
+  a2dp_audio_sbc_decoder.sbc_decoder =
-    a2dp_audio_sbc_decoder.pcm_data = (btif_sbc_pcm_data_t *)a2dp_audio_heap_malloc(sizeof(btif_sbc_pcm_data_t));
+      (btif_sbc_decoder_t *)a2dp_audio_heap_malloc(sizeof(btif_sbc_decoder_t));
-    a2dp_audio_sbc_decoder_preparse = (btif_sbc_decoder_t *)a2dp_audio_heap_malloc(sizeof(btif_sbc_decoder_t));
+  a2dp_audio_sbc_decoder.pcm_data =
+      (btif_sbc_pcm_data_t *)a2dp_audio_heap_malloc(
+          sizeof(btif_sbc_pcm_data_t));
+  a2dp_audio_sbc_decoder_preparse =
+      (btif_sbc_decoder_t *)a2dp_audio_heap_malloc(sizeof(btif_sbc_decoder_t));
 #ifdef A2DP_CP_ACCEL
   int ret;
   cp_codec_reset = true;
   ret = a2dp_cp_init(a2dp_cp_sbc_cp_decode, CP_PROC_DELAY_2_FRAMES);
-    ASSERT_A2DP_DECODER(ret == 0, "%s: a2dp_cp_init() failed: ret=%d", __func__, ret);
+  ASSERT_A2DP_DECODER(ret == 0, "%s: a2dp_cp_init() failed: ret=%d", __func__,
+                      ret);
 #else
   sbc_codec_init();
 #endif
@@ -407,8 +440,7 @@ int a2dp_audio_sbc_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config, void *context)
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_sbc_deinit(void)
+int a2dp_audio_sbc_deinit(void) {
-{
 #ifdef A2DP_CP_ACCEL
   a2dp_cp_deinit();
 #endif
@@ -421,8 +453,7 @@ int a2dp_audio_sbc_deinit(void)
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_sbc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_sbc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes) {
-{
   bt_status_t ret = BT_STS_SUCCESS;
   uint16_t bytes_parsed = 0;
   float sbc_subbands_gain[8] = {1, 1, 1, 1, 1, 1, 1, 1};
@@ -436,7 +467,6 @@ int a2dp_audio_sbc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
   pcm_data = a2dp_audio_sbc_decoder.pcm_data;
   frame_pcmbyte = sbc_decoder->maxPcmLen;
 
-
   a2dp_audio_sbc_decoder_frame_t *sbc_decoder_frame = NULL;
   list_node_t *node = NULL;
 
@@ -447,48 +477,57 @@ int a2dp_audio_sbc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
 
   TRACE_A2DP_DECODER_D("[MCU][SBC] size:%d", a2dp_audio_list_length(list));
 
-    for (pcm_output_byte = 0; pcm_output_byte<buffer_bytes; pcm_output_byte += frame_pcmbyte){
+  for (pcm_output_byte = 0; pcm_output_byte < buffer_bytes;
+       pcm_output_byte += frame_pcmbyte) {
     node = a2dp_audio_list_begin(list);
 
     if (node) {
       uint32_t lock;
 
-            sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+      sbc_decoder_frame =
+          (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
 
       lock = int_lock();
-            ret = btif_sbc_decode_frames(sbc_decoder, sbc_decoder_frame->sbc_buffer, sbc_decoder_frame->sbc_buffer_len,
+      ret = btif_sbc_decode_frames(sbc_decoder, sbc_decoder_frame->sbc_buffer,
-                                        &bytes_parsed,
+                                   sbc_decoder_frame->sbc_buffer_len,
-                                        pcm_data,
+                                   &bytes_parsed, pcm_data, buffer_bytes,
-                                        buffer_bytes,
                                    sbc_subbands_gain);
       int_unlock(lock);
       TRACE_A2DP_DECODER_D("[MCU][SBC] seq:%d/%d/%d len:%d ret:%d used:%d",
                            sbc_decoder_frame->curSubSequenceNumber,
                            sbc_decoder_frame->totalSubSequenceNumber,
                            sbc_decoder_frame->sequenceNumber,
-                                                                        sbc_decoder_frame->sbc_buffer_len,
+                           sbc_decoder_frame->sbc_buffer_len, ret,
-                                                                        ret,
                            bytes_parsed);
 
-            a2dp_audio_sbc_lastframe_info.sequenceNumber = sbc_decoder_frame->sequenceNumber;
+      a2dp_audio_sbc_lastframe_info.sequenceNumber =
+          sbc_decoder_frame->sequenceNumber;
       a2dp_audio_sbc_lastframe_info.timestamp = sbc_decoder_frame->timestamp;
-            a2dp_audio_sbc_lastframe_info.curSubSequenceNumber = sbc_decoder_frame->curSubSequenceNumber;
+      a2dp_audio_sbc_lastframe_info.curSubSequenceNumber =
-            a2dp_audio_sbc_lastframe_info.totalSubSequenceNumber = sbc_decoder_frame->totalSubSequenceNumber;
+          sbc_decoder_frame->curSubSequenceNumber;
+      a2dp_audio_sbc_lastframe_info.totalSubSequenceNumber =
+          sbc_decoder_frame->totalSubSequenceNumber;
       a2dp_audio_sbc_lastframe_info.frame_samples = sbc_decoder->maxPcmLen / 4;
       a2dp_audio_sbc_lastframe_info.decoded_frames++;
-            a2dp_audio_sbc_lastframe_info.undecode_frames = a2dp_audio_list_length(list)-1;
+      a2dp_audio_sbc_lastframe_info.undecode_frames =
-            a2dp_audio_sbc_lastframe_info.check_sum = a2dp_audio_decoder_internal_check_sum_generate(sbc_decoder_frame->sbc_buffer, sbc_decoder_frame->sbc_buffer_len);
+          a2dp_audio_list_length(list) - 1;
-            a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_sbc_lastframe_info);
+      a2dp_audio_sbc_lastframe_info.check_sum =
+          a2dp_audio_decoder_internal_check_sum_generate(
+              sbc_decoder_frame->sbc_buffer, sbc_decoder_frame->sbc_buffer_len);
+      a2dp_audio_decoder_internal_lastframe_info_set(
+          &a2dp_audio_sbc_lastframe_info);
       a2dp_audio_list_remove(list, sbc_decoder_frame);
-            switch (ret)
+      switch (ret) {
-            {
       case BT_STS_SUCCESS:
         if (pcm_data->dataLen != buffer_bytes) {
-                        TRACE_A2DP_DECODER_W("[MCU][SBC] WARNING pcm buff mismatch %d/%d", pcm_data->dataLen, buffer_bytes);
+          TRACE_A2DP_DECODER_W("[MCU][SBC] WARNING pcm buff mismatch %d/%d",
+                               pcm_data->dataLen, buffer_bytes);
         }
         if (pcm_data->dataLen == buffer_bytes) {
           if (pcm_output_byte + frame_pcmbyte != buffer_bytes) {
-                            TRACE_A2DP_DECODER_W("[MCU][SBC]WARNING loop not break %d/%d frame_pcm:%d", pcm_output_byte, buffer_bytes, frame_pcmbyte);
+            TRACE_A2DP_DECODER_W(
+                "[MCU][SBC]WARNING loop not break %d/%d frame_pcm:%d",
+                pcm_output_byte, buffer_bytes, frame_pcmbyte);
             goto exit;
           }
         }
@@ -497,7 +536,8 @@ int a2dp_audio_sbc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
         continue;
         break;
       case BT_STS_NO_RESOURCES:
-                    ASSERT_A2DP_DECODER(0, "sbc_decode BT_STS_NO_RESOURCES pcm has no more buffer, i think can't reach here");
+        ASSERT_A2DP_DECODER(0, "sbc_decode BT_STS_NO_RESOURCES pcm has no more "
+                               "buffer, i think can't reach here");
         break;
       case BT_STS_FAILED:
       default:
@@ -510,21 +550,21 @@ int a2dp_audio_sbc_mcu_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
       cache_underflow = true;
       goto exit;
     }
-
   }
 exit:
   if (cache_underflow) {
-        TRACE_A2DP_DECODER_W("[MCU][SBC] A2DP PACKET CACHE UNDERFLOW need add some process");
+    TRACE_A2DP_DECODER_W(
+        "[MCU][SBC] A2DP PACKET CACHE UNDERFLOW need add some process");
     a2dp_audio_sbc_lastframe_info.undecode_frames = 0;
     a2dp_audio_sbc_lastframe_info.check_sum = 0;
-        a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_sbc_lastframe_info);
+    a2dp_audio_decoder_internal_lastframe_info_set(
+        &a2dp_audio_sbc_lastframe_info);
     ret = A2DP_DECODER_CACHE_UNDERFLOW_ERROR;
   }
   return ret;
 }
 
-int a2dp_audio_sbc_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_sbc_decode_frame(uint8_t *buffer, uint32_t buffer_bytes) {
-{
   int nRet = 0;
   if (sbc_chnl_mode_mono) {
     int i = 0;
@@ -555,8 +595,8 @@ int a2dp_audio_sbc_decode_frame(uint8_t *buffer, uint32_t buffer_bytes)
   return nRet;
 }
 
-int a2dp_audio_sbc_preparse_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_sbc_preparse_packet(btif_media_header_t *header, uint8_t *buffer,
-{
+                                   uint32_t buffer_bytes) {
   uint16_t bytes_parsed = 0;
   uint32_t frame_num = 0;
   uint8_t *parser_p = buffer;
@@ -565,57 +605,63 @@ int a2dp_audio_sbc_preparse_packet(btif_media_header_t * header, uint8_t *buffer
   parser_p++;
   buffer_bytes--;
 
-    // TODO: Remove the following sbc init and decode codes. They might conflict with the calls
+  // TODO: Remove the following sbc init and decode codes. They might conflict
-    //       during CP process. CP process is triggered by audioflinger PCM callback.
+  // with the calls
-
+  //       during CP process. CP process is triggered by audioflinger PCM
+  //       callback.
 
   if (*parser_p != 0x9c) {
-        TRACE_A2DP_DECODER_I("[SBC][PRE] ERROR SBC FRAME !!! frame_num:%d", frame_num);
+    TRACE_A2DP_DECODER_I("[SBC][PRE] ERROR SBC FRAME !!! frame_num:%d",
+                         frame_num);
     DUMP8("%02x ", parser_p, 12);
   } else {
-        btif_sbc_decode_frames_parser(a2dp_audio_sbc_decoder_preparse,parser_p, buffer_bytes, &bytes_parsed);
+    btif_sbc_decode_frames_parser(a2dp_audio_sbc_decoder_preparse, parser_p,
-        TRACE_A2DP_DECODER_I("[SBC][PRE] seq:%d tStmp:%08x smpR:%d ch:%d len:%d",
+                                  buffer_bytes, &bytes_parsed);
-                                                                                  header->sequenceNumber,
+    TRACE_A2DP_DECODER_I(
-                                                                                  header->timestamp,
+        "[SBC][PRE] seq:%d tStmp:%08x smpR:%d ch:%d len:%d",
+        header->sequenceNumber, header->timestamp,
         a2dp_audio_sbc_decoder_preparse->streamInfo.sampleFreq,
         a2dp_audio_sbc_decoder_preparse->streamInfo.channelMode,
         a2dp_audio_sbc_decoder_preparse->maxPcmLen);
-        TRACE_A2DP_DECODER_I("[SBC][PRE] frmN:%d par:%d/%d", frame_num, buffer_bytes, bytes_parsed);
+    TRACE_A2DP_DECODER_I("[SBC][PRE] frmN:%d par:%d/%d", frame_num,
+                         buffer_bytes, bytes_parsed);
 
     a2dp_audio_sbc_lastframe_info.sequenceNumber = header->sequenceNumber;
     a2dp_audio_sbc_lastframe_info.timestamp = header->timestamp;
     a2dp_audio_sbc_lastframe_info.curSubSequenceNumber = 0;
     a2dp_audio_sbc_lastframe_info.totalSubSequenceNumber = frame_num;
-        a2dp_audio_sbc_lastframe_info.frame_samples = a2dp_audio_sbc_decoder_preparse->maxPcmLen/4;
+    a2dp_audio_sbc_lastframe_info.frame_samples =
+        a2dp_audio_sbc_decoder_preparse->maxPcmLen / 4;
     a2dp_audio_sbc_lastframe_info.list_samples = SBC_LIST_SAMPLES;
     a2dp_audio_sbc_lastframe_info.decoded_frames = 0;
     a2dp_audio_sbc_lastframe_info.undecode_frames = 0;
-        a2dp_audio_decoder_internal_lastframe_info_set(&a2dp_audio_sbc_lastframe_info);
+    a2dp_audio_decoder_internal_lastframe_info_set(
+        &a2dp_audio_sbc_lastframe_info);
   }
-    if (a2dp_audio_sbc_decoder_preparse->streamInfo.channelMode == BTIF_SBC_CHNL_MODE_MONO){
+  if (a2dp_audio_sbc_decoder_preparse->streamInfo.channelMode ==
+      BTIF_SBC_CHNL_MODE_MONO) {
     sbc_chnl_mode_mono = true;
   }
   return A2DP_DECODER_NO_ERROR;
 }
 
-
+static int a2dp_audio_sbc_header_parser_init(void) {
-static int a2dp_audio_sbc_header_parser_init(void)
-{
   a2dp_audio_sbc_decoder_config.auto_synchronize_support = true;
   sbc_decoder_last_valid_frame_ready = false;
-    memset(&sbc_decoder_last_valid_frame, 0, sizeof(sbc_decoder_last_valid_frame));
+  memset(&sbc_decoder_last_valid_frame, 0,
+         sizeof(sbc_decoder_last_valid_frame));
   return 0;
 }
 
-static int a2dp_audio_sbc_packet_recover_save_last(btif_media_header_t *sbc_decoder_frame)
+static int a2dp_audio_sbc_packet_recover_save_last(
-{
+    btif_media_header_t *sbc_decoder_frame) {
   sbc_decoder_last_valid_frame = *sbc_decoder_frame;
   sbc_decoder_last_valid_frame_ready = true;
   return 0;
 }
 
-static int a2dp_audio_sbc_packet_recover_find_missing(btif_media_header_t *sbc_decoder_frame, uint8_t frame_cnt)
+static int a2dp_audio_sbc_packet_recover_find_missing(
-{
+    btif_media_header_t *sbc_decoder_frame, uint8_t frame_cnt) {
   uint16_t diff_seq = 0;
   uint32_t diff_timestamp = 0;
   uint32_t diff = 0;
@@ -625,8 +671,12 @@ static int a2dp_audio_sbc_packet_recover_find_missing(btif_media_header_t *sbc_d
     return need_recover_pkt;
   }
 
-    diff_seq = a2dp_audio_get_passed(sbc_decoder_frame->sequenceNumber, sbc_decoder_last_valid_frame.sequenceNumber, UINT16_MAX);
+  diff_seq = a2dp_audio_get_passed(sbc_decoder_frame->sequenceNumber,
-    diff_timestamp = a2dp_audio_get_passed(sbc_decoder_frame->timestamp, sbc_decoder_last_valid_frame.timestamp, UINT32_MAX);
+                                   sbc_decoder_last_valid_frame.sequenceNumber,
+                                   UINT16_MAX);
+  diff_timestamp =
+      a2dp_audio_get_passed(sbc_decoder_frame->timestamp,
+                            sbc_decoder_last_valid_frame.timestamp, UINT32_MAX);
   if (diff_seq > 1) {
     diff = diff_timestamp / diff_seq;
     if (diff % SBC_LIST_SAMPLES == 0) {
@@ -638,31 +688,41 @@ static int a2dp_audio_sbc_packet_recover_find_missing(btif_media_header_t *sbc_d
       diff_seq--;
       need_recover_pkt = diff_seq * frame_cnt;
     }
-        TRACE_A2DP_DECODER_W("[SBC][INPUT][PLC] seq:%d/%d stmp:%d/%d", sbc_decoder_frame->sequenceNumber, sbc_decoder_last_valid_frame.sequenceNumber,
+    TRACE_A2DP_DECODER_W("[SBC][INPUT][PLC] seq:%d/%d stmp:%d/%d",
-                                                                                  sbc_decoder_frame->timestamp, sbc_decoder_last_valid_frame.timestamp);
+                         sbc_decoder_frame->sequenceNumber,
-        TRACE_A2DP_DECODER_W("[SBC][INPUT][PLC] diff_seq:%d diff_stmp:%d diff:%d missing:%d", diff_seq, diff_timestamp, diff, need_recover_pkt);
+                         sbc_decoder_last_valid_frame.sequenceNumber,
+                         sbc_decoder_frame->timestamp,
+                         sbc_decoder_last_valid_frame.timestamp);
+    TRACE_A2DP_DECODER_W(
+        "[SBC][INPUT][PLC] diff_seq:%d diff_stmp:%d diff:%d missing:%d",
+        diff_seq, diff_timestamp, diff, need_recover_pkt);
   }
 
   return need_recover_pkt;
 }
 
-static int a2dp_audio_sbc_packet_recover_proc(btif_media_header_t *sbc_decoder_frame, a2dp_audio_sbc_decoder_frame_t *sbc_raw_frame, uint8_t frame_cnt)
+static int a2dp_audio_sbc_packet_recover_proc(
-{
+    btif_media_header_t *sbc_decoder_frame,
+    a2dp_audio_sbc_decoder_frame_t *sbc_raw_frame, uint8_t frame_cnt) {
   int nRet = A2DP_DECODER_NO_ERROR;
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
   int missing_pkt_cnt = 0;
-    missing_pkt_cnt = a2dp_audio_sbc_packet_recover_find_missing(sbc_decoder_frame, frame_cnt);
+  missing_pkt_cnt =
+      a2dp_audio_sbc_packet_recover_find_missing(sbc_decoder_frame, frame_cnt);
   if (missing_pkt_cnt && sbc_raw_frame &&
       (a2dp_audio_list_length(list) + missing_pkt_cnt) < sbc_mtu_limiter) {
     for (uint8_t i = 0; i < missing_pkt_cnt; i++) {
-            a2dp_audio_sbc_decoder_frame_t *frame_p = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_sbc_subframe_malloc(sbc_raw_frame->sbc_buffer_len);
+      a2dp_audio_sbc_decoder_frame_t *frame_p =
+          (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_sbc_subframe_malloc(
+              sbc_raw_frame->sbc_buffer_len);
       if (!frame_p) {
         nRet = A2DP_DECODER_MEMORY_ERROR;
         goto exit;
       }
       frame_p->sequenceNumber = UINT16_MAX;
       frame_p->timestamp = UINT32_MAX;
-            memcpy(frame_p->sbc_buffer, sbc_raw_frame->sbc_buffer, sbc_raw_frame->sbc_buffer_len);
+      memcpy(frame_p->sbc_buffer, sbc_raw_frame->sbc_buffer,
+             sbc_raw_frame->sbc_buffer_len);
       frame_p->sbc_buffer_len = sbc_raw_frame->sbc_buffer_len;
       a2dp_audio_list_append(list, frame_p);
     }
@@ -672,8 +732,8 @@ exit:
 }
 
 #define FRAME_LIST_MAX (20)
-int a2dp_audio_sbc_store_packet(btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
+int a2dp_audio_sbc_store_packet(btif_media_header_t *header, uint8_t *buffer,
-{
+                                uint32_t buffer_bytes) {
   int nRet = A2DP_DECODER_NO_ERROR;
 
   uint32_t frame_cnt = 0;
@@ -682,7 +742,9 @@ int a2dp_audio_sbc_store_packet(btif_media_header_t * header, uint8_t *buffer, u
   uint8_t *parser_p = buffer;
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
   uint16_t bytes_parsed = 0;
-    a2dp_audio_sbc_decoder_frame_t *frame_list[FRAME_LIST_MAX] = {0,};
+  a2dp_audio_sbc_decoder_frame_t *frame_list[FRAME_LIST_MAX] = {
+      0,
+  };
   uint8_t frame_list_idx = 0;
   bool find_err = false;
   uint32_t i = 0;
@@ -690,7 +752,8 @@ int a2dp_audio_sbc_store_packet(btif_media_header_t * header, uint8_t *buffer, u
   frame_num = *parser_p;
 
   if (!frame_num) {
-        TRACE_A2DP_DECODER_W("[SBC][INPUT] ERROR SBC FRAME !!! frame_num:%d", frame_num);
+    TRACE_A2DP_DECODER_W("[SBC][INPUT] ERROR SBC FRAME !!! frame_num:%d",
+                         frame_num);
     DUMP8("%02x ", parser_p, 12);
     return A2DP_DECODER_DECODE_ERROR;
   }
@@ -703,14 +766,18 @@ int a2dp_audio_sbc_store_packet(btif_media_header_t * header, uint8_t *buffer, u
     for (i = 0; i < buffer_bytes; i += bytes_parsed, frame_cnt++) {
       bytes_parsed = 0;
       if (*(parser_p + i) == 0x9c) {
-                if (btif_sbc_decode_frames_parser(a2dp_audio_sbc_decoder_preparse, parser_p+i, buffer_bytes, &bytes_parsed) != BT_STS_SUCCESS){
+        if (btif_sbc_decode_frames_parser(a2dp_audio_sbc_decoder_preparse,
+                                          parser_p + i, buffer_bytes,
+                                          &bytes_parsed) != BT_STS_SUCCESS) {
           bytes_parsed = frame_len;
           TRACE_A2DP_DECODER_W("[SBC][INPUT] ERROR SBC FRAME PARSER !!!");
           DUMP8("%02x ", parser_p + i, 12);
           find_err = true;
           break;
         }
-                a2dp_audio_sbc_decoder_frame_t *frame_p = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_sbc_subframe_malloc(bytes_parsed);
+        a2dp_audio_sbc_decoder_frame_t *frame_p =
+            (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_sbc_subframe_malloc(
+                bytes_parsed);
         if (!frame_p) {
           nRet = A2DP_DECODER_MEMORY_ERROR;
           find_err = true;
@@ -749,15 +816,15 @@ int a2dp_audio_sbc_store_packet(btif_media_header_t * header, uint8_t *buffer, u
       nRet = A2DP_DECODER_NO_ERROR;
     }
   } else {
-        TRACE_A2DP_DECODER_W("[SBC][INPUT] OVERFLOW list:%d", a2dp_audio_list_length(list));
+    TRACE_A2DP_DECODER_W("[SBC][INPUT] OVERFLOW list:%d",
+                         a2dp_audio_list_length(list));
     nRet = A2DP_DECODER_MTU_LIMTER_ERROR;
   }
 
   return nRet;
 }
 
-int a2dp_audio_sbc_discards_packet(uint32_t packets)
+int a2dp_audio_sbc_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;
@@ -773,14 +840,16 @@ int a2dp_audio_sbc_discards_packet(uint32_t packets)
   if (!node) {
     goto exit;
   }
-    sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+  sbc_decoder_frame =
+      (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
 
   for (j = 0; j < a2dp_audio_list_length(list); j++) {
     node = a2dp_audio_list_begin(list);
     if (!node) {
       goto exit;
     }
-        sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+    sbc_decoder_frame =
+        (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
     if (sbc_decoder_frame->curSubSequenceNumber != 0) {
       a2dp_audio_list_remove(list, sbc_decoder_frame);
     } else {
@@ -792,8 +861,10 @@ int a2dp_audio_sbc_discards_packet(uint32_t packets)
   if (!node) {
     goto exit;
   }
-    sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+  sbc_decoder_frame =
-    ASSERT_A2DP_DECODER(sbc_decoder_frame->curSubSequenceNumber == 0, "sbc_discards_packet not align curSubSequenceNumber:%d",
+      (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+  ASSERT_A2DP_DECODER(sbc_decoder_frame->curSubSequenceNumber == 0,
+                      "sbc_discards_packet not align curSubSequenceNumber:%d",
                       sbc_decoder_frame->curSubSequenceNumber);
 
   totalSubSequenceNumber = sbc_decoder_frame->totalSubSequenceNumber;
@@ -805,7 +876,8 @@ int a2dp_audio_sbc_discards_packet(uint32_t packets)
         if (!node) {
           goto exit;
         }
-                sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+        sbc_decoder_frame =
+            (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, sbc_decoder_frame);
       }
     }
@@ -816,18 +888,22 @@ exit:
   return nRet;
 }
 
-int a2dp_audio_sbc_headframe_info_get(A2DP_AUDIO_HEADFRAME_INFO_T *headframe_info)
+int a2dp_audio_sbc_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_sbc_decoder_frame_t *sbc_decoder_frame = NULL;
 
-    if (a2dp_audio_list_length(list) && ((node = a2dp_audio_list_begin(list)) != NULL)){
+  if (a2dp_audio_list_length(list) &&
-        sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+      ((node = a2dp_audio_list_begin(list)) != NULL)) {
+    sbc_decoder_frame =
+        (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
     headframe_info->sequenceNumber = sbc_decoder_frame->sequenceNumber;
     headframe_info->timestamp = sbc_decoder_frame->timestamp;
-        headframe_info->curSubSequenceNumber   = sbc_decoder_frame->curSubSequenceNumber;
+    headframe_info->curSubSequenceNumber =
-        headframe_info->totalSubSequenceNumber = sbc_decoder_frame->totalSubSequenceNumber;
+        sbc_decoder_frame->curSubSequenceNumber;
+    headframe_info->totalSubSequenceNumber =
+        sbc_decoder_frame->totalSubSequenceNumber;
   } else {
     memset(headframe_info, 0, sizeof(A2DP_AUDIO_HEADFRAME_INFO_T));
   }
@@ -835,13 +911,10 @@ int a2dp_audio_sbc_headframe_info_get(A2DP_AUDIO_HEADFRAME_INFO_T *headframe_inf
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_sbc_info_get(void *info)
+int a2dp_audio_sbc_info_get(void *info) { return A2DP_DECODER_NO_ERROR; }
-{
-    return A2DP_DECODER_NO_ERROR;
-}
 
-int a2dp_audio_sbc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info, uint32_t mask)
+int a2dp_audio_sbc_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;
@@ -857,10 +930,19 @@ int a2dp_audio_sbc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info, ui
   for (uint16_t i = 0; i < list_len; i++) {
     node = a2dp_audio_list_begin(list);
     if (node) {
-            sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+      sbc_decoder_frame =
-            if  (A2DP_AUDIO_SYNCFRAME_CHK(sbc_decoder_frame->sequenceNumber         == sync_info->sequenceNumber,        A2DP_AUDIO_SYNCFRAME_MASK_SEQ,        mask)&&
+          (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
-                 A2DP_AUDIO_SYNCFRAME_CHK(sbc_decoder_frame->curSubSequenceNumber   == sync_info->curSubSequenceNumber,  A2DP_AUDIO_SYNCFRAME_MASK_CURRSUBSEQ, mask)&&
+      if (A2DP_AUDIO_SYNCFRAME_CHK(sbc_decoder_frame->sequenceNumber ==
-                 A2DP_AUDIO_SYNCFRAME_CHK(sbc_decoder_frame->totalSubSequenceNumber == sync_info->totalSubSequenceNumber,A2DP_AUDIO_SYNCFRAME_MASK_TOTALSUBSEQ,mask)){
+                                       sync_info->sequenceNumber,
+                                   A2DP_AUDIO_SYNCFRAME_MASK_SEQ, mask) &&
+          A2DP_AUDIO_SYNCFRAME_CHK(sbc_decoder_frame->curSubSequenceNumber ==
+                                       sync_info->curSubSequenceNumber,
+                                   A2DP_AUDIO_SYNCFRAME_MASK_CURRSUBSEQ,
+                                   mask) &&
+          A2DP_AUDIO_SYNCFRAME_CHK(sbc_decoder_frame->totalSubSequenceNumber ==
+                                       sync_info->totalSubSequenceNumber,
+                                   A2DP_AUDIO_SYNCFRAME_MASK_TOTALSUBSEQ,
+                                   mask)) {
         nRet = A2DP_DECODER_NO_ERROR;
         break;
       }
@@ -870,10 +952,13 @@ int a2dp_audio_sbc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info, ui
 
   node = a2dp_audio_list_begin(list);
   if (node) {
-        sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+    sbc_decoder_frame =
-        TRACE_A2DP_DECODER_I("[MCU][SYNC][SBC] sync pkt nRet:%d SEQ:%d timestamp:%d %d/%d",
+        (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
-                                                      nRet, sbc_decoder_frame->sequenceNumber, sbc_decoder_frame->timestamp,
+    TRACE_A2DP_DECODER_I(
-                                                      sbc_decoder_frame->curSubSequenceNumber, sbc_decoder_frame->totalSubSequenceNumber);
+        "[MCU][SYNC][SBC] sync pkt nRet:%d SEQ:%d timestamp:%d %d/%d", nRet,
+        sbc_decoder_frame->sequenceNumber, sbc_decoder_frame->timestamp,
+        sbc_decoder_frame->curSubSequenceNumber,
+        sbc_decoder_frame->totalSubSequenceNumber);
   } else {
     TRACE_A2DP_DECODER_I("[MCU][SYNC][SBC] sync pkt nRet:%d", nRet);
   }
@@ -881,8 +966,7 @@ int a2dp_audio_sbc_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *sync_info, ui
   return nRet;
 }
 
-int a2dp_audio_sbc_synchronize_dest_packet_mut(uint16_t packet_mut)
+int a2dp_audio_sbc_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;
@@ -893,19 +977,20 @@ int a2dp_audio_sbc_synchronize_dest_packet_mut(uint16_t packet_mut)
     do {
       node = a2dp_audio_list_begin(list);
       if (node) {
-                sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+        sbc_decoder_frame =
+            (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, sbc_decoder_frame);
       }
     } while (a2dp_audio_list_length(list) > packet_mut);
   }
 
-    TRACE_A2DP_DECODER_I("[MCU][SYNC][SBC] dest pkt list:%d", a2dp_audio_list_length(list));
+  TRACE_A2DP_DECODER_I("[MCU][SYNC][SBC] dest pkt list:%d",
+                       a2dp_audio_list_length(list));
 
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_sbc_convert_list_to_samples(uint32_t *samples)
+int a2dp_audio_sbc_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;
 
@@ -917,15 +1002,15 @@ int a2dp_audio_sbc_convert_list_to_samples(uint32_t *samples)
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_sbc_discards_samples(uint32_t samples)
+int a2dp_audio_sbc_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_sbc_decoder_frame_t *sbc_decoder_frame = NULL;
   list_node_t *node = NULL;
   int need_remove_list = 0;
   uint32_t list_samples = 0;
-    ASSERT_A2DP_DECODER(!(samples%SBC_LIST_SAMPLES), "%s samples err:%d", __func__, samples);
+  ASSERT_A2DP_DECODER(!(samples % SBC_LIST_SAMPLES), "%s samples err:%d",
+                      __func__, samples);
 
   a2dp_audio_sbc_convert_list_to_samples(&list_samples);
   if (list_samples >= samples) {
@@ -933,7 +1018,8 @@ int a2dp_audio_sbc_discards_samples(uint32_t samples)
     for (int i = 0; i < need_remove_list; i++) {
       node = a2dp_audio_list_begin(list);
       if (node) {
-                sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
+        sbc_decoder_frame =
+            (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, sbc_decoder_frame);
       }
     }
@@ -943,8 +1029,7 @@ int a2dp_audio_sbc_discards_samples(uint32_t samples)
   return nRet;
 }
 
-int a2dp_audio_sbc_channel_select(A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel)
+int a2dp_audio_sbc_channel_select(A2DP_AUDIO_CHANNEL_SELECT_E chnl_sel) {
-{
   return A2DP_DECODER_NO_ERROR;
 }
 
@@ -966,4 +1051,3 @@ A2DP_AUDIO_DECODER_T a2dp_audio_sbc_decoder_config = {
     a2dp_audio_sbc_subframe_free,
     a2dp_audio_sbc_channel_select,
 };
-

apps/audioplayers/a2dp_decoder/a2dp_decoder_scalable.cpp

@@ -14,13 +14,13 @@
  *
  ****************************************************************************/
 // Standard C Included Files
-#include "cmsis.h"
-#include "plat_types.h"
-#include <string.h>
-#include "heap_api.h"
-#include "hal_location.h"
 #include "a2dp_decoder_internal.h"
 #include "app_audio.h"
+#include "cmsis.h"
+#include "hal_location.h"
+#include "heap_api.h"
+#include "plat_types.h"
+#include <string.h>
 #if defined(A2DP_SCALABLE_ON)
 #include "heap_api.h"
 #include "ssc.h"
@@ -43,7 +43,6 @@ static HANDLE_DECODER scalableDec_handle = NULL;
 
 static A2DP_AUDIO_DECODER_LASTFRAME_INFO_T lastframe_info;
 
-
 typedef struct {
   uint16_t sequenceNumber;
   uint32_t timestamp;
@@ -51,26 +50,22 @@ typedef struct {
   int buffer_len;
 } a2dp_audio_scalable_decoder_frame_t;
 
-static void ss_to_24bit_buf(int32_t * out, int32_t * in, int size)
+static void ss_to_24bit_buf(int32_t *out, int32_t *in, int size) {
-{
   for (int i = 0; i < size; i++) {
     out[i] = in[i];
   }
 }
 
-static void a2dp_audio_scalable_decoder_init(void)
+static void a2dp_audio_scalable_decoder_init(void) {
-{
   if (scalableDec_handle == NULL) {
     scalableDec_handle = scalable_decoder_place;
 
-
+    ssc_decoder_init(scalableDec_handle, output_config.num_channels,
-        ssc_decoder_init(scalableDec_handle, output_config.num_channels, output_config.sample_rate);
+                     output_config.sample_rate);
-
   }
 }
 
-static int scalableDecoder_Close(HANDLE_DECODER handle)
+static int scalableDecoder_Close(HANDLE_DECODER handle) {
-{
   if (handle) {
     a2dp_audio_heap_free(handle);
     a2dp_audio_heap_free(scalable_decoder_temp_buf);
@@ -79,30 +74,29 @@ static int scalableDecoder_Close(HANDLE_DECODER handle)
   return 0;
 }
 
-static void a2dp_audio_scalable_decoder_deinit(void)
+static void a2dp_audio_scalable_decoder_deinit(void) {
-{
   if (scalableDec_handle) {
     scalableDecoder_Close(scalableDec_handle);
     scalableDec_handle = NULL;
   }
 }
 
-static void a2dp_audio_scalable_decoder_reinit(void)
+static void a2dp_audio_scalable_decoder_reinit(void) {
-{
   if (scalableDec_handle) {
     a2dp_audio_scalable_decoder_deinit();
   }
   a2dp_audio_scalable_decoder_init();
 }
 
-static bool is_valid_frame(a2dp_audio_scalable_decoder_frame_t * decoder_frame_p)
+static bool
-{
+is_valid_frame(a2dp_audio_scalable_decoder_frame_t *decoder_frame_p) {
   int hw_tmp, len, bitrate_bps, frame_len, frame_size;
 
   int sampling_rate = 44100;
   unsigned char *input_buf = decoder_frame_p->buffer;
   if (decoder_frame_p->buffer_len < SCALABLE_HEAD_SIZE) {
-        TRACE_A2DP_DECODER_E("invalid scalable a2dp frame, length < SCALABLE_HEAD_SIZE !!!!!!!");
+    TRACE_A2DP_DECODER_E(
+        "invalid scalable a2dp frame, length < SCALABLE_HEAD_SIZE !!!!!!!");
     return false;
   }
 
@@ -144,21 +138,20 @@ static bool is_valid_frame(a2dp_audio_scalable_decoder_frame_t * decoder_frame_p
   } else {
     len = 369; // 744/2-4+1
   }
-    TRACE_A2DP_DECODER_D
+  TRACE_A2DP_DECODER_D(
-    ("scalable a2dp frame, length:%d bitrate:%d sampling_rate:%d",
+      "scalable a2dp frame, length:%d bitrate:%d sampling_rate:%d",
       decoder_frame_p->buffer_len, bitrate_bps, sampling_rate);
   frame_len = SCALABLE_HEAD_SIZE + len - 1;
 
   if (decoder_frame_p->buffer_len < frame_len) {
-    TRACE_A2DP_DECODER_E
+    TRACE_A2DP_DECODER_E(
-        ("invalid scalable a2dp frame, length:%d  <  %d !!!!!!!", decoder_frame_p->buffer_len, frame_len);
+        "invalid scalable a2dp frame, length:%d  <  %d !!!!!!!",
+        decoder_frame_p->buffer_len, frame_len);
     return false;
   }
   return true;
-
 }
 
-
 #ifdef A2DP_CP_ACCEL
 struct A2DP_CP_scalable_IN_FRM_INFO_T {
   uint16_t sequenceNumber;
@@ -176,8 +169,8 @@ struct A2DP_CP_scalable_OUT_FRM_INFO_T {
 static bool cp_codec_reset;
 extern uint32_t app_bt_stream_get_dma_buffer_samples(void);
 
-TEXT_SSC_LOC static int a2dp_cp_scalable_mcu_decode(uint8_t * buffer, uint32_t buffer_bytes)
+TEXT_SSC_LOC static int a2dp_cp_scalable_mcu_decode(uint8_t *buffer,
-{
+                                                    uint32_t buffer_bytes) {
   a2dp_audio_scalable_decoder_frame_t *decoder_frame_p = NULL;
   list_node_t *node = NULL;
   list_t *list = a2dp_audio_context_p->audio_datapath.input_raw_packet_list;
@@ -191,9 +184,11 @@ TEXT_SSC_LOC static int a2dp_cp_scalable_mcu_decode(uint8_t * buffer, uint32_t b
 
   cp_buffer_frames_max = app_bt_stream_get_dma_buffer_samples() / 2;
   if (cp_buffer_frames_max % (lastframe_info.frame_samples)) {
-        cp_buffer_frames_max =  cp_buffer_frames_max /(lastframe_info.frame_samples) +1;
+    cp_buffer_frames_max =
+        cp_buffer_frames_max / (lastframe_info.frame_samples) + 1;
   } else {
-        cp_buffer_frames_max =  cp_buffer_frames_max /(lastframe_info.frame_samples);
+    cp_buffer_frames_max =
+        cp_buffer_frames_max / (lastframe_info.frame_samples);
   }
 
   out_frame_len = sizeof(*p_out_info) + buffer_bytes;
@@ -202,8 +197,8 @@ TEXT_SSC_LOC static int a2dp_cp_scalable_mcu_decode(uint8_t * buffer, uint32_t b
   ASSERT(ret == 0, "%s: a2dp_cp_decoder_init() failed: ret=%d", __func__, ret);
 
   while ((node = a2dp_audio_list_begin(list)) != NULL) {
-        decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
+    decoder_frame_p =
-        a2dp_audio_list_node(node);
+        (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
 
     if (false == is_valid_frame(decoder_frame_p)) {
       return A2DP_DECODER_DECODE_ERROR;
@@ -212,7 +207,9 @@ TEXT_SSC_LOC static int a2dp_cp_scalable_mcu_decode(uint8_t * buffer, uint32_t b
     in_info.sequenceNumber = decoder_frame_p->sequenceNumber;
     in_info.timestamp = decoder_frame_p->timestamp;
 
-        ret = a2dp_cp_put_in_frame(&in_info, sizeof(in_info), decoder_frame_p->buffer, decoder_frame_p->buffer_len);
+    ret =
+        a2dp_cp_put_in_frame(&in_info, sizeof(in_info), decoder_frame_p->buffer,
+                             decoder_frame_p->buffer_len);
     if (ret) {
       break;
     }
@@ -229,7 +226,8 @@ TEXT_SSC_LOC static int a2dp_cp_scalable_mcu_decode(uint8_t * buffer, uint32_t b
     a2dp_cp_consume_full_out_frame();
     return A2DP_DECODER_NO_ERROR;
   }
-    ASSERT(out_len == out_frame_len, "%s: Bad out len %u (should be %u)", __func__, out_len, out_frame_len);
+  ASSERT(out_len == out_frame_len, "%s: Bad out len %u (should be %u)",
+         __func__, out_len, out_frame_len);
 
   p_out_info = (struct A2DP_CP_scalable_OUT_FRM_INFO_T *)out;
   if (p_out_info->pcm_len) {
@@ -240,7 +238,8 @@ TEXT_SSC_LOC static int a2dp_cp_scalable_mcu_decode(uint8_t * buffer, uint32_t b
     lastframe_info.frame_samples = p_out_info->frame_samples;
     lastframe_info.decoded_frames += p_out_info->decoded_frames;
     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_list_length(list) +
+        a2dp_cp_get_in_frame_cnt_by_index(p_out_info->frame_idx) - 1;
     a2dp_audio_decoder_internal_lastframe_info_set(&lastframe_info);
   }
 
@@ -252,13 +251,13 @@ TEXT_SSC_LOC static int a2dp_cp_scalable_mcu_decode(uint8_t * buffer, uint32_t b
   }
 
   ret = a2dp_cp_consume_full_out_frame();
-    ASSERT(ret == 0, "%s: a2dp_cp_consume_full_out_frame() failed: ret=%d", __func__, ret);
+  ASSERT(ret == 0, "%s: a2dp_cp_consume_full_out_frame() failed: ret=%d",
+         __func__, ret);
 
   return dec_ret;
 }
 
-TEXT_SSC_LOC int a2dp_cp_scalable_cp_decode(void)
+TEXT_SSC_LOC int a2dp_cp_scalable_cp_decode(void) {
-{
   int ret;
   enum CP_EMPTY_OUT_FRM_T out_frm_st;
   uint8_t *out;
@@ -272,30 +271,30 @@ TEXT_SSC_LOC int a2dp_cp_scalable_cp_decode(void)
   uint32_t dec_sum;
   int error, output_samples = 0, output_byte = 0;
 
-    if (cp_codec_reset)
+  if (cp_codec_reset) {
-    {
     cp_codec_reset = false;
     a2dp_audio_scalable_decoder_init();
   }
 
   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)
+  if (out_frm_st != CP_EMPTY_OUT_FRM_OK &&
-    {
+      out_frm_st != CP_EMPTY_OUT_FRM_WORKING) {
     return 1;
   }
 
-    ASSERT(out_len > sizeof(*p_out_info), "%s: Bad out_len %u (should > %u)", __func__, out_len, sizeof(*p_out_info));
+  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_scalable_OUT_FRM_INFO_T *)out;
-    if (out_frm_st == CP_EMPTY_OUT_FRM_OK)
+  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);
+         "%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);
@@ -307,30 +306,31 @@ TEXT_SSC_LOC int a2dp_cp_scalable_cp_decode(void)
   dec_sum = 0;
   error = 0;
 
-    while (dec_sum < dec_len && error == 0)
+  while (dec_sum < dec_len && error == 0) {
-    {
     ret = a2dp_cp_get_in_frame((void **)&in_buf, &in_len);
 
-        if (ret)
+    if (ret) {
-        {
       break;
     }
 
-        ASSERT(in_len > sizeof(*p_in_info), "%s: Bad in_len %u (should > %u)", __func__, in_len, sizeof(*p_in_info));
+    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_scalable_IN_FRM_INFO_T *)in_buf;
     in_buf += sizeof(*p_in_info);
     in_len -= sizeof(*p_in_info);
     /* decode one SSC frame */
-        output_samples = ssc_decode(scalableDec_handle,(const unsigned char*)in_buf, ss_pcm_buff, SCALABLE_FRAME_SIZE, 0, 2);
+    output_samples =
-        if (0 == output_samples)
+        ssc_decode(scalableDec_handle, (const unsigned char *)in_buf,
-        {  
+                   ss_pcm_buff, SCALABLE_FRAME_SIZE, 0, 2);
+    if (0 == output_samples) {
       a2dp_audio_scalable_decoder_reinit();
       TRACE(0, "scalable_decode reinin codec \n");
       error = A2DP_DECODER_DECODE_ERROR;
       goto exit;
     }
 
-        ss_to_24bit_buf((int32_t *) (dec_start+dec_sum), (int32_t *) ss_pcm_buff, output_samples);
+    ss_to_24bit_buf((int32_t *)(dec_start + dec_sum), (int32_t *)ss_pcm_buff,
+                    output_samples);
     output_byte = output_samples * 4;
     dec_sum += output_byte;
   exit:
@@ -340,22 +340,24 @@ exit:
     p_out_info->frame_idx = a2dp_cp_get_in_frame_index();
 
     ret = a2dp_cp_consume_in_frame();
-        ASSERT(ret == 0, "%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);
   }
 
   p_out_info->pcm_len += dec_sum;
 
   if (error || 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);
+    ASSERT(ret == 0, "%s: a2dp_cp_consume_emtpy_out_frame() failed: ret=%d",
+           __func__, ret);
   }
 
   return error;
 }
 #endif
 
-static int a2dp_audio_scalable_init(A2DP_AUDIO_OUTPUT_CONFIG_T * config, void *context)
+static int a2dp_audio_scalable_init(A2DP_AUDIO_OUTPUT_CONFIG_T *config,
-{
+                                    void *context) {
   TRACE_A2DP_DECODER_D("%s", __func__);
 
   TRACE(0, "\n\nA2DP SSC-LC INIT\n");
@@ -371,19 +373,25 @@ static int a2dp_audio_scalable_init(A2DP_AUDIO_OUTPUT_CONFIG_T * config, void *c
   a2dp_audio_decoder_internal_lastframe_info_set(&lastframe_info);
 
   ASSERT(a2dp_audio_context_p->dest_packet_mut < SCALABLE_MTU_LIMITER,
-       "%s MTU OVERFLOW:%u/%u", __func__, a2dp_audio_context_p->dest_packet_mut, SCALABLE_MTU_LIMITER);
+         "%s MTU OVERFLOW:%u/%u", __func__,
+         a2dp_audio_context_p->dest_packet_mut, SCALABLE_MTU_LIMITER);
 
   int decoder_size;
 
-    decoder_size = ssc_decoder_get_size(output_config.num_channels); //todo:  get size with codec capability
+  decoder_size = ssc_decoder_get_size(
+      output_config.num_channels); // todo:  get size with codec capability
 
   TRACE(0, "decoder size %d", decoder_size);
 
-    scalable_decoder_place = (unsigned char *)a2dp_audio_heap_malloc(decoder_size);
+  scalable_decoder_place =
-    ASSERT_A2DP_DECODER(scalable_decoder_place, "no memory resource for scalable_decoder_place");
+      (unsigned char *)a2dp_audio_heap_malloc(decoder_size);
+  ASSERT_A2DP_DECODER(scalable_decoder_place,
+                      "no memory resource for scalable_decoder_place");
 
-    scalable_decoder_temp_buf = (unsigned char *)a2dp_audio_heap_malloc(SCALABLE_FRAME_SIZE * 16);
+  scalable_decoder_temp_buf =
-    ASSERT_A2DP_DECODER(scalable_decoder_temp_buf, "no memory resource for scalable_decoder_temp_buf");
+      (unsigned char *)a2dp_audio_heap_malloc(SCALABLE_FRAME_SIZE * 16);
+  ASSERT_A2DP_DECODER(scalable_decoder_temp_buf,
+                      "no memory resource for scalable_decoder_temp_buf");
 
 #ifdef A2DP_CP_ACCEL
   int ret;
@@ -397,8 +405,7 @@ static int a2dp_audio_scalable_init(A2DP_AUDIO_OUTPUT_CONFIG_T * config, void *c
   return A2DP_DECODER_NO_ERROR;
 }
 
-static int a2dp_audio_scalable_deinit(void)
+static int a2dp_audio_scalable_deinit(void) {
-{
 #ifdef A2DP_CP_ACCEL
   a2dp_cp_deinit();
 #endif
@@ -410,8 +417,8 @@ static int a2dp_audio_scalable_deinit(void)
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_scalable_mcu_decode_frame(uint8_t * buffer, uint32_t buffer_bytes)
+int a2dp_audio_scalable_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_scalable_decoder_frame_t *decoder_frame_p = NULL;
@@ -421,7 +428,8 @@ int a2dp_audio_scalable_mcu_decode_frame(uint8_t * buffer, uint32_t buffer_bytes
   int output_byte = 0, output_samples = 0;
   uint8_t *output = buffer;
   // TRACE(1,"bbd %d",buffer_bytes );
-    if (buffer_bytes < (SCALABLE_FRAME_SIZE * output_config.num_channels * output_config.bits_depth / 8)) {
+  if (buffer_bytes < (SCALABLE_FRAME_SIZE * output_config.num_channels *
+                      output_config.bits_depth / 8)) {
     TRACE(1, "scalable_decode pcm_len = %d \n", buffer_bytes);
     return A2DP_DECODER_NO_ERROR;
   }
@@ -437,8 +445,8 @@ int a2dp_audio_scalable_mcu_decode_frame(uint8_t * buffer, uint32_t buffer_bytes
       cache_underflow = true;
       goto exit;
     } else {
-        decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
+      decoder_frame_p =
-        a2dp_audio_list_node(node);
+          (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
 
       if (false == is_valid_frame(decoder_frame_p)) {
         TRACE_A2DP_DECODER_E("%s %d invalid a2dp frame", __func__, __LINE__);
@@ -447,13 +455,12 @@ int a2dp_audio_scalable_mcu_decode_frame(uint8_t * buffer, uint32_t buffer_bytes
       }
 
       /* decode one SSC frame */
-        output_samples =
+      output_samples = ssc_decode(scalableDec_handle, decoder_frame_p->buffer,
-        ssc_decode(scalableDec_handle,
+                                  ss_pcm_buff, SCALABLE_FRAME_SIZE, 0, 2);
-               decoder_frame_p->buffer, ss_pcm_buff, SCALABLE_FRAME_SIZE,0,2);
 
-        TRACE_A2DP_DECODER_D
+      TRACE_A2DP_DECODER_D("scalable_decode seq:%d len:%d output_samples:%d",
-        ("scalable_decode seq:%d len:%d output_samples:%d",
+                           decoder_frame_p->sequenceNumber,
-         decoder_frame_p->sequenceNumber, decoder_frame_p->buffer_len, output_samples);
+                           decoder_frame_p->buffer_len, output_samples);
 
       if (0 == output_samples) {
         TRACE(0, "scalable_decode failed  !!!!!!");
@@ -463,12 +470,13 @@ int a2dp_audio_scalable_mcu_decode_frame(uint8_t * buffer, uint32_t buffer_bytes
         ret = A2DP_DECODER_DECODE_ERROR;
         goto exit;
       }
-        ss_to_24bit_buf((int32_t *) output, (int32_t *) ss_pcm_buff, output_samples * 2);
+      ss_to_24bit_buf((int32_t *)output, (int32_t *)ss_pcm_buff,
+                      output_samples * 2);
       output_byte = output_samples * 8;
 
-
       output += output_byte;
-        ASSERT(SCALABLE_FRAME_SIZE == output_samples, "scalable_decode output mismatch samples:%d", output_samples);
+      ASSERT(SCALABLE_FRAME_SIZE == output_samples,
+             "scalable_decode output mismatch samples:%d", output_samples);
       lastframe_info.sequenceNumber = decoder_frame_p->sequenceNumber;
       lastframe_info.timestamp = decoder_frame_p->timestamp;
       lastframe_info.curSubSequenceNumber = 0;
@@ -478,9 +486,7 @@ int a2dp_audio_scalable_mcu_decode_frame(uint8_t * buffer, uint32_t buffer_bytes
       lastframe_info.undecode_frames = a2dp_audio_list_length(list) - 1;
       a2dp_audio_decoder_internal_lastframe_info_set(&lastframe_info);
       a2dp_audio_list_remove(list, decoder_frame_p);
-
     }
-
   }
 
 exit:
@@ -493,8 +499,8 @@ int a2dp_audio_scalable_mcu_decode_frame(uint8_t * buffer, uint32_t buffer_bytes
   return ret;
 }
 
-static int a2dp_audio_scalable_decode_frame(uint8_t * buffer, uint32_t buffer_bytes)
+static int a2dp_audio_scalable_decode_frame(uint8_t *buffer,
-{
+                                            uint32_t buffer_bytes) {
 #ifdef A2DP_CP_ACCEL
   return a2dp_cp_scalable_mcu_decode(buffer, buffer_bytes);
 #else
@@ -502,8 +508,9 @@ static int a2dp_audio_scalable_decode_frame(uint8_t * buffer, uint32_t buffer_by
 #endif
 }
 
-static int a2dp_audio_scalable_preparse_packet(btif_media_header_t * header, uint8_t * buffer, uint32_t buffer_bytes)
+static int a2dp_audio_scalable_preparse_packet(btif_media_header_t *header,
-{
+                                               uint8_t *buffer,
+                                               uint32_t buffer_bytes) {
   lastframe_info.sequenceNumber = header->sequenceNumber;
   lastframe_info.timestamp = header->timestamp;
   lastframe_info.curSubSequenceNumber = 0;
@@ -514,39 +521,43 @@ static int a2dp_audio_scalable_preparse_packet(btif_media_header_t * header, uin
   lastframe_info.undecode_frames = 0;
   a2dp_audio_decoder_internal_lastframe_info_set(&lastframe_info);
 
-    TRACE(3,"%s seq:%d timestamp:%08x", __func__, header->sequenceNumber, header->timestamp);
+  TRACE(3, "%s seq:%d timestamp:%08x", __func__, header->sequenceNumber,
+        header->timestamp);
 
   return A2DP_DECODER_NO_ERROR;
 }
 
-static void *a2dp_audio_scalable_frame_malloc(uint32_t packet_len)
+static void *a2dp_audio_scalable_frame_malloc(uint32_t packet_len) {
-{
   a2dp_audio_scalable_decoder_frame_t *decoder_frame_p = NULL;
   uint8_t *buffer = NULL;
 
   buffer = (uint8_t *)a2dp_audio_heap_malloc(SCALABLE_READBUF_SIZE);
-    decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
+  decoder_frame_p =
-    a2dp_audio_heap_malloc(sizeof(a2dp_audio_scalable_decoder_frame_t));
+      (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_heap_malloc(
+          sizeof(a2dp_audio_scalable_decoder_frame_t));
   decoder_frame_p->buffer = buffer;
   decoder_frame_p->buffer_len = packet_len;
   return (void *)decoder_frame_p;
 }
 
-static void a2dp_audio_scalable_free(void *packet)
+static void a2dp_audio_scalable_free(void *packet) {
-{
+  a2dp_audio_scalable_decoder_frame_t *decoder_frame_p =
-    a2dp_audio_scalable_decoder_frame_t *decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *) packet;
+      (a2dp_audio_scalable_decoder_frame_t *)packet;
   a2dp_audio_heap_free(decoder_frame_p->buffer);
   a2dp_audio_heap_free(decoder_frame_p);
 }
 
-static int a2dp_audio_scalable_store_packet(btif_media_header_t * header, uint8_t * buffer, uint32_t buffer_bytes)
+static int a2dp_audio_scalable_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;
   if (a2dp_audio_list_length(list) < SCALABLE_MTU_LIMITER) {
-    a2dp_audio_scalable_decoder_frame_t *decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
+    a2dp_audio_scalable_decoder_frame_t *decoder_frame_p =
-        a2dp_audio_scalable_frame_malloc(buffer_bytes);
+        (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_scalable_frame_malloc(
-    TRACE_A2DP_DECODER_D("%s seq:%d len:%d", __func__, header->sequenceNumber, buffer_bytes);
+            buffer_bytes);
+    TRACE_A2DP_DECODER_D("%s seq:%d len:%d", __func__, header->sequenceNumber,
+                         buffer_bytes);
     decoder_frame_p->sequenceNumber = header->sequenceNumber;
     decoder_frame_p->timestamp = header->timestamp;
     memcpy(decoder_frame_p->buffer, buffer, buffer_bytes);
@@ -554,15 +565,15 @@ static int a2dp_audio_scalable_store_packet(btif_media_header_t * header, uint8_
     a2dp_audio_list_append(list, decoder_frame_p);
     nRet = A2DP_DECODER_NO_ERROR;
   } else {
-    TRACE(2,"%s list full current len:%d", __func__, a2dp_audio_list_length(list));
+    TRACE(2, "%s list full current len:%d", __func__,
+          a2dp_audio_list_length(list));
     nRet = A2DP_DECODER_MTU_LIMTER_ERROR;
   }
 
   return nRet;
 }
 
-static int a2dp_audio_scalable_discards_packet(uint32_t packets)
+static int a2dp_audio_scalable_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;
@@ -575,8 +586,8 @@ static int a2dp_audio_scalable_discards_packet(uint32_t packets)
   if (packets <= a2dp_audio_list_length(list)) {
     for (uint8_t i = 0; i < packets; i++) {
       if ((node = a2dp_audio_list_begin(list)) != NULL) {
-            decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
+        decoder_frame_p =
-            a2dp_audio_list_node(node);
+            (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, decoder_frame_p);
       }
     }
@@ -587,15 +598,16 @@ static int a2dp_audio_scalable_discards_packet(uint32_t packets)
   return nRet;
 }
 
-static int a2dp_audio_scalable_headframe_info_get(A2DP_AUDIO_HEADFRAME_INFO_T* headframe_info)
+static int a2dp_audio_scalable_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_scalable_decoder_frame_t *decoder_frame_p = NULL;
 
   if (a2dp_audio_list_length(list)) {
     if ((node = a2dp_audio_list_begin(list)) != NULL) {
-            decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
+      decoder_frame_p =
+          (a2dp_audio_scalable_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;
@@ -608,13 +620,13 @@ static int a2dp_audio_scalable_headframe_info_get(A2DP_AUDIO_HEADFRAME_INFO_T* h
   return A2DP_DECODER_NO_ERROR;
 }
 
-static int a2dp_audio_scalable_info_get(void *info)
+static int a2dp_audio_scalable_info_get(void *info) {
-{
   return A2DP_DECODER_NO_ERROR;
 }
 
-static int a2dp_audio_scalable_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T * sync_info, uint32_t mask)
+static int
-{
+a2dp_audio_scalable_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;
@@ -629,10 +641,14 @@ static int a2dp_audio_scalable_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *
 
   for (uint16_t i = 0; i < list_len; i++) {
     if ((node = a2dp_audio_list_begin(list)) != NULL) {
-            decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
+      decoder_frame_p =
-                a2dp_audio_list_node(node);
+          (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
-            if (A2DP_AUDIO_SYNCFRAME_CHK(decoder_frame_p->sequenceNumber == sync_info->sequenceNumber, A2DP_AUDIO_SYNCFRAME_MASK_SEQ,       mask)&&
+      if (A2DP_AUDIO_SYNCFRAME_CHK(decoder_frame_p->sequenceNumber ==
-                A2DP_AUDIO_SYNCFRAME_CHK(decoder_frame_p->timestamp      == sync_info->timestamp,      A2DP_AUDIO_SYNCFRAME_MASK_TIMESTAMP, mask)) {
+                                       sync_info->sequenceNumber,
+                                   A2DP_AUDIO_SYNCFRAME_MASK_SEQ, mask) &&
+          A2DP_AUDIO_SYNCFRAME_CHK(decoder_frame_p->timestamp ==
+                                       sync_info->timestamp,
+                                   A2DP_AUDIO_SYNCFRAME_MASK_TIMESTAMP, mask)) {
         nRet = A2DP_DECODER_NO_ERROR;
         break;
       }
@@ -642,8 +658,8 @@ static int a2dp_audio_scalable_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *
 
   node = a2dp_audio_list_begin(list);
   if (node) {
-    decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
+    decoder_frame_p =
-        a2dp_audio_list_node(node);
+        (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
     TRACE(4, "%s nRet:%d SEQ:%d timestamp:%d", __func__, nRet,
           decoder_frame_p->sequenceNumber, decoder_frame_p->timestamp);
   } else {
@@ -653,8 +669,8 @@ static int a2dp_audio_scalable_synchronize_packet(A2DP_AUDIO_SYNCFRAME_INFO_T *
   return nRet;
 }
 
-static int a2dp_audio_scalable_synchronize_dest_packet_mut(uint16_t packet_mut)
+static int
-{
+a2dp_audio_scalable_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;
@@ -664,10 +680,9 @@ static int a2dp_audio_scalable_synchronize_dest_packet_mut(uint16_t packet_mut)
   if (list_len > packet_mut) {
     do {
       node = a2dp_audio_list_begin(list);
-        if (node)
+      if (node) {
-        {
+        decoder_frame_p =
-            decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
+            (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
-            a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, decoder_frame_p);
       }
     } while (a2dp_audio_list_length(list) > packet_mut);
@@ -678,8 +693,7 @@ static int a2dp_audio_scalable_synchronize_dest_packet_mut(uint16_t packet_mut)
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_scalable_convert_list_to_samples(uint32_t *samples)
+int a2dp_audio_scalable_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;
 
@@ -691,24 +705,24 @@ int a2dp_audio_scalable_convert_list_to_samples(uint32_t *samples)
   return A2DP_DECODER_NO_ERROR;
 }
 
-int a2dp_audio_scalable_discards_samples(uint32_t samples)
+int a2dp_audio_scalable_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_scalable_decoder_frame_t *scalable_decoder_frame = NULL;
   list_node_t *node = NULL;
   int need_remove_list = 0;
   uint32_t list_samples = 0;
-    ASSERT(!(samples%SCALABLE_FRAME_SIZE), "%s samples err:%d", __func__, samples);
+  ASSERT(!(samples % SCALABLE_FRAME_SIZE), "%s samples err:%d", __func__,
+         samples);
 
   a2dp_audio_scalable_convert_list_to_samples(&list_samples);
   if (list_samples >= samples) {
     need_remove_list = samples / SCALABLE_FRAME_SIZE;
     for (int i = 0; i < need_remove_list; i++) {
       node = a2dp_audio_list_begin(list);
-            if (node)
+      if (node) {
-            {
+        scalable_decoder_frame =
-                scalable_decoder_frame = (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
+            (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
         a2dp_audio_list_remove(list, scalable_decoder_frame);
       }
     }
@@ -735,5 +749,7 @@ A2DP_AUDIO_DECODER_T a2dp_audio_scalable_decoder_config = {
     a2dp_audio_scalable_free,
 };
 #else
-A2DP_AUDIO_DECODER_T a2dp_audio_scalable_decoder_config = { 0, };
+A2DP_AUDIO_DECODER_T a2dp_audio_scalable_decoder_config = {
+    0,
+};
 #endif

apps/audioplayers/app_audio.cpp

@@ -13,25 +13,25 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "cmsis_os.h"
 #include "app_bt_trace.h"
+#include "cmsis_os.h"
 #include "string.h"
 
-#include "cqueue.h"
-#include "list.h"
-#include "hal_aud.h"
-#include "resources.h"
-#include "app_thread.h"
 #include "app_audio.h"
 #include "app_media_player.h"
 #include "app_ring_merge.h"
+#include "app_thread.h"
+#include "cqueue.h"
+#include "hal_aud.h"
+#include "list.h"
 #include "nvrecord.h"
+#include "resources.h"
 #include <assert.h>
 
 #include "a2dp_api.h"
 
-#include "btapp.h"
 #include "app_bt_media_manager.h"
+#include "btapp.h"
 
 extern uint8_t __StackLimit[];
 extern uint8_t __HeapLimit[];
@@ -41,12 +41,12 @@ static const size_t heap_size = __StackLimit - __HeapLimit - 512;
 static bool app_audio_init = false;
 
 static uint32_t capture_audio_buff_size_used;
-// from the bottom of the system available memory pool, size is APP_CAPTURE_AUDIO_BUFFER_SIZE
+// from the bottom of the system available memory pool, size is
-// can be overlayed with the sco used audio buffer
+// APP_CAPTURE_AUDIO_BUFFER_SIZE can be overlayed with the sco used audio buffer
-static uint8_t* capture_audio_buffer = __HeapLimit + heap_size - APP_CAPTURE_AUDIO_BUFFER_SIZE;
+static uint8_t *capture_audio_buffer =
+    __HeapLimit + heap_size - APP_CAPTURE_AUDIO_BUFFER_SIZE;
 
-int app_capture_audio_mempool_init(void)
+int app_capture_audio_mempool_init(void) {
-{
   TRACE_AUD_HDL_I("[CAPMEM][INIT] size %d.", APP_CAPTURE_AUDIO_BUFFER_SIZE);
   capture_audio_buff_size_used = 0;
   memset((uint8_t *)capture_audio_buffer, 0, APP_CAPTURE_AUDIO_BUFFER_SIZE);
@@ -54,13 +54,11 @@ int app_capture_audio_mempool_init(void)
   return 0;
 }
 
-uint32_t app_capture_audio_mempool_free_buff_size()
+uint32_t app_capture_audio_mempool_free_buff_size() {
-{
   return APP_CAPTURE_AUDIO_BUFFER_SIZE - capture_audio_buff_size_used;
 }
 
-int app_capture_audio_mempool_get_buff(uint8_t **buff, uint32_t size)
+int app_capture_audio_mempool_get_buff(uint8_t **buff, uint32_t size) {
-{
   uint32_t buff_size_free;
   uint8_t *capture_buf_addr = (uint8_t *)capture_audio_buffer;
   buff_size_free = app_capture_audio_mempool_free_buff_size();
@@ -69,15 +67,18 @@ int app_capture_audio_mempool_get_buff(uint8_t **buff, uint32_t size)
     size = size + (4 - size % 4);
   }
 
-    TRACE_AUD_HDL_I("[CAPMEM][GET] current free %d to allocate %d", buff_size_free, size);
+  TRACE_AUD_HDL_I("[CAPMEM][GET] current free %d to allocate %d",
+                  buff_size_free, size);
 
-    ASSERT(size <= buff_size_free, "[%s] size = %d > free size = %d", __func__, size, buff_size_free);
+  ASSERT(size <= buff_size_free, "[%s] size = %d > free size = %d", __func__,
+         size, buff_size_free);
 
   *buff = capture_buf_addr + capture_audio_buff_size_used;
 
   capture_audio_buff_size_used += size;
-    TRACE_AUD_HDL_I("[CAPMEM][GET] %d, now used %d left %d",
+  TRACE_AUD_HDL_I("[CAPMEM][GET] %d, now used %d left %d", size,
-        size, capture_audio_buff_size_used, app_capture_audio_mempool_free_buff_size());
+                  capture_audio_buff_size_used,
+                  app_capture_audio_mempool_free_buff_size());
 
   return 0;
 }
@@ -100,60 +101,48 @@ typedef struct {
   list_t *audio_list;
 } APP_AUDIO_CONFIG;
 
-APP_AUDIO_CONFIG app_audio_conifg = {
+APP_AUDIO_CONFIG app_audio_conifg = {.audio_list = NULL};
-    .audio_list = NULL
-};
 
 #endif
 
-void LOCK_APP_AUDIO_QUEUE()
+void LOCK_APP_AUDIO_QUEUE() {
-{
   osMutexWait(g_app_audio_queue_mutex_id, osWaitForever);
 }
 
-void UNLOCK_APP_AUDIO_QUEUE()
+void UNLOCK_APP_AUDIO_QUEUE() { osMutexRelease(g_app_audio_queue_mutex_id); }
-{
-    osMutexRelease(g_app_audio_queue_mutex_id);
-}
 
-uint32_t app_audio_lr_balance(uint8_t *buf, uint32_t len, int8_t balance)
+uint32_t app_audio_lr_balance(uint8_t *buf, uint32_t len, int8_t balance) {
-{
   short *balance_buf = (short *)buf;
   uint32_t balance_len = len / 2;
   float factor;
 
-    ASSERT((balance >= -100) && (balance <= 100), "balance = %d is invalid!", balance);
+  ASSERT((balance >= -100) && (balance <= 100), "balance = %d is invalid!",
+         balance);
 
-    if(balance > 0)
+  if (balance > 0) {
-    {
     // reduce L channel
     factor = 1 - 0.01 * balance;
-        for(uint32_t i=0; i<balance_len;i+=2)
+    for (uint32_t i = 0; i < balance_len; i += 2) {
-        {
       balance_buf[i] = (short)(factor * balance_buf[i]);
     }
-    }
+  } else if (balance < 0) {
-    else if(balance < 0)
-    {
     // reduce R channel
     factor = 1 + 0.01 * balance;
-        for(uint32_t i=0; i<balance_len;i+=2)
+    for (uint32_t i = 0; i < balance_len; i += 2) {
-        {
       balance_buf[i + 1] = (short)(factor * balance_buf[i + 1]);
     }
   }
   return 0;
 }
 
-void app_audio_mempool_init_with_specific_size(uint32_t size)
+void app_audio_mempool_init_with_specific_size(uint32_t size) {
-{
   syspool_init_specific_size(size);
 }
 
-int app_audio_pcmbuff_init(uint8_t *buff, uint16_t len)
+int app_audio_pcmbuff_init(uint8_t *buff, uint16_t len) {
-{
   if (app_audio_pcmbuff_mutex_id == NULL)
-        app_audio_pcmbuff_mutex_id = osMutexCreate((osMutex(app_audio_pcmbuff_mutex)));
+    app_audio_pcmbuff_mutex_id =
+        osMutexCreate((osMutex(app_audio_pcmbuff_mutex)));
 
   if ((buff == NULL) || (app_audio_pcmbuff_mutex_id == NULL))
     return -1;
@@ -166,8 +155,7 @@ int app_audio_pcmbuff_init(uint8_t *buff, uint16_t len)
   return 0;
 }
 
-int app_audio_pcmbuff_length(void)
+int app_audio_pcmbuff_length(void) {
-{
   int len;
 
   osMutexWait(app_audio_pcmbuff_mutex_id, osWaitForever);
@@ -177,8 +165,7 @@ int app_audio_pcmbuff_length(void)
   return len;
 }
 
-int app_audio_pcmbuff_put(uint8_t *buff, uint16_t len)
+int app_audio_pcmbuff_put(uint8_t *buff, uint16_t len) {
-{
   int status;
 
   osMutexWait(app_audio_pcmbuff_mutex_id, osWaitForever);
@@ -188,8 +175,7 @@ int app_audio_pcmbuff_put(uint8_t *buff, uint16_t len)
   return status;
 }
 
-int app_audio_pcmbuff_get(uint8_t *buff, uint16_t len)
+int app_audio_pcmbuff_get(uint8_t *buff, uint16_t len) {
-{
   unsigned char *e1 = NULL, *e2 = NULL;
   unsigned int len1 = 0, len2 = 0;
   int status;
@@ -210,8 +196,7 @@ int app_audio_pcmbuff_get(uint8_t *buff, uint16_t len)
   return status;
 }
 
-int app_audio_pcmbuff_discard(uint16_t len)
+int app_audio_pcmbuff_discard(uint16_t len) {
-{
   int status;
 
   osMutexWait(app_audio_pcmbuff_mutex_id, osWaitForever);
@@ -221,27 +206,25 @@ int app_audio_pcmbuff_discard(uint16_t len)
   return status;
 }
 
-void __attribute__((section(".fast_text_sram"))) app_audio_memcpy_16bit(int16_t *des, int16_t *src, int len)
+void __attribute__((section(".fast_text_sram")))
-{
+app_audio_memcpy_16bit(int16_t *des, int16_t *src, int len) {
   // Check input
-    for(int i=0; i<len; i++)
+  for (int i = 0; i < len; i++) {
-    {
     des[i] = src[i];
   }
 }
 
-void __attribute__((section(".fast_text_sram"))) app_audio_memset_16bit(int16_t *des, int16_t val, int len)
+void __attribute__((section(".fast_text_sram")))
-{
+app_audio_memset_16bit(int16_t *des, int16_t val, int len) {
   // Check input
-    for(int i=0; i<len; i++)
+  for (int i = 0; i < len; i++) {
-    {
     des[i] = val;
   }
 }
 
 #ifdef __AUDIO_QUEUE_SUPPORT__
-int app_audio_sendrequest_param(uint16_t id, uint8_t status, uint32_t ptr, uint32_t param)
+int app_audio_sendrequest_param(uint16_t id, uint8_t status, uint32_t ptr,
-{
+                                uint32_t param) {
   uint32_t audevt;
   APP_MESSAGE_BLOCK msg;
 
@@ -258,23 +241,20 @@ int app_audio_sendrequest_param(uint16_t id, uint8_t status, uint32_t ptr, uint3
   return 0;
 }
 
-int app_audio_sendrequest(uint16_t id, uint8_t status, uint32_t ptr)
+int app_audio_sendrequest(uint16_t id, uint8_t status, uint32_t ptr) {
-{
   return app_audio_sendrequest_param(id, status, ptr, 0);
 }
 
 extern bool app_audio_list_playback_exist(void);
 #ifdef MEDIA_PLAYER_SUPPORT
-static uint8_t app_audio_get_list_playback_num(void)
+static uint8_t app_audio_get_list_playback_num(void) {
-{
   APP_AUDIO_STATUS *audio_handle = NULL;
   list_node_t *node = NULL;
   uint8_t num = 0;
-    for (node = list_begin(app_audio_conifg.audio_list); node != list_end(app_audio_conifg.audio_list); node = list_next(node))
+  for (node = list_begin(app_audio_conifg.audio_list);
-    {
+       node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
     audio_handle = (APP_AUDIO_STATUS *)list_node(node);
-        if(audio_handle == NULL)
+    if (audio_handle == NULL) {
-        {
       return num;
     }
     if (audio_handle->id == APP_PLAY_BACK_AUDIO)
@@ -286,8 +266,7 @@ static uint8_t app_audio_get_list_playback_num(void)
 #endif
 
 static bool need_flush_flash_switch_audio = false;
-void app_audio_switch_flash_flush_req(void)
+void app_audio_switch_flash_flush_req(void) {
-{
   uint32_t lock;
 
   lock = int_lock();
@@ -295,8 +274,7 @@ void app_audio_switch_flash_flush_req(void)
   int_unlock(lock);
 }
 
-static void app_audio_switch_flash_proc(void)
+static void app_audio_switch_flash_proc(void) {
-{
   // no need to do this across the audio switch,
   // will use suspend flash erase to assure that no audio
   // irq is missing for handling caused by long time global irq disabling
@@ -322,24 +300,20 @@ static void app_audio_switch_flash_proc(void)
 }
 
 #ifdef VOICE_DATAPATH
-static bool app_audio_handle_pre_processing(APP_MESSAGE_BODY *msg_body)
+static bool app_audio_handle_pre_processing(APP_MESSAGE_BODY *msg_body) {
-{
   uint16_t stream_type;
   APP_AUDIO_GET_AUD_ID(msg_body->message_ptr, stream_type);
 
   bool isToResetCaptureStream = false;
-    if ((BT_STREAM_SBC == stream_type) || (BT_STREAM_MEDIA == stream_type))
+  if ((BT_STREAM_SBC == stream_type) || (BT_STREAM_MEDIA == stream_type)) {
-    {
+    if (app_audio_manager_capture_is_active()) {
-        if (app_audio_manager_capture_is_active())
-        {
       isToResetCaptureStream = true;
     }
   }
 
-    if (isToResetCaptureStream)
+  if (isToResetCaptureStream) {
-    {
+    app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP, BT_STREAM_CAPTURE,
-        app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP,
+                                  0, 0);
-                BT_STREAM_CAPTURE, 0, 0);
 
     APP_MESSAGE_BLOCK msg;
     msg.msg_body = *msg_body;
@@ -349,16 +323,13 @@ static bool app_audio_handle_pre_processing(APP_MESSAGE_BODY *msg_body)
                                   BT_STREAM_CAPTURE, 0, 0);
 
     return false;
-    }
+  } else {
-    else
-    {
     return true;
   }
 }
 #endif
 
-static int app_audio_handle_process(APP_MESSAGE_BODY *msg_body)
+static int app_audio_handle_process(APP_MESSAGE_BODY *msg_body) {
-{
   int nRet = -1;
 
   APP_AUDIO_STATUS aud_status;
@@ -368,8 +339,7 @@ static int app_audio_handle_process(APP_MESSAGE_BODY *msg_body)
 
 #ifdef VOICE_DATAPATH
   bool isContinue = app_audio_handle_pre_processing(msg_body);
-    if (!isContinue)
+  if (!isContinue) {
-    {
     return -1;
   }
 #endif
@@ -379,23 +349,16 @@ static int app_audio_handle_process(APP_MESSAGE_BODY *msg_body)
   APP_AUDIO_GET_AUD_ID(msg_body->message_ptr, aud_status.aud_id);
   APP_AUDIO_GET_FREQ(msg_body->message_Param0, aud_status.freq);
 
-    switch (aud_status.status)
+  switch (aud_status.status) {
-    {
   case APP_BT_SETTING_OPEN:
 #ifdef __AUDIO_QUEUE_SUPPORT__
-        TRACE_AUD_HDL_I(
+    TRACE_AUD_HDL_I("[OPEN] before status_id: 0x%x%s, aud_id: %d, len = %d",
-                    "[OPEN] before status_id: 0x%x%s, aud_id: %d, len = %d",
+                    aud_status.id, player2str(aud_status.id), aud_status.aud_id,
-                    aud_status.id,
-                    player2str(aud_status.id),
-                    aud_status.aud_id,
                     list_length(app_audio_conifg.audio_list));
 
-        if (app_audio_list_append(&aud_status))
+    if (app_audio_list_append(&aud_status)) {
-        {
       app_bt_stream_open(&aud_status);
-            TRACE_AUD_HDL_I(
+      TRACE_AUD_HDL_I("[OPEN] after status_id: 0x%x%s, len = %d", aud_status.id,
-                        "[OPEN] after status_id: 0x%x%s, len = %d",
-                        aud_status.id,
                       player2str(aud_status.id),
                       list_length(app_audio_conifg.audio_list));
     }
@@ -408,30 +371,23 @@ static int app_audio_handle_process(APP_MESSAGE_BODY *msg_body)
     app_audio_switch_flash_proc();
 #ifdef __AUDIO_QUEUE_SUPPORT__
     APP_AUDIO_STATUS next_status;
-        TRACE_AUD_HDL_I(
+    TRACE_AUD_HDL_I("[CLOSE] current id: 0x%x%s", aud_status.id,
-                    "[CLOSE] current id: 0x%x%s",
-                    aud_status.id,
                     player2str(aud_status.id));
     app_bt_stream_close(aud_status.id);
     app_audio_switch_flash_proc();
 #ifdef MEDIA_PLAYER_SUPPORT
-        if (aud_status.id == APP_PLAY_BACK_AUDIO)
+    if (aud_status.id == APP_PLAY_BACK_AUDIO) {
-        {
       TRACE_AUD_HDL_I("[CLOSE] list: %d", app_audio_get_list_playback_num());
-            if (app_audio_get_list_playback_num() == 1)
+      if (app_audio_get_list_playback_num() == 1) {
-            {
         TRACE_AUD_HDL_I("=======>APP_BT_SETTING_CLOSE MEDIA");
         bt_media_stop(BT_STREAM_MEDIA, BT_DEVICE_ID_1);
       }
     }
 #endif
-        if (app_audio_list_rmv_callback(&aud_status, &next_status, APP_BT_SETTING_Q_POS_HEAD, false))
+    if (app_audio_list_rmv_callback(&aud_status, &next_status,
-        {
+                                    APP_BT_SETTING_Q_POS_HEAD, false)) {
-            TRACE_AUD_HDL_I(
+      TRACE_AUD_HDL_I("[CLOSE] %p, next id: 0x%x%s, status %d", &next_status,
-                        "[CLOSE] %p, next id: 0x%x%s, status %d",
+                      next_status.id, player2str(next_status.id),
-                        &next_status,
-                        next_status.id,
-                        player2str(next_status.id),
                       next_status.status);
       app_bt_stream_open(&next_status);
     }
@@ -461,37 +417,33 @@ static int app_audio_handle_process(APP_MESSAGE_BODY *msg_body)
 }
 
 #ifdef __AUDIO_QUEUE_SUPPORT__
-static void app_audio_handle_free(void* data)
+static void app_audio_handle_free(void *data) {
-{
 #ifdef MEDIA_PLAYER_SUPPORT
   APP_AUDIO_STATUS *status = (APP_AUDIO_STATUS *)data;
 
-    if(status->id == APP_PLAY_BACK_AUDIO)
+  if (status->id == APP_PLAY_BACK_AUDIO) {
-    {
+    TRACE_AUD_HDL_I("[HANDLE_FREE] , aud_id: 0x%x, type = 0x%x", status->aud_id,
-        TRACE_AUD_HDL_I("[HANDLE_FREE] , aud_id: 0x%x, type = 0x%x", status->aud_id, status->aud_type);
+                    status->aud_type);
   }
 #endif
   osPoolFree(app_audio_status_mempool, data);
 }
 
-void app_audio_list_create()
+void app_audio_list_create() {
-{
+  if (app_audio_conifg.audio_list == NULL) {
-    if (app_audio_conifg.audio_list == NULL)
-    {
     app_audio_conifg.audio_list = list_new(app_audio_handle_free, NULL, NULL);
   }
 }
 
-bool app_audio_list_stream_exist()
+bool app_audio_list_stream_exist() {
-{
   APP_AUDIO_STATUS *audio_handle = NULL;
   list_node_t *node = NULL;
 
-    for (node = list_begin(app_audio_conifg.audio_list); node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
+  for (node = list_begin(app_audio_conifg.audio_list);
+       node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
 
     audio_handle = (APP_AUDIO_STATUS *)list_node(node);
-        if(audio_handle == NULL)
+    if (audio_handle == NULL) {
-        {
       return false;
     }
     if (audio_handle->id == APP_BT_STREAM_HFP_PCM ||
@@ -508,8 +460,7 @@ bool app_audio_list_stream_exist()
 #ifdef __THIRDPARTY
         audio_handle->id == APP_BT_STREAM_THIRDPARTY_VOICE ||
 #endif
-            audio_handle->id == APP_BT_STREAM_A2DP_VENDOR
+        audio_handle->id == APP_BT_STREAM_A2DP_VENDOR) {
-        ) {
       TRACE_AUD_HDL_I("[STREAM_LIST][EXIST] id 0x%x", audio_handle->id);
       return true;
     }
@@ -518,8 +469,7 @@ bool app_audio_list_stream_exist()
   return false;
 }
 
-bool app_audio_list_filter_exist(APP_AUDIO_STATUS* aud_status)
+bool app_audio_list_filter_exist(APP_AUDIO_STATUS *aud_status) {
-{
 #ifdef MEDIA_PLAYER_SUPPORT
   APP_AUDIO_STATUS *audio_handle = NULL;
   list_node_t *node = NULL;
@@ -527,19 +477,23 @@ bool app_audio_list_filter_exist(APP_AUDIO_STATUS* aud_status)
 
   if (aud_status->id == APP_PLAY_BACK_AUDIO) {
     if (aud_status->aud_id == AUD_ID_BT_CALL_INCOMING_CALL) {
-            for (node = list_begin(app_audio_conifg.audio_list); node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
+      for (node = list_begin(app_audio_conifg.audio_list);
+           node != list_end(app_audio_conifg.audio_list);
+           node = list_next(node)) {
         audio_handle = (APP_AUDIO_STATUS *)list_node(node);
-                if(audio_handle == NULL)
+        if (audio_handle == NULL) {
-                {
           return false;
         }
-                if (audio_handle->id == APP_PLAY_BACK_AUDIO && audio_handle->aud_id == AUD_ID_BT_CALL_INCOMING_CALL) {
+        if (audio_handle->id == APP_PLAY_BACK_AUDIO &&
+            audio_handle->aud_id == AUD_ID_BT_CALL_INCOMING_CALL) {
           TRACE_AUD_HDL_I("[STREAM_LIST][FILTER] id 0x%x", audio_handle->id);
           return true;
         }
       }
     } else {
-            for (node = list_begin(app_audio_conifg.audio_list); node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
+      for (node = list_begin(app_audio_conifg.audio_list);
+           node != list_end(app_audio_conifg.audio_list);
+           node = list_next(node)) {
         audio_handle = (APP_AUDIO_STATUS *)list_node(node);
         if (cnt++ > 1) {
           TRACE_AUD_HDL_I("[STREAM_LIST][FILTER] cnt %d", cnt);
@@ -552,16 +506,15 @@ bool app_audio_list_filter_exist(APP_AUDIO_STATUS* aud_status)
   return false;
 }
 
-bool app_audio_list_playback_exist(void)
+bool app_audio_list_playback_exist(void) {
-{
 #ifdef MEDIA_PLAYER_SUPPORT
   APP_AUDIO_STATUS *audio_handle = NULL;
   list_node_t *node = NULL;
 
-    for (node = list_begin(app_audio_conifg.audio_list); node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
+  for (node = list_begin(app_audio_conifg.audio_list);
+       node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
     audio_handle = (APP_AUDIO_STATUS *)list_node(node);
-        if(audio_handle == NULL)
+    if (audio_handle == NULL) {
-        {
       return false;
     }
     if (audio_handle->id == APP_PLAY_BACK_AUDIO) {
@@ -573,16 +526,15 @@ bool app_audio_list_playback_exist(void)
   return false;
 }
 
-void app_audio_list_playback_clear(void)
+void app_audio_list_playback_clear(void) {
-{
 #ifdef MEDIA_PLAYER_SUPPORT
   APP_AUDIO_STATUS *audio_handle = NULL;
   list_node_t *node = NULL;
 
-    for (node = list_begin(app_audio_conifg.audio_list); node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
+  for (node = list_begin(app_audio_conifg.audio_list);
+       node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
     audio_handle = (APP_AUDIO_STATUS *)list_node(node);
-        if(audio_handle == NULL)
+    if (audio_handle == NULL) {
-        {
       TRACE_AUD_HDL_I("[STREAM_LIST][CLR] find null\n ");
       return;
     }
@@ -593,182 +545,162 @@ void app_audio_list_playback_clear(void)
 #endif
 }
 
-bool app_audio_list_append(APP_AUDIO_STATUS* aud_status)
+bool app_audio_list_append(APP_AUDIO_STATUS *aud_status) {
-{
   APP_AUDIO_STATUS *data_to_append = NULL;
   bool add_data_to_head_of_list = false;
   bool ret = true;
-    TRACE_AUD_HDL_I("[STREAM_LIST][APPEND] id 0x%x%s", aud_status->id, player2str(aud_status->id));
+  TRACE_AUD_HDL_I("[STREAM_LIST][APPEND] id 0x%x%s", aud_status->id,
+                  player2str(aud_status->id));
 #ifdef MEDIA_PLAYER_SUPPORT
-    if (aud_status->id == APP_PLAY_BACK_AUDIO)
+  if (aud_status->id == APP_PLAY_BACK_AUDIO) {
-    {
     // ignore redundant ring ind from hfp...
-        if (app_audio_list_filter_exist(aud_status))
+    if (app_audio_list_filter_exist(aud_status)) {
-        {
       return false;
     }
 
-        if (app_audio_list_playback_exist())
+    if (app_audio_list_playback_exist()) {
-        {
+      if (list_length(app_audio_conifg.audio_list) >= MAX_AUDIO_BUF_LIST) {
-            if (list_length(app_audio_conifg.audio_list) >= MAX_AUDIO_BUF_LIST)
+        if (app_audio_list_stream_exist()) {
-            {
+          data_to_append =
-                if (app_audio_list_stream_exist())
+              (APP_AUDIO_STATUS *)osPoolCAlloc(app_audio_status_mempool);
-                {
+          if (data_to_append == NULL) {
-                    data_to_append = (APP_AUDIO_STATUS *)osPoolCAlloc (app_audio_status_mempool);
-                    if(data_to_append == NULL)
-                    {
             return false;
           }
-                    memcpy(data_to_append, (const void *)list_front(app_audio_conifg.audio_list), sizeof(APP_AUDIO_STATUS));
+          memcpy(data_to_append,
+                 (const void *)list_front(app_audio_conifg.audio_list),
+                 sizeof(APP_AUDIO_STATUS));
           add_data_to_head_of_list = true;
         }
 
         app_audio_list_clear();
         TRACE_AUD_HDL_E("[STREAM_LIST][APPEND] FIXME!!!!\n ");
-            }
+      } else {
-            else
-            {
         ret = false;
       }
     }
-    }
+  } else
-    else
 #endif
   {
     add_data_to_head_of_list = true;
   }
 
-    if (data_to_append == NULL)
+  if (data_to_append == NULL) {
-    {
     data_to_append = (APP_AUDIO_STATUS *)osPoolCAlloc(app_audio_status_mempool);
-        if(data_to_append == NULL)
+    if (data_to_append == NULL) {
-        {
       return false;
     }
     memcpy(data_to_append, aud_status, sizeof(APP_AUDIO_STATUS));
   }
 
-    if (add_data_to_head_of_list)
+  if (add_data_to_head_of_list) {
-    {
     list_prepend(app_audio_conifg.audio_list, (void *)data_to_append);
-    }
+  } else {
-    else
-    {
     list_append(app_audio_conifg.audio_list, (void *)data_to_append);
   }
 
-    TRACE_AUD_HDL_I("[STREAM_LIST][APPEND] id 0x%x%s status %d len %d ret %d", data_to_append->id, player2str(data_to_append->id), \
+  TRACE_AUD_HDL_I("[STREAM_LIST][APPEND] id 0x%x%s status %d len %d ret %d",
-                    data_to_append->status, list_length(app_audio_conifg.audio_list), ret);
+                  data_to_append->id, player2str(data_to_append->id),
+                  data_to_append->status,
+                  list_length(app_audio_conifg.audio_list), ret);
   return ret;
 }
 
-bool app_audio_list_rmv_callback(APP_AUDIO_STATUS *status_close, APP_AUDIO_STATUS *status_next, enum APP_BT_AUDIO_Q_POS pos, bool pop_next)
+bool app_audio_list_rmv_callback(APP_AUDIO_STATUS *status_close,
-{
+                                 APP_AUDIO_STATUS *status_next,
+                                 enum APP_BT_AUDIO_Q_POS pos, bool pop_next) {
   void *data_to_remove = NULL;
   bool ret = false;
 
-    //for status: first bt_a2dp->APP_BT_SETTING_CLOSE,then ring-> APP_BT_SETTING_CLOSE
+  // for status: first bt_a2dp->APP_BT_SETTING_CLOSE,then ring->
-    TRACE_AUD_HDL_I("[STREAM_LIST][RMV] audio list len %d close_id 0x%x%s", list_length(app_audio_conifg.audio_list), \
+  // APP_BT_SETTING_CLOSE
-                                                        status_close->id, player2str(status_close->id));
+  TRACE_AUD_HDL_I("[STREAM_LIST][RMV] audio list len %d close_id 0x%x%s",
-    if(list_length(app_audio_conifg.audio_list) == 0)
+                  list_length(app_audio_conifg.audio_list), status_close->id,
-    {
+                  player2str(status_close->id));
+  if (list_length(app_audio_conifg.audio_list) == 0) {
     return false;
   }
 
 #ifdef MEDIA_PLAYER_SUPPORT
   APP_AUDIO_STATUS *audio_handle = NULL;
   list_node_t *node = NULL;
-    if (status_close->id == APP_PLAY_BACK_AUDIO)
+  if (status_close->id == APP_PLAY_BACK_AUDIO) {
-    {
+    for (node = list_begin(app_audio_conifg.audio_list);
-        for (node = list_begin(app_audio_conifg.audio_list); node != list_end(app_audio_conifg.audio_list); node = list_next(node))
+         node != list_end(app_audio_conifg.audio_list);
-        {
+         node = list_next(node)) {
       audio_handle = (APP_AUDIO_STATUS *)list_node(node);
-            if(audio_handle == NULL)
+      if (audio_handle == NULL) {
-            {
         return ret;
       }
-            if (audio_handle->id == APP_PLAY_BACK_AUDIO)
+      if (audio_handle->id == APP_PLAY_BACK_AUDIO) {
-            {
         list_node_t *nod_next = list_next(node);
         data_to_remove = list_node(node);
 
-                if (pop_next)
+        if (pop_next) {
-                {
           memcpy(status_next, list_node(node), sizeof(APP_AUDIO_STATUS));
           ret = true;
           break;
         }
-                if (nod_next != NULL)
+        if (nod_next != NULL) {
-                {
           memcpy(status_next, list_node(nod_next), sizeof(APP_AUDIO_STATUS));
-                    ASSERT(status_next->id == APP_PLAY_BACK_AUDIO, "[%s] 111ERROR: status_next->id != APP_PLAY_BACK_AUDIO", __func__);
+          ASSERT(status_next->id == APP_PLAY_BACK_AUDIO,
+                 "[%s] 111ERROR: status_next->id != APP_PLAY_BACK_AUDIO",
+                 __func__);
 
           ret = true;
-                }
+        } else if (app_audio_list_stream_exist()) {
-                else if (app_audio_list_stream_exist())
-                {
           void *indata = list_front(app_audio_conifg.audio_list);
-                    if(indata == NULL)
+          if (indata == NULL) {
-                    {
             return ret;
           }
           memcpy(status_next, indata, sizeof(APP_AUDIO_STATUS));
-                    ASSERT(status_next->id != APP_PLAY_BACK_AUDIO, "[%s] 222ERROR: status_next->id != APP_PLAY_BACK_AUDIO", __func__);
+          ASSERT(status_next->id != APP_PLAY_BACK_AUDIO,
+                 "[%s] 222ERROR: status_next->id != APP_PLAY_BACK_AUDIO",
+                 __func__);
 
           ret = true;
         }
         break;
       }
     }
-    }
+  } else // maybe...a2dp send >> APP_BT_SETTING_CLOSE,  when ring
-    else //maybe...a2dp send >> APP_BT_SETTING_CLOSE,  when ring
 #endif
   {
-        if (app_audio_list_stream_exist())
+    if (app_audio_list_stream_exist()) {
-        {
+      if (pos == APP_BT_SETTING_Q_POS_HEAD) {
-            if(pos == APP_BT_SETTING_Q_POS_HEAD)
-            {
         data_to_remove = list_front(app_audio_conifg.audio_list);
-            }
+      } else if (pos == APP_BT_SETTING_Q_POS_TAIL) {
-            else if (pos == APP_BT_SETTING_Q_POS_TAIL)
-            {
         data_to_remove = list_back(app_audio_conifg.audio_list);
       }
     }
   }
 
-    if (data_to_remove)
+  if (data_to_remove) {
-    {
     list_remove(app_audio_conifg.audio_list, data_to_remove);
   }
-    TRACE_AUD_HDL_I("[STREAM_LIST][RMV] end len:%d ret %d data %p", list_length(app_audio_conifg.audio_list), ret, data_to_remove);
+  TRACE_AUD_HDL_I("[STREAM_LIST][RMV] end len:%d ret %d data %p",
+                  list_length(app_audio_conifg.audio_list), ret,
+                  data_to_remove);
   return ret;
 }
 
-void app_audio_list_clear()
+void app_audio_list_clear() { list_clear(app_audio_conifg.audio_list); }
-{
-    list_clear(app_audio_conifg.audio_list);
-}
 #endif
 
-void app_audio_open(void)
+void app_audio_open(void) {
-{
+  if (app_audio_init) {
-    if(app_audio_init)
-    {
     return;
   }
-    if (g_app_audio_queue_mutex_id == NULL)
+  if (g_app_audio_queue_mutex_id == NULL) {
-    {
+    g_app_audio_queue_mutex_id =
-        g_app_audio_queue_mutex_id = osMutexCreate((osMutex(g_app_audio_queue_mutex)));
+        osMutexCreate((osMutex(g_app_audio_queue_mutex)));
-    }
+  } else {
-    else
-    {
     ASSERT(0, "[%s] ERROR: g_app_audio_queue_mutex_id != NULL", __func__);
   }
 
   if (app_audio_status_mempool == NULL)
     app_audio_status_mempool = osPoolCreate(osPool(app_audio_status_mempool));
-    ASSERT(app_audio_status_mempool, "[%s] ERROR: app_audio_status_mempool != NULL", __func__);
+  ASSERT(app_audio_status_mempool,
+         "[%s] ERROR: app_audio_status_mempool != NULL", __func__);
 
 #ifdef __AUDIO_QUEUE_SUPPORT__
   app_audio_list_create();
@@ -782,10 +714,7 @@ void app_audio_open(void)
   app_audio_init = true;
 }
 
-void app_audio_close(void)
+void app_audio_close(void) {
-{
   app_set_threadhandle(APP_MODUAL_AUDIO, NULL);
   app_audio_init = false;
 }
-
-

apps/audioplayers/bt_sco_chain.c

@@ -19,69 +19,88 @@
 // RX: Receive process
 // 16k: base 25M/208M(1300,1302) base 28M/104M(1400,1402)
 |-------|--------------------|-----------------------------------|----------------------------------|-----------|----------------------|
-| TX/RX |        New         |                Old                |           description            |  MIPS(M)  |         Note         |
+| TX/RX |        New         |                Old                | description
-|       |                    |                                   |                                  | 16k    8k |                      |
+|  MIPS(M)  |         Note         | |       |                    | | | 16k 8k |
+|
 |-------|--------------------|-----------------------------------|----------------------------------|-----------|----------------------|
-|       | SPEECH_TX_DC_FILTER|                                   | Direct Current filter            | 1~2    \  |                      |
+|       | SPEECH_TX_DC_FILTER|                                   | Direct
-|       | SPEECH_TX_AEC      | SPEECH_ECHO_CANCEL                | Acoustic Echo Cancellation(old)  | 40     \  | HWFFT: 37            |
+Current filter            | 1~2    \  |                      | |       |
-|       | SPEECH_TX_AEC2     | SPEECH_AEC_FIX                    | Acoustic Echo Cancellation(new)  | 39     \  | enable NLP           |
+SPEECH_TX_AEC      | SPEECH_ECHO_CANCEL                | Acoustic Echo
-|       | SPEECH_TX_AEC3     |                                   | Acoustic Echo Cancellation(new)  | 14/18  \  | 2 filters/4 filters  |
+Cancellation(old)  | 40     \  | HWFFT: 37            | |       | SPEECH_TX_AEC2
-|       | SPEECH_TX_AEC2FLOAT|                                   | Acoustic Echo Cancellation(new)  | 23/22  \  | nlp/af(blocks=1)     |
+| SPEECH_AEC_FIX                    | Acoustic Echo Cancellation(new)  | 39 \  |
-|       | SPEECH_TX_AEC2FLOAT|                                   | Acoustic Echo Cancellation(ns)   | 14/10  \  | banks=256/banks=128  |
+enable NLP           | |       | SPEECH_TX_AEC3     | | Acoustic Echo
-|       | (ns_enabled)       |                                   |                                  | 8/6    \  | banks=64/banks=32    |
+Cancellation(new)  | 14/18  \  | 2 filters/4 filters  | |       |
-|       | SPEECH_TX_NS       | SPEECH_NOISE_SUPPRESS             | 1 mic noise suppress(old)        | 30     \  | HWFFT: 19            |
+SPEECH_TX_AEC2FLOAT|                                   | Acoustic Echo
-|       | SPEECH_TX_NS2      | LC_MMSE_NOISE_SUPPRESS            | 1 mic noise suppress(new)        | 16     \  | HWFFT: 12            |
+Cancellation(new)  | 23/22  \  | nlp/af(blocks=1)     | |       |
-|       | SPEECH_TX_NS3      |                                   | 1 mic noise suppress(new)        | 26     \  |                      |
+SPEECH_TX_AEC2FLOAT|                                   | Acoustic Echo
-|       | SPEECH_TX_NS2FLOAT | LC_MMSE_NOISE_SUPPRESS_FLOAT      | 1 mic noise suppress(new float)  | 12.5   \  | banks=64             |
+Cancellation(ns)   | 14/10  \  | banks=256/banks=128  | |       | (ns_enabled)
-| TX    | SPEECH_TX_2MIC_NS  | DUAL_MIC_DENOISE                  | 2 mic noise suppres(long space)  | \         |                      |
+|                                   |                                  | 8/6 \
-|       | SPEECH_TX_2MIC_NS2 | 2MIC_DENOISE                      | 2 mic noise suppres(short space) | 22        | delay_taps 5M        |
+| banks=64/banks=32    | |       | SPEECH_TX_NS       | SPEECH_NOISE_SUPPRESS |
-|       |                                                                                                      freq_smooth_enable 1.5M |                 |
+1 mic noise suppress(old)        | 30     \  | HWFFT: 19            | |       |
-|       |                                                                                                         wnr_enable 1.5M      |
+SPEECH_TX_NS2      | LC_MMSE_NOISE_SUPPRESS            | 1 mic noise
-|       | SPEECH_TX_2MIC_NS4 | SENSORMIC_DENOISE                 | sensor mic noise suppress        | 31.5      |                      |
+suppress(new)        | 16     \  | HWFFT: 12            | |       |
-|       | SPEECH_TX_2MIC_NS3 | FAR_FIELD_SPEECH_ENHANCEMENT      | 2 mic noise suppres(far field)   | \         |                      |
+SPEECH_TX_NS3      |                                   | 1 mic noise
-|       | SPEECH_TX_2MIC_NS5 | LEFTRIGHT_DENOISE                 | 2 mic noise suppr(left right end)| \         |                      |
+suppress(new)        | 26     \  |                      | |       |
-|       | SPEECH_TX_2MIC_NS6 | FF_2MIC_DENOISE                   | 2 mic noise suppr(far field)     | 70        |                      |
+SPEECH_TX_NS2FLOAT | LC_MMSE_NOISE_SUPPRESS_FLOAT      | 1 mic noise
-|       | SPEECH_TX_AGC      | SPEECH_AGC                        | Automatic Gain Control           | 3         |                      |
+suppress(new float)  | 12.5   \  | banks=64             | | TX    |
-|       | SPEECH_TX_COMPEXP  |                                   | Compressor and expander          | 4         |                      |
+SPEECH_TX_2MIC_NS  | DUAL_MIC_DENOISE                  | 2 mic noise
-|       | SPEECH_TX_EQ       | SPEECH_WEIGHTING_FILTER_SUPPRESS  | Default EQ                       | 0.5     \ | each section         |
+suppres(long space)  | \         |                      | |       |
+SPEECH_TX_2MIC_NS2 | 2MIC_DENOISE                      | 2 mic noise
+suppres(short space) | 22        | delay_taps 5M        | |       |
+freq_smooth_enable 1.5M |                 | |       | wnr_enable 1.5M      | |
+| SPEECH_TX_2MIC_NS4 | SENSORMIC_DENOISE                 | sensor mic noise
+suppress        | 31.5      |                      | |       |
+SPEECH_TX_2MIC_NS3 | FAR_FIELD_SPEECH_ENHANCEMENT      | 2 mic noise suppres(far
+field)   | \         |                      | |       | SPEECH_TX_2MIC_NS5 |
+LEFTRIGHT_DENOISE                 | 2 mic noise suppr(left right end)| \ | | |
+| SPEECH_TX_2MIC_NS6 | FF_2MIC_DENOISE                   | 2 mic noise suppr(far
+field)     | 70        |                      | |       | SPEECH_TX_AGC      |
+SPEECH_AGC                        | Automatic Gain Control           | 3 | | |
+| SPEECH_TX_COMPEXP  |                                   | Compressor and
+expander          | 4         |                      | |       | SPEECH_TX_EQ |
+SPEECH_WEIGHTING_FILTER_SUPPRESS  | Default EQ                       | 0.5     \
+| each section         |
 |-------|--------------------|-----------------------------------|----------------------------------|-----------|----------------------|
-|       | SPEECH_RX_NS       | SPEAKER_NOISE_SUPPRESS            | 1 mic noise suppress(old)        | 30      \ |                      |
+|       | SPEECH_RX_NS       | SPEAKER_NOISE_SUPPRESS            | 1 mic noise
-| RX    | SPEECH_RX_NS2      | LC_MMSE_NOISE_SUPPRESS_SPK        | 1 mic noise suppress(new)        | 16      \ |                      |
+suppress(old)        | 30      \ |                      | | RX    |
-|       | SPEECH_RX_AGC      | SPEECH_AGC_SPK                    | Automatic Gain Control           | 3         |                      |
+SPEECH_RX_NS2      | LC_MMSE_NOISE_SUPPRESS_SPK        | 1 mic noise
-|       | SPEECH_RX_EQ       | SPEAKER_WEIGHTING_FILTER_SUPPRESS | Default EQ                       | 0.5     \ | each section         |
+suppress(new)        | 16      \ |                      | |       |
+SPEECH_RX_AGC      | SPEECH_AGC_SPK                    | Automatic Gain Control
+| 3         |                      | |       | SPEECH_RX_EQ       |
+SPEAKER_WEIGHTING_FILTER_SUPPRESS | Default EQ                       | 0.5     \
+| each section         |
 |-------|--------------------|-----------------------------------|----------------------------------|-----------|----------------------|
 **/
 
-#include "plat_types.h"
-#include "hal_trace.h"
-#include "hal_timer.h"
-#include "audio_dump.h"
-#include "speech_cfg.h"
 #include "bt_sco_chain.h"
+#include "audio_dump.h"
 #include "bt_sco_chain_cfg.h"
 #include "bt_sco_chain_tuning.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
+#include "plat_types.h"
+#include "speech_cfg.h"
 #if defined(SPEECH_TX_2MIC_NS4)
 #include "app_anc.h"
 #endif
 #include "app_utils.h"
 
 #if defined(SCO_CP_ACCEL)
-#include "hal_location.h"
 #include "bt_sco_chain_cp.h"
+#include "hal_location.h"
 
 #define SCO_CP_ACCEL_ALGO_START()                                              \
   *_pcm_len = pcm_len;                                                         \
   }                                                                            \
   CP_TEXT_SRAM_LOC                                                             \
-    void _speech_tx_process_mid(short *pcm_buf, short *ref_buf, int *_pcm_len) \
+  void _speech_tx_process_mid(short *pcm_buf, short *ref_buf, int *_pcm_len) { \
-    {                                                                          \
     int pcm_len = *_pcm_len;
 
 #define SCO_CP_ACCEL_ALGO_END()                                                \
   *_pcm_len = pcm_len;                                                         \
   }                                                                            \
-    void _speech_tx_process_post(short *pcm_buf, short *ref_buf, int *_pcm_len) \
+  void _speech_tx_process_post(short *pcm_buf, short *ref_buf,                 \
-    {                                                                           \
+                               int *_pcm_len) {                                \
     int pcm_len = *_pcm_len;
 
 #define SPEECH_TX_AEC2FLOAT_CORE 1
@@ -125,7 +144,8 @@ static int32_t *tx_pcmbuf32 = NULL;
 short *aec_echo_buf = NULL;
 #endif
 
-#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
+#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) ||                       \
+    defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
 // Use to free buffer
 #if defined(SPEECH_TX_24BIT)
 static int32_t *aec_echo_buf_ptr;
@@ -152,7 +172,6 @@ SpeechFirCalibState *speech_tx_mic_fir_calib_st = NULL;
 extern const SpeechFirCalibConfig speech_tx_mic_fir_calib_cfg;
 #endif
 
-
 // AEC
 #if defined(SPEECH_TX_AEC)
 SpeechAecState *speech_tx_aec_st = NULL;
@@ -167,15 +186,10 @@ SpeechAec2State *speech_tx_aec2_st = NULL;
 short delay = 70;
 short bufferstate[356];
 short buf_out[256];
-void CODEC_OpVecCpy(
+void CODEC_OpVecCpy(short *pshwDes, short *pshwSrc, short swLen) {
-                short       *pshwDes,
-                short       *pshwSrc,
-                short        swLen)
-{
   short i = 0;
 
-    for (i = 0; i < swLen; i++)
+  for (i = 0; i < swLen; i++) {
-    {
     pshwDes[i] = pshwSrc[i];
   }
 }
@@ -189,7 +203,8 @@ static Ec2FloatState *speech_tx_aec2float_st = NULL;
 
 // 2MIC NS
 #if defined(SPEECH_TX_2MIC_NS)
-// float mic2_ft_caliration[] = {0.395000,0.809000,0.939000,1.748000,1.904000,1.957000,1.944000,1.906000,1.935000,1.940000,1.937000,1.931000,1.929000,1.911000,1.887000,1.871000,1.846000,1.779000,1.748000,2.086000,2.055000,2.002000,1.903000,1.885000,1.854000,1.848000,1.848000,1.844000,1.852000,1.870000,1.866000,1.843000,1.838000,1.824000,1.861000,1.871000,1.866000,1.833000,1.800000,1.769000,1.749000,1.690000,1.664000,1.573000,1.602000,1.692000,1.759000,1.758000,1.698000,1.628000,1.525000,1.509000,1.492000,1.515000,1.530000,1.644000,1.653000,1.617000,1.667000,1.746000,1.663000,1.606000,1.560000,1.500000,1.579000,1.632000,1.623000,1.549000,1.524000,1.512000,1.493000,1.476000,1.421000,1.396000,1.386000,1.459000,1.463000,1.496000,1.568000,1.544000,1.555000,1.547000,1.619000,1.630000,1.574000,1.491000,1.414000,1.383000,1.352000,1.464000,1.474000,1.450000,1.419000,1.425000,1.411000,1.479000,1.517000,1.486000,1.428000,1.389000,1.330000,1.284000,1.267000,1.249000,1.256000,1.215000,1.250000,1.402000,1.386000,1.334000,1.287000,1.329000,1.337000,1.292000,1.226000,1.212000,1.142000,1.087000,1.086000,1.112000,1.145000,1.194000,1.163000,1.131000,1.162000,1.166000,1.259000,1.218000,1.218000,1.322000,1.347000,1.436000,1.890000,1.693000,1.591000,1.518000,1.422000,1.345000,1.331000,1.308000,1.330000,1.305000,1.218000,1.286000,1.340000,1.399000,1.406000,1.353000,1.280000,1.246000,1.185000,1.129000,1.014000,0.985000,0.981000,1.189000,1.533000,1.694000,1.613000,1.464000,1.419000,1.448000,1.449000,1.442000,1.367000,1.283000,1.232000,1.381000,1.484000,1.497000,1.554000,1.438000,1.365000,1.326000,1.332000,1.335000,1.367000,1.301000,1.288000,1.168000,1.103000,1.067000,1.026000,1.076000,1.126000,1.068000,1.045000,0.978000,0.926000,0.939000,0.854000,0.772000,0.902000,0.742000,1.073000,1.220000,1.177000,1.762000,1.573000,1.390000,1.406000,1.148000,1.054000,1.210000,1.344000,1.849000,2.078000,1.756000,1.646000,1.597000,1.447000,1.322000,1.279000,1.007000,0.921000,0.871000,0.864000,1.067000,1.129000,1.128000,1.027000,0.983000,0.889000,0.774000,0.759000,0.724000,0.949000,1.237000,1.499000,1.658000,1.837000,1.492000,1.452000,1.151000,1.100000,0.996000,0.986000,1.023000,1.071000,1.252000,1.295000,1.309000,1.343000,1.220000,1.161000,1.142000,1.041000,0.974000,0.885000,0.799000,0.669000,0.732000,0.953000,0.861000,0.881000,0.988000,0.891000};
+// float mic2_ft_caliration[] =
+// {0.395000,0.809000,0.939000,1.748000,1.904000,1.957000,1.944000,1.906000,1.935000,1.940000,1.937000,1.931000,1.929000,1.911000,1.887000,1.871000,1.846000,1.779000,1.748000,2.086000,2.055000,2.002000,1.903000,1.885000,1.854000,1.848000,1.848000,1.844000,1.852000,1.870000,1.866000,1.843000,1.838000,1.824000,1.861000,1.871000,1.866000,1.833000,1.800000,1.769000,1.749000,1.690000,1.664000,1.573000,1.602000,1.692000,1.759000,1.758000,1.698000,1.628000,1.525000,1.509000,1.492000,1.515000,1.530000,1.644000,1.653000,1.617000,1.667000,1.746000,1.663000,1.606000,1.560000,1.500000,1.579000,1.632000,1.623000,1.549000,1.524000,1.512000,1.493000,1.476000,1.421000,1.396000,1.386000,1.459000,1.463000,1.496000,1.568000,1.544000,1.555000,1.547000,1.619000,1.630000,1.574000,1.491000,1.414000,1.383000,1.352000,1.464000,1.474000,1.450000,1.419000,1.425000,1.411000,1.479000,1.517000,1.486000,1.428000,1.389000,1.330000,1.284000,1.267000,1.249000,1.256000,1.215000,1.250000,1.402000,1.386000,1.334000,1.287000,1.329000,1.337000,1.292000,1.226000,1.212000,1.142000,1.087000,1.086000,1.112000,1.145000,1.194000,1.163000,1.131000,1.162000,1.166000,1.259000,1.218000,1.218000,1.322000,1.347000,1.436000,1.890000,1.693000,1.591000,1.518000,1.422000,1.345000,1.331000,1.308000,1.330000,1.305000,1.218000,1.286000,1.340000,1.399000,1.406000,1.353000,1.280000,1.246000,1.185000,1.129000,1.014000,0.985000,0.981000,1.189000,1.533000,1.694000,1.613000,1.464000,1.419000,1.448000,1.449000,1.442000,1.367000,1.283000,1.232000,1.381000,1.484000,1.497000,1.554000,1.438000,1.365000,1.326000,1.332000,1.335000,1.367000,1.301000,1.288000,1.168000,1.103000,1.067000,1.026000,1.076000,1.126000,1.068000,1.045000,0.978000,0.926000,0.939000,0.854000,0.772000,0.902000,0.742000,1.073000,1.220000,1.177000,1.762000,1.573000,1.390000,1.406000,1.148000,1.054000,1.210000,1.344000,1.849000,2.078000,1.756000,1.646000,1.597000,1.447000,1.322000,1.279000,1.007000,0.921000,0.871000,0.864000,1.067000,1.129000,1.128000,1.027000,0.983000,0.889000,0.774000,0.759000,0.724000,0.949000,1.237000,1.499000,1.658000,1.837000,1.492000,1.452000,1.151000,1.100000,0.996000,0.986000,1.023000,1.071000,1.252000,1.295000,1.309000,1.343000,1.220000,1.161000,1.142000,1.041000,0.974000,0.885000,0.799000,0.669000,0.732000,0.953000,0.861000,0.881000,0.988000,0.891000};
 #endif
 
 #if defined(SPEECH_TX_2MIC_NS2)
@@ -305,9 +320,9 @@ SpeechGainState *speech_rx_post_gain_st = NULL;
 
 static bool dualmic_enable = true;
 
-void switch_dualmic_status(void)
+void switch_dualmic_status(void) {
-{
+  TRACE(3, "[%s] dualmic status: %d -> %d", __FUNCTION__, dualmic_enable,
-    TRACE(3,"[%s] dualmic status: %d -> %d", __FUNCTION__, dualmic_enable, !dualmic_enable);
+        !dualmic_enable);
   dualmic_enable ^= true;
 }
 
@@ -318,16 +333,14 @@ static int speech_rx_frame_len = 256;
 static bool speech_tx_frame_resizer_enable = false;
 static bool speech_rx_frame_resizer_enable = false;
 
-static int32_t _speech_tx_process_(void *pcm_buf, void *ref_buf, int32_t *pcm_len);
+static int32_t _speech_tx_process_(void *pcm_buf, void *ref_buf,
+                                   int32_t *pcm_len);
 static int32_t _speech_rx_process_(void *pcm_buf, int32_t *pcm_len);
 enum APP_SYSFREQ_FREQ_T speech_get_proper_sysfreq(int *needed_mips);
 
-
+void *speech_get_ext_buff(int size) {
-void *speech_get_ext_buff(int size)
-{
   void *pBuff = NULL;
-    if (size % 4)
+  if (size % 4) {
-    {
     size = size + (4 - size % 4);
   }
 
@@ -337,42 +350,44 @@ void *speech_get_ext_buff(int size)
   return pBuff;
 }
 
-int speech_store_config(const SpeechConfig *cfg)
+int speech_store_config(const SpeechConfig *cfg) {
-{
+  if (speech_cfg) {
-    if (speech_cfg)
-    {
     memcpy(speech_cfg, cfg, sizeof(SpeechConfig));
-    }
+  } else {
-    else
-    {
     TRACE(1, "[%s] WARNING: Please phone call...", __func__);
   }
 
   return 0;
 }
 
-int speech_tx_init(int sample_rate, int frame_len)
+int speech_tx_init(int sample_rate, int frame_len) {
-{
+  TRACE(3, "[%s] Start, sample_rate: %d, frame_len: %d", __func__, sample_rate,
-    TRACE(3,"[%s] Start, sample_rate: %d, frame_len: %d", __func__, sample_rate, frame_len);
+        frame_len);
 
 #if defined(SPEECH_TX_DC_FILTER)
   int channel_num = SPEECH_TX_CHANNEL_NUM;
   int data_separation = 0;
 
-    speech_tx_dc_filter_st = speech_dc_filter_create(sample_rate, &speech_cfg->tx_dc_filter);
+  speech_tx_dc_filter_st =
-    speech_dc_filter_ctl(speech_tx_dc_filter_st, SPEECH_DC_FILTER_SET_CHANNEL_NUM, &channel_num);
+      speech_dc_filter_create(sample_rate, &speech_cfg->tx_dc_filter);
-    speech_dc_filter_ctl(speech_tx_dc_filter_st, SPEECH_DC_FILTER_SET_DATA_SEPARATION, &data_separation);
+  speech_dc_filter_ctl(speech_tx_dc_filter_st, SPEECH_DC_FILTER_SET_CHANNEL_NUM,
+                       &channel_num);
+  speech_dc_filter_ctl(speech_tx_dc_filter_st,
+                       SPEECH_DC_FILTER_SET_DATA_SEPARATION, &data_separation);
 #endif
 
 #if defined(SPEECH_TX_MIC_CALIBRATION)
-    speech_tx_mic_calib_st = speech_iir_calib_init(sample_rate, frame_len, &speech_tx_mic_calib_cfg);
+  speech_tx_mic_calib_st =
+      speech_iir_calib_init(sample_rate, frame_len, &speech_tx_mic_calib_cfg);
 #endif
 
 #if defined(SPEECH_TX_MIC_FIR_CALIBRATION)
-    speech_tx_mic_fir_calib_st = speech_fir_calib_init(sample_rate, frame_len, &speech_tx_mic_fir_calib_cfg);
+  speech_tx_mic_fir_calib_st = speech_fir_calib_init(
+      sample_rate, frame_len, &speech_tx_mic_fir_calib_cfg);
 #endif
 
-#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
+#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) ||                       \
+    defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
   // #if !(defined(__AUDIO_RESAMPLE__) && defined(SW_SCO_RESAMPLE))
   aec_out_buf = (short *)speech_calloc(frame_len, sizeof(short));
 #if defined(SPEECH_TX_24BIT)
@@ -385,32 +400,41 @@ int speech_tx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_TX_AEC)
-    speech_tx_aec_st = speech_aec_create(sample_rate, frame_len, &speech_cfg->tx_aec);
+  speech_tx_aec_st =
-    speech_aec_ctl(speech_tx_aec_st, SPEECH_AEC_GET_LIB_ST, &speech_tx_aec_lib_st);
+      speech_aec_create(sample_rate, frame_len, &speech_cfg->tx_aec);
+  speech_aec_ctl(speech_tx_aec_st, SPEECH_AEC_GET_LIB_ST,
+                 &speech_tx_aec_lib_st);
 #endif
 
 #if defined(SPEECH_TX_AEC2)
-    speech_tx_aec2_st = speech_aec2_create(sample_rate, frame_len, &speech_cfg->tx_aec2);
+  speech_tx_aec2_st =
+      speech_aec2_create(sample_rate, frame_len, &speech_cfg->tx_aec2);
 #endif
 #if defined(SPEECH_TX_AEC3)
-    speech_tx_aec3_st = SubBandAec_init(sample_rate, frame_len, &speech_cfg->tx_aec3);
+  speech_tx_aec3_st =
+      SubBandAec_init(sample_rate, frame_len, &speech_cfg->tx_aec3);
 #endif
 
 #if defined(SPEECH_TX_AEC2FLOAT)
-    speech_tx_aec2float_st = ec2float_create(sample_rate, frame_len, SPEECH_TX_AEC2FLOAT_CORE, &speech_cfg->tx_aec2float);
+  speech_tx_aec2float_st =
+      ec2float_create(sample_rate, frame_len, SPEECH_TX_AEC2FLOAT_CORE,
+                      &speech_cfg->tx_aec2float);
 #endif
 
 #if defined(SPEECH_TX_2MIC_NS)
   dual_mic_denoise_init(sample_rate, frame_len, &speech_cfg->tx_2mic_ns, NULL);
-    // dual_mic_denoise_ctl(DUAL_MIC_DENOISE_SET_CALIBRATION_COEF, mic2_ft_caliration);
+  // dual_mic_denoise_ctl(DUAL_MIC_DENOISE_SET_CALIBRATION_COEF,
+  // mic2_ft_caliration);
 #endif
 
 #if defined(SPEECH_TX_2MIC_NS2)
-    speech_tx_2mic_ns2_st = speech_2mic_ns2_create(sample_rate, frame_len, &speech_cfg->tx_2mic_ns2);
+  speech_tx_2mic_ns2_st =
+      speech_2mic_ns2_create(sample_rate, frame_len, &speech_cfg->tx_2mic_ns2);
 #endif
 
   // #if defined(SPEECH_CS_VAD)
-//     speech_cs_vad_st = VAD_process_state_init(sample_rate, 64, &speech_cfg->cs_vad);
+  //     speech_cs_vad_st = VAD_process_state_init(sample_rate, 64,
+  //     &speech_cfg->cs_vad);
   // #endif
 
 #if defined(SPEECH_TX_2MIC_NS3)
@@ -419,7 +443,8 @@ int speech_tx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_TX_2MIC_NS5)
-    speech_tx_2mic_ns5_st = leftright_denoise_create(sample_rate, 64, &speech_cfg->tx_2mic_ns5);
+  speech_tx_2mic_ns5_st =
+      leftright_denoise_create(sample_rate, 64, &speech_cfg->tx_2mic_ns5);
 #endif
 
 #if defined(SPEECH_TX_2MIC_NS6)
@@ -427,20 +452,25 @@ int speech_tx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_TX_2MIC_NS4)
-    //speech_tx_2mic_ns4_st = sensormic_denoise_create(sample_rate, 64, &speech_cfg->tx_2mic_ns4);
+  // speech_tx_2mic_ns4_st = sensormic_denoise_create(sample_rate, 64,
-    speech_tx_2mic_ns4_st = sensormic_denoise_create(sample_rate, 128, 256, 31, &speech_cfg->tx_2mic_ns4);
+  // &speech_cfg->tx_2mic_ns4);
+  speech_tx_2mic_ns4_st = sensormic_denoise_create(sample_rate, 128, 256, 31,
+                                                   &speech_cfg->tx_2mic_ns4);
 #endif
 
 #if defined(SPEECH_TX_3MIC_NS)
-    speech_tx_3mic_ns_st = speech_3mic_ns_create(sample_rate, 64, &speech_cfg->tx_3mic_ns);
+  speech_tx_3mic_ns_st =
+      speech_3mic_ns_create(sample_rate, 64, &speech_cfg->tx_3mic_ns);
 #endif
 
 #if defined(SPEECH_TX_3MIC_NS3)
-    speech_tx_3mic_ns3_st = triple_mic_denoise3_init(sample_rate, frame_len, &speech_cfg->tx_3mic_ns3);
+  speech_tx_3mic_ns3_st = triple_mic_denoise3_init(sample_rate, frame_len,
+                                                   &speech_cfg->tx_3mic_ns3);
 #endif
 
 #if defined(SPEECH_TX_NS)
-    speech_tx_ns_st = speech_ns_create(sample_rate, frame_len, &speech_cfg->tx_ns);
+  speech_tx_ns_st =
+      speech_ns_create(sample_rate, frame_len, &speech_cfg->tx_ns);
 #if defined(SPEECH_TX_AEC)
   speech_ns_ctl(speech_tx_ns_st, SPEECH_NS_SET_AEC_STATE, speech_tx_aec_lib_st);
   int32_t echo_supress = -39;
@@ -449,7 +479,8 @@ int speech_tx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_TX_NS2)
-    speech_tx_ns2_st = speech_ns2_create(sample_rate, frame_len, &speech_cfg->tx_ns2);
+  speech_tx_ns2_st =
+      speech_ns2_create(sample_rate, frame_len, &speech_cfg->tx_ns2);
 #if defined(SPEECH_TX_AEC)
   speech_ns2_set_echo_state(speech_tx_ns2_st, speech_tx_aec_lib_st);
   speech_ns2_set_echo_suppress(speech_tx_ns2_st, -40);
@@ -457,7 +488,9 @@ int speech_tx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_TX_NS2FLOAT)
-    speech_tx_ns2float_st = speech_ns2float_create(sample_rate, frame_len, SPEECH_TX_NS2FLOAT_CORE, &speech_cfg->tx_ns2float);
+  speech_tx_ns2float_st =
+      speech_ns2float_create(sample_rate, frame_len, SPEECH_TX_NS2FLOAT_CORE,
+                             &speech_cfg->tx_ns2float);
 #if defined(SPEECH_TX_AEC)
   speech_ns2float_set_echo_state(speech_tx_ns2float_st, speech_tx_aec_lib_st);
   speech_ns2float_set_echo_suppress(speech_tx_ns2float_st, -40);
@@ -473,15 +506,18 @@ int speech_tx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_TX_NOISE_GATE)
-    speech_tx_noise_gate_st = speech_noise_gate_create(sample_rate, frame_len, &speech_cfg->tx_noise_gate);
+  speech_tx_noise_gate_st = speech_noise_gate_create(
+      sample_rate, frame_len, &speech_cfg->tx_noise_gate);
 #endif
 
 #if defined(SPEECH_TX_COMPEXP)
-    speech_tx_compexp_st = compexp_create(sample_rate, frame_len, &speech_cfg->tx_compexp);
+  speech_tx_compexp_st =
+      compexp_create(sample_rate, frame_len, &speech_cfg->tx_compexp);
 #endif
 
 #if defined(SPEECH_TX_AGC)
-    speech_tx_agc_st = agc_state_create(sample_rate, frame_len, &speech_cfg->tx_agc);
+  speech_tx_agc_st =
+      agc_state_create(sample_rate, frame_len, &speech_cfg->tx_agc);
 #endif
 
 #if defined(SPEECH_TX_EQ)
@@ -489,7 +525,8 @@ int speech_tx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_TX_POST_GAIN)
-    speech_tx_post_gain_st = speech_gain_create(sample_rate, frame_len, &speech_cfg->tx_post_gain);
+  speech_tx_post_gain_st =
+      speech_gain_create(sample_rate, frame_len, &speech_cfg->tx_post_gain);
 #endif
 
   TRACE(1, "[%s] End", __func__);
@@ -497,20 +534,24 @@ int speech_tx_init(int sample_rate, int frame_len)
   return 0;
 }
 
-int speech_rx_init(int sample_rate, int frame_len)
+int speech_rx_init(int sample_rate, int frame_len) {
-{
+  TRACE(3, "[%s] Start, sample_rate: %d, frame_len: %d", __func__, sample_rate,
-    TRACE(3,"[%s] Start, sample_rate: %d, frame_len: %d", __func__, sample_rate, frame_len);
+        frame_len);
 
 #if defined(SPEECH_RX_NS)
-    speech_rx_ns_st = speech_ns_create(sample_rate, frame_len, &speech_cfg->rx_ns);
+  speech_rx_ns_st =
+      speech_ns_create(sample_rate, frame_len, &speech_cfg->rx_ns);
 #endif
 
 #if defined(SPEECH_RX_NS2)
-    speech_rx_ns2_st = speech_ns2_create(sample_rate, frame_len, &speech_cfg->rx_ns2);
+  speech_rx_ns2_st =
+      speech_ns2_create(sample_rate, frame_len, &speech_cfg->rx_ns2);
 #endif
 
 #if defined(SPEECH_RX_NS2FLOAT)
-    speech_rx_ns2float_st = speech_ns2float_create(sample_rate, frame_len, SPEECH_RX_NS2FLOAT_CORE, &speech_cfg->rx_ns2float);
+  speech_rx_ns2float_st =
+      speech_ns2float_create(sample_rate, frame_len, SPEECH_RX_NS2FLOAT_CORE,
+                             &speech_cfg->rx_ns2float);
 #endif
 
 #if defined(SPEECH_RX_NS3)
@@ -518,7 +559,8 @@ int speech_rx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_RX_AGC)
-    speech_rx_agc_st = agc_state_create(sample_rate, frame_len, &speech_cfg->rx_agc);
+  speech_rx_agc_st =
+      agc_state_create(sample_rate, frame_len, &speech_cfg->rx_agc);
 #endif
 
 #if defined(SPEECH_RX_EQ)
@@ -526,7 +568,8 @@ int speech_rx_init(int sample_rate, int frame_len)
 #endif
 
 #if defined(SPEECH_RX_POST_GAIN)
-    speech_rx_post_gain_st = speech_gain_create(sample_rate, frame_len, &speech_cfg->rx_post_gain);
+  speech_rx_post_gain_st =
+      speech_gain_create(sample_rate, frame_len, &speech_cfg->rx_post_gain);
 #endif
 
   TRACE(1, "[%s] End", __func__);
@@ -534,14 +577,12 @@ int speech_rx_init(int sample_rate, int frame_len)
   return 0;
 }
 
-int speech_init(int tx_sample_rate, int rx_sample_rate,
+int speech_init(int tx_sample_rate, int rx_sample_rate, int tx_frame_ms,
-                     int tx_frame_ms, int rx_frame_ms,
+                int rx_frame_ms, int sco_frame_ms, uint8_t *buf, int len) {
-                     int sco_frame_ms,
-                     uint8_t *buf, int len)
-{
   TRACE(1, "[%s] Start...", __func__);
 
-    //ASSERT(frame_ms == SPEECH_PROCESS_FRAME_MS, "[%s] frame_ms(%d) != SPEECH_PROCESS_FRAME_MS(%d)", __func__,
+  // ASSERT(frame_ms == SPEECH_PROCESS_FRAME_MS, "[%s] frame_ms(%d) !=
+  // SPEECH_PROCESS_FRAME_MS(%d)", __func__,
   //                                                                                                frame_ms,
   //                                                                                                SPEECH_PROCESS_FRAME_MS);
 
@@ -553,9 +594,9 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
   speech_heap_init(buf, len);
 
 #if defined(SCO_OPTIMIZE_FOR_RAM)
-    TRACE(2,"[%s] sco_overlay_ram_buf_len = %d", __func__, sco_overlay_ram_buf_len);
+  TRACE(2, "[%s] sco_overlay_ram_buf_len = %d", __func__,
-    if (sco_overlay_ram_buf_len >= 1024)
+        sco_overlay_ram_buf_len);
-    {
+  if (sco_overlay_ram_buf_len >= 1024) {
     speech_heap_add_block(sco_overlay_ram_buf, sco_overlay_ram_buf_len);
   }
 #endif
@@ -575,11 +616,13 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
 #endif
 
   int aec_enable = 0;
-#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
+#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) ||                       \
+    defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
   aec_enable = 1;
 #endif
 
-    int capture_sample_size = sizeof(int16_t), playback_sample_size = sizeof(int16_t);
+  int capture_sample_size = sizeof(int16_t),
+      playback_sample_size = sizeof(int16_t);
 #if defined(SPEECH_TX_24BIT)
   capture_sample_size = sizeof(int32_t);
 #endif
@@ -587,22 +630,19 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
   playback_sample_size = sizeof(int32_t);
 #endif
 
-    CAPTURE_HANDLER_T tx_handler = (tx_frame_ms == sco_frame_ms) ? NULL : _speech_tx_process_;
+  CAPTURE_HANDLER_T tx_handler =
-    PLAYBACK_HANDLER_T rx_handler = (rx_frame_ms == sco_frame_ms) ? NULL : _speech_rx_process_;
+      (tx_frame_ms == sco_frame_ms) ? NULL : _speech_tx_process_;
+  PLAYBACK_HANDLER_T rx_handler =
+      (rx_frame_ms == sco_frame_ms) ? NULL : _speech_rx_process_;
 
   speech_tx_frame_resizer_enable = (tx_handler != NULL);
   speech_rx_frame_resizer_enable = (rx_handler != NULL);
 
   if (speech_tx_frame_resizer_enable || speech_rx_frame_resizer_enable) {
-        speech_frame_resize_st = frame_resize_create(SPEECH_FRAME_MS_TO_LEN(tx_sample_rate, sco_frame_ms),
+    speech_frame_resize_st = frame_resize_create(
-                                                     SPEECH_TX_CHANNEL_NUM,
+        SPEECH_FRAME_MS_TO_LEN(tx_sample_rate, sco_frame_ms),
-                                                     speech_tx_frame_len,
+        SPEECH_TX_CHANNEL_NUM, speech_tx_frame_len, capture_sample_size,
-                                                     capture_sample_size,
+        playback_sample_size, aec_enable, tx_handler, rx_handler);
-                                                     playback_sample_size,
-                                                     aec_enable,
-                                                     tx_handler,
-                                                     rx_handler
-                                                    );
   }
 
 #if defined(SCO_CP_ACCEL)
@@ -615,7 +655,8 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
 
 #if !defined(SCO_CP_ACCEL)
   int needed_freq = 0;
-    enum APP_SYSFREQ_FREQ_T min_system_freq = speech_get_proper_sysfreq(&needed_freq);
+  enum APP_SYSFREQ_FREQ_T min_system_freq =
+      speech_get_proper_sysfreq(&needed_freq);
   enum APP_SYSFREQ_FREQ_T freq = hal_sysfreq_get();
 
   if (freq < min_system_freq) {
@@ -628,7 +669,9 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
     TRACE(2, "[%s]: sys freq calc : %d\n", __FUNCTION__, system_freq);
 
     if (system_freq <= needed_freq * 1000 * 1000) {
-            TRACE(3,"[%s] WARNING: system freq(%d) seems to be lower than needed(%d).", __FUNCTION__, system_freq/1000000, needed_freq);
+      TRACE(3,
+            "[%s] WARNING: system freq(%d) seems to be lower than needed(%d).",
+            __FUNCTION__, system_freq / 1000000, needed_freq);
     }
   }
 #endif
@@ -638,8 +681,7 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
   return 0;
 }
 
-int speech_tx_deinit(void)
+int speech_tx_deinit(void) {
-{
   TRACE(1, "[%s] Start...", __func__);
 
 #if defined(SPEECH_TX_POST_GAIN)
@@ -734,7 +776,8 @@ int speech_tx_deinit(void)
   ec2float_destroy(speech_tx_aec2float_st);
 #endif
 
-#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
+#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) ||                       \
+    defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
   speech_free(aec_echo_buf_ptr);
   speech_free(aec_out_buf);
 #endif
@@ -756,8 +799,7 @@ int speech_tx_deinit(void)
   return 0;
 }
 
-int speech_rx_deinit(void)
+int speech_rx_deinit(void) {
-{
   TRACE(1, "[%s] Start...", __func__);
 
 #if defined(SPEECH_RX_POST_GAIN)
@@ -793,8 +835,7 @@ int speech_rx_deinit(void)
   return 0;
 }
 
-int speech_deinit(void)
+int speech_deinit(void) {
-{
   TRACE(1, "[%s] Start...", __func__);
 
   speech_rx_deinit();
@@ -823,7 +864,8 @@ int speech_deinit(void)
 
   size_t total = 0, used = 0, max_used = 0;
   speech_memory_info(&total, &used, &max_used);
-    TRACE(3,"SPEECH MALLOC MEM: total - %d, used - %d, max_used - %d.", total, used, max_used);
+  TRACE(3, "SPEECH MALLOC MEM: total - %d, used - %d, max_used - %d.", total,
+        used, max_used);
   ASSERT(used == 0, "[%s] used != 0", __func__);
 
   TRACE(1, "[%s] End", __func__);
@@ -831,8 +873,7 @@ int speech_deinit(void)
   return 0;
 }
 
-float speech_tx_get_required_mips(void)
+float speech_tx_get_required_mips(void) {
-{
   float mips = 0;
 
 #if defined(SPEECH_TX_DC_FILTER)
@@ -942,8 +983,7 @@ float speech_tx_get_required_mips(void)
   return mips;
 }
 
-float speech_rx_get_required_mips(void)
+float speech_rx_get_required_mips(void) {
-{
   float mips = 0;
 
 #if defined(SPEECH_RX_NS)
@@ -977,15 +1017,13 @@ float speech_rx_get_required_mips(void)
   return mips;
 }
 
-float speech_get_required_mips(void)
+float speech_get_required_mips(void) {
-{
   return speech_tx_get_required_mips() + speech_rx_get_required_mips();
 }
 
 #define SYSTEM_BASE_MIPS (18)
 
-enum APP_SYSFREQ_FREQ_T speech_get_proper_sysfreq(int *needed_mips)
+enum APP_SYSFREQ_FREQ_T speech_get_proper_sysfreq(int *needed_mips) {
-{
   enum APP_SYSFREQ_FREQ_T freq = APP_SYSFREQ_32K;
   int required_mips = (int)ceilf(speech_get_required_mips() + SYSTEM_BASE_MIPS);
 
@@ -1005,8 +1043,7 @@ enum APP_SYSFREQ_FREQ_T speech_get_proper_sysfreq(int *needed_mips)
   return freq;
 }
 
-int speech_set_config(const SpeechConfig *cfg)
+int speech_set_config(const SpeechConfig *cfg) {
-{
 #if defined(SPEECH_TX_DC_FILTER)
   speech_dc_filter_set_config(speech_tx_dc_filter_st, &cfg->tx_dc_filter);
 #endif
@@ -1017,7 +1054,8 @@ int speech_set_config(const SpeechConfig *cfg)
   speech_aec2_set_config(speech_tx_aec2_st, &cfg->tx_aec2);
 #endif
 #if defined(SPEECH_TX_AEC2FLOAT)
-    ec2float_set_config(speech_tx_aec2float_st, &cfg->tx_aec2float, SPEECH_TX_AEC2FLOAT_CORE);
+  ec2float_set_config(speech_tx_aec2float_st, &cfg->tx_aec2float,
+                      SPEECH_TX_AEC2FLOAT_CORE);
 #endif
 #if defined(SPEECH_TX_2MIC_NS)
   TRACE(1, "[%s] WARNING: Can not support tuning SPEECH_TX_2MIC_NS", __func__);
@@ -1071,7 +1109,8 @@ int speech_set_config(const SpeechConfig *cfg)
   speech_ns2_set_config(speech_rx_ns2_st, &cfg->rx_ns2);
 #endif
 #if defined(SPEECH_RX_NS2FLOAT)
-    speech_ns2float_set_config(speech_rx_ns2float_st, &cfg->rx_ns2float, SPEECH_RX_NS2FLOAT_CORE);
+  speech_ns2float_set_config(speech_rx_ns2float_st, &cfg->rx_ns2float,
+                             SPEECH_RX_NS2FLOAT_CORE);
 #endif
 #if defined(SPEECH_RX_NS3)
   ns3_set_config(speech_rx_ns3_st, &cfg->rx_ns3);
@@ -1096,8 +1135,7 @@ int speech_set_config(const SpeechConfig *cfg)
   return 0;
 }
 
-void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
+void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len) {
-{
   int pcm_len = *_pcm_len;
 
 #if defined(BT_SCO_CHAIN_PROFILE)
@@ -1107,19 +1145,19 @@ void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
   // TRACE(2,"[%s] pcm_len = %d", __func__, pcm_len);
 
 #ifdef AUDIO_DEBUG_V0_1_0
-    if (speech_tuning_get_status())
+  if (speech_tuning_get_status()) {
-    {
     speech_set_config(speech_cfg);
 
     speech_tuning_set_status(false);
 
-        // If has MIPS problem, can move this block code into speech_rx_process or return directly
+    // If has MIPS problem, can move this block code into speech_rx_process or
-        // return 0
+    // return directly return 0
   }
 #endif
 
 #if defined(SPEECH_TX_24BIT)
-#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
+#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) ||                       \
+    defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
   tx_refbuf16 = (int16_t *)ref_buf;
   tx_refbuf32 = (int32_t *)ref_buf;
   for (int i = 0; i < pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM; i++) {
@@ -1154,9 +1192,12 @@ void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
   speech_dc_filter_process(speech_tx_dc_filter_st, pcm_buf, pcm_len);
 #endif
 
-#if (SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2) && defined(AUDIO_DUMP) && defined(BT_SCO_CHAIN_AUDIO_DUMP)
+#if (SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2) && defined(AUDIO_DUMP) &&          \
-    audio_dump_add_channel_data_from_multi_channels(0, pcm_buf, pcm_len / 2, 2, 0);
+    defined(BT_SCO_CHAIN_AUDIO_DUMP)
-    audio_dump_add_channel_data_from_multi_channels(1, pcm_buf, pcm_len / 2, 2, 1);
+  audio_dump_add_channel_data_from_multi_channels(0, pcm_buf, pcm_len / 2, 2,
+                                                  0);
+  audio_dump_add_channel_data_from_multi_channels(1, pcm_buf, pcm_len / 2, 2,
+                                                  1);
 #endif
 
 #if defined(SPEECH_TX_MIC_CALIBRATION)
@@ -1167,9 +1208,12 @@ void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
   speech_fir_calib_process(speech_tx_mic_fir_calib_st, pcm_buf, pcm_len);
 #endif
 
-#if (SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2) && defined(AUDIO_DUMP) && defined(BT_SCO_CHAIN_AUDIO_DUMP)
+#if (SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2) && defined(AUDIO_DUMP) &&          \
-    audio_dump_add_channel_data_from_multi_channels(2, pcm_buf, pcm_len / 2, 2, 0);
+    defined(BT_SCO_CHAIN_AUDIO_DUMP)
-    audio_dump_add_channel_data_from_multi_channels(3, pcm_buf, pcm_len / 2, 2, 1);
+  audio_dump_add_channel_data_from_multi_channels(2, pcm_buf, pcm_len / 2, 2,
+                                                  0);
+  audio_dump_add_channel_data_from_multi_channels(3, pcm_buf, pcm_len / 2, 2,
+                                                  1);
 #endif
 
 #if defined(SPEECH_TX_2MIC_NS)
@@ -1187,7 +1231,8 @@ void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
 #if defined(SPEECH_TX_2MIC_NS4)
   if (dualmic_enable == true) {
 #if defined(ANC_APP)
-        sensormic_denoise_set_anc_status(speech_tx_2mic_ns4_st, app_anc_work_status());
+    sensormic_denoise_set_anc_status(speech_tx_2mic_ns4_st,
+                                     app_anc_work_status());
 #endif
     sensormic_denoise_process(speech_tx_2mic_ns4_st, pcm_buf, pcm_len, pcm_buf);
   } else {
@@ -1226,7 +1271,8 @@ void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
 
 #if defined(BT_SCO_CHAIN_AUDIO_DUMP)
   audio_dump_add_channel_data(0, pcm_buf, pcm_len);
-#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
+#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) ||                       \
+    defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT)
   audio_dump_add_channel_data(1, ref_buf, pcm_len);
 #else
   audio_dump_add_channel_data(1, pcm_buf, pcm_len);
@@ -1255,10 +1301,13 @@ void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
 #if defined(SPEECH_TX_AEC2FLOAT)
 #if defined(SPEECH_TX_2MIC_NS4)
   if (dualmic_enable == true)
-        TRACE(2,"[%s] vad: %d", __FUNCTION__, sensormic_denoise_get_vad(speech_tx_2mic_ns4_st));
+    TRACE(2, "[%s] vad: %d", __FUNCTION__,
-    ec2float_set_external_vad(speech_tx_aec2float_st, sensormic_denoise_get_vad(speech_tx_2mic_ns4_st));
+          sensormic_denoise_get_vad(speech_tx_2mic_ns4_st));
+  ec2float_set_external_vad(speech_tx_aec2float_st,
+                            sensormic_denoise_get_vad(speech_tx_2mic_ns4_st));
 #endif
-    ec2float_process(speech_tx_aec2float_st, pcm_buf, ref_buf, pcm_len, aec_out_buf);
+  ec2float_process(speech_tx_aec2float_st, pcm_buf, ref_buf, pcm_len,
+                   aec_out_buf);
   speech_copy_int16(pcm_buf, aec_out_buf, pcm_len);
 #endif
 
@@ -1279,7 +1328,9 @@ void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
 #if defined(SPEECH_TX_NS2FLOAT)
 #if defined(SPEECH_TX_2MIC_NS4)
   if (dualmic_enable == true)
-        speech_ns2float_set_external_vad(speech_tx_ns2float_st, sensormic_denoise_get_vad(speech_tx_2mic_ns4_st));
+    speech_ns2float_set_external_vad(
+        speech_tx_ns2float_st,
+        sensormic_denoise_get_vad(speech_tx_2mic_ns4_st));
 #endif
   speech_ns2float_process(speech_tx_ns2float_st, pcm_buf, pcm_len);
 #endif
@@ -1350,8 +1401,7 @@ void _speech_tx_process_pre(short *pcm_buf, short *ref_buf, int *_pcm_len)
 
 #if defined(SCO_CP_ACCEL)
 CP_TEXT_SRAM_LOC
-int sco_cp_algo(short *pcm_buf, short *ref_buf, int *_pcm_len)
+int sco_cp_algo(short *pcm_buf, short *ref_buf, int *_pcm_len) {
-{
 #if defined(SCO_TRACE_CP_ACCEL)
   TRACE(1, "[%s] ...", __func__);
 #endif
@@ -1362,8 +1412,7 @@ int sco_cp_algo(short *pcm_buf, short *ref_buf, int *_pcm_len)
 }
 #endif
 
-int32_t _speech_tx_process_(void *pcm_buf, void *ref_buf, int32_t *_pcm_len)
+int32_t _speech_tx_process_(void *pcm_buf, void *ref_buf, int32_t *_pcm_len) {
-{
   _speech_tx_process_pre(pcm_buf, ref_buf, (int *)_pcm_len);
 #if defined(SCO_CP_ACCEL)
   sco_cp_process(pcm_buf, ref_buf, (int *)_pcm_len);
@@ -1373,8 +1422,7 @@ int32_t _speech_tx_process_(void *pcm_buf, void *ref_buf, int32_t *_pcm_len)
   return 0;
 }
 
-int32_t _speech_rx_process_(void *pcm_buf, int32_t *_pcm_len)
+int32_t _speech_rx_process_(void *pcm_buf, int32_t *_pcm_len) {
-{
   int32_t pcm_len = *_pcm_len;
 
 #if defined(BT_SCO_CHAIN_PROFILE)
@@ -1400,8 +1448,7 @@ int32_t _speech_rx_process_(void *pcm_buf, int32_t *_pcm_len)
 #if defined(SPEECH_RX_NS2)
   // fix 0dB signal
   int16_t *pcm_buf16 = (int16_t *)pcm_buf;
-    for(int i=0; i<pcm_len; i++)
+  for (int i = 0; i < pcm_len; i++) {
-    {
     pcm_buf16[i] = (int16_t)(pcm_buf16[i] * 0.94);
   }
   speech_ns2_process(speech_rx_ns2_st, pcm_buf, pcm_len);
@@ -1410,8 +1457,7 @@ int32_t _speech_rx_process_(void *pcm_buf, int32_t *_pcm_len)
 #if defined(SPEECH_RX_NS2FLOAT)
   // FIXME
   int16_t *pcm_buf16 = (int16_t *)pcm_buf;
-    for(int i=0; i<pcm_len; i++)
+  for (int i = 0; i < pcm_len; i++) {
-    {
     pcm_buf16[i] = (int16_t)(pcm_buf16[i] * 0.94);
   }
   speech_ns2float_process(speech_rx_ns2float_st, pcm_buf, pcm_len);
@@ -1459,24 +1505,24 @@ int32_t _speech_rx_process_(void *pcm_buf, int32_t *_pcm_len)
   return 0;
 }
 
-int speech_tx_process(void *pcm_buf, void *ref_buf, int *pcm_len)
+int speech_tx_process(void *pcm_buf, void *ref_buf, int *pcm_len) {
-{
   if (speech_tx_frame_resizer_enable == false) {
     _speech_tx_process_(pcm_buf, ref_buf, (int32_t *)pcm_len);
   } else {
     // MUST use (int32_t *)??????
-        frame_resize_process_capture(speech_frame_resize_st, pcm_buf, ref_buf, (int32_t *)pcm_len);
+    frame_resize_process_capture(speech_frame_resize_st, pcm_buf, ref_buf,
+                                 (int32_t *)pcm_len);
   }
 
   return 0;
 }
 
-int speech_rx_process(void *pcm_buf, int *pcm_len)
+int speech_rx_process(void *pcm_buf, int *pcm_len) {
-{
   if (speech_rx_frame_resizer_enable == false) {
     _speech_rx_process_(pcm_buf, (int32_t *)pcm_len);
   } else {
-        frame_resize_process_playback(speech_frame_resize_st, pcm_buf, (int32_t *)pcm_len);
+    frame_resize_process_playback(speech_frame_resize_st, pcm_buf,
+                                  (int32_t *)pcm_len);
   }
 
   return 0;

apps/audioplayers/bt_sco_chain_cfg_default.c

@@ -13,11 +13,13 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "plat_types.h"
 #include "bt_sco_chain_cfg.h"
+#include "plat_types.h"
 
 #if defined(SPEECH_TX_2MIC_NS4)
-static float ff_fb_h[256] = {1.f, };
+static float ff_fb_h[256] = {
+    1.f,
+};
 #endif
 
 #if defined(SPEECH_TX_MIC_CALIBRATION)
@@ -27,28 +29,22 @@ static float ff_fb_h[256] = {1.f, };
  * Parameters:
  *     bypass(0/1): bypass enable or disable.
  *     mic_num(1~4): the number of microphones. The filter num is (mic_num - 1)
- *     calib: {bypass, gain, num, {type, frequency, gain, q}}. Please refer to SPEECH_TX_EQ section
+ *     calib: {bypass, gain, num, {type, frequency, gain, q}}. Please refer to
- *         in this file
+ *SPEECH_TX_EQ section in this file Resource consumption: RAM:     None FLASE:
- * Resource consumption:
+ *None MIPS:    fs = 16kHz, 0.5M/section; Note: None
- *     RAM:     None
- *     FLASE:   None
- *     MIPS:    fs = 16kHz, 0.5M/section;
- * Note:
- *     None
  ****************************************************************************************************/
-const SpeechIirCalibConfig WEAK speech_tx_mic_calib_cfg =
+const SpeechIirCalibConfig WEAK speech_tx_mic_calib_cfg = {
-{
     .bypass = 0,
     .mic_num = 2,
-    .calib = {
+    .calib =
         {
-            .bypass = 0,
+            {.bypass = 0,
              .gain = 0.f,
              .num = 0,
-            .params = {
+             .params =
+                 {
                      {IIR_BIQUARD_LOWSHELF, 150, -2.5, 0.707},
-            }
+                 }},
-        },
         },
 };
 #endif
@@ -68,13 +64,15 @@ const SpeechIirCalibConfig WEAK speech_tx_mic_calib_cfg =
  * Note:
  *     None
  ****************************************************************************************************/
-float mic2_ft_caliration[256] = {1.f, };
+float mic2_ft_caliration[256] = {
-const SpeechFirCalibConfig WEAK speech_tx_mic_fir_calib_cfg =
+    1.f,
-{
+};
+const SpeechFirCalibConfig WEAK speech_tx_mic_fir_calib_cfg = {
     .bypass = 0,
     .mic_num = SPEECH_CODEC_CAPTURE_CHANNEL_NUM,
     .delay = 0,
-    .calib = {
+    .calib =
+        {
             {
                 .filter = mic2_ft_caliration,
                 .filter_length = ARRAY_SIZE(mic2_ft_caliration),
@@ -86,7 +84,8 @@ const SpeechFirCalibConfig WEAK speech_tx_mic_fir_calib_cfg =
 const SpeechConfig WEAK speech_cfg_default = {
 
 #if defined(SPEECH_TX_DC_FILTER)
-    .tx_dc_filter = {
+    .tx_dc_filter =
+        {
             .bypass = 0,
             .gain = 0,
         },
@@ -99,19 +98,16 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Parameters:
      *     bypass(0/1): bypass enable or disable.
      *     delay(>0): delay samples from mic to speak, unit(sample).
- *     leak_estimate(0~32767): echo supression value. This is a fixed mode. It has relatively large
+     *     leak_estimate(0~32767): echo supression value. This is a fixed mode.
- *         echo supression and large damage to speech signal.
+     *It has relatively large echo supression and large damage to speech signal.
- *     leak_estimate_shift(0~8): echo supression value. if leak_estimate == 0, then leak_estimate_shift
+     *     leak_estimate_shift(0~8): echo supression value. if leak_estimate ==
- *         can take effect. This is a adaptive mode. It has relatively small echo supression and also 
+     *0, then leak_estimate_shift can take effect. This is a adaptive mode. It
- *         small damage to speech signal.
+     *has relatively small echo supression and also small damage to speech
- * Resource consumption:
+     *signal. Resource consumption: RAM:     None FLASE:   None MIPS:    fs =
- *     RAM:     None
+     *16kHz, 40M; Note: If possible, use SPEECH_TX_AEC2FLOAT
- *     FLASE:   None
- *     MIPS:    fs = 16kHz, 40M;
- * Note:
- *     If possible, use SPEECH_TX_AEC2FLOAT
      ****************************************************************************************************/
-    .tx_aec = {
+    .tx_aec =
+        {
             .bypass = 0,
             .delay = 60,
             .leak_estimate = 16383,
@@ -135,7 +131,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     If possible, use SPEECH_TX_AEC2FLOAT
      ****************************************************************************************************/
-    .tx_aec2 = {
+    .tx_aec2 =
+        {
             .bypass = 0,
             .enEAecEnable = 1,
             .enHpfEnable = 1,
@@ -157,26 +154,23 @@ const SpeechConfig WEAK speech_cfg_default = {
      *     Acoustic Echo Cancellation
      * Parameters:
      *     bypass(0/1): bypass enable or disable.
- *     hpf_enabled(0/1): high pass filter enable or disable. Used to remove DC for Near and Ref signals.
+     *     hpf_enabled(0/1): high pass filter enable or disable. Used to remove
- *     af_enabled(0/1): adaptive filter enable or disable. If the echo signal is very large, enable this
+     *DC for Near and Ref signals. af_enabled(0/1): adaptive filter enable or
- *     nlp_enabled(0/1): non-linear process enable or disable. Enable this by default.
+     *disable. If the echo signal is very large, enable this nlp_enabled(0/1):
- *     ns_enabled(0/1): noise supression enable or disable. Enable this by default.
+     *non-linear process enable or disable. Enable this by default.
- *     cng_enabled(0/1):  comfort noise generator enable or disable.
+     *     ns_enabled(0/1): noise supression enable or disable. Enable this by
+     *default. cng_enabled(0/1):  comfort noise generator enable or disable.
      *     blocks(1~8): the length of adaptive filter = blocks * frame length
      *     delay(>0): delay samples from mic to speak, unit(sample).
- *     min_ovrd(1~6): supression factor, min_ovrd becomes larger and echo suppression becomes larger.
+     *     min_ovrd(1~6): supression factor, min_ovrd becomes larger and echo
- *     target_supp(<0): target echo suppression, unit(dB)
+     *suppression becomes larger. target_supp(<0): target echo suppression,
- *     noise_supp(-30~0): noise suppression, unit(dB)
+     *unit(dB) noise_supp(-30~0): noise suppression, unit(dB) cng_type(0/1):
- *     cng_type(0/1): noise type(0: White noise; 1: Pink noise)
+     *noise type(0: White noise; 1: Pink noise) cng_level(<0): noise gain,
- *     cng_level(<0): noise gain, unit(dB)
+     *unit(dB) Resource consumption: RAM:     None FLASE:   None MIPS:    fs =
- * Resource consumption:
+     *16kHz; Note: This is the recommended AEC
- *     RAM:     None
- *     FLASE:   None
- *     MIPS:    fs = 16kHz;
- * Note:
- *     This is the recommended AEC
      ****************************************************************************************************/
-    .tx_aec2float = {
+    .tx_aec2float =
+        {
             .bypass = 0,
             .hpf_enabled = false,
             .af_enabled = false,
@@ -198,7 +192,8 @@ const SpeechConfig WEAK speech_cfg_default = {
 #endif
 
 #if defined(SPEECH_TX_AEC3)
-    .tx_aec3 = {
+    .tx_aec3 =
+        {
             .bypass = 0,
             .filter_size = 16,
         },
@@ -217,7 +212,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .tx_2mic_ns = {
+    .tx_2mic_ns =
+        {
             .bypass = 0,
             .alpha_h = 0.8,
             .alpha_slow = 0.9,
@@ -239,20 +235,16 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Parameters:
      *     bypass(0/1): bypass enable or disable.
      *     delay_taps(0~4): ceil{[d(MIC1~mouth) - d(MIC2~mouth)] / 2}.
- *         ceil: Returns the largest integer less than or equal to the specified data
+     *         ceil: Returns the largest integer less than or equal to the
- *         d(MIC~mouth): The dinstance from MIC to mouth
+     *specified data d(MIC~mouth): The dinstance from MIC to mouth e.g. 0:
- *         e.g. 0: 0~2cm; 1: 2~4; 2: 5~6...
+     *0~2cm; 1: 2~4; 2: 5~6... freq_smooth_enable(1): Must enable
- *     freq_smooth_enable(1): Must enable
+     *     wnr_enable(0/1): wind noise reduction enable or disable. This is also
- *     wnr_enable(0/1): wind noise reduction enable or disable. This is also useful for improving
+     *useful for improving noise suppression, but it also has some damage to
- *         noise suppression, but it also has some damage to speech signal. 
+     *speech signal. Resource consumption: RAM:     None FLASE:   None MIPS: fs
- * Resource consumption:
+     *= 16kHz, 32M; Note: None
- *     RAM:     None
- *     FLASE:   None
- *     MIPS:    fs = 16kHz, 32M;
- * Note:
- *     None
      ****************************************************************************************************/
-    .tx_2mic_ns2 = {
+    .tx_2mic_ns2 =
+        {
             .bypass = 0,
             .delay_taps = 0.f,
             .freq_smooth_enable = 1,
@@ -266,23 +258,19 @@ const SpeechConfig WEAK speech_cfg_default = {
      *     2 MICs Noise Suppression
      * Parameters:
      *     bypass(0/1): bypass enable or disable.
- *     delay_taps(0~4): ceil{[d(MIC1~mouth) - d(MIC2~mouth)] / 2}. Default as 0
+     *     delay_taps(0~4): ceil{[d(MIC1~mouth) - d(MIC2~mouth)] / 2}. Default
- *         ceil: Returns the largest integer less than or equal to the specified data
+     *as 0 ceil: Returns the largest integer less than or equal to the specified
- *         d(MIC~mouth): The dinstance from MIC to mouth
+     *data d(MIC~mouth): The dinstance from MIC to mouth e.g. 0: 0~2cm; 1: 2~4;
- *         e.g. 0: 0~2cm; 1: 2~4; 2: 5~6...
+     *2: 5~6... freq_smooth_enable(1): Must enable wnr_enable(0/1): wind noise
- *     freq_smooth_enable(1): Must enable
+     *reduction enable or disable. This is also useful for improving noise
- *     wnr_enable(0/1): wind noise reduction enable or disable. This is also useful for improving
+     *suppression, but it also has some damage to speech signal.
- *         noise suppression, but it also has some damage to speech signal. 
+     *     delay_enable(0/1): enable the delay_taps or not. Ideally, never need
- *     delay_enable(0/1): enable the delay_taps or not. Ideally, never need to enable the delay and
+     *to enable the delay and delay_taps will be a useless parameter. Resource
- *          delay_taps will be a useless parameter.
+     *consumption: RAM:     None FLASE:   None MIPS:    fs = 16kHz, 32M; Note:
- * Resource consumption:
- *     RAM:     None
- *     FLASE:   None
- *     MIPS:    fs = 16kHz, 32M;
- * Note:
      *     None
      ****************************************************************************************************/
-    .tx_2mic_ns5 = {
+    .tx_2mic_ns5 =
+        {
             .bypass = 0,
             .delay_taps = 0.0f,
             .freq_smooth_enable = 1,
@@ -304,7 +292,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .tx_2mic_ns4 = {
+    .tx_2mic_ns4 =
+        {
             .bypass = 0,
             .blend_en = 1,
             // .left_gain          = 1.0f,
@@ -313,10 +302,14 @@ const SpeechConfig WEAK speech_cfg_default = {
             .delay_tapsS = 0,
             // .delay_tapsC        = 32,
             //////////////////////////{{a0,a1,a2,a3,a4},{b0,b1,b2,b3,b4}}///////////////////////////
-        // .coefH[0]           = {1.0, -1.88561808316413, 1.55555555555556, -0.628539361054709, 0.111111111111111},
+            // .coefH[0]           = {1.0, -1.88561808316413, 1.55555555555556,
-        // .coefH[1]           = {0.323801506930344, -1.29520602772138, 1.94280904158206, -1.29520602772138, 0.323801506930344},
+            // -0.628539361054709, 0.111111111111111}, .coefH[1]           =
-        // .coefL[0]           = {1.0, -1.88561808316413, 1.55555555555556, -0.628539361054709, 0.111111111111111},
+            // {0.323801506930344, -1.29520602772138, 1.94280904158206,
-        // .coefL[1]           = {0.00953182640298944, 0.0381273056119578, 0.0571909584179366, 0.0381273056119578, 0.00953182640298944},
+            // -1.29520602772138, 0.323801506930344}, .coefL[0]           =
+            // {1.0, -1.88561808316413, 1.55555555555556, -0.628539361054709,
+            // 0.111111111111111}, .coefL[1]           = {0.00953182640298944,
+            // 0.0381273056119578, 0.0571909584179366, 0.0381273056119578,
+            // 0.00953182640298944},
             .crossover_freq = 1000,
             .ff_fb_coeff = ff_fb_h,
             .ff_fb_coeff_len = ARRAY_SIZE(ff_fb_h),
@@ -329,19 +322,16 @@ const SpeechConfig WEAK speech_cfg_default = {
      *     3 MICs Noise Suppression
      * Parameters:
      *     bypass(0/1): bypass enable or disable.
- *     delay_tapsM(0~4): MIC L/R delay samples. Refer to SPEECH_TX_2MIC_NS2 delay_taps
+     *     delay_tapsM(0~4): MIC L/R delay samples. Refer to SPEECH_TX_2MIC_NS2
- *     delay_tapsS(0~4): MIC L/S delay samples. Refer to SPEECH_TX_2MIC_NS2 delay_taps
+     *delay_taps delay_tapsS(0~4): MIC L/S delay samples. Refer to
- *     freq_smooth_enable(1): Must enable
+     *SPEECH_TX_2MIC_NS2 delay_taps freq_smooth_enable(1): Must enable
- *     wnr_enable(0/1): wind noise reduction enable or disable. This is also useful for improving
+     *     wnr_enable(0/1): wind noise reduction enable or disable. This is also
- *         noise suppression, but it also has some damage to speech signal. 
+     *useful for improving noise suppression, but it also has some damage to
- * Resource consumption:
+     *speech signal. Resource consumption: RAM:     None FLASE:   None MIPS: fs
- *     RAM:     None
+     *= 16kHz; Note: None
- *     FLASE:   None
- *     MIPS:    fs = 16kHz;
- * Note:
- *     None
      ****************************************************************************************************/
-    .tx_3mic_ns = {
+    .tx_3mic_ns =
+        {
             .bypass = 0,
             .blend_en = 1,
             .authen_en = 1,
@@ -365,20 +355,16 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Parameters:
      *     bypass(0/1): bypass enable or disable.
      *     delay_taps(0~4): ceil{[d(MIC1~mouth) - d(MIC2~mouth)] / 2}.
- *         ceil: Returns the largest integer less than or equal to the specified data
+     *         ceil: Returns the largest integer less than or equal to the
- *         d(MIC~mouth): The dinstance from MIC to mouth
+     *specified data d(MIC~mouth): The dinstance from MIC to mouth e.g. 0:
- *         e.g. 0: 0~2cm; 1: 2~4; 2: 5~6...
+     *0~2cm; 1: 2~4; 2: 5~6... freq_smooth_enable(1): Must enable
- *     freq_smooth_enable(1): Must enable
+     *     wnr_enable(0/1): wind noise reduction enable or disable. This is also
- *     wnr_enable(0/1): wind noise reduction enable or disable. This is also useful for improving
+     *useful for improving noise suppression, but it also has some damage to
- *         noise suppression, but it also has some damage to speech signal. 
+     *speech signal. Resource consumption: RAM:     None FLASE:   None MIPS: fs
- * Resource consumption:
+     *= 16kHz, 32M; Note: None
- *     RAM:     None
- *     FLASE:   None
- *     MIPS:    fs = 16kHz, 32M;
- * Note:
- *     None
      ****************************************************************************************************/
-    .tx_3mic_ns3 = {
+    .tx_3mic_ns3 =
+        {
             .bypass = 0,
             .endfire_enable = 1,
             .broadside_enable = 1,
@@ -401,7 +387,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     If possible, use SPEECH_TX_NS2 or SPEECH_TX_NS2FLOAT
      ****************************************************************************************************/
-    .tx_ns = {
+    .tx_ns =
+        {
             .bypass = 0,
             .denoise_dB = -12,
         },
@@ -424,7 +411,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .tx_ns2 = {
+    .tx_ns2 =
+        {
             .bypass = 0,
             .denoise_dB = -15,
         },
@@ -446,7 +434,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      *     This is a 'float' version for SPEECH_TX_NS2.
      *     It needs more MIPS and RAM, but can redece quantization noise.
      ****************************************************************************************************/
-    .tx_ns2float = {
+    .tx_ns2float =
+        {
             .bypass = 0,
             .denoise_dB = -15,
             .banks = 64,
@@ -467,7 +456,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .tx_ns3 = {
+    .tx_ns3 =
+        {
             .bypass = 0,
             .mode = NS3_SUPPRESSION_HIGH,
         },
@@ -481,8 +471,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      *     bypass(0/1): bypass enable or disable.
      *     lpf_cutoff: lowpass filter for wind noise detection
      *     hpf_cutoff: highpass filter for wind noise suppression
- *     power_ratio_thr: ratio of the power spectrum of the lower frequencies over the total power
+     *     power_ratio_thr: ratio of the power spectrum of the lower frequencies
-                        spectrum for all frequencies
+    over the total power spectrum for all frequencies
      *     power_thr: normalized power of the low frequencies
      * Resource consumption:
      *     RAM:     None
@@ -491,7 +481,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
     ****************************************************************************************************/
-    .tx_wnr = {
+    .tx_wnr =
+        {
             .bypass = 0,
             .lpf_cutoff = 1000,
             .hpf_cutoff = 400,
@@ -506,8 +497,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      *     Noise Gate
      * Parameters:
      *     bypass(0/1): bypass enable or disable.
- *     data_threshold(0~32767): distinguish between noise and speech, unit(sample).
+     *     data_threshold(0~32767): distinguish between noise and speech,
- *     data_shift(1~3): 1: -6dB; 2: -12dB; 3: -18dB
+     *unit(sample). data_shift(1~3): 1: -6dB; 2: -12dB; 3: -18dB
      *     factor_up(float): attack time, unit(s)
      *     factor_down(float): release time, unit(s)
      * Resource consumption:
@@ -517,7 +508,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .tx_noise_gate = {
+    .tx_noise_gate =
+        {
             .bypass = 0,
             .data_threshold = 640,
             .data_shift = 1,
@@ -540,7 +532,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .tx_compexp = {
+    .tx_compexp =
+        {
             .bypass = 0,
             .comp_threshold = -10.f,
             .comp_ratio = 2.f,
@@ -561,15 +554,14 @@ const SpeechConfig WEAK speech_cfg_default = {
      *     bypass(0/1): bypass enable or disable.
      *     target_level(>0): signal can not exceed (-1 * target_level)dB.
      *     compression_gain(>0): excepted gain.
- *     limiter_enable(0/1): 0: target_level does not take effect; 1: target_level takes effect.
+     *     limiter_enable(0/1): 0: target_level does not take effect; 1:
- * Resource consumption:
+     *target_level takes effect. Resource consumption: RAM:     None FLASE: None
- *     RAM:     None
- *     FLASE:   None
      *     MIPS:    fs = 16kHz, 3M;
      * Note:
      *     None
      ****************************************************************************************************/
-    .tx_agc = {
+    .tx_agc =
+        {
             .bypass = 0,
             .target_level = 3,
             .compression_gain = 6,
@@ -585,19 +577,17 @@ const SpeechConfig WEAK speech_cfg_default = {
      *     bypass(0/1): bypass enable or disable.
      *     gain(float): normalized gain. It is usually less than or equal to 0
      *     num(0~6): the number of EQs
- *     params: {type, frequency, gain, q}. It supports a lot of types, please refer to iirfilt.h file
+     *     params: {type, frequency, gain, q}. It supports a lot of types,
- * Resource consumption:
+     *please refer to iirfilt.h file Resource consumption: RAM:     None FLASE:
- *     RAM:     None
+     *None MIPS:    fs = 16kHz, 0.5M/section; Note: None
- *     FLASE:   None
- *     MIPS:    fs = 16kHz, 0.5M/section;
- * Note:
- *     None
      ****************************************************************************************************/
-    .tx_eq = {
+    .tx_eq =
+        {
             .bypass = 0,
             .gain = 0.f,
             .num = 1,
-        .params = {
+            .params =
+                {
                     {IIR_BIQUARD_HPF, {{60, 0, 0.707f}}},
                 },
         },
@@ -616,7 +606,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .tx_post_gain = {
+    .tx_post_gain =
+        {
             .bypass = 0,
             .gain_dB = 6.0f,
         },
@@ -650,7 +641,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_ns = {
+    .rx_ns =
+        {
             .bypass = 0,
             .denoise_dB = -12,
         },
@@ -665,7 +657,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_ns2 = {
+    .rx_ns2 =
+        {
             .bypass = 0,
             .denoise_dB = -15,
         },
@@ -680,7 +673,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_ns2float = {
+    .rx_ns2float =
+        {
             .bypass = 0,
             .denoise_dB = -15,
             .banks = 64,
@@ -696,7 +690,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_ns3 = {
+    .rx_ns3 =
+        {
             .bypass = 0,
             .mode = NS3_SUPPRESSION_HIGH,
         },
@@ -711,7 +706,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_noise_gate = {
+    .rx_noise_gate =
+        {
             .bypass = 0,
             .data_threshold = 640,
             .data_shift = 1,
@@ -729,7 +725,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_compexp = {
+    .rx_compexp =
+        {
             .bypass = 0,
             .comp_threshold = -10.f,
             .comp_slope = 0.5f,
@@ -751,7 +748,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_agc = {
+    .rx_agc =
+        {
             .bypass = 0,
             .target_level = 3,
             .compression_gain = 6,
@@ -768,11 +766,13 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_eq = {
+    .rx_eq =
+        {
             .bypass = 0,
             .gain = 0.f,
             .num = 1,
-        .params = {
+            .params =
+                {
                     {IIR_BIQUARD_HPF, {{60, 0, 0.707f}}},
                 },
         },
@@ -787,7 +787,8 @@ const SpeechConfig WEAK speech_cfg_default = {
      * Note:
      *     None
      ****************************************************************************************************/
-    .rx_post_gain = {
+    .rx_post_gain =
+        {
             .bypass = 0,
             .gain_dB = 6.0f,
         },

apps/audioplayers/bt_sco_chain_cp.c

@@ -17,14 +17,18 @@
  * Usage:
  *  1.  Enable SCO_CP_ACCEL ?= 1 to enable dual core in sco
  *  2.  Enable SCO_TRACE_CP_ACCEL ?= 1 to see debug log.
- *  3.  Change channel number if the algo(run in cp) input is more than one channel: sco_cp_init(speech_tx_frame_len, 1);
+ *  3.  Change channel number if the algo(run in cp) input is more than one
- *  4.  The code between SCO_CP_ACCEL_ALGO_START(); and SCO_CP_ACCEL_ALGO_END(); will run in CP core.
+ *channel: sco_cp_init(speech_tx_frame_len, 1);
- *  5.  These algorithms will work in AP. Need to move this algorithms from overlay to fast ram.
+ *  4.  The code between SCO_CP_ACCEL_ALGO_START(); and SCO_CP_ACCEL_ALGO_END();
+ *will run in CP core.
+ *  5.  These algorithms will work in AP. Need to move this algorithms from
+ *overlay to fast ram.
  *
  * NOTE:
- *  1.  spx fft and hw fft will share buffer, so just one core can use these fft.
+ *  1.  spx fft and hw fft will share buffer, so just one core can use these
- *  2.  audio_dump_add_channel_data function can not work correctly in CP core, because
+ *fft.
- *      audio_dump_add_channel_data is possible called after audio_dump_run();
+ *  2.  audio_dump_add_channel_data function can not work correctly in CP core,
+ *because audio_dump_add_channel_data is possible called after audio_dump_run();
  *  3.  AP and CP just can use 85%
  *
  *
@@ -33,14 +37,14 @@
  *  1.  FFT, RAM, CODE overlay
  **/
 #if defined(SCO_CP_ACCEL)
+#include "cmsis_os.h"
 #include "cp_accel.h"
 #include "hal_location.h"
-#include "hal_trace.h"
 #include "hal_timer.h"
-#include "cmsis_os.h"
+#include "hal_trace.h"
-#include "speech_cfg.h"
 #include "math.h"
 #include "norflash_api.h"
+#include "speech_cfg.h"
 
 // malloc data from pool in init function
 #define FRAME_LEN_MAX (256)
@@ -74,20 +78,21 @@ static CP_BSS_LOC int g_channel_num;
 static int g_require_cnt = 0;
 static int g_run_cnt = 0;
 
-int sco_cp_process(short *pcm_buf, short *ref_buf, int *_pcm_len)
+int sco_cp_process(short *pcm_buf, short *ref_buf, int *_pcm_len) {
-{
   int32_t pcm_len = *_pcm_len;
   uint32_t wait_cnt = 0;
 
-    ASSERT(g_frame_len * g_channel_num == pcm_len, "[%s] g_frame_len(%d) * g_channel_num(%d) != pcm_len(%d)", __func__, g_frame_len, g_channel_num, pcm_len);
+  ASSERT(g_frame_len * g_channel_num == pcm_len,
+         "[%s] g_frame_len(%d) * g_channel_num(%d) != pcm_len(%d)", __func__,
+         g_frame_len, g_channel_num, pcm_len);
 
   // Check CP has new data to get and can get data from buffer
 #if defined(SCO_TRACE_CP_ACCEL)
-    TRACE(4,"[%s] g_require_cnt: %d, status: %d, pcm_len: %d", __func__, g_require_cnt, g_cp_state, pcm_len);
+  TRACE(4, "[%s] g_require_cnt: %d, status: %d, pcm_len: %d", __func__,
+        g_require_cnt, g_cp_state, pcm_len);
 #endif
 
-    while (g_cp_state == CP_SCO_STATE_WORKING)
+  while (g_cp_state == CP_SCO_STATE_WORKING) {
-    {
     hal_sys_timer_delay_us(10);
 
     if (wait_cnt++ > 300000) { // 3s
@@ -95,11 +100,9 @@ int sco_cp_process(short *pcm_buf, short *ref_buf, int *_pcm_len)
     }
   }
 
-    if (g_cp_state == CP_SCO_STATE_IDLE)
+  if (g_cp_state == CP_SCO_STATE_IDLE) {
-    {
     speech_copy_int16(g_in_pcm_buf, pcm_buf, pcm_len);
-        if (ref_buf)
+    if (ref_buf) {
-        {
       speech_copy_int16(g_in_ref_buf, ref_buf, pcm_len / g_channel_num);
     }
     speech_copy_int16(pcm_buf, g_out_pcm_buf, g_pcm_len);
@@ -108,10 +111,9 @@ int sco_cp_process(short *pcm_buf, short *ref_buf, int *_pcm_len)
 
     g_require_cnt++;
     g_cp_state = CP_SCO_STATE_WORKING;
-        cp_accel_send_event_mcu2cp(CP_BUILD_ID(CP_TASK_SCO, CP_EVENT_SCO_PROCESSING));
+    cp_accel_send_event_mcu2cp(
-    }
+        CP_BUILD_ID(CP_TASK_SCO, CP_EVENT_SCO_PROCESSING));
-    else
+  } else {
-    {
     // Multi channels to one channel
 #if 0
         for (int i = 0; i < pcm_len / g_channel_num; i++)
@@ -133,8 +135,7 @@ int sco_cp_process(short *pcm_buf, short *ref_buf, int *_pcm_len)
 extern int sco_cp_algo(short *pcm_buf, short *ref_buf, int *_pcm_len);
 
 CP_TEXT_SRAM_LOC
-static unsigned int sco_cp_main(uint8_t event)
+static unsigned int sco_cp_main(uint8_t event) {
-{
 #if defined(SCO_TRACE_CP_ACCEL)
   TRACE(2, "[%s] g_run_cnt: %d", __func__, g_run_cnt);
 #endif
@@ -167,17 +168,21 @@ static unsigned int sco_cp_main(uint8_t event)
   return 0;
 }
 
-static struct cp_task_desc TASK_DESC_SCO = {CP_ACCEL_STATE_CLOSED, sco_cp_main, NULL, NULL, NULL};
+static struct cp_task_desc TASK_DESC_SCO = {CP_ACCEL_STATE_CLOSED, sco_cp_main,
-int sco_cp_init(int frame_len, int channel_num)
+                                            NULL, NULL, NULL};
-{
+int sco_cp_init(int frame_len, int channel_num) {
-    TRACE(3,"[%s] frame_len: %d, channel_num: %d", __func__, frame_len, channel_num);
+  TRACE(3, "[%s] frame_len: %d, channel_num: %d", __func__, frame_len,
-    ASSERT(frame_len <= FRAME_LEN_MAX, "[%s] frame_len(%d) > FRAME_LEN_MAX", __func__, frame_len);
+        channel_num);
-    ASSERT(channel_num <= CHANNEL_NUM_MAX, "[%s] channel_num(%d) > CHANNEL_NUM_MAX", __func__, channel_num);
+  ASSERT(frame_len <= FRAME_LEN_MAX, "[%s] frame_len(%d) > FRAME_LEN_MAX",
+         __func__, frame_len);
+  ASSERT(channel_num <= CHANNEL_NUM_MAX,
+         "[%s] channel_num(%d) > CHANNEL_NUM_MAX", __func__, channel_num);
 
   g_require_cnt = 0;
   g_run_cnt = 0;
 
-    norflash_api_flush_disable(NORFLASH_API_USER_CP,(uint32_t)cp_accel_init_done);
+  norflash_api_flush_disable(NORFLASH_API_USER_CP,
+                             (uint32_t)cp_accel_init_done);
   cp_accel_open(CP_TASK_SCO, &TASK_DESC_SCO);
 
   uint32_t cnt = 0;
@@ -212,11 +217,9 @@ int sco_cp_init(int frame_len, int channel_num)
   TRACE(2, "[%s] status = %d", __func__, g_cp_state);
 
   return 0;
-
 }
 
-int sco_cp_deinit(void)
+int sco_cp_deinit(void) {
-{
   TRACE(1, "[%s] ...", __func__);
 
   cp_accel_close(CP_TASK_SCO);

apps/audioplayers/bt_sco_chain_thirdparty.c

@@ -1,9 +1,9 @@
+#include "audio_dump.h"
 #include "bt_sco_chain.h"
+#include "hal_trace.h"
+#include "speech_cfg.h"
 #include "speech_memory.h"
 #include "speech_utils.h"
-#include "hal_trace.h"
-#include "audio_dump.h"
-#include "speech_cfg.h"
 
 #if defined(SPEECH_TX_24BIT)
 int32_t *aec_echo_buf = NULL;
@@ -27,11 +27,8 @@ static short *aec_echo_buf_ptr;
 SpeechDcFilterState *speech_tx_dc_filter_st = NULL;
 #endif
 
-int speech_init(int tx_sample_rate, int rx_sample_rate,
+int speech_init(int tx_sample_rate, int rx_sample_rate, int tx_frame_ms,
-                     int tx_frame_ms, int rx_frame_ms,
+                int rx_frame_ms, int sco_frame_ms, uint8_t *buf, int len) {
-                     int sco_frame_ms,
-                     uint8_t *buf, int len)
-{
   // we shoule keep a minmum buffer for speech heap
   // MSBC_16K_SAMPLE_RATE = 0, 560 bytes
   // MSBC_16K_SAMPLE_RATE = 1, 2568 bytes
@@ -61,9 +58,12 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
       .gain = 0.f,
   };
 
-    speech_tx_dc_filter_st = speech_dc_filter_create(tx_sample_rate, frame_len, &dc_filter_cfg);
+  speech_tx_dc_filter_st =
-    speech_dc_filter_ctl(speech_tx_dc_filter_st, SPEECH_DC_FILTER_SET_CHANNEL_NUM, &channel_num);
+      speech_dc_filter_create(tx_sample_rate, frame_len, &dc_filter_cfg);
-    speech_dc_filter_ctl(speech_tx_dc_filter_st, SPEECH_DC_FILTER_SET_DATA_SEPARATION, &data_separation);
+  speech_dc_filter_ctl(speech_tx_dc_filter_st, SPEECH_DC_FILTER_SET_CHANNEL_NUM,
+                       &channel_num);
+  speech_dc_filter_ctl(speech_tx_dc_filter_st,
+                       SPEECH_DC_FILTER_SET_DATA_SEPARATION, &data_separation);
 #endif
 
   audio_dump_init(frame_len, sizeof(int16_t), 3);
@@ -71,8 +71,7 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
   return 0;
 }
 
-int speech_deinit(void)
+int speech_deinit(void) {
-{
 #if defined(SPEECH_TX_DC_FILTER)
   speech_dc_filter_destroy(speech_tx_dc_filter_st);
 #endif
@@ -81,7 +80,8 @@ int speech_deinit(void)
 
   size_t total = 0, used = 0, max_used = 0;
   speech_memory_info(&total, &used, &max_used);
-    TRACE(3,"SPEECH MALLOC MEM: total - %d, used - %d, max_used - %d.", total, used, max_used);
+  TRACE(3, "SPEECH MALLOC MEM: total - %d, used - %d, max_used - %d.", total,
+        used, max_used);
   ASSERT(used == 0, "[%s] used != 0", __func__);
 
   return 0;
@@ -91,8 +91,7 @@ int speech_deinit(void)
 extern void bt_sco_get_tdm_buffer(uint8_t **buf, uint32_t *len);
 #endif
 
-int speech_tx_process(void *_pcm_buf, void *_ref_buf, int *_pcm_len)
+int speech_tx_process(void *_pcm_buf, void *_ref_buf, int *_pcm_len) {
-{
 #if defined(SPEECH_TX_24BIT)
   int32_t *pcm_buf = (int32_t *)_pcm_buf;
   int32_t *ref_buf = (int32_t *)_ref_buf;
@@ -110,12 +109,18 @@ int speech_tx_process(void *_pcm_buf, void *_ref_buf, int *_pcm_len)
 #endif
 
   audio_dump_clear_up();
-    audio_dump_add_channel_data(0, ref_buf, pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
+  audio_dump_add_channel_data(0, ref_buf,
-    audio_dump_add_channel_data_from_multi_channels(1, pcm_buf, pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM, SPEECH_CODEC_CAPTURE_CHANNEL_NUM, 0);
+                              pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
-    audio_dump_add_channel_data_from_multi_channels(2, pcm_buf, pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM, SPEECH_CODEC_CAPTURE_CHANNEL_NUM, 1);
+  audio_dump_add_channel_data_from_multi_channels(
+      1, pcm_buf, pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM,
+      SPEECH_CODEC_CAPTURE_CHANNEL_NUM, 0);
+  audio_dump_add_channel_data_from_multi_channels(
+      2, pcm_buf, pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM,
+      SPEECH_CODEC_CAPTURE_CHANNEL_NUM, 1);
 
 #if defined(BONE_SENSOR_TDM)
-    audio_dump_add_channel_data(3, bone_buf, pcm16_len/SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
+  audio_dump_add_channel_data(3, bone_buf,
+                              pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
 #endif
 
   audio_dump_run();
@@ -130,7 +135,8 @@ int speech_tx_process(void *_pcm_buf, void *_ref_buf, int *_pcm_len)
 
   // Add your algrithm here and disable #if macro
 #if 1
-    for (int i = 0, j = 0; i < pcm_len; i += SPEECH_CODEC_CAPTURE_CHANNEL_NUM, j++) {
+  for (int i = 0, j = 0; i < pcm_len;
+       i += SPEECH_CODEC_CAPTURE_CHANNEL_NUM, j++) {
     // choose main microphone data
     pcm_buf[j] = pcm_buf[i];
     // choose reference data, i.e. loopback
@@ -148,8 +154,7 @@ int speech_tx_process(void *_pcm_buf, void *_ref_buf, int *_pcm_len)
   return 0;
 }
 
-int speech_rx_process(void *pcm_buf, int *pcm_len)
+int speech_rx_process(void *pcm_buf, int *pcm_len) {
-{
   // Add your algorithm here
   return 0;
 }

apps/audioplayers/bt_sco_chain_thirdparty_alango.c

@@ -1,10 +1,10 @@
+#include "audio_dump.h"
 #include "bt_sco_chain.h"
+#include "hal_trace.h"
 #include "speech_memory.h"
 #include "speech_utils.h"
-#include "hal_trace.h"
-#include "audio_dump.h"
-#include "vcp-api.h"
 #include "spf-postapi.h"
+#include "vcp-api.h"
 
 #define ALANGO_TRACE(s, ...) TRACE(1, "%s: " s, __FUNCTION__, ##__VA_ARGS__)
 
@@ -28,8 +28,8 @@ mem_reg_t reg[NUM_MEM_REGIONS];
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM >= 2
 static int16_t *deinterleaved_buf = NULL;
 
-static void deinterleave_audio(int16_t *dst, int16_t *src, uint32_t len, uint32_t ch_num)
+static void deinterleave_audio(int16_t *dst, int16_t *src, uint32_t len,
-{
+                               uint32_t ch_num) {
   uint32_t samples_per_channel = len / ch_num;
 
   for (uint32_t i = 0; i < samples_per_channel; i++) {
@@ -40,11 +40,8 @@ static void deinterleave_audio(int16_t *dst, int16_t *src, uint32_t len, uint32_
 }
 #endif
 
-int speech_init(int tx_sample_rate, int rx_sample_rate,
+int speech_init(int tx_sample_rate, int rx_sample_rate, int tx_frame_ms,
-                     int tx_frame_ms, int rx_frame_ms,
+                int rx_frame_ms, int sco_frame_ms, uint8_t *buf, int len) {
-                     int sco_frame_ms,
-                     uint8_t *buf, int len)
-{
   speech_heap_init(buf, len);
 
   int frame_len = SPEECH_FRAME_MS_TO_LEN(tx_sample_rate, tx_frame_ms);
@@ -63,7 +60,9 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
       ALANGO_TRACE(1, "Profile error: %d", err.err);
   }
 
-    ASSERT(frame_len % curr_profile->p_gen->frlen == 0, "Profile error: frame_len(%d) should be divided by frlen(%d)", frame_len, curr_profile->p_gen->frlen);
+  ASSERT(frame_len % curr_profile->p_gen->frlen == 0,
+         "Profile error: frame_len(%d) should be divided by frlen(%d)",
+         frame_len, curr_profile->p_gen->frlen);
 
   unsigned int smem = vcp_get_hook_size();
   mem = speech_malloc(smem);
@@ -74,20 +73,25 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
 
   for (int i = 0; i < NUM_MEM_REGIONS; i++) {
     reg[i].mem = (void *)speech_malloc(reg[i].size);
-        ALANGO_TRACE(2,"I need %d bytes of memory in memory region %d to work.\n", reg[i].size, i + 1);
+    ALANGO_TRACE(2, "I need %d bytes of memory in memory region %d to work.\n",
+                 reg[i].size, i + 1);
   }
 
   err = vcp_init_debug(curr_profile, reg);
   if (err.err == ERR_NOT_ENOUGH_MEMORY) {
-        ALANGO_TRACE(2,"%d more bytes needed in region %d!\n", -reg[err.pid].size, err.pid);
+    ALANGO_TRACE(2, "%d more bytes needed in region %d!\n", -reg[err.pid].size,
+                 err.pid);
   } else if (err.err == ERR_UNKNOWN) {
     ALANGO_TRACE(0, "vcp_init_debug() returns UNKNOWN error\n!");
   } else if (err.err != ERR_NO_ERROR) {
-        ALANGO_TRACE(2,"vcp_init_debug() returns error %d, pid %d!\n", err.err, err.pid);
+    ALANGO_TRACE(2, "vcp_init_debug() returns error %d, pid %d!\n", err.err,
+                 err.pid);
   }
 
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM >= 2
-    deinterleaved_buf = speech_malloc(curr_profile->p_gen->frlen * SPEECH_CODEC_CAPTURE_CHANNEL_NUM * sizeof(int16_t));
+  deinterleaved_buf =
+      speech_malloc(curr_profile->p_gen->frlen *
+                    SPEECH_CODEC_CAPTURE_CHANNEL_NUM * sizeof(int16_t));
 #endif
 
   audio_dump_init(frame_len, sizeof(int16_t), 3);
@@ -95,8 +99,7 @@ int speech_init(int tx_sample_rate, int rx_sample_rate,
   return 0;
 }
 
-int speech_deinit(void)
+int speech_deinit(void) {
-{
   speech_free(aec_echo_buf_ptr);
   speech_free(mem);
 
@@ -109,7 +112,8 @@ int speech_deinit(void)
 
   size_t total = 0, used = 0, max_used = 0;
   speech_memory_info(&total, &used, &max_used);
-    TRACE(3,"SPEECH MALLOC MEM: total - %d, used - %d, max_used - %d.", total, used, max_used);
+  TRACE(3, "SPEECH MALLOC MEM: total - %d, used - %d, max_used - %d.", total,
+        used, max_used);
   ASSERT(used == 0, "[%s] used != 0", __func__);
 
   return 0;
@@ -119,8 +123,7 @@ int speech_deinit(void)
 extern void bt_sco_get_tdm_buffer(uint8_t **buf, uint32_t *len);
 #endif
 
-int speech_tx_process(void *pcm_buf, void *ref_buf, int *pcm_len)
+int speech_tx_process(void *pcm_buf, void *ref_buf, int *pcm_len) {
-{
   int16_t *pcm16_buf = (int16_t *)pcm_buf;
   int16_t *ref16_buf = (int16_t *)ref_buf;
   int pcm16_len = *pcm_len;
@@ -132,12 +135,18 @@ int speech_tx_process(void *pcm_buf, void *ref_buf, int *pcm_len)
 #endif
 
   audio_dump_clear_up();
-    audio_dump_add_channel_data(0, ref_buf, pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
+  audio_dump_add_channel_data(0, ref_buf,
-    audio_dump_add_channel_data_from_multi_channels(1, pcm16_buf, pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM, SPEECH_CODEC_CAPTURE_CHANNEL_NUM, 0);
+                              pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
-    audio_dump_add_channel_data_from_multi_channels(2, pcm16_buf, pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM, SPEECH_CODEC_CAPTURE_CHANNEL_NUM, 1);
+  audio_dump_add_channel_data_from_multi_channels(
+      1, pcm16_buf, pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM,
+      SPEECH_CODEC_CAPTURE_CHANNEL_NUM, 0);
+  audio_dump_add_channel_data_from_multi_channels(
+      2, pcm16_buf, pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM,
+      SPEECH_CODEC_CAPTURE_CHANNEL_NUM, 1);
 
 #if defined(BONE_SENSOR_TDM)
-    audio_dump_add_channel_data(3, bone_buf, pcm16_len/SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
+  audio_dump_add_channel_data(3, bone_buf,
+                              pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
 #endif
 
   audio_dump_run();
@@ -152,13 +161,21 @@ int speech_tx_process(void *pcm_buf, void *ref_buf, int *pcm_len)
     }
     pcm16_len /= SPEECH_CODEC_CAPTURE_CHANNEL_NUM;
 #else
-    for (int i = 0, j = 0; i < pcm16_len; i += curr_profile->p_gen->frlen * SPEECH_CODEC_CAPTURE_CHANNEL_NUM, j += curr_profile->p_gen->frlen) {
+  for (int i = 0, j = 0; i < pcm16_len;
+       i += curr_profile->p_gen->frlen * SPEECH_CODEC_CAPTURE_CHANNEL_NUM,
+           j += curr_profile->p_gen->frlen) {
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM >= 2
-        deinterleave_audio(deinterleaved_buf, &pcm16_buf[i], curr_profile->p_gen->frlen * SPEECH_CODEC_CAPTURE_CHANNEL_NUM, SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
+    deinterleave_audio(deinterleaved_buf, &pcm16_buf[i],
-        err_t err = vcp_process_tx(reg, deinterleaved_buf, &ref16_buf[j], &pcm16_buf[j]);
+                       curr_profile->p_gen->frlen *
-        //memcpy(&pcm16_buf[j], deinterleaved_buf, curr_profile->p_gen->frlen * sizeof(int16_t));
+                           SPEECH_CODEC_CAPTURE_CHANNEL_NUM,
+                       SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
+    err_t err =
+        vcp_process_tx(reg, deinterleaved_buf, &ref16_buf[j], &pcm16_buf[j]);
+    // memcpy(&pcm16_buf[j], deinterleaved_buf, curr_profile->p_gen->frlen *
+    // sizeof(int16_t));
 #else
-        err_t err = vcp_process_tx(reg, &pcm16_buf[i], &ref16_buf[j], &pcm16_buf[j]);
+    err_t err =
+        vcp_process_tx(reg, &pcm16_buf[i], &ref16_buf[j], &pcm16_buf[j]);
 #endif
     if (err.err != ERR_NO_ERROR) {
       ALANGO_TRACE(1, "vcp_process_tx error: %d", err.err);
@@ -176,8 +193,7 @@ int speech_tx_process(void *pcm_buf, void *ref_buf, int *pcm_len)
   return 0;
 }
 
-int speech_rx_process(void *pcm_buf, int *pcm_len)
+int speech_rx_process(void *pcm_buf, int *pcm_len) {
-{
   int16_t *pcm16_buf = (int16_t *)pcm_buf;
   int pcm16_len = *pcm_len;
 

apps/audioplayers/bt_sco_chain_tuning.c

@@ -13,8 +13,8 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "bt_sco_chain_cfg.h"
 #include "aud_section.h"
+#include "bt_sco_chain_cfg.h"
 #include "hal_trace.h"
 
 static bool speech_tuning_status = false;
@@ -29,8 +29,7 @@ typedef struct {
 
 static AUDIO_SECTION_SPEECH_CFG_T audio_section_speech_cfg;
 
-int store_speech_cfg_into_audio_section(SpeechConfig *cfg)
+int store_speech_cfg_into_audio_section(SpeechConfig *cfg) {
-{
   int res = 0;
 
   memcpy(&audio_section_speech_cfg.cfg, cfg, sizeof(SpeechConfig));
@@ -39,21 +38,16 @@ int store_speech_cfg_into_audio_section(SpeechConfig *cfg)
                                 (uint8_t *)&audio_section_speech_cfg,
                                 sizeof(AUDIO_SECTION_SPEECH_CFG_T));
 
-
+  if (res) {
-    if(res)
-    {
     TRACE(2, "[%s] ERROR: res = %d", __func__, res);
-    }
+  } else {
-    else
-    {
     TRACE(1, "[%s] Store speech cfg into audio section!!!", __func__);
   }
 
   return res;
 }
 
-void *load_speech_cfg_from_audio_section(void)
+void *load_speech_cfg_from_audio_section(void) {
-{
   int res = 0;
   res = audio_section_load_cfg(AUDIO_SECTION_DEVICE_SPEECH,
                                (uint8_t *)&audio_section_speech_cfg,
@@ -61,13 +55,10 @@ void *load_speech_cfg_from_audio_section(void)
 
   void *res_ptr = NULL;
 
-    if (res)
+  if (res) {
-    {
     TRACE(2, "[%s] ERROR: res = %d", __func__, res);
     res_ptr = NULL;
-    }
+  } else {
-    else
-    {
     TRACE(1, "[%s] Load speech cfg from audio section!!!", __func__);
     res_ptr = (void *)&audio_section_speech_cfg.cfg;
   }
@@ -76,41 +67,35 @@ void *load_speech_cfg_from_audio_section(void)
 }
 #endif
 
-int speech_tuning_set_status(bool en)
+int speech_tuning_set_status(bool en) {
-{
   speech_tuning_status = en;
 
   return 0;
 }
 
-bool speech_tuning_get_status(void)
+bool speech_tuning_get_status(void) { return speech_tuning_status; }
-{
-    return speech_tuning_status;
-}
 
-uint32_t speech_tuning_check(unsigned char *buf, uint32_t len)
+uint32_t speech_tuning_check(unsigned char *buf, uint32_t len) {
-{
   uint32_t res = 0;
 
   // Check valid
   uint32_t config_size = sizeof(SpeechConfig);
 
-    if (config_size != len)
+  if (config_size != len) {
-    {
     TRACE(2, "[speech tuning] len(%d) != config_size(%d)", len, config_size);
     res = 1;
-    }
+  } else {
-    else
-    {
     TRACE(1, "[speech tuning] len(%d) is OK", len);
     // SpeechConfig POSSIBLY_UNUSED *cfg = (SpeechConfig *)buf;
 
     // Test parameters
     //#if defined(SPEECH_TX_2MIC_NS2)
-//        TRACE(1,"[speech tuning] TX: delay_taps(x100): %d", (int)(cfg->tx_2mic_ns2.delay_taps * 100));
+    //        TRACE(1,"[speech tuning] TX: delay_taps(x100): %d",
+    //        (int)(cfg->tx_2mic_ns2.delay_taps * 100));
     //#endif
     //#if defined(SPEECH_TX_NOISE_GATE)
-//        TRACE(1,"[speech tuning] TX: data_threshold: %d", cfg->tx_noise_gate.data_threshold);
+    //        TRACE(1,"[speech tuning] TX: data_threshold: %d",
+    //        cfg->tx_noise_gate.data_threshold);
     //#endif
     //#if defined(SPEECH_TX_EQ)
     //        TRACE(1,"[speech tuning] TX: eq num: %d", cfg->tx_eq.num);
@@ -123,19 +108,16 @@ uint32_t speech_tuning_check(unsigned char *buf, uint32_t len)
   return res;
 }
 
-uint32_t speech_tuning_rx_callback(unsigned char *buf, uint32_t len)
+uint32_t speech_tuning_rx_callback(unsigned char *buf, uint32_t len) {
-{
   uint32_t res = 0;
 
   res = speech_tuning_check(buf, len);
 
-    if (res)
+  if (res) {
-    {
     TRACE(1, "[speech tuning] ERROR: Send check res = %d", res);
-        TRACE(0,"[Speech Tuning] res : 1; info : Send len(%d) != config_size(%d);", len, sizeof(SpeechConfig));
+    TRACE(0, "[Speech Tuning] res : 1; info : Send len(%d) != config_size(%d);",
-    }
+          len, sizeof(SpeechConfig));
-    else
+  } else {
-    {
     // Save cfg
     speech_store_config((SpeechConfig *)buf);
 
@@ -150,29 +132,24 @@ uint32_t speech_tuning_rx_callback(unsigned char *buf, uint32_t len)
 }
 
 #ifdef AUDIO_SECTION_ENABLE
-uint32_t speech_tuning_burn_rx_callback(unsigned char *buf, uint32_t len)
+uint32_t speech_tuning_burn_rx_callback(unsigned char *buf, uint32_t len) {
-{
   uint32_t res = 0;
 
   res = speech_tuning_check(buf, len);
 
-    if (res)
+  if (res) {
-    {
     TRACE(1, "[speech tuning] ERROR: Burn check res = %d", res);
-        TRACE(0,"[Speech Tuning] res : 1; info : Burn len(%d) != config_size(%d);", len, sizeof(SpeechConfig));
+    TRACE(0, "[Speech Tuning] res : 1; info : Burn len(%d) != config_size(%d);",
-    }
+          len, sizeof(SpeechConfig));
-    else
+  } else {
-    {
     res = store_speech_cfg_into_audio_section((SpeechConfig *)buf);
 
-        if(res)
+    if (res) {
-        {
       TRACE(1, "[speech tuning] ERROR: Store res = %d", res);
       res += 100;
-            TRACE(0,"[Speech Tuning] res : 2; info : Do not enable AUDIO_SECTION_ENABLE;");
+      TRACE(0, "[Speech Tuning] res : 2; info : Do not enable "
-        }
+               "AUDIO_SECTION_ENABLE;");
-        else
+    } else {
-        {
       TRACE(0, "[speech tuning] OK: Store cfg");
       TRACE(0, "[Speech Tuning] res : 0;");
     }
@@ -182,13 +159,15 @@ uint32_t speech_tuning_burn_rx_callback(unsigned char *buf, uint32_t len)
 }
 #endif
 
-int speech_tuning_init(void)
+int speech_tuning_init(void) {
-{
 #if defined(HAL_TRACE_RX_ENABLE) && !defined(SPEECH_TX_THIRDPARTY)
-    hal_trace_rx_register("Speech Tuning", (HAL_TRACE_RX_CALLBACK_T)speech_tuning_rx_callback);
+  hal_trace_rx_register("Speech Tuning",
+                        (HAL_TRACE_RX_CALLBACK_T)speech_tuning_rx_callback);
 
 #ifdef AUDIO_SECTION_ENABLE
-    hal_trace_rx_register("Speech Tuning Burn", (HAL_TRACE_RX_CALLBACK_T)speech_tuning_burn_rx_callback);
+  hal_trace_rx_register(
+      "Speech Tuning Burn",
+      (HAL_TRACE_RX_CALLBACK_T)speech_tuning_burn_rx_callback);
 #endif
 
 #endif
@@ -198,15 +177,13 @@ int speech_tuning_init(void)
   return 0;
 }
 
-int speech_tuning_open(void)
+int speech_tuning_open(void) {
-{
 #ifdef AUDIO_SECTION_ENABLE
   SpeechConfig *speech_cfg_load = NULL;
 
   speech_cfg_load = (SpeechConfig *)load_speech_cfg_from_audio_section();
 
-    if (speech_cfg_load)
+  if (speech_cfg_load) {
-    {
     speech_store_config(speech_cfg_load);
   }
 #endif
@@ -216,8 +193,7 @@ int speech_tuning_open(void)
   return 0;
 }
 
-int speech_tuning_close(void)
+int speech_tuning_close(void) {
-{
   speech_tuning_set_status(false);
 
   return 0;

apps/audioplayers/cvsdplay.cpp

@@ -17,23 +17,22 @@
 #include "mbed.h"
 #endif
 // Standard C Included Files
-#include <string.h>
 #include <math.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #ifdef MBED
 //#include "rtos.h"
 #endif
 #ifdef MBED
 #include "SDFileSystem.h"
 #endif
+#include "app_audio.h"
 #include "cqueue.h"
-#include "hal_uart.h"
 #include "hal_timer.h"
 #include "hal_trace.h"
-#include "app_audio.h"
+#include "hal_uart.h"
-
 
 // BT
 
@@ -52,8 +51,7 @@ static enum APP_AUDIO_CACHE_T voicecvsd_cache_status = APP_AUDIO_CACHE_QTY;
 #define LOCK_VOICECVSD_QUEUE()                                                 \
   osMutexWait(g_voicecvsd_queue_mutex_id, osWaitForever)
 
-#define UNLOCK_VOICECVSD_QUEUE() \
+#define UNLOCK_VOICECVSD_QUEUE() osMutexRelease(g_voicecvsd_queue_mutex_id)
-    osMutexRelease(g_voicecvsd_queue_mutex_id)
 
 void xLOCK_VOICECVSD_QUEUE(void)
 {

apps/audioplayers/digmici2splay.cpp

@@ -14,28 +14,26 @@
  *
  ****************************************************************************/
 // Standard C Included Files
-#include <string.h>
-#include <math.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include "cqueue.h"
-#include "hal_uart.h"
 #include "hal_timer.h"
 #include "hal_trace.h"
+#include "hal_uart.h"
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 uint8_t digmic_buf[100 * 1024];
 uint32_t digmic_buf_len = 0;
 
-uint32_t dig_mic_audio_more_data(uint8_t *buf, uint32_t len)
+uint32_t dig_mic_audio_more_data(uint8_t *buf, uint32_t len) {
-{
   TRACE(2, "%s:%d\n", __func__, __LINE__);
   memcpy(buf, digmic_buf, len);
 
   return len;
 }
-uint32_t dig_mic_audio_data_come(uint8_t *buf, uint32_t len)
+uint32_t dig_mic_audio_data_come(uint8_t *buf, uint32_t len) {
-{
   TRACE(2, "%s:%d\n", __func__, __LINE__);
 
   memcpy(digmic_buf + digmic_buf_len, buf, len);

apps/audioplayers/flacplay.cpp

@@ -14,15 +14,15 @@
  *
  ****************************************************************************/
 // Standard C Included Files
-#include <string.h>
-#include <math.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include "cqueue.h"
-#include "hal_uart.h"
 #include "hal_timer.h"
 #include "hal_trace.h"
+#include "hal_uart.h"
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #ifdef RTOS
 #include "cmsis_os.h"
 #endif
@@ -38,22 +38,20 @@ unsigned char flac_queue_buf[FLAC_QUEUE_SIZE];
 CQueue flac_queue;
 static uint32_t ok_to_decode = 0;
 
-#define LOCK_FLAC_QUEUE() \
+#define LOCK_FLAC_QUEUE() osMutexWait(g_flac_queue_mutex_id, osWaitForever)
-	osMutexWait(g_flac_queue_mutex_id, osWaitForever)
 
-#define UNLOCK_FLAC_QUEUE() \
+#define UNLOCK_FLAC_QUEUE() osMutexRelease(g_flac_queue_mutex_id)
-	osMutexRelease(g_flac_queue_mutex_id)
 
-static void copy_one_trace_to_two_track_16bits(uint16_t *src_buf, uint16_t *dst_buf, uint32_t src_len)
+static void copy_one_trace_to_two_track_16bits(uint16_t *src_buf,
-{
+                                               uint16_t *dst_buf,
+                                               uint32_t src_len) {
   uint32_t i = 0;
   for (i = 0; i < src_len; ++i) {
     dst_buf[i * 2 + 0] = dst_buf[i * 2 + 1] = src_buf[i];
   }
 }
 
-int store_flac_buffer(unsigned char *buf, unsigned int len)
+int store_flac_buffer(unsigned char *buf, unsigned int len) {
-{
   LOCK_FLAC_QUEUE();
   EnCQueue(&flac_queue, buf, len);
   if (LengthOfCQueue(&flac_queue) > FLAC_TEMP_BUFFER_SIZE * 2) {
@@ -64,8 +62,7 @@ int store_flac_buffer(unsigned char *buf, unsigned int len)
   return 0;
 }
 
-int decode_flac_frame(unsigned char *pcm_buffer, unsigned int pcm_len)
+int decode_flac_frame(unsigned char *pcm_buffer, unsigned int pcm_len) {
-{
   uint32_t r = 0, got_len = 0;
   unsigned char *e1 = NULL, *e2 = NULL;
   unsigned int len1 = 0, len2 = 0;
@@ -80,7 +77,8 @@ get_again:
   }
 
   // memcpy(pcm_buffer + got_len, e1, len1);
-    copy_one_trace_to_two_track_16bits((uint16_t *)e1, (uint16_t *)(pcm_buffer + got_len), len1/2);
+  copy_one_trace_to_two_track_16bits(
+      (uint16_t *)e1, (uint16_t *)(pcm_buffer + got_len), len1 / 2);
 
   LOCK_FLAC_QUEUE();
   DeCQueue(&flac_queue, 0, len1);
@@ -90,7 +88,8 @@ get_again:
 
   if (len2 != 0) {
     // memcpy(pcm_buffer + got_len, e2, len2);
-        copy_one_trace_to_two_track_16bits((uint16_t *)e2, (uint16_t *)(pcm_buffer + got_len), len2/2);
+    copy_one_trace_to_two_track_16bits(
+        (uint16_t *)e2, (uint16_t *)(pcm_buffer + got_len), len2 / 2);
 
     LOCK_FLAC_QUEUE();
     DeCQueue(&flac_queue, 0, len2);
@@ -105,15 +104,13 @@ get_again:
   return pcm_len;
 }
 
-uint32_t flac_audio_data_come(uint8_t *buf, uint32_t len)
+uint32_t flac_audio_data_come(uint8_t *buf, uint32_t len) {
-{
   TRACE(1, "data come %d\n", len);
 
   return 0;
 }
 
-uint32_t flac_audio_more_data(uint8_t *buf, uint32_t len)
+uint32_t flac_audio_more_data(uint8_t *buf, uint32_t len) {
-{
   uint32_t l = 0;
   // uint32_t cur_ticks = 0, ticks = 0;
 
@@ -128,8 +125,7 @@ uint32_t flac_audio_more_data(uint8_t *buf, uint32_t len)
   return l;
 }
 
-int flac_audio_init(void)
+int flac_audio_init(void) {
-{
   g_flac_queue_mutex_id = osMutexCreate((osMutex(g_flac_queue_mutex)));
   /* flac queue*/
   InitCQueue(&flac_queue, FLAC_QUEUE_SIZE, (unsigned char *)&flac_queue_buf);

apps/audioplayers/fmradio.cpp

@@ -15,23 +15,23 @@
  ****************************************************************************/
 #ifdef CHIP_BEST1000
 
+#include "app_audio.h"
+#include "app_overlay.h"
+#include "app_utils.h"
+#include "audiobuffer.h"
+#include "audioflinger.h"
 #include "cmsis.h"
 #include "cmsis_os.h"
-#include "hal_trace.h"
+#include "cqueue.h"
 #include "fmdec.h"
-#include "hal_dma.h"
-#include "hal_timer.h"
-#include "hal_cmu.h"
 #include "hal_analogif.h"
 #include "hal_chipid.h"
-#include "audioflinger.h"
+#include "hal_cmu.h"
-#include "audiobuffer.h"
+#include "hal_dma.h"
-#include "cqueue.h"
+#include "hal_timer.h"
-#include "app_audio.h"
+#include "hal_trace.h"
-#include "app_utils.h"
-#include "app_overlay.h"
-#include "string.h"
 #include "pmu.h"
+#include "string.h"
 
 //#define FM_DEBUG 1
 
@@ -56,14 +56,18 @@
 extern int app_bt_stream_local_volume_get(void);
 static int32_t *fm_sample_buffer_p;
 
-static void fm_handler(uint8_t chan, uint32_t remains, uint32_t error, struct HAL_DMA_DESC_T *lli)
+static void fm_handler(uint8_t chan, uint32_t remains, uint32_t error,
-{
+                       struct HAL_DMA_DESC_T *lli) {
   static int cnt = 0;
   int16_t fm_decbuf[(FM_SAMPLE_NUM / 9)];
-    FmDemodulate((int16_t *)(fm_sample_buffer_p +((cnt%FM_FRAME_NUM)*FM_SAMPLE_NUM)), fm_decbuf,FM_SAMPLE_NUM);
+  FmDemodulate(
+      (int16_t *)(fm_sample_buffer_p + ((cnt % FM_FRAME_NUM) * FM_SAMPLE_NUM)),
+      fm_decbuf, FM_SAMPLE_NUM);
   cnt++;
   app_audio_pcmbuff_put((uint8_t *)fm_decbuf, (FM_SAMPLE_NUM / 9) << 1);
-    FmDemodulate((int16_t *)(fm_sample_buffer_p +((cnt%FM_FRAME_NUM)*FM_SAMPLE_NUM)), fm_decbuf,FM_SAMPLE_NUM);
+  FmDemodulate(
+      (int16_t *)(fm_sample_buffer_p + ((cnt % FM_FRAME_NUM) * FM_SAMPLE_NUM)),
+      fm_decbuf, FM_SAMPLE_NUM);
   cnt++;
   app_audio_pcmbuff_put((uint8_t *)fm_decbuf, (FM_SAMPLE_NUM / 9) << 1);
 
@@ -80,13 +84,13 @@ static void fm_handler(uint8_t chan, uint32_t remains, uint32_t error, struct HA
       diff_ticks = TICKS_TO_MS(cur_ticks - preTicks);
       preTicks = cur_ticks;
     }
-        TRACE(3,"[fm_handler]       diff=%d add:%d remain:%d input", diff_ticks, (FM_SAMPLE_NUM/9)<<1, app_audio_pcmbuff_length());
+    TRACE(3, "[fm_handler]       diff=%d add:%d remain:%d input", diff_ticks,
+          (FM_SAMPLE_NUM / 9) << 1, app_audio_pcmbuff_length());
   }
 #endif
 }
 
-uint32_t fm_pcm_more_data(uint8_t *buf, uint32_t len)
+uint32_t fm_pcm_more_data(uint8_t *buf, uint32_t len) {
-{
   app_audio_pcmbuff_get(buf, len);
 #ifdef FM_DEBUG
   {
@@ -100,42 +104,39 @@ uint32_t fm_pcm_more_data(uint8_t *buf, uint32_t len)
       preTicks = cur_ticks;
     }
 
-        TRACE(5,"[fm_pcm_more_data] diff=%d get:%d remain:%d output isr:0x%08x cnt:%d", diff_ticks, len/2, app_audio_pcmbuff_length(), FM_DIGITAL_REG(0x40160020), FM_DIGITAL_REG(0x40160028));
+    TRACE(
+        5,
+        "[fm_pcm_more_data] diff=%d get:%d remain:%d output isr:0x%08x cnt:%d",
+        diff_ticks, len / 2, app_audio_pcmbuff_length(),
+        FM_DIGITAL_REG(0x40160020), FM_DIGITAL_REG(0x40160028));
   }
 #endif
   return 0;
 }
 
-uint32_t fm_capture_more_data(uint8_t *buf, uint32_t len)
+uint32_t fm_capture_more_data(uint8_t *buf, uint32_t len) {
-{
   fm_handler(0, 0, 0, NULL);
   return len;
 }
 
-void fm_radio_digit_init(void)
+void fm_radio_digit_init(void) {
-{
+  FM_DIGITAL_REG(0xd0350244) = (FM_DIGITAL_REG(0xd0350244) & ~0x01fff) |
-    FM_DIGITAL_REG(0xd0350244) = (FM_DIGITAL_REG(0xd0350244) & ~0x01fff) | 0x20f; //-890k -> 0 if_shift, for 110.5292m adc
+                               0x20f; //-890k -> 0 if_shift, for 110.5292m adc
 
   //    FM_DIGITAL_REG(0x40180e0c) = 0x34;
-   //FM_DIGITAL_REG(0x4000a050) = (FM_DIGITAL_REG(0x4000a050) & ~0x18000) | 0x18000;
+  // FM_DIGITAL_REG(0x4000a050) = (FM_DIGITAL_REG(0x4000a050) & ~0x18000) |
-
+  // 0x18000;
-
-
 
 #ifdef ATAN2_HARDWARE
 
-
   FM_DIGITAL_REG(0xd0330038) |= (1 << 11);
   FM_DIGITAL_REG(0xd0330038) |= (1 << 17);
   FM_DIGITAL_REG(0xd0350248) = 0x80c00000;
   //    FM_DIGITAL_REG(0x40160030) = 1;
   //   FM_DIGITAL_REG(0x40160000) = 0x21;
 
-
 #else
 
-
-
   FM_DIGITAL_REG(0xd0330038) |= (1 << 11);
   FM_DIGITAL_REG(0xd0350248) = 0x80c00000;
   //    FM_DIGITAL_REG(0x40160030) = 1;
@@ -143,8 +144,6 @@ void fm_radio_digit_init(void)
 
 #endif
 
-
-
 #ifdef SINGLECHANLE
   // 0x4000a010  bit2 写0   单channel dac
   FM_DIGITAL_REG(0x4000a010) = (1 << 5) | (1 << 4);
@@ -153,8 +152,6 @@ void fm_radio_digit_init(void)
   FM_DIGITAL_REG(0x4000a010) = (1 << 5) | (1 << 2) | (1 << 4);
 #endif
 
-
-
   FM_DIGITAL_REG(0x4000a020) = ~0UL;
   FM_DIGITAL_REG(0x4000a02c) = 4;
   FM_DIGITAL_REG(0x4000a030) = 4;
@@ -193,23 +190,24 @@ void fm_radio_digit_init(void)
   //    FM_DIGITAL_REG(0x40010014) = 0x03a80005;
   // FM_DIGITAL_REG(0x40010018) = 0x00200019;
   FM_DIGITAL_REG(0x4000a050) = 0x24200000; // for adc_div_3_6 bypass
-    FM_DIGITAL_REG(0x4000a050) = (FM_DIGITAL_REG(0x4000a050) & ~0x780) | 0x380; // for channel 1 adc volume, bit10~7
+  FM_DIGITAL_REG(0x4000a050) = (FM_DIGITAL_REG(0x4000a050) & ~0x780) |
-    FM_DIGITAL_REG(0x4000a050) = (FM_DIGITAL_REG(0x4000a050) & ~0x18000) | 0x18000; // for dual channel adc/dac
+                               0x380; // for channel 1 adc volume, bit10~7
+  FM_DIGITAL_REG(0x4000a050) = (FM_DIGITAL_REG(0x4000a050) & ~0x18000) |
+                               0x18000; // for dual channel adc/dac
 
 #ifdef SINGLECHANLE
   // 0x4000a050  bit16  写0   单channel dac for codec
   FM_DIGITAL_REG(0x4000a050) = (FM_DIGITAL_REG(0x4000a050) & ~(1 << 16));
 #endif
 
-
+  FM_DIGITAL_REG(0x4000a048) = (FM_DIGITAL_REG(0x4000a048) & ~0x00000f00) |
-    FM_DIGITAL_REG(0x4000a048) = (FM_DIGITAL_REG(0x4000a048) & ~0x00000f00) | 0x40000900; //set for sdm gain
+                               0x40000900; // set for sdm gain
-    FM_DIGITAL_REG(0x4000a044) = (FM_DIGITAL_REG(0x4000a044) & ~0x60000000) | 0x60000000; //for adc en, and dac en
+  FM_DIGITAL_REG(0x4000a044) = (FM_DIGITAL_REG(0x4000a044) & ~0x60000000) |
+                               0x60000000; // for adc en, and dac en
 
   // Start DAC
   FM_DIGITAL_REG(0x4000a010) |= (1 << 1);
 
-
-
   // Delay 2 ms
   //    for (volatile int kk = 0; kk < 1000/64; kk++);
   osDelay(2);
@@ -218,10 +216,8 @@ void fm_radio_digit_init(void)
   // Start ADC
   // FM_DIGITAL_REG(0x4000a010) |= (1 << 0);
 
-
 #ifdef ATAN2_HARDWARE
 
-
 #ifdef FM_NEWMODE
   FM_DIGITAL_REG(0x40160030) = 1;
   FM_DIGITAL_REG(0x40160000) = 0x1;
@@ -239,11 +235,9 @@ void fm_radio_digit_init(void)
 #endif
 }
 
-int fm_radio_analog_init(void)
+int fm_radio_analog_init(void) {
-{
   int ret;
 
-
   /*
 
   // fm initial
@@ -251,31 +245,30 @@ int fm_radio_analog_init(void)
   rfspi_wvalue( 8'h01 , 16'b1010_1101_1111_1111 ) ; // power on fm lna
   rfspi_wvalue( 8'h02 , 16'b1000_0000_1001_0100 ) ; // reg_fm_lna_pu_mixersw
 
-    rfspi_wvalue( 8'h1a , 16'b0101_0000_1011_0000 ) ; // reg_bt_vco_fm_buff_vctrl_dr=1
+  rfspi_wvalue( 8'h1a , 16'b0101_0000_1011_0000 ) ; //
+  reg_bt_vco_fm_buff_vctrl_dr=1
 
   rfspi_wvalue( 8'h18 , 16'b0000_0110_1000_0000 ) ; // power on vco
 
   rfspi_wvalue( 8'h19 , 16'b0110_0100_0100_0000 ) ; // reg_bt_vco_fm_buff_vctrl
   rfspi_wvalue( 8'h1d , 16'b0111_1000_1010_0100 ) ; // reg_bt_rfpll_pu_dr
-    rfspi_wvalue( 8'h1c , 16'b0000_0000_1100_1000 ) ; // reg_bt_vco_fm_lo_en reg_bt_vco_fm_div_ctrl=8
+  rfspi_wvalue( 8'h1c , 16'b0000_0000_1100_1000 ) ; // reg_bt_vco_fm_lo_en
+  reg_bt_vco_fm_div_ctrl=8
 
   rfspi_wvalue( 8'h0a , 16'b0001_0010_0010_1111 ) ; // reg_btfm_flt_fm_en
 
-    rfspi_wvalue( 8'h2d , 16'b0000_0111_1000_0010 ) ; // bb ldo on reg_bb_ldo_pu_vddr15a_dr
+  rfspi_wvalue( 8'h2d , 16'b0000_0111_1000_0010 ) ; // bb ldo on
-    rfspi_wvalue( 8'h07 , 16'b0000_0010_1011_1001 ) ; // reg_btfm_flt_pu_dr
+  reg_bb_ldo_pu_vddr15a_dr rfspi_wvalue( 8'h07 , 16'b0000_0010_1011_1001 ) ; //
+  reg_btfm_flt_pu_dr
 
   rfspi_wvalue( 8'h2a , 16'b0001_0110_1100_0000 ) ; // reg_bt_rfpll_sdm_freq_dr
-    rfspi_wvalue( 8'h26 , 16'b0000_0000_0000_0000 ) ; // vco freq[31:16] ( 2400 + x )*2^25/26MHZ*N (2400+x= frf)
+  rfspi_wvalue( 8'h26 , 16'b0000_0000_0000_0000 ) ; // vco freq[31:16] ( 2400 +
-    rfspi_wvalue( 8'h25 , 16'b0000_0000_0000_0000 ) ; // vco freq[15:00] fm_freq = frf/(4*reg_bt_vco_fm_div_ctrl)
+  x )*2^25/26MHZ*N (2400+x= frf) rfspi_wvalue( 8'h25 , 16'b0000_0000_0000_0000 )
-    rfspi_wvalue( 8'h17 , 16'b1000_0000_0000_0000 ) ; // reg_bt_vco_calen
+  ; // vco freq[15:00] fm_freq = frf/(4*reg_bt_vco_fm_div_ctrl) rfspi_wvalue(
+  8'h17 , 16'b1000_0000_0000_0000 ) ; // reg_bt_vco_calen
 
   */
 
-
-
-
-
-
   fm_write_rf_reg(0x2c, 0b0111000001011100); // dig_vtoi_en
   fm_write_rf_reg(0x01, 0b1010110111111111); // power on fm lna
   fm_write_rf_reg(0x02, 0b1000000010010100); // reg_fm_lna_pu_mixersw
@@ -286,30 +279,25 @@ int fm_radio_analog_init(void)
 
   fm_write_rf_reg(0x19, 0b0110010001000000); // reg_bt_vco_fm_buff_vctrl
   fm_write_rf_reg(0x1d, 0b0111100010100100); // reg_bt_rfpll_pu_dr
-    fm_write_rf_reg( 0x1c , 0b0000000011001000 ) ; // reg_bt_vco_fm_lo_en reg_bt_vco_fm_div_ctrl=8
+  fm_write_rf_reg(
+      0x1c, 0b0000000011001000); // reg_bt_vco_fm_lo_en reg_bt_vco_fm_div_ctrl=8
 
   fm_write_rf_reg(0x0a, 0b0001001000101111); // reg_btfm_flt_fm_en
 
-    fm_write_rf_reg( 0x2d , 0b0000011110000010 ) ; // bb ldo on reg_bb_ldo_pu_vddr15a_dr
+  fm_write_rf_reg(0x2d,
+                  0b0000011110000010); // bb ldo on reg_bb_ldo_pu_vddr15a_dr
   fm_write_rf_reg(0x07, 0b0000001010111001); // reg_btfm_flt_pu_dr
 
   fm_write_rf_reg(0x2a, 0b0001011011000000); // reg_bt_rfpll_sdm_freq_dr
-    fm_write_rf_reg( 0x26 , 0b0000000000000000 ) ; // vco freq[31:16] ( 2400 + x )*2^25/26MHZ*N (2400+x= frf)
+  fm_write_rf_reg(0x26, 0b0000000000000000); // vco freq[31:16] ( 2400 + x
-    fm_write_rf_reg( 0x25 , 0b0000000000000000 ) ; // vco freq[15:00] fm_freq = frf/(4*reg_bt_vco_fm_div_ctrl)
+                                             // )*2^25/26MHZ*N (2400+x= frf)
+  fm_write_rf_reg(0x25, 0b0000000000000000); // vco freq[15:00] fm_freq =
+                                             // frf/(4*reg_bt_vco_fm_div_ctrl)
   fm_write_rf_reg(0x17, 0b1000000000000000); // reg_bt_vco_calen
 
-
-
-
-
-
-
   // adc也要开的话，需要配 cmu
   // 0x40000060[29] = 1  最好先读再写，否则把别的bit冲掉了。
 
-
-
-
   //需要配置的spi寄存器：ana interface:
 
   // 0x05 = 0xFCB1 // Audio Pll
@@ -318,7 +306,6 @@ int fm_radio_analog_init(void)
   // 0x37 = 0x1000 // codec_bbpll1_fm_adc_clk_en
   // 0x31 = 0x0130 // codec_tx_en_ldac codec_tx_en_rdac
 
-
   ret = fm_write_rf_reg(0x05, 0xfcb1);
   if (ret) {
     return ret;
@@ -345,11 +332,9 @@ int fm_radio_analog_init(void)
     return ret;
   }
 
-
   // delay 32ms
   osDelay(32);
 
-
   ret = fm_write_rf_reg(0x31, 0x0130);
   if (ret) {
     return ret;
@@ -397,16 +382,13 @@ void  fm_radio_poweron(void)
   pmu_fm_config(1);
 
   fm_write_rf_reg(0x0c, 0x3584);
-        if(hal_get_chip_metal_id() == HAL_CHIP_METAL_ID_2 || hal_get_chip_metal_id() == HAL_CHIP_METAL_ID_3) ////
+  if (hal_get_chip_metal_id() == HAL_CHIP_METAL_ID_2 ||
+      hal_get_chip_metal_id() == HAL_CHIP_METAL_ID_3) ////
   {
     FM_DIGITAL_REG(0xc00003b4) = 0x00060020; // turn off bt sleep
-        }
+  } else if (hal_get_chip_metal_id() == HAL_CHIP_METAL_ID_4) {
-        else if(hal_get_chip_metal_id() == HAL_CHIP_METAL_ID_4)
-        {
     FM_DIGITAL_REG(0xc00003b0) = 0x00060020; // turn off bt sleep
-        }
+  } else {
-        else
-        {
     FM_DIGITAL_REG(0xc00003ac) = 0x00060020; // turn off bt sleep
   }
   FM_DIGITAL_REG(0xd0330038) = 0x00008D0D;
@@ -414,16 +396,14 @@ void  fm_radio_poweron(void)
                                            // fm_write_rf_reg(0x02, 0xe694);
 }
 
-void* fm_radio_get_ext_buff(int size)
+void *fm_radio_get_ext_buff(int size) {
-{
   uint8_t *pBuff = NULL;
   size = size + size % 4;
   app_audio_mempool_get_buff(&pBuff, size);
   return (void *)pBuff;
 }
 
-int fm_radio_player(bool on)
+int fm_radio_player(bool on) {
-{
   static struct AF_STREAM_CONFIG_T stream_cfg;
   static bool isRun = false;
   uint8_t *buff = NULL;
@@ -441,7 +421,8 @@ int fm_radio_player(bool on)
     osDelay(200);
     buff = (uint8_t *)fm_radio_get_ext_buff(FM_AUDIO_BUFFER_SIZE * 2);
     app_audio_pcmbuff_init(buff, FM_AUDIO_BUFFER_SIZE * 2);
-        fm_sample_buffer_p = (int32_t *)fm_radio_get_ext_buff(FM_SAMPLE_BUFFER_SIZE);
+    fm_sample_buffer_p =
+        (int32_t *)fm_radio_get_ext_buff(FM_SAMPLE_BUFFER_SIZE);
 #if FPGA == 0
     app_overlay_select(APP_OVERLAY_FM);
 #endif
@@ -484,12 +465,10 @@ int fm_radio_player(bool on)
   return 0;
 }
 
-int fm_tune(uint32_t freqkhz)
+int fm_tune(uint32_t freqkhz) {
-{
   uint32_t reg;
   unsigned long long tmp = 0;
 
-
   //[rfpll_cal]
   fm_write_rf_reg(0x21, 0x3979); // ref sel 52MHz
   fm_write_rf_reg(0x22, 0x7A22); // doubler setting
@@ -512,18 +491,15 @@ int fm_tune(uint32_t freqkhz)
 
   osDelay(20);
 
-
   fm_write_rf_reg(0x1d, 0x7ac4); // close pll loop
 
   return 0;
 }
 
-void fm_test_main(void)
+void fm_test_main(void) {
-{
   fm_radio_player(true);
   osDelay(20);
   fm_tune(90500);
 }
 
 #endif
-

apps/audioplayers/msbcplay.cpp

@@ -14,20 +14,19 @@
  *
  ****************************************************************************/
 // Standard C Included Files
-#include <string.h>
-#include <math.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include "cmsis_os.h"
 #include "cqueue.h"
-#include "hal_uart.h"
 #include "hal_timer.h"
 #include "hal_trace.h"
+#include "hal_uart.h"
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 // BT
 
-
 #if 0
 /* mutex */
 osMutexId g_voicemsbc_queue_mutex_id;
@@ -43,8 +42,7 @@ static uint32_t ok_to_decode = 0;
 #define LOCK_VOICEMSBC_QUEUE()                                                 \
   osMutexWait(g_voicemsbc_queue_mutex_id, osWaitForever)
 
-#define UNLOCK_VOICEMSBC_QUEUE() \
+#define UNLOCK_VOICEMSBC_QUEUE() osMutexRelease(g_voicemsbc_queue_mutex_id)
-	osMutexRelease(g_voicemsbc_queue_mutex_id)
 
 static void dump_buffer_to_psram(char *buf, unsigned int len)
 {

apps/audioplayers/plc_utils.c

@@ -1,9 +1,10 @@
-#include <stdbool.h>
-#include <string.h>
 #include "plc_utils.h"
 #include "hal_trace.h"
+#include <stdbool.h>
+#include <string.h>
 
-#if defined(CHIP_BEST1400) || defined(CHIP_BEST1402) || defined(CHIP_BEST2300P) || defined(CHIP_BEST2300A)
+#if defined(CHIP_BEST1400) || defined(CHIP_BEST1402) ||                        \
+    defined(CHIP_BEST2300P) || defined(CHIP_BEST2300A)
 #define MSBC_MUTE_PATTERN (0x55)
 #else
 #define MSBC_MUTE_PATTERN (0x00)
@@ -19,9 +20,8 @@
 //#define ENABLE_PAD_CHECK
 
 /*
- * if msbc frame is filled by 10+ samples in the trail, crc maybe not detect this
+ * if msbc frame is filled by 10+ samples in the trail, crc maybe not detect
- * satuation.
+ * this satuation. Do not check this by default
- * Do not check this by default
  */
 //#define ENABLE_TRAILING_ZERO_CHECK
 
@@ -58,12 +58,10 @@ static const uint8_t sbc_crc_tbl[256] = {
     0x10, 0x0D, 0x2A, 0x37, 0x64, 0x79, 0x5E, 0x43, 0xB2, 0xAF, 0x88, 0x95,
     0xC6, 0xDB, 0xFC, 0xE1, 0x5A, 0x47, 0x60, 0x7D, 0x2E, 0x33, 0x14, 0x09,
     0x7F, 0x62, 0x45, 0x58, 0x0B, 0x16, 0x31, 0x2C, 0x97, 0x8A, 0xAD, 0xB0,
-    0xE3, 0xFE, 0xD9, 0xC4
+    0xE3, 0xFE, 0xD9, 0xC4};
-};
 #endif
 
-static int sco_parse_synchronization_header(uint8_t *buf, uint8_t *sn)
+static int sco_parse_synchronization_header(uint8_t *buf, uint8_t *sn) {
-{
   uint8_t sn1, sn2;
 #ifdef ENABLE_CRC_CHECK
   uint8_t fcs = 0x0F;
@@ -73,15 +71,12 @@ static int sco_parse_synchronization_header(uint8_t *buf, uint8_t *sn)
 #endif
   *sn = 0xff;
 #if defined(MSBC_SYNC_HACKER)
-    if (((buf[0] != 0x01) && (buf[0] != 0x00)) ||
+  if (((buf[0] != 0x01) && (buf[0] != 0x00)) || ((buf[1] & 0x0f) != 0x08) ||
-        ((buf[1] & 0x0f) != 0x08) ||
       (buf[2] != 0xad)) {
     return -1;
   }
 #else
-    if ((buf[0] != 0x01) ||
+  if ((buf[0] != 0x01) || ((buf[1] & 0x0f) != 0x08) || (buf[2] != 0xad)) {
-        ((buf[1] & 0x0f) != 0x08) ||
-        (buf[2] != 0xad)) {
     return -1;
   }
 #endif
@@ -108,8 +103,7 @@ static int sco_parse_synchronization_header(uint8_t *buf, uint8_t *sn)
       /* Sum the whole byte */
       fcs = sbc_crc_tbl[fcs ^ buf[ind]];
       ind = ind + 1;
-        }
+    } else {
-        else {
       if (sb == 7) {
         /* Sum the next 4 bits */
 
@@ -119,8 +113,7 @@ static int sco_parse_synchronization_header(uint8_t *buf, uint8_t *sn)
           bit = (uint8_t)((0x01 & (buf[ind] >> shift--)) ^ (fcs >> 7));
           if (bit) {
             fcs = (uint8_t)(((fcs << 1) | bit) ^ 0x1C);
-                    }
+          } else {
-                    else {
             fcs = (uint8_t)((fcs << 1));
           }
         }
@@ -147,8 +140,7 @@ static int sco_parse_synchronization_header(uint8_t *buf, uint8_t *sn)
 }
 
 #ifdef ENABLE_BLE_CONFLICT_CHECK
-static bool memcmp_U8(uint8_t *x, uint8_t *y, uint16_t size)
+static bool memcmp_U8(uint8_t *x, uint8_t *y, uint16_t size) {
-{
   for (int i = 0; i < size; i++) {
     if (x[i] != y[i])
       return true;
@@ -157,12 +149,13 @@ static bool memcmp_U8(uint8_t *x, uint8_t *y, uint16_t size)
   return false;
 }
 
-// when signal is mute, msbc data remains the same except seq num. We should check history flag,
+// when signal is mute, msbc data remains the same except seq num. We should
-// otherwise a single conflict may be detected twice
+// check history flag, otherwise a single conflict may be detected twice
-static bool update_ble_sco_conflict(PacketLossState* st, uint8_t *last_pkt, uint8_t *pkt)
+static bool update_ble_sco_conflict(PacketLossState *st, uint8_t *last_pkt,
-{
+                                    uint8_t *pkt) {
   // do not check padding byte as it maybe useless when msbc_offset is 1
-    bool ret = (st->prev_ble_sco_conflict_flag[1] == false && memcmp_U8(last_pkt, pkt, MSBC_PKTSIZE - 1) == false);
+  bool ret = (st->prev_ble_sco_conflict_flag[1] == false &&
+              memcmp_U8(last_pkt, pkt, MSBC_PKTSIZE - 1) == false);
 
   memcpy(&last_pkt[0], &last_pkt[MSBC_PKTSIZE], MSBC_PKTSIZE);
   memcpy(&last_pkt[MSBC_PKTSIZE], pkt, MSBC_PKTSIZE);
@@ -170,8 +163,7 @@ static bool update_ble_sco_conflict(PacketLossState* st, uint8_t *last_pkt, uint
   return ret;
 }
 
-static bool check_ble_sco_conflict(PacketLossState* st, bool ret)
+static bool check_ble_sco_conflict(PacketLossState *st, bool ret) {
-{
   st->prev_ble_sco_conflict_flag[1] = st->prev_ble_sco_conflict_flag[0];
   st->prev_ble_sco_conflict_flag[0] = ret;
 
@@ -179,8 +171,7 @@ static bool check_ble_sco_conflict(PacketLossState* st, bool ret)
 }
 #endif
 
-static bool msbc_check_controller_mute_pattern(uint8_t *pkt, uint8_t pattern)
+static bool msbc_check_controller_mute_pattern(uint8_t *pkt, uint8_t pattern) {
-{
   // do not check padding byte as it maybe useless when msbc_offset is 1
   for (int i = 0; i < MSBC_PKTSIZE - 1; i++)
     if (pkt[i] != pattern)
@@ -190,8 +181,7 @@ static bool msbc_check_controller_mute_pattern(uint8_t *pkt, uint8_t pattern)
 }
 
 #ifdef ENABLE_TRAILING_ZERO_CHECK
-static int msbc_check_pkt_trailing_zeros(uint8_t *pkt)
+static int msbc_check_pkt_trailing_zeros(uint8_t *pkt) {
-{
   int idx = MSBC_PKTSIZE;
 
   for (int i = MSBC_PKTSIZE - 1; i >= 0; i--) {
@@ -205,22 +195,21 @@ static int msbc_check_pkt_trailing_zeros(uint8_t *pkt)
 }
 #endif
 
-static uint8_t get_next_sequence_num(uint8_t seq_num)
+static uint8_t get_next_sequence_num(uint8_t seq_num) {
-{
   return (seq_num + 1 == 4) ? 0 : (seq_num + 1);
 }
 
-void packet_loss_detection_init(PacketLossState *st)
+void packet_loss_detection_init(PacketLossState *st) {
-{
   st->last_seq_num = 0xff;
 
   memset(st->last_pkt, 0, sizeof(st->last_pkt));
-    memset(st->prev_ble_sco_conflict_flag, 0, sizeof(st->prev_ble_sco_conflict_flag));
+  memset(st->prev_ble_sco_conflict_flag, 0,
+         sizeof(st->prev_ble_sco_conflict_flag));
   memset(st->hist, 0, sizeof(st->hist));
 }
 
-plc_type_t packet_loss_detection_process(PacketLossState *st, uint8_t *sbc_buf)
+plc_type_t packet_loss_detection_process(PacketLossState *st,
-{
+                                         uint8_t *sbc_buf) {
   plc_type_t plc_type = PLC_TYPE_PASS;
 
 #ifdef ENABLE_BLE_CONFLICT_CHECK
@@ -267,22 +256,18 @@ plc_type_t packet_loss_detection_process(PacketLossState *st, uint8_t *sbc_buf)
       if (st->last_seq_num == 0xff) {
         if (seq_num == 0xff) {
           plc_type = PLC_TYPE_SEQUENCE_DISCONTINUE;
-                }
+        } else {
-                else {
           plc_type = PLC_TYPE_PASS;
         }
         st->last_seq_num = seq_num;
-            }
+      } else {
-            else {
         if (seq_num == 0xff) {
           st->last_seq_num = 0xff;
           plc_type = PLC_TYPE_SEQUENCE_DISCONTINUE;
-                }
+        } else if (seq_num == get_next_sequence_num(st->last_seq_num)) {
-                else if (seq_num == get_next_sequence_num(st->last_seq_num)) {
           st->last_seq_num = seq_num;
           plc_type = PLC_TYPE_PASS;
-                }
+        } else {
-                else {
           st->last_seq_num = 0xff;
           plc_type = PLC_TYPE_SEQUENCE_DISCONTINUE;
         }
@@ -298,8 +283,8 @@ plc_type_t packet_loss_detection_process(PacketLossState *st, uint8_t *sbc_buf)
   return plc_type;
 }
 
-void packet_loss_detection_update_histogram(PacketLossState *st, plc_type_t plc_type)
+void packet_loss_detection_update_histogram(PacketLossState *st,
-{
+                                            plc_type_t plc_type) {
   if (plc_type < 0 || plc_type >= PLC_TYPE_NUM) {
     TRACE(2, "[%s] plc type %d is invalid", __FUNCTION__, plc_type);
     return;
@@ -313,8 +298,7 @@ void packet_loss_detection_update_histogram(PacketLossState *st, plc_type_t plc_
   st->hist[plc_type] += 1;
 }
 
-void packet_loss_detection_report(PacketLossState *st)
+void packet_loss_detection_report(PacketLossState *st) {
-{
   uint32_t packet_loss_num = 0;
 
   for (uint8_t i = 1; i < PLC_TYPE_NUM; i++) {
@@ -324,5 +308,6 @@ void packet_loss_detection_report(PacketLossState *st)
 
   uint32_t packet_total_num = st->hist[0] + packet_loss_num;
   TRACE(4, "[%s] packet loss percent %d/10000(%d/%d)", __FUNCTION__,
-          (int32_t)(10000.f * packet_loss_num/ packet_total_num), packet_loss_num, packet_total_num);
+        (int32_t)(10000.f * packet_loss_num / packet_total_num),
+        packet_loss_num, packet_total_num);
 }

apps/audioplayers/rbplay/rb_ctl.cpp

@@ -20,44 +20,44 @@
 #include "mbed.h"
 #include "rtos.h"
 #endif
-#include <string.h>
-#include <math.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <unistd.h>
 #include "SDFileSystem.h"
-#include "hal_uart.h"
+#include "app_audio.h"
-#include "hal_timer.h"
-#include "hal_trace.h"
 #include "audioflinger.h"
 #include "cqueue.h"
-#include "app_audio.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
+#include "hal_uart.h"
+#include <ctype.h>
+#include <fcntl.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
-#include "eq.h"
-#include "pga.h"
-#include "metadata.h"
-#include "dsp_core.h"
-#include "codecs.h"
-#include "codeclib.h"
-#include "compressor.h"
-#include "channel_mode.h"
 #include "audiohw.h"
+#include "channel_mode.h"
 #include "codec_platform.h"
+#include "codeclib.h"
+#include "codecs.h"
+#include "compressor.h"
+#include "dsp_core.h"
+#include "eq.h"
+#include "metadata.h"
 #include "metadata_parsers.h"
+#include "pga.h"
 
-#include "hal_overlay.h"
+#include "app_key.h"
 #include "app_overlay.h"
-#include "rbpcmbuf.h"
-#include "rbplay.h"
 #include "app_thread.h"
 #include "app_utils.h"
-#include "app_key.h"
+#include "hal_overlay.h"
+#include "rbpcmbuf.h"
+#include "rbplay.h"
 
-#include "rbplaysd.h"
 #include "rb_ctl.h"
+#include "rbplaysd.h"
 
 /* Internals */
 
@@ -75,10 +75,18 @@ extern "C" void hal_sysfreq_print(void);
 #define RBPLAY_DEBUG 1
 #if RBPLAY_DEBUG
 #define _LOG_DBG(str, ...) TRACE(0, _LOG_TAG "" str, ##__VA_ARGS__)
-#define _LOG_ERR(str,...) TRACE(0,_LOG_TAG"err:"""str, ##__VA_ARGS__)
+#define _LOG_ERR(str, ...)                                                     \
+  TRACE(0,                                                                     \
+        _LOG_TAG "err:"                                                        \
+                 "" str,                                                       \
+        ##__VA_ARGS__)
 #else
 #define _LOG_DBG(str, ...)
-#define _LOG_ERR(str,...) TRACE(0,_LOG_TAG"err:"""str, ##__VA_ARGS__)
+#define _LOG_ERR(str, ...)                                                     \
+  TRACE(0,                                                                     \
+        _LOG_TAG "err:"                                                        \
+                 "" str,                                                       \
+        ##__VA_ARGS__)
 #endif
 
 #include "rb_ctl.h"
@@ -103,7 +111,6 @@ int rb_ctl_mailbox_put(RBCTL_MSG_BLOCK* msg_src);
 // playlist
 extern playlist_struct sd_playlist;
 
-
 rb_ctl_struct rb_ctl_context;
 
 extern void rb_thread_set_decode_vars(int fd, int type, void *id3);
@@ -115,13 +122,9 @@ extern  bool rb_pcmbuf_suspend_play_loop(void);
 void app_rbplay_load_playlist(playlist_struct *list);
 int rb_thread_post_msg(RB_MODULE_EVT evt, uint32_t arg);
 
-static rb_ctl_status rb_ctl_get_status(void)
+static rb_ctl_status rb_ctl_get_status(void) { return rb_ctl_context.status; }
-{
-	return rb_ctl_context.status;
-}
 
-bool rb_ctl_parse_file(const char* file_path)
+bool rb_ctl_parse_file(const char *file_path) {
-{
   /* open file */
 
   _LOG_DBG(1, "open file  %s\n", file_path);
@@ -131,21 +134,25 @@ bool rb_ctl_parse_file(const char* file_path)
     return false;
   }
 
-    if (!get_metadata(&rb_ctl_context.song_id3, rb_ctl_context.file_handle, rb_ctl_context.rb_fname)) {
+  if (!get_metadata(&rb_ctl_context.song_id3, rb_ctl_context.file_handle,
+                    rb_ctl_context.rb_fname)) {
     _LOG_DBG(0, "get_metadata failed\n");
     close(rb_ctl_context.file_handle);
     return false;
   }
 
-    _LOG_DBG(4,"%s bitr:%d,saps %d, freq:%d\n",__func__,rb_ctl_context.song_id3.bitrate,rb_ctl_context.song_id3.samples,rb_ctl_context.song_id3.frequency);
+  _LOG_DBG(4, "%s bitr:%d,saps %d, freq:%d\n", __func__,
+           rb_ctl_context.song_id3.bitrate, rb_ctl_context.song_id3.samples,
+           rb_ctl_context.song_id3.frequency);
 
-    rb_thread_set_decode_vars(rb_ctl_context.file_handle, rb_ctl_context.song_id3.codectype,&rb_ctl_context.song_id3);
+  rb_thread_set_decode_vars(rb_ctl_context.file_handle,
+                            rb_ctl_context.song_id3.codectype,
+                            &rb_ctl_context.song_id3);
 
   return true;
 }
 
-void rb_ctl_vol_operation(bool inc )
+void rb_ctl_vol_operation(bool inc) {
-{
   uint32_t ret;
   struct AF_STREAM_CONFIG_T *stream_cfg = NULL;
 
@@ -154,7 +161,6 @@ void rb_ctl_vol_operation(bool inc )
   if (inc) {
     if (rb_ctl_context.rb_player_vol < 16) {
       rb_ctl_context.rb_player_vol++;
-
     }
   } else {
     if (rb_ctl_context.rb_player_vol > 1) {
@@ -164,20 +170,19 @@ void rb_ctl_vol_operation(bool inc )
   if (rb_ctl_context.status != RB_CTL_PLAYING)
     return;
 
-    ret = af_stream_get_cfg(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg, true);
+  ret = af_stream_get_cfg(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg,
+                          true);
   if (ret == 0) {
     stream_cfg->vol = rb_ctl_context.rb_player_vol;
     af_stream_setup(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, stream_cfg);
   }
 }
 
-bool rb_ctl_is_playing(void)
+bool rb_ctl_is_playing(void) {
-{
   return (rb_ctl_context.status == RB_CTL_PLAYING);
 }
 
-void rb_ctl_set_vol(uint32_t vol)
+void rb_ctl_set_vol(uint32_t vol) {
-{
   uint32_t ret;
   struct AF_STREAM_CONFIG_T *stream_cfg = NULL;
 
@@ -189,15 +194,15 @@ void rb_ctl_set_vol(uint32_t vol)
   vol = (vol > 16) ? 16 : vol;
   rb_ctl_context.rb_player_vol = vol;
 
-    ret = af_stream_get_cfg(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg, true);
+  ret = af_stream_get_cfg(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg,
+                          true);
   if (ret == 0) {
     stream_cfg->vol = rb_ctl_context.rb_player_vol;
     af_stream_setup(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, stream_cfg);
   }
 }
 
-void rb_ctl_stop_play(void )
+void rb_ctl_stop_play(void) {
-{
   _LOG_DBG(1, "%s  \n", __func__);
 
   rb_codec_set_halt(1);
@@ -216,8 +221,7 @@ void rb_ctl_stop_play(void )
   return;
 }
 
-void rb_ctl_sync_stop_play(void )
+void rb_ctl_sync_stop_play(void) {
-{
   rb_player_sync_set_wait_thread(osThreadGetId());
 
   rb_ctl_stop_play();
@@ -230,8 +234,7 @@ void rb_ctl_sync_stop_play(void )
   rb_ctl_context.file_handle = -1;
 }
 
-void rb_ctl_pause_playing(void )
+void rb_ctl_pause_playing(void) {
-{
   af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
   _LOG_DBG(0, " af   stream close \n");
   af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
@@ -245,70 +248,65 @@ void rb_ctl_pause_playing(void )
   _LOG_DBG(1, "%s sucessed ", __func__);
 }
 
-void rb_ctl_resume_playing(void )
+void rb_ctl_resume_playing(void) {
-{
 #ifndef __TWS__
   rb_pcmbuf_init();
 #endif
 }
 
-
+void rb_ctl_set_priority(int priority) {
-void rb_ctl_set_priority(int priority)
-{
   osThreadSetPriority(rb_ctl_tid, (osPriority)priority);
 }
 
-int rb_ctl_get_priority(void)
+int rb_ctl_get_priority(void) { return (int)osThreadGetPriority(rb_ctl_tid); }
-{
-    return (int)osThreadGetPriority(rb_ctl_tid);
-}
 
-int rb_ctl_get_default_priority(void)
+int rb_ctl_get_default_priority(void) { return rb_ctl_default_priority; }
-{
-    return rb_ctl_default_priority;
-}
 
-void rb_ctl_reset_priority(void)
+void rb_ctl_reset_priority(void) {
-{
   osThreadSetPriority(rb_ctl_tid, (osPriority)rb_ctl_default_priority);
 }
 
 #ifdef __IAG_BLE_INCLUDE__
 extern "C" void app_ble_inform_music_switch(uint16_t index);
 #endif
-static int rb_ctl_handle_event(RBCTL_MSG_BLOCK *msg_body)
+static int rb_ctl_handle_event(RBCTL_MSG_BLOCK *msg_body) {
-{
   RB_MODULE_EVT evt = (RB_MODULE_EVT)msg_body->evt;
   uint32_t arg = msg_body->arg;
   //    hal_sysfreq_print();
 
-
   switch (evt) {
   case RB_MODULE_EVT_PLAY:
     if (rb_ctl_context.status != RB_CTL_IDLE) {
       if (rb_ctl_context.status == RB_CTL_SUSPEND)
         rb_thread_send_resume();
       else
-                    _LOG_DBG(2,"%s  st  %d not in idle \n",__func__,rb_ctl_context.status);
+        _LOG_DBG(2, "%s  st  %d not in idle \n", __func__,
+                 rb_ctl_context.status);
       break;
     }
-			_LOG_DBG(3," %s start %d/%d ",__func__, rb_ctl_context.curr_song_idx ,sd_playlist.total_songs);
+    _LOG_DBG(3, " %s start %d/%d ", __func__, rb_ctl_context.curr_song_idx,
+             sd_playlist.total_songs);
     if (sd_playlist.total_songs > 0) {
       playlist_item *it;
 
       it = app_rbplay_get_playitem(rb_ctl_context.curr_song_idx);
 
       if (it == NULL) {
-                    _LOG_DBG(2," %s get item fail idx %d",__func__,rb_ctl_context.curr_song_idx);
+        _LOG_DBG(2, " %s get item fail idx %d", __func__,
+                 rb_ctl_context.curr_song_idx);
       }
 
-                _LOG_DBG(2,"%s  start songidx %d \n",__func__,rb_ctl_context.curr_song_idx);
+      _LOG_DBG(2, "%s  start songidx %d \n", __func__,
+               rb_ctl_context.curr_song_idx);
 
-                memcpy(rb_ctl_context.rb_audio_file,it->file_path,sizeof(uint16_t)*FILE_PATH_LEN - 4);
+      memcpy(rb_ctl_context.rb_audio_file, it->file_path,
-                memcpy(rb_ctl_context.rb_fname,it->file_name,sizeof(rb_ctl_context.rb_fname));
+             sizeof(uint16_t) * FILE_PATH_LEN - 4);
+      memcpy(rb_ctl_context.rb_fname, it->file_name,
+             sizeof(rb_ctl_context.rb_fname));
 
       if (rb_ctl_parse_file((const char *)rb_ctl_context.rb_audio_file)) {
-                    _LOG_DBG(2,"%s  start init, the tid 0x%x\n",__func__,osThreadGetId());
+        _LOG_DBG(2, "%s  start init, the tid 0x%x\n", __func__,
+                 osThreadGetId());
         rb_play_codec_init();
         _LOG_DBG(1, "%s  start run\n", __func__);
         rb_play_codec_run();
@@ -316,7 +314,8 @@ static int rb_ctl_handle_event(RBCTL_MSG_BLOCK *msg_body)
         app_rbcodec_ctl_set_play_status(true);
         break;
       } else {
-                    _LOG_DBG(2,"%s  evt  %d parse fail,find next\n",__func__,msg_body->evt);
+        _LOG_DBG(2, "%s  evt  %d parse fail,find next\n", __func__,
+                 msg_body->evt);
         rb_thread_post_msg(RB_MODULE_EVT_PLAY_NEXT, true);
       }
 
@@ -360,7 +359,6 @@ static int rb_ctl_handle_event(RBCTL_MSG_BLOCK *msg_body)
     } else if (rb_ctl_context.status == RB_CTL_SUSPEND) {
       rb_thread_post_msg(RB_MODULE_EVT_STOP, 0);
     } else {
-
     }
     if (arg == 0) {
       rb_ctl_context.curr_song_idx--;
@@ -401,7 +399,6 @@ static int rb_ctl_handle_event(RBCTL_MSG_BLOCK *msg_body)
     } else if (rb_ctl_context.status == RB_CTL_SUSPEND) {
       rb_thread_post_msg(RB_MODULE_EVT_STOP, 0);
     } else {
-
     }
 
     rb_ctl_context.curr_song_idx = (uint16_t)arg;
@@ -465,41 +462,35 @@ static int rb_ctl_handle_event(RBCTL_MSG_BLOCK *msg_body)
 #endif
 #ifdef SBC_RECORD_TEST
 
-		case SBC_RECORD_ACTION_START:
+  case SBC_RECORD_ACTION_START: {
-		{
     rb_ctl_context.sbc_record_on = true;
     app_rbplay_set_store_flag(true);
     app_rbplay_open_sbc_file();
 
-		}
+  } break;
-		break;
 
-		case SBC_RECORD_ACTION_DATA_IND:
+  case SBC_RECORD_ACTION_DATA_IND: {
-		{
     if (rb_ctl_context.sbc_record_on) {
       app_rbplay_process_sbc_data();
     }
-		}
+  } break;
-		break;
 
-		case SBC_RECORD_ACTION_STOP:
+  case SBC_RECORD_ACTION_STOP: {
-		{
     rb_ctl_context.sbc_record_on = false;
     app_rbplay_set_store_flag(false);
     app_rbplay_close_sbc_file();
-		}
+  } break;
-		break;
 #endif
   default:
     break;
   }
   if (SBC_RECORD_ACTION_DATA_IND != msg_body->evt)
-    _LOG_DBG(3,"%s  rbcodec evt  %d  ,st %d ended\n",__func__,msg_body->evt,rb_ctl_context.status);
+    _LOG_DBG(3, "%s  rbcodec evt  %d  ,st %d ended\n", __func__, msg_body->evt,
+             rb_ctl_context.status);
   return 0;
 }
 
-int rb_thread_post_msg(RB_MODULE_EVT evt,uint32_t arg )
+int rb_thread_post_msg(RB_MODULE_EVT evt, uint32_t arg) {
-{
   int ret;
   RBCTL_MSG_BLOCK msg;
 
@@ -514,14 +505,12 @@ int rb_thread_post_msg(RB_MODULE_EVT evt,uint32_t arg )
   return 0;
 }
 
-void app_wait_player_stoped(void )
+void app_wait_player_stoped(void) {
-{
   while (rb_ctl_context.status != RB_CTL_IDLE)
     osThreadYield();
 }
 
-void app_wait_player_suspend(void )
+void app_wait_player_suspend(void) {
-{
   if (rb_ctl_context.status == RB_CTL_IDLE)
     return;
 
@@ -529,8 +518,7 @@ void app_wait_player_suspend(void )
     osThreadYield();
 }
 
-void app_wait_player_resumed(void )
+void app_wait_player_resumed(void) {
-{
   if (rb_ctl_context.status == RB_CTL_IDLE)
     return;
 
@@ -538,14 +526,12 @@ void app_wait_player_resumed(void )
     osThreadYield();
 }
 
-void rb_thread_send_play(void )
+void rb_thread_send_play(void) {
-{
   _LOG_DBG(1, " %s ", __FUNCTION__);
   rb_thread_post_msg(RB_MODULE_EVT_PLAY, (uint32_t)osThreadGetId());
 }
 
-void rb_thread_send_stop(void )
+void rb_thread_send_stop(void) {
-{
   _LOG_DBG(1, " %s ", __FUNCTION__);
   rb_thread_post_msg(RB_MODULE_EVT_STOP, (uint32_t)osThreadGetId());
 
@@ -553,8 +539,7 @@ void rb_thread_send_stop(void )
   app_wait_player_stoped();
 }
 
-void rb_thread_send_pause(void)
+void rb_thread_send_pause(void) {
-{
   _LOG_DBG(1, " %s ", __FUNCTION__);
 
   rb_thread_post_msg(RB_MODULE_EVT_SUSPEND, (uint32_t)osThreadGetId());
@@ -563,8 +548,7 @@ void rb_thread_send_pause(void)
   _LOG_DBG(1, " %s end", __FUNCTION__);
 }
 
-void rb_thread_send_resume(void)
+void rb_thread_send_resume(void) {
-{
   _LOG_DBG(1, " %s ", __FUNCTION__);
 
   rb_thread_post_msg(RB_MODULE_EVT_RESUME, (uint32_t)osThreadGetId());
@@ -572,16 +556,14 @@ void rb_thread_send_resume(void)
   _LOG_DBG(1, " %s end", __FUNCTION__);
 }
 
-void rb_play_dual_play_restore(uint8_t stream_type )
+void rb_play_dual_play_restore(uint8_t stream_type) {
-{
   _LOG_DBG(2, "%s %d \n", __func__, __LINE__);
 
   rb_thread_post_msg(RB_MODULE_EVT_RESTORE_DUAL_PLAY, stream_type);
   _LOG_DBG(2, "%s %d \n", __func__, __LINE__);
 }
 
-void rb_thread_send_switch(bool next)
+void rb_thread_send_switch(bool next) {
-{
   _LOG_DBG(2, "%s %d \n", __func__, __LINE__);
 
   rb_thread_post_msg(RB_MODULE_EVT_PLAY_NEXT, next);
@@ -589,99 +571,85 @@ void rb_thread_send_switch(bool next)
   _LOG_DBG(2, "%s %d \n", __func__, __LINE__);
 }
 
-void rb_play_linein_start(void )
+void rb_play_linein_start(void) {
-{
   _LOG_DBG(2, "%s %d \n", __func__, __LINE__);
 
   rb_thread_post_msg(RB_MODULE_EVT_LINEIN_START, 0);
   _LOG_DBG(2, "%s %d \n", __func__, __LINE__);
 }
 
-void rb_play_reconfig_stream(uint32_t arg )
+void rb_play_reconfig_stream(uint32_t arg) {
-{
   _LOG_DBG(3, "%s %d arg:0x%x\n", __func__, __LINE__, arg);
 
   rb_thread_post_msg(RB_MODULE_EVT_RECONFIG_STREAM, arg);
   _LOG_DBG(2, "%s %d \n", __func__, __LINE__);
 }
 
-void rb_play_set_tws_mode(uint32_t arg )
+void rb_play_set_tws_mode(uint32_t arg) {
-{
   _LOG_DBG(3, "%s %d arg:0x%x\n", __func__, __LINE__, arg);
 
   rb_thread_post_msg(RB_MODULE_EVT_SET_TWS_MODE, arg);
   _LOG_DBG(2, "%s %d \n", __func__, __LINE__);
 }
 
-void rb_thread_send_play_idx(uint32_t array_subidx)
+void rb_thread_send_play_idx(uint32_t array_subidx) {
-{
   _LOG_DBG(2, " %s array_subidx %d, ", __FUNCTION__, array_subidx);
 
   rb_thread_post_msg(RB_MODULE_EVT_PLAY_IDX, array_subidx);
 }
 
-
+void rb_thread_send_vol(bool inc) {
-void rb_thread_send_vol(bool inc)
-{
   _LOG_DBG(2, " %s inc %d, ", __FUNCTION__, inc);
 
   rb_thread_post_msg(RB_MODULE_EVT_CHANGE_VOL, inc);
 }
 
-void rb_thread_send_status_change(void )
+void rb_thread_send_status_change(void) {
-{
   _LOG_DBG(1, " %s , ", __FUNCTION__);
 
   rb_thread_post_msg(RB_MODULE_EVT_CHANGE_IDLE, 0);
 }
 
-void rb_thread_set_vol(uint32_t vol)
+void rb_thread_set_vol(uint32_t vol) {
-{
   _LOG_DBG(1, " %s , ", __FUNCTION__);
 
   rb_thread_post_msg(RB_MODULE_EVT_SET_VOL, vol);
 }
 
-void rb_thread_send_del_file(uint16_t idx )
+void rb_thread_send_del_file(uint16_t idx) {
-{
   _LOG_DBG(1, " %s , ", __FUNCTION__);
 
   rb_thread_post_msg(RB_MODULE_EVT_DEL_FILE, idx);
 }
 
-void rb_thread_send_sbc_record_start(void )
+void rb_thread_send_sbc_record_start(void) {
-{
   _LOG_DBG(1, " %s , ", __FUNCTION__);
 
   rb_thread_post_msg(SBC_RECORD_ACTION_START, (uint32_t)osThreadGetId());
 }
 
-void rb_thread_send_sbc_record_data_ind(void )
+void rb_thread_send_sbc_record_data_ind(void) {
-{
   if (!rb_ctl_context.sbc_record_on)
     return;
   //  _LOG_DBG(1," %s , ",__FUNCTION__);
   rb_thread_post_msg(SBC_RECORD_ACTION_DATA_IND, (uint32_t)osThreadGetId());
 }
 
-void rb_thread_send_sbc_record_stop(void )
+void rb_thread_send_sbc_record_stop(void) {
-{
   _LOG_DBG(1, " %s , ", __FUNCTION__);
 
   rb_thread_post_msg(SBC_RECORD_ACTION_STOP, (uint32_t)osThreadGetId());
 }
 
-
 // interface for audio module
 static bool user_key_pause_stream = false;
-void app_rbplay_audio_reset_pause_status(void)
+void app_rbplay_audio_reset_pause_status(void) {
-{
   user_key_pause_stream = false;
 }
 
-int app_rbplay_audio_onoff(bool onoff, uint16_t aud_id)
+int app_rbplay_audio_onoff(bool onoff, uint16_t aud_id) {
-{
+  _LOG_DBG(3, " %s onoff %d, get status:%d", __FUNCTION__, onoff,
-    _LOG_DBG(3," %s onoff %d, get status:%d",__FUNCTION__,onoff, rb_ctl_get_status());
+           rb_ctl_get_status());
 
   if (app_rbcodec_check_hfp_active() && !onoff) {
     if (RB_CTL_PLAYING == rb_ctl_get_status()) {
@@ -704,8 +672,7 @@ int app_rbplay_audio_onoff(bool onoff, uint16_t aud_id)
   return 0;
 }
 
-void app_rbplay_pause_resume(void)
+void app_rbplay_pause_resume(void) {
-{
   _LOG_DBG(2, " %s get status:%d", __func__, rb_ctl_get_status());
 
   user_key_pause_stream = true;
@@ -720,8 +687,7 @@ void app_rbplay_pause_resume(void)
 }
 // sbc reader run within thread
 
-static int rb_ctl_mailbox_init(void)
+static int rb_ctl_mailbox_init(void) {
-{
   rb_ctl_mailbox = osMailCreate(osMailQ(rb_ctl_mailbox), NULL);
   if (rb_ctl_mailbox == NULL) {
     TRACE(0, "Failed to Create rb_ctl_mailbox\n");
@@ -730,8 +696,7 @@ static int rb_ctl_mailbox_init(void)
   return 0;
 }
 
-int rb_ctl_mailbox_put(RBCTL_MSG_BLOCK* msg_src)
+int rb_ctl_mailbox_put(RBCTL_MSG_BLOCK *msg_src) {
-{
   osStatus status;
 
   RBCTL_MSG_BLOCK *msg_p = NULL;
@@ -752,8 +717,7 @@ int rb_ctl_mailbox_put(RBCTL_MSG_BLOCK* msg_src)
   return (int)status;
 }
 
-int rb_ctl_mailbox_free(RBCTL_MSG_BLOCK* msg_p)
+int rb_ctl_mailbox_free(RBCTL_MSG_BLOCK *msg_p) {
-{
   osStatus status;
 
   status = osMailFree(rb_ctl_mailbox, msg_p);
@@ -761,8 +725,7 @@ int rb_ctl_mailbox_free(RBCTL_MSG_BLOCK* msg_p)
   return (int)status;
 }
 
-int rb_ctl_mailbox_get(RBCTL_MSG_BLOCK** msg_p)
+int rb_ctl_mailbox_get(RBCTL_MSG_BLOCK **msg_p) {
-{
   osEvent evt;
   evt = osMailGet(rb_ctl_mailbox, osWaitForever);
   if (evt.status == osEventMail) {
@@ -807,8 +770,7 @@ void rb_ctl_action_stop(void)
 
 }
 #endif
-static void rb_ctl_thread(void const *argument)
+static void rb_ctl_thread(void const *argument) {
-{
   osEvent evt;
 #if 1
   app_sysfreq_req(APP_SYSFREQ_USER_APP_PLAYER, APP_SYSFREQ_208M);
@@ -819,7 +781,6 @@ static void rb_ctl_thread(void const *argument)
   rb_ctl_context.rb_player_vol = 6;
   rb_ctl_context.status = RB_CTL_IDLE;
 
-
   rb_ctl_context.curr_song_idx = 0;
   // load playlist here
 
@@ -842,9 +803,7 @@ static void rb_ctl_thread(void const *argument)
   }
 }
 
-
+int rb_ctl_init(void) {
-int rb_ctl_init(void)
-{
   _LOG_DBG(1, "%s \n", __func__);
 
   rb_ctl_context.init_done = false;
@@ -865,23 +824,10 @@ int rb_ctl_init(void)
   return 0;
 }
 
-uint8_t rb_ctl_get_vol(void)
+uint8_t rb_ctl_get_vol(void) { return rb_ctl_context.rb_player_vol; }
-{
-    return rb_ctl_context.rb_player_vol;
-}
 
-bool rb_ctl_is_init_done(void)
+bool rb_ctl_is_init_done(void) { return rb_ctl_context.init_done; }
-{
-	return rb_ctl_context.init_done;
-}
 
-bool rb_ctl_is_paused(void)
+bool rb_ctl_is_paused(void) { return (RB_CTL_SUSPEND == rb_ctl_get_status()); }
-{
-	return ( RB_CTL_SUSPEND == rb_ctl_get_status());
-}
-
-uint16_t rb_ctl_songs_count(void)
-{
-	return sd_playlist.total_songs;
-}
 
+uint16_t rb_ctl_songs_count(void) { return sd_playlist.total_songs; }

apps/audioplayers/rbplay/rbpcmbuf.cpp

@@ -15,24 +15,24 @@
  ****************************************************************************/
 /* rbpcmbuf source */
 /* pcmbuf management & af control & mixer */
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
 #ifdef MBED
 #include "mbed.h"
 #include "rtos.h"
 #endif
-#include "audioflinger.h"
-#include "cqueue.h"
 #include "app_audio.h"
 #include "app_utils.h"
+#include "audioflinger.h"
+#include "cqueue.h"
 #include "hal_trace.h"
 
-#include "rbplay.h"
 #include "rbpcmbuf.h"
+#include "rbplay.h"
 #include "utils.h"
 
 #define RB_PCMBUF_DMA_BUFFER_SIZE (1024 * 12)
@@ -47,17 +47,17 @@ static osMutexId _rb_media_buf_queue_mutex_id = NULL;
 static osMutexDef(_rb_media_buf_queue_mutex);
 
 #define LOCK_MEDIA_BUF_QUEUE()                                                 \
-    if(osErrorISR == osMutexWait(_rb_media_buf_queue_mutex_id, osWaitForever))	{\
+  if (osErrorISR ==                                                            \
+      osMutexWait(_rb_media_buf_queue_mutex_id, osWaitForever)) {              \
     error("%s LOCK_MEDIA_BUF_QUEUE from IRQ!!!!!!!\n", __func__);              \
-    }\
+  }
 
 #define UNLOCK_MEDIA_BUF_QUEUE()                                               \
   if (osErrorISR == osMutexRelease(_rb_media_buf_queue_mutex_id)) {            \
     error("%s UNLOCK_MEDIA_BUF_QUEUE from IRQ!!!!!!\n");                       \
-    }    \
+  }
 
-static uint32_t rbplay_more_data(uint8_t *buf, uint32_t len)
+static uint32_t rbplay_more_data(uint8_t *buf, uint32_t len) {
-{
   CQItemType *e1 = NULL;
   CQItemType *e2 = NULL;
   unsigned int len1 = 0;
@@ -83,16 +83,17 @@ static uint32_t rbplay_more_data(uint8_t *buf, uint32_t len)
 }
 
 extern uint8_t rb_ctl_get_vol(void);
-void rb_pcmbuf_init(void)
+void rb_pcmbuf_init(void) {
-{
   info("pcmbuff init");
   if (!_rb_media_buf_queue_mutex_id)
-        _rb_media_buf_queue_mutex_id  = osMutexCreate((osMutex(_rb_media_buf_queue_mutex)));
+    _rb_media_buf_queue_mutex_id =
+        osMutexCreate((osMutex(_rb_media_buf_queue_mutex)));
 
   app_audio_mempool_init();
 
   app_audio_mempool_get_buff(&rb_pcmbuf_media_buf, RB_PCMBUF_MEDIA_BUFFER_SIZE);
-    InitCQueue(&rb_pcmbuf_media_buf_queue, RB_PCMBUF_MEDIA_BUFFER_SIZE, (unsigned char *)rb_pcmbuf_media_buf);
+  InitCQueue(&rb_pcmbuf_media_buf_queue, RB_PCMBUF_MEDIA_BUFFER_SIZE,
+             (unsigned char *)rb_pcmbuf_media_buf);
 
   app_audio_mempool_get_buff(&rbplay_dma_buffer, RB_PCMBUF_DMA_BUFFER_SIZE);
   app_audio_mempool_get_buff(&rb_decode_out_buff, RB_DECODE_OUT_BUFFER_SIZE);
@@ -115,26 +116,23 @@ void rb_pcmbuf_init(void)
   af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
 }
 
-void *rb_pcmbuf_request_buffer(int *size)
+void *rb_pcmbuf_request_buffer(int *size) {
-{
   *size = RB_DECODE_OUT_BUFFER_SIZE / 4;
   return rb_decode_out_buff;
 }
 
-void rb_pcmbuf_write(unsigned int size)
+void rb_pcmbuf_write(unsigned int size) {
-{
   int ret;
   do {
     LOCK_MEDIA_BUF_QUEUE();
-        ret = EnCQueue(&rb_pcmbuf_media_buf_queue, (CQItemType *)rb_decode_out_buff, size*(2*2));
+    ret = EnCQueue(&rb_pcmbuf_media_buf_queue, (CQItemType *)rb_decode_out_buff,
+                   size * (2 * 2));
     UNLOCK_MEDIA_BUF_QUEUE();
     osThreadYield();
   } while (ret == CQ_ERR);
 }
 
-void rb_pcmbuf_stop(void)
+void rb_pcmbuf_stop(void) {
-{
   af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
   af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
 }
-

apps/audioplayers/rbplay/rbplay.cpp

@@ -16,34 +16,34 @@
 /* rbplay source */
 /* playback control & rockbox codec porting & codec thread */
 
-#include <string.h>
+#include <ctype.h>
+#include <fcntl.h>
 #include <math.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include <fcntl.h>
+#include <stdlib.h>
-#include <ctype.h>
+#include <string.h>
 #include <unistd.h>
 
 #ifdef MBED
 #include "mbed.h"
 #include "rtos.h"
 #endif
-#include "metadata.h"
+#include "app_overlay.h"
+#include "apps.h"
+#include "audioflinger.h"
 #include "codecs.h"
 #include "eq_export.h"
 #include "hal_overlay.h"
-#include "app_overlay.h"
-#include "audioflinger.h"
 #include "hal_trace.h"
-#include "apps.h"
+#include "metadata.h"
 
-#include "rbpcmbuf.h"
+#include "app_key.h"
-#include "rbplaysd.h"
 #include "app_thread.h"
 #include "app_utils.h"
-#include "app_key.h"
+#include "rbpcmbuf.h"
 #include "rbplay.h"
+#include "rbplaysd.h"
 #include "utils.h"
 
 #ifdef __TWS__
@@ -66,7 +66,9 @@ extern "C" {
 void sbc_codec_run(void);
 }
 
-extern void rb_pcm_player_open(enum AUD_BITS_T bits,enum AUD_SAMPRATE_T sample_rate,enum AUD_CHANNEL_NUM_T channel_num,uint8_t vol) ;
+extern void rb_pcm_player_open(enum AUD_BITS_T bits,
+                               enum AUD_SAMPRATE_T sample_rate,
+                               enum AUD_CHANNEL_NUM_T channel_num, uint8_t vol);
 
 #if defined(__TWS__)
 typedef struct _rb_tws_codec_info {
@@ -92,7 +94,8 @@ int rb_decode_mailbox_put(RBTHREAD_MSG_BLOCK* msg_src);
 static osMailQId rb_decode_mailbox = NULL;
 
 static void rb_decode_thread(void const *argument);
-osThreadDef(rb_decode_thread, osPriorityAboveNormal, 1, 1024 * 2, "rb_decorder");
+osThreadDef(rb_decode_thread, osPriorityAboveNormal, 1, 1024 * 2,
+            "rb_decorder");
 
 // rbcodec info
 static int song_fd;
@@ -122,15 +125,11 @@ extern void rb_thread_send_status_change(void );
 
 enum APP_SYSFREQ_FREQ_T rb_player_get_work_freq(void);
 
-static void rb_player_sync_close_done(void)
+static void rb_player_sync_close_done(void) { thread_tid_waiter = NULL; }
-{
-    thread_tid_waiter = NULL;
-}
 
 extern void rb_check_stream_reconfig(int32_t freq, uint8_t ch);
-static void f_codec_pcmbuf_insert_callback(
+static void f_codec_pcmbuf_insert_callback(const void *ch1, const void *ch2,
-        const void *ch1, const void *ch2, int count)
+                                           int count) {
-{
   struct dsp_buffer src;
   struct dsp_buffer dst;
 
@@ -161,7 +160,9 @@ static void f_codec_pcmbuf_insert_callback(
 #else
 
   if (codec_info.update_codec_info) {
-        rb_set_sbc_encoder_freq_ch(codec_info.sample_freq, codec_info.channel_num); //should call this to set trigger timer
+    rb_set_sbc_encoder_freq_ch(
+        codec_info.sample_freq,
+        codec_info.channel_num); // should call this to set trigger timer
     rb_check_stream_reconfig(codec_info.sample_freq, codec_info.channel_num);
     codec_info.update_codec_info = 0;
   }
@@ -192,14 +193,12 @@ static void f_codec_pcmbuf_insert_callback(
 #endif
 }
 
-static void f_audio_codec_update_elapsed(unsigned long elapsed)
+static void f_audio_codec_update_elapsed(unsigned long elapsed) {
-{
   // info("Update elapsed: %d", elapsed);
   return;
 }
 
-static size_t f_codec_filebuf_callback(void *ptr, size_t size)
+static size_t f_codec_filebuf_callback(void *ptr, size_t size) {
-{
   ssize_t ret;
   ret = read(song_fd, ptr, size);
   if (ret < 0) {
@@ -207,16 +206,13 @@ static size_t f_codec_filebuf_callback(void *ptr, size_t size)
   }
 
   return ret;
-
 }
 
-static void * f_codec_request_buffer_callback(size_t *realsize, size_t reqsize)
+static void *f_codec_request_buffer_callback(size_t *realsize, size_t reqsize) {
-{
   return NULL;
 }
 
-static void * f_codec_advance_buffer_callback(size_t amount)
+static void *f_codec_advance_buffer_callback(size_t amount) {
-{
   off_t ret = lseek(song_fd, (off_t)(ci->curpos + amount), SEEK_SET);
   if (ret < 0) {
     error("File seek fail");
@@ -225,11 +221,9 @@ static void * f_codec_advance_buffer_callback(size_t amount)
 
   ci->curpos += amount;
   return (void *)ci;
-
 }
 
-static bool f_codec_seek_buffer_callback(size_t newpos)
+static bool f_codec_seek_buffer_callback(size_t newpos) {
-{
   off_t ret = lseek(song_fd, (off_t)newpos, SEEK_SET);
   if (ret < 0) {
     error("File seek fail");
@@ -240,26 +234,21 @@ static bool f_codec_seek_buffer_callback(size_t newpos)
   return true;
 }
 
-static void f_codec_seek_complete_callback(void)
+static void f_codec_seek_complete_callback(void) {
-{
   info("Seek complete");
   dsp_configure(ci->dsp, DSP_FLUSH, 0);
 }
 
-static void f_audio_codec_update_offset(size_t offset)
+static void f_audio_codec_update_offset(size_t offset) {}
-{
-}
 
-static void f_codec_configure_callback(int setting, intptr_t value)
+static void f_codec_configure_callback(int setting, intptr_t value) {
-{
   dsp_configure(ci->dsp, setting, value);
 #ifdef __TWS__
   if (setting == DSP_SET_FREQUENCY) {
     if (codec_info.sample_freq != value)
       codec_info.update_codec_info = 1;
     codec_info.sample_freq = value;
-    }
+  } else if (setting == DSP_SET_STEREO_MODE) {
-    else if(setting == DSP_SET_STEREO_MODE){
     if (codec_info.channel_num != (value == STEREO_MONO ? 1 : 2))
       codec_info.update_codec_info = 1;
     codec_info.channel_num = value == STEREO_MONO ? 1 : 2;
@@ -267,21 +256,16 @@ static void f_codec_configure_callback(int setting, intptr_t value)
 #endif
 }
 
-static enum codec_command_action f_codec_get_command_callback(intptr_t *param)
+static enum codec_command_action f_codec_get_command_callback(intptr_t *param) {
-{
   if (rb_decode_halt_flag == 1)
     return CODEC_ACTION_HALT;
 
   return CODEC_ACTION_NULL;
 }
 
-static bool f_codec_loop_track_callback(void)
+static bool f_codec_loop_track_callback(void) { return false; }
-{
-    return false;
-}
 
-static void init_ci_file(void)
+static void init_ci_file(void) {
-{
   ci->codec_get_buffer = 0;
   ci->pcmbuf_insert = f_codec_pcmbuf_insert_callback;
   ci->set_elapsed = f_audio_codec_update_elapsed;
@@ -296,8 +280,7 @@ static void init_ci_file(void)
   ci->loop_track = f_codec_loop_track_callback;
 }
 
-static void rb_play_init(void)
+static void rb_play_init(void) {
-{
   init_dsp();
 
   init_ci_file();
@@ -307,24 +290,21 @@ static void rb_play_init(void)
 #endif
 }
 
-void rb_play_codec_init(void)
+void rb_play_codec_init(void) {
-{
   RBTHREAD_MSG_BLOCK msg;
   msg.evt = (uint32_t)RB_CTRL_CMD_CODEC_INIT;
   msg.arg = (uint32_t)0;
   rb_decode_mailbox_put(&msg);
 }
 
-void rb_play_codec_run(void)
+void rb_play_codec_run(void) {
-{
   RBTHREAD_MSG_BLOCK msg;
   msg.evt = (uint32_t)RB_CTRL_CMD_CODEC_RUN;
   msg.arg = (uint32_t)0;
   rb_decode_mailbox_put(&msg);
 }
 
-static int rb_codec_init_desc(void )
+static int rb_codec_init_desc(void) {
-{
   info("Init decode format: %d", song_format);
 
   switch (song_format) {
@@ -361,8 +341,7 @@ static int rb_codec_init_desc(void )
   return 0;
 }
 
-static int rb_codec_loop_on(void)
+static int rb_codec_loop_on(void) {
-{
 #ifdef __TWS__
   // set start transfer to slave
   tws_local_player_set_tran_2_slave_flag(1);
@@ -394,8 +373,7 @@ static int rb_codec_loop_on(void)
   return 0;
 }
 
-static int rb_thread_process_evt(RB_CTRL_CMD_T evt)
+static int rb_thread_process_evt(RB_CTRL_CMD_T evt) {
-{
   info("Decode event:%d", evt);
 
   switch (evt) {
@@ -448,8 +426,7 @@ static int rb_thread_process_evt(RB_CTRL_CMD_T evt)
   return 0;
 }
 
-int rb_decode_mailbox_put(RBTHREAD_MSG_BLOCK* msg_src)
+int rb_decode_mailbox_put(RBTHREAD_MSG_BLOCK *msg_src) {
-{
   osStatus status;
 
   RBTHREAD_MSG_BLOCK *msg_p = NULL;
@@ -468,8 +445,7 @@ int rb_decode_mailbox_put(RBTHREAD_MSG_BLOCK* msg_src)
   return (int)status;
 }
 
-int rb_decode_mailbox_free(RBTHREAD_MSG_BLOCK* msg_p)
+int rb_decode_mailbox_free(RBTHREAD_MSG_BLOCK *msg_p) {
-{
   osStatus status;
 
   status = osMailFree(rb_decode_mailbox, msg_p);
@@ -477,8 +453,7 @@ int rb_decode_mailbox_free(RBTHREAD_MSG_BLOCK* msg_p)
   return (int)status;
 }
 
-int rb_decode_mailbox_get(RBTHREAD_MSG_BLOCK** msg_p)
+int rb_decode_mailbox_get(RBTHREAD_MSG_BLOCK **msg_p) {
-{
   osEvent evt;
   evt = osMailGet(rb_decode_mailbox, osWaitForever);
   if (evt.status == osEventMail) {
@@ -488,8 +463,7 @@ int rb_decode_mailbox_get(RBTHREAD_MSG_BLOCK** msg_p)
   return -1;
 }
 
-static void rb_decode_thread(void const *argument)
+static void rb_decode_thread(void const *argument) {
-{
   RB_CTRL_CMD_T action;
   RBTHREAD_MSG_BLOCK *msg_p;
 
@@ -510,12 +484,10 @@ static void rb_decode_thread(void const *argument)
         osSignalSet(rb_decode_tid, 0x1203);
       rb_caller_tid = NULL;
     }
-
   }
 }
 
-int app_rbplay_open(void)
+int app_rbplay_open(void) {
-{
   if (rb_decode_tid != NULL) {
     warn("Decode thread reopen");
     return -1;
@@ -536,40 +508,30 @@ int app_rbplay_open(void)
   return 0;
 }
 
-int rb_codec_running(void)
+int rb_codec_running(void) { return ((rb_decode_halt_flag == 0) ? 1 : 0); }
-{
-    return ((rb_decode_halt_flag == 0)?1:0);
-}
 
-void rb_codec_set_halt(int halt)
+void rb_codec_set_halt(int halt) { rb_decode_halt_flag = halt; }
-{
-    rb_decode_halt_flag = halt;
-}
 
-void rb_thread_set_decode_vars(int fd, int type ,void* id3)
+void rb_thread_set_decode_vars(int fd, int type, void *id3) {
-{
   song_fd = fd;
   song_format = type;
   current_id3 = (struct mp3entry *)id3;
 }
 
-void rb_player_sync_set_wait_thread(osThreadId tid)
+void rb_player_sync_set_wait_thread(osThreadId tid) {
-{
   if (rbplay_loop_on)
     thread_tid_waiter = tid;
   else
     thread_tid_waiter = NULL;
 }
 
-void rb_player_sync_wait_close(void )
+void rb_player_sync_wait_close(void) {
-{
   while (NULL != thread_tid_waiter) {
     osThreadYield();
   }
 }
 
-enum APP_SYSFREQ_FREQ_T rb_player_get_work_freq(void)
+enum APP_SYSFREQ_FREQ_T rb_player_get_work_freq(void) {
-{
   enum APP_SYSFREQ_FREQ_T freq;
 
   hal_sysfreq_print();
@@ -611,5 +573,3 @@ enum APP_SYSFREQ_FREQ_T rb_player_get_work_freq(void)
   info("Decode thread run at: %d", freq);
   return freq;
 }
-
-

apps/audioplayers/rbplay/rbplaysd.cpp

@@ -16,18 +16,18 @@
 /* rbplay source */
 /* playback control & rockbox codec porting & codec thread */
 
-#include <string.h>
+#include <ctype.h>
+#include <fcntl.h>
 #include <math.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include <fcntl.h>
+#include <stdlib.h>
-#include <ctype.h>
+#include <string.h>
 #include <unistd.h>
 
+#include "SDFileSystem.h"
 #include "hal_trace.h"
 #include "metadata.h"
-#include "SDFileSystem.h"
 #include "rbplaysd.h"
 #include "utils.h"
 
@@ -41,8 +41,7 @@ static playlist_item sd_curritem;
 
 playlist_struct sd_playlist;
 
-static void playlist_insert(playlist_item* item)
+static void playlist_insert(playlist_item *item) {
-{
   int fd;
   fd = open(PLAYLIST_PATH, O_RDWR | O_CREAT);
   if (fd <= 0) {
@@ -55,8 +54,7 @@ static void playlist_insert(playlist_item* item)
   close(fd);
 }
 
-static bool sdcard_mount(void)
+static bool sdcard_mount(void) {
-{
   if (sdfs) {
     info("SD card already mount");
     return true;
@@ -80,8 +78,7 @@ static bool sdcard_mount(void)
   return true;
 }
 
-static void app_rbplay_gen_playlist(playlist_struct *list)
+static void app_rbplay_gen_playlist(playlist_struct *list) {
-{
   struct dirent *p;
   DIR *d;
   uint32_t total;
@@ -122,7 +119,8 @@ static void app_rbplay_gen_playlist(playlist_struct *list)
     get_metadata(&current_id3, fd, sd_curritem.file_path);
     close(fd);
 
-        if(current_id3.bitrate == 0 || current_id3.filesize == 0 || current_id3.length == 0)
+    if (current_id3.bitrate == 0 || current_id3.filesize == 0 ||
+        current_id3.length == 0)
       break;
 
     info("bits:%d, type:%d, freq:%d", current_id3.bitrate,
@@ -139,31 +137,36 @@ static void app_rbplay_gen_playlist(playlist_struct *list)
     str = current_id3.title;
     if (str != NULL) {
       memset(sd_curritem_p->title, 0x0, MP3_TITLE_LEN);
-            memcpy(sd_curritem_p->title ,str,strlen(str)>MP3_TITLE_LEN?MP3_TITLE_LEN:strlen(str));
+      memcpy(sd_curritem_p->title, str,
+             strlen(str) > MP3_TITLE_LEN ? MP3_TITLE_LEN : strlen(str));
     }
 
     str = current_id3.artist;
     if (str != NULL) {
       memset(sd_curritem_p->artist, 0x0, MP3_ARTIST_LEN);
-            memcpy(sd_curritem_p->artist ,str,strlen(str)>MP3_ARTIST_LEN?MP3_ARTIST_LEN:strlen(str));
+      memcpy(sd_curritem_p->artist, str,
+             strlen(str) > MP3_ARTIST_LEN ? MP3_ARTIST_LEN : strlen(str));
     }
 
     str = current_id3.album;
     if (str != NULL) {
       memset(sd_curritem_p->album, 0x0, MP3_ALBUM_LEN);
-            memcpy(sd_curritem_p->album ,str,strlen(str)>MP3_ALBUM_LEN?MP3_ALBUM_LEN:strlen(str));
+      memcpy(sd_curritem_p->album, str,
+             strlen(str) > MP3_ALBUM_LEN ? MP3_ALBUM_LEN : strlen(str));
     }
 
     str = current_id3.genre_string;
     if (str != NULL) {
       memset(sd_curritem_p->genre, 0x0, MP3_GENRE_LEN);
-            memcpy(sd_curritem_p->genre ,str,strlen(str)>MP3_GENRE_LEN?MP3_GENRE_LEN:strlen(str));
+      memcpy(sd_curritem_p->genre, str,
+             strlen(str) > MP3_GENRE_LEN ? MP3_GENRE_LEN : strlen(str));
     }
 
     str = current_id3.composer;
     if (str != NULL) {
       memset(sd_curritem_p->composer, 0x0, MP3_COMPOSER_LEN);
-            memcpy(sd_curritem_p->composer ,str,strlen(str)>MP3_COMPOSER_LEN?MP3_COMPOSER_LEN:strlen(str));
+      memcpy(sd_curritem_p->composer, str,
+             strlen(str) > MP3_COMPOSER_LEN ? MP3_COMPOSER_LEN : strlen(str));
     }
 #endif
     playlist_insert(sd_curritem_p);
@@ -175,11 +178,9 @@ static void app_rbplay_gen_playlist(playlist_struct *list)
 
   closedir(d);
   info("---------%d audio file searched---------", total);
-
 }
 
-void app_rbplay_load_playlist(playlist_struct *list)
+void app_rbplay_load_playlist(playlist_struct *list) {
-{
   if (sdcard_mount() == false)
     return;
 
@@ -188,8 +189,7 @@ void app_rbplay_load_playlist(playlist_struct *list)
   app_rbplay_gen_playlist(list);
 }
 
-playlist_item *app_rbplay_get_playitem(const int idx)
+playlist_item *app_rbplay_get_playitem(const int idx) {
-{
   int fd;
   if (idx >= sd_playlist.total_songs) {
     warn("Index exceed: %d / %d", idx, sd_playlist.total_songs);
@@ -212,8 +212,7 @@ playlist_item *app_rbplay_get_playitem(const int idx)
   return sd_playlist.current_item;
 }
 
-int app_ctl_remove_file(const int idx)
+int app_ctl_remove_file(const int idx) {
-{
   playlist_item *item = app_rbplay_get_playitem(idx);
   if (!item)
     return -1;
@@ -221,5 +220,3 @@ int app_ctl_remove_file(const int idx)
 
   return 0;
 }
-
-

apps/audioplayers/voice_test.c

@@ -13,13 +13,13 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "cmsis_os.h"
 #include "app_utils.h"
+#include "audio_dump.h"
 #include "audioflinger.h"
+#include "cmsis_os.h"
 #include "hal_timer.h"
 #include "hal_trace.h"
 #include "string.h"
-#include "audio_dump.h"
 // #include "local_wav.h"
 
 #define CHANNEL_NUM (2)
@@ -31,11 +31,9 @@
 #define SAMPLE_BITS (16)
 #define SAMPLE_BYTES (SAMPLE_BITS / 8)
 
-
 #define TX_SAMPLE_RATE (16000)
 #define RX_SAMPLE_RATE (16000)
 
-
 #define TX_FRAME_LEN (256)
 #define RX_FRAME_LEN (256)
 
@@ -58,8 +56,7 @@ static uint32_t POSSIBLY_UNUSED codec_playback_cnt = 0;
 
 #define CODEC_STREAM_ID AUD_STREAM_ID_0
 
-static uint32_t codec_capture_callback(uint8_t *buf, uint32_t len)
+static uint32_t codec_capture_callback(uint8_t *buf, uint32_t len) {
-{
   int POSSIBLY_UNUSED pcm_len = len / sizeof(VOICE_PCM_T) / CHANNEL_NUM;
   VOICE_PCM_T POSSIBLY_UNUSED *pcm_buf[CHANNEL_NUM];
   int interval_len = len * 2 / CHANNEL_NUM;
@@ -77,8 +74,7 @@ static uint32_t codec_capture_callback(uint8_t *buf, uint32_t len)
   return len;
 }
 
-static uint32_t codec_playback_callback(uint8_t *buf, uint32_t len)
+static uint32_t codec_playback_callback(uint8_t *buf, uint32_t len) {
-{
   int POSSIBLY_UNUSED pcm_len = len / sizeof(VOICE_PCM_T) / CHANNEL_NUM;
   VOICE_PCM_T POSSIBLY_UNUSED *pcm_buf[CHANNEL_NUM];
   int interval_len = len * 2 / CHANNEL_NUM;
@@ -92,8 +88,7 @@ static uint32_t codec_playback_callback(uint8_t *buf, uint32_t len)
   return len;
 }
 
-static int voice_start(bool on)
+static int voice_start(bool on) {
-{
   int ret = 0;
   static bool isRun = false;
   enum APP_SYSFREQ_FREQ_T freq = APP_SYSFREQ_208M;
@@ -109,7 +104,8 @@ static int voice_start(bool on)
     af_set_priority(AF_USER_TEST, osPriorityHigh);
 
     app_sysfreq_req(APP_SYSFREQ_USER_APP_0, freq);
-        TRACE(2, "[%s] sys freq calc : %d\n", __func__, hal_sys_timer_calc_cpu_freq(5, 0));
+    TRACE(2, "[%s] sys freq calc : %d\n", __func__,
+          hal_sys_timer_calc_cpu_freq(5, 0));
 
     // Initialize Cqueue
     codec_capture_cnt = 0;
@@ -127,7 +123,8 @@ static int voice_start(bool on)
     stream_cfg.handler = codec_capture_callback;
     stream_cfg.data_ptr = codec_capture_buf;
 
-        TRACE(3, "[%s] codec capture sample_rate: %d, data_size: %d", __func__, stream_cfg.sample_rate, stream_cfg.data_size);
+    TRACE(3, "[%s] codec capture sample_rate: %d, data_size: %d", __func__,
+          stream_cfg.sample_rate, stream_cfg.data_size);
     af_stream_open(CODEC_STREAM_ID, AUD_STREAM_CAPTURE, &stream_cfg);
     ASSERT(ret == 0, "codec capture failed: %d", ret);
 
@@ -143,7 +140,8 @@ static int voice_start(bool on)
     stream_cfg.handler = codec_playback_callback;
     stream_cfg.data_ptr = codec_playback_buf;
 
-        TRACE(3, "[%s] codec playback sample_rate: %d, data_size: %d", __func__, stream_cfg.sample_rate, stream_cfg.data_size);
+    TRACE(3, "[%s] codec playback sample_rate: %d, data_size: %d", __func__,
+          stream_cfg.sample_rate, stream_cfg.data_size);
     af_stream_open(CODEC_STREAM_ID, AUD_STREAM_PLAYBACK, &stream_cfg);
     ASSERT(ret == 0, "codec playback failed: %d", ret);
 
@@ -152,9 +150,7 @@ static int voice_start(bool on)
     // Start
     af_stream_start(CODEC_STREAM_ID, AUD_STREAM_CAPTURE);
     af_stream_start(CODEC_STREAM_ID, AUD_STREAM_PLAYBACK);
-    }
+  } else {
-    else
-    {
     // Close stream
     af_stream_stop(CODEC_STREAM_ID, AUD_STREAM_PLAYBACK);
     af_stream_stop(CODEC_STREAM_ID, AUD_STREAM_CAPTURE);
@@ -176,8 +172,7 @@ static int voice_start(bool on)
 }
 
 static bool voice_test_status = true;
-void voice_test(void)
+void voice_test(void) {
-{
   TRACE(2, "[%s] status = %d", __func__, voice_test_status);
 
   voice_start(voice_test_status);

apps/audioplayers/voicebtpcmplay_sco_dma_snapshot.cpp

@@ -14,25 +14,25 @@
  *
  ****************************************************************************/
 // Standard C Included Files
-#include <string.h>
-#include <math.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "cmsis_os.h"
-#include "plat_types.h"
-#include "hal_uart.h"
-#include "hal_timer.h"
-#include "hal_trace.h"
-#include "cqueue.h"
 #include "app_audio.h"
 #include "app_overlay.h"
 #include "app_ring_merge.h"
-#include "tgt_hardware.h"
-#include "bt_sco_chain.h"
-#include "iir_resample.h"
-#include "hfp_api.h"
 #include "audio_prompt_sbc.h"
+#include "bt_sco_chain.h"
+#include "cmsis_os.h"
+#include "cqueue.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
+#include "hal_uart.h"
+#include "hfp_api.h"
+#include "iir_resample.h"
+#include "plat_types.h"
+#include "tgt_hardware.h"
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #ifdef TX_RX_PCM_MASK
 #include "bt_drv_interface.h"
 #endif
@@ -101,7 +101,8 @@ static IirResampleState *downlink_resample_st = NULL;
 
 #if defined(HFP_1_6_ENABLE)
 static btif_sbc_decoder_t *msbc_decoder;
-static float msbc_eq_band_gain[CFG_HW_AUD_EQ_NUM_BANDS]= {0,0,0,0,0,0,0,0};
+static float msbc_eq_band_gain[CFG_HW_AUD_EQ_NUM_BANDS] = {0, 0, 0, 0,
+                                                           0, 0, 0, 0};
 
 #define MSBC_ENCODE_PCM_LEN (240)
 
@@ -125,7 +126,9 @@ LpcPlcState *msbc_plc_state = NULL;
 #define VOICEBTPCM_TRACE(s, ...)
 // TRACE(s, ##__VA_ARGS__)
 
-#if defined(CHIP_BEST1400) || defined(CHIP_BEST1402) || defined(CHIP_BEST2300P) || defined(CHIP_BEST2300A) || defined(CHIP_BEST2001)
+#if defined(CHIP_BEST1400) || defined(CHIP_BEST1402) ||                        \
+    defined(CHIP_BEST2300P) || defined(CHIP_BEST2300A) ||                      \
+    defined(CHIP_BEST2001)
 #define MSBC_MUTE_PATTERN (0x55)
 #else
 #define MSBC_MUTE_PATTERN (0x00)
@@ -146,14 +149,18 @@ static PacketLossState pld;
 
 extern bool bt_sco_codec_is_msbc(void);
 
-int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len, unsigned char *pcm_buf,unsigned int pcm_len);
+int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
-int process_downlink_cvsd_frames(unsigned char *cvsd_buf, unsigned int cvsd_len, unsigned char *pcm_buf,unsigned int pcm_len);
+                                 unsigned char *pcm_buf, unsigned int pcm_len);
-int process_uplink_msbc_frames(unsigned char *pcm_buf, unsigned int pcm_len, unsigned char *msbc_buf,unsigned int msbc_len);
+int process_downlink_cvsd_frames(unsigned char *cvsd_buf, unsigned int cvsd_len,
-int process_uplink_cvsd_frames(unsigned char *pcm_buf, unsigned int pcm_len, unsigned char *cvsd_buf,unsigned int cvsd_len);
+                                 unsigned char *pcm_buf, unsigned int pcm_len);
+int process_uplink_msbc_frames(unsigned char *pcm_buf, unsigned int pcm_len,
+                               unsigned char *msbc_buf, unsigned int msbc_len);
+int process_uplink_cvsd_frames(unsigned char *pcm_buf, unsigned int pcm_len,
+                               unsigned char *cvsd_buf, unsigned int cvsd_len);
 
-
+int process_downlink_bt_voice_frames(uint8_t *in_buf, uint32_t in_len,
-int process_downlink_bt_voice_frames(uint8_t *in_buf, uint32_t in_len, uint8_t *out_buf,uint32_t out_len,int32_t codec_type)
+                                     uint8_t *out_buf, uint32_t out_len,
-{
+                                     int32_t codec_type) {
   // TRACE(3,"[%s] in_len = %d, out_len = %d", __FUNCTION__, in_len, out_len);
 
 #if defined(SPEECH_RX_24BIT)
@@ -169,20 +176,24 @@ int process_downlink_bt_voice_frames(uint8_t *in_buf, uint32_t in_len, uint8_t *
   }
 
   if (bt_sco_codec_is_msbc()) {
-        process_downlink_msbc_frames(in_buf, in_len, (uint8_t *)pcm_buf, pcm_len * sizeof(int16_t));
+    process_downlink_msbc_frames(in_buf, in_len, (uint8_t *)pcm_buf,
+                                 pcm_len * sizeof(int16_t));
 
     // Down sampling
     if (resample_needed_flag) {
-            iir_resample_process(downlink_resample_st, pcm_buf, (int16_t *)out_buf, pcm_len);
+      iir_resample_process(downlink_resample_st, pcm_buf, (int16_t *)out_buf,
+                           pcm_len);
       pcm_buf = (int16_t *)out_buf;
       pcm_len >>= 1;
     }
   } else {
-        process_downlink_cvsd_frames(in_buf, in_len, (uint8_t *)pcm_buf, pcm_len * sizeof(int16_t));
+    process_downlink_cvsd_frames(in_buf, in_len, (uint8_t *)pcm_buf,
+                                 pcm_len * sizeof(int16_t));
 
     // Up sampling
     if (resample_needed_flag) {
-            iir_resample_process(downlink_resample_st, pcm_buf, (int16_t *)out_buf, pcm_len);
+      iir_resample_process(downlink_resample_st, pcm_buf, (int16_t *)out_buf,
+                           pcm_len);
       pcm_buf = (int16_t *)out_buf;
       pcm_len <<= 1;
     }
@@ -204,8 +215,10 @@ int process_downlink_bt_voice_frames(uint8_t *in_buf, uint32_t in_len, uint8_t *
   return 0;
 }
 
-int process_uplink_bt_voice_frames(uint8_t *in_buf, uint32_t in_len, uint8_t *ref_buf, uint32_t ref_len, uint8_t *out_buf,uint32_t out_len,int32_t codec_type)
+int process_uplink_bt_voice_frames(uint8_t *in_buf, uint32_t in_len,
-{
+                                   uint8_t *ref_buf, uint32_t ref_len,
+                                   uint8_t *out_buf, uint32_t out_len,
+                                   int32_t codec_type) {
   // TRACE(3,"[%s] in_len = %d, out_len = %d", __FUNCTION__, in_len, out_len);
 
 #if defined(SPEECH_TX_24BIT)
@@ -217,21 +230,32 @@ int process_uplink_bt_voice_frames(uint8_t *in_buf, uint32_t in_len, uint8_t *re
 #endif
 
 #if defined(SPEECH_TX_AEC_CODEC_REF)
-    ASSERT(pcm_len % (SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1) == 0, "[%s] pcm_len(%d) should be divided by %d", __FUNCTION__, pcm_len, SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1);
+  ASSERT(pcm_len % (SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1) == 0,
+         "[%s] pcm_len(%d) should be divided by %d", __FUNCTION__, pcm_len,
+         SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1);
   // copy reference buffer
-#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT) || defined(SPEECH_TX_THIRDPARTY)
+#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) ||                       \
-    for (int i = SPEECH_CODEC_CAPTURE_CHANNEL_NUM, j = 0; i < pcm_len; i += SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1, j++) {
+    defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT) ||                 \
+    defined(SPEECH_TX_THIRDPARTY)
+  for (int i = SPEECH_CODEC_CAPTURE_CHANNEL_NUM, j = 0; i < pcm_len;
+       i += SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1, j++) {
     aec_echo_buf[j] = pcm_buf[i];
   }
 #endif
-    for (int i = 0, j = 0; i < pcm_len; i += SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1, j += SPEECH_CODEC_CAPTURE_CHANNEL_NUM) {
+  for (int i = 0, j = 0; i < pcm_len; i += SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1,
+           j += SPEECH_CODEC_CAPTURE_CHANNEL_NUM) {
     for (int k = 0; k < SPEECH_CODEC_CAPTURE_CHANNEL_NUM; k++)
       pcm_buf[j + k] = pcm_buf[i + k];
   }
-    pcm_len = pcm_len / (SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1) * SPEECH_CODEC_CAPTURE_CHANNEL_NUM;
+  pcm_len = pcm_len / (SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1) *
-#elif (defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT) || defined(SPEECH_TX_THIRDPARTY))
+            SPEECH_CODEC_CAPTURE_CHANNEL_NUM;
+#elif (defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) ||                    \
+       defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT) ||              \
+       defined(SPEECH_TX_THIRDPARTY))
   int ref_pcm_len = ref_len / sizeof(int16_t);
-    ASSERT(pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM == ref_pcm_len, "[%s] Length error: %d / %d != %d", __func__, pcm_len, SPEECH_CODEC_CAPTURE_CHANNEL_NUM, ref_pcm_len);
+  ASSERT(pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM == ref_pcm_len,
+         "[%s] Length error: %d / %d != %d", __func__, pcm_len,
+         SPEECH_CODEC_CAPTURE_CHANNEL_NUM, ref_pcm_len);
 
   for (int i = 0; i < ref_pcm_len; i++) {
     aec_echo_buf[i] = ref_buf[i];
@@ -251,30 +275,33 @@ int process_uplink_bt_voice_frames(uint8_t *in_buf, uint32_t in_len, uint8_t *re
   if (bt_sco_codec_is_msbc()) {
     // Up sampling
     if (resample_needed_flag) {
-            iir_resample_process(uplink_resample_st, (int16_t *)pcm_buf_16bits, resample_buf, pcm_len);
+      iir_resample_process(uplink_resample_st, (int16_t *)pcm_buf_16bits,
+                           resample_buf, pcm_len);
       pcm_buf_16bits = resample_buf;
       pcm_len = sco_frame_length;
     }
 
-        process_uplink_msbc_frames((uint8_t *)pcm_buf_16bits, pcm_len * sizeof(int16_t), out_buf, out_len);
+    process_uplink_msbc_frames((uint8_t *)pcm_buf_16bits,
+                               pcm_len * sizeof(int16_t), out_buf, out_len);
   } else {
     // Down sampling
     if (resample_needed_flag) {
-            iir_resample_process(uplink_resample_st, (int16_t *)pcm_buf_16bits, resample_buf, pcm_len);
+      iir_resample_process(uplink_resample_st, (int16_t *)pcm_buf_16bits,
+                           resample_buf, pcm_len);
       pcm_buf_16bits = resample_buf;
       pcm_len = sco_frame_length;
     }
 
-        process_uplink_cvsd_frames((uint8_t *)pcm_buf_16bits, pcm_len * sizeof(int16_t), out_buf, out_len);
+    process_uplink_cvsd_frames((uint8_t *)pcm_buf_16bits,
+                               pcm_len * sizeof(int16_t), out_buf, out_len);
   }
   return 0;
 }
 
-int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len, unsigned char *pcm_buf,unsigned int pcm_len)
+int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
-{
+                                 unsigned char *pcm_buf, unsigned int pcm_len) {
 #if defined(HFP_1_6_ENABLE)
 
-
   btif_sbc_pcm_data_t pcm_data;
   unsigned int msbc_offset_lowdelay = 0;
   unsigned int i, j;
@@ -284,18 +311,21 @@ int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
   unsigned int frame_counter = 0;
   unsigned short byte_decode = 0;
   unsigned int msbc_offset_total = 0;
-    int msbc_offset_drift[6] = {0, };
+  int msbc_offset_drift[6] = {
+      0,
+  };
 
   short *dec_pcm_buf = (short *)pcm_buf;
-    unsigned char dec_msbc_buf[MSBC_LEN_PER_FRAME] = {0, };
+  unsigned char dec_msbc_buf[MSBC_LEN_PER_FRAME] = {
+      0,
+  };
 
   // unsigned int timer_begin=hal_sys_timer_get();
 
   // TRACE(2,"process_downlink_msbc_frames:pcm_len:%d,msbc_len:%d",pcm_len,msbc_len);
 
   // TRACE(1,"decode_msbc_frame,msbc_len:%d",msbc_len);
-    for(i =0; i<msbc_len; i++)
+  for (i = 0; i < msbc_len; i++) {
-    {
     msbc_buf_all[i + MSBC_LEN_FORMBT_PER_FRAME] = msbc_buffer[i];
   }
 
@@ -308,37 +338,31 @@ int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
   }
   */
 
-    for(j =0; j<msbc_len/MSBC_LEN_FORMBT_PER_FRAME; j++)
+  for (j = 0; j < msbc_len / MSBC_LEN_FORMBT_PER_FRAME; j++) {
-    {
     frame_flag[j] = 0;
   }
 
-    if(msbc_find_first_sync==0)
+  if (msbc_find_first_sync == 0) {
-    {
+    for (i = 0; i < msbc_len; i++) {
-        for(i =0; i<msbc_len; i++)
+      if ((msbc_buf_all[i] == 0x01) && ((msbc_buf_all[i + 1] & 0x0f) == 0x08) &&
-        {
+          (msbc_buf_all[i + 2] == 0xad))
-            if((msbc_buf_all[i]==0x01)&&((msbc_buf_all[i+1]&0x0f)==0x08)&&(msbc_buf_all[i+2]==0xad))break;
+        break;
     }
 
     TRACE(1, "sync......:%d", i);
 
-        if(i<msbc_len)
+    if (i < msbc_len) {
-        {
       msbc_find_first_sync = 1;
       msbc_offset = i % MSBC_LEN_FORMBT_PER_FRAME;
       msbc_offset_total = i;
-        }
+    } else {
-    else
+      for (j = 0; j < msbc_len / MSBC_LEN_FORMBT_PER_FRAME; j++) {
-    {
-        for (j = 0; j < msbc_len / MSBC_LEN_FORMBT_PER_FRAME; j++)
-        {
         frame_flag[j] = 1;
       }
     }
   }
 
-    if(msbc_find_first_sync==1)
+  if (msbc_find_first_sync == 1) {
-    {
     int value = 0;
     unsigned char headerm1 = 0;
     unsigned char header0 = 0;
@@ -347,55 +371,53 @@ int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
     unsigned char header3 = 0;
     //        unsigned char tail0 = 0;
 
-    if(msbc_offset==0||msbc_offset==1)
+    if (msbc_offset == 0 || msbc_offset == 1) {
-    {
       msbc_offset_lowdelay = msbc_offset + 60;
       // msbc_offset_lowdelay=msbc_offset;
-    }
+    } else {
-     else
-    {
       msbc_offset_lowdelay = msbc_offset;
     }
 
-
     // check again
-        for(j =0; j<(msbc_len/MSBC_LEN_FORMBT_PER_FRAME); j++)
+    for (j = 0; j < (msbc_len / MSBC_LEN_FORMBT_PER_FRAME); j++) {
-        {
+      if (next_frame_flag == 1) {
-        if (next_frame_flag == 1)
-        {
         next_frame_flag = 0;
         frame_flag[j] = 1;
         continue;
       }
-        if(msbc_offset_lowdelay==0&&j==0)
+      if (msbc_offset_lowdelay == 0 && j == 0) {
-        {
         headerm1 = 0x01;
-        }
+      } else {
-        else
+        headerm1 = msbc_buf_all[msbc_offset_lowdelay +
-        {
+                                j * MSBC_LEN_FORMBT_PER_FRAME - 1];
-            headerm1 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME-1];
       }
 
-        header0 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME];
+      header0 =
-        header1 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME + 1];
+          msbc_buf_all[msbc_offset_lowdelay + j * MSBC_LEN_FORMBT_PER_FRAME];
-        header2 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME + 2];
+      header1 = msbc_buf_all[msbc_offset_lowdelay +
-        header3 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME + 3];
+                             j * MSBC_LEN_FORMBT_PER_FRAME + 1];
+      header2 = msbc_buf_all[msbc_offset_lowdelay +
+                             j * MSBC_LEN_FORMBT_PER_FRAME + 2];
+      header3 = msbc_buf_all[msbc_offset_lowdelay +
+                             j * MSBC_LEN_FORMBT_PER_FRAME + 3];
 
-        /*if ((headerm1 == 0x01) && ((header0 & 0x0f) == 0x08) && (header1 == 0xad) ||
+      /*if ((headerm1 == 0x01) && ((header0 & 0x0f) == 0x08) && (header1 ==
-            (header0 == 0x01) && ((header1 & 0x0f) == 0x08) && (header2 == 0xad) ||
+      0xad) || (header0 == 0x01) && ((header1 & 0x0f) == 0x08) && (header2 ==
-            (header1 == 0x01) && ((header2 & 0x0f) == 0x08) && (header3 == 0xad))
+      0xad) || (header1 == 0x01) && ((header2 & 0x0f) == 0x08) && (header3 ==
+      0xad))
       {
           frame_flag[j] = 0;
       }*/
-        if ((headerm1 == 0x01) && ((header0 & 0x0f) == 0x08) && (header1 == 0xad))
+      if ((headerm1 == 0x01) && ((header0 & 0x0f) == 0x08) &&
-        {
+          (header1 == 0xad)) {
         frame_flag[j] = 0;
         // It seems that offset is reduced by 1
         msbc_offset_drift[j] = -1;
         TRACE(1, "[%s] msbc_offset is reduced by 1", __FUNCTION__);
         /*
-            tail0 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME + 59 - 1];
+            tail0 = msbc_buf_all[msbc_offset_lowdelay +
-            if (tail0 == 0x00 || tail0 == 0x01|| tail0==0xff)
+           j*MSBC_LEN_FORMBT_PER_FRAME + 59 - 1]; if (tail0 == 0x00 || tail0 ==
+           0x01|| tail0==0xff)
             {
                 frame_flag[j] = 0;
             }
@@ -405,13 +427,13 @@ int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
                 next_frame_flag = 1;
             }
             */
-        }
+      } else if ((header0 == 0x01) && ((header1 & 0x0f) == 0x08) &&
-        else if ((header0 == 0x01) && ((header1 & 0x0f) == 0x08) && (header2 == 0xad))
+                 (header2 == 0xad)) {
-        {
         frame_flag[j] = 0;
         /*
-            tail0 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME + 59];
+            tail0 = msbc_buf_all[msbc_offset_lowdelay +
-            if (tail0 == 0x00 || tail0 == 0x01|| tail0==0xff)
+           j*MSBC_LEN_FORMBT_PER_FRAME + 59]; if (tail0 == 0x00 || tail0 ==
+           0x01|| tail0==0xff)
             {
                 frame_flag[j] = 0;
             }
@@ -421,15 +443,15 @@ int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
                 next_frame_flag = 1;
             }
             */
-        }
+      } else if ((header1 == 0x01) && ((header2 & 0x0f) == 0x08) &&
-        else if ((header1 == 0x01) && ((header2 & 0x0f) == 0x08) && (header3 == 0xad))
+                 (header3 == 0xad)) {
-        {
         frame_flag[j] = 0;
         msbc_offset_drift[j] = 1;
         TRACE(1, "[%s] msbc_offset is increased by 1", __FUNCTION__);
         /*
-            tail0 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME + 59 + 1];
+            tail0 = msbc_buf_all[msbc_offset_lowdelay +
-            if (tail0 == 0x00 || tail0==0x01|| tail0==0xff)
+           j*MSBC_LEN_FORMBT_PER_FRAME + 59 + 1]; if (tail0 == 0x00 ||
+           tail0==0x01|| tail0==0xff)
             {
                 frame_flag[j] = 0;
             }
@@ -439,54 +461,52 @@ int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
                 next_frame_flag = 1;
             }
             */
-        }
+      } else {
-        else
+        if ((header0 == MSBC_MUTE_PATTERN) &&
-        {
+            ((header1 & 0x0f) == (MSBC_MUTE_PATTERN & 0x0f)) &&
-            if ((header0 == MSBC_MUTE_PATTERN)&& ((header1 & 0x0f) == (MSBC_MUTE_PATTERN & 0x0f)) && (header2 == MSBC_MUTE_PATTERN))
+            (header2 == MSBC_MUTE_PATTERN)) {
-            {
           frame_flag[j] = 1;
-            }
+        } else {
-            else
+          if ((msbc_offset_lowdelay + j * MSBC_LEN_FORMBT_PER_FRAME) >=
-            {
+              msbc_offset_total) {
-                if((msbc_offset_lowdelay+j*MSBC_LEN_FORMBT_PER_FRAME)>=msbc_offset_total)
-                {
             frame_flag[j] = 3;
-             }
+          } else {
-             else
-             {
             frame_flag[j] = 1;
           }
         }
       }
     }
 
-        for(j =0; j<msbc_len/MSBC_LEN_FORMBT_PER_FRAME; j++)
+    for (j = 0; j < msbc_len / MSBC_LEN_FORMBT_PER_FRAME; j++) {
-        {
       value = value | frame_flag[j];
     }
     // abnormal msbc packet.
-        if(value>1)msbc_find_first_sync=0;
+    if (value > 1)
+      msbc_find_first_sync = 0;
   }
 
-    while((frame_counter<msbc_len/MSBC_LEN_FORMBT_PER_FRAME)&&(frame_counter<pcm_len/BYTES_PER_PCM_FRAME))
+  while ((frame_counter < msbc_len / MSBC_LEN_FORMBT_PER_FRAME) &&
-    {
+         (frame_counter < pcm_len / BYTES_PER_PCM_FRAME)) {
-        //TRACE(3,"[%s] decoding, offset %d, offset drift %d", __FUNCTION__, msbc_offset, msbc_offset_drift[frame_counter]);
+    // TRACE(3,"[%s] decoding, offset %d, offset drift %d", __FUNCTION__,
+    // msbc_offset, msbc_offset_drift[frame_counter]);
     // skip first byte when msbc_offset == 0 and msbc_offset_drift == -1
     unsigned int start_idx = 0;
     if (msbc_offset_lowdelay == 0 && msbc_offset_drift[frame_counter] == -1) {
       start_idx = 1;
       dec_msbc_buf[0] = 0x01;
     }
-        for(i = start_idx; i<MSBC_LEN_PER_FRAME; i++)
+    for (i = start_idx; i < MSBC_LEN_PER_FRAME; i++) {
-        {
       // DecMsbcBuf[i]=DecMsbcBufAll[i+msbc_offset_lowdelay+frame_counter*MSBC_LEN_FORMBT_PER_FRAME+2];
-            dec_msbc_buf[i]=msbc_buf_all[i+msbc_offset_lowdelay+msbc_offset_drift[frame_counter]+frame_counter*MSBC_LEN_FORMBT_PER_FRAME];
+      dec_msbc_buf[i] = msbc_buf_all[i + msbc_offset_lowdelay +
+                                     msbc_offset_drift[frame_counter] +
+                                     frame_counter * MSBC_LEN_FORMBT_PER_FRAME];
     }
 
     // TRACE(1,"msbc header:0x%x",DecMsbcBuf[0]);
 
 #ifdef SPEECH_RX_PLC_DUMP_DATA
-        audio_dump_add_channel_data(2, (short *)dec_msbc_buf, MSBC_LEN_PER_FRAME/2);
+    audio_dump_add_channel_data(2, (short *)dec_msbc_buf,
+                                MSBC_LEN_PER_FRAME / 2);
 #endif
 
     plc_type_t plc_type = packet_loss_detection_process(&pld, dec_msbc_buf);
@@ -501,13 +521,12 @@ int process_downlink_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_len,
     pcm_data.dataLen = 0;
     pcm_data.data = (uint8_t *)dec_pcm_buf;
 
-        ret = btif_sbc_decode_frames(msbc_decoder,
+    ret = btif_sbc_decode_frames(msbc_decoder, (unsigned char *)dec_msbc_buf,
-                (unsigned char *)dec_msbc_buf,
+                                 MSBC_LEN_PER_FRAME, &byte_decode, &pcm_data,
-                MSBC_LEN_PER_FRAME, &byte_decode,
+                                 SAMPLES_LEN_PER_FRAME * 2, msbc_eq_band_gain);
-                &pcm_data, SAMPLES_LEN_PER_FRAME*2,
-                msbc_eq_band_gain);
 
-        //ASSERT(ret == BT_STS_SUCCESS, "[%s] msbc decoder should never fail", __FUNCTION__);
+    // ASSERT(ret == BT_STS_SUCCESS, "[%s] msbc decoder should never fail",
+    // __FUNCTION__);
     if (ret != BT_STS_SUCCESS) {
       plc_type = PLC_TYPE_DECODER_ERROR;
       packet_loss_detection_update_histogram(&pld, plc_type);
@@ -521,22 +540,21 @@ do_plc:
       PLC_good_frame(&msbc_plc_state, dec_pcm_buf, dec_pcm_buf);
 #endif
 #ifdef SPEECH_RX_PLC_DUMP_DATA
-            audio_dump_add_channel_data(0, (short *)dec_pcm_buf, MSBC_ENCODE_PCM_LEN/2);
+      audio_dump_add_channel_data(0, (short *)dec_pcm_buf,
+                                  MSBC_ENCODE_PCM_LEN / 2);
 #endif
-        }
+    } else {
-        else
-        {
       TRACE(1, "PLC bad frame, plc type: %d", plc_type);
 #if defined(PLC_DEBUG_PRINT_DATA)
       DUMP8("0x%02x, ", dec_msbc_buf, 60);
 #endif
 
 #ifdef SPEECH_RX_PLC_DUMP_DATA
-            for(uint32_t i=0; i< MSBC_ENCODE_PCM_LEN/2; i++)
+      for (uint32_t i = 0; i < MSBC_ENCODE_PCM_LEN / 2; i++) {
-            {
         audio_dump_temp_buf[i] = (plc_type - 1) * 5000;
       }
-            audio_dump_add_channel_data(0, audio_dump_temp_buf, MSBC_ENCODE_PCM_LEN/2);
+      audio_dump_add_channel_data(0, audio_dump_temp_buf,
+                                  MSBC_ENCODE_PCM_LEN / 2);
 #endif
 #if defined(ENABLE_LPC_PLC)
       lpc_plc_generate(msbc_plc_state, dec_pcm_buf,
@@ -553,7 +571,8 @@ do_plc:
       pcm_data.dataLen = MSBC_ENCODE_PCM_LEN;
       pcm_data.data = (uint8_t *)(msbc_plc_encoder_buffer + MSBC_CODEC_DELAY);
 
-            btif_plc_update_sbc_decoder_state(msbc_plc_encoder, &pcm_data, msbc_decoder, msbc_eq_band_gain);
+      btif_plc_update_sbc_decoder_state(msbc_plc_encoder, &pcm_data,
+                                        msbc_decoder, msbc_eq_band_gain);
 #endif
 
 #else
@@ -562,20 +581,21 @@ do_plc:
       pcm_data.dataLen = 0;
       pcm_data.data = (uint8_t *)dec_pcm_buf;
 
-            ret = btif_sbc_decode_frames(msbc_decoder,
+      ret =
-                    (unsigned char *)indices0,
+          btif_sbc_decode_frames(msbc_decoder, (unsigned char *)indices0,
-                    MSBC_LEN_PER_FRAME, &byte_decode,
+                                 MSBC_LEN_PER_FRAME, &byte_decode, &pcm_data,
-                    &pcm_data, SAMPLES_LEN_PER_FRAME*2,
+                                 SAMPLES_LEN_PER_FRAME * 2, msbc_eq_band_gain);
-                    msbc_eq_band_gain);
 
       PLC_bad_frame(&msbc_plc_state, dec_pcm_buf, dec_pcm_buf);
 
-            ASSERT(ret == BT_STS_SUCCESS, "[%s] msbc decoder should never fail", __FUNCTION__);
+      ASSERT(ret == BT_STS_SUCCESS, "[%s] msbc decoder should never fail",
+             __FUNCTION__);
 #endif
     }
 
 #ifdef SPEECH_RX_PLC_DUMP_DATA
-        audio_dump_add_channel_data(1, (short *)dec_pcm_buf, MSBC_ENCODE_PCM_LEN/2);
+    audio_dump_add_channel_data(1, (short *)dec_pcm_buf,
+                                MSBC_ENCODE_PCM_LEN / 2);
     audio_dump_run();
 #endif
 
@@ -583,8 +603,7 @@ do_plc:
     frame_counter++;
   }
 
-    for(i =0; i<MSBC_LEN_FORMBT_PER_FRAME; i++)
+  for (i = 0; i < MSBC_LEN_FORMBT_PER_FRAME; i++) {
-    {
     msbc_buf_all[i] = msbc_buf_all[i + msbc_len];
   }
 #endif
@@ -602,11 +621,13 @@ do_plc:
 #endif
 #endif
 
-#define MSBC_OFFSET_HEADER0_BYTES ((MSBC_LEN_PER_FRAME-MSBC_OFFSET_BYTES)%MSBC_LEN_PER_FRAME)
+#define MSBC_OFFSET_HEADER0_BYTES                                              \
-#define MSBC_OFFSET_HEADER1_BYTES ((MSBC_LEN_PER_FRAME-MSBC_OFFSET_BYTES+1)%MSBC_LEN_PER_FRAME)
+  ((MSBC_LEN_PER_FRAME - MSBC_OFFSET_BYTES) % MSBC_LEN_PER_FRAME)
+#define MSBC_OFFSET_HEADER1_BYTES                                              \
+  ((MSBC_LEN_PER_FRAME - MSBC_OFFSET_BYTES + 1) % MSBC_LEN_PER_FRAME)
 
-int process_uplink_msbc_frames(unsigned char *pcm_buf, unsigned int pcm_len, unsigned char *msbc_buf,unsigned int msbc_len)
+int process_uplink_msbc_frames(unsigned char *pcm_buf, unsigned int pcm_len,
-{
+                               unsigned char *msbc_buf, unsigned int msbc_len) {
 #if defined(HFP_1_6_ENABLE)
   uint32_t frame_counter = 0;
   static uint32_t frame_counter_total = 0;
@@ -617,21 +638,23 @@ int process_uplink_msbc_frames(unsigned char *pcm_buf, unsigned int pcm_len, uns
 
   // TRACE(2,"process_uplink_msbc_frames:pcm_len:%d,msbc_len:%d",pcm_len,msbc_len);
 
-    while((frame_counter<msbc_len/MSBC_LEN_FORMBT_PER_FRAME)&&(frame_counter<pcm_len/BYTES_PER_PCM_FRAME))
+  while ((frame_counter < msbc_len / MSBC_LEN_FORMBT_PER_FRAME) &&
-    {
+         (frame_counter < pcm_len / BYTES_PER_PCM_FRAME)) {
     unsigned short *msbc_buf_dst_p;
     pcm_data_enc.data = pcm_buf + frame_counter * BYTES_PER_PCM_FRAME;
     pcm_data_enc.dataLen = BYTES_PER_PCM_FRAME;
 
-#if (MSBC_OFFSET_BYTES==0)||(MSBC_OFFSET_BYTES==1)||(MSBC_OFFSET_BYTES==2)
+#if (MSBC_OFFSET_BYTES == 0) || (MSBC_OFFSET_BYTES == 1) ||                    \
+    (MSBC_OFFSET_BYTES == 2)
     // body
-        btif_sbc_encode_frames(msbc_encoder, &pcm_data_enc, &bytes_encoded, &(msbc_buf_frame[2-MSBC_OFFSET_BYTES]), (uint16_t *)&msbc_len_frame, 0xFFFF);
+    btif_sbc_encode_frames(msbc_encoder, &pcm_data_enc, &bytes_encoded,
+                           &(msbc_buf_frame[2 - MSBC_OFFSET_BYTES]),
+                           (uint16_t *)&msbc_len_frame, 0xFFFF);
     // tail
     msbc_buf_frame[59 - MSBC_OFFSET_BYTES] = 0x00;
     // header
     msbc_buf_frame[MSBC_OFFSET_HEADER0_BYTES] = 0x01;
-        switch((frame_counter_total%4))
+    switch ((frame_counter_total % 4)) {
-        {
     case 0:
       msbc_buf_frame[MSBC_OFFSET_HEADER1_BYTES] = 0x08;
       break;
@@ -645,17 +668,18 @@ int process_uplink_msbc_frames(unsigned char *pcm_buf, unsigned int pcm_len, uns
       msbc_buf_frame[MSBC_OFFSET_HEADER1_BYTES] = 0xf8;
       break;
     }
-        msbc_buf_dst_p=(uint16_t *)(msbc_buf+frame_counter*MSBC_LEN_PER_FRAME*2);
+    msbc_buf_dst_p =
+        (uint16_t *)(msbc_buf + frame_counter * MSBC_LEN_PER_FRAME * 2);
 
-        for (int i = 0; i < MSBC_LEN_PER_FRAME; i++)
+    for (int i = 0; i < MSBC_LEN_PER_FRAME; i++) {
-        {
       msbc_buf_dst_p[i] = msbc_buf_frame[i] << 8;
     }
 #else
-        btif_sbc_encode_frames(msbc_encoder, &pcm_data_enc, &bytes_encoded, &(msbc_buf_frame[MSBC_LEN_PER_FRAME+2]), (uint16_t *)&msbc_len_frame, 0xFFFF);
+    btif_sbc_encode_frames(msbc_encoder, &pcm_data_enc, &bytes_encoded,
+                           &(msbc_buf_frame[MSBC_LEN_PER_FRAME + 2]),
+                           (uint16_t *)&msbc_len_frame, 0xFFFF);
     msbc_buf_frame[MSBC_LEN_PER_FRAME + 0] = 0x01;
-        switch((frame_counter_total%4))
+    switch ((frame_counter_total % 4)) {
-        {
     case 0:
       msbc_buf_frame[MSBC_LEN_PER_FRAME + 1] = 0x08;
       break;
@@ -670,15 +694,14 @@ int process_uplink_msbc_frames(unsigned char *pcm_buf, unsigned int pcm_len, uns
       break;
     }
     msbc_buf_frame[MSBC_LEN_PER_FRAME + 59] = 0x00;
-        msbc_buf_dst_p=(uint16_t *)(msbc_buf+frame_counter*MSBC_LEN_PER_FRAME*2);
+    msbc_buf_dst_p =
+        (uint16_t *)(msbc_buf + frame_counter * MSBC_LEN_PER_FRAME * 2);
 
-              for (int i = 0; i < MSBC_LEN_PER_FRAME; i++)
+    for (int i = 0; i < MSBC_LEN_PER_FRAME; i++) {
-              {
       msbc_buf_dst_p[i] = msbc_buf_frame[MSBC_OFFSET_BYTES + i] << 8;
     }
 
-              for (int i = 0; i < MSBC_LEN_PER_FRAME; i++)
+    for (int i = 0; i < MSBC_LEN_PER_FRAME; i++) {
-              {
       msbc_buf_frame[i] = msbc_buf_frame[MSBC_LEN_PER_FRAME + i];
     }
 #endif
@@ -703,10 +726,10 @@ int process_uplink_msbc_frames(unsigned char *pcm_buf, unsigned int pcm_len, uns
 
 #define CVSD_PCM_SIZE (120)
 
-static POSSIBLY_UNUSED uint8_t cvsd_buf_all[CVSD_PACKET_SIZE + CVSD_OFFSET_BYTES];
+static POSSIBLY_UNUSED uint8_t
+    cvsd_buf_all[CVSD_PACKET_SIZE + CVSD_OFFSET_BYTES];
 
-POSSIBLY_UNUSED plc_type_t check_cvsd_mute_pattern(uint8_t *buf, uint32_t len)
+POSSIBLY_UNUSED plc_type_t check_cvsd_mute_pattern(uint8_t *buf, uint32_t len) {
-{
   for (uint32_t i = 0; i < len; i++)
     if (buf[i] != CVSD_MUTE_PATTERN)
       return PLC_TYPE_PASS;
@@ -714,12 +737,14 @@ POSSIBLY_UNUSED plc_type_t check_cvsd_mute_pattern(uint8_t *buf, uint32_t len)
   return PLC_TYPE_CONTROLLER_MUTE;
 }
 
-int process_downlink_cvsd_frames(unsigned char *cvsd_buf, unsigned int cvsd_len, unsigned char *pcm_buf,unsigned int pcm_len)
+int process_downlink_cvsd_frames(unsigned char *cvsd_buf, unsigned int cvsd_len,
-{
+                                 unsigned char *pcm_buf, unsigned int pcm_len) {
-    //TRACE(2,"process_downlink_cvsd_frames  pcm_len:%d,cvsd_len:%d",pcm_len,cvsd_len);
+  // TRACE(2,"process_downlink_cvsd_frames
+  // pcm_len:%d,cvsd_len:%d",pcm_len,cvsd_len);
 
 #if defined(CVSD_BYPASS) && defined(ENABLE_LPC_PLC)
-    ASSERT(cvsd_len % CVSD_PACKET_SIZE == 0, "[%s] cvsd input length(%d) error", __FUNCTION__, cvsd_len);
+  ASSERT(cvsd_len % CVSD_PACKET_SIZE == 0, "[%s] cvsd input length(%d) error",
+         __FUNCTION__, cvsd_len);
   for (uint32_t i = 0; i < cvsd_len; i += CVSD_PACKET_SIZE) {
     memcpy(&cvsd_buf_all[CVSD_OFFSET_BYTES], cvsd_buf, CVSD_PACKET_SIZE);
     memcpy(cvsd_buf, cvsd_buf_all, CVSD_PACKET_SIZE);
@@ -763,19 +788,18 @@ do_plc:
 
   return 0;
 }
-int process_uplink_cvsd_frames(unsigned char *pcm_buf, unsigned int pcm_len, unsigned char *cvsd_buf,unsigned int cvsd_len)
+int process_uplink_cvsd_frames(unsigned char *pcm_buf, unsigned int pcm_len,
-{
+                               unsigned char *cvsd_buf, unsigned int cvsd_len) {
-    //TRACE(2,"process_uplink_cvsd_frames  pcm_len:%d,cvsd_len:%d",pcm_len,cvsd_len);
+  // TRACE(2,"process_uplink_cvsd_frames
+  // pcm_len:%d,cvsd_len:%d",pcm_len,cvsd_len);
 #if defined(CVSD_BYPASS)
   Pcm8kToCvsd((short *)pcm_buf, cvsd_buf, pcm_len / 2);
 #endif
   return 0;
 }
-void *voicebtpcm_get_ext_buff(int size)
+void *voicebtpcm_get_ext_buff(int size) {
-{
   uint8_t *pBuff = NULL;
-    if (size % 4)
+  if (size % 4) {
-    {
     size = size + (4 - size % 4);
   }
   app_audio_mempool_get_buff(&pBuff, size);
@@ -784,25 +808,29 @@ void *voicebtpcm_get_ext_buff(int size)
 }
 // sco sample rate: encoder/decoder sample rate
 // codec sample rate: hardware sample rate
-int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate)
+int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate) {
-{
   uint8_t POSSIBLY_UNUSED *speech_buf = NULL;
   int POSSIBLY_UNUSED speech_len = 0;
 
-    sco_frame_length = SPEECH_FRAME_MS_TO_LEN(sco_sample_rate, SPEECH_SCO_FRAME_MS);
+  sco_frame_length =
-    codec_frame_length = SPEECH_FRAME_MS_TO_LEN(codec_sample_rate, SPEECH_SCO_FRAME_MS);
+      SPEECH_FRAME_MS_TO_LEN(sco_sample_rate, SPEECH_SCO_FRAME_MS);
+  codec_frame_length =
+      SPEECH_FRAME_MS_TO_LEN(codec_sample_rate, SPEECH_SCO_FRAME_MS);
 
-    TRACE(3, "[%s] TX: sample rate = %d, frame len = %d", __func__, codec_sample_rate, codec_frame_length);
+  TRACE(3, "[%s] TX: sample rate = %d, frame len = %d", __func__,
-    TRACE(3, "[%s] RX: sample rate = %d, frame len = %d", __func__, codec_sample_rate, codec_frame_length);
+        codec_sample_rate, codec_frame_length);
+  TRACE(3, "[%s] RX: sample rate = %d, frame len = %d", __func__,
+        codec_sample_rate, codec_frame_length);
 
   memset(cvsd_buf_all, CVSD_MUTE_PATTERN, sizeof(cvsd_buf_all));
 #if defined(HFP_1_6_ENABLE)
 
   memset(msbc_buf_all, MSBC_MUTE_PATTERN & 0xFF, sizeof(msbc_buf_all));
-    if (bt_sco_codec_is_msbc())
+  if (bt_sco_codec_is_msbc()) {
-    {
+    app_audio_mempool_get_buff((uint8_t **)&msbc_encoder,
-        app_audio_mempool_get_buff((uint8_t **)&msbc_encoder, sizeof(btif_sbc_encoder_t));
+                               sizeof(btif_sbc_encoder_t));
-     app_audio_mempool_get_buff((uint8_t **)&msbc_decoder, sizeof(btif_sbc_decoder_t));
+    app_audio_mempool_get_buff((uint8_t **)&msbc_decoder,
+                               sizeof(btif_sbc_decoder_t));
 
     // init msbc encoder
     btif_sbc_init_encoder(msbc_encoder);
@@ -817,18 +845,15 @@ int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate)
     msbc_encoder->streamInfo.numSubBands = 8;
 
     // init msbc decoder
-        const float EQLevel[25] =
+    const float EQLevel[25] = {
-        {
         0.0630957, 0.0794328, 0.1,       0.1258925, 0.1584893,
         0.1995262, 0.2511886, 0.3162278, 0.398107,  0.5011872,
         0.6309573, 0.794328,  1,         1.258925,  1.584893,
         1.995262,  2.5118864, 3.1622776, 3.9810717, 5.011872,
-            6.309573,  7.943282, 10, 12.589254, 15.848932
+        6.309573,  7.943282,  10,        12.589254, 15.848932}; //-12~12
-        };//-12~12
     uint8_t i;
 
-        for (i=0; i<sizeof(msbc_eq_band_gain)/sizeof(float); i++)
+    for (i = 0; i < sizeof(msbc_eq_band_gain) / sizeof(float); i++) {
-        {
       msbc_eq_band_gain[i] = EQLevel[cfg_aud_eq_sbc_band_settings[i] + 12];
     }
 
@@ -856,7 +881,8 @@ int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate)
     packet_loss_detection_init(&pld);
 
 #if defined(ENABLE_PLC_ENCODER)
-        app_audio_mempool_get_buff((uint8_t **)&msbc_plc_encoder, sizeof(btif_sbc_encoder_t));
+    app_audio_mempool_get_buff((uint8_t **)&msbc_plc_encoder,
+                               sizeof(btif_sbc_encoder_t));
     btif_sbc_init_encoder(msbc_plc_encoder);
     msbc_plc_encoder->streamInfo.mSbcFlag = 1;
     msbc_plc_encoder->streamInfo.bitPool = 26;
@@ -868,10 +894,11 @@ int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate)
     /* The number of subbands in the stream (4 or 8) */
     msbc_plc_encoder->streamInfo.numSubBands = 8;
     msbc_plc_encoder->streamInfo.numChannels = 1;
-        app_audio_mempool_get_buff((uint8_t **)&msbc_plc_encoder_buffer, sizeof(int16_t) * (SAMPLES_LEN_PER_FRAME + MSBC_CODEC_DELAY));
+    app_audio_mempool_get_buff((uint8_t **)&msbc_plc_encoder_buffer,
+                               sizeof(int16_t) *
+                                   (SAMPLES_LEN_PER_FRAME + MSBC_CODEC_DELAY));
 #endif
-    }
+  } else
-    else
 #endif
   {
 #ifndef ENABLE_LPC_PLC
@@ -884,7 +911,8 @@ int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate)
 #endif
 
 #ifdef SPEECH_RX_PLC_DUMP_DATA
-    audio_dump_temp_buf = (int16_t *)voicebtpcm_get_ext_buff(sizeof(int16_t) * 120);
+  audio_dump_temp_buf =
+      (int16_t *)voicebtpcm_get_ext_buff(sizeof(int16_t) * 120);
   audio_dump_init(120, sizeof(short), 3);
 #endif
 
@@ -892,12 +920,15 @@ int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate)
 
   if (resample_needed_flag) {
     TRACE(1, "[%s] SCO <-- Resample --> CODEC", __func__);
-        resample_buf = (int16_t *)voicebtpcm_get_ext_buff(sizeof(int16_t) * sco_frame_length);
+    resample_buf =
+        (int16_t *)voicebtpcm_get_ext_buff(sizeof(int16_t) * sco_frame_length);
   }
 
 #if defined(SCO_OPTIMIZE_FOR_RAM)
-    sco_overlay_ram_buf_len = hal_overlay_get_text_free_size((enum HAL_OVERLAY_ID_T)APP_OVERLAY_HFP);
+  sco_overlay_ram_buf_len =
-    sco_overlay_ram_buf = (uint8_t *)hal_overlay_get_text_free_addr((enum HAL_OVERLAY_ID_T)APP_OVERLAY_HFP);
+      hal_overlay_get_text_free_size((enum HAL_OVERLAY_ID_T)APP_OVERLAY_HFP);
+  sco_overlay_ram_buf = (uint8_t *)hal_overlay_get_text_free_addr(
+      (enum HAL_OVERLAY_ID_T)APP_OVERLAY_HFP);
 #endif
 
   speech_len = app_audio_mempool_free_buff_size() - APP_BT_STREAM_USE_BUF_SIZE;
@@ -905,11 +936,16 @@ int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate)
 
   int tx_frame_ms = SPEECH_PROCESS_FRAME_MS;
   int rx_frame_ms = SPEECH_SCO_FRAME_MS;
-    speech_init(codec_sample_rate, codec_sample_rate, tx_frame_ms, rx_frame_ms, SPEECH_SCO_FRAME_MS, speech_buf, speech_len);
+  speech_init(codec_sample_rate, codec_sample_rate, tx_frame_ms, rx_frame_ms,
+              SPEECH_SCO_FRAME_MS, speech_buf, speech_len);
 
   if (resample_needed_flag) {
-        uplink_resample_st = iir_resample_init(codec_frame_length, iir_resample_choose_mode(codec_sample_rate, sco_sample_rate));
+    uplink_resample_st = iir_resample_init(
-        downlink_resample_st = iir_resample_init(sco_frame_length, iir_resample_choose_mode(sco_sample_rate, codec_sample_rate));
+        codec_frame_length,
+        iir_resample_choose_mode(codec_sample_rate, sco_sample_rate));
+    downlink_resample_st = iir_resample_init(
+        sco_frame_length,
+        iir_resample_choose_mode(sco_sample_rate, codec_sample_rate));
   }
 
 #if defined(ENABLE_LPC_PLC)
@@ -919,10 +955,10 @@ int voicebtpcm_pcm_audio_init(int sco_sample_rate, int codec_sample_rate)
   return 0;
 }
 
-int voicebtpcm_pcm_audio_deinit(void)
+int voicebtpcm_pcm_audio_deinit(void) {
-{
   TRACE(1, "[%s] Close...", __func__);
-    // TRACE(2,"[%s] app audio buffer free = %d", __func__, app_audio_mempool_free_buff_size());
+  // TRACE(2,"[%s] app audio buffer free = %d", __func__,
+  // app_audio_mempool_free_buff_size());
 
 #if defined(ENABLE_LPC_PLC)
   lpc_plc_destroy(msbc_plc_state);

apps/audioplayers/wavplay.cpp

@@ -17,23 +17,22 @@
 #include "mbed.h"
 #endif
 // Standard C Included Files
-#include <string.h>
 #include <math.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-#include "hal_uart.h"
-#include "hal_trace.h"
 #include "hal_timer.h"
+#include "hal_trace.h"
+#include "hal_uart.h"
 
 /*!
  *  * @brief Standard Winodws PCM wave file header length
  *   */
 #define WAVE_FILE_HEADER_SIZE 0x2CU
 
-typedef struct wave_header
+typedef struct wave_header {
-{
   uint8_t riff[4];
   uint32_t size;
   uint8_t waveFlag[4];
@@ -52,8 +51,7 @@ typedef struct wave_header
 /*!
  *  * @brief Wave file structure
  *   */
-typedef struct wave_file
+typedef struct wave_file {
-{
   wave_header_t header;
   uint32_t *data;
 } wave_file_t;
@@ -71,16 +69,13 @@ static int32_t (*wav_file_playback_callback)(int32_t ) = NULL;
 ////////////////////////////////////////////////////////////////////////////////
 // Code
 ////////////////////////////////////////////////////////////////////////////////
-void wav_file_set_playeback_cb(int32_t (* cb)(int32_t))
+void wav_file_set_playeback_cb(int32_t (*cb)(int32_t)) {
-{
   wav_file_playback_callback = cb;
 }
-bool wav_file_isplaydone(void)
+bool wav_file_isplaydone(void) {
-{
   return (g_curr_play_index >= g_total_play_count) ? true : false;
 }
-uint32_t wav_file_audio_more_data(uint8_t *buf, uint32_t len)
+uint32_t wav_file_audio_more_data(uint8_t *buf, uint32_t len) {
-{
   //    static uint32_t g_preIrqTime = 0;
   uint32_t reallen = 0;
   //    int32_t stime,etime;
@@ -107,7 +102,9 @@ uint32_t wav_file_audio_more_data(uint8_t *buf, uint32_t len)
     return (len);
   }
 
-//  TRACE(5,"wav_file_audio_more_data irqDur:%d fsSpend:%d, readbuff:0x%08x %d/%d\n ", TICKS_TO_MS(stime - g_preIrqTime),TICKS_TO_MS(etime - stime),buf,reallen,len);
+  //  TRACE(5,"wav_file_audio_more_data irqDur:%d fsSpend:%d, readbuff:0x%08x
+  //  %d/%d\n ", TICKS_TO_MS(stime - g_preIrqTime),TICKS_TO_MS(etime -
+  //  stime),buf,reallen,len);
   //    g_preIrqTime = stime;
 
   /* walk index */
@@ -116,15 +113,13 @@ uint32_t wav_file_audio_more_data(uint8_t *buf, uint32_t len)
   return reallen;
 }
 
-uint32_t get_wav_data(wave_file_t *waveFile)
+uint32_t get_wav_data(wave_file_t *waveFile) {
-{
   uint8_t *dataTemp = (uint8_t *)waveFile->data;
 
   // check for RIFF
   memcpy(waveFile->header.riff, dataTemp, 4);
   dataTemp += 4;
-    if( memcmp( (uint8_t*)waveFile->header.riff, "RIFF", 4) )
+  if (memcmp((uint8_t *)waveFile->header.riff, "RIFF", 4)) {
-    {
     return 0;
   }
 
@@ -137,16 +132,14 @@ uint32_t get_wav_data(wave_file_t *waveFile)
   // .wav file flag
   memcpy(waveFile->header.waveFlag, dataTemp, 4);
   dataTemp += 4;
-    if( memcmp( (uint8_t*)waveFile->header.waveFlag, "WAVE", 4) )
+  if (memcmp((uint8_t *)waveFile->header.waveFlag, "WAVE", 4)) {
-    {
     return 0;
   }
 
   // fmt
   memcpy(waveFile->header.fmt, dataTemp, 4);
   dataTemp += 4;
-    if( memcmp( (uint8_t*)waveFile->header.fmt, "fmt ", 4) )
+  if (memcmp((uint8_t *)waveFile->header.fmt, "fmt ", 4)) {
-    {
     return 0;
   }
 
@@ -184,8 +177,7 @@ uint32_t get_wav_data(wave_file_t *waveFile)
   // Data
   memcpy(waveFile->header.dataFlag, dataTemp, 4);
   dataTemp += 4;
-    if( memcmp( (uint8_t*)waveFile->header.dataFlag, "data ", 4) )
+  if (memcmp((uint8_t *)waveFile->header.dataFlag, "data ", 4)) {
-    {
     return 0;
   }
   memcpy(&waveFile->header.length, dataTemp, 4);
@@ -194,9 +186,7 @@ uint32_t get_wav_data(wave_file_t *waveFile)
   return 0;
 }
 
-
+void audio_wav_init(wave_file_t *newWav) {
-void audio_wav_init(wave_file_t *newWav)
-{
   get_wav_data(newWav);
 
   // Configure the play audio g_format
@@ -206,8 +196,7 @@ void audio_wav_init(wave_file_t *newWav)
   // g_format.mono_streo = (sai_mono_streo_t)((newWav->header.channels) - 1);
 }
 
-uint32_t play_wav_file(char *file_path)
+uint32_t play_wav_file(char *file_path) {
-{
   uint32_t bytesToRead = 0;
 
   wave_file_t *newWav = &g_wave_file_info;
@@ -228,7 +217,8 @@ uint32_t play_wav_file(char *file_path)
   audio_wav_init(newWav);
 
   // Remove header size from byte count
-    // Adjust note duration by divider value, wav tables in pcm_data.h are 200ms by default
+  // Adjust note duration by divider value, wav tables in pcm_data.h are 200ms
+  // by default
   bytesToRead = (newWav->header.length - WAVE_FILE_HEADER_SIZE);
 
   g_curr_play_index = 0;
@@ -237,8 +227,7 @@ uint32_t play_wav_file(char *file_path)
   return newWav->header.sampFreq;
 }
 
-uint32_t stop_wav_file(void)
+uint32_t stop_wav_file(void) {
-{
   memset(&g_wave_file_info, 0, sizeof(g_wave_file_info));
   g_curr_play_index = 0;
   g_total_play_count = 0;

apps/battery/app_battery.cpp

@@ -13,19 +13,19 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_battery.h"
+#include "app_status_ind.h"
+#include "app_thread.h"
+#include "apps.h"
 #include "cmsis_os.h"
-#include "tgt_hardware.h"
+#include "hal_chipid.h"
-#include "pmu.h"
-#include "hal_timer.h"
 #include "hal_gpadc.h"
-#include "hal_trace.h"
 #include "hal_gpio.h"
 #include "hal_iomux.h"
-#include "hal_chipid.h"
+#include "hal_timer.h"
-#include "app_thread.h"
+#include "hal_trace.h"
-#include "app_battery.h"
+#include "pmu.h"
-#include "apps.h"
+#include "tgt_hardware.h"
-#include "app_status_ind.h"
 #ifdef BT_USB_AUDIO_DUAL_MODE
 #include "btusb_audio.h"
 #endif
@@ -74,21 +74,31 @@ extern "C" bool app_usbaudio_mode_on(void);
 #define CHARGER_PLUGINOUT_DEBOUNCE_CNT (3)
 #endif
 
-#define APP_BATTERY_CHARGING_PLUGOUT_DEDOUNCE_CNT (APP_BATTERY_CHARGING_PERIODIC_MS<500?3:1)
+#define APP_BATTERY_CHARGING_PLUGOUT_DEDOUNCE_CNT                              \
+  (APP_BATTERY_CHARGING_PERIODIC_MS < 500 ? 3 : 1)
 
-#define APP_BATTERY_CHARGING_EXTPIN_MEASURE_CNT (APP_BATTERY_CHARGING_PERIODIC_MS<2*1000?2*1000/APP_BATTERY_CHARGING_PERIODIC_MS:1)
+#define APP_BATTERY_CHARGING_EXTPIN_MEASURE_CNT                                \
+  (APP_BATTERY_CHARGING_PERIODIC_MS < 2 * 1000                                 \
+       ? 2 * 1000 / APP_BATTERY_CHARGING_PERIODIC_MS                           \
+       : 1)
 #define APP_BATTERY_CHARGING_EXTPIN_DEDOUNCE_CNT (6)
 
-#define APP_BATTERY_CHARGING_OVERVOLT_MEASURE_CNT (APP_BATTERY_CHARGING_PERIODIC_MS<2*1000?2*1000/APP_BATTERY_CHARGING_PERIODIC_MS:1)
+#define APP_BATTERY_CHARGING_OVERVOLT_MEASURE_CNT                              \
+  (APP_BATTERY_CHARGING_PERIODIC_MS < 2 * 1000                                 \
+       ? 2 * 1000 / APP_BATTERY_CHARGING_PERIODIC_MS                           \
+       : 1)
 #define APP_BATTERY_CHARGING_OVERVOLT_DEDOUNCE_CNT (3)
 
-#define APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT (APP_BATTERY_CHARGING_PERIODIC_MS<20*1000?20*1000/APP_BATTERY_CHARGING_PERIODIC_MS:1)
+#define APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT                                 \
+  (APP_BATTERY_CHARGING_PERIODIC_MS < 20 * 1000                                \
+       ? 20 * 1000 / APP_BATTERY_CHARGING_PERIODIC_MS                          \
+       : 1)
 #define APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT (6)
 
-
 #define APP_BATTERY_REPORT_INTERVAL (5)
 
-#define APP_BATTERY_MV_BASE ((APP_BATTERY_MAX_MV-APP_BATTERY_PD_MV)/(APP_BATTERY_LEVEL_NUM))
+#define APP_BATTERY_MV_BASE                                                    \
+  ((APP_BATTERY_MAX_MV - APP_BATTERY_PD_MV) / (APP_BATTERY_LEVEL_NUM))
 
 #define APP_BATTERY_STABLE_COUNT (5)
 #define APP_BATTERY_MEASURE_PERIODIC_FAST_MS (200)
@@ -97,15 +107,17 @@ extern "C" bool app_usbaudio_mode_on(void);
 #else
 #define APP_BATTERY_MEASURE_PERIODIC_NORMAL_MS (10000)
 #endif
-#define APP_BATTERY_CHARGING_PERIODIC_MS (APP_BATTERY_MEASURE_PERIODIC_NORMAL_MS)
+#define APP_BATTERY_CHARGING_PERIODIC_MS                                       \
+  (APP_BATTERY_MEASURE_PERIODIC_NORMAL_MS)
 
-#define APP_BATTERY_SET_MESSAGE(appevt, status, volt) (appevt = (((uint32_t)status&0xffff)<<16)|(volt&0xffff))
+#define APP_BATTERY_SET_MESSAGE(appevt, status, volt)                          \
-#define APP_BATTERY_GET_STATUS(appevt, status) (status = (appevt>>16)&0xffff)
+  (appevt = (((uint32_t)status & 0xffff) << 16) | (volt & 0xffff))
+#define APP_BATTERY_GET_STATUS(appevt, status)                                 \
+  (status = (appevt >> 16) & 0xffff)
 #define APP_BATTERY_GET_VOLT(appevt, volt) (volt = appevt & 0xffff)
 #define APP_BATTERY_GET_PRAMS(appevt, prams) ((prams) = appevt & 0xffff)
 
-enum APP_BATTERY_MEASURE_PERIODIC_T
+enum APP_BATTERY_MEASURE_PERIODIC_T {
-{
   APP_BATTERY_MEASURE_PERIODIC_FAST = 0,
   APP_BATTERY_MEASURE_PERIODIC_NORMAL,
   APP_BATTERY_MEASURE_PERIODIC_CHARGING,
@@ -113,19 +125,17 @@ enum APP_BATTERY_MEASURE_PERIODIC_T
   APP_BATTERY_MEASURE_PERIODIC_QTY,
 };
 
-struct APP_BATTERY_MEASURE_CHARGER_STATUS_T
+struct APP_BATTERY_MEASURE_CHARGER_STATUS_T {
-{
   HAL_GPADC_MV_T prevolt;
   int32_t slope_1000[APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT];
   int slope_1000_index;
   int cnt;
 };
 
+typedef void (*APP_BATTERY_EVENT_CB_T)(enum APP_BATTERY_STATUS_T,
+                                       APP_BATTERY_MV_T volt);
 
-typedef void (*APP_BATTERY_EVENT_CB_T)(enum APP_BATTERY_STATUS_T, APP_BATTERY_MV_T volt);
+struct APP_BATTERY_MEASURE_T {
-
-struct APP_BATTERY_MEASURE_T
-{
   uint32_t start_time;
   enum APP_BATTERY_STATUS_T status;
 #ifdef __INTERCONNECTION__
@@ -152,7 +162,8 @@ static enum APP_BATTERY_CHARGER_T app_battery_charger_forcegetstatus(void);
 
 static void app_battery_pluginout_debounce_start(void);
 static void app_battery_pluginout_debounce_handler(void const *param);
-osTimerDef (APP_BATTERY_PLUGINOUT_DEBOUNCE, app_battery_pluginout_debounce_handler);
+osTimerDef(APP_BATTERY_PLUGINOUT_DEBOUNCE,
+           app_battery_pluginout_debounce_handler);
 static osTimerId app_battery_pluginout_debounce_timer = NULL;
 static uint32_t app_battery_pluginout_debounce_ctx = 0;
 static uint32_t app_battery_pluginout_debounce_cnt = 0;
@@ -165,59 +176,47 @@ static struct APP_BATTERY_MEASURE_T app_battery_measure;
 static int app_battery_charger_handle_process(void);
 
 #ifdef __INTERCONNECTION__
-uint8_t* app_battery_get_mobile_support_self_defined_command_p(void)
+uint8_t *app_battery_get_mobile_support_self_defined_command_p(void) {
-{
   return &app_battery_measure.isMobileSupportSelfDefinedCommand;
 }
 #endif
 
-
+void app_battery_irqhandler(uint16_t irq_val, HAL_GPADC_MV_T volt) {
-void app_battery_irqhandler(uint16_t irq_val, HAL_GPADC_MV_T volt)
-{
   uint8_t i;
   uint32_t meanBattVolt = 0;
   HAL_GPADC_MV_T vbat = volt;
   APP_BATTERY_TRACE(2, "%s %d", __func__, vbat);
-    if (vbat == HAL_GPADC_BAD_VALUE)
+  if (vbat == HAL_GPADC_BAD_VALUE) {
-    {
     app_battery_measure.cb(APP_BATTERY_STATUS_INVALID, vbat);
     return;
   }
 
 #if (defined(BTUSB_AUDIO_MODE) || defined(BTUSB_AUDIO_MODE))
-    if(app_usbaudio_mode_on()) return ;
+  if (app_usbaudio_mode_on())
+    return;
 #endif
-    app_battery_measure.voltage[app_battery_measure.index++%APP_BATTERY_STABLE_COUNT] = vbat<<2;
+  app_battery_measure
+      .voltage[app_battery_measure.index++ % APP_BATTERY_STABLE_COUNT] = vbat
+                                                                         << 2;
 
-    if (app_battery_measure.index > APP_BATTERY_STABLE_COUNT)
+  if (app_battery_measure.index > APP_BATTERY_STABLE_COUNT) {
-    {
+    for (i = 0; i < APP_BATTERY_STABLE_COUNT; i++) {
-        for (i=0; i<APP_BATTERY_STABLE_COUNT; i++)
-        {
       meanBattVolt += app_battery_measure.voltage[i];
     }
     meanBattVolt /= APP_BATTERY_STABLE_COUNT;
-        if (app_battery_measure.cb)
+    if (app_battery_measure.cb) {
-        {
+      if (meanBattVolt > app_battery_measure.highvolt) {
-            if (meanBattVolt>app_battery_measure.highvolt)
-            {
         app_battery_measure.cb(APP_BATTERY_STATUS_OVERVOLT, meanBattVolt);
-            }
+      } else if ((meanBattVolt > app_battery_measure.pdvolt) &&
-            else if((meanBattVolt>app_battery_measure.pdvolt) && (meanBattVolt<app_battery_measure.lowvolt))
+                 (meanBattVolt < app_battery_measure.lowvolt)) {
-            {
         app_battery_measure.cb(APP_BATTERY_STATUS_UNDERVOLT, meanBattVolt);
-            }
+      } else if (meanBattVolt < app_battery_measure.pdvolt) {
-            else if(meanBattVolt<app_battery_measure.pdvolt)
-            {
         app_battery_measure.cb(APP_BATTERY_STATUS_PDVOLT, meanBattVolt);
-            }
+      } else {
-            else
-            {
         app_battery_measure.cb(APP_BATTERY_STATUS_NORMAL, meanBattVolt);
       }
     }
-    }
+  } else {
-    else
-    {
     int8_t level = 0;
     meanBattVolt = vbat << 2;
     level = (meanBattVolt - APP_BATTERY_PD_MV) / APP_BATTERY_MV_BASE;
@@ -229,7 +228,8 @@ void app_battery_irqhandler(uint16_t irq_val, HAL_GPADC_MV_T volt)
 
     app_battery_measure.currvolt = meanBattVolt;
 #ifdef __INTERCONNECTION__
-        APP_BATTERY_INFO_T* pBatteryInfo = (APP_BATTERY_INFO_T*)&app_battery_measure.currentBatteryInfo;
+    APP_BATTERY_INFO_T *pBatteryInfo =
+        (APP_BATTERY_INFO_T *)&app_battery_measure.currentBatteryInfo;
     pBatteryInfo->batteryLevel = level;
 #else
     app_battery_measure.currlevel = level;
@@ -237,14 +237,13 @@ void app_battery_irqhandler(uint16_t irq_val, HAL_GPADC_MV_T volt)
   }
 }
 
-static void app_battery_timer_start(enum APP_BATTERY_MEASURE_PERIODIC_T periodic)
+static void
-{
+app_battery_timer_start(enum APP_BATTERY_MEASURE_PERIODIC_T periodic) {
   uint32_t periodic_millisec = 0;
 
   if (app_battery_measure.periodic != periodic) {
     app_battery_measure.periodic = periodic;
-        switch (periodic)
+    switch (periodic) {
-        {
     case APP_BATTERY_MEASURE_PERIODIC_FAST:
       periodic_millisec = APP_BATTERY_MEASURE_PERIODIC_FAST_MS;
       break;
@@ -261,13 +260,13 @@ static void app_battery_timer_start(enum APP_BATTERY_MEASURE_PERIODIC_T periodic
   }
 }
 
-static void app_battery_timer_handler(void const *param)
+static void app_battery_timer_handler(void const *param) {
-{
+  hal_gpadc_open(HAL_GPADC_CHAN_BATTERY, HAL_GPADC_ATP_ONESHOT,
-    hal_gpadc_open(HAL_GPADC_CHAN_BATTERY, HAL_GPADC_ATP_ONESHOT, app_battery_irqhandler);
+                 app_battery_irqhandler);
 }
 
-static void app_battery_event_process(enum APP_BATTERY_STATUS_T status, APP_BATTERY_MV_T volt)
+static void app_battery_event_process(enum APP_BATTERY_STATUS_T status,
-{
+                                      APP_BATTERY_MV_T volt) {
   uint32_t app_battevt;
   APP_MESSAGE_BLOCK msg;
 
@@ -277,15 +276,13 @@ static void app_battery_event_process(enum APP_BATTERY_STATUS_T status, APP_BATT
   msg.msg_body.message_id = app_battevt;
   msg.msg_body.message_ptr = (uint32_t)NULL;
   app_mailbox_put(&msg);
-
 }
 
-int app_battery_handle_process_normal(uint32_t status,  union APP_BATTERY_MSG_PRAMS prams)
+int app_battery_handle_process_normal(uint32_t status,
-{
+                                      union APP_BATTERY_MSG_PRAMS prams) {
   int8_t level = 0;
 
-    switch (status)
+  switch (status) {
-    {
   case APP_BATTERY_STATUS_UNDERVOLT:
     TRACE(1, "UNDERVOLT:%d", prams.volt);
     app_status_indication_set(APP_STATUS_INDICATION_CHARGENEED);
@@ -307,14 +304,12 @@ int app_battery_handle_process_normal(uint32_t status,  union APP_BATTERY_MSG_PR
       level = APP_BATTERY_LEVEL_MAX;
 #ifdef __INTERCONNECTION__
     APP_BATTERY_INFO_T *pBatteryInfo;
-            pBatteryInfo = (APP_BATTERY_INFO_T*)&app_battery_measure.currentBatteryInfo;
+    pBatteryInfo =
+        (APP_BATTERY_INFO_T *)&app_battery_measure.currentBatteryInfo;
     pBatteryInfo->batteryLevel = level;
-            if(level == APP_BATTERY_LEVEL_MAX)
+    if (level == APP_BATTERY_LEVEL_MAX) {
-            {
       level = 9;
-            }
+    } else {
-            else
-            {
       level /= 10;
     }
 #else
@@ -331,8 +326,7 @@ int app_battery_handle_process_normal(uint32_t status,  union APP_BATTERY_MSG_PR
     break;
   case APP_BATTERY_STATUS_CHARGING:
     TRACE(1, "CHARGING-->APP_BATTERY_CHARGER :%d", prams.charger);
-            if (prams.charger == APP_BATTERY_CHARGER_PLUGIN)
+    if (prams.charger == APP_BATTERY_CHARGER_PLUGIN) {
-            {
 #ifdef BT_USB_AUDIO_DUAL_MODE
       TRACE(1, "%s:PLUGIN.", __func__);
       btusb_switch(BTUSB_MODE_USB);
@@ -356,10 +350,9 @@ int app_battery_handle_process_normal(uint32_t status,  union APP_BATTERY_MSG_PR
   return 0;
 }
 
-int app_battery_handle_process_charging(uint32_t status,  union APP_BATTERY_MSG_PRAMS prams)
+int app_battery_handle_process_charging(uint32_t status,
-{
+                                        union APP_BATTERY_MSG_PRAMS prams) {
-    switch (status)
+  switch (status) {
-    {
   case APP_BATTERY_STATUS_OVERVOLT:
   case APP_BATTERY_STATUS_NORMAL:
   case APP_BATTERY_STATUS_UNDERVOLT:
@@ -368,8 +361,7 @@ int app_battery_handle_process_charging(uint32_t status,  union APP_BATTERY_MSG_
     break;
   case APP_BATTERY_STATUS_CHARGING:
     TRACE(1, "CHARGING:%d", prams.charger);
-            if (prams.charger == APP_BATTERY_CHARGER_PLUGOUT)
+    if (prams.charger == APP_BATTERY_CHARGER_PLUGOUT) {
-            {
 #ifdef BT_USB_AUDIO_DUAL_MODE
       TRACE(1, "%s:PlUGOUT.", __func__);
       btusb_switch(BTUSB_MODE_BT);
@@ -381,9 +373,7 @@ int app_battery_handle_process_charging(uint32_t status,  union APP_BATTERY_MSG_
       app_battery_measure.status = APP_BATTERY_STATUS_NORMAL;
 #endif
 #endif
-            }
+    } else if (prams.charger == APP_BATTERY_CHARGER_PLUGIN) {
-            else if (prams.charger == APP_BATTERY_CHARGER_PLUGIN)
-            {
 #ifdef BT_USB_AUDIO_DUAL_MODE
       TRACE(1, "%s:PLUGIN.", __func__);
       btusb_switch(BTUSB_MODE_USB);
@@ -395,10 +385,8 @@ int app_battery_handle_process_charging(uint32_t status,  union APP_BATTERY_MSG_
     break;
   }
 
-    if (app_battery_charger_handle_process()<=0)
+  if (app_battery_charger_handle_process() <= 0) {
-    {
+    if (app_status_indication_get() != APP_STATUS_INDICATION_FULLCHARGE) {
-        if (app_status_indication_get() != APP_STATUS_INDICATION_FULLCHARGE)
-        {
       TRACE(1, "FULL_CHARGING:%d", app_battery_measure.currvolt);
       app_status_indication_set(APP_STATUS_INDICATION_FULLCHARGE);
       app_shutdown();
@@ -416,8 +404,7 @@ int app_battery_handle_process_charging(uint32_t status,  union APP_BATTERY_MSG_
   return 0;
 }
 
-static int app_battery_handle_process(APP_MESSAGE_BODY *msg_body)
+static int app_battery_handle_process(APP_MESSAGE_BODY *msg_body) {
-{
   uint8_t status;
   union APP_BATTERY_MSG_PRAMS msg_prams;
 
@@ -425,19 +412,16 @@ static int app_battery_handle_process(APP_MESSAGE_BODY *msg_body)
   APP_BATTERY_GET_PRAMS(msg_body->message_id, msg_prams.prams);
 
   uint32_t generatedSeed = hal_sys_timer_get();
-    for (uint8_t index = 0; index < sizeof(bt_addr); index++)
+  for (uint8_t index = 0; index < sizeof(bt_addr); index++) {
-    {
+    generatedSeed ^=
-        generatedSeed ^= (((uint32_t)(bt_addr[index])) << (hal_sys_timer_get()&0xF));
+        (((uint32_t)(bt_addr[index])) << (hal_sys_timer_get() & 0xF));
   }
   srand(generatedSeed);
 
   if (status == APP_BATTERY_STATUS_PLUGINOUT) {
     app_battery_pluginout_debounce_start();
-    }
+  } else {
-    else
+    switch (app_battery_measure.status) {
-    {
-        switch (app_battery_measure.status)
-        {
     case APP_BATTERY_STATUS_NORMAL:
       app_battery_handle_process_normal((uint32_t)status, msg_prams);
       break;
@@ -450,44 +434,41 @@ static int app_battery_handle_process(APP_MESSAGE_BODY *msg_body)
       break;
     }
   }
-    if (NULL != app_battery_measure.user_cb)
+  if (NULL != app_battery_measure.user_cb) {
-    {
     uint8_t batteryLevel;
 #ifdef __INTERCONNECTION__
     APP_BATTERY_INFO_T *pBatteryInfo;
-        pBatteryInfo = (APP_BATTERY_INFO_T*)&app_battery_measure.currentBatteryInfo;
+    pBatteryInfo =
-        pBatteryInfo->chargingStatus = ((app_battery_measure.status == APP_BATTERY_STATUS_CHARGING)? 1:0);
+        (APP_BATTERY_INFO_T *)&app_battery_measure.currentBatteryInfo;
+    pBatteryInfo->chargingStatus =
+        ((app_battery_measure.status == APP_BATTERY_STATUS_CHARGING) ? 1 : 0);
     batteryLevel = pBatteryInfo->batteryLevel;
 
 #else
     batteryLevel = app_battery_measure.currlevel;
 #endif
-        app_battery_measure.user_cb(app_battery_measure.currvolt,
+    app_battery_measure.user_cb(app_battery_measure.currvolt, batteryLevel,
-                                    batteryLevel, app_battery_measure.status,status,msg_prams);
+                                app_battery_measure.status, status, msg_prams);
   }
 
   return 0;
 }
 
-int app_battery_register(APP_BATTERY_CB_T user_cb)
+int app_battery_register(APP_BATTERY_CB_T user_cb) {
-{
+  if (NULL == app_battery_measure.user_cb) {
-    if(NULL == app_battery_measure.user_cb)
-    {
     app_battery_measure.user_cb = user_cb;
     return 0;
   }
   return 1;
 }
 
-int app_battery_get_info(APP_BATTERY_MV_T *currvolt, uint8_t *currlevel, enum APP_BATTERY_STATUS_T *status)
+int app_battery_get_info(APP_BATTERY_MV_T *currvolt, uint8_t *currlevel,
-{
+                         enum APP_BATTERY_STATUS_T *status) {
-    if (currvolt)
+  if (currvolt) {
-    {
     *currvolt = app_battery_measure.currvolt;
   }
 
-    if (currlevel)
+  if (currlevel) {
-    {
 #ifdef __INTERCONNECTION__
     *currlevel = app_battery_measure.currentBatteryInfo;
 #else
@@ -495,24 +476,26 @@ int app_battery_get_info(APP_BATTERY_MV_T *currvolt, uint8_t *currlevel, enum AP
 #endif
   }
 
-    if (status)
+  if (status) {
-    {
     *status = app_battery_measure.status;
   }
 
   return 0;
 }
 
-int app_battery_open(void)
+int app_battery_open(void) {
-{
+  APP_BATTERY_TRACE(3, "%s batt range:%d~%d", __func__, APP_BATTERY_MIN_MV,
-    APP_BATTERY_TRACE(3,"%s batt range:%d~%d",__func__, APP_BATTERY_MIN_MV, APP_BATTERY_MAX_MV);
+                    APP_BATTERY_MAX_MV);
   int nRet = APP_BATTERY_OPEN_MODE_INVALID;
 
   if (app_battery_timer == NULL)
-        app_battery_timer = osTimerCreate (osTimer(APP_BATTERY), osTimerPeriodic, NULL);
+    app_battery_timer =
+        osTimerCreate(osTimer(APP_BATTERY), osTimerPeriodic, NULL);
 
   if (app_battery_pluginout_debounce_timer == NULL)
-        app_battery_pluginout_debounce_timer = osTimerCreate (osTimer(APP_BATTERY_PLUGINOUT_DEBOUNCE), osTimerOnce, &app_battery_pluginout_debounce_ctx);
+    app_battery_pluginout_debounce_timer =
+        osTimerCreate(osTimer(APP_BATTERY_PLUGINOUT_DEBOUNCE), osTimerOnce,
+                      &app_battery_pluginout_debounce_ctx);
 
   app_battery_measure.status = APP_BATTERY_STATUS_NORMAL;
 #ifdef __INTERCONNECTION__
@@ -538,26 +521,32 @@ int app_battery_open(void)
 
   app_set_threadhandle(APP_MODUAL_BATTERY, app_battery_handle_process);
 
-    if (app_battery_ext_charger_detecter_cfg.pin != HAL_IOMUX_PIN_NUM)
+  if (app_battery_ext_charger_detecter_cfg.pin != HAL_IOMUX_PIN_NUM) {
-    {
+    hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP
-        hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&app_battery_ext_charger_detecter_cfg, 1);
+                        *)&app_battery_ext_charger_detecter_cfg,
-        hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin, HAL_GPIO_DIR_IN, 1);
+                   1);
+    hal_gpio_pin_set_dir(
+        (enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin,
+        HAL_GPIO_DIR_IN, 1);
   }
 
-    if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM)
+  if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM) {
-    {
+    hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP
-        hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&app_battery_ext_charger_detecter_cfg, 1);
+                        *)&app_battery_ext_charger_detecter_cfg,
-        hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin, HAL_GPIO_DIR_OUT, 1);
+                   1);
+    hal_gpio_pin_set_dir(
+        (enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin,
+        HAL_GPIO_DIR_OUT, 1);
   }
 
-    if (app_battery_charger_indication_open() == APP_BATTERY_CHARGER_PLUGIN)
+  if (app_battery_charger_indication_open() == APP_BATTERY_CHARGER_PLUGIN) {
-    {
     app_battery_measure.status = APP_BATTERY_STATUS_CHARGING;
     app_battery_measure.start_time = hal_sys_timer_get();
     // pmu_charger_plugin_config();
-        if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM)
+    if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM) {
-        {
+      hal_gpio_pin_set_dir(
-            hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin, HAL_GPIO_DIR_OUT, 0);
+          (enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin,
+          HAL_GPIO_DIR_OUT, 0);
     }
 
 #if (CHARGER_PLUGINOUT_RESET == 0)
@@ -565,9 +554,7 @@ int app_battery_open(void)
 #else
     nRet = APP_BATTERY_OPEN_MODE_CHARGING;
 #endif
-    }
+  } else {
-    else
-    {
     app_battery_measure.status = APP_BATTERY_STATUS_NORMAL;
     // pmu_charger_plugout_config();
     nRet = APP_BATTERY_OPEN_MODE_NORMAL;
@@ -575,8 +562,7 @@ int app_battery_open(void)
   return nRet;
 }
 
-int app_battery_start(void)
+int app_battery_start(void) {
-{
   APP_BATTERY_TRACE(2, "%s %d", __func__, APP_BATTERY_MEASURE_PERIODIC_FAST_MS);
 
   app_battery_timer_start(APP_BATTERY_MEASURE_PERIODIC_FAST);
@@ -584,30 +570,26 @@ int app_battery_start(void)
   return 0;
 }
 
-int app_battery_stop(void)
+int app_battery_stop(void) {
-{
   osTimerStop(app_battery_timer);
 
   return 0;
 }
 
-int app_battery_close(void)
+int app_battery_close(void) {
-{
   hal_gpadc_close(HAL_GPADC_CHAN_BATTERY);
 
   return 0;
 }
 
-
+static int32_t app_battery_charger_slope_calc(int32_t t1, int32_t v1,
-static int32_t app_battery_charger_slope_calc(int32_t t1, int32_t v1, int32_t t2, int32_t v2)
+                                              int32_t t2, int32_t v2) {
-{
   int32_t slope_1000;
   slope_1000 = (v2 - v1) * 1000 / (t2 - t1);
   return slope_1000;
 }
 
-static int app_battery_charger_handle_process(void)
+static int app_battery_charger_handle_process(void) {
-{
   int nRet = 1;
   int8_t i = 0, cnt = 0;
   uint32_t slope_1000 = 0;
@@ -617,45 +599,38 @@ static int app_battery_charger_handle_process(void)
 
   charging_min = hal_sys_timer_get() - app_battery_measure.start_time;
   charging_min = TICKS_TO_MS(charging_min) / 1000 / 60;
-    if (charging_min >= app_battery_measure.chargetimeout)
+  if (charging_min >= app_battery_measure.chargetimeout) {
-    {
     // TRACE(0,"TIMEROUT-->FULL_CHARGING");
     nRet = -1;
     goto exit;
   }
 
-    if ((app_battery_measure.charger_status.cnt++%APP_BATTERY_CHARGING_OVERVOLT_MEASURE_CNT) == 0)
+  if ((app_battery_measure.charger_status.cnt++ %
-    {
+       APP_BATTERY_CHARGING_OVERVOLT_MEASURE_CNT) == 0) {
-        if (app_battery_measure.currvolt>=(app_battery_measure.highvolt+APP_BATTERY_CHARGE_OFFSET_MV))
+    if (app_battery_measure.currvolt >=
-        {
+        (app_battery_measure.highvolt + APP_BATTERY_CHARGE_OFFSET_MV)) {
       overvolt_full_charge_cnt++;
-        }
+    } else {
-        else
-        {
       overvolt_full_charge_cnt = 0;
     }
-        if (overvolt_full_charge_cnt>=APP_BATTERY_CHARGING_OVERVOLT_DEDOUNCE_CNT)
+    if (overvolt_full_charge_cnt >=
-        {
+        APP_BATTERY_CHARGING_OVERVOLT_DEDOUNCE_CNT) {
       // TRACE(0,"OVERVOLT-->FULL_CHARGING");
       nRet = -1;
       goto exit;
     }
   }
 
-    if ((app_battery_measure.charger_status.cnt++%APP_BATTERY_CHARGING_EXTPIN_MEASURE_CNT) == 0)
+  if ((app_battery_measure.charger_status.cnt++ %
-    {
+       APP_BATTERY_CHARGING_EXTPIN_MEASURE_CNT) == 0) {
-        if (app_battery_ext_charger_detecter_cfg.pin != HAL_IOMUX_PIN_NUM)
+    if (app_battery_ext_charger_detecter_cfg.pin != HAL_IOMUX_PIN_NUM) {
-        {
+      if (hal_gpio_pin_get_val(
-            if (hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin))
+              (enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin)) {
-            {
         ext_pin_full_charge_cnt++;
-            }
+      } else {
-            else
-            {
         ext_pin_full_charge_cnt = 0;
       }
-            if (ext_pin_full_charge_cnt>=APP_BATTERY_CHARGING_EXTPIN_DEDOUNCE_CNT)
+      if (ext_pin_full_charge_cnt >= APP_BATTERY_CHARGING_EXTPIN_DEDOUNCE_CNT) {
-            {
         TRACE(0, "EXT PIN-->FULL_CHARGING");
         nRet = -1;
         goto exit;
@@ -663,41 +638,44 @@ static int app_battery_charger_handle_process(void)
     }
   }
 
-    if ((app_battery_measure.charger_status.cnt++%APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT) == 0)
+  if ((app_battery_measure.charger_status.cnt++ %
-    {
+       APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT) == 0) {
-        if (!app_battery_measure.charger_status.prevolt)
+    if (!app_battery_measure.charger_status.prevolt) {
-        {
+      app_battery_measure.charger_status
-            app_battery_measure.charger_status.slope_1000[app_battery_measure.charger_status.slope_1000_index%APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT] = slope_1000;
+          .slope_1000[app_battery_measure.charger_status.slope_1000_index %
+                      APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT] = slope_1000;
       app_battery_measure.charger_status.prevolt = app_battery_measure.currvolt;
-            for (i=0; i<APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT; i++)
+      for (i = 0; i < APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT; i++) {
-            {
         app_battery_measure.charger_status.slope_1000[i] = 100;
       }
-        }
+    } else {
-        else
+      slope_1000 = app_battery_charger_slope_calc(
-        {
+          0, app_battery_measure.charger_status.prevolt,
-            slope_1000 = app_battery_charger_slope_calc(0, app_battery_measure.charger_status.prevolt,
+          APP_BATTERY_CHARGING_PERIODIC_MS *
-                         APP_BATTERY_CHARGING_PERIODIC_MS*APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT/1000, app_battery_measure.currvolt);
+              APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT / 1000,
-            app_battery_measure.charger_status.slope_1000[app_battery_measure.charger_status.slope_1000_index%APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT] = slope_1000;
+          app_battery_measure.currvolt);
+      app_battery_measure.charger_status
+          .slope_1000[app_battery_measure.charger_status.slope_1000_index %
+                      APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT] = slope_1000;
       app_battery_measure.charger_status.prevolt = app_battery_measure.currvolt;
-            for (i=0; i<APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT; i++)
+      for (i = 0; i < APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT; i++) {
-            {
         if (app_battery_measure.charger_status.slope_1000[i] > 0)
           cnt++;
         else
           cnt--;
-                TRACE(3,"slope_1000[%d]=%d cnt:%d", i,app_battery_measure.charger_status.slope_1000[i], cnt);
+        TRACE(3, "slope_1000[%d]=%d cnt:%d", i,
+              app_battery_measure.charger_status.slope_1000[i], cnt);
       }
-            TRACE(3,"app_battery_charger_slope_proc slope*1000=%d cnt:%d nRet:%d", slope_1000, cnt, nRet);
+      TRACE(3, "app_battery_charger_slope_proc slope*1000=%d cnt:%d nRet:%d",
-            if (cnt>1)
+            slope_1000, cnt, nRet);
-            {
+      if (cnt > 1) {
         nRet = 1;
       } /*else (3>=cnt && cnt>=-3){
            nRet = 0;
-            }*/else
+       }*/
-            {
+      else {
-                if (app_battery_measure.currvolt>=(app_battery_measure.highvolt-APP_BATTERY_CHARGE_OFFSET_MV))
+        if (app_battery_measure.currvolt >=
-                {
+            (app_battery_measure.highvolt - APP_BATTERY_CHARGE_OFFSET_MV)) {
           TRACE(0, "SLOPE-->FULL_CHARGING");
           nRet = -1;
         }
@@ -709,20 +687,16 @@ exit:
   return nRet;
 }
 
-static enum APP_BATTERY_CHARGER_T app_battery_charger_forcegetstatus(void)
+static enum APP_BATTERY_CHARGER_T app_battery_charger_forcegetstatus(void) {
-{
   enum APP_BATTERY_CHARGER_T status = APP_BATTERY_CHARGER_QTY;
   enum PMU_CHARGER_STATUS_T charger;
 
   charger = pmu_charger_get_status();
 
-    if (charger == PMU_CHARGER_PLUGIN)
+  if (charger == PMU_CHARGER_PLUGIN) {
-    {
     status = APP_BATTERY_CHARGER_PLUGIN;
     // TRACE(0,"force APP_BATTERY_CHARGER_PLUGIN");
-    }
+  } else {
-    else
-    {
     status = APP_BATTERY_CHARGER_PLUGOUT;
     // TRACE(0,"force APP_BATTERY_CHARGER_PLUGOUT");
   }
@@ -730,63 +704,64 @@ static enum APP_BATTERY_CHARGER_T app_battery_charger_forcegetstatus(void)
   return status;
 }
 
-static void app_battery_charger_handler(enum PMU_CHARGER_STATUS_T status)
+static void app_battery_charger_handler(enum PMU_CHARGER_STATUS_T status) {
-{
   TRACE(2, "%s: status=%d", __func__, status);
   pmu_charger_set_irq_handler(NULL);
   app_battery_event_process(APP_BATTERY_STATUS_PLUGINOUT,
-                              (status == PMU_CHARGER_PLUGIN) ? APP_BATTERY_CHARGER_PLUGIN : APP_BATTERY_CHARGER_PLUGOUT);
+                            (status == PMU_CHARGER_PLUGIN)
+                                ? APP_BATTERY_CHARGER_PLUGIN
+                                : APP_BATTERY_CHARGER_PLUGOUT);
 }
 
-static void app_battery_pluginout_debounce_start(void)
+static void app_battery_pluginout_debounce_start(void) {
-{
   TRACE(1, "%s", __func__);
-    app_battery_pluginout_debounce_ctx = (uint32_t)app_battery_charger_forcegetstatus();
+  app_battery_pluginout_debounce_ctx =
+      (uint32_t)app_battery_charger_forcegetstatus();
   app_battery_pluginout_debounce_cnt = 1;
-    osTimerStart(app_battery_pluginout_debounce_timer, CHARGER_PLUGINOUT_DEBOUNCE_MS);
+  osTimerStart(app_battery_pluginout_debounce_timer,
+               CHARGER_PLUGINOUT_DEBOUNCE_MS);
 }
 
-static void app_battery_pluginout_debounce_handler(void const *param)
+static void app_battery_pluginout_debounce_handler(void const *param) {
-{
+  enum APP_BATTERY_CHARGER_T status_charger =
-    enum APP_BATTERY_CHARGER_T status_charger = app_battery_charger_forcegetstatus();
+      app_battery_charger_forcegetstatus();
 
   if (app_battery_pluginout_debounce_ctx == (uint32_t)status_charger) {
     app_battery_pluginout_debounce_cnt++;
-    }
+  } else {
-    else
+    TRACE(2, "%s dithering cnt %u", __func__,
-    {
+          app_battery_pluginout_debounce_cnt);
-        TRACE(2,"%s dithering cnt %u", __func__, app_battery_pluginout_debounce_cnt);
     app_battery_pluginout_debounce_cnt = 0;
     app_battery_pluginout_debounce_ctx = (uint32_t)status_charger;
   }
 
   if (app_battery_pluginout_debounce_cnt >= CHARGER_PLUGINOUT_DEBOUNCE_CNT) {
-        TRACE(2,"%s %s", __func__, status_charger == APP_BATTERY_CHARGER_PLUGOUT ? "PLUGOUT" : "PLUGIN");
+    TRACE(2, "%s %s", __func__,
-        if (status_charger == APP_BATTERY_CHARGER_PLUGIN)
+          status_charger == APP_BATTERY_CHARGER_PLUGOUT ? "PLUGOUT" : "PLUGIN");
-        {
+    if (status_charger == APP_BATTERY_CHARGER_PLUGIN) {
-            if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM)
+      if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM) {
-            {
+        hal_gpio_pin_set_dir(
-                hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin, HAL_GPIO_DIR_OUT, 0);
+            (enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin,
+            HAL_GPIO_DIR_OUT, 0);
       }
       app_battery_measure.start_time = hal_sys_timer_get();
-        }
+    } else {
-        else
+      if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM) {
-        {
+        hal_gpio_pin_set_dir(
-            if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM)
+            (enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin,
-            {
+            HAL_GPIO_DIR_OUT, 1);
-                hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin, HAL_GPIO_DIR_OUT, 1);
       }
     }
     app_battery_event_process(APP_BATTERY_STATUS_CHARGING, status_charger);
     pmu_charger_set_irq_handler(app_battery_charger_handler);
     osTimerStop(app_battery_pluginout_debounce_timer);
   } else {
-        osTimerStart(app_battery_pluginout_debounce_timer, CHARGER_PLUGINOUT_DEBOUNCE_MS);
+    osTimerStart(app_battery_pluginout_debounce_timer,
+                 CHARGER_PLUGINOUT_DEBOUNCE_MS);
   }
 }
 
-int app_battery_charger_indication_open(void)
+int app_battery_charger_indication_open(void) {
-{
   enum APP_BATTERY_CHARGER_T status = APP_BATTERY_CHARGER_QTY;
   uint8_t cnt = 0;
 
@@ -794,19 +769,16 @@ int app_battery_charger_indication_open(void)
 
   pmu_charger_init();
 
-    do
+  do {
-    {
     status = app_battery_charger_forcegetstatus();
     if (status == APP_BATTERY_CHARGER_PLUGIN)
       break;
     osDelay(20);
-    }
+  } while (cnt++ < 5);
-    while(cnt++<5);
 
-    if (app_battery_ext_charger_detecter_cfg.pin != HAL_IOMUX_PIN_NUM)
+  if (app_battery_ext_charger_detecter_cfg.pin != HAL_IOMUX_PIN_NUM) {
-    {
+    if (!hal_gpio_pin_get_val(
-        if (!hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin))
+            (enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin)) {
-        {
       status = APP_BATTERY_CHARGER_PLUGIN;
     }
   }
@@ -816,8 +788,7 @@ int app_battery_charger_indication_open(void)
   return status;
 }
 
-int8_t app_battery_current_level(void)
+int8_t app_battery_current_level(void) {
-{
 #ifdef __INTERCONNECTION__
   return app_battery_measure.currentBatteryInfo & 0x7f;
 #else
@@ -825,8 +796,7 @@ int8_t app_battery_current_level(void)
 #endif
 }
 
-int8_t app_battery_is_charging(void)
+int8_t app_battery_is_charging(void) {
-{
   return (APP_BATTERY_STATUS_CHARGING == app_battery_measure.status);
 }
 
@@ -840,8 +810,7 @@ typedef uint16_t NTP_TEMPERATURE_C_T;
 
 typedef void (*NTC_CAPTURE_MEASURE_CB_T)(NTP_TEMPERATURE_C_T);
 
-struct NTC_CAPTURE_MEASURE_T
+struct NTC_CAPTURE_MEASURE_T {
-{
   NTP_TEMPERATURE_C_T temperature;
   NTP_VOLTAGE_MV_T currvolt;
   NTP_VOLTAGE_MV_T voltage[NTC_CAPTURE_STABLE_COUNT];
@@ -851,38 +820,36 @@ struct NTC_CAPTURE_MEASURE_T
 
 static struct NTC_CAPTURE_MEASURE_T ntc_capture_measure;
 
-void ntc_capture_irqhandler(uint16_t irq_val, HAL_GPADC_MV_T volt)
+void ntc_capture_irqhandler(uint16_t irq_val, HAL_GPADC_MV_T volt) {
-{
   uint32_t meanVolt = 0;
   TRACE(3, "%s %d irq:0x%04x", __func__, volt, irq_val);
 
-    if (volt == HAL_GPADC_BAD_VALUE)
+  if (volt == HAL_GPADC_BAD_VALUE) {
-    {
     return;
   }
 
-    ntc_capture_measure.voltage[ntc_capture_measure.index++%NTC_CAPTURE_STABLE_COUNT] = volt;
+  ntc_capture_measure
+      .voltage[ntc_capture_measure.index++ % NTC_CAPTURE_STABLE_COUNT] = volt;
 
-    if (ntc_capture_measure.index > NTC_CAPTURE_STABLE_COUNT)
+  if (ntc_capture_measure.index > NTC_CAPTURE_STABLE_COUNT) {
-    {
+    for (uint8_t i = 0; i < NTC_CAPTURE_STABLE_COUNT; i++) {
-        for (uint8_t i=0; i<NTC_CAPTURE_STABLE_COUNT; i++)
-        {
       meanVolt += ntc_capture_measure.voltage[i];
     }
     meanVolt /= NTC_CAPTURE_STABLE_COUNT;
     ntc_capture_measure.currvolt = meanVolt;
-    }
+  } else if (!ntc_capture_measure.currvolt) {
-    else if (!ntc_capture_measure.currvolt)
-    {
     ntc_capture_measure.currvolt = volt;
   }
-    ntc_capture_measure.temperature = ((int32_t)ntc_capture_measure.currvolt - NTC_CAPTURE_VOLTAGE_REF)/NTC_CAPTURE_TEMPERATURE_STEP + NTC_CAPTURE_TEMPERATURE_REF;
+  ntc_capture_measure.temperature =
+      ((int32_t)ntc_capture_measure.currvolt - NTC_CAPTURE_VOLTAGE_REF) /
+          NTC_CAPTURE_TEMPERATURE_STEP +
+      NTC_CAPTURE_TEMPERATURE_REF;
   pmu_ntc_capture_disable();
-    TRACE(3,"%s ad:%d temperature:%d",__func__, ntc_capture_measure.currvolt, ntc_capture_measure.temperature);
+  TRACE(3, "%s ad:%d temperature:%d", __func__, ntc_capture_measure.currvolt,
+        ntc_capture_measure.temperature);
 }
 
-int ntc_capture_open(void)
+int ntc_capture_open(void) {
-{
 
   ntc_capture_measure.currvolt = 0;
   ntc_capture_measure.index = 0;
@@ -890,14 +857,14 @@ int ntc_capture_open(void)
   ntc_capture_measure.cb = NULL;
 
   pmu_ntc_capture_enable();
-    hal_gpadc_open(HAL_GPADC_CHAN_0, HAL_GPADC_ATP_ONESHOT, ntc_capture_irqhandler);
+  hal_gpadc_open(HAL_GPADC_CHAN_0, HAL_GPADC_ATP_ONESHOT,
+                 ntc_capture_irqhandler);
   return 0;
 }
 
-int ntc_capture_start(void)
+int ntc_capture_start(void) {
-{
   pmu_ntc_capture_enable();
-    hal_gpadc_open(HAL_GPADC_CHAN_0, HAL_GPADC_ATP_ONESHOT, ntc_capture_irqhandler);
+  hal_gpadc_open(HAL_GPADC_CHAN_0, HAL_GPADC_ATP_ONESHOT,
+                 ntc_capture_irqhandler);
   return 0;
 }
-

apps/btusbaudio/btusb_audio.c

@@ -13,17 +13,17 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "stdio.h"
+#include "app_audio.h"
 #include "cmsis_os.h"
 #include "hal_timer.h"
 #include "hal_trace.h"
-#include "app_audio.h"
+#include "stdio.h"
 
 #include "a2dp_api.h"
 #include "app_bt.h"
 #include "btapp.h"
-#include "usb_audio_app.h"
 #include "btusb_audio.h"
+#include "usb_audio_app.h"
 
 extern void btusbaudio_entry(void);
 extern void btusbaudio_exit(void);
@@ -41,8 +41,7 @@ static bool btusb_bt_audio_is_suspend = false;
 #define BT_USB_DEBUG() // TRACE(2,"_debug: %s,%d",__func__,__LINE__)
 extern struct BT_DEVICE_T app_bt_device;
 
-static void _btusb_stream_open(unsigned int timeout_ms)
+static void _btusb_stream_open(unsigned int timeout_ms) {
-{
   a2dp_stream_t *stream = NULL;
   bt_bdaddr_t bdaddr;
   uint32_t stime = 0;
@@ -53,32 +52,30 @@ static void _btusb_stream_open(unsigned int timeout_ms)
   stream = (a2dp_stream_t *)app_bt_get_steam(BT_DEVICE_ID_1);
 
   app_bt_get_bt_addr(BT_DEVICE_ID_1, &bdaddr);
-    if(stream)
+  if (stream) {
-    {
     // struct BT_DEVICE_T *bt_dev = &app_bt_device;
-        //A2DP_Register((a2dp_stream_t *)bt_dev->a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream, &a2dp_avdtpcodec, NULL, (A2dpCallback) a2dp_callback);
+    // A2DP_Register((a2dp_stream_t
-        //AVRCP_Register((AvrcpChannel *)bt_dev->avrcp_channel[BT_DEVICE_ID_1]->avrcp_channel_handle, (AvrcpCallback)avrcp_callback_CT, BTIF_AVRCP_CT_CATEGORY_1 | BTIF_AVRCP_CT_CATEGORY_2 | BTIF_AVRCP_TG_CATEGORY_2);
+    // *)bt_dev->a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream, &a2dp_avdtpcodec,
+    // NULL, (A2dpCallback) a2dp_callback); AVRCP_Register((AvrcpChannel
+    // *)bt_dev->avrcp_channel[BT_DEVICE_ID_1]->avrcp_channel_handle,
+    // (AvrcpCallback)avrcp_callback_CT, BTIF_AVRCP_CT_CATEGORY_1 |
+    // BTIF_AVRCP_CT_CATEGORY_2 | BTIF_AVRCP_TG_CATEGORY_2);
     BT_USB_DEBUG();
     osDelay(10);
     app_bt_A2DP_OpenStream(stream, &bdaddr);
-    }
+  } else {
-    else
-    {
     BT_USB_DEBUG();
     return;
   }
-    while(1)
+  while (1) {
-    {
     if (app_bt_a2dp_service_is_connected()) {
       etime = hal_sys_timer_get();
-            TRACE(1,"_debug: a2dp service connected, wait time = 0x%x.",TICKS_TO_MS(etime - stime));
+      TRACE(1, "_debug: a2dp service connected, wait time = 0x%x.",
+            TICKS_TO_MS(etime - stime));
       break;
-        }
+    } else {
-        else
-        {
       etime = hal_sys_timer_get();
-            if(TICKS_TO_MS(etime - stime) >= timeout_ms)
+      if (TICKS_TO_MS(etime - stime) >= timeout_ms) {
-            {
         TRACE(1, "_debug: a2dp service connect timeout = 0x%x.",
               TICKS_TO_MS(etime - stime));
         break;
@@ -89,8 +86,7 @@ static void _btusb_stream_open(unsigned int timeout_ms)
   // BT_USB_DEBUG();
 }
 
-static void _btusb_stream_close(unsigned int timeout_ms)
+static void _btusb_stream_close(unsigned int timeout_ms) {
-{
   a2dp_stream_t *stream = NULL;
   uint32_t stime = 0;
   uint32_t etime = 0;
@@ -98,19 +94,15 @@ static void _btusb_stream_close(unsigned int timeout_ms)
   stime = hal_sys_timer_get();
   BT_USB_DEBUG();
   stream = (a2dp_stream_t *)app_bt_get_steam(BT_DEVICE_ID_1);
-    if(stream)
+  if (stream) {
-    {
     BT_USB_DEBUG();
     app_bt_A2DP_CloseStream(stream);
-    }
+  } else {
-    else
-    {
     BT_USB_DEBUG();
     return;
   }
   stime = hal_sys_timer_get();
-    while(1)
+  while (1) {
-    {
     if (!app_bt_a2dp_service_is_connected()) {
       // struct BT_DEVICE_T *bt_dev = &app_bt_device;
       // AVRCP_Deregister(bt_dev->avrcp_channel[BT_DEVICE_ID_1]->avrcp_channel_handle);
@@ -119,12 +111,9 @@ static void _btusb_stream_close(unsigned int timeout_ms)
       TRACE(1, "a2dp service diconnected, wait time = 0x%x.",
             TICKS_TO_MS(etime - stime));
       break;
-        }
+    } else {
-        else
-        {
       etime = hal_sys_timer_get();
-            if(TICKS_TO_MS(etime - stime) >= timeout_ms)
+      if (TICKS_TO_MS(etime - stime) >= timeout_ms) {
-            {
         TRACE(1, "a2dp service diconnect timeout = 0x%x.",
               TICKS_TO_MS(etime - stime));
         break;
@@ -135,75 +124,61 @@ static void _btusb_stream_close(unsigned int timeout_ms)
   BT_USB_DEBUG();
 }
 
-static void btusb_usbaudio_entry(void)
+static void btusb_usbaudio_entry(void) {
-{
   BT_USB_DEBUG();
   btusbaudio_entry();
   btusb_usb_is_on = true;
 }
 
-void btusb_usbaudio_open(void)
+void btusb_usbaudio_open(void) {
-{
   BT_USB_DEBUG();
-    if(!btusb_usb_is_on)
+  if (!btusb_usb_is_on) {
-    {
     btusb_usbaudio_entry();
     BT_USB_DEBUG();
-    }
+  } else {
-    else
-    {
     usb_audio_app(1);
   }
   BT_USB_DEBUG();
 }
 
-void btusb_usbaudio_close(void)
+void btusb_usbaudio_close(void) {
-{
   BT_USB_DEBUG();
-    if(btusb_usb_is_on)
+  if (btusb_usb_is_on) {
-    {
     usb_audio_app(0);
     BT_USB_DEBUG();
-    }
+  } else {
-    else
-    {
     BT_USB_DEBUG();
   }
 }
 
-void btusb_btaudio_close(bool is_wait)
+void btusb_btaudio_close(bool is_wait) {
-{
   BT_USB_DEBUG();
   // if(!btusb_bt_audio_is_suspend)
   {
     BT_USB_DEBUG();
-        if(is_wait)
+    if (is_wait) {
-        {
+      app_audio_sendrequest(APP_PLAY_BACK_AUDIO,
-            app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_CLOSEALL, 0);
+                            (uint8_t)APP_BT_SETTING_CLOSEALL, 0);
       _btusb_stream_close(BTUSB_OUTTIME_MS);
-        }
+    } else {
-        else
-        {
       _btusb_stream_close(0);
     }
     btusb_bt_audio_is_suspend = true;
   }
 }
 
-void btusb_btaudio_open(bool is_wait)
+void btusb_btaudio_open(bool is_wait) {
-{
   BT_USB_DEBUG();
   // if(btusb_bt_audio_is_suspend)
   {
     TRACE(2, "%s: %d.", __func__, __LINE__);
-        if(is_wait)
+    if (is_wait) {
-        {
       _btusb_stream_open(BTUSB_OUTTIME_MS);
-            app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_CLOSE, 0);
+      app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_CLOSE,
-            app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_SETUP, 0);
+                            0);
-        }
+      app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_SETUP,
-        else
+                            0);
-        {
+    } else {
       _btusb_stream_open(0);
     }
     TRACE(2, "%s: %d.", __func__, __LINE__);
@@ -211,11 +186,9 @@ void btusb_btaudio_open(bool is_wait)
   }
 }
 
-void btusb_switch(enum BTUSB_MODE mode)
+void btusb_switch(enum BTUSB_MODE mode) {
-{
   // BT_USB_DEBUG();
-    if(mode != BTUSB_MODE_BT && mode != BTUSB_MODE_USB)
+  if (mode != BTUSB_MODE_BT && mode != BTUSB_MODE_USB) {
-    {
     ASSERT(0, "%s:%d, mode = %d.", __func__, __LINE__, mode);
   }
 
@@ -224,26 +197,21 @@ void btusb_switch(enum BTUSB_MODE mode)
     return;
   }
 
-    if(btusb_mode == BTUSB_MODE_INVALID)
+  if (btusb_mode == BTUSB_MODE_INVALID) {
-    {
     if (mode == BTUSB_MODE_BT) {
       TRACE(1, "%s: switch to BT mode.", __func__);
       btusb_mode = BTUSB_MODE_BT;
-        }
+    } else {
-        else {
       TRACE(1, "%s: switch to USB mode.", __func__);
       // btusb_btaudio_close(true);
       osDelay(500);
       btusb_usbaudio_open();
       btusb_mode = BTUSB_MODE_USB;
     }
-    }
+  } else {
-    else
-    {
     if (mode == BTUSB_MODE_BT) {
       TRACE(1, "%s: switch to BT mode.", __func__);
-            if(btusb_usb_is_on)
+      if (btusb_usb_is_on) {
-            {
         TRACE(1, "%s: btusb_usbaudio_close.", __func__);
         btusb_usbaudio_close();
         TRACE(1, "%s: btusb_usbaudio_close done.", __func__);
@@ -252,10 +220,8 @@ void btusb_switch(enum BTUSB_MODE mode)
       btusb_mode = BTUSB_MODE_BT;
       btusb_btaudio_open(true);
       TRACE(1, "%s: switch to BT mode done.", __func__);
-        }
+    } else {
-        else {
+      if (btapp_hfp_is_call_active() == 1) {
-            if(btapp_hfp_is_call_active() == 1)
-            {
         TRACE(1, "%s: hfp is call active.", __func__);
         return;
       }
@@ -270,38 +236,25 @@ void btusb_switch(enum BTUSB_MODE mode)
   }
 }
 
-bool btusb_is_bt_mode(void)
+bool btusb_is_bt_mode(void) {
-{
   BT_USB_DEBUG();
   return btusb_mode == BTUSB_MODE_BT ? true : false;
 }
 
-bool btusb_is_usb_mode(void)
+bool btusb_is_usb_mode(void) {
-{
   return btusb_mode == BTUSB_MODE_USB ? true : false;
 }
 
-
 #if defined(BT_USB_AUDIO_DUAL_MODE_TEST)
-void test_btusb_switch(void)
+void test_btusb_switch(void) {
-{
+  if (btusb_mode == BTUSB_MODE_BT) {
-    if(btusb_mode == BTUSB_MODE_BT)
-    {
     btusb_switch(BTUSB_MODE_USB);
-    }
+  } else {
-    else
-    {
     btusb_switch(BTUSB_MODE_BT);
   }
 }
 
-void test_btusb_switch_to_bt(void)
+void test_btusb_switch_to_bt(void) { btusb_switch(BTUSB_MODE_BT); }
-{
-     btusb_switch(BTUSB_MODE_BT);
-}
 
-void test_btusb_switch_to_usb(void)
+void test_btusb_switch_to_usb(void) { btusb_switch(BTUSB_MODE_USB); }
-{
-     btusb_switch(BTUSB_MODE_USB);
-}
 #endif

apps/btusbaudio/usbaudio_thread.c

@@ -13,11 +13,11 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "usbaudio_thread.h"
+#include "app_utils.h"
 #include "cmsis_os.h"
 #include "hal_trace.h"
-#include "app_utils.h"
 #include "usb_audio_app.h"
-#include "usbaudio_thread.h"
 
 static void usb_thread(void const *argument);
 osThreadDef(usb_thread, osPriorityHigh, 1, 2048, "usb");
@@ -26,8 +26,7 @@ osMailQDef (usb_mailbox, USB_MAILBOX_MAX, USB_MESSAGE);
 static osMailQId usb_mailbox = NULL;
 static uint8_t usb_mailbox_cnt = 0;
 #define USBAUDIO_DEBUG TRACE
-static int usb_mailbox_init(void)
+static int usb_mailbox_init(void) {
-{
   USBAUDIO_DEBUG("%s,%d", __func__, __LINE__);
   usb_mailbox = osMailCreate(osMailQ(usb_mailbox), NULL);
   if (usb_mailbox == NULL) {
@@ -38,16 +37,14 @@ static int usb_mailbox_init(void)
   return 0;
 }
 
-int usb_mailbox_put(USB_MESSAGE* msg_src)
+int usb_mailbox_put(USB_MESSAGE *msg_src) {
-{
   osStatus status;
   USB_MESSAGE *msg_p = NULL;
 
   USBAUDIO_DEBUG("%s,%d", __func__, __LINE__);
-    if(usb_mailbox_cnt >= 1)
+  if (usb_mailbox_cnt >= 1) {
-    {
+    USBAUDIO_DEBUG("%s,%d usb_mailbox_cnt  = %d.", __func__, __LINE__,
-        USBAUDIO_DEBUG("%s,%d usb_mailbox_cnt  = %d.",
+                   usb_mailbox_cnt);
-              __func__,__LINE__,usb_mailbox_cnt);
     return 0;
   }
   msg_p = (USB_MESSAGE *)osMailAlloc(usb_mailbox, 0);
@@ -60,24 +57,24 @@ int usb_mailbox_put(USB_MESSAGE* msg_src)
   status = osMailPut(usb_mailbox, msg_p);
   if (osOK == status)
     usb_mailbox_cnt++;
-    USBAUDIO_DEBUG("%s,%d,usb_mailbox_cnt = %d.",__func__,__LINE__,usb_mailbox_cnt);
+  USBAUDIO_DEBUG("%s,%d,usb_mailbox_cnt = %d.", __func__, __LINE__,
+                 usb_mailbox_cnt);
   return (int)status;
 }
 
-int usb_mailbox_free(USB_MESSAGE* msg_p)
+int usb_mailbox_free(USB_MESSAGE *msg_p) {
-{
   osStatus status;
 
   USBAUDIO_DEBUG("%s,%d", __func__, __LINE__);
   status = osMailFree(usb_mailbox, msg_p);
   if (osOK == status)
     usb_mailbox_cnt--;
-    USBAUDIO_DEBUG("%s,%d,usb_mailbox_cnt = %d.",__func__,__LINE__,usb_mailbox_cnt);
+  USBAUDIO_DEBUG("%s,%d,usb_mailbox_cnt = %d.", __func__, __LINE__,
+                 usb_mailbox_cnt);
   return (int)status;
 }
 
-int usb_mailbox_get(USB_MESSAGE **msg_p)
+int usb_mailbox_get(USB_MESSAGE **msg_p) {
-{
   osEvent evt;
   evt = osMailGet(usb_mailbox, osWaitForever);
   if (evt.status == osEventMail) {
@@ -87,8 +84,7 @@ int usb_mailbox_get(USB_MESSAGE **msg_p)
   return -1;
 }
 
-static void usb_thread(void const *argument)
+static void usb_thread(void const *argument) {
-{
   // USB_FUNC_T usb_funcp;
   USBAUDIO_DEBUG("%s,%d", __func__, __LINE__);
   while (1) {
@@ -96,17 +92,16 @@ static void usb_thread(void const *argument)
 
     if (!usb_mailbox_get(&msg_p)) {
       // TRACE(2,"_debug: %s,%d",__func__,__LINE__);
-            USBAUDIO_DEBUG("usb_thread: id = 0x%x, ptr = 0x%x,param0 = 0x%x,param1 = 0x%x.",
+      USBAUDIO_DEBUG(
+          "usb_thread: id = 0x%x, ptr = 0x%x,param0 = 0x%x,param1 = 0x%x.",
           msg_p->id, msg_p->ptr, msg_p->param0, msg_p->param1);
       usb_mailbox_free(msg_p);
       usb_audio_app_loop();
-
     }
   }
 }
 
-static void usb_enqueue_cmd(uint32_t data)
+static void usb_enqueue_cmd(uint32_t data) {
-{
   USB_MESSAGE usb_msg;
 
   usb_msg.id = 0;
@@ -116,8 +111,7 @@ static void usb_enqueue_cmd(uint32_t data)
   usb_mailbox_put(&usb_msg);
 }
 
-int usb_os_init(void)
+int usb_os_init(void) {
-{
   osThreadId usb_tid;
 
   USBAUDIO_DEBUG("%s,%d", __func__, __LINE__);
@@ -135,5 +129,3 @@ int usb_os_init(void)
 
   return 0;
 }
-
-

apps/cmd/app_cmd.cpp

@@ -14,19 +14,18 @@
  *
  ****************************************************************************/
 #ifdef __PC_CMD_UART__
-#include "cmsis_os.h"
-#include "list.h"
-#include "string.h"
-#include "app_thread.h"
 #include "app_cmd.h"
+#include "app_thread.h"
+#include "audio_process.h"
+#include "cmsis_os.h"
 #include "hal_cmd.h"
 #include "hal_trace.h"
-#include "audio_process.h"
+#include "list.h"
+#include "string.h"
 
 #define APP_CMD_TRACE(s, ...) TRACE(s, ##__VA_ARGS__)
 
-void cmd_event_process(hal_cmd_rx_status_t status)
+void cmd_event_process(hal_cmd_rx_status_t status) {
-{
   APP_CMD_TRACE(1, "%s", __func__);
   APP_MESSAGE_BLOCK msg;
   msg.mod_id = APP_MODUAL_CMD;
@@ -36,16 +35,14 @@ void cmd_event_process(hal_cmd_rx_status_t status)
   return;
 }
 
-static int app_cmd_handle_process(APP_MESSAGE_BODY *msg_body)
+static int app_cmd_handle_process(APP_MESSAGE_BODY *msg_body) {
-{
   hal_cmd_run((hal_cmd_rx_status_t)msg_body->message_id);
   return 0;
 }
 
 uint8_t app_cmd_flag = 0;
 
-void app_cmd_open(void)
+void app_cmd_open(void) {
-{
   APP_CMD_TRACE(1, "%s", __func__);
 
   app_cmd_flag = 1;
@@ -56,11 +53,9 @@ void app_cmd_open(void)
   return;
 }
 
-void app_cmd_close(void)
+void app_cmd_close(void) {
-{
   APP_CMD_TRACE(1, "%s", __func__);
-    if(app_cmd_flag)
+  if (app_cmd_flag) {
-    {
     app_cmd_flag = 0;
     hal_cmd_close();
     app_set_threadhandle(APP_MODUAL_CMD, NULL);
@@ -68,4 +63,3 @@ void app_cmd_close(void)
   return;
 }
 #endif
-

apps/common/app_spec_ostimer.cpp

@@ -13,15 +13,15 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "cmsis_os.h"
-#include "stdint.h"
 #include "app_spec_ostimer.h"
+#include "cmsis_os.h"
 #include "hal_trace.h"
-
+#include "stdint.h"
 
 /// Create timer
-osStatus app_spec_timer_create (SPEC_TIMER_CTX_T *spec_timer_ctx, const osTimerDef_t *timer_def, os_timer_type type, void *argument)
+osStatus app_spec_timer_create(SPEC_TIMER_CTX_T *spec_timer_ctx,
-{    
+                               const osTimerDef_t *timer_def,
+                               os_timer_type type, void *argument) {
   spec_timer_ctx->type = type;
   spec_timer_ctx->argument = argument;
   spec_timer_ctx->timerid = osTimerCreate(timer_def, type, spec_timer_ctx);
@@ -29,8 +29,8 @@ osStatus app_spec_timer_create (SPEC_TIMER_CTX_T *spec_timer_ctx, const osTimerD
 }
 
 /// Start or restart timer
-osStatus app_spec_timer_start (SPEC_TIMER_CTX_T *spec_timer_ctx, uint32_t millisec)
+osStatus app_spec_timer_start(SPEC_TIMER_CTX_T *spec_timer_ctx,
-{
+                              uint32_t millisec) {
   osStatus status;
 
   // TRACE(1,"%s", __func__);
@@ -48,19 +48,16 @@ osStatus app_spec_timer_start (SPEC_TIMER_CTX_T *spec_timer_ctx, uint32_t millis
 }
 
 /// Stop timer
-osStatus app_spec_timer_stop (SPEC_TIMER_CTX_T *spec_timer_ctx)
+osStatus app_spec_timer_stop(SPEC_TIMER_CTX_T *spec_timer_ctx) {
-{
   return osTimerStop(spec_timer_ctx->timerid);
 }
 
 /// Delete timer
-osStatus app_spec_timer_delete (SPEC_TIMER_CTX_T *spec_timer_ctx)
+osStatus app_spec_timer_delete(SPEC_TIMER_CTX_T *spec_timer_ctx) {
-{
   return osTimerDelete(spec_timer_ctx->timerid);
 }
 
-void app_spec_timer_handler(void const *para)
+void app_spec_timer_handler(void const *para) {
-{
   SPEC_TIMER_CTX_T *spec_timer_ctx = (SPEC_TIMER_CTX_T *)para;
 
   if (spec_timer_ctx->ctx > UINT16_MAX) {

apps/common/app_thread.c

@@ -13,12 +13,11 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "cmsis_os.h"
-#include "hal_trace.h"
-#include "hal_timer.h"
-#include "app_utils.h"
 #include "app_thread.h"
-
+#include "app_utils.h"
+#include "cmsis_os.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
 
 static APP_MOD_HANDLER_T mod_handler[APP_MODUAL_NUM];
 
@@ -30,8 +29,7 @@ static osMailQId app_mailbox = NULL;
 static uint8_t app_mailbox_cnt = 0;
 osThreadId app_thread_tid;
 
-static int app_mailbox_init(void)
+static int app_mailbox_init(void) {
-{
   app_mailbox = osMailCreate(osMailQ(app_mailbox), NULL);
   if (app_mailbox == NULL) {
     TRACE(0, "Failed to Create app_mailbox\n");
@@ -41,8 +39,7 @@ static int app_mailbox_init(void)
   return 0;
 }
 
-int app_mailbox_put(APP_MESSAGE_BLOCK* msg_src)
+int app_mailbox_put(APP_MESSAGE_BLOCK *msg_src) {
-{
   osStatus status;
 
   APP_MESSAGE_BLOCK *msg_p = NULL;
@@ -55,9 +52,10 @@ int app_mailbox_put(APP_MESSAGE_BLOCK* msg_src)
     for (uint8_t i = 0; i < APP_MAILBOX_MAX; i++) {
       evt = osMailGet(app_mailbox, 0);
       if (evt.status == osEventMail) {
-                TRACE_IMM(9,"cnt:%d mod:%d src:%08x tim:%d id:%x ptr:%08x para:%08x/%08x/%08x", 
+        TRACE_IMM(
-                                                                       i,
+            9,
-                                                                       ((APP_MESSAGE_BLOCK *)(evt.value.p))->mod_id,
+            "cnt:%d mod:%d src:%08x tim:%d id:%x ptr:%08x para:%08x/%08x/%08x",
+            i, ((APP_MESSAGE_BLOCK *)(evt.value.p))->mod_id,
             ((APP_MESSAGE_BLOCK *)(evt.value.p))->src_thread,
             ((APP_MESSAGE_BLOCK *)(evt.value.p))->system_time,
             ((APP_MESSAGE_BLOCK *)(evt.value.p))->msg_body.message_id,
@@ -90,8 +88,7 @@ int app_mailbox_put(APP_MESSAGE_BLOCK* msg_src)
   return (int)status;
 }
 
-int app_mailbox_free(APP_MESSAGE_BLOCK* msg_p)
+int app_mailbox_free(APP_MESSAGE_BLOCK *msg_p) {
-{
   osStatus status;
 
   status = osMailFree(app_mailbox, msg_p);
@@ -101,8 +98,7 @@ int app_mailbox_free(APP_MESSAGE_BLOCK* msg_p)
   return (int)status;
 }
 
-int app_mailbox_get(APP_MESSAGE_BLOCK** msg_p)
+int app_mailbox_get(APP_MESSAGE_BLOCK **msg_p) {
-{
   osEvent evt;
   evt = osMailGet(app_mailbox, osWaitForever);
   if (evt.status == osEventMail) {
@@ -112,8 +108,7 @@ int app_mailbox_get(APP_MESSAGE_BLOCK** msg_p)
   return -1;
 }
 
-static void app_thread(void const *argument)
+static void app_thread(void const *argument) {
-{
   while (1) {
     APP_MESSAGE_BLOCK *msg_p = NULL;
 
@@ -130,8 +125,7 @@ static void app_thread(void const *argument)
   }
 }
 
-int app_os_init(void)
+int app_os_init(void) {
-{
   if (app_mailbox_init())
     return -1;
 
@@ -143,8 +137,8 @@ int app_os_init(void)
   return 0;
 }
 
-int app_set_threadhandle(enum APP_MODUAL_ID_T mod_id, APP_MOD_HANDLER_T handler)
+int app_set_threadhandle(enum APP_MODUAL_ID_T mod_id,
-{
+                         APP_MOD_HANDLER_T handler) {
   if (mod_id >= APP_MODUAL_NUM)
     return -1;
 
@@ -152,13 +146,8 @@ int app_set_threadhandle(enum APP_MODUAL_ID_T mod_id, APP_MOD_HANDLER_T handler)
   return 0;
 }
 
-void * app_os_tid_get(void)
+void *app_os_tid_get(void) { return (void *)app_thread_tid; }
-{
-    return (void *)app_thread_tid;
-}
 
-bool app_is_module_registered(enum APP_MODUAL_ID_T mod_id)
+bool app_is_module_registered(enum APP_MODUAL_ID_T mod_id) {
-{
   return mod_handler[mod_id];
 }
-

apps/common/app_thread.h

@@ -15,6 +15,8 @@
  ****************************************************************************/
 #ifndef __APP_THREAD_H__
 #define __APP_THREAD_H__
+#include <stdbool.h>
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -79,7 +81,8 @@ int app_mailbox_get(APP_MESSAGE_BLOCK** msg_p);
 
 int app_os_init(void);
 
-int app_set_threadhandle(enum APP_MODUAL_ID_T mod_id, APP_MOD_HANDLER_T handler);
+int app_set_threadhandle(enum APP_MODUAL_ID_T mod_id,
+                         APP_MOD_HANDLER_T handler);
 
 void *app_os_tid_get(void);
 

apps/common/app_utils.c

@@ -13,13 +13,13 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_utils.h"
+#include "analog.h"
 #include "cmsis.h"
-#include "hal_trace.h"
 #include "hal_timer.h"
+#include "hal_trace.h"
 #include "hal_wdt.h"
 #include "pmu.h"
-#include "analog.h"
-#include "app_utils.h"
 #ifdef RTOS
 #include "cmsis_os.h"
 #endif
@@ -41,19 +41,16 @@
  */
 /*
  * NOTE:
- * The macro QOS_USERS works only when the APP_SYSFREQ_USER_APP_XXX is not large than
+ * The macro QOS_USERS works only when the APP_SYSFREQ_USER_APP_XXX is not large
- * 32, currently this works, but if the are more user, another way needed
+ * than 32, currently this works, but if the are more user, another way needed
  */
-#define QOS_USERS   ((1 << (APP_SYSFREQ_USER_AI_VOICE)) | \
+#define QOS_USERS                                                              \
-                    (1 << (APP_SYSFREQ_USER_BT_A2DP)))
+  ((1 << (APP_SYSFREQ_USER_AI_VOICE)) | (1 << (APP_SYSFREQ_USER_BT_A2DP)))
 
 static const uint32_t freq_map[] = {
-    [HAL_CMU_FREQ_32K] = FREQ_FREE,
+    [HAL_CMU_FREQ_32K] = FREQ_FREE,  [HAL_CMU_FREQ_26M] = FREQ_26M,
-    [HAL_CMU_FREQ_26M] = FREQ_26M,
+    [HAL_CMU_FREQ_52M] = FREQ_52M,   [HAL_CMU_FREQ_78M] = FREQ_78M,
-    [HAL_CMU_FREQ_52M] = FREQ_52M,
+    [HAL_CMU_FREQ_104M] = FREQ_104M, [HAL_CMU_FREQ_208M] = FREQ_208M,
-    [HAL_CMU_FREQ_78M] = FREQ_78M,
-    [HAL_CMU_FREQ_104M] = FREQ_104M,
-    [HAL_CMU_FREQ_208M] = FREQ_208M,
 };
 
 static const uint32_t user_map[] = {
@@ -89,8 +86,8 @@ static uint32_t qos_freqs_map;
  */
 static uint32_t qos_users_map;
 
-static int app_qosfreq_req(enum APP_SYSFREQ_USER_T user, enum APP_SYSFREQ_FREQ_T freq)
+static int app_qosfreq_req(enum APP_SYSFREQ_USER_T user,
-{
+                           enum APP_SYSFREQ_FREQ_T freq) {
   int ret;
   int qos_freq_num = 0;
   uint32_t max_qos_freq = 0;
@@ -160,21 +157,23 @@ static int app_qosfreq_req(enum APP_SYSFREQ_USER_T user, enum APP_SYSFREQ_FREQ_T
 
   user = APP_SYSFREQ_USER_QOS;
   TRACE(2, "User %d require sysfreq %d", user, qos_freq_num);
-    ret = hal_sysfreq_req((enum HAL_SYSFREQ_USER_T)user, (enum HAL_CMU_FREQ_T)qos_freq_num);
+  ret = hal_sysfreq_req((enum HAL_SYSFREQ_USER_T)user,
+                        (enum HAL_CMU_FREQ_T)qos_freq_num);
 
   int_unlock(lock);
   return ret;
 }
 
-int app_sysfreq_req(enum APP_SYSFREQ_USER_T user, enum APP_SYSFREQ_FREQ_T freq)
+int app_sysfreq_req(enum APP_SYSFREQ_USER_T user,
-{
+                    enum APP_SYSFREQ_FREQ_T freq) {
   int ret;
 
   // if user is qos user
   if ((1 << user) & QOS_USERS) {
     ret = app_qosfreq_req(user, freq);
   } else { // if user is NOT qos user
-        ret = hal_sysfreq_req((enum HAL_SYSFREQ_USER_T)user, (enum HAL_CMU_FREQ_T)freq);
+    ret = hal_sysfreq_req((enum HAL_SYSFREQ_USER_T)user,
+                          (enum HAL_CMU_FREQ_T)freq);
   }
 
   return ret;
@@ -188,28 +187,24 @@ static osTimerId wdt_ping_timer_id;
 osTimerDef(wdt_ping_timer, watchdog_ping_handler);
 static uint32_t wdt_ping_period;
 
-static void watchdog_ping(void)
+static void watchdog_ping(void) {
-{
   hal_wdt_ping(HAL_WDT_ID_0);
 #ifndef CHIP_BEST2000
   pmu_wdt_feed();
 #endif
 }
 
-static void app_wdt_irq_handle(enum HAL_WDT_ID_T id, uint32_t status)
+static void app_wdt_irq_handle(enum HAL_WDT_ID_T id, uint32_t status) {
-{
   analog_aud_codec_mute();
   ASSERT(0, "%s id:%d status:%d", __func__, id, status);
 }
 
-static void pmu_wdt_irq_handle(void)
+static void pmu_wdt_irq_handle(void) {
-{
   analog_aud_codec_mute();
   ASSERT(1, "%s", __func__);
 }
 
-static void watchdog_ping_handler(void const *unused)
+static void watchdog_ping_handler(void const *unused) {
-{
   int ret;
 
   watchdog_ping();
@@ -221,8 +216,7 @@ static void watchdog_ping_handler(void const *unused)
   osTimerStart(wdt_ping_timer_id, wdt_ping_period);
 }
 
-int app_wdt_open(int seconds)
+int app_wdt_open(int seconds) {
-{
   uint32_t lock = int_lock();
 
   hal_wdt_set_irq_callback(HAL_WDT_ID_0, app_wdt_irq_handle);
@@ -245,8 +239,7 @@ int app_wdt_open(int seconds)
   return 0;
 }
 
-int app_wdt_reopen(int seconds)
+int app_wdt_reopen(int seconds) {
-{
   uint32_t lock = int_lock();
   hal_wdt_stop(HAL_WDT_ID_0);
   hal_wdt_set_timeout(HAL_WDT_ID_0, seconds);
@@ -261,8 +254,7 @@ int app_wdt_reopen(int seconds)
   return 0;
 }
 
-int app_wdt_close(void)
+int app_wdt_close(void) {
-{
   uint32_t lock;
 
   osTimerStop(wdt_ping_timer_id);
@@ -278,4 +270,3 @@ int app_wdt_close(void)
 }
 
 #endif
-

apps/common/randfrommic.c

@@ -1,16 +1,16 @@
 #ifdef __RAND_FROM_MIC__
-#include "audioflinger.h"
-#include "hal_trace.h"
-#include "app_utils.h"
-#include "string.h"
-#include "stdlib.h"
-#include "stdio.h"
-#include "app_bt_stream.h"
 #include "randfrommic.h"
-#include "hal_timer.h"
-#include "cmsis_os.h"
-#include "cmsis_gcc.h"
 #include "app_audio.h"
+#include "app_bt_stream.h"
+#include "app_utils.h"
+#include "audioflinger.h"
+#include "cmsis_gcc.h"
+#include "cmsis_os.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "string.h"
 
 #if BT_DRV_DEBUG
 #define RAND_TRACE(n, fmt, ...) TRACE(n, fmt, ##__VA_ARGS__)
@@ -32,24 +32,19 @@ static bool randInitialised = false;
 #define RAND_GRAB_BITS_PER_SAMPLE 4
 #define RAND_GRAB_BITS_MASK_PER_SAMPLE ((1 << RAND_GRAB_BITS_PER_SAMPLE) - 1)
 
-RAND_NUMBER_T randomBuffer =
+RAND_NUMBER_T randomBuffer = {
-{
     25,
     RAND_STATUS_CLOSE,
 };
 
 /**
- * Description: parse mic data according to the stream cfg(bit mode and channel number)
+ * Description: parse mic data according to the stream cfg(bit mode and channel
- *              only the lowest byte of each frame is taken
+ * number) only the lowest byte of each frame is taken ADC format: 16bit mode ->
- * ADC format:
+ * [15:0] is valid 24bit mode -> [23:4] is valid 32bit mode -> [31:12] is valid
- *      16bit mode -> [15:0] is valid
- *      24bit mode -> [23:4] is valid
- *      32bit mode -> [31:12] is valid
  *
  */
 static int randDataParse(uint8_t *buf, uint32_t len, enum AUD_BITS_T bits,
-    enum AUD_CHANNEL_NUM_T ch_num)
+                         enum AUD_CHANNEL_NUM_T ch_num) {
-{
   uint8_t index = 0;
 
   union {
@@ -66,49 +61,46 @@ static int randDataParse(uint8_t *buf, uint32_t len, enum AUD_BITS_T bits,
   RAND_TRACE(1, "%s", __func__);
   RAND_DUMP("%x ", buf, 16);
 
-    switch (bits)
+  switch (bits) {
-    {
+  case AUD_BITS_16: {
-        case AUD_BITS_16:
-        {
     uint16_t *content = (uint16_t *)buf;
 
-            for (index = 0;index < 4; index++)
+    for (index = 0; index < 4; index++) {
-            {
+      seedData.value[index] =
-                seedData.value[index] = ((*content) & RAND_GRAB_BITS_MASK_PER_SAMPLE) |
+          ((*content) & RAND_GRAB_BITS_MASK_PER_SAMPLE) |
-                    (((*(content+ch_num)) & RAND_GRAB_BITS_MASK_PER_SAMPLE) << RAND_GRAB_BITS_PER_SAMPLE);
+          (((*(content + ch_num)) & RAND_GRAB_BITS_MASK_PER_SAMPLE)
+           << RAND_GRAB_BITS_PER_SAMPLE);
       content += ((8 / RAND_GRAB_BITS_PER_SAMPLE) * ch_num);
     }
     break;
   }
-        case AUD_BITS_24:
+  case AUD_BITS_24: {
-        {
     uint32_t *content = (uint32_t *)buf;
-            for (index = 0;index < 4; index++)
+    for (index = 0; index < 4; index++) {
-            {
       // bit 23:4 are valid
-                seedData.value[index] = (((*content) >> 4) & RAND_GRAB_BITS_MASK_PER_SAMPLE) |
+      seedData.value[index] =
-                    ((((*(content+ch_num)) >> 4)&RAND_GRAB_BITS_MASK_PER_SAMPLE) << RAND_GRAB_BITS_PER_SAMPLE);
+          (((*content) >> 4) & RAND_GRAB_BITS_MASK_PER_SAMPLE) |
+          ((((*(content + ch_num)) >> 4) & RAND_GRAB_BITS_MASK_PER_SAMPLE)
+           << RAND_GRAB_BITS_PER_SAMPLE);
       content += ((8 / RAND_GRAB_BITS_PER_SAMPLE) * ch_num);
     }
     break;
   }
-        case AUD_BITS_32:
+  case AUD_BITS_32: {
-        {
     uint32_t *content = (uint32_t *)buf;
-            for (index = 0;index < 4; index++)
+    for (index = 0; index < 4; index++) {
-            {
       // bit 31:12 are valid
-                seedData.value[index] = (((*content) >> 12) & RAND_GRAB_BITS_MASK_PER_SAMPLE) |
+      seedData.value[index] =
-                    ((((*(content+ch_num)) >> 12) & RAND_GRAB_BITS_MASK_PER_SAMPLE) << RAND_GRAB_BITS_PER_SAMPLE);
+          (((*content) >> 12) & RAND_GRAB_BITS_MASK_PER_SAMPLE) |
+          ((((*(content + ch_num)) >> 12) & RAND_GRAB_BITS_MASK_PER_SAMPLE)
+           << RAND_GRAB_BITS_PER_SAMPLE);
       content += ((8 / RAND_GRAB_BITS_PER_SAMPLE) * ch_num);
     }
     break;
   }
-        default:
+  default: {
-        {
     return -1;
-        }
+  } break;
-        break;
   }
 
   randSeed = seedData.seedValue;
@@ -116,21 +108,18 @@ static int randDataParse(uint8_t *buf, uint32_t len, enum AUD_BITS_T bits,
   return 0;
 }
 
-static void generateRand(bool on)
+static void generateRand(bool on) {
-{
   struct AF_STREAM_CONFIG_T stream_cfg;
 
   RAND_TRACE(2, "%s op:%d", __func__, on);
 
-    if (on)
+  if (on) {
-    {
     randomBuffer.skipRound = 10;
 
     randomBuffer.status = random_mic_is_on(&deviceId);
     RAND_TRACE(2, "%s random status = %d", __func__, randomBuffer.status);
 
-        if (RAND_STATUS_CLOSE == randomBuffer.status)
+    if (RAND_STATUS_CLOSE == randomBuffer.status) {
-        {
       app_sysfreq_req(APP_SYSFREQ_USER_RANDOM, APP_SYSFREQ_208M);
       app_capture_audio_mempool_init();
       app_capture_audio_mempool_get_buff(&captureBuffer,
@@ -149,22 +138,15 @@ static void generateRand(bool on)
       af_stream_open(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE, &stream_cfg);
       af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
       randomBuffer.status = RAND_STATUS_OPEN;
-        }
+    } else if (RAND_STATUS_MIC_OPENED == randomBuffer.status) {
-        else if(RAND_STATUS_MIC_OPENED == randomBuffer.status)
-        {
       af_stream_start(deviceId, AUD_STREAM_CAPTURE);
     }
-    }
+  } else {
-    else
-    {
     // release the acquired system clock
     app_sysfreq_req(APP_SYSFREQ_USER_RANDOM, APP_SYSFREQ_32K);
-        if (RAND_STATUS_MIC_OPENED == randomBuffer.status)
+    if (RAND_STATUS_MIC_OPENED == randomBuffer.status) {
-        {
       af_stream_stop(deviceId, AUD_STREAM_CAPTURE);
-        }
+    } else if (RAND_STATUS_OPEN == randomBuffer.status) {
-        else if (RAND_STATUS_OPEN == randomBuffer.status)
-        {
       af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
       af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
     }
@@ -172,46 +154,37 @@ static void generateRand(bool on)
   }
 }
 
-static uint32_t rand_data_handle(uint8_t *buf, uint32_t len)
+static uint32_t rand_data_handle(uint8_t *buf, uint32_t len) {
-{
+  if (buf == NULL) {
-    if (buf == NULL)
-    {
     return len;
   }
 
   if ((1 == randomBuffer.skipRound) &&
-        (!randDataParse(buf, len, AUD_BITS_16, AUD_CHANNEL_NUM_1)))
+      (!randDataParse(buf, len, AUD_BITS_16, AUD_CHANNEL_NUM_1))) {
-    {
     generateRand(false);
     randomBuffer.skipRound = 0;
-    }
+  } else if (1 != randomBuffer.skipRound) {
-    else if (1 != randomBuffer.skipRound)
-    {
     randomBuffer.skipRound--;
   }
 
   return len;
 }
 
-void initSeed(void)
+void initSeed(void) {
-{
   uint8_t count = 100; // avoid deed loop
 
   RAND_TRACE(2, "%s:+++ initialised = %d", __func__, randInitialised);
 
-    if (randInitialised)
+  if (randInitialised) {
-    {
     generateRand(true);
 
-        while ((0 != randomBuffer.skipRound) && (0 != count))
+    while ((0 != randomBuffer.skipRound) && (0 != count)) {
-        {
       osDelay(10);
       count--;
     }
   }
 
-    if ((0 == count) || (false == randInitialised))
+  if ((0 == count) || (false == randInitialised)) {
-    {
     RAND_TRACE(1, "%s not ready", __func__);
     randSeed = (uint32_t)hal_sys_timer_get();
     generateRand(false);
@@ -221,47 +194,36 @@ void initSeed(void)
   RAND_TRACE(2, "%s:--- count = %d", __func__, count);
 }
 
-void random_status_sync(void)
+void random_status_sync(void) {
-{
+  if (RAND_STATUS_OPEN == randomBuffer.status) {
-    if (RAND_STATUS_OPEN == randomBuffer.status)
-    {
     RAND_TRACE(1, "%s random mic has already on,should be closed", __func__);
     generateRand(false);
   }
 }
 
 void random_data_process(uint8_t *buf, uint32_t len, enum AUD_BITS_T bits,
-    enum AUD_CHANNEL_NUM_T ch_num)
+                         enum AUD_CHANNEL_NUM_T ch_num) {
-{
+  if (buf == NULL) {
-    if (buf == NULL)
-    {
     return;
   }
 
   if ((RAND_STATUS_MIC_STARTED == randomBuffer.status) ||
-        (RAND_STATUS_MIC_OPENED == randomBuffer.status))
+      (RAND_STATUS_MIC_OPENED == randomBuffer.status)) {
-    {
+    if (len >= RANDOM_CAPTURE_BUFFER_SIZE / 2) {
-        if (len >= RANDOM_CAPTURE_BUFFER_SIZE/2)
+      RAND_TRACE(4, "%s buf address = 0x%p, bits = %d, channel num = %d",
-        {
+                 __func__, buf, bits, ch_num);
-            RAND_TRACE(4, "%s buf address = 0x%p, bits = %d, channel num = %d", __func__, buf, bits, ch_num);
       RAND_DUMP("%02x ", buf, 32);
       if ((1 == randomBuffer.skipRound) &&
-                (!randDataParse(buf, len, bits, ch_num)))
+          (!randDataParse(buf, len, bits, ch_num))) {
-            {
         generateRand(false);
         randomBuffer.skipRound = 0;
-            }
+      } else if (1 != randomBuffer.skipRound) {
-            else if (1 != randomBuffer.skipRound)
-            {
         randomBuffer.skipRound--;
       }
     }
   }
 }
 
-void randInit(void)
+void randInit(void) { randInitialised = true; }
-{
-    randInitialised = true;
-}
 
 #endif

apps/factory/app_factory.cpp

@@ -13,46 +13,44 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_factory.h"
+#include "app_bt_stream.h"
+#include "app_key.h"
+#include "app_media_player.h"
+#include "bluetooth.h"
+#include "bt_drv_interface.h"
+#include "bt_drv_reg_op.h"
 #include "cmsis_os.h"
-#include "list.h"
-#include "hal_trace.h"
 #include "hal_bootmode.h"
 #include "hal_cmu.h"
 #include "hal_sleep.h"
-#include "app_key.h"
+#include "hal_trace.h"
-#include "app_factory.h"
+#include "list.h"
-#include "bt_drv_interface.h"
-#include "bt_drv_reg_op.h"
-#include "bluetooth.h"
 #include "nvrecord.h"
 #include "nvrecord_dev.h"
 #include "nvrecord_env.h"
-#include "resources.h"
-#include "app_bt_stream.h"
-#include "app_media_player.h"
 #include "pmu.h"
+#include "resources.h"
 
 // for init
-#include "apps.h"
+#include "app_battery.h"
+#include "app_key.h"
+#include "app_overlay.h"
+#include "app_pwl.h"
 #include "app_status_ind.h"
 #include "app_thread.h"
-#include "app_key.h"
-#include "app_pwl.h"
-#include "app_overlay.h"
-#include "app_battery.h"
 #include "app_utils.h"
+#include "apps.h"
 
 // for bt
-#include "besbt.h"
 #include "app_bt.h"
 #include "app_factory_bt.h"
+#include "besbt.h"
 
 // for audio
-#include "audioflinger.h"
 #include "app_audio.h"
 #include "app_utils.h"
-
+#include "audioflinger.h"
-
 
 // for progress
 #include "hal_uart.h"
@@ -78,20 +76,22 @@ void app_bt_key_shutdown(APP_KEY_STATUS *status, void *param);
 void app_factorymode_result_set(bool result);
 
 static osThreadId app_factorymode_tid = NULL;
-static struct message_t send_msg = { { PREFIX_CHAR, }, };
+static struct message_t send_msg = {
+    {
+        PREFIX_CHAR,
+    },
+};
 static unsigned char send_seq = 0;
 
 osTimerId app_factory_timer = NULL;
 osTimerDef(APP_FACTORY_TIMER, app_factorymode_timehandler);
 
-int app_factorymode_languageswitch_proc(void)
+int app_factorymode_languageswitch_proc(void) {
-{
 #ifdef MEDIA_PLAYER_SUPPORT
   int lan;
   int new_lan;
   struct nvrecord_env_t *nvrecord_env;
 
-
   APP_FACTORY_TRACE(1, "%s", __func__);
   lan = app_play_audio_get_lang();
   new_lan = lan;
@@ -107,15 +107,14 @@ int app_factorymode_languageswitch_proc(void)
   return 0;
 }
 
-void app_factorymode_languageswitch(APP_KEY_STATUS *status, void *param)
+void app_factorymode_languageswitch(APP_KEY_STATUS *status, void *param) {
-{
   app_factorymode_languageswitch_proc();
 }
 
-void app_factorymode_enter(void)
+void app_factorymode_enter(void) {
-{
   APP_FACTORY_TRACE(1, "%s", __func__);
-    hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE|HAL_SW_BOOTMODE_TEST_SIGNALINGMODE);
+  hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE |
+                      HAL_SW_BOOTMODE_TEST_SIGNALINGMODE);
   hal_cmu_sys_reboot();
 }
 
@@ -123,20 +122,12 @@ extern "C" {
 
 static bool isInFactoryMode = false;
 
-bool app_factorymode_get(void)
+bool app_factorymode_get(void) { return isInFactoryMode; }
-{
-    return isInFactoryMode;
-}
-
-void app_factorymode_set(bool set)
-{
-    isInFactoryMode = set;
-}
 
+void app_factorymode_set(bool set) { isInFactoryMode = set; }
 }
 #ifdef POWERKEY_I2C_SWITCH
-void app_factorymode_i2c_switch(APP_KEY_STATUS *status, void *param)
+void app_factorymode_i2c_switch(APP_KEY_STATUS *status, void *param) {
-{
   static int i = 0;
 
   i++;
@@ -154,30 +145,49 @@ void app_factorymode_i2c_switch(APP_KEY_STATUS *status, void *param)
 
 #ifdef __IBRT_IBRT_TESTMODE__
 void bt_drv_ibrt_test_key_click(APP_KEY_STATUS *status, void *param);
-void bt_drv_ibrt_test_key_click(APP_KEY_STATUS *status, void *param)
+void bt_drv_ibrt_test_key_click(APP_KEY_STATUS *status, void *param) {
-{
   btdrv_connect_ibrt_device(bt_addr);
 }
 #endif
 
-void app_factorymode_key_init(void)
+void app_factorymode_key_init(void) {
-{
   const APP_KEY_HANDLE app_factorymode_handle_cfg[] = {
 #ifdef POWERKEY_I2C_SWITCH
-        {{APP_KEY_CODE_PWR,APP_KEY_EVENT_RAMPAGECLICK},"bt i2c key",app_factorymode_i2c_switch, NULL},
+      {{APP_KEY_CODE_PWR, APP_KEY_EVENT_RAMPAGECLICK},
+       "bt i2c key",
+       app_factorymode_i2c_switch,
+       NULL},
 #endif
 #ifdef __POWERKEY_CTRL_ONOFF_ONLY__
-        {{APP_KEY_CODE_PWR,APP_KEY_EVENT_UP},"bt function key",app_bt_key_shutdown, NULL},
+      {{APP_KEY_CODE_PWR, APP_KEY_EVENT_UP},
+       "bt function key",
+       app_bt_key_shutdown,
+       NULL},
 #else
-        {{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGLONGPRESS},"bt function key",app_bt_key_shutdown, NULL},
+      {{APP_KEY_CODE_PWR, APP_KEY_EVENT_LONGLONGPRESS},
+       "bt function key",
+       app_bt_key_shutdown,
+       NULL},
 #endif
 #ifdef __IBRT_IBRT_TESTMODE__
-        {{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",bt_drv_ibrt_test_key_click, NULL},
+      {{APP_KEY_CODE_PWR, APP_KEY_EVENT_CLICK},
+       "bt function key",
+       bt_drv_ibrt_test_key_click,
+       NULL},
 #else
-        {{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",app_factorymode_languageswitch, NULL},
+      {{APP_KEY_CODE_PWR, APP_KEY_EVENT_CLICK},
+       "bt function key",
+       app_factorymode_languageswitch,
+       NULL},
 #endif
-        {{APP_KEY_CODE_PWR,APP_KEY_EVENT_DOUBLECLICK},"bt function key",app_factorymode_bt_xtalcalib, NULL},
+      {{APP_KEY_CODE_PWR, APP_KEY_EVENT_DOUBLECLICK},
-        {{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGPRESS},"bt function key",app_factorymode_bt_signalingtest, NULL},
+       "bt function key",
+       app_factorymode_bt_xtalcalib,
+       NULL},
+      {{APP_KEY_CODE_PWR, APP_KEY_EVENT_LONGPRESS},
+       "bt function key",
+       app_factorymode_bt_signalingtest,
+       NULL},
   };
 
   uint8_t i = 0;
@@ -185,70 +195,68 @@ void app_factorymode_key_init(void)
   APP_FACTORY_TRACE(1, "%s", __func__);
 
   app_key_handle_clear();
-    for (i=0; i<(sizeof(app_factorymode_handle_cfg)/sizeof(APP_KEY_HANDLE)); i++){
+  for (i = 0; i < (sizeof(app_factorymode_handle_cfg) / sizeof(APP_KEY_HANDLE));
+       i++) {
     app_key_handle_registration(&app_factorymode_handle_cfg[i]);
   }
 }
 
-static void app_factorymode_audioloopswitch(APP_KEY_STATUS *status, void *param)
+static void app_factorymode_audioloopswitch(APP_KEY_STATUS *status,
-{
+                                            void *param) {
   static bool onaudioloop = false;
 
   onaudioloop = onaudioloop ? false : true;
 
   if (onaudioloop)
-        app_audio_sendrequest(APP_FACTORYMODE_AUDIO_LOOP, (uint8_t)APP_BT_SETTING_OPEN, 0);
+    app_audio_sendrequest(APP_FACTORYMODE_AUDIO_LOOP,
+                          (uint8_t)APP_BT_SETTING_OPEN, 0);
   else
-        app_audio_sendrequest(APP_FACTORYMODE_AUDIO_LOOP, (uint8_t)APP_BT_SETTING_CLOSE, 0);
+    app_audio_sendrequest(APP_FACTORYMODE_AUDIO_LOOP,
+                          (uint8_t)APP_BT_SETTING_CLOSE, 0);
 }
 
-void app_factorymode_test_key_init(void)
+void app_factorymode_test_key_init(void) {
-{
   const APP_KEY_HANDLE app_factorymode_handle_cfg[] = {
-        {{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",app_factorymode_audioloopswitch, NULL},
+      {{APP_KEY_CODE_PWR, APP_KEY_EVENT_CLICK},
+       "bt function key",
+       app_factorymode_audioloopswitch,
+       NULL},
   };
 
   uint8_t i = 0;
   APP_FACTORY_TRACE(1, "%s", __func__);
-    for (i=0; i<(sizeof(app_factorymode_handle_cfg)/sizeof(APP_KEY_HANDLE)); i++){
+  for (i = 0; i < (sizeof(app_factorymode_handle_cfg) / sizeof(APP_KEY_HANDLE));
+       i++) {
     app_key_handle_registration(&app_factorymode_handle_cfg[i]);
   }
 }
 
-void app_factorymode_result_clean(void)
+void app_factorymode_result_clean(void) {
-{
   osSignalClear(app_factorymode_tid, 0x01);
   osSignalClear(app_factorymode_tid, 0x02);
 }
 
-void app_factorymode_result_set(bool result)
+void app_factorymode_result_set(bool result) {
-{
   if (result)
     osSignalSet(app_factorymode_tid, 0x01);
   else
     osSignalSet(app_factorymode_tid, 0x02);
 }
 
-bool app_factorymode_result_wait(void)
+bool app_factorymode_result_wait(void) {
-{
   bool nRet;
   osEvent evt;
 
-    while(1)
+  while (1) {
-    {
     // wait any signal
     evt = osSignalWait(0x0, osWaitForever);
 
     // get role from signal value
-        if(evt.status == osEventSignal)
+    if (evt.status == osEventSignal) {
-        {
+      if (evt.value.signals & 0x01) {
-            if(evt.value.signals & 0x01)
-            {
         nRet = true;
         break;
-            }
+      } else if (evt.value.signals & 0x02) {
-            else if(evt.value.signals & 0x02)
-            {
         nRet = false;
         break;
       }
@@ -257,8 +265,7 @@ bool app_factorymode_result_wait(void)
   return nRet;
 }
 
-static int app_factorymode_send_progress (uint8_t progress)
+static int app_factorymode_send_progress(uint8_t progress) {
-{
   APP_MESSAGE_BLOCK msg;
 
   msg.mod_id = APP_MODUAL_OHTER;
@@ -269,8 +276,7 @@ static int app_factorymode_send_progress (uint8_t progress)
   return 0;
 }
 
-static int app_factorymode_send_code (uint32_t progress)
+static int app_factorymode_send_code(uint32_t progress) {
-{
   APP_MESSAGE_BLOCK msg;
 
   msg.mod_id = APP_MODUAL_OHTER;
@@ -281,8 +287,7 @@ static int app_factorymode_send_code (uint32_t progress)
   return 0;
 }
 
-int app_factorymode_proc(void)
+int app_factorymode_proc(void) {
-{
   uint8_t cnt = 0;
   bool nRet;
   app_factorymode_tid = osThreadGetId();
@@ -313,8 +318,8 @@ exit:
   }
 }
 
-static unsigned char app_factorymode_msg_check_sum(unsigned char *buf, unsigned char len)
+static unsigned char app_factorymode_msg_check_sum(unsigned char *buf,
-{
+                                                   unsigned char len) {
   int i;
   unsigned char sum = 0;
 
@@ -325,8 +330,7 @@ static unsigned char app_factorymode_msg_check_sum(unsigned char *buf, unsigned
   return sum;
 }
 
-static int app_factorymode_msg_uart_send(const unsigned char *buf, size_t len)
+static int app_factorymode_msg_uart_send(const unsigned char *buf, size_t len) {
-{
   uint32_t sent = 0;
 
   while (sent < len) {
@@ -340,8 +344,7 @@ static int app_factorymode_msg_uart_send(const unsigned char *buf, size_t len)
   return 0;
 }
 
-static int app_factorymode_msg_send_ping(void)
+static int app_factorymode_msg_send_ping(void) {
-{
   int ret;
 
   send_msg.hdr.type = 0x88;
@@ -349,15 +352,16 @@ static int app_factorymode_msg_send_ping(void)
   send_msg.hdr.len = 2;
   send_msg.data[0] = 0xaa;
   send_msg.data[1] = 0x55;
-    send_msg.data[2] = ~app_factorymode_msg_check_sum((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg) - 1);
+  send_msg.data[2] = ~app_factorymode_msg_check_sum(
+      (unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg) - 1);
 
-    ret = app_factorymode_msg_uart_send((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg));
+  ret = app_factorymode_msg_uart_send((unsigned char *)&send_msg,
+                                      MSG_TOTAL_LEN(&send_msg));
 
   return ret;
 }
 
-static int app_factorymode_msg_send_progress (uint8_t progress)
+static int app_factorymode_msg_send_progress(uint8_t progress) {
-{
   int ret;
 
   send_msg.hdr.type = 0x88;
@@ -365,15 +369,16 @@ static int app_factorymode_msg_send_progress (uint8_t progress)
   send_msg.hdr.len = 2;
   send_msg.data[0] = progress;
   send_msg.data[1] = 100;
-    send_msg.data[2] = ~app_factorymode_msg_check_sum((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg) - 1);
+  send_msg.data[2] = ~app_factorymode_msg_check_sum(
+      (unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg) - 1);
 
-    ret = app_factorymode_msg_uart_send((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg));
+  ret = app_factorymode_msg_uart_send((unsigned char *)&send_msg,
+                                      MSG_TOTAL_LEN(&send_msg));
 
   return ret;
 }
 
-static int app_factorymode_msg_send_32bitcode(uint32_t code)
+static int app_factorymode_msg_send_32bitcode(uint32_t code) {
-{
   int ret;
 
   send_msg.hdr.type = 0x88;
@@ -381,15 +386,16 @@ static int app_factorymode_msg_send_32bitcode(uint32_t code)
   send_msg.hdr.len = 4;
   send_msg.data[0] = 0xf2;
   *(uint32_t *)&(send_msg.data[1]) = code;
-    send_msg.data[4] = ~app_factorymode_msg_check_sum((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg) - 1);
+  send_msg.data[4] = ~app_factorymode_msg_check_sum(
+      (unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg) - 1);
 
-    ret = app_factorymode_msg_uart_send((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg));
+  ret = app_factorymode_msg_uart_send((unsigned char *)&send_msg,
+                                      MSG_TOTAL_LEN(&send_msg));
 
   return ret;
 }
 
-static int app_factorymode_process(APP_MESSAGE_BODY *msg_body)
+static int app_factorymode_process(APP_MESSAGE_BODY *msg_body) {
-{
   if (msg_body->message_id == 1) {
     app_factorymode_msg_send_ping();
   }
@@ -402,20 +408,16 @@ static int app_factorymode_process(APP_MESSAGE_BODY *msg_body)
   return 0;
 }
 
-static int app_factorymode_uart_init(void)
+static int app_factorymode_uart_init(void) {
-{
   struct HAL_UART_CFG_T uart_cfg;
 
   memset(&uart_cfg, 0, sizeof(struct HAL_UART_CFG_T));
-    uart_cfg.parity = HAL_UART_PARITY_NONE,
+  uart_cfg.parity = HAL_UART_PARITY_NONE, uart_cfg.stop = HAL_UART_STOP_BITS_1,
-    uart_cfg.stop = HAL_UART_STOP_BITS_1,
   uart_cfg.data = HAL_UART_DATA_BITS_8,
   uart_cfg.flow = HAL_UART_FLOW_CONTROL_NONE, // HAL_UART_FLOW_CONTROL_RTSCTS,
       uart_cfg.tx_level = HAL_UART_FIFO_LEVEL_1_2,
-    uart_cfg.rx_level = HAL_UART_FIFO_LEVEL_1_4,
+  uart_cfg.rx_level = HAL_UART_FIFO_LEVEL_1_4, uart_cfg.baud = 921600,
-    uart_cfg.baud = 921600,
+  uart_cfg.dma_rx = false, uart_cfg.dma_tx = false,
-    uart_cfg.dma_rx = false,
-    uart_cfg.dma_tx = false,
   uart_cfg.dma_rx_stop_on_err = false;
   hal_uart_close(HAL_UART_ID_0);
   hal_uart_open(HAL_UART_ID_0, &uart_cfg);
@@ -423,9 +425,7 @@ static int app_factorymode_uart_init(void)
   return 0;
 }
 
-
+static void app_factorymode_timehandler(void const *param) {
-static void app_factorymode_timehandler(void const *param)
-{
   APP_MESSAGE_BLOCK msg;
 
   msg.mod_id = APP_MODUAL_OHTER;
@@ -433,8 +433,7 @@ static void app_factorymode_timehandler(void const *param)
   app_mailbox_put(&msg);
 }
 
-static uint8_t app_factorymode_indication_init(void)
+static uint8_t app_factorymode_indication_init(void) {
-{
   struct APP_PWL_CFG_T cfg;
 
   memset(&cfg, 0, sizeof(struct APP_PWL_CFG_T));
@@ -444,8 +443,8 @@ static uint8_t app_factorymode_indication_init(void)
   return 0;
 }
 
-static uint8_t app_factorymode_status_indication(APP_FACTORYMODE_STATUS_INDICATION_T status)
+static uint8_t
-{
+app_factorymode_status_indication(APP_FACTORYMODE_STATUS_INDICATION_T status) {
   struct APP_PWL_CFG_T cfg0;
   struct APP_PWL_CFG_T cfg1;
   APP_FACTORY_TRACE(2, "%s %d", __func__, status);
@@ -504,8 +503,7 @@ static uint8_t app_factorymode_status_indication(APP_FACTORYMODE_STATUS_INDICATI
   return 0;
 }
 
-int app_factorymode_init(uint32_t factorymode)
+int app_factorymode_init(uint32_t factorymode) {
-{
   uint8_t cnt = 0;
   int nRet = 0;
   uint32_t capval = 0x00;
@@ -527,7 +525,8 @@ int app_factorymode_init(uint32_t factorymode)
     goto exit;
   }
   app_set_threadhandle(APP_MODUAL_OHTER, app_factorymode_process);
-    app_factory_timer = osTimerCreate (osTimer(APP_FACTORY_TIMER), osTimerPeriodic, NULL);
+  app_factory_timer =
+      osTimerCreate(osTimer(APP_FACTORY_TIMER), osTimerPeriodic, NULL);
   osTimerStart(app_factory_timer, 300);
   app_factorymode_send_progress(10);
 
@@ -592,8 +591,7 @@ exit:
   return nRet;
 }
 
-int app_factorymode_calib_only(void)
+int app_factorymode_calib_only(void) {
-{
   uint8_t cnt = 0;
   int nRet = 0;
   uint32_t capval = 0x00;
@@ -611,7 +609,8 @@ int app_factorymode_calib_only(void)
   app_factorymode_indication_init();
 
   app_set_threadhandle(APP_MODUAL_OHTER, app_factorymode_process);
-    app_factory_timer = osTimerCreate(osTimer(APP_FACTORY_TIMER),osTimerPeriodic,NULL);
+  app_factory_timer =
+      osTimerCreate(osTimer(APP_FACTORY_TIMER), osTimerPeriodic, NULL);
   osTimerStart(app_factory_timer, 300);
   app_factorymode_status_indication(APP_FACTORYMODE_STATUS_INDICATION_RUNNING);
   app_factorymode_send_progress(10);
@@ -650,25 +649,21 @@ exit:
 
 #ifdef __USB_COMM__
 // for usb
-#include "usb_cdc.h"
 #include "hal_timer.h"
 #include "hwtimer_list.h"
+#include "usb_cdc.h"
 
-#include "hal_usb.h"
 #include "app_factory_cdc_comm.h"
+#include "hal_usb.h"
 #include "sys_api_cdc_comm.h"
 
 static const struct USB_SERIAL_CFG_T cdc_cfg = {
     .mode = USB_SERIAL_API_NONBLOCKING,
 };
 
-static void usb_serial_recv_timeout(void *param)
+static void usb_serial_recv_timeout(void *param) { usb_serial_cancel_recv(); }
-{
-    usb_serial_cancel_recv();
-}
 
-int app_factorymode_cdc_comm(void)
+int app_factorymode_cdc_comm(void) {
-{
   HWTIMER_ID timer;
   pmu_usb_config(PMU_USB_CONFIG_TYPE_DEVICE);
   usb_serial_open(&cdc_cfg);

apps/factory/app_factory.h

@@ -15,7 +15,8 @@
  ****************************************************************************/
 #ifndef __APP_FACTORY_H__
 #define __APP_FACTORY_H__
-
+#include <stdbool.h>
+#include <stdint.h>
 #define APP_FACTORY_TRACE(s, ...) TRACE(s, ##__VA_ARGS__)
 
 void app_factorymode_result_set(bool result);

apps/factory/app_factory_audio.cpp

@@ -13,30 +13,28 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_bt_stream.h"
+#include "app_factory.h"
+#include "app_media_player.h"
 #include "cmsis_os.h"
 #include "hal_trace.h"
 #include "resources.h"
-#include "app_bt_stream.h"
-#include "app_media_player.h"
-#include "app_factory.h"
 #include "string.h"
 
 // for audio
-#include "audioflinger.h"
 #include "app_audio.h"
 #include "app_utils.h"
+#include "audioflinger.h"
 
 #include "app_factory_audio.h"
 
-
 #ifdef __FACTORY_MODE_SUPPORT__
 
 #define BT_AUDIO_FACTORMODE_BUFF_SIZE (1024 * 2)
 static enum APP_AUDIO_CACHE_T a2dp_cache_status = APP_AUDIO_CACHE_QTY;
 static int16_t *app_audioloop_play_cache = NULL;
 
-static uint32_t app_factorymode_data_come(uint8_t *buf, uint32_t len)
+static uint32_t app_factorymode_data_come(uint8_t *buf, uint32_t len) {
-{
   DUMP16("%d,", (int *)buf, 30);
 
   app_audio_pcmbuff_put(buf, len);
@@ -46,23 +44,23 @@ static uint32_t app_factorymode_data_come(uint8_t *buf, uint32_t len)
   return len;
 }
 
-static uint32_t app_factorymode_more_data(uint8_t *buf, uint32_t len)
+static uint32_t app_factorymode_more_data(uint8_t *buf, uint32_t len) {
-{
   if (a2dp_cache_status != APP_AUDIO_CACHE_QTY) {
     app_audio_pcmbuff_get((uint8_t *)app_audioloop_play_cache, len / 2);
-        app_bt_stream_copy_track_one_to_two_16bits((int16_t *)buf, app_audioloop_play_cache, len/2/2);
+    app_bt_stream_copy_track_one_to_two_16bits(
+        (int16_t *)buf, app_audioloop_play_cache, len / 2 / 2);
   }
   return len;
 }
 
-int app_factorymode_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq)
+int app_factorymode_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq) {
-{
   uint8_t *buff_play = NULL;
   uint8_t *buff_capture = NULL;
   uint8_t *buff_loop = NULL;
   struct AF_STREAM_CONFIG_T stream_cfg;
   static bool isRun = false;
-    APP_FACTORY_TRACE(3,"app_factorymode_audioloop work:%d op:%d freq:%d", isRun, on, freq);
+  APP_FACTORY_TRACE(3, "app_factorymode_audioloop work:%d op:%d freq:%d", isRun,
+                    on, freq);
 
   if (isRun == on)
     return 0;
@@ -77,7 +75,8 @@ int app_factorymode_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq)
     app_audio_mempool_init();
     app_audio_mempool_get_buff(&buff_capture, BT_AUDIO_FACTORMODE_BUFF_SIZE);
     app_audio_mempool_get_buff(&buff_play, BT_AUDIO_FACTORMODE_BUFF_SIZE * 2);
-        app_audio_mempool_get_buff((uint8_t **)&app_audioloop_play_cache, BT_AUDIO_FACTORMODE_BUFF_SIZE*2/2/2);
+    app_audio_mempool_get_buff((uint8_t **)&app_audioloop_play_cache,
+                               BT_AUDIO_FACTORMODE_BUFF_SIZE * 2 / 2 / 2);
     app_audio_mempool_get_buff(&buff_loop, BT_AUDIO_FACTORMODE_BUFF_SIZE << 2);
     app_audio_pcmbuff_init(buff_loop, BT_AUDIO_FACTORMODE_BUFF_SIZE << 2);
     memset(&stream_cfg, 0, sizeof(stream_cfg));
@@ -132,44 +131,33 @@ int app_factorymode_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq)
   return 0;
 }
 
-int app_factorymode_output_pcmpatten(audio_test_pcmpatten_t *pcmpatten, uint8_t *buf, uint32_t len)
+int app_factorymode_output_pcmpatten(audio_test_pcmpatten_t *pcmpatten,
-{
+                                     uint8_t *buf, uint32_t len) {
   uint32_t remain_size = len;
   uint32_t curr_size = 0;
 
-    if (remain_size > pcmpatten->len)
+  if (remain_size > pcmpatten->len) {
-    {
     do {
-            if (pcmpatten->cuur_buf_pos)
+      if (pcmpatten->cuur_buf_pos) {
-            {
         curr_size = pcmpatten->len - pcmpatten->cuur_buf_pos;
         memcpy(buf, &(pcmpatten->buf[pcmpatten->cuur_buf_pos / 2]), curr_size);
         remain_size -= curr_size;
         pcmpatten->cuur_buf_pos = 0;
-            }
+      } else if (remain_size > pcmpatten->len) {
-            else if (remain_size>pcmpatten->len)
-            {
         memcpy(buf + curr_size, pcmpatten->buf, pcmpatten->len);
         curr_size += pcmpatten->len;
         remain_size -= pcmpatten->len;
-            }
+      } else {
-            else
-            {
         memcpy(buf + curr_size, pcmpatten->buf, remain_size);
         pcmpatten->cuur_buf_pos = remain_size;
         remain_size = 0;
       }
     } while (remain_size);
-    }
+  } else {
-    else
+    if ((pcmpatten->len - pcmpatten->cuur_buf_pos) >= len) {
-    {
-        if ((pcmpatten->len - pcmpatten->cuur_buf_pos) >= len)
-        {
       memcpy(buf, &(pcmpatten->buf[pcmpatten->cuur_buf_pos / 2]), len);
       pcmpatten->cuur_buf_pos += len;
-        }
+    } else {
-        else 
-        {
       curr_size = pcmpatten->len - pcmpatten->cuur_buf_pos;
       memcpy(buf, &(pcmpatten->buf[pcmpatten->cuur_buf_pos / 2]), curr_size);
       pcmpatten->cuur_buf_pos = len - curr_size;
@@ -197,12 +185,14 @@ struct mic_st_t{
   signed long out[N];
 };
 
-int app_factorymode_mic_cancellation_run(void * mic_st, signed short *inbuf, int sample)
+int app_factorymode_mic_cancellation_run(void *mic_st, signed short *inbuf,
-{
+                                         int sample) {
   struct mic_st_t *st = (struct mic_st_t *)mic_st;
   int i, k, jj, ii;
-    //int dataWidth = 16;     // input word format is 16 bit twos complement fractional format 1.15
+  // int dataWidth = 16;     // input word format is 16 bit twos complement
-    int twiddleWidth = 16;  // input word format is 16 bit twos complement fractional format 2.14
+  // fractional format 1.15
+  int twiddleWidth =
+      16; // input word format is 16 bit twos complement fractional format 2.14
   FftMode_t ifft = FFT_MODE;
 
   make_symmetric_twiddles(st->w, N, twiddleWidth);
@@ -213,30 +203,33 @@ int app_factorymode_mic_cancellation_run(void * mic_st, signed short *inbuf, int
     st->x[i].im = 0;
   }
 
-    for(ii = 0; ii < 1; ii++)
+  for (ii = 0; ii < 1; ii++) {
-    {
     k = 0;
-        for (jj = 0; jj < N*2; jj+=2)
+    for (jj = 0; jj < N * 2; jj += 2) {
-        {
       FftData_t tmp;
 
       tmp.re = st->x[jj].re;
       tmp.im = st->x[jj].im;
 
-              st->data_even[k].re = tmp.re;//(int) (double(tmp.re)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
+      st->data_even[k].re =
-              st->data_even[k].im = tmp.im;//(int) (double(tmp.im)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
+          tmp.re; //(int) (double(tmp.re)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
+      st->data_even[k].im =
+          tmp.im; //(int) (double(tmp.im)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
       tmp.re = st->x[jj + 1].re;
       tmp.im = st->x[jj + 1].im;
-              st->data_odd[k].re  = tmp.re;//(int) (double(tmp.re)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
+      st->data_odd[k].re =
-              st->data_odd[k].im  = tmp.im;//(int) (double(tmp.im)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
+          tmp.re; //(int) (double(tmp.re)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
+      st->data_odd[k].im =
+          tmp.im; //(int) (double(tmp.im)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
       k++;
     }
 
-        fftr4(NFFT/2, st->data_even, st->w, FFTR4_TWIDDLE_WIDTH, FFTR4_DATA_WIDTH, ifft);
+    fftr4(NFFT / 2, st->data_even, st->w, FFTR4_TWIDDLE_WIDTH, FFTR4_DATA_WIDTH,
-        fftr4(NFFT/2, st->data_odd, st->w, FFTR4_TWIDDLE_WIDTH, FFTR4_DATA_WIDTH, ifft);
+          ifft);
+    fftr4(NFFT / 2, st->data_odd, st->w, FFTR4_TWIDDLE_WIDTH, FFTR4_DATA_WIDTH,
+          ifft);
 
-        for (jj = 0; jj < NFFT/2; jj++)
+    for (jj = 0; jj < NFFT / 2; jj++) {
-        {
 
       int idx = dibit_reverse_int(jj, NFFT / 2);
       st->data_even_d[jj].re = st->data_even[idx].re;
@@ -244,14 +237,15 @@ int app_factorymode_mic_cancellation_run(void * mic_st, signed short *inbuf, int
       st->data_odd_d[jj].re = st->data_odd[idx].re;
       st->data_odd_d[jj].im = st->data_odd[idx].im;
     }
-        for (jj=0;jj<NFFT/2;jj++)
+    for (jj = 0; jj < NFFT / 2; jj++) {
-        {
       long long mbr, mbi;
       FftData_t ta;
       FftData_t tmp;
       double a;
-      mbr = (long long)(st->data_odd_d[jj].re) * st->w128[jj].re - (long long)(st->data_odd_d[jj].im) * st->w128[jj].im;
+      mbr = (long long)(st->data_odd_d[jj].re) * st->w128[jj].re -
-      mbi = (long long)(st->data_odd_d[jj].im) * st->w128[jj].re + (long long)(st->data_odd_d[jj].re) * st->w128[jj].im;
+            (long long)(st->data_odd_d[jj].im) * st->w128[jj].im;
+      mbi = (long long)(st->data_odd_d[jj].im) * st->w128[jj].re +
+            (long long)(st->data_odd_d[jj].re) * st->w128[jj].im;
       ta.re = int(mbr >> (FFTR4_TWIDDLE_WIDTH - 2));
       ta.im = int(mbi >> (FFTR4_TWIDDLE_WIDTH - 2));
       st->data[jj].re = (st->data_even_d[jj].re + ta.re) / 2;
@@ -261,15 +255,19 @@ int app_factorymode_mic_cancellation_run(void * mic_st, signed short *inbuf, int
       st->data[jj + NFFT / 2].im = (st->data_even_d[jj].im - ta.im) / 2;
       // data[jj+NFFT/2] = sat(data[jj+NFFT/2],FFTR4_DATA_WIDTH);
 
-      a = st->data[jj].re;///double(1 << FFTR4_OUTPUT_FORMAT_Y);// * double(1 << FFTR4_SCALE);
+      a = st->data[jj].re; /// double(1 << FFTR4_OUTPUT_FORMAT_Y);// * double(1
+                           /// << FFTR4_SCALE);
       tmp.re = (int)a;
-          a = st->data[jj].im;///double(1 << FFTR4_OUTPUT_FORMAT_Y);// * double(1 << FFTR4_SCALE);
+      a = st->data[jj].im; /// double(1 << FFTR4_OUTPUT_FORMAT_Y);// * double(1
+                           /// << FFTR4_SCALE);
       tmp.im = (int)a;
       st->x[ii * NFFT + jj].re = (int)tmp.re;
       st->x[ii * NFFT + jj].im = (int)tmp.im;
-      a = st->data[jj+NFFT/2].re;///double(1 << FFTR4_OUTPUT_FORMAT_Y);// * double(1 << FFTR4_SCALE);
+      a = st->data[jj + NFFT / 2].re; /// double(1 << FFTR4_OUTPUT_FORMAT_Y);//
+                                      /// * double(1 << FFTR4_SCALE);
       tmp.re = (int)a;
-          a = st->data[jj+NFFT/2].im;///double(1 << FFTR4_OUTPUT_FORMAT_Y);// * double(1 << FFTR4_SCALE);
+      a = st->data[jj + NFFT / 2].im; /// double(1 << FFTR4_OUTPUT_FORMAT_Y);//
+                                      /// * double(1 << FFTR4_SCALE);
       tmp.im = (int)a;
       st->x[ii * NFFT + jj + NFFT / 2].re = (int)tmp.re;
       st->x[ii * NFFT + jj + NFFT / 2].im = (int)tmp.im;
@@ -281,15 +279,12 @@ int app_factorymode_mic_cancellation_run(void * mic_st, signed short *inbuf, int
   }
 
   return 0;
-
 }
 
-void *app_factorymode_mic_cancellation_init(void* (* alloc_ext)(int))
+void *app_factorymode_mic_cancellation_init(void *(*alloc_ext)(int)) {
-{
   struct mic_st_t *mic_st;
   mic_st = (struct mic_st_t *)alloc_ext(sizeof(struct mic_st_t));
   return (void *)mic_st;
 }
 
 #endif
-

apps/factory/app_factory_bt.cpp

@@ -13,78 +13,72 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "cmsis_os.h"
-#include "hal_trace.h"
-#include "hal_sleep.h"
-#include "bt_drv_interface.h"
-#include "intersyshci.h"
-#include "apps.h"
-#include "app_factory.h"
 #include "app_factory_bt.h"
+#include "app_battery.h"
+#include "app_factory.h"
 #include "app_utils.h"
+#include "apps.h"
 #include "bluetooth.h"
+#include "bt_drv_interface.h"
+#include "bt_drv_reg_op.h"
+#include "cmsis_os.h"
+#include "conmgr_api.h"
+#include "hal_bootmode.h"
+#include "hal_chipid.h"
+#include "hal_sleep.h"
+#include "hal_trace.h"
+#include "intersyshci.h"
+#include "me_api.h"
 #include "nvrecord.h"
 #include "nvrecord_dev.h"
 #include "pmu.h"
 #include "tgt_hardware.h"
-#include "app_battery.h"
-#include "bt_drv_reg_op.h"
-#include "conmgr_api.h"
-#include "me_api.h"
-#include "hal_bootmode.h"
-#include "hal_chipid.h"
-
 
 #define APP_FACT_CPU_WAKE_LOCK HAL_CPU_WAKE_LOCK_USER_3
 
 #ifdef __FACTORY_MODE_SUPPORT__
-static uint8_t inquiry_buff[] = {0x01, 0x72, 0x77, 0xb0, 0x18, 0x57, 0x60,\
+static uint8_t inquiry_buff[] = {0x01, 0x72, 0x77, 0xb0, 0x18, 0x57, 0x60, 0x01,
-                        0x01, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00};
+                                 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00};
-
 
 static btif_cmgr_handler_t *app_factorymode_cmgrHandler;
 
-
 static void bt_error_check_timer_handler(void const *param);
 osTimerDef(bt_error_check_timer, bt_error_check_timer_handler);
 static osTimerId bt_error_check_timer_id = NULL;
 uint8_t test_mode_type = 0;
-static void bt_error_check_timer_handler(void const *param)
+static void bt_error_check_timer_handler(void const *param) {
-{
   // dump rssi
   bt_drv_rssi_dump_handler();
   // check BT core status
-    if(bt_drv_error_check_handler())
+  if (bt_drv_error_check_handler()) {
-    {
+    if (test_mode_type == 1) {
-        if(test_mode_type==1)
+      hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE |
-        {
+                          HAL_SW_BOOTMODE_TEST_SIGNALINGMODE);
-            hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE|HAL_SW_BOOTMODE_TEST_SIGNALINGMODE);
+    } else if (test_mode_type == 2) {
-        }
+      hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE |
-        else if(test_mode_type==2)
+                          HAL_SW_BOOTMODE_TEST_NOSIGNALINGMODE);
-        {
-            hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE|HAL_SW_BOOTMODE_TEST_NOSIGNALINGMODE);
     }
     hal_cmu_sys_reboot();
   }
 }
 
-static void app_factorymode_bt_inquiry_buff_update(void)
+static void app_factorymode_bt_inquiry_buff_update(void) {
-{
   bt_bdaddr_t flsh_dongle_addr;
   int ret = -1;
 
   ret = nvrec_dev_get_dongleaddr(&flsh_dongle_addr);
   if (0 == ret) {
-        memcpy((void *)&inquiry_buff[1],(void *)flsh_dongle_addr.address,BTIF_BD_ADDR_SIZE);
+    memcpy((void *)&inquiry_buff[1], (void *)flsh_dongle_addr.address,
+           BTIF_BD_ADDR_SIZE);
     DUMP8("0x%02x ", &inquiry_buff[2], BTIF_BD_ADDR_SIZE);
   }
 }
 
 static void app_factorymode_CmgrCallback(btif_cmgr_handler_t *cHandler,
                                          cmgr_event_t Event,
-                              bt_status_t     Status)
+                                         bt_status_t Status) {
-{
+  APP_FACTORY_TRACE(4, "%s cHandler:%p Event:%d status:%d", __func__, cHandler,
-    APP_FACTORY_TRACE(4,"%s cHandler:%p Event:%d status:%d", __func__, cHandler, Event, Status);
+                    Event, Status);
   if (Event == BTIF_CMEVENT_DATA_LINK_CON_CNF) {
     if (Status == BT_STS_SUCCESS) {
       APP_FACTORY_TRACE(0, "connect ok");
@@ -106,20 +100,19 @@ static void app_factorymode_CmgrCallback(btif_cmgr_handler_t *cHandler,
   }
 }
 
-static void app_factorymode_bt_InquiryResult_add(void)
+static void app_factorymode_bt_InquiryResult_add(void) {
-{
   U8 len = 15;
   bool rssi = false, extended = false;
   U8 *parm = (U8 *)inquiry_buff;
 
   /* Found one or more devices. Report to clients */
-    APP_FACTORY_TRACE(4,"%s len:%d rssi:%d extended:%d", __func__, len, rssi, extended);
+  APP_FACTORY_TRACE(4, "%s len:%d rssi:%d extended:%d", __func__, len, rssi,
+                    extended);
   DUMP8("0x%02x ", parm, len);
   btif_me_inquiry_result_setup(parm, rssi, extended);
 }
 
-void app_factorymode_bt_create_connect(void)
+void app_factorymode_bt_create_connect(void) {
-{
   bt_status_t status;
   bt_bdaddr_t *bdAddr = (bt_bdaddr_t *)(inquiry_buff + 1);
 
@@ -127,8 +120,7 @@ void app_factorymode_bt_create_connect(void)
   APP_FACTORY_TRACE(2, "%s:%d", __func__, status);
 }
 
-void app_factorymode_bt_init_connect(void)
+void app_factorymode_bt_init_connect(void) {
-{
   app_factorymode_cmgrHandler = btif_cmgr_handler_create();
 
   btif_cmgr_register_handler(app_factorymode_cmgrHandler,
@@ -145,8 +137,7 @@ extern osTimerId app_bt_accessmode_timer;
 #define XTAL_FCAP_RANGE (0xFF)
 #endif
 
-void app_factorymode_bt_xtalrangetest(APP_KEY_STATUS *status, void *param)
+void app_factorymode_bt_xtalrangetest(APP_KEY_STATUS *status, void *param) {
-{
   dev_addr_name devinfo;
   uint32_t fcap = 0;
   APP_FACTORY_TRACE(1, "%s", __func__);
@@ -160,7 +151,8 @@ void app_factorymode_bt_xtalrangetest(APP_KEY_STATUS *status, void *param)
     osTimerStop(app_bt_accessmode_timer);
   }
   if (!bt_error_check_timer_id) {
-        bt_error_check_timer_id = osTimerCreate(osTimer(bt_error_check_timer), osTimerPeriodic, NULL);
+    bt_error_check_timer_id =
+        osTimerCreate(osTimer(bt_error_check_timer), osTimerPeriodic, NULL);
   }
   if (bt_error_check_timer_id != NULL) {
     osTimerStart(bt_error_check_timer_id, 1000);
@@ -182,7 +174,8 @@ void app_factorymode_bt_xtalrangetest(APP_KEY_STATUS *status, void *param)
   devinfo.ble_addr = ble_addr;
   devinfo.localname = BT_LOCAL_NAME;
   nvrec_dev_localname_addr_init(&devinfo);
-    btdrv_write_localinfo((char *)devinfo.localname, strlen(devinfo.localname) + 1, devinfo.btd_addr);
+  btdrv_write_localinfo((char *)devinfo.localname,
+                        strlen(devinfo.localname) + 1, devinfo.btd_addr);
 
   btdrv_vco_test_start(78);
   while (1) {
@@ -193,8 +186,7 @@ void app_factorymode_bt_xtalrangetest(APP_KEY_STATUS *status, void *param)
   }
 }
 
-void app_factorymode_bt_signalingtest(APP_KEY_STATUS *status, void *param)
+void app_factorymode_bt_signalingtest(APP_KEY_STATUS *status, void *param) {
-{
   dev_addr_name devinfo;
   APP_FACTORY_TRACE(1, "%s", __func__);
 #ifdef __WATCHER_DOG_RESET__
@@ -207,7 +199,8 @@ void app_factorymode_bt_signalingtest(APP_KEY_STATUS *status, void *param)
     osTimerStop(app_bt_accessmode_timer);
   }
   if (!bt_error_check_timer_id) {
-        bt_error_check_timer_id = osTimerCreate(osTimer(bt_error_check_timer), osTimerPeriodic, NULL);
+    bt_error_check_timer_id =
+        osTimerCreate(osTimer(bt_error_check_timer), osTimerPeriodic, NULL);
   }
   if (bt_error_check_timer_id != NULL) {
     osTimerStart(bt_error_check_timer_id, 1000);
@@ -236,7 +229,8 @@ void app_factorymode_bt_signalingtest(APP_KEY_STATUS *status, void *param)
   memcpy(bt_addr, ibrt_address, 6);
   memcpy(devinfo.btd_addr, ibrt_address, 6);
 #endif
-    btdrv_write_localinfo((char *)devinfo.localname, strlen(devinfo.localname) + 1, devinfo.btd_addr);
+  btdrv_write_localinfo((char *)devinfo.localname,
+                        strlen(devinfo.localname) + 1, devinfo.btd_addr);
   bt_drv_extra_config_after_init();
   btdrv_enable_dut();
 #ifdef __IBRT_IBRT_TESTMODE__
@@ -245,8 +239,7 @@ void app_factorymode_bt_signalingtest(APP_KEY_STATUS *status, void *param)
 }
 
 int app_battery_stop(void);
-void app_factorymode_bt_nosignalingtest(APP_KEY_STATUS *status, void *param)
+void app_factorymode_bt_nosignalingtest(APP_KEY_STATUS *status, void *param) {
-{
   dev_addr_name devinfo;
   APP_FACTORY_TRACE(1, "%s", __func__);
 #ifdef __WATCHER_DOG_RESET__
@@ -258,7 +251,8 @@ void app_factorymode_bt_nosignalingtest(APP_KEY_STATUS *status, void *param)
   app_status_indication_set(APP_STATUS_INDICATION_TESTMODE1);
   osTimerStop(app_bt_accessmode_timer);
   if (!bt_error_check_timer_id) {
-        bt_error_check_timer_id = osTimerCreate(osTimer(bt_error_check_timer), osTimerPeriodic, NULL);
+    bt_error_check_timer_id =
+        osTimerCreate(osTimer(bt_error_check_timer), osTimerPeriodic, NULL);
   }
   if (bt_error_check_timer_id != NULL) {
     osTimerStart(bt_error_check_timer_id, 1000);
@@ -283,7 +277,8 @@ void app_factorymode_bt_nosignalingtest(APP_KEY_STATUS *status, void *param)
   devinfo.localname = BT_LOCAL_NAME;
   devinfo.ble_name = BT_LOCAL_NAME;
   nvrec_dev_localname_addr_init(&devinfo);
-    btdrv_write_localinfo((char *)devinfo.localname, strlen(devinfo.localname) + 1, devinfo.btd_addr);
+  btdrv_write_localinfo((char *)devinfo.localname,
+                        strlen(devinfo.localname) + 1, devinfo.btd_addr);
 #endif
   bt_drv_extra_config_after_init();
   btdrv_hcioff();
@@ -296,8 +291,7 @@ void app_factorymode_bt_nosignalingtest(APP_KEY_STATUS *status, void *param)
 #endif
   btdrv_uart_bridge_loop();
 }
-int app_factorymode_bt_xtalcalib_proc(void)
+int app_factorymode_bt_xtalcalib_proc(void) {
-{
   uint32_t capval = 0x80;
   int nRet;
 
@@ -321,11 +315,9 @@ int app_factorymode_bt_xtalcalib_proc(void)
   return nRet;
 }
 
-void app_factorymode_bt_xtalcalib(APP_KEY_STATUS *status, void *param)
+void app_factorymode_bt_xtalcalib(APP_KEY_STATUS *status, void *param) {
-{
   APP_FACTORY_TRACE(1, "%s", __func__);
   app_factorymode_bt_xtalcalib_proc();
 }
 
 #endif
-

apps/factory/app_factory_cdc_comm.c

@@ -1,19 +1,22 @@
 #ifdef __USB_COMM__
-#include "stdint.h"
-#include "stdbool.h"
-#include "plat_types.h"
-#include "string.h"
-#include "stdio.h"
-#include "tool_msg.h"
-#include "sys_api_cdc_comm.h"
 #include "app_factory_cdc_comm.h"
+#include "plat_types.h"
+#include "stdbool.h"
+#include "stdint.h"
+#include "stdio.h"
+#include "string.h"
+#include "sys_api_cdc_comm.h"
+#include "tool_msg.h"
 
 static enum PARSE_STATE parse_state;
 static struct message_t recv_msg;
-static struct message_t send_msg = { { PREFIX_CHAR, }, };
+static struct message_t send_msg = {
-
-static unsigned char check_sum(unsigned char *buf, unsigned char len)
     {
+        PREFIX_CHAR,
+    },
+};
+
+static unsigned char check_sum(unsigned char *buf, unsigned char len) {
   int i;
   unsigned char sum = 0;
 
@@ -24,8 +27,7 @@ static unsigned char check_sum(unsigned char *buf, unsigned char len)
   return sum;
 }
 
-int send_reply(const unsigned char *payload, unsigned int len)
+int send_reply(const unsigned char *payload, unsigned int len) {
-{
   int ret = 0;
 
   if (len + 1 > sizeof(send_msg.data)) {
@@ -37,15 +39,15 @@ int send_reply(const unsigned char *payload, unsigned int len)
   send_msg.hdr.seq = recv_msg.hdr.seq;
   send_msg.hdr.len = len;
   memcpy(&send_msg.data[0], payload, len);
-    send_msg.data[len] = ~check_sum((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg) - 1);
+  send_msg.data[len] =
+      ~check_sum((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg) - 1);
 
   ret = send_data((unsigned char *)&send_msg, MSG_TOTAL_LEN(&send_msg));
 
   return ret;
 }
 
-static void reset_parse_state(unsigned char **buf, size_t *len)
+static void reset_parse_state(unsigned char **buf, size_t *len) {
-{
   parse_state = PARSE_HEADER;
   memset(&recv_msg.hdr, 0, sizeof(recv_msg.hdr));
 
@@ -53,8 +55,7 @@ static void reset_parse_state(unsigned char **buf, size_t *len)
   *len = sizeof(recv_msg.hdr);
 }
 
-static enum ERR_CODE check_msg_hdr(void)
+static enum ERR_CODE check_msg_hdr(void) {
-{
   enum ERR_CODE errcode = ERR_NONE;
 
   switch (recv_msg.hdr.type) {
@@ -87,8 +88,8 @@ static enum ERR_CODE check_msg_hdr(void)
   return errcode;
 }
 
-static enum ERR_CODE handle_sys_cmd(enum SYS_CMD_TYPE cmd, unsigned char *param, unsigned int len)
+static enum ERR_CODE handle_sys_cmd(enum SYS_CMD_TYPE cmd, unsigned char *param,
-{
+                                    unsigned int len) {
   unsigned char cret[5];
   unsigned int bootmode;
 
@@ -149,8 +150,7 @@ static enum ERR_CODE handle_sys_cmd(enum SYS_CMD_TYPE cmd, unsigned char *param,
   return ERR_NONE;
 }
 
-static enum ERR_CODE handle_data(unsigned char **buf, size_t *len, int *extra)
+static enum ERR_CODE handle_data(unsigned char **buf, size_t *len, int *extra) {
-{
   enum ERR_CODE errcode = ERR_NONE;
 #if 0
 	uint32_t rlen = 0;
@@ -166,7 +166,8 @@ static enum ERR_CODE handle_data(unsigned char **buf, size_t *len, int *extra)
   switch (recv_msg.hdr.type) {
   case TYPE_SYS: {
     TRACE_TIME(0, "------ SYS CMD ------");
-            errcode = handle_sys_cmd((enum SYS_CMD_TYPE)recv_msg.data[0], &recv_msg.data[1], recv_msg.hdr.len - 1);
+    errcode = handle_sys_cmd((enum SYS_CMD_TYPE)recv_msg.data[0],
+                             &recv_msg.data[1], recv_msg.hdr.len - 1);
     if (errcode != ERR_NONE) {
       return errcode;
     }
@@ -208,8 +209,7 @@ static enum ERR_CODE handle_data(unsigned char **buf, size_t *len, int *extra)
   return ERR_NONE;
 }
 
-static int parse_packet(unsigned char **buf, size_t *len)
+static int parse_packet(unsigned char **buf, size_t *len) {
-{
   enum ERR_CODE errcode;
   int rlen = *len;
   unsigned char *data;
@@ -264,8 +264,7 @@ _err:
   return 1;
 }
 
-void comm_loop(void)
+void comm_loop(void) {
-{
   int ret;
   unsigned char *buf = NULL;
   size_t len = 0;

apps/factory/sys_api_cdc_comm.c

@@ -11,7 +11,8 @@
 #define TIMEOUT_INFINITE ((uint32_t)-1)
 
 const unsigned int default_recv_timeout_short = MS_TO_TICKS(500);
-const unsigned int default_recv_timeout_idle = TIMEOUT_INFINITE; //MS_TO_TICKS(10 * 60 * 1000);
+const unsigned int default_recv_timeout_idle =
+    TIMEOUT_INFINITE; // MS_TO_TICKS(10 * 60 * 1000);
 const unsigned int default_recv_timeout_4k_data = MS_TO_TICKS(500);
 const unsigned int default_send_timeout = MS_TO_TICKS(500);
 
@@ -29,8 +30,7 @@ static const struct USB_SERIAL_CFG_T cdc_cfg = {
     .mode = USB_SERIAL_API_NONBLOCKING,
 };
 
-void reset_transport(void)
+void reset_transport(void) {
-{
   cancel_xfer = false;
 
   if (xfer_timer) {
@@ -45,23 +45,13 @@ void reset_transport(void)
   set_send_timeout(default_send_timeout);
 }
 
-void set_recv_timeout(unsigned int timeout)
+void set_recv_timeout(unsigned int timeout) { recv_timeout = timeout; }
-{
-    recv_timeout = timeout;
-}
 
-void set_send_timeout(unsigned int timeout)
+void set_send_timeout(unsigned int timeout) { send_timeout = timeout; }
-{
-    send_timeout = timeout;
-}
 
-static void usb_send_timeout(void *param)
+static void usb_send_timeout(void *param) { usb_serial_cancel_send(); }
-{
-    usb_serial_cancel_send();
-}
 
-static void usb_send_timer_start(void)
+static void usb_send_timer_start(void) {
-{
   if (send_timeout == TIMEOUT_INFINITE) {
     return;
   }
@@ -71,15 +61,13 @@ static void usb_send_timer_start(void)
   }
 }
 
-static void usb_send_timer_stop(void)
+static void usb_send_timer_stop(void) {
-{
   if (xfer_timer) {
     hwtimer_stop(xfer_timer);
   }
 }
 
-static int usb_send_data(const unsigned char *buf, size_t len)
+static int usb_send_data(const unsigned char *buf, size_t len) {
-{
   int ret;
 
   usb_send_timer_start();
@@ -88,21 +76,16 @@ static int usb_send_data(const unsigned char *buf, size_t len)
   return ret;
 }
 
-int send_data(const unsigned char *buf, size_t len)
+int send_data(const unsigned char *buf, size_t len) {
-{
   if (cancel_xfer) {
     return -1;
   }
   return usb_send_data(buf, len);
 }
 
-static void usb_recv_timeout(void *param)
+static void usb_recv_timeout(void *param) { usb_serial_cancel_recv(); }
-{
-    usb_serial_cancel_recv();
-}
 
-static void usb_recv_timer_start(void)
+static void usb_recv_timer_start(void) {
-{
   if (recv_timeout == TIMEOUT_INFINITE) {
     return;
   }
@@ -112,15 +95,13 @@ static void usb_recv_timer_start(void)
   }
 }
 
-static void usb_recv_timer_stop(void)
+static void usb_recv_timer_stop(void) {
-{
   if (xfer_timer) {
     hwtimer_stop(xfer_timer);
   }
 }
 
-static int usb_recv_data(unsigned char *buf, size_t len, size_t *rlen)
+static int usb_recv_data(unsigned char *buf, size_t len, size_t *rlen) {
-{
   int ret;
 
   usb_recv_timer_start();
@@ -132,16 +113,14 @@ static int usb_recv_data(unsigned char *buf, size_t len, size_t *rlen)
   return ret;
 }
 
-int recv_data_ex(unsigned char *buf, size_t len, size_t expect, size_t *rlen)
+int recv_data_ex(unsigned char *buf, size_t len, size_t expect, size_t *rlen) {
-{
   if (cancel_xfer) {
     return -1;
   }
   return usb_recv_data(buf, expect, rlen);
 }
 
-static int usb_handle_error(void)
+static int usb_handle_error(void) {
-{
   int ret;
 
   TRACE(0, "****** Send break ******");
@@ -154,8 +133,7 @@ static int usb_handle_error(void)
   return ret;
 }
 
-int handle_error(void)
+int handle_error(void) {
-{
   int ret = 0;
   uint32_t err_time;
 
@@ -182,24 +160,16 @@ int handle_error(void)
   return ret;
 }
 
-static int usb_cancel_input(void)
+static int usb_cancel_input(void) { return usb_serial_flush_recv_buffer(); }
-{
-    return usb_serial_flush_recv_buffer();
-}
 
-int cancel_input(void)
+int cancel_input(void) { return usb_cancel_input(); }
-{
-    return usb_cancel_input();
-}
 
-void system_reboot(void)
+void system_reboot(void) {
-{
   hal_sys_timer_delay(MS_TO_TICKS(10));
   hal_cmu_sys_reboot();
 }
 
-void system_shutdown(void)
+void system_shutdown(void) {
-{
 #if 0
     if (dld_transport == TRANSPORT_USB) {
         // Avoid PC usb serial driver hanging
@@ -210,20 +180,15 @@ void system_shutdown(void)
   pmu_shutdown();
 }
 
-void system_set_bootmode(unsigned int bootmode)
+void system_set_bootmode(unsigned int bootmode) {
-{
   bootmode &= ~(HAL_SW_BOOTMODE_READ_ENABLED | HAL_SW_BOOTMODE_WRITE_ENABLED);
   hal_sw_bootmode_set(bootmode);
 }
 
-void system_clear_bootmode(unsigned int bootmode)
+void system_clear_bootmode(unsigned int bootmode) {
-{
   bootmode &= ~(HAL_SW_BOOTMODE_READ_ENABLED | HAL_SW_BOOTMODE_WRITE_ENABLED);
   hal_sw_bootmode_clear(bootmode);
 }
 
-unsigned int system_get_bootmode(void)
+unsigned int system_get_bootmode(void) { return hal_sw_bootmode_get(); }
-{
-    return hal_sw_bootmode_get();
-}
 #endif

apps/key/app_key.cpp

@@ -13,12 +13,12 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_key.h"
+#include "app_thread.h"
 #include "cmsis_os.h"
+#include "hal_trace.h"
 #include "list.h"
 #include "string.h"
-#include "app_thread.h"
-#include "app_key.h"
-#include "hal_trace.h"
 
 #define APP_KEY_TRACE(s, ...) // TRACE(s, ##__VA_ARGS__)
 
@@ -28,16 +28,13 @@ typedef struct {
   list_t *key_list;
 } APP_KEY_CONFIG;
 
-APP_KEY_CONFIG app_key_conifg = {
+APP_KEY_CONFIG app_key_conifg = {.key_list = NULL};
-    .key_list = NULL
-};
 
 osPoolDef(app_key_handle_mempool, 20, APP_KEY_HANDLE);
 osPoolId app_key_handle_mempool = NULL;
 static uint8_t key_event_cnt = 0;
 
-static int key_event_process(uint32_t key_code, uint8_t key_event)
+static int key_event_process(uint32_t key_code, uint8_t key_event) {
-{
   uint32_t app_keyevt;
   APP_MESSAGE_BLOCK msg;
 
@@ -56,39 +53,38 @@ static int key_event_process(uint32_t key_code, uint8_t key_event)
   return 0;
 }
 
-void app_key_simulate_key_event(uint32_t key_code, uint8_t key_event)
+void app_key_simulate_key_event(uint32_t key_code, uint8_t key_event) {
-{
   key_event_process(key_code, key_event);
 }
 
-static void app_key_handle_free(void *key_handle)
+static void app_key_handle_free(void *key_handle) {
-{
   osPoolFree(app_key_handle_mempool, key_handle);
 }
 
-static APP_KEY_HANDLE *app_key_handle_find(const APP_KEY_STATUS *key_status)
+static APP_KEY_HANDLE *app_key_handle_find(const APP_KEY_STATUS *key_status) {
-{
   APP_KEY_HANDLE *key_handle = NULL;
   list_node_t *node = NULL;
 
-    for (node = list_begin(app_key_conifg.key_list); node != list_end(app_key_conifg.key_list); node = list_next(node)) {
+  for (node = list_begin(app_key_conifg.key_list);
+       node != list_end(app_key_conifg.key_list); node = list_next(node)) {
     key_handle = (APP_KEY_HANDLE *)list_node(node);
-        if ((key_handle->key_status.code == key_status->code)&&(key_handle->key_status.event == key_status->event))
+    if ((key_handle->key_status.code == key_status->code) &&
+        (key_handle->key_status.event == key_status->event))
       return key_handle;
   }
 
   return NULL;
 }
 
-static int app_key_handle_process(APP_MESSAGE_BODY *msg_body)
+static int app_key_handle_process(APP_MESSAGE_BODY *msg_body) {
-{
   APP_KEY_STATUS key_status;
   APP_KEY_HANDLE *key_handle = NULL;
 
   APP_KEY_GET_CODE(msg_body->message_id, key_status.code);
   APP_KEY_GET_EVENT(msg_body->message_id, key_status.event);
 
-    APP_KEY_TRACE(3,"%s code:%d event:%d",__func__,key_status.code, key_status.event);
+  APP_KEY_TRACE(3, "%s code:%d event:%d", __func__, key_status.code,
+                key_status.event);
 
   key_event_cnt--;
 
@@ -100,8 +96,7 @@ static int app_key_handle_process(APP_MESSAGE_BODY *msg_body)
   return 0;
 }
 
-int app_key_handle_registration(const APP_KEY_HANDLE *key_handle)
+int app_key_handle_registration(const APP_KEY_HANDLE *key_handle) {
-{
   APP_KEY_HANDLE *dest_key_handle = NULL;
   APP_KEY_TRACE(1, "%s", __func__);
   dest_key_handle = app_key_handle_find(&(key_handle->key_status));
@@ -114,23 +109,22 @@ int app_key_handle_registration(const APP_KEY_HANDLE *key_handle)
   }
   if (dest_key_handle == NULL)
     return -1;
-    APP_KEY_TRACE(5,"%s set handle:0x%x code:%d event:%d function:%x",__func__,dest_key_handle, key_handle->key_status.code, key_handle->key_status.event, key_handle->function);
+  APP_KEY_TRACE(5, "%s set handle:0x%x code:%d event:%d function:%x", __func__,
+                dest_key_handle, key_handle->key_status.code,
+                key_handle->key_status.event, key_handle->function);
   dest_key_handle->key_status.code = key_handle->key_status.code;
   dest_key_handle->key_status.event = key_handle->key_status.event;
   dest_key_handle->string = key_handle->string;
   dest_key_handle->function = key_handle->function;
-    dest_key_handle->param = key_handle->param;;
+  dest_key_handle->param = key_handle->param;
+  ;
 
   return 0;
 }
 
-void app_key_handle_clear(void)
+void app_key_handle_clear(void) { list_clear(app_key_conifg.key_list); }
-{
-    list_clear(app_key_conifg.key_list);
-}
 
-int app_key_open(int checkPwrKey)
+int app_key_open(int checkPwrKey) {
-{
   APP_KEY_TRACE(2, "%s %x", __func__, app_key_conifg.key_list);
 
   if (app_key_conifg.key_list == NULL)
@@ -144,8 +138,7 @@ int app_key_open(int checkPwrKey)
   return hal_key_open(checkPwrKey, key_event_process);
 }
 
-int app_key_close(void)
+int app_key_close(void) {
-{
   hal_key_close();
   if (app_key_conifg.key_list != NULL)
     list_free(app_key_conifg.key_list);
@@ -153,15 +146,12 @@ int app_key_close(void)
   return 0;
 }
 
-uint32_t app_key_read_status(uint32_t code)
+uint32_t app_key_read_status(uint32_t code) {
-{
   return (uint32_t)hal_key_read_status((enum HAL_KEY_CODE_T)code);
 }
 
 #if defined(_AUTO_TEST_)
-int simul_key_event_process(uint32_t key_code, uint8_t key_event)
+int simul_key_event_process(uint32_t key_code, uint8_t key_event) {
-{
   return key_event_process(key_code, key_event);
 }
 #endif
-

apps/key/app_key.h

@@ -13,12 +13,17 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "hal_key.h"
+
 #ifndef __APP_KEY_H__
 #define __APP_KEY_H__
 
-#include "hal_key.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-#define APP_KEY_SET_MESSAGE(appevt, code, evt) (appevt = (((uint32_t)code&0xffffff)<<8)|(evt&0xff))
+#define APP_KEY_SET_MESSAGE(appevt, code, evt)                                 \
+  (appevt = (((uint32_t)code & 0xffffff) << 8) | (evt & 0xff))
 #define APP_KEY_GET_CODE(appevt, code) (code = (appevt >> 8) & 0xffffff)
 #define APP_KEY_GET_EVENT(appevt, evt) (evt = appevt & 0xff)
 
@@ -106,4 +111,8 @@ void app_key_simulate_key_event(uint32_t key_code, uint8_t key_event);
 #if defined(_AUTO_TEST_)
 int simul_key_event_process(uint32_t key_code, uint8_t key_event);
 #endif
+
+#ifdef __cplusplus
+};
+#endif
 #endif //__FMDEC_H__

apps/main/apps_tester.cpp

@@ -13,21 +13,21 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "stdio.h"
 #include "cmsis_os.h"
+#include "stdio.h"
 #include "string.h"
 
-#include "hal_iomux.h"
 #include "app_key.h"
-#include "hal_trace.h"
+#include "hal_iomux.h"
 #include "hal_sleep.h"
+#include "hal_trace.h"
 
-#include "audioflinger.h"
-#include "audiobuffer.h"
 #include "app_thread.h"
 #include "app_utils.h"
-#include "bt_drv_interface.h"
+#include "audiobuffer.h"
+#include "audioflinger.h"
 #include "besbt.h"
+#include "bt_drv_interface.h"
 
 #if defined(APP_TEST_AUDIO) && defined(ANC_APP)
 #include "anc_usb_app.h"
@@ -43,8 +43,7 @@ extern void app_anc_usb_init(void);
 
 #define REG(a) *(volatile uint32_t *)(a)
 
-void bt_signaling_test(APP_KEY_STATUS *status, void *param)
+void bt_signaling_test(APP_KEY_STATUS *status, void *param) {
-{
   TRACE(3, "%s %d,%d", __func__, status->code, status->event);
 
   hal_cpu_wake_lock(APP_TESTER_CPU_WAKE_LOCK);
@@ -52,16 +51,14 @@ void bt_signaling_test(APP_KEY_STATUS *status, void *param)
   btdrv_enable_dut();
 }
 
-void bt_stack_test(APP_KEY_STATUS *status, void *param)
+void bt_stack_test(APP_KEY_STATUS *status, void *param) {
-{
   TRACE(3, "%s %d,%d", __func__, status->code, status->event);
 
   btdrv_start_bt();
   BesbtInit();
 }
 
-void bt_ble_test(APP_KEY_STATUS *status, void *param)
+void bt_ble_test(APP_KEY_STATUS *status, void *param) {
-{
   TRACE(3, "%s %d,%d", __func__, status->code, status->event);
 
   hal_cpu_wake_lock(APP_TESTER_CPU_WAKE_LOCK);
@@ -72,8 +69,7 @@ void bt_ble_test(APP_KEY_STATUS *status, void *param)
   btdrv_uart_bridge_loop();
 }
 
-void bt_test_104m(APP_KEY_STATUS *status, void *param)
+void bt_test_104m(APP_KEY_STATUS *status, void *param) {
-{
   TRACE(3, "%s %d,%d", __func__, status->code, status->event);
 
   hal_analogif_reg_write(0x35, 0x0);
@@ -84,48 +80,39 @@ void bt_test_104m(APP_KEY_STATUS *status, void *param)
   hal_analogif_reg_write(0xC, 0x3790);
 }
 
-void bt_change_to_iic(APP_KEY_STATUS *status, void *param)
+void bt_change_to_iic(APP_KEY_STATUS *status, void *param) {
-{
   TRACE(3, "%s %d,%d", __func__, status->code, status->event);
 
   hal_iomux_set_analog_i2c();
 }
 
-void bt_change_to_uart0(APP_KEY_STATUS *status, void *param)
+void bt_change_to_uart0(APP_KEY_STATUS *status, void *param) {
-{
   TRACE(3, "%s %d,%d", __func__, status->code, status->event);
 
   hal_iomux_set_uart0();
 }
 
-void app_switch_i2c_uart(APP_KEY_STATUS *status, void *param)
+void app_switch_i2c_uart(APP_KEY_STATUS *status, void *param) {
-{
   static uint32_t flag = 1;
 
   TRACE(2, "[%s] flag = %d", __func__, flag);
-    if(flag)
+  if (flag) {
-    {
     bt_change_to_iic(NULL, NULL);
-    }
+  } else {
-    else
-    {
     bt_change_to_uart0(NULL, NULL);
   }
   flag = !flag;
 }
 
-void test_power_off(APP_KEY_STATUS *status, void *param)
+void test_power_off(APP_KEY_STATUS *status, void *param) {
-{
   TRACE(0, "app_power_off\n");
 }
 
 extern APP_KEY_STATUS bt_key;
 
-void test_bt_key(APP_KEY_STATUS *status, void *param)
+void test_bt_key(APP_KEY_STATUS *status, void *param) {
-{
   TRACE(3, "%s %d,%d", __func__, status->code, status->event);
-        if(bt_key.code == 0xff)
+  if (bt_key.code == 0xff) {
-        {
     bt_key.code = status->code;
     bt_key.event = status->event;
     OS_NotifyEvm();
@@ -138,8 +125,7 @@ void test_bt_key(APP_KEY_STATUS *status, void *param)
 #define SD_BUF_SIZE (10)
 uint8_t sd_buf[SD_BUF_SIZE] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
-void test_sd_card()
+void test_sd_card() {
-{
   sd_open();
 
   dump_data2sd(APP_SDMMC_DUMP_OPEN, NULL, 0);
@@ -149,84 +135,118 @@ void test_sd_card()
 #endif
 
 #ifdef APP_TEST_AUDIO
-extern void adc_looptester(bool on, enum AUD_IO_PATH_T input_path, enum AUD_SAMPRATE_T sample_rate);
+extern void adc_looptester(bool on, enum AUD_IO_PATH_T input_path,
-void test_codec_loop(APP_KEY_STATUS *status, void *param)
+                           enum AUD_SAMPRATE_T sample_rate);
-{
+void test_codec_loop(APP_KEY_STATUS *status, void *param) {
   audio_buffer_init();
   adc_looptester(true, AUD_INPUT_PATH_MAINMIC, AUD_SAMPRATE_8000);
 }
 
 #ifdef ANC_APP
-void test_anc(APP_KEY_STATUS *status, void *param)
+void test_anc(APP_KEY_STATUS *status, void *param) { anc_usb_app((bool)param); }
-{
-    anc_usb_app((bool)param);
-}
 
-void test_usb_audio(APP_KEY_STATUS *status, void *param)
+void test_usb_audio(APP_KEY_STATUS *status, void *param) {
-{
   usb_audio_app((bool)param);
   // dualadc_audio_app((bool)param);
 }
 #endif
 #endif
 
-void bt_change_to_jlink(APP_KEY_STATUS *status, void *param)
+void bt_change_to_jlink(APP_KEY_STATUS *status, void *param) {
-{
   hal_iomux_set_jtag();
 
   hal_cmu_jtag_clock_enable();
-
 }
 
-void bt_enable_tports(void)
+void bt_enable_tports(void) {
-{
   hal_iomux_set_bt_tport();
   bt_drv_bt_tport_type_config();
 }
 
 #ifdef APP_TEST_AUDIO
 extern void da_tester(uint8_t on);
-void bt_test_dsp_process(APP_KEY_STATUS *status, void *param)
+void bt_test_dsp_process(APP_KEY_STATUS *status, void *param) { da_tester(1); }
-{
-    da_tester(1);
-}
 #endif
 #define MENU_TITLE_MAX_SIZE (50)
 APP_KEY_HANDLE app_testcase[] = {
 #if defined(APP_TEST_AUDIO) && defined(ANC_APP)
-    {{APP_KEY_CODE_FN2,APP_KEY_EVENT_UP},"USB AUDIO TEST OFF",test_usb_audio, (void *)0},
+    {{APP_KEY_CODE_FN2, APP_KEY_EVENT_UP},
-    {{APP_KEY_CODE_FN5,APP_KEY_EVENT_UP},"USB AUDIO TEST ON",test_usb_audio, (void *)1},
+     "USB AUDIO TEST OFF",
+     test_usb_audio,
+     (void *)0},
+    {{APP_KEY_CODE_FN5, APP_KEY_EVENT_UP},
+     "USB AUDIO TEST ON",
+     test_usb_audio,
+     (void *)1},
     {{APP_KEY_CODE_FN3, APP_KEY_EVENT_UP}, "ANC TEST OFF", test_anc, (void *)0},
     {{APP_KEY_CODE_FN6, APP_KEY_EVENT_UP}, "ANC TEST ON", test_anc, (void *)1},
 #else
 #ifdef APP_TEST_AUDIO
-    {{APP_KEY_CODE_FN1,APP_KEY_EVENT_LONGPRESS},"LONGPRESS: test_codec_loop",test_codec_loop, NULL},
+    {{APP_KEY_CODE_FN1, APP_KEY_EVENT_LONGPRESS},
+     "LONGPRESS: test_codec_loop",
+     test_codec_loop,
+     NULL},
 #endif
-    {{APP_KEY_CODE_FN1,APP_KEY_EVENT_UP},"bt_signaling_test",bt_signaling_test, NULL},
+    {{APP_KEY_CODE_FN1, APP_KEY_EVENT_UP},
+     "bt_signaling_test",
+     bt_signaling_test,
+     NULL},
     {{APP_KEY_CODE_FN2, APP_KEY_EVENT_UP}, "bt gogogogo", bt_stack_test, NULL},
-    {{APP_KEY_CODE_FN3,APP_KEY_EVENT_UP},"bt change to 104m",bt_test_104m, NULL},
+    {{APP_KEY_CODE_FN3, APP_KEY_EVENT_UP},
+     "bt change to 104m",
+     bt_test_104m,
+     NULL},
     {{APP_KEY_CODE_FN4, APP_KEY_EVENT_UP}, "ble test mode", bt_ble_test, NULL},
 #ifdef APP_TEST_AUDIO
-    {{APP_KEY_CODE_FN5,APP_KEY_EVENT_UP},"dsp eq test"          ,bt_test_dsp_process, NULL},
+    {{APP_KEY_CODE_FN5, APP_KEY_EVENT_UP},
+     "dsp eq test",
+     bt_test_dsp_process,
+     NULL},
 #endif
-    {{APP_KEY_CODE_FN5,APP_KEY_EVENT_LONGPRESS},"LONGPRESS: bt volume up key"          ,test_bt_key, NULL},
+    {{APP_KEY_CODE_FN5, APP_KEY_EVENT_LONGPRESS},
+     "LONGPRESS: bt volume up key",
+     test_bt_key,
+     NULL},
 
-    {{APP_KEY_CODE_FN6,APP_KEY_EVENT_UP},"bt volume down key"           ,test_bt_key, NULL},
+    {{APP_KEY_CODE_FN6, APP_KEY_EVENT_UP},
-    {{APP_KEY_CODE_FN6,APP_KEY_EVENT_LONGPRESS},"LONGPRESS: bt volume down key"            ,test_bt_key, NULL},
+     "bt volume down key",
+     test_bt_key,
+     NULL},
+    {{APP_KEY_CODE_FN6, APP_KEY_EVENT_LONGPRESS},
+     "LONGPRESS: bt volume down key",
+     test_bt_key,
+     NULL},
 
-    {{APP_KEY_CODE_FN7,APP_KEY_EVENT_CLICK},"bt function key"           ,test_bt_key, NULL},
+    {{APP_KEY_CODE_FN7, APP_KEY_EVENT_CLICK},
-    {{APP_KEY_CODE_FN7,APP_KEY_EVENT_DOUBLECLICK},"DOUBLECLICK: bt function key"         ,test_bt_key, NULL},
+     "bt function key",
-    {{APP_KEY_CODE_FN7,APP_KEY_EVENT_LONGPRESS},"LONGPRESS: bt function key"           ,test_bt_key, NULL},
+     test_bt_key,
+     NULL},
+    {{APP_KEY_CODE_FN7, APP_KEY_EVENT_DOUBLECLICK},
+     "DOUBLECLICK: bt function key",
+     test_bt_key,
+     NULL},
+    {{APP_KEY_CODE_FN7, APP_KEY_EVENT_LONGPRESS},
+     "LONGPRESS: bt function key",
+     test_bt_key,
+     NULL},
 
-    {{APP_KEY_CODE_FN8,APP_KEY_EVENT_UP},"open jlink"   ,bt_change_to_jlink, NULL},
+    {{APP_KEY_CODE_FN8, APP_KEY_EVENT_UP},
-    {{APP_KEY_CODE_FN9,APP_KEY_EVENT_UP},"iic_map2_P3_0"    ,bt_change_to_iic, NULL},
+     "open jlink",
-    {{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGPRESS},"LONGPRESS: power off" ,test_power_off, NULL},
+     bt_change_to_jlink,
+     NULL},
+    {{APP_KEY_CODE_FN9, APP_KEY_EVENT_UP},
+     "iic_map2_P3_0",
+     bt_change_to_iic,
+     NULL},
+    {{APP_KEY_CODE_PWR, APP_KEY_EVENT_LONGPRESS},
+     "LONGPRESS: power off",
+     test_power_off,
+     NULL},
 #endif // !(APP_TEST_AUDIO && ANC_APP)
     {{0xff, APP_KEY_EVENT_NONE}, NULL, (uint32_t)NULL, 0},
 };
 
-int app_testcase_disp_menu(APP_KEY_HANDLE* testcase, bool printall)
+int app_testcase_disp_menu(APP_KEY_HANDLE *testcase, bool printall) {
-{
   char buf[MENU_TITLE_MAX_SIZE + 1];
   if (strlen(testcase->string) > (MENU_TITLE_MAX_SIZE - 15)) {
     TRACE(0, "string too long, please check again\n");
@@ -245,7 +265,8 @@ int app_testcase_disp_menu(APP_KEY_HANDLE* testcase, bool printall)
   }
 
   do {
-        snprintf(buf, sizeof(buf), "|      (0x%X)%s", testcase->key_status.code, testcase->string);
+    snprintf(buf, sizeof(buf), "|      (0x%X)%s", testcase->key_status.code,
+             testcase->string);
     memset(buf + strlen(buf), ' ', sizeof(buf) - strlen(buf) - 3);
     buf[MENU_TITLE_MAX_SIZE - 3] = '|';
     buf[MENU_TITLE_MAX_SIZE - 2] = '\r';
@@ -269,8 +290,7 @@ int app_testcase_disp_menu(APP_KEY_HANDLE* testcase, bool printall)
   return 0;
 }
 
-int app_testcase_key_response(APP_MESSAGE_BODY *msg_body)
+int app_testcase_key_response(APP_MESSAGE_BODY *msg_body) {
-{
   uint8_t i = 0;
   APP_KEY_STATUS key_status;
 
@@ -281,7 +301,8 @@ int app_testcase_key_response(APP_MESSAGE_BODY *msg_body)
     return -1;
 
   for (i = 0; i < (sizeof(app_testcase) / sizeof(APP_KEY_HANDLE)); i++) {
-        if (app_testcase[i].key_status.code == key_status.code && (app_testcase[i].key_status.event == key_status.event))
+    if (app_testcase[i].key_status.code == key_status.code &&
+        (app_testcase[i].key_status.event == key_status.event))
       break;
   }
 
@@ -291,14 +312,14 @@ int app_testcase_key_response(APP_MESSAGE_BODY *msg_body)
   if (app_testcase[i].function != (uint32_t)NULL) {
     if (app_testcase[i].string != (uint32_t)NULL)
       app_testcase_disp_menu(&app_testcase[i], 0);
-        ((APP_KEY_HANDLE_CB_T)app_testcase[i].function)(&key_status,app_testcase[i].param);
+    ((APP_KEY_HANDLE_CB_T)app_testcase[i].function)(&key_status,
+                                                    app_testcase[i].param);
   }
 
   return 0;
 }
 
-void app_test_init(void)
+void app_test_init(void) {
-{
   uint8_t i = 0;
   TRACE(1, "%s", __func__);
   for (i = 0; i < (sizeof(app_testcase) / sizeof(APP_KEY_HANDLE)); i++) {

apps/mic/app_mic.cpp

@@ -14,46 +14,45 @@
  *
  ****************************************************************************/
 //#include "mbed.h"
-#include <stdio.h>
 #include <assert.h>
+#include <stdio.h>
 
-#include "cmsis_os.h"
-#include "tgt_hardware.h"
-#include "hal_uart.h"
-#include "hal_timer.h"
-#include "audioflinger.h"
-#include "lockcqueue.h"
-#include "hal_trace.h"
-#include "hal_cmu.h"
-#include "hal_chipid.h"
 #include "analog.h"
+#include "app_audio.h"
 #include "app_bt_stream.h"
 #include "app_overlay.h"
-#include "app_audio.h"
 #include "app_utils.h"
+#include "apps.h"
+#include "audioflinger.h"
+#include "cmsis_os.h"
+#include "hal_chipid.h"
+#include "hal_cmu.h"
+#include "hal_codec.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
+#include "hal_uart.h"
+#include "lockcqueue.h"
 #include "nvrecord.h"
 #include "nvrecord_env.h"
-#include "hal_codec.h"
+#include "tgt_hardware.h"
-#include "apps.h"
 
 #include "app_ring_merge.h"
 
-#include "bt_drv.h"
-#include "bt_xtal_sync.h"
-#include "besbt.h"
 #include "app_bt_func.h"
 #include "app_mic.h"
+#include "besbt.h"
+#include "bt_drv.h"
+#include "bt_xtal_sync.h"
 
-
-#include "app_thread.h"
-#include "cqueue.h"
-#include "btapp.h"
 #include "app_bt_media_manager.h"
-#include "string.h"
-#include "hal_location.h"
-#include "hal_codec.h"
-#include "hal_sleep.h"
 #include "app_hfp.h"
+#include "app_thread.h"
+#include "btapp.h"
+#include "cqueue.h"
+#include "hal_codec.h"
+#include "hal_location.h"
+#include "hal_sleep.h"
+#include "string.h"
 
 extern bool app_hfp_siri_is_active(void);
 extern int a2dp_volume_2_level_convert(uint8_t vol);
@@ -70,47 +69,33 @@ static struct AF_STREAM_CONFIG_T mic_config[MIC_APP_MAX];
 osMutexId app_mic_mutex_id = NULL;
 osMutexDef(app_mic_mutex);
 
-
 // flag of is first mic date, if true ,will delete to avoid POP voice
 bool first_mic_in = false;
 
-static int internal_mic_start(MIC_APP_TYPE new_mictype)
+static int internal_mic_start(MIC_APP_TYPE new_mictype) {
-{
   TRACE(1, "MIC_EVENT_START,current_mictype=%d", current_mictype);
   assert(new_mictype != MIC_APP_NONE);
   if (current_mictype != MIC_APP_NONE) {
     TRACE(0, "MIC START ERROR################");
     return false;
   }
-    if (new_mictype == MIC_APP_SOC_CALL)
+  if (new_mictype == MIC_APP_SOC_CALL) {
-    {
+    if (btapp_hfp_get_call_state() || app_hfp_siri_is_active()) {
-        if (btapp_hfp_get_call_state() || app_hfp_siri_is_active())
+      TRACE(2, "[%s] tws_mic_start_telephone_call: %d", __func__,
-        {
+            mic_config[new_mictype].sample_rate);
-            TRACE(2,"[%s] tws_mic_start_telephone_call: %d", __func__, mic_config[new_mictype].sample_rate);
+      if (mic_config[new_mictype].data_ptr != NULL) {
-        	if (mic_config[new_mictype].data_ptr != NULL)
+      } else {
-            {
-            }
-            else
-        	{
         TRACE(1, "[%s] Warning sco play not started", __func__);
       }
       current_mictype = MIC_APP_SOC_CALL;
     }
-    }
+  } else if (new_mictype == MIC_APP_SPEECH_RECO) {
-    else if (new_mictype == MIC_APP_SPEECH_RECO)
+  } else if (new_mictype == MIC_APP_CSPOTTER) {
-    {
-    }
-    else if (new_mictype == MIC_APP_CSPOTTER)
-    {
     first_mic_in = true;
     current_mictype = MIC_APP_CSPOTTER;
-    }
+  } else if (new_mictype == MIC_APP_MICRECORD) {
-    else if (new_mictype == MIC_APP_MICRECORD)
-    {
     current_mictype = MIC_APP_MICRECORD;
-    }
+  } else if (new_mictype == MIC_APP_OTHER) {
-    else if (new_mictype == MIC_APP_OTHER)
-    {
     TRACE(0, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
   }
 
@@ -119,8 +104,7 @@ static int internal_mic_start(MIC_APP_TYPE new_mictype)
   return false;
 }
 
-static int internal_mic_stop(MIC_APP_TYPE new_mictype)
+static int internal_mic_stop(MIC_APP_TYPE new_mictype) {
-{
   TRACE(1, "MIC_EVENT_STOP,current_mictype=%d", current_mictype);
   // assert(currentMicStauts == currentStatus);
   if (new_mictype != current_mictype) {
@@ -135,50 +119,46 @@ static int internal_mic_stop(MIC_APP_TYPE new_mictype)
   return true;
 }
 
-static int app_mic_process(APP_MESSAGE_BODY *msg_body)
+static int app_mic_process(APP_MESSAGE_BODY *msg_body) {
-{
   MIC_EVENT_TYPE mic_event = (MIC_EVENT_TYPE)msg_body->message_id;
   MIC_APP_TYPE new_mictype = (MIC_APP_TYPE)msg_body->message_ptr;
   int ret = -1;
-    TRACE(4,"%s mic_event:%d new_mictype:%d current_mictype:%d",__func__,mic_event, new_mictype, current_mictype);
+  TRACE(4, "%s mic_event:%d new_mictype:%d current_mictype:%d", __func__,
+        mic_event, new_mictype, current_mictype);
 
   osMutexWait(app_mic_mutex_id, osWaitForever);
   if (mic_event == MIC_EVENT_START)
     ret = internal_mic_start(new_mictype);
   else if (mic_event == MIC_EVENT_STOP)
     ret = internal_mic_stop(new_mictype);
-    else if (mic_event == MIC_EVENT_CHECK)
+  else if (mic_event == MIC_EVENT_CHECK) {
-    {
     TRACE(1, "MIC_EVENT_CHECK,current_mictype=%d", current_mictype);
-        if (current_mictype != new_mictype)
+    if (current_mictype != new_mictype) {
-        {
       if (current_mictype != MIC_APP_NONE)
         internal_mic_stop(current_mictype);
       if (new_mictype != MIC_APP_CSPOTTER)
         internal_mic_start(new_mictype);
       ret = 0;
     }
-    }
+  } else
-    else
     assert(0);
   osMutexRelease(app_mic_mutex_id);
   return ret;
 }
 
-void app_mic_init()
+void app_mic_init() {
-{
   app_mic_mutex_id = osMutexCreate((osMutex(app_mic_mutex)));
   app_set_threadhandle(APP_MODUAL_MIC, app_mic_process);
 }
 
-int app_mic_register(MIC_APP_TYPE mic_type, struct AF_STREAM_CONFIG_T *newStream)
+int app_mic_register(MIC_APP_TYPE mic_type,
-{
+                     struct AF_STREAM_CONFIG_T *newStream) {
-    TRACE(2,"app_mic_registration mic_type:%d,newStream=%p\n",mic_type,newStream);
+  TRACE(2, "app_mic_registration mic_type:%d,newStream=%p\n", mic_type,
-    if (mic_type > MIC_APP_NONE && mic_type < MIC_APP_MAX)
+        newStream);
-    {
+  if (mic_type > MIC_APP_NONE && mic_type < MIC_APP_MAX) {
     osMutexWait(app_mic_mutex_id, osWaitForever);
-        if (memcmp(&mic_config[mic_type],newStream,sizeof(struct AF_STREAM_CONFIG_T)) != 0)
+    if (memcmp(&mic_config[mic_type], newStream,
-        {
+               sizeof(struct AF_STREAM_CONFIG_T)) != 0) {
       TRACE(0, "app_mic_registration Warning mic stream config changed!!!");
     }
     memcpy(&mic_config[mic_type], newStream, sizeof(struct AF_STREAM_CONFIG_T));
@@ -188,11 +168,9 @@ int app_mic_register(MIC_APP_TYPE mic_type, struct AF_STREAM_CONFIG_T *newStream
   return -1;
 }
 
-int app_mic_deregister(MIC_APP_TYPE mic_type)
+int app_mic_deregister(MIC_APP_TYPE mic_type) {
-{
   TRACE(1, "app_mic_deregister mic_type:%d\n", mic_type);
-    if (mic_type > MIC_APP_NONE && mic_type < MIC_APP_MAX)
+  if (mic_type > MIC_APP_NONE && mic_type < MIC_APP_MAX) {
-    {
     osMutexWait(app_mic_mutex_id, osWaitForever);
     memset(&mic_config[mic_type], 0, sizeof(struct AF_STREAM_CONFIG_T));
     osMutexRelease(app_mic_mutex_id);
@@ -201,12 +179,10 @@ int app_mic_deregister(MIC_APP_TYPE mic_type)
   return -1;
 }
 
-bool app_mic_is_registed(MIC_APP_TYPE mic_type)
+bool app_mic_is_registed(MIC_APP_TYPE mic_type) {
-{
   TRACE(1, "app_mic_is_registed mic_type:%d\n", mic_type);
   bool ret = false;
-    if (mic_type > MIC_APP_NONE && mic_type < MIC_APP_MAX)
+  if (mic_type > MIC_APP_NONE && mic_type < MIC_APP_MAX) {
-    {
     osMutexWait(app_mic_mutex_id, osWaitForever);
     ret = mic_config[mic_type].data_ptr != NULL;
     osMutexRelease(app_mic_mutex_id);
@@ -214,8 +190,7 @@ bool app_mic_is_registed(MIC_APP_TYPE mic_type)
   return ret;
 }
 
-bool app_mic_start(MIC_APP_TYPE mic_type)
+bool app_mic_start(MIC_APP_TYPE mic_type) {
-{
   APP_MESSAGE_BLOCK msg;
   msg.mod_id = APP_MODUAL_MIC;
   msg.msg_body.message_id = MIC_EVENT_START;
@@ -224,8 +199,7 @@ bool app_mic_start(MIC_APP_TYPE mic_type)
   return true;
 }
 
-bool app_mic_stop(MIC_APP_TYPE mic_type)
+bool app_mic_stop(MIC_APP_TYPE mic_type) {
-{
   APP_MESSAGE_BLOCK msg;
   msg.mod_id = APP_MODUAL_MIC;
   msg.msg_body.message_id = MIC_EVENT_STOP;
@@ -234,8 +208,7 @@ bool app_mic_stop(MIC_APP_TYPE mic_type)
   return true;
 }
 
-void app_mic_check(MIC_APP_TYPE mic_type)
+void app_mic_check(MIC_APP_TYPE mic_type) {
-{
   APP_MESSAGE_BLOCK msg;
   msg.mod_id = APP_MODUAL_MIC;
   msg.msg_body.message_id = MIC_EVENT_CHECK;
@@ -243,12 +216,10 @@ void app_mic_check(MIC_APP_TYPE mic_type)
   app_mailbox_put(&msg);
 }
 
-MIC_APP_TYPE app_mic_status(void)
+MIC_APP_TYPE app_mic_status(void) {
-{
   MIC_APP_TYPE ret;
   osMutexWait(app_mic_mutex_id, osWaitForever);
   ret = current_mictype;
   osMutexRelease(app_mic_mutex_id);
   return ret;
 }
-

apps/mic_alg/app_mic_alg.cpp

@@ -13,18 +13,18 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_bt_stream.h"
+#include "app_media_player.h"
 #include "cmsis_os.h"
 #include "hal_trace.h"
 #include "resources.h"
-#include "app_bt_stream.h"
-#include "app_media_player.h"
 //#include "app_factory.h"
 #include "string.h"
 
 // for audio
-#include "audioflinger.h"
 #include "app_audio.h"
 #include "app_utils.h"
+#include "audioflinger.h"
 #include "hal_timer.h"
 
 #include "app_mic_alg.h"
@@ -42,7 +42,6 @@
 
 #include "apps.h"
 
-
 #ifdef WEBRTC_AGC
 #include "agc_main.h"
 #endif
@@ -51,17 +50,14 @@
 #define WEBRTC_NSX_BUFF_SIZE (14000)
 #endif
 
-
 #ifdef WL_VAD
 #include "vad_user.h"
 #endif
 
-
 #ifdef WL_DEBUG_MODE
 #include "nvrecord_env.h"
 #endif
 
-
 #ifdef REMOTE_UART
 #include "app_remoter_uart.h"
 #endif
@@ -79,35 +75,27 @@ static inline float clampf(float v, float min, float max){
   return v < min ? min : (v > max ? max : v);
 }
 
-
-
 #ifdef WL_NSX_5MS
 #define BT_AUDIO_FACTORMODE_BUFF_SIZE (160 * 2)
 #else
 #define BT_AUDIO_FACTORMODE_BUFF_SIZE (6 * 320 * 16)
 #endif
 
-
-
 #define NSX_FRAME_SIZE 160
 
-
 static enum APP_AUDIO_CACHE_T a2dp_cache_status = APP_AUDIO_CACHE_QTY;
 
-
 #if defined(WL_AEC)
 static short POSSIBLY_UNUSED aec_out[BT_AUDIO_FACTORMODE_BUFF_SIZE >> 2];
 static short POSSIBLY_UNUSED far_buff[BT_AUDIO_FACTORMODE_BUFF_SIZE >> 2];
 #endif
 
-
 static short POSSIBLY_UNUSED out_buff[BT_AUDIO_FACTORMODE_BUFF_SIZE >> 2];
 static short POSSIBLY_UNUSED tmp_buff[BT_AUDIO_FACTORMODE_BUFF_SIZE >> 2];
 
 // static short revert_buff[BT_AUDIO_FACTORMODE_BUFF_SIZE>>2];
 // static short audio_uart_buff[BT_AUDIO_FACTORMODE_BUFF_SIZE>>2];
 
-
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2
 
 static short POSSIBLY_UNUSED one_buff[BT_AUDIO_FACTORMODE_BUFF_SIZE >> 2];
@@ -116,26 +104,27 @@ static short POSSIBLY_UNUSED  two_buff[BT_AUDIO_FACTORMODE_BUFF_SIZE>>2];
 static short POSSIBLY_UNUSED left_out[BT_AUDIO_FACTORMODE_BUFF_SIZE >> 2];
 static short POSSIBLY_UNUSED right_out[BT_AUDIO_FACTORMODE_BUFF_SIZE >> 2];
 
-static void POSSIBLY_UNUSED aaudio_div_stero_to_rmono(int16_t *dst_buf, int16_t *src_buf, uint32_t src_len)
+static void POSSIBLY_UNUSED aaudio_div_stero_to_rmono(int16_t *dst_buf,
-{
+                                                      int16_t *src_buf,
+                                                      uint32_t src_len) {
   // Copy from tail so that it works even if dst_buf == src_buf
-    for (uint32_t i = 0; i < src_len>>1; i++)
+  for (uint32_t i = 0; i < src_len >> 1; i++) {
-    {
     dst_buf[i] = src_buf[i * 2 + 1];
   }
 }
-static void POSSIBLY_UNUSED aaudio_div_stero_to_lmono(int16_t *dst_buf, int16_t *src_buf, uint32_t src_len)
+static void POSSIBLY_UNUSED aaudio_div_stero_to_lmono(int16_t *dst_buf,
-{
+                                                      int16_t *src_buf,
+                                                      uint32_t src_len) {
   // Copy from tail so that it works even if dst_buf == src_buf
-    for (uint32_t i = 0; i < src_len>>1; i++)
+  for (uint32_t i = 0; i < src_len >> 1; i++) {
-    {
     dst_buf[i] = src_buf[i * 2 + 0];
   }
 }
 
-
+static void POSSIBLY_UNUSED audio_mono2stereo_16bits(int16_t *dst_buf,
-static void POSSIBLY_UNUSED audio_mono2stereo_16bits(int16_t *dst_buf, int16_t *left_buf, int16_t *right_buf, uint32_t src_len)
+                                                     int16_t *left_buf,
-{
+                                                     int16_t *right_buf,
+                                                     uint32_t src_len) {
   uint32_t i = 0;
   for (i = 0; i < src_len; ++i) {
     dst_buf[i * 2 + 0] = left_buf[i];
@@ -145,7 +134,6 @@ static void POSSIBLY_UNUSED audio_mono2stereo_16bits(int16_t *dst_buf, int16_t *
 
 #elif SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 3
 
-
 #elif SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 4
 
 #endif
@@ -155,41 +143,32 @@ extern uint32_t transfer_factor;
 extern uint32_t diff_energy;
 extern uint32_t level_shift;
 
-static inline double convert_multiple_to_db(uint32_t multiple)
+static inline double convert_multiple_to_db(uint32_t multiple) {
-{
   return 20 * log10(multiple);
 }
 #define DUMP_FRAME_LEN 0x3C0
 static short POSSIBLY_UNUSED revert_buff[2 + 1 * DUMP_FRAME_LEN];
 int32_t tx_pcmbuf32[960];
 
-
 extern int app_reset(void);
 
 extern void app_bt_volumeup();
 extern void app_bt_volumedown();
 
-void vol_state_process(uint32_t db_val)
+void vol_state_process(uint32_t db_val) {
-{
+  TRACE(2, "db value is:%d volume_is:%d ", db_val,
-    TRACE(2,"db value is:%d volume_is:%d ",db_val,app_bt_stream_local_volume_get());
+        app_bt_stream_local_volume_get());
 
-    if((db_val < 52) && (app_bt_stream_local_volume_get() > 10))
+  if ((db_val < 52) && (app_bt_stream_local_volume_get() > 10)) {
-    {
     app_bt_volumedown();
-    }
+  } else if ((db_val > 60) && (app_bt_stream_local_volume_get() < 13)) {
-    else if((db_val > 60) && (app_bt_stream_local_volume_get() < 13))
+    app_bt_volumeup();
-    {
+  } else if ((db_val > 72) && (app_bt_stream_local_volume_get() < 15)) {
     app_bt_volumeup();
   }
-    else if((db_val > 72) && (app_bt_stream_local_volume_get() < 15))
-    {
-        app_bt_volumeup();
 }
 
-}
+static uint32_t app_mic_alg_data_come(uint8_t *buf, uint32_t len) {
-
-static uint32_t app_mic_alg_data_come(uint8_t *buf, uint32_t len)
-{
   uint32_t pcm_len = len >> 1;
 
   short POSSIBLY_UNUSED *tx_pcmbuf16 = (short *)buf;
@@ -201,27 +180,23 @@ static uint32_t app_mic_alg_data_come(uint8_t *buf, uint32_t len)
   static int32_t nsx_cnt = 0;
   static int32_t dump_cnt = 0;
 
-
   nsx_cnt++;
   dump_cnt++;
 
   DUMP16("%d,", tx_pcmbuf16, 30);
-    if(false == (nsx_cnt & 0x3F))
+  if (false == (nsx_cnt & 0x3F)) {
-    {
     stime = hal_sys_timer_get();
     // TRACE("aecm  echo time: lens:%d  g_time_cnt:%d ",len, g_time_cnt);
   }
 
 #ifdef WL_DET
-    if(nsx_cnt > 100)
+  if (nsx_cnt > 100) {
-    {
     static double last_sum = 0, last_avg = 0;
 
     uint32_t sum_ss = 0;
     // short db_val = 0;
     double db_sum = 0;
-        for (uint32_t i_cnt = 0; i_cnt < pcm_len; i_cnt++)
+    for (uint32_t i_cnt = 0; i_cnt < pcm_len; i_cnt++) {
-        {
       sum_ss += ABS(tx_pcmbuf16[i_cnt]);
     }
 
@@ -241,15 +216,16 @@ static uint32_t app_mic_alg_data_come(uint8_t *buf, uint32_t len)
 
 #endif
 
-
+  if (false == (nsx_cnt & 0x3F)) {
-    if(false == (nsx_cnt & 0x3F))
+    // TRACE("drc 48 mic_alg 16k nsx 3 agc 15 closed speed  time:%d ms and
-    {
+    // pcm_lens:%d freq:%d ", TICKS_TO_MS(hal_sys_timer_get() - stime),
-        //TRACE("drc 48 mic_alg 16k nsx 3 agc 15 closed speed  time:%d ms and pcm_lens:%d freq:%d ", TICKS_TO_MS(hal_sys_timer_get() - stime), pcm_len,hal_sysfreq_get());
+    // pcm_len,hal_sysfreq_get()); TRACE("notch 500 mic_alg 16k nsx 3 agc 15
-        //TRACE("notch 500 mic_alg 16k nsx 3 agc 15 closed speed  time:%d ms and pcm_lens:%d freq:%d ", TICKS_TO_MS(hal_sys_timer_get() - stime), pcm_len,hal_sysfreq_get());
+    // closed speed  time:%d ms and pcm_lens:%d freq:%d ",
-        TRACE(2,"denoise det  speed  time:%d ms and pcm_lens:%d freq:%d ", TICKS_TO_MS(hal_sys_timer_get() - stime), pcm_len,hal_sysfreq_get());
+    // TICKS_TO_MS(hal_sys_timer_get() - stime), pcm_len,hal_sysfreq_get());
+    TRACE(2, "denoise det  speed  time:%d ms and pcm_lens:%d freq:%d ",
+          TICKS_TO_MS(hal_sys_timer_get() - stime), pcm_len, hal_sysfreq_get());
   }
 
-
   if (a2dp_cache_status == APP_AUDIO_CACHE_QTY) {
     a2dp_cache_status = APP_AUDIO_CACHE_OK;
   }
@@ -262,13 +238,14 @@ static uint32_t app_mic_alg_data_come(uint8_t *buf, uint32_t len)
 // #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2
 //         #ifdef WL_AEC
 //         app_audio_pcmbuff_get((uint8_t *)app_audioloop_play_cache, len/2);
-//         app_bt_stream_copy_track_one_to_two_16bits((int16_t *)buf, app_audioloop_play_cache, len/2/2);
+//         app_bt_stream_copy_track_one_to_two_16bits((int16_t *)buf,
-//         #else
+//         app_audioloop_play_cache, len/2/2); #else
 //         app_audio_pcmbuff_get((uint8_t *)buf, len);
 //         #endif
 // #else
 //         app_audio_pcmbuff_get((uint8_t *)app_audioloop_play_cache, len/2);
-//         app_bt_stream_copy_track_one_to_two_16bits((int16_t *)buf, app_audioloop_play_cache, len/2/2);
+//         app_bt_stream_copy_track_one_to_two_16bits((int16_t *)buf,
+//         app_audioloop_play_cache, len/2/2);
 // #endif
 //     }
 //     return len;
@@ -276,8 +253,7 @@ static uint32_t app_mic_alg_data_come(uint8_t *buf, uint32_t len)
 
 static uint8_t buff_capture[BT_AUDIO_FACTORMODE_BUFF_SIZE];
 
-int app_mic_alg_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq)
+int app_mic_alg_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq) {
-{
   struct AF_STREAM_CONFIG_T stream_cfg;
   static bool isRun = false;
 
@@ -288,21 +264,18 @@ int app_mic_alg_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq)
 
   if (on) {
 
-
     app_sysfreq_req(APP_SYSFREQ_USER_APP_0, freq);
 
     a2dp_cache_status = APP_AUDIO_CACHE_QTY;
 
     memset(&stream_cfg, 0, sizeof(stream_cfg));
 
-
     stream_cfg.bits = AUD_BITS_16;
 
     stream_cfg.channel_num = AUD_CHANNEL_NUM_1;
 
     stream_cfg.sample_rate = AUD_SAMPRATE_48000;
 
-
     stream_cfg.device = AUD_STREAM_USE_INT_CODEC;
 
     stream_cfg.vol = CODEC_SADC_VOL;
@@ -311,7 +284,8 @@ int app_mic_alg_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq)
     stream_cfg.handler = app_mic_alg_data_come;
 
     stream_cfg.data_ptr = BT_AUDIO_CACHE_2_UNCACHE(buff_capture);
-        stream_cfg.data_size = BT_AUDIO_FACTORMODE_BUFF_SIZE*stream_cfg.channel_num;
+    stream_cfg.data_size =
+        BT_AUDIO_FACTORMODE_BUFF_SIZE * stream_cfg.channel_num;
     af_stream_open(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE, &stream_cfg);
 
     // stream_cfg.channel_num = AUD_CHANNEL_NUM_2;
@@ -339,5 +313,3 @@ int app_mic_alg_audioloop(bool on, enum APP_SYSFREQ_FREQ_T freq)
   isRun = on;
   return 0;
 }
-
-

apps/pwl/app_pwl.cpp

@@ -13,14 +13,14 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_pwl.h"
 #include "cmsis_os.h"
-#include "tgt_hardware.h"
 #include "hal_gpio.h"
 #include "hal_iomux.h"
 #include "hal_trace.h"
 #include "pmu.h"
-#include "app_pwl.h"
 #include "string.h"
+#include "tgt_hardware.h"
 
 #define APP_PWL_TRACE(s, ...)
 // TRACE(s, ##__VA_ARGS__)
@@ -42,8 +42,7 @@ struct APP_PWL_T {
 
 static struct APP_PWL_T app_pwl[APP_PWL_ID_QTY];
 
-static void app_pwl_timehandler(void const *param)
+static void app_pwl_timehandler(void const *param) {
-{
   struct APP_PWL_T *pwl = (struct APP_PWL_T *)param;
   struct APP_PWL_CFG_T *cfg = &(pwl->config);
   APP_PWL_TRACE(2, "%s %x", __func__, param);
@@ -61,48 +60,54 @@ static void app_pwl_timehandler(void const *param)
     }
   }
 
-    APP_PWL_TRACE(3,"idx:%d pin:%d lvl:%d", pwl->partidx, cfg_hw_pinmux_pwl[pwl->id].pin, cfg->part[pwl->partidx].level);
+  APP_PWL_TRACE(3, "idx:%d pin:%d lvl:%d", pwl->partidx,
+                cfg_hw_pinmux_pwl[pwl->id].pin, cfg->part[pwl->partidx].level);
   if (!cfg->part[pwl->partidx].level) {
 #if defined(__PMU_VIO_DYNAMIC_CTRL_MODE__)
-        pmu_viorise_req(pwl->id == APP_PWL_ID_0 ? PMU_VIORISE_REQ_USER_PWL0 : PMU_VIORISE_REQ_USER_PWL1, true);
+    pmu_viorise_req(pwl->id == APP_PWL_ID_0 ? PMU_VIORISE_REQ_USER_PWL0
+                                            : PMU_VIORISE_REQ_USER_PWL1,
+                    true);
 #endif
     hal_gpio_pin_set((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[pwl->id].pin);
   } else {
     hal_gpio_pin_clr((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[pwl->id].pin);
 #if defined(__PMU_VIO_DYNAMIC_CTRL_MODE__)
-        pmu_viorise_req(pwl->id == APP_PWL_ID_0 ? PMU_VIORISE_REQ_USER_PWL0 : PMU_VIORISE_REQ_USER_PWL1, false);
+    pmu_viorise_req(pwl->id == APP_PWL_ID_0 ? PMU_VIORISE_REQ_USER_PWL0
+                                            : PMU_VIORISE_REQ_USER_PWL1,
+                    false);
 #endif
   }
   osTimerStart(pwl->timer, cfg->part[pwl->partidx].time);
 }
 #endif
 
-int app_pwl_open(void)
+int app_pwl_open(void) {
-{
 #if (CFG_HW_PLW_NUM > 0)
   uint8_t i;
   APP_PWL_TRACE(1, "%s", __func__);
   for (i = 0; i < APP_PWL_ID_QTY; i++) {
     app_pwl[i].id = APP_PWL_ID_QTY;
     memset(&(app_pwl[i].config), 0, sizeof(struct APP_PWL_CFG_T));
-        hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&cfg_hw_pinmux_pwl[i], 1);
+    hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&cfg_hw_pinmux_pwl[i],
-        hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[i].pin, HAL_GPIO_DIR_OUT, 1);
+                   1);
+    hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[i].pin,
+                         HAL_GPIO_DIR_OUT, 1);
   }
-    app_pwl[APP_PWL_ID_0].timer = osTimerCreate (osTimer(APP_PWL_TIMER0), osTimerOnce, &app_pwl[APP_PWL_ID_0]);
+  app_pwl[APP_PWL_ID_0].timer = osTimerCreate(
+      osTimer(APP_PWL_TIMER0), osTimerOnce, &app_pwl[APP_PWL_ID_0]);
 #if (CFG_HW_PLW_NUM == 2)
-    app_pwl[APP_PWL_ID_1].timer = osTimerCreate (osTimer(APP_PWL_TIMER1), osTimerOnce, &app_pwl[APP_PWL_ID_1]);
+  app_pwl[APP_PWL_ID_1].timer = osTimerCreate(
+      osTimer(APP_PWL_TIMER1), osTimerOnce, &app_pwl[APP_PWL_ID_1]);
 #endif
 #endif
   return 0;
 }
 
-int app_pwl_start(enum APP_PWL_ID_T id)
+int app_pwl_start(enum APP_PWL_ID_T id) {
-{
 #if (CFG_HW_PLW_NUM > 0)
   struct APP_PWL_T *pwl = NULL;
   struct APP_PWL_CFG_T *cfg = NULL;
 
-
   if (id >= APP_PWL_ID_QTY) {
     return -1;
   }
@@ -123,16 +128,21 @@ int app_pwl_start(enum APP_PWL_ID_T id)
 
   osTimerStop(pwl->timer);
 
-    APP_PWL_TRACE(3,"idx:%d pin:%d lvl:%d", pwl->partidx, cfg_hw_pinmux_pwl[pwl->id].pin, cfg->part[pwl->partidx].level);
+  APP_PWL_TRACE(3, "idx:%d pin:%d lvl:%d", pwl->partidx,
+                cfg_hw_pinmux_pwl[pwl->id].pin, cfg->part[pwl->partidx].level);
   if (!cfg->part[pwl->partidx].level) {
 #if defined(__PMU_VIO_DYNAMIC_CTRL_MODE__)
-        pmu_viorise_req(pwl->id == APP_PWL_ID_0 ? PMU_VIORISE_REQ_USER_PWL0 : PMU_VIORISE_REQ_USER_PWL1, false);
+    pmu_viorise_req(pwl->id == APP_PWL_ID_0 ? PMU_VIORISE_REQ_USER_PWL0
+                                            : PMU_VIORISE_REQ_USER_PWL1,
+                    false);
 #endif
     hal_gpio_pin_set((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[pwl->id].pin);
   } else {
     hal_gpio_pin_clr((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[pwl->id].pin);
 #if defined(__PMU_VIO_DYNAMIC_CTRL_MODE__)
-        pmu_viorise_req(pwl->id == APP_PWL_ID_0 ? PMU_VIORISE_REQ_USER_PWL0 : PMU_VIORISE_REQ_USER_PWL1, false);
+    pmu_viorise_req(pwl->id == APP_PWL_ID_0 ? PMU_VIORISE_REQ_USER_PWL0
+                                            : PMU_VIORISE_REQ_USER_PWL1,
+                    false);
 #endif
   }
   osTimerStart(pwl->timer, cfg->part[pwl->partidx].time);
@@ -140,15 +150,15 @@ int app_pwl_start(enum APP_PWL_ID_T id)
   return 0;
 }
 
-int app_pwl_setup(enum APP_PWL_ID_T id, struct APP_PWL_CFG_T *cfg)
+int app_pwl_setup(enum APP_PWL_ID_T id, struct APP_PWL_CFG_T *cfg) {
-{
 #if (CFG_HW_PLW_NUM > 0)
   if (cfg == NULL || id >= APP_PWL_ID_QTY) {
     return -1;
   }
   APP_PWL_TRACE(2, "%s %d", __func__, id);
 
-    hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[id].pin, HAL_GPIO_DIR_OUT, cfg->startlevel?0:1);
+  hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[id].pin,
+                       HAL_GPIO_DIR_OUT, cfg->startlevel ? 0 : 1);
   app_pwl[id].id = id;
   memcpy(&(app_pwl[id].config), cfg, sizeof(struct APP_PWL_CFG_T));
 
@@ -157,8 +167,7 @@ int app_pwl_setup(enum APP_PWL_ID_T id, struct APP_PWL_CFG_T *cfg)
   return 0;
 }
 
-int app_pwl_stop(enum APP_PWL_ID_T id)
+int app_pwl_stop(enum APP_PWL_ID_T id) {
-{
 #if (CFG_HW_PLW_NUM > 0)
   if (id >= APP_PWL_ID_QTY) {
     return -1;
@@ -170,8 +179,7 @@ int app_pwl_stop(enum APP_PWL_ID_T id)
   return 0;
 }
 
-int app_pwl_close(void)
+int app_pwl_close(void) {
-{
 #if (CFG_HW_PLW_NUM > 0)
   uint8_t i;
   for (i = 0; i < APP_PWL_ID_QTY; i++) {
@@ -181,5 +189,3 @@ int app_pwl_close(void)
 #endif
   return 0;
 }
-
-

apps/sdmmc/app_sdmmc.cpp

@@ -19,30 +19,28 @@
 
 //#include "hal_sdmmc.h"
 #include "SDFileSystem.h"
-#include "audioflinger.h"
-#include "audiobuffer.h"
 #include "app_sdmmc.h"
-
+#include "audiobuffer.h"
+#include "audioflinger.h"
 
 #define APP_TEST_PLAYBACK_BUFF_SIZE (120 * 20)
 #define APP_TEST_CAPTURE_BUFF_SIZE (120 * 20)
-extern uint8_t app_test_playback_buff[APP_TEST_PLAYBACK_BUFF_SIZE] __attribute__ ((aligned(4)));
+extern uint8_t app_test_playback_buff[APP_TEST_PLAYBACK_BUFF_SIZE]
-extern uint8_t app_test_capture_buff[APP_TEST_CAPTURE_BUFF_SIZE] __attribute__ ((aligned(4)));
+    __attribute__((aligned(4)));
+extern uint8_t app_test_capture_buff[APP_TEST_CAPTURE_BUFF_SIZE]
+    __attribute__((aligned(4)));
 SDFileSystem sdfs("sd");
 
-int sd_open()
+int sd_open() {
-{
   DIR *d = opendir("/sd");
-    if (!d)
+  if (!d) {
-    {
     TRACE(0, "sd file system borked\n");
     return -1;
   }
 
   TRACE(0, "---------root---------\n");
   struct dirent *p;
-    while ((p = readdir(d)))
+  while ((p = readdir(d))) {
-    {
     int len = sizeof(dirent);
     TRACE(2, "%s %d\n", p->d_name, len);
   }
@@ -54,8 +52,7 @@ extern uint32_t play_wav_file(char *file_path);
 extern uint32_t stop_wav_file(void);
 extern uint32_t wav_file_audio_more_data(uint8_t *buf, uint32_t len);
 
-void test_wave_play(bool  on)
+void test_wave_play(bool on) {
-{
   struct AF_STREAM_CONFIG_T stream_cfg;
   uint32_t reallen;
   uint32_t totalreadsize;
@@ -70,7 +67,6 @@ void test_wave_play(bool  on)
   else
     isRun = on;
 
-
   TRACE(2, "%s %d\n", __func__, on);
   memset(&stream_cfg, 0, sizeof(stream_cfg));
   if (on) {
@@ -99,25 +95,21 @@ void test_wave_play(bool  on)
   return;
 }
 
-
 FIL pcm_fil;
 FRESULT pcm_res;
 UINT pcm_num;
-uint32_t pcm_save_more_data(uint8_t *buf, uint32_t len)
+uint32_t pcm_save_more_data(uint8_t *buf, uint32_t len) {
-{
   //    TRACE(2,"%s\n len:%d", __func__, len);
 
   audio_buffer_set_stereo2mono_16bits(buf, len, 1);
   pcm_res = f_write(&pcm_fil, (uint8_t *)buf, len >> 1, &pcm_num);
-	if(pcm_res != FR_OK)
+  if (pcm_res != FR_OK) {
-	{
     TRACE(2, "[%s]:error-->res = %d", __func__, pcm_res);
   }
   return 0;
 }
 
-void  ad_tester(bool run)
+void ad_tester(bool run) {
-{
   char filename[] = "/sd/audio_dump.bin";
 
   struct AF_STREAM_CONFIG_T stream_cfg;
@@ -156,45 +148,39 @@ void  ad_tester(bool run)
 }
 
 // if dump data into sd, buffer length should make sd card speed enough
-// Bench32.exe can test sd card speed in PC, then make sure bufer length, buffer length < 16k(sd driver)
+// Bench32.exe can test sd card speed in PC, then make sure bufer length, buffer
-void dump_data2sd(enum APP_SDMMC_DUMP_T opt, uint8_t *buf, uint32_t len)
+// length < 16k(sd driver)
-{
+void dump_data2sd(enum APP_SDMMC_DUMP_T opt, uint8_t *buf, uint32_t len) {
   static FIL sd_fil;
   FRESULT res;
 
+  ASSERT(opt < APP_SDMMC_DUMP_NUM, "[%s] opt(%d) >= APP_SDMMC_DUMP_NUM",
+         __func__, opt);
 
-    ASSERT(opt < APP_SDMMC_DUMP_NUM, "[%s] opt(%d) >= APP_SDMMC_DUMP_NUM", __func__, opt);
+  if (opt == APP_SDMMC_DUMP_OPEN) {
-    
-    if(opt == APP_SDMMC_DUMP_OPEN)
-    {
     //        res = f_open(&sd_fil,"dump.bin",FA_CREATE_ALWAYS | FA_WRITE);
     res = f_open(&sd_fil, "test.txt", FA_READ);
 
-//        ASSERT(pcm_res == FR_OK,"[%s]:Cannot creat dump.bin, res = %d",__func__, pcm_res);
+    //        ASSERT(pcm_res == FR_OK,"[%s]:Cannot creat dump.bin, res =
+    //        %d",__func__, pcm_res);
   }
-    if(opt == APP_SDMMC_DUMP_READ)
+  if (opt == APP_SDMMC_DUMP_READ) {
-    {
     res = f_read(&sd_fil, buf, len, &pcm_num);
 
-//        ASSERT(pcm_res == FR_OK,"[%s]:Cannot creat dump.bin, res = %d",__func__, pcm_res);
+    //        ASSERT(pcm_res == FR_OK,"[%s]:Cannot creat dump.bin, res =
-    }
+    //        %d",__func__, pcm_res);
-    else if(opt == APP_SDMMC_DUMP_WRITE)
+  } else if (opt == APP_SDMMC_DUMP_WRITE) {
-    {
     res = f_write(&sd_fil, buf, len, &pcm_num);
 
-//        ASSERT(pcm_res == FR_OK,"[%s]:Write dump.bin failed, res = %d", __func__, pcm_res);
+    //        ASSERT(pcm_res == FR_OK,"[%s]:Write dump.bin failed, res = %d",
-    }
+    //        __func__, pcm_res);
-    else if(opt == APP_SDMMC_DUMP_CLOSE)
+  } else if (opt == APP_SDMMC_DUMP_CLOSE) {
-    {
     res = f_close(&sd_fil);
   }
 
-    if(res == FR_OK)
+  if (res == FR_OK) {
-    {
     TRACE(3, "[%s] SUCESS: opt = %d, res = %d", __func__, opt, res);
-    }
+  } else {
-    else
-    {
     TRACE(3, "[%s] ERROR: opt = %d, res = %d", __func__, opt, res);
   }
 }

apps/usbaudio/usbaudio_entry.c

@@ -13,30 +13,30 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "plat_addr_map.h"
+#include "analog.h"
+#include "audioflinger.h"
+#include "cmsis.h"
 #include "hal_cmu.h"
-#include "hal_timer.h"
-#include "hal_trace.h"
-#include "hal_iomux.h"
 #include "hal_dma.h"
-#include "hal_key.h"
 #include "hal_gpadc.h"
+#include "hal_iomux.h"
+#include "hal_key.h"
 #include "hal_sleep.h"
 #include "hal_sysfreq.h"
-#include "cmsis.h"
+#include "hal_timer.h"
-#include "pmu.h"
+#include "hal_trace.h"
-#include "analog.h"
-#include "string.h"
 #include "hwtimer_list.h"
-#include "audioflinger.h"
+#include "plat_addr_map.h"
+#include "pmu.h"
+#include "string.h"
 #if defined(ANC_APP)
 #include "anc_usb_app.h"
 #endif
-#include "usb_audio_app.h"
-#include "dualadc_audio_app.h"
-#include "usb_audio_frm_defs.h"
-#include "tgt_hardware.h"
 #include "audio_process.h"
+#include "dualadc_audio_app.h"
+#include "tgt_hardware.h"
+#include "usb_audio_app.h"
+#include "usb_audio_frm_defs.h"
 
 #ifdef RTOS
 #include "cmsis_os.h"
@@ -54,15 +54,20 @@
 #endif
 
 #if (CODEC_BUFF_FRAME_NUM >= USB_BUFF_FRAME_NUM)
-#error "Codec buffer frame num should be less than usb buffer frame num (on the requirement of conflict ctrl)"
+#error                                                                         \
+    "Codec buffer frame num should be less than usb buffer frame num (on the requirement of conflict ctrl)"
 #endif
 
 #ifdef USB_AUDIO_DYN_CFG
-#define USB_AUDIO_PLAYBACK_BUFF_SIZE    NON_EXP_ALIGN(MAX_FRAME_SIZE_PLAYBACK * CODEC_BUFF_FRAME_NUM, DAC_BUFF_ALIGN)
+#define USB_AUDIO_PLAYBACK_BUFF_SIZE                                           \
-#define USB_AUDIO_CAPTURE_BUFF_SIZE     NON_EXP_ALIGN(MAX_FRAME_SIZE_CAPTURE * CODEC_BUFF_FRAME_NUM, ADC_BUFF_ALIGN)
+  NON_EXP_ALIGN(MAX_FRAME_SIZE_PLAYBACK *CODEC_BUFF_FRAME_NUM, DAC_BUFF_ALIGN)
+#define USB_AUDIO_CAPTURE_BUFF_SIZE                                            \
+  NON_EXP_ALIGN(MAX_FRAME_SIZE_CAPTURE *CODEC_BUFF_FRAME_NUM, ADC_BUFF_ALIGN)
 
-#define USB_AUDIO_RECV_BUFF_SIZE        NON_EXP_ALIGN(MAX_FRAME_SIZE_RECV * USB_BUFF_FRAME_NUM, RECV_BUFF_ALIGN)
+#define USB_AUDIO_RECV_BUFF_SIZE                                               \
-#define USB_AUDIO_SEND_BUFF_SIZE        NON_EXP_ALIGN(MAX_FRAME_SIZE_SEND * USB_BUFF_FRAME_NUM, SEND_BUFF_ALIGN)
+  NON_EXP_ALIGN(MAX_FRAME_SIZE_RECV *USB_BUFF_FRAME_NUM, RECV_BUFF_ALIGN)
+#define USB_AUDIO_SEND_BUFF_SIZE                                               \
+  NON_EXP_ALIGN(MAX_FRAME_SIZE_SEND *USB_BUFF_FRAME_NUM, SEND_BUFF_ALIGN)
 
 #if defined(CHIP_BEST1000)
 // FIR EQ is working on 16-bit
@@ -79,42 +84,59 @@
 #endif
 
 #else
-#define USB_AUDIO_PLAYBACK_BUFF_SIZE    NON_EXP_ALIGN(FRAME_SIZE_PLAYBACK * CODEC_BUFF_FRAME_NUM, DAC_BUFF_ALIGN)
+#define USB_AUDIO_PLAYBACK_BUFF_SIZE                                           \
-#define USB_AUDIO_CAPTURE_BUFF_SIZE     NON_EXP_ALIGN(FRAME_SIZE_CAPTURE * CODEC_BUFF_FRAME_NUM, ADC_BUFF_ALIGN)
+  NON_EXP_ALIGN(FRAME_SIZE_PLAYBACK *CODEC_BUFF_FRAME_NUM, DAC_BUFF_ALIGN)
+#define USB_AUDIO_CAPTURE_BUFF_SIZE                                            \
+  NON_EXP_ALIGN(FRAME_SIZE_CAPTURE *CODEC_BUFF_FRAME_NUM, ADC_BUFF_ALIGN)
 
-#define USB_AUDIO_RECV_BUFF_SIZE        NON_EXP_ALIGN(FRAME_SIZE_RECV * USB_BUFF_FRAME_NUM, RECV_BUFF_ALIGN)
+#define USB_AUDIO_RECV_BUFF_SIZE                                               \
-#define USB_AUDIO_SEND_BUFF_SIZE        NON_EXP_ALIGN(FRAME_SIZE_SEND * USB_BUFF_FRAME_NUM, SEND_BUFF_ALIGN)
+  NON_EXP_ALIGN(FRAME_SIZE_RECV *USB_BUFF_FRAME_NUM, RECV_BUFF_ALIGN)
+#define USB_AUDIO_SEND_BUFF_SIZE                                               \
+  NON_EXP_ALIGN(FRAME_SIZE_SEND *USB_BUFF_FRAME_NUM, SEND_BUFF_ALIGN)
 
 #if defined(CHIP_BEST1000)
 // FIR EQ is working on 16-bit
-#define USB_AUDIO_FIR_EQ_BUFF_SIZE      (USB_AUDIO_PLAYBACK_BUFF_SIZE * sizeof(int16_t) / SAMPLE_SIZE_PLAYBACK)
+#define USB_AUDIO_FIR_EQ_BUFF_SIZE                                             \
+  (USB_AUDIO_PLAYBACK_BUFF_SIZE * sizeof(int16_t) / SAMPLE_SIZE_PLAYBACK)
 #elif defined(CHIP_BEST2000)
 // FIR EQ is working on 16-bit
-#define USB_AUDIO_FIR_EQ_BUFF_SIZE      (USB_AUDIO_PLAYBACK_BUFF_SIZE * sizeof(int32_t) / SAMPLE_SIZE_PLAYBACK)
+#define USB_AUDIO_FIR_EQ_BUFF_SIZE                                             \
+  (USB_AUDIO_PLAYBACK_BUFF_SIZE * sizeof(int32_t) / SAMPLE_SIZE_PLAYBACK)
 #elif defined(CHIP_BEST2300) || defined(CHIP_BEST2300P)
 // FIR EQ is working on 16-bit
-#define USB_AUDIO_FIR_EQ_BUFF_SIZE      (USB_AUDIO_PLAYBACK_BUFF_SIZE * sizeof(int32_t) / SAMPLE_SIZE_PLAYBACK)
+#define USB_AUDIO_FIR_EQ_BUFF_SIZE                                             \
+  (USB_AUDIO_PLAYBACK_BUFF_SIZE * sizeof(int32_t) / SAMPLE_SIZE_PLAYBACK)
 #endif
 #endif
 
-#if (defined(CHIP_BEST1000) && (defined(ANC_APP) || defined(_DUAL_AUX_MIC_))) && (CHAN_NUM_CAPTURE == CHAN_NUM_SEND)
+#if (defined(CHIP_BEST1000) &&                                                 \
-// Resample input buffer size should be (half_of_max_sample_num * SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE).
+     (defined(ANC_APP) || defined(_DUAL_AUX_MIC_))) &&                         \
-// half_of_max_sample_num = 48000 / 1000 * CODEC_BUFF_FRAME_NUM / 2 * 48 / 44
+    (CHAN_NUM_CAPTURE == CHAN_NUM_SEND)
-#define RESAMPLE_INPUT_BUFF_SIZE        ALIGN(48000 / 1000 * SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE * CODEC_BUFF_FRAME_NUM / 2 * 48 / 44, 4)
+// Resample input buffer size should be (half_of_max_sample_num *
+// SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE). half_of_max_sample_num = 48000 /
+// 1000 * CODEC_BUFF_FRAME_NUM / 2 * 48 / 44
+#define RESAMPLE_INPUT_BUFF_SIZE                                               \
+  ALIGN(48000 / 1000 * SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE *                \
+            CODEC_BUFF_FRAME_NUM / 2 * 48 / 44,                                \
+        4)
 #else
 #define RESAMPLE_INPUT_BUFF_SIZE 0
 #endif
 // Resample history buffer size should be
-// sizeof(struct RESAMPLE_CTRL_T) + ((SAMPLE_NUM + phase_coef_num) * SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE)
+// sizeof(struct RESAMPLE_CTRL_T) + ((SAMPLE_NUM + phase_coef_num) *
-#define RESAMPLE_HISTORY_BUFF_SIZE      (50 + (256 * SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE))
+// SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE)
-#define USB_AUDIO_RESAMPLE_BUFF_SIZE    (RESAMPLE_INPUT_BUFF_SIZE + RESAMPLE_HISTORY_BUFF_SIZE)
+#define RESAMPLE_HISTORY_BUFF_SIZE                                             \
+  (50 + (256 * SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE))
+#define USB_AUDIO_RESAMPLE_BUFF_SIZE                                           \
+  (RESAMPLE_INPUT_BUFF_SIZE + RESAMPLE_HISTORY_BUFF_SIZE)
 
 #define ALIGNED4 ALIGNED(4)
 
 #if defined(USB_AUDIO_APP) || defined(DUALADC_AUDIO_TEST)
 
 #ifdef AUDIO_ANC_FB_MC
-static uint8_t ALIGNED4 playback_buff[USB_AUDIO_PLAYBACK_BUFF_SIZE * 9];//max 48->384 or 44.1->44.1*8;
+static uint8_t ALIGNED4 playback_buff[USB_AUDIO_PLAYBACK_BUFF_SIZE *
+                                      9]; // max 48->384 or 44.1->44.1*8;
 #else
 static uint8_t ALIGNED4 playback_buff[USB_AUDIO_PLAYBACK_BUFF_SIZE];
 #endif
@@ -125,7 +147,8 @@ static uint8_t ALIGNED4 capture_buff[USB_AUDIO_CAPTURE_BUFF_SIZE];
 
 #ifdef USB_AUDIO_APP
 #if defined(__HW_FIR_EQ_PROCESS__) && defined(__HW_IIR_EQ_PROCESS__)
-static uint8_t ALIGNED4 eq_buff[USB_AUDIO_FIR_EQ_BUFF_SIZE+USB_AUDIO_IIR_EQ_BUFF_SIZE];
+static uint8_t ALIGNED4
+    eq_buff[USB_AUDIO_FIR_EQ_BUFF_SIZE + USB_AUDIO_IIR_EQ_BUFF_SIZE];
 #elif defined(__HW_FIR_EQ_PROCESS__) && !defined(__HW_IIR_EQ_PROCESS__)
 static uint8_t ALIGNED4 eq_buff[USB_AUDIO_FIR_EQ_BUFF_SIZE];
 #elif !defined(__HW_FIR_EQ_PROCESS__) && defined(__HW_IIR_EQ_PROCESS__)
@@ -146,7 +169,8 @@ static uint8_t ALIGNED4 send_buff[USB_AUDIO_SEND_BUFF_SIZE];
 
 #ifdef CFG_HW_KEY_LED_PIN
 const struct HAL_IOMUX_PIN_FUNCTION_MAP pinmux_key_led[1] = {
-    {CFG_HW_KEY_LED_PIN, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+    {CFG_HW_KEY_LED_PIN, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_NOPULL},
 };
 #endif
 
@@ -154,8 +178,7 @@ const struct HAL_IOMUX_PIN_FUNCTION_MAP pinmux_key_led[1] = {
 extern void mic_key_open(void);
 #endif
 
-static void uart_i2c_switch(void)
+static void uart_i2c_switch(void) {
-{
   static int flag = 0;
 
   flag ^= 1;
@@ -167,8 +190,8 @@ static void uart_i2c_switch(void)
   }
 }
 
-static int POSSIBLY_UNUSED key_event_process(uint32_t key_code, uint8_t key_event)
+static int POSSIBLY_UNUSED key_event_process(uint32_t key_code,
-{
+                                             uint8_t key_event) {
   TRACE(3, "%s: code=0x%X, event=%u", __FUNCTION__, key_code, key_event);
 
 #ifdef CFG_HW_KEY_LED_PIN
@@ -200,8 +223,7 @@ static int POSSIBLY_UNUSED key_event_process(uint32_t key_code, uint8_t key_even
   return 0;
 }
 
-void anc_usb_open(void)
+void anc_usb_open(void) {
-{
   TRACE(1, "%s", __FUNCTION__);
 
 #ifdef __AUDIO_RESAMPLE__
@@ -234,7 +256,8 @@ void anc_usb_open(void)
 #endif
 
 #ifdef ANC_APP
-    anc_usb_app_init(AUD_INPUT_PATH_MAINMIC, SAMPLE_RATE_PLAYBACK, SAMPLE_RATE_CAPTURE);
+  anc_usb_app_init(AUD_INPUT_PATH_MAINMIC, SAMPLE_RATE_PLAYBACK,
+                   SAMPLE_RATE_CAPTURE);
 #endif
 
 #ifdef DUALADC_AUDIO_TEST
@@ -276,14 +299,10 @@ void anc_usb_open(void)
   }
 }
 
-void anc_usb_close(void)
+void anc_usb_close(void) { usb_audio_app(0); }
-{
-    usb_audio_app(0);
-}
 
 #ifdef CFG_HW_GPADCKEY
-void gpadc_key_handler(uint16_t irq_val, HAL_GPADC_MV_T volt)
+void gpadc_key_handler(uint16_t irq_val, HAL_GPADC_MV_T volt) {
-{
   static uint16_t stable_cnt = 0;
   static uint16_t click_cnt = 0;
   static uint32_t click_time;
@@ -295,10 +314,12 @@ void gpadc_key_handler(uint16_t irq_val, HAL_GPADC_MV_T volt)
 
   if (volt < 100) {
     stable_cnt++;
-        //TRACE(5,"adc_key down: volt=%u stable=%u click_cnt=%u click_time=%u time=%u", volt, stable_cnt, click_cnt, click_time, time);
+    // TRACE(5,"adc_key down: volt=%u stable=%u click_cnt=%u click_time=%u
+    // time=%u", volt, stable_cnt, click_cnt, click_time, time);
   } else {
     if (stable_cnt > 1) {
-            //TRACE(5,"adc_key up: volt=%u stable=%u click_cnt=%u click_time=%u time=%u", volt, stable_cnt, click_cnt, click_time, time);
+      // TRACE(5,"adc_key up: volt=%u stable=%u click_cnt=%u click_time=%u
+      // time=%u", volt, stable_cnt, click_cnt, click_time, time);
       if (click_cnt == 0 || (time - click_time) < MS_TO_TICKS(500)) {
         click_time = time;
         click_cnt++;
@@ -316,7 +337,8 @@ void gpadc_key_handler(uint16_t irq_val, HAL_GPADC_MV_T volt)
     }
 
     if (send_event) {
-            //TRACE(5,"adc_key click: volt=%u stable=%u click_cnt=%u click_time=%u time=%u", volt, stable_cnt, click_cnt, click_time, time);
+      // TRACE(5,"adc_key click: volt=%u stable=%u click_cnt=%u click_time=%u
+      // time=%u", volt, stable_cnt, click_cnt, click_time, time);
       if (click_cnt == 1) {
         event = HAL_KEY_EVENT_CLICK;
       } else if (click_cnt == 2) {
@@ -333,15 +355,9 @@ void gpadc_key_handler(uint16_t irq_val, HAL_GPADC_MV_T volt)
 
 // GDB can set a breakpoint on the main function only if it is
 // declared as below, when linking with STD libraries.
-int btusbaudio_entry(void)
+int btusbaudio_entry(void) {
-{
   anc_usb_open();
   return 0;
 }
 
-void btusbaudio_exit(void)
+void btusbaudio_exit(void) { anc_usb_close(); }
-{
-    anc_usb_close();
-}
-
-

apps/usbhost/app_usbhost.c

@@ -13,9 +13,6 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
+#include "app_thread.h"
 #include "cmsis_os.h"
 #include "hal_trace.h"
-#include "app_thread.h"
-
-
-

apps/voice_detector/app_voice_detector.cpp

@@ -1,20 +1,22 @@
-#include <stdio.h>
-#include <assert.h>
-#include "cmsis_os.h"
-#include "tgt_hardware.h"
-#include "audioflinger.h"
-#include "hal_trace.h"
-#include "hal_timer.h"
-#include "app_thread.h"
-#include "voice_detector.h"
 #include "app_voice_detector.h"
+#include "app_thread.h"
+#include "audioflinger.h"
+#include "cmsis_os.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
+#include "tgt_hardware.h"
+#include "voice_detector.h"
+#include <assert.h>
+#include <stdio.h>
 
 #define APP_VD_DEBUG
 
 #ifdef APP_VD_DEBUG
 #define APP_VD_LOG(str, ...) LOG_DEBUG(LOG_MOD(AUD), str, ##__VA_ARGS__)
 #else
-#define APP_VD_LOG(...) do{}while(0)
+#define APP_VD_LOG(...)                                                        \
+  do {                                                                         \
+  } while (0)
 #endif
 #define APP_VD_ERR(str, ...) LOG_ERROR(LOG_MOD(AUD), str, ##__VA_ARGS__)
 
@@ -22,10 +24,8 @@ osMutexId vd_mutex_id = NULL;
 osMutexDef(vd_mutex);
 
 static int cmd_arr_evt_vad_start[] = {
-    VOICE_DET_CMD_AUD_CAP_STOP,
+    VOICE_DET_CMD_AUD_CAP_STOP, VOICE_DET_CMD_AUD_CAP_CLOSE,
-    VOICE_DET_CMD_AUD_CAP_CLOSE,
+    VOICE_DET_CMD_VAD_OPEN,     VOICE_DET_CMD_VAD_START,
-    VOICE_DET_CMD_VAD_OPEN,
-    VOICE_DET_CMD_VAD_START,
     VOICE_DET_CMD_SYS_CLK_32K,
 };
 #if 0
@@ -44,10 +44,8 @@ static int cmd_arr_evt_cap_start[] = {
 };
 #endif
 static int cmd_arr_evt_close[] = {
-    VOICE_DET_CMD_AUD_CAP_STOP,
+    VOICE_DET_CMD_AUD_CAP_STOP, VOICE_DET_CMD_AUD_CAP_CLOSE,
-    VOICE_DET_CMD_AUD_CAP_CLOSE,
+    VOICE_DET_CMD_VAD_STOP,     VOICE_DET_CMD_VAD_CLOSE,
-    VOICE_DET_CMD_VAD_STOP,
-    VOICE_DET_CMD_VAD_CLOSE,
     VOICE_DET_CMD_EXIT,
 };
 #if 1
@@ -63,8 +61,7 @@ static int cmd_arr_evt_vad_close[] = {
     VOICE_DET_CMD_EXIT,
 };
 
-static int app_voice_detector_process(APP_MESSAGE_BODY *msg_body)
+static int app_voice_detector_process(APP_MESSAGE_BODY *msg_body) {
-{
   enum voice_detector_id id = (enum voice_detector_id)msg_body->message_id;
   enum voice_detector_evt evt = (enum voice_detector_evt)msg_body->message_ptr;
   int ret = 0, num, *cmds;
@@ -115,8 +112,7 @@ static int app_voice_detector_process(APP_MESSAGE_BODY *msg_body)
   return ret;
 }
 
-static void voice_detector_send_msg(uint32_t id, uint32_t evt)
+static void voice_detector_send_msg(uint32_t id, uint32_t evt) {
-{
   APP_MESSAGE_BLOCK msg;
 
   msg.mod_id = APP_MODUAL_VOICE_DETECTOR;
@@ -126,8 +122,7 @@ static void voice_detector_send_msg(uint32_t id, uint32_t evt)
   app_mailbox_put(&msg);
 }
 
-static void voice_detector_wakeup_system(int state, void *param)
+static void voice_detector_wakeup_system(int state, void *param) {
-{
   enum voice_detector_id id = VOICE_DETECTOR_ID_0;
 
   if (voice_detector_query_status(id) == VOICE_DET_STATE_VAD_START) {
@@ -138,8 +133,7 @@ static void voice_detector_wakeup_system(int state, void *param)
   // APP_VD_LOG("cpu freq=%d", hal_sys_timer_calc_cpu_freq(5,0));
 }
 
-static void voice_not_detector_wakeup_system(int state, void *param)
+static void voice_not_detector_wakeup_system(int state, void *param) {
-{
   enum voice_detector_id id = VOICE_DETECTOR_ID_0;
 
   if (voice_detector_query_status(id) == VOICE_DET_STATE_VAD_START) {
@@ -150,8 +144,7 @@ static void voice_not_detector_wakeup_system(int state, void *param)
   // APP_VD_LOG("cpu freq=%d", hal_sys_timer_calc_cpu_freq(5,0));
 }
 
-void app_voice_detector_init(void)
+void app_voice_detector_init(void) {
-{
   APP_VD_LOG("%s", __func__);
 
   if (vd_mutex_id == NULL) {
@@ -160,8 +153,8 @@ void app_voice_detector_init(void)
   }
 }
 
-int app_voice_detector_open(enum voice_detector_id id, enum AUD_VAD_TYPE_T vad_type)
+int app_voice_detector_open(enum voice_detector_id id,
-{
+                            enum AUD_VAD_TYPE_T vad_type) {
   int r;
 
   APP_VD_LOG("%s", __func__);
@@ -183,8 +176,7 @@ int app_voice_detector_open(enum voice_detector_id id, enum AUD_VAD_TYPE_T vad_t
 }
 
 int app_voice_detector_setup_vad(enum voice_detector_id id,
-                                struct AUD_VAD_CONFIG_T *conf)
+                                 struct AUD_VAD_CONFIG_T *conf) {
-{
   int r;
 
   APP_VD_LOG("%s", __func__);
@@ -201,8 +193,7 @@ int app_voice_detector_setup_vad(enum voice_detector_id id,
 
 int app_voice_detector_setup_stream(enum voice_detector_id id,
                                     enum AUD_STREAM_T stream_id,
-                                    struct AF_STREAM_CONFIG_T *stream)
+                                    struct AF_STREAM_CONFIG_T *stream) {
-{
   int r;
 
   APP_VD_LOG("%s", __func__);
@@ -219,9 +210,7 @@ int app_voice_detector_setup_stream(enum voice_detector_id id,
 
 int app_voice_detector_setup_callback(enum voice_detector_id id,
                                       enum voice_detector_cb_id func_id,
-                                      voice_detector_cb_t func,
+                                      voice_detector_cb_t func, void *param) {
-                                      void *param)
-{
   int r;
 
   APP_VD_LOG("%s", __func__);
@@ -237,31 +226,26 @@ int app_voice_detector_setup_callback(enum voice_detector_id id,
 }
 
 int app_voice_detector_send_event(enum voice_detector_id id,
-                                enum voice_detector_evt evt)
+                                  enum voice_detector_evt evt) {
-{
   APP_VD_LOG("%s, id=%d, evt=%d", __func__, id, evt);
 
   voice_detector_send_msg(id, evt);
   return 0;
 }
 
-void app_voice_detector_close(enum voice_detector_id id)
+void app_voice_detector_close(enum voice_detector_id id) {
-{
   APP_VD_LOG("%s", __func__);
 
   voice_detector_send_msg(id, VOICE_DET_EVT_CLOSE);
 }
 
-void app_voice_detector_capture_start(enum voice_detector_id id)
+void app_voice_detector_capture_start(enum voice_detector_id id) {
-{
   APP_VD_LOG("%s", __func__);
 
   voice_detector_send_msg(id, VOICE_DET_EVT_AUD_CAP_START);
 }
 
-void app_voice_detector_get_vad_data_info(enum voice_detector_id id,
+void app_voice_detector_get_vad_data_info(
-                              struct CODEC_VAD_BUF_INFO_T* vad_buf_info)
+    enum voice_detector_id id, struct CODEC_VAD_BUF_INFO_T *vad_buf_info) {
-{
   voice_detector_get_vad_data_info(id, vad_buf_info);
 }
-

apps/voice_detector/voice_detector.c

@@ -1,16 +1,16 @@
-#include "hal_trace.h"
-#include "hal_cmu.h"
-#include "hal_aud.h"
-#include "hal_timer.h"
-#include "hal_sleep.h"
 #include "analog.h"
 #include "audioflinger.h"
+#include "hal_aud.h"
+#include "hal_cmu.h"
+#include "hal_sleep.h"
+#include "hal_timer.h"
+#include "hal_trace.h"
 //#include "app_audio.h"
 #include "app_utils.h"
-#include "voice_detector.h"
-#include <string.h>
 #include "audio_dump.h"
 #include "speech_ssat.h"
+#include "voice_detector.h"
+#include <string.h>
 
 #include "pmu.h"
 #ifdef __CYBERON
@@ -27,13 +27,17 @@
 #ifdef VD_DEBUG
 #define VD_LOG TRACE
 #else
-#define VD_LOG(...) do{}while(0)
+#define VD_LOG(...)                                                            \
+  do {                                                                         \
+  } while (0)
 #endif
 
 #ifdef VD_TEST
 #define VD_TRACE TRACE
 #else
-#define VD_TRACE(...) do{}while(0)
+#define VD_TRACE(...)                                                          \
+  do {                                                                         \
+  } while (0)
 #endif
 
 #define CMD_QUEUE_DATA_SIZE 15
@@ -82,8 +86,7 @@ static void voice_detector_exec_callback(struct voice_detector_dev *pdev,
 
 #define to_voice_dev(id) (&voice_det_devs[(id)])
 
-static int cmd_queue_enqueue(struct command_queue *q, int c)
+static int cmd_queue_enqueue(struct command_queue *q, int c) {
-{
   if (q->idx >= CMD_QUEUE_DATA_SIZE) {
     VD_LOG(2, "%s, overflow cmd=%d", __func__, c);
     return -2;
@@ -96,8 +99,7 @@ static int cmd_queue_enqueue(struct command_queue *q, int c)
   return 0;
 }
 
-static int cmd_queue_dequeue(struct command_queue *q)
+static int cmd_queue_dequeue(struct command_queue *q) {
-{
   int cmd;
 
   if (q->idx < 0) {
@@ -116,21 +118,19 @@ static int cmd_queue_dequeue(struct command_queue *q)
   return cmd;
 }
 
-static int cmd_queue_is_empty(struct command_queue *q)
+static int cmd_queue_is_empty(struct command_queue *q) {
-{
   return (q->idx < 0) ? 1 : 0;
 }
 
-static void voice_detector_init_cmd_queue(struct command_queue *q)
+static void voice_detector_init_cmd_queue(struct command_queue *q) {
-{
   if (q) {
     q->idx = -1;
     q->out = -1;
   }
 }
 
-static void voice_detector_init_vad(struct AUD_VAD_CONFIG_T *c, int id, enum AUD_VAD_TYPE_T vad_type)
+static void voice_detector_init_vad(struct AUD_VAD_CONFIG_T *c, int id,
-{
+                                    enum AUD_VAD_TYPE_T vad_type) {
   if (c) {
     c->type = vad_type;
 #ifdef VAD_USE_8K_SAMPLE_RATE
@@ -164,8 +164,8 @@ static void voice_detector_init_vad(struct AUD_VAD_CONFIG_T *c, int id, enum AUD
   }
 }
 
-int voice_detector_open(enum voice_detector_id id, enum AUD_VAD_TYPE_T vad_type)
+int voice_detector_open(enum voice_detector_id id,
-{
+                        enum AUD_VAD_TYPE_T vad_type) {
   struct voice_detector_dev *pdev;
 
   if (id >= VOICE_DETECTOR_QTY) {
@@ -196,8 +196,7 @@ int voice_detector_open(enum voice_detector_id id, enum AUD_VAD_TYPE_T vad_type)
   return 0;
 }
 
-void voice_detector_close(enum voice_detector_id id)
+void voice_detector_close(enum voice_detector_id id) {
-{
   struct voice_detector_dev *pdev;
 
   if (id >= VOICE_DETECTOR_QTY) {
@@ -215,8 +214,7 @@ void voice_detector_close(enum voice_detector_id id)
 }
 
 int voice_detector_setup_vad(enum voice_detector_id id,
-        struct AUD_VAD_CONFIG_T *conf)
+                             struct AUD_VAD_CONFIG_T *conf) {
-{
   struct voice_detector_dev *pdev;
 
   if (id >= VOICE_DETECTOR_QTY) {
@@ -239,8 +237,8 @@ int voice_detector_setup_vad(enum voice_detector_id id,
 }
 
 int voice_detector_setup_stream(enum voice_detector_id id,
-        enum AUD_STREAM_T stream_id, struct AF_STREAM_CONFIG_T *stream)
+                                enum AUD_STREAM_T stream_id,
-{
+                                struct AF_STREAM_CONFIG_T *stream) {
   struct voice_detector_dev *pdev;
 
   if (id >= VOICE_DETECTOR_QTY) {
@@ -263,8 +261,8 @@ int voice_detector_setup_stream(enum voice_detector_id id,
 }
 
 int voice_detector_setup_callback(enum voice_detector_id id,
-        enum voice_detector_cb_id func_id, voice_detector_cb_t func, void *param)
+                                  enum voice_detector_cb_id func_id,
-{
+                                  voice_detector_cb_t func, void *param) {
   struct voice_detector_dev *pdev;
 
   if (id >= VOICE_DETECTOR_QTY) {
@@ -287,8 +285,8 @@ int voice_detector_setup_callback(enum voice_detector_id id,
   return 0;
 }
 
-int voice_detector_send_cmd(enum voice_detector_id id, enum voice_detector_cmd cmd)
+int voice_detector_send_cmd(enum voice_detector_id id,
-{
+                            enum voice_detector_cmd cmd) {
   int r;
   struct voice_detector_dev *pdev;
 
@@ -302,8 +300,8 @@ int voice_detector_send_cmd(enum voice_detector_id id, enum voice_detector_cmd c
   return r;
 }
 
-int voice_detector_send_cmd_array(enum voice_detector_id id, int *cmd_array, int num)
+int voice_detector_send_cmd_array(enum voice_detector_id id, int *cmd_array,
-{
+                                  int num) {
   int r, i;
   struct voice_detector_dev *pdev;
 
@@ -321,8 +319,8 @@ int voice_detector_send_cmd_array(enum voice_detector_id id, int *cmd_array, int
   return 0;
 }
 
-enum voice_detector_state voice_detector_query_status(enum voice_detector_id id)
+enum voice_detector_state
-{
+voice_detector_query_status(enum voice_detector_id id) {
   struct voice_detector_dev *pdev;
 
   if (id >= VOICE_DETECTOR_QTY) {
@@ -334,8 +332,7 @@ enum voice_detector_state voice_detector_query_status(enum voice_detector_id id)
   return pdev->state;
 }
 
-static void voice_detector_vad_callback(int found)
+static void voice_detector_vad_callback(int found) {
-{
   struct voice_detector_dev *pdev;
   enum voice_detector_id id = VOICE_DETECTOR_ID_0;
 
@@ -343,8 +340,8 @@ static void voice_detector_vad_callback(int found)
 
   pdev->wakeup_cnt++;
 
-    VD_LOG(3, "%s, voice detector[%d], wakeup_cnt=%d",
+  VD_LOG(3, "%s, voice detector[%d], wakeup_cnt=%d", __func__, id,
-            __func__, id, pdev->wakeup_cnt);
+         pdev->wakeup_cnt);
 
   if (pdev->wakeup_cnt == 1) {
     /*
@@ -352,12 +349,12 @@ static void voice_detector_vad_callback(int found)
      * after CPU is waked up from sleeping.
      * The VAD already can gernerates interrupts at this monment or later.
      */
-        voice_detector_exec_callback(pdev, found ? VOICE_DET_FIND_APP : VOICE_DET_NOT_FIND_APP);
+    voice_detector_exec_callback(pdev, found ? VOICE_DET_FIND_APP
+                                             : VOICE_DET_NOT_FIND_APP);
   }
 }
 
-static int voice_detector_vad_open(struct voice_detector_dev *pdev)
+static int voice_detector_vad_open(struct voice_detector_dev *pdev) {
-{
   struct AUD_VAD_CONFIG_T *c = &pdev->conf;
 
   if (pdev->dfl) {
@@ -370,8 +367,7 @@ static int voice_detector_vad_open(struct voice_detector_dev *pdev)
   return 0;
 }
 
-static int voice_detector_vad_start(struct voice_detector_dev *pdev)
+static int voice_detector_vad_start(struct voice_detector_dev *pdev) {
-{
   /* wakeup_cnt is cleared while VAD starts */
   pdev->wakeup_cnt = 0;
   af_vad_start();
@@ -381,8 +377,7 @@ static int voice_detector_vad_start(struct voice_detector_dev *pdev)
   return 0;
 }
 
-static int voice_detector_vad_stop(struct voice_detector_dev *pdev)
+static int voice_detector_vad_stop(struct voice_detector_dev *pdev) {
-{
   af_vad_stop();
 
 #ifdef I2C_VAD
@@ -390,7 +385,8 @@ static int voice_detector_vad_stop(struct voice_detector_dev *pdev)
 #else
   /* get vad buf info after stopping it */
   af_vad_get_data_info(&(pdev->vad_buf_info));
-    TRACE(4,"vad_buf base_addr:0x%x, buf_size:0x%x, data_count:%d, addr_count:%d", 
+  TRACE(4,
+        "vad_buf base_addr:0x%x, buf_size:0x%x, data_count:%d, addr_count:%d",
         pdev->vad_buf_info.base_addr, pdev->vad_buf_info.buf_size,
         pdev->vad_buf_info.data_count, pdev->vad_buf_info.addr_count);
 #if defined(CHIP_BEST2300)
@@ -402,9 +398,8 @@ static int voice_detector_vad_stop(struct voice_detector_dev *pdev)
   return 0;
 }
 
-void voice_detector_get_vad_data_info(enum voice_detector_id id, 
+void voice_detector_get_vad_data_info(
-	                                                                   struct CODEC_VAD_BUF_INFO_T* vad_buf_info)
+    enum voice_detector_id id, struct CODEC_VAD_BUF_INFO_T *vad_buf_info) {
-{
 
   struct voice_detector_dev *pdev;
 
@@ -414,11 +409,9 @@ void voice_detector_get_vad_data_info(enum voice_detector_id id,
   vad_buf_info->buf_size = pdev->vad_buf_info.buf_size;
   vad_buf_info->data_count = pdev->vad_buf_info.data_count;
   vad_buf_info->addr_count = pdev->vad_buf_info.addr_count;
-
 }
 
-static int voice_detector_vad_close(struct voice_detector_dev *pdev)
+static int voice_detector_vad_close(struct voice_detector_dev *pdev) {
-{
 #ifdef I2C_VAD
   vad_sensor_close();
 #endif
@@ -426,8 +419,7 @@ static int voice_detector_vad_close(struct voice_detector_dev *pdev)
   return 0;
 }
 
-static int voice_detector_aud_cap_open(struct voice_detector_dev *pdev)
+static int voice_detector_aud_cap_open(struct voice_detector_dev *pdev) {
-{
   struct AF_STREAM_CONFIG_T *conf = &pdev->cap_conf;
 
   if ((!conf->handler) || (!conf->data_ptr)) {
@@ -438,43 +430,40 @@ static int voice_detector_aud_cap_open(struct voice_detector_dev *pdev)
   return 0;
 }
 
-static int voice_detector_aud_cap_start(struct voice_detector_dev *pdev)
+static int voice_detector_aud_cap_start(struct voice_detector_dev *pdev) {
-{
   af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
   return 0;
 }
 
-static int voice_detector_aud_cap_stop(struct voice_detector_dev *pdev)
+static int voice_detector_aud_cap_stop(struct voice_detector_dev *pdev) {
-{
   af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
   return 0;
 }
 
-static int voice_detector_aud_cap_close(struct voice_detector_dev *pdev)
+static int voice_detector_aud_cap_close(struct voice_detector_dev *pdev) {
-{
   af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
   return 0;
 }
 
-static int voice_detector_sys_clk(struct voice_detector_dev *pdev)
+static int voice_detector_sys_clk(struct voice_detector_dev *pdev) {
-{
 #ifdef VD_TEST
-    app_sysfreq_req(APP_SYSFREQ_USER_APP_0, (enum APP_SYSFREQ_FREQ_T)(pdev->sys_clk));
+  app_sysfreq_req(APP_SYSFREQ_USER_APP_0,
+                  (enum APP_SYSFREQ_FREQ_T)(pdev->sys_clk));
 #else
-    app_sysfreq_req(APP_SYSFREQ_USER_AI_VOICE, (enum APP_SYSFREQ_FREQ_T)(pdev->sys_clk));
+  app_sysfreq_req(APP_SYSFREQ_USER_AI_VOICE,
+                  (enum APP_SYSFREQ_FREQ_T)(pdev->sys_clk));
 #endif
-//    VD_TRACE(2,"%s, cpu freq=%d", __func__, hal_sys_timer_calc_cpu_freq(5,0));
+  //    VD_TRACE(2,"%s, cpu freq=%d", __func__,
+  //    hal_sys_timer_calc_cpu_freq(5,0));
   return 0;
 }
 
-static int voice_detector_exit(struct voice_detector_dev *pdev)
+static int voice_detector_exit(struct voice_detector_dev *pdev) {
-{
   // TODO: exit process
   return 0;
 }
 
-static int voice_detector_idle(struct voice_detector_dev *pdev)
+static int voice_detector_idle(struct voice_detector_dev *pdev) {
-{
   // TODO: idle process
   return 0;
 }
@@ -502,8 +491,8 @@ static struct cmd_vector cmd_vectors[] = {
     {"clk104m", VOICE_DET_CMD_SYS_CLK_104M, voice_detector_sys_clk},
 };
 
-static int voice_detector_process_cmd(struct voice_detector_dev *pdev, int cmd)
+static int voice_detector_process_cmd(struct voice_detector_dev *pdev,
-{
+                                      int cmd) {
   int err;
 
   VD_LOG(3, "%s, cmd[%d]: %s", __func__, cmd, cmd_vectors[(int)cmd].name);
@@ -528,12 +517,12 @@ static int voice_detector_process_cmd(struct voice_detector_dev *pdev, int cmd)
   return err;
 }
 
-static void voice_detector_set_status(struct voice_detector_dev *pdev, enum voice_detector_state s)
+static void voice_detector_set_status(struct voice_detector_dev *pdev,
-{
+                                      enum voice_detector_state s) {
-    if ((s == VOICE_DET_STATE_SYS_CLK_104M)
+  if ((s == VOICE_DET_STATE_SYS_CLK_104M) ||
-            || (s == VOICE_DET_STATE_SYS_CLK_52M)
+      (s == VOICE_DET_STATE_SYS_CLK_52M) ||
-            || (s == VOICE_DET_STATE_SYS_CLK_26M)
+      (s == VOICE_DET_STATE_SYS_CLK_26M) ||
-            || (s == VOICE_DET_STATE_SYS_CLK_32K)) {
+      (s == VOICE_DET_STATE_SYS_CLK_32K)) {
     return;
   }
   pdev->state = s;
@@ -541,8 +530,7 @@ static void voice_detector_set_status(struct voice_detector_dev *pdev, enum voic
 }
 
 static void voice_detector_exec_callback(struct voice_detector_dev *pdev,
-                enum voice_detector_cb_id id)
+                                         enum voice_detector_cb_id id) {
-{
   voice_detector_cb_t func;
 
   func = pdev->callback[id];
@@ -553,8 +541,7 @@ static void voice_detector_exec_callback(struct voice_detector_dev *pdev,
   }
 }
 
-int voice_detector_enhance_perform(enum voice_detector_id id)
+int voice_detector_enhance_perform(enum voice_detector_id id) {
-{
   struct voice_detector_dev *pdev = to_voice_dev(id);
 
   pdev->sys_clk = APP_SYSFREQ_26M;
@@ -563,8 +550,7 @@ int voice_detector_enhance_perform(enum voice_detector_id id)
                          (enum APP_SYSFREQ_FREQ_T)(pdev->sys_clk));
 }
 
-int voice_detector_run(enum voice_detector_id id, int continous)
+int voice_detector_run(enum voice_detector_id id, int continous) {
-{
   int exit = 0;
   int exit_code = 0;
   struct voice_detector_dev *pdev;
@@ -642,24 +628,17 @@ static uint32_t buff_capture[AUDIO_CAP_BUFF_SIZE/4];
 static uint32_t voice_det_evt = 0;
 static uint8_t vad_data_buf[8 * 1024];
 
-static void voice_detector_send_evt(uint32_t evt)
+static void voice_detector_send_evt(uint32_t evt) { voice_det_evt = evt; }
-{
-    voice_det_evt = evt;
-}
 
-static void print_vad_raw_data(uint8_t *buf, uint32_t len)
+static void print_vad_raw_data(uint8_t *buf, uint32_t len) {
-{
   VD_TRACE(3, "%s, buf=%x, len=%d", __func__, (uint32_t)buf, len);
   // TODO: print data
 }
 
-
 static int State_M_1 = 0;
-void dc_filter_f(short *in, int len, float left_gain, float right_gain)
+void dc_filter_f(short *in, int len, float left_gain, float right_gain) {
-{
   int tmp1;
-	for (int i = 0; i<len; i+=1)
+  for (int i = 0; i < len; i += 1) {
-	{
     State_M_1 = (15 * State_M_1 + in[i]) >> 4;
     tmp1 = in[i];
     tmp1 -= State_M_1;
@@ -667,9 +646,7 @@ void dc_filter_f(short *in, int len, float left_gain, float right_gain)
   }
 }
 
-
+static uint32_t mic_data_come(uint8_t *buf, uint32_t len) {
-static uint32_t mic_data_come(uint8_t *buf, uint32_t len)
-{
   static int come_cnt = 0;
   short *p16data = (short *)buf;
   uint32_t sample_len = len / 2;
@@ -695,7 +672,6 @@ static uint32_t mic_data_come(uint8_t *buf, uint32_t len)
     TRACE(1, "CSpotter_GetResultScore return Score: %d", score);
 
     CSpotter_Reset(h_CSpotter);
-
   }
 #endif
 
@@ -716,8 +692,7 @@ static uint32_t mic_data_come(uint8_t *buf, uint32_t len)
 }
 
 #ifdef __CYBERON
-static int CSpotter_Init_bes()
+static int CSpotter_Init_bes() {
-{
 #define TIMES (1000)
   int err;
   int state_size, mem_size;
@@ -737,7 +712,8 @@ static int CSpotter_Init_bes()
     goto fail;
   }
 
-    mem_size = CSpotter_GetMemoryUsage_Sep((BYTE*)BASE_MODEL_DATA, (BYTE*)COMMAND_MODEL_DATA, TIMES);
+  mem_size = CSpotter_GetMemoryUsage_Sep((BYTE *)BASE_MODEL_DATA,
+                                         (BYTE *)COMMAND_MODEL_DATA, TIMES);
   TRACE(1, "mem_size=%d", mem_size);
 
   mem_pool = p_combuf + cyb_buf_used;
@@ -748,8 +724,9 @@ static int CSpotter_Init_bes()
     goto fail;
   }
 
-    h_CSpotter = CSpotter_Init_Sep((BYTE*)BASE_MODEL_DATA, (BYTE*)COMMAND_MODEL_DATA,
+  h_CSpotter = CSpotter_Init_Sep((BYTE *)BASE_MODEL_DATA,
-            TIMES, mem_pool, mem_size, state_buffer, state_size, &err);
+                                 (BYTE *)COMMAND_MODEL_DATA, TIMES, mem_pool,
+                                 mem_size, state_buffer, state_size, &err);
   if (!h_CSpotter) {
     TRACE(1, "CSpotter Init fail! err : %d\n", err);
     err = -3;
@@ -763,8 +740,7 @@ fail:
 }
 #endif
 
-static void cmd_wait_handler(int state, void *param)
+static void cmd_wait_handler(int state, void *param) {
-{
   voice_detector_send_evt(VOICE_DET_EVT_IDLE);
 
   VD_TRACE(2, "%s, state=%d", __func__, state);
@@ -774,33 +750,31 @@ static void cmd_wait_handler(int state, void *param)
   //    hal_sleep_enter_sleep();
 }
 
-static void cmd_done_handler(int state, void *param)
+static void cmd_done_handler(int state, void *param) {
-{
   VD_TRACE(2, "%s, state=%d", __func__, state);
 }
 
-static void cpu_det_find_wakeup_handler(int state, void *param)
+static void cpu_det_find_wakeup_handler(int state, void *param) {
-{
   static uint32_t cpu_wakeup_cnt = 0;
 
   cpu_wakeup_cnt++;
   VD_TRACE(3, "%s, state=%d, cnt=%d", __func__, state, cpu_wakeup_cnt);
-    //VD_TRACE(2,"%s, calc sys freq=%d", __func__, hal_sys_timer_calc_cpu_freq(5,0));
+  // VD_TRACE(2,"%s, calc sys freq=%d", __func__,
+  // hal_sys_timer_calc_cpu_freq(5,0));
 
   voice_detector_send_evt(VOICE_DET_EVT_AUD_CAP_START);
 }
 
-static void cpu_det_notfind_wakeup_handler(int state, void *param)
+static void cpu_det_notfind_wakeup_handler(int state, void *param) {
-{
 
   VD_TRACE(2, "%s, state=%d", __func__, state);
-    //VD_TRACE(2,"%s, calc sys freq=%d", __func__, hal_sys_timer_calc_cpu_freq(5,0));
+  // VD_TRACE(2,"%s, calc sys freq=%d", __func__,
+  // hal_sys_timer_calc_cpu_freq(5,0));
 
   voice_detector_send_evt(VOICE_DET_EVT_VAD_START);
 }
 
-void voice_detector_test(void)
+void voice_detector_test(void) {
-{
   enum voice_detector_id id = VOICE_DETECTOR_ID_0;
   int r, run;
   struct AF_STREAM_CONFIG_T stream_cfg;
@@ -836,12 +810,17 @@ void voice_detector_test(void)
   }
 
   voice_detector_setup_stream(id, AUD_STREAM_CAPTURE, &stream_cfg);
-    voice_detector_setup_callback(id, VOICE_DET_CB_RUN_WAIT, cmd_wait_handler, NULL);
+  voice_detector_setup_callback(id, VOICE_DET_CB_RUN_WAIT, cmd_wait_handler,
-    voice_detector_setup_callback(id, VOICE_DET_CB_RUN_DONE, cmd_done_handler, NULL);
+                                NULL);
-    voice_detector_setup_callback(id, VOICE_DET_FIND_APP, cpu_det_find_wakeup_handler, NULL);
+  voice_detector_setup_callback(id, VOICE_DET_CB_RUN_DONE, cmd_done_handler,
-    voice_detector_setup_callback(id, VOICE_DET_NOT_FIND_APP, cpu_det_notfind_wakeup_handler, NULL);
+                                NULL);
+  voice_detector_setup_callback(id, VOICE_DET_FIND_APP,
+                                cpu_det_find_wakeup_handler, NULL);
+  voice_detector_setup_callback(id, VOICE_DET_NOT_FIND_APP,
+                                cpu_det_notfind_wakeup_handler, NULL);
 
-    VD_TRACE(2,"%s, calc sys freq=%d", __func__, hal_sys_timer_calc_cpu_freq(5,0));
+  VD_TRACE(2, "%s, calc sys freq=%d", __func__,
+           hal_sys_timer_calc_cpu_freq(5, 0));
 
   voice_detector_send_cmd(id, VOICE_DET_CMD_AUD_CAP_OPEN);
   voice_detector_send_cmd(id, VOICE_DET_CMD_AUD_CAP_CLOSE);
@@ -894,8 +873,8 @@ void voice_detector_test(void)
       VD_TRACE(0, "wake up from deep sleep");
     }
 
-        len = voice_detector_recv_vad_data(VOICE_DETECTOR_ID_0,
+    len = voice_detector_recv_vad_data(VOICE_DETECTOR_ID_0, vad_data_buf,
-                vad_data_buf, sizeof(vad_data_buf));
+                                       sizeof(vad_data_buf));
     if (len) {
       print_vad_raw_data(vad_data_buf, len);
     }

config/_default_cfg_src_/app_status_ind.c

@@ -13,18 +13,18 @@
  * trademark and other intellectual property rights.
  *
  ****************************************************************************/
-#include "cmsis_os.h"
-#include "stdbool.h"
-#include "hal_trace.h"
-#include "app_pwl.h"
 #include "app_status_ind.h"
+#include "app_pwl.h"
+#include "cmsis_os.h"
+#include "hal_trace.h"
+#include "stdbool.h"
 #include "string.h"
 
 static APP_STATUS_INDICATION_T app_status = APP_STATUS_INDICATION_NUM;
-static APP_STATUS_INDICATION_T app_status_ind_filter = APP_STATUS_INDICATION_NUM;
+static APP_STATUS_INDICATION_T app_status_ind_filter =
+    APP_STATUS_INDICATION_NUM;
 
-const char *app_status_indication_str[] =
+const char *app_status_indication_str[] = {
-{
     "[POWERON]",
     "[INITIAL]",
     "[PAGESCAN]",
@@ -64,36 +64,26 @@ const char *app_status_indication_str[] =
     "[TILE_FIND]",
 };
 
-
+const char *status2str(uint16_t status) {
-const char *status2str(uint16_t status)
-{
   const char *str = NULL;
 
-    if (status >= 0 && status < APP_STATUS_INDICATION_NUM)
+  if (status >= 0 && status < APP_STATUS_INDICATION_NUM) {
-    {
     str = app_status_indication_str[status];
-    }
+  } else {
-    else
-    {
     str = "[UNKNOWN]";
   }
 
   return str;
 }
 
-int app_status_indication_filter_set(APP_STATUS_INDICATION_T status)
+int app_status_indication_filter_set(APP_STATUS_INDICATION_T status) {
-{
   app_status_ind_filter = status;
   return 0;
 }
 
-APP_STATUS_INDICATION_T app_status_indication_get(void)
+APP_STATUS_INDICATION_T app_status_indication_get(void) { return app_status; }
-{
-    return app_status;
-}
 
-int app_status_indication_set(APP_STATUS_INDICATION_T status)
+int app_status_indication_set(APP_STATUS_INDICATION_T status) {
-{
   struct APP_PWL_CFG_T cfg0;
   struct APP_PWL_CFG_T cfg1;
 

config/_default_cfg_src_/tgt_hardware.c

@@ -15,19 +15,16 @@
  ****************************************************************************/
 #include "tgt_hardware.h"
 
-const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_pinmux_pwl[CFG_HW_PLW_NUM] = {
+const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_pinmux_pwl[CFG_HW_PLW_NUM] = {};
-};
 
 // adckey define
 const uint16_t CFG_HW_ADCKEY_MAP_TABLE[CFG_HW_ADCKEY_NUMBER] = {
     HAL_KEY_CODE_FN9, HAL_KEY_CODE_FN8, HAL_KEY_CODE_FN7,
     HAL_KEY_CODE_FN6, HAL_KEY_CODE_FN5, HAL_KEY_CODE_FN4,
-    HAL_KEY_CODE_FN3,HAL_KEY_CODE_FN2,HAL_KEY_CODE_FN1
+    HAL_KEY_CODE_FN3, HAL_KEY_CODE_FN2, HAL_KEY_CODE_FN1};
-};
 
 // gpiokey define
-const struct HAL_KEY_GPIOKEY_CFG_T cfg_hw_gpio_key_cfg[CFG_HW_GPIOKEY_NUM] = {
+const struct HAL_KEY_GPIOKEY_CFG_T cfg_hw_gpio_key_cfg[CFG_HW_GPIOKEY_NUM] = {};
-};
 
 // bt config
 const char *BT_LOCAL_NAME = TO_STRING(BT_DEV_NAME) "\0";
@@ -37,63 +34,69 @@ uint8_t ble_addr[6] = {
 #ifdef BLE_DEV_ADDR
     BLE_DEV_ADDR
 #else
-	0xBE,0x99,0x34,0x45,0x56,0x67
+    0xBE, 0x99, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 uint8_t bt_addr[6] = {
 #ifdef BT_DEV_ADDR
     BT_DEV_ADDR
 #else
-	0x1e,0x57,0x34,0x45,0x56,0x67
+    0x1e, 0x57, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 
 // audio config
-//freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K], [12.5K:15K], [15K:17.5K], [17.5K:20K]}
+// freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K],
-//gain range -12~+12
+// [12.5K:15K], [15K:17.5K], [17.5K:20K]} gain range -12~+12
-const int8_t cfg_hw_aud_eq_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {0, 0, 0, 0, 0, 0, 0, 0};
+const int8_t cfg_hw_aud_eq_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {
+    0, 0, 0, 0, 0, 0, 0, 0};
 
 #define TX_PA_GAIN CODEC_TX_PA_GAIN_DEFAULT
 
 const struct CODEC_DAC_VOL_T codec_dac_vol[TGT_VOLUME_LEVEL_QTY] = {
-    {TX_PA_GAIN,0x03,-11},
+    {TX_PA_GAIN, 0x03, -11}, {TX_PA_GAIN, 0x03, -99},
-    {TX_PA_GAIN,0x03,-99},
+    {TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
-    {TX_PA_GAIN,0x03,-45},
+    {TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
-    {TX_PA_GAIN,0x03,-42},
+    {TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
-    {TX_PA_GAIN,0x03,-39},
+    {TX_PA_GAIN, 0x03, -27}, {TX_PA_GAIN, 0x03, -24},
-    {TX_PA_GAIN,0x03,-36},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -18},
-    {TX_PA_GAIN,0x03,-33},
+    {TX_PA_GAIN, 0x03, -15}, {TX_PA_GAIN, 0x03, -12},
-    {TX_PA_GAIN,0x03,-30},
+    {TX_PA_GAIN, 0x03, -9},  {TX_PA_GAIN, 0x03, -6},
-    {TX_PA_GAIN,0x03,-27},
+    {TX_PA_GAIN, 0x03, -3},  {TX_PA_GAIN, 0x03, 0}, // 0dBm
-    {TX_PA_GAIN,0x03,-24},
-    {TX_PA_GAIN,0x03,-21},
-    {TX_PA_GAIN,0x03,-18},
-    {TX_PA_GAIN,0x03,-15},
-    {TX_PA_GAIN,0x03,-12},
-    {TX_PA_GAIN,0x03, -9},
-    {TX_PA_GAIN,0x03, -6},
-    {TX_PA_GAIN,0x03, -3},
-    {TX_PA_GAIN,0x03,  0},  //0dBm
 };
 
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
-#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV    (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
+  (AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
-#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV                                       \
-const struct AUD_IO_PATH_CFG_T cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV, },
+#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV                                       \
-    { AUD_INPUT_PATH_LINEIN,  CFG_HW_AUD_INPUT_PATH_LINEIN_DEV, },
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
-    { AUD_INPUT_PATH_VADMIC,  CFG_HW_AUD_INPUT_PATH_VADMIC_DEV, },
+const struct AUD_IO_PATH_CFG_T
+    cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV,
+        },
+        {
+            AUD_INPUT_PATH_LINEIN,
+            CFG_HW_AUD_INPUT_PATH_LINEIN_DEV,
+        },
+        {
+            AUD_INPUT_PATH_VADMIC,
+            CFG_HW_AUD_INPUT_PATH_VADMIC_DEV,
+        },
 };
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_enable_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_detecter_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
-
-const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
-};
 
+const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg =
+    {HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE};

config/bak_open/tgt_hardware.c

@@ -14,31 +14,38 @@
  *
  ****************************************************************************/
 #include "tgt_hardware.h"
-#include "iir_process.h"
-#include "fir_process.h"
 #include "drc.h"
+#include "fir_process.h"
+#include "iir_process.h"
 #include "limiter.h"
 #include "spectrum_fix.h"
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_pinmux_pwl[CFG_HW_PLW_NUM] = {
 #if (CFG_HW_PLW_NUM > 0)
-    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 #endif
 };
 
 #ifdef __APP_USE_LED_INDICATE_IBRT_STATUS__
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_ibrt_indication_pinmux_pwl[3] = {
-    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
-    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 };
 #endif
 
 #ifdef __KNOWLES
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_pinmux_uart[2] = {
-    {HAL_IOMUX_PIN_P2_2, HAL_IOMUX_FUNC_UART2_RX, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+    {HAL_IOMUX_PIN_P2_2, HAL_IOMUX_FUNC_UART2_RX, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_P2_3, HAL_IOMUX_FUNC_UART2_TX,  HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+     HAL_IOMUX_PIN_NOPULL},
+    {HAL_IOMUX_PIN_P2_3, HAL_IOMUX_FUNC_UART2_TX, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_NOPULL},
 };
 #endif
 
@@ -58,30 +65,40 @@ const struct HAL_KEY_GPIOKEY_CFG_T cfg_hw_gpio_key_cfg[CFG_HW_GPIOKEY_NUM] = {
     /*
     #if (CFG_HW_GPIOKEY_NUM > 0)
     #ifdef BES_AUDIO_DEV_Main_Board_9v0
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    //{HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO,
-   // {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-#else
+        {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO,
-#ifndef TPORTS_KEY_COEXIST
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        //{HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+       // {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #else #ifndef
-#else
+    TPORTS_KEY_COEXIST {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3,
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_PULLUP_ENABLE}}, {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0,
-#endif
+    HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-#endif
+    HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #else
+        {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #endif #endif
     #ifdef IS_MULTI_AI_ENABLED
-    //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
-    //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-#endif
+        //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
-#endif
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #endif #endif
     */
-	{HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN1,
+     {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
 };
 
 // bt config
@@ -92,147 +109,152 @@ uint8_t ble_addr[6] = {
 #ifdef BLE_DEV_ADDR
     BLE_DEV_ADDR
 #else
-	0xBE,0x99,0x34,0x45,0x56,0x67
+    0xBE, 0x99, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 uint8_t bt_addr[6] = {
 #ifdef BT_DEV_ADDR
     BT_DEV_ADDR
 #else
-	0x1e,0x57,0x34,0x45,0x56,0x67
+    0x1e, 0x57, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 
 // audio config
-//freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K], [12.5K:15K], [15K:17.5K], [17.5K:20K]}
+// freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K],
-//gain range -12~+12
+// [12.5K:15K], [15K:17.5K], [17.5K:20K]} gain range -12~+12
-const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {0, 0, 0, 0, 0, 0, 0, 0};
+const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {
+    0, 0, 0, 0, 0, 0, 0, 0};
 
 #define TX_PA_GAIN CODEC_TX_PA_GAIN_DEFAULT
 
 const struct CODEC_DAC_VOL_T codec_dac_vol[TGT_VOLUME_LEVEL_QTY] = {
-    {TX_PA_GAIN,0x03,-21},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -99},
-    {TX_PA_GAIN,0x03,-99},
+    {TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
-    {TX_PA_GAIN,0x03,-45},
+    {TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
-    {TX_PA_GAIN,0x03,-42},
+    {TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
-    {TX_PA_GAIN,0x03,-39},
+    {TX_PA_GAIN, 0x03, -27}, {TX_PA_GAIN, 0x03, -24},
-    {TX_PA_GAIN,0x03,-36},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -18},
-    {TX_PA_GAIN,0x03,-33},
+    {TX_PA_GAIN, 0x03, -15}, {TX_PA_GAIN, 0x03, -12},
-    {TX_PA_GAIN,0x03,-30},
+    {TX_PA_GAIN, 0x03, -9},  {TX_PA_GAIN, 0x03, -6},
-    {TX_PA_GAIN,0x03,-27},
+    {TX_PA_GAIN, 0x03, -3},  {TX_PA_GAIN, 0x03, 0}, // 0dBm
-    {TX_PA_GAIN,0x03,-24},
-    {TX_PA_GAIN,0x03,-21},
-    {TX_PA_GAIN,0x03,-18},
-    {TX_PA_GAIN,0x03,-15},
-    {TX_PA_GAIN,0x03,-12},
-    {TX_PA_GAIN,0x03, -9},
-    {TX_PA_GAIN,0x03, -6},
-    {TX_PA_GAIN,0x03, -3},
-    {TX_PA_GAIN,0x03,  0},  //0dBm
 };
 
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC2|AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC2 |            \
+   AUD_VMIC_MAP_VMIC3)
 #elif SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 3
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 |           \
+   AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
 #endif
 
-#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV    (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
+#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV                                       \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
 #ifdef VOICE_DETECTOR_EN
-#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
 #endif
 
-const struct AUD_IO_PATH_CFG_T cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
+const struct AUD_IO_PATH_CFG_T
+    cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
 #if defined(SPEECH_TX_AEC_CODEC_REF)
-    // NOTE: If enable Ch5 and CH6, need to add channel_num when setup audioflinger stream
+        // NOTE: If enable Ch5 and CH6, need to add channel_num when setup
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4, },
+        // audioflinger stream
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4,
+        },
 #else
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV, },
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV,
+        },
 #endif
-    { AUD_INPUT_PATH_LINEIN,  CFG_HW_AUD_INPUT_PATH_LINEIN_DEV, },
+        {
+            AUD_INPUT_PATH_LINEIN,
+            CFG_HW_AUD_INPUT_PATH_LINEIN_DEV,
+        },
 #ifdef VOICE_DETECTOR_EN
-    { AUD_INPUT_PATH_VADMIC,  CFG_HW_AUD_INPUT_PATH_VADMIC_DEV, },
+        {
+            AUD_INPUT_PATH_VADMIC,
+            CFG_HW_AUD_INPUT_PATH_VADMIC_DEV,
+        },
 #else
-    { AUD_INPUT_PATH_ASRMIC,  CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV, },
+        {
+            AUD_INPUT_PATH_ASRMIC,
+            CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV,
+        },
 #endif
 };
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_enable_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_detecter_cfg = {
-    HAL_IOMUX_PIN_P1_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P1_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
-
-const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
-};
 
+const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg =
+    {HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 /*
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_INT ={
-	HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+        HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+HAL_IOMUX_PIN_PULLUP_ENABLE
 };
 */
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_I2C_SDA = {
-	HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_I2C_SCL = {
-	HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
-
 
 const IIR_CFG_T audio_eq_sw_iir_cfg = {
     .gain0 = 0,
     .gain1 = 0,
     .num = 5,
-    .param = {
+    .param = {{IIR_TYPE_PEAK, .0, 200, 2},
-        {IIR_TYPE_PEAK, .0,   200,   2},
               {IIR_TYPE_PEAK, .0, 600, 2},
               {IIR_TYPE_PEAK, .0, 2000.0, 2},
               {IIR_TYPE_PEAK, .0, 6000.0, 2},
-        {IIR_TYPE_PEAK, .0,  12000.0, 2}            
+              {IIR_TYPE_PEAK, .0, 12000.0, 2}}};
-    }
-};
 
 const IIR_CFG_T *const audio_eq_sw_iir_cfg_list[EQ_SW_IIR_LIST_NUM] = {
     &audio_eq_sw_iir_cfg,
 };
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
-    .gain = 0.0f,
                                              .len = 384,
-    .coef =
+                                             .coef = {
-    {
                                                  (1 << 23) - 1,
-    }
+                                             }};
-};
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.gain = 0.0f,
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
-
+const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {.gain = 0.0f,
-const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
 const FIR_CFG_T *const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM] = {
     &audio_eq_hw_fir_cfg_44p1k,
@@ -241,8 +263,7 @@ const FIR_CFG_T * const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM]={
 };
 
 // hardware dac iir eq
-const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {
+const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                            .gain1 = 0,
                                            .num = 8,
                                            .param = {
@@ -254,10 +275,10 @@ const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
-    }
+                                           }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM] = {
         &audio_eq_hw_dac_iir_cfg,
 };
 
@@ -268,18 +289,15 @@ const IIR_CFG_T audio_eq_hw_adc_iir_adc_cfg = {
     .num = 1,
     .param = {
         {IIR_TYPE_PEAK, 0.0, 1000.0, 0.7},
-    }
+    }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM] = {
         &audio_eq_hw_adc_iir_adc_cfg,
 };
 
-
-
 // hardware iir eq
-const IIR_CFG_T audio_eq_hw_iir_cfg = {
+const IIR_CFG_T audio_eq_hw_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                        .gain1 = 0,
                                        .num = 8,
                                        .param = {
@@ -292,23 +310,21 @@ const IIR_CFG_T audio_eq_hw_iir_cfg = {
                                            {IIR_TYPE_PEAK, -10.1, 7000.0, 7},
                                            {IIR_TYPE_PEAK, -10.1, 9000.0, 7},
 
-    }
+                                       }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM] = {
         &audio_eq_hw_iir_cfg,
 };
 
-const DrcConfig audio_drc_cfg = {
+const DrcConfig audio_drc_cfg = {.knee = 3,
-     .knee = 3,
                                  .filter_type = {14, -1},
                                  .band_num = 2,
                                  .look_ahead_time = 10,
                                  .band_settings = {
                                      {-20, 0, 2, 3, 3000, 1},
                                      {-20, 0, 2, 3, 3000, 1},
-     }
+                                 }};
- };
 
 const LimiterConfig audio_drc2_cfg = {
     .knee = 2,
@@ -324,4 +340,3 @@ const SpectrumFixConfig audio_spectrum_cfg = {
     .freq_num = 9,
     .freq_list = {200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800},
 };
-

config/best2300p_ibrt/tgt_hardware.c

@@ -14,31 +14,38 @@
  *
  ****************************************************************************/
 #include "tgt_hardware.h"
-#include "iir_process.h"
-#include "fir_process.h"
 #include "drc.h"
+#include "fir_process.h"
+#include "iir_process.h"
 #include "limiter.h"
 #include "spectrum_fix.h"
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_pinmux_pwl[CFG_HW_PLW_NUM] = {
 #if (CFG_HW_PLW_NUM > 0)
-    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 #endif
 };
 
 #ifdef __APP_USE_LED_INDICATE_IBRT_STATUS__
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_ibrt_indication_pinmux_pwl[3] = {
-    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
-    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 };
 #endif
 
 #ifdef __KNOWLES
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_pinmux_uart[2] = {
-    {HAL_IOMUX_PIN_P2_2, HAL_IOMUX_FUNC_UART2_RX, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+    {HAL_IOMUX_PIN_P2_2, HAL_IOMUX_FUNC_UART2_RX, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_P2_3, HAL_IOMUX_FUNC_UART2_TX,  HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+     HAL_IOMUX_PIN_NOPULL},
+    {HAL_IOMUX_PIN_P2_3, HAL_IOMUX_FUNC_UART2_TX, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_NOPULL},
 };
 #endif
 
@@ -58,30 +65,40 @@ const struct HAL_KEY_GPIOKEY_CFG_T cfg_hw_gpio_key_cfg[CFG_HW_GPIOKEY_NUM] = {
     /*
     #if (CFG_HW_GPIOKEY_NUM > 0)
     #ifdef BES_AUDIO_DEV_Main_Board_9v0
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    //{HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO,
-   // {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-#else
+        {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO,
-#ifndef TPORTS_KEY_COEXIST
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        //{HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+       // {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #else #ifndef
-#else
+    TPORTS_KEY_COEXIST {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3,
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_PULLUP_ENABLE}}, {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0,
-#endif
+    HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-#endif
+    HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #else
+        {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #endif #endif
     #ifdef IS_MULTI_AI_ENABLED
-    //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
-    //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-#endif
+        //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
-#endif
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #endif #endif
     */
-	{HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN1,
+     {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
 };
 
 // bt config
@@ -91,107 +108,126 @@ uint8_t ble_addr[6] = {
 #ifdef BLE_DEV_ADDR
     BLE_DEV_ADDR
 #else
-	0xBE,0x99,0x34,0x45,0x56,0x67
+    0xBE, 0x99, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 uint8_t bt_addr[6] = {
 #ifdef BT_DEV_ADDR
     BT_DEV_ADDR
 #else
-	0x1e,0x57,0x34,0x45,0x56,0x67
+    0x1e, 0x57, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 
 // audio config
-//freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K], [12.5K:15K], [15K:17.5K], [17.5K:20K]}
+// freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K],
-//gain range -12~+12
+// [12.5K:15K], [15K:17.5K], [17.5K:20K]} gain range -12~+12
-const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {0, 0, 0, 0, 0, 0, 0, 0};
+const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {
+    0, 0, 0, 0, 0, 0, 0, 0};
 
 #define TX_PA_GAIN CODEC_TX_PA_GAIN_DEFAULT
 
 const struct CODEC_DAC_VOL_T codec_dac_vol[TGT_VOLUME_LEVEL_QTY] = {
-    {TX_PA_GAIN,0x03,-21},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -99},
-    {TX_PA_GAIN,0x03,-99},
+    {TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
-    {TX_PA_GAIN,0x03,-45},
+    {TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
-    {TX_PA_GAIN,0x03,-42},
+    {TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
-    {TX_PA_GAIN,0x03,-39},
+    {TX_PA_GAIN, 0x03, -27}, {TX_PA_GAIN, 0x03, -24},
-    {TX_PA_GAIN,0x03,-36},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -18},
-    {TX_PA_GAIN,0x03,-33},
+    {TX_PA_GAIN, 0x03, -15}, {TX_PA_GAIN, 0x03, -12},
-    {TX_PA_GAIN,0x03,-30},
+    {TX_PA_GAIN, 0x03, -9},  {TX_PA_GAIN, 0x03, -6},
-    {TX_PA_GAIN,0x03,-27},
+    {TX_PA_GAIN, 0x03, -3},  {TX_PA_GAIN, 0x03, 0}, // 0dBm
-    {TX_PA_GAIN,0x03,-24},
-    {TX_PA_GAIN,0x03,-21},
-    {TX_PA_GAIN,0x03,-18},
-    {TX_PA_GAIN,0x03,-15},
-    {TX_PA_GAIN,0x03,-12},
-    {TX_PA_GAIN,0x03, -9},
-    {TX_PA_GAIN,0x03, -6},
-    {TX_PA_GAIN,0x03, -3},
-    {TX_PA_GAIN,0x03,  0},  //0dBm
 };
 
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC2|AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC2 |            \
+   AUD_VMIC_MAP_VMIC3)
 #elif SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 3
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 |           \
+   AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
 #endif
 
-#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV    (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
+#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV                                       \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
 #ifdef VOICE_DETECTOR_EN
-#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV    (AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
 #endif
 
-const struct AUD_IO_PATH_CFG_T cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
+const struct AUD_IO_PATH_CFG_T
+    cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
 #if defined(SPEECH_TX_AEC_CODEC_REF)
-    // NOTE: If enable Ch5 and CH6, need to add channel_num when setup audioflinger stream
+        // NOTE: If enable Ch5 and CH6, need to add channel_num when setup
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4, },
+        // audioflinger stream
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4,
+        },
 #else
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV, },
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV,
+        },
 #endif
-    { AUD_INPUT_PATH_LINEIN,  CFG_HW_AUD_INPUT_PATH_LINEIN_DEV, },
+        {
+            AUD_INPUT_PATH_LINEIN,
+            CFG_HW_AUD_INPUT_PATH_LINEIN_DEV,
+        },
 #ifdef VOICE_DETECTOR_EN
-    { AUD_INPUT_PATH_VADMIC,  CFG_HW_AUD_INPUT_PATH_VADMIC_DEV, },
+        {
+            AUD_INPUT_PATH_VADMIC,
+            CFG_HW_AUD_INPUT_PATH_VADMIC_DEV,
+        },
 #else
-    { AUD_INPUT_PATH_ASRMIC,  CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV, },
+        {
+            AUD_INPUT_PATH_ASRMIC,
+            CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV,
+        },
 #endif
 };
 
-
-
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_enable_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_detecter_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
-const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg = {
+const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg =
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    {HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+     HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_tws_channel_cfg = {
-    HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE//HAL_IOMUX_PIN_P1_5		500:HAL_IOMUX_PIN_P2_5
+    HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+    HAL_IOMUX_PIN_PULLUP_ENABLE // HAL_IOMUX_PIN_P1_5
+                                // 500:HAL_IOMUX_PIN_P2_5
 };
 /*
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_INT ={
-	HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+        HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+HAL_IOMUX_PIN_PULLUP_ENABLE
 };
 */
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_I2C_SDA = {
-	HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_I2C_SCL = {
-	HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
-bool tgt_tws_get_channel_is_right(void)
+bool tgt_tws_get_channel_is_right(void) {
-{
 #ifdef __FIXED_TWS_EAR_SIDE__
   return TWS_EAR_SIDE_ROLE;
 #else
@@ -203,46 +239,33 @@ const IIR_CFG_T audio_eq_sw_iir_cfg = {
     .gain0 = 0,
     .gain1 = 0,
     .num = 5,
-    .param = {
+    .param = {{IIR_TYPE_PEAK, .0, 200, 2},
-        {IIR_TYPE_PEAK, .0,   200,   2},
               {IIR_TYPE_PEAK, .0, 600, 2},
               {IIR_TYPE_PEAK, .0, 2000.0, 2},
               {IIR_TYPE_PEAK, .0, 6000.0, 2},
-        {IIR_TYPE_PEAK, .0,  12000.0, 2}            
+              {IIR_TYPE_PEAK, .0, 12000.0, 2}}};
-    }
-};
 
 const IIR_CFG_T *const audio_eq_sw_iir_cfg_list[EQ_SW_IIR_LIST_NUM] = {
     &audio_eq_sw_iir_cfg,
 };
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
-    .gain = 0.0f,
                                              .len = 384,
-    .coef =
+                                             .coef = {
-    {
                                                  (1 << 23) - 1,
-    }
+                                             }};
-};
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.gain = 0.0f,
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
-
+const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {.gain = 0.0f,
-const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
 const FIR_CFG_T *const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM] = {
     &audio_eq_hw_fir_cfg_44p1k,
@@ -251,8 +274,7 @@ const FIR_CFG_T * const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM]={
 };
 
 // hardware dac iir eq
-const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {
+const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                            .gain1 = 0,
                                            .num = 8,
                                            .param = {
@@ -264,10 +286,10 @@ const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
-    }
+                                           }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM] = {
         &audio_eq_hw_dac_iir_cfg,
 };
 
@@ -278,18 +300,15 @@ const IIR_CFG_T audio_eq_hw_adc_iir_adc_cfg = {
     .num = 1,
     .param = {
         {IIR_TYPE_PEAK, 0.0, 1000.0, 0.7},
-    }
+    }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM] = {
         &audio_eq_hw_adc_iir_adc_cfg,
 };
 
-
-
 // hardware iir eq
-const IIR_CFG_T audio_eq_hw_iir_cfg = {
+const IIR_CFG_T audio_eq_hw_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                        .gain1 = 0,
                                        .num = 8,
                                        .param = {
@@ -302,23 +321,21 @@ const IIR_CFG_T audio_eq_hw_iir_cfg = {
                                            {IIR_TYPE_PEAK, -10.1, 7000.0, 7},
                                            {IIR_TYPE_PEAK, -10.1, 9000.0, 7},
 
-    }
+                                       }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM] = {
         &audio_eq_hw_iir_cfg,
 };
 
-const DrcConfig audio_drc_cfg = {
+const DrcConfig audio_drc_cfg = {.knee = 3,
-     .knee = 3,
                                  .filter_type = {14, -1},
                                  .band_num = 2,
                                  .look_ahead_time = 10,
                                  .band_settings = {
                                      {-20, 0, 2, 3, 3000, 1},
                                      {-20, 0, 2, 3, 3000, 1},
-     }
+                                 }};
- };
 
 const LimiterConfig audio_drc2_cfg = {
     .knee = 2,
@@ -334,4 +351,3 @@ const SpectrumFixConfig audio_spectrum_cfg = {
     .freq_num = 9,
     .freq_list = {200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800},
 };
-

config/best2300p_ibrt_anc/tgt_hardware.c

@@ -15,16 +15,18 @@
  ****************************************************************************/
 #include "tgt_hardware.h"
 #include "aud_section.h"
-#include "iir_process.h"
-#include "fir_process.h"
 #include "drc.h"
+#include "fir_process.h"
+#include "iir_process.h"
 #include "limiter.h"
 #include "spectrum_fix.h"
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_pinmux_pwl[CFG_HW_PLW_NUM] = {
 #if (CFG_HW_PLW_NUM > 0)
-    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_P1_4, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_P1_4, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 #endif
 };
 
@@ -43,26 +45,51 @@ const uint16_t CFG_HW_ADCKEY_MAP_TABLE[CFG_HW_ADCKEY_NUMBER] = {
 const struct HAL_KEY_GPIOKEY_CFG_T cfg_hw_gpio_key_cfg[CFG_HW_GPIOKEY_NUM] = {
 #if (CFG_HW_GPIOKEY_NUM > 0)
 #ifdef BES_AUDIO_DEV_Main_Board_9v0
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN1,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+     {HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-   	{HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN2,
-    {HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+     {HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN3,
+     {HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN4,
+     {HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN5,
+     {HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN6,
+     {HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
 #else
 #ifndef TPORTS_KEY_COEXIST
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN1,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+     {HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN2,
+     {HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    // HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN15,
+     {HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
 #else
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN1,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+     {HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN15,
+     {HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
 #endif
 #endif
 #ifdef IS_MULTI_AI_ENABLED
-    //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+//{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
-    //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+// HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+//{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+// HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
 #endif
 #endif
 };
@@ -74,80 +101,97 @@ uint8_t ble_addr[6] = {
 #ifdef BLE_DEV_ADDR
     BLE_DEV_ADDR
 #else
-	0xBE,0x99,0x34,0x45,0x56,0x67
+    0xBE, 0x99, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 uint8_t bt_addr[6] = {
 #ifdef BT_DEV_ADDR
     BT_DEV_ADDR
 #else
-	0x1e,0x57,0x34,0x45,0x56,0x67
+    0x1e, 0x57, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 
 // audio config
-//freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K], [12.5K:15K], [15K:17.5K], [17.5K:20K]}
+// freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K],
-//gain range -12~+12
+// [12.5K:15K], [15K:17.5K], [17.5K:20K]} gain range -12~+12
-const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {0, 0, 0, 0, 0, 0, 0, 0};
+const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {
+    0, 0, 0, 0, 0, 0, 0, 0};
 
 #define TX_PA_GAIN CODEC_TX_PA_GAIN_DEFAULT
 
 const struct CODEC_DAC_VOL_T codec_dac_vol[TGT_VOLUME_LEVEL_QTY] = {
-    {TX_PA_GAIN,0x03,-11},
+    {TX_PA_GAIN, 0x03, -11}, {TX_PA_GAIN, 0x03, -99},
-    {TX_PA_GAIN,0x03,-99},
+    {TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
-    {TX_PA_GAIN,0x03,-45},
+    {TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
-    {TX_PA_GAIN,0x03,-42},
+    {TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
-    {TX_PA_GAIN,0x03,-39},
+    {TX_PA_GAIN, 0x03, -27}, {TX_PA_GAIN, 0x03, -24},
-    {TX_PA_GAIN,0x03,-36},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -18},
-    {TX_PA_GAIN,0x03,-33},
+    {TX_PA_GAIN, 0x03, -15}, {TX_PA_GAIN, 0x03, -12},
-    {TX_PA_GAIN,0x03,-30},
+    {TX_PA_GAIN, 0x03, -9},  {TX_PA_GAIN, 0x03, -6},
-    {TX_PA_GAIN,0x03,-27},
+    {TX_PA_GAIN, 0x03, -3},  {TX_PA_GAIN, 0x03, 0}, // 0dBm
-    {TX_PA_GAIN,0x03,-24},
-    {TX_PA_GAIN,0x03,-21},
-    {TX_PA_GAIN,0x03,-18},
-    {TX_PA_GAIN,0x03,-15},
-    {TX_PA_GAIN,0x03,-12},
-    {TX_PA_GAIN,0x03, -9},
-    {TX_PA_GAIN,0x03, -6},
-    {TX_PA_GAIN,0x03, -3},
-    {TX_PA_GAIN,0x03,  0},  //0dBm
 };
 
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_VMIC_MAP_VMIC1)
 #elif SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 3
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 |           \
+   AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
 #endif
-#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV    (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
+#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV                                       \
-#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
-#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV    (AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
 
-const struct AUD_IO_PATH_CFG_T cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
+const struct AUD_IO_PATH_CFG_T
+    cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
 #if defined(SPEECH_TX_AEC_CODEC_REF)
-    // NOTE: If enable Ch5 and CH6, need to add channel_num when setup audioflinger stream
+        // NOTE: If enable Ch5 and CH6, need to add channel_num when setup
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_ECMIC_CH0, },
+        // audioflinger stream
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_ECMIC_CH0,
+        },
 #else
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV, },
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV,
+        },
 #endif
-    { AUD_INPUT_PATH_LINEIN,  CFG_HW_AUD_INPUT_PATH_LINEIN_DEV, },
+        {
-    { AUD_INPUT_PATH_VADMIC,  CFG_HW_AUD_INPUT_PATH_VADMIC_DEV, },
+            AUD_INPUT_PATH_LINEIN,
-    { AUD_INPUT_PATH_ASRMIC,  CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV, },
+            CFG_HW_AUD_INPUT_PATH_LINEIN_DEV,
+        },
+        {
+            AUD_INPUT_PATH_VADMIC,
+            CFG_HW_AUD_INPUT_PATH_VADMIC_DEV,
+        },
+        {
+            AUD_INPUT_PATH_ASRMIC,
+            CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV,
+        },
 };
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_enable_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_detecter_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
-
-const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
-};
 
+const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg =
+    {HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 /*
 
@@ -175,9 +219,11 @@ Filter4_A=[    134217728,   -257297054,    123731878];
 #define IIR_COUNTER_FB_L (5)
 #define IIR_COUNTER_FB_R (5)
 
-
+static const struct_anc_cfg POSSIBLY_UNUSED
-static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_50p7k_mode0 = {
+    AncFirCoef_50p7k_mode0 =
-    .anc_cfg_ff_l = {
+        {
+            .anc_cfg_ff_l =
+                {
                     // .total_gain = 440,
                     .total_gain = 350,
 
@@ -212,7 +258,8 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_50p7k_mode0 = {
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_ff_r = {
+            .anc_cfg_ff_r =
+                {
                     //  .total_gain = 382,
                     .total_gain = 350,
 
@@ -248,7 +295,6 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_50p7k_mode0 = {
                     .adc_gain_offset = (0) * 4,
                 },
 
-
             /*
 
             Filter1_B=[     27461831,    -54408898,     27001841];
@@ -266,7 +312,8 @@ Filter4_A=[    134217728,   -264794659,    130668486];
 
             */
 
-    .anc_cfg_fb_l = {
+            .anc_cfg_fb_l =
+                {
                     .total_gain = 350,
 
                     .iir_bypass_flag = 0,
@@ -298,14 +345,11 @@ Filter4_A=[    134217728,   -264794659,    130668486];
                             },
                     */
 
-
-
-
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_fb_r = {
+            .anc_cfg_fb_r =
+                {
                     .total_gain = 350,
 
                     .iir_bypass_flag = 0,
@@ -329,7 +373,6 @@ Filter4_A=[    134217728,   -264794659,    130668486];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-		
                     /*		.fir_bypass_flag=1,
                             .fir_len = AUD_COEF_LEN,
                             .fir_coef =
@@ -341,11 +384,8 @@ Filter4_A=[    134217728,   -264794659,    130668486];
                     .adc_gain_offset = (0) * 4,
                 },
 
-
-			
 };
 
-
 /*
 
 //ff
@@ -367,8 +407,11 @@ Filter4_A=[    134217728,   -256639526,    123150471];
 
 */
 
-static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_48k_mode0 = {
+static const struct_anc_cfg POSSIBLY_UNUSED
-    .anc_cfg_ff_l = {
+    AncFirCoef_48k_mode0 =
+        {
+            .anc_cfg_ff_l =
+                {
                     // .total_gain = 440,
                     .total_gain = 312,
 
@@ -403,7 +446,8 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_48k_mode0 = {
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_ff_r = {
+            .anc_cfg_ff_r =
+                {
                     //  .total_gain = 382,
                     .total_gain = 288,
 
@@ -438,7 +482,6 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_48k_mode0 = {
                     .adc_gain_offset = (0) * 4,
                 },
 
-
             /*
 
             Filter1_B=[     27172676,    -53803459,     26691412];
@@ -456,7 +499,8 @@ Filter4_A=[    134217728,   -264581113,    130465777];
 
             */
 
-    .anc_cfg_fb_l = {
+            .anc_cfg_fb_l =
+                {
                     .total_gain = 511,
 
                     .iir_bypass_flag = 0,
@@ -490,7 +534,8 @@ Filter4_A=[    134217728,   -264581113,    130465777];
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_fb_r = {
+            .anc_cfg_fb_r =
+                {
                     .total_gain = 511,
 
                     .iir_bypass_flag = 0,
@@ -527,7 +572,6 @@ Filter4_A=[    134217728,   -264581113,    130465777];
 
 #if (AUD_SECTION_STRUCT_VERSION == 2)
 
-
             /*
             1.0000000000000000,-1.5858874672928407,0.6974239598044429,0.2832267077115959,-0.3117526885614825,0.1400624733614886,
             Filter1_B=[      4751756,     -5230342,      2349858];
@@ -576,10 +620,8 @@ Filter5_B=[     16490453,    -32048020,     15620931];
             Filter5_A=[     16777216,    -32048020,     15334169];
             */
 
-
+            .anc_cfg_mc_l =
-
+                {
-
-    .anc_cfg_mc_l = {
                     .total_gain = 1228,
 
                     .iir_bypass_flag = 0,
@@ -603,11 +645,11 @@ Filter5_A=[     16777216,    -32048020,     15334169];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_mc_r = {
+            .anc_cfg_mc_r =
+                {
                     .total_gain = 1331,
 
                     .iir_bypass_flag = 0,
@@ -631,7 +673,6 @@ Filter5_A=[     16777216,    -32048020,     15334169];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
@@ -658,10 +699,11 @@ Filter4_A=[    134217728,   -255575175,    122217496];
 
 */
 
-
+static const struct_anc_cfg POSSIBLY_UNUSED
-
+    AncFirCoef_44p1k_mode0 =
-static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_44p1k_mode0 = {
+        {
-    .anc_cfg_ff_l = {
+            .anc_cfg_ff_l =
+                {
                     // .total_gain = 440,
                     .total_gain = 312,
 
@@ -696,7 +738,8 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_44p1k_mode0 = {
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_ff_r = {
+            .anc_cfg_ff_r =
+                {
                     //  .total_gain = 382,
                     .total_gain = 288,
 
@@ -748,8 +791,8 @@ Filter4_A=[    134217728,   -264235686,    130139109];
 
             */
 
-            
+            .anc_cfg_fb_l =
-    .anc_cfg_fb_l = {
+                {
                     .total_gain = 511,
 
                     .iir_bypass_flag = 0,
@@ -783,7 +826,8 @@ Filter4_A=[    134217728,   -264235686,    130139109];
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_fb_r = {
+            .anc_cfg_fb_r =
+                {
                     .total_gain = 511,
 
                     .iir_bypass_flag = 0,
@@ -807,7 +851,6 @@ Filter4_A=[    134217728,   -264235686,    130139109];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-		
                     /*		.fir_bypass_flag=1,
                             .fir_len = AUD_COEF_LEN,
                             .fir_coef =
@@ -820,8 +863,6 @@ Filter4_A=[    134217728,   -264235686,    130139109];
                 },
 #if (AUD_SECTION_STRUCT_VERSION == 2)
 
-
-
             /*
 
             Filter1_B=[     19847881,    -39594823,     19747071];
@@ -840,10 +881,8 @@ Filter5_B=[     16466312,    -31915122,     15523589];
             Filter5_A=[     16777216,    -31915122,     15212684];
             */
 
-
+            .anc_cfg_mc_l =
-
+                {
-
-    .anc_cfg_mc_l = {
                     .total_gain = 1228,
 
                     .iir_bypass_flag = 0,
@@ -867,11 +906,11 @@ Filter5_A=[     16777216,    -31915122,     15212684];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_mc_r = {
+            .anc_cfg_mc_r =
+                {
                     .total_gain = 1331,
 
                     .iir_bypass_flag = 0,
@@ -895,7 +934,6 @@ Filter5_A=[     16777216,    -31915122,     15212684];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
@@ -909,13 +947,10 @@ const struct_anc_cfg * anc_coef_list_50p7k[ANC_COEF_LIST_NUM] = {
     &AncFirCoef_50p7k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 3)
-    &AncFirCoef_50p7k_mode0,
+    &AncFirCoef_50p7k_mode0, &AncFirCoef_50p7k_mode0,
-    &AncFirCoef_50p7k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 4)
-    &AncFirCoef_50p7k_mode0,
+    &AncFirCoef_50p7k_mode0, &AncFirCoef_50p7k_mode0, &AncFirCoef_50p7k_mode0,
-    &AncFirCoef_50p7k_mode0,
-    &AncFirCoef_50p7k_mode0,
 #endif
 };
 
@@ -925,13 +960,10 @@ const struct_anc_cfg * anc_coef_list_48k[ANC_COEF_LIST_NUM] = {
     &AncFirCoef_48k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 3)
-    &AncFirCoef_48k_mode0,
+    &AncFirCoef_48k_mode0, &AncFirCoef_48k_mode0,
-    &AncFirCoef_48k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 4)
-    &AncFirCoef_48k_mode0,
+    &AncFirCoef_48k_mode0, &AncFirCoef_48k_mode0, &AncFirCoef_48k_mode0,
-    &AncFirCoef_48k_mode0,
-    &AncFirCoef_48k_mode0,
 #endif
 };
 
@@ -941,13 +973,10 @@ const struct_anc_cfg * anc_coef_list_44p1k[ANC_COEF_LIST_NUM] = {
     &AncFirCoef_44p1k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 3)
-    &AncFirCoef_44p1k_mode0,
+    &AncFirCoef_44p1k_mode0, &AncFirCoef_44p1k_mode0,
-    &AncFirCoef_44p1k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 4)
-    &AncFirCoef_44p1k_mode0,
+    &AncFirCoef_44p1k_mode0, &AncFirCoef_44p1k_mode0, &AncFirCoef_44p1k_mode0,
-    &AncFirCoef_44p1k_mode0,
-    &AncFirCoef_44p1k_mode0,
 #endif
 };
 
@@ -955,46 +984,33 @@ const IIR_CFG_T audio_eq_sw_iir_cfg = {
     .gain0 = 0,
     .gain1 = 0,
     .num = 5,
-    .param = {
+    .param = {{IIR_TYPE_PEAK, .0, 200, 2},
-        {IIR_TYPE_PEAK, .0,   200,   2},
               {IIR_TYPE_PEAK, .0, 600, 2},
               {IIR_TYPE_PEAK, .0, 2000.0, 2},
               {IIR_TYPE_PEAK, .0, 6000.0, 2},
-        {IIR_TYPE_PEAK, .0,  12000.0, 2}            
+              {IIR_TYPE_PEAK, .0, 12000.0, 2}}};
-    }
-};
 
 const IIR_CFG_T *const audio_eq_sw_iir_cfg_list[EQ_SW_IIR_LIST_NUM] = {
     &audio_eq_sw_iir_cfg,
 };
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
-    .gain = 0.0f,
                                              .len = 384,
-    .coef =
+                                             .coef = {
-    {
                                                  (1 << 23) - 1,
-    }
+                                             }};
-};
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.gain = 0.0f,
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
-
+const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {.gain = 0.0f,
-const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
 const FIR_CFG_T *const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM] = {
     &audio_eq_hw_fir_cfg_44p1k,
@@ -1003,8 +1019,7 @@ const FIR_CFG_T * const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM]={
 };
 
 // hardware dac iir eq
-const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {
+const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                            .gain1 = 0,
                                            .num = 8,
                                            .param = {
@@ -1016,10 +1031,10 @@ const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
-    }
+                                           }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM] = {
         &audio_eq_hw_dac_iir_cfg,
 };
 
@@ -1030,18 +1045,15 @@ const IIR_CFG_T audio_eq_hw_adc_iir_adc_cfg = {
     .num = 1,
     .param = {
         {IIR_TYPE_PEAK, 0.0, 1000.0, 0.7},
-    }
+    }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM] = {
         &audio_eq_hw_adc_iir_adc_cfg,
 };
 
-
-
 // hardware iir eq
-const IIR_CFG_T audio_eq_hw_iir_cfg = {
+const IIR_CFG_T audio_eq_hw_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                        .gain1 = 0,
                                        .num = 8,
                                        .param = {
@@ -1054,23 +1066,21 @@ const IIR_CFG_T audio_eq_hw_iir_cfg = {
                                            {IIR_TYPE_PEAK, -10.1, 7000.0, 7},
                                            {IIR_TYPE_PEAK, -10.1, 9000.0, 7},
 
-    }
+                                       }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM] = {
         &audio_eq_hw_iir_cfg,
 };
 
-const DrcConfig audio_drc_cfg = {
+const DrcConfig audio_drc_cfg = {.knee = 3,
-     .knee = 3,
                                  .filter_type = {14, -1},
                                  .band_num = 2,
                                  .look_ahead_time = 10,
                                  .band_settings = {
                                      {-20, 0, 2, 3, 3000, 1},
                                      {-20, 0, 2, 3, 3000, 1},
-     }
+                                 }};
- };
 
 const LimiterConfig audio_drc2_cfg = {
     .knee = 2,
@@ -1086,4 +1096,3 @@ const SpectrumFixConfig audio_spectrum_cfg = {
     .freq_num = 9,
     .freq_list = {200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800},
 };
-

config/mic_alg/tgt_hardware.c

@@ -14,31 +14,38 @@
  *
  ****************************************************************************/
 #include "tgt_hardware.h"
-#include "iir_process.h"
-#include "fir_process.h"
 #include "drc.h"
+#include "fir_process.h"
+#include "iir_process.h"
 #include "limiter.h"
 #include "spectrum_fix.h"
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_pinmux_pwl[CFG_HW_PLW_NUM] = {
 #if (CFG_HW_PLW_NUM > 0)
-    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 #endif
 };
 
 #ifdef __APP_USE_LED_INDICATE_IBRT_STATUS__
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_ibrt_indication_pinmux_pwl[3] = {
-    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
-    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 };
 #endif
 
 #ifdef __KNOWLES
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_pinmux_uart[2] = {
-    {HAL_IOMUX_PIN_P2_2, HAL_IOMUX_FUNC_UART2_RX, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+    {HAL_IOMUX_PIN_P2_2, HAL_IOMUX_FUNC_UART2_RX, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_P2_3, HAL_IOMUX_FUNC_UART2_TX,  HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+     HAL_IOMUX_PIN_NOPULL},
+    {HAL_IOMUX_PIN_P2_3, HAL_IOMUX_FUNC_UART2_TX, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_NOPULL},
 };
 #endif
 
@@ -58,30 +65,40 @@ const struct HAL_KEY_GPIOKEY_CFG_T cfg_hw_gpio_key_cfg[CFG_HW_GPIOKEY_NUM] = {
     /*
     #if (CFG_HW_GPIOKEY_NUM > 0)
     #ifdef BES_AUDIO_DEV_Main_Board_9v0
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    //{HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO,
-   // {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-#else
+        {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO,
-#ifndef TPORTS_KEY_COEXIST
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        //{HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+       // {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #else #ifndef
-#else
+    TPORTS_KEY_COEXIST {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3,
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_PULLUP_ENABLE}}, {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0,
-#endif
+    HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-#endif
+    HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #else
+        {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #endif #endif
     #ifdef IS_MULTI_AI_ENABLED
-    //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
-    //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-#endif
+        //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
-#endif
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #endif #endif
     */
-	{HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    {HAL_KEY_CODE_FN1,
+     {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+      HAL_IOMUX_PIN_PULLUP_ENABLE}},
 };
 
 // bt config
@@ -91,109 +108,130 @@ uint8_t ble_addr[6] = {
 #ifdef BLE_DEV_ADDR
     BLE_DEV_ADDR
 #else
-	0xBE,0x99,0x34,0x45,0x56,0x67
+    0xBE, 0x99, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 uint8_t bt_addr[6] = {
 #ifdef BT_DEV_ADDR
     BT_DEV_ADDR
 #else
-	0x1e,0x57,0x34,0x45,0x56,0x67
+    0x1e, 0x57, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 
 // audio config
-//freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K], [12.5K:15K], [15K:17.5K], [17.5K:20K]}
+// freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K],
-//gain range -12~+12
+// [12.5K:15K], [15K:17.5K], [17.5K:20K]} gain range -12~+12
-const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {0, 0, 0, 0, 0, 0, 0, 0};
+const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {
+    0, 0, 0, 0, 0, 0, 0, 0};
 
 #define TX_PA_GAIN CODEC_TX_PA_GAIN_DEFAULT
 
 const struct CODEC_DAC_VOL_T codec_dac_vol[TGT_VOLUME_LEVEL_QTY] = {
-    {TX_PA_GAIN,0x03,-21},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -99},
-    {TX_PA_GAIN,0x03,-99},
+    {TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
-    {TX_PA_GAIN,0x03,-45},
+    {TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
-    {TX_PA_GAIN,0x03,-42},
+    {TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
-    {TX_PA_GAIN,0x03,-39},
+    {TX_PA_GAIN, 0x03, -27}, {TX_PA_GAIN, 0x03, -24},
-    {TX_PA_GAIN,0x03,-36},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -18},
-    {TX_PA_GAIN,0x03,-33},
+    {TX_PA_GAIN, 0x03, -15}, {TX_PA_GAIN, 0x03, -12},
-    {TX_PA_GAIN,0x03,-30},
+    {TX_PA_GAIN, 0x03, -9},  {TX_PA_GAIN, 0x03, -6},
-    {TX_PA_GAIN,0x03,-27},
+    {TX_PA_GAIN, 0x03, -3},  {TX_PA_GAIN, 0x03, 0}, // 0dBm
-    {TX_PA_GAIN,0x03,-24},
-    {TX_PA_GAIN,0x03,-21},
-    {TX_PA_GAIN,0x03,-18},
-    {TX_PA_GAIN,0x03,-15},
-    {TX_PA_GAIN,0x03,-12},
-    {TX_PA_GAIN,0x03, -9},
-    {TX_PA_GAIN,0x03, -6},
-    {TX_PA_GAIN,0x03, -3},
-    {TX_PA_GAIN,0x03,  0},  //0dBm
 };
 
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC2|AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC2 |            \
+   AUD_VMIC_MAP_VMIC3)
 #elif SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 3
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 |           \
+   AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
 #endif
 
-#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV    (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
+#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV                                       \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
 #ifdef VOICE_DETECTOR_EN
-#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
 #endif
 
-const struct AUD_IO_PATH_CFG_T cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
+const struct AUD_IO_PATH_CFG_T
+    cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
 #if defined(SPEECH_TX_AEC_CODEC_REF)
-    // NOTE: If enable Ch5 and CH6, need to add channel_num when setup audioflinger stream
+        // NOTE: If enable Ch5 and CH6, need to add channel_num when setup
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4, },
+        // audioflinger stream
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4,
+        },
 #else
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV, },
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV,
+        },
 #endif
-    { AUD_INPUT_PATH_LINEIN,  CFG_HW_AUD_INPUT_PATH_LINEIN_DEV, },
+        {
+            AUD_INPUT_PATH_LINEIN,
+            CFG_HW_AUD_INPUT_PATH_LINEIN_DEV,
+        },
 #ifdef VOICE_DETECTOR_EN
-    { AUD_INPUT_PATH_VADMIC,  CFG_HW_AUD_INPUT_PATH_VADMIC_DEV, },
+        {
+            AUD_INPUT_PATH_VADMIC,
+            CFG_HW_AUD_INPUT_PATH_VADMIC_DEV,
+        },
 #else
-    { AUD_INPUT_PATH_ASRMIC,  CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV, },
+        {
+            AUD_INPUT_PATH_ASRMIC,
+            CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV,
+        },
 #endif
 };
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP MuteOutPwl = {
-	HAL_IOMUX_PIN_P1_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL 
+    HAL_IOMUX_PIN_P1_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_NOPULL};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_enable_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_detecter_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
-const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg = {
+const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg =
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    {HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+     HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_tws_channel_cfg = {
-    HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE//HAL_IOMUX_PIN_P1_5		500:HAL_IOMUX_PIN_P2_5
+    HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+    HAL_IOMUX_PIN_PULLUP_ENABLE // HAL_IOMUX_PIN_P1_5
+                                // 500:HAL_IOMUX_PIN_P2_5
 };
 /*
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_INT ={
-	HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+        HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+HAL_IOMUX_PIN_PULLUP_ENABLE
 };
 */
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_I2C_SDA = {
-	HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_I2C_SCL = {
-	HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
-bool tgt_tws_get_channel_is_right(void)
+bool tgt_tws_get_channel_is_right(void) {
-{
 #ifdef __FIXED_TWS_EAR_SIDE__
   return TWS_EAR_SIDE_ROLE;
 #else
@@ -205,46 +243,33 @@ const IIR_CFG_T audio_eq_sw_iir_cfg = {
     .gain0 = 0,
     .gain1 = 0,
     .num = 5,
-    .param = {
+    .param = {{IIR_TYPE_PEAK, .0, 200, 2},
-        {IIR_TYPE_PEAK, .0,   200,   2},
               {IIR_TYPE_PEAK, .0, 600, 2},
               {IIR_TYPE_PEAK, .0, 2000.0, 2},
               {IIR_TYPE_PEAK, .0, 6000.0, 2},
-        {IIR_TYPE_PEAK, .0,  12000.0, 2}            
+              {IIR_TYPE_PEAK, .0, 12000.0, 2}}};
-    }
-};
 
 const IIR_CFG_T *const audio_eq_sw_iir_cfg_list[EQ_SW_IIR_LIST_NUM] = {
     &audio_eq_sw_iir_cfg,
 };
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
-    .gain = 0.0f,
                                              .len = 384,
-    .coef =
+                                             .coef = {
-    {
                                                  (1 << 23) - 1,
-    }
+                                             }};
-};
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.gain = 0.0f,
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
-
+const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {.gain = 0.0f,
-const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
 const FIR_CFG_T *const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM] = {
     &audio_eq_hw_fir_cfg_44p1k,
@@ -253,8 +278,7 @@ const FIR_CFG_T * const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM]={
 };
 
 // hardware dac iir eq
-const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {
+const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                            .gain1 = 0,
                                            .num = 8,
                                            .param = {
@@ -266,10 +290,10 @@ const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
                                                {IIR_TYPE_PEAK, 0, 1000.0, 0.7},
-    }
+                                           }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM] = {
         &audio_eq_hw_dac_iir_cfg,
 };
 
@@ -280,18 +304,15 @@ const IIR_CFG_T audio_eq_hw_adc_iir_adc_cfg = {
     .num = 1,
     .param = {
         {IIR_TYPE_PEAK, 0.0, 1000.0, 0.7},
-    }
+    }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM] = {
         &audio_eq_hw_adc_iir_adc_cfg,
 };
 
-
-
 // hardware iir eq
-const IIR_CFG_T audio_eq_hw_iir_cfg = {
+const IIR_CFG_T audio_eq_hw_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                        .gain1 = 0,
                                        .num = 8,
                                        .param = {
@@ -304,23 +325,21 @@ const IIR_CFG_T audio_eq_hw_iir_cfg = {
                                            {IIR_TYPE_PEAK, -10.1, 7000.0, 7},
                                            {IIR_TYPE_PEAK, -10.1, 9000.0, 7},
 
-    }
+                                       }};
-};
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM] = {
         &audio_eq_hw_iir_cfg,
 };
 
-const DrcConfig audio_drc_cfg = {
+const DrcConfig audio_drc_cfg = {.knee = 3,
-     .knee = 3,
                                  .filter_type = {14, -1},
                                  .band_num = 2,
                                  .look_ahead_time = 10,
                                  .band_settings = {
                                      {-20, 0, 2, 3, 3000, 1},
                                      {-20, 0, 2, 3, 3000, 1},
-     }
+                                 }};
- };
 
 const LimiterConfig audio_drc2_cfg = {
     .knee = 2,
@@ -336,4 +355,3 @@ const SpectrumFixConfig audio_spectrum_cfg = {
     .freq_num = 9,
     .freq_list = {200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800},
 };
-

config/open_source/tgt_hardware.c

@@ -15,31 +15,38 @@
  ****************************************************************************/
 #include "tgt_hardware.h"
 #include "aud_section.h"
-#include "iir_process.h"
-#include "fir_process.h"
 #include "drc.h"
+#include "fir_process.h"
+#include "iir_process.h"
 #include "limiter.h"
 #include "spectrum_fix.h"
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_pinmux_pwl[CFG_HW_PLW_NUM] = {
 #if (CFG_HW_PLW_NUM > 0)
-    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 #endif
 };
 
 #ifdef __APP_USE_LED_INDICATE_IBRT_STATUS__
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_ibrt_indication_pinmux_pwl[3] = {
-    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT, HAL_IOMUX_PIN_PULLUP_ENABLE},
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
-    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT, HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
+    {HAL_IOMUX_PIN_LED2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VBAT,
+     HAL_IOMUX_PIN_PULLUP_ENABLE},
 };
 #endif
 
 #ifdef __KNOWLES
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_pinmux_uart[2] = {
-    {HAL_IOMUX_PIN_P2_2, HAL_IOMUX_FUNC_UART2_RX, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+    {HAL_IOMUX_PIN_P2_2, HAL_IOMUX_FUNC_UART2_RX, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_IOMUX_PIN_P2_3, HAL_IOMUX_FUNC_UART2_TX,  HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_NOPULL},
+     HAL_IOMUX_PIN_NOPULL},
+    {HAL_IOMUX_PIN_P2_3, HAL_IOMUX_FUNC_UART2_TX, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_NOPULL},
 };
 #endif
 
@@ -59,30 +66,39 @@ const struct HAL_KEY_GPIOKEY_CFG_T cfg_hw_gpio_key_cfg[CFG_HW_GPIOKEY_NUM] = {
     /*
     #if (CFG_HW_GPIOKEY_NUM > 0)
     #ifdef BES_AUDIO_DEV_Main_Board_9v0
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P0_3, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P0_0, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    //{HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P0_1, HAL_IOMUX_FUNC_AS_GPIO,
-   // {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-#else
+        {HAL_KEY_CODE_FN4,{HAL_IOMUX_PIN_P0_2, HAL_IOMUX_FUNC_AS_GPIO,
-#ifndef TPORTS_KEY_COEXIST
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        //{HAL_KEY_CODE_FN5,{HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-    // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+       // {HAL_KEY_CODE_FN6,{HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #else #ifndef
-#else
+    TPORTS_KEY_COEXIST {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3,
-    {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-    {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_PULLUP_ENABLE}}, {HAL_KEY_CODE_FN2,{HAL_IOMUX_PIN_P1_0,
-#endif
+    HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-#endif
+    HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        // {HAL_KEY_CODE_FN3,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #else
+        {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        {HAL_KEY_CODE_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO,
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #endif #endif
     #ifdef IS_MULTI_AI_ENABLED
-    //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+        //{HAL_KEY_CODE_FN13,{HAL_IOMUX_PIN_P1_3, HAL_IOMUX_FUNC_AS_GPIO,
-    //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
-#endif
+        //{HAL_KEY_CODE_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
-#endif
+    HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}}, #endif #endif
     */
-	// {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
+    // {HAL_KEY_CODE_FN1,{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO,
+    // HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
 };
 
 // bt config
@@ -93,27 +109,29 @@ uint8_t ble_addr[6] = {
 #ifdef BLE_DEV_ADDR
     BLE_DEV_ADDR
 #else
-	0xBE,0x99,0x34,0x45,0x56,0x67
+    0xBE, 0x99, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 uint8_t bt_addr[6] = {
 #ifdef BT_DEV_ADDR
     BT_DEV_ADDR
 #else
-	0x1e,0x57,0x34,0x45,0x56,0x67
+    0x1e, 0x57, 0x34, 0x45,
+    0x56, 0x67
 #endif
 };
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP cfg_hw_tws_channel_cfg = {
-    HAL_IOMUX_PIN_P1_4, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P1_4, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
-bool tgt_tws_get_channel_is_right(void)
+bool tgt_tws_get_channel_is_right(void) {
-{
 #ifdef __FIXED_TWS_EAR_SIDE__
   return TWS_EAR_SIDE_ROLE;
 #else
-    hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&cfg_hw_tws_channel_cfg,1);
+  hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&cfg_hw_tws_channel_cfg,
+                 1);
 
   // Pinebuds pull down to 0 for right ear, but float to 1 for left ear
   return (hal_gpio_pin_get_val(
@@ -122,100 +140,119 @@ bool tgt_tws_get_channel_is_right(void)
 }
 
 // audio config
-//freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K], [12.5K:15K], [15K:17.5K], [17.5K:20K]}
+// freq bands range {[0k:2.5K], [2.5k:5K], [5k:7.5K], [7.5K:10K], [10K:12.5K],
-//gain range -12~+12
+// [12.5K:15K], [15K:17.5K], [17.5K:20K]} gain range -12~+12
-const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {0, 0, 0, 0, 0, 0, 0, 0};
+const int8_t cfg_aud_eq_sbc_band_settings[CFG_HW_AUD_EQ_NUM_BANDS] = {
+    0, 0, 0, 0, 0, 0, 0, 0};
 
 #define TX_PA_GAIN CODEC_TX_PA_GAIN_DEFAULT
 
 const struct CODEC_DAC_VOL_T codec_dac_vol[TGT_VOLUME_LEVEL_QTY] = {
-    {TX_PA_GAIN,0x03,-21},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -99},
-    {TX_PA_GAIN,0x03,-99},
+    {TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
-    {TX_PA_GAIN,0x03,-45},
+    {TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
-    {TX_PA_GAIN,0x03,-42},
+    {TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
-    {TX_PA_GAIN,0x03,-39},
+    {TX_PA_GAIN, 0x03, -27}, {TX_PA_GAIN, 0x03, -24},
-    {TX_PA_GAIN,0x03,-36},
+    {TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -18},
-    {TX_PA_GAIN,0x03,-33},
+    {TX_PA_GAIN, 0x03, -15}, {TX_PA_GAIN, 0x03, -12},
-    {TX_PA_GAIN,0x03,-30},
+    {TX_PA_GAIN, 0x03, -9},  {TX_PA_GAIN, 0x03, -6},
-    {TX_PA_GAIN,0x03,-27},
+    {TX_PA_GAIN, 0x03, -3},  {TX_PA_GAIN, 0x03, 0}, // 0dBm
-    {TX_PA_GAIN,0x03,-24},
-    {TX_PA_GAIN,0x03,-21},
-    {TX_PA_GAIN,0x03,-18},
-    {TX_PA_GAIN,0x03,-15},
-    {TX_PA_GAIN,0x03,-12},
-    {TX_PA_GAIN,0x03, -9},
-    {TX_PA_GAIN,0x03, -6},
-    {TX_PA_GAIN,0x03, -3},
-    {TX_PA_GAIN,0x03,  0},  //0dBm
 };
 
 #if SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC2|AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC2 |            \
+   AUD_VMIC_MAP_VMIC3)
 #elif SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 3
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1 | AUD_CHANNEL_MAP_CH4 |           \
+   AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV   (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV                                      \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
 #endif
 
-#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV    (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
+#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV                                       \
+  (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
 #ifdef VOICE_DETECTOR_EN
-#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
+#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
 #else
-#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV    (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
+#define CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV                                       \
+  (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC3)
 #endif
 
-const struct AUD_IO_PATH_CFG_T cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
+const struct AUD_IO_PATH_CFG_T
+    cfg_audio_input_path_cfg[CFG_HW_AUD_INPUT_PATH_NUM] = {
 #if defined(SPEECH_TX_AEC_CODEC_REF)
-    // NOTE: If enable Ch5 and CH6, need to add channel_num when setup audioflinger stream
+        // NOTE: If enable Ch5 and CH6, need to add channel_num when setup
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4, },
+        // audioflinger stream
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4,
+        },
 #else
-    { AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV, },
+        {
+            AUD_INPUT_PATH_MAINMIC,
+            CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV,
+        },
 #endif
-    { AUD_INPUT_PATH_LINEIN,  CFG_HW_AUD_INPUT_PATH_LINEIN_DEV, },
+        {
+            AUD_INPUT_PATH_LINEIN,
+            CFG_HW_AUD_INPUT_PATH_LINEIN_DEV,
+        },
 #ifdef VOICE_DETECTOR_EN
-    { AUD_INPUT_PATH_VADMIC,  CFG_HW_AUD_INPUT_PATH_VADMIC_DEV, },
+        {
+            AUD_INPUT_PATH_VADMIC,
+            CFG_HW_AUD_INPUT_PATH_VADMIC_DEV,
+        },
 #else
-    { AUD_INPUT_PATH_ASRMIC,  CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV, },
+        {
+            AUD_INPUT_PATH_ASRMIC,
+            CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV,
+        },
 #endif
 };
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_enable_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_detecter_cfg = {
-    HAL_IOMUX_PIN_P1_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+    HAL_IOMUX_PIN_P1_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
-};
+    HAL_IOMUX_PIN_PULLUP_ENABLE};
-
-const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg = {
-    HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
-};
 
+const struct HAL_IOMUX_PIN_FUNCTION_MAP app_battery_ext_charger_indicator_cfg =
+    {HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+     HAL_IOMUX_PIN_PULLUP_ENABLE};
 
 /*
 const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_INT ={
-	HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+        HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+HAL_IOMUX_PIN_PULLUP_ENABLE
 };
 */
 
 // const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_I2C_SDA ={
-// 	HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+// 	HAL_IOMUX_PIN_P2_1, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+// HAL_IOMUX_PIN_PULLUP_ENABLE
 // };
 
 // const struct HAL_IOMUX_PIN_FUNCTION_MAP TOUCH_I2C_SCL ={
-// 	HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE
+// 	HAL_IOMUX_PIN_P2_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
+// HAL_IOMUX_PIN_PULLUP_ENABLE
 // };
 
-
-
 #define IIR_COUNTER_FF_L (6)
 #define IIR_COUNTER_FF_R (6)
 #define IIR_COUNTER_FB_L (5)
 #define IIR_COUNTER_FB_R (5)
 
-
+static const struct_anc_cfg POSSIBLY_UNUSED
-static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_50p7k_mode0 = {
+    AncFirCoef_50p7k_mode0 =
-    .anc_cfg_ff_l = {
+        {
+            .anc_cfg_ff_l =
+                {
                     // .total_gain = 440,
                     .total_gain = 350,
 
@@ -250,7 +287,8 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_50p7k_mode0 = {
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_ff_r = {
+            .anc_cfg_ff_r =
+                {
                     //  .total_gain = 382,
                     .total_gain = 350,
 
@@ -286,7 +324,6 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_50p7k_mode0 = {
                     .adc_gain_offset = (0) * 4,
                 },
 
-
             /*
 
             Filter1_B=[     27461831,    -54408898,     27001841];
@@ -304,7 +341,8 @@ Filter4_A=[    134217728,   -264794659,    130668486];
 
             */
 
-    .anc_cfg_fb_l = {
+            .anc_cfg_fb_l =
+                {
                     .total_gain = 350,
 
                     .iir_bypass_flag = 0,
@@ -339,7 +377,8 @@ Filter4_A=[    134217728,   -264794659,    130668486];
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_fb_r = {
+            .anc_cfg_fb_r =
+                {
                     .total_gain = 350,
 
                     .iir_bypass_flag = 0,
@@ -363,7 +402,6 @@ Filter4_A=[    134217728,   -264794659,    130668486];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-		
                     /*		.fir_bypass_flag=1,
                             .fir_len = AUD_COEF_LEN,
                             .fir_coef =
@@ -375,11 +413,8 @@ Filter4_A=[    134217728,   -264794659,    130668486];
                     .adc_gain_offset = (0) * 4,
                 },
 
-
-			
 };
 
-
 /*
 
 //ff
@@ -401,8 +436,11 @@ Filter4_A=[    134217728,   -256639526,    123150471];
 
 */
 
-static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_48k_mode0 = {
+static const struct_anc_cfg POSSIBLY_UNUSED
-    .anc_cfg_ff_l = {
+    AncFirCoef_48k_mode0 =
+        {
+            .anc_cfg_ff_l =
+                {
                     // .total_gain = 440,
                     .total_gain = 312,
 
@@ -437,7 +475,8 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_48k_mode0 = {
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_ff_r = {
+            .anc_cfg_ff_r =
+                {
                     //  .total_gain = 382,
                     .total_gain = 288,
 
@@ -472,7 +511,6 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_48k_mode0 = {
                     .adc_gain_offset = (0) * 4,
                 },
 
-
             /*
 
             Filter1_B=[     27172676,    -53803459,     26691412];
@@ -490,7 +528,8 @@ Filter4_A=[    134217728,   -264581113,    130465777];
 
             */
 
-    .anc_cfg_fb_l = {
+            .anc_cfg_fb_l =
+                {
                     .total_gain = 511,
 
                     .iir_bypass_flag = 0,
@@ -524,7 +563,8 @@ Filter4_A=[    134217728,   -264581113,    130465777];
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_fb_r = {
+            .anc_cfg_fb_r =
+                {
                     .total_gain = 511,
 
                     .iir_bypass_flag = 0,
@@ -561,7 +601,6 @@ Filter4_A=[    134217728,   -264581113,    130465777];
 
 #if (AUD_SECTION_STRUCT_VERSION == 2)
 
-
             /*
             1.0000000000000000,-1.5858874672928407,0.6974239598044429,0.2832267077115959,-0.3117526885614825,0.1400624733614886,
             Filter1_B=[      4751756,     -5230342,      2349858];
@@ -610,10 +649,8 @@ Filter5_B=[     16490453,    -32048020,     15620931];
             Filter5_A=[     16777216,    -32048020,     15334169];
             */
 
-
+            .anc_cfg_mc_l =
-
+                {
-
-    .anc_cfg_mc_l = {
                     .total_gain = 1228,
 
                     .iir_bypass_flag = 0,
@@ -637,11 +674,11 @@ Filter5_A=[     16777216,    -32048020,     15334169];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_mc_r = {
+            .anc_cfg_mc_r =
+                {
                     .total_gain = 1331,
 
                     .iir_bypass_flag = 0,
@@ -665,7 +702,6 @@ Filter5_A=[     16777216,    -32048020,     15334169];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
@@ -692,10 +728,11 @@ Filter4_A=[    134217728,   -255575175,    122217496];
 
 */
 
-
+static const struct_anc_cfg POSSIBLY_UNUSED
-
+    AncFirCoef_44p1k_mode0 =
-static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_44p1k_mode0 = {
+        {
-    .anc_cfg_ff_l = {
+            .anc_cfg_ff_l =
+                {
                     // .total_gain = 440,
                     .total_gain = 312,
 
@@ -730,7 +767,8 @@ static const struct_anc_cfg POSSIBLY_UNUSED AncFirCoef_44p1k_mode0 = {
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_ff_r = {
+            .anc_cfg_ff_r =
+                {
                     //  .total_gain = 382,
                     .total_gain = 288,
 
@@ -782,8 +820,8 @@ Filter4_A=[    134217728,   -264235686,    130139109];
 
             */
 
-            
+            .anc_cfg_fb_l =
-    .anc_cfg_fb_l = {
+                {
                     .total_gain = 511,
 
                     .iir_bypass_flag = 0,
@@ -817,7 +855,8 @@ Filter4_A=[    134217728,   -264235686,    130139109];
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_fb_r = {
+            .anc_cfg_fb_r =
+                {
                     .total_gain = 511,
 
                     .iir_bypass_flag = 0,
@@ -841,7 +880,6 @@ Filter4_A=[    134217728,   -264235686,    130139109];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-		
                     /*		.fir_bypass_flag=1,
                             .fir_len = AUD_COEF_LEN,
                             .fir_coef =
@@ -854,8 +892,6 @@ Filter4_A=[    134217728,   -264235686,    130139109];
                 },
 #if (AUD_SECTION_STRUCT_VERSION == 2)
 
-
-
             /*
 
             Filter1_B=[     19847881,    -39594823,     19747071];
@@ -874,10 +910,8 @@ Filter5_B=[     16466312,    -31915122,     15523589];
             Filter5_A=[     16777216,    -31915122,     15212684];
             */
 
-
+            .anc_cfg_mc_l =
-
+                {
-
-    .anc_cfg_mc_l = {
                     .total_gain = 1228,
 
                     .iir_bypass_flag = 0,
@@ -901,11 +935,11 @@ Filter5_A=[     16777216,    -31915122,     15212684];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
-    .anc_cfg_mc_r = {
+            .anc_cfg_mc_r =
+                {
                     .total_gain = 1331,
 
                     .iir_bypass_flag = 0,
@@ -929,7 +963,6 @@ Filter5_A=[     16777216,    -31915122,     15212684];
                     .iir_coef[5].coef_b = {0x8000000, 0, 0},
                     .iir_coef[5].coef_a = {0x8000000, 0, 0},
 
-
                     .dac_gain_offset = 0,
                     .adc_gain_offset = (0) * 4,
                 },
@@ -943,13 +976,10 @@ const struct_anc_cfg * anc_coef_list_50p7k[ANC_COEF_LIST_NUM] = {
     &AncFirCoef_50p7k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 3)
-    &AncFirCoef_50p7k_mode0,
+    &AncFirCoef_50p7k_mode0, &AncFirCoef_50p7k_mode0,
-    &AncFirCoef_50p7k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 4)
-    &AncFirCoef_50p7k_mode0,
+    &AncFirCoef_50p7k_mode0, &AncFirCoef_50p7k_mode0, &AncFirCoef_50p7k_mode0,
-    &AncFirCoef_50p7k_mode0,
-    &AncFirCoef_50p7k_mode0,
 #endif
 };
 
@@ -959,13 +989,10 @@ const struct_anc_cfg * anc_coef_list_48k[ANC_COEF_LIST_NUM] = {
     &AncFirCoef_48k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 3)
-    &AncFirCoef_48k_mode0,
+    &AncFirCoef_48k_mode0, &AncFirCoef_48k_mode0,
-    &AncFirCoef_48k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 4)
-    &AncFirCoef_48k_mode0,
+    &AncFirCoef_48k_mode0, &AncFirCoef_48k_mode0, &AncFirCoef_48k_mode0,
-    &AncFirCoef_48k_mode0,
-    &AncFirCoef_48k_mode0,
 #endif
 };
 
@@ -975,18 +1002,14 @@ const struct_anc_cfg * anc_coef_list_44p1k[ANC_COEF_LIST_NUM] = {
     &AncFirCoef_44p1k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 3)
-    &AncFirCoef_44p1k_mode0,
+    &AncFirCoef_44p1k_mode0, &AncFirCoef_44p1k_mode0,
-    &AncFirCoef_44p1k_mode0,
 #endif
 #if (ANC_COEF_LIST_NUM == 4)
-    &AncFirCoef_44p1k_mode0,
+    &AncFirCoef_44p1k_mode0, &AncFirCoef_44p1k_mode0, &AncFirCoef_44p1k_mode0,
-    &AncFirCoef_44p1k_mode0,
-    &AncFirCoef_44p1k_mode0,
 #endif
 };
 
-const IIR_CFG_T audio_eq_sw_iir_cfg = {
+const IIR_CFG_T audio_eq_sw_iir_cfg = {.gain0 = 0,
-    .gain0 = 0,
                                        .gain1 = 0,
                                        .num = 14,
                                        .param = {
@@ -1004,40 +1027,29 @@ const IIR_CFG_T audio_eq_sw_iir_cfg = {
                                            {IIR_TYPE_PEAK, -4.96, 8000, 2},
                                            {IIR_TYPE_PEAK, 13.58, 16000, 2},
                                            {IIR_TYPE_PEAK, 8.89, 20000, 2},
-    }
+                                       }};
-};
 
 const IIR_CFG_T *const audio_eq_sw_iir_cfg_list[EQ_SW_IIR_LIST_NUM] = {
     &audio_eq_sw_iir_cfg,
 };
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
-    .gain = 0.0f,
                                              .len = 384,
-    .coef =
+                                             .coef = {
-    {
                                                  (1 << 23) - 1,
-    }
+                                             }};
-};
 
-const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
+const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.gain = 0.0f,
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
-
+const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {.gain = 0.0f,
-const FIR_CFG_T audio_eq_hw_fir_cfg_96k = {
-    .gain = 0.0f,
                                            .len = 384,
-    .coef =
+                                           .coef = {
-    {
                                                (1 << 23) - 1,
-    }
+                                           }};
-};
 
 const FIR_CFG_T *const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM] = {
     &audio_eq_hw_fir_cfg_44p1k,
@@ -1048,34 +1060,35 @@ const FIR_CFG_T * const audio_eq_hw_fir_cfg_list[EQ_HW_FIR_LIST_NUM]={
 // hardware dac iir eq
 const IIR_CFG_T audio_eq_hw_dac_iir_cfg = audio_eq_sw_iir_cfg;
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_dac_iir_cfg_list[EQ_HW_DAC_IIR_LIST_NUM] = {
         &audio_eq_hw_dac_iir_cfg,
 };
 
 // hardware dac iir eq
 const IIR_CFG_T audio_eq_hw_adc_iir_adc_cfg = audio_eq_sw_iir_cfg;
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_adc_iir_cfg_list[EQ_HW_ADC_IIR_LIST_NUM] = {
         &audio_eq_hw_adc_iir_adc_cfg,
 };
 
 // hardware iir eq
 const IIR_CFG_T audio_eq_hw_iir_cfg = audio_eq_sw_iir_cfg;
 
-const IIR_CFG_T * const POSSIBLY_UNUSED audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM]={
+const IIR_CFG_T *const POSSIBLY_UNUSED
+    audio_eq_hw_iir_cfg_list[EQ_HW_IIR_LIST_NUM] = {
         &audio_eq_hw_iir_cfg,
 };
 
-const DrcConfig audio_drc_cfg = {
+const DrcConfig audio_drc_cfg = {.knee = 3,
-     .knee = 3,
                                  .filter_type = {14, -1},
                                  .band_num = 2,
                                  .look_ahead_time = 10,
                                  .band_settings = {
                                      {-20, 0, 2, 3, 3000, 1},
                                      {-20, 0, 2, 3, 3000, 1},
-     }
+                                 }};
- };
 
 const LimiterConfig audio_drc2_cfg = {
     .knee = 2,
@@ -1091,4 +1104,3 @@ const SpectrumFixConfig audio_spectrum_cfg = {
     .freq_num = 9,
     .freq_list = {200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800},
 };
-

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_abs_f32.c

@@ -60,11 +60,7 @@
   @return        none
  */
 
-void arm_abs_f32(
+void arm_abs_f32(const float32_t *pSrc, float32_t *pDst, uint32_t blockSize) {
-  const float32_t * pSrc,
-        float32_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -72,8 +68,7 @@ void arm_abs_f32(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = |A| */
 
     /* Calculate absolute and store result in destination buffer. */
@@ -99,8 +94,7 @@ void arm_abs_f32(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = |A| */
 
     /* Calculate absolute and store result in destination buffer. */
@@ -109,7 +103,6 @@ void arm_abs_f32(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_abs_q15.c

@@ -46,14 +46,11 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF.
+                   The Q15 value -1 (0x8000) will be saturated to the maximum
+  allowable positive value 0x7FFF.
  */
 
-void arm_abs_q15(
+void arm_abs_q15(const q15_t *pSrc, q15_t *pDst, uint32_t blockSize) {
-  const q15_t * pSrc,
-        q15_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
   q15_t in;        /* Temporary input variable */
 
@@ -62,11 +59,11 @@ void arm_abs_q15(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = |A| */
 
-    /* Calculate absolute of input (if -1 then saturated to 0x7fff) and store result in destination buffer. */
+    /* Calculate absolute of input (if -1 then saturated to 0x7fff) and store
+     * result in destination buffer. */
     in = *pSrc++;
 #if defined(ARM_MATH_DSP)
     *pDst++ = (in > 0) ? in : (q15_t)__QSUB16(0, in);
@@ -109,11 +106,11 @@ void arm_abs_q15(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = |A| */
 
-    /* Calculate absolute of input (if -1 then saturated to 0x7fff) and store result in destination buffer. */
+    /* Calculate absolute of input (if -1 then saturated to 0x7fff) and store
+     * result in destination buffer. */
     in = *pSrc++;
 #if defined(ARM_MATH_DSP)
     *pDst++ = (in > 0) ? in : (q15_t)__QSUB16(0, in);
@@ -124,7 +121,6 @@ void arm_abs_q15(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_abs_q31.c

@@ -46,14 +46,11 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   The Q31 value -1 (0x80000000) will be saturated to the maximum allowable positive value 0x7FFFFFFF.
+                   The Q31 value -1 (0x80000000) will be saturated to the
+  maximum allowable positive value 0x7FFFFFFF.
  */
 
-void arm_abs_q31(
+void arm_abs_q31(const q31_t *pSrc, q31_t *pDst, uint32_t blockSize) {
-  const q31_t * pSrc,
-        q31_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
   q31_t in;        /* Temporary variable */
 
@@ -62,11 +59,11 @@ void arm_abs_q31(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = |A| */
 
-    /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and store result in destination buffer. */
+    /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and
+     * store result in destination buffer. */
     in = *pSrc++;
 #if defined(ARM_MATH_DSP)
     *pDst++ = (in > 0) ? in : (q31_t)__QSUB(0, in);
@@ -109,11 +106,11 @@ void arm_abs_q31(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = |A| */
 
-    /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and store result in destination buffer. */
+    /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and
+     * store result in destination buffer. */
     in = *pSrc++;
 #if defined(ARM_MATH_DSP)
     *pDst++ = (in > 0) ? in : (q31_t)__QSUB(0, in);
@@ -124,7 +121,6 @@ void arm_abs_q31(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_abs_q7.c

@@ -48,14 +48,11 @@
                    Input and output buffers should be aligned by 32-bit
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F.
+                   The Q7 value -1 (0x80) will be saturated to the maximum
+  allowable positive value 0x7F.
  */
 
-void arm_abs_q7(
+void arm_abs_q7(const q7_t *pSrc, q7_t *pDst, uint32_t blockSize) {
-  const q7_t * pSrc,
-        q7_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
   q7_t in;         /* Temporary input variable */
 
@@ -64,11 +61,11 @@ void arm_abs_q7(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = |A| */
 
-    /* Calculate absolute of input (if -1 then saturated to 0x7f) and store result in destination buffer. */
+    /* Calculate absolute of input (if -1 then saturated to 0x7f) and store
+     * result in destination buffer. */
     in = *pSrc++;
 #if defined(ARM_MATH_DSP)
     *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in);
@@ -111,11 +108,11 @@ void arm_abs_q7(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = |A| */
 
-    /* Calculate absolute of input (if -1 then saturated to 0x7f) and store result in destination buffer. */
+    /* Calculate absolute of input (if -1 then saturated to 0x7f) and store
+     * result in destination buffer. */
     in = *pSrc++;
 #if defined(ARM_MATH_DSP)
     *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in);
@@ -126,7 +123,6 @@ void arm_abs_q7(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_add_f32.c

@@ -58,12 +58,8 @@
   @return        none
  */
 
-void arm_add_f32(
+void arm_add_f32(const float32_t *pSrcA, const float32_t *pSrcB,
-  const float32_t * pSrcA,
+                 float32_t *pDst, uint32_t blockSize) {
-  const float32_t * pSrcB,
-        float32_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -71,8 +67,7 @@ void arm_add_f32(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + B */
 
     /* Add and store result in destination buffer. */
@@ -95,8 +90,7 @@ void arm_add_f32(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + B */
 
     /* Add and store result in destination buffer. */
@@ -105,7 +99,6 @@ void arm_add_f32(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_add_q15.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
+                   Results outside of the allowable Q15 range [0x8000 0x7FFF]
+  are saturated.
  */
 
-void arm_add_q15(
+void arm_add_q15(const q15_t *pSrcA, const q15_t *pSrcB, q15_t *pDst,
-  const q15_t * pSrcA,
+                 uint32_t blockSize) {
-  const q15_t * pSrcB,
-        q15_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -68,8 +65,7 @@ void arm_add_q15(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + B */
 
 #if defined(ARM_MATH_DSP)
@@ -104,8 +100,7 @@ void arm_add_q15(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + B */
 
     /* Add and store result in destination buffer. */
@@ -118,7 +113,6 @@ void arm_add_q15(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_add_q31.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
+                   Results outside of the allowable Q31 range [0x80000000
+  0x7FFFFFFF] are saturated.
  */
 
-void arm_add_q31(
+void arm_add_q31(const q31_t *pSrcA, const q31_t *pSrcB, q31_t *pDst,
-  const q31_t * pSrcA,
+                 uint32_t blockSize) {
-  const q31_t * pSrcB,
-        q31_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -63,8 +60,7 @@ void arm_add_q31(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + B */
 
     /* Add and store result in destination buffer. */
@@ -90,8 +86,7 @@ void arm_add_q31(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + B */
 
     /* Add and store result in destination buffer. */
@@ -100,7 +95,6 @@ void arm_add_q31(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_add_q7.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
+                   Results outside of the allowable Q7 range [0x80 0x7F] are
+  saturated.
  */
 
-void arm_add_q7(
+void arm_add_q7(const q7_t *pSrcA, const q7_t *pSrcB, q7_t *pDst,
-  const q7_t * pSrcA,
+                uint32_t blockSize) {
-  const q7_t * pSrcB,
-        q7_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -63,13 +60,13 @@ void arm_add_q7(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + B */
 
 #if defined(ARM_MATH_DSP)
     /* Add and store result in destination buffer (4 samples at a time). */
-    write_q7x4_ia (&pDst, __QADD8 (read_q7x4_ia ((q7_t **) &pSrcA), read_q7x4_ia ((q7_t **) &pSrcB)));
+    write_q7x4_ia(&pDst, __QADD8(read_q7x4_ia((q7_t **)&pSrcA),
+                                 read_q7x4_ia((q7_t **)&pSrcB)));
 #else
     *pDst++ = (q7_t)__SSAT((q15_t)*pSrcA++ + *pSrcB++, 8);
     *pDst++ = (q7_t)__SSAT((q15_t)*pSrcA++ + *pSrcB++, 8);
@@ -91,8 +88,7 @@ void arm_add_q7(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + B */
 
     /* Add and store result in destination buffer. */
@@ -101,7 +97,6 @@ void arm_add_q7(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_dot_prod_f32.c

@@ -39,7 +39,8 @@
   The vectors are multiplied element-by-element and then summed.
 
   <pre>
-      sum = pSrcA[0]*pSrcB[0] + pSrcA[1]*pSrcB[1] + ... + pSrcA[blockSize-1]*pSrcB[blockSize-1]
+      sum = pSrcA[0]*pSrcB[0] + pSrcA[1]*pSrcB[1] + ... +
+  pSrcA[blockSize-1]*pSrcB[blockSize-1]
   </pre>
 
   There are separate functions for floating-point, Q7, Q15, and Q31 data types.
@@ -59,12 +60,8 @@
   @return        none
  */
 
-void arm_dot_prod_f32(
+void arm_dot_prod_f32(const float32_t *pSrcA, const float32_t *pSrcB,
-  const float32_t * pSrcA,
+                      uint32_t blockSize, float32_t *result) {
-  const float32_t * pSrcB,
-        uint32_t blockSize,
-        float32_t * result)
-{
   uint32_t blkCnt;      /* Loop counter */
   float32_t sum = 0.0f; /* Temporary return variable */
 
@@ -73,9 +70,9 @@ void arm_dot_prod_f32(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
+    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
-    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+     * B[blockSize-1] */
 
     /* Calculate dot product and store result in a temporary buffer. */
     sum += (*pSrcA++) * (*pSrcB++);
@@ -100,9 +97,9 @@ void arm_dot_prod_f32(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
+    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
-    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+     * B[blockSize-1] */
 
     /* Calculate dot product and store result in a temporary buffer. */
     sum += (*pSrcA++) * (*pSrcB++);

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_dot_prod_q15.c

@@ -46,19 +46,15 @@
   @return        none
 
   @par           Scaling and Overflow Behavior
-                   The intermediate multiplications are in 1.15 x 1.15 = 2.30 format and these
+                   The intermediate multiplications are in 1.15 x 1.15 = 2.30
-                   results are added to a 64-bit accumulator in 34.30 format.
+  format and these results are added to a 64-bit accumulator in 34.30 format.
-                   Nonsaturating additions are used and given that there are 33 guard bits in the accumulator
+                   Nonsaturating additions are used and given that there are 33
-                   there is no risk of overflow.
+  guard bits in the accumulator there is no risk of overflow. The return result
-                   The return result is in 34.30 format.
+  is in 34.30 format.
  */
 
-void arm_dot_prod_q15(
+void arm_dot_prod_q15(const q15_t *pSrcA, const q15_t *pSrcB,
-  const q15_t * pSrcA,
+                      uint32_t blockSize, q63_t *result) {
-  const q15_t * pSrcB,
-        uint32_t blockSize,
-        q63_t * result)
-{
   uint32_t blkCnt; /* Loop counter */
   q63_t sum = 0;   /* Temporary return variable */
 
@@ -67,14 +63,16 @@ void arm_dot_prod_q15(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
+    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
-    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+     * B[blockSize-1] */
 
 #if defined(ARM_MATH_DSP)
     /* Calculate dot product and store result in a temporary buffer. */
-    sum = __SMLALD(read_q15x2_ia ((q15_t **) &pSrcA), read_q15x2_ia ((q15_t **) &pSrcB), sum);
+    sum = __SMLALD(read_q15x2_ia((q15_t **)&pSrcA),
-    sum = __SMLALD(read_q15x2_ia ((q15_t **) &pSrcA), read_q15x2_ia ((q15_t **) &pSrcB), sum);
+                   read_q15x2_ia((q15_t **)&pSrcB), sum);
+    sum = __SMLALD(read_q15x2_ia((q15_t **)&pSrcA),
+                   read_q15x2_ia((q15_t **)&pSrcB), sum);
 #else
     sum += (q63_t)((q31_t)*pSrcA++ * *pSrcB++);
     sum += (q63_t)((q31_t)*pSrcA++ * *pSrcB++);
@@ -96,9 +94,9 @@ void arm_dot_prod_q15(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
+    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
-    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+     * B[blockSize-1] */
 
     /* Calculate dot product and store result in a temporary buffer. */
     //#if defined (ARM_MATH_DSP)

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_dot_prod_q31.c

@@ -46,20 +46,16 @@
   @return        none
 
   @par           Scaling and Overflow Behavior
-                   The intermediate multiplications are in 1.31 x 1.31 = 2.62 format and these
+                   The intermediate multiplications are in 1.31 x 1.31 = 2.62
-                   are truncated to 2.48 format by discarding the lower 14 bits.
+  format and these are truncated to 2.48 format by discarding the lower 14 bits.
-                   The 2.48 result is then added without saturation to a 64-bit accumulator in 16.48 format.
+                   The 2.48 result is then added without saturation to a 64-bit
-                   There are 15 guard bits in the accumulator and there is no risk of overflow as long as
+  accumulator in 16.48 format. There are 15 guard bits in the accumulator and
-                   the length of the vectors is less than 2^16 elements.
+  there is no risk of overflow as long as the length of the vectors is less than
-                   The return result is in 16.48 format.
+  2^16 elements. The return result is in 16.48 format.
  */
 
-void arm_dot_prod_q31(
+void arm_dot_prod_q31(const q31_t *pSrcA, const q31_t *pSrcB,
-  const q31_t * pSrcA,
+                      uint32_t blockSize, q63_t *result) {
-  const q31_t * pSrcB,
-        uint32_t blockSize,
-        q63_t * result)
-{
   uint32_t blkCnt; /* Loop counter */
   q63_t sum = 0;   /* Temporary return variable */
 
@@ -68,9 +64,9 @@ void arm_dot_prod_q31(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
+    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
-    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+     * B[blockSize-1] */
 
     /* Calculate dot product and store result in a temporary buffer. */
     sum += ((q63_t)*pSrcA++ * *pSrcB++) >> 14U;
@@ -95,9 +91,9 @@ void arm_dot_prod_q31(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
+    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
-    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+     * B[blockSize-1] */
 
     /* Calculate dot product and store result in a temporary buffer. */
     sum += ((q63_t)*pSrcA++ * *pSrcB++) >> 14U;

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_dot_prod_q7.c

@@ -46,19 +46,15 @@
   @return        none
 
   @par           Scaling and Overflow Behavior
-                   The intermediate multiplications are in 1.7 x 1.7 = 2.14 format and these
+                   The intermediate multiplications are in 1.7 x 1.7 = 2.14
-                   results are added to an accumulator in 18.14 format.
+  format and these results are added to an accumulator in 18.14 format.
-                   Nonsaturating additions are used and there is no danger of wrap around as long as
+                   Nonsaturating additions are used and there is no danger of
-                   the vectors are less than 2^18 elements long.
+  wrap around as long as the vectors are less than 2^18 elements long. The
-                   The return result is in 18.14 format.
+  return result is in 18.14 format.
  */
 
-void arm_dot_prod_q7(
+void arm_dot_prod_q7(const q7_t *pSrcA, const q7_t *pSrcB, uint32_t blockSize,
-  const q7_t * pSrcA,
+                     q31_t *result) {
-  const q7_t * pSrcB,
-        uint32_t blockSize,
-        q31_t * result)
-{
   uint32_t blkCnt; /* Loop counter */
   q31_t sum = 0;   /* Temporary return variable */
 
@@ -72,9 +68,9 @@ void arm_dot_prod_q7(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
+    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
-    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+     * B[blockSize-1] */
 
 #if defined(ARM_MATH_DSP)
     /* read 4 samples at a time from sourceA */
@@ -115,9 +111,9 @@ void arm_dot_prod_q7(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
+    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
-    /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+     * B[blockSize-1] */
 
     /* Calculate dot product and store result in a temporary buffer. */
     //#if defined (ARM_MATH_DSP)

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_mult_f32.c

@@ -58,12 +58,8 @@
   @return        none
  */
 
-void arm_mult_f32(
+void arm_mult_f32(const float32_t *pSrcA, const float32_t *pSrcB,
-  const float32_t * pSrcA,
+                  float32_t *pDst, uint32_t blockSize) {
-  const float32_t * pSrcB,
-        float32_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -71,8 +67,7 @@ void arm_mult_f32(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * B */
 
     /* Multiply inputs and store result in destination buffer. */
@@ -98,8 +93,7 @@ void arm_mult_f32(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * B */
 
     /* Multiply input and store result in destination buffer. */
@@ -108,7 +102,6 @@ void arm_mult_f32(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_mult_q15.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
+                   Results outside of the allowable Q15 range [0x8000 0x7FFF]
+  are saturated.
  */
 
-void arm_mult_q15(
+void arm_mult_q15(const q15_t *pSrcA, const q15_t *pSrcB, q15_t *pDst,
-  const q15_t * pSrcA,
+                  uint32_t blockSize) {
-  const q15_t * pSrcB,
-        q15_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -69,8 +66,7 @@ void arm_mult_q15(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * B */
 
 #if defined(ARM_MATH_DSP)
@@ -125,8 +121,7 @@ void arm_mult_q15(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * B */
 
     /* Multiply inputs and store result in destination buffer. */
@@ -135,7 +130,6 @@ void arm_mult_q15(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_mult_q31.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q31 range[0x80000000 0x7FFFFFFF] are saturated.
+                   Results outside of the allowable Q31 range[0x80000000
+  0x7FFFFFFF] are saturated.
  */
 
-void arm_mult_q31(
+void arm_mult_q31(const q31_t *pSrcA, const q31_t *pSrcB, q31_t *pDst,
-  const q31_t * pSrcA,
+                  uint32_t blockSize) {
-  const q31_t * pSrcB,
-        q31_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
   q31_t out;       /* Temporary output variable */
 
@@ -64,8 +61,7 @@ void arm_mult_q31(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * B */
 
     /* Multiply inputs and store result in destination buffer. */
@@ -99,8 +95,7 @@ void arm_mult_q31(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * B */
 
     /* Multiply inputs and store result in destination buffer. */
@@ -111,7 +106,6 @@ void arm_mult_q31(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_mult_q7.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
+                   Results outside of the allowable Q7 range [0x80 0x7F] are
+  saturated.
  */
 
-void arm_mult_q7(
+void arm_mult_q7(const q7_t *pSrcA, const q7_t *pSrcB, q7_t *pDst,
-  const q7_t * pSrcA,
+                 uint32_t blockSize) {
-  const q7_t * pSrcB,
-        q7_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -67,8 +64,7 @@ void arm_mult_q7(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * B */
 
 #if defined(ARM_MATH_DSP)
@@ -101,8 +97,7 @@ void arm_mult_q7(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * B */
 
     /* Multiply input and store result in destination buffer. */
@@ -111,7 +106,6 @@ void arm_mult_q7(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_negate_f32.c

@@ -59,11 +59,8 @@
   @return        none
  */
 
-void arm_negate_f32(
+void arm_negate_f32(const float32_t *pSrc, float32_t *pDst,
-  const float32_t * pSrc,
+                    uint32_t blockSize) {
-        float32_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -71,8 +68,7 @@ void arm_negate_f32(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = -A */
 
     /* Negate and store result in destination buffer. */
@@ -98,8 +94,7 @@ void arm_negate_f32(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = -A */
 
     /* Negate and store result in destination buffer. */
@@ -108,7 +103,6 @@ void arm_negate_f32(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_negate_q15.c

@@ -48,14 +48,11 @@
                    Input and output buffers should be aligned by 32-bit
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   The Q15 value -1 (0x8000) is saturated to the maximum allowable positive value 0x7FFF.
+                   The Q15 value -1 (0x8000) is saturated to the maximum
+  allowable positive value 0x7FFF.
  */
 
-void arm_negate_q15(
+void arm_negate_q15(const q15_t *pSrc, q15_t *pDst, uint32_t blockSize) {
-  const q15_t * pSrc,
-        q15_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
   q15_t in;        /* Temporary input variable */
 
@@ -68,8 +65,7 @@ void arm_negate_q15(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = -A */
 
 #if defined(ARM_MATH_DSP)
@@ -107,8 +103,7 @@ void arm_negate_q15(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = -A */
 
     /* Negate and store result in destination buffer. */
@@ -118,7 +113,6 @@ void arm_negate_q15(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_negate_q31.c

@@ -46,14 +46,11 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   The Q31 value -1 (0x80000000) is saturated to the maximum allowable positive value 0x7FFFFFFF.
+                   The Q31 value -1 (0x80000000) is saturated to the maximum
+  allowable positive value 0x7FFFFFFF.
  */
 
-void arm_negate_q31(
+void arm_negate_q31(const q31_t *pSrc, q31_t *pDst, uint32_t blockSize) {
-  const q31_t * pSrc,
-        q31_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
   q31_t in;        /* Temporary input variable */
 
@@ -62,8 +59,7 @@ void arm_negate_q31(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = -A */
 
     /* Negate and store result in destination buffer. */
@@ -109,8 +105,7 @@ void arm_negate_q31(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = -A */
 
     /* Negate and store result in destination buffer. */
@@ -124,7 +119,6 @@ void arm_negate_q31(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_negate_q7.c

@@ -46,14 +46,11 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   The Q7 value -1 (0x80) is saturated to the maximum allowable positive value 0x7F.
+                   The Q7 value -1 (0x80) is saturated to the maximum allowable
+  positive value 0x7F.
  */
 
-void arm_negate_q7(
+void arm_negate_q7(const q7_t *pSrc, q7_t *pDst, uint32_t blockSize) {
-  const q7_t * pSrc,
-        q7_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
   q7_t in;         /* Temporary input variable */
 
@@ -66,8 +63,7 @@ void arm_negate_q7(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = -A */
 
 #if defined(ARM_MATH_DSP)
@@ -102,8 +98,7 @@ void arm_negate_q7(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = -A */
 
     /* Negate and store result in destination buffer. */
@@ -118,7 +113,6 @@ void arm_negate_q7(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_offset_f32.c

@@ -60,12 +60,8 @@
   @return        none
  */
 
-void arm_offset_f32(
+void arm_offset_f32(const float32_t *pSrc, float32_t offset, float32_t *pDst,
-  const float32_t * pSrc,
+                    uint32_t blockSize) {
-        float32_t offset,
-        float32_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -73,8 +69,7 @@ void arm_offset_f32(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + offset */
 
     /* Add offset and store result in destination buffer. */
@@ -100,8 +95,7 @@ void arm_offset_f32(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + offset */
 
     /* Add offset and store result in destination buffer. */
@@ -110,7 +104,6 @@ void arm_offset_f32(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_offset_q15.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
+                   Results outside of the allowable Q15 range [0x8000 0x7FFF]
+  are saturated.
  */
 
-void arm_offset_q15(
+void arm_offset_q15(const q15_t *pSrc, q15_t offset, q15_t *pDst,
-  const q15_t * pSrc,
+                    uint32_t blockSize) {
-        q15_t offset,
-        q15_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -70,14 +67,16 @@ void arm_offset_q15(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + offset */
 
 #if defined(ARM_MATH_DSP)
-    /* Add offset and store result in destination buffer (2 samples at a time). */
+    /* Add offset and store result in destination buffer (2 samples at a time).
-    write_q15x2_ia (&pDst, __QADD16(read_q15x2_ia ((q15_t **) &pSrc), offset_packed));
+     */
-    write_q15x2_ia (&pDst, __QADD16(read_q15x2_ia ((q15_t **) &pSrc), offset_packed));
+    write_q15x2_ia(&pDst,
+                   __QADD16(read_q15x2_ia((q15_t **)&pSrc), offset_packed));
+    write_q15x2_ia(&pDst,
+                   __QADD16(read_q15x2_ia((q15_t **)&pSrc), offset_packed));
 #else
     *pDst++ = (q15_t)__SSAT(((q31_t)*pSrc++ + offset), 16);
     *pDst++ = (q15_t)__SSAT(((q31_t)*pSrc++ + offset), 16);
@@ -99,8 +98,7 @@ void arm_offset_q15(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + offset */
 
     /* Add offset and store result in destination buffer. */
@@ -113,7 +111,6 @@ void arm_offset_q15(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_offset_q31.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
+                   Results outside of the allowable Q31 range [0x80000000
+  0x7FFFFFFF] are saturated.
  */
 
-void arm_offset_q31(
+void arm_offset_q31(const q31_t *pSrc, q31_t offset, q31_t *pDst,
-  const q31_t * pSrc,
+                    uint32_t blockSize) {
-        q31_t offset,
-        q31_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -63,8 +60,7 @@ void arm_offset_q31(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + offset */
 
     /* Add offset and store result in destination buffer. */
@@ -106,8 +102,7 @@ void arm_offset_q31(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + offset */
 
     /* Add offset and store result in destination buffer. */
@@ -120,7 +115,6 @@ void arm_offset_q31(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_offset_q7.c

@@ -47,15 +47,12 @@
 
   @par           Scaling and Overflow Behavior
                    The function uses saturating arithmetic.
-                   Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
+                   Results outside of the allowable Q7 range [0x80 0x7F] are
+  saturated.
  */
 
-void arm_offset_q7(
+void arm_offset_q7(const q7_t *pSrc, q7_t offset, q7_t *pDst,
-  const q7_t * pSrc,
+                   uint32_t blockSize) {
-        q7_t offset,
-        q7_t * pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -70,12 +67,12 @@ void arm_offset_q7(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + offset */
 
 #if defined(ARM_MATH_DSP)
-    /* Add offset and store result in destination buffer (4 samples at a time). */
+    /* Add offset and store result in destination buffer (4 samples at a time).
+     */
     write_q7x4_ia(&pDst, __QADD8(read_q7x4_ia((q7_t **)&pSrc), offset_packed));
 #else
     *pDst++ = (q7_t)__SSAT(*pSrc++ + offset, 8);
@@ -98,8 +95,7 @@ void arm_offset_q7(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A + offset */
 
     /* Add offset and store result in destination buffer. */
@@ -108,7 +104,6 @@ void arm_offset_q7(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**

platform/cmsis/DSP_Lib/BasicMathFunctions/arm_scale_f32.c

@@ -35,16 +35,17 @@
 /**
   @defgroup BasicScale Vector Scale
 
-  Multiply a vector by a scalar value.  For floating-point data, the algorithm used is:
+  Multiply a vector by a scalar value.  For floating-point data, the algorithm
+  used is:
 
   <pre>
       pDst[n] = pSrc[n] * scale,   0 <= n < blockSize.
   </pre>
 
-  In the fixed-point Q7, Q15, and Q31 functions, <code>scale</code> is represented by
+  In the fixed-point Q7, Q15, and Q31 functions, <code>scale</code> is
-  a fractional multiplication <code>scaleFract</code> and an arithmetic shift <code>shift</code>.
+  represented by a fractional multiplication <code>scaleFract</code> and an
-  The shift allows the gain of the scaling operation to exceed 1.0.
+  arithmetic shift <code>shift</code>. The shift allows the gain of the scaling
-  The algorithm used with fixed-point data is:
+  operation to exceed 1.0. The algorithm used with fixed-point data is:
 
   <pre>
       pDst[n] = (pSrc[n] * scaleFract) << shift,   0 <= n < blockSize.
@@ -73,12 +74,8 @@
   @return        none
  */
 
-void arm_scale_f32(
+void arm_scale_f32(const float32_t *pSrc, float32_t scale, float32_t *pDst,
-  const float32_t *pSrc,
+                   uint32_t blockSize) {
-        float32_t scale,
-        float32_t *pDst,
-        uint32_t blockSize)
-{
   uint32_t blkCnt; /* Loop counter */
 
 #if defined(ARM_MATH_LOOPUNROLL)
@@ -86,8 +83,7 @@ void arm_scale_f32(
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * scale */
 
     /* Scale input and store result in destination buffer. */
@@ -113,8 +109,7 @@ void arm_scale_f32(
 
 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
 
-  while (blkCnt > 0U)
+  while (blkCnt > 0U) {
-  {
     /* C = A * scale */
 
     /* Scale input and store result in destination buffer. */
@@ -123,7 +118,6 @@ void arm_scale_f32(
     /* Decrement loop counter */
     blkCnt--;
   }
-
 }
 
 /**