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