#include "asm/includes.h"
#include "media/includes.h"
#include "system/includes.h"
#include "asm/audio_src.h"
#include "audio_enc.h"
#include "app_main.h"
#include "app_action.h"
#include "encode/encode_write.h"
#include "clock_cfg.h"
#include "audio_config.h"
#include "audio_track.h"
#define LADC_MIC_BUF_NUM        2
#define LADC_MIC_CH_NUM         1
#define LADC_MIC_IRQ_POINTS     256
#define LADC_MIC_BUFS_SIZE      (LADC_MIC_CH_NUM * LADC_MIC_BUF_NUM * LADC_MIC_IRQ_POINTS)

typedef struct {
    struct audio_adc_output_hdl adc_output;
    struct adc_mic_ch mic_ch;
    s16 adc_buf[LADC_MIC_BUFS_SIZE];    //align 4Bytes
    int cut_timer;
} ladc_mic_t;
static ladc_mic_t *ladc_mic = NULL;

extern struct audio_adc_hdl adc_hdl;
int audio_adc_mic_init(u16 sr)
{
    //printf("ladc_mic_open:%d\n",sr);
    ASSERT(ladc_mic == NULL);
    ladc_mic = zalloc(sizeof(ladc_mic_t));
    if (ladc_mic) {
        audio_adc_mic_open(&ladc_mic->mic_ch, AUDIO_ADC_MIC_CH, &adc_hdl);
        audio_adc_mic_set_sample_rate(&ladc_mic->mic_ch, sr);
        audio_adc_mic_set_gain(&ladc_mic->mic_ch, 5);
        audio_adc_mic_set_buffs(&ladc_mic->mic_ch, ladc_mic->adc_buf, LADC_MIC_IRQ_POINTS * 2, LADC_MIC_BUF_NUM);
        audio_adc_mic_start(&ladc_mic->mic_ch);
        return 0;
    } else {
        return -1;
    }
}

void audio_adc_mic_exit(void)
{
    //printf("ladc_mic_close\n");
    if (ladc_mic) {
        audio_adc_mic_close(&ladc_mic->mic_ch);
        free(ladc_mic);
        ladc_mic = NULL;
    }
}

/*audio_adc采样输出回调函数*/
static void audio_adc_data_hdl(void *priv, s16 *data, int len)
{
    struct audio_adc_hdl *hdl = priv;
    putchar('o');
    //printf("adc:%x,len:%d",data,len);
#if 0 //直接推adc数据到dac听,用来测试adc采样数据是否正常
    int wlen = app_audio_output_write(data, len * hdl->channel);
    if (wlen != len) {
        //printf("wlen:%d-%d",wlen,len);
    }
#endif
}

/******************************************************/
#define LADC_LINEIN_BUF_NUM        2
#define LADC_LINEIN_CH_NUM         1
#define LADC_LINEIN_IRQ_POINTS     256
#define LADC_LINEIN_BUFS_SIZE      (LADC_LINEIN_CH_NUM * LADC_LINEIN_BUF_NUM * LADC_LINEIN_IRQ_POINTS)
struct audio_adc_var {
    struct audio_adc_output_hdl adc_output;
    struct audio_adc_ch ch;
    s16 adc_buf[LADC_LINEIN_BUFS_SIZE];    //align 4Bytes
};
struct audio_adc_var *ladc_linein = NULL;

void audio_adc_linein_demo(void)
{
    u16 ladc_linein_sr = 44100;
    r_printf("audio_adc_linein_demo...");
    ladc_linein = zalloc(sizeof(*ladc_linein));
    if (ladc_linein) {
        audio_adc_linein_open(&ladc_linein->ch, AUDIO_ADC_LINE0_L, &adc_hdl);
        audio_adc_linein_set_sample_rate(&ladc_linein->ch, ladc_linein_sr);
        audio_adc_linein_set_gain(&ladc_linein->ch, 5);
        printf("adc_buf_size:%d", sizeof(ladc_linein->adc_buf));
        audio_adc_set_buffs(&ladc_linein->ch, ladc_linein->adc_buf, LADC_LINEIN_CH_NUM * LADC_LINEIN_IRQ_POINTS * 2, LADC_LINEIN_BUF_NUM);
        ladc_linein->adc_output.handler = audio_adc_data_hdl;
        ladc_linein->adc_output.priv = &adc_hdl;
        audio_adc_add_output_handler(&adc_hdl, &ladc_linein->adc_output);
        audio_adc_linein_start(&ladc_linein->ch);

        app_audio_output_samplerate_set(ladc_linein_sr);
        app_audio_output_start();
    }
}


#define ADC_BUF_NUM        2
#define ADC_CH_NUM         1
#define ADC_IRQ_POINTS     256
#define ADC_BUFS_SIZE      (ADC_BUF_NUM *ADC_CH_NUM* ADC_IRQ_POINTS)

#if TCFG_MIC_EFFECT_ENABLE
#define ADC_STORE_PCM_SIZE     (ADC_BUFS_SIZE * 6)
#else
#define ADC_STORE_PCM_SIZE     (ADC_BUFS_SIZE * 16)
#endif/*TCFG_MIC_EFFECT_ENABLE*/


#define ADC_LINEIN_IRQ_POINTS         32
#define ADC_LINEIN_BUFS_SIZE          (ADC_BUF_NUM *ADC_CH_NUM* ADC_LINEIN_IRQ_POINTS)
#define ADC_LINEIN_STORE_PCM_SIZE     (ADC_LINEIN_BUFS_SIZE * 6)


struct linein_sample_hdl {
    OS_SEM sem;
    struct audio_adc_ch linein_ch;
    struct audio_adc_output_hdl sample_output;
    s16 adc_buf[ADC_BUFS_SIZE];
    /* s16 *store_pcm_buf[ADC_STORE_PCM_SIZE]; */
    s16 *store_pcm_buf;
    cbuffer_t cbuf;
    void (*resume)(void);
    volatile u8 wait_resume;
    u8 channel_num;
    int samples;
    u16 sample_rate;
    void *audio_track;
};

/* struct linein_sample_hdl g_linein_sample_hdl sec(.linein_pcm_mem); */
/* static s16 linein_store_pcm_buf[ADC_STORE_PCM_SIZE] sec(.linein_pcm_mem); */

void linein_sample_set_resume_handler(void *priv, void (*resume)(void))
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)priv;

    if (linein) {
        linein->resume = resume;
    }
}

AT(.fm_data_code)
void fm_inside_output_handler(void *priv, s16 *data, int len)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)priv;

    if (linein->audio_track) {
        audio_local_sample_track_in_period(linein->audio_track, (len >> 1) / linein->channel_num);
    }

    int wlen = cbuf_write(&linein->cbuf, data, len);
    os_sem_post(&linein->sem);
    if (wlen != len) {
        putchar('w');
    }

    if (linein->resume) {
        if (linein->wait_resume) {
            linein->wait_resume = 0;
            linein->resume();
        }
    }
}

static void linein_sample_output_handler(void *priv, s16 *data, int len)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)priv;

    if (linein->audio_track) {
        audio_local_sample_track_in_period(linein->audio_track, (len >> 1));
    }

    int wlen = cbuf_write(&linein->cbuf, data, len * linein->channel_num);
    os_sem_post(&linein->sem);
    if (wlen != len * linein->channel_num) {
        putchar('W');
    }
    if (linein->resume) {
        if (linein->wait_resume) {
            linein->wait_resume = 0;
            linein->resume();
        }
    }
}

AT(.fm_data_code)
int linein_stream_sample_rate(void *hdl)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)hdl;

    if (linein->audio_track) {
        int sr =  audio_local_sample_track_rate(linein->audio_track);
        if ((sr < (linein->sample_rate + 200)) && (sr > linein->sample_rate - 200)) {
            return sr;
        }
        printf("linein audio_track reset \n");
        local_irq_disable();
        audio_local_sample_track_close(linein->audio_track);
        linein->audio_track = audio_local_sample_track_open(linein->channel_num, linein->sample_rate, 1000);
        local_irq_enable();
    }

    return linein->sample_rate;
}

AT(.fm_data_code)
int linein_sample_read(void *hdl, void *data, int len)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)hdl;
#if 0
// no wait
    u8 count = 0;
__retry:
    if (cbuf_get_data_size(&linein->cbuf) < len) {
        local_irq_disable();
        os_sem_set(&linein->sem, 0);
        local_irq_enable();
        os_sem_pend(&linein->sem, 2);
        if (cbuf_get_data_size(&linein->cbuf) < len) {
            if (++count > 4) {
                return 0;
            }
            goto __retry;
        }

    }
#endif
    int rlen = cbuf_read(&linein->cbuf, data, 64);
    local_irq_disable();
    if (rlen < len) {
        linein->wait_resume = 1;
    }
    local_irq_enable();
    return rlen;
}

AT(.fm_data_code)
int linein_sample_size(void *hdl)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)hdl;
    return cbuf_get_data_size(&linein->cbuf);
}

AT(.fm_data_code)
int linein_sample_total(void *hdl)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)hdl;
    return linein->cbuf.total_len;
}

void *linein_sample_open(u8 source, u16 sample_rate)
{
    struct linein_sample_hdl *linein = NULL;

    /* linein = &g_linein_sample_hdl;// zalloc(sizeof(struct linein_sample_hdl)); */
    linein =  zalloc(sizeof(struct linein_sample_hdl));
    if (!linein) {
        return NULL;
    }

    memset(linein, 0x0, sizeof(struct linein_sample_hdl));

    linein->store_pcm_buf = malloc(ADC_LINEIN_STORE_PCM_SIZE);
    if (!linein->store_pcm_buf) {
        return NULL;
    }

    if (source != 0xff) {
        audio_adc_linein_open(&linein->linein_ch, (source << 2), &adc_hdl);
    }

    cbuf_init(&linein->cbuf, linein->store_pcm_buf, ADC_LINEIN_STORE_PCM_SIZE);
    linein->sample_rate = sample_rate;
    linein->audio_track = audio_local_sample_track_open(linein->channel_num, sample_rate, 1000);
    os_sem_create(&linein->sem, 0);
    if (source == 0xff) {
        return linein;
    }
    linein->channel_num = adc_hdl.channel;
    audio_adc_linein_set_sample_rate(&linein->linein_ch, sample_rate);
    audio_adc_linein_set_gain(&linein->linein_ch, 3);
    audio_adc_set_buffs(&linein->linein_ch, linein->adc_buf, ADC_CH_NUM * ADC_LINEIN_IRQ_POINTS * 2, ADC_BUF_NUM);

    linein->sample_output.handler = linein_sample_output_handler;
    linein->sample_output.priv = linein;

    audio_adc_add_output_handler(&adc_hdl, &linein->sample_output);

    audio_adc_linein_start(&linein->linein_ch);

    return linein;
}

void linein_sample_close(void *hdl)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)hdl;

    if (!linein) {
        return;
    }
    audio_adc_linein_close(&linein->linein_ch);
    audio_adc_del_output_handler(&adc_hdl, &linein->sample_output);
    if (linein->audio_track) {
        audio_local_sample_track_close(linein->audio_track);
    }


    free(linein->store_pcm_buf);
    free(linein);
}


void *fm_sample_open(u8 source, u16 sample_rate)
{

    struct linein_sample_hdl *linein = NULL;
    /* linein = &g_linein_sample_hdl;// zalloc(sizeof(struct linein_sample_hdl)); */
    linein =  zalloc(sizeof(struct linein_sample_hdl));
    if (!linein) {
        return NULL;
    }
    memset(linein, 0x0, sizeof(struct linein_sample_hdl));

    linein->store_pcm_buf = zalloc(ADC_STORE_PCM_SIZE);
    if (!linein->store_pcm_buf) {
        return NULL;
    }

    cbuf_init(&linein->cbuf, linein->store_pcm_buf, ADC_STORE_PCM_SIZE);
    os_sem_create(&linein->sem, 0);

    linein->sample_rate = sample_rate;
    linein->audio_track = audio_local_sample_track_open(linein->channel_num, sample_rate, 1000);

    linein->channel_num = 2;
    if (source == 1) { //line1
        audio_adc_linein_open(&linein->linein_ch, AUDIO_ADC_LINE1_LR, &adc_hdl);
    } else if (source == 0) { //linein0
        audio_adc_linein_open(&linein->linein_ch, AUDIO_ADC_LINE0_LR, &adc_hdl);
    } else if (source == 2) {
        audio_adc_linein_open(&linein->linein_ch, AUDIO_ADC_LINE2_LR, &adc_hdl);
    } else {
        return linein;
    }

    audio_adc_linein_set_sample_rate(&linein->linein_ch, sample_rate);
    audio_adc_linein_set_gain(&linein->linein_ch, 1);

    audio_adc_set_buffs(&linein->linein_ch, linein->adc_buf, ADC_CH_NUM * ADC_IRQ_POINTS * 2, ADC_BUF_NUM);

    linein->sample_output.handler = linein_sample_output_handler;
    linein->sample_output.priv = linein;

    audio_adc_add_output_handler(&adc_hdl, &linein->sample_output);
    audio_adc_linein_start(&linein->linein_ch);
    return linein;
}

void fm_sample_close(void *hdl, u8 source)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)hdl;

    if (!linein) {
        return;
    }

    if (source <= 2) {
        audio_adc_linein_close(&linein->linein_ch);
        audio_adc_del_output_handler(&adc_hdl, &linein->sample_output);
    }
    if (linein->audio_track) {
        audio_local_sample_track_close(linein->audio_track);
    }

    free(linein->store_pcm_buf);
    free(linein);
}


////>>>>>>>>>>>>>>record_player api录音接口<<<<<<<<<<<<<<<<<<<<<///
#if 1

/* #define RECORD_PLAYER_DEFULT_SAMPLERATE	(44100L) */
#define RECORD_PLAYER_DEFULT_SAMPLERATE	(16000L)
#define RECORD_PLAYER_DEFULT_BITRATE	(128L)
#define RECORD_PLAYER_DEFULT_ADPCM_BLOCKSIZE (1024L) //256/512/1024/2048
#define RECORD_PLAYER_MIXER_CHANNELS		 1     //mixer record single channel

#define REC_ALIN(var,al)     ((((var)+(al)-1)/(al))*(al))

struct record_hdl {
    struct audio_adc_output_hdl adc_output;
    struct adc_mic_ch    mic_ch;
    struct audio_adc_ch linein_ch;
    struct __dev *dev;
    void *file;
    //s16 adc_buf[ADC_BUFS_SIZE];
    s16 *adc_buf;
    u32 magic;
    u32 start_sys_tick;
    enum enc_source source;
    u16	sample_rate;
    u16 cut_head_timer;
    u8  cut_head_flag;
    u8  stop_req;
    u8  nchl;
    u8  coding_type;
    volatile u8  busy;
    volatile u8  status;
    void (*err_callback)(void);
};

extern u32 timer_get_ms(void);
extern u32 audio_output_channel_num(void);

extern struct audio_mixer mixer;

static struct record_hdl *rec_hdl = NULL;

int recorder_get_enc_time()
{
    int ret = 0;
    if (rec_hdl && rec_hdl->file) {
        ret = pcm2file_enc_get_time(rec_hdl->file);
    }
//	log_d("get ret %d s\n", ret);
    return ret;
}

static void recorder_encode_clock_add(u32 coding_type)
{
    if ((coding_type == AUDIO_CODING_WAV) || (coding_type == AUDIO_CODING_PCM)) {
        clock_add(ENC_WAV_CLK);
    } else if (coding_type == AUDIO_CODING_G726) {
        clock_add(ENC_G726_CLK);
    } else if (coding_type == AUDIO_CODING_MP3) {
        clock_add(ENC_MP3_CLK);
    }
    clock_set_cur();
}

static void recorder_encode_clock_remove(u32 coding_type)
{
    if ((coding_type == AUDIO_CODING_WAV) || (coding_type == AUDIO_CODING_PCM)) {
        clock_remove(ENC_WAV_CLK);
    } else if (coding_type == AUDIO_CODING_G726) {
        clock_remove(ENC_G726_CLK);
    } else if (coding_type == AUDIO_CODING_MP3) {
        clock_remove(ENC_MP3_CLK);
    }
    clock_set_cur();
}

void recorder_encode_stop(void)
{
    if (rec_hdl) {
        switch (rec_hdl->source) {
        case ENCODE_SOURCE_MIX:
            break;
        case ENCODE_SOURCE_MIC:
#if 0
            audio_adc_mic_close(&rec_hdl->mic_ch);
            audio_adc_del_output_handler(&adc_hdl, &rec_hdl->adc_output);
#else
            audio_mic_close(&rec_hdl->mic_ch, &rec_hdl->adc_output);
#endif
            break;
        case ENCODE_SOURCE_LINE0_LR:
        case ENCODE_SOURCE_LINE1_LR:
        case ENCODE_SOURCE_LINE2_LR:
            audio_adc_linein_close(&rec_hdl->linein_ch);
            audio_adc_del_output_handler(&adc_hdl, &rec_hdl->adc_output);
            break;
        default:
            break;
        }
        rec_hdl->magic++;

        rec_hdl->status = 0;
        printf("[%s], wait busy\n", __FUNCTION__);
        while (rec_hdl->busy) {
            os_time_dly(2);
        }
        printf("[%s], wait busy ok\n", __FUNCTION__);
        pcm2file_enc_close(&rec_hdl->file);
        recorder_encode_clock_remove(rec_hdl->coding_type);
        rec_hdl->file = NULL;
        sys_timeout_del(rec_hdl->cut_head_timer);
        local_irq_disable();
        free(rec_hdl);
        rec_hdl = NULL;
        local_irq_enable();
        vddiom_set_dynamic(TCFG_LOWPOWER_VDDIOM_LEVEL);

    }
}

static void recorder_encode_event_handler(struct audio_encoder *hdl, int argc, int *argv)
{
    if (rec_hdl == NULL) {
        return ;
    }

    struct audio_encoder *enc = get_pcm2file_encoder_hdl(rec_hdl->file);
    printf("%s, argv[]:%d, %d , hdl = %x, enc = %x", __FUNCTION__,  argv[0], argv[1], hdl, enc);
    if ((hdl != NULL) && (hdl == enc)) {
        if (rec_hdl->err_callback) {
            rec_hdl->err_callback();
        } else {
            recorder_encode_stop();
        }
    } else {
        printf("err enc handle !!\n");
    }
}



static void adc_output_to_enc(void *priv, s16 *data, int len)
{
    /* putchar('o'); */
    if (rec_hdl == NULL) {
        return ;
    }

    if (rec_hdl->cut_head_flag) {
        return ;
    }

    switch (rec_hdl->source) {
    case ENCODE_SOURCE_MIC:
    case ENCODE_SOURCE_LINE0_LR:
    case ENCODE_SOURCE_LINE1_LR:
    case ENCODE_SOURCE_LINE2_LR:
        pcm2file_enc_write_pcm(rec_hdl->file, data, len * adc_hdl.channel);
        break;
    default:
        break;
    }
}

void record_cut_head_timeout(void *priv)
{
    if (rec_hdl) {
        rec_hdl->cut_head_flag = 0;
        printf("record_cut_head_timeout \n");
    }
}

u32 recorder_get_encoding_time()
{
    return recorder_get_enc_time();
//   u32 time_sec = 0;
//   if (rec_hdl) {
//	   time_sec = (timer_get_ms() - rec_hdl->start_sys_tick) / 1000;
//	   /* printf("rec time sec = %d\n",time_sec); */
//   }
//    return time_sec;
}

///检查录音是否正在进行
int recorder_is_encoding(void)
{
    if (rec_hdl) {
        return 1;
    }
    return 0;
}


int recorder_encode_start(struct record_file_fmt *f)
{
    struct audio_fmt afmt;
    struct record_file_fmt fmt;
    u32 cut_tail_size = 0;
    struct record_hdl *rec = NULL;

    vddiom_set_dynamic(TCFG_VDDIO_DEV_ACCESS_LEVEL);
    memcpy((u8 *)&fmt, (u8 *)f, sizeof(struct record_file_fmt));
    if ((fmt.coding_type == AUDIO_CODING_WAV) || fmt.coding_type == AUDIO_CODING_G726) {
        fmt.bit_rate    = RECORD_PLAYER_DEFULT_ADPCM_BLOCKSIZE;
    } else {
        fmt.bit_rate    = RECORD_PLAYER_DEFULT_BITRATE;
    }
#if TCFG_MIC_EFFECT_ENABLE
    fmt.sample_rate = MIC_EFFECT_SAMPLERATE;
#endif
    afmt.coding_type = fmt.coding_type;
    afmt.channel = fmt.channel;
    afmt.sample_rate = fmt.sample_rate;
    afmt.bit_rate = fmt.bit_rate;

    if (rec_hdl) {
        recorder_encode_stop();
    }

    u32 offset = 0;
    u32 size = REC_ALIN(sizeof(struct record_hdl), 4);
    if ((fmt.source == ENCODE_SOURCE_LINE0_LR)
        || (fmt.source == ENCODE_SOURCE_LINE1_LR)
        || (fmt.source == ENCODE_SOURCE_LINE2_LR)
       ) {
        size += REC_ALIN((sizeof(s16) * ADC_BUFS_SIZE), 4);
    }

    u8 *buf = zalloc(size);
    if (!buf) {
        vddiom_set_dynamic(TCFG_LOWPOWER_VDDIOM_LEVEL);
        return -1;
    }
    rec = (struct record_hdl *)(buf + offset);
    offset += REC_ALIN(sizeof(struct record_hdl), 4);

    rec->source = fmt.source;
    rec->dev = dev_manager_find_spec(fmt.dev, 0);
    if (rec->dev == NULL) {
        free(rec);
        vddiom_set_dynamic(TCFG_LOWPOWER_VDDIOM_LEVEL);
        return -1;
    }

    rec->sample_rate = fmt.sample_rate;
    rec->nchl = fmt.channel;
    rec->coding_type = fmt.coding_type;
    recorder_encode_clock_add(fmt.coding_type);
    rec->file = pcm2file_enc_open(&afmt, fmt.dev, fmt.folder, fmt.filename);
    if (!rec->file) {
        free(rec);
        recorder_encode_clock_remove(fmt.coding_type);
        vddiom_set_dynamic(TCFG_LOWPOWER_VDDIOM_LEVEL);
        return -1;
    }

    rec->cut_head_flag = 1;
    rec->cut_head_timer = sys_timeout_add(NULL, record_cut_head_timeout, fmt.cut_head_time);

    if ((fmt.coding_type == AUDIO_CODING_WAV) || (fmt.coding_type == AUDIO_CODING_G726)) {
        cut_tail_size = (4 * fmt.sample_rate * fmt.channel) * fmt.cut_tail_time / 1000 / 8;
        cut_tail_size = ((cut_tail_size + fmt.bit_rate - 1) / fmt.bit_rate) * fmt.bit_rate;
    } else {
        cut_tail_size = fmt.bit_rate * fmt.cut_tail_time / 8;
    }

    rec->err_callback = NULL;
    if (fmt.err_callback) {
        rec->err_callback = fmt.err_callback;
    }

    last_enc_file_codeing_type_save(afmt.coding_type);
    pcm2file_enc_set_evt_handler(rec->file, recorder_encode_event_handler, rec->magic);
    pcm2file_enc_write_file_set_limit(rec->file, cut_tail_size, fmt.limit_size);
    pcm2file_enc_start(rec->file);

    switch (rec->source) {
    case ENCODE_SOURCE_MIX:
        break;
    case ENCODE_SOURCE_MIC:
        rec->adc_output.handler = adc_output_to_enc;
        rec->adc_output.priv    = rec;
        if (audio_mic_open(&rec->mic_ch, fmt.sample_rate, fmt.gain) == 0) {
            audio_mic_add_output(&rec->adc_output);
            audio_mic_start(&rec->mic_ch);
        }
        break;
    case ENCODE_SOURCE_LINE0_LR:
    case ENCODE_SOURCE_LINE1_LR:
    case ENCODE_SOURCE_LINE2_LR:
        rec->adc_buf = (s16 *)(buf + offset);
        audio_adc_linein_open(&rec->linein_ch, AUDIO_ADC_LINE0_LR + (rec->source - ENCODE_SOURCE_LINE0_LR), &adc_hdl);
        audio_adc_linein_set_sample_rate(&rec->linein_ch, fmt.sample_rate);
        audio_adc_linein_set_gain(&rec->linein_ch, fmt.gain);
        audio_adc_set_buffs(&rec->linein_ch, rec->adc_buf, ADC_CH_NUM * ADC_IRQ_POINTS * 2, ADC_BUF_NUM);
        rec->adc_output.handler = adc_output_to_enc;
        rec->adc_output.priv = &adc_hdl;
        audio_adc_add_output_handler(&adc_hdl, &rec->adc_output);
        audio_adc_linein_start(&rec->linein_ch);
        break;
    default:
        break;
    }

    rec->start_sys_tick = timer_get_ms();
    rec_hdl = rec;

    rec_hdl->status = 1;
    rec_hdl->busy = 0;

    return 0;
}

void recorder_encode_pp()
{
    struct pcm2file_enc_hdl *file_hdl = (struct pcm2file_enc_hdl *)rec_hdl->file;
    if (rec_hdl) {
        if (rec_hdl->status == 1) {
            enc_change_status(rec_hdl->file);
        }
        printf("[%s] recorder pp\n", __FUNCTION__);
    }
}

int recorder_userdata_to_enc(s16 *data, int len)
{
    if ((rec_hdl == NULL) || (rec_hdl->status == 0)) {
        return 0;
    }
    rec_hdl->busy = 1;
    if (rec_hdl->cut_head_flag) {
        rec_hdl->busy = 0;
        return 0;
    }
    int wlen = pcm2file_enc_write_pcm(rec_hdl->file, data, len);
    rec_hdl->busy = 0;
    return wlen;
}

void recorder_device_offline_check(char *logo)
{
    if (rec_hdl) {
        if (!strcmp(dev_manager_get_logo(rec_hdl->dev), logo)) {
            ///当前录音正在使用的设备掉线， 应该停掉录音
            printf("is the recording dev = %s\n", logo);
            recorder_encode_stop();
        }
    }
}

#endif//