/*****************************************************************
>file name : spatial_audio.c
>create time : Mon 03 Jan 2022 01:58:51 PM CST
*****************************************************************/
#include "typedef.h"
#include "spatial_effect_imu.h"
#include "system/includes.h"
#include "audio_base.h"
#include "app_config.h"
#include "audio_codec_clock.h"
#include "spatial_effect_tws.h"

#if TCFG_AUDIO_SPATIAL_EFFECT_ENABLE
#include "spatial_effect.h"

#if SPATIAL_AUDIO_EFFECT_ENABLE
#include "tech_lib/effect_surTheta_api.h"
#include "tech_lib/SpatialAudio_api.h"
#endif

const int  voicechange_fft_PLATFORM = 2;

/*T0模式下有效
0：环境声更明显
1：最左最右的时候音量差异更明显*/
const int OLD_V_FLAG = 1;/*0 or 1*/
/*角度的映射音量密度
OLD_V_FLAG = 1时有效*/
const int P360_MRATE = 128;/*0 ~ 128*/

/*空间音频模式使能控制变量
 * 0: 关闭音效，保留角度跟踪
 * 1: 打开音效和角度跟踪
 * 2: 轻量级音效和角度跟踪*/
const int P360_REVERB_NE = 1;

static struct spatial_audio_context *spatial_hdl = NULL;

struct sound360td_algo {
    int angle;
    const PointSound360TD_FUNC_API *ops;
    unsigned int run_buf[0];
};

struct spatial_calculator {
    void *privtate_data;
    u8 work_buf[0];
};
int  anglevolume = 150;
int  angleresetflag = 0;

static RP_PARM_CONIFG parmK = {
    .trackKIND = P360_T0,
    .ReverbKIND = P360_R1,
    .reverbance = 70,
    .dampingval = 70,
};
static u8 param_update_flag = 0;

#if TCFG_SPATIAL_EFFECT_ONLINE_ENABLE
void spatial_effect_online_updata(RP_PARM_CONIFG *params)
{
    memcpy(&parmK, params, sizeof(parmK));
    param_update_flag = 1;
}
void get_spatial_effect_reverb_params(RP_PARM_CONIFG *params)
{
    memcpy(params, &parmK, sizeof(parmK));
}

#endif /*TCFG_SPATIAL_EFFECT_ONLINE_ENABLE*/

static void *spatial_audio_effect_init(void)
{
    struct sound360td_algo *algo = NULL;

    PointSound360TD_FUNC_API *ops = get_PointSound360TD_func_api();
    PointSound360TD_PARM_SET params;
    RP_PARM_CONIFG  rp_obj;

    angleresetflag = 1;

    /*音效参数初始化*/
    memcpy(&rp_obj, &parmK, sizeof(parmK));
    param_update_flag = 0;

    params.theta = 0;
    params.volume = anglevolume;

    int buf_size = ops->need_buf(P360TD_REV_K1);

    algo = (struct sound360td_algo *)malloc(sizeof(struct sound360td_algo) + buf_size);
    if (!algo) {
        return NULL;
    }

    algo->ops = ops;
    algo->ops->open_config(algo->run_buf, &params, &rp_obj);
    algo->angle = 0;

    return algo;
}

static int spatial_audio_effect_handler(void *effect, void *data, int len)
{
    struct sound360td_algo *algo = (struct sound360td_algo *)effect;
    int frames = len >> 2;

#if TCFG_SPATIAL_EFFECT_ONLINE_ENABLE
    if (param_update_flag) {
        param_update_flag = 0;
        PointSound360TD_PARM_SET params;
        params.theta = 0;
        params.volume = anglevolume;
        algo->ops->open_config(algo->run_buf, &params, &parmK);
    }
#endif /*TCFG_SPATIAL_EFFECT_ONLINE_ENABLE*/

    algo->ops->run(algo->run_buf, data, data, frames);

    return len;
}

static void spatial_audio_effect_close(void *effect)
{
    struct sound360td_algo *algo = (struct sound360td_algo *)effect;

    free(algo);
}

/*
 * 空间效果参数配置接口
 */
static void spatial_audio_effect_params_setup(void *effect, int angle)
{
    struct sound360td_algo *algo = (struct sound360td_algo *)effect;

    if (angle != algo->angle) {
        PointSound360TD_PARM_SET params;
        //TODO
        params.theta = angle;
        params.volume = 100;
        params.volume = anglevolume;
        algo->ops->init(algo->run_buf, &params);
        algo->angle = angle;
    }

}

extern void put_float(double fv);
/*获取vm加速度计偏置*/
int read_vm_acc_cel_param(acc_cel_t *acc_cel)
{
    int ret = 0;
    ret = syscfg_read(CFG_IMU_ACC_OFFEST_ID, acc_cel, sizeof(acc_cel_t));
    if (ret != sizeof(acc_cel_t)) {
        printf("vm acc_cel read fail !!!");
        acc_cel->acc_offx = -48.231f;
        acc_cel->acc_offy = -57.035f;
        acc_cel->acc_offz = -84.097f;
    } else {
        printf("vm acc_cel read succ !!!");
    }
    printf("acc_offx : ");
    put_float(acc_cel->acc_offx);
    printf("acc_offy : ");
    put_float(acc_cel->acc_offy);
    printf("acc_offz : ");
    put_float(acc_cel->acc_offz);
    return 0;
}

/*获取vm陀螺仪偏置*/
int read_vm_gyro_cel_param(gyro_cel_t *gyro_cel)
{
    int ret = 0;
    ret = syscfg_read(CFG_IMU_GYRO_OFFEST_ID, gyro_cel, sizeof(gyro_cel_t));
    if (ret != sizeof(gyro_cel_t)) {
        printf("vm gyro_cel read fail !!!");
        gyro_cel->gyro_x = -1.694f;
        gyro_cel->gyro_y = -0.521f;
        gyro_cel->gyro_z = -0.078f;
    } else {
        printf("vm gyro_cel read succ !!!");
    }
    printf("gyro_x : ");
    put_float(gyro_cel->gyro_x);
    printf("gyro_y : ");
    put_float(gyro_cel->gyro_y);
    printf("gyro_z : ");
    put_float(gyro_cel->gyro_z);
    return 0;
}

/*配置传感器算法参数*/
int space_motion_param_init(info_spa_t *info_spa, spatial_config_t *conf, tranval_t *tranval)
{
#if TCFG_ICM42670P_ENABLE
    if (info_spa) {
        info_spa->fs = 99.f;
        info_spa->len = 6;
        info_spa->sensitivity = 16.4f;
        info_spa->range = 16;
    }
    if (conf) {
        conf->beta = 0.1f;
        conf->cel_val = 0.14f;
        conf->SerialTime = 0.2f;
        conf->time = 1.0f;
        conf->val = 0.02f;
        conf->sensval = 0.02f;
    }
    if (tranval) {
        tranval->trans_x[0] =  0;
        tranval->trans_x[1] =  1;
        tranval->trans_x[2] =  0;
        tranval->trans_y[0] =  0;
        tranval->trans_y[1] =  0;
        tranval->trans_y[2] = -1;
        tranval->trans_z[0] = -1;
        tranval->trans_z[1] =  0;
        tranval->trans_z[2] =  0;
    }

#elif TCFG_LSM6DSL_ENABLE
    if (info_spa) {
        info_spa->fs = 104.f;
        info_spa->len = 6;
        info_spa->sensitivity = 14.28f;
        info_spa->range = 16;
    }
    if (conf) {
        conf->beta = 0.1f;
        conf->cel_val = 0.12f;
        conf->SerialTime = 0.24f;
        conf->time = 1.f;
        conf->val = 0.02f;
        conf->sensval = 0.01f;
    }
    if (tranval) {
        tranval->trans_x[0] =  0;
        tranval->trans_x[1] =  1;
        tranval->trans_x[2] =  0;
        tranval->trans_y[0] =  0;
        tranval->trans_y[1] =  0;
        tranval->trans_y[2] = -1;
        tranval->trans_z[0] = -1;
        tranval->trans_z[1] =  0;
        tranval->trans_z[2] =  0;
    }

#elif TCFG_MPU6887P_ENABLE
    if (info_spa) {
        info_spa->fs = 100.f;
        info_spa->len = 6;
        info_spa->sensitivity = 16.4f;
        info_spa->range = 16;
    }
    if (conf) {
        conf->beta = 0.1f;
        conf->cel_val = 0.12f;
        conf->SerialTime = 0.2f;
        conf->time = 1.0f;
        conf->val = 0.07f;
        conf->sensval = 0.01f;
    }
    if (tranval) {
        tranval->trans_x[0] = -1;
        tranval->trans_x[1] =  0;
        tranval->trans_x[2] =  0;
        tranval->trans_y[0] =  0;
        tranval->trans_y[1] =  0;
        tranval->trans_y[2] = -1;
        tranval->trans_z[0] =  0;
        tranval->trans_z[1] = -1;
        tranval->trans_z[2] =  0;
    }

#else /*TCFG_MPU6050_EN*/
    if (info_spa) {
        info_spa->fs = 100.f;
        info_spa->len = 6;
        info_spa->sensitivity = 16.4f;
        info_spa->range = 16;
    }
    if (conf) {
        conf->beta = 0.1f;
        conf->cel_val = 0.08f;
        conf->SerialTime = 0.2f;
        conf->time = 1.0f;
        conf->val = 0.02f;
        conf->sensval = 0.01f;
    }
    if (tranval) {
        tranval->trans_x[0] = -1;
        tranval->trans_x[1] =  0;
        tranval->trans_x[2] =  0;
        tranval->trans_y[0] =  0;
        tranval->trans_y[1] =  0;
        tranval->trans_y[2] = -1;
        tranval->trans_z[0] =  0;
        tranval->trans_z[1] = -1;
        tranval->trans_z[2] =  0;
    }

#endif
    return 0;
}

static void *space_motion_calculator_open(void)
{
    struct spatial_calculator *c = NULL;

    //传感器算法参数初始化
    info_spa_t info_spa;
    spatial_config_t conf;
    tranval_t tranval;
    space_motion_param_init(&info_spa, &conf, &tranval);
    //陀螺仪偏置
    gyro_cel_t gyro_cel;
    read_vm_gyro_cel_param(&gyro_cel);
    //加速度偏置
    acc_cel_t acc_cel;
    read_vm_acc_cel_param(&acc_cel);

    int buf_size = get_Spatial_buf(info_spa.len);

    c = (struct spatial_calculator *)zalloc(sizeof(struct spatial_calculator) + buf_size);
    if (!c) {
        return NULL;
    }

    init_Spatial(c->work_buf, &info_spa, &tranval, &conf, &gyro_cel, &acc_cel);

    return c;
}

static void space_motion_calculator_close(void *calculator)
{
    if (calculator) {
        free(calculator);
    }
}

/*
 * 空间位置检测处理
 */
static int space_motion_detect(void *calculator, short *data, int len)
{
    struct spatial_calculator *c = (struct spatial_calculator *)calculator;
    int heading = 0;

    if (len == 0) {
        return 0;
    }
    /*
     * TODO : 这里是空间运动检测处理
     */
    if (angleresetflag) {
        Spatial_reset(c->work_buf);
        angleresetflag = 0;
    }

    int group_num = (len >> 1) / 6;
    while (group_num--) {
        Spatial_cacl(c->work_buf, data);
        data += 6;
        heading = get_Spa_angle(c->work_buf, TRACK_SENSITIVITY, ANGLE_RESET_SENSITIVITY);/*1 ~ 0.001，1：表示即时跟踪，数值越小跟踪越慢*/
        int flag = Spatial_stra(c->work_buf, ANGLE_RESET_TIME, 0.5f);
        if (flag == 1) {
            Spatial_reset(c->work_buf);
            flag = 0;
        }
    }
    /* printf("%d\n", heading); */
    return heading;

}

#if TCFG_USER_TWS_ENABLE
static void spatial_tws_data_handler(void *priv, void *data, int len)
{
    struct spatial_audio_context *ctx = (struct spatial_audio_context *)priv;
    memcpy(&ctx->tws_angle, data, sizeof(ctx->tws_angle));
}
#endif

extern u8 get_a2dp_spatial_audio_head_tracked(void);
void *spatial_audio_open(void)
{
    struct spatial_audio_context *ctx;

#if SPATIAL_AUDIO_EFFECT_ENABLE
    ctx = (struct spatial_audio_context *)zalloc(sizeof(struct spatial_audio_context) + 1024);
#else
    ctx = (struct spatial_audio_context *)zalloc(sizeof(struct spatial_audio_context));
#endif
    if (!ctx) {
        return NULL;
    }
    spatial_hdl = ctx;

    audio_codec_clock_set(SPATIAL_EFFECT_MODE, AUDIO_CODING_PCM, 0);

    ctx->head_tracked = get_a2dp_spatial_audio_head_tracked();
    if (ctx->head_tracked) {
        ctx->sensor = space_motion_detect_open();
    }
#if SPATIAL_AUDIO_EFFECT_ENABLE
    ctx->effect = spatial_audio_effect_init();
    ctx->calculator = space_motion_calculator_open();
#endif
#if TCFG_USER_TWS_ENABLE
    ctx->tws_conn = spatial_tws_create_connection(100, (void *)ctx, spatial_tws_data_handler);
#endif

#if SPATIAL_AUDIO_EXPORT_DATA
#if SPATIAL_AUDIO_EXPORT_MODE == 0
    extern void force_set_sd_online(char *sdx);
    force_set_sd_online("sd0");
    void *mnt = mount("sd0", "storage/sd0", "fat", 3, NULL);
    if (!mnt) {
        printf("sd0 mount fat failed.\n");
    }
#endif
    task_create(audio_export_task, (void *)ctx, "ftask");
    os_taskq_post_msg("ftask", 1, 0);
#endif

    /*空间音频正常的声道映射为左右声道*/
    ctx->mapping_channel = AUDIO_CH_LR;
    return ctx;
}

int spatial_audio_set_mapping_channel(void *sa, u8 channel)
{
    struct spatial_audio_context *ctx = (struct spatial_audio_context *)sa;

    ctx->mapping_channel = channel;

    return 0;
}

void spatial_audio_close(void *sa)
{
    struct spatial_audio_context *ctx = (struct spatial_audio_context *)sa;

    if (ctx->sensor) {
        space_motion_detect_close(ctx->sensor);
    }
#if SPATIAL_AUDIO_EFFECT_ENABLE
    if (ctx->effect) {
        spatial_audio_effect_close(ctx->effect);
    }
    if (ctx->calculator) {
        space_motion_calculator_close(ctx->calculator);
    }
#endif

#if TCFG_USER_TWS_ENABLE
    if (ctx->tws_conn) {
        spatial_tws_delete_connection(ctx->tws_conn);
    }
#endif

#if SPATIAL_AUDIO_EXPORT_DATA
    OS_SEM *sem = (OS_SEM *)malloc(sizeof(OS_SEM));
    os_sem_create(sem, 0);
    os_taskq_post_msg("ftask", 2, 1, (int)sem);
    os_sem_pend(sem, 0);
    free(sem);
    task_kill("ftask");
#endif
    free(ctx);
    spatial_hdl = NULL;
    audio_codec_clock_del(SPATIAL_EFFECT_MODE);
}

static int spatial_audio_remapping_data_handler(struct spatial_audio_context *ctx, void *data, int len)
{
    int pcm_frames = (len >> 2);
    s16 *pcm_buf = (s16 *)data;
    int i = 0;
    int tmp = 0;

    switch (ctx->mapping_channel) {
    case AUDIO_CH_L:
        for (i = 0; i < pcm_frames; i++) {
            pcm_buf[i] = pcm_buf[i * 2];
        }
        len /= 2;
        break;
    case AUDIO_CH_R:
        for (i = 0; i < pcm_frames; i++) {
            pcm_buf[i] = pcm_buf[i * 2 + 1];
        }
        len /= 2;
        break;
    case AUDIO_CH_MIX_MONO:
        for (i = 0; i < pcm_frames; i++) {
            tmp = pcm_buf[i * 2] + pcm_buf[i * 2 + 1];
            pcm_buf[i] = tmp / 2;
        }
        len /= 2;
        break;
    default:
        break;
    }

    return len;
}

int spatial_audio_space_data_read(void *data)
{
    int data_len = 0;
    if (spatial_hdl) {
        void *sensor = spatial_hdl->sensor;
        data_len = space_motion_data_read(sensor, data, 1024);
    }
    return data_len;
}

extern int aud_spatial_sensor_get_data_len();
extern int aud_spatial_sensor_data_read(s16 *data, int len);
static int spatial_audio_data_handler(struct spatial_audio_context *ctx, void *data, int len)
{
    int data_len = 0;
    if (ctx->sensor) {
#if TCFG_SENSOR_DATA_READ_IN_DEC_TASK
        data_len = aud_spatial_sensor_get_data_len();
        if (data_len) {
            data_len = aud_spatial_sensor_data_read(ctx->data, data_len);
        }

#else
#if !SPATIAL_AUDIO_EXPORT_DATA
        data_len = space_motion_data_read(ctx->sensor, ctx->data, 1024);
#endif /*SPATIAL_AUDIO_EXPORT_DATA*/
#endif /*TCFG_SENSOR_DATA_READ_IN_DEC_TASK*/
    }

    if (!ctx->calculator) {
        return 0;
    }

    int angle = 0;
    if (ctx->head_tracked == 0) {
        angle = 0;
    } else {
#if SPATIAL_AUDIO_EXPORT_DATA
        angle = space_motion_detect(ctx->calculator, (s16 *)ctx->space_fifo_buf, ctx->space_data_single_len);
#else
        angle = space_motion_detect(ctx->calculator, (s16 *)ctx->data, data_len);
#endif
    }

#if TCFG_USER_TWS_ENABLE
    if (ctx->tws_conn && data_len) {
        spatial_tws_audio_data_sync(ctx->tws_conn, (void *)&angle, sizeof(angle));
    }
#endif

    if (ctx->effect) {
        spatial_audio_effect_handler(ctx->effect, data, len);
#if (TCFG_SPATIAL_EFFECT_ONLINE_ENABLE)
        extern int set_bt_media_imu_angle(int angle);
#if TCFG_USER_TWS_ENABLE
        set_bt_media_imu_angle(ctx->tws_angle);
#else
        if (data_len) {
            set_bt_media_imu_angle(angle);
        }
#endif /*TCFG_USER_TWS_ENABLE*/
#endif /*TCFG_SPATIAL_EFFECT_ONLINE_ENABLE*/
        if (ctx->sensor) { /*处理一只耳机有传感器一只耳机没有传感器的情况*/
            /*有传感器的时候需要判读有传感器数据才更新角度到算法*/
            if (data_len) {
#if TCFG_USER_TWS_ENABLE
                spatial_audio_effect_params_setup(ctx->effect, ctx->tws_angle);
#else
                spatial_audio_effect_params_setup(ctx->effect, angle);
#endif
            }
        } else {
            /*没有传感器的时候，直接使用对耳角度*/
#if TCFG_USER_TWS_ENABLE
            spatial_audio_effect_params_setup(ctx->effect, ctx->tws_angle);
#else
            spatial_audio_effect_params_setup(ctx->effect, angle);
#endif
        }
    }

    return spatial_audio_remapping_data_handler(ctx, data, len);
}

void spatial_audio_head_tracked_en(struct spatial_audio_context *ctx, u8 en)
{
    printf("head_tracked = %d\n", en);
    ctx->head_tracked = en;
}

u8 get_spatial_audio_head_tracked(struct spatial_audio_context *ctx)
{
    printf("head_tracked = %d\n", ctx->head_tracked);
    return ctx->head_tracked;
}

int spatial_audio_filter(void *sa, void *data, int len)
{
    struct spatial_audio_context *ctx = (struct spatial_audio_context *)sa;

    if (!len) {
        return 0;
    }

#if SPATIAL_AUDIO_EXPORT_DATA
    if (ctx->export) {
        struct data_export_header header;
        ctx->audio_data_len += len;

        header.magic = 0x5A;
        header.ch = 0;
        header.seqn = ctx->audio_seqn++;
        header.len = len;
        header.timestamp = jiffies;
        header.crc = CRC16(data, len);
        header.total_len = ctx->audio_data_len;

        if (cbuf_is_write_able(&ctx->audio_cbuf, sizeof(header) + len)) {
            cbuf_write(&ctx->audio_cbuf, &header, sizeof(header));
            cbuf_write(&ctx->audio_cbuf, data, len);
        } else {
            printf("--- audio data export error --\n");
        }

        if (ctx->sensor) {
            int data_len = 1024;
            /*putchar('1');*/
            data_len = space_motion_data_read(ctx->sensor, ctx->space_fifo_buf, data_len);
            /*putchar('2');*/
            if (data_len) {
                ASSERT(data_len % 12 == 0, " , data_len : %d\n", data_len);
                ctx->space_data_len += data_len;
                ctx->space_data_single_len = data_len;

                header.magic = 0x5A;
                header.ch = 1;
                header.seqn = ctx->space_seqn++;
                header.len = data_len;
                header.timestamp = jiffies;
                header.crc = CRC16(ctx->space_fifo_buf, data_len);
                header.total_len = ctx->space_data_len;
#if 0
                if (cbuf_is_write_able(&ctx->space_cbuf, sizeof(header) + data_len)) {
                    cbuf_write(&ctx->space_cbuf, &header, sizeof(header));
                    cbuf_write(&ctx->space_cbuf, ctx->space_fifo_buf, data_len);
                } else {
                    printf("--- space data export error --\n");
                }
#else
                if (cbuf_is_write_able(&ctx->audio_cbuf, sizeof(header) + data_len)) {
                    cbuf_write(&ctx->audio_cbuf, &header, sizeof(header));
                    cbuf_write(&ctx->audio_cbuf, ctx->space_fifo_buf, data_len);
                    /*
                    s16 *print_data = ctx->space_fifo_buf;
                    data_len /= 2;
                    printf("[%d, %d, %d]\n", print_data[data_len - 3], print_data[data_len - 2], print_data[data_len - 1]);
                    */
                } else {
                    printf("--- space data export error --\n");
                }
#endif
            }
        }
#if SPATIAL_AUDIO_EFFECT_ENABLE	//增加处理后的数据
        spatial_audio_data_handler(ctx, data, len);
        header.magic = 0x5A;
        header.ch = 2;
        header.seqn = ctx->audio_out_seqn++;
        header.len = len;
        header.timestamp = jiffies;
        header.crc = CRC16(data, len);
        header.total_len = ctx->audio_data_len;

        if (cbuf_is_write_able(&ctx->audio_cbuf, sizeof(header) + len)) {
            cbuf_write(&ctx->audio_cbuf, &header, sizeof(header));
            cbuf_write(&ctx->audio_cbuf, data, len);
        } else {
            printf("--- audio data export error --\n");
        }
#endif/*SPATIAL_AUDIO_EFFECT_ENABLE*/
        os_taskq_post_msg("ftask", 1, 2);
    }
#elif SPATIAL_AUDIO_EFFECT_ENABLE
    return spatial_audio_data_handler(ctx, data, len);
#endif
    return len;
}

#if SPATIAL_AUDIO_EXPORT_DATA

static int spatial_audio_export_init(struct spatial_audio_context *ctx)
{
    int audio_buf_size = 40 * 1024;
    int space_buf_size = 8 * 1024;
    ctx->space_fifo_buf = (u8 *)malloc(1024);
    ctx->audio_buf = (u8 *)malloc(audio_buf_size);
    /*ctx->space_buf = (u8 *)malloc(space_buf_size);*/
    cbuf_init(&ctx->audio_cbuf, ctx->audio_buf, audio_buf_size);
    /*cbuf_init(&ctx->space_cbuf, ctx->space_buf, space_buf_size);*/

#if SPATIAL_AUDIO_EXPORT_MODE == 0
    ctx->audio_file = fopen("storage/sd0/C/spatial_audio/aud***.raw", "w+");
    /*ctx->space_file = fopen("storage/sd0/C/spatial_audio/spa***.raw", "w+"); */
#elif SPATIAL_AUDIO_EXPORT_MODE == 1
    aec_uart_init();
#endif
    ctx->export = 1;
    return 0;
}

static void spatial_audio_export_release(struct spatial_audio_context *ctx)
{
    ctx->export = 0;

    if (ctx->audio_buf) {
        free(ctx->audio_buf);
        ctx->audio_buf = NULL;
    }

    if (ctx->space_buf) {
        free(ctx->space_buf);
        ctx->space_buf = NULL;
    }

    if (ctx->space_fifo_buf) {
        free(ctx->space_fifo_buf);
        ctx->space_fifo_buf = NULL;
    }

#if SPATIAL_AUDIO_EXPORT_MODE == 0
    if (ctx->audio_file) {
        fclose(ctx->audio_file);
    }

    if (ctx->space_file) {
        fclose(ctx->space_file);
    }
#elif SPATIAL_AUDIO_EXPORT_MODE == 1
    aec_uart_close();
#endif
}

static int audio_data_export_handler(struct spatial_audio_context *ctx)
{
    int err = -EINVAL;
#if SPATIAL_AUDIO_EXPORT_MODE == 0
    if (ctx->audio_file) {
        if (cbuf_get_data_len(&ctx->audio_cbuf) >= 512) {
            fwrite(ctx->audio_file, cbuf_get_readptr(&ctx->audio_cbuf), 512);
            cbuf_read_updata(&ctx->audio_cbuf, 512);
            err = 0;
        } else {
            //TODO
        }
    }

#if 0
    if (ctx->space_file) {
        if (cbuf_get_data_len(&ctx->space_cbuf) >= 512) {
            fwrite(ctx->space_file, cbuf_get_readptr(&ctx->space_cbuf), 512);
            cbuf_read_updata(&ctx->space_cbuf, 512);
            err = 0;
        } else {
            //TODO
        }
    }
#endif
#elif SPATIAL_AUDIO_EXPORT_MODE == 1
    u8 send = 0;
    if (cbuf_get_data_len(&ctx->audio_cbuf) >= 512) {
        aec_uart_fill(0, cbuf_get_readptr(&ctx->audio_cbuf), 512);
        cbuf_read_updata(&ctx->audio_cbuf, 512);
        err = 0;
        send = 1;
    }

    if (!send && cbuf_get_data_len(&ctx->space_cbuf) >= 512) {
        aec_uart_fill(0, cbuf_get_readptr(&ctx->space_cbuf), 512);
        cbuf_read_updata(&ctx->space_cbuf, 512);
        err = 0;
        send = 1;
    }

    if (send) {
        putchar('t');
        aec_uart_write();
    }
#endif

    return err;
}

void audio_export_task(void *arg)
{
    int msg[16];
    int res;
    int pend_taskq = 1;
    struct spatial_audio_context *ctx = (struct spatial_audio_context *)arg;

    while (1) {
        if (pend_taskq) {
            res = os_taskq_pend("taskq", msg, ARRAY_SIZE(msg));
        } else {
            res = os_taskq_accept(ARRAY_SIZE(msg), msg);
        }

        if (res == OS_TASKQ) {
            switch (msg[1]) {
            case 0:
                spatial_audio_export_init(ctx);
                break;
            case 1:
                spatial_audio_export_release(ctx);
                os_sem_post((OS_SEM *)msg[2]);
                pend_taskq = 1;
                break;
            case 2: //音频数据
                break;
            case 3: //空间移动信息
                break;
            }
        }

        if (ctx->export) {
            if (0 != audio_data_export_handler(ctx)) {
                pend_taskq = 1;
            } else {
                pend_taskq = 0;
            }
        }

    }
}
#endif

#endif/*TCFG_AUDIO_SPATIAL_EFFECT_ENABLE*/