![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to alsaaudio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / audio|
Return to alsaaudio.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / audio |
1.1 root 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"
26:
27: #define AUDIO_CAP "alsa"
28: #include "audio_int.h"
29:
30: typedef struct ALSAVoiceOut {
31: HWVoiceOut hw;
32: void *pcm_buf;
33: snd_pcm_t *handle;
34: } ALSAVoiceOut;
35:
36: typedef struct ALSAVoiceIn {
37: HWVoiceIn hw;
38: snd_pcm_t *handle;
39: void *pcm_buf;
40: } ALSAVoiceIn;
41:
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;
52:
53: int buffer_size_in_overriden;
54: int period_size_in_overriden;
55:
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 = "hw:0,0",
65: .pcm_name_in = "hw:0,0",
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: };
86:
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: };
94:
95: struct alsa_params_obt {
96: int freq;
97: audfmt_e fmt;
98: int nchannels;
99: snd_pcm_uframes_t samples;
100: };
101:
102: static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
103: {
104: va_list ap;
105:
106: va_start (ap, fmt);
107: AUD_vlog (AUDIO_CAP, fmt, ap);
108: va_end (ap);
109:
110: AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
111: }
112:
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;
121:
122: AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
123:
124: va_start (ap, fmt);
125: AUD_vlog (AUDIO_CAP, fmt, ap);
126: va_end (ap);
127:
128: AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
129: }
130:
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: }
139:
140: static int alsa_write (SWVoiceOut *sw, void *buf, int len)
141: {
142: return audio_pcm_sw_write (sw, buf, len);
143: }
144:
145: static int aud_to_alsafmt (audfmt_e fmt)
146: {
147: switch (fmt) {
148: case AUD_FMT_S8:
149: return SND_PCM_FORMAT_S8;
150:
151: case AUD_FMT_U8:
152: return SND_PCM_FORMAT_U8;
153:
154: case AUD_FMT_S16:
155: return SND_PCM_FORMAT_S16_LE;
156:
157: case AUD_FMT_U16:
158: return SND_PCM_FORMAT_U16_LE;
159:
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: }
168:
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;
176:
177: case SND_PCM_FORMAT_U8:
178: *endianness = 0;
179: *fmt = AUD_FMT_U8;
180: break;
181:
182: case SND_PCM_FORMAT_S16_LE:
183: *endianness = 0;
184: *fmt = AUD_FMT_S16;
185: break;
186:
187: case SND_PCM_FORMAT_U16_LE:
188: *endianness = 0;
189: *fmt = AUD_FMT_U16;
190: break;
191:
192: case SND_PCM_FORMAT_S16_BE:
193: *endianness = 1;
194: *fmt = AUD_FMT_S16;
195: break;
196:
197: case SND_PCM_FORMAT_U16_BE:
198: *endianness = 1;
199: *fmt = AUD_FMT_U16;
200: break;
201:
202: default:
203: dolog ("Unrecognized audio format %d\n", alsafmt);
204: return -1;
205: }
206:
207: return 0;
208: }
209:
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
225:
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;
230:
231: snd_pcm_sw_params_alloca (&sw_params);
232:
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: }
239:
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: }
247:
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: }
255:
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";
266:
267: freq = req->freq;
268: period_size = req->period_size;
269: buffer_size = req->buffer_size;
270: nchannels = req->nchannels;
271:
272: snd_pcm_hw_params_alloca (&hw_params);
273:
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: }
284:
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: }
290:
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: }
300:
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: }
306:
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: }
312:
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: }
323:
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: }
330:
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: }
337:
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: }
354:
355: err = snd_pcm_hw_params_set_buffer_time_near (
356: handle,
357: hw_params,
358: &buffer_size,
359: 0
360: );
361:
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;
372:
373: if (period_size) {
374: minval = period_size;
375: dir = 0;
376:
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: }
402:
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: }
415:
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: }
440:
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: }
456:
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: }
462:
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: }
468:
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: }
474:
475: if (!in && conf.threshold) {
476: snd_pcm_uframes_t threshold;
477: int bytes_per_sec;
478:
479: bytes_per_sec = freq
480: << (nchannels == 2)
481: << (req->fmt == AUD_FMT_S16 || req->fmt == AUD_FMT_U16);
482:
483: threshold = (conf.threshold * bytes_per_sec) / 1000;
484: alsa_set_threshold (handle, threshold);
485: }
486:
487: obt->fmt = req->fmt;
488: obt->nchannels = nchannels;
489: obt->freq = freq;
490: obt->samples = obt_buffer_size;
491: *handlep = handle;
492:
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
501:
502: #ifdef DEBUG
503: alsa_dump_info (req, obt);
504: #endif
505: return 0;
506:
507: err:
508: alsa_anal_close (&handle);
509: return -1;
510: }
511:
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: }
521:
522: static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
523: {
524: snd_pcm_sframes_t avail;
525:
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: }
533:
534: if (avail < 0) {
535: alsa_logerr (avail,
536: "Could not obtain number of available frames\n");
537: return -1;
538: }
539: }
540:
541: return avail;
542: }
543:
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;
552:
553: live = audio_pcm_hw_get_live_out (hw);
554: if (!live) {
555: return 0;
556: }
557:
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: }
563:
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;
571:
572: src = hw->mix_buf + rpos;
573: dst = advance (alsa->pcm_buf, rpos << hw->info.shift);
574:
575: hw->clip (dst, src, len);
576:
577: while (len) {
578: written = snd_pcm_writei (alsa->handle, dst, len);
579:
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;
587:
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;
598:
599: case -EAGAIN:
600: goto exit;
601:
602: default:
603: alsa_logerr (written, "Failed to write %d frames to %p\n",
604: len, dst);
605: goto exit;
606: }
607: }
608:
609: mixeng_clear (src, written);
610: rpos = (rpos + written) % hw->samples;
611: samples -= written;
612: len -= written;
613: dst = advance (dst, written << hw->info.shift);
614: src += written;
615: }
616: }
617:
618: exit:
619: hw->rpos = rpos;
620: return decr;
621: }
622:
623: static void alsa_fini_out (HWVoiceOut *hw)
624: {
625: ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
626:
627: ldebug ("alsa_fini\n");
628: alsa_anal_close (&alsa->handle);
629:
630: if (alsa->pcm_buf) {
631: qemu_free (alsa->pcm_buf);
632: alsa->pcm_buf = NULL;
633: }
634: }
635:
636: static int alsa_init_out (HWVoiceOut *hw, audsettings_t *as)
637: {
638: ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
639: struct alsa_params_req req;
640: struct alsa_params_obt obt;
641: audfmt_e effective_fmt;
642: int endianness;
643: int err;
644: snd_pcm_t *handle;
645: audsettings_t obt_as;
646:
647: req.fmt = aud_to_alsafmt (as->fmt);
648: req.freq = as->freq;
649: req.nchannels = as->nchannels;
650: req.period_size = conf.period_size_out;
651: req.buffer_size = conf.buffer_size_out;
652:
653: if (alsa_open (0, &req, &obt, &handle)) {
654: return -1;
655: }
656:
657: err = alsa_to_audfmt (obt.fmt, &effective_fmt, &endianness);
658: if (err) {
659: alsa_anal_close (&handle);
660: return -1;
661: }
662:
663: obt_as.freq = obt.freq;
664: obt_as.nchannels = obt.nchannels;
665: obt_as.fmt = effective_fmt;
666:
667: audio_pcm_init_info (
668: &hw->info,
669: &obt_as,
670: audio_need_to_swap_endian (endianness)
671: );
672: hw->samples = obt.samples;
673:
674: alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);
675: if (!alsa->pcm_buf) {
676: dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
677: hw->samples, 1 << hw->info.shift);
678: alsa_anal_close (&handle);
679: return -1;
680: }
681:
682: alsa->handle = handle;
683: return 0;
684: }
685:
686: static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause)
687: {
688: int err;
689:
690: if (pause) {
691: err = snd_pcm_drop (handle);
692: if (err < 0) {
693: alsa_logerr (err, "Could not stop %s\n", typ);
694: return -1;
695: }
696: }
697: else {
698: err = snd_pcm_prepare (handle);
699: if (err < 0) {
700: alsa_logerr (err, "Could not prepare handle for %s\n", typ);
701: return -1;
702: }
703: }
704:
705: return 0;
706: }
707:
708: static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
709: {
710: ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
711:
712: switch (cmd) {
713: case VOICE_ENABLE:
714: ldebug ("enabling voice\n");
715: return alsa_voice_ctl (alsa->handle, "playback", 0);
716:
717: case VOICE_DISABLE:
718: ldebug ("disabling voice\n");
719: return alsa_voice_ctl (alsa->handle, "playback", 1);
720: }
721:
722: return -1;
723: }
724:
725: static int alsa_init_in (HWVoiceIn *hw, audsettings_t *as)
726: {
727: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
728: struct alsa_params_req req;
729: struct alsa_params_obt obt;
730: int endianness;
731: int err;
732: audfmt_e effective_fmt;
733: snd_pcm_t *handle;
734: audsettings_t obt_as;
735:
736: req.fmt = aud_to_alsafmt (as->fmt);
737: req.freq = as->freq;
738: req.nchannels = as->nchannels;
739: req.period_size = conf.period_size_in;
740: req.buffer_size = conf.buffer_size_in;
741:
742: if (alsa_open (1, &req, &obt, &handle)) {
743: return -1;
744: }
745:
746: err = alsa_to_audfmt (obt.fmt, &effective_fmt, &endianness);
747: if (err) {
748: alsa_anal_close (&handle);
749: return -1;
750: }
751:
752: obt_as.freq = obt.freq;
753: obt_as.nchannels = obt.nchannels;
754: obt_as.fmt = effective_fmt;
755:
756: audio_pcm_init_info (
757: &hw->info,
758: &obt_as,
759: audio_need_to_swap_endian (endianness)
760: );
761: hw->samples = obt.samples;
762:
763: alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
764: if (!alsa->pcm_buf) {
765: dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
766: hw->samples, 1 << hw->info.shift);
767: alsa_anal_close (&handle);
768: return -1;
769: }
770:
771: alsa->handle = handle;
772: return 0;
773: }
774:
775: static void alsa_fini_in (HWVoiceIn *hw)
776: {
777: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
778:
779: alsa_anal_close (&alsa->handle);
780:
781: if (alsa->pcm_buf) {
782: qemu_free (alsa->pcm_buf);
783: alsa->pcm_buf = NULL;
784: }
785: }
786:
787: static int alsa_run_in (HWVoiceIn *hw)
788: {
789: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
790: int hwshift = hw->info.shift;
791: int i;
792: int live = audio_pcm_hw_get_live_in (hw);
793: int dead = hw->samples - live;
794: int decr;
795: struct {
796: int add;
797: int len;
798: } bufs[2] = {
799: { hw->wpos, 0 },
800: { 0, 0 }
801: };
802: snd_pcm_sframes_t avail;
803: snd_pcm_uframes_t read_samples = 0;
804:
805: if (!dead) {
806: return 0;
807: }
808:
809: avail = alsa_get_avail (alsa->handle);
810: if (avail < 0) {
811: dolog ("Could not get number of captured frames\n");
812: return 0;
813: }
814:
815: if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) {
816: avail = hw->samples;
817: }
818:
819: decr = audio_MIN (dead, avail);
820: if (!decr) {
821: return 0;
822: }
823:
824: if (hw->wpos + decr > hw->samples) {
825: bufs[0].len = (hw->samples - hw->wpos);
826: bufs[1].len = (decr - (hw->samples - hw->wpos));
827: }
828: else {
829: bufs[0].len = decr;
830: }
831:
832: for (i = 0; i < 2; ++i) {
833: void *src;
834: st_sample_t *dst;
835: snd_pcm_sframes_t nread;
836: snd_pcm_uframes_t len;
837:
838: len = bufs[i].len;
839:
840: src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
841: dst = hw->conv_buf + bufs[i].add;
842:
843: while (len) {
844: nread = snd_pcm_readi (alsa->handle, src, len);
845:
846: if (nread <= 0) {
847: switch (nread) {
848: case 0:
849: if (conf.verbose) {
850: dolog ("Failed to read %ld frames (read zero)\n", len);
851: }
852: goto exit;
853:
854: case -EPIPE:
855: if (alsa_recover (alsa->handle)) {
856: alsa_logerr (nread, "Failed to read %ld frames\n", len);
857: goto exit;
858: }
859: if (conf.verbose) {
860: dolog ("Recovering from capture xrun\n");
861: }
862: continue;
863:
864: case -EAGAIN:
865: goto exit;
866:
867: default:
868: alsa_logerr (
869: nread,
870: "Failed to read %ld frames from %p\n",
871: len,
872: src
873: );
874: goto exit;
875: }
876: }
877:
878: hw->conv (dst, src, nread, &nominal_volume);
879:
880: src = advance (src, nread << hwshift);
881: dst += nread;
882:
883: read_samples += nread;
884: len -= nread;
885: }
886: }
887:
888: exit:
889: hw->wpos = (hw->wpos + read_samples) % hw->samples;
890: return read_samples;
891: }
892:
893: static int alsa_read (SWVoiceIn *sw, void *buf, int size)
894: {
895: return audio_pcm_sw_read (sw, buf, size);
896: }
897:
898: static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
899: {
900: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
901:
902: switch (cmd) {
903: case VOICE_ENABLE:
904: ldebug ("enabling voice\n");
905: return alsa_voice_ctl (alsa->handle, "capture", 0);
906:
907: case VOICE_DISABLE:
908: ldebug ("disabling voice\n");
909: return alsa_voice_ctl (alsa->handle, "capture", 1);
910: }
911:
912: return -1;
913: }
914:
915: static void *alsa_audio_init (void)
916: {
917: return &conf;
918: }
919:
920: static void alsa_audio_fini (void *opaque)
921: {
922: (void) opaque;
923: }
924:
925: static struct audio_option alsa_options[] = {
926: {"DAC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_out,
927: "DAC period/buffer size in microseconds (otherwise in frames)", NULL, 0},
928: {"DAC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_out,
929: "DAC period size", &conf.period_size_out_overriden, 0},
930: {"DAC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_out,
931: "DAC buffer size", &conf.buffer_size_out_overriden, 0},
932:
933: {"ADC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_in,
934: "ADC period/buffer size in microseconds (otherwise in frames)", NULL, 0},
935: {"ADC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_in,
936: "ADC period size", &conf.period_size_in_overriden, 0},
937: {"ADC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_in,
938: "ADC buffer size", &conf.buffer_size_in_overriden, 0},
939:
940: {"THRESHOLD", AUD_OPT_INT, &conf.threshold,
941: "(undocumented)", NULL, 0},
942:
943: {"DAC_DEV", AUD_OPT_STR, &conf.pcm_name_out,
944: "DAC device name (for instance dmix)", NULL, 0},
945:
946: {"ADC_DEV", AUD_OPT_STR, &conf.pcm_name_in,
947: "ADC device name", NULL, 0},
948:
949: {"VERBOSE", AUD_OPT_BOOL, &conf.verbose,
950: "Behave in a more verbose way", NULL, 0},
951:
952: {NULL, 0, NULL, NULL, NULL, 0}
953: };
954:
955: static struct audio_pcm_ops alsa_pcm_ops = {
956: alsa_init_out,
957: alsa_fini_out,
958: alsa_run_out,
959: alsa_write,
960: alsa_ctl_out,
961:
962: alsa_init_in,
963: alsa_fini_in,
964: alsa_run_in,
965: alsa_read,
966: alsa_ctl_in
967: };
968:
969: struct audio_driver alsa_audio_driver = {
970: INIT_FIELD (name = ) "alsa",
971: INIT_FIELD (descr = ) "ALSA http://www.alsa-project.org",
972: INIT_FIELD (options = ) alsa_options,
973: INIT_FIELD (init = ) alsa_audio_init,
974: INIT_FIELD (fini = ) alsa_audio_fini,
975: INIT_FIELD (pcm_ops = ) &alsa_pcm_ops,
976: INIT_FIELD (can_be_default = ) 1,
977: INIT_FIELD (max_voices_out = ) INT_MAX,
978: INIT_FIELD (max_voices_in = ) INT_MAX,
979: INIT_FIELD (voice_size_out = ) sizeof (ALSAVoiceOut),
980: INIT_FIELD (voice_size_in = ) sizeof (ALSAVoiceIn)
981: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.