1957 lines
49 KiB
C
1957 lines
49 KiB
C
/***************************************************************************
|
|
*
|
|
* 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
|
|
|