]>
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> | |
749bc4bf PB |
25 | #include "qemu-common.h" |
26 | #include "audio.h" | |
1d14ffa9 FB |
27 | |
28 | #define AUDIO_CAP "alsa" | |
29 | #include "audio_int.h" | |
30 | ||
31 | typedef struct ALSAVoiceOut { | |
32 | HWVoiceOut hw; | |
33 | void *pcm_buf; | |
34 | snd_pcm_t *handle; | |
1d14ffa9 FB |
35 | } ALSAVoiceOut; |
36 | ||
37 | typedef struct ALSAVoiceIn { | |
38 | HWVoiceIn hw; | |
39 | snd_pcm_t *handle; | |
40 | void *pcm_buf; | |
1d14ffa9 FB |
41 | } ALSAVoiceIn; |
42 | ||
43 | static struct { | |
44 | int size_in_usec_in; | |
45 | int size_in_usec_out; | |
46 | const char *pcm_name_in; | |
47 | const char *pcm_name_out; | |
48 | unsigned int buffer_size_in; | |
49 | unsigned int period_size_in; | |
50 | unsigned int buffer_size_out; | |
51 | unsigned int period_size_out; | |
52 | unsigned int threshold; | |
53 | ||
fe8f096b TS |
54 | int buffer_size_in_overridden; |
55 | int period_size_in_overridden; | |
1d14ffa9 | 56 | |
fe8f096b TS |
57 | int buffer_size_out_overridden; |
58 | int period_size_out_overridden; | |
571ec3d6 | 59 | int verbose; |
1d14ffa9 | 60 | } conf = { |
5a1237c4 AZ |
61 | #define DEFAULT_BUFFER_SIZE 1024 |
62 | #define DEFAULT_PERIOD_SIZE 256 | |
1d14ffa9 FB |
63 | #ifdef HIGH_LATENCY |
64 | .size_in_usec_in = 1, | |
65 | .size_in_usec_out = 1, | |
66 | #endif | |
8ead62cf FB |
67 | .pcm_name_out = "default", |
68 | .pcm_name_in = "default", | |
1d14ffa9 FB |
69 | #ifdef HIGH_LATENCY |
70 | .buffer_size_in = 400000, | |
71 | .period_size_in = 400000 / 4, | |
72 | .buffer_size_out = 400000, | |
73 | .period_size_out = 400000 / 4, | |
74 | #else | |
571ec3d6 FB |
75 | .buffer_size_in = DEFAULT_BUFFER_SIZE * 4, |
76 | .period_size_in = DEFAULT_PERIOD_SIZE * 4, | |
1d14ffa9 FB |
77 | .buffer_size_out = DEFAULT_BUFFER_SIZE, |
78 | .period_size_out = DEFAULT_PERIOD_SIZE, | |
fe8f096b TS |
79 | .buffer_size_in_overridden = 0, |
80 | .buffer_size_out_overridden = 0, | |
81 | .period_size_in_overridden = 0, | |
82 | .period_size_out_overridden = 0, | |
1d14ffa9 | 83 | #endif |
571ec3d6 FB |
84 | .threshold = 0, |
85 | .verbose = 0 | |
1d14ffa9 FB |
86 | }; |
87 | ||
88 | struct alsa_params_req { | |
ca9cc28c AZ |
89 | int freq; |
90 | snd_pcm_format_t fmt; | |
91 | int nchannels; | |
1d14ffa9 FB |
92 | unsigned int buffer_size; |
93 | unsigned int period_size; | |
94 | }; | |
95 | ||
96 | struct alsa_params_obt { | |
97 | int freq; | |
98 | audfmt_e fmt; | |
ca9cc28c | 99 | int endianness; |
1d14ffa9 | 100 | int nchannels; |
c0fe3827 | 101 | snd_pcm_uframes_t samples; |
1d14ffa9 FB |
102 | }; |
103 | ||
104 | static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...) | |
105 | { | |
106 | va_list ap; | |
107 | ||
108 | va_start (ap, fmt); | |
109 | AUD_vlog (AUDIO_CAP, fmt, ap); | |
110 | va_end (ap); | |
111 | ||
112 | AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err)); | |
113 | } | |
114 | ||
115 | static void GCC_FMT_ATTR (3, 4) alsa_logerr2 ( | |
116 | int err, | |
117 | const char *typ, | |
118 | const char *fmt, | |
119 | ... | |
120 | ) | |
121 | { | |
122 | va_list ap; | |
123 | ||
c0fe3827 | 124 | AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ); |
1d14ffa9 FB |
125 | |
126 | va_start (ap, fmt); | |
127 | AUD_vlog (AUDIO_CAP, fmt, ap); | |
128 | va_end (ap); | |
129 | ||
130 | AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err)); | |
131 | } | |
132 | ||
133 | static void alsa_anal_close (snd_pcm_t **handlep) | |
134 | { | |
135 | int err = snd_pcm_close (*handlep); | |
136 | if (err) { | |
137 | alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep); | |
138 | } | |
139 | *handlep = NULL; | |
140 | } | |
141 | ||
142 | static int alsa_write (SWVoiceOut *sw, void *buf, int len) | |
143 | { | |
144 | return audio_pcm_sw_write (sw, buf, len); | |
145 | } | |
146 | ||
ca9cc28c | 147 | static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt) |
1d14ffa9 FB |
148 | { |
149 | switch (fmt) { | |
150 | case AUD_FMT_S8: | |
151 | return SND_PCM_FORMAT_S8; | |
152 | ||
153 | case AUD_FMT_U8: | |
154 | return SND_PCM_FORMAT_U8; | |
155 | ||
156 | case AUD_FMT_S16: | |
157 | return SND_PCM_FORMAT_S16_LE; | |
158 | ||
159 | case AUD_FMT_U16: | |
160 | return SND_PCM_FORMAT_U16_LE; | |
161 | ||
f941aa25 TS |
162 | case AUD_FMT_S32: |
163 | return SND_PCM_FORMAT_S32_LE; | |
164 | ||
165 | case AUD_FMT_U32: | |
166 | return SND_PCM_FORMAT_U32_LE; | |
167 | ||
1d14ffa9 FB |
168 | default: |
169 | dolog ("Internal logic error: Bad audio format %d\n", fmt); | |
170 | #ifdef DEBUG_AUDIO | |
171 | abort (); | |
172 | #endif | |
173 | return SND_PCM_FORMAT_U8; | |
174 | } | |
175 | } | |
176 | ||
ca9cc28c AZ |
177 | static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt, |
178 | int *endianness) | |
1d14ffa9 FB |
179 | { |
180 | switch (alsafmt) { | |
181 | case SND_PCM_FORMAT_S8: | |
182 | *endianness = 0; | |
183 | *fmt = AUD_FMT_S8; | |
184 | break; | |
185 | ||
186 | case SND_PCM_FORMAT_U8: | |
187 | *endianness = 0; | |
188 | *fmt = AUD_FMT_U8; | |
189 | break; | |
190 | ||
191 | case SND_PCM_FORMAT_S16_LE: | |
192 | *endianness = 0; | |
193 | *fmt = AUD_FMT_S16; | |
194 | break; | |
195 | ||
196 | case SND_PCM_FORMAT_U16_LE: | |
197 | *endianness = 0; | |
198 | *fmt = AUD_FMT_U16; | |
199 | break; | |
200 | ||
201 | case SND_PCM_FORMAT_S16_BE: | |
202 | *endianness = 1; | |
203 | *fmt = AUD_FMT_S16; | |
204 | break; | |
205 | ||
206 | case SND_PCM_FORMAT_U16_BE: | |
207 | *endianness = 1; | |
208 | *fmt = AUD_FMT_U16; | |
209 | break; | |
210 | ||
f941aa25 TS |
211 | case SND_PCM_FORMAT_S32_LE: |
212 | *endianness = 0; | |
213 | *fmt = AUD_FMT_S32; | |
214 | break; | |
215 | ||
216 | case SND_PCM_FORMAT_U32_LE: | |
217 | *endianness = 0; | |
218 | *fmt = AUD_FMT_U32; | |
219 | break; | |
220 | ||
221 | case SND_PCM_FORMAT_S32_BE: | |
222 | *endianness = 1; | |
223 | *fmt = AUD_FMT_S32; | |
224 | break; | |
225 | ||
226 | case SND_PCM_FORMAT_U32_BE: | |
227 | *endianness = 1; | |
228 | *fmt = AUD_FMT_U32; | |
229 | break; | |
230 | ||
1d14ffa9 FB |
231 | default: |
232 | dolog ("Unrecognized audio format %d\n", alsafmt); | |
233 | return -1; | |
234 | } | |
235 | ||
236 | return 0; | |
237 | } | |
238 | ||
1d14ffa9 FB |
239 | static void alsa_dump_info (struct alsa_params_req *req, |
240 | struct alsa_params_obt *obt) | |
241 | { | |
242 | dolog ("parameter | requested value | obtained value\n"); | |
243 | dolog ("format | %10d | %10d\n", req->fmt, obt->fmt); | |
244 | dolog ("channels | %10d | %10d\n", | |
245 | req->nchannels, obt->nchannels); | |
246 | dolog ("frequency | %10d | %10d\n", req->freq, obt->freq); | |
247 | dolog ("============================================\n"); | |
248 | dolog ("requested: buffer size %d period size %d\n", | |
249 | req->buffer_size, req->period_size); | |
c0fe3827 | 250 | dolog ("obtained: samples %ld\n", obt->samples); |
1d14ffa9 | 251 | } |
1d14ffa9 FB |
252 | |
253 | static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold) | |
254 | { | |
255 | int err; | |
256 | snd_pcm_sw_params_t *sw_params; | |
257 | ||
258 | snd_pcm_sw_params_alloca (&sw_params); | |
259 | ||
260 | err = snd_pcm_sw_params_current (handle, sw_params); | |
261 | if (err < 0) { | |
c0fe3827 | 262 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
263 | alsa_logerr (err, "Failed to get current software parameters\n"); |
264 | return; | |
265 | } | |
266 | ||
267 | err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold); | |
268 | if (err < 0) { | |
c0fe3827 | 269 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
270 | alsa_logerr (err, "Failed to set software threshold to %ld\n", |
271 | threshold); | |
272 | return; | |
273 | } | |
274 | ||
275 | err = snd_pcm_sw_params (handle, sw_params); | |
276 | if (err < 0) { | |
c0fe3827 | 277 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
278 | alsa_logerr (err, "Failed to set software parameters\n"); |
279 | return; | |
280 | } | |
281 | } | |
282 | ||
283 | static int alsa_open (int in, struct alsa_params_req *req, | |
284 | struct alsa_params_obt *obt, snd_pcm_t **handlep) | |
285 | { | |
286 | snd_pcm_t *handle; | |
287 | snd_pcm_hw_params_t *hw_params; | |
60fe76f3 TS |
288 | int err; |
289 | unsigned int freq, nchannels; | |
1d14ffa9 FB |
290 | const char *pcm_name = in ? conf.pcm_name_in : conf.pcm_name_out; |
291 | unsigned int period_size, buffer_size; | |
292 | snd_pcm_uframes_t obt_buffer_size; | |
293 | const char *typ = in ? "ADC" : "DAC"; | |
ca9cc28c | 294 | snd_pcm_format_t obtfmt; |
1d14ffa9 FB |
295 | |
296 | freq = req->freq; | |
297 | period_size = req->period_size; | |
298 | buffer_size = req->buffer_size; | |
299 | nchannels = req->nchannels; | |
300 | ||
301 | snd_pcm_hw_params_alloca (&hw_params); | |
302 | ||
303 | err = snd_pcm_open ( | |
304 | &handle, | |
305 | pcm_name, | |
306 | in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK, | |
307 | SND_PCM_NONBLOCK | |
308 | ); | |
309 | if (err < 0) { | |
310 | alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name); | |
311 | return -1; | |
312 | } | |
313 | ||
314 | err = snd_pcm_hw_params_any (handle, hw_params); | |
315 | if (err < 0) { | |
316 | alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n"); | |
317 | goto err; | |
318 | } | |
319 | ||
320 | err = snd_pcm_hw_params_set_access ( | |
321 | handle, | |
322 | hw_params, | |
323 | SND_PCM_ACCESS_RW_INTERLEAVED | |
324 | ); | |
325 | if (err < 0) { | |
326 | alsa_logerr2 (err, typ, "Failed to set access type\n"); | |
327 | goto err; | |
328 | } | |
329 | ||
330 | err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt); | |
ca9cc28c | 331 | if (err < 0 && conf.verbose) { |
1d14ffa9 | 332 | alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt); |
1d14ffa9 FB |
333 | } |
334 | ||
335 | err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0); | |
336 | if (err < 0) { | |
337 | alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq); | |
338 | goto err; | |
339 | } | |
340 | ||
341 | err = snd_pcm_hw_params_set_channels_near ( | |
342 | handle, | |
343 | hw_params, | |
344 | &nchannels | |
345 | ); | |
346 | if (err < 0) { | |
347 | alsa_logerr2 (err, typ, "Failed to set number of channels %d\n", | |
348 | req->nchannels); | |
349 | goto err; | |
350 | } | |
351 | ||
352 | if (nchannels != 1 && nchannels != 2) { | |
353 | alsa_logerr2 (err, typ, | |
354 | "Can not handle obtained number of channels %d\n", | |
355 | nchannels); | |
356 | goto err; | |
357 | } | |
358 | ||
359 | if (!((in && conf.size_in_usec_in) || (!in && conf.size_in_usec_out))) { | |
360 | if (!buffer_size) { | |
361 | buffer_size = DEFAULT_BUFFER_SIZE; | |
362 | period_size= DEFAULT_PERIOD_SIZE; | |
363 | } | |
364 | } | |
365 | ||
366 | if (buffer_size) { | |
367 | if ((in && conf.size_in_usec_in) || (!in && conf.size_in_usec_out)) { | |
368 | if (period_size) { | |
369 | err = snd_pcm_hw_params_set_period_time_near ( | |
370 | handle, | |
371 | hw_params, | |
372 | &period_size, | |
c0fe3827 FB |
373 | 0 |
374 | ); | |
1d14ffa9 FB |
375 | if (err < 0) { |
376 | alsa_logerr2 (err, typ, | |
377 | "Failed to set period time %d\n", | |
378 | req->period_size); | |
379 | goto err; | |
380 | } | |
381 | } | |
382 | ||
383 | err = snd_pcm_hw_params_set_buffer_time_near ( | |
384 | handle, | |
385 | hw_params, | |
386 | &buffer_size, | |
c0fe3827 FB |
387 | 0 |
388 | ); | |
1d14ffa9 FB |
389 | |
390 | if (err < 0) { | |
391 | alsa_logerr2 (err, typ, | |
392 | "Failed to set buffer time %d\n", | |
393 | req->buffer_size); | |
394 | goto err; | |
395 | } | |
396 | } | |
397 | else { | |
398 | int dir; | |
399 | snd_pcm_uframes_t minval; | |
400 | ||
401 | if (period_size) { | |
402 | minval = period_size; | |
403 | dir = 0; | |
404 | ||
405 | err = snd_pcm_hw_params_get_period_size_min ( | |
406 | hw_params, | |
407 | &minval, | |
408 | &dir | |
409 | ); | |
410 | if (err < 0) { | |
411 | alsa_logerr ( | |
412 | err, | |
c0fe3827 | 413 | "Could not get minmal period size for %s\n", |
1d14ffa9 FB |
414 | typ |
415 | ); | |
416 | } | |
417 | else { | |
418 | if (period_size < minval) { | |
fe8f096b TS |
419 | if ((in && conf.period_size_in_overridden) |
420 | || (!in && conf.period_size_out_overridden)) { | |
1d14ffa9 FB |
421 | dolog ("%s period size(%d) is less " |
422 | "than minmal period size(%ld)\n", | |
423 | typ, | |
424 | period_size, | |
425 | minval); | |
426 | } | |
427 | period_size = minval; | |
428 | } | |
429 | } | |
430 | ||
431 | err = snd_pcm_hw_params_set_period_size ( | |
432 | handle, | |
433 | hw_params, | |
434 | period_size, | |
435 | 0 | |
436 | ); | |
437 | if (err < 0) { | |
438 | alsa_logerr2 (err, typ, "Failed to set period size %d\n", | |
439 | req->period_size); | |
440 | goto err; | |
441 | } | |
442 | } | |
443 | ||
444 | minval = buffer_size; | |
445 | err = snd_pcm_hw_params_get_buffer_size_min ( | |
446 | hw_params, | |
447 | &minval | |
448 | ); | |
449 | if (err < 0) { | |
c0fe3827 | 450 | alsa_logerr (err, "Could not get minmal buffer size for %s\n", |
1d14ffa9 FB |
451 | typ); |
452 | } | |
453 | else { | |
454 | if (buffer_size < minval) { | |
fe8f096b TS |
455 | if ((in && conf.buffer_size_in_overridden) |
456 | || (!in && conf.buffer_size_out_overridden)) { | |
1d14ffa9 FB |
457 | dolog ( |
458 | "%s buffer size(%d) is less " | |
459 | "than minimal buffer size(%ld)\n", | |
460 | typ, | |
461 | buffer_size, | |
462 | minval | |
463 | ); | |
464 | } | |
465 | buffer_size = minval; | |
466 | } | |
467 | } | |
468 | ||
469 | err = snd_pcm_hw_params_set_buffer_size ( | |
470 | handle, | |
471 | hw_params, | |
472 | buffer_size | |
473 | ); | |
474 | if (err < 0) { | |
475 | alsa_logerr2 (err, typ, "Failed to set buffer size %d\n", | |
476 | req->buffer_size); | |
477 | goto err; | |
478 | } | |
479 | } | |
480 | } | |
481 | else { | |
c0fe3827 | 482 | dolog ("warning: Buffer size is not set\n"); |
1d14ffa9 FB |
483 | } |
484 | ||
485 | err = snd_pcm_hw_params (handle, hw_params); | |
486 | if (err < 0) { | |
487 | alsa_logerr2 (err, typ, "Failed to apply audio parameters\n"); | |
488 | goto err; | |
489 | } | |
490 | ||
491 | err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size); | |
492 | if (err < 0) { | |
493 | alsa_logerr2 (err, typ, "Failed to get buffer size\n"); | |
494 | goto err; | |
495 | } | |
496 | ||
ca9cc28c AZ |
497 | err = snd_pcm_hw_params_get_format (hw_params, &obtfmt); |
498 | if (err < 0) { | |
499 | alsa_logerr2 (err, typ, "Failed to get format\n"); | |
500 | goto err; | |
501 | } | |
502 | ||
503 | if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) { | |
504 | dolog ("Invalid format was returned %d\n", obtfmt); | |
505 | goto err; | |
506 | } | |
507 | ||
1d14ffa9 FB |
508 | err = snd_pcm_prepare (handle); |
509 | if (err < 0) { | |
c0fe3827 | 510 | alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle); |
1d14ffa9 FB |
511 | goto err; |
512 | } | |
513 | ||
1d14ffa9 FB |
514 | if (!in && conf.threshold) { |
515 | snd_pcm_uframes_t threshold; | |
516 | int bytes_per_sec; | |
517 | ||
ca9cc28c AZ |
518 | bytes_per_sec = freq << (nchannels == 2); |
519 | ||
520 | switch (obt->fmt) { | |
521 | case AUD_FMT_S8: | |
522 | case AUD_FMT_U8: | |
523 | break; | |
524 | ||
525 | case AUD_FMT_S16: | |
526 | case AUD_FMT_U16: | |
527 | bytes_per_sec <<= 1; | |
528 | break; | |
529 | ||
530 | case AUD_FMT_S32: | |
531 | case AUD_FMT_U32: | |
532 | bytes_per_sec <<= 2; | |
533 | break; | |
534 | } | |
1d14ffa9 FB |
535 | |
536 | threshold = (conf.threshold * bytes_per_sec) / 1000; | |
537 | alsa_set_threshold (handle, threshold); | |
538 | } | |
539 | ||
1d14ffa9 FB |
540 | obt->nchannels = nchannels; |
541 | obt->freq = freq; | |
c0fe3827 | 542 | obt->samples = obt_buffer_size; |
ca9cc28c | 543 | |
1d14ffa9 FB |
544 | *handlep = handle; |
545 | ||
ca9cc28c AZ |
546 | if (conf.verbose && |
547 | (obt->fmt != req->fmt || | |
548 | obt->nchannels != req->nchannels || | |
549 | obt->freq != req->freq)) { | |
550 | dolog ("Audio paramters for %s\n", typ); | |
1d14ffa9 | 551 | alsa_dump_info (req, obt); |
1d14ffa9 FB |
552 | } |
553 | ||
554 | #ifdef DEBUG | |
555 | alsa_dump_info (req, obt); | |
556 | #endif | |
557 | return 0; | |
558 | ||
559 | err: | |
560 | alsa_anal_close (&handle); | |
561 | return -1; | |
562 | } | |
563 | ||
564 | static int alsa_recover (snd_pcm_t *handle) | |
565 | { | |
566 | int err = snd_pcm_prepare (handle); | |
567 | if (err < 0) { | |
568 | alsa_logerr (err, "Failed to prepare handle %p\n", handle); | |
569 | return -1; | |
570 | } | |
571 | return 0; | |
572 | } | |
573 | ||
571ec3d6 FB |
574 | static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle) |
575 | { | |
576 | snd_pcm_sframes_t avail; | |
577 | ||
578 | avail = snd_pcm_avail_update (handle); | |
579 | if (avail < 0) { | |
580 | if (avail == -EPIPE) { | |
581 | if (!alsa_recover (handle)) { | |
582 | avail = snd_pcm_avail_update (handle); | |
583 | } | |
584 | } | |
585 | ||
586 | if (avail < 0) { | |
587 | alsa_logerr (avail, | |
588 | "Could not obtain number of available frames\n"); | |
589 | return -1; | |
590 | } | |
591 | } | |
592 | ||
593 | return avail; | |
594 | } | |
595 | ||
1d14ffa9 FB |
596 | static int alsa_run_out (HWVoiceOut *hw) |
597 | { | |
598 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; | |
599 | int rpos, live, decr; | |
600 | int samples; | |
601 | uint8_t *dst; | |
602 | st_sample_t *src; | |
603 | snd_pcm_sframes_t avail; | |
604 | ||
605 | live = audio_pcm_hw_get_live_out (hw); | |
606 | if (!live) { | |
607 | return 0; | |
608 | } | |
609 | ||
571ec3d6 | 610 | avail = alsa_get_avail (alsa->handle); |
1d14ffa9 | 611 | if (avail < 0) { |
571ec3d6 | 612 | dolog ("Could not get number of available playback frames\n"); |
1d14ffa9 FB |
613 | return 0; |
614 | } | |
615 | ||
1d14ffa9 FB |
616 | decr = audio_MIN (live, avail); |
617 | samples = decr; | |
618 | rpos = hw->rpos; | |
619 | while (samples) { | |
620 | int left_till_end_samples = hw->samples - rpos; | |
571ec3d6 | 621 | int len = audio_MIN (samples, left_till_end_samples); |
1d14ffa9 FB |
622 | snd_pcm_sframes_t written; |
623 | ||
624 | src = hw->mix_buf + rpos; | |
625 | dst = advance (alsa->pcm_buf, rpos << hw->info.shift); | |
626 | ||
571ec3d6 | 627 | hw->clip (dst, src, len); |
1d14ffa9 | 628 | |
571ec3d6 FB |
629 | while (len) { |
630 | written = snd_pcm_writei (alsa->handle, dst, len); | |
4787c71d | 631 | |
571ec3d6 | 632 | if (written <= 0) { |
4787c71d | 633 | switch (written) { |
571ec3d6 FB |
634 | case 0: |
635 | if (conf.verbose) { | |
636 | dolog ("Failed to write %d frames (wrote zero)\n", len); | |
4787c71d | 637 | } |
4787c71d FB |
638 | goto exit; |
639 | ||
571ec3d6 FB |
640 | case -EPIPE: |
641 | if (alsa_recover (alsa->handle)) { | |
642 | alsa_logerr (written, "Failed to write %d frames\n", | |
643 | len); | |
644 | goto exit; | |
645 | } | |
646 | if (conf.verbose) { | |
647 | dolog ("Recovering from playback xrun\n"); | |
648 | } | |
4787c71d FB |
649 | continue; |
650 | ||
571ec3d6 FB |
651 | case -EAGAIN: |
652 | goto exit; | |
653 | ||
4787c71d FB |
654 | default: |
655 | alsa_logerr (written, "Failed to write %d frames to %p\n", | |
571ec3d6 | 656 | len, dst); |
4787c71d | 657 | goto exit; |
1d14ffa9 | 658 | } |
1d14ffa9 | 659 | } |
1d14ffa9 | 660 | |
4787c71d FB |
661 | rpos = (rpos + written) % hw->samples; |
662 | samples -= written; | |
571ec3d6 | 663 | len -= written; |
4787c71d FB |
664 | dst = advance (dst, written << hw->info.shift); |
665 | src += written; | |
666 | } | |
1d14ffa9 FB |
667 | } |
668 | ||
669 | exit: | |
670 | hw->rpos = rpos; | |
671 | return decr; | |
672 | } | |
673 | ||
674 | static void alsa_fini_out (HWVoiceOut *hw) | |
675 | { | |
676 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; | |
677 | ||
678 | ldebug ("alsa_fini\n"); | |
679 | alsa_anal_close (&alsa->handle); | |
680 | ||
681 | if (alsa->pcm_buf) { | |
682 | qemu_free (alsa->pcm_buf); | |
683 | alsa->pcm_buf = NULL; | |
684 | } | |
685 | } | |
686 | ||
c0fe3827 | 687 | static int alsa_init_out (HWVoiceOut *hw, audsettings_t *as) |
1d14ffa9 FB |
688 | { |
689 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; | |
690 | struct alsa_params_req req; | |
691 | struct alsa_params_obt obt; | |
1d14ffa9 | 692 | snd_pcm_t *handle; |
c0fe3827 | 693 | audsettings_t obt_as; |
1d14ffa9 | 694 | |
c0fe3827 FB |
695 | req.fmt = aud_to_alsafmt (as->fmt); |
696 | req.freq = as->freq; | |
697 | req.nchannels = as->nchannels; | |
1d14ffa9 FB |
698 | req.period_size = conf.period_size_out; |
699 | req.buffer_size = conf.buffer_size_out; | |
700 | ||
701 | if (alsa_open (0, &req, &obt, &handle)) { | |
702 | return -1; | |
703 | } | |
704 | ||
c0fe3827 FB |
705 | obt_as.freq = obt.freq; |
706 | obt_as.nchannels = obt.nchannels; | |
ca9cc28c AZ |
707 | obt_as.fmt = obt.fmt; |
708 | obt_as.endianness = obt.endianness; | |
c0fe3827 | 709 | |
d929eba5 | 710 | audio_pcm_init_info (&hw->info, &obt_as); |
c0fe3827 | 711 | hw->samples = obt.samples; |
1d14ffa9 | 712 | |
c0fe3827 | 713 | alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift); |
1d14ffa9 | 714 | if (!alsa->pcm_buf) { |
4787c71d FB |
715 | dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n", |
716 | hw->samples, 1 << hw->info.shift); | |
1d14ffa9 FB |
717 | alsa_anal_close (&handle); |
718 | return -1; | |
719 | } | |
720 | ||
721 | alsa->handle = handle; | |
1d14ffa9 FB |
722 | return 0; |
723 | } | |
724 | ||
571ec3d6 | 725 | static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause) |
1d14ffa9 FB |
726 | { |
727 | int err; | |
571ec3d6 FB |
728 | |
729 | if (pause) { | |
730 | err = snd_pcm_drop (handle); | |
731 | if (err < 0) { | |
32d448c4 | 732 | alsa_logerr (err, "Could not stop %s\n", typ); |
571ec3d6 FB |
733 | return -1; |
734 | } | |
735 | } | |
736 | else { | |
737 | err = snd_pcm_prepare (handle); | |
738 | if (err < 0) { | |
32d448c4 | 739 | alsa_logerr (err, "Could not prepare handle for %s\n", typ); |
571ec3d6 FB |
740 | return -1; |
741 | } | |
742 | } | |
743 | ||
744 | return 0; | |
745 | } | |
746 | ||
747 | static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...) | |
748 | { | |
1d14ffa9 FB |
749 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; |
750 | ||
751 | switch (cmd) { | |
752 | case VOICE_ENABLE: | |
753 | ldebug ("enabling voice\n"); | |
571ec3d6 | 754 | return alsa_voice_ctl (alsa->handle, "playback", 0); |
1d14ffa9 FB |
755 | |
756 | case VOICE_DISABLE: | |
757 | ldebug ("disabling voice\n"); | |
571ec3d6 | 758 | return alsa_voice_ctl (alsa->handle, "playback", 1); |
1d14ffa9 | 759 | } |
571ec3d6 FB |
760 | |
761 | return -1; | |
1d14ffa9 FB |
762 | } |
763 | ||
c0fe3827 | 764 | static int alsa_init_in (HWVoiceIn *hw, audsettings_t *as) |
1d14ffa9 FB |
765 | { |
766 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
767 | struct alsa_params_req req; | |
768 | struct alsa_params_obt obt; | |
1d14ffa9 | 769 | snd_pcm_t *handle; |
c0fe3827 | 770 | audsettings_t obt_as; |
1d14ffa9 | 771 | |
c0fe3827 FB |
772 | req.fmt = aud_to_alsafmt (as->fmt); |
773 | req.freq = as->freq; | |
774 | req.nchannels = as->nchannels; | |
1d14ffa9 FB |
775 | req.period_size = conf.period_size_in; |
776 | req.buffer_size = conf.buffer_size_in; | |
777 | ||
778 | if (alsa_open (1, &req, &obt, &handle)) { | |
779 | return -1; | |
780 | } | |
781 | ||
c0fe3827 FB |
782 | obt_as.freq = obt.freq; |
783 | obt_as.nchannels = obt.nchannels; | |
ca9cc28c AZ |
784 | obt_as.fmt = obt.fmt; |
785 | obt_as.endianness = obt.endianness; | |
c0fe3827 | 786 | |
d929eba5 | 787 | audio_pcm_init_info (&hw->info, &obt_as); |
c0fe3827 FB |
788 | hw->samples = obt.samples; |
789 | ||
790 | alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift); | |
1d14ffa9 | 791 | if (!alsa->pcm_buf) { |
4787c71d FB |
792 | dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n", |
793 | hw->samples, 1 << hw->info.shift); | |
1d14ffa9 FB |
794 | alsa_anal_close (&handle); |
795 | return -1; | |
796 | } | |
797 | ||
798 | alsa->handle = handle; | |
799 | return 0; | |
800 | } | |
801 | ||
802 | static void alsa_fini_in (HWVoiceIn *hw) | |
803 | { | |
804 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
805 | ||
806 | alsa_anal_close (&alsa->handle); | |
807 | ||
808 | if (alsa->pcm_buf) { | |
809 | qemu_free (alsa->pcm_buf); | |
810 | alsa->pcm_buf = NULL; | |
811 | } | |
812 | } | |
813 | ||
814 | static int alsa_run_in (HWVoiceIn *hw) | |
815 | { | |
816 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
817 | int hwshift = hw->info.shift; | |
818 | int i; | |
819 | int live = audio_pcm_hw_get_live_in (hw); | |
820 | int dead = hw->samples - live; | |
571ec3d6 | 821 | int decr; |
1d14ffa9 FB |
822 | struct { |
823 | int add; | |
824 | int len; | |
825 | } bufs[2] = { | |
826 | { hw->wpos, 0 }, | |
827 | { 0, 0 } | |
828 | }; | |
571ec3d6 | 829 | snd_pcm_sframes_t avail; |
1d14ffa9 FB |
830 | snd_pcm_uframes_t read_samples = 0; |
831 | ||
832 | if (!dead) { | |
833 | return 0; | |
834 | } | |
835 | ||
571ec3d6 FB |
836 | avail = alsa_get_avail (alsa->handle); |
837 | if (avail < 0) { | |
838 | dolog ("Could not get number of captured frames\n"); | |
839 | return 0; | |
840 | } | |
841 | ||
842 | if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) { | |
843 | avail = hw->samples; | |
844 | } | |
845 | ||
846 | decr = audio_MIN (dead, avail); | |
847 | if (!decr) { | |
848 | return 0; | |
849 | } | |
850 | ||
851 | if (hw->wpos + decr > hw->samples) { | |
1d14ffa9 | 852 | bufs[0].len = (hw->samples - hw->wpos); |
571ec3d6 | 853 | bufs[1].len = (decr - (hw->samples - hw->wpos)); |
1d14ffa9 FB |
854 | } |
855 | else { | |
571ec3d6 | 856 | bufs[0].len = decr; |
1d14ffa9 FB |
857 | } |
858 | ||
1d14ffa9 FB |
859 | for (i = 0; i < 2; ++i) { |
860 | void *src; | |
861 | st_sample_t *dst; | |
862 | snd_pcm_sframes_t nread; | |
863 | snd_pcm_uframes_t len; | |
864 | ||
865 | len = bufs[i].len; | |
866 | ||
867 | src = advance (alsa->pcm_buf, bufs[i].add << hwshift); | |
868 | dst = hw->conv_buf + bufs[i].add; | |
869 | ||
870 | while (len) { | |
871 | nread = snd_pcm_readi (alsa->handle, src, len); | |
872 | ||
571ec3d6 | 873 | if (nread <= 0) { |
1d14ffa9 | 874 | switch (nread) { |
571ec3d6 FB |
875 | case 0: |
876 | if (conf.verbose) { | |
877 | dolog ("Failed to read %ld frames (read zero)\n", len); | |
1d14ffa9 | 878 | } |
1d14ffa9 FB |
879 | goto exit; |
880 | ||
571ec3d6 FB |
881 | case -EPIPE: |
882 | if (alsa_recover (alsa->handle)) { | |
883 | alsa_logerr (nread, "Failed to read %ld frames\n", len); | |
884 | goto exit; | |
885 | } | |
886 | if (conf.verbose) { | |
887 | dolog ("Recovering from capture xrun\n"); | |
888 | } | |
1d14ffa9 FB |
889 | continue; |
890 | ||
571ec3d6 FB |
891 | case -EAGAIN: |
892 | goto exit; | |
893 | ||
1d14ffa9 FB |
894 | default: |
895 | alsa_logerr ( | |
896 | nread, | |
897 | "Failed to read %ld frames from %p\n", | |
898 | len, | |
899 | src | |
900 | ); | |
901 | goto exit; | |
902 | } | |
903 | } | |
904 | ||
905 | hw->conv (dst, src, nread, &nominal_volume); | |
906 | ||
907 | src = advance (src, nread << hwshift); | |
908 | dst += nread; | |
909 | ||
910 | read_samples += nread; | |
911 | len -= nread; | |
912 | } | |
913 | } | |
914 | ||
915 | exit: | |
916 | hw->wpos = (hw->wpos + read_samples) % hw->samples; | |
917 | return read_samples; | |
918 | } | |
919 | ||
920 | static int alsa_read (SWVoiceIn *sw, void *buf, int size) | |
921 | { | |
922 | return audio_pcm_sw_read (sw, buf, size); | |
923 | } | |
924 | ||
925 | static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...) | |
926 | { | |
571ec3d6 FB |
927 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; |
928 | ||
929 | switch (cmd) { | |
930 | case VOICE_ENABLE: | |
931 | ldebug ("enabling voice\n"); | |
932 | return alsa_voice_ctl (alsa->handle, "capture", 0); | |
933 | ||
934 | case VOICE_DISABLE: | |
935 | ldebug ("disabling voice\n"); | |
936 | return alsa_voice_ctl (alsa->handle, "capture", 1); | |
937 | } | |
938 | ||
939 | return -1; | |
1d14ffa9 FB |
940 | } |
941 | ||
942 | static void *alsa_audio_init (void) | |
943 | { | |
944 | return &conf; | |
945 | } | |
946 | ||
947 | static void alsa_audio_fini (void *opaque) | |
948 | { | |
949 | (void) opaque; | |
950 | } | |
951 | ||
952 | static struct audio_option alsa_options[] = { | |
953 | {"DAC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_out, | |
954 | "DAC period/buffer size in microseconds (otherwise in frames)", NULL, 0}, | |
955 | {"DAC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_out, | |
fe8f096b | 956 | "DAC period size", &conf.period_size_out_overridden, 0}, |
1d14ffa9 | 957 | {"DAC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_out, |
fe8f096b | 958 | "DAC buffer size", &conf.buffer_size_out_overridden, 0}, |
1d14ffa9 FB |
959 | |
960 | {"ADC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_in, | |
961 | "ADC period/buffer size in microseconds (otherwise in frames)", NULL, 0}, | |
962 | {"ADC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_in, | |
fe8f096b | 963 | "ADC period size", &conf.period_size_in_overridden, 0}, |
1d14ffa9 | 964 | {"ADC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_in, |
fe8f096b | 965 | "ADC buffer size", &conf.buffer_size_in_overridden, 0}, |
1d14ffa9 FB |
966 | |
967 | {"THRESHOLD", AUD_OPT_INT, &conf.threshold, | |
968 | "(undocumented)", NULL, 0}, | |
969 | ||
970 | {"DAC_DEV", AUD_OPT_STR, &conf.pcm_name_out, | |
971 | "DAC device name (for instance dmix)", NULL, 0}, | |
972 | ||
973 | {"ADC_DEV", AUD_OPT_STR, &conf.pcm_name_in, | |
974 | "ADC device name", NULL, 0}, | |
571ec3d6 FB |
975 | |
976 | {"VERBOSE", AUD_OPT_BOOL, &conf.verbose, | |
977 | "Behave in a more verbose way", NULL, 0}, | |
978 | ||
1d14ffa9 FB |
979 | {NULL, 0, NULL, NULL, NULL, 0} |
980 | }; | |
981 | ||
982 | static struct audio_pcm_ops alsa_pcm_ops = { | |
983 | alsa_init_out, | |
984 | alsa_fini_out, | |
985 | alsa_run_out, | |
986 | alsa_write, | |
987 | alsa_ctl_out, | |
988 | ||
989 | alsa_init_in, | |
990 | alsa_fini_in, | |
991 | alsa_run_in, | |
992 | alsa_read, | |
993 | alsa_ctl_in | |
994 | }; | |
995 | ||
996 | struct audio_driver alsa_audio_driver = { | |
997 | INIT_FIELD (name = ) "alsa", | |
998 | INIT_FIELD (descr = ) "ALSA http://www.alsa-project.org", | |
999 | INIT_FIELD (options = ) alsa_options, | |
1000 | INIT_FIELD (init = ) alsa_audio_init, | |
1001 | INIT_FIELD (fini = ) alsa_audio_fini, | |
1002 | INIT_FIELD (pcm_ops = ) &alsa_pcm_ops, | |
1003 | INIT_FIELD (can_be_default = ) 1, | |
1004 | INIT_FIELD (max_voices_out = ) INT_MAX, | |
1005 | INIT_FIELD (max_voices_in = ) INT_MAX, | |
1006 | INIT_FIELD (voice_size_out = ) sizeof (ALSAVoiceOut), | |
1007 | INIT_FIELD (voice_size_in = ) sizeof (ALSAVoiceIn) | |
1008 | }; |