rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/apps/anc/src/app_anc.c

1957 lines
49 KiB
C
Raw Normal View History

add first commit
2022-08-15 04:20:27 -05:00
/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#include "plat_types.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "hal_sysfreq.h"
#include "aud_section.h"
#include "audioflinger.h"
#include "anc_process.h"
#include "cmsis.h"
#include "cmsis_os.h"
#include "hwtimer_list.h"
#include "app_thread.h"
#include "tgt_hardware.h"
#include "pmu.h"
#include "hal_bootmode.h"
#include "hal_codec.h"
#include "app_anc.h"
#include "anc_wnr.h"
#include "anc_assist.h"
#include "app_ibrt_keyboard.h"
#include "app_ibrt_ui.h"
#include "app_status_ind.h"
#ifdef __SIMPLE_INTERNAL_PLAYER_SUPPORT__
#include "simple_internal_player.h"
#endif
#include "hal_aud.h"
#ifdef IBRT
#include "app_tws_ibrt.h"
#include "app_tws_ibrt_cmd_handler.h"
#include "app_tws_ctrl_thread.h"
#endif
#include "co_math.h"
//#define ANC_MODE_SWITCH_WITHOUT_FADE //Comment this line if you need fade function between anc mode
#ifndef _ANC_FADE_STACK_SIZE
#define _ANC_FADE_STACK_SIZE (1*1024)
#endif
static osThreadId anc_fade_thread_tid;
#define FADE_IN 0x0001
#define FADE_OUT 0x0002
#define CHANGE_FROM_ANC_TO_TT_DIRECTLY 0x0003
static void anc_fade_thread(void const *argument);
osThreadDef(anc_fade_thread, osPriorityBelowNormal,1,_ANC_FADE_STACK_SIZE,"anc_fade_thread");
extern uint8_t app_poweroff_flag;
uint32_t app_anc_get_anc_status(void);
void app_anc_disable(void);
void app_anc_close_anc(void);
osStatus osDelay(uint32_t millisec);
void app_anc_timer_set(uint32_t request, uint32_t delay);
void app_anc_timer_close(void);
extern bool app_mode_is_usbaudio(void); //96k 384k
extern bool app_mode_is_i2s(void); //96k 384k
void app_anc_init_timer(void);
extern void i2s_player_send_stop(void);
extern void fb_anti_howl_start(void);
extern void fb_anti_howl_stop(void);
extern void hal_codec_reconfig_pll_freq(enum AUD_SAMPRATE_T dac_rate, enum AUD_SAMPRATE_T adc_rate);
extern void anc_status_sync(void);
extern void anc_status_sync_init(void);
extern uint8_t is_sbc_mode (void);
extern uint8_t is_sco_mode (void);
void app_anc_switch_set_edge(uint8_t down_edge);
#ifdef __ANC_STICK_SWITCH_USE_GPIO__
typedef void (*ANC_KEY_CALLBACK)(uint8_t status);
static ANC_KEY_CALLBACK app_switch_callback;
#endif
extern int app_shutdown(void);
extern int app_reset(void);
extern void analog_aud_codec_speaker_enable(bool en);
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
extern bool anc_single_mode_is_on(void);
#endif
enum
{
ANC_STATUS_OFF = 0,
ANC_STATUS_ON,
ANC_STATUS_WAITING_ON,
ANC_STATUS_WAITING_OFF,
ANC_STATUS_INIT_ON,
ANC_STATUS_NONE
};
enum
{
ANC_EVENT_INIT = 0,
ANC_EVENT_OPEN,
ANC_EVENT_CLOSE,
ANC_EVENT_FADE_IN,
ANC_EVENT_FADE_OUT,
ANC_EVENT_CHANGE_SAMPLERATE,
ANC_EVENT_CHANGE_STATUS,
ANC_EVENT_HOWL_PROCESS,
ANC_EVENT_SYNC_STATUS,
ANC_EVENT_SYNC_INIT,
ANC_EVENT_PWR_KEY_MONITOR,
ANC_EVENT_PWR_KEY_MONITOR_REBOOT,
ANC_EVENT_SWITCH_KEY_DEBONCE,
SIMPLE_PLAYER_CLOSE_CODEC_EVT,
SIMPLE_PLAYER_DELAY_STOP_EVT,
ANC_EVENT_NONE
};
static uint32_t anc_work_status = ANC_STATUS_OFF;
static uint32_t anc_timer_request = ANC_EVENT_NONE;
static enum AUD_SAMPRATE_T anc_sample_rate[AUD_STREAM_NUM];
static HWTIMER_ID anc_timerid = NULL;
#define anc_gain_adjust_gap (60)
#define anc_init_switch_off_time (MS_TO_TICKS(1000 * 60 * 2))
#define anc_auto_power_off_time (MS_TO_TICKS(1000 * 60 * 60))
#define anc_switch_on_time (MS_TO_TICKS(600))
#define anc_close_delay_time (MS_TO_TICKS(1000 * 20))
#define anc_pwr_key_monitor_time (MS_TO_TICKS(1500))
#define anc_switch_key_debonce_time (MS_TO_TICKS(40))
#if 0//def ANC_FB_CHECK
uint32_t app_fb_check_threshold_vale=0x4000000;
enum ANC_TYPE_T app_anc_check_type = ANC_FEEDBACK;
uint32_t app_fb_check_delay_time=((MS_TO_TICKS(5000)));
#endif
#ifdef ANC_FB_CHECK
uint32_t app_fb_check_threshold_vale=0x4000000;
enum ANC_TYPE_T app_anc_check_type=ANC_FEEDFORWARD;
uint32_t app_fb_check_decrease_resume_delay_time = (MS_TO_TICKS(400));
uint8_t app_fb_check_decrease_value = 18;
uint32_t app_fb_check_delay_time = (MS_TO_TICKS(3000));
uint8_t app_fb_check_delay_time_flag = 0;
uint32_t app_fb_check_delay_time2 = (MS_TO_TICKS(3000));
uint32_t app_fb_check_threshold_count = 20;
uint8_t app_gain_resume_status=1;
#endif
enum
{
APP_ANC_IDLE = 0,
APP_ANC_FADE_IN,
APP_ANC_FADE_OUT,
};
uint32_t app_anc_fade_status = APP_ANC_IDLE;
static bool app_init_done = false;
#ifdef ANC_SWITCH_PIN
static bool app_anc_shutdown = false;
#endif
bool anc_set_dac_pa_delay = false;
static enum ANC_INDEX anc_coef_idx = 0;
extern void analog_aud_enable_dac_pa(uint8_t dac);
bool app_anc_is_on(void)
{
return (ANC_STATUS_ON == anc_work_status);
}
uint32_t app_anc_get_sample_rate(void)
{
return (uint32_t)anc_sample_rate[AUD_STREAM_CAPTURE];
}
void app_anc_set_coef_idx(uint8_t idx)
{
anc_coef_idx = idx;
}
uint8_t app_anc_get_coef_idx(void)
{
return anc_coef_idx;
}
#if defined(IBRT)
static enum ANC_INDEX anc_peer_coef_idx = 0;
static bool anc_status_sync_flag = false;
void app_anc_set_peer_coef_idx(uint8_t idx)
{
anc_peer_coef_idx = idx;
}
uint8_t app_anc_get_peer_coef_idx(void)
{
return anc_peer_coef_idx;
}
void app_anc_set_status_sync_flag(bool status)
{
anc_status_sync_flag = status;
}
bool app_anc_get_status_sync_flag(void)
{
return anc_status_sync_flag;
}
#endif
void app_anc_set_init_done(void)
{
app_init_done = true;
}
void app_anc_switch_turnled(bool on);
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
static ANC_KEY_CALLBACK app_pwr_key_monitor_callback;
static void app_pwr_key_monitor_handler(enum HAL_GPIO_PIN_T pin)
{
uint8_t gpio_val = hal_gpio_pin_get_val(pin);
TRACE(2," %s :%d ", __func__, gpio_val);
if (app_pwr_key_monitor_callback)
app_pwr_key_monitor_callback(gpio_val);
}
bool app_pwr_key_monitor_get_val(void)
{
return (bool)hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)PWR_KEY_MONITOR_PIN);
}
void app_pwr_key_monitor_set_int_edge(uint8_t down_edge)
{
struct HAL_GPIO_IRQ_CFG_T gpiocfg;
gpiocfg.irq_enable = true;
gpiocfg.irq_debounce = true;
gpiocfg.irq_type = HAL_GPIO_IRQ_TYPE_EDGE_SENSITIVE;
gpiocfg.irq_polarity = (down_edge == 1) ? HAL_GPIO_IRQ_POLARITY_LOW_FALLING : HAL_GPIO_IRQ_POLARITY_HIGH_RISING;
gpiocfg.irq_handler = app_pwr_key_monitor_handler;
TRACE(2," %s :%d ", __func__, down_edge);
hal_gpio_setup_irq((enum HAL_GPIO_PIN_T)PWR_KEY_MONITOR_PIN, &gpiocfg);
}
void app_pwr_key_monitor_init(ANC_KEY_CALLBACK callback)
{
app_pwr_key_monitor_callback = callback;
}
#endif
#ifdef ANC_LED_PIN
void app_anc_switch_turnled(bool on)
{
TRACE(2," %s on %d ", __func__, on);
if (cfg_anc_led.pin != HAL_IOMUX_PIN_NUM)
{
if (on)
{
TRACE(0,"on\n");
hal_gpio_pin_set((enum HAL_GPIO_PIN_T)cfg_anc_led.pin);
}
else
{
TRACE(0,"off\n");
hal_gpio_pin_clr((enum HAL_GPIO_PIN_T)cfg_anc_led.pin);
}
}
}
#endif
#ifdef __ANC_STICK_SWITCH_USE_GPIO__
static void app_anc_switch_int_handler(enum HAL_GPIO_PIN_T pin)
{
// uint8_t gpio_val;
uint8_t gpio_val = hal_gpio_pin_get_val(pin);
TRACE(3," %s ,pin %d,status %d", __func__, pin, gpio_val);
#ifdef ANC_LED_PIN
if (gpio_val)
app_anc_switch_turnled(true);
else
app_anc_switch_turnled(false);
#endif
app_anc_switch_set_edge(gpio_val);
app_anc_timer_set(ANC_EVENT_SWITCH_KEY_DEBONCE, anc_switch_key_debonce_time);
//if (app_switch_callback)
// app_switch_callback(gpio_val);
// app_anc_key_handler();
}
void app_anc_switch_init(ANC_KEY_CALLBACK callback)
{
app_switch_callback = callback;
}
#endif
#ifdef ANC_SWITCH_PIN
bool app_anc_set_reboot(void)
{
return (app_anc_shutdown && hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)ANC_SWITCH_PIN));
}
bool app_anc_switch_get_val(void)
{
return (bool)hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)ANC_SWITCH_PIN);
}
void app_anc_switch_set_edge(uint8_t down_edge)
{
struct HAL_GPIO_IRQ_CFG_T gpiocfg;
gpiocfg.irq_enable = true;
gpiocfg.irq_debounce = true;
gpiocfg.irq_type = HAL_GPIO_IRQ_TYPE_EDGE_SENSITIVE;
gpiocfg.irq_polarity = (down_edge == 1) ? HAL_GPIO_IRQ_POLARITY_LOW_FALLING : HAL_GPIO_IRQ_POLARITY_HIGH_RISING;
gpiocfg.irq_handler = app_anc_switch_int_handler;
TRACE(2," %s :%d ", __func__, down_edge);
hal_gpio_setup_irq((enum HAL_GPIO_PIN_T)ANC_SWITCH_PIN, &gpiocfg);
}
#endif
int __anc_usb_app_fadein(enum ANC_TYPE_T type)
{
int32_t gain0_curr, gain1_curr;
int32_t gain0_tg, gain1_tg;
anc_get_gain(&gain0_curr, &gain1_curr, type);
anc_get_cfg_gain(&gain0_tg, &gain1_tg, type);
if (gain0_tg > 0)
{
if (gain0_curr < gain0_tg)
{
gain0_curr++;
}
}
else
{
if (gain0_curr > gain0_tg)
{
gain0_curr--;
}
}
if (gain1_tg > 0)
{
if (gain1_curr < gain1_tg)
{
gain1_curr++;
}
}
else
{
if (gain1_curr > gain1_tg)
{
gain1_curr--;
}
}
hal_sys_timer_delay_us(25);
anc_set_gain(gain0_curr, gain1_curr, type);
if ((gain0_curr == gain0_tg) && (gain1_curr == gain1_tg))
{
TRACE(3,"[%s] cur gain: %d %d", __func__, gain0_curr, gain1_curr);
return 0;
}
return 1;
}
int __anc_usb_app_fadeout(enum ANC_TYPE_T type)
{
int32_t gain0_curr, gain1_curr;
anc_get_gain(&gain0_curr, &gain1_curr, type);
if (gain0_curr > 0)
{
gain0_curr--;
}
else if (gain0_curr < 0)
{
gain0_curr++;
}
if (gain1_curr > 0)
{
gain1_curr--;
}
else if (gain1_curr < 0)
{
gain1_curr++;
}
// gain0_curr = gain1_curr = 0 ;
hal_sys_timer_delay_us(25);
anc_set_gain(gain0_curr, gain1_curr, type);
if ((gain0_curr == 0) && (gain1_curr == 0))
{
TRACE(3,"[%s] gain: %d, %d", __func__, gain0_curr, gain1_curr);
return 0;
}
return 1;
}
#if defined(ANC_FF_ENABLED) && defined(ANC_FB_ENABLED)
int __anc_usb_app_fadein_ff_fb(void)
{
int32_t gain0_curr, gain1_curr;
int32_t gain2_curr, gain3_curr;
int32_t gain0_tg, gain1_tg;
int32_t gain2_tg, gain3_tg;
anc_get_gain(&gain0_curr, &gain1_curr, ANC_FEEDFORWARD);
anc_get_gain(&gain2_curr, &gain3_curr, ANC_FEEDBACK);
anc_get_cfg_gain(&gain0_tg, &gain1_tg, ANC_FEEDFORWARD);
anc_get_cfg_gain(&gain2_tg, &gain3_tg, ANC_FEEDBACK);
uint32_t random_factor = rand();
random_factor %= 5;
if(random_factor==0) random_factor++;
uint32_t random_factor_inverse = 5-random_factor;
if(random_factor_inverse==0) random_factor_inverse++;
random_factor_inverse =1;
if(is_sbc_mode() || is_sco_mode()){
if (gain0_tg > 0)
{
if (gain0_curr < gain0_tg)
{
gain0_curr = MIN(gain0_curr+random_factor_inverse, gain0_tg);
}
}
else
{
if (gain0_curr > gain0_tg)
{
gain0_curr = MAX(gain0_curr-random_factor_inverse, gain0_tg);
}
}
if (gain1_tg > 0)
{
if (gain1_curr < gain1_tg)
{
gain1_curr = MIN(gain1_curr+random_factor_inverse, gain1_tg);
}
}
else
{
if (gain1_curr > gain1_tg)
{
gain1_curr = MAX(gain1_curr-random_factor_inverse, gain1_tg);
}
}
if (gain2_tg > 0)
{
if (gain2_curr < gain2_tg)
{
gain2_curr = MIN(gain2_curr+random_factor_inverse, gain2_tg);
}
}
else
{
if (gain2_curr > gain2_tg)
{
gain2_curr = MAX(gain2_curr-random_factor_inverse, gain2_tg);
}
}
if (gain3_tg > 0)
{
if (gain3_curr < gain3_tg)
{
gain3_curr = MIN(gain3_curr+random_factor_inverse, gain3_tg);
}
}
else
{
if (gain3_curr > gain3_tg)
{
gain3_curr = MAX(gain3_curr-random_factor_inverse, gain3_tg);
}
}
}else{
if (gain0_tg > 0)
{
if (gain0_curr < gain0_tg)
{
gain0_curr = MIN(gain0_curr+random_factor_inverse, gain0_tg);
}
}
else
{
if (gain0_curr > gain0_tg)
{
gain0_curr = MAX(gain0_curr-random_factor_inverse, gain0_tg);
}
}
if (gain1_tg > 0)
{
if (gain1_curr < gain1_tg)
{
gain1_curr = MIN(gain1_curr+random_factor_inverse, gain1_tg);
}
}
else
{
if (gain1_curr > gain1_tg)
{
gain1_curr = MAX(gain1_curr-random_factor_inverse, gain1_tg);
}
}
if (gain2_tg > 0)
{
if (gain2_curr < gain2_tg)
{
gain2_curr = MIN(gain2_curr+random_factor_inverse, gain2_tg);
}
}
else
{
if (gain2_curr > gain2_tg)
{
gain2_curr = MAX(gain2_curr-random_factor_inverse, gain2_tg);
}
}
if (gain3_tg > 0)
{
if (gain3_curr < gain3_tg)
{
gain3_curr = MIN(gain3_curr+random_factor_inverse, gain3_tg);
}
}
else
{
if (gain3_curr > gain3_tg)
{
gain3_curr = MAX(gain3_curr-random_factor_inverse, gain3_tg);
}
}
}
anc_set_gain(gain0_curr, gain1_curr, ANC_FEEDFORWARD);
anc_set_gain(gain2_curr, gain3_curr, ANC_FEEDBACK);
//TRACE(5,"[%s] cur gain: %d %d %d %d", __func__, gain0_curr, gain1_curr, gain2_curr, gain3_curr);
//osDelay(random_factor);
hal_sys_timer_delay_us(40);
if(gain0_curr%40==0)
{
//osDelay(random_factor);
}
if ((gain0_curr == gain0_tg) && (gain1_curr == gain1_tg) && (gain2_curr == gain2_tg) && (gain3_curr == gain3_tg))
{
anc_disable_gain_updated_when_pass0(1);
anc_set_gain(gain0_curr, gain1_curr, ANC_FEEDFORWARD);
anc_set_gain(gain2_curr, gain3_curr, ANC_FEEDBACK);
TRACE(5,"[%s] end cur gain: %d, %d, %d, %d", __func__, gain0_curr, gain1_curr,gain2_curr,gain3_curr);
return 0;
}
return 1;
}
int __anc_usb_app_fadeout_ff_fb(void)
{
int32_t gain0_curr, gain1_curr;
int32_t gain2_curr, gain3_curr;
anc_get_gain(&gain0_curr, &gain1_curr, ANC_FEEDFORWARD);
anc_get_gain(&gain2_curr, &gain3_curr, ANC_FEEDBACK);
uint32_t random_factor = rand();
random_factor = random_factor%5;
if(random_factor==0) random_factor++;
uint32_t random_factor_inverse = 5-random_factor;
if(random_factor_inverse==0) random_factor_inverse++;
random_factor_inverse =1;
if(is_sbc_mode() || is_sco_mode()){
if (gain0_curr > 0)
{
gain0_curr = MAX(gain0_curr-random_factor_inverse,0);
}
else if (gain0_curr < 0)
{
gain0_curr = MIN(gain0_curr+random_factor_inverse,0);
}
if (gain1_curr > 0)
{
gain1_curr = MAX(gain1_curr-random_factor_inverse,0);
}
else if (gain1_curr < 0)
{
gain1_curr = MIN(gain1_curr+random_factor_inverse,0);
}
if (gain2_curr > 0)
{
gain2_curr = MAX(gain2_curr-random_factor_inverse,0);
}
else if (gain2_curr < 0)
{
gain2_curr = MIN(gain2_curr+random_factor_inverse,0);
}
if (gain3_curr > 0)
{
gain3_curr = MAX(gain3_curr-random_factor_inverse,0);
}
else if (gain3_curr < 0)
{
gain3_curr = MIN(gain3_curr+random_factor_inverse,0);
}
}else{
if (gain0_curr > 0)
{
gain0_curr = MAX(gain0_curr-random_factor_inverse,0);
}
else if (gain0_curr < 0)
{
gain0_curr = MIN(gain0_curr+random_factor_inverse,0);
}
if (gain1_curr > 0)
{
gain1_curr = MAX(gain1_curr-random_factor_inverse,0);
}
else if (gain1_curr < 0)
{
gain1_curr = MIN(gain1_curr+random_factor_inverse,0);
}
if (gain2_curr > 0)
{
gain2_curr = MAX(gain2_curr-random_factor_inverse,0);
}
else if (gain2_curr < 0)
{
gain2_curr = MIN(gain2_curr+random_factor_inverse,0);
}
if (gain3_curr > 0)
{
gain3_curr = MAX(gain3_curr-random_factor_inverse,0);
}
else if (gain3_curr < 0)
{
gain3_curr = MIN(gain3_curr+random_factor_inverse,0);
}
}
anc_set_gain(gain0_curr, gain1_curr, ANC_FEEDFORWARD);
anc_set_gain(gain2_curr, gain3_curr, ANC_FEEDBACK);
//TRACE(5,"[%s] cur gain: %d %d %d %d", __func__, gain0_curr, gain1_curr, gain2_curr, gain3_curr);
//osDelay(random_factor);
hal_sys_timer_delay_us(40);
if(gain0_curr%40==0)
{
//osDelay(random_factor);
}
if ((gain0_curr == 0) && (gain1_curr == 0) && (gain2_curr == 0) && (gain3_curr == 0))
{
anc_disable_gain_updated_when_pass0(1);
anc_set_gain(gain0_curr, gain1_curr, ANC_FEEDFORWARD);
anc_set_gain(gain2_curr, gain3_curr, ANC_FEEDBACK);
TRACE(5,"[%s] end cur gain: %d, %d, %d, %d", __func__, gain0_curr, gain1_curr,gain2_curr,gain3_curr);
return 0;
}
return 1;
}
#endif
void anc_gain_fade_handle(void)
{
TRACE(2," %s %d ", __func__, app_anc_fade_status);
if (app_anc_fade_status == APP_ANC_FADE_OUT)
{
osSignalSet(anc_fade_thread_tid,FADE_OUT);
}
if (app_anc_fade_status == APP_ANC_FADE_IN)
{
#ifdef ANC_LED_PIN
app_anc_switch_turnled(true);
#endif
osSignalSet(anc_fade_thread_tid,FADE_IN);
if (anc_set_dac_pa_delay)
{
anc_set_dac_pa_delay = false;
// osDelay(600);
// analog_aud_enable_dac_pa(48);
}
}
}
void anc_fade_thread(void const *argument)
{
osEvent evt;
evt.status = 0;
uint32_t singles = 0;
while(1)
{
evt = osSignalWait(0,osWaitForever);
singles = evt.value.signals;
TRACE(2,"anc_fade_thread. %d",singles);
if(evt.status == osEventSignal)
{
switch (singles)
{
case FADE_IN:
#if defined(ANC_FF_ENABLED) && defined(ANC_FB_ENABLED)
anc_disable_gain_updated_when_pass0(0);
while(__anc_usb_app_fadein_ff_fb());
#else
#ifdef ANC_FF_ENABLED
while (__anc_usb_app_fadein(ANC_FEEDFORWARD))
;
#endif
#ifdef ANC_FB_ENABLED
while (__anc_usb_app_fadein(ANC_FEEDBACK))
;
#endif
#endif
app_anc_fade_status = APP_ANC_IDLE;
break;
case FADE_OUT:
#if defined(ANC_FF_ENABLED) && defined(ANC_FB_ENABLED)
anc_disable_gain_updated_when_pass0(0);
while(__anc_usb_app_fadeout_ff_fb());
#else
#ifdef ANC_FF_ENABLED
while (__anc_usb_app_fadeout(ANC_FEEDFORWARD))
;
#endif
#ifdef ANC_FB_ENABLED
while (__anc_usb_app_fadeout(ANC_FEEDBACK))
;
#endif
#endif
app_anc_fade_status = APP_ANC_IDLE;
#ifdef ANC_FB_CHECK
hal_codec_anc_fb_check_set_irq_handler(anc_fb_check_irq_handler);
anc_fb_check_param();
#endif
break;
case CHANGE_FROM_ANC_TO_TT_DIRECTLY:
#if defined(ANC_FF_ENABLED) && defined(ANC_FB_ENABLED)
anc_disable_gain_updated_when_pass0(0);
while(__anc_usb_app_fadeout_ff_fb());
#else
#ifdef ANC_FF_ENABLED
while (__anc_usb_app_fadeout(ANC_FEEDFORWARD));
#endif
#ifdef ANC_FB_ENABLED
while (__anc_usb_app_fadeout(ANC_FEEDBACK));
#endif
#endif
#if defined(ANC_FF_ENABLED) && defined(ANC_FB_ENABLED)
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_FEEDFORWARD,ANC_GAIN_DELAY);
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_FEEDBACK,ANC_GAIN_DELAY);
#ifdef AUDIO_ANC_FB_MC_HW
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_MUSICCANCLE,ANC_GAIN_DELAY);
#endif
#else
#ifdef ANC_FF_ENABLED
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_FEEDFORWARD,ANC_GAIN_DELAY);
#endif
#ifdef ANC_FB_ENABLED
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_FEEDBACK,ANC_GAIN_DELAY);
#endif
#endif
#if defined(ANC_FF_ENABLED) && defined(ANC_FB_ENABLED)
anc_disable_gain_updated_when_pass0(0);
while(__anc_usb_app_fadein_ff_fb());
#else
#ifdef ANC_FF_ENABLED
while (__anc_usb_app_fadein(ANC_FEEDFORWARD));
#endif
#ifdef ANC_FB_ENABLED
while (__anc_usb_app_fadein(ANC_FEEDBACK));
#endif
#endif
app_anc_fade_status = APP_ANC_IDLE;
//recommand to play "ANC SWITCH" prompt here...
break;
default:
break;
}
}
else
{
TRACE(2,"anc fade thread evt error");
continue;
}
}
}
void app_anc_gain_fadein(void)
{
APP_MESSAGE_BLOCK msg;
TRACE(1," %s ", __func__);
if (app_poweroff_flag)
return;
app_anc_fade_status = APP_ANC_FADE_IN;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = ANC_EVENT_FADE_IN;
app_mailbox_put(&msg);
}
void app_anc_post_anc_codec_close(void)
{
APP_MESSAGE_BLOCK msg;
TRACE(1," %s ", __func__);
if (app_poweroff_flag)
return;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = SIMPLE_PLAYER_CLOSE_CODEC_EVT;
app_mailbox_put(&msg);
}
void app_anc_gain_fadeout(void)
{
APP_MESSAGE_BLOCK msg;
TRACE(1," %s ", __func__);
if (app_poweroff_flag)
return;
app_anc_fade_status = APP_ANC_FADE_OUT;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = ANC_EVENT_FADE_OUT;
app_mailbox_put(&msg);
}
void app_anc_status_post(uint8_t status)
{
APP_MESSAGE_BLOCK msg;
TRACE(2," %s status %d", __func__, status);
if (app_poweroff_flag)
return;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = ANC_EVENT_CHANGE_STATUS;
msg.msg_body.message_Param0 = status;
app_mailbox_put(&msg);
}
void app_anc_status_sync(uint8_t status)
{
APP_MESSAGE_BLOCK msg;
TRACE(2," %s status %d", __func__, status);
if (app_poweroff_flag)
return;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = ANC_EVENT_SYNC_STATUS;
msg.msg_body.message_Param0 = status;
app_mailbox_put(&msg);
}
void app_anc_status_sync_init(void)
{
APP_MESSAGE_BLOCK msg;
TRACE(1," %s ", __func__);
if (app_poweroff_flag)
return;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = ANC_EVENT_SYNC_INIT;
app_mailbox_put(&msg);
}
void app_anc_do_init(void)
{
APP_MESSAGE_BLOCK msg;
TRACE(1," %s DO INIT", __func__);
if (app_poweroff_flag)
return;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = ANC_EVENT_INIT;
app_mailbox_put(&msg);
}
void app_anc_send_howl_evt(uint32_t howl)
{
APP_MESSAGE_BLOCK msg;
TRACE(2," %s %d", __func__, howl);
if (app_poweroff_flag)
return;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = ANC_EVENT_HOWL_PROCESS;
msg.msg_body.message_Param0 = howl;
app_mailbox_put(&msg);
}
void app_anc_send_pwr_key_monitor_evt(uint8_t level)
{
APP_MESSAGE_BLOCK msg;
TRACE(2," %s %d", __func__, level);
if (app_poweroff_flag)
return;
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = ANC_EVENT_PWR_KEY_MONITOR;
msg.msg_body.message_Param0 = level;
app_mailbox_put(&msg);
}
extern void simple_player_delay_stop(void);
void app_anc_post_simplayer_stop_evt(void)
{
APP_MESSAGE_BLOCK msg;
TRACE(1," %s d", __func__);
msg.mod_id = APP_MODUAL_ANC;
msg.msg_body.message_id = SIMPLE_PLAYER_DELAY_STOP_EVT;
msg.msg_body.message_Param0 = 0;
app_mailbox_put(&msg);
}
bool anc_enabled(void)
{
return (anc_work_status == ANC_STATUS_ON);
}
void app_anc_resample(uint32_t res_ratio, uint32_t *in, uint32_t *out, uint32_t samples)
{
uint32_t flag = int_lock();
for (int i = samples; i > 0; i--)
{
for (int j = 0; j < res_ratio; j++)
{
*(out + (i - 1) * res_ratio + j) = *(in + i - 1);
}
}
int_unlock(flag);
}
void app_anc_select_coef(void)
{
TRACE(2,"enter %s %d\n", __FUNCTION__, __LINE__);
#ifdef ANC_FF_ENABLED
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_FEEDFORWARD, ANC_GAIN_DELAY);
#endif
#ifdef ANC_FB_ENABLED
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_FEEDBACK, ANC_GAIN_DELAY);
#endif
#ifdef AUDIO_ANC_FB_MC_HW
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_MUSICCANCLE, ANC_GAIN_NO_DELAY);
#endif
TRACE(2,"exit %s %d\n", __FUNCTION__, __LINE__);
}
void app_anc_enable(void)
{
TRACE(2,"enter %s %d\n", __FUNCTION__, __LINE__);
//anc_active_codec();
#ifndef __SIMPLE_INTERNAL_PLAYER_SUPPORT__
analog_aud_codec_speaker_enable(true);
#endif
#ifdef ANC_FF_ENABLED
anc_open(ANC_FEEDFORWARD);
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_FEEDFORWARD, ANC_GAIN_DELAY);
#endif
#ifdef ANC_FB_ENABLED
anc_open(ANC_FEEDBACK);
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_FEEDBACK, ANC_GAIN_DELAY);
#endif
#ifdef AUDIO_ANC_FB_MC_HW
anc_open(ANC_MUSICCANCLE);
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_MUSICCANCLE, ANC_GAIN_NO_DELAY);
#endif
#ifdef AUDIO_ANC_FB_MC_HW
int32_t gain_ch_l = 0;
int32_t gain_ch_r = 0;
anc_get_cfg_gain(&gain_ch_l, &gain_ch_r, ANC_MUSICCANCLE);
anc_set_gain(gain_ch_l, gain_ch_r, ANC_MUSICCANCLE);
#endif
#if defined(ANC_WNR_ENABLED)
if (is_sco_mode()) {
anc_wnr_open(ANC_WNR_OPEN_MODE_CONFIGURE);
} else {
anc_wnr_open(ANC_WNR_OPEN_MODE_STANDALONE);
}
#endif
#if defined(ANC_ASSIST_ENABLED)
anc_assist_open(ANC_ASSIST_STANDALONE);
#endif
TRACE(2,"exit %s %d\n", __FUNCTION__, __LINE__);
}
void app_anc_disable(void)
{
TRACE(2,"enter %s %d\n", __FUNCTION__, __LINE__);
#if defined(ANC_WNR_ENABLED)
anc_wnr_close();
#endif
#if defined(ANC_ASSIST_ENABLED)
anc_assist_close();
#endif
#ifdef AUDIO_ANC_FB_MC_HW
anc_close(ANC_MUSICCANCLE);
#endif
#ifdef ANC_FF_ENABLED
anc_close(ANC_FEEDFORWARD);
#endif
#ifdef ANC_FB_ENABLED
anc_close(ANC_FEEDBACK);
#endif
TRACE(2,"exit %s %d\n", __FUNCTION__, __LINE__);
}
static void anc_sample_rate_change(enum AUD_STREAM_T stream, enum AUD_SAMPRATE_T rate, enum AUD_SAMPRATE_T *new_play, enum AUD_SAMPRATE_T *new_cap)
{
enum AUD_SAMPRATE_T play_rate, cap_rate;
if (anc_sample_rate[stream] != rate) {
#ifdef CHIP_BEST1000
if (stream == AUD_STREAM_PLAYBACK) {
play_rate = rate;
cap_rate = rate * (anc_sample_rate[AUD_STREAM_CAPTURE] / anc_sample_rate[AUD_STREAM_PLAYBACK]);
} else {
play_rate = rate / (anc_sample_rate[AUD_STREAM_CAPTURE] / anc_sample_rate[AUD_STREAM_PLAYBACK]);
cap_rate = rate;
}
#else
play_rate = rate;
cap_rate = rate;
#ifdef ANC_FF_ENABLED
anc_select_coef(play_rate,anc_coef_idx, ANC_FEEDFORWARD, ANC_GAIN_NO_DELAY);
#endif
#ifdef ANC_FB_ENABLED
anc_select_coef(play_rate,anc_coef_idx, ANC_FEEDBACK, ANC_GAIN_NO_DELAY);
#endif
#ifdef AUDIO_ANC_FB_MC_HW
anc_select_coef(play_rate,anc_coef_idx, ANC_MUSICCANCLE, ANC_GAIN_NO_DELAY);
#endif
#endif //CHIP_BEST1000
TRACE(5,"%s: Update anc sample rate from %u/%u to %u/%u", __func__,
anc_sample_rate[AUD_STREAM_PLAYBACK], anc_sample_rate[AUD_STREAM_CAPTURE], play_rate, cap_rate);
if (new_play) {
*new_play= play_rate;
}
if (new_cap) {
*new_cap = cap_rate;
}
anc_sample_rate[AUD_STREAM_PLAYBACK] = play_rate;
anc_sample_rate[AUD_STREAM_CAPTURE] = cap_rate;
}
}
void app_anc_open_anc(void)
{
enum AUD_SAMPRATE_T playback_rate;
enum AUD_SAMPRATE_T capture_rate;
AF_ANC_HANDLER handler;
TRACE(2,"enter %s %d\n", __FUNCTION__, __LINE__);
handler = anc_sample_rate_change;
#ifdef __SIMPLE_INTERNAL_PLAYER_SUPPORT__
app_start_player_by_anc();
#endif
if (anc_sample_rate[AUD_STREAM_PLAYBACK] == AUD_SAMPRATE_NULL) {
#ifdef CHIP_BEST1000
anc_sample_rate[AUD_STREAM_PLAYBACK] = AUD_SAMPRATE_96000;
anc_sample_rate[AUD_STREAM_CAPTURE] = AUD_SAMPRATE_384000;
#else // !CHIP_BEST1000
anc_sample_rate[AUD_STREAM_PLAYBACK] = AUD_SAMPRATE_48000;
anc_sample_rate[AUD_STREAM_CAPTURE] = AUD_SAMPRATE_48000;
#endif
anc_sample_rate[AUD_STREAM_PLAYBACK] = hal_codec_anc_convert_rate(anc_sample_rate[AUD_STREAM_PLAYBACK]);
anc_sample_rate[AUD_STREAM_CAPTURE] = hal_codec_anc_convert_rate(anc_sample_rate[AUD_STREAM_CAPTURE]);
}
playback_rate = anc_sample_rate[AUD_STREAM_PLAYBACK];
capture_rate = anc_sample_rate[AUD_STREAM_CAPTURE];
pmu_anc_config(1);
#ifdef ANC_FF_ENABLED
af_anc_open(ANC_FEEDFORWARD, playback_rate, capture_rate, handler);
anc_open(ANC_FEEDFORWARD);
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_FEEDFORWARD, ANC_GAIN_DELAY);
#endif
#ifdef ANC_FB_ENABLED
af_anc_open(ANC_FEEDBACK, playback_rate, capture_rate, handler);
anc_open(ANC_FEEDBACK);
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_FEEDBACK, ANC_GAIN_DELAY);
#endif
#ifdef AUDIO_ANC_FB_MC_HW
anc_open(ANC_MUSICCANCLE);
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_MUSICCANCLE, ANC_GAIN_NO_DELAY);
#endif
#if defined(AUDIO_ANC_TT_HW)
anc_open(ANC_TALKTHRU);
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx, ANC_TALKTHRU, ANC_GAIN_NO_DELAY);
#endif
#ifdef AUDIO_ANC_FB_MC_HW
int32_t gain_ch_l = 0;
int32_t gain_ch_r = 0;
anc_get_cfg_gain(&gain_ch_l, &gain_ch_r, ANC_MUSICCANCLE);
anc_set_gain(gain_ch_l, gain_ch_r, ANC_MUSICCANCLE);
#endif
#if defined(ANC_WNR_ENABLED)
if (is_sco_mode()) {
anc_wnr_open(ANC_WNR_OPEN_MODE_CONFIGURE);
} else {
anc_wnr_open(ANC_WNR_OPEN_MODE_STANDALONE);
}
#endif
#if defined(ANC_ASSIST_ENABLED)
anc_assist_open(ANC_ASSIST_STANDALONE);
#endif
TRACE(2,"exit %s %d\n", __FUNCTION__, __LINE__);
}
void app_anc_close_anc(void)
{
TRACE(2,"enter %s %d\n", __FUNCTION__, __LINE__);
anc_set_dac_pa_delay = false;
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
if (anc_single_mode_is_on())
{
analog_aud_codec_speaker_enable(false);
}
#endif
#ifdef ANC_WNR_ENABLED
anc_wnr_close();
#endif
#if defined(ANC_ASSIST_ENABLED)
anc_assist_close();
#endif
#if defined(AUDIO_ANC_TT_HW)
anc_close(ANC_TALKTHRU);
#endif
#ifdef ANC_FF_ENABLED
anc_close(ANC_FEEDFORWARD);
af_anc_close(ANC_FEEDFORWARD);
#endif
#ifdef ANC_FB_ENABLED
#if defined(AUDIO_ANC_FB_MC_HW)
anc_close(ANC_MUSICCANCLE);
#endif
anc_close(ANC_FEEDBACK);
af_anc_close(ANC_FEEDBACK);
#endif
pmu_anc_config(0);
#ifdef __SIMPLE_INTERNAL_PLAYER_SUPPORT__
app_stop_player_by_anc();
#endif
TRACE(2,"exit %s %d\n", __FUNCTION__, __LINE__);
}
void app_anc_bitrate_reopen(void)
{
TRACE(2," %s status %d", __func__, anc_work_status);
if (anc_work_status == ANC_STATUS_INIT_ON)
{
// hal_codec_reconfig_pll_freq(playback_rate, capture_rate);
}
else if (anc_work_status == ANC_STATUS_ON)
{
// hal_codec_reconfig_pll_freq(playback_rate, capture_rate);
}
else if (anc_work_status == ANC_STATUS_WAITING_ON)
{
}
else
{
TRACE(0,"no deal situation.");
}
}
void app_anc_status_change(void)
{
#if defined(IBRT)
ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
if (p_ibrt_ctrl->current_role == IBRT_SLAVE)
{
anc_coef_idx = anc_peer_coef_idx;
}
#endif
TRACE(3,"%s anc_work_status: %d anc_coef_idx: %d", __func__, anc_work_status, anc_coef_idx);
switch (anc_work_status)
{
case ANC_STATUS_OFF:
anc_work_status = ANC_STATUS_WAITING_ON;
app_anc_timer_set(ANC_EVENT_OPEN, anc_switch_on_time);
app_anc_open_anc();
break;
case ANC_STATUS_ON:
#if (ANC_COEF_LIST_NUM > 1)
#ifdef __BT_ANC_KEY__
if(anc_status_sync_flag == false)
{
anc_coef_idx++;
}
#endif
if (anc_coef_idx < ANC_COEF_LIST_NUM)
{
TRACE(2," %s set coef idx: %d ", __func__, anc_coef_idx);
#ifdef ANC_MODE_SWITCH_WITHOUT_FADE
#ifdef ANC_FF_ENABLED
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_FEEDFORWARD,ANC_GAIN_NO_DELAY);
#endif
#ifdef ANC_FB_ENABLED
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_FEEDBACK,ANC_GAIN_NO_DELAY);
#endif
#ifdef AUDIO_ANC_FB_MC_HW
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_MUSICCANCLE,ANC_GAIN_NO_DELAY);
#endif
//recommand to play "ANC SWITCH" prompt here...
#else
osSignalSet(anc_fade_thread_tid,CHANGE_FROM_ANC_TO_TT_DIRECTLY);
#endif
}
else
{
anc_coef_idx = 0;
app_anc_timer_set(ANC_EVENT_CLOSE, anc_close_delay_time);
app_anc_gain_fadeout();
anc_work_status = ANC_STATUS_WAITING_OFF;
}
#else
anc_coef_idx = 0;
app_anc_timer_set(ANC_EVENT_CLOSE, anc_close_delay_time);
app_anc_gain_fadeout();
anc_work_status = ANC_STATUS_WAITING_OFF;
#endif
break;
case ANC_STATUS_INIT_ON:
app_anc_select_coef();
app_anc_gain_fadein();
anc_work_status = ANC_STATUS_WAITING_ON;
app_anc_timer_close();
break;
default:
break;
}
if(anc_status_sync_flag == true)
anc_status_sync_flag = false;
}
static int app_anc_handle_process(APP_MESSAGE_BODY *msg_body)
{
uint32_t evt = msg_body->message_id;
uint32_t arg0 = msg_body->message_Param0;
TRACE(4," %s evt: %d, arg0: %d , anc status :%d", __func__, evt, arg0, anc_work_status);
switch (evt)
{
case ANC_EVENT_INIT:
//init anc_timer
app_anc_init_timer();
//init anc&open codec
#ifdef __AUDIO_SECTION_SUPPT__
anc_load_cfg();
#endif
#ifdef __ANC_INIT_ON__
app_anc_open_anc();
anc_work_status = ANC_STATUS_INIT_ON;
app_anc_timer_set(ANC_EVENT_CLOSE, anc_init_switch_off_time);
#else
anc_work_status = ANC_STATUS_OFF;
#endif
#ifdef __ANC_STICK_SWITCH_USE_GPIO__
if (app_anc_switch_get_val() == ANC_SWITCH_ON_LEVEL)
{
app_anc_switch_set_edge(ANC_SWITCH_ON_LEVEL);
app_anc_status_post(ANC_SWITCH_ON_LEVEL);
}
else
{
app_anc_switch_set_edge(!(bool)ANC_SWITCH_ON_LEVEL);
}
#endif
//anc_coef_idx = 0;
anc_fade_thread_tid = osThreadCreate(osThread(anc_fade_thread),NULL);
break;
case ANC_EVENT_FADE_IN:
case ANC_EVENT_FADE_OUT:
anc_gain_fade_handle();
if (evt == ANC_EVENT_FADE_IN)
{
anc_work_status = ANC_STATUS_ON;
//recommand to play "ANC ON" prompt here...
}
if (evt == ANC_EVENT_FADE_OUT)
{
anc_work_status = ANC_STATUS_INIT_ON;
//recommand to play "ANC OFF" prompt here...
}
break;
case ANC_EVENT_CHANGE_SAMPLERATE:
app_anc_bitrate_reopen();
break;
case ANC_EVENT_CHANGE_STATUS:
#ifdef __ANC_STICK_SWITCH_USE_GPIO__
osDelay(10);
if (app_anc_switch_get_val() != (bool)arg0)
{ //debonce
TRACE(0,"io level not equeue exit");
break;
}
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
if (anc_single_mode_is_on())
{
if (arg0 != ANC_SWITCH_ON_LEVEL)
{
TRACE(1," Anc ON but exit %d ", app_init_done);
if (app_init_done)
{
app_anc_shutdown = true;
app_shutdown();
}
else
{
app_anc_timer_set(ANC_EVENT_SWITCH_KEY_DEBONCE, anc_switch_key_debonce_time);
}
return 0;
}
}
#endif
if (arg0 != ANC_SWITCH_ON_LEVEL)
app_anc_switch_set_edge((!(bool)ANC_SWITCH_ON_LEVEL));
else
app_anc_switch_set_edge(ANC_SWITCH_ON_LEVEL);
if (((arg0 == ANC_SWITCH_ON_LEVEL) && (anc_work_status == ANC_STATUS_ON)) ||
((arg0 != ANC_SWITCH_ON_LEVEL) && (anc_work_status == ANC_STATUS_OFF)))
{
//status same, no handle
TRACE(0," Anc NOT ON, exit");
return 0;
}
#endif
#if defined(IBRT)
if(((BOOL)arg0 == false) && (app_anc_work_status() == false))
{
anc_coef_idx = 0;
anc_peer_coef_idx = 0;
anc_status_sync_flag = 0;
return 0;
}
if(((BOOL)arg0 == true) && (app_anc_work_status() == true) && (anc_coef_idx == anc_peer_coef_idx))
{
anc_status_sync_flag = 0;
return 0;
}
#endif
app_anc_status_change();
break;
case ANC_EVENT_SYNC_STATUS:
#if defined(IBRT)
TRACE(4,"%s anc_work_status %d--->%d anc_coef_idx:%d ", __func__, anc_work_status, arg0, anc_coef_idx);
if(ANC_STATUS_ON == arg0)
{
arg0 = 1;
}
else
{
arg0 = 0;
}
uint8_t buf[3] = {0};
buf[0] = (uint8_t)arg0;
buf[1] = (uint8_t)anc_coef_idx;
buf[2] = false;//set peer anc_status_sync_flag = false
tws_ctrl_send_cmd(APP_TWS_CMD_SYNC_ANC_STATUS, buf, 3);
#endif
break;
case ANC_EVENT_SYNC_INIT:break;
case ANC_EVENT_HOWL_PROCESS:
//disable anc,set max gain,enable anc
{
//uint32_t howl = arg0;
if (anc_work_status == ANC_STATUS_ON)
{
//__anc_usb_app_howl_set_gain(howl);
}
}
break;
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
case ANC_EVENT_PWR_KEY_MONITOR:
osDelay(10);
if (app_pwr_key_monitor_get_val() != (bool)arg0) //debonce
return 0;
if ((bool)arg0)
{
app_anc_timer_set(ANC_EVENT_PWR_KEY_MONITOR_REBOOT, anc_pwr_key_monitor_time);
app_pwr_key_monitor_set_int_edge(1);
}
else
{
hwtimer_stop(anc_timerid);
app_pwr_key_monitor_set_int_edge(0);
}
break;
#endif
case SIMPLE_PLAYER_DELAY_STOP_EVT:
#ifdef __SIMPLE_INTERNAL_PLAYER_SUPPORT__
simple_player_delay_stop();
#endif
break;
case SIMPLE_PLAYER_CLOSE_CODEC_EVT:
app_anc_close_anc();
anc_work_status = ANC_STATUS_OFF;
break;
default:break;
}
return 0;
}
static void anc_gain_fade_timer_handler(void *p)
{
TRACE(2," %s , request %d ", __func__, anc_timer_request);
switch (anc_timer_request)
{
case ANC_EVENT_OPEN:
app_anc_gain_fadein();
break;
case ANC_EVENT_CLOSE:
//real close
//app_anc_close_anc();
//anc_work_status = ANC_STATUS_OFF;
app_anc_post_anc_codec_close();
break;
case ANC_EVENT_PWR_KEY_MONITOR_REBOOT:
TRACE(0," reboot !");
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_REBOOT);
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_REBOOT_ANC_ON);
hal_sw_bootmode_set(HAL_SW_BOOTMODE_REBOOT_BT_ON);
app_reset();
break;
case ANC_EVENT_SWITCH_KEY_DEBONCE:
TRACE(0," ANC SWITCH KEY ");
#ifdef __ANC_STICK_SWITCH_USE_GPIO__
if (app_switch_callback)
app_switch_callback(hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)ANC_SWITCH_PIN));
#endif
break;
default:
break;
}
anc_timer_request = ANC_EVENT_NONE;
hwtimer_stop(anc_timerid);
}
void app_anc_init_timer(void)
{
if (anc_timerid == NULL)
anc_timerid = hwtimer_alloc((HWTIMER_CALLBACK_T)anc_gain_fade_timer_handler, &anc_timer_request);
}
void app_anc_timer_set(uint32_t request, uint32_t delay)
{
TRACE(3," %s request %d , delay %ds ", __func__, request, (TICKS_TO_MS(delay) / 1000));
if (anc_timerid == NULL)
return;
anc_timer_request = request;
hwtimer_stop(anc_timerid);
hwtimer_start(anc_timerid, delay);
}
void app_anc_timer_close(void)
{
TRACE(3," %s enter...", __func__);
if (anc_timerid == NULL)
{
return;
}
anc_timer_request = ANC_EVENT_NONE;
hwtimer_stop(anc_timerid);
}
#if defined(IBRT)
void app_anc_cmd_receive_process(uint8_t *buf, uint16_t len)
{
TRACE(1, "[%s] enter...", __func__);
if(buf[0] == IBRT_ACTION_ANC_NOTIRY_MASTER_EXCHANGE_COEF)
{
switch(buf[1])
{
#ifdef __BT_ANC_KEY__
case 0:app_anc_key(NULL, NULL);break;//slave invoke app_anc_key();
#endif
#ifndef __BT_ANC_KEY__
case 1:app_anc_start();break;//slave invoke app_anc_start();
case 2:app_anc_switch_coef(buf[2]);break;//slave invoke app_anc_switch_coef();
case 3:app_anc_stop();break;//slave invoke app_anc_stop();
#endif
default:TRACE(1, "[%s] cmd invalid...", __func__);break;
}
}
}
static void app_anc_notify_master_to_exchange_coef(uint8_t arg0, uint8_t arg1)
{
uint8_t buf[3] = {0};
TRACE(3,"[%s] arg0:%d arg1:%d", __func__, arg0, arg1);
buf[0] = IBRT_ACTION_ANC_NOTIRY_MASTER_EXCHANGE_COEF;
buf[1] = arg0;
buf[2] = arg1;
app_ibrt_ui_send_user_action(buf, 3);
}
#endif
#ifdef __BT_ANC_KEY__
void app_anc_key(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s anc_work_st:%d , timer:%d", __func__, anc_work_status, anc_timer_request);
bool flag = app_anc_work_status();
#if defined(IBRT)
ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
TRACE(2,"[%s] current_role: %d", __func__, p_ibrt_ctrl->current_role);
if (p_ibrt_ctrl->current_role == IBRT_SLAVE)
{
app_anc_notify_master_to_exchange_coef(0,0);
return;
}
app_anc_status_sync(!flag);
#endif
app_anc_status_post(!flag);
}
#endif
#ifndef __BT_ANC_KEY__
int app_anc_start(void)
{
TRACE(1,"[%s] enter...", __func__);
bool flag = app_anc_work_status();
if(flag == true)
{
TRACE(1,"[%s] anc has been on...", __func__);
return -1;
}
#if defined(IBRT)
ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
TRACE(2,"[%s] current_role: %d", __func__, p_ibrt_ctrl->current_role);
if (p_ibrt_ctrl->current_role == IBRT_SLAVE)
{
app_anc_notify_master_to_exchange_coef(1,0);
return -1;
}
anc_coef_idx = 0;
app_anc_status_sync(!flag);
#endif
anc_coef_idx = 0;
app_anc_status_post(!flag);
return 0;
}
int app_anc_switch_coef(uint8_t index)
{
TRACE(1,"[%s] enter...", __func__);
bool flag = app_anc_work_status();
if(flag == false)
{
TRACE(1,"[%s] anc has been off...", __func__);
return -1;
}
if(index == anc_coef_idx)
{
TRACE(1,"[%s] anc coef has been load...", __func__);
return -1;
}
#if defined(IBRT)
ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
TRACE(2,"[%s] current_role: %d", __func__, p_ibrt_ctrl->current_role);
if (p_ibrt_ctrl->current_role == IBRT_SLAVE)
{
app_anc_notify_master_to_exchange_coef(2,index);
return -1;
}
anc_coef_idx = index;
app_anc_status_sync(!flag);
#endif
anc_coef_idx = index;
app_anc_status_post(!flag);
return 0;
}
int app_anc_stop(void)
{
TRACE(1,"[%s] enter...", __func__);
bool flag = app_anc_work_status();
if(flag == false)
{
TRACE(1,"[%s] anc has been off...", __func__);
return -1;
}
#if defined(IBRT)
ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
TRACE(2,"[%s] current_role: %d", __func__, p_ibrt_ctrl->current_role);
if (p_ibrt_ctrl->current_role == IBRT_SLAVE)
{
app_anc_notify_master_to_exchange_coef(3,0);
return -1;
}
anc_coef_idx = ANC_COEF_NUM;
app_anc_status_sync(!flag);
#endif
anc_coef_idx = ANC_COEF_NUM;
app_anc_status_post(!flag);
return 0;
}
#endif
void app_anc_ios_init(void)
{
#ifdef __ANC_STICK_SWITCH_USE_GPIO__
if (cfg_anc_switch.pin != HAL_IOMUX_PIN_NUM)
{
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&cfg_anc_switch, 1);
hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)cfg_anc_switch.pin, HAL_GPIO_DIR_IN, 0);
}
#endif
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
if (cfg_pwr_key_monitor.pin != HAL_IOMUX_PIN_NUM)
{
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&cfg_pwr_key_monitor, 1);
hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)cfg_pwr_key_monitor.pin, HAL_GPIO_DIR_IN, 0);
}
if (cfg_anc_led.pin != HAL_IOMUX_PIN_NUM)
{
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&cfg_anc_led, 1);
hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)cfg_anc_led.pin, HAL_GPIO_DIR_OUT, 0);
}
#endif
#ifdef ANC_SWITCH_PIN
uint8_t gpio_val = hal_gpio_pin_get_val(ANC_SWITCH_PIN);
if (gpio_val)
{
app_anc_switch_turnled(true);
TRACE(1," %s turn on led", __func__);
}
else
{
app_anc_switch_turnled(false);
TRACE(1," %s turn off led", __func__);
}
#endif
}
int app_anc_open_module(void)
{
TRACE(1,"%s ", __func__);
//set app module
app_set_threadhandle(APP_MODUAL_ANC, app_anc_handle_process);
app_anc_do_init();
#ifdef __ANC_STICK_SWITCH_USE_GPIO__
app_anc_switch_init(app_anc_status_post);
app_anc_switch_set_edge(app_anc_switch_get_val());
#endif
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
if (anc_single_mode_is_on())
{
// app_pwr_key_monitor_init(app_anc_send_pwr_key_monitor_evt);
// app_pwr_key_monitor_set_int_edge(app_pwr_key_monitor_get_val());
}
#endif
return 0;
}
int app_anc_close_module(void)
{
TRACE(1," %s ", __func__);
anc_timer_request = ANC_EVENT_NONE;
if (anc_timerid)
{
hwtimer_stop(anc_timerid);
hwtimer_free(anc_timerid);
anc_timerid = NULL;
}
if (app_anc_get_anc_status() != ANC_STATUS_OFF)
{
anc_work_status = ANC_STATUS_OFF;
app_anc_disable();
app_anc_close_anc();
}
app_set_threadhandle(APP_MODUAL_ANC, NULL);
return 0;
}
enum AUD_SAMPRATE_T app_anc_get_play_rate(void)
{
return anc_sample_rate[AUD_STREAM_PLAYBACK];
}
bool app_anc_work_status(void)
{
// TRACE(2," %s st %d", __func__, anc_work_status);
return (anc_work_status == ANC_STATUS_ON || anc_work_status == ANC_STATUS_WAITING_ON);
}
uint32_t app_anc_get_anc_status(void)
{
return anc_work_status;
}
void test_anc(void)
{
app_anc_open_anc();
app_anc_enable();
}
void test_anc_switch_coef(void)
{
anc_coef_idx++;
TRACE(2," %s set coef idx: %d ", __func__, anc_coef_idx);
if (ANC_STATUS_OFF == anc_work_status || ANC_STATUS_INIT_ON == anc_work_status)
{
app_anc_status_change();
anc_coef_idx = 0;
return;
}
if (anc_coef_idx < (ANC_COEF_LIST_NUM))
{
#ifdef ANC_FF_ENABLED
while (__anc_usb_app_fadeout(ANC_FEEDFORWARD))
;
#endif
#ifdef ANC_FB_ENABLED
while (__anc_usb_app_fadeout(ANC_FEEDBACK))
;
#endif
app_anc_disable();
anc_select_coef(anc_sample_rate[AUD_STREAM_PLAYBACK],anc_coef_idx,ANC_FEEDFORWARD,ANC_GAIN_DELAY);
app_anc_enable();
#ifdef ANC_FF_ENABLED
while (__anc_usb_app_fadein(ANC_FEEDFORWARD))
;
#endif
#ifdef ANC_FB_ENABLED
while (__anc_usb_app_fadein(ANC_FEEDBACK))
;
#endif
}
else
{
anc_coef_idx = 0;
app_anc_timer_set(ANC_EVENT_CLOSE, anc_close_delay_time);
app_anc_gain_fadeout();
anc_work_status = ANC_STATUS_WAITING_OFF;
}
}
#if defined(IBRT)
void app_anc_sync_status(void)
{
uint8_t buf[3] = {0};
bool flag = app_anc_work_status();
buf[0] = (uint8_t)flag;
if(flag == true)
{
buf[1] = (uint8_t)anc_coef_idx;
}
else
{
buf[1] = (uint8_t)ANC_COEF_NUM;
}
buf[2] = true;//set peer anc_status_sync_flag = true
anc_peer_coef_idx = 0;
TRACE(4,"%s anc_work_status:%d, anc_coef_idx:%d, anc_sync_status_flag:%d", __func__, buf[0], buf[1], buf[2]);
ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
if (p_ibrt_ctrl->current_role == IBRT_MASTER)
{
tws_ctrl_send_cmd(APP_TWS_CMD_SYNC_ANC_STATUS, buf, 3);
}
}
#endif