/*************************************************************************** * __________ __ ___. * 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 #include #include #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 "audiohw.h" #include #include #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; audiohw_preinit(); 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); } pcm_dma_apply_settings(); #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) { audiohw_postinit(); } 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 */