/***************************************************************************
 *
 * 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 "cmsis_os.h"
#include "hal_trace.h"
#include "app_thread.h"

#include "hal_timer.h"
#include "app_audtest_pattern.h"

#include "hal_aud.h"
#include "audioflinger.h"
#include "audiobuffer.h"
#include "stdbool.h"
#include <string.h>
#include "eq_export.h"
#include "app_utils.h"

#if defined(APP_TEST_AUDIO) && defined(ANC_APP)
#include "anc_usb_app.h"
#include "usb_audio_app.h"
#include "usb_audio_frm_defs.h"
//#include "dualadc_audio_app.h"
#endif

#define USB_AUDIO_PLAYBACK_BUFF_SIZE    (FRAME_SIZE_PLAYBACK * 4)
#define USB_AUDIO_CAPTURE_BUFF_SIZE     (FRAME_SIZE_CAPTURE * 4)

#define USB_AUDIO_RECV_BUFF_SIZE        (FRAME_SIZE_RECV * 8)
#define USB_AUDIO_SEND_BUFF_SIZE        (FRAME_SIZE_SEND * 8)

#define APP_TEST_PLAYBACK_BUFF_SIZE     (128 * 20)
#define APP_TEST_CAPTURE_BUFF_SIZE      (128 * 20)

#if (USB_AUDIO_PLAYBACK_BUFF_SIZE > APP_TEST_PLAYBACK_BUFF_SIZE)
#define REAL_PLAYBACK_BUFF_SIZE         USB_AUDIO_PLAYBACK_BUFF_SIZE
#else
#define REAL_PLAYBACK_BUFF_SIZE         APP_TEST_PLAYBACK_BUFF_SIZE
#endif

#if (USB_AUDIO_CAPTURE_BUFF_SIZE > APP_TEST_CAPTURE_BUFF_SIZE)
#define REAL_CAPTURE_BUFF_SIZE          USB_AUDIO_CAPTURE_BUFF_SIZE
#else
#define REAL_CAPTURE_BUFF_SIZE          APP_TEST_CAPTURE_BUFF_SIZE
#endif

#define ALIGNED4                        ALIGNED(4)

static uint8_t ALIGNED4 app_test_playback_buff[REAL_PLAYBACK_BUFF_SIZE];
static uint8_t ALIGNED4 app_test_capture_buff[REAL_CAPTURE_BUFF_SIZE];

#if defined(APP_TEST_AUDIO) && defined(ANC_APP)
static uint8_t ALIGNED4 app_test_recv_buff[USB_AUDIO_RECV_BUFF_SIZE];
static uint8_t ALIGNED4 app_test_send_buff[USB_AUDIO_SEND_BUFF_SIZE];
#endif

uint32_t pcm_1ksin_more_data(uint8_t *buf, uint32_t len)
{
    static uint32_t nextPbufIdx = 0;
    uint32_t remain_size = len;
    uint32_t curr_size = 0;
    static uint32_t pcm_preIrqTime = 0;;
    uint32_t stime = 0;


    stime = hal_sys_timer_get();
    TRACE(3,"pcm_1ksin_more_data irqDur:%d readbuff:0x%08x %d\n ", TICKS_TO_MS(stime - pcm_preIrqTime), buf, len);
    pcm_preIrqTime = stime;

    //  TRACE(2,"[pcm_1ksin_more_data] len=%d nextBuf:%d\n", len, nextPbufIdx);
    if (remain_size > sizeof(sinwave))
    {
        do{
            if (nextPbufIdx)
            {
                curr_size = sizeof(sinwave)-nextPbufIdx;
                memcpy(buf,&sinwave[nextPbufIdx/2], curr_size);
                remain_size -= curr_size;
                nextPbufIdx = 0;
            }
            else if (remain_size>sizeof(sinwave))
            {
                memcpy(buf+curr_size,sinwave,sizeof(sinwave));
                curr_size += sizeof(sinwave);
                remain_size -= sizeof(sinwave);
            }
            else
            {
                memcpy(buf+curr_size,sinwave,remain_size);
                nextPbufIdx = remain_size;
                remain_size = 0;
            }
        }while(remain_size);
    }
    else
    {
        if ((sizeof(sinwave) - nextPbufIdx) >= len)
        {
            memcpy(buf, &sinwave[nextPbufIdx/2],len);
            nextPbufIdx += len;
        }
        else
        {
            curr_size = sizeof(sinwave)-nextPbufIdx;
            memcpy(buf, &sinwave[nextPbufIdx/2],curr_size);
            nextPbufIdx = len - curr_size;
            memcpy(buf+curr_size,sinwave, nextPbufIdx);
        }
    }

    return 0;
}

uint32_t pcm_mute_more_data(uint8_t *buf, uint32_t len)
{
    memset(buf, 0 , len);
    return 0;
}

void da_output_sin1k(bool  on)
{
    static bool isRun =  false;
    struct AF_STREAM_CONFIG_T stream_cfg;
    memset(&stream_cfg, 0, sizeof(stream_cfg));

    if (isRun==on)
        return;
    else
        isRun=on;
    TRACE(2,"%s %d\n", __func__, on);

    if (on){
        stream_cfg.bits = AUD_BITS_16;
        stream_cfg.channel_num = AUD_CHANNEL_NUM_2;
        stream_cfg.sample_rate = AUD_SAMPRATE_44100;

        stream_cfg.device = AUD_STREAM_USE_INT_CODEC;
        stream_cfg.io_path = AUD_OUTPUT_PATH_SPEAKER;
        stream_cfg.vol = 16;

        stream_cfg.handler = pcm_1ksin_more_data;
        stream_cfg.data_ptr = app_test_playback_buff;
        stream_cfg.data_size = APP_TEST_PLAYBACK_BUFF_SIZE;

        af_stream_open(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg);
        af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
    }else{
        af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
        af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
    }

}

void da_tester(uint8_t on)
{
	da_output_sin1k(on);
}

extern int voicecvsd_audio_init(void);
extern uint32_t voicecvsd_audio_more_data(uint8_t *buf, uint32_t len);
extern int get_voicecvsd_buffer_size(void);
extern int store_voice_pcm2cvsd(unsigned char *buf, unsigned int len);

static uint32_t pcm_data_capture(uint8_t *buf, uint32_t len)
{
    uint32_t stime, etime;
    static uint32_t preIrqTime = 0;

    stime = hal_sys_timer_get();
//  audio_buffer_set_stereo2mono_16bits(buf, len, 1);
    audio_buffer_set(buf, len);
    etime = hal_sys_timer_get();
    TRACE(4,"%s irqDur:%d fsSpend:%d, Len:%d", __func__, TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
    preIrqTime = stime;
    return 0;
}

static uint32_t pcm_data_playback(uint8_t *buf, uint32_t len)
{
    uint32_t stime, etime;
    static uint32_t preIrqTime = 0;
    stime = hal_sys_timer_get();
//  audio_buffer_get_mono2stereo_16bits(buf, len);
    audio_buffer_get(buf, len);
    etime = hal_sys_timer_get();
    TRACE(4,"%s irqDur:%d fsSpend:%d, Len:%d", __func__, TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
    preIrqTime = stime;
    return 0;
}

uint32_t pcm_cvsd_data_capture(uint8_t *buf, uint32_t len)
{
    uint32_t stime, etime;
    static uint32_t preIrqTime = 0;

    //TRACE(1,"%s enter", __func__);
    stime = hal_sys_timer_get();
    len >>= 1;
    audio_stereo2mono_16bits(0, (uint16_t *)buf, (uint16_t *)buf, len);
    store_voice_pcm2cvsd(buf, len);
    etime = hal_sys_timer_get();
    TRACE(4,"%s exit irqDur:%d fsSpend:%d, add:%d", __func__, TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len);
    preIrqTime = stime;
    return 0;
}

uint32_t pcm_cvsd_data_playback(uint8_t *buf, uint32_t len)
{
    int n;
    uint32_t stime, etime;
    static uint32_t preIrqTime = 0;

    //TRACE(1,"%s enter", __func__);
    stime = hal_sys_timer_get();
    pcm_1ksin_more_data(buf, len);
    voicecvsd_audio_more_data(buf, len);
    n = get_voicecvsd_buffer_size();
    etime = hal_sys_timer_get();
    TRACE(5,"%s exit irqDur:%d fsSpend:%d, get:%d remain:%d", __func__, TICKS_TO_MS(stime - preIrqTime), TICKS_TO_MS(etime - stime), len, n);
    preIrqTime = stime;
    return 0;
}

void adc_looptester(bool on, enum AUD_IO_PATH_T input_path, enum AUD_SAMPRATE_T sample_rate)
{
    struct AF_STREAM_CONFIG_T stream_cfg;

    static bool isRun = false;

    if (isRun==on)
        return;
    else
        isRun=on;

    if (on){
        audio_buffer_init();
        memset(&stream_cfg, 0, sizeof(stream_cfg));

        stream_cfg.bits = AUD_BITS_16;
        stream_cfg.channel_num = AUD_CHANNEL_NUM_2;
        stream_cfg.sample_rate = sample_rate;

        stream_cfg.device = AUD_STREAM_USE_INT_CODEC;
        stream_cfg.io_path = input_path;
        stream_cfg.vol = 0x03;

        stream_cfg.handler = pcm_data_capture;

        stream_cfg.data_ptr = app_test_capture_buff;
        stream_cfg.data_size = APP_TEST_CAPTURE_BUFF_SIZE;
        af_stream_open(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE, &stream_cfg);

        stream_cfg.handler = pcm_data_playback;
        stream_cfg.io_path = AUD_OUTPUT_PATH_SPEAKER;

        stream_cfg.data_ptr = app_test_playback_buff;
        stream_cfg.data_size = APP_TEST_PLAYBACK_BUFF_SIZE;
        af_stream_open(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg);

        af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
        af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
    }else{
        af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
        af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
        af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
        af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
    }
}

#if defined(APP_TEST_AUDIO) && defined(ANC_APP)
void app_anc_usb_init(void)
{
    app_sysfreq_req(APP_SYSFREQ_USER_APP_0, APP_SYSFREQ_52M);

    anc_usb_app_init(AUD_INPUT_PATH_MAINMIC, AUD_SAMPRATE_96000, AUD_SAMPRATE_192000);

    struct USB_AUDIO_BUF_CFG cfg;

    memset(&cfg, 0, sizeof(cfg));
    cfg.play_buf = app_test_playback_buff;
    cfg.play_size = USB_AUDIO_PLAYBACK_BUFF_SIZE;
    cfg.cap_buf = app_test_capture_buff;
    cfg.cap_size = USB_AUDIO_CAPTURE_BUFF_SIZE;
    cfg.recv_buf = app_test_recv_buff;
    cfg.recv_size = USB_AUDIO_RECV_BUFF_SIZE;
    cfg.send_buf = app_test_send_buff;
    cfg.send_size = USB_AUDIO_SEND_BUFF_SIZE;

    usb_audio_app_init(&cfg);

    //dualadc_audio_app_init(app_test_playback_buff, USB_AUDIO_PLAYBACK_BUFF_SIZE,
        //app_test_capture_buff, USB_AUDIO_CAPTURE_BUFF_SIZE);
}
#endif