2 * This file is part of DisOrder.
3 * Copyright (C) 2008 Richard Kettlewell
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 * @brief Background-thread interface to ALSA
21 * This wraps ALSA with an interface which calls back to the client from a
22 * thread. It's not intended for completely general use, just what DisOrder
25 * Only builds on Linux systems.
30 #if HAVE_ALSA_ASOUNDLIB_H
31 #include <alsa/asoundlib.h>
37 /** @brief Output handle */
38 static snd_pcm_t *pcm;
40 /** @brief Called to get audio data */
41 static alsa_bg_supply *supplyfn;
43 static pthread_t alsa_bg_collect_tid, alsa_bg_play_tid;
45 /** @brief Set to shut down the background threads */
46 static int alsa_bg_shutdown = 0;
48 /** @brief Number of channels (samples per frame) */
51 /** @brief Number of bytes per samples */
52 #define BYTES_PER_SAMPLE 2
54 /** @brief Number of bytes per frame */
55 #define BYTES_PER_FRAME (CHANNELS * BYTES_PER_SAMPLE)
57 /** @brief Buffer size in bytes */
58 #define BUFFER_BYTES 65536
60 /** @brief Buffer size in frames */
61 #define BUFFER_FRAMES (BUFFER_BYTES / BYTES_PER_FRAME)
63 /** @brief Buffer size in samples */
64 #define BUFFER_SAMPLES (BUFFER_BYTES / BYTES_PER_SAMPLE)
66 /** @brief Audio buffer */
67 static uint8_t alsa_bg_buffer[BUFFER_BYTES];
69 /** @brief First playable byte in audio buffer */
70 static unsigned alsa_bg_start;
72 /** @brief Number of playable bytes in audio buffer */
73 static unsigned alsa_bg_count;
75 /** @brief Current enable status */
76 static int alsa_bg_enabled;
78 /** @brief Lock protecting audio buffer pointers */
79 static pthread_mutex_t alsa_bg_lock = PTHREAD_MUTEX_INITIALIZER;
81 /** @brief Signaled when buffer contents changes */
82 static pthread_cond_t alsa_bg_cond = PTHREAD_COND_INITIALIZER;
84 /** @brief Call a pthread_ function and fatal() on exit */
89 fatal(prc, "%s", #x); \
92 /** @brief Data collection thread
94 * This thread collects audio data to play and stores it in the ring
97 static void *alsa_bg_collect(void attribute((unused)) *arg) {
98 unsigned avail_start, avail_count;
101 ep(pthread_mutex_lock(&alsa_bg_lock));
103 /* If we're shutting down, quit straight away */
106 /* While we're disabled or the buffer is full, just wait */
107 if(!alsa_bg_enabled || alsa_bg_count == BUFFER_BYTES) {
108 ep(pthread_cond_wait(&alsa_bg_cond, &alsa_bg_lock));
111 /* Figure out where and how big the gap we can write into is */
112 avail_start = alsa_bg_start + alsa_bg_count;
113 if(avail_start < BUFFER_BYTES)
114 avail_count = BUFFER_BYTES - avail_start;
116 avail_start %= BUFFER_BYTES;
117 avail_count = alsa_bg_start - avail_start;
119 assert(avail_start < BUFFER_BYTES);
120 assert(avail_count <= BUFFER_BYTES);
121 assert(avail_count + alsa_bg_count <= BUFFER_BYTES);
122 ep(pthread_mutex_unlock(&alsa_bg_lock));
123 count = supplyfn(alsa_bg_buffer + avail_start,
124 avail_count / BYTES_PER_SAMPLE);
125 ep(pthread_mutex_lock(&alsa_bg_lock));
126 alsa_bg_count += count * BYTES_PER_SAMPLE;
127 assert(alsa_bg_start < BUFFER_BYTES);
128 assert(alsa_bg_count <= BUFFER_BYTES);
129 ep(pthread_cond_signal(&alsa_bg_cond));
131 ep(pthread_mutex_unlock(&alsa_bg_lock));
135 /** @brief Playback thread
137 * This thread reads audio data out of the ring buffer and plays it back
139 static void *alsa_bg_play(void attribute((unused)) *arg) {
140 int prepared = 1, err;
141 int start, nbytes, nframes, rframes;
143 ep(pthread_mutex_lock(&alsa_bg_lock));
145 /* If we're shutting down, quit straight away */
148 /* Wait for some data to be available. (If we are marked disabled
149 * we keep on playing what we've got.) */
150 if(alsa_bg_count == 0) {
152 if((err = snd_pcm_drain(pcm)))
153 fatal(0, "snd_pcm_drain: %d", err);
156 ep(pthread_cond_wait(&alsa_bg_cond, &alsa_bg_lock));
159 /* Calculate how much we can play */
160 start = alsa_bg_start;
161 if(start + alsa_bg_count <= BUFFER_BYTES)
162 nbytes = alsa_bg_count;
164 nbytes = BUFFER_BYTES - start;
165 /* Limit how much of the buffer we play. The effect is that we return from
166 * _writei earlier, and therefore free up more buffer space to read fresh
167 * data into. /2 works fine, /4 is just conservative. /1 (i.e. abolishing
168 * the heuristic) produces noticably noisy output. */
169 if(nbytes > BUFFER_BYTES / 4)
170 nbytes = BUFFER_BYTES / 4;
171 assert((unsigned)nbytes <= alsa_bg_count);
172 nframes = nbytes / BYTES_PER_FRAME;
173 ep(pthread_mutex_unlock(&alsa_bg_lock));
174 /* Make sure the PCM is prepared */
176 if((err = snd_pcm_prepare(pcm)))
177 fatal(0, "snd_pcm_prepare: %d", err);
180 /* Play what we can */
181 rframes = snd_pcm_writei(pcm, alsa_bg_buffer + start, nframes);
182 ep(pthread_mutex_lock(&alsa_bg_lock));
186 error(0, "underrun detected");
187 if((err = snd_pcm_prepare(pcm)))
188 fatal(0, "snd_pcm_prepare: %d", err);
191 fatal(0, "snd_pcm_writei: %d", rframes);
194 const int rbytes = rframes * BYTES_PER_FRAME;
195 /*fprintf(stderr, "%5d -> %5d\n", nbytes, rbytes);*/
196 /* Update the buffer pointers */
197 alsa_bg_count -= rbytes;
198 alsa_bg_start += rbytes;
199 if(alsa_bg_start >= BUFFER_BYTES)
200 alsa_bg_start -= BUFFER_BYTES;
201 assert(alsa_bg_start < BUFFER_BYTES);
202 assert(alsa_bg_count <= BUFFER_BYTES);
203 /* Let the collector know we've opened up some space */
204 ep(pthread_cond_signal(&alsa_bg_cond));
207 ep(pthread_mutex_unlock(&alsa_bg_lock));
211 /** @brief Enable ALSA play */
212 void alsa_bg_enable(void) {
213 ep(pthread_mutex_lock(&alsa_bg_lock));
215 ep(pthread_cond_broadcast(&alsa_bg_cond));
216 ep(pthread_mutex_unlock(&alsa_bg_lock));
219 /** @brief Disable ALSA play */
220 void alsa_bg_disable(void) {
221 ep(pthread_mutex_lock(&alsa_bg_lock));
223 ep(pthread_cond_broadcast(&alsa_bg_cond));
224 ep(pthread_mutex_unlock(&alsa_bg_lock));
227 /** @brief Initialize background ALSA playback
228 * @param device Target device or NULL to use default
229 * @param supply Function to call to get audio data to play
231 * Playback is not initially enabled; see alsa_bg_enable(). When playback is
232 * enabled, @p supply will be called in a background thread to request audio
233 * data. It should return in a timely manner, but playback happens from a
234 * further thread and delays in @p supply will not delay transfer of data to
235 * the sound device (provided it doesn't actually run out).
237 void alsa_bg_init(const char *device,
238 alsa_bg_supply *supply) {
239 snd_pcm_hw_params_t *hwparams;
240 /* Only support one format for now */
241 const int sample_format = SND_PCM_FORMAT_S16_BE;
242 unsigned rate = 44100;
245 if((err = snd_pcm_open(&pcm,
246 device ? device : "default",
247 SND_PCM_STREAM_PLAYBACK,
249 fatal(0, "error from snd_pcm_open: %d", err);
250 /* Set up 'hardware' parameters */
251 snd_pcm_hw_params_alloca(&hwparams);
252 if((err = snd_pcm_hw_params_any(pcm, hwparams)) < 0)
253 fatal(0, "error from snd_pcm_hw_params_any: %d", err);
254 if((err = snd_pcm_hw_params_set_access(pcm, hwparams,
255 SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
256 fatal(0, "error from snd_pcm_hw_params_set_access: %d", err);
257 if((err = snd_pcm_hw_params_set_format(pcm, hwparams,
260 fatal(0, "error from snd_pcm_hw_params_set_format (%d): %d",
262 if((err = snd_pcm_hw_params_set_rate_near(pcm, hwparams, &rate, 0)) < 0)
263 fatal(0, "error from snd_pcm_hw_params_set_rate (%d): %d",
265 if((err = snd_pcm_hw_params_set_channels(pcm, hwparams,
267 fatal(0, "error from snd_pcm_hw_params_set_channels (%d): %d",
269 if((err = snd_pcm_hw_params(pcm, hwparams)) < 0)
270 fatal(0, "error calling snd_pcm_hw_params: %d", err);
272 /* Record the audio supply function */
275 /* Create the audio output thread */
276 alsa_bg_shutdown = 0;
278 ep(pthread_create(&alsa_bg_collect_tid, 0, alsa_bg_collect, 0));
279 ep(pthread_create(&alsa_bg_play_tid, 0, alsa_bg_play, 0));
282 /** @brief Deinitialize background ALSA playback
284 * The opposite of alsa_bg_init().
286 void alsa_bg_close(void) {
289 /* Notify background threads that we're shutting down */
290 ep(pthread_mutex_lock(&alsa_bg_lock));
292 alsa_bg_shutdown = 1;
293 ep(pthread_cond_signal(&alsa_bg_cond));
294 ep(pthread_mutex_unlock(&alsa_bg_lock));
295 /* Join background threads when they're done */
296 ep(pthread_join(alsa_bg_collect_tid, &r));
297 ep(pthread_join(alsa_bg_play_tid, &r));
298 /* Close audio device */