![[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>
1.1.1.3 root 25: #include "qemu-common.h"
1.1.1.6 root 26: #include "qemu-char.h"
1.1.1.3 root 27: #include "audio.h"
1.1 root 28:
1.1.1.5 root 29: #if QEMU_GNUC_PREREQ(4, 3)
30: #pragma GCC diagnostic ignored "-Waddress"
31: #endif
32:
1.1 root 33: #define AUDIO_CAP "alsa"
34: #include "audio_int.h"
35:
1.1.1.6 root 36: struct pollhlp {
37: snd_pcm_t *handle;
38: struct pollfd *pfds;
39: int count;
40: int mask;
41: };
42:
1.1 root 43: typedef struct ALSAVoiceOut {
44: HWVoiceOut hw;
1.1.1.6 root 45: int wpos;
46: int pending;
1.1 root 47: void *pcm_buf;
48: snd_pcm_t *handle;
1.1.1.6 root 49: struct pollhlp pollhlp;
1.1 root 50: } ALSAVoiceOut;
51:
52: typedef struct ALSAVoiceIn {
53: HWVoiceIn hw;
54: snd_pcm_t *handle;
55: void *pcm_buf;
1.1.1.6 root 56: struct pollhlp pollhlp;
1.1 root 57: } ALSAVoiceIn;
58:
59: static struct {
60: int size_in_usec_in;
61: int size_in_usec_out;
62: const char *pcm_name_in;
63: const char *pcm_name_out;
64: unsigned int buffer_size_in;
65: unsigned int period_size_in;
66: unsigned int buffer_size_out;
67: unsigned int period_size_out;
68: unsigned int threshold;
69:
1.1.1.3 root 70: int buffer_size_in_overridden;
71: int period_size_in_overridden;
1.1 root 72:
1.1.1.3 root 73: int buffer_size_out_overridden;
74: int period_size_out_overridden;
1.1 root 75: int verbose;
76: } conf = {
1.1.1.6 root 77: .buffer_size_out = 4096,
78: .period_size_out = 1024,
1.1.1.2 root 79: .pcm_name_out = "default",
80: .pcm_name_in = "default",
1.1 root 81: };
82:
83: struct alsa_params_req {
1.1.1.4 root 84: int freq;
85: snd_pcm_format_t fmt;
86: int nchannels;
87: int size_in_usec;
88: int override_mask;
1.1 root 89: unsigned int buffer_size;
90: unsigned int period_size;
91: };
92:
93: struct alsa_params_obt {
94: int freq;
95: audfmt_e fmt;
1.1.1.4 root 96: int endianness;
1.1 root 97: int nchannels;
98: snd_pcm_uframes_t samples;
99: };
100:
101: static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
102: {
103: va_list ap;
104:
105: va_start (ap, fmt);
106: AUD_vlog (AUDIO_CAP, fmt, ap);
107: va_end (ap);
108:
109: AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
110: }
111:
112: static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (
113: int err,
114: const char *typ,
115: const char *fmt,
116: ...
117: )
118: {
119: va_list ap;
120:
121: AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
122:
123: va_start (ap, fmt);
124: AUD_vlog (AUDIO_CAP, fmt, ap);
125: va_end (ap);
126:
127: AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
128: }
129:
1.1.1.6 root 130: static void alsa_fini_poll (struct pollhlp *hlp)
131: {
132: int i;
133: struct pollfd *pfds = hlp->pfds;
134:
135: if (pfds) {
136: for (i = 0; i < hlp->count; ++i) {
137: qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);
138: }
139: qemu_free (pfds);
140: }
141: hlp->pfds = NULL;
142: hlp->count = 0;
143: hlp->handle = NULL;
144: }
145:
146: static void alsa_anal_close1 (snd_pcm_t **handlep)
1.1 root 147: {
148: int err = snd_pcm_close (*handlep);
149: if (err) {
150: alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep);
151: }
152: *handlep = NULL;
153: }
154:
1.1.1.6 root 155: static void alsa_anal_close (snd_pcm_t **handlep, struct pollhlp *hlp)
156: {
157: alsa_fini_poll (hlp);
158: alsa_anal_close1 (handlep);
159: }
160:
161: static int alsa_recover (snd_pcm_t *handle)
162: {
163: int err = snd_pcm_prepare (handle);
164: if (err < 0) {
165: alsa_logerr (err, "Failed to prepare handle %p\n", handle);
166: return -1;
167: }
168: return 0;
169: }
170:
171: static int alsa_resume (snd_pcm_t *handle)
172: {
173: int err = snd_pcm_resume (handle);
174: if (err < 0) {
175: alsa_logerr (err, "Failed to resume handle %p\n", handle);
176: return -1;
177: }
178: return 0;
179: }
180:
181: static void alsa_poll_handler (void *opaque)
182: {
183: int err, count;
184: snd_pcm_state_t state;
185: struct pollhlp *hlp = opaque;
186: unsigned short revents;
187:
188: count = poll (hlp->pfds, hlp->count, 0);
189: if (count < 0) {
190: dolog ("alsa_poll_handler: poll %s\n", strerror (errno));
191: return;
192: }
193:
194: if (!count) {
195: return;
196: }
197:
198: /* XXX: ALSA example uses initial count, not the one returned by
199: poll, correct? */
200: err = snd_pcm_poll_descriptors_revents (hlp->handle, hlp->pfds,
201: hlp->count, &revents);
202: if (err < 0) {
203: alsa_logerr (err, "snd_pcm_poll_descriptors_revents");
204: return;
205: }
206:
207: if (!(revents & hlp->mask)) {
208: if (conf.verbose) {
209: dolog ("revents = %d\n", revents);
210: }
211: return;
212: }
213:
214: state = snd_pcm_state (hlp->handle);
215: switch (state) {
1.1.1.7 root 216: case SND_PCM_STATE_SETUP:
217: alsa_recover (hlp->handle);
218: break;
219:
1.1.1.6 root 220: case SND_PCM_STATE_XRUN:
221: alsa_recover (hlp->handle);
222: break;
223:
224: case SND_PCM_STATE_SUSPENDED:
225: alsa_resume (hlp->handle);
226: break;
227:
228: case SND_PCM_STATE_PREPARED:
229: audio_run ("alsa run (prepared)");
230: break;
231:
232: case SND_PCM_STATE_RUNNING:
233: audio_run ("alsa run (running)");
234: break;
235:
236: default:
237: dolog ("Unexpected state %d\n", state);
238: }
239: }
240:
241: static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask)
242: {
243: int i, count, err;
244: struct pollfd *pfds;
245:
246: count = snd_pcm_poll_descriptors_count (handle);
247: if (count <= 0) {
248: dolog ("Could not initialize poll mode\n"
249: "Invalid number of poll descriptors %d\n", count);
250: return -1;
251: }
252:
253: pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds));
254: if (!pfds) {
255: dolog ("Could not initialize poll mode\n");
256: return -1;
257: }
258:
259: err = snd_pcm_poll_descriptors (handle, pfds, count);
260: if (err < 0) {
261: alsa_logerr (err, "Could not initialize poll mode\n"
262: "Could not obtain poll descriptors\n");
263: qemu_free (pfds);
264: return -1;
265: }
266:
267: for (i = 0; i < count; ++i) {
268: if (pfds[i].events & POLLIN) {
269: err = qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler,
270: NULL, hlp);
271: }
272: if (pfds[i].events & POLLOUT) {
273: if (conf.verbose) {
274: dolog ("POLLOUT %d %d\n", i, pfds[i].fd);
275: }
276: err = qemu_set_fd_handler (pfds[i].fd, NULL,
277: alsa_poll_handler, hlp);
278: }
279: if (conf.verbose) {
280: dolog ("Set handler events=%#x index=%d fd=%d err=%d\n",
281: pfds[i].events, i, pfds[i].fd, err);
282: }
283:
284: if (err) {
285: dolog ("Failed to set handler events=%#x index=%d fd=%d err=%d\n",
286: pfds[i].events, i, pfds[i].fd, err);
287:
288: while (i--) {
289: qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);
290: }
291: qemu_free (pfds);
292: return -1;
293: }
294: }
295: hlp->pfds = pfds;
296: hlp->count = count;
297: hlp->handle = handle;
298: hlp->mask = mask;
299: return 0;
300: }
301:
302: static int alsa_poll_out (HWVoiceOut *hw)
303: {
304: ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
305:
306: return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLOUT);
307: }
308:
309: static int alsa_poll_in (HWVoiceIn *hw)
310: {
311: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
312:
313: return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLIN);
314: }
315:
1.1 root 316: static int alsa_write (SWVoiceOut *sw, void *buf, int len)
317: {
318: return audio_pcm_sw_write (sw, buf, len);
319: }
320:
1.1.1.4 root 321: static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt)
1.1 root 322: {
323: switch (fmt) {
324: case AUD_FMT_S8:
325: return SND_PCM_FORMAT_S8;
326:
327: case AUD_FMT_U8:
328: return SND_PCM_FORMAT_U8;
329:
330: case AUD_FMT_S16:
331: return SND_PCM_FORMAT_S16_LE;
332:
333: case AUD_FMT_U16:
334: return SND_PCM_FORMAT_U16_LE;
335:
1.1.1.3 root 336: case AUD_FMT_S32:
337: return SND_PCM_FORMAT_S32_LE;
338:
339: case AUD_FMT_U32:
340: return SND_PCM_FORMAT_U32_LE;
341:
1.1 root 342: default:
343: dolog ("Internal logic error: Bad audio format %d\n", fmt);
344: #ifdef DEBUG_AUDIO
345: abort ();
346: #endif
347: return SND_PCM_FORMAT_U8;
348: }
349: }
350:
1.1.1.4 root 351: static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt,
352: int *endianness)
1.1 root 353: {
354: switch (alsafmt) {
355: case SND_PCM_FORMAT_S8:
356: *endianness = 0;
357: *fmt = AUD_FMT_S8;
358: break;
359:
360: case SND_PCM_FORMAT_U8:
361: *endianness = 0;
362: *fmt = AUD_FMT_U8;
363: break;
364:
365: case SND_PCM_FORMAT_S16_LE:
366: *endianness = 0;
367: *fmt = AUD_FMT_S16;
368: break;
369:
370: case SND_PCM_FORMAT_U16_LE:
371: *endianness = 0;
372: *fmt = AUD_FMT_U16;
373: break;
374:
375: case SND_PCM_FORMAT_S16_BE:
376: *endianness = 1;
377: *fmt = AUD_FMT_S16;
378: break;
379:
380: case SND_PCM_FORMAT_U16_BE:
381: *endianness = 1;
382: *fmt = AUD_FMT_U16;
383: break;
384:
1.1.1.3 root 385: case SND_PCM_FORMAT_S32_LE:
386: *endianness = 0;
387: *fmt = AUD_FMT_S32;
388: break;
389:
390: case SND_PCM_FORMAT_U32_LE:
391: *endianness = 0;
392: *fmt = AUD_FMT_U32;
393: break;
394:
395: case SND_PCM_FORMAT_S32_BE:
396: *endianness = 1;
397: *fmt = AUD_FMT_S32;
398: break;
399:
400: case SND_PCM_FORMAT_U32_BE:
401: *endianness = 1;
402: *fmt = AUD_FMT_U32;
403: break;
404:
1.1 root 405: default:
406: dolog ("Unrecognized audio format %d\n", alsafmt);
407: return -1;
408: }
409:
410: return 0;
411: }
412:
413: static void alsa_dump_info (struct alsa_params_req *req,
1.1.1.8 ! root 414: struct alsa_params_obt *obt,
! 415: snd_pcm_format_t obtfmt)
1.1 root 416: {
417: dolog ("parameter | requested value | obtained value\n");
1.1.1.8 ! root 418: dolog ("format | %10d | %10d\n", req->fmt, obtfmt);
1.1 root 419: dolog ("channels | %10d | %10d\n",
420: req->nchannels, obt->nchannels);
421: dolog ("frequency | %10d | %10d\n", req->freq, obt->freq);
422: dolog ("============================================\n");
423: dolog ("requested: buffer size %d period size %d\n",
424: req->buffer_size, req->period_size);
425: dolog ("obtained: samples %ld\n", obt->samples);
426: }
427:
428: static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold)
429: {
430: int err;
431: snd_pcm_sw_params_t *sw_params;
432:
433: snd_pcm_sw_params_alloca (&sw_params);
434:
435: err = snd_pcm_sw_params_current (handle, sw_params);
436: if (err < 0) {
437: dolog ("Could not fully initialize DAC\n");
438: alsa_logerr (err, "Failed to get current software parameters\n");
439: return;
440: }
441:
442: err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold);
443: if (err < 0) {
444: dolog ("Could not fully initialize DAC\n");
445: alsa_logerr (err, "Failed to set software threshold to %ld\n",
446: threshold);
447: return;
448: }
449:
450: err = snd_pcm_sw_params (handle, sw_params);
451: if (err < 0) {
452: dolog ("Could not fully initialize DAC\n");
453: alsa_logerr (err, "Failed to set software parameters\n");
454: return;
455: }
456: }
457:
458: static int alsa_open (int in, struct alsa_params_req *req,
459: struct alsa_params_obt *obt, snd_pcm_t **handlep)
460: {
461: snd_pcm_t *handle;
462: snd_pcm_hw_params_t *hw_params;
1.1.1.3 root 463: int err;
1.1.1.4 root 464: int size_in_usec;
1.1.1.3 root 465: unsigned int freq, nchannels;
1.1 root 466: const char *pcm_name = in ? conf.pcm_name_in : conf.pcm_name_out;
467: snd_pcm_uframes_t obt_buffer_size;
468: const char *typ = in ? "ADC" : "DAC";
1.1.1.4 root 469: snd_pcm_format_t obtfmt;
1.1 root 470:
471: freq = req->freq;
472: nchannels = req->nchannels;
1.1.1.4 root 473: size_in_usec = req->size_in_usec;
1.1 root 474:
475: snd_pcm_hw_params_alloca (&hw_params);
476:
477: err = snd_pcm_open (
478: &handle,
479: pcm_name,
480: in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
481: SND_PCM_NONBLOCK
482: );
483: if (err < 0) {
484: alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name);
485: return -1;
486: }
487:
488: err = snd_pcm_hw_params_any (handle, hw_params);
489: if (err < 0) {
490: alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n");
491: goto err;
492: }
493:
494: err = snd_pcm_hw_params_set_access (
495: handle,
496: hw_params,
497: SND_PCM_ACCESS_RW_INTERLEAVED
498: );
499: if (err < 0) {
500: alsa_logerr2 (err, typ, "Failed to set access type\n");
501: goto err;
502: }
503:
504: err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt);
1.1.1.4 root 505: if (err < 0 && conf.verbose) {
1.1 root 506: alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt);
507: }
508:
509: err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0);
510: if (err < 0) {
511: alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq);
512: goto err;
513: }
514:
515: err = snd_pcm_hw_params_set_channels_near (
516: handle,
517: hw_params,
518: &nchannels
519: );
520: if (err < 0) {
521: alsa_logerr2 (err, typ, "Failed to set number of channels %d\n",
522: req->nchannels);
523: goto err;
524: }
525:
526: if (nchannels != 1 && nchannels != 2) {
527: alsa_logerr2 (err, typ,
528: "Can not handle obtained number of channels %d\n",
529: nchannels);
530: goto err;
531: }
532:
1.1.1.4 root 533: if (req->buffer_size) {
534: unsigned long obt;
1.1 root 535:
1.1.1.4 root 536: if (size_in_usec) {
537: int dir = 0;
538: unsigned int btime = req->buffer_size;
1.1 root 539:
540: err = snd_pcm_hw_params_set_buffer_time_near (
541: handle,
542: hw_params,
1.1.1.4 root 543: &btime,
544: &dir
1.1 root 545: );
1.1.1.4 root 546: obt = btime;
1.1 root 547: }
548: else {
1.1.1.4 root 549: snd_pcm_uframes_t bsize = req->buffer_size;
1.1 root 550:
1.1.1.4 root 551: err = snd_pcm_hw_params_set_buffer_size_near (
552: handle,
553: hw_params,
554: &bsize
555: );
556: obt = bsize;
557: }
558: if (err < 0) {
559: alsa_logerr2 (err, typ, "Failed to set buffer %s to %d\n",
560: size_in_usec ? "time" : "size", req->buffer_size);
561: goto err;
562: }
1.1 root 563:
1.1.1.4 root 564: if ((req->override_mask & 2) && (obt - req->buffer_size))
565: dolog ("Requested buffer %s %u was rejected, using %lu\n",
566: size_in_usec ? "time" : "size", req->buffer_size, obt);
567: }
568:
569: if (req->period_size) {
570: unsigned long obt;
571:
572: if (size_in_usec) {
573: int dir = 0;
574: unsigned int ptime = req->period_size;
1.1 root 575:
1.1.1.4 root 576: err = snd_pcm_hw_params_set_period_time_near (
577: handle,
1.1 root 578: hw_params,
1.1.1.4 root 579: &ptime,
580: &dir
1.1 root 581: );
1.1.1.4 root 582: obt = ptime;
583: }
584: else {
585: int dir = 0;
586: snd_pcm_uframes_t psize = req->period_size;
1.1 root 587:
1.1.1.4 root 588: err = snd_pcm_hw_params_set_period_size_near (
1.1 root 589: handle,
590: hw_params,
1.1.1.4 root 591: &psize,
592: &dir
1.1 root 593: );
1.1.1.4 root 594: obt = psize;
1.1 root 595: }
1.1.1.4 root 596:
597: if (err < 0) {
598: alsa_logerr2 (err, typ, "Failed to set period %s to %d\n",
599: size_in_usec ? "time" : "size", req->period_size);
600: goto err;
601: }
602:
1.1.1.6 root 603: if (((req->override_mask & 1) && (obt - req->period_size)))
1.1.1.4 root 604: dolog ("Requested period %s %u was rejected, using %lu\n",
605: size_in_usec ? "time" : "size", req->period_size, obt);
1.1 root 606: }
607:
608: err = snd_pcm_hw_params (handle, hw_params);
609: if (err < 0) {
610: alsa_logerr2 (err, typ, "Failed to apply audio parameters\n");
611: goto err;
612: }
613:
614: err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size);
615: if (err < 0) {
616: alsa_logerr2 (err, typ, "Failed to get buffer size\n");
617: goto err;
618: }
619:
1.1.1.4 root 620: err = snd_pcm_hw_params_get_format (hw_params, &obtfmt);
621: if (err < 0) {
622: alsa_logerr2 (err, typ, "Failed to get format\n");
623: goto err;
624: }
625:
626: if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) {
627: dolog ("Invalid format was returned %d\n", obtfmt);
628: goto err;
629: }
630:
1.1 root 631: err = snd_pcm_prepare (handle);
632: if (err < 0) {
633: alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle);
634: goto err;
635: }
636:
637: if (!in && conf.threshold) {
638: snd_pcm_uframes_t threshold;
639: int bytes_per_sec;
640:
1.1.1.4 root 641: bytes_per_sec = freq << (nchannels == 2);
642:
643: switch (obt->fmt) {
644: case AUD_FMT_S8:
645: case AUD_FMT_U8:
646: break;
647:
648: case AUD_FMT_S16:
649: case AUD_FMT_U16:
650: bytes_per_sec <<= 1;
651: break;
652:
653: case AUD_FMT_S32:
654: case AUD_FMT_U32:
655: bytes_per_sec <<= 2;
656: break;
657: }
1.1 root 658:
659: threshold = (conf.threshold * bytes_per_sec) / 1000;
660: alsa_set_threshold (handle, threshold);
661: }
662:
663: obt->nchannels = nchannels;
664: obt->freq = freq;
665: obt->samples = obt_buffer_size;
1.1.1.4 root 666:
1.1 root 667: *handlep = handle;
668:
1.1.1.4 root 669: if (conf.verbose &&
1.1.1.8 ! root 670: (obtfmt != req->fmt ||
1.1.1.4 root 671: obt->nchannels != req->nchannels ||
672: obt->freq != req->freq)) {
1.1.1.7 root 673: dolog ("Audio parameters for %s\n", typ);
1.1.1.8 ! root 674: alsa_dump_info (req, obt, obtfmt);
1.1 root 675: }
676:
677: #ifdef DEBUG
1.1.1.8 ! root 678: alsa_dump_info (req, obt, obtfmt);
1.1 root 679: #endif
680: return 0;
681:
682: err:
1.1.1.6 root 683: alsa_anal_close1 (&handle);
1.1 root 684: return -1;
685: }
686:
687: static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
688: {
689: snd_pcm_sframes_t avail;
690:
691: avail = snd_pcm_avail_update (handle);
692: if (avail < 0) {
693: if (avail == -EPIPE) {
694: if (!alsa_recover (handle)) {
695: avail = snd_pcm_avail_update (handle);
696: }
697: }
698:
699: if (avail < 0) {
700: alsa_logerr (avail,
701: "Could not obtain number of available frames\n");
702: return -1;
703: }
704: }
705:
706: return avail;
707: }
708:
1.1.1.6 root 709: static void alsa_write_pending (ALSAVoiceOut *alsa)
1.1 root 710: {
1.1.1.6 root 711: HWVoiceOut *hw = &alsa->hw;
1.1 root 712:
1.1.1.6 root 713: while (alsa->pending) {
714: int left_till_end_samples = hw->samples - alsa->wpos;
715: int len = audio_MIN (alsa->pending, left_till_end_samples);
716: char *src = advance (alsa->pcm_buf, alsa->wpos << hw->info.shift);
1.1 root 717:
718: while (len) {
1.1.1.6 root 719: snd_pcm_sframes_t written;
720:
721: written = snd_pcm_writei (alsa->handle, src, len);
1.1 root 722:
723: if (written <= 0) {
724: switch (written) {
725: case 0:
726: if (conf.verbose) {
727: dolog ("Failed to write %d frames (wrote zero)\n", len);
728: }
1.1.1.6 root 729: return;
1.1 root 730:
731: case -EPIPE:
732: if (alsa_recover (alsa->handle)) {
733: alsa_logerr (written, "Failed to write %d frames\n",
734: len);
1.1.1.6 root 735: return;
1.1 root 736: }
737: if (conf.verbose) {
738: dolog ("Recovering from playback xrun\n");
739: }
740: continue;
741:
1.1.1.6 root 742: case -ESTRPIPE:
743: /* stream is suspended and waiting for an
744: application recovery */
745: if (alsa_resume (alsa->handle)) {
746: alsa_logerr (written, "Failed to write %d frames\n",
747: len);
748: return;
749: }
750: if (conf.verbose) {
751: dolog ("Resuming suspended output stream\n");
752: }
753: continue;
754:
1.1 root 755: case -EAGAIN:
1.1.1.6 root 756: return;
1.1 root 757:
758: default:
1.1.1.6 root 759: alsa_logerr (written, "Failed to write %d frames from %p\n",
760: len, src);
761: return;
1.1 root 762: }
763: }
764:
1.1.1.6 root 765: alsa->wpos = (alsa->wpos + written) % hw->samples;
766: alsa->pending -= written;
1.1 root 767: len -= written;
768: }
769: }
1.1.1.6 root 770: }
1.1 root 771:
1.1.1.6 root 772: static int alsa_run_out (HWVoiceOut *hw, int live)
773: {
774: ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
775: int decr;
776: snd_pcm_sframes_t avail;
777:
778: avail = alsa_get_avail (alsa->handle);
779: if (avail < 0) {
780: dolog ("Could not get number of available playback frames\n");
781: return 0;
782: }
783:
784: decr = audio_MIN (live, avail);
785: decr = audio_pcm_hw_clip_out (hw, alsa->pcm_buf, decr, alsa->pending);
786: alsa->pending += decr;
787: alsa_write_pending (alsa);
1.1 root 788: return decr;
789: }
790:
791: static void alsa_fini_out (HWVoiceOut *hw)
792: {
793: ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
794:
795: ldebug ("alsa_fini\n");
1.1.1.6 root 796: alsa_anal_close (&alsa->handle, &alsa->pollhlp);
1.1 root 797:
798: if (alsa->pcm_buf) {
799: qemu_free (alsa->pcm_buf);
800: alsa->pcm_buf = NULL;
801: }
802: }
803:
1.1.1.4 root 804: static int alsa_init_out (HWVoiceOut *hw, struct audsettings *as)
1.1 root 805: {
806: ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
807: struct alsa_params_req req;
808: struct alsa_params_obt obt;
809: snd_pcm_t *handle;
1.1.1.4 root 810: struct audsettings obt_as;
1.1 root 811:
812: req.fmt = aud_to_alsafmt (as->fmt);
813: req.freq = as->freq;
814: req.nchannels = as->nchannels;
815: req.period_size = conf.period_size_out;
816: req.buffer_size = conf.buffer_size_out;
1.1.1.4 root 817: req.size_in_usec = conf.size_in_usec_out;
1.1.1.5 root 818: req.override_mask =
819: (conf.period_size_out_overridden ? 1 : 0) |
820: (conf.buffer_size_out_overridden ? 2 : 0);
1.1 root 821:
822: if (alsa_open (0, &req, &obt, &handle)) {
823: return -1;
824: }
825:
826: obt_as.freq = obt.freq;
827: obt_as.nchannels = obt.nchannels;
1.1.1.4 root 828: obt_as.fmt = obt.fmt;
829: obt_as.endianness = obt.endianness;
1.1 root 830:
1.1.1.2 root 831: audio_pcm_init_info (&hw->info, &obt_as);
1.1 root 832: hw->samples = obt.samples;
833:
834: alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);
835: if (!alsa->pcm_buf) {
836: dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
837: hw->samples, 1 << hw->info.shift);
1.1.1.6 root 838: alsa_anal_close1 (&handle);
1.1 root 839: return -1;
840: }
841:
842: alsa->handle = handle;
843: return 0;
844: }
845:
846: static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause)
847: {
848: int err;
849:
850: if (pause) {
851: err = snd_pcm_drop (handle);
852: if (err < 0) {
853: alsa_logerr (err, "Could not stop %s\n", typ);
854: return -1;
855: }
856: }
857: else {
858: err = snd_pcm_prepare (handle);
859: if (err < 0) {
860: alsa_logerr (err, "Could not prepare handle for %s\n", typ);
861: return -1;
862: }
863: }
864:
865: return 0;
866: }
867:
868: static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
869: {
870: ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
871:
872: switch (cmd) {
873: case VOICE_ENABLE:
1.1.1.6 root 874: {
875: va_list ap;
876: int poll_mode;
877:
878: va_start (ap, cmd);
879: poll_mode = va_arg (ap, int);
880: va_end (ap);
881:
882: ldebug ("enabling voice\n");
883: if (poll_mode && alsa_poll_out (hw)) {
884: poll_mode = 0;
885: }
886: hw->poll_mode = poll_mode;
887: return alsa_voice_ctl (alsa->handle, "playback", 0);
888: }
1.1 root 889:
890: case VOICE_DISABLE:
891: ldebug ("disabling voice\n");
892: return alsa_voice_ctl (alsa->handle, "playback", 1);
893: }
894:
895: return -1;
896: }
897:
1.1.1.4 root 898: static int alsa_init_in (HWVoiceIn *hw, struct audsettings *as)
1.1 root 899: {
900: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
901: struct alsa_params_req req;
902: struct alsa_params_obt obt;
903: snd_pcm_t *handle;
1.1.1.4 root 904: struct audsettings obt_as;
1.1 root 905:
906: req.fmt = aud_to_alsafmt (as->fmt);
907: req.freq = as->freq;
908: req.nchannels = as->nchannels;
909: req.period_size = conf.period_size_in;
910: req.buffer_size = conf.buffer_size_in;
1.1.1.4 root 911: req.size_in_usec = conf.size_in_usec_in;
1.1.1.5 root 912: req.override_mask =
913: (conf.period_size_in_overridden ? 1 : 0) |
914: (conf.buffer_size_in_overridden ? 2 : 0);
1.1 root 915:
916: if (alsa_open (1, &req, &obt, &handle)) {
917: return -1;
918: }
919:
920: obt_as.freq = obt.freq;
921: obt_as.nchannels = obt.nchannels;
1.1.1.4 root 922: obt_as.fmt = obt.fmt;
923: obt_as.endianness = obt.endianness;
1.1 root 924:
1.1.1.2 root 925: audio_pcm_init_info (&hw->info, &obt_as);
1.1 root 926: hw->samples = obt.samples;
927:
928: alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
929: if (!alsa->pcm_buf) {
930: dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
931: hw->samples, 1 << hw->info.shift);
1.1.1.6 root 932: alsa_anal_close1 (&handle);
1.1 root 933: return -1;
934: }
935:
936: alsa->handle = handle;
937: return 0;
938: }
939:
940: static void alsa_fini_in (HWVoiceIn *hw)
941: {
942: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
943:
1.1.1.6 root 944: alsa_anal_close (&alsa->handle, &alsa->pollhlp);
1.1 root 945:
946: if (alsa->pcm_buf) {
947: qemu_free (alsa->pcm_buf);
948: alsa->pcm_buf = NULL;
949: }
950: }
951:
952: static int alsa_run_in (HWVoiceIn *hw)
953: {
954: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
955: int hwshift = hw->info.shift;
956: int i;
957: int live = audio_pcm_hw_get_live_in (hw);
958: int dead = hw->samples - live;
959: int decr;
960: struct {
961: int add;
962: int len;
963: } bufs[2] = {
1.1.1.6 root 964: { .add = hw->wpos, .len = 0 },
965: { .add = 0, .len = 0 }
1.1 root 966: };
967: snd_pcm_sframes_t avail;
968: snd_pcm_uframes_t read_samples = 0;
969:
970: if (!dead) {
971: return 0;
972: }
973:
974: avail = alsa_get_avail (alsa->handle);
975: if (avail < 0) {
976: dolog ("Could not get number of captured frames\n");
977: return 0;
978: }
979:
1.1.1.6 root 980: if (!avail) {
981: snd_pcm_state_t state;
982:
983: state = snd_pcm_state (alsa->handle);
984: switch (state) {
985: case SND_PCM_STATE_PREPARED:
986: avail = hw->samples;
987: break;
988: case SND_PCM_STATE_SUSPENDED:
989: /* stream is suspended and waiting for an application recovery */
990: if (alsa_resume (alsa->handle)) {
991: dolog ("Failed to resume suspended input stream\n");
992: return 0;
993: }
994: if (conf.verbose) {
995: dolog ("Resuming suspended input stream\n");
996: }
997: break;
998: default:
999: if (conf.verbose) {
1000: dolog ("No frames available and ALSA state is %d\n", state);
1001: }
1002: return 0;
1003: }
1.1 root 1004: }
1005:
1006: decr = audio_MIN (dead, avail);
1007: if (!decr) {
1008: return 0;
1009: }
1010:
1011: if (hw->wpos + decr > hw->samples) {
1012: bufs[0].len = (hw->samples - hw->wpos);
1013: bufs[1].len = (decr - (hw->samples - hw->wpos));
1014: }
1015: else {
1016: bufs[0].len = decr;
1017: }
1018:
1019: for (i = 0; i < 2; ++i) {
1020: void *src;
1.1.1.4 root 1021: struct st_sample *dst;
1.1 root 1022: snd_pcm_sframes_t nread;
1023: snd_pcm_uframes_t len;
1024:
1025: len = bufs[i].len;
1026:
1027: src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
1028: dst = hw->conv_buf + bufs[i].add;
1029:
1030: while (len) {
1031: nread = snd_pcm_readi (alsa->handle, src, len);
1032:
1033: if (nread <= 0) {
1034: switch (nread) {
1035: case 0:
1036: if (conf.verbose) {
1037: dolog ("Failed to read %ld frames (read zero)\n", len);
1038: }
1039: goto exit;
1040:
1041: case -EPIPE:
1042: if (alsa_recover (alsa->handle)) {
1043: alsa_logerr (nread, "Failed to read %ld frames\n", len);
1044: goto exit;
1045: }
1046: if (conf.verbose) {
1047: dolog ("Recovering from capture xrun\n");
1048: }
1049: continue;
1050:
1051: case -EAGAIN:
1052: goto exit;
1053:
1054: default:
1055: alsa_logerr (
1056: nread,
1057: "Failed to read %ld frames from %p\n",
1058: len,
1059: src
1060: );
1061: goto exit;
1062: }
1063: }
1064:
1065: hw->conv (dst, src, nread, &nominal_volume);
1066:
1067: src = advance (src, nread << hwshift);
1068: dst += nread;
1069:
1070: read_samples += nread;
1071: len -= nread;
1072: }
1073: }
1074:
1075: exit:
1076: hw->wpos = (hw->wpos + read_samples) % hw->samples;
1077: return read_samples;
1078: }
1079:
1080: static int alsa_read (SWVoiceIn *sw, void *buf, int size)
1081: {
1082: return audio_pcm_sw_read (sw, buf, size);
1083: }
1084:
1085: static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
1086: {
1087: ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
1088:
1089: switch (cmd) {
1090: case VOICE_ENABLE:
1.1.1.6 root 1091: {
1092: va_list ap;
1093: int poll_mode;
1094:
1095: va_start (ap, cmd);
1096: poll_mode = va_arg (ap, int);
1097: va_end (ap);
1098:
1099: ldebug ("enabling voice\n");
1100: if (poll_mode && alsa_poll_in (hw)) {
1101: poll_mode = 0;
1102: }
1103: hw->poll_mode = poll_mode;
1104:
1105: return alsa_voice_ctl (alsa->handle, "capture", 0);
1106: }
1.1 root 1107:
1108: case VOICE_DISABLE:
1109: ldebug ("disabling voice\n");
1.1.1.6 root 1110: if (hw->poll_mode) {
1111: hw->poll_mode = 0;
1112: alsa_fini_poll (&alsa->pollhlp);
1113: }
1.1 root 1114: return alsa_voice_ctl (alsa->handle, "capture", 1);
1115: }
1116:
1117: return -1;
1118: }
1119:
1120: static void *alsa_audio_init (void)
1121: {
1122: return &conf;
1123: }
1124:
1125: static void alsa_audio_fini (void *opaque)
1126: {
1127: (void) opaque;
1128: }
1129:
1130: static struct audio_option alsa_options[] = {
1.1.1.6 root 1131: {
1132: .name = "DAC_SIZE_IN_USEC",
1133: .tag = AUD_OPT_BOOL,
1134: .valp = &conf.size_in_usec_out,
1135: .descr = "DAC period/buffer size in microseconds (otherwise in frames)"
1136: },
1137: {
1138: .name = "DAC_PERIOD_SIZE",
1139: .tag = AUD_OPT_INT,
1140: .valp = &conf.period_size_out,
1141: .descr = "DAC period size (0 to go with system default)",
1142: .overriddenp = &conf.period_size_out_overridden
1143: },
1144: {
1145: .name = "DAC_BUFFER_SIZE",
1146: .tag = AUD_OPT_INT,
1147: .valp = &conf.buffer_size_out,
1148: .descr = "DAC buffer size (0 to go with system default)",
1149: .overriddenp = &conf.buffer_size_out_overridden
1150: },
1151: {
1152: .name = "ADC_SIZE_IN_USEC",
1153: .tag = AUD_OPT_BOOL,
1154: .valp = &conf.size_in_usec_in,
1155: .descr =
1156: "ADC period/buffer size in microseconds (otherwise in frames)"
1157: },
1158: {
1159: .name = "ADC_PERIOD_SIZE",
1160: .tag = AUD_OPT_INT,
1161: .valp = &conf.period_size_in,
1162: .descr = "ADC period size (0 to go with system default)",
1163: .overriddenp = &conf.period_size_in_overridden
1164: },
1165: {
1166: .name = "ADC_BUFFER_SIZE",
1167: .tag = AUD_OPT_INT,
1168: .valp = &conf.buffer_size_in,
1169: .descr = "ADC buffer size (0 to go with system default)",
1170: .overriddenp = &conf.buffer_size_in_overridden
1171: },
1172: {
1173: .name = "THRESHOLD",
1174: .tag = AUD_OPT_INT,
1175: .valp = &conf.threshold,
1176: .descr = "(undocumented)"
1177: },
1178: {
1179: .name = "DAC_DEV",
1180: .tag = AUD_OPT_STR,
1181: .valp = &conf.pcm_name_out,
1182: .descr = "DAC device name (for instance dmix)"
1183: },
1184: {
1185: .name = "ADC_DEV",
1186: .tag = AUD_OPT_STR,
1187: .valp = &conf.pcm_name_in,
1188: .descr = "ADC device name"
1189: },
1190: {
1191: .name = "VERBOSE",
1192: .tag = AUD_OPT_BOOL,
1193: .valp = &conf.verbose,
1194: .descr = "Behave in a more verbose way"
1195: },
1196: { /* End of list */ }
1.1 root 1197: };
1198:
1199: static struct audio_pcm_ops alsa_pcm_ops = {
1.1.1.6 root 1200: .init_out = alsa_init_out,
1201: .fini_out = alsa_fini_out,
1202: .run_out = alsa_run_out,
1203: .write = alsa_write,
1204: .ctl_out = alsa_ctl_out,
1205:
1206: .init_in = alsa_init_in,
1207: .fini_in = alsa_fini_in,
1208: .run_in = alsa_run_in,
1209: .read = alsa_read,
1210: .ctl_in = alsa_ctl_in,
1.1 root 1211: };
1212:
1213: struct audio_driver alsa_audio_driver = {
1.1.1.6 root 1214: .name = "alsa",
1215: .descr = "ALSA http://www.alsa-project.org",
1216: .options = alsa_options,
1217: .init = alsa_audio_init,
1218: .fini = alsa_audio_fini,
1219: .pcm_ops = &alsa_pcm_ops,
1220: .can_be_default = 1,
1221: .max_voices_out = INT_MAX,
1222: .max_voices_in = INT_MAX,
1223: .voice_size_out = sizeof (ALSAVoiceOut),
1224: .voice_size_in = sizeof (ALSAVoiceIn)
1.1 root 1225: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.