519 lines
13 KiB
C
519 lines
13 KiB
C
|
/***************************************************************************
|
||
|
|
* __________ __ ___.
|
||
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
||
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
||
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
||
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
||
|
|
* \/ \/ \/ \/ \/
|
||
|
|
* $Id$
|
||
|
|
*
|
||
|
|
* Copyright (C) 2010 Thomas Martitz
|
||
|
|
*
|
||
|
|
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
||
|
|
* KIND, either express or implied.
|
||
|
|
*
|
||
|
|
****************************************************************************/
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Based, but heavily modified, on the example given at
|
||
|
|
* http://www.alsa-project.org/alsa-doc/alsa-lib/_2test_2pcm_8c-example.html
|
||
|
|
*
|
||
|
|
* This driver uses the so-called unsafe async callback method and hardcoded device
|
||
|
|
* names. It fails when the audio device is busy by other apps.
|
||
|
|
*
|
||
|
|
* TODO: Rewrite this to do it properly with multithreading
|
||
|
|
*
|
||
|
|
* Alternatively, a version using polling in a tick task is provided. While
|
||
|
|
* supposedly safer, it appears to use more CPU (however I didn't measure it
|
||
|
|
* accurately, only looked at htop). At least, in this mode the "default"
|
||
|
|
* device works which doesnt break with other apps running.
|
||
|
|
* device works which doesnt break with other apps running.
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
#include "autoconf.h"
|
||
|
|
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <stdbool.h>
|
||
|
|
#include <alsa/asoundlib.h>
|
||
|
|
#include "system.h"
|
||
|
|
#include "debug.h"
|
||
|
|
#include "kernel.h"
|
||
|
|
|
||
|
|
#include "pcm.h"
|
||
|
|
#include "pcm-internal.h"
|
||
|
|
#include "pcm_mixer.h"
|
||
|
|
#include "pcm_sampr.h"
|
||
|
|
|
||
|
|
#include <pthread.h>
|
||
|
|
#include <signal.h>
|
||
|
|
|
||
|
|
#define USE_ASYNC_CALLBACK
|
||
|
|
/* plughw:0,0 works with both, however "default" is recommended.
|
||
|
|
* default doesnt seem to work with async callback but doesn't break
|
||
|
|
* with multple applications running */
|
||
|
|
static char device[] = "plughw:0,0"; /* playback device */
|
||
|
|
static const snd_pcm_access_t access_ = SND_PCM_ACCESS_RW_INTERLEAVED; /* access mode */
|
||
|
|
static const snd_pcm_format_t format = SND_PCM_FORMAT_S16; /* sample format */
|
||
|
|
static const int channels = 2; /* count of channels */
|
||
|
|
static unsigned int rate = 44100; /* stream rate */
|
||
|
|
|
||
|
|
static snd_pcm_t *handle;
|
||
|
|
static snd_pcm_sframes_t buffer_size = MIX_FRAME_SAMPLES * 32; /* ~16k */
|
||
|
|
static snd_pcm_sframes_t period_size = MIX_FRAME_SAMPLES * 4; /* ~4k */
|
||
|
|
static short *frames;
|
||
|
|
|
||
|
|
static const char *pcm_data = 0;
|
||
|
|
static size_t pcm_size = 0;
|
||
|
|
|
||
|
|
#ifdef USE_ASYNC_CALLBACK
|
||
|
|
static snd_async_handler_t *ahandler;
|
||
|
|
static pthread_mutex_t pcm_mtx;
|
||
|
|
#else
|
||
|
|
static int recursion;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
static int set_hwparams(snd_pcm_t *handle, unsigned sample_rate)
|
||
|
|
{
|
||
|
|
unsigned int rrate;
|
||
|
|
int err;
|
||
|
|
snd_pcm_hw_params_t *params;
|
||
|
|
snd_pcm_hw_params_alloca(¶ms);
|
||
|
|
|
||
|
|
|
||
|
|
/* choose all parameters */
|
||
|
|
err = snd_pcm_hw_params_any(handle, params);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
/* set the interleaved read/write format */
|
||
|
|
err = snd_pcm_hw_params_set_access(handle, params, access_);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Access type not available for playback: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
/* set the sample format */
|
||
|
|
err = snd_pcm_hw_params_set_format(handle, params, format);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Sample format not available for playback: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
/* set the count of channels */
|
||
|
|
err = snd_pcm_hw_params_set_channels(handle, params, channels);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Channels count (%i) not available for playbacks: %s\n", channels, snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
/* set the stream rate */
|
||
|
|
rrate = sample_rate;
|
||
|
|
err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Rate %iHz not available for playback: %s\n", rate, snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
if (rrate != sample_rate)
|
||
|
|
{
|
||
|
|
printf("Rate doesn't match (requested %iHz, get %iHz)\n", sample_rate, err);
|
||
|
|
return -EINVAL;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* set the buffer size */
|
||
|
|
err = snd_pcm_hw_params_set_buffer_size_near(handle, params, &buffer_size);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Unable to set buffer size %i for playback: %s\n", buffer_size, snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* set the period size */
|
||
|
|
err = snd_pcm_hw_params_set_period_size_near (handle, params, &period_size, NULL);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Unable to set period size %i for playback: %s\n", period_size, snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
if (!frames)
|
||
|
|
frames = malloc(period_size * channels * sizeof(short));
|
||
|
|
|
||
|
|
/* write the parameters to device */
|
||
|
|
err = snd_pcm_hw_params(handle, params);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Set sw params: playback start threshold and low buffer watermark */
|
||
|
|
static int set_swparams(snd_pcm_t *handle)
|
||
|
|
{
|
||
|
|
int err;
|
||
|
|
|
||
|
|
snd_pcm_sw_params_t *swparams;
|
||
|
|
snd_pcm_sw_params_alloca(&swparams);
|
||
|
|
|
||
|
|
/* get the current swparams */
|
||
|
|
err = snd_pcm_sw_params_current(handle, swparams);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Unable to determine current swparams for playback: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
/* start the transfer when the buffer is haalmost full */
|
||
|
|
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, buffer_size / 2);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
/* allow the transfer when at least period_size samples can be processed */
|
||
|
|
err = snd_pcm_sw_params_set_avail_min(handle, swparams, period_size);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Unable to set avail min for playback: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
/* write the parameters to the playback device */
|
||
|
|
err = snd_pcm_sw_params(handle, swparams);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
printf("Unable to set sw params for playback: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* copy pcm samples to a spare buffer, suitable for snd_pcm_writei() */
|
||
|
|
static bool fill_frames(void)
|
||
|
|
{
|
||
|
|
ssize_t copy_n, frames_left = period_size;
|
||
|
|
bool new_buffer = false;
|
||
|
|
|
||
|
|
while (frames_left > 0)
|
||
|
|
{
|
||
|
|
if (!pcm_size)
|
||
|
|
{
|
||
|
|
new_buffer = true;
|
||
|
|
pcm_play_get_more_callback((void **)&pcm_data, &pcm_size);
|
||
|
|
if (!pcm_size || !pcm_data)
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
copy_n = MIN((ssize_t)pcm_size, frames_left*4);
|
||
|
|
memcpy(&frames[2*(period_size-frames_left)], pcm_data, copy_n);
|
||
|
|
|
||
|
|
pcm_data += copy_n;
|
||
|
|
pcm_size -= copy_n;
|
||
|
|
frames_left -= copy_n/4;
|
||
|
|
|
||
|
|
if (new_buffer)
|
||
|
|
{
|
||
|
|
new_buffer = false;
|
||
|
|
pcm_play_dma_started_callback();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef USE_ASYNC_CALLBACK
|
||
|
|
static void async_callback(snd_async_handler_t *ahandler)
|
||
|
|
{
|
||
|
|
snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler);
|
||
|
|
|
||
|
|
if (pthread_mutex_trylock(&pcm_mtx) != 0)
|
||
|
|
return;
|
||
|
|
#else
|
||
|
|
static void pcm_tick(void)
|
||
|
|
{
|
||
|
|
if (snd_pcm_state(handle) != SND_PCM_STATE_RUNNING)
|
||
|
|
return;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
while (snd_pcm_avail_update(handle) >= period_size)
|
||
|
|
{
|
||
|
|
if (fill_frames())
|
||
|
|
{
|
||
|
|
int err = snd_pcm_writei(handle, frames, period_size);
|
||
|
|
if (err < 0 && err != period_size && err != -EAGAIN)
|
||
|
|
{
|
||
|
|
printf("Write error: written %i expected %li\n", err, period_size);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DEBUGF("%s: No Data.\n", __func__);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#ifdef USE_ASYNC_CALLBACK
|
||
|
|
pthread_mutex_unlock(&pcm_mtx);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
static int async_rw(snd_pcm_t *handle)
|
||
|
|
{
|
||
|
|
int err;
|
||
|
|
snd_pcm_sframes_t sample_size;
|
||
|
|
short *samples;
|
||
|
|
|
||
|
|
#ifdef USE_ASYNC_CALLBACK
|
||
|
|
err = snd_async_add_pcm_handler(&ahandler, handle, async_callback, NULL);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
DEBUGF("Unable to register async handler: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* fill buffer with silence to initiate playback without noisy click */
|
||
|
|
sample_size = buffer_size;
|
||
|
|
samples = malloc(sample_size * channels * sizeof(short));
|
||
|
|
|
||
|
|
snd_pcm_format_set_silence(format, samples, sample_size);
|
||
|
|
err = snd_pcm_writei(handle, samples, sample_size);
|
||
|
|
free(samples);
|
||
|
|
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
DEBUGF("Initial write error: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
if (err != (ssize_t)sample_size)
|
||
|
|
{
|
||
|
|
DEBUGF("Initial write error: written %i expected %li\n", err, sample_size);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
if (snd_pcm_state(handle) == SND_PCM_STATE_PREPARED)
|
||
|
|
{
|
||
|
|
err = snd_pcm_start(handle);
|
||
|
|
if (err < 0)
|
||
|
|
{
|
||
|
|
DEBUGF("Start error: %s\n", snd_strerror(err));
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void cleanup(void)
|
||
|
|
{
|
||
|
|
free(frames);
|
||
|
|
frames = NULL;
|
||
|
|
snd_pcm_close(handle);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void pcm_play_dma_init(void)
|
||
|
|
{
|
||
|
|
int err;
|
||
|
|
|
||
|
|
|
||
|
|
if ((err = snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0)
|
||
|
|
{
|
||
|
|
printf("%s(): Cannot open device %s: %s\n", __func__, device, snd_strerror(err));
|
||
|
|
exit(EXIT_FAILURE);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((err = snd_pcm_nonblock(handle, 1)))
|
||
|
|
printf("Could not set non-block mode: %s\n", snd_strerror(err));
|
||
|
|
|
||
|
|
if ((err = set_hwparams(handle, rate)) < 0)
|
||
|
|
{
|
||
|
|
printf("Setting of hwparams failed: %s\n", snd_strerror(err));
|
||
|
|
exit(EXIT_FAILURE);
|
||
|
|
}
|
||
|
|
if ((err = set_swparams(handle)) < 0)
|
||
|
|
{
|
||
|
|
printf("Setting of swparams failed: %s\n", snd_strerror(err));
|
||
|
|
exit(EXIT_FAILURE);
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef USE_ASYNC_CALLBACK
|
||
|
|
pthread_mutexattr_t attr;
|
||
|
|
pthread_mutexattr_init(&attr);
|
||
|
|
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
||
|
|
pthread_mutex_init(&pcm_mtx, &attr);
|
||
|
|
#else
|
||
|
|
tick_add_task(pcm_tick);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
atexit(cleanup);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void pcm_play_lock(void)
|
||
|
|
{
|
||
|
|
#ifdef USE_ASYNC_CALLBACK
|
||
|
|
pthread_mutex_lock(&pcm_mtx);
|
||
|
|
#else
|
||
|
|
if (recursion++ == 0)
|
||
|
|
tick_remove_task(pcm_tick);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_play_unlock(void)
|
||
|
|
{
|
||
|
|
#ifdef USE_ASYNC_CALLBACK
|
||
|
|
pthread_mutex_unlock(&pcm_mtx);
|
||
|
|
#else
|
||
|
|
if (--recursion == 0)
|
||
|
|
tick_add_task(pcm_tick);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
static void pcm_dma_apply_settings_nolock(void)
|
||
|
|
{
|
||
|
|
snd_pcm_drop(handle);
|
||
|
|
set_hwparams(handle, pcm_sampr);
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_dma_apply_settings(void)
|
||
|
|
{
|
||
|
|
pcm_play_lock();
|
||
|
|
pcm_dma_apply_settings_nolock();
|
||
|
|
pcm_play_unlock();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void pcm_play_dma_pause(bool pause)
|
||
|
|
{
|
||
|
|
snd_pcm_pause(handle, pause);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void pcm_play_dma_stop(void)
|
||
|
|
{
|
||
|
|
snd_pcm_drain(handle);
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_play_dma_start(const void *addr, size_t size)
|
||
|
|
{
|
||
|
|
pcm_dma_apply_settings_nolock();
|
||
|
|
|
||
|
|
pcm_data = addr;
|
||
|
|
pcm_size = size;
|
||
|
|
|
||
|
|
while (1)
|
||
|
|
{
|
||
|
|
snd_pcm_state_t state = snd_pcm_state(handle);
|
||
|
|
switch (state)
|
||
|
|
{
|
||
|
|
case SND_PCM_STATE_RUNNING:
|
||
|
|
return;
|
||
|
|
case SND_PCM_STATE_XRUN:
|
||
|
|
{
|
||
|
|
DEBUGF("Trying to recover from error\n");
|
||
|
|
int err = snd_pcm_recover(handle, -EPIPE, 0);
|
||
|
|
if (err < 0)
|
||
|
|
DEBUGF("Recovery failed: %s\n", snd_strerror(err));
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
case SND_PCM_STATE_SETUP:
|
||
|
|
{
|
||
|
|
int err = snd_pcm_prepare(handle);
|
||
|
|
if (err < 0)
|
||
|
|
printf("Prepare error: %s\n", snd_strerror(err));
|
||
|
|
/* fall through */
|
||
|
|
}
|
||
|
|
case SND_PCM_STATE_PREPARED:
|
||
|
|
{ /* prepared state, we need to fill the buffer with silence before
|
||
|
|
* starting */
|
||
|
|
int err = async_rw(handle);
|
||
|
|
if (err < 0)
|
||
|
|
printf("Start error: %s\n", snd_strerror(err));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
case SND_PCM_STATE_PAUSED:
|
||
|
|
{ /* paused, simply resume */
|
||
|
|
pcm_play_dma_pause(0);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
case SND_PCM_STATE_DRAINING:
|
||
|
|
/* run until drained */
|
||
|
|
continue;
|
||
|
|
default:
|
||
|
|
DEBUGF("Unhandled state: %s\n", snd_pcm_state_name(state));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
size_t pcm_get_bytes_waiting(void)
|
||
|
|
{
|
||
|
|
return pcm_size;
|
||
|
|
}
|
||
|
|
|
||
|
|
const void * pcm_play_dma_get_peak_buffer(int *count)
|
||
|
|
{
|
||
|
|
uintptr_t addr = (uintptr_t)pcm_data;
|
||
|
|
*count = pcm_size / 4;
|
||
|
|
return (void *)((addr + 3) & ~3);
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_play_dma_postinit(void)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void pcm_set_mixer_volume(int volume)
|
||
|
|
{
|
||
|
|
(void)volume;
|
||
|
|
}
|
||
|
|
#ifdef HAVE_RECORDING
|
||
|
|
void pcm_rec_lock(void)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_rec_unlock(void)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_rec_dma_init(void)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_rec_dma_close(void)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_rec_dma_start(void *start, size_t size)
|
||
|
|
{
|
||
|
|
(void)start;
|
||
|
|
(void)size;
|
||
|
|
}
|
||
|
|
|
||
|
|
void pcm_rec_dma_stop(void)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
const void * pcm_rec_dma_get_peak_buffer(void)
|
||
|
|
{
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
void audiohw_set_recvol(int left, int right, int type)
|
||
|
|
{
|
||
|
|
(void)left;
|
||
|
|
(void)right;
|
||
|
|
(void)type;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif /* HAVE_RECORDING */
|