Mirrors_Framework/nuttx
1
0
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2026-05-20 20:44:39 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

cxd56: add initial audio SRC implementation

Browse Source 
Add basic sample rate conversion to the CXD56 Spresense audio
driver using libsamplerate. Currently conversion is only done
during playback and all output is fixed at 48 kHz.

Issues:
- 16 kHz SRC has glitches (unless data dump is enabled)
- 44.1 kHz SRC gets stuck
Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
This commit is contained in:
Tobias Johansson
2020-10-19 16:53:09 +02:00
committed by Masayuki Ishikawa
parent 50e1a49c6e
commit c06c6ffa81
6 changed files with 997 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/audio/Kconfig
+8
View File
@@ -40,6 +40,14 @@ if AUDIO_CXD56
if AUDIO_DRIVER_SPECIFIC_BUFFERS
config AUDIO_CXD56_SRC
bool "CXD56 audio sample rate convertor"
select AUDIO_SRC
default n
---help---
Enable support for audio playback using the CXD5247 chip on the
CXD56 Spresense board with sample rate convertor.
config CXD56_AUDIO_NUM_BUFFERS
int "Number of audio buffers to use"
default 4
drivers/audio/Make.defs
+3
View File
@@ -41,6 +41,9 @@ ifeq ($(CONFIG_DRIVERS_AUDIO),y)
ifeq ($(CONFIG_AUDIO_CXD56),y)
CSRCS += cxd56.c
ifeq ($(CONFIG_AUDIO_CXD56_SRC),y)
CSRCS += cxd56_src.c
endif
endif
ifeq ($(CONFIG_AUDIO_VS1053),y)
drivers/audio/cxd56.c
+257 -75
View File
@@ -55,6 +55,10 @@
#include "cxd56.h"
#ifdef CONFIG_AUDIO_CXD56_SRC
#include "cxd56_src.h"
#endif
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
@@ -1272,6 +1276,157 @@ static void cxd56_reset_channel_sel(cxd56_dmahandle_t handle)
}
}
#ifdef CONFIG_CXD56_AUCIO_SRC
static void _process_audio_with_src(cxd56_dmahandle_t hdl, uint16_t err_code)
{
struct audio_msg_s msg;
struct cxd56_dev_s *dev;
irqstate_t flags;
bool request_buffer = true;
int ret;
dev = g_dev[hdl];
/* Trigger new DMA job */
flags = spin_lock_irqsave();
if (err_code == CXD56_AUDIO_ECODE_DMA_TRANS)
{
/* Notify end of data */
if (dev->state != CXD56_DEV_STATE_PAUSED
&& dq_count(&dev->down_pendq) == 0)
{
msg.msg_id = AUDIO_MSG_STOP;
msg.u.data = 0;
spin_unlock_irqrestore(flags);
ret = nxmq_send(dev->mq, (FAR const char *)&msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
flags = spin_lock_irqsave();
if (ret != OK)
{
auderr("ERROR: nxmq_send to stop failed (%d)\n", ret);
}
}
}
if (dq_count(&dev->down_runq) > 0)
{
FAR struct ap_buffer_s *src_apb;
src_apb = (struct ap_buffer_s *) dq_get(&dev->down_runq);
src_apb->nbytes = 0;
dq_put(&dev->down_doneq, &src_apb->dq_entry);
if (src_apb->flags & AUDIO_APB_SRC_FINAL)
{
struct ap_buffer_s *apb;
apb = dq_get(&dev->up_runq);
spin_unlock_irqrestore(flags);
dev->dev.upper(dev->dev.priv, AUDIO_CALLBACK_DEQUEUE, apb, OK);
flags = spin_lock_irqsave();
/* End of data? */
if ((apb->flags & AUDIO_APB_FINAL) != 0)
{
msg.msg_id = AUDIO_MSG_STOP;
msg.u.data = 0;
spin_unlock_irqrestore(flags);
ret = nxmq_send(dev->mq, (FAR const char *)&msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
flags = spin_lock_irqsave();
if (ret != OK)
{
auderr("ERROR: nxmq_send to stop failed (%d)\n", ret);
}
request_buffer = false;
}
}
}
if (request_buffer && dev->mq != NULL)
{
/* Request more data */
msg.msg_id = AUDIO_MSG_DATA_REQUEST;
msg.u.data = 0;
spin_unlock_irqrestore(flags);
ret = nxmq_send(dev->mq, (FAR const char *) &msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
flags = spin_lock_irqsave();
if (ret != OK)
{
auderr("ERROR: nxmq_send to request failed (%d)\n", ret);
}
}
spin_unlock_irqrestore(flags);
}
#else
static void _process_audio(cxd56_dmahandle_t hdl, uint16_t err_code)
{
struct audio_msg_s msg;
struct cxd56_dev_s *dev;
irqstate_t flags;
int ret;
dev = g_dev[hdl];
/* Trigger new DMA job */
flags = spin_lock_irqsave();
if (dq_count(&dev->up_runq) > 0)
{
FAR struct ap_buffer_s *apb;
apb = (struct ap_buffer_s *) dq_get(&dev->up_runq);
spin_unlock_irqrestore(flags);
dev->dev.upper(dev->dev.priv, AUDIO_CALLBACK_DEQUEUE, apb, OK);
flags = spin_lock_irqsave();
}
spin_unlock_irqrestore(flags);
if (err_code == CXD56_AUDIO_ECODE_DMA_TRANS)
{
/* Notify end of data */
if (dev->state != CXD56_DEV_STATE_PAUSED)
{
audinfo("DMA_TRANS up_pendq=%d \n",
dq_count(&dev->up_pendq));
msg.msg_id = AUDIO_MSG_STOP;
msg.u.data = 0;
ret = nxmq_send(dev->mq, (FAR const char *)&msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
if (ret != OK)
{
auderr("ERROR: nxmq_send to stop failed (%d)\n", ret);
}
}
}
else if (dev->mq != NULL)
{
/* Request more data */
msg.msg_id = AUDIO_MSG_DATA_REQUEST;
msg.u.data = 0;
ret = nxmq_send(dev->mq, (FAR const char *) &msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
if (ret != OK)
{
auderr("ERROR: nxmq_send to request failed (%d)\n", ret);
}
}
}
#endif
static void cxd56_dma_int_handler(void)
{
uint16_t err_code;
@@ -1360,60 +1515,11 @@ static void cxd56_dma_int_handler(void)
if (err_code != CXD56_AUDIO_ECODE_DMA_HANDLE_INV)
{
struct audio_msg_s msg;
struct cxd56_dev_s *dev;
irqstate_t flags;
int ret;
dev = g_dev[hdl];
/* Trigger new DMA job */
flags = spin_lock_irqsave();
if (dq_count(&dev->up_runq) > 0)
{
FAR struct ap_buffer_s *apb;
apb = (struct ap_buffer_s *) dq_get(&dev->up_runq);
spin_unlock_irqrestore(flags);
dev->dev.upper(dev->dev.priv, AUDIO_CALLBACK_DEQUEUE, apb, OK);
flags = spin_lock_irqsave();
}
spin_unlock_irqrestore(flags);
if (err_code == CXD56_AUDIO_ECODE_DMA_TRANS)
{
/* Notify end of data */
if (dev->state != CXD56_DEV_STATE_PAUSED)
{
audinfo("DMA_TRANS up_pendq=%d \n",
dq_count(&dev->up_pendq));
msg.msg_id = AUDIO_MSG_STOP;
msg.u.data = 0;
ret = nxmq_send(dev->mq, (FAR const char *)&msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
if (ret != OK)
{
auderr("ERROR: nxmq_send to stop failed (%d)\n", ret);
}
}
}
else if (dev->mq != NULL)
{
/* Request more data */
msg.msg_id = AUDIO_MSG_DATA_REQUEST;
msg.u.data = 0;
ret = nxmq_send(dev->mq, (FAR const char *) &msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
if (ret != OK)
{
auderr("ERROR: nxmq_send to request failed (%d)\n", ret);
}
}
#ifdef CONFIG_CXD56_AUCIO_SRC
_process_audio_with_src(hdl, err_code);
#else
_process_audio(hdl, err_code);
#endif
}
}
@@ -1627,6 +1733,11 @@ static void cxd56_init_dma(FAR struct cxd56_dev_s *dev)
dq_clear(&dev->up_pendq);
dq_clear(&dev->up_runq);
#ifdef CONFIG_AUDIO_CXD56_SRC
dq_clear(&dev->down_pendq);
dq_clear(&dev->down_runq);
dq_clear(&dev->down_doneq);
#endif
ints = CXD56_DMA_INT_DONE | CXD56_DMA_INT_ERR | CXD56_DMA_INT_CMB;
@@ -2693,6 +2804,15 @@ static int cxd56_configure(FAR struct audio_lowerhalf_s *lower,
priv->channels = caps->ac_channels;
priv->bitwidth = caps->ac_controls.b[2];
#ifdef CONFIG_AUDIO_CXD56_SRC
ret = cxd56_src_init(priv, &priv->down_doneq, &priv->down_pendq);
if (ret != OK)
{
auderr("ERROR: Could not initialize SRC (%d)\n", ret);
return -ENOMEM;
}
#endif
g_dev[priv->dma_handle] = priv;
poweron = 1;
@@ -3068,7 +3188,13 @@ static int cxd56_start_dma(FAR struct cxd56_dev_s *dev)
int ret = OK;
flags = spin_lock_irqsave();
#ifdef CONFIG_AUDIO_CXD56_SRC
FAR struct ap_buffer_s *src_apb;
if (dq_count(&dev->down_pendq) == 0)
#else
if (dq_count(&dev->up_pendq) == 0)
#endif
{
/* Underrun occurred, stop DMA and change state for buffering */
@@ -3090,7 +3216,11 @@ static int cxd56_start_dma(FAR struct cxd56_dev_s *dev)
{
/* Fill up with as many DMA requests as we can */
#ifdef CONFIG_AUDIO_CXD56_SRC
while (dq_count(&dev->down_pendq) > 0)
#else
while (dq_count(&dev->up_pendq) > 0)
#endif
{
if (cxd56_dma_is_busy(dev->dma_handle))
{
@@ -3100,9 +3230,15 @@ static int cxd56_start_dma(FAR struct cxd56_dev_s *dev)
goto exit;
}
#ifdef CONFIG_AUDIO_CXD56_SRC
src_apb = (struct ap_buffer_s *) dq_peek(&dev->down_pendq);
addr = ((uint32_t)src_apb->samp) & CXD56_DMA_START_ADDR_MASK;
size = (src_apb->nbytes / (dev->bitwidth / 8) / dev->channels) - 1;
#else
apb = (struct ap_buffer_s *) dq_peek(&dev->up_pendq);
addr = ((uint32_t)apb->samp) & CXD56_DMA_START_ADDR_MASK;
size = (apb->nbytes / (dev->bitwidth / 8) / dev->channels) - 1;
#endif
if (dev->dma_handle == CXD56_AUDIO_DMA_MIC)
{
@@ -3114,7 +3250,13 @@ static int cxd56_start_dma(FAR struct cxd56_dev_s *dev)
if (dev->bitwidth == 16 &&
CXD56_DMA_FORMAT == CXD56_DMA_FORMAT_RL)
{
cxd56_swap_buffer_rl((uint32_t)apb->samp, apb->nbytes);
#ifdef CONFIG_AUDIO_CXD56_SRC
cxd56_swap_buffer_rl((uint32_t)src_apb->samp,
src_apb->nbytes);
#else
cxd56_swap_buffer_rl((uint32_t)apb->samp,
apb->nbytes);
#endif
}
write_reg(REG_I2S1_OUT_START_ADR, addr);
@@ -3223,10 +3365,19 @@ static int cxd56_start_dma(FAR struct cxd56_dev_s *dev)
cxd56_set_dma_running(dev->dma_handle, true);
}
#ifdef CONFIG_AUDIO_CXD56_SRC
dq_get(&dev->down_pendq);
dq_put(&dev->down_runq, &src_apb->dq_entry);
apb = (struct ap_buffer_s *) dq_get(&dev->up_pendq);
#else
dq_get(&dev->up_pendq);
#endif
dq_put(&dev->up_runq, &apb->dq_entry);
dev->state = CXD56_DEV_STATE_STARTED;
#ifndef CONFIG_AUDIO_CXD56_SRC
if ((apb->flags & AUDIO_APB_FINAL) != 0)
{
/* If the apb is final, send stop message */
@@ -3247,6 +3398,7 @@ static int cxd56_start_dma(FAR struct cxd56_dev_s *dev)
goto exit;
}
}
#endif
}
}
@@ -3269,29 +3421,40 @@ static int cxd56_enqueuebuffer(FAR struct audio_lowerhalf_s *lower,
FAR struct cxd56_dev_s *priv = (FAR struct cxd56_dev_s *)lower;
struct audio_msg_s msg;
irqstate_t flags;
int ret;
flags = spin_lock_irqsave();
apb->dq_entry.flink = NULL;
dq_put(&priv->up_pendq, &apb->dq_entry);
spin_unlock_irqrestore(flags);
if (priv->mq != NULL)
#ifdef CONFIG_AUDIO_CXD56_SRC
ret = cxd56_src_enqueue(apb);
if (ret != OK)
{
int ret;
msg.msg_id = AUDIO_MSG_ENQUEUE;
msg.u.data = 0;
ret = nxmq_send(priv->mq, (FAR const char *) &msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
if (ret != OK)
{
auderr("ERROR: nxmq_send to enqueue failed (%d)\n", ret);
return ret;
}
auderr("ERROR: SRC processing failed (%d)\n", ret);
}
else
{
#endif
flags = spin_lock_irqsave();
apb->dq_entry.flink = NULL;
dq_put(&priv->up_pendq, &apb->dq_entry);
spin_unlock_irqrestore(flags);
if (priv->mq != NULL)
{
msg.msg_id = AUDIO_MSG_ENQUEUE;
msg.u.data = 0;
ret = nxmq_send(priv->mq, (FAR const char *) &msg,
sizeof(msg), CONFIG_CXD56_MSG_PRIO);
if (ret != OK)
{
auderr("ERROR: nxmq_send to enqueue failed (%d)\n", ret);
return ret;
}
}
#ifdef CONFIG_AUDIO_CXD56_SRC
}
#endif
return OK;
}
@@ -3409,6 +3572,20 @@ static void *cxd56_workerthread(pthread_addr_t pvarg)
priv->running = false;
}
#ifdef CONFIG_AUDIO_CXD56_SRC
ret = cxd56_src_stop();
if (ret != OK)
{
auderr("ERROR: Could not stop SRC (%d)\n", ret);
}
ret = cxd56_src_deinit();
if (ret != OK)
{
auderr("ERROR: Could not deinit SRC (%d)\n", ret);
}
#endif
priv->state = CXD56_DEV_STATE_STOPPED;
priv->running = false;
audinfo("Workerthread stopped.\n");
@@ -3547,6 +3724,11 @@ struct audio_lowerhalf_s *cxd56_initialize(
nxsem_init(&priv->pendsem, 0, 1);
dq_init(&priv->up_pendq);
dq_init(&priv->up_runq);
#ifdef CONFIG_AUDIO_CXD56_SRC
dq_init(&priv->down_pendq);
dq_init(&priv->down_runq);
dq_init(&priv->down_doneq);
#endif
}
return &priv->dev;
drivers/audio/cxd56.h
+6
View File
@@ -287,6 +287,12 @@ struct cxd56_dev_s
struct dq_queue_s up_pendq; /* Pending buffers from app to process */
struct dq_queue_s up_runq; /* Buffers from app being played */
#ifdef CONFIG_AUDIO_CXD56_SRC
struct dq_queue_s down_pendq; /* Pending SRC buffers to be DMA'd */
struct dq_queue_s down_runq; /* SRC buffers being processed */
struct dq_queue_s down_doneq; /* Done SRC buffers to be re-used */
#endif
uint16_t samplerate; /* Sample rate */
#ifndef CONFIG_AUDIO_EXCLUDE_VOLUME
int16_t volume; /* Output volume {0..63} */
drivers/audio/cxd56_src.c
+603
View File
File diff suppressed because it is too large Load Diff
drivers/audio/cxd56_src.h
+120
View File
@@ -0,0 +1,120 @@
/****************************************************************************
* drivers/audio/cxd56_src.h
*
* Copyright 2020 Sony Semiconductor Solutions Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __DRIVERS_AUDIO_CXD56_SRC_H
#define __DRIVERS_AUDIO_CXD56_SRC_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <pthread.h>
#include <mqueue.h>
#include <nuttx/audio/audio.h>
#include <nuttx/config.h>
#ifdef CONFIG_AUDIO
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifndef CONFIG_CXD56_AUDIO_SRC_STACKSIZE
# define CONFIG_CXD56_AUDIO_SRC_STACKSIZE 768
#endif
#ifndef CONFIG_CXD56_SRC_MSG_PRIO
# define CONFIG_CXD56_SRC_MSG_PRIO 1
#endif
#ifndef SRC_SINC_BEST_QUALITY
# define SRC_SINC_BEST_QUALITY 0
#endif
#ifndef SRC_SINC_MEDIUM_QUALITY
# define SRC_SINC_MEDIUM_QUALITY 1
#endif
#ifndef SRC_SINC_FASTEST
# define SRC_SINC_FASTEST 2
#endif
#ifndef SRC_ZERO_ORDER_HOLD
# define SRC_ZERO_ORDER_HOLD 3
#endif
#ifndef SRC_LINEAR
# define SRC_LINEAR 4
#endif
#define AUDIO_APB_SRC_FINAL (1 << 4) /* Last buffer in SRC processing */
/****************************************************************************
* Public Types
****************************************************************************/
typedef struct SRC_STATE_TAG SRC_STATE;
typedef struct
{
const float *data_in;
float *data_out;
long input_frames;
long output_frames;
long input_frames_used;
long output_frames_gen;
int end_of_input;
double src_ratio;
} SRC_DATA;
SRC_STATE *src_new (int converter_type, int channels, int *error);
SRC_STATE *src_delete (SRC_STATE *state);
int src_process (SRC_STATE *state, SRC_DATA *data);
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
int cxd56_src_init(FAR struct cxd56_dev_s *dev, FAR struct dq_queue_s *inq,
FAR struct dq_queue_s *outq);
int cxd56_src_deinit(void);
int cxd56_src_enqueue(FAR struct ap_buffer_s *apb);
int cxd56_src_stop(void);
#endif /* CONFIG_AUDIO */
#endif /* __DRIVERS_AUDIO_CXD56_SRC_H */