Make writers remove btr node on errors.
[paraslash.git] / alsa_write.c
1 /*
2  * Copyright (C) 2005-2009 Andre Noll <maan@systemlinux.org>
3  *
4  * Licensed under the GPL v2. For licencing details see COPYING.
5  */
6
7 /** \file alsa_write.c paraslash's alsa output plugin */
8
9 /*
10  * Based in parts on aplay.c from the alsa-utils-1.0.8 package,
11  * Copyright (c) by Jaroslav Kysela <perex@suse.cz>, which is
12  * based on the vplay program by Michael Beck.
13  */
14
15 #include <regex.h>
16 #include <sys/types.h>
17 #include <dirent.h>
18 #include <alsa/asoundlib.h>
19 #include <sys/time.h>
20 #include <stdbool.h>
21
22 #include "para.h"
23 #include "fd.h"
24 #include "string.h"
25 #include "list.h"
26 #include "sched.h"
27 #include "ggo.h"
28 #include "buffer_tree.h"
29 #include "write.h"
30 #include "write_common.h"
31 #include "alsa_write.cmdline.h"
32 #include "error.h"
33
34 /** always use 16 bit little endian */
35 #define FORMAT SND_PCM_FORMAT_S16_LE
36
37 /** Data specific to the alsa writer. */
38 struct private_alsa_write_data {
39         /** The alsa handle */
40         snd_pcm_t *handle;
41         /** Determined and set by alsa_open(). */
42         int bytes_per_frame; /* TODO: Kill this after btr switch */
43         /** The approximate maximum buffer duration in us. */
44         unsigned buffer_time;
45         /* Number of frames that fit into the buffer. */
46         snd_pcm_uframes_t buffer_frames;
47         /**
48          * The samplerate given by command line option or the decoder
49          * of the writer node group.
50          */
51         unsigned samplerate;
52         /**
53          * The number of channels, given by command line option or the
54          * decoder of the writer node group.
55          */
56         unsigned channels;
57 };
58
59 /* Install PCM software and hardware configuration. */
60 static int alsa_init(struct private_alsa_write_data *pad,
61                 struct alsa_write_args_info *conf)
62 {
63         snd_pcm_hw_params_t *hwparams;
64         snd_pcm_sw_params_t *swparams;
65         snd_pcm_uframes_t start_threshold, stop_threshold;
66         snd_pcm_uframes_t period_size;
67         int err;
68
69         PARA_INFO_LOG("opening %s\n", conf->device_arg);
70         err = snd_pcm_open(&pad->handle, conf->device_arg,
71                 SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
72         if (err < 0)
73                 return -E_PCM_OPEN;
74
75         snd_pcm_hw_params_alloca(&hwparams);
76         snd_pcm_sw_params_alloca(&swparams);
77         if (snd_pcm_hw_params_any(pad->handle, hwparams) < 0)
78                 return -E_BROKEN_CONF;
79         if (snd_pcm_hw_params_set_access(pad->handle, hwparams,
80                         SND_PCM_ACCESS_RW_INTERLEAVED) < 0)
81                 return -E_ACCESS_TYPE;
82         if (snd_pcm_hw_params_set_format(pad->handle, hwparams, FORMAT) < 0)
83                 return -E_SAMPLE_FORMAT;
84         if (snd_pcm_hw_params_set_channels(pad->handle, hwparams,
85                         pad->channels) < 0)
86                 return -E_CHANNEL_COUNT;
87         if (snd_pcm_hw_params_set_rate_near(pad->handle, hwparams,
88                         &pad->samplerate, NULL) < 0)
89                 return -E_SET_RATE;
90         err = snd_pcm_hw_params_get_buffer_time_max(hwparams,
91                 &pad->buffer_time, NULL);
92         if (err < 0 || !pad->buffer_time)
93                 return -E_GET_BUFFER_TIME;
94         PARA_INFO_LOG("buffer time: %d\n", pad->buffer_time);
95         if (snd_pcm_hw_params_set_buffer_time_near(pad->handle, hwparams,
96                         &pad->buffer_time, NULL) < 0)
97                 return -E_SET_BUFFER_TIME;
98         if (snd_pcm_hw_params(pad->handle, hwparams) < 0)
99                 return -E_HW_PARAMS;
100         snd_pcm_hw_params_get_period_size(hwparams, &period_size, NULL);
101         snd_pcm_hw_params_get_buffer_size(hwparams, &pad->buffer_frames);
102         PARA_INFO_LOG("buffer size: %lu, period_size: %lu\n", pad->buffer_frames,
103                 period_size);
104         if (period_size == pad->buffer_frames)
105                 return -E_BAD_PERIOD;
106         snd_pcm_sw_params_current(pad->handle, swparams);
107         snd_pcm_sw_params_set_avail_min(pad->handle, swparams, period_size);
108         if (pad->buffer_frames < 1)
109                 start_threshold = 1;
110         else
111                 start_threshold = PARA_MIN(pad->buffer_frames,
112                         (snd_pcm_uframes_t)pad->samplerate);
113         if (snd_pcm_sw_params_set_start_threshold(pad->handle, swparams,
114                         start_threshold) < 0)
115                 return -E_START_THRESHOLD;
116         stop_threshold = pad->buffer_frames;
117         if (snd_pcm_sw_params_set_stop_threshold(pad->handle, swparams,
118                         stop_threshold) < 0)
119                 return -E_STOP_THRESHOLD;
120         if (snd_pcm_sw_params(pad->handle, swparams) < 0)
121                 PARA_WARNING_LOG("unable to install sw params\n");
122         pad->bytes_per_frame = snd_pcm_format_physical_width(FORMAT)
123                 * pad->channels / 8;
124         if (pad->bytes_per_frame <= 0)
125                 return -E_PHYSICAL_WIDTH;
126         PARA_INFO_LOG("bytes per frame: %d\n", pad->bytes_per_frame);
127         if (snd_pcm_nonblock(pad->handle, 1))
128                 PARA_ERROR_LOG("failed to set nonblock mode\n");
129         return 1;
130 }
131
132 /* Open an instance of the alsa writer. */
133 static int alsa_open_nobtr(struct writer_node *wn)
134 {
135         struct alsa_write_args_info *conf = wn->conf;
136         struct writer_node_group *wng = wn->wng;
137         struct private_alsa_write_data *pad = para_calloc(sizeof(*pad));
138
139         wn->private_data = pad;
140         if (!conf->samplerate_given && wng->samplerate)
141                 pad->samplerate = *wng->samplerate;
142         else
143                 pad->samplerate = conf->samplerate_arg;
144         if (!conf->channels_given && wng->channels)
145                 pad->channels = *wng->channels;
146         else
147                 pad->channels = conf->channels_arg;
148         PARA_INFO_LOG("%d channel(s), %dHz\n", pad->channels, pad->samplerate);
149         return 1;
150 }
151
152 static int alsa_open_btr(struct writer_node *wn)
153 {
154         struct private_alsa_write_data *pad = para_calloc(sizeof(*pad));
155
156         wn->private_data = pad;
157         return 1;
158 }
159 static int alsa_open(struct writer_node *wn)
160 {
161         if (wn->btrn)
162                 return alsa_open_btr(wn);
163         return alsa_open_nobtr(wn);
164 }
165
166 static int alsa_write_pre_select(struct sched *s, struct writer_node *wn)
167 {
168         struct private_alsa_write_data *pad = wn->private_data;
169         struct writer_node_group *wng = wn->wng;
170         struct timeval tv;
171         snd_pcm_sframes_t avail, underrun;
172
173         if (!pad->handle)
174                 return 1;
175         if (wn->btrn) {
176                 int ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF);
177                 if (ret == 0)
178                         return 1;
179                 if (ret < 0) {
180                         sched_request_timeout_ms(20, s);
181                         return 42;
182                 }
183         } else {
184                 if (*wng->loaded - wn->written < pad->bytes_per_frame)
185                         return 1;
186         }
187         /*
188          * Data is available to be written to the alsa handle.  Compute number
189          * of milliseconds until next buffer underrun would occur.
190          *
191          * snd_pcm_avail_update() updates the current available count of
192          * samples for writing.  It is a light method to obtain current stream
193          * position, because it does not require the user <-> kernel context
194          * switch, but the value is less accurate, because ring buffer pointers
195          * are updated in kernel drivers only when an interrupt occurs.
196          */
197         avail = snd_pcm_avail_update(pad->handle);
198         if (avail < 0)
199                 avail = 0;
200         underrun = (pad->buffer_frames - avail) * pad->buffer_time
201                 / pad->buffer_frames / 1000;
202         if (underrun < 50)
203                 underrun = 50;
204         underrun -= 50;
205         ms2tv(underrun, &tv);
206         if (tv_diff(&s->timeout, &tv, NULL) > 0)
207                 s->timeout = tv;
208         //PARA_CRIT_LOG("timout: %lu\n", tv2ms(&s->timeout));
209         return 1;
210 }
211
212 static void alsa_write_pre_select_btr(struct sched *s, struct task *t)
213 {
214         struct writer_node *wn = container_of(t, struct writer_node, task);
215         alsa_write_pre_select(s, wn);
216 }
217
218 static void xrun(snd_pcm_t *handle)
219 {
220         snd_pcm_status_t *status;
221         int ret;
222         struct timeval tv, diff;
223
224         snd_pcm_status_alloca(&status);
225         ret = snd_pcm_status(handle, status);
226         if (ret < 0)
227                 return;
228         if (snd_pcm_status_get_state(status) != SND_PCM_STATE_XRUN)
229                 return;
230         snd_pcm_status_get_trigger_tstamp(status, &tv);
231         tv_diff(now, &tv, &diff);
232         PARA_WARNING_LOG("underrun: %lums\n", tv2ms(&diff));
233 }
234
235 static int alsa_write_post_select(__a_unused struct sched *s,
236                 struct writer_node *wn)
237 {
238         struct private_alsa_write_data *pad = wn->private_data;
239         struct writer_node_group *wng = wn->wng;
240         size_t bytes = *wng->loaded - wn->written;
241         unsigned char *data = (unsigned char*)*wng->bufp + wn->written;
242         snd_pcm_sframes_t ret, frames, avail;
243
244         if (*wng->input_error < 0 && (!pad->handle || bytes < pad->bytes_per_frame)) {
245                 wn->written = *wng->loaded;
246                 return *wng->input_error;
247         }
248         if (!bytes) /* no data available */
249                 return 0;
250         if (!pad->handle) {
251                 int err = alsa_init(pad, wn->conf);
252                 if (err < 0)
253                         return err;
254         }
255         frames = bytes / pad->bytes_per_frame;
256         if (!frames) /* less than a single frame available */
257                 return 0;
258         avail = snd_pcm_avail_update(pad->handle);
259         if (avail <= 0)
260                 return 0;
261         frames = PARA_MIN(frames, avail);
262         ret = snd_pcm_writei(pad->handle, data, frames);
263         if (ret >= 0) {
264                 wn->written += ret * pad->bytes_per_frame;
265                 return 1;
266         }
267         if (ret == -EPIPE) {
268                 xrun(pad->handle);
269                 snd_pcm_prepare(pad->handle);
270                 return 0;
271         }
272         PARA_WARNING_LOG("%s\n", snd_strerror(-ret));
273         if (ret == -EAGAIN)
274                 return 0;
275         return -E_ALSA_WRITE;
276 }
277
278 static void alsa_close(struct writer_node *wn)
279 {
280         struct private_alsa_write_data *pad = wn->private_data;
281         PARA_INFO_LOG("closing writer node %p\n", wn);
282
283         if (pad->handle) {
284                 /*
285                  * It's OK to have a blocking operation here because we already
286                  * made sure that the PCM output buffer is (nearly) empty.
287                  */
288                 snd_pcm_nonblock(pad->handle, 0);
289                 snd_pcm_drain(pad->handle);
290                 snd_pcm_close(pad->handle);
291                 snd_config_update_free_global();
292         }
293         free(pad);
294 }
295
296 static void alsa_write_post_select_btr(__a_unused struct sched *s,
297                 struct task *t)
298 {
299         struct writer_node *wn = container_of(t, struct writer_node, task);
300         struct private_alsa_write_data *pad = wn->private_data;
301         struct btr_node *btrn = wn->btrn;
302         char *data;
303         size_t bytes;
304         snd_pcm_sframes_t frames, avail;
305         int ret;
306
307 again:
308         t->error = 0;
309         ret = btr_node_status(btrn, wn->min_iqs, BTR_NT_LEAF);
310         if (ret == 0)
311                 return;
312         btr_merge(btrn, wn->min_iqs);
313         bytes = btr_next_buffer(btrn, &data);
314         if (ret < 0 || bytes < pad->bytes_per_frame) { /* eof */
315                 assert(btr_no_parent(btrn));
316                 ret = -E_ALSA_EOF;
317                 if (!pad->handle)
318                         goto err;
319                 /* wait until pending frames are played */
320                 avail = snd_pcm_avail_update(pad->handle);
321                 if (avail + 1000 > pad->buffer_frames)
322                         goto err;
323                 PARA_DEBUG_LOG("waiting for device to drain\n");
324                 return;
325         }
326         if (!pad->handle) {
327                 struct alsa_write_args_info *conf = wn->conf;
328                 if (bytes == 0) /* no data available */
329                         return;
330                 /* defaults */
331                 pad->samplerate = conf->samplerate_arg;
332                 pad->channels = conf->channels_arg;
333                 if (!conf->samplerate_given) { /* config option trumps btr_exec */
334                         int32_t rate;
335                         if (get_btr_samplerate(btrn, &rate) >= 0)
336                                 pad->samplerate = rate;
337                 }
338                 if (!conf->channels_given) {
339                         int32_t ch;
340                         if (get_btr_channels(btrn, &ch) >= 0)
341                                 pad->channels = ch;
342                 }
343                 PARA_INFO_LOG("%d channel(s), %dHz\n", pad->channels, pad->samplerate);
344                 ret = 1;
345                 ret = alsa_init(pad, wn->conf);
346                 if (ret < 0)
347                         goto err;
348                 wn->min_iqs = pad->bytes_per_frame;
349         }
350         frames = bytes / pad->bytes_per_frame;
351         frames = snd_pcm_writei(pad->handle, data, frames);
352         if (frames >= 0) {
353                 btr_consume(btrn, frames * pad->bytes_per_frame);
354                 goto again;
355         }
356         if (frames == -EPIPE) {
357                 xrun(pad->handle);
358                 snd_pcm_prepare(pad->handle);
359                 return;
360         }
361         if (frames == -EAGAIN)
362                 return;
363         PARA_WARNING_LOG("%s\n", snd_strerror(-frames));
364         ret = -E_ALSA_WRITE;
365 err:
366         assert(ret < 0);
367         btr_remove_node(btrn);
368         t->error = ret;
369 }
370
371 __malloc static void *alsa_parse_config(const char *options)
372 {
373         int ret;
374         struct alsa_write_args_info *conf
375                 = para_calloc(sizeof(struct alsa_write_args_info));
376
377         PARA_INFO_LOG("options: %s, %zd\n", options, strcspn(options, " \t"));
378         ret = alsa_cmdline_parser_string(options, conf, "alsa_write");
379         if (ret)
380                 goto err_out;
381         PARA_INFO_LOG("help given: %d\n", conf->help_given);
382         return conf;
383 err_out:
384         free(conf);
385         return NULL;
386 }
387
388 static void alsa_free_config(void *conf)
389 {
390         alsa_cmdline_parser_free(conf);
391 }
392
393 /**
394  * The init function of the alsa writer.
395  *
396  * \param w Pointer to the writer to initialize.
397  *
398  * \sa \ref struct writer.
399  */
400 void alsa_write_init(struct writer *w)
401 {
402         struct alsa_write_args_info dummy;
403
404         alsa_cmdline_parser_init(&dummy);
405         w->open = alsa_open;
406         w->close = alsa_close;
407         w->pre_select = alsa_write_pre_select;
408         w->pre_select_btr = alsa_write_pre_select_btr;
409         w->post_select = alsa_write_post_select;
410         w->post_select_btr = alsa_write_post_select_btr;
411         w->parse_config = alsa_parse_config;
412         w->shutdown = NULL; /* nothing to do */
413         w->free_config = alsa_free_config;
414         w->help = (struct ggo_help) {
415                 .short_help = alsa_write_args_info_help,
416                 .detailed_help = alsa_write_args_info_detailed_help
417         };
418         alsa_cmdline_parser_free(&dummy);
419 }