/*
 * Copyright (C) 2017 Amlogic Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define LOG_TAG "audio_hw_hal_kara"
//#define LOG_NDEBUG 0

#include "aml_audio_log.h"
#include <audio_utils/channels.h>
#include <unistd.h>
#include <limits.h>

#include "audio_data_process.h"
#include "audio_hw_utils.h"
#include "karaoke_manager.h"
#include "aml_volume_utils.h"
//#include "EffectReverb.h"
#include "aml_malloc_debug.h"
#include "aml_reverb.h"
#include "aml_dump_debug.h"
#include "audio_hw_ms12_v2.h"
#include "alsa_device_parser.h"

#define USB_DEFAULT_PERIOD_SIZE      512
#define USB_DEFAULT_PERIOD_COUNT     4

#define LINEIN_DEFAULT_SAMPLE_RATE   48000
#define LINEIN_DEFAULT_CHANNEL       2
#define LINEIN_DEFAULT_FORMAT        PCM_FORMAT_S16_LE
#define LINEIN_DEFAULT_PERIOD_SIZE   1024
#define LINEIN_DEFAULT_PERIOD_COUNT  4

#define ALOOP_DEFAULT_PERIOD_SIZE   512
#define ALOOP_DEFAULT_PERIOD_COUNT  6

struct voice_in {
    struct audioCfg cfg;
    bool debug;
    struct pcm *pcm_handle;
    struct pcm_config pcm_in_config;
    void *conversion_buffer;
    size_t conversion_buffer_size;
};

struct kara_device {
    pthread_mutex_t lock;
    kara_input_type_t kara_input_type;
    kara_output_type_t kara_output_type;
    bool karaoke_on;
    bool karaoke_enable;
    bool karaoke_start;
    bool kara_mic_record;
    bool kara_mic_mute;
    float kara_mic_gain;
    struct voice_in in;
    void *buf;
    size_t buf_len;
    ring_buffer_t mic_buffer;
    struct audioCfg mixout_config;
    void *echo_reference;
    struct pcm *loopback_handle;
    int (*open)(struct kara_device *in, struct audioCfg *cfg);
    int (*close)(struct kara_device *in);
    /* mixer audio data to output */
    int (*mix)(struct kara_device *in, void *buffer, size_t bytes);
    /* read data from ringbuffer */
    ssize_t (*read)(struct kara_device *in, void *buffer, size_t bytes);
    /* reverb for mic */
    void *reverb_handle;
    bool reverb_enable;
    int reverb_mode;
    audio_resample_config_t resample_config;
    aml_audio_resample_t *resample_handle;
    ring_buffer_t resample_buffer;
    int resample_wait_count;
};

struct kara_manager {
    struct kara_device in_device[KARA_INPUT_TYPE_MAX];
};

/* karaoke init*/
int karaoke_init(struct kara_device *kara,
                      kara_input_type_t kara_input_type,
                      kara_output_type_t kara_output_type);

/* karaoke check if should do capture and mix */
int karaoke_check_mix_output(struct kara_device *karaoke, void *buffer, size_t bytes);
/* karaoke get audio config from ms12 info */
int karaoke_get_audioCfg_from_ms12_info(struct audioCfg *cfg, struct aml_ms12_dec_info *ms12_info);
/* karaoke get audio config from pcm_config */
int karaoke_get_audioCfg_from_pcm_config(struct audioCfg *cfg, struct pcm_config *pcm_cfg);
/* karaoke close */
int karaoke_close(struct kara_device *kara);

/* karaoke key parameters get && set function*/
kara_input_type_t karaoke_get_input_type(struct kara_device *kara);
int karaoke_set_input_type(struct kara_device *kara, kara_input_type_t value);
kara_output_type_t karaoke_get_output_type(struct kara_device *kara);
int karaoke_set_output_type(struct kara_device *kara, kara_output_type_t value);
bool karaoke_get_on(struct kara_device *kara);
int karaoke_set_on(struct kara_device *kara, bool value);
bool karaoke_get_enable(struct kara_device *kara);
int karaoke_set_enable(struct kara_device *kara, bool value);
bool karaoke_get_start(struct kara_device *kara);
int karaoke_set_start(struct kara_device *kara, bool value);
bool karaoke_get_mic_record(struct kara_device *kara);
int karaoke_set_mic_record(struct kara_device *kara, bool value);
bool karaoke_get_mic_mute(struct kara_device *kara);
int karaoke_set_mic_mute(struct kara_device *kara, bool value);
float karaoke_get_mic_gain(struct kara_device *kara);
int karaoke_set_mic_gain(struct kara_device *kara, float value);
bool karaoke_get_debug(struct kara_device *kara);
int karaoke_set_debug(struct kara_device *kara, bool value);

/* get audio config for recording such as adev_open_input_stream */
int karaoke_get_config_by_record_type(struct kara_device *kara,
                                                    kara_record_type_t record_type,
                                                    struct audio_config *config);


/* privide data for recorder by ring_buffer/echo_reference/ALOOP and HW loopback(hw provide) */
static int provide_data_for_recorder(struct kara_device *kara,
                                    kara_record_type_t record_type,
                                    void* buffer,
                                    struct audioCfg config,
                                    size_t size)
{
    if (!kara || !buffer || 0 == size) {
        return -EINVAL;
    }

    /* Original mic data, recorder by ring buffer */
    if (KARA_RECORD_TYPE_MIC_ORIGINAL == record_type) {
        // write data only when record start
        if (kara->kara_mic_record) {
            ring_buffer_write(&kara->mic_buffer, (unsigned char *)buffer, size, UNCOVER_WRITE);
        }
        return size;
    }

    struct voice_in *in = &kara->in;
    if (!in) {
        return -EINVAL;
    }
    /* Mic data after volume process, recorder by echo_reference buffer */
    if (KARA_RECORD_TYPE_MIC_AFTER_VOLUME == record_type) {
        size_t original_size = size;
        size_t after_process_size = original_size; //size after process
        int channel_support = 2; //ench reference only support 2ch write currently
        void* ench_source_buffer = NULL;
        if (0 == config.channelCnt) {
            return -EINVAL;
        }
        if (kara->echo_reference == NULL) {
        // do nothing
        } else {
            //use conversion buffer for saving data after channel adjust
            if (channel_support != config.channelCnt) {
                after_process_size = (original_size * channel_support) / config.channelCnt;
                if (after_process_size > in->conversion_buffer_size) {
                    in->conversion_buffer_size = after_process_size;
                    in->conversion_buffer = aml_audio_realloc(in->conversion_buffer, in->conversion_buffer_size);
                    if (!in->conversion_buffer) {
                        AM_LOGE("conversion_buffer malloc is fail");
                        return -1;
                    }
                }
                /* adjust to channel supported by echo_reference */
                enum pcm_format format = convert_audio_format_2_alsa_format(config.format);
                unsigned int sample_size_in_bytes = pcm_format_to_bits(format) / 8;
                after_process_size = adjust_channels(buffer, config.channelCnt,
                                        in->conversion_buffer, channel_support,
                                        sample_size_in_bytes, original_size);
                ench_source_buffer = in->conversion_buffer;
            } else {
                ench_source_buffer = buffer;
            }
            /* save data to echo reference*/
            #if 0
            struct echo_reference_buffer b;
            b.raw = ench_source_buffer;
            b.frame_count = original_size / config.frame_size;
            clock_gettime(CLOCK_REALTIME, &b.time_stamp);
            b.delay_ns = 0;
            kara->echo_reference->write(kara->echo_reference, &b);
            #endif
            if (get_debug_value(AML_DUMP_AUDIOHAL_OUT) || in->debug) {
                aml_dump_audio_bitstreams("/data/audio/kara_echo_reference.raw", ench_source_buffer, after_process_size);
            }
        }
        return size;
    }

    /* Mic data after reverb process */
    if (KARA_RECORD_TYPE_MIC_AFTER_REVERB == record_type) {
        // implement when need record data after reverb
    }

    /* Data after mix, recorder by ALOOP */
    if (KARA_RECORD_TYPE_MIC_AFTER_SW_MIX == record_type) {
        if (kara->karaoke_on && kara->loopback_handle) {
            pcm_write(kara->loopback_handle, (void *)buffer, size);
            if (get_debug_value(AML_DUMP_AUDIOHAL_OUT) || in->debug) {
                aml_dump_audio_bitstreams("/data/audio/kara_write_to_loopback.pcm", buffer, size);
            }
        }
        return size;
    }

    return size;
}

/* Kara input data manager */
static ssize_t mic_data_input(struct kara_device *kara, size_t frames)
{
    if (!kara || 0 == frames) {
        return -EINVAL;
    }
    struct voice_in *in = &kara->in;
    if (!in) {
        return -EINVAL;
    }
    uint32_t in_framesize = in->cfg.frame_size;
    if (0 == in_framesize) {
        return -EINVAL;
    }
    int ret = -1;
    /* real read size/frames from alsa or third party */
    size_t num_read_buff_bytes = frames * in_framesize; // init read size
    size_t real_frames = frames; // init real_frames as sample rate is same

    /* read size need modify when in&mixout sample rate are different */
    if (kara->resample_handle && kara->resample_config.output_sr) {
        real_frames = (real_frames * kara->resample_config.input_sr) / kara->resample_config.output_sr;
        int remainder = (real_frames * kara->resample_config.input_sr) % kara->resample_config.output_sr;
        if (remainder) {
            real_frames += 1; // read more 1 frame because data may overrun
        }
        num_read_buff_bytes = real_frames * in_framesize;
    }

    /* kara->buf is for saving the original mic data */
    if (num_read_buff_bytes > kara->buf_len) {
        kara->buf = aml_audio_realloc(kara->buf, num_read_buff_bytes);
        if (!kara->buf) {
            AM_LOGE("kara->buf aml_audio_realloc is fail");
            return -1;
        }
        kara->buf_len = num_read_buff_bytes;
    }
    void *read_buff = kara->buf;
    if (!read_buff) {
        AM_LOGE("kara->buf is null");
        return -1;
    }
    /* Read mic data via different way */
    switch (kara->kara_input_type) {
        case KARA_INPUT_TYPE_USB_MIC:
        case KARA_INPUT_TYPE_LINEIN_MIC:
            if (!in->pcm_handle) {
                AM_LOGE("in->pcm_handle is null");
                return -1;
            }
            ret = pcm_read(in->pcm_handle, read_buff, num_read_buff_bytes);
            break;
        default:
            //add other read function here
            break;
    }

    //AM_LOGD("ret = %d, num_read_buff_bytes = %zu", ret, num_read_buff_bytes);
    if (0 == ret) {
        if (get_debug_value(AML_DUMP_AUDIOHAL_OUT) || in->debug) {
            if (KARA_INPUT_TYPE_USB_MIC == kara->kara_input_type) {
                aml_dump_audio_bitstreams("/data/audio/kara_mic_input_original_usb.raw", read_buff, num_read_buff_bytes);
            } else if (KARA_INPUT_TYPE_LINEIN_MIC == kara->kara_input_type) {
                aml_dump_audio_bitstreams("/data/audio/kara_mic_input_original_linein.raw", read_buff, num_read_buff_bytes);
            } else {
                aml_dump_audio_bitstreams("/data/audio/kara_mic_input_original.raw", read_buff, num_read_buff_bytes);
            }
        }
        /* Provide data for recording original data */
        provide_data_for_recorder(kara, KARA_RECORD_TYPE_MIC_ORIGINAL, read_buff, in->cfg, num_read_buff_bytes);
    } else {
        real_frames = 0;
    }

    return real_frames;
}

static ssize_t mic_data_process(struct kara_device *kara, size_t in_frames, size_t out_frames)
{
    if (!kara || !kara->buf || 0 == in_frames || 0 == out_frames) {
        return -EINVAL;
    }
    struct voice_in *in = &kara->in;
    if (!in) {
        return -EINVAL;
    }
    size_t original_size = in_frames * in->cfg.frame_size; // size of original mic data

    enum pcm_format format = in->pcm_in_config.format;
    unsigned int sample_size_in_bytes = pcm_format_to_bits(format) / 8;

    /* Volume Process Start*/
    //AM_LOGD("original_size=%zu mute=%d gain=%f", original_size, kara->kara_mic_mute, kara->kara_mic_gain);
    if (kara->kara_mic_mute) {
        memset(kara->buf, 0, original_size); // mute mic data
    } else {
        apply_volume(kara->kara_mic_gain, kara->buf, sample_size_in_bytes, original_size);
    }
    if (get_debug_value(AML_DUMP_AUDIOHAL_OUT) || in->debug) {
        if (KARA_INPUT_TYPE_USB_MIC == kara->kara_input_type) {
            aml_dump_audio_bitstreams("/data/audio/kara_after_volume_process_usb.raw", kara->buf, original_size);
        } else if (KARA_INPUT_TYPE_LINEIN_MIC == kara->kara_input_type) {
            aml_dump_audio_bitstreams("/data/audio/kara_after_volume_process_linein.raw", kara->buf, original_size);
        } else {
            aml_dump_audio_bitstreams("/data/audio/kara_after_volume_process.raw", kara->buf, original_size);
        }
    }
    /* Provide data for recording after volume process */
    provide_data_for_recorder(kara, KARA_RECORD_TYPE_MIC_AFTER_VOLUME, kara->buf, in->cfg, original_size);
    /* Volume Process End*/

    /* Reverb Process Start*/
    if (kara->reverb_enable) {
        /* reverb only support 2 channel & 16 bit currently */
        if ( 2 == in->pcm_in_config.channels && PCM_FORMAT_S16_LE == in->pcm_in_config.format) {
            AML_Reverb_Set_Mode(kara->reverb_handle, kara->reverb_mode);
            AML_Reverb_Process(kara->reverb_handle, kara->buf, kara->buf, original_size >> 2);
        } else {
            // todo after reverb support more input config
        }
    }
    if (get_debug_value(AML_DUMP_AUDIOHAL_OUT) || in->debug) {
        aml_dump_audio_bitstreams("/data/audio/kara_after_reverb_process.pcm", kara->buf, original_size);
    }
    /* Reverb Process End */

    return in_frames;
}

static ssize_t mic_data_output(struct kara_device *kara, void *main_buffer, size_t in_frames, size_t out_frames)
{
    if (!kara || !kara->buf || !main_buffer || 0 == out_frames) {
        return -EINVAL;
    }
    struct voice_in *in = &kara->in;
    if (!in) {
        return -EINVAL;
    }
    size_t original_size = in_frames * in->cfg.frame_size; // size of original mic data
    size_t after_process_size = original_size; // size after process, initial with no process
    size_t mixout_bytes = out_frames * kara->mixout_config.frame_size;
    void *read_buff = kara->buf;
    void *out_buff = kara->buf;
    unsigned int num_in_channels = in->cfg.channelCnt;
    unsigned int num_mixout_channels = kara->mixout_config.channelCnt;
    uint32_t in_sample_rate = in->cfg.sampleRate;
    uint32_t out_sample_rate = kara->mixout_config.sampleRate;
    if (0 == num_in_channels || 0 == num_mixout_channels
        || 0 == in_sample_rate || 0 == out_sample_rate) {
        return -EINVAL;
    }
    enum pcm_format in_format = in->pcm_in_config.format;
    unsigned int in_sample_size = pcm_format_to_bits(in_format) / 8;

    /* SW Mix Process Start */
    if (KARA_OUTPUT_TYPE_SW_MIX == kara->kara_output_type) {
        /* 1.do channel adjust */
        if (num_in_channels == num_mixout_channels) {
            //do not need channel adjust
            out_buff = kara->buf;
        } else {
            // need channel adjust
            after_process_size = (original_size * num_mixout_channels) / num_in_channels;
            if (after_process_size <= kara->buf_len) {
                // use kara->buf for saving data after channel contract
                read_buff = kara->buf;
                out_buff = kara->buf;
            } else {
                // use conversion_buffer for saving data after channel expand
                if (after_process_size > in->conversion_buffer_size) {
                    in->conversion_buffer = aml_audio_realloc(in->conversion_buffer, after_process_size);
                    if (!in->conversion_buffer) {
                        AM_LOGE("channel adjust conversion_buffer malloc error");
                        return -1;
                    }
                    in->conversion_buffer_size = after_process_size;
                }
                read_buff = kara->buf;
                out_buff = in->conversion_buffer;
            }
            after_process_size = adjust_channels(read_buff, num_in_channels,
                                                 out_buff, num_mixout_channels,
                                                 in_sample_size, original_size);
        }

        /* 2.do resample */
        if (kara->resample_handle) {
            read_buff = out_buff; //the last out buffer is the next input buffer
            if (!aml_audio_resample_process(kara->resample_handle, read_buff, after_process_size)) {
                after_process_size = kara->resample_handle->resample_size;
                if (after_process_size <= kara->buf_len) {
                    // use kara->buf for saving data after resample contract
                    out_buff = kara->buf;
                } else {
                    // use conversion_buffer for saving data after resample expand
                    if (after_process_size > in->conversion_buffer_size) {
                        in->conversion_buffer = aml_audio_realloc(in->conversion_buffer, after_process_size);
                        if (!in->conversion_buffer) {
                            AM_LOGE("resample conversion_buffer malloc error");
                            return -1;
                        }
                        in->conversion_buffer_size = after_process_size;
                    }
                    out_buff = in->conversion_buffer;
                }
                // use ring buffer because resample handle different length each time
                ring_buffer_write(&kara->resample_buffer, (unsigned char *)kara->resample_handle->resample_buffer,
                                  kara->resample_handle->resample_size, UNCOVER_WRITE);
                if (kara->resample_wait_count <= 3) {
                    kara->resample_wait_count += 1;
                    return 0;
                }
                // copy resample data to out buffer
                enum pcm_format out_format = convert_audio_format_2_alsa_format(kara->mixout_config.format);
                int out_sample_size = pcm_format_to_bits(out_format) / 8;
                int single_bytes = mixout_bytes * in_sample_size / out_sample_size;
                if (get_buffer_read_space(&kara->resample_buffer) >= single_bytes) {
                    ring_buffer_read(&kara->resample_buffer, out_buff, single_bytes);
                    //memcpy(out_buff, kara->resample_handle->resample_buffer, kara->resample_handle->resample_size);
                } else {
                    AM_LOGE("resample ring buffer size(%d) not enough for single_bytes(%d)",
                               get_buffer_read_space(&kara->resample_buffer), single_bytes);
                }
            }
        }

        /* 3.mixer mic data with main buffer */
        read_buff = out_buff; //the last out buffer is the next input buffer
        do_mixing_specified_channel_cnt(main_buffer, read_buff, out_frames,
                                        in->cfg.format, kara->mixout_config.format,
                                        num_mixout_channels);

        /* 4.dump data after mix process when debug */
        if (get_debug_value(AML_DUMP_AUDIOHAL_OUT) || in->debug) {
            if (KARA_INPUT_TYPE_USB_MIC == kara->kara_input_type) {
                aml_dump_audio_bitstreams("/data/audio/kara_after_mix_usb.raw", main_buffer, mixout_bytes);
            } else if (KARA_INPUT_TYPE_LINEIN_MIC == kara->kara_input_type) {
                aml_dump_audio_bitstreams("/data/audio/kara_after_mix_linein.raw", main_buffer, mixout_bytes);
            } else {
                aml_dump_audio_bitstreams("/data/audio/kara_after_mix.raw", main_buffer, mixout_bytes);
            }
        }
        /* 5.Provide data for recording data after mix process */
        provide_data_for_recorder(kara, KARA_RECORD_TYPE_MIC_AFTER_SW_MIX, main_buffer, kara->mixout_config, mixout_bytes);
        /* SW Mix Process End */
    }else {
        // add other output type here
    }

    return after_process_size;
}

static int kara_mix_micphone(struct kara_device *kara, void *buf, size_t bytes)
{
    if (!kara || !buf || 0 == bytes) {
        return -EINVAL;
    }
    if (0 == kara->mixout_config.frame_size) {
        return -EINVAL;
    }

    size_t out_frames = bytes / kara->mixout_config.frame_size; // frames on main buffer
    ssize_t frames_ret = 0;
    pthread_mutex_lock(&kara->lock);

    /* 1.mic data input management*/
    frames_ret = mic_data_input(kara, out_frames); // return real read frames
    if (frames_ret <= 0) {
        AM_LOGE("mic_data_input fail frames_ret(%zu)", frames_ret);
        goto exit;
    }

    /* 2.mic data process management */
    frames_ret = mic_data_process(kara, frames_ret, out_frames);
    if (frames_ret <= 0) {
        AM_LOGE("mic_data_process fail frames_ret(%zu)", frames_ret);
        goto exit;
    }

    /* 3.mic data output management */
    frames_ret = mic_data_output(kara, buf, frames_ret, out_frames);
    if (frames_ret <= 0) {
        AM_LOGE("mic_data_output fail frames_ret(%zu)", frames_ret);
        goto exit;
    }

exit:
    pthread_mutex_unlock(&kara->lock);
    return frames_ret;
}

/* For userspace recording original mic buffer */
static ssize_t kara_read_mic_buffer(struct kara_device *kara, void *buffer, size_t bytes)
{
    if (!kara || !buffer || kara->mic_buffer.size == 0 || !kara->karaoke_start) {
        return -EINVAL;
    }

    uint32_t read_bytes = 0;
    int nodata_count = 0;
    int retry_max_count = 20;
    int sleep_us = 5000;
    size_t ret = 0;
    while (read_bytes < bytes) {
        ret = ring_buffer_read(&kara->mic_buffer, (uint8_t *)buffer + read_bytes, bytes - read_bytes);
        read_bytes += ret;
        if (read_bytes == bytes) {
            return bytes;
        }
        nodata_count++;
        if (nodata_count >= retry_max_count) {
            AM_LOGW("read data timeout, need:%zu, read_bytes:%d", bytes, read_bytes);
            memset(buffer, 0, bytes);
            return bytes;
        }
        usleep(sleep_us);
    }
    return bytes;
}

/* init ALOOP handle*/
static int kara_open_aloop_handle(struct kara_device *kara, struct audioCfg *cfg)
{
    if (!kara || !cfg) {
        AM_LOGE("Input null pointer");
        return -EINVAL;
    }
    int aloop_card = alsa_device_get_card_index_by_name("Loopback");
    if (aloop_card < 0) {
        kara->loopback_handle = NULL;
        AM_LOGI("Aloop card device not found");
        return -1;
    } else {
        unsigned int aloop_device = 0; // Aloop device 0 for pcm write
        AM_LOGI("Aloop card device exist");
        struct pcm_config pcm_mixout_config;
        memset(&pcm_mixout_config, 0, sizeof(pcm_mixout_config));
        pcm_mixout_config.channels = cfg->channelCnt;
        pcm_mixout_config.rate = cfg->sampleRate;
        pcm_mixout_config.format = convert_audio_format_2_alsa_format(cfg->format);
        pcm_mixout_config.period_size = ALOOP_DEFAULT_PERIOD_SIZE;
        pcm_mixout_config.period_count = ALOOP_DEFAULT_PERIOD_COUNT;
        pcm_mixout_config.start_threshold = pcm_mixout_config.period_size *
                                            pcm_mixout_config.period_count / 2;
        pcm_mixout_config.silence_size = LONG_MAX;
        kara->loopback_handle = pcm_open(aloop_card, aloop_device, PCM_OUT, &pcm_mixout_config);
        if (!pcm_is_ready(kara->loopback_handle)) {
            AM_LOGE("cannot open loopback: %s", pcm_get_error(kara->loopback_handle));
            pcm_close (kara->loopback_handle);
            kara->loopback_handle = NULL;
        }
    }
    return 0;
}

static int kara_open_micphone(struct kara_device *kara, struct audioCfg *cfg)
{
    /* open alsa capture handle */
    int card = 0;
    int device = 0;

    AM_LOGI("Enter");
    if (!kara || !cfg) {
        AM_LOGE("Input null pointer");
        return -EINVAL;
    }
    pthread_mutex_lock(&kara->lock);
    if (true == kara->karaoke_start) {
        AM_LOGI("%s() linein karaoke is already opened!", __func__);
        pthread_mutex_unlock(&kara->lock);
        return 0;
    }

    int init_ret = -EINVAL;
    struct voice_in *in = NULL;
    struct pcm *pcmIn = NULL;
    struct pcm_config config;
    memset(&config, 0, sizeof(config));
    /*the record parameter depends on pcm in config */
    config.channels = LINEIN_DEFAULT_CHANNEL;
    config.rate = LINEIN_DEFAULT_SAMPLE_RATE;
    config.format = LINEIN_DEFAULT_FORMAT;
    if (KARA_INPUT_TYPE_USB_MIC == kara->kara_input_type) {
        config.period_size = USB_DEFAULT_PERIOD_SIZE;
        config.period_count = USB_DEFAULT_PERIOD_COUNT;
    } else if (KARA_INPUT_TYPE_LINEIN_MIC == kara->kara_input_type) {
        config.period_size = LINEIN_DEFAULT_PERIOD_SIZE;
        config.period_count = LINEIN_DEFAULT_PERIOD_COUNT;
    } else {
        AM_LOGE("unsupport input type: %d", kara->kara_input_type);
        goto err;
    }

    AM_LOGD("channels %d, format %d, rate %d", config.channels, config.format, config.rate);

    in = &kara->in;
    /* in config for channel adjust and mix */
    in->cfg.channelCnt = config.channels;
    in->cfg.channelMask = AUDIO_CHANNEL_IN_STEREO;
    in->cfg.sampleRate = config.rate;
    in->cfg.format = AUDIO_FORMAT_PCM_16_BIT;
    in->cfg.frame_size = in->cfg.channelCnt * pcm_format_to_bits(config.format) / 8;
    in->debug = 0;
    in->pcm_in_config = config;
    kara->mixout_config = *cfg;
    kara->mixout_config.channelMask = AUDIO_CHANNEL_IN_STEREO;


    if (KARA_INPUT_TYPE_USB_MIC == kara->kara_input_type) {
        card = alsa_device_get_card_index_by_name("USB Audio");
        device = alsa_device_get_pcm_index_by_name("USB Audio");
    } else if (KARA_INPUT_TYPE_LINEIN_MIC == kara->kara_input_type) {
        card = alsa_device_get_card_index();
        device = alsa_device_update_pcm_index(PORT_I2S, CAPTURE);
    }
    pcmIn = pcm_open(card, device, PCM_IN, &config);
    if (!pcm_is_ready(pcmIn)) {
        AM_LOGE("pcm_is_ready error!");
        if (pcmIn != NULL) {
            pcm_close(pcmIn);
            pcmIn = NULL;
        }
        init_ret = -1;
        goto err;
    }

    in->pcm_handle = pcmIn;
    in->conversion_buffer = NULL;
    in->conversion_buffer_size = 0;
    kara->buf = NULL;
    kara->buf_len = 0;

    /* init resample */
    if (in->cfg.sampleRate != kara->mixout_config.sampleRate) {
        kara->resample_config.aformat   = in->cfg.format;
        kara->resample_config.channels  = kara->mixout_config.channelCnt; // do channel adjust before resample
        kara->resample_config.input_sr  = in->cfg.sampleRate;
        kara->resample_config.output_sr = kara->mixout_config.sampleRate;
        ALOGI("init resampler from in-samplerate(%d) to out-samplerate(%d) channels(%d) format(%d)\n",
                kara->resample_config.input_sr, kara->resample_config.output_sr,
                kara->resample_config.channels, kara->resample_config.aformat);
        init_ret = aml_audio_resample_init((aml_audio_resample_t **)&kara->resample_handle, AML_AUDIO_SIMPLE_RESAMPLE, &kara->resample_config);
        if (init_ret < 0) {
            ALOGE("karaoke resample init error\n");
            kara->resample_handle = NULL;
        }
        /* init resample buffer for saving data after resample */
        init_ret = ring_buffer_init(&kara->resample_buffer, LINEIN_DEFAULT_PERIOD_SIZE * 32);
        if (init_ret < 0) {
            AM_LOGE("malloc resample_buffer error");
        }
    } else {
        kara->resample_handle = NULL;
    }
    kara->resample_wait_count = 0;

    init_ret = ring_buffer_init(&kara->mic_buffer, LINEIN_DEFAULT_PERIOD_SIZE * 32);
    if (init_ret < 0) {
        AM_LOGE("malloc mic buffer error");
    }

    AM_LOGI("in_configs: channels = %d, format = %d, rate = %d, frame_size = %d",
            in->cfg.channelCnt, in->cfg.format, in->cfg.sampleRate, in->cfg.frame_size);
    AM_LOGI("mixout_configs: channels = %d, format = %d, rate = %d, frame_size = %d",
            cfg->channelCnt, cfg->format, cfg->sampleRate, cfg->frame_size);

    /* init ALOOP handle for recording */
    kara_open_aloop_handle(kara, cfg);

    kara->karaoke_start = true;
    pthread_mutex_unlock(&kara->lock);
    AM_LOGI("success and exit");
    return 0;

err:
    AM_LOGI("fail and exit");
    kara->karaoke_start = false;
    pthread_mutex_unlock(&kara->lock);
    return init_ret;
}

static int kara_close_micphone(struct kara_device *kara)
{
    if (!kara) {
        AM_LOGE("Input null pointer");
        return -EINVAL;
    }

    struct voice_in *in = &kara->in;
    AM_LOGI("enter");
    pthread_mutex_lock(&kara->lock);
    if (kara->karaoke_start == false) {
        AM_LOGI("karaoke already closed");
        pthread_mutex_unlock(&kara->lock);
        return 0;
    }

    /* close mic handle*/
    if (in->pcm_handle != NULL) {
        pcm_close(in->pcm_handle);
        in->pcm_handle = NULL;
    } else {
        // add close function for other input here
    }

    aml_audio_free(in->conversion_buffer);
    in->conversion_buffer = NULL;
    in->conversion_buffer_size = 0;
    aml_audio_free(kara->buf);
    kara->buf = NULL;
    kara->buf_len = 0;
    ring_buffer_release(&kara->mic_buffer);
    kara->karaoke_start = false;
    /* close resample handle */
    if (kara->resample_handle) {
        aml_audio_resample_close(kara->resample_handle);
        kara->resample_handle = NULL;
    }
    kara->resample_wait_count = 0;
    /* close loopback handle */
    if (kara->loopback_handle) {
        pcm_close(kara->loopback_handle);
        kara->loopback_handle = NULL;
        ring_buffer_release(&kara->resample_buffer);
        kara->resample_wait_count = 0;
    }
    pthread_mutex_unlock(&kara->lock);
    AM_LOGI("exit");

    return 0;
}

int karaoke_check_mix_output(struct kara_device *kara, void *buffer, size_t bytes)
{
    if (!kara || !buffer || 0 == bytes) {
        AM_LOGE("parameter invalid");
        return -EINVAL;
    }
    int ret = 0;
//    AM_LOGI("karaoke_input_type=%d, karaoke_on=%d, karaoke_enable=%d, karaoke_start=%d",
//             kara->kara_input_type, kara->karaoke_on, kara->karaoke_enable, kara->karaoke_start);
    if (kara->karaoke_on && kara->karaoke_enable) {
        if (!kara->karaoke_start && kara->open) {
            ret = kara->open(kara, &kara->mixout_config);
            if (ret < 0) {
                AM_LOGE("karaoke open failed: %d", ret);
            }
        } else if (kara->karaoke_start && kara->mix) {
            kara->mix(kara, buffer, bytes);
        }
    } else if (kara->karaoke_start && kara->close) {
        kara->close(kara);
    }

    return 0;
}

int karaoke_get_audioCfg_from_ms12_info(struct audioCfg *cfg, struct aml_ms12_dec_info *ms12_info)
{
    int ret = 0;
    if (!cfg || !ms12_info) {
        AM_LOGE("parameter invalid");
        ret = -EINVAL;
        return ret;
    }
    cfg->format = ms12_info->data_type;
    cfg->channelCnt = ms12_info->output_ch;
    cfg->sampleRate = ms12_info->output_sr;
    cfg->frame_size = cfg->channelCnt *
                      pcm_format_to_bits(convert_audio_format_2_alsa_format(cfg->format)) / 8;

    AM_LOGI("format=%d, channel=%d, sampleRate=%d", cfg->format, cfg->channelCnt, cfg->sampleRate);
    return ret;
}

int karaoke_get_audioCfg_from_pcm_config(struct audioCfg *cfg, struct pcm_config *pcm_cfg)
{
    int ret = 0;
    if (!cfg || !pcm_cfg) {
        AM_LOGE("parameter invalid");
        ret = -EINVAL;
        return ret;
    }
    cfg->channelCnt = pcm_cfg->channels;
    cfg->sampleRate = pcm_cfg->rate;
    cfg->format = AUDIO_FORMAT_PCM_16_BIT;
    cfg->frame_size = cfg->channelCnt * pcm_format_to_bits(pcm_cfg->format) / 8;

    AM_LOGI("format=%d, channel=%d, sampleRate=%d, frame_size=%d",
            cfg->format, cfg->channelCnt, cfg->sampleRate, cfg->frame_size);
    return ret;
}

/* karaoke init*/
int karaoke_init(struct kara_device *kara,
                      kara_input_type_t kara_input_type,
                      kara_output_type_t kara_output_type)
{
    AM_LOGI("enter, kara_input_type=%d, kara_output_type=%d", kara_input_type, kara_output_type);
    if (!kara) {
        return -EINVAL;
    }
    int ret = -1;
    pthread_mutex_init(&kara->lock, NULL);
    kara->kara_output_type = kara_output_type;

    /* distinguish different input open by kara_input_type*/
    kara->kara_input_type = kara_input_type;

    kara->open = kara_open_micphone;
    kara->read = kara_read_mic_buffer;
    kara->mix = kara_mix_micphone;
    kara->close = kara_close_micphone;
    kara->kara_mic_gain = 1.0f;

    kara->mixout_config.channelCnt = 2;
    kara->mixout_config.sampleRate = 48000;
    kara->mixout_config.channelMask = AUDIO_CHANNEL_IN_STEREO;
    kara->mixout_config.format = AUDIO_FORMAT_PCM_16_BIT;
    kara->mixout_config.frame_size = kara->mixout_config.channelCnt *
                      pcm_format_to_bits(convert_audio_format_2_alsa_format(AUDIO_FORMAT_PCM_16_BIT)) / 8;;

    /* init reverb handle */
    if (!kara->reverb_handle) {
        ret = AML_Reverb_Init(&kara->reverb_handle);
        if (ret < 0) {
            AM_LOGE("%s() int Reverb Error!", __func__);
            return -EINVAL;
        }
    }

    AM_LOGI("exit");
    return 0;
}

/* karaoke close mic and free resource */
int karaoke_close(struct kara_device *kara)
{
    AM_LOGI("enter");
    int ret = 0;
    if (!kara || !kara->close) {
        ret = -ENOSYS;
        return ret;
    }

    if (kara->karaoke_start) {
        kara->close(kara);
    }
    AM_LOGI("exit");
    return ret;
}

/* query karaoke input type */
kara_input_type_t karaoke_get_input_type(struct kara_device *kara)
{
    if (!kara) {
        return KARA_INPUT_TYPE_NONE;
    }
    AM_LOGI("type = %d", kara->kara_input_type);
    return kara->kara_input_type;
}

/* set karaoke input type */
int karaoke_set_input_type(struct kara_device *kara, kara_input_type_t value)
{
    AM_LOGI("value = %d", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->kara_input_type = value;
    return 0;
}

/* query karaoke output type */
kara_output_type_t karaoke_get_output_type(struct kara_device *kara)
{
    if (!kara) {
        return KARA_OUTPUT_TYPE_NONE;
    }
    AM_LOGI("type = %d", kara->kara_output_type);
    return kara->kara_output_type;
}

/* set karaoke output type */
int karaoke_set_output_type(struct kara_device *kara, kara_output_type_t value)
{
    AM_LOGI("value = %d", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->kara_output_type = value;
    return 0;
}

/* query karaoke is on or not*/
bool karaoke_get_on(struct kara_device *kara)
{
    if (!kara) {
        return false;
    }
    //AM_LOGI("value = %d", kara->karaoke_on);
    return kara->karaoke_on;
}

/* set karaoke on ture or false*/
int karaoke_set_on(struct kara_device *kara, bool value)
{
    AM_LOGI("value = %d", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->karaoke_on = value;
    return 0;
}

/* query karaoke is enabled or not*/
bool karaoke_get_enable(struct kara_device *kara)
{
    if (!kara) {
        return false;
    }
    //AM_LOGI("value = %d", kara->karaoke_enable);
    return kara->karaoke_enable;
}

/* set karaoke enable ture or false*/
int karaoke_set_enable(struct kara_device *kara, bool value)
{
    AM_LOGI("value = %d", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->karaoke_enable = value;
    return 0;
}

/* query karaoke is started or not*/
bool karaoke_get_start(struct kara_device *kara)
{
    if (!kara) {
        return false;
    }
    //AM_LOGI("value = %d", kara->karaoke_start);
    return kara->karaoke_start;
}

/* set karaoke start ture or false*/
int karaoke_set_start(struct kara_device *kara, bool value)
{
    AM_LOGI("value = %d", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->karaoke_start = value;
    return 0;
}

/* query karaoke record start or not*/
bool karaoke_get_mic_record(struct kara_device *kara)
{
    if (!kara) {
        return false;
    }
    AM_LOGI("value = %d", kara->kara_mic_record);
    return kara->kara_mic_record;
}

/* set karaoke mic record start ture or false*/
int karaoke_set_mic_record(struct kara_device *kara, bool value)
{
    AM_LOGI("value = %d", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->kara_mic_record = value;
    return 0;
}

/* query karaoke mic mute ture or false*/
bool karaoke_get_mic_mute(struct kara_device *kara)
{
    if (!kara) {
        return false;
    }
    AM_LOGI("value = %d", kara->kara_mic_mute);
    return kara->kara_mic_mute;
}

/* set karaoke mic mute ture or false*/
int karaoke_set_mic_mute(struct kara_device *kara, bool value)
{
    AM_LOGI("value = %d", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->kara_mic_mute = value;
    return 0;
}

/* query karaoke mic volume gain*/
float karaoke_get_mic_gain(struct kara_device *kara)
{
    if (!kara) {
        return false;
    }
    AM_LOGI("value = %f", kara->kara_mic_gain);
    return kara->kara_mic_gain;
}

/* set karaoke mic gain*/
int karaoke_set_mic_gain(struct kara_device *kara, float value)
{
    AM_LOGI("value = %f", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->kara_mic_gain = value;
    return 0;
}

/* query karaoke debug value */
bool karaoke_get_debug(struct kara_device *kara)
{
    if (!kara) {
        return false;
    }
    AM_LOGI("value = %d", kara->in.debug);
    return kara->in.debug;
}

/* set karaoke debug value */
int karaoke_set_debug(struct kara_device *kara, bool value)
{
    AM_LOGI("value = %d", value);
    if (!kara) {
        return -EINVAL;
    }
    kara->in.debug = value;
    return 0;
}

/* get audio config for recording such as adev_open_input_stream */
int karaoke_get_config_by_record_type(struct kara_device *kara,
                                                    kara_record_type_t record_type,
                                                    struct audio_config *config)
{
    AM_LOGI("record_type = %d", record_type);
    if (!kara) {
        return -EINVAL;
    }

    switch (record_type) {
        case KARA_RECORD_TYPE_MIC_ORIGINAL:
            config->sample_rate = kara->in.cfg.sampleRate;
            config->format = kara->in.cfg.format;
            config->channel_mask = kara->in.cfg.channelMask;
            break;
        case KARA_RECORD_TYPE_MIC_AFTER_VOLUME:
        case KARA_RECORD_TYPE_MIC_AFTER_REVERB:
            config->sample_rate = kara->in.cfg.sampleRate;
            config->format = kara->in.cfg.format;
            //default 2 when using echo_reference
            config->channel_mask = AUDIO_CHANNEL_IN_STEREO;
            break;
        case KARA_RECORD_TYPE_MIC_AFTER_SW_MIX:
            config->sample_rate = kara->mixout_config.sampleRate;
            config->format = kara->mixout_config.format;
            config->channel_mask = kara->mixout_config.channelMask;
            break;
        default:
            //add other config here
            AM_LOGW("record_type do not support");
            return -1;
    }

    AM_LOGI("config->sample_rate(%d), config->format(%d), config->channel_mask(%x)",
               config->sample_rate, config->format, config->channel_mask);
    return 0;
}

int karaoke_manager_init(void ** manager)
{
    struct kara_manager * pmanager = NULL;
    int index = 0;
    if (!manager) {
        return -1;
    }

    pmanager = aml_audio_calloc(1, sizeof(struct kara_manager));
    if (!pmanager) {
        AM_LOGE("malloc fail!!!");
        return -1;
    }
    //only support USB mic and Linein mic, so initialize both.
    for (index = 0; index <= KARA_INPUT_TYPE_LINEIN_MIC; index ++) {
        karaoke_init(&pmanager->in_device[index], index, KARA_OUTPUT_TYPE_SW_MIX);
    }

    *manager = pmanager;

    return 0;
}
int karaoke_manager_release(void * manager)
{
    struct kara_manager * pmanager = (struct kara_manager *)manager;
    int index = 0;
    if (!manager) {
        return -1;
    }

    for (index = 0; index <= KARA_INPUT_TYPE_LINEIN_MIC; index ++) {
        karaoke_close(&pmanager->in_device[index]);
    }

    aml_audio_free(manager);

    return 0;
}
int karaoke_manager_process(void * manager, const void *buffer, size_t bytes, audio_format_t format)
{
    struct kara_manager * pmanager = (struct kara_manager *)manager;
    int index = 0;
    if (!manager) {
        return -1;
    }

    if (format != pmanager->in_device[KARA_INPUT_TYPE_USB_MIC].mixout_config.format ||
        format != pmanager->in_device[KARA_INPUT_TYPE_LINEIN_MIC].mixout_config.format) {
        int index = 0;
        for (index = 0; index <= KARA_INPUT_TYPE_LINEIN_MIC; index ++) {
            pmanager->in_device[index].mixout_config.channelCnt = 2;
            pmanager->in_device[index].mixout_config.sampleRate = 48000;
            pmanager->in_device[index].mixout_config.channelMask = AUDIO_CHANNEL_IN_STEREO;
            pmanager->in_device[index].mixout_config.format = format;
            pmanager->in_device[index].mixout_config.frame_size = pmanager->in_device[index].mixout_config.channelCnt *
                              pcm_format_to_bits(convert_audio_format_2_alsa_format(format)) / 8;
        }
    }

    for (index = 0; index <= KARA_INPUT_TYPE_LINEIN_MIC; index ++) {
        karaoke_check_mix_output(&pmanager->in_device[index], buffer, bytes);
    }

    return 0;
}

int karaoke_manager_command(void * manager, char *cmd, int length)
{
    struct kara_manager * pmanager = (struct kara_manager *)manager;
    int index = 0;
    char* sub_cmd = NULL;
    int val = 0;
    char *pt = NULL, *tmp = NULL;
    int i = 0;
    if (!manager || !cmd) {
        return -1;
    }

    pt = strtok_r (cmd, ", ", &tmp);
    while (pt != NULL) {
        switch (i) {
        case 0:
            sub_cmd = pt;
            break;
        case 1:
            index = atoi(pt);
            break;
        case 2:
            val = atoi(pt);
            break;
        default:
            break;
        }

        pt = strtok_r (NULL, ", ", &tmp);
        i++;
    }

    sscanf(cmd, "%s,%d,%d", sub_cmd, &index, &val);

    AM_LOGI("cmd:%s, index:%d, val:%d", sub_cmd, index, val);

    if (KARA_INPUT_TYPE_USB_MIC != index && KARA_INPUT_TYPE_LINEIN_MIC != index) {
        AM_LOGE("unsupport type:%d", index);
        return -1;
    }

    if (!strncmp(sub_cmd, "switch", 6)) {
        bool karaoke_on = !!val;
        karaoke_set_on(&pmanager->in_device[index], karaoke_on);
        karaoke_set_enable(&pmanager->in_device[index], karaoke_on);
    } else if(!strncmp(sub_cmd, "debug", 5)) {
        bool kara_debug = !!val;
        karaoke_set_debug(&pmanager->in_device[index], kara_debug);
    } else if(!strncmp(sub_cmd, "mic_mute", 8)) {
        bool mic_mute = !!val;
        karaoke_set_mic_mute(&pmanager->in_device[index], mic_mute);
    } else if(!strncmp(sub_cmd, "mic_volume", 10)) {
        float volume = (float)val/100;
        karaoke_set_mic_gain(&pmanager->in_device[index], volume);
    } else if(!strncmp(sub_cmd, "reverb_enable", 13)) {
        bool reverb_enable = !!val;
        pmanager->in_device[index].reverb_enable = reverb_enable;
    } else if(!strncmp(sub_cmd, "reverb_mode", 11)) {
        pmanager->in_device[index].reverb_mode = val;
    } else {
        AM_LOGE("unsupport command!");
    }

    return 0;
}

int karaoke_manager_dump(void * manager, int fd)
{
    struct kara_manager * pmanager = (struct kara_manager *)manager;
    struct kara_device * pdevice = NULL;
    int i = 0;
    if (!manager) {
        return -1;
    }

    dprintf(fd, "\n-------------[AML_HAL] karaoke manager info------------------\n");

    for (i = 0; i <= KARA_INPUT_TYPE_LINEIN_MIC; i ++) {
        pdevice = &pmanager->in_device[i];

        dprintf(fd, "  [AML_HAL] ==== input type: %d ====\n", i);
        dprintf(fd, "  [AML_HAL] output type: %d\n", pdevice->kara_output_type);
        dprintf(fd, "  [AML_HAL] on(%d) enable(%d) start(%d) record(%d)\n",
            pdevice->karaoke_on, pdevice->karaoke_enable, pdevice->karaoke_start, pdevice->kara_mic_record);
        dprintf(fd, "  [AML_HAL] mute(%d) gain(%5f)\n", pdevice->kara_mic_mute, pdevice->kara_mic_gain);
        if (pdevice->in.pcm_handle)
            aml_alsa_pcm_info_dump(pdevice->in.pcm_handle, fd);

        dprintf(fd, "  [AML_HAL] reverb enable(%d) mode(%d)\n\n", pdevice->reverb_enable, pdevice->reverb_mode);

    }

    return 0;
}