/***************************************************************************
 *
 * 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 "app_anc.h"
#include "anc_assist.h"
#include "anc_process.h"
#include "anc_wnr.h"
#include "app_ibrt_keyboard.h"
#include "app_ibrt_ui.h"
#include "app_thread.h"
#include "apps.h"
#include "aud_section.h"
#include "audioflinger.h"
#include "cmsis.h"
#include "cmsis_os.h"
#include "hal_bootmode.h"
#include "hal_codec.h"
#include "hal_sysfreq.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "hwtimer_list.h"
#include "plat_types.h"
#include "pmu.h"
#include "tgt_hardware.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_ctrl_thread.h"
#include "app_tws_ibrt.h"
#include "app_tws_ibrt_cmd_handler.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...
      app_voice_report(APP_STATUS_INDICATION_ALEXA_START,
                       0); // close latlatency mode
    }
    if (evt == ANC_EVENT_FADE_OUT) {
      anc_work_status = ANC_STATUS_INIT_ON;
      // recommand to play "ANC OFF" prompt here...
      app_voice_report(APP_STATUS_INDICATION_ALEXA_STOP,
                       0); // close latlatency mode
    }
    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