]>
Commit | Line | Data |
---|---|---|
1d14ffa9 FB |
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; | |
1d14ffa9 FB |
34 | } ALSAVoiceOut; |
35 | ||
36 | typedef struct ALSAVoiceIn { | |
37 | HWVoiceIn hw; | |
38 | snd_pcm_t *handle; | |
39 | void *pcm_buf; | |
1d14ffa9 FB |
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; | |
571ec3d6 | 58 | int verbose; |
1d14ffa9 FB |
59 | } conf = { |
60 | #ifdef HIGH_LATENCY | |
61 | .size_in_usec_in = 1, | |
62 | .size_in_usec_out = 1, | |
63 | #endif | |
8ead62cf FB |
64 | .pcm_name_out = "default", |
65 | .pcm_name_in = "default", | |
1d14ffa9 FB |
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 | |
571ec3d6 FB |
74 | .buffer_size_in = DEFAULT_BUFFER_SIZE * 4, |
75 | .period_size_in = DEFAULT_PERIOD_SIZE * 4, | |
1d14ffa9 FB |
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 | |
571ec3d6 FB |
83 | .threshold = 0, |
84 | .verbose = 0 | |
1d14ffa9 FB |
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; | |
c0fe3827 | 99 | snd_pcm_uframes_t samples; |
1d14ffa9 FB |
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 | ||
c0fe3827 | 122 | AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ); |
1d14ffa9 FB |
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 | ||
c0fe3827 | 210 | #if defined DEBUG_MISMATCHES || defined DEBUG |
1d14ffa9 FB |
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); | |
c0fe3827 | 222 | dolog ("obtained: samples %ld\n", obt->samples); |
1d14ffa9 FB |
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) { | |
c0fe3827 | 235 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
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) { | |
c0fe3827 | 242 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
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) { | |
c0fe3827 | 250 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
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, | |
c0fe3827 FB |
345 | 0 |
346 | ); | |
1d14ffa9 FB |
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, | |
c0fe3827 FB |
359 | 0 |
360 | ); | |
1d14ffa9 FB |
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, | |
c0fe3827 | 385 | "Could not get minmal period size for %s\n", |
1d14ffa9 FB |
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) { | |
c0fe3827 | 422 | alsa_logerr (err, "Could not get minmal buffer size for %s\n", |
1d14ffa9 FB |
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 { | |
c0fe3827 | 454 | dolog ("warning: Buffer size is not set\n"); |
1d14ffa9 FB |
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) { | |
c0fe3827 | 471 | alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle); |
1d14ffa9 FB |
472 | goto err; |
473 | } | |
474 | ||
1d14ffa9 FB |
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; | |
c0fe3827 | 490 | obt->samples = obt_buffer_size; |
1d14ffa9 FB |
491 | *handlep = handle; |
492 | ||
c0fe3827 | 493 | #if defined DEBUG_MISMATCHES || defined DEBUG |
1d14ffa9 FB |
494 | if (obt->fmt != req->fmt || |
495 | obt->nchannels != req->nchannels || | |
496 | obt->freq != req->freq) { | |
1d14ffa9 FB |
497 | dolog ("Audio paramters mismatch for %s\n", typ); |
498 | alsa_dump_info (req, obt); | |
1d14ffa9 | 499 | } |
c0fe3827 | 500 | #endif |
1d14ffa9 FB |
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 | ||
571ec3d6 FB |
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 | ||
1d14ffa9 FB |
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 | ||
571ec3d6 | 558 | avail = alsa_get_avail (alsa->handle); |
1d14ffa9 | 559 | if (avail < 0) { |
571ec3d6 | 560 | dolog ("Could not get number of available playback frames\n"); |
1d14ffa9 FB |
561 | return 0; |
562 | } | |
563 | ||
1d14ffa9 FB |
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; | |
571ec3d6 | 569 | int len = audio_MIN (samples, left_till_end_samples); |
1d14ffa9 FB |
570 | snd_pcm_sframes_t written; |
571 | ||
572 | src = hw->mix_buf + rpos; | |
573 | dst = advance (alsa->pcm_buf, rpos << hw->info.shift); | |
574 | ||
571ec3d6 | 575 | hw->clip (dst, src, len); |
1d14ffa9 | 576 | |
571ec3d6 FB |
577 | while (len) { |
578 | written = snd_pcm_writei (alsa->handle, dst, len); | |
4787c71d | 579 | |
571ec3d6 | 580 | if (written <= 0) { |
4787c71d | 581 | switch (written) { |
571ec3d6 FB |
582 | case 0: |
583 | if (conf.verbose) { | |
584 | dolog ("Failed to write %d frames (wrote zero)\n", len); | |
4787c71d | 585 | } |
4787c71d FB |
586 | goto exit; |
587 | ||
571ec3d6 FB |
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 | } | |
4787c71d FB |
597 | continue; |
598 | ||
571ec3d6 FB |
599 | case -EAGAIN: |
600 | goto exit; | |
601 | ||
4787c71d FB |
602 | default: |
603 | alsa_logerr (written, "Failed to write %d frames to %p\n", | |
571ec3d6 | 604 | len, dst); |
4787c71d | 605 | goto exit; |
1d14ffa9 | 606 | } |
1d14ffa9 | 607 | } |
1d14ffa9 | 608 | |
4787c71d FB |
609 | rpos = (rpos + written) % hw->samples; |
610 | samples -= written; | |
571ec3d6 | 611 | len -= written; |
4787c71d FB |
612 | dst = advance (dst, written << hw->info.shift); |
613 | src += written; | |
614 | } | |
1d14ffa9 FB |
615 | } |
616 | ||
617 | exit: | |
618 | hw->rpos = rpos; | |
619 | return decr; | |
620 | } | |
621 | ||
622 | static void alsa_fini_out (HWVoiceOut *hw) | |
623 | { | |
624 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; | |
625 | ||
626 | ldebug ("alsa_fini\n"); | |
627 | alsa_anal_close (&alsa->handle); | |
628 | ||
629 | if (alsa->pcm_buf) { | |
630 | qemu_free (alsa->pcm_buf); | |
631 | alsa->pcm_buf = NULL; | |
632 | } | |
633 | } | |
634 | ||
c0fe3827 | 635 | static int alsa_init_out (HWVoiceOut *hw, audsettings_t *as) |
1d14ffa9 FB |
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; | |
c0fe3827 | 644 | audsettings_t obt_as; |
1d14ffa9 | 645 | |
c0fe3827 FB |
646 | req.fmt = aud_to_alsafmt (as->fmt); |
647 | req.freq = as->freq; | |
648 | req.nchannels = as->nchannels; | |
1d14ffa9 FB |
649 | req.period_size = conf.period_size_out; |
650 | req.buffer_size = conf.buffer_size_out; | |
651 | ||
652 | if (alsa_open (0, &req, &obt, &handle)) { | |
653 | return -1; | |
654 | } | |
655 | ||
656 | err = alsa_to_audfmt (obt.fmt, &effective_fmt, &endianness); | |
657 | if (err) { | |
658 | alsa_anal_close (&handle); | |
659 | return -1; | |
660 | } | |
661 | ||
c0fe3827 FB |
662 | obt_as.freq = obt.freq; |
663 | obt_as.nchannels = obt.nchannels; | |
664 | obt_as.fmt = effective_fmt; | |
665 | ||
1d14ffa9 FB |
666 | audio_pcm_init_info ( |
667 | &hw->info, | |
c0fe3827 | 668 | &obt_as, |
1d14ffa9 FB |
669 | audio_need_to_swap_endian (endianness) |
670 | ); | |
c0fe3827 | 671 | hw->samples = obt.samples; |
1d14ffa9 | 672 | |
c0fe3827 | 673 | alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift); |
1d14ffa9 | 674 | if (!alsa->pcm_buf) { |
4787c71d FB |
675 | dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n", |
676 | hw->samples, 1 << hw->info.shift); | |
1d14ffa9 FB |
677 | alsa_anal_close (&handle); |
678 | return -1; | |
679 | } | |
680 | ||
681 | alsa->handle = handle; | |
1d14ffa9 FB |
682 | return 0; |
683 | } | |
684 | ||
571ec3d6 | 685 | static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause) |
1d14ffa9 FB |
686 | { |
687 | int err; | |
571ec3d6 FB |
688 | |
689 | if (pause) { | |
690 | err = snd_pcm_drop (handle); | |
691 | if (err < 0) { | |
32d448c4 | 692 | alsa_logerr (err, "Could not stop %s\n", typ); |
571ec3d6 FB |
693 | return -1; |
694 | } | |
695 | } | |
696 | else { | |
697 | err = snd_pcm_prepare (handle); | |
698 | if (err < 0) { | |
32d448c4 | 699 | alsa_logerr (err, "Could not prepare handle for %s\n", typ); |
571ec3d6 FB |
700 | return -1; |
701 | } | |
702 | } | |
703 | ||
704 | return 0; | |
705 | } | |
706 | ||
707 | static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...) | |
708 | { | |
1d14ffa9 FB |
709 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; |
710 | ||
711 | switch (cmd) { | |
712 | case VOICE_ENABLE: | |
713 | ldebug ("enabling voice\n"); | |
571ec3d6 | 714 | return alsa_voice_ctl (alsa->handle, "playback", 0); |
1d14ffa9 FB |
715 | |
716 | case VOICE_DISABLE: | |
717 | ldebug ("disabling voice\n"); | |
571ec3d6 | 718 | return alsa_voice_ctl (alsa->handle, "playback", 1); |
1d14ffa9 | 719 | } |
571ec3d6 FB |
720 | |
721 | return -1; | |
1d14ffa9 FB |
722 | } |
723 | ||
c0fe3827 | 724 | static int alsa_init_in (HWVoiceIn *hw, audsettings_t *as) |
1d14ffa9 FB |
725 | { |
726 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
727 | struct alsa_params_req req; | |
728 | struct alsa_params_obt obt; | |
729 | int endianness; | |
730 | int err; | |
731 | audfmt_e effective_fmt; | |
732 | snd_pcm_t *handle; | |
c0fe3827 | 733 | audsettings_t obt_as; |
1d14ffa9 | 734 | |
c0fe3827 FB |
735 | req.fmt = aud_to_alsafmt (as->fmt); |
736 | req.freq = as->freq; | |
737 | req.nchannels = as->nchannels; | |
1d14ffa9 FB |
738 | req.period_size = conf.period_size_in; |
739 | req.buffer_size = conf.buffer_size_in; | |
740 | ||
741 | if (alsa_open (1, &req, &obt, &handle)) { | |
742 | return -1; | |
743 | } | |
744 | ||
745 | err = alsa_to_audfmt (obt.fmt, &effective_fmt, &endianness); | |
746 | if (err) { | |
747 | alsa_anal_close (&handle); | |
748 | return -1; | |
749 | } | |
750 | ||
c0fe3827 FB |
751 | obt_as.freq = obt.freq; |
752 | obt_as.nchannels = obt.nchannels; | |
753 | obt_as.fmt = effective_fmt; | |
754 | ||
1d14ffa9 FB |
755 | audio_pcm_init_info ( |
756 | &hw->info, | |
c0fe3827 | 757 | &obt_as, |
1d14ffa9 FB |
758 | audio_need_to_swap_endian (endianness) |
759 | ); | |
c0fe3827 FB |
760 | hw->samples = obt.samples; |
761 | ||
762 | alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift); | |
1d14ffa9 | 763 | if (!alsa->pcm_buf) { |
4787c71d FB |
764 | dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n", |
765 | hw->samples, 1 << hw->info.shift); | |
1d14ffa9 FB |
766 | alsa_anal_close (&handle); |
767 | return -1; | |
768 | } | |
769 | ||
770 | alsa->handle = handle; | |
771 | return 0; | |
772 | } | |
773 | ||
774 | static void alsa_fini_in (HWVoiceIn *hw) | |
775 | { | |
776 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
777 | ||
778 | alsa_anal_close (&alsa->handle); | |
779 | ||
780 | if (alsa->pcm_buf) { | |
781 | qemu_free (alsa->pcm_buf); | |
782 | alsa->pcm_buf = NULL; | |
783 | } | |
784 | } | |
785 | ||
786 | static int alsa_run_in (HWVoiceIn *hw) | |
787 | { | |
788 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
789 | int hwshift = hw->info.shift; | |
790 | int i; | |
791 | int live = audio_pcm_hw_get_live_in (hw); | |
792 | int dead = hw->samples - live; | |
571ec3d6 | 793 | int decr; |
1d14ffa9 FB |
794 | struct { |
795 | int add; | |
796 | int len; | |
797 | } bufs[2] = { | |
798 | { hw->wpos, 0 }, | |
799 | { 0, 0 } | |
800 | }; | |
571ec3d6 | 801 | snd_pcm_sframes_t avail; |
1d14ffa9 FB |
802 | snd_pcm_uframes_t read_samples = 0; |
803 | ||
804 | if (!dead) { | |
805 | return 0; | |
806 | } | |
807 | ||
571ec3d6 FB |
808 | avail = alsa_get_avail (alsa->handle); |
809 | if (avail < 0) { | |
810 | dolog ("Could not get number of captured frames\n"); | |
811 | return 0; | |
812 | } | |
813 | ||
814 | if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) { | |
815 | avail = hw->samples; | |
816 | } | |
817 | ||
818 | decr = audio_MIN (dead, avail); | |
819 | if (!decr) { | |
820 | return 0; | |
821 | } | |
822 | ||
823 | if (hw->wpos + decr > hw->samples) { | |
1d14ffa9 | 824 | bufs[0].len = (hw->samples - hw->wpos); |
571ec3d6 | 825 | bufs[1].len = (decr - (hw->samples - hw->wpos)); |
1d14ffa9 FB |
826 | } |
827 | else { | |
571ec3d6 | 828 | bufs[0].len = decr; |
1d14ffa9 FB |
829 | } |
830 | ||
1d14ffa9 FB |
831 | for (i = 0; i < 2; ++i) { |
832 | void *src; | |
833 | st_sample_t *dst; | |
834 | snd_pcm_sframes_t nread; | |
835 | snd_pcm_uframes_t len; | |
836 | ||
837 | len = bufs[i].len; | |
838 | ||
839 | src = advance (alsa->pcm_buf, bufs[i].add << hwshift); | |
840 | dst = hw->conv_buf + bufs[i].add; | |
841 | ||
842 | while (len) { | |
843 | nread = snd_pcm_readi (alsa->handle, src, len); | |
844 | ||
571ec3d6 | 845 | if (nread <= 0) { |
1d14ffa9 | 846 | switch (nread) { |
571ec3d6 FB |
847 | case 0: |
848 | if (conf.verbose) { | |
849 | dolog ("Failed to read %ld frames (read zero)\n", len); | |
1d14ffa9 | 850 | } |
1d14ffa9 FB |
851 | goto exit; |
852 | ||
571ec3d6 FB |
853 | case -EPIPE: |
854 | if (alsa_recover (alsa->handle)) { | |
855 | alsa_logerr (nread, "Failed to read %ld frames\n", len); | |
856 | goto exit; | |
857 | } | |
858 | if (conf.verbose) { | |
859 | dolog ("Recovering from capture xrun\n"); | |
860 | } | |
1d14ffa9 FB |
861 | continue; |
862 | ||
571ec3d6 FB |
863 | case -EAGAIN: |
864 | goto exit; | |
865 | ||
1d14ffa9 FB |
866 | default: |
867 | alsa_logerr ( | |
868 | nread, | |
869 | "Failed to read %ld frames from %p\n", | |
870 | len, | |
871 | src | |
872 | ); | |
873 | goto exit; | |
874 | } | |
875 | } | |
876 | ||
877 | hw->conv (dst, src, nread, &nominal_volume); | |
878 | ||
879 | src = advance (src, nread << hwshift); | |
880 | dst += nread; | |
881 | ||
882 | read_samples += nread; | |
883 | len -= nread; | |
884 | } | |
885 | } | |
886 | ||
887 | exit: | |
888 | hw->wpos = (hw->wpos + read_samples) % hw->samples; | |
889 | return read_samples; | |
890 | } | |
891 | ||
892 | static int alsa_read (SWVoiceIn *sw, void *buf, int size) | |
893 | { | |
894 | return audio_pcm_sw_read (sw, buf, size); | |
895 | } | |
896 | ||
897 | static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...) | |
898 | { | |
571ec3d6 FB |
899 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; |
900 | ||
901 | switch (cmd) { | |
902 | case VOICE_ENABLE: | |
903 | ldebug ("enabling voice\n"); | |
904 | return alsa_voice_ctl (alsa->handle, "capture", 0); | |
905 | ||
906 | case VOICE_DISABLE: | |
907 | ldebug ("disabling voice\n"); | |
908 | return alsa_voice_ctl (alsa->handle, "capture", 1); | |
909 | } | |
910 | ||
911 | return -1; | |
1d14ffa9 FB |
912 | } |
913 | ||
914 | static void *alsa_audio_init (void) | |
915 | { | |
916 | return &conf; | |
917 | } | |
918 | ||
919 | static void alsa_audio_fini (void *opaque) | |
920 | { | |
921 | (void) opaque; | |
922 | } | |
923 | ||
924 | static struct audio_option alsa_options[] = { | |
925 | {"DAC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_out, | |
926 | "DAC period/buffer size in microseconds (otherwise in frames)", NULL, 0}, | |
927 | {"DAC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_out, | |
928 | "DAC period size", &conf.period_size_out_overriden, 0}, | |
929 | {"DAC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_out, | |
930 | "DAC buffer size", &conf.buffer_size_out_overriden, 0}, | |
931 | ||
932 | {"ADC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_in, | |
933 | "ADC period/buffer size in microseconds (otherwise in frames)", NULL, 0}, | |
934 | {"ADC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_in, | |
935 | "ADC period size", &conf.period_size_in_overriden, 0}, | |
936 | {"ADC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_in, | |
937 | "ADC buffer size", &conf.buffer_size_in_overriden, 0}, | |
938 | ||
939 | {"THRESHOLD", AUD_OPT_INT, &conf.threshold, | |
940 | "(undocumented)", NULL, 0}, | |
941 | ||
942 | {"DAC_DEV", AUD_OPT_STR, &conf.pcm_name_out, | |
943 | "DAC device name (for instance dmix)", NULL, 0}, | |
944 | ||
945 | {"ADC_DEV", AUD_OPT_STR, &conf.pcm_name_in, | |
946 | "ADC device name", NULL, 0}, | |
571ec3d6 FB |
947 | |
948 | {"VERBOSE", AUD_OPT_BOOL, &conf.verbose, | |
949 | "Behave in a more verbose way", NULL, 0}, | |
950 | ||
1d14ffa9 FB |
951 | {NULL, 0, NULL, NULL, NULL, 0} |
952 | }; | |
953 | ||
954 | static struct audio_pcm_ops alsa_pcm_ops = { | |
955 | alsa_init_out, | |
956 | alsa_fini_out, | |
957 | alsa_run_out, | |
958 | alsa_write, | |
959 | alsa_ctl_out, | |
960 | ||
961 | alsa_init_in, | |
962 | alsa_fini_in, | |
963 | alsa_run_in, | |
964 | alsa_read, | |
965 | alsa_ctl_in | |
966 | }; | |
967 | ||
968 | struct audio_driver alsa_audio_driver = { | |
969 | INIT_FIELD (name = ) "alsa", | |
970 | INIT_FIELD (descr = ) "ALSA http://www.alsa-project.org", | |
971 | INIT_FIELD (options = ) alsa_options, | |
972 | INIT_FIELD (init = ) alsa_audio_init, | |
973 | INIT_FIELD (fini = ) alsa_audio_fini, | |
974 | INIT_FIELD (pcm_ops = ) &alsa_pcm_ops, | |
975 | INIT_FIELD (can_be_default = ) 1, | |
976 | INIT_FIELD (max_voices_out = ) INT_MAX, | |
977 | INIT_FIELD (max_voices_in = ) INT_MAX, | |
978 | INIT_FIELD (voice_size_out = ) sizeof (ALSAVoiceOut), | |
979 | INIT_FIELD (voice_size_in = ) sizeof (ALSAVoiceIn) | |
980 | }; |