/***************************************************************************
 *
 * 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 "codec_int.h"
#include "hal_codec.h"
#include "hal_trace.h"
#include "hal_sleep.h"
#include "stdbool.h"
#include "analog.h"
#include "tgt_hardware.h"

#define CODEC_TRACE(n, s, ...)          TRACE(n, s, ##__VA_ARGS__)

#define CODEC_INT_INST                  HAL_CODEC_ID_0

#ifndef CODEC_OUTPUT_DEV
#define CODEC_OUTPUT_DEV                CFG_HW_AUD_OUTPUT_PATH_SPEAKER_DEV
#endif

#ifdef __CODEC_ASYNC_CLOSE__
#include "cmsis_os.h"

#define CODEC_ASYNC_CLOSE_DELAY (5000)

static void codec_timehandler(void const *param);

osTimerDef (CODEC_TIMER, codec_timehandler);
static osTimerId codec_timer;
static CODEC_CLOSE_HANDLER close_hdlr;

enum CODEC_HW_STATE_T {
    CODEC_HW_STATE_CLOSED,
    CODEC_HW_STATE_CLOSE_PENDING,
    CODEC_HW_STATE_OPENED,
};

enum CODEC_HW_STATE_T codec_hw_state = CODEC_HW_STATE_CLOSED;
#endif

enum CODEC_USER_T {
    CODEC_USER_STREAM   = (1 << 0),
    CODEC_USER_ANC      = (1 << 1),
    CODEC_USER_VAD      = (1 << 2),
};

struct CODEC_CONFIG_T {
    enum CODEC_USER_T user_map;
    bool resample_en;
    bool mute_state[AUD_STREAM_NUM];
    bool chan_vol_set[AUD_STREAM_NUM];
    struct STREAM_CONFIG_T {
        bool opened;
        bool started;
        struct HAL_CODEC_CONFIG_T codec_cfg;
    } stream_cfg[AUD_STREAM_NUM];
};

static struct CODEC_CONFIG_T codec_int_cfg = {
    .user_map = 0,
    .resample_en = false,
    .mute_state = { false, false, },
    .chan_vol_set = { false, false, },
    //playback
    .stream_cfg[AUD_STREAM_PLAYBACK] = {
        .opened = false,
        .started = false,
        .codec_cfg = {
            .sample_rate = AUD_SAMPRATE_NULL,
        }
    },
    //capture
    .stream_cfg[AUD_STREAM_CAPTURE] = {
        .opened = false,
        .started = false,
        .codec_cfg = {
            .sample_rate = AUD_SAMPRATE_NULL,
        }
    }
};

static bool anc_ff_enabled;
static bool anc_fb_enabled;
static enum AUD_SAMPRATE_T codec_anc_samp_rate;
static CODEC_ANC_HANDLER codec_anc_handler;

#ifdef VOICE_DETECTOR_EN
static enum AUD_VAD_TYPE_T vad_type;
#endif

#ifdef CODEC_ANC_BOOST
static CODEC_ANC_BOOST_DELAY_FUNC boost_delay;

void codec_set_anc_boost_delay_func(CODEC_ANC_BOOST_DELAY_FUNC delay_func)
{
    boost_delay = delay_func;
}
#endif

uint32_t codec_int_stream_open(enum AUD_STREAM_T stream)
{
    CODEC_TRACE(2,"%s: stream=%d", __func__, stream);
    codec_int_cfg.stream_cfg[stream].opened = true;
    return 0;
}

uint32_t codec_int_stream_setup(enum AUD_STREAM_T stream, struct HAL_CODEC_CONFIG_T *cfg)
{
    enum AUD_CHANNEL_MAP_T ch_map;

    CODEC_TRACE(2,"%s: stream=%d", __func__, stream);

    if (codec_int_cfg.stream_cfg[stream].codec_cfg.sample_rate == AUD_SAMPRATE_NULL) {
        // Codec uninitialized -- all config items should be set
        codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag = HAL_CODEC_CONFIG_ALL;
    } else {
        // Codec initialized before -- only different config items need to be set
        codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag = HAL_CODEC_CONFIG_NULL;
    }

    // Always config sample rate, for the pll setting might have been changed by the other stream
    CODEC_TRACE(2,"[sample_rate]old=%d new=%d", codec_int_cfg.stream_cfg[stream].codec_cfg.sample_rate, cfg->sample_rate);
    if (codec_int_cfg.user_map & CODEC_USER_ANC) {
        // Check ANC sample rate
        if (codec_anc_handler) {
            enum AUD_SAMPRATE_T cfg_rate;
            enum AUD_SAMPRATE_T old_rate;

            cfg_rate = hal_codec_anc_convert_rate(cfg->sample_rate);
            if (cfg_rate != codec_anc_samp_rate) {
                old_rate = codec_anc_samp_rate;

                codec_anc_handler(stream, cfg_rate, NULL, NULL);

                codec_anc_samp_rate = cfg_rate;
                TRACE(5,"%s: ANC sample rate changes from %u to %u due to stream=%d samp_rate=%u",
                    __func__, old_rate, codec_anc_samp_rate, stream, cfg->sample_rate);
            }
        }
    }
    codec_int_cfg.stream_cfg[stream].codec_cfg.sample_rate = cfg->sample_rate;
    codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |= HAL_CODEC_CONFIG_SAMPLE_RATE;

    if(codec_int_cfg.stream_cfg[stream].codec_cfg.bits != cfg->bits)
    {
        CODEC_TRACE(2,"[bits]old=%d new=%d", codec_int_cfg.stream_cfg[stream].codec_cfg.bits, cfg->bits);
        codec_int_cfg.stream_cfg[stream].codec_cfg.bits = cfg->bits;
        codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |= HAL_CODEC_CONFIG_BITS;
    }

    if(codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num != cfg->channel_num)
    {
        CODEC_TRACE(2,"[channel_num]old=%d new=%d", codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num, cfg->channel_num);
        codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num = cfg->channel_num;
        codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |= HAL_CODEC_CONFIG_CHANNEL_NUM;
    }

    ch_map = cfg->channel_map;
    if (ch_map == 0) {
        if (stream == AUD_STREAM_PLAYBACK) {
            ch_map = (enum AUD_CHANNEL_MAP_T)CODEC_OUTPUT_DEV;
        } else {
            ch_map = (enum AUD_CHANNEL_MAP_T)hal_codec_get_input_path_cfg(cfg->io_path);
        }
        ch_map &= AUD_CHANNEL_MAP_ALL;
    }

    if(codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map != ch_map)
    {
        CODEC_TRACE(2,"[channel_map]old=0x%x new=0x%x", codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map, ch_map);
        codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map = ch_map;
        codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |= HAL_CODEC_CONFIG_CHANNEL_MAP | HAL_CODEC_CONFIG_VOL | HAL_CODEC_CONFIG_BITS;
    }

    if(codec_int_cfg.stream_cfg[stream].codec_cfg.use_dma != cfg->use_dma)
    {
        CODEC_TRACE(2,"[use_dma]old=%d new=%d", codec_int_cfg.stream_cfg[stream].codec_cfg.use_dma, cfg->use_dma);
        codec_int_cfg.stream_cfg[stream].codec_cfg.use_dma = cfg->use_dma;
    }

    if(codec_int_cfg.stream_cfg[stream].codec_cfg.vol != cfg->vol)
    {
        CODEC_TRACE(3,"[vol]old=%d new=%d chan_vol_set=%d", codec_int_cfg.stream_cfg[stream].codec_cfg.vol, cfg->vol, codec_int_cfg.chan_vol_set[stream]);
        codec_int_cfg.stream_cfg[stream].codec_cfg.vol = cfg->vol;
        if (!codec_int_cfg.chan_vol_set[stream]) {
            codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |= HAL_CODEC_CONFIG_VOL;
        }
    }

    if(codec_int_cfg.stream_cfg[stream].codec_cfg.io_path != cfg->io_path)
    {
        CODEC_TRACE(2,"[io_path]old=%d new=%d", codec_int_cfg.stream_cfg[stream].codec_cfg.io_path, cfg->io_path);
        codec_int_cfg.stream_cfg[stream].codec_cfg.io_path = cfg->io_path;
    }

    CODEC_TRACE(3,"[%s]stream=%d set_flag=0x%x",__func__,stream,codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag);
    hal_codec_setup_stream(CODEC_INT_INST, stream, &(codec_int_cfg.stream_cfg[stream].codec_cfg));

    return 0;
}

void codec_int_stream_mute(enum AUD_STREAM_T stream, bool mute)
{
    bool anc_on;

    CODEC_TRACE(3,"%s: stream=%d mute=%d", __func__, stream, mute);

    if (mute == codec_int_cfg.mute_state[stream]) {
        CODEC_TRACE(2,"[%s] Codec already in mute status: %d", __func__, mute);
        return;
    }

    anc_on = !!(codec_int_cfg.user_map & CODEC_USER_ANC);

    if (stream == AUD_STREAM_PLAYBACK) {
        if (mute) {
            if (!anc_on) {
                analog_aud_codec_mute();
            }
            hal_codec_dac_mute(true);
        } else {
            hal_codec_dac_mute(false);
            if (!anc_on) {
                analog_aud_codec_nomute();
            }
        }
    } else {
        hal_codec_adc_mute(mute);
    }

    codec_int_cfg.mute_state[stream] = mute;
}

void codec_int_stream_set_chan_vol(enum AUD_STREAM_T stream, enum AUD_CHANNEL_MAP_T ch_map, uint8_t vol)
{
    CODEC_TRACE(4,"%s: stream=%d ch_map=0x%X vol=%u", __func__, stream, ch_map, vol);

    codec_int_cfg.chan_vol_set[stream] = true;
    hal_codec_set_chan_vol(stream, ch_map, vol);
}

void codec_int_stream_restore_chan_vol(enum AUD_STREAM_T stream)
{
    CODEC_TRACE(2,"%s: stream=%d", __func__, stream);

    if (codec_int_cfg.chan_vol_set[stream]) {
        codec_int_cfg.chan_vol_set[stream] = false;
        // Restore normal volume
        codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag = HAL_CODEC_CONFIG_VOL;
        hal_codec_setup_stream(CODEC_INT_INST, stream, &(codec_int_cfg.stream_cfg[stream].codec_cfg));
    }
}

static void codec_hw_start(enum AUD_STREAM_T stream)
{
    CODEC_TRACE(2,"%s: stream=%d", __func__, stream);

    if (stream == AUD_STREAM_PLAYBACK) {
        // Enable DAC before starting stream (specifically before enabling PA)
        analog_aud_codec_dac_enable(true);
    }

    hal_codec_start_stream(CODEC_INT_INST, stream);
}

static void codec_hw_stop(enum AUD_STREAM_T stream)
{
    CODEC_TRACE(2,"%s: stream=%d", __func__, stream);

    hal_codec_stop_stream(CODEC_INT_INST, stream);

    if (stream == AUD_STREAM_PLAYBACK) {
        // Disable DAC after stopping stream (specifically after disabling PA)
        analog_aud_codec_dac_enable(false);
    }
}

uint32_t codec_int_stream_start(enum AUD_STREAM_T stream)
{
    CODEC_TRACE(2,"%s: stream=%d", __func__, stream);

    codec_int_cfg.stream_cfg[stream].started = true;

    if (stream == AUD_STREAM_CAPTURE) {
        analog_aud_codec_adc_enable(codec_int_cfg.stream_cfg[stream].codec_cfg.io_path,
            codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map, true);
    }

    hal_codec_start_interface(CODEC_INT_INST, stream,
        codec_int_cfg.stream_cfg[stream].codec_cfg.use_dma);

    if ((codec_int_cfg.user_map & CODEC_USER_ANC) == 0) {
        codec_hw_start(stream);
    }

    return 0;
}

uint32_t codec_int_stream_stop(enum AUD_STREAM_T stream)
{
    CODEC_TRACE(2,"%s: stream=%d", __func__, stream);

    hal_codec_stop_interface(CODEC_INT_INST, stream);

    if ((codec_int_cfg.user_map & CODEC_USER_ANC) == 0) {
        codec_hw_stop(stream);
    }

    if (stream == AUD_STREAM_CAPTURE) {
        analog_aud_codec_adc_enable(codec_int_cfg.stream_cfg[stream].codec_cfg.io_path,
            codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map, false);
    }

    codec_int_cfg.stream_cfg[stream].started = false;

    return 0;
}

uint32_t codec_int_stream_close(enum AUD_STREAM_T stream)
{
    //close all stream
    CODEC_TRACE(2,"%s: stream=%d", __func__, stream);
    if (codec_int_cfg.stream_cfg[stream].started) {
        codec_int_stream_stop(stream);
    }
    codec_int_stream_restore_chan_vol(stream);
    codec_int_cfg.stream_cfg[stream].opened = false;
    return 0;
}

static void codec_hw_open(enum CODEC_USER_T user)
{
    enum CODEC_USER_T old_map;
#ifdef __AUDIO_RESAMPLE__
    bool resample_en = !!hal_cmu_get_audio_resample_status();
#endif

    old_map = codec_int_cfg.user_map;
    codec_int_cfg.user_map |= user;

    if (old_map) {
#ifdef __AUDIO_RESAMPLE__
        ASSERT(codec_int_cfg.resample_en == resample_en,
            "%s: Bad resamp status %d for user 0x%X (old_map=0x%X)", __func__, resample_en, user, old_map);
#endif
        return;
    }

#ifdef __AUDIO_RESAMPLE__
    codec_int_cfg.resample_en = resample_en;
#endif

    CODEC_TRACE(1,"%s", __func__);

#ifdef __CODEC_ASYNC_CLOSE__
    if (codec_timer == NULL) {
        codec_timer = osTimerCreate (osTimer(CODEC_TIMER), osTimerOnce, NULL);
    }
    osTimerStop(codec_timer);
#endif

    // Audio resample: Might have different clock source, so must be reconfigured here
    hal_codec_open(CODEC_INT_INST);

#ifdef __CODEC_ASYNC_CLOSE__
    CODEC_TRACE(2,"%s: codec_hw_state=%d", __func__, codec_hw_state);

    if (codec_hw_state == CODEC_HW_STATE_CLOSED) {
        codec_hw_state = CODEC_HW_STATE_OPENED;
        // Continue to open the codec hardware
    } else if (codec_hw_state == CODEC_HW_STATE_CLOSE_PENDING) {
        // Still opened
        codec_hw_state = CODEC_HW_STATE_OPENED;
        return;
    } else {
        // Already opened
        return;
    }
#endif

    analog_aud_codec_open();
}

static void codec_hw_close(enum CODEC_CLOSE_TYPE_T type, enum CODEC_USER_T user)
{
    codec_int_cfg.user_map &= ~user;

    if (type == CODEC_CLOSE_NORMAL) {
        if (codec_int_cfg.user_map) {
            return;
        }
    }

#ifdef __CODEC_ASYNC_CLOSE__
    CODEC_TRACE(3,"%s: type=%d codec_hw_state=%d", __func__, type, codec_hw_state);
#else
    CODEC_TRACE(2,"%s: type=%d", __func__, type);
#endif

    if (type == CODEC_CLOSE_NORMAL) {
        // Audio resample: Might have different clock source, so close now and reconfigure when open
        hal_codec_close(CODEC_INT_INST);
#ifdef CODEC_POWER_DOWN
        memset(&codec_int_cfg, 0, sizeof(codec_int_cfg));
#endif
#ifdef __CODEC_ASYNC_CLOSE__
        ASSERT(codec_hw_state == CODEC_HW_STATE_OPENED, "%s: (type=%d) Bad codec_hw_state=%d", __func__, type, codec_hw_state);
        // Start a timer to close the codec hardware
        codec_hw_state = CODEC_HW_STATE_CLOSE_PENDING;
        osTimerStop(codec_timer);
        osTimerStart(codec_timer, CODEC_ASYNC_CLOSE_DELAY);
        return;
    } else if (type == CODEC_CLOSE_ASYNC_REAL) {
        if (codec_hw_state != CODEC_HW_STATE_CLOSE_PENDING) {
            // Already closed or reopened
            return;
        }
        codec_hw_state = CODEC_HW_STATE_CLOSED;
#endif
    } else if (type == CODEC_CLOSE_FORCED) {
        hal_codec_crash_mute();
    }

    analog_aud_codec_close();
}

uint32_t codec_int_open(void)
{
    CODEC_TRACE(2,"%s: user_map=0x%X", __func__, codec_int_cfg.user_map);

    codec_hw_open(CODEC_USER_STREAM);

    return 0;
}

uint32_t codec_int_close(enum CODEC_CLOSE_TYPE_T type)
{
    CODEC_TRACE(3,"%s: type=%d user_map=0x%X", __func__, type, codec_int_cfg.user_map);

    if (type == CODEC_CLOSE_NORMAL) {
        if (codec_int_cfg.stream_cfg[AUD_STREAM_PLAYBACK].opened == false &&
                codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].opened == false){
            codec_hw_close(type, CODEC_USER_STREAM);
        }
    } else {
        codec_hw_close(type, CODEC_USER_STREAM);
    }

    return 0;
}

#ifdef __CODEC_ASYNC_CLOSE__
void codec_int_set_close_handler(CODEC_CLOSE_HANDLER hdlr)
{
    close_hdlr = hdlr;
}

static void codec_timehandler(void const *param)
{
    if (close_hdlr) {
        close_hdlr();
    }
}
#endif

int codec_anc_open(enum ANC_TYPE_T type, enum AUD_SAMPRATE_T dac_rate, enum AUD_SAMPRATE_T adc_rate, CODEC_ANC_HANDLER hdlr)
{
    bool anc_running = false;

    CODEC_TRACE(4,"%s: type=%d dac_rate=%d adc_rate=%d", __func__, type, dac_rate, adc_rate);

    dac_rate = hal_codec_anc_convert_rate(dac_rate);
    adc_rate = hal_codec_anc_convert_rate(adc_rate);
    ASSERT(dac_rate == adc_rate, "%s: Unmatched rates: dac_rate=%u adc_rate=%u", __func__, dac_rate, adc_rate);

    if (hdlr && (codec_int_cfg.user_map & CODEC_USER_STREAM)) {
        enum AUD_SAMPRATE_T cfg_dac_rate, cfg_adc_rate;

        if (codec_int_cfg.stream_cfg[AUD_STREAM_PLAYBACK].opened) {
            cfg_dac_rate = hal_codec_anc_convert_rate(codec_int_cfg.stream_cfg[AUD_STREAM_PLAYBACK].codec_cfg.sample_rate);
        } else {
            cfg_dac_rate = dac_rate;
        }
        if (codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].opened) {
            cfg_adc_rate = hal_codec_anc_convert_rate(codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].codec_cfg.sample_rate);
        } else {
            cfg_adc_rate = adc_rate;
        }
        if (codec_int_cfg.stream_cfg[AUD_STREAM_PLAYBACK].opened && codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].opened) {
            ASSERT(cfg_dac_rate == cfg_adc_rate, "%s: Unmatched cfg rates: dac_rate=%u adc_rate=%u", __func__, cfg_dac_rate, cfg_adc_rate);
        } else if (codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].opened) {
            cfg_dac_rate = cfg_adc_rate;
        }
        if (dac_rate != cfg_dac_rate) {
            hdlr(AUD_STREAM_PLAYBACK, cfg_dac_rate, NULL, NULL);
            TRACE(3,"%s: ANC sample rate changes from %u to %u", __func__, dac_rate, cfg_dac_rate);
            dac_rate = cfg_dac_rate;
        }
    }

    codec_anc_samp_rate = dac_rate;
    codec_anc_handler = hdlr;

    if (anc_ff_enabled || anc_fb_enabled) {
        anc_running = true;
    }

    if (type == ANC_FEEDFORWARD) {
        anc_ff_enabled = true;
    } else if (type == ANC_FEEDBACK) {
        anc_fb_enabled = true;
    }

    if (!anc_running) {
        hal_chip_wake_lock(HAL_CHIP_WAKE_LOCK_USER_ANC);

        hal_cmu_anc_enable(HAL_CMU_ANC_CLK_USER_ANC);

        enum AUD_STREAM_T stream;
        enum AUD_CHANNEL_NUM_T play_chan_num;

        codec_hw_open(CODEC_USER_ANC);

        if (CODEC_OUTPUT_DEV == (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)) {
            play_chan_num = AUD_CHANNEL_NUM_2;
        } else {
            play_chan_num = AUD_CHANNEL_NUM_1;
        }

        for (stream = AUD_STREAM_PLAYBACK; stream <= AUD_STREAM_CAPTURE; stream++) {
            if (codec_int_cfg.stream_cfg[stream].opened) {
                if (stream == AUD_STREAM_PLAYBACK) {
                /*    ASSERT(codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num == play_chan_num,
                        "Invalid existing ANC channel num %d != %d for stream %d",
                        codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num,
                        play_chan_num,
                        stream);*/
                }
            } else {
                codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag = 0;
                codec_int_cfg.stream_cfg[stream].codec_cfg.sample_rate = codec_anc_samp_rate;
                codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |= HAL_CODEC_CONFIG_SAMPLE_RATE;
                if (stream == AUD_STREAM_PLAYBACK) {
                    codec_int_cfg.stream_cfg[stream].codec_cfg.vol = TGT_VOLUME_LEVEL_10;
                } else {
                    codec_int_cfg.stream_cfg[stream].codec_cfg.vol = CODEC_SADC_VOL;
                }
                codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |= HAL_CODEC_CONFIG_VOL;
                if (stream == AUD_STREAM_PLAYBACK) {
                    codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num = play_chan_num;
                    codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map = CODEC_OUTPUT_DEV;
                } else {
                    codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num = 0;
                    codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map = 0;
                }
                codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |= HAL_CODEC_CONFIG_CHANNEL_NUM;

                hal_codec_setup_stream(CODEC_INT_INST, stream, &(codec_int_cfg.stream_cfg[stream].codec_cfg));
            }
        }

        // Start play first, then start capture last
        for (stream = AUD_STREAM_PLAYBACK; stream <= AUD_STREAM_CAPTURE; stream++) {
            if (!codec_int_cfg.stream_cfg[stream].started) {
                codec_hw_start(stream);
            }
        }
    }

    hal_codec_anc_adc_enable(type);

    analog_aud_codec_anc_enable(type, true);

    if (!anc_running) {
        // Enable pa if dac muted before
        if (codec_int_cfg.mute_state[AUD_STREAM_PLAYBACK]) {
            analog_aud_codec_nomute();
        }

#ifdef CODEC_ANC_BOOST
        analog_aud_codec_anc_boost(true, (ANALOG_ANC_BOOST_DELAY_FUNC)boost_delay);
#endif
    }

    return 0;
}

int codec_anc_close(enum ANC_TYPE_T type)
{
    CODEC_TRACE(2,"%s: type=%d", __func__, type);

    if (type == ANC_FEEDFORWARD) {
        anc_ff_enabled = false;
    } else if (type == ANC_FEEDBACK) {
        anc_fb_enabled = false;
    }

    hal_codec_anc_adc_disable(type);

    analog_aud_codec_anc_enable(type, false);

    if (anc_ff_enabled || anc_fb_enabled) {
        return 0;
    }

#ifdef CODEC_ANC_BOOST
    analog_aud_codec_anc_boost(false, (ANALOG_ANC_BOOST_DELAY_FUNC)boost_delay);
#endif

    enum AUD_STREAM_T stream;

    // Stop capture first, then stop play last
    for (stream = AUD_STREAM_CAPTURE; stream >= AUD_STREAM_PLAYBACK && stream <= AUD_STREAM_CAPTURE; stream--) {
        if (!codec_int_cfg.stream_cfg[stream].started) {
            codec_hw_stop(stream);
        }
    }

    codec_hw_close(CODEC_CLOSE_NORMAL, CODEC_USER_ANC);

    hal_cmu_anc_disable(HAL_CMU_ANC_CLK_USER_ANC);

    hal_chip_wake_unlock(HAL_CHIP_WAKE_LOCK_USER_ANC);

    // Disable pa if dac muted before
    if (codec_int_cfg.mute_state[AUD_STREAM_PLAYBACK]) {
        analog_aud_codec_mute();
    }

    codec_anc_handler = NULL;

    return 0;
}

#ifdef VOICE_DETECTOR_EN
int codec_vad_open(const struct AUD_VAD_CONFIG_T *cfg)
{
    if (cfg->type == AUD_VAD_TYPE_NONE) {
        return codec_vad_close();
    }

    if (vad_type == cfg->type) {
        return 0;
    }

    vad_type = cfg->type;

    if (codec_int_cfg.user_map == 0) {
        codec_hw_open(CODEC_USER_VAD);
    }

    hal_codec_vad_open(cfg);

    codec_int_cfg.user_map |= (1 << CODEC_USER_VAD);

    return 0;
}

int codec_vad_close(void)
{
    if (vad_type == AUD_VAD_TYPE_NONE) {
        return 0;
    }

    vad_type = AUD_VAD_TYPE_NONE;

    codec_int_cfg.user_map &= ~(1 << CODEC_USER_VAD);

    if (codec_int_cfg.user_map == 0) {
        codec_hw_close(CODEC_CLOSE_NORMAL, CODEC_USER_VAD);
    }

    return 0;
}
#endif