rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Formatting

Browse source 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
This commit is contained in:
Ben V. Brown 2023-02-02 07:52:54 +11:00
parent dcb8fed27b
commit 75381150fd
794 changed files with 240573 additions and 256459 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
apps/anc/inc/anc_wnr.h
View file

@ -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,

194
apps/anc/src/anc_assist.c
View file

@ -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(){
return 1;
}
bool audio_engine_tt_is_on() { 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) || 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)
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{
if(g_anc_assist_mode == ANC_ASSIST_STANDALONE || g_anc_assist_mode == ANC_ASSIST_MUSIC ){
} else {
if (g_anc_assist_mode == ANC_ASSIST_STANDALONE ||
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;
case(1):
{
} break;
case (1): {
TRACE(2, "[%s] use fb mic only", __func__);
MIC_NUM = 3;
MIC_MAP = AUD_INPUT_PATH_AF_ANC;
}
break;
case(4):
{
} break;
case (4): {
TRACE(2, "[%s] use ff mic only", __func__);
MIC_NUM = 3;
MIC_MAP = AUD_INPUT_PATH_ANC_WNR;
}
break;
case(5):
{
} break;
case (5): {
TRACE(2, "[%s] use ff mic and fb mic", __func__);
MIC_NUM = 3;
MIC_MAP = AUD_INPUT_PATH_ANC_WNR;
}
break;
case(6):
{
} break;
case (6): {
TRACE(2, "[%s] use ff1 mic and ff2 mic", __func__);
MIC_NUM = 2;
MIC_MAP = AUD_INPUT_PATH_AF_ANC;
}
break;
case(7):
{
} break;
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);
TRACE(2,"[%s] sample_rate:%d, data_size:%d", __func__, stream_cfg.sample_rate, stream_cfg.data_size);
ASSERT(stream_cfg.channel_num == MIC_NUM,
"[%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

635
apps/anc/src/anc_wnr.c
View file

File diff suppressed because it is too large Load diff

933
apps/anc/src/app_anc.c
View file

File diff suppressed because it is too large Load diff

58
apps/anc/src/peak_detector.c
View file

@ -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(3,"buf = %d, pkd_alphaR = %f, pkd_alphaA = %f", buf[len-1], pkd_alphaR, pkd_alphaA);
// TRACE(4,"pkd_factor1 = %f, pkd_factor2 = %f, normal_rate = %f, tgt_rate = %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));
// TRACE(2,"vol_level = %d, pkd_vol_multiple = %f", vol_level,
// pkd_vol_multiple[vol_level]); TRACE(3,"buf = %d, pkd_alphaR = %f,
// pkd_alphaA = %f", buf[len-1], pkd_alphaR, pkd_alphaA);
// TRACE(4,"pkd_factor1 = %f, pkd_factor2 = %f, normal_rate = %f, tgt_rate =
// %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();
}

99
apps/apptester/app_audtest.cpp
View file

@ -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 "audioflinger.h"
#include "app_utils.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
{
if ((sizeof(sinwave) - nextPbufIdx) >= len)
{
} else {
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)
{
da_output_sin1k(on);
}
void da_tester(uint8_t 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,
//app_test_capture_buff, USB_AUDIO_CAPTURE_BUFF_SIZE);
// dualadc_audio_app_init(app_test_playback_buff,
// USB_AUDIO_PLAYBACK_BUFF_SIZE, app_test_capture_buff,
// USB_AUDIO_CAPTURE_BUFF_SIZE);
}
#endif

42
apps/apptester/audiobuffer.c
View file

@ -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;

834
apps/audioplayers/a2dp_decoder/a2dp_decoder.cpp
View file

File diff suppressed because it is too large Load diff

454
apps/audioplayers/a2dp_decoder/a2dp_decoder_aac_lc.cpp
View file

@ -14,19 +14,19 @@
*
****************************************************************************/
// Standard C Included Files
#include "a2dp_decoder_internal.h"
#include "cmsis.h"
#include "plat_types.h"
#include <string.h>
#include "heap_api.h"
#include "cmsis_os.h"
#include "hal_location.h"
#include "hal_timer.h"
#include "a2dp_decoder_internal.h"
#include "cmsis_os.h"
#include "heap_api.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)
{
a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p = (a2dp_audio_aac_decoder_frame_t *)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 *)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_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);
a2dp_audio_list_length(list) +
a2dp_cp_get_in_frame_cnt_by_index(p_out_info->frame_idx) - 1;
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 */);
TRACE_A2DP_DECODER_D("[CP][AAC] decoder seq:%d len:%d err:%x", p_in_info->sequenceNumber,
(dec_len - dec_sum),
decoder_err =
aacDecoder_DecodeFrame(aacDec_handle, (short *)(dec_start + 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]);
ASSERT_A2DP_DECODER(AAC_OUTPUT_FRAME_SAMPLES == bufferSize/4, "aac_lc_decode output mismatch samples:%d", bufferSize/4);
bufferSize = stream_info->frameSize * stream_info->numChannels *
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)
{
AAC_DECODER_CHANNEL_SELECT_E aac_decoder_channel_select = AAC_DECODER_CHANNEL_SELECT_SELECT_STEREO;
switch(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_SELECT_STEREO;
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.",
total, used, max_used);
TRACE_A2DP_DECODER_I(
"[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 */);
TRACE_A2DP_DECODER_D("[MCU][AAC] decoder seq:%d len:%d err:%x", aac_decoder_frame_p->sequenceNumber,
aac_decoder_frame_p->aac_buffer_len,
decoder_err);
decoder_err = aacDecoder_DecodeFrame(aacDec_handle, (short *)buffer,
buffer_bytes / 2, 0 /* flags */);
TRACE_A2DP_DECODER_D("[MCU][AAC] decoder seq:%d len:%d err:%x",
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]);
ASSERT_A2DP_DECODER(AAC_OUTPUT_FRAME_SAMPLES == output_byte/4, "aac_lc_decode output mismatch samples:%d", output_byte/4);
output_byte = stream_info->frameSize * stream_info->numChannels *
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.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_aac_lastframe_info.undecode_frames =
a2dp_audio_list_length(list) - 1;
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,
btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
{
int a2dp_audio_aac_lc_reorder_store_packet(
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,
btif_media_header_t * header, uint8_t *buffer, uint32_t buffer_bytes)
{
int a2dp_audio_aac_lc_reorder_proc(
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);
dest_buf = &aac_decoder_frame_p->aac_buffer[aac_decoder_frame_p->aac_buffer_len];
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);
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_timestamp = a2dp_audio_get_passed(aac_decoder_frame->timestamp, aac_decoder_last_valid_frame.timestamp, UINT32_MAX);
diff_seq = a2dp_audio_get_passed(aac_decoder_frame->sequenceNumber,
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,
aac_decoder_frame->timestamp, aac_decoder_last_valid_frame.timestamp);
TRACE_A2DP_DECODER_W("[AAC][INPUT][PLC] seq:%d/%d stmp:%d/%d",
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/
((1000.f/(float)a2dp_audio_context_p->output_cfg.sample_rate)*(float)AAC_OUTPUT_FRAME_SAMPLES);
tmp_pkt_cnt =
(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);
if (missing_pkt_cnt <= 4 && a2dp_audio_list_length(list) + missing_pkt_cnt < aac_mtu_limiter){
missing_pkt_cnt =
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);
a2dp_audio_aac_lc_reorder_store_packet(aac_decoder_frame_p, header, buffer, buffer_bytes);
TRACE_A2DP_DECODER_W("[AAC][INPUT][REORDER] start seq:%d len:%d",
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);
TRACE_A2DP_DECODER_D("[AAC][INPUT]seq:%d len:%d", header->sequenceNumber, buffer_bytes);
a2dp_audio_aac_decoder_frame_t *aac_decoder_frame_p =
(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)){
aac_decoder_frame = (a2dp_audio_aac_decoder_frame_t *)a2dp_audio_list_node(node);
if (a2dp_audio_list_length(list) &&
((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)
{
return A2DP_DECODER_NO_ERROR;
}
int a2dp_audio_aac_lc_info_get(void *info) { 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);
TRACE_A2DP_DECODER_D("[synchronize_packet]%d/%d %x/%x", aac_decoder_frame_p->sequenceNumber, sync_info->sequenceNumber,
aac_decoder_frame_p =
(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)&&
A2DP_AUDIO_SYNCFRAME_CHK(aac_decoder_frame_p->timestamp == sync_info->timestamp, A2DP_AUDIO_SYNCFRAME_MASK_TIMESTAMP, mask)){
if (A2DP_AUDIO_SYNCFRAME_CHK(aac_decoder_frame_p->sequenceNumber ==
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);
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);
aac_decoder_frame_p =
(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

99
apps/audioplayers/a2dp_decoder/a2dp_decoder_cp.c
View file

@ -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)
{
return cp_accel_init_done();
}
bool is_cp_init_done(void) { 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};
int a2dp_cp_init(A2DP_CP_DECODE_T decode_func, enum CP_PROC_DELAY_T delay)
{
static struct cp_task_desc TASK_DESC_A2DP = {
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)
{
return proc_delay;
}
uint32_t get_in_cp_frame_delay(void) { 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)
{
return cp_in_ridx;
}
uint32_t a2dp_cp_get_in_frame_index(void) { 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)
{
return reset_frames;
}
bool a2dp_cp_get_frame_reset_status(void) { 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

72
apps/audioplayers/a2dp_decoder/a2dp_decoder_example.cpp
View file

@ -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)
{
a2dp_audio_example_decoder_frame_t *decoder_frame_p = (a2dp_audio_example_decoder_frame_t *)packet;
void a2dp_audio_example_free(void *packet) {
a2dp_audio_example_decoder_frame_t *decoder_frame_p =
(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)
{
return A2DP_DECODER_NO_ERROR;
}
int a2dp_audio_example_info_get(void *info) { 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));
memcpy(&a2dp_audio_example_output_config, config, sizeof(A2DP_AUDIO_OUTPUT_CONFIG_T));
memset(&a2dp_audio_ldac_example_info, 0,
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)
{
return A2DP_DECODER_NO_ERROR;
}
int a2dp_audio_example_synchronize_dest_packet_mut(uint16_t packet_mut)
{
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,
};

643
apps/audioplayers/a2dp_decoder/a2dp_decoder_ldac.cpp
View file

File diff suppressed because it is too large Load diff

697
apps/audioplayers/a2dp_decoder/a2dp_decoder_lhdc.cpp
View file

File diff suppressed because it is too large Load diff

440
apps/audioplayers/a2dp_decoder/a2dp_decoder_sbc.cpp
View file

@ -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)
{
a2dp_audio_sbc_decoder_frame_t *sbc_decoder_frame_p = (a2dp_audio_sbc_decoder_frame_t *)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 *)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.totalSubSequenceNumber = p_out_info->in_info.totalSubSequenceNumber;
a2dp_audio_sbc_lastframe_info.curSubSequenceNumber =
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_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);
a2dp_audio_list_length(list) +
a2dp_cp_get_in_frame_cnt_by_index(p_out_info->frame_idx) - 1;
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,
&bytes_parsed,
pcm_data,
dec_len,
sbc_subbands_gain);
switch (decoder_err)
{
decoder_err =
btif_sbc_decode_frames(sbc_decoder, in_buf, in_len, &bytes_parsed,
pcm_data, dec_len, 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.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));
a2dp_audio_sbc_decoder.sbc_decoder =
(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,
&bytes_parsed,
pcm_data,
buffer_bytes,
ret = btif_sbc_decode_frames(sbc_decoder, sbc_decoder_frame->sbc_buffer,
sbc_decoder_frame->sbc_buffer_len,
&bytes_parsed, pcm_data, 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,
ret,
sbc_decoder_frame->sbc_buffer_len, 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.totalSubSequenceNumber = sbc_decoder_frame->totalSubSequenceNumber;
a2dp_audio_sbc_lastframe_info.curSubSequenceNumber =
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.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_sbc_lastframe_info.undecode_frames =
a2dp_audio_list_length(list) - 1;
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
// during CP process. CP process is triggered by audioflinger PCM callback.
// TODO: Remove the following sbc init and decode codes. They might conflict
// 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);
TRACE_A2DP_DECODER_I("[SBC][PRE] seq:%d tStmp:%08x smpR:%d ch:%d len:%d",
header->sequenceNumber,
header->timestamp,
btif_sbc_decode_frames_parser(a2dp_audio_sbc_decoder_preparse, parser_p,
buffer_bytes, &bytes_parsed);
TRACE_A2DP_DECODER_I(
"[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_timestamp = a2dp_audio_get_passed(sbc_decoder_frame->timestamp, sbc_decoder_last_valid_frame.timestamp, UINT32_MAX);
diff_seq = a2dp_audio_get_passed(sbc_decoder_frame->sequenceNumber,
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,
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);
TRACE_A2DP_DECODER_W("[SBC][INPUT][PLC] seq:%d/%d stmp:%d/%d",
sbc_decoder_frame->sequenceNumber,
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);
ASSERT_A2DP_DECODER(sbc_decoder_frame->curSubSequenceNumber == 0, "sbc_discards_packet not align curSubSequenceNumber:%d",
sbc_decoder_frame =
(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)){
sbc_decoder_frame = (a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
if (a2dp_audio_list_length(list) &&
((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->totalSubSequenceNumber = sbc_decoder_frame->totalSubSequenceNumber;
headframe_info->curSubSequenceNumber =
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)
{
return A2DP_DECODER_NO_ERROR;
}
int a2dp_audio_sbc_info_get(void *info) { 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);
if (A2DP_AUDIO_SYNCFRAME_CHK(sbc_decoder_frame->sequenceNumber == 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)){
sbc_decoder_frame =
(a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
if (A2DP_AUDIO_SYNCFRAME_CHK(sbc_decoder_frame->sequenceNumber ==
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);
TRACE_A2DP_DECODER_I("[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);
sbc_decoder_frame =
(a2dp_audio_sbc_decoder_frame_t *)a2dp_audio_list_node(node);
TRACE_A2DP_DECODER_I(
"[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,
};

286
apps/audioplayers/a2dp_decoder/a2dp_decoder_scalable.cpp
View file

@ -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, output_config.sample_rate);
ssc_decoder_init(scalableDec_handle, output_config.num_channels,
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
("scalable a2dp frame, length:%d bitrate:%d sampling_rate:%d",
TRACE_A2DP_DECODER_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
("invalid scalable a2dp frame, length:%d < %d !!!!!!!", decoder_frame_p->buffer_len, frame_len);
TRACE_A2DP_DECODER_E(
"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 *)
a2dp_audio_list_node(node);
decoder_frame_p =
(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);
if (0 == output_samples)
{
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);
ASSERT_A2DP_DECODER(scalable_decoder_place, "no memory resource for scalable_decoder_place");
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);
ASSERT_A2DP_DECODER(scalable_decoder_temp_buf, "no memory resource for scalable_decoder_temp_buf");
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 *)
a2dp_audio_list_node(node);
decoder_frame_p =
(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 =
ssc_decode(scalableDec_handle,
decoder_frame_p->buffer, ss_pcm_buff, SCALABLE_FRAME_SIZE,0,2);
output_samples = ssc_decode(scalableDec_handle, decoder_frame_p->buffer,
ss_pcm_buff, SCALABLE_FRAME_SIZE, 0, 2);
TRACE_A2DP_DECODER_D
("scalable_decode seq:%d len:%d output_samples:%d",
decoder_frame_p->sequenceNumber, decoder_frame_p->buffer_len, output_samples);
TRACE_A2DP_DECODER_D("scalable_decode seq:%d len:%d output_samples:%d",
decoder_frame_p->sequenceNumber,
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 *)
a2dp_audio_heap_malloc(sizeof(a2dp_audio_scalable_decoder_frame_t));
decoder_frame_p =
(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)
{
a2dp_audio_scalable_decoder_frame_t *decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *) packet;
static void a2dp_audio_scalable_free(void *packet) {
a2dp_audio_scalable_decoder_frame_t *decoder_frame_p =
(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_frame_malloc(buffer_bytes);
TRACE_A2DP_DECODER_D("%s seq:%d len:%d", __func__, header->sequenceNumber, buffer_bytes);
a2dp_audio_scalable_decoder_frame_t *decoder_frame_p =
(a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_scalable_frame_malloc(
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 *)
a2dp_audio_list_node(node);
decoder_frame_p =
(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 *)
a2dp_audio_list_node(node);
if (A2DP_AUDIO_SYNCFRAME_CHK(decoder_frame_p->sequenceNumber == 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)) {
decoder_frame_p =
(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) &&
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 *)
a2dp_audio_list_node(node);
decoder_frame_p =
(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)
{
decoder_frame_p = (a2dp_audio_scalable_decoder_frame_t *)
a2dp_audio_list_node(node);
if (node) {
decoder_frame_p =
(a2dp_audio_scalable_decoder_frame_t *)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)
{
scalable_decoder_frame = (a2dp_audio_scalable_decoder_frame_t *)a2dp_audio_list_node(node);
if (node) {
scalable_decoder_frame =
(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

787
apps/audioplayers/a2dpplay.cpp
View file

File diff suppressed because it is too large Load diff

413
apps/audioplayers/app_audio.cpp
View file

@ -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
// can be overlayed with the sco used audio buffer
static uint8_t* capture_audio_buffer = __HeapLimit + heap_size - APP_CAPTURE_AUDIO_BUFFER_SIZE;
// from the bottom of the system available memory pool, size is
// 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;
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",
size, capture_audio_buff_size_used, app_capture_audio_mempool_free_buff_size());
TRACE_AUD_HDL_I("[CAPMEM][GET] %d, now used %d left %d", 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 = {
.audio_list = NULL
};
APP_AUDIO_CONFIG app_audio_conifg = {.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()
{
osMutexRelease(g_app_audio_queue_mutex_id);
}
void UNLOCK_APP_AUDIO_QUEUE() { 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 (app_audio_manager_capture_is_active())
{
if ((BT_STREAM_SBC == stream_type) || (BT_STREAM_MEDIA == stream_type)) {
if (app_audio_manager_capture_is_active()) {
isToResetCaptureStream = true;
}
}
if (isToResetCaptureStream)
{
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP,
BT_STREAM_CAPTURE, 0, 0);
if (isToResetCaptureStream) {
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP, 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(
"[OPEN] before status_id: 0x%x%s, aud_id: %d, len = %d",
aud_status.id,
player2str(aud_status.id),
aud_status.aud_id,
TRACE_AUD_HDL_I("[OPEN] before status_id: 0x%x%s, aud_id: %d, len = %d",
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(
"[OPEN] after status_id: 0x%x%s, len = %d",
aud_status.id,
TRACE_AUD_HDL_I("[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(
"[CLOSE] current id: 0x%x%s",
aud_status.id,
TRACE_AUD_HDL_I("[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))
{
TRACE_AUD_HDL_I(
"[CLOSE] %p, next id: 0x%x%s, status %d",
&next_status,
next_status.id,
player2str(next_status.id),
if (app_audio_list_rmv_callback(&aud_status, &next_status,
APP_BT_SETTING_Q_POS_HEAD, false)) {
TRACE_AUD_HDL_I("[CLOSE] %p, next id: 0x%x%s, status %d", &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)
{
TRACE_AUD_HDL_I("[HANDLE_FREE] , aud_id: 0x%x, type = 0x%x", status->aud_id, status->aud_type);
if (status->id == APP_PLAY_BACK_AUDIO) {
TRACE_AUD_HDL_I("[HANDLE_FREE] , aud_id: 0x%x, type = 0x%x", status->aud_id,
status->aud_type);
}
#endif
osPoolFree(app_audio_status_mempool, data);
}
void app_audio_list_create()
{
if (app_audio_conifg.audio_list == NULL)
{
void app_audio_list_create() {
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 (list_length(app_audio_conifg.audio_list) >= MAX_AUDIO_BUF_LIST)
{
if (app_audio_list_stream_exist())
{
data_to_append = (APP_AUDIO_STATUS *)osPoolCAlloc (app_audio_status_mempool);
if(data_to_append == NULL)
{
if (app_audio_list_playback_exist()) {
if (list_length(app_audio_conifg.audio_list) >= MAX_AUDIO_BUF_LIST) {
if (app_audio_list_stream_exist()) {
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), \
data_to_append->status, list_length(app_audio_conifg.audio_list), ret);
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),
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
TRACE_AUD_HDL_I("[STREAM_LIST][RMV] audio list len %d close_id 0x%x%s", list_length(app_audio_conifg.audio_list), \
status_close->id, player2str(status_close->id));
if(list_length(app_audio_conifg.audio_list) == 0)
{
// for status: first bt_a2dp->APP_BT_SETTING_CLOSE,then ring->
// APP_BT_SETTING_CLOSE
TRACE_AUD_HDL_I("[STREAM_LIST][RMV] audio list len %d close_id 0x%x%s",
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)
{
for (node = list_begin(app_audio_conifg.audio_list); node != list_end(app_audio_conifg.audio_list); node = list_next(node))
{
if (status_close->id == APP_PLAY_BACK_AUDIO) {
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 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(pos == APP_BT_SETTING_Q_POS_HEAD)
{
if (app_audio_list_stream_exist()) {
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()
{
list_clear(app_audio_conifg.audio_list);
}
void app_audio_list_clear() { list_clear(app_audio_conifg.audio_list); }
#endif
void app_audio_open(void)
{
if(app_audio_init)
{
void app_audio_open(void) {
if (app_audio_init) {
return;
}
if (g_app_audio_queue_mutex_id == NULL)
{
g_app_audio_queue_mutex_id = osMutexCreate((osMutex(g_app_audio_queue_mutex)));
}
else
{
if (g_app_audio_queue_mutex_id == NULL) {
g_app_audio_queue_mutex_id =
osMutexCreate((osMutex(g_app_audio_queue_mutex)));
} 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;
}

406
apps/audioplayers/bt_sco_chain.c
View file

@ -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 |
| | | | | 16k 8k | |
| TX/RX | New | Old | description
| MIPS(M) | Note | | | | | | 16k 8k |
|
|-------|--------------------|-----------------------------------|----------------------------------|-----------|----------------------|
| | SPEECH_TX_DC_FILTER| | Direct Current filter | 1~2 \ | |
| | SPEECH_TX_AEC | SPEECH_ECHO_CANCEL | Acoustic Echo Cancellation(old) | 40 \ | HWFFT: 37 |
| | SPEECH_TX_AEC2 | SPEECH_AEC_FIX | Acoustic Echo Cancellation(new) | 39 \ | enable NLP |
| | SPEECH_TX_AEC3 | | Acoustic Echo Cancellation(new) | 14/18 \ | 2 filters/4 filters |
| | SPEECH_TX_AEC2FLOAT| | Acoustic Echo Cancellation(new) | 23/22 \ | nlp/af(blocks=1) |
| | SPEECH_TX_AEC2FLOAT| | Acoustic Echo Cancellation(ns) | 14/10 \ | banks=256/banks=128 |
| | (ns_enabled) | | | 8/6 \ | banks=64/banks=32 |
| | SPEECH_TX_NS | SPEECH_NOISE_SUPPRESS | 1 mic noise suppress(old) | 30 \ | HWFFT: 19 |
| | SPEECH_TX_NS2 | LC_MMSE_NOISE_SUPPRESS | 1 mic noise suppress(new) | 16 \ | HWFFT: 12 |
| | SPEECH_TX_NS3 | | 1 mic noise suppress(new) | 26 \ | |
| | SPEECH_TX_NS2FLOAT | LC_MMSE_NOISE_SUPPRESS_FLOAT | 1 mic noise suppress(new float) | 12.5 \ | banks=64 |
| TX | SPEECH_TX_2MIC_NS | DUAL_MIC_DENOISE | 2 mic noise 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_TX_DC_FILTER| | Direct
Current filter | 1~2 \ | | | |
SPEECH_TX_AEC | SPEECH_ECHO_CANCEL | Acoustic Echo
Cancellation(old) | 40 \ | HWFFT: 37 | | | SPEECH_TX_AEC2
| SPEECH_AEC_FIX | Acoustic Echo Cancellation(new) | 39 \ |
enable NLP | | | SPEECH_TX_AEC3 | | Acoustic Echo
Cancellation(new) | 14/18 \ | 2 filters/4 filters | | |
SPEECH_TX_AEC2FLOAT| | Acoustic Echo
Cancellation(new) | 23/22 \ | nlp/af(blocks=1) | | |
SPEECH_TX_AEC2FLOAT| | Acoustic Echo
Cancellation(ns) | 14/10 \ | banks=256/banks=128 | | | (ns_enabled)
| | | 8/6 \
| banks=64/banks=32 | | | SPEECH_TX_NS | SPEECH_NOISE_SUPPRESS |
1 mic noise suppress(old) | 30 \ | HWFFT: 19 | | |
SPEECH_TX_NS2 | LC_MMSE_NOISE_SUPPRESS | 1 mic noise
suppress(new) | 16 \ | HWFFT: 12 | | |
SPEECH_TX_NS3 | | 1 mic noise
suppress(new) | 26 \ | | | |
SPEECH_TX_NS2FLOAT | LC_MMSE_NOISE_SUPPRESS_FLOAT | 1 mic noise
suppress(new float) | 12.5 \ | banks=64 | | TX |
SPEECH_TX_2MIC_NS | DUAL_MIC_DENOISE | 2 mic noise
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 \ | |
| RX | SPEECH_RX_NS2 | LC_MMSE_NOISE_SUPPRESS_SPK | 1 mic noise 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 |
| | SPEECH_RX_NS | SPEAKER_NOISE_SUPPRESS | 1 mic noise
suppress(old) | 30 \ | | | RX |
SPEECH_RX_NS2 | LC_MMSE_NOISE_SUPPRESS_SPK | 1 mic noise
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(
short *pshwDes,
short *pshwSrc,
short swLen)
{
void CODEC_OpVecCpy(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)
{
TRACE(3,"[%s] dualmic status: %d -> %d", __FUNCTION__, dualmic_enable, !dualmic_enable);
void switch_dualmic_status(void) {
TRACE(3, "[%s] dualmic status: %d -> %d", __FUNCTION__, 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)
{
if (speech_cfg)
{
int speech_store_config(const SpeechConfig *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)
{
TRACE(3,"[%s] Start, sample_rate: %d, frame_len: %d", __func__, sample_rate, 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,
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_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);
speech_tx_dc_filter_st =
speech_dc_filter_create(sample_rate, &speech_cfg->tx_dc_filter);
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_aec_ctl(speech_tx_aec_st, SPEECH_AEC_GET_LIB_ST, &speech_tx_aec_lib_st);
speech_tx_aec_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, 128, 256, 31, &speech_cfg->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, 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)
{
TRACE(3,"[%s] Start, sample_rate: %d, frame_len: %d", __func__, sample_rate, 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,
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 tx_frame_ms, int rx_frame_ms,
int sco_frame_ms,
uint8_t *buf, int len)
{
int speech_init(int tx_sample_rate, int rx_sample_rate, int tx_frame_ms,
int rx_frame_ms, 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);
if (sco_overlay_ram_buf_len >= 1024)
{
TRACE(2, "[%s] sco_overlay_ram_buf_len = %d", __func__,
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_;
PLAYBACK_HANDLER_T rx_handler = (rx_frame_ms == sco_frame_ms) ? NULL : _speech_rx_process_;
CAPTURE_HANDLER_T tx_handler =
(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_TX_CHANNEL_NUM,
speech_tx_frame_len,
capture_sample_size,
playback_sample_size,
aec_enable,
tx_handler,
rx_handler
);
speech_frame_resize_st = frame_resize_create(
SPEECH_FRAME_MS_TO_LEN(tx_sample_rate, sco_frame_ms),
SPEECH_TX_CHANNEL_NUM, speech_tx_frame_len, capture_sample_size,
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
// return 0
// If has MIPS problem, can move this block code into speech_rx_process or
// 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)
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);
#if (SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2) && defined(AUDIO_DUMP) && \
defined(BT_SCO_CHAIN_AUDIO_DUMP)
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)
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);
#if (SPEECH_CODEC_CAPTURE_CHANNEL_NUM == 2) && defined(AUDIO_DUMP) && \
defined(BT_SCO_CHAIN_AUDIO_DUMP)
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));
ec2float_set_external_vad(speech_tx_aec2float_st, sensormic_denoise_get_vad(speech_tx_2mic_ns4_st));
TRACE(2, "[%s] vad: %d", __FUNCTION__,
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;

297
apps/audioplayers/bt_sco_chain_cfg_default.c
View file

@ -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
* in this file
* Resource consumption:
* RAM: None
* FLASE: None
* MIPS: fs = 16kHz, 0.5M/section;
* Note:
* None
* calib: {bypass, gain, num, {type, frequency, gain, q}}. Please refer to
*SPEECH_TX_EQ section in this file Resource consumption: 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, };
const SpeechFirCalibConfig WEAK speech_tx_mic_fir_calib_cfg =
{
float mic2_ft_caliration[256] = {
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
* echo supression and large damage to speech signal.
* leak_estimate_shift(0~8): echo supression value. if leak_estimate == 0, then leak_estimate_shift
* can take effect. This is a adaptive mode. It has relatively small echo supression and also
* small damage to speech signal.
* Resource consumption:
* RAM: None
* FLASE: None
* MIPS: fs = 16kHz, 40M;
* Note:
* If possible, use SPEECH_TX_AEC2FLOAT
* leak_estimate(0~32767): echo supression value. This is a fixed mode.
*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 can take effect. This is a adaptive mode. It
*has relatively small echo supression and also small damage to speech
*signal. Resource consumption: RAM: None 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.
* af_enabled(0/1): adaptive filter enable or disable. If the echo signal is very large, enable this
* nlp_enabled(0/1): non-linear process enable or disable. Enable this by default.
* ns_enabled(0/1): noise supression enable or disable. Enable this by default.
* cng_enabled(0/1): comfort noise generator enable or disable.
* hpf_enabled(0/1): high pass filter enable or disable. Used to remove
*DC for Near and Ref signals. af_enabled(0/1): adaptive filter enable or
*disable. If the echo signal is very large, enable this nlp_enabled(0/1):
*non-linear process enable or disable. Enable this by default.
* 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.
* target_supp(<0): target echo suppression, unit(dB)
* noise_supp(-30~0): noise suppression, unit(dB)
* cng_type(0/1): noise type(0: White noise; 1: Pink noise)
* cng_level(<0): noise gain, unit(dB)
* Resource consumption:
* RAM: None
* FLASE: None
* MIPS: fs = 16kHz;
* Note:
* This is the recommended AEC
* min_ovrd(1~6): supression factor, min_ovrd becomes larger and echo
*suppression becomes larger. target_supp(<0): target echo suppression,
*unit(dB) noise_supp(-30~0): noise suppression, unit(dB) cng_type(0/1):
*noise type(0: White noise; 1: Pink noise) cng_level(<0): noise gain,
*unit(dB) Resource consumption: 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
* d(MIC~mouth): The dinstance from MIC to mouth
* e.g. 0: 0~2cm; 1: 2~4; 2: 5~6...
* freq_smooth_enable(1): Must enable
* wnr_enable(0/1): wind noise reduction enable or disable. This is also useful for improving
* noise suppression, but it also has some damage to speech signal.
* Resource consumption:
* RAM: None
* FLASE: None
* MIPS: fs = 16kHz, 32M;
* Note:
* None
* ceil: Returns the largest integer less than or equal to the
*specified data d(MIC~mouth): The dinstance from MIC to mouth e.g. 0:
*0~2cm; 1: 2~4; 2: 5~6... freq_smooth_enable(1): Must enable
* wnr_enable(0/1): wind noise reduction enable or disable. This is also
*useful for improving noise suppression, but it also has some damage to
*speech signal. Resource consumption: 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
* ceil: Returns the largest integer less than or equal to the specified data
* d(MIC~mouth): The dinstance from MIC to mouth
* e.g. 0: 0~2cm; 1: 2~4; 2: 5~6...
* freq_smooth_enable(1): Must enable
* wnr_enable(0/1): wind noise reduction enable or disable. This is also useful for improving
* noise suppression, but it also has some damage to speech signal.
* delay_enable(0/1): enable the delay_taps or not. Ideally, never need to enable the delay and
* delay_taps will be a useless parameter.
* Resource consumption:
* RAM: None
* FLASE: None
* MIPS: fs = 16kHz, 32M;
* Note:
* delay_taps(0~4): ceil{[d(MIC1~mouth) - d(MIC2~mouth)] / 2}. Default
*as 0 ceil: Returns the largest integer less than or equal to the specified
*data d(MIC~mouth): The dinstance from MIC to mouth e.g. 0: 0~2cm; 1: 2~4;
*2: 5~6... freq_smooth_enable(1): Must enable wnr_enable(0/1): wind noise
*reduction enable or disable. This is also useful for improving noise
*suppression, but it also has some damage to speech signal.
* delay_enable(0/1): enable the delay_taps or not. Ideally, never need
*to enable the delay and delay_taps will be a useless parameter. 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[1] = {0.323801506930344, -1.29520602772138, 1.94280904158206, -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},
// .coefH[0] = {1.0, -1.88561808316413, 1.55555555555556,
// -0.628539361054709, 0.111111111111111}, .coefH[1] =
// {0.323801506930344, -1.29520602772138, 1.94280904158206,
// -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_tapsS(0~4): MIC L/S delay samples. Refer to 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
* noise suppression, but it also has some damage to speech signal.
* Resource consumption:
* RAM: None
* FLASE: None
* MIPS: fs = 16kHz;
* Note:
* None
* delay_tapsM(0~4): MIC L/R delay samples. Refer to SPEECH_TX_2MIC_NS2
*delay_taps delay_tapsS(0~4): MIC L/S delay samples. Refer to
*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 noise suppression, but it also has some damage to
*speech signal. Resource consumption: RAM: 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
* d(MIC~mouth): The dinstance from MIC to mouth
* e.g. 0: 0~2cm; 1: 2~4; 2: 5~6...
* freq_smooth_enable(1): Must enable
* wnr_enable(0/1): wind noise reduction enable or disable. This is also useful for improving
* noise suppression, but it also has some damage to speech signal.
* Resource consumption:
* RAM: None
* FLASE: None
* MIPS: fs = 16kHz, 32M;
* Note:
* None
* ceil: Returns the largest integer less than or equal to the
*specified data d(MIC~mouth): The dinstance from MIC to mouth e.g. 0:
*0~2cm; 1: 2~4; 2: 5~6... freq_smooth_enable(1): Must enable
* wnr_enable(0/1): wind noise reduction enable or disable. This is also
*useful for improving noise suppression, but it also has some damage to
*speech signal. Resource consumption: 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
spectrum for all frequencies
* power_ratio_thr: ratio of the power spectrum of the lower 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_shift(1~3): 1: -6dB; 2: -12dB; 3: -18dB
* data_threshold(0~32767): distinguish between noise and speech,
*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.
* Resource consumption:
* RAM: None
* FLASE: None
* limiter_enable(0/1): 0: target_level does not take effect; 1:
*target_level takes effect. Resource consumption: 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
* Resource consumption:
* RAM: None
* FLASE: None
* MIPS: fs = 16kHz, 0.5M/section;
* Note:
* None
* params: {type, frequency, gain, q}. It supports a lot of types,
*please refer to iirfilt.h file Resource consumption: RAM: 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,
},

73
apps/audioplayers/bt_sco_chain_cp.c
View file

@ -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);
* 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.
* 3. Change channel number if the algo(run in cp) input is more than one
*channel: sco_cp_init(speech_tx_frame_len, 1);
* 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.
* 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();
* 1. spx fft and hw fft will share buffer, so just one core can use these
*fft.
* 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 "speech_cfg.h"
#include "hal_trace.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));
}
else
{
cp_accel_send_event_mcu2cp(
CP_BUILD_ID(CP_TASK_SCO, CP_EVENT_SCO_PROCESSING));
} 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};
int sco_cp_init(int frame_len, int channel_num)
{
TRACE(3,"[%s] frame_len: %d, channel_num: %d", __func__, frame_len, 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);
static struct cp_task_desc TASK_DESC_SCO = {CP_ACCEL_STATE_CLOSED, sco_cp_main,
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);
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);

51
apps/audioplayers/bt_sco_chain_thirdparty.c
View file

@ -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 tx_frame_ms, int rx_frame_ms,
int sco_frame_ms,
uint8_t *buf, int len)
{
int speech_init(int tx_sample_rate, int rx_sample_rate, int tx_frame_ms,
int rx_frame_ms, 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_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);
speech_tx_dc_filter_st =
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_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_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);
audio_dump_add_channel_data(0, ref_buf,
pcm_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
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;
}

78
apps/audioplayers/bt_sco_chain_thirdparty_alango.c
View file

@ -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 tx_frame_ms, int rx_frame_ms,
int sco_frame_ms,
uint8_t *buf, int len)
{
int speech_init(int tx_sample_rate, int rx_sample_rate, int tx_frame_ms,
int rx_frame_ms, 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_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);
audio_dump_add_channel_data(0, ref_buf,
pcm16_len / SPEECH_CODEC_CAPTURE_CHANNEL_NUM);
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);
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));
deinterleave_audio(deinterleaved_buf, &pcm16_buf[i],
curr_profile->p_gen->frlen *
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;

102
apps/audioplayers/bt_sco_chain_tuning.c
View file

@ -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)
{
return speech_tuning_status;
}
bool speech_tuning_get_status(void) { 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));
}
else
{
TRACE(0, "[Speech Tuning] res : 1; info : Send len(%d) != config_size(%d);",
len, sizeof(SpeechConfig));
} 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));
}
else
{
TRACE(0, "[Speech Tuning] res : 1; info : Burn len(%d) != config_size(%d);",
len, sizeof(SpeechConfig));
} 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;");
}
else
{
TRACE(0, "[Speech Tuning] res : 2; info : Do not enable "
"AUDIO_SECTION_ENABLE;");
} 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;

12
apps/audioplayers/cvsdplay.cpp
View file

@ -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() \
osMutexRelease(g_voicecvsd_queue_mutex_id)
#define UNLOCK_VOICECVSD_QUEUE() osMutexRelease(g_voicecvsd_queue_mutex_id)
void xLOCK_VOICECVSD_QUEUE(void)
{

18
apps/audioplayers/digmici2splay.cpp
View file

@ -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);

44
apps/audioplayers/flacplay.cpp
View file

@ -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() \
osMutexWait(g_flac_queue_mutex_id, osWaitForever)
#define LOCK_FLAC_QUEUE() osMutexWait(g_flac_queue_mutex_id, osWaitForever)
#define UNLOCK_FLAC_QUEUE() \
osMutexRelease(g_flac_queue_mutex_id)
#define UNLOCK_FLAC_QUEUE() 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);

166
apps/audioplayers/fmradio.cpp
View file

@ -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 "audiobuffer.h"
#include "cqueue.h"
#include "app_audio.h"
#include "app_utils.h"
#include "app_overlay.h"
#include "string.h"
#include "hal_cmu.h"
#include "hal_dma.h"
#include "hal_timer.h"
#include "hal_trace.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)
{
FM_DIGITAL_REG(0xd0350244) = (FM_DIGITAL_REG(0xd0350244) & ~0x01fff) | 0x20f; //-890k -> 0 if_shift, for 110.5292m adc
void fm_radio_digit_init(void) {
FM_DIGITAL_REG(0xd0350244) = (FM_DIGITAL_REG(0xd0350244) & ~0x01fff) |
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) & ~0x18000) | 0x18000; // for dual channel adc/dac
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) & ~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) | 0x40000900; //set for sdm gain
FM_DIGITAL_REG(0x4000a044) = (FM_DIGITAL_REG(0x4000a044) & ~0x60000000) | 0x60000000; //for adc en, and dac en
FM_DIGITAL_REG(0x4000a048) = (FM_DIGITAL_REG(0x4000a048) & ~0x00000f00) |
0x40000900; // set for sdm gain
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'h07 , 16'b0000_0010_1011_1001 ) ; // reg_btfm_flt_pu_dr
rfspi_wvalue( 8'h2d , 16'b0000_0111_1000_0010 ) ; // bb ldo on
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'h25 , 16'b0000_0000_0000_0000 ) ; // 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
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'h25 , 16'b0000_0000_0000_0000 )
; // 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( 0x25 , 0b0000000000000000 ) ; // vco freq[15:00] fm_freq = frf/(4*reg_bt_vco_fm_div_ctrl)
fm_write_rf_reg(0x26, 0b0000000000000000); // vco freq[31:16] ( 2400 + x
// )*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

16
apps/audioplayers/msbcplay.cpp
View file

@ -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() \
osMutexRelease(g_voicemsbc_queue_mutex_id)
#define UNLOCK_VOICEMSBC_QUEUE() osMutexRelease(g_voicemsbc_queue_mutex_id)
static void dump_buffer_to_psram(char *buf, unsigned int len)
{

89
apps/audioplayers/plc_utils.c
View file

@ -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
* satuation.
* Do not check this by default
* if msbc frame is filled by 10+ samples in the trail, crc maybe not detect
* this satuation. 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)) ||
((buf[1] & 0x0f) != 0x08) ||
if (((buf[0] != 0x01) && (buf[0] != 0x00)) || ((buf[1] & 0x0f) != 0x08) ||
(buf[2] != 0xad)) {
return -1;
}
#else
if ((buf[0] != 0x01) ||
((buf[1] & 0x0f) != 0x08) ||
(buf[2] != 0xad)) {
if ((buf[0] != 0x01) || ((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,
// otherwise a single conflict may be detected twice
static bool update_ble_sco_conflict(PacketLossState* st, uint8_t *last_pkt, uint8_t *pkt)
{
// when signal is mute, msbc data remains the same except seq num. We should
// 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) {
// 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);
}

296
apps/audioplayers/rbplay/rb_ctl.cpp
View file

@ -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 "hal_timer.h"
#include "hal_trace.h"
#include "app_audio.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)
{
return rb_ctl_context.status;
}
static rb_ctl_status rb_ctl_get_status(void) { 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)
{
return (int)osThreadGetPriority(rb_ctl_tid);
}
int rb_ctl_get_priority(void) { return (int)osThreadGetPriority(rb_ctl_tid); }
int rb_ctl_get_default_priority(void)
{
return rb_ctl_default_priority;
}
int rb_ctl_get_default_priority(void) { 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_fname,it->file_name,sizeof(rb_ctl_context.rb_fname));
memcpy(rb_ctl_context.rb_audio_file, it->file_path,
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)
{
_LOG_DBG(3," %s onoff %d, get status:%d",__FUNCTION__,onoff, rb_ctl_get_status());
int app_rbplay_audio_onoff(bool onoff, uint16_t aud_id) {
_LOG_DBG(3, " %s onoff %d, get status:%d", __FUNCTION__, onoff,
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)
{
return rb_ctl_context.rb_player_vol;
}
uint8_t rb_ctl_get_vol(void) { return rb_ctl_context.rb_player_vol; }
bool rb_ctl_is_init_done(void)
{
return rb_ctl_context.init_done;
}
bool rb_ctl_is_init_done(void) { return rb_ctl_context.init_done; }
bool rb_ctl_is_paused(void)
{
return ( RB_CTL_SUSPEND == rb_ctl_get_status());
}
uint16_t rb_ctl_songs_count(void)
{
return sd_playlist.total_songs;
}
bool rb_ctl_is_paused(void) { return (RB_CTL_SUSPEND == rb_ctl_get_status()); }
uint16_t rb_ctl_songs_count(void) { return sd_playlist.total_songs; }

44
apps/audioplayers/rbplay/rbpcmbuf.cpp
View file

@ -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);
}

142
apps/audioplayers/rbplay/rbplay.cpp
View file

@ -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 <ctype.h>
#include <stdlib.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 "rbplaysd.h"
#include "app_key.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)
{
thread_tid_waiter = NULL;
}
static void rb_player_sync_close_done(void) { thread_tid_waiter = NULL; }
extern void rb_check_stream_reconfig(int32_t freq, uint8_t ch);
static void f_codec_pcmbuf_insert_callback(
const void *ch1, const void *ch2, int count)
{
static void f_codec_pcmbuf_insert_callback(const void *ch1, const void *ch2,
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)
{
return false;
}
static bool f_codec_loop_track_callback(void) { 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)
{
return ((rb_decode_halt_flag == 0)?1:0);
}
int rb_codec_running(void) { return ((rb_decode_halt_flag == 0) ? 1 : 0); }
void rb_codec_set_halt(int halt)
{
rb_decode_halt_flag = halt;
}
void rb_codec_set_halt(int 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;
}

49
apps/audioplayers/rbplay/rbplaysd.cpp
View file

@ -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 <ctype.h>
#include <stdlib.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;
}

31
apps/audioplayers/voice_test.c
View file

@ -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);

1064
apps/audioplayers/voicebtpcmplay.cpp
View file

File diff suppressed because it is too large Load diff

460
apps/audioplayers/voicebtpcmplay_sco_dma_snapshot.cpp
View file

@ -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_cvsd_frames(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_msbc_frames(unsigned char *msbc_buf, unsigned int msbc_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);
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, uint8_t *out_buf,uint32_t out_len,int32_t codec_type)
{
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) {
// 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)
for (int i = SPEECH_CODEC_CAPTURE_CHANNEL_NUM, j = 0; i < pcm_len; i += SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1, j++) {
#if defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || \
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;
#elif (defined(SPEECH_TX_AEC) || defined(SPEECH_TX_AEC2) || defined(SPEECH_TX_AEC3) || defined(SPEECH_TX_AEC2FLOAT) || defined(SPEECH_TX_THIRDPARTY))
pcm_len = pcm_len / (SPEECH_CODEC_CAPTURE_CHANNEL_NUM + 1) *
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)
{
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))break;
if (msbc_find_first_sync == 0) {
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))
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
{
for (j = 0; j < msbc_len / MSBC_LEN_FORMBT_PER_FRAME; j++)
{
} else {
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++)
{
if (next_frame_flag == 1)
{
for (j = 0; j < (msbc_len / MSBC_LEN_FORMBT_PER_FRAME); j++) {
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
{
headerm1 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME-1];
} else {
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];
header1 = msbc_buf_all[msbc_offset_lowdelay + 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];
header0 =
msbc_buf_all[msbc_offset_lowdelay + j * MSBC_LEN_FORMBT_PER_FRAME];
header1 = msbc_buf_all[msbc_offset_lowdelay +
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) ||
(header0 == 0x01) && ((header1 & 0x0f) == 0x08) && (header2 == 0xad) ||
(header1 == 0x01) && ((header2 & 0x0f) == 0x08) && (header3 == 0xad))
/*if ((headerm1 == 0x01) && ((header0 & 0x0f) == 0x08) && (header1 ==
0xad) || (header0 == 0x01) && ((header1 & 0x0f) == 0x08) && (header2 ==
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];
if (tail0 == 0x00 || tail0 == 0x01|| tail0==0xff)
tail0 = msbc_buf_all[msbc_offset_lowdelay +
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) && (header2 == 0xad))
{
} else if ((header0 == 0x01) && ((header1 & 0x0f) == 0x08) &&
(header2 == 0xad)) {
frame_flag[j] = 0;
/*
tail0 = msbc_buf_all[msbc_offset_lowdelay + j*MSBC_LEN_FORMBT_PER_FRAME + 59];
if (tail0 == 0x00 || tail0 == 0x01|| tail0==0xff)
tail0 = msbc_buf_all[msbc_offset_lowdelay +
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) && (header3 == 0xad))
{
} else if ((header1 == 0x01) && ((header2 & 0x0f) == 0x08) &&
(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];
if (tail0 == 0x00 || tail0==0x01|| tail0==0xff)
tail0 = msbc_buf_all[msbc_offset_lowdelay +
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
{
if ((header0 == MSBC_MUTE_PATTERN)&& ((header1 & 0x0f) == (MSBC_MUTE_PATTERN & 0x0f)) && (header2 == MSBC_MUTE_PATTERN))
{
} else {
if ((header0 == MSBC_MUTE_PATTERN) &&
((header1 & 0x0f) == (MSBC_MUTE_PATTERN & 0x0f)) &&
(header2 == MSBC_MUTE_PATTERN)) {
frame_flag[j] = 1;
}
else
{
if((msbc_offset_lowdelay+j*MSBC_LEN_FORMBT_PER_FRAME)>=msbc_offset_total)
{
} else {
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))
{
//TRACE(3,"[%s] decoding, offset %d, offset drift %d", __FUNCTION__, msbc_offset, msbc_offset_drift[frame_counter]);
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]);
// 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,
(unsigned char *)dec_msbc_buf,
MSBC_LEN_PER_FRAME, &byte_decode,
&pcm_data, SAMPLES_LEN_PER_FRAME*2,
msbc_eq_band_gain);
ret = btif_sbc_decode_frames(msbc_decoder, (unsigned char *)dec_msbc_buf,
MSBC_LEN_PER_FRAME, &byte_decode, &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,
(unsigned char *)indices0,
MSBC_LEN_PER_FRAME, &byte_decode,
&pcm_data, SAMPLES_LEN_PER_FRAME*2,
msbc_eq_band_gain);
ret =
btif_sbc_decode_frames(msbc_decoder, (unsigned char *)indices0,
MSBC_LEN_PER_FRAME, &byte_decode, &pcm_data,
SAMPLES_LEN_PER_FRAME * 2, 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_HEADER1_BYTES ((MSBC_LEN_PER_FRAME-MSBC_OFFSET_BYTES+1)%MSBC_LEN_PER_FRAME)
#define MSBC_OFFSET_HEADER0_BYTES \
((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)
{
//TRACE(2,"process_downlink_cvsd_frames pcm_len:%d,cvsd_len:%d",pcm_len,cvsd_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);
#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)
{
//TRACE(2,"process_uplink_cvsd_frames pcm_len:%d,cvsd_len:%d",pcm_len,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);
#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);
codec_frame_length = SPEECH_FRAME_MS_TO_LEN(codec_sample_rate, SPEECH_SCO_FRAME_MS);
sco_frame_length =
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] RX: sample rate = %d, frame len = %d", __func__, codec_sample_rate, codec_frame_length);
TRACE(3, "[%s] TX: sample rate = %d, frame len = %d", __func__,
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())
{
app_audio_mempool_get_buff((uint8_t **)&msbc_encoder, sizeof(btif_sbc_encoder_t));
app_audio_mempool_get_buff((uint8_t **)&msbc_decoder, sizeof(btif_sbc_decoder_t));
if (bt_sco_codec_is_msbc()) {
app_audio_mempool_get_buff((uint8_t **)&msbc_encoder,
sizeof(btif_sbc_encoder_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
};//-12~12
6.309573, 7.943282, 10, 12.589254, 15.848932}; //-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 = (uint8_t *)hal_overlay_get_text_free_addr((enum HAL_OVERLAY_ID_T)APP_OVERLAY_HFP);
sco_overlay_ram_buf_len =
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));
downlink_resample_st = iir_resample_init(sco_frame_length, iir_resample_choose_mode(sco_sample_rate, codec_sample_rate));
uplink_resample_st = iir_resample_init(
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);

55
apps/audioplayers/wavplay.cpp
View file

@ -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;

503
apps/battery/app_battery.cpp
View file

@ -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 "pmu.h"
#include "hal_timer.h"
#include "hal_chipid.h"
#include "hal_gpadc.h"
#include "hal_trace.h"
#include "hal_gpio.h"
#include "hal_iomux.h"
#include "hal_chipid.h"
#include "app_thread.h"
#include "app_battery.h"
#include "apps.h"
#include "app_status_ind.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "pmu.h"
#include "tgt_hardware.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_GET_STATUS(appevt, status) (status = (appevt>>16)&0xffff)
#define APP_BATTERY_SET_MESSAGE(appevt, status, volt) \
(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)
{
for (i=0; i<APP_BATTERY_STABLE_COUNT; i++)
{
if (app_battery_measure.index > APP_BATTERY_STABLE_COUNT) {
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 (meanBattVolt>app_battery_measure.highvolt)
{
if (app_battery_measure.cb) {
if (meanBattVolt > app_battery_measure.highvolt) {
app_battery_measure.cb(APP_BATTERY_STATUS_OVERVOLT, meanBattVolt);
}
else if((meanBattVolt>app_battery_measure.pdvolt) && (meanBattVolt<app_battery_measure.lowvolt))
{
} else if ((meanBattVolt > app_battery_measure.pdvolt) &&
(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)
{
hal_gpadc_open(HAL_GPADC_CHAN_BATTERY, HAL_GPADC_ATP_ONESHOT, app_battery_irqhandler);
static void app_battery_timer_handler(void const *param) {
hal_gpadc_open(HAL_GPADC_CHAN_BATTERY, HAL_GPADC_ATP_ONESHOT,
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)
{
switch (status)
{
int app_battery_handle_process_charging(uint32_t status,
union APP_BATTERY_MSG_PRAMS prams) {
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_status_indication_get() != APP_STATUS_INDICATION_FULLCHARGE)
{
if (app_battery_charger_handle_process() <= 0) {
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++)
{
generatedSeed ^= (((uint32_t)(bt_addr[index])) << (hal_sys_timer_get()&0xF));
for (uint8_t index = 0; index < sizeof(bt_addr); index++) {
generatedSeed ^=
(((uint32_t)(bt_addr[index])) << (hal_sys_timer_get() & 0xF));
}
srand(generatedSeed);
if (status == APP_BATTERY_STATUS_PLUGINOUT) {
app_battery_pluginout_debounce_start();
}
else
{
switch (app_battery_measure.status)
{
} else {
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->chargingStatus = ((app_battery_measure.status == APP_BATTERY_STATUS_CHARGING)? 1:0);
pBatteryInfo =
(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,
batteryLevel, app_battery_measure.status,status,msg_prams);
app_battery_measure.user_cb(app_battery_measure.currvolt, batteryLevel,
app_battery_measure.status, status, msg_prams);
}
return 0;
}
int app_battery_register(APP_BATTERY_CB_T user_cb)
{
if(NULL == app_battery_measure.user_cb)
{
int app_battery_register(APP_BATTERY_CB_T 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)
{
if (currvolt)
{
int app_battery_get_info(APP_BATTERY_MV_T *currvolt, uint8_t *currlevel,
enum APP_BATTERY_STATUS_T *status) {
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)
{
APP_BATTERY_TRACE(3,"%s batt range:%d~%d",__func__, APP_BATTERY_MIN_MV, APP_BATTERY_MAX_MV);
int app_battery_open(void) {
APP_BATTERY_TRACE(3, "%s batt range:%d~%d", __func__, APP_BATTERY_MIN_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)
{
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&app_battery_ext_charger_detecter_cfg, 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_detecter_cfg.pin != HAL_IOMUX_PIN_NUM) {
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP
*)&app_battery_ext_charger_detecter_cfg,
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)
{
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&app_battery_ext_charger_detecter_cfg, 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_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM) {
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP
*)&app_battery_ext_charger_detecter_cfg,
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)
{
hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin, HAL_GPIO_DIR_OUT, 0);
if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM) {
hal_gpio_pin_set_dir(
(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, int32_t t2, int32_t v2)
{
static int32_t app_battery_charger_slope_calc(int32_t t1, int32_t v1,
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.currvolt>=(app_battery_measure.highvolt+APP_BATTERY_CHARGE_OFFSET_MV))
{
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)) {
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_ext_charger_detecter_cfg.pin != HAL_IOMUX_PIN_NUM)
{
if (hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin))
{
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 (hal_gpio_pin_get_val(
(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.prevolt)
{
app_battery_measure.charger_status.slope_1000[app_battery_measure.charger_status.slope_1000_index%APP_BATTERY_CHARGING_SLOPE_TABLE_COUNT] = slope_1000;
if ((app_battery_measure.charger_status.cnt++ %
APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT) == 0) {
if (!app_battery_measure.charger_status.prevolt) {
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++) {
app_battery_measure.charger_status.slope_1000[i] = 100;
}
}
else
{
slope_1000 = app_battery_charger_slope_calc(0, app_battery_measure.charger_status.prevolt,
APP_BATTERY_CHARGING_PERIODIC_MS*APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT/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;
} else {
slope_1000 = app_battery_charger_slope_calc(
0, app_battery_measure.charger_status.prevolt,
APP_BATTERY_CHARGING_PERIODIC_MS *
APP_BATTERY_CHARGING_SLOPE_MEASURE_CNT / 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);
if (cnt>1)
{
TRACE(3, "app_battery_charger_slope_proc slope*1000=%d cnt:%d nRet:%d",
slope_1000, cnt, nRet);
if (cnt > 1) {
nRet = 1;
} /*else (3>=cnt && cnt>=-3){
nRet = 0;
}*/else
{
if (app_battery_measure.currvolt>=(app_battery_measure.highvolt-APP_BATTERY_CHARGE_OFFSET_MV))
{
}*/
else {
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)
{
enum APP_BATTERY_CHARGER_T status_charger = app_battery_charger_forcegetstatus();
static void app_battery_pluginout_debounce_handler(void const *param) {
enum APP_BATTERY_CHARGER_T status_charger =
app_battery_charger_forcegetstatus();
if (app_battery_pluginout_debounce_ctx == (uint32_t)status_charger) {
app_battery_pluginout_debounce_cnt++;
}
else
{
TRACE(2,"%s dithering cnt %u", __func__, app_battery_pluginout_debounce_cnt);
} else {
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");
if (status_charger == APP_BATTERY_CHARGER_PLUGIN)
{
if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM)
{
hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin, HAL_GPIO_DIR_OUT, 0);
TRACE(2, "%s %s", __func__,
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) {
hal_gpio_pin_set_dir(
(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
{
if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM)
{
hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin, HAL_GPIO_DIR_OUT, 1);
} else {
if (app_battery_ext_charger_enable_cfg.pin != HAL_IOMUX_PIN_NUM) {
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 (!hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)app_battery_ext_charger_detecter_cfg.pin))
{
if (app_battery_ext_charger_detecter_cfg.pin != HAL_IOMUX_PIN_NUM) {
if (!hal_gpio_pin_get_val(
(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)
{
for (uint8_t i=0; i<NTC_CAPTURE_STABLE_COUNT; i++)
{
if (ntc_capture_measure.index > NTC_CAPTURE_STABLE_COUNT) {
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;
}

161
apps/btusbaudio/btusb_audio.c
View file

@ -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);
//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);
// A2DP_Register((a2dp_stream_t
// *)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)
{
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_CLOSEALL, 0);
if (is_wait) {
app_audio_sendrequest(APP_PLAY_BACK_AUDIO,
(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_SETUP, 0);
}
else
{
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_SETUP,
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 {
if(btapp_hfp_is_call_active() == 1)
{
} else {
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)
{
if(btusb_mode == BTUSB_MODE_BT)
{
void test_btusb_switch(void) {
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)
{
btusb_switch(BTUSB_MODE_BT);
}
void test_btusb_switch_to_bt(void) { btusb_switch(BTUSB_MODE_BT); }
void test_btusb_switch_to_usb(void)
{
btusb_switch(BTUSB_MODE_USB);
}
void test_btusb_switch_to_usb(void) { btusb_switch(BTUSB_MODE_USB); }
#endif

44
apps/btusbaudio/usbaudio_thread.c
View file

@ -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)
{
USBAUDIO_DEBUG("%s,%d usb_mailbox_cnt = %d.",
__func__,__LINE__,usb_mailbox_cnt);
if (usb_mailbox_cnt >= 1) {
USBAUDIO_DEBUG("%s,%d usb_mailbox_cnt = %d.", __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;
}

26
apps/cmd/app_cmd.cpp
View file

@ -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

23
apps/common/app_spec_ostimer.cpp
View file

@ -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) {

47
apps/common/app_thread.c
View file

@ -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",
i,
((APP_MESSAGE_BLOCK *)(evt.value.p))->mod_id,
TRACE_IMM(
9,
"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)
{
return (void *)app_thread_tid;
}
void *app_os_tid_get(void) { 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];
}

5
apps/common/app_thread.h
View file

@ -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);

59
apps/common/app_utils.c
View file

@ -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
* 32, currently this works, but if the are more user, another way needed
* The macro QOS_USERS works only when the APP_SYSFREQ_USER_APP_XXX is not large
* than 32, currently this works, but if the are more user, another way needed
*/
#define QOS_USERS ((1 << (APP_SYSFREQ_USER_AI_VOICE)) | \
(1 << (APP_SYSFREQ_USER_BT_A2DP)))
#define QOS_USERS \
((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_26M] = FREQ_26M,
[HAL_CMU_FREQ_52M] = FREQ_52M,
[HAL_CMU_FREQ_78M] = FREQ_78M,
[HAL_CMU_FREQ_104M] = FREQ_104M,
[HAL_CMU_FREQ_208M] = FREQ_208M,
[HAL_CMU_FREQ_32K] = FREQ_FREE, [HAL_CMU_FREQ_26M] = FREQ_26M,
[HAL_CMU_FREQ_52M] = FREQ_52M, [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

162
apps/common/randfrommic.c
View file

@ -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)
* only the lowest byte of each frame is taken
* ADC format:
* 16bit mode -> [15:0] is valid
* 24bit mode -> [23:4] is valid
* 32bit mode -> [31:12] is valid
* Description: parse mic data according to the stream cfg(bit mode and channel
* number) only the lowest byte of each frame is taken ADC format: 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)
{
case AUD_BITS_16:
{
switch (bits) {
case AUD_BITS_16: {
uint16_t *content = (uint16_t *)buf;
for (index = 0;index < 4; index++)
{
seedData.value[index] = ((*content) & RAND_GRAB_BITS_MASK_PER_SAMPLE) |
(((*(content+ch_num)) & RAND_GRAB_BITS_MASK_PER_SAMPLE) << RAND_GRAB_BITS_PER_SAMPLE);
for (index = 0; index < 4; index++) {
seedData.value[index] =
((*content) & RAND_GRAB_BITS_MASK_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) |
((((*(content+ch_num)) >> 4)&RAND_GRAB_BITS_MASK_PER_SAMPLE) << RAND_GRAB_BITS_PER_SAMPLE);
seedData.value[index] =
(((*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) |
((((*(content+ch_num)) >> 12) & RAND_GRAB_BITS_MASK_PER_SAMPLE) << RAND_GRAB_BITS_PER_SAMPLE);
seedData.value[index] =
(((*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)
{
if (buf == NULL)
{
static uint32_t rand_data_handle(uint8_t *buf, uint32_t len) {
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)
{
if (RAND_STATUS_OPEN == randomBuffer.status)
{
void random_status_sync(void) {
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)
{
if (buf == NULL)
{
enum AUD_CHANNEL_NUM_T ch_num) {
if (buf == NULL) {
return;
}
if ((RAND_STATUS_MIC_STARTED == randomBuffer.status) ||
(RAND_STATUS_MIC_OPENED == randomBuffer.status))
{
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_STATUS_MIC_OPENED == randomBuffer.status)) {
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_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)
{
randInitialised = true;
}
void randInit(void) { randInitialised = true; }
#endif

249
apps/factory/app_factory.cpp
View file

@ -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 "app_factory.h"
#include "bt_drv_interface.h"
#include "bt_drv_reg_op.h"
#include "bluetooth.h"
#include "hal_trace.h"
#include "list.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)
{
return isInFactoryMode;
}
void app_factorymode_set(bool set)
{
isInFactoryMode = set;
}
bool app_factorymode_get(void) { return isInFactoryMode; }
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_LONGPRESS},"bt function key",app_factorymode_bt_signalingtest, NULL},
{{APP_KEY_CODE_PWR, APP_KEY_EVENT_DOUBLECLICK},
"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.value.signals & 0x01)
{
if (evt.status == osEventSignal) {
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.stop = HAL_UART_STOP_BITS_1,
uart_cfg.parity = HAL_UART_PARITY_NONE, 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.baud = 921600,
uart_cfg.dma_rx = false,
uart_cfg.dma_tx = false,
uart_cfg.rx_level = HAL_UART_FIFO_LEVEL_1_4, uart_cfg.baud = 921600,
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)
{
usb_serial_cancel_recv();
}
static void usb_serial_recv_timeout(void *param) { 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);

3
apps/factory/app_factory.h
View file

@ -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);

119
apps/factory/app_factory_audio.cpp
View file

@ -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
{
if ((pcmpatten->len - pcmpatten->cuur_buf_pos) >= len)
{
} else {
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 twiddleWidth = 16; // input word format is 16 bit twos complement fractional format 2.14
// int dataWidth = 16; // input word format is 16 bit twos complement
// 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].im = tmp.im;//(int) (double(tmp.im)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
st->data_even[k].re =
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].im = tmp.im;//(int) (double(tmp.im)*double(1 << FFTR4_INPUT_FORMAT_Y)) ;
st->data_odd[k].re =
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_odd, st->w, FFTR4_TWIDDLE_WIDTH, FFTR4_DATA_WIDTH, ifft);
fftr4(NFFT / 2, st->data_even, st->w, FFTR4_TWIDDLE_WIDTH, FFTR4_DATA_WIDTH,
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;
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;
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;
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

110
apps/factory/app_factory_bt.cpp
View file

@ -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,\
0x01, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00};
static uint8_t inquiry_buff[] = {0x01, 0x72, 0x77, 0xb0, 0x18, 0x57, 0x60, 0x01,
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(test_mode_type==1)
{
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|HAL_SW_BOOTMODE_TEST_NOSIGNALINGMODE);
if (bt_drv_error_check_handler()) {
if (test_mode_type == 1) {
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 |
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)
{
APP_FACTORY_TRACE(4,"%s cHandler:%p Event:%d status:%d", __func__, cHandler, Event, Status);
bt_status_t Status) {
APP_FACTORY_TRACE(4, "%s cHandler:%p Event:%d status:%d", __func__, cHandler,
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

51
apps/factory/app_factory_cdc_comm.c
View file

@ -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 unsigned char check_sum(unsigned char *buf, unsigned char len)
static struct message_t send_msg = {
{
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;

83
apps/factory/sys_api_cdc_comm.c
View file

@ -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)
{
recv_timeout = timeout;
}
void set_recv_timeout(unsigned int timeout) { recv_timeout = timeout; }
void set_send_timeout(unsigned int timeout)
{
send_timeout = timeout;
}
void set_send_timeout(unsigned int timeout) { send_timeout = timeout; }
static void usb_send_timeout(void *param)
{
usb_serial_cancel_send();
}
static void usb_send_timeout(void *param) { 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)
{
usb_serial_cancel_recv();
}
static void usb_recv_timeout(void *param) { 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)
{
return usb_serial_flush_recv_buffer();
}
static int usb_cancel_input(void) { return usb_serial_flush_recv_buffer(); }
int cancel_input(void)
{
return usb_cancel_input();
}
int cancel_input(void) { 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)
{
return hal_sw_bootmode_get();
}
unsigned int system_get_bootmode(void) { return hal_sw_bootmode_get(); }
#endif

62
apps/key/app_key.cpp
View file

@ -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 = {
.key_list = NULL
};
APP_KEY_CONFIG app_key_conifg = {.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)
{
list_clear(app_key_conifg.key_list);
}
void app_key_handle_clear(void) { 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

13
apps/key/app_key.h
View file

@ -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__

1325
apps/main/apps.cpp
View file

File diff suppressed because it is too large Load diff

171
apps/main/apps_tester.cpp
View file

@ -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);
void test_codec_loop(APP_KEY_STATUS *status, void *param)
{
extern void adc_looptester(bool on, enum AUD_IO_PATH_T input_path,
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)
{
anc_usb_app((bool)param);
}
void test_anc(APP_KEY_STATUS *status, void *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)
{
da_tester(1);
}
void bt_test_dsp_process(APP_KEY_STATUS *status, void *param) { 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_FN5,APP_KEY_EVENT_UP},"USB AUDIO TEST ON",test_usb_audio, (void *)1},
{{APP_KEY_CODE_FN2, APP_KEY_EVENT_UP},
"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_LONGPRESS},"LONGPRESS: bt volume down 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_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_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_FN7, APP_KEY_EVENT_CLICK},
"bt function key",
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_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},
{{APP_KEY_CODE_FN8, APP_KEY_EVENT_UP},
"open jlink",
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++) {

143
apps/mic/app_mic.cpp
View file

@ -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 "apps.h"
#include "tgt_hardware.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 (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);
if (mic_config[new_mictype].data_ptr != NULL)
{
}
else
{
if (new_mictype == MIC_APP_SOC_CALL) {
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);
if (mic_config[new_mictype].data_ptr != NULL) {
} 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_CSPOTTER)
{
} else if (new_mictype == MIC_APP_SPEECH_RECO) {
} 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)
{
TRACE(2,"app_mic_registration mic_type:%d,newStream=%p\n",mic_type,newStream);
if (mic_type > MIC_APP_NONE && mic_type < MIC_APP_MAX)
{
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);
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;
}

112
apps/mic_alg/app_mic_alg.cpp
View file

@ -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, int16_t *left_buf, int16_t *right_buf, uint32_t src_len)
{
static void POSSIBLY_UNUSED audio_mono2stereo_16bits(int16_t *dst_buf,
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)
{
TRACE(2,"db value is:%d volume_is:%d ",db_val,app_bt_stream_local_volume_get());
void vol_state_process(uint32_t db_val) {
TRACE(2, "db value is:%d volume_is:%d ", db_val,
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))
{
//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());
//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());
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 (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),
// pcm_len,hal_sysfreq_get()); 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());
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);
// #else
// app_bt_stream_copy_track_one_to_two_16bits((int16_t *)buf,
// 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;
}

62
apps/pwl/app_pwl.cpp
View file

@ -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_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)cfg_hw_pinmux_pwl[i].pin, HAL_GPIO_DIR_OUT, 1);
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&cfg_hw_pinmux_pwl[i],
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;
}

74
apps/sdmmc/app_sdmmc.cpp
View file

@ -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_capture_buff[APP_TEST_CAPTURE_BUFF_SIZE] __attribute__ ((aligned(4)));
extern uint8_t app_test_playback_buff[APP_TEST_PLAYBACK_BUFF_SIZE]
__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)
void dump_data2sd(enum APP_SDMMC_DUMP_T opt, uint8_t *buf, uint32_t len)
{
// Bench32.exe can test sd card speed in PC, then make sure bufer length, buffer
// 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);
}
else if(opt == APP_SDMMC_DUMP_WRITE)
{
// ASSERT(pcm_res == FR_OK,"[%s]:Cannot creat dump.bin, res =
// %d",__func__, pcm_res);
} 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);
}
else if(opt == APP_SDMMC_DUMP_CLOSE)
{
// ASSERT(pcm_res == FR_OK,"[%s]:Write dump.bin failed, res = %d",
// __func__, pcm_res);
} 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);
}
}

136
apps/usbaudio/usbaudio_entry.c
View file

@ -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 "pmu.h"
#include "analog.h"
#include "string.h"
#include "hal_timer.h"
#include "hal_trace.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_CAPTURE_BUFF_SIZE NON_EXP_ALIGN(MAX_FRAME_SIZE_CAPTURE * CODEC_BUFF_FRAME_NUM, ADC_BUFF_ALIGN)
#define USB_AUDIO_PLAYBACK_BUFF_SIZE \
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_SEND_BUFF_SIZE NON_EXP_ALIGN(MAX_FRAME_SIZE_SEND * USB_BUFF_FRAME_NUM, SEND_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_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_CAPTURE_BUFF_SIZE NON_EXP_ALIGN(FRAME_SIZE_CAPTURE * CODEC_BUFF_FRAME_NUM, ADC_BUFF_ALIGN)
#define USB_AUDIO_PLAYBACK_BUFF_SIZE \
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_SEND_BUFF_SIZE NON_EXP_ALIGN(FRAME_SIZE_SEND * USB_BUFF_FRAME_NUM, SEND_BUFF_ALIGN)
#define USB_AUDIO_RECV_BUFF_SIZE \
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)
// 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)
#if (defined(CHIP_BEST1000) && \
(defined(ANC_APP) || defined(_DUAL_AUX_MIC_))) && \
(CHAN_NUM_CAPTURE == CHAN_NUM_SEND)
// 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)
#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)
// sizeof(struct RESAMPLE_CTRL_T) + ((SAMPLE_NUM + phase_coef_num) *
// SAMPLE_SIZE_CAPTURE * CHAN_NUM_CAPTURE)
#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)
{
usb_audio_app(0);
}
void anc_usb_close(void) { 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)
{
anc_usb_close();
}
void btusbaudio_exit(void) { anc_usb_close(); }

5
apps/usbhost/app_usbhost.c
View file

@ -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"

78
apps/voice_detector/app_voice_detector.cpp
View file

@ -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_CLOSE,
VOICE_DET_CMD_VAD_OPEN,
VOICE_DET_CMD_VAD_START,
VOICE_DET_CMD_AUD_CAP_STOP, VOICE_DET_CMD_AUD_CAP_CLOSE,
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_CLOSE,
VOICE_DET_CMD_VAD_STOP,
VOICE_DET_CMD_VAD_CLOSE,
VOICE_DET_CMD_AUD_CAP_STOP, VOICE_DET_CMD_AUD_CAP_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,
void *param)
{
voice_detector_cb_t func, 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,
struct CODEC_VAD_BUF_INFO_T* vad_buf_info)
{
void app_voice_detector_get_vad_data_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);
}

225
apps/voice_detector/voice_detector.c
View file

@ -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",
__func__, id, pdev->wakeup_cnt);
VD_LOG(3, "%s, voice detector[%d], wakeup_cnt=%d", __func__, id,
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,
struct CODEC_VAD_BUF_INFO_T* vad_buf_info)
{
void voice_detector_get_vad_data_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)
{
if ((s == VOICE_DET_STATE_SYS_CLK_104M)
|| (s == VOICE_DET_STATE_SYS_CLK_52M)
|| (s == VOICE_DET_STATE_SYS_CLK_26M)
|| (s == VOICE_DET_STATE_SYS_CLK_32K)) {
static void voice_detector_set_status(struct voice_detector_dev *pdev,
enum voice_detector_state s) {
if ((s == VOICE_DET_STATE_SYS_CLK_104M) ||
(s == VOICE_DET_STATE_SYS_CLK_52M) ||
(s == VOICE_DET_STATE_SYS_CLK_26M) ||
(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)
{
voice_det_evt = evt;
}
static void voice_detector_send_evt(uint32_t 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,
TIMES, mem_pool, mem_size, state_buffer, state_size, &err);
h_CSpotter = CSpotter_Init_Sep((BYTE *)BASE_MODEL_DATA,
(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_DONE, cmd_done_handler, 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);
voice_detector_setup_callback(id, VOICE_DET_CB_RUN_WAIT, cmd_wait_handler,
NULL);
voice_detector_setup_callback(id, VOICE_DET_CB_RUN_DONE, cmd_done_handler,
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,
vad_data_buf, sizeof(vad_data_buf));
len = voice_detector_recv_vad_data(VOICE_DETECTOR_ID_0, vad_data_buf,
sizeof(vad_data_buf));
if (len) {
print_vad_raw_data(vad_data_buf, len);
}

36
config/_default_cfg_src_/app_status_ind.c
View file

@ -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)
{
return app_status;
}
APP_STATUS_INDICATION_T app_status_indication_get(void) { 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;

91
config/_default_cfg_src_/tgt_hardware.c
View file

@ -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]}
//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};
// 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]} 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};
#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,-99},
{TX_PA_GAIN,0x03,-45},
{TX_PA_GAIN,0x03,-42},
{TX_PA_GAIN,0x03,-39},
{TX_PA_GAIN,0x03,-36},
{TX_PA_GAIN,0x03,-33},
{TX_PA_GAIN,0x03,-30},
{TX_PA_GAIN,0x03,-27},
{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
{TX_PA_GAIN, 0x03, -11}, {TX_PA_GAIN, 0x03, -99},
{TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
{TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
{TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
{TX_PA_GAIN, 0x03, -27}, {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_LINEIN_DEV (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV (AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
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, },
#define CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV \
(AUD_CHANNEL_MAP_CH0 | AUD_VMIC_MAP_VMIC1)
#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV \
(AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
#define CFG_HW_AUD_INPUT_PATH_VADMIC_DEV \
(AUD_CHANNEL_MAP_CH4 | AUD_VMIC_MAP_VMIC1)
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
};
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 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};

265
config/bak_open/tgt_hardware.c
View file

@ -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_LED1, 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_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_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},
{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
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_3, HAL_IOMUX_FUNC_UART2_TX, 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_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_FN2,{HAL_IOMUX_PIN_P0_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_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_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_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
#endif
#endif
{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_FN2,{HAL_IOMUX_PIN_P0_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_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_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_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_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
#endif
#endif
//{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_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
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]}
//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};
// 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]} 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};
#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,-99},
{TX_PA_GAIN,0x03,-45},
{TX_PA_GAIN,0x03,-42},
{TX_PA_GAIN,0x03,-39},
{TX_PA_GAIN,0x03,-36},
{TX_PA_GAIN,0x03,-33},
{TX_PA_GAIN,0x03,-30},
{TX_PA_GAIN,0x03,-27},
{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
{TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -99},
{TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
{TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
{TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
{TX_PA_GAIN, 0x03, -27}, {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
{ AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4, },
// NOTE: If enable Ch5 and CH6, need to add channel_num when setup
// 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
};
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_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 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 = {
{IIR_TYPE_PEAK, .0, 200, 2},
.param = {{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 = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
.len = 384,
.coef =
{
.coef = {
(1 << 23) - 1,
}
};
}};
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_hw_iir_cfg = {.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 = {
.knee = 3,
const DrcConfig audio_drc_cfg = {.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},
};

272
config/best2300p_ibrt/tgt_hardware.c
View file

@ -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_LED1, 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_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_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},
{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
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_3, HAL_IOMUX_FUNC_UART2_TX, 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_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_FN2,{HAL_IOMUX_PIN_P0_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_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_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_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
#endif
#endif
{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_FN2,{HAL_IOMUX_PIN_P0_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_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_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_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_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
#endif
#endif
//{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_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
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]}
//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};
// 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]} 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};
#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,-99},
{TX_PA_GAIN,0x03,-45},
{TX_PA_GAIN,0x03,-42},
{TX_PA_GAIN,0x03,-39},
{TX_PA_GAIN,0x03,-36},
{TX_PA_GAIN,0x03,-33},
{TX_PA_GAIN,0x03,-30},
{TX_PA_GAIN,0x03,-27},
{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
{TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -99},
{TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
{TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
{TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
{TX_PA_GAIN, 0x03, -27}, {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
{ AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4, },
// NOTE: If enable Ch5 and CH6, need to add channel_num when setup
// 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 = {
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 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
};
bool tgt_tws_get_channel_is_right(void)
{
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) {
#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 = {
{IIR_TYPE_PEAK, .0, 200, 2},
.param = {{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 = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
.len = 384,
.coef =
{
.coef = {
(1 << 23) - 1,
}
};
}};
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_hw_iir_cfg = {.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 = {
.knee = 3,
const DrcConfig audio_drc_cfg = {.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},
};

345
config/best2300p_ibrt_anc/tgt_hardware.c
View file

@ -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_4, 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},
{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_FN2,{HAL_IOMUX_PIN_P0_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_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}},
{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_FN2,
{HAL_IOMUX_PIN_P0_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_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_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}},
{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_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_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, 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_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_FN14,{HAL_IOMUX_PIN_P1_2, 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_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]}
//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};
// 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]} 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};
#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,-99},
{TX_PA_GAIN,0x03,-45},
{TX_PA_GAIN,0x03,-42},
{TX_PA_GAIN,0x03,-39},
{TX_PA_GAIN,0x03,-36},
{TX_PA_GAIN,0x03,-33},
{TX_PA_GAIN,0x03,-30},
{TX_PA_GAIN,0x03,-27},
{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
{TX_PA_GAIN, 0x03, -11}, {TX_PA_GAIN, 0x03, -99},
{TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
{TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
{TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
{TX_PA_GAIN, 0x03, -27}, {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_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)
#define CFG_HW_AUD_INPUT_PATH_LINEIN_DEV \
(AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)
#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
{ AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_ECMIC_CH0, },
// NOTE: If enable Ch5 and CH6, need to add channel_num when setup
// 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_ASRMIC, CFG_HW_AUD_INPUT_PATH_ASRMIC_DEV, },
{
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_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
};
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 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 AncFirCoef_50p7k_mode0 = {
.anc_cfg_ff_l = {
static const struct_anc_cfg POSSIBLY_UNUSED
AncFirCoef_50p7k_mode0 =
{
.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 = {
.anc_cfg_ff_l = {
static const struct_anc_cfg POSSIBLY_UNUSED
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 = {
.anc_cfg_ff_l = {
static const struct_anc_cfg POSSIBLY_UNUSED
AncFirCoef_44p1k_mode0 =
{
.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 = {
{IIR_TYPE_PEAK, .0, 200, 2},
.param = {{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 = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
.len = 384,
.coef =
{
.coef = {
(1 << 23) - 1,
}
};
}};
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_hw_iir_cfg = {.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 = {
.knee = 3,
const DrcConfig audio_drc_cfg = {.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},
};

274
config/mic_alg/tgt_hardware.c
View file

@ -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_LED1, 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_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_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},
{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
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_3, HAL_IOMUX_FUNC_UART2_TX, 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_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_FN2,{HAL_IOMUX_PIN_P0_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_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_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_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
#endif
#endif
{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_FN2,{HAL_IOMUX_PIN_P0_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_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_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_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_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
#endif
#endif
//{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_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
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]}
//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};
// 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]} 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};
#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,-99},
{TX_PA_GAIN,0x03,-45},
{TX_PA_GAIN,0x03,-42},
{TX_PA_GAIN,0x03,-39},
{TX_PA_GAIN,0x03,-36},
{TX_PA_GAIN,0x03,-33},
{TX_PA_GAIN,0x03,-30},
{TX_PA_GAIN,0x03,-27},
{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
{TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -99},
{TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
{TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
{TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
{TX_PA_GAIN, 0x03, -27}, {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
{ AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4, },
// NOTE: If enable Ch5 and CH6, need to add channel_num when setup
// 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 = {
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 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
};
bool tgt_tws_get_channel_is_right(void)
{
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) {
#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 = {
{IIR_TYPE_PEAK, .0, 200, 2},
.param = {{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 = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
.len = 384,
.coef =
{
.coef = {
(1 << 23) - 1,
}
};
}};
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_hw_dac_iir_cfg = {.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_hw_iir_cfg = {.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 = {
.knee = 3,
const DrcConfig audio_drc_cfg = {.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},
};

360
config/open_source/tgt_hardware.c
View file

@ -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_LED1, 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_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_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},
{HAL_IOMUX_PIN_P1_5, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
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_3, HAL_IOMUX_FUNC_UART2_TX, 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_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_FN2,{HAL_IOMUX_PIN_P0_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_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_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_FN15,{HAL_IOMUX_PIN_P1_0, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
#endif
#endif
{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_FN2,{HAL_IOMUX_PIN_P0_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_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_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_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_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO, HAL_IOMUX_PIN_PULLUP_ENABLE}},
#endif
#endif
//{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_FN14,{HAL_IOMUX_PIN_P1_2, HAL_IOMUX_FUNC_AS_GPIO,
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]}
//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};
// 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]} 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};
#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,-99},
{TX_PA_GAIN,0x03,-45},
{TX_PA_GAIN,0x03,-42},
{TX_PA_GAIN,0x03,-39},
{TX_PA_GAIN,0x03,-36},
{TX_PA_GAIN,0x03,-33},
{TX_PA_GAIN,0x03,-30},
{TX_PA_GAIN,0x03,-27},
{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
{TX_PA_GAIN, 0x03, -21}, {TX_PA_GAIN, 0x03, -99},
{TX_PA_GAIN, 0x03, -45}, {TX_PA_GAIN, 0x03, -42},
{TX_PA_GAIN, 0x03, -39}, {TX_PA_GAIN, 0x03, -36},
{TX_PA_GAIN, 0x03, -33}, {TX_PA_GAIN, 0x03, -30},
{TX_PA_GAIN, 0x03, -27}, {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
{ AUD_INPUT_PATH_MAINMIC, CFG_HW_AUD_INPUT_PATH_MAINMIC_DEV | AUD_CHANNEL_MAP_CH4, },
// NOTE: If enable Ch5 and CH6, need to add channel_num when setup
// 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
};
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_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 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 AncFirCoef_50p7k_mode0 = {
.anc_cfg_ff_l = {
static const struct_anc_cfg POSSIBLY_UNUSED
AncFirCoef_50p7k_mode0 =
{
.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 = {
.anc_cfg_ff_l = {
static const struct_anc_cfg POSSIBLY_UNUSED
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 = {
.anc_cfg_ff_l = {
static const struct_anc_cfg POSSIBLY_UNUSED
AncFirCoef_44p1k_mode0 =
{
.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 = {
.gain0 = 0,
const IIR_CFG_T audio_eq_sw_iir_cfg = {.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 = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_44p1k = {.gain = 0.0f,
.len = 384,
.coef =
{
.coef = {
(1 << 23) - 1,
}
};
}};
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {
.gain = 0.0f,
const FIR_CFG_T audio_eq_hw_fir_cfg_48k = {.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 = {
.knee = 3,
const DrcConfig audio_drc_cfg = {.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},
};

13
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_abs_f32.c
View file

@ -60,11 +60,7 @@
@return none
*/
void arm_abs_f32(
const float32_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
void arm_abs_f32(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--;
}
}
/**

22
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_abs_q15.c
View file

@ -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(
const q15_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
void arm_abs_q15(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--;
}
}
/**

22
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_abs_q31.c
View file

@ -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(
const q31_t * pSrc,
q31_t * pDst,
uint32_t blockSize)
{
void arm_abs_q31(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--;
}
}
/**

22
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_abs_q7.c
View file

@ -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(
const q7_t * pSrc,
q7_t * pDst,
uint32_t blockSize)
{
void arm_abs_q7(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--;
}
}
/**

15
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_add_f32.c
View file

@ -58,12 +58,8 @@
@return none
*/
void arm_add_f32(
const float32_t * pSrcA,
const float32_t * pSrcB,
float32_t * pDst,
uint32_t blockSize)
{
void arm_add_f32(const float32_t *pSrcA, 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--;
}
}
/**

18
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_add_q15.c
View file

@ -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(
const q15_t * pSrcA,
const q15_t * pSrcB,
q15_t * pDst,
uint32_t blockSize)
{
void arm_add_q15(const q15_t *pSrcA, 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--;
}
}
/**

18
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_add_q31.c
View file

@ -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(
const q31_t * pSrcA,
const q31_t * pSrcB,
q31_t * pDst,
uint32_t blockSize)
{
void arm_add_q31(const q31_t *pSrcA, 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--;
}
}
/**

21
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_add_q7.c
View file

@ -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(
const q7_t * pSrcA,
const q7_t * pSrcB,
q7_t * pDst,
uint32_t blockSize)
{
void arm_add_q7(const q7_t *pSrcA, 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--;
}
}
/**

23
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_dot_prod_f32.c
View file

@ -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(
const float32_t * pSrcA,
const float32_t * pSrcB,
uint32_t blockSize,
float32_t * result)
{
void arm_dot_prod_f32(const float32_t *pSrcA, 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)
{
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
while (blkCnt > 0U) {
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[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)
{
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
while (blkCnt > 0U) {
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
* B[blockSize-1] */
/* Calculate dot product and store result in a temporary buffer. */
sum += (*pSrcA++) * (*pSrcB++);

36
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_dot_prod_q15.c
View file

@ -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
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
there is no risk of overflow.
The return result is in 34.30 format.
The intermediate multiplications are in 1.15 x 1.15 = 2.30
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 there is no risk of overflow. The return result
is in 34.30 format.
*/
void arm_dot_prod_q15(
const q15_t * pSrcA,
const q15_t * pSrcB,
uint32_t blockSize,
q63_t * result)
{
void arm_dot_prod_q15(const q15_t *pSrcA, 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)
{
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
while (blkCnt > 0U) {
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[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), read_q15x2_ia ((q15_t **) &pSrcB), sum);
sum = __SMLALD(read_q15x2_ia((q15_t **)&pSrcA),
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)
{
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
while (blkCnt > 0U) {
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
* B[blockSize-1] */
/* Calculate dot product and store result in a temporary buffer. */
//#if defined (ARM_MATH_DSP)

32
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_dot_prod_q31.c
View file

@ -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
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.
There are 15 guard bits in the accumulator and there is no risk of overflow as long as
the length of the vectors is less than 2^16 elements.
The return result is in 16.48 format.
The intermediate multiplications are in 1.31 x 1.31 = 2.62
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. There are 15 guard bits in the accumulator and
there is no risk of overflow as long as the length of the vectors is less than
2^16 elements. The return result is in 16.48 format.
*/
void arm_dot_prod_q31(
const q31_t * pSrcA,
const q31_t * pSrcB,
uint32_t blockSize,
q63_t * result)
{
void arm_dot_prod_q31(const q31_t *pSrcA, 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)
{
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
while (blkCnt > 0U) {
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[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)
{
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
while (blkCnt > 0U) {
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
* B[blockSize-1] */
/* Calculate dot product and store result in a temporary buffer. */
sum += ((q63_t)*pSrcA++ * *pSrcB++) >> 14U;

30
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_dot_prod_q7.c
View file

@ -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
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
the vectors are less than 2^18 elements long.
The return result is in 18.14 format.
The intermediate multiplications are in 1.7 x 1.7 = 2.14
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 the vectors are less than 2^18 elements long. The
return result is in 18.14 format.
*/
void arm_dot_prod_q7(
const q7_t * pSrcA,
const q7_t * pSrcB,
uint32_t blockSize,
q31_t * result)
{
void arm_dot_prod_q7(const q7_t *pSrcA, 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)
{
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
while (blkCnt > 0U) {
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[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)
{
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
while (blkCnt > 0U) {
/* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]*
* B[blockSize-1] */
/* Calculate dot product and store result in a temporary buffer. */
//#if defined (ARM_MATH_DSP)

15
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_mult_f32.c
View file

@ -58,12 +58,8 @@
@return none
*/
void arm_mult_f32(
const float32_t * pSrcA,
const float32_t * pSrcB,
float32_t * pDst,
uint32_t blockSize)
{
void arm_mult_f32(const float32_t *pSrcA, 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--;
}
}
/**

18
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_mult_q15.c
View file

@ -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(
const q15_t * pSrcA,
const q15_t * pSrcB,
q15_t * pDst,
uint32_t blockSize)
{
void arm_mult_q15(const q15_t *pSrcA, 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--;
}
}
/**

18
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_mult_q31.c
View file

@ -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(
const q31_t * pSrcA,
const q31_t * pSrcB,
q31_t * pDst,
uint32_t blockSize)
{
void arm_mult_q31(const q31_t *pSrcA, 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--;
}
}
/**

18
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_mult_q7.c
View file

@ -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(
const q7_t * pSrcA,
const q7_t * pSrcB,
q7_t * pDst,
uint32_t blockSize)
{
void arm_mult_q7(const q7_t *pSrcA, 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--;
}
}
/**

14
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_negate_f32.c
View file

@ -59,11 +59,8 @@
@return none
*/
void arm_negate_f32(
const float32_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
void arm_negate_f32(const float32_t *pSrc, 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--;
}
}
/**

16
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_negate_q15.c
View file

@ -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(
const q15_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
void arm_negate_q15(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--;
}
}
/**

16
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_negate_q31.c
View file

@ -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(
const q31_t * pSrc,
q31_t * pDst,
uint32_t blockSize)
{
void arm_negate_q31(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--;
}
}
/**

16
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_negate_q7.c
View file

@ -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(
const q7_t * pSrc,
q7_t * pDst,
uint32_t blockSize)
{
void arm_negate_q7(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--;
}
}
/**

15
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_offset_f32.c
View file

@ -60,12 +60,8 @@
@return none
*/
void arm_offset_f32(
const float32_t * pSrc,
float32_t offset,
float32_t * pDst,
uint32_t blockSize)
{
void arm_offset_f32(const float32_t *pSrc, 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--;
}
}
/**

27
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_offset_q15.c
View file

@ -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(
const q15_t * pSrc,
q15_t offset,
q15_t * pDst,
uint32_t blockSize)
{
void arm_offset_q15(const q15_t *pSrc, 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). */
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));
/* 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));
#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--;
}
}
/**

18
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_offset_q31.c
View file

@ -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(
const q31_t * pSrc,
q31_t offset,
q31_t * pDst,
uint32_t blockSize)
{
void arm_offset_q31(const q31_t *pSrc, 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--;
}
}
/**

21
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_offset_q7.c
View file

@ -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(
const q7_t * pSrc,
q7_t offset,
q7_t * pDst,
uint32_t blockSize)
{
void arm_offset_q7(const q7_t *pSrc, 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--;
}
}
/**

26
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_scale_f32.c
View file

@ -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
a fractional multiplication <code>scaleFract</code> and an arithmetic shift <code>shift</code>.
The shift allows the gain of the scaling operation to exceed 1.0.
The algorithm used with fixed-point data is:
In the fixed-point Q7, Q15, and Q31 functions, <code>scale</code> is
represented by a fractional multiplication <code>scaleFract</code> and an
arithmetic shift <code>shift</code>. The shift allows the gain of the scaling
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(
const float32_t *pSrc,
float32_t scale,
float32_t *pDst,
uint32_t blockSize)
{
void arm_scale_f32(const float32_t *pSrc, 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--;
}
}
/**

21
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_scale_q15.c
View file

@ -47,17 +47,13 @@
@return none
@par Scaling and Overflow Behavior
The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.15 format.
These are multiplied to yield a 2.30 intermediate result and this is shifted with saturation to 1.15 format.
The input data <code>*pSrc</code> and <code>scaleFract</code>
are in 1.15 format. These are multiplied to yield a 2.30 intermediate result
and this is shifted with saturation to 1.15 format.
*/
void arm_scale_q15(
const q15_t *pSrc,
q15_t scaleFract,
int8_t shift,
q15_t *pDst,
uint32_t blockSize)
{
void arm_scale_q15(const q15_t *pSrc, q15_t scaleFract, int8_t shift,
q15_t *pDst, uint32_t blockSize) {
uint32_t blkCnt; /* Loop counter */
int8_t kShift = 15 - shift; /* Shift to apply after scaling */
@ -74,8 +70,7 @@ void arm_scale_q15(
/* Loop unrolling: Compute 4 outputs at a time */
blkCnt = blockSize >> 2U;
while (blkCnt > 0U)
{
while (blkCnt > 0U) {
/* C = A * scale */
#if defined(ARM_MATH_DSP)
@ -126,8 +121,7 @@ void arm_scale_q15(
#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
while (blkCnt > 0U)
{
while (blkCnt > 0U) {
/* C = A * scale */
/* Scale input and store result in destination buffer. */
@ -136,7 +130,6 @@ void arm_scale_q15(
/* Decrement loop counter */
blkCnt--;
}
}
/**

47
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_scale_q31.c
View file

@ -47,17 +47,13 @@
@return none
@par Scaling and Overflow Behavior
The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.31 format.
These are multiplied to yield a 2.62 intermediate result and this is shifted with saturation to 1.31 format.
The input data <code>*pSrc</code> and <code>scaleFract</code>
are in 1.31 format. These are multiplied to yield a 2.62 intermediate result
and this is shifted with saturation to 1.31 format.
*/
void arm_scale_q31(
const q31_t *pSrc,
q31_t scaleFract,
int8_t shift,
q31_t *pDst,
uint32_t blockSize)
{
void arm_scale_q31(const q31_t *pSrc, q31_t scaleFract, int8_t shift,
q31_t *pDst, uint32_t blockSize) {
uint32_t blkCnt; /* Loop counter */
q31_t in, out; /* Temporary variables */
int8_t kShift = shift + 1; /* Shift to apply after scaling */
@ -68,15 +64,14 @@ void arm_scale_q31(
/* Loop unrolling: Compute 4 outputs at a time */
blkCnt = blockSize >> 2U;
if (sign == 0U)
{
while (blkCnt > 0U)
{
if (sign == 0U) {
while (blkCnt > 0U) {
/* C = A * scale */
/* Scale input and store result in destination buffer. */
in = *pSrc++; /* read input from source */
in = ((q63_t) in * scaleFract) >> 32; /* multiply input with scaler value */
in =
((q63_t)in * scaleFract) >> 32; /* multiply input with scaler value */
out = in << kShift; /* apply shifting */
if (in != (out >> kShift)) /* saturate the result */
out = 0x7FFFFFFF ^ (in >> 31);
@ -106,16 +101,14 @@ void arm_scale_q31(
/* Decrement loop counter */
blkCnt--;
}
}
else
{
while (blkCnt > 0U)
{
} else {
while (blkCnt > 0U) {
/* C = A * scale */
/* Scale input and store result in destination buffer. */
in = *pSrc++; /* read four inputs from source */
in = ((q63_t) in * scaleFract) >> 32; /* multiply input with scaler value */
in =
((q63_t)in * scaleFract) >> 32; /* multiply input with scaler value */
out = in >> -kShift; /* apply shifting */
*pDst++ = out; /* Store result destination */
@ -149,10 +142,8 @@ void arm_scale_q31(
#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
if (sign == 0U)
{
while (blkCnt > 0U)
{
if (sign == 0U) {
while (blkCnt > 0U) {
/* C = A * scale */
/* Scale input and store result in destination buffer. */
@ -166,11 +157,8 @@ void arm_scale_q31(
/* Decrement loop counter */
blkCnt--;
}
}
else
{
while (blkCnt > 0U)
{
} else {
while (blkCnt > 0U) {
/* C = A * scale */
/* Scale input and store result in destination buffer. */
@ -183,7 +171,6 @@ void arm_scale_q31(
blkCnt--;
}
}
}
/**

21
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_scale_q7.c
View file

@ -47,17 +47,13 @@
@return none
@par Scaling and Overflow Behavior
The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.7 format.
These are multiplied to yield a 2.14 intermediate result and this is shifted with saturation to 1.7 format.
The input data <code>*pSrc</code> and <code>scaleFract</code>
are in 1.7 format. These are multiplied to yield a 2.14 intermediate result
and this is shifted with saturation to 1.7 format.
*/
void arm_scale_q7(
const q7_t * pSrc,
q7_t scaleFract,
int8_t shift,
q7_t * pDst,
uint32_t blockSize)
{
void arm_scale_q7(const q7_t *pSrc, q7_t scaleFract, int8_t shift, q7_t *pDst,
uint32_t blockSize) {
uint32_t blkCnt; /* Loop counter */
int8_t kShift = 7 - shift; /* Shift to apply after scaling */
@ -71,8 +67,7 @@ void arm_scale_q7(
/* Loop unrolling: Compute 4 outputs at a time */
blkCnt = blockSize >> 2U;
while (blkCnt > 0U)
{
while (blkCnt > 0U) {
/* C = A * scale */
#if defined(ARM_MATH_DSP)
@ -111,8 +106,7 @@ void arm_scale_q7(
#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
while (blkCnt > 0U)
{
while (blkCnt > 0U) {
/* C = A * scale */
/* Scale input and store result in destination buffer. */
@ -121,7 +115,6 @@ void arm_scale_q7(
/* Decrement loop counter */
blkCnt--;
}
}
/**

66
platform/cmsis/DSP_Lib/BasicMathFunctions/arm_shift_q15.c
View file

@ -1,7 +1,8 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_shift_q15.c
* Description: Shifts the elements of a Q15 vector by a specified number of bits
* Description: Shifts the elements of a Q15 vector by a specified number of
* bits
*
* $Date: 18. March 2019
* $Revision: V1.6.0
@ -40,22 +41,20 @@
/**
@brief Shifts the elements of a Q15 vector a specified number of bits
@param[in] pSrc points to the input vector
@param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right.
@param[in] shiftBits number of bits to shift. A positive value shifts
left; a negative value shifts right.
@param[out] pDst points to the output vector
@param[in] blockSize number of samples in each vector
@return none
@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_shift_q15(
const q15_t * pSrc,
int8_t shiftBits,
q15_t * pDst,
uint32_t blockSize)
{
void arm_shift_q15(const q15_t *pSrc, int8_t shiftBits, q15_t *pDst,
uint32_t blockSize) {
uint32_t blkCnt; /* Loop counter */
uint8_t sign = (shiftBits & 0x80); /* Sign of shiftBits */
@ -69,10 +68,8 @@ void arm_shift_q15(
blkCnt = blockSize >> 2U;
/* If the shift value is positive then do right shift else left shift */
if (sign == 0U)
{
while (blkCnt > 0U)
{
if (sign == 0U) {
while (blkCnt > 0U) {
/* C = A << shiftBits */
#if defined(ARM_MATH_DSP)
@ -80,7 +77,8 @@ void arm_shift_q15(
in1 = *pSrc++;
in2 = *pSrc++;
/* Shift the inputs and then store the results in the destination buffer. */
/* Shift the inputs and then store the results in the destination buffer.
*/
#ifndef ARM_MATH_BIG_ENDIAN
write_q15x2_ia(&pDst, __PKHBT(__SSAT((in1 << shiftBits), 16),
__SSAT((in2 << shiftBits), 16), 16));
@ -111,11 +109,8 @@ void arm_shift_q15(
/* Decrement loop counter */
blkCnt--;
}
}
else
{
while (blkCnt > 0U)
{
} else {
while (blkCnt > 0U) {
/* C = A >> shiftBits */
#if defined(ARM_MATH_DSP)
@ -123,13 +118,14 @@ void arm_shift_q15(
in1 = *pSrc++;
in2 = *pSrc++;
/* Shift the inputs and then store the results in the destination buffer. */
/* Shift the inputs and then store the results in the destination buffer.
*/
#ifndef ARM_MATH_BIG_ENDIAN
write_q15x2_ia (&pDst, __PKHBT((in1 >> -shiftBits),
(in2 >> -shiftBits), 16));
write_q15x2_ia(&pDst,
__PKHBT((in1 >> -shiftBits), (in2 >> -shiftBits), 16));
#else
write_q15x2_ia (&pDst, __PKHBT((in2 >> -shiftBits),
(in1 >> -shiftBits), 16));
write_q15x2_ia(&pDst,
__PKHBT((in2 >> -shiftBits), (in1 >> -shiftBits), 16));
#endif /* #ifndef ARM_MATH_BIG_ENDIAN */
/* read 2 samples from source */
@ -137,11 +133,11 @@ void arm_shift_q15(
in2 = *pSrc++;
#ifndef ARM_MATH_BIG_ENDIAN
write_q15x2_ia (&pDst, __PKHBT((in1 >> -shiftBits),
(in2 >> -shiftBits), 16));
write_q15x2_ia(&pDst,
__PKHBT((in1 >> -shiftBits), (in2 >> -shiftBits), 16));
#else
write_q15x2_ia (&pDst, __PKHBT((in2 >> -shiftBits),
(in1 >> -shiftBits), 16));
write_q15x2_ia(&pDst,
__PKHBT((in2 >> -shiftBits), (in1 >> -shiftBits), 16));
#endif /* #ifndef ARM_MATH_BIG_ENDIAN */
#else
@ -167,10 +163,8 @@ void arm_shift_q15(
#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
/* If the shift value is positive then do right shift else left shift */
if (sign == 0U)
{
while (blkCnt > 0U)
{
if (sign == 0U) {
while (blkCnt > 0U) {
/* C = A << shiftBits */
/* Shift input and store result in destination buffer. */
@ -179,11 +173,8 @@ void arm_shift_q15(
/* Decrement loop counter */
blkCnt--;
}
}
else
{
while (blkCnt > 0U)
{
} else {
while (blkCnt > 0U) {
/* C = A >> shiftBits */
/* Shift input and store result in destination buffer. */
@ -193,7 +184,6 @@ void arm_shift_q15(
blkCnt--;
}
}
}
/**

Some files were not shown because too many files have changed in this diff Show more