ia64/xen-unstable

view tools/ioemu/audio/alsaaudio.c @ 15841:c5f735271e22

[IA64] Foreign p2m: Fix vti domain builder.

It should set arch_domain::convmem_end.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Alex Williamson <alex.williamson@hp.com>
date Thu Sep 06 13:48:43 2007 -0600 (2007-09-06)
parents 08a11694b109
children
line source
1 /*
2 * QEMU ALSA audio driver
3 *
4 * Copyright (c) 2005 Vassili Karpov (malc)
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include <alsa/asoundlib.h>
25 #include "vl.h"
27 #define AUDIO_CAP "alsa"
28 #include "audio_int.h"
30 typedef struct ALSAVoiceOut {
31 HWVoiceOut hw;
32 void *pcm_buf;
33 snd_pcm_t *handle;
34 } ALSAVoiceOut;
36 typedef struct ALSAVoiceIn {
37 HWVoiceIn hw;
38 snd_pcm_t *handle;
39 void *pcm_buf;
40 } ALSAVoiceIn;
42 static struct {
43 int size_in_usec_in;
44 int size_in_usec_out;
45 const char *pcm_name_in;
46 const char *pcm_name_out;
47 unsigned int buffer_size_in;
48 unsigned int period_size_in;
49 unsigned int buffer_size_out;
50 unsigned int period_size_out;
51 unsigned int threshold;
53 int buffer_size_in_overriden;
54 int period_size_in_overriden;
56 int buffer_size_out_overriden;
57 int period_size_out_overriden;
58 int verbose;
59 } conf = {
60 #ifdef HIGH_LATENCY
61 .size_in_usec_in = 1,
62 .size_in_usec_out = 1,
63 #endif
64 .pcm_name_out = "default",
65 .pcm_name_in = "default",
66 #ifdef HIGH_LATENCY
67 .buffer_size_in = 400000,
68 .period_size_in = 400000 / 4,
69 .buffer_size_out = 400000,
70 .period_size_out = 400000 / 4,
71 #else
72 #define DEFAULT_BUFFER_SIZE 1024
73 #define DEFAULT_PERIOD_SIZE 256
74 .buffer_size_in = DEFAULT_BUFFER_SIZE * 4,
75 .period_size_in = DEFAULT_PERIOD_SIZE * 4,
76 .buffer_size_out = DEFAULT_BUFFER_SIZE,
77 .period_size_out = DEFAULT_PERIOD_SIZE,
78 .buffer_size_in_overriden = 0,
79 .buffer_size_out_overriden = 0,
80 .period_size_in_overriden = 0,
81 .period_size_out_overriden = 0,
82 #endif
83 .threshold = 0,
84 .verbose = 0
85 };
87 struct alsa_params_req {
88 int freq;
89 audfmt_e fmt;
90 int nchannels;
91 unsigned int buffer_size;
92 unsigned int period_size;
93 };
95 struct alsa_params_obt {
96 int freq;
97 audfmt_e fmt;
98 int nchannels;
99 snd_pcm_uframes_t samples;
100 };
102 static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
103 {
104 va_list ap;
106 va_start (ap, fmt);
107 AUD_vlog (AUDIO_CAP, fmt, ap);
108 va_end (ap);
110 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
111 }
113 static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (
114 int err,
115 const char *typ,
116 const char *fmt,
117 ...
118 )
119 {
120 va_list ap;
122 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
124 va_start (ap, fmt);
125 AUD_vlog (AUDIO_CAP, fmt, ap);
126 va_end (ap);
128 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
129 }
131 static void alsa_anal_close (snd_pcm_t **handlep)
132 {
133 int err = snd_pcm_close (*handlep);
134 if (err) {
135 alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep);
136 }
137 *handlep = NULL;
138 }
140 static int alsa_write (SWVoiceOut *sw, void *buf, int len)
141 {
142 return audio_pcm_sw_write (sw, buf, len);
143 }
145 static int aud_to_alsafmt (audfmt_e fmt)
146 {
147 switch (fmt) {
148 case AUD_FMT_S8:
149 return SND_PCM_FORMAT_S8;
151 case AUD_FMT_U8:
152 return SND_PCM_FORMAT_U8;
154 case AUD_FMT_S16:
155 return SND_PCM_FORMAT_S16_LE;
157 case AUD_FMT_U16:
158 return SND_PCM_FORMAT_U16_LE;
160 default:
161 dolog ("Internal logic error: Bad audio format %d\n", fmt);
162 #ifdef DEBUG_AUDIO
163 abort ();
164 #endif
165 return SND_PCM_FORMAT_U8;
166 }
167 }
169 static int alsa_to_audfmt (int alsafmt, audfmt_e *fmt, int *endianness)
170 {
171 switch (alsafmt) {
172 case SND_PCM_FORMAT_S8:
173 *endianness = 0;
174 *fmt = AUD_FMT_S8;
175 break;
177 case SND_PCM_FORMAT_U8:
178 *endianness = 0;
179 *fmt = AUD_FMT_U8;
180 break;
182 case SND_PCM_FORMAT_S16_LE:
183 *endianness = 0;
184 *fmt = AUD_FMT_S16;
185 break;
187 case SND_PCM_FORMAT_U16_LE:
188 *endianness = 0;
189 *fmt = AUD_FMT_U16;
190 break;
192 case SND_PCM_FORMAT_S16_BE:
193 *endianness = 1;
194 *fmt = AUD_FMT_S16;
195 break;
197 case SND_PCM_FORMAT_U16_BE:
198 *endianness = 1;
199 *fmt = AUD_FMT_U16;
200 break;
202 default:
203 dolog ("Unrecognized audio format %d\n", alsafmt);
204 return -1;
205 }
207 return 0;
208 }
210 #if defined DEBUG_MISMATCHES || defined DEBUG
211 static void alsa_dump_info (struct alsa_params_req *req,
212 struct alsa_params_obt *obt)
213 {
214 dolog ("parameter | requested value | obtained value\n");
215 dolog ("format | %10d | %10d\n", req->fmt, obt->fmt);
216 dolog ("channels | %10d | %10d\n",
217 req->nchannels, obt->nchannels);
218 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq);
219 dolog ("============================================\n");
220 dolog ("requested: buffer size %d period size %d\n",
221 req->buffer_size, req->period_size);
222 dolog ("obtained: samples %ld\n", obt->samples);
223 }
224 #endif
226 static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold)
227 {
228 int err;
229 snd_pcm_sw_params_t *sw_params;
231 snd_pcm_sw_params_alloca (&sw_params);
233 err = snd_pcm_sw_params_current (handle, sw_params);
234 if (err < 0) {
235 dolog ("Could not fully initialize DAC\n");
236 alsa_logerr (err, "Failed to get current software parameters\n");
237 return;
238 }
240 err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold);
241 if (err < 0) {
242 dolog ("Could not fully initialize DAC\n");
243 alsa_logerr (err, "Failed to set software threshold to %ld\n",
244 threshold);
245 return;
246 }
248 err = snd_pcm_sw_params (handle, sw_params);
249 if (err < 0) {
250 dolog ("Could not fully initialize DAC\n");
251 alsa_logerr (err, "Failed to set software parameters\n");
252 return;
253 }
254 }
256 static int alsa_open (int in, struct alsa_params_req *req,
257 struct alsa_params_obt *obt, snd_pcm_t **handlep)
258 {
259 snd_pcm_t *handle;
260 snd_pcm_hw_params_t *hw_params;
261 int err, freq, nchannels;
262 const char *pcm_name = in ? conf.pcm_name_in : conf.pcm_name_out;
263 unsigned int period_size, buffer_size;
264 snd_pcm_uframes_t obt_buffer_size;
265 const char *typ = in ? "ADC" : "DAC";
267 freq = req->freq;
268 period_size = req->period_size;
269 buffer_size = req->buffer_size;
270 nchannels = req->nchannels;
272 snd_pcm_hw_params_alloca (&hw_params);
274 err = snd_pcm_open (
275 &handle,
276 pcm_name,
277 in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
278 SND_PCM_NONBLOCK
279 );
280 if (err < 0) {
281 alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name);
282 return -1;
283 }
285 err = snd_pcm_hw_params_any (handle, hw_params);
286 if (err < 0) {
287 alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n");
288 goto err;
289 }
291 err = snd_pcm_hw_params_set_access (
292 handle,
293 hw_params,
294 SND_PCM_ACCESS_RW_INTERLEAVED
295 );
296 if (err < 0) {
297 alsa_logerr2 (err, typ, "Failed to set access type\n");
298 goto err;
299 }
301 err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt);
302 if (err < 0) {
303 alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt);
304 goto err;
305 }
307 err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0);
308 if (err < 0) {
309 alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq);
310 goto err;
311 }
313 err = snd_pcm_hw_params_set_channels_near (
314 handle,
315 hw_params,
316 &nchannels
317 );
318 if (err < 0) {
319 alsa_logerr2 (err, typ, "Failed to set number of channels %d\n",
320 req->nchannels);
321 goto err;
322 }
324 if (nchannels != 1 && nchannels != 2) {
325 alsa_logerr2 (err, typ,
326 "Can not handle obtained number of channels %d\n",
327 nchannels);
328 goto err;
329 }
331 if (!((in && conf.size_in_usec_in) || (!in && conf.size_in_usec_out))) {
332 if (!buffer_size) {
333 buffer_size = DEFAULT_BUFFER_SIZE;
334 period_size= DEFAULT_PERIOD_SIZE;
335 }
336 }
338 if (buffer_size) {
339 if ((in && conf.size_in_usec_in) || (!in && conf.size_in_usec_out)) {
340 if (period_size) {
341 err = snd_pcm_hw_params_set_period_time_near (
342 handle,
343 hw_params,
344 &period_size,
345 0
346 );
347 if (err < 0) {
348 alsa_logerr2 (err, typ,
349 "Failed to set period time %d\n",
350 req->period_size);
351 goto err;
352 }
353 }
355 err = snd_pcm_hw_params_set_buffer_time_near (
356 handle,
357 hw_params,
358 &buffer_size,
359 0
360 );
362 if (err < 0) {
363 alsa_logerr2 (err, typ,
364 "Failed to set buffer time %d\n",
365 req->buffer_size);
366 goto err;
367 }
368 }
369 else {
370 int dir;
371 snd_pcm_uframes_t minval;
373 if (period_size) {
374 minval = period_size;
375 dir = 0;
377 err = snd_pcm_hw_params_get_period_size_min (
378 hw_params,
379 &minval,
380 &dir
381 );
382 if (err < 0) {
383 alsa_logerr (
384 err,
385 "Could not get minmal period size for %s\n",
386 typ
387 );
388 }
389 else {
390 if (period_size < minval) {
391 if ((in && conf.period_size_in_overriden)
392 || (!in && conf.period_size_out_overriden)) {
393 dolog ("%s period size(%d) is less "
394 "than minmal period size(%ld)\n",
395 typ,
396 period_size,
397 minval);
398 }
399 period_size = minval;
400 }
401 }
403 err = snd_pcm_hw_params_set_period_size (
404 handle,
405 hw_params,
406 period_size,
407 0
408 );
409 if (err < 0) {
410 alsa_logerr2 (err, typ, "Failed to set period size %d\n",
411 req->period_size);
412 goto err;
413 }
414 }
416 minval = buffer_size;
417 err = snd_pcm_hw_params_get_buffer_size_min (
418 hw_params,
419 &minval
420 );
421 if (err < 0) {
422 alsa_logerr (err, "Could not get minmal buffer size for %s\n",
423 typ);
424 }
425 else {
426 if (buffer_size < minval) {
427 if ((in && conf.buffer_size_in_overriden)
428 || (!in && conf.buffer_size_out_overriden)) {
429 dolog (
430 "%s buffer size(%d) is less "
431 "than minimal buffer size(%ld)\n",
432 typ,
433 buffer_size,
434 minval
435 );
436 }
437 buffer_size = minval;
438 }
439 }
441 err = snd_pcm_hw_params_set_buffer_size (
442 handle,
443 hw_params,
444 buffer_size
445 );
446 if (err < 0) {
447 alsa_logerr2 (err, typ, "Failed to set buffer size %d\n",
448 req->buffer_size);
449 goto err;
450 }
451 }
452 }
453 else {
454 dolog ("warning: Buffer size is not set\n");
455 }
457 err = snd_pcm_hw_params (handle, hw_params);
458 if (err < 0) {
459 alsa_logerr2 (err, typ, "Failed to apply audio parameters\n");
460 goto err;
461 }
463 err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size);
464 if (err < 0) {
465 alsa_logerr2 (err, typ, "Failed to get buffer size\n");
466 goto err;
467 }
469 err = snd_pcm_prepare (handle);
470 if (err < 0) {
471 alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle);
472 goto err;
473 }
475 if (!in && conf.threshold) {
476 snd_pcm_uframes_t threshold;
477 int bytes_per_sec;
479 bytes_per_sec = freq
480 << (nchannels == 2)
481 << (req->fmt == AUD_FMT_S16 || req->fmt == AUD_FMT_U16);
483 threshold = (conf.threshold * bytes_per_sec) / 1000;
484 alsa_set_threshold (handle, threshold);
485 }
487 obt->fmt = req->fmt;
488 obt->nchannels = nchannels;
489 obt->freq = freq;
490 obt->samples = obt_buffer_size;
491 *handlep = handle;
493 #if defined DEBUG_MISMATCHES || defined DEBUG
494 if (obt->fmt != req->fmt ||
495 obt->nchannels != req->nchannels ||
496 obt->freq != req->freq) {
497 dolog ("Audio paramters mismatch for %s\n", typ);
498 alsa_dump_info (req, obt);
499 }
500 #endif
502 #ifdef DEBUG
503 alsa_dump_info (req, obt);
504 #endif
505 return 0;
507 err:
508 alsa_anal_close (&handle);
509 return -1;
510 }
512 static int alsa_recover (snd_pcm_t *handle)
513 {
514 int err = snd_pcm_prepare (handle);
515 if (err < 0) {
516 alsa_logerr (err, "Failed to prepare handle %p\n", handle);
517 return -1;
518 }
519 return 0;
520 }
522 static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
523 {
524 snd_pcm_sframes_t avail;
526 avail = snd_pcm_avail_update (handle);
527 if (avail < 0) {
528 if (avail == -EPIPE) {
529 if (!alsa_recover (handle)) {
530 avail = snd_pcm_avail_update (handle);
531 }
532 }
534 if (avail < 0) {
535 alsa_logerr (avail,
536 "Could not obtain number of available frames\n");
537 return -1;
538 }
539 }
541 return avail;
542 }
544 static int alsa_run_out (HWVoiceOut *hw)
545 {
546 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
547 int rpos, live, decr;
548 int samples;
549 uint8_t *dst;
550 st_sample_t *src;
551 snd_pcm_sframes_t avail;
553 live = audio_pcm_hw_get_live_out (hw);
554 if (!live) {
555 return 0;
556 }
558 avail = alsa_get_avail (alsa->handle);
559 if (avail < 0) {
560 dolog ("Could not get number of available playback frames\n");
561 return 0;
562 }
564 decr = audio_MIN (live, avail);
565 samples = decr;
566 rpos = hw->rpos;
567 while (samples) {
568 int left_till_end_samples = hw->samples - rpos;
569 int len = audio_MIN (samples, left_till_end_samples);
570 snd_pcm_sframes_t written;
572 src = hw->mix_buf + rpos;
573 dst = advance (alsa->pcm_buf, rpos << hw->info.shift);
575 hw->clip (dst, src, len);
577 while (len) {
578 written = snd_pcm_writei (alsa->handle, dst, len);
580 if (written <= 0) {
581 switch (written) {
582 case 0:
583 if (conf.verbose) {
584 dolog ("Failed to write %d frames (wrote zero)\n", len);
585 }
586 goto exit;
588 case -EPIPE:
589 if (alsa_recover (alsa->handle)) {
590 alsa_logerr (written, "Failed to write %d frames\n",
591 len);
592 goto exit;
593 }
594 if (conf.verbose) {
595 dolog ("Recovering from playback xrun\n");
596 }
597 continue;
599 case -EAGAIN:
600 goto exit;
602 default:
603 alsa_logerr (written, "Failed to write %d frames to %p\n",
604 len, dst);
605 goto exit;
606 }
607 }
609 rpos = (rpos + written) % hw->samples;
610 samples -= written;
611 len -= written;
612 dst = advance (dst, written << hw->info.shift);
613 src += written;
614 }
615 }
617 exit:
618 hw->rpos = rpos;
619 return decr;
620 }
622 static void alsa_fini_out (HWVoiceOut *hw)
623 {
624 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
626 ldebug ("alsa_fini\n");
627 alsa_anal_close (&alsa->handle);
629 if (alsa->pcm_buf) {
630 qemu_free (alsa->pcm_buf);
631 alsa->pcm_buf = NULL;
632 }
633 }
635 static int alsa_init_out (HWVoiceOut *hw, audsettings_t *as)
636 {
637 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
638 struct alsa_params_req req;
639 struct alsa_params_obt obt;
640 audfmt_e effective_fmt;
641 int endianness;
642 int err;
643 snd_pcm_t *handle;
644 audsettings_t obt_as;
646 req.fmt = aud_to_alsafmt (as->fmt);
647 req.freq = as->freq;
648 req.nchannels = as->nchannels;
649 req.period_size = conf.period_size_out;
650 req.buffer_size = conf.buffer_size_out;
652 if (alsa_open (0, &req, &obt, &handle)) {
653 return -1;
654 }
656 err = alsa_to_audfmt (obt.fmt, &effective_fmt, &endianness);
657 if (err) {
658 alsa_anal_close (&handle);
659 return -1;
660 }
662 obt_as.freq = obt.freq;
663 obt_as.nchannels = obt.nchannels;
664 obt_as.fmt = effective_fmt;
665 obt_as.endianness = endianness;
667 audio_pcm_init_info (&hw->info, &obt_as);
668 hw->samples = obt.samples;
670 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);
671 if (!alsa->pcm_buf) {
672 dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
673 hw->samples, 1 << hw->info.shift);
674 alsa_anal_close (&handle);
675 return -1;
676 }
678 alsa->handle = handle;
679 return 0;
680 }
682 static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause)
683 {
684 int err;
686 if (pause) {
687 err = snd_pcm_drop (handle);
688 if (err < 0) {
689 alsa_logerr (err, "Could not stop %s\n", typ);
690 return -1;
691 }
692 }
693 else {
694 err = snd_pcm_prepare (handle);
695 if (err < 0) {
696 alsa_logerr (err, "Could not prepare handle for %s\n", typ);
697 return -1;
698 }
699 }
701 return 0;
702 }
704 static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
705 {
706 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
708 switch (cmd) {
709 case VOICE_ENABLE:
710 ldebug ("enabling voice\n");
711 return alsa_voice_ctl (alsa->handle, "playback", 0);
713 case VOICE_DISABLE:
714 ldebug ("disabling voice\n");
715 return alsa_voice_ctl (alsa->handle, "playback", 1);
716 }
718 return -1;
719 }
721 static int alsa_init_in (HWVoiceIn *hw, audsettings_t *as)
722 {
723 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
724 struct alsa_params_req req;
725 struct alsa_params_obt obt;
726 int endianness;
727 int err;
728 audfmt_e effective_fmt;
729 snd_pcm_t *handle;
730 audsettings_t obt_as;
732 req.fmt = aud_to_alsafmt (as->fmt);
733 req.freq = as->freq;
734 req.nchannels = as->nchannels;
735 req.period_size = conf.period_size_in;
736 req.buffer_size = conf.buffer_size_in;
738 if (alsa_open (1, &req, &obt, &handle)) {
739 return -1;
740 }
742 err = alsa_to_audfmt (obt.fmt, &effective_fmt, &endianness);
743 if (err) {
744 alsa_anal_close (&handle);
745 return -1;
746 }
748 obt_as.freq = obt.freq;
749 obt_as.nchannels = obt.nchannels;
750 obt_as.fmt = effective_fmt;
751 obt_as.endianness = endianness;
753 audio_pcm_init_info (&hw->info, &obt_as);
754 hw->samples = obt.samples;
756 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
757 if (!alsa->pcm_buf) {
758 dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
759 hw->samples, 1 << hw->info.shift);
760 alsa_anal_close (&handle);
761 return -1;
762 }
764 alsa->handle = handle;
765 return 0;
766 }
768 static void alsa_fini_in (HWVoiceIn *hw)
769 {
770 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
772 alsa_anal_close (&alsa->handle);
774 if (alsa->pcm_buf) {
775 qemu_free (alsa->pcm_buf);
776 alsa->pcm_buf = NULL;
777 }
778 }
780 static int alsa_run_in (HWVoiceIn *hw)
781 {
782 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
783 int hwshift = hw->info.shift;
784 int i;
785 int live = audio_pcm_hw_get_live_in (hw);
786 int dead = hw->samples - live;
787 int decr;
788 struct {
789 int add;
790 int len;
791 } bufs[2] = {
792 { hw->wpos, 0 },
793 { 0, 0 }
794 };
795 snd_pcm_sframes_t avail;
796 snd_pcm_uframes_t read_samples = 0;
798 if (!dead) {
799 return 0;
800 }
802 avail = alsa_get_avail (alsa->handle);
803 if (avail < 0) {
804 dolog ("Could not get number of captured frames\n");
805 return 0;
806 }
808 if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) {
809 avail = hw->samples;
810 }
812 decr = audio_MIN (dead, avail);
813 if (!decr) {
814 return 0;
815 }
817 if (hw->wpos + decr > hw->samples) {
818 bufs[0].len = (hw->samples - hw->wpos);
819 bufs[1].len = (decr - (hw->samples - hw->wpos));
820 }
821 else {
822 bufs[0].len = decr;
823 }
825 for (i = 0; i < 2; ++i) {
826 void *src;
827 st_sample_t *dst;
828 snd_pcm_sframes_t nread;
829 snd_pcm_uframes_t len;
831 len = bufs[i].len;
833 src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
834 dst = hw->conv_buf + bufs[i].add;
836 while (len) {
837 nread = snd_pcm_readi (alsa->handle, src, len);
839 if (nread <= 0) {
840 switch (nread) {
841 case 0:
842 if (conf.verbose) {
843 dolog ("Failed to read %ld frames (read zero)\n", len);
844 }
845 goto exit;
847 case -EPIPE:
848 if (alsa_recover (alsa->handle)) {
849 alsa_logerr (nread, "Failed to read %ld frames\n", len);
850 goto exit;
851 }
852 if (conf.verbose) {
853 dolog ("Recovering from capture xrun\n");
854 }
855 continue;
857 case -EAGAIN:
858 goto exit;
860 default:
861 alsa_logerr (
862 nread,
863 "Failed to read %ld frames from %p\n",
864 len,
865 src
866 );
867 goto exit;
868 }
869 }
871 hw->conv (dst, src, nread, &nominal_volume);
873 src = advance (src, nread << hwshift);
874 dst += nread;
876 read_samples += nread;
877 len -= nread;
878 }
879 }
881 exit:
882 hw->wpos = (hw->wpos + read_samples) % hw->samples;
883 return read_samples;
884 }
886 static int alsa_read (SWVoiceIn *sw, void *buf, int size)
887 {
888 return audio_pcm_sw_read (sw, buf, size);
889 }
891 static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
892 {
893 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
895 switch (cmd) {
896 case VOICE_ENABLE:
897 ldebug ("enabling voice\n");
898 return alsa_voice_ctl (alsa->handle, "capture", 0);
900 case VOICE_DISABLE:
901 ldebug ("disabling voice\n");
902 return alsa_voice_ctl (alsa->handle, "capture", 1);
903 }
905 return -1;
906 }
908 static void *alsa_audio_init (void)
909 {
910 return &conf;
911 }
913 static void alsa_audio_fini (void *opaque)
914 {
915 (void) opaque;
916 }
918 static struct audio_option alsa_options[] = {
919 {"DAC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_out,
920 "DAC period/buffer size in microseconds (otherwise in frames)", NULL, 0},
921 {"DAC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_out,
922 "DAC period size", &conf.period_size_out_overriden, 0},
923 {"DAC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_out,
924 "DAC buffer size", &conf.buffer_size_out_overriden, 0},
926 {"ADC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_in,
927 "ADC period/buffer size in microseconds (otherwise in frames)", NULL, 0},
928 {"ADC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_in,
929 "ADC period size", &conf.period_size_in_overriden, 0},
930 {"ADC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_in,
931 "ADC buffer size", &conf.buffer_size_in_overriden, 0},
933 {"THRESHOLD", AUD_OPT_INT, &conf.threshold,
934 "(undocumented)", NULL, 0},
936 {"DAC_DEV", AUD_OPT_STR, &conf.pcm_name_out,
937 "DAC device name (for instance dmix)", NULL, 0},
939 {"ADC_DEV", AUD_OPT_STR, &conf.pcm_name_in,
940 "ADC device name", NULL, 0},
942 {"VERBOSE", AUD_OPT_BOOL, &conf.verbose,
943 "Behave in a more verbose way", NULL, 0},
945 {NULL, 0, NULL, NULL, NULL, 0}
946 };
948 static struct audio_pcm_ops alsa_pcm_ops = {
949 alsa_init_out,
950 alsa_fini_out,
951 alsa_run_out,
952 alsa_write,
953 alsa_ctl_out,
955 alsa_init_in,
956 alsa_fini_in,
957 alsa_run_in,
958 alsa_read,
959 alsa_ctl_in
960 };
962 struct audio_driver alsa_audio_driver = {
963 INIT_FIELD (name = ) "alsa",
964 INIT_FIELD (descr = ) "ALSA http://www.alsa-project.org",
965 INIT_FIELD (options = ) alsa_options,
966 INIT_FIELD (init = ) alsa_audio_init,
967 INIT_FIELD (fini = ) alsa_audio_fini,
968 INIT_FIELD (pcm_ops = ) &alsa_pcm_ops,
969 INIT_FIELD (can_be_default = ) 1,
970 INIT_FIELD (max_voices_out = ) INT_MAX,
971 INIT_FIELD (max_voices_in = ) INT_MAX,
972 INIT_FIELD (voice_size_out = ) sizeof (ALSAVoiceOut),
973 INIT_FIELD (voice_size_in = ) sizeof (ALSAVoiceIn)
974 };