RTT音频框架和I2S驱动求助

发布于 2019-02-14 14:21:29 浏览：4172 订阅该版

12 个回答

XQQ 2019-02-14

这家伙很懒，什么也没写！

水清沙白 2019-02-14

这家伙很懒，什么也没写！

什么问题，播放MP3需要有MP3解码库的支持，RT-Thread的音频处理逻辑为首先初始化一块内存池(如其中包含4个小块)，应用申内存，然后填入解码数据，驱动开始播放，播放完成(DMA中断或者I2S缓冲区空中断)时Free内存。

可参考原子stm32f429 阿波罗的audio驱动，[https://github.com/RT-Thread/rt-thread/tree/master/bsp/stm32f429-apollo/drivers/audio](https://github.com/RT-Thread/rt-thread/tree/master/bsp/stm32f429-apollo/drivers/audio)

应用层播放wav文件的示例如下：

```
/*
 * Copyright (c) 2006-2018, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2018-11-15     ZeroFree     first implementation
 */

#include <rtthread.h>
#include <rtdevice.h>
#include <finsh.h>

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#define DBG_ENABLE
#define DBG_LEVEL DBG_LOG
#define DBG_COLOR
#define DBG_SECTION_NAME    "Sound"
#include <rtdbg.h>

#define SOUND_DEVICE_DECODE_MP_SZ  (4096)
#define SOUND_DEVICE_DECODE_MP_CNT (2)

#define BUFSZ   (SOUND_DEVICE_DECODE_MP_SZ / 2)

struct RIFF_HEADER_DEF
{
    char riff_id[4];     // 'R','I','F','F'
    uint32_t riff_size;
    char riff_format[4]; // 'W','A','V','E'
};

struct WAVE_FORMAT_DEF
{
    uint16_t FormatTag;
    uint16_t Channels;
    uint32_t SamplesPerSec;
    uint32_t AvgBytesPerSec;
    uint16_t BlockAlign;
    uint16_t BitsPerSample;
};

struct FMT_BLOCK_DEF
{
    char fmt_id[4];    // 'f','m','t',' '
    uint32_t fmt_size;
    struct WAVE_FORMAT_DEF wav_format;
};

struct DATA_BLOCK_DEF
{
    char data_id[4];     // 'R','I','F','F'
    uint32_t data_size;
};

struct wav_info
{
    struct RIFF_HEADER_DEF header;
    struct FMT_BLOCK_DEF   fmt_block;
    struct DATA_BLOCK_DEF  data_block;
};

enum SOUND_DEVICE_STATE
{
    SOUND_DEVICE_IDLE,
    SOUND_DEVICE_PLAYBACK,
    SOUND_DEVICE_CLOSE,
};

struct wav_player
{
    struct rt_device *snd;
    struct rt_mempool *mp;
    char *uri;

int state;
};

static struct wav_player *player = RT_NULL;

static rt_err_t sound_device_write_done(struct rt_device *device, void *ptr)
{
    if (ptr == RT_NULL)
    {
        LOG_E("device buf_release NULL\n");
        return -RT_ERROR;
    }
    // LOG_D("free %p", ptr);
    rt_mp_free(ptr);
    return RT_EOK;
}

static int wav_player_init(void)
{
    int result;
    if (player != RT_NULL)
        return RT_EOK;

player = rt_malloc(sizeof(struct wav_player));
    if (player == RT_NULL)
    {
        LOG_E("Malloc memory for wav player failed!");
        result = -RT_ENOMEM;
        goto __exit;
    }
    memset(player, 0, sizeof(struct wav_player));

player->mp = rt_mp_create("adbuf", SOUND_DEVICE_DECODE_MP_CNT, SOUND_DEVICE_DECODE_MP_SZ);
    if (player->mp == RT_NULL)
    {
        LOG_E("Malloc memory for audio mempool failed!");
        result = -RT_ENOMEM;
        goto __exit;
    }

/* find sound device */
    player->snd = rt_device_find("sound");
    if (player->snd == NULL)
    {
        LOG_E("sound device not found \n");
        result = -RT_ERROR;
        goto __exit;
    }

player->state = SOUND_DEVICE_IDLE;
    /* set tx complete call back function */
    rt_device_set_tx_complete(player->snd, sound_device_write_done);

return RT_EOK;

__exit:
    if (player->mp != RT_NULL)
    {
        rt_mp_delete(player->mp);
        player->mp = RT_NULL;
    }

if (player != RT_NULL)
    {
        rt_free(player);
        player = RT_NULL;
    }

return result;
}

static int wav_player_play(char *uri)
{
    int samplerate;
    FILE *fp = NULL;
    uint16_t *buffer = NULL;
    struct wav_info *info = NULL;

fp = fopen(uri, "rb");
    if (!fp)
    {
        LOG_E("open file failed!\n");
        goto __exit;
    }

info = (struct wav_info *) malloc(sizeof(*info));
    if (!info) goto __exit;

if (fread(&(info->header),     sizeof(struct RIFF_HEADER_DEF), 1, fp) != 1) goto __exit;
    if (fread(&(info->fmt_block),  sizeof(struct FMT_BLOCK_DEF),   1, fp) != 1) goto __exit;
    if (fread(&(info->data_block), sizeof(struct DATA_BLOCK_DEF),  1, fp) != 1) goto __exit;

LOG_I("wav information:");
    LOG_I("samplerate %d", info->fmt_block.wav_format.SamplesPerSec);
    LOG_I("channel %d", info->fmt_block.wav_format.Channels);

samplerate = info->fmt_block.wav_format.SamplesPerSec;
    player->state = SOUND_DEVICE_PLAYBACK;
    rt_device_open(player->snd, RT_DEVICE_OFLAG_WRONLY);
    rt_device_control(player->snd, CODEC_CMD_SAMPLERATE, &samplerate);

while (!feof(fp))
    {
        int length;

buffer = rt_mp_alloc(player->mp, RT_WAITING_FOREVER);
        // LOG_D("malloc %p", buffer);
        length = fread(buffer, 1, BUFSZ, fp);
        if (length)
        {
            if (info->fmt_block.wav_format.Channels == 1)
            {
                /* extend to stereo channels */
                int index;
                uint16_t *ptr;

ptr = (uint16_t *)((uint8_t *)buffer + BUFSZ * 2);
                for (index = 1; index < BUFSZ / 2; index ++)
                {
                    *ptr = *(ptr - 1) = buffer[BUFSZ / 2 - index];
                    ptr -= 2;
                }

length = length * 2;
            }

rt_device_write(player->snd, 0, (uint8_t *)buffer, length);
        }
        else
        {
            // LOG_D("read end %p", buffer);
            rt_mp_free((uint8_t *)buffer);
            break;
        }

if (player->state == SOUND_DEVICE_CLOSE)
        {
            break;
        }
    }
    rt_thread_mdelay(100);
    rt_device_close(player->snd);
    player->state = SOUND_DEVICE_CLOSE;
    if (fp) fclose(fp);
    if (info) free(info);

return RT_EOK;

__exit:
    if (fp) fclose(fp);
    if (info) free(info);
    return -RT_ERROR;
}

static void wav_player_stop(void)
{
    player->state = SOUND_DEVICE_CLOSE;
}

void wavplay_thread_entry(void *parameter)
{
    wav_player_play(player->uri);
}

int wavplay(int argc, char **argv)
{
    int result;
    rt_thread_t tid = RT_NULL;

if (argc != 2)
    {
        rt_kprintf("Usage:\n");
        rt_kprintf("wavplay song.wav\n");
        return -RT_ERROR;
    }

result = wav_player_init();
    if (result == RT_EOK)
    {
        if (player->state == SOUND_DEVICE_PLAYBACK)
        {
            wav_player_stop();
            rt_thread_mdelay(100);
        }

if (player->uri)
            rt_free(player->uri);
        player->uri = rt_strdup(argv[1]);
        tid = rt_thread_create("wayplay",
                               wavplay_thread_entry,
                               RT_NULL,
                               1024 * 8,
                               22,
                               10);
        if (tid != RT_NULL)
            rt_thread_startup(tid);

return RT_EOK;
    }

return -RT_ERROR;
}
MSH_CMD_EXPORT(wavplay, wavplay song.wav); // wavplay 1.wav

void wavstop(void)
{
    wav_player_stop();
}
MSH_CMD_EXPORT(wavstop, stop wav play);

```