CODEC

简要说明

codec是音频编解码器，其具有音频采集（将模拟量转换为数字量）和音频播放功能（数字音频转换为模拟量），同时可以进行数据滤波、增益等。

接口描述

csi_codec_init

int32_t csi_codec_init(uint32_t idx);

• 功能描述:
  • 通过设备号初始化对应的codec实例，获取codec资源。
• 参数:
  • idx: 设备号。
• 返回值:
  • 0: 初始化成功 。
  • 其它: 错误码。

csi_codec_uninit

void csi_codec_uninit(uint32_t idx);

• 功能描述:
  • 反初始化codec实例，释放codec资源。
• 参数:
  • idx: 设备号。
• 返回值:
  • 无。

csi_codec_power_control

int32_t csi_codec_power_control(int32_t idx, csi_power_stat_e state);

• 功能描述:
  • codec 功率控制
• 参数:
  • idx: 设备号。
  • state: 功率模式，见csi_power_stat_e定义。
• 返回值:
  • 0：成功。
  • 其他：错误码

csi_power_stat_e:

csi_codec_input_open

int32_t csi_codec_input_open(codec_input_t *handle);

• 功能描述:
  • 开启codec输入通路（录音通路）。
• 参数:
  • handle: ocdec input句柄，用于配置与控制input通路，在通路开启时，为通路分配资源。见codec_input_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码

csi_codec_input_close

int32_t csi_codec_input_close(codec_input_t *handle);

• 功能描述:
  • 关闭codec输入通路（录音通路）。
• 参数:
  • handle: ocdec input句柄，用于配置与控制input通路，见codec_input_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码

codec_input_t：

codec_event_cb_t：

typedef void (*codec_event_cb_t)(codec_event_t event, void *arg);

• 功能描述:

  • codec事件回调函数，用户注册。

• 参数:

  • event: codec事件，见 codec_event_t定义。
  • arg: 用户注册回调参数，当回调函数触发时，会传入用户定义的的参数。

• 返回值:

  • 无。

codec_event_t

csi_codec_input_config

int32_t csi_codec_input_config(codec_input_t *handle, codec_input_config_t *config);

• 功能描述:
  • codec 输入通路初始化，需要在codec input 通路启动前调用，运行过程中不可配置。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • config: codec 输入通路配置参数，见 codec_input_config_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码

codec_input_config_t：

codec_sample_rate_e：

csi_codec_input_read

uint32_t csi_codec_input_read(codec_input_t *handle, uint8_t *buf, uint32_t length);

• 功能描述:
  • 读取codec 输入通路数据
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • buf: 读出数据的存储区。
  • length: 读取数据长度，单位bytes。
• 返回值:
  • 实际读取数据长度（单位bytes），例如：length=1000，缓存区内数据为100，则实际读取数据为100，返回值为100。

csi_codec_input_buf_avail

uint32_t csi_codec_input_buf_avail(codec_input_t *handle);

• 功能描述:
  • 获取codec input通路缓存区空闲区域大小。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
• 返回值:
  • codec input通路缓存区空闲空间，单位bytes。

csi_codec_input_buf_reset

int32_t csi_codec_input_buf_reset(codec_input_t *handle);

• 功能描述:
  • 复位codec input通路缓存区，复位后，缓存区的数据全部清空。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_start

int32_t csi_codec_input_start(codec_input_t *handle);

• 功能描述:
  • 启动codec input 通路，启动后，codec input开始采集数据。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_stop

int32_t csi_codec_input_stop(codec_input_t *handle);

• 功能描述:
  • 停止codec input 通路数据采集，调用stop后，当前缓存区内的数据全部被清空。若想停止采集并且数不被清空，可调用csi_codec_input_pause函数，见csi_codec_input_pause定义。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_pause

int32_t csi_codec_input_pause(codec_input_t *handle);

• 功能描述:
  • 暂停codec input 通路，codec input通路暂停后，数据停止采集，缓存区内数据不丢失，调用csi_codec_input_resume恢复采集后，数据续接。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_resume

int32_t csi_codec_input_resume(codec_input_t *handle);

• 功能描述:
  • 从暂停状态恢复codec input通路的数据采集。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_set_digital_gain

int32_t csi_codec_input_set_digital_gain(codec_input_t *handle, int32_t val);

• 功能描述:
  • 设置codec input 通路的数字增益。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_set_analog_gain

int32_t csi_codec_input_set_analog_gain(codec_input_t *handle, int32_t val);

• 功能描述:
  • 设置codec input 通路模拟增益。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_get_digital_gain

int32_t csi_codec_input_get_digital_gain(codec_input_t *handle, int32_t *val);

• 功能描述:
  • 获取当前codec input 通路数字增益值。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_get_analog_gain

int32_t csi_codec_input_get_analog_gain(codec_input_t *handle, int32_t *val);

• 功能描述:
  • 获取codec input 通路当前模拟增益。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_set_mixer_gain

int32_t csi_codec_input_set_mixer_gain(codec_input_t *handle, int32_t val);

• 功能描述:
  • 设置codec input 通路混频器增益。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_get_mixer_gain

int32_t csi_codec_input_get_mixer_gain(codec_input_t *handle, int32_t *val);

• 功能描述:
  • 获取codec input 通路当前混频器增益。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_input_mute

int32_t csi_codec_input_mute(codec_input_t *handle, int en);

• 功能描述:
  • 控制codec input通路静音，当使能静音时，input通路采集的数据无声音。
• 参数:
  • handle: ocdec input句柄，见codec_input_t定义。
  • en: 1:使能，0关闭。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_open

int32_t csi_codec_output_open(codec_output_t *handle);

• 功能描述:
  • 开启codec输输出通路（播放通路）。
• 参数:
  • handle: codec_output_t句柄，用于配置与控制output通路，在通路开启时，为通路分配资源。见codec_output_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码

csi_codec_output_close

int32_t csi_codec_output_close(codec_output_t *handle);

• 功能描述:
  • 关闭codec输输出通路（播放通路）。
• 参数:
  • handle: codec_output_t句柄。
• 返回值:
  • 0：成功。
  • 其他：错误码

codec_output_t：

csi_codec_output_config

int32_t csi_codec_output_config(codec_output_t *handle, codec_output_config_t *config);

• 功能描述:
  • codec 输除通路初始化，需要在codec output通路启动前调用，运行过程中不可配置。
• 参数:
  • handle: codec_output_t句柄，见codec_input_t定义。
  • config: codec 输出通路配置参数，见 codec_output_config_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码

codec_output_config_t：

codec_sample_rate_e：

csi_codec_output_write

uint32_t csi_codec_output_write(codec_output_t *handle, uint8_t *buf, uint32_t length);

• 功能描述:
  • 向codec 输出通路写入数据
• 参数:
  • handle: ocdec output句柄，见codec_input_t定义。
  • buf: 写入数据。
  • length: 写入数据长度，单位bytes。
• 返回值:
  • 实际写入数据长度（单位bytes），例如：length=1000bytes，缓存区空余100bytes，则实际写入数据为100bytes，返回值为100。

csi_codec_output_buf_avail

uint32_t csi_codec_output_buf_avail(codec_output_t *handle);

• 功能描述:
  • 获取codec output通路缓存区空闲区域大小。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
• 返回值:
  • codec output通路缓存区空闲空间，单位bytes。

csi_codec_output_buf_reset

int32_t csi_codec_output_buf_reset(codec_output_t *handle);

• 功能描述:
  • 复位codec input通路缓存区，复位后，缓存区的数据全部清空。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_start

int32_t csi_codec_output_start(codec_output_t *handle);

• 功能描述:
  • 启动codec output通路，启动后，codec output开始采集数据。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_stop

int32_t csi_codec_output_stop(codec_output_t *handle);

• 功能描述:
  • 停止codec output通路数据输出，调用stop后，当前缓存区内的数据全部被清空。若想停止输出并且数不被清空，可调用csi_codec_output_pause函数，见csi_codec_output_pause定义。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_pause

int32_t csi_codec_output_pause(codec_output_t *handle);

• 功能描述:
  • 暂停codec output通路，codec output通路暂停后，停止播放数据，缓存区内数据不丢失，调用csi_codec_output_resume恢复播放，数据续接。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_resume

int32_t csi_codec_output_resume(codec_output_t *handle);

• 功能描述:
  • 从暂停状态恢复codec output通路的数据输出。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_set_digital_left_gain

int32_t csi_codec_output_set_digital_left_gain(codec_output_t *handle, int32_t val);

• 功能描述:
  • 设置codec output通路的左声道数字增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_set_digital_right_gain

int32_t csi_codec_output_set_digital_right_gain(codec_output_t *handle, int32_t val);

• 功能描述:
  • 设置codec output通路的右声道数字增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_set_analog_left_gain

int32_t csi_codec_output_set_analog_left_gain(codec_output_t *handle, int32_t val);

• 功能描述:
  • 设置codec output通路左声道模拟增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_set_analog_right_gain

int32_t csi_codec_output_set_analog_right_gain(codec_output_t *handle, int32_t val);

• 功能描述:
  • 设置codec output通路右声道模拟增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_get_digital_left_gain

int32_t csi_codec_output_get_digital_left_gain(codec_output_t *handle, int32_t *val);

• 功能描述:
  • 获取当前codec output通路左声道数字增益值。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_get_digital_right_gain

int32_t csi_codec_output_get_digital_right_gain(codec_output_t *handle, int32_t *val);

• 功能描述:
  • 获取当前codec output通路右声道数字增益值。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_get_analog_left_gain

int32_t csi_codec_output_get_analog_left_gain(codec_output_t *handle, int32_t *val);

• 功能描述:
  • 获取codec output通路当前左声道模拟增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_get_analog_right_gain

int32_t csi_codec_output_get_analog_right_gain(codec_output_t *handle, int32_t *val);

• 功能描述:
  • 获取codec output通路当前右声道模拟增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_set_mixer_left_gain

int32_t csi_codec_output_set_mixer_left_gain(codec_output_t *handle, int32_t val);

• 功能描述:
  • 设置codec output通路混频器左声道增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_set_mixer_right_gain

int32_t csi_codec_output_set_mixer_right_gain(codec_output_t *handle, int32_t val);

• 功能描述:
  • 设置codec output通路混频器右声道增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_get_mixer_left_gain

int32_t csi_codec_output_get_mixer_left_gain(codec_output_t *handle, int32_t *val);

• 功能描述:
  • 获取codec output通路当前混频器左声道增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_get_mixer_right_gain

int32_t csi_codec_output_get_mixer_right_gain(codec_output_t *handle, int32_t *val);

• 功能描述:
  • 获取codec output通路当前混频器右声道增益。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • val: 存储增益数值
• 返回值:
  • 0：成功。
  • 其他：错误码。

csi_codec_output_mute

int32_t csi_codec_output_mute(codec_output_t *handle, int en);

• 功能描述:
  • 控制codec output通路静音，当使能静音时，output通路播放无声音输出。
• 参数:
  • handle: ocdec output句柄，见codec_output_t定义。
  • en: 1:使能，0关闭。
• 返回值:
  • 0：成功。
  • 其他：错误码。

示例：

/*
 * Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved.
 *
 * 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.
 */

/******************************************************************************
 * @file     main.c
 * @brief    CSI Source File for main
 * @version  V1.0
 * @date     12. June 2018
 ******************************************************************************/

#include <stdint.h>
#include <stdio.h>
#include <csi_kernel.h>
#include "pinmux.h"
#include "drv_gpio.h"
#include "pin.h"
#include "drv_codec.h"

static void speaker_init()
{
    drv_pinmux_config(EXAMPLE_CODEC_PA_CTRL_PIN, EXAMPLE_CODEC_PA_CTRL_PIN_FUNC);
    gpio_pin_handle_t pgpio_pin_handle = csi_gpio_pin_initialize(PB22, NULL);
    csi_gpio_pin_config_mode(pgpio_pin_handle, GPIO_MODE_PULLNONE);
    csi_gpio_pin_config_direction(pgpio_pin_handle, GPIO_DIRECTION_OUTPUT);
    csi_gpio_pin_write(pgpio_pin_handle, true);
}

static k_sem_handle_t player_sem;
static void player_cb(codec_event_t event, void *arg)
{

    if (event == CODEC_EVENT_WRITE_BUFFER_EMPTY) {
        printf("empty\n");
    }

    csi_kernel_sem_post(player_sem);
}


#define PLAYER_BUF_SIZE (1024 * 10)
static uint8_t player_buf[PLAYER_BUF_SIZE];
static codec_output_t output_handle;

static int player_init()
{
    player_sem = csi_kernel_sem_new(1, 0);
    if (player_sem == NULL) {
        return -1;
    }

    output_handle.buf = player_buf;
    output_handle.buf_size = PLAYER_BUF_SIZE;
    output_handle.cb = player_cb;
    output_handle.cb_arg = NULL;
    output_handle.ch_idx = 0;
    output_handle.codec_idx = 0;
    output_handle.period = 4096;

    int ret = csi_codec_output_open(&output_handle);
    if (ret != 0) {
        printf("codec output open error\n");
        return -1;
    }

    codec_output_config_t config;
    config.bit_width = 16;
    config.mono_mode_en = 0;
    config.sample_rate = 48000;

    ret = csi_codec_output_config(&output_handle, &config);
    if (ret != 0) {
        printf("output config error\n");
        return -1;
    }

    csi_codec_output_set_mixer_left_gain(&output_handle, -20);
    csi_codec_output_set_mixer_right_gain(&output_handle, -20);

    return 0;
}

extern unsigned char  voice_file[];
extern uint32_t voice_len;

static void play_sound()
{
    int ret = -1;

    csi_codec_output_start(&output_handle);
    printf("output start\n");

    while(1) {
        uint32_t tx_data_len = 150*1024;
        uint8_t *tx_data = voice_file;
        uint32_t ret_len = 0;
        while(tx_data_len) {
            ret_len = csi_codec_output_write(&output_handle, (uint8_t *)tx_data, tx_data_len);
            tx_data_len -= ret_len;
            tx_data += ret_len;
            csi_kernel_sem_wait(player_sem, -1);
        }
    }

    printf("player end\n");
    csi_codec_output_stop(&output_handle);

    ret = csi_codec_output_close(&output_handle);
    if (ret != 0) {
        printf("2 codec output close error\n");
        return;
    }

}

void player_test()
{
    if (player_init() == -1) {
        printf("player init error\n");
        return;
    }

    printf("player init end\n");
    play_sound();
}


#define RECORD_BUF_SIZE (1024 * 100)
static uint8_t receive_buf[RECORD_BUF_SIZE];
static codec_input_t input_handle;

#define RX_BUF_SIZE (10 * 1024)
static uint8_t rx_buf[RX_BUF_SIZE];

static k_sem_handle_t record_sem;
static void record_cb(codec_event_t event, void *arg)
{

    if (event == CODEC_EVENT_WRITE_BUFFER_EMPTY) {
        printf("empty\n");
    }

    csi_kernel_sem_post(record_sem);
}

static int record_init()
{
    record_sem = csi_kernel_sem_new(1, 0);
    if (record_sem == NULL) {
        return -1;
    }

    input_handle.buf = rx_buf;
    input_handle.buf_size = RX_BUF_SIZE;
    input_handle.cb = record_cb;
    input_handle.cb_arg = NULL;
    input_handle.ch_idx = 0;
    input_handle.codec_idx = 0;
    input_handle.period = 2560;

    int ret = csi_codec_input_open(&input_handle);
    if (ret != 0) {
        printf("codec input open error\n");
        return -1;
    }

    codec_input_config_t config;
    config.bit_width = 16;
    config.channel_num = 1;
    config.sample_rate = 16000;
    ret = csi_codec_input_config(&input_handle, &config);
    if (ret != 0) {
        printf("codec input config error\n");
        return -1;
    }

    csi_codec_input_set_analog_gain(&input_handle, 4);
    return 0;
}

void record_teset()
{
    int ret = record_init();
    if (ret != 0) {
        printf("record init error\n");
        return;
    }

    printf("record init end\n");

    uint32_t rx_data_len = RECORD_BUF_SIZE;
    uint8_t *rx_buf = (uint8_t *)receive_buf;
    uint32_t ret_len = 0;
    csi_codec_input_start(&input_handle);

    while(rx_data_len) {
        csi_kernel_sem_wait(record_sem, -1);
        ret_len = csi_codec_input_read(&input_handle, rx_buf, rx_data_len);
        rx_data_len -= ret_len;
        rx_buf+= ret_len;
    }

    printf("record end\n");
}

static uint8_t receive_buf1[RECORD_BUF_SIZE];
static codec_input_t input_handle1;
static uint8_t rx_buf1[RX_BUF_SIZE];
static k_sem_handle_t record_ref_sem;

static void record_ref_cb(codec_event_t event, void *arg)
{

    if (event == CODEC_EVENT_WRITE_BUFFER_EMPTY) {
        printf("empty\n");
    }

    csi_kernel_sem_post(record_ref_sem);
}

static int record_ref_init()
{
    record_ref_sem = csi_kernel_sem_new(1, 0);
    if (record_ref_sem == NULL) {
        return -1;
    }

    input_handle1.buf = rx_buf1;
    input_handle1.buf_size = RX_BUF_SIZE;
    input_handle1.cb = record_ref_cb;
    input_handle1.cb_arg = NULL;
    input_handle1.ch_idx = 2;
    input_handle1.codec_idx = 0;
    input_handle1.period = 2560;

    int ret = csi_codec_input_open(&input_handle1);
    if (ret != 0) {
        printf("codec input open error\n");
        return -1;
    }

    codec_input_config_t config;
    config.bit_width = 16;
    config.channel_num = 1;
    config.sample_rate = 16000;
    ret = csi_codec_input_config(&input_handle1, &config);
    if (ret != 0) {
        printf("codec input config error\n");
        return -1;
    }

    csi_codec_input_set_analog_gain(&input_handle1, 4);

    return 0;
}

void record_ref_teset()
{
    int ret = record_ref_init();
    if (ret != 0) {
        printf("record ref init error\n");
        return;
    }

    printf("record ref init end\n");

    uint32_t rx_data_len = RECORD_BUF_SIZE;
    uint8_t *rx_buf = (uint8_t *)receive_buf1;
    uint32_t ret_len = 0;
    csi_codec_input_start(&input_handle1);

    while(rx_data_len) {
        csi_kernel_sem_wait(record_ref_sem, -1);
        ret_len = csi_codec_input_read(&input_handle1, rx_buf, rx_data_len);
        rx_data_len -= ret_len;
        rx_buf+= ret_len;
    }

    printf("record ref end\n");
}

#define EXAMPLE_PRIO    5
#define EXAMPLE_TASK_STK_SIZE 1024

k_task_handle_t player_task;
k_task_handle_t record_task;
k_task_handle_t ref_record_task;

void player(void)
{
    player_test();
}

void record()
{
    record_teset();
}

void ref_record()
{
    record_ref_teset();
}

int main(void)
{
    csi_kernel_init();

    speaker_init();
    int32_t ret = csi_codec_init(0);
    if (ret != 0) {
        printf("codec init error\n");
    }

    printf("codec init end\n");

    csi_kernel_task_new((k_task_entry_t)player, "player",
                         0, EXAMPLE_PRIO, 0, 0, EXAMPLE_TASK_STK_SIZE, &player_task);


    csi_kernel_task_new((k_task_entry_t)record, "record",
                         0, EXAMPLE_PRIO, 0, 0, EXAMPLE_TASK_STK_SIZE, &record_task);


    csi_kernel_task_new((k_task_entry_t)ref_record, "ref_record",
                         0, EXAMPLE_PRIO, 0, 0, EXAMPLE_TASK_STK_SIZE, &ref_record_task);



    csi_kernel_start();

    return 0;
}