/* * File : audio.c * This file is part of RT-Thread RTOS * COPYRIGHT (C) 2006 - 2017, RT-Thread Development Team * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Change Logs: * Date Author Notes * 2017-05-09 Urey first version */ #include <stdio.h> #include <rthw.h> #include <rtthread.h> #include <rtdevice.h> #include <drivers/audio.h> #define AUDIO_DEBUG 0 #if AUDIO_DEBUG #define AUDIO_DBG(...) printf("[AUDIO]:"),printf(__VA_ARGS__) #else #define AUDIO_DBG(...) #endif static rt_err_t _audio_send_replay_frame(struct rt_audio_device *audio) { rt_err_t result = RT_EOK; rt_base_t level; struct rt_audio_frame frame; RT_ASSERT(audio != RT_NULL); //check repaly queue is empty if (rt_data_queue_peak(&audio->replay->queue, &frame.data_ptr, &frame.data_size) != RT_EOK) { AUDIO_DBG("TX queue is empty\n"); result = -RT_EEMPTY; level = rt_hw_interrupt_disable(); audio->replay->activated = RT_FALSE; rt_hw_interrupt_enable(level); goto _exit; } if (audio->ops->transmit != RT_NULL) { AUDIO_DBG("audio transmit...\n"); if (audio->ops->transmit(audio, frame.data_ptr, RT_NULL, frame.data_size) != frame.data_size) { result = -RT_EBUSY; goto _exit; } } //pop the head frame... rt_data_queue_pop(&audio->replay->queue, &frame.data_ptr, &frame.data_size, RT_WAITING_FOREVER); _exit: return result; } static rt_err_t _audio_flush_replay_frame(struct rt_audio_device *audio) { struct rt_audio_frame frame; if (audio->replay == RT_NULL) return -RT_EIO; while (rt_data_queue_peak(&audio->replay->queue, &frame.data_ptr, &frame.data_size) == RT_EOK) { //pop the head frame... rt_data_queue_pop(&audio->replay->queue, &frame.data_ptr, &frame.data_size, RT_WAITING_FOREVER); /* notify transmitted complete. */ if (audio->parent.tx_complete != RT_NULL) audio->parent.tx_complete(&audio->parent, (void *) frame.data_ptr); } return RT_EOK; } static rt_err_t _audio_dev_init(struct rt_device *dev) { rt_err_t result = RT_EOK; struct rt_audio_device *audio; RT_ASSERT(dev != RT_NULL); audio = (struct rt_audio_device *) dev; /* initialize replay & record */ audio->replay = RT_NULL; audio->record = RT_NULL; /* apply configuration */ if (audio->ops->init) result = audio->ops->init(audio); return result; } static rt_err_t _audio_dev_open(struct rt_device *dev, rt_uint16_t oflag) { rt_err_t result = RT_EOK; rt_base_t level; struct rt_audio_device *audio; RT_ASSERT(dev != RT_NULL); audio = (struct rt_audio_device *) dev; /* check device flag with the open flag */ if ((oflag & RT_DEVICE_OFLAG_RDONLY) && !(dev->flag & RT_DEVICE_FLAG_RDONLY)) return -RT_EIO; if ((oflag & RT_DEVICE_OFLAG_WRONLY) && !(dev->flag & RT_DEVICE_FLAG_WRONLY)) return -RT_EIO; /* get open flags */ dev->open_flag = oflag & 0xff; /* initialize the Rx/Tx structure according to open flag */ if (oflag & RT_DEVICE_OFLAG_WRONLY) { AUDIO_DBG("open audio device ,oflag = %x\n",oflag); if (audio->replay == RT_NULL) { struct rt_audio_replay *replay = (struct rt_audio_replay *) rt_malloc(sizeof(struct rt_audio_replay)); if (replay == RT_NULL) { AUDIO_DBG("request memory for replay error\n"); return -RT_ENOMEM; } //init queue for audio replay rt_data_queue_init(&replay->queue, CFG_AUDIO_REPLAY_QUEUE_COUNT, CFG_AUDIO_REPLAY_QUEUE_COUNT / 2, RT_NULL); replay->activated = RT_FALSE; audio->replay = replay; } dev->open_flag |= RT_DEVICE_OFLAG_WRONLY; } if (oflag & RT_DEVICE_OFLAG_RDONLY) { if (audio->record == RT_NULL) { struct rt_audio_record *record = (struct rt_audio_record *) rt_malloc(sizeof(struct rt_audio_record)); if (record == RT_NULL) { AUDIO_DBG("request memory for record error\n"); return -RT_ENOMEM; } //init pipe for record { rt_size_t size = CFG_AUDIO_RECORD_PIPE_SIZE; rt_uint8_t *buf = rt_malloc(CFG_AUDIO_RECORD_PIPE_SIZE); if (buf == RT_NULL) { rt_free(record); AUDIO_DBG("request pipe memory error\n"); return -RT_ENOMEM; } rt_pipe_init(&record->pipe, "recpipe", RT_PIPE_FLAG_FORCE_WR | RT_PIPE_FLAG_BLOCK_RD, buf, CFG_AUDIO_RECORD_PIPE_SIZE); } record->activated = RT_FALSE; audio->record = record; } //open record pipe if (audio->record != RT_NULL) { rt_device_open(RT_DEVICE(&audio->record->pipe), RT_DEVICE_OFLAG_RDONLY); } dev->open_flag |= RT_DEVICE_OFLAG_RDONLY; } return RT_EOK; } static rt_err_t _audio_dev_close(struct rt_device *dev) { struct rt_audio_device *audio; RT_ASSERT(dev != RT_NULL); audio = (struct rt_audio_device *) dev; //shutdown the lower device if (audio->ops->shutdown != RT_NULL) audio->ops->shutdown(audio); if (dev->open_flag & RT_DEVICE_OFLAG_WRONLY) { struct rt_audio_frame frame; //stop replay stream audio->ops->stop(audio, AUDIO_STREAM_REPLAY); //flush all frame while (rt_data_queue_peak(&audio->replay->queue, &frame.data_ptr, &frame.data_size) == RT_EOK) { //pop the head frame... rt_data_queue_pop(&audio->replay->queue, &frame.data_ptr, &frame.data_size, RT_WAITING_FOREVER); /* notify transmitted complete. */ if (audio->parent.tx_complete != RT_NULL) audio->parent.tx_complete(&audio->parent, (void *) frame.data_ptr); } dev->open_flag &= ~RT_DEVICE_OFLAG_WRONLY; } if (dev->open_flag & RT_DEVICE_OFLAG_RDONLY) { //stop record stream audio->ops->stop(audio, AUDIO_STREAM_RECORD); //close record pipe if (audio->record != RT_NULL) rt_device_close(RT_DEVICE(&audio->record->pipe)); dev->open_flag &= ~RT_DEVICE_OFLAG_RDONLY; } return RT_EOK; } static rt_size_t _audio_dev_read(struct rt_device *dev, rt_off_t pos, void *buffer, rt_size_t size) { struct rt_audio_device *audio; RT_ASSERT(dev != RT_NULL); audio = (struct rt_audio_device *) dev; if (!(dev->open_flag & RT_DEVICE_OFLAG_RDONLY) || (audio->record == RT_NULL)) return 0; return rt_device_read(RT_DEVICE(&audio->record->pipe), pos, buffer, size); } static rt_size_t _audio_dev_write(struct rt_device *dev, rt_off_t pos, const void *buffer, rt_size_t size) { rt_err_t result = RT_EOK; rt_base_t level; struct rt_audio_device *audio; RT_ASSERT(dev != RT_NULL); audio = (struct rt_audio_device *) dev; if (!(dev->open_flag & RT_DEVICE_OFLAG_WRONLY) || (audio->replay == RT_NULL)) return 0; AUDIO_DBG("audio write : pos = %d,buffer = %x,size = %d\n",pos,(rt_uint32_t)buffer,size); //push a new frame to tx queue { result = rt_data_queue_push(&audio->replay->queue, buffer, size, RT_WAITING_FOREVER); if (result != RT_EOK) { AUDIO_DBG("TX frame queue push error\n"); rt_set_errno(-RT_EFULL); return 0; } } //check tx state... level = rt_hw_interrupt_disable(); if (audio->replay->activated != RT_TRUE) { audio->replay->activated = RT_TRUE; rt_hw_interrupt_enable(level); _audio_send_replay_frame(audio); } return size; } static rt_err_t _audio_dev_control(struct rt_device *dev, int cmd, void *args) { rt_err_t result = RT_EOK; struct rt_audio_device *audio; RT_ASSERT(dev != RT_NULL); audio = (struct rt_audio_device *) dev; //dev stat... switch (cmd) { case AUDIO_CTL_GETCAPS: { struct rt_audio_caps *caps = (struct rt_audio_caps *) args; AUDIO_DBG("AUDIO_CTL_GETCAPS: main_type = %d,sub_type = %d\n",caps->main_type,caps->sub_type); if (audio->ops->getcaps != RT_NULL) { result = audio->ops->getcaps(audio, caps); } } break; case AUDIO_CTL_CONFIGURE: { struct rt_audio_caps *caps = (struct rt_audio_caps *) args; AUDIO_DBG("AUDIO_CTL_CONFIGURE: main_type = %d,sub_type = %d\n",caps->main_type,caps->sub_type); if (audio->ops->configure != RT_NULL) { result = audio->ops->configure(audio, caps); } } break; case AUDIO_CTL_SHUTDOWN: { AUDIO_DBG("AUDIO_CTL_SHUTDOWN\n"); if (audio->ops->shutdown != RT_NULL) result = audio->ops->shutdown(audio); //flush replay frame... _audio_flush_replay_frame(audio); } break; case AUDIO_CTL_START: { int stream = *(int *) args; AUDIO_DBG("AUDIO_CTL_START: stream = %d\n",stream); if (audio->ops->start != RT_NULL) result = audio->ops->start(audio, stream); } break; case AUDIO_CTL_STOP: { int stream = *(int *) args; AUDIO_DBG("AUDIO_CTL_STOP: stream = %d\n",stream); if (audio->ops->start != RT_NULL) result = audio->ops->stop(audio, stream); if (stream == AUDIO_STREAM_REPLAY) { _audio_flush_replay_frame(audio); } } break; case AUDIO_CTL_PAUSE: { int stream = *(int *) args; AUDIO_DBG("AUDIO_CTL_PAUSE: stream = %d\n",stream); if (audio->ops->start != RT_NULL) result = audio->ops->suspend(audio, stream); } break; case AUDIO_CTL_RESUME: { int stream = *(int *) args; AUDIO_DBG("AUDIO_CTL_RESUME: stream = %d\n",stream); if (audio->ops->start != RT_NULL) result = audio->ops->resume(audio, stream); //resume tx frame... if (stream == AUDIO_STREAM_REPLAY) _audio_send_replay_frame(audio); } break; case AUDIO_CTL_ALLOCBUFFER: { struct rt_audio_buf_desc *desc = (struct rt_audio_buf_desc *) args; if (desc) { desc->data_size = AUDIO_DEVICE_DECODE_MP_BLOCK_SZ * 2; desc->data_ptr = rt_mp_alloc(&audio->mp, RT_WAITING_FOREVER); result = RT_EOK; } else result = -RT_EIO; } break; case AUDIO_CTL_FREEBUFFER: { rt_uint8_t *data_ptr = (rt_uint8_t *) args; if (data_ptr) rt_mp_free(data_ptr); } break; default: result = audio->ops->control(audio, cmd, args); break; } return result; } rt_err_t rt_audio_register(struct rt_audio_device *audio, const char *name, rt_uint32_t flag, void *data) { struct rt_device *device; RT_ASSERT(audio != RT_NULL); device = &(audio->parent); device->type = RT_Device_Class_Sound; device->rx_indicate = RT_NULL; device->tx_complete = RT_NULL; device->init = _audio_dev_init; device->open = _audio_dev_open; device->close = _audio_dev_close; device->read = _audio_dev_read; device->write = _audio_dev_write; device->control = _audio_dev_control; device->user_data = data; //init memory pool for replay { rt_uint8_t *mempool = rt_malloc(AUDIO_DEVICE_DECODE_MP_SZ); rt_mp_init(&audio->mp, "adu_mp", mempool, AUDIO_DEVICE_DECODE_MP_SZ, AUDIO_DEVICE_DECODE_MP_BLOCK_SZ * 2); } /* register a character device */ return rt_device_register(device, name, flag | RT_DEVICE_FLAG_REMOVABLE); } int rt_audio_samplerate_to_speed(rt_uint32_t bitValue) { int speed = 0; switch (bitValue) { case AUDIO_SAMP_RATE_8K: speed = 8000; break; case AUDIO_SAMP_RATE_11K: speed = 11052; break; case AUDIO_SAMP_RATE_16K: speed = 16000; break; case AUDIO_SAMP_RATE_22K: speed = 22050; break; case AUDIO_SAMP_RATE_32K: speed = 32000; break; case AUDIO_SAMP_RATE_44K: speed = 44100; break; case AUDIO_SAMP_RATE_48K: speed = 48000; break; case AUDIO_SAMP_RATE_96K: speed = 96000; break; case AUDIO_SAMP_RATE_128K: speed = 128000; break; case AUDIO_SAMP_RATE_160K: speed = 160000; break; case AUDIO_SAMP_RATE_172K: speed = 176400; break; case AUDIO_SAMP_RATE_192K: speed = 192000; break; default: break; } return speed; } rt_uint32_t rt_audio_format_to_bits(rt_uint32_t format) { switch (format) { case AUDIO_FMT_PCM_U8: case AUDIO_FMT_PCM_S8: return 8; case AUDIO_FMT_PCM_S16_LE: case AUDIO_FMT_PCM_S16_BE: case AUDIO_FMT_PCM_U16_LE: case AUDIO_FMT_PCM_U16_BE: return 16; default: return 32; }; } void rt_audio_tx_complete(struct rt_audio_device *audio, rt_uint8_t *pbuf) { rt_err_t result; AUDIO_DBG("audio tx complete ptr=%x...\n",(rt_uint32_t)pbuf); //try to send all frame do { result = _audio_send_replay_frame(audio); } while (result == RT_EOK); /* notify transmitted complete. */ if (audio->parent.tx_complete != RT_NULL) audio->parent.tx_complete(&audio->parent, (void *) pbuf); } void rt_audio_rx_done(struct rt_audio_device *audio, rt_uint8_t *pbuf, rt_size_t len) { rt_err_t result = RT_EOK; //save data to record pipe rt_device_write(RT_DEVICE(RT_DEVICE(&audio->record->pipe)), 0, pbuf, len); /* invoke callback */ if (audio->parent.rx_indicate != RT_NULL) audio->parent.rx_indicate(&audio->parent, len); }