]>
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 | */ | |
0b8fa32f | 24 | |
6086a565 | 25 | #include "qemu/osdep.h" |
1d14ffa9 | 26 | #include <alsa/asoundlib.h> |
1de7afc9 | 27 | #include "qemu/main-loop.h" |
0b8fa32f | 28 | #include "qemu/module.h" |
749bc4bf | 29 | #include "audio.h" |
fbb7ef56 | 30 | #include "trace.h" |
1d14ffa9 | 31 | |
2637872b | 32 | #pragma GCC diagnostic ignored "-Waddress" |
2637872b | 33 | |
1d14ffa9 FB |
34 | #define AUDIO_CAP "alsa" |
35 | #include "audio_int.h" | |
36 | ||
8b438ba3 | 37 | struct pollhlp { |
38 | snd_pcm_t *handle; | |
39 | struct pollfd *pfds; | |
40 | int count; | |
b4f763b8 | 41 | int mask; |
18e2c177 | 42 | AudioState *s; |
8b438ba3 | 43 | }; |
44 | ||
1d14ffa9 FB |
45 | typedef struct ALSAVoiceOut { |
46 | HWVoiceOut hw; | |
1d14ffa9 | 47 | snd_pcm_t *handle; |
8b438ba3 | 48 | struct pollhlp pollhlp; |
a93f3281 | 49 | Audiodev *dev; |
1d14ffa9 FB |
50 | } ALSAVoiceOut; |
51 | ||
52 | typedef struct ALSAVoiceIn { | |
53 | HWVoiceIn hw; | |
54 | snd_pcm_t *handle; | |
8b438ba3 | 55 | struct pollhlp pollhlp; |
a93f3281 | 56 | Audiodev *dev; |
1d14ffa9 FB |
57 | } ALSAVoiceIn; |
58 | ||
1d14ffa9 | 59 | struct alsa_params_req { |
ca9cc28c AZ |
60 | int freq; |
61 | snd_pcm_format_t fmt; | |
62 | int nchannels; | |
1d14ffa9 FB |
63 | }; |
64 | ||
65 | struct alsa_params_obt { | |
66 | int freq; | |
85bc5852 | 67 | AudioFormat fmt; |
ca9cc28c | 68 | int endianness; |
1d14ffa9 | 69 | int nchannels; |
c0fe3827 | 70 | snd_pcm_uframes_t samples; |
1d14ffa9 FB |
71 | }; |
72 | ||
73 | static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...) | |
74 | { | |
75 | va_list ap; | |
76 | ||
77 | va_start (ap, fmt); | |
78 | AUD_vlog (AUDIO_CAP, fmt, ap); | |
79 | va_end (ap); | |
80 | ||
81 | AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err)); | |
82 | } | |
83 | ||
84 | static void GCC_FMT_ATTR (3, 4) alsa_logerr2 ( | |
85 | int err, | |
86 | const char *typ, | |
87 | const char *fmt, | |
88 | ... | |
89 | ) | |
90 | { | |
91 | va_list ap; | |
92 | ||
c0fe3827 | 93 | AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ); |
1d14ffa9 FB |
94 | |
95 | va_start (ap, fmt); | |
96 | AUD_vlog (AUDIO_CAP, fmt, ap); | |
97 | va_end (ap); | |
98 | ||
99 | AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err)); | |
100 | } | |
101 | ||
6ebfda13 | 102 | static void alsa_fini_poll (struct pollhlp *hlp) |
103 | { | |
104 | int i; | |
105 | struct pollfd *pfds = hlp->pfds; | |
106 | ||
107 | if (pfds) { | |
108 | for (i = 0; i < hlp->count; ++i) { | |
109 | qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL); | |
110 | } | |
7267c094 | 111 | g_free (pfds); |
6ebfda13 | 112 | } |
113 | hlp->pfds = NULL; | |
114 | hlp->count = 0; | |
115 | hlp->handle = NULL; | |
116 | } | |
117 | ||
118 | static void alsa_anal_close1 (snd_pcm_t **handlep) | |
1d14ffa9 FB |
119 | { |
120 | int err = snd_pcm_close (*handlep); | |
121 | if (err) { | |
122 | alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep); | |
123 | } | |
124 | *handlep = NULL; | |
125 | } | |
126 | ||
6ebfda13 | 127 | static void alsa_anal_close (snd_pcm_t **handlep, struct pollhlp *hlp) |
128 | { | |
129 | alsa_fini_poll (hlp); | |
130 | alsa_anal_close1 (handlep); | |
131 | } | |
132 | ||
8b438ba3 | 133 | static int alsa_recover (snd_pcm_t *handle) |
134 | { | |
135 | int err = snd_pcm_prepare (handle); | |
136 | if (err < 0) { | |
137 | alsa_logerr (err, "Failed to prepare handle %p\n", handle); | |
138 | return -1; | |
139 | } | |
140 | return 0; | |
141 | } | |
142 | ||
143 | static int alsa_resume (snd_pcm_t *handle) | |
144 | { | |
145 | int err = snd_pcm_resume (handle); | |
146 | if (err < 0) { | |
147 | alsa_logerr (err, "Failed to resume handle %p\n", handle); | |
148 | return -1; | |
149 | } | |
150 | return 0; | |
151 | } | |
152 | ||
153 | static void alsa_poll_handler (void *opaque) | |
154 | { | |
155 | int err, count; | |
156 | snd_pcm_state_t state; | |
157 | struct pollhlp *hlp = opaque; | |
158 | unsigned short revents; | |
159 | ||
160 | count = poll (hlp->pfds, hlp->count, 0); | |
161 | if (count < 0) { | |
162 | dolog ("alsa_poll_handler: poll %s\n", strerror (errno)); | |
163 | return; | |
164 | } | |
165 | ||
166 | if (!count) { | |
167 | return; | |
168 | } | |
169 | ||
170 | /* XXX: ALSA example uses initial count, not the one returned by | |
171 | poll, correct? */ | |
172 | err = snd_pcm_poll_descriptors_revents (hlp->handle, hlp->pfds, | |
173 | hlp->count, &revents); | |
174 | if (err < 0) { | |
175 | alsa_logerr (err, "snd_pcm_poll_descriptors_revents"); | |
176 | return; | |
177 | } | |
178 | ||
b4f763b8 | 179 | if (!(revents & hlp->mask)) { |
fbb7ef56 | 180 | trace_alsa_revents(revents); |
8b438ba3 | 181 | return; |
182 | } | |
183 | ||
184 | state = snd_pcm_state (hlp->handle); | |
185 | switch (state) { | |
d9812b03 | 186 | case SND_PCM_STATE_SETUP: |
187 | alsa_recover (hlp->handle); | |
188 | break; | |
189 | ||
8b438ba3 | 190 | case SND_PCM_STATE_XRUN: |
191 | alsa_recover (hlp->handle); | |
192 | break; | |
193 | ||
194 | case SND_PCM_STATE_SUSPENDED: | |
195 | alsa_resume (hlp->handle); | |
196 | break; | |
197 | ||
198 | case SND_PCM_STATE_PREPARED: | |
18e2c177 | 199 | audio_run(hlp->s, "alsa run (prepared)"); |
8b438ba3 | 200 | break; |
201 | ||
202 | case SND_PCM_STATE_RUNNING: | |
18e2c177 | 203 | audio_run(hlp->s, "alsa run (running)"); |
8b438ba3 | 204 | break; |
205 | ||
206 | default: | |
207 | dolog ("Unexpected state %d\n", state); | |
208 | } | |
209 | } | |
210 | ||
b4f763b8 | 211 | static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask) |
8b438ba3 | 212 | { |
213 | int i, count, err; | |
214 | struct pollfd *pfds; | |
215 | ||
216 | count = snd_pcm_poll_descriptors_count (handle); | |
217 | if (count <= 0) { | |
218 | dolog ("Could not initialize poll mode\n" | |
219 | "Invalid number of poll descriptors %d\n", count); | |
220 | return -1; | |
221 | } | |
222 | ||
223 | pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds)); | |
224 | if (!pfds) { | |
225 | dolog ("Could not initialize poll mode\n"); | |
226 | return -1; | |
227 | } | |
228 | ||
229 | err = snd_pcm_poll_descriptors (handle, pfds, count); | |
230 | if (err < 0) { | |
231 | alsa_logerr (err, "Could not initialize poll mode\n" | |
232 | "Could not obtain poll descriptors\n"); | |
7267c094 | 233 | g_free (pfds); |
8b438ba3 | 234 | return -1; |
235 | } | |
236 | ||
237 | for (i = 0; i < count; ++i) { | |
238 | if (pfds[i].events & POLLIN) { | |
be93f216 | 239 | qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler, NULL, hlp); |
8b438ba3 | 240 | } |
241 | if (pfds[i].events & POLLOUT) { | |
fbb7ef56 | 242 | trace_alsa_pollout(i, pfds[i].fd); |
be93f216 | 243 | qemu_set_fd_handler (pfds[i].fd, NULL, alsa_poll_handler, hlp); |
8b438ba3 | 244 | } |
fbb7ef56 | 245 | trace_alsa_set_handler(pfds[i].events, i, pfds[i].fd, err); |
8b438ba3 | 246 | |
8b438ba3 | 247 | } |
248 | hlp->pfds = pfds; | |
249 | hlp->count = count; | |
250 | hlp->handle = handle; | |
b4f763b8 | 251 | hlp->mask = mask; |
8b438ba3 | 252 | return 0; |
253 | } | |
254 | ||
255 | static int alsa_poll_out (HWVoiceOut *hw) | |
256 | { | |
257 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; | |
258 | ||
b4f763b8 | 259 | return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLOUT); |
8b438ba3 | 260 | } |
261 | ||
262 | static int alsa_poll_in (HWVoiceIn *hw) | |
263 | { | |
264 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
265 | ||
b4f763b8 | 266 | return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLIN); |
8b438ba3 | 267 | } |
268 | ||
85bc5852 | 269 | static snd_pcm_format_t aud_to_alsafmt (AudioFormat fmt, int endianness) |
1d14ffa9 FB |
270 | { |
271 | switch (fmt) { | |
85bc5852 | 272 | case AUDIO_FORMAT_S8: |
1d14ffa9 FB |
273 | return SND_PCM_FORMAT_S8; |
274 | ||
85bc5852 | 275 | case AUDIO_FORMAT_U8: |
1d14ffa9 FB |
276 | return SND_PCM_FORMAT_U8; |
277 | ||
85bc5852 | 278 | case AUDIO_FORMAT_S16: |
d66bddd7 MW |
279 | if (endianness) { |
280 | return SND_PCM_FORMAT_S16_BE; | |
281 | } | |
282 | else { | |
283 | return SND_PCM_FORMAT_S16_LE; | |
284 | } | |
1d14ffa9 | 285 | |
85bc5852 | 286 | case AUDIO_FORMAT_U16: |
d66bddd7 MW |
287 | if (endianness) { |
288 | return SND_PCM_FORMAT_U16_BE; | |
289 | } | |
290 | else { | |
291 | return SND_PCM_FORMAT_U16_LE; | |
292 | } | |
1d14ffa9 | 293 | |
85bc5852 | 294 | case AUDIO_FORMAT_S32: |
d66bddd7 MW |
295 | if (endianness) { |
296 | return SND_PCM_FORMAT_S32_BE; | |
297 | } | |
298 | else { | |
299 | return SND_PCM_FORMAT_S32_LE; | |
300 | } | |
f941aa25 | 301 | |
85bc5852 | 302 | case AUDIO_FORMAT_U32: |
d66bddd7 MW |
303 | if (endianness) { |
304 | return SND_PCM_FORMAT_U32_BE; | |
305 | } | |
306 | else { | |
307 | return SND_PCM_FORMAT_U32_LE; | |
308 | } | |
f941aa25 | 309 | |
1d14ffa9 FB |
310 | default: |
311 | dolog ("Internal logic error: Bad audio format %d\n", fmt); | |
312 | #ifdef DEBUG_AUDIO | |
313 | abort (); | |
314 | #endif | |
315 | return SND_PCM_FORMAT_U8; | |
316 | } | |
317 | } | |
318 | ||
85bc5852 | 319 | static int alsa_to_audfmt (snd_pcm_format_t alsafmt, AudioFormat *fmt, |
ca9cc28c | 320 | int *endianness) |
1d14ffa9 FB |
321 | { |
322 | switch (alsafmt) { | |
323 | case SND_PCM_FORMAT_S8: | |
324 | *endianness = 0; | |
85bc5852 | 325 | *fmt = AUDIO_FORMAT_S8; |
1d14ffa9 FB |
326 | break; |
327 | ||
328 | case SND_PCM_FORMAT_U8: | |
329 | *endianness = 0; | |
85bc5852 | 330 | *fmt = AUDIO_FORMAT_U8; |
1d14ffa9 FB |
331 | break; |
332 | ||
333 | case SND_PCM_FORMAT_S16_LE: | |
334 | *endianness = 0; | |
85bc5852 | 335 | *fmt = AUDIO_FORMAT_S16; |
1d14ffa9 FB |
336 | break; |
337 | ||
338 | case SND_PCM_FORMAT_U16_LE: | |
339 | *endianness = 0; | |
85bc5852 | 340 | *fmt = AUDIO_FORMAT_U16; |
1d14ffa9 FB |
341 | break; |
342 | ||
343 | case SND_PCM_FORMAT_S16_BE: | |
344 | *endianness = 1; | |
85bc5852 | 345 | *fmt = AUDIO_FORMAT_S16; |
1d14ffa9 FB |
346 | break; |
347 | ||
348 | case SND_PCM_FORMAT_U16_BE: | |
349 | *endianness = 1; | |
85bc5852 | 350 | *fmt = AUDIO_FORMAT_U16; |
1d14ffa9 FB |
351 | break; |
352 | ||
f941aa25 TS |
353 | case SND_PCM_FORMAT_S32_LE: |
354 | *endianness = 0; | |
85bc5852 | 355 | *fmt = AUDIO_FORMAT_S32; |
f941aa25 TS |
356 | break; |
357 | ||
358 | case SND_PCM_FORMAT_U32_LE: | |
359 | *endianness = 0; | |
85bc5852 | 360 | *fmt = AUDIO_FORMAT_U32; |
f941aa25 TS |
361 | break; |
362 | ||
363 | case SND_PCM_FORMAT_S32_BE: | |
364 | *endianness = 1; | |
85bc5852 | 365 | *fmt = AUDIO_FORMAT_S32; |
f941aa25 TS |
366 | break; |
367 | ||
368 | case SND_PCM_FORMAT_U32_BE: | |
369 | *endianness = 1; | |
85bc5852 | 370 | *fmt = AUDIO_FORMAT_U32; |
f941aa25 TS |
371 | break; |
372 | ||
1d14ffa9 FB |
373 | default: |
374 | dolog ("Unrecognized audio format %d\n", alsafmt); | |
375 | return -1; | |
376 | } | |
377 | ||
378 | return 0; | |
379 | } | |
380 | ||
1d14ffa9 | 381 | static void alsa_dump_info (struct alsa_params_req *req, |
8bb414d2 | 382 | struct alsa_params_obt *obt, |
a93f3281 KZ |
383 | snd_pcm_format_t obtfmt, |
384 | AudiodevAlsaPerDirectionOptions *apdo) | |
1d14ffa9 | 385 | { |
a93f3281 KZ |
386 | dolog("parameter | requested value | obtained value\n"); |
387 | dolog("format | %10d | %10d\n", req->fmt, obtfmt); | |
388 | dolog("channels | %10d | %10d\n", | |
389 | req->nchannels, obt->nchannels); | |
390 | dolog("frequency | %10d | %10d\n", req->freq, obt->freq); | |
391 | dolog("============================================\n"); | |
392 | dolog("requested: buffer len %" PRId32 " period len %" PRId32 "\n", | |
393 | apdo->buffer_length, apdo->period_length); | |
394 | dolog("obtained: samples %ld\n", obt->samples); | |
1d14ffa9 | 395 | } |
1d14ffa9 FB |
396 | |
397 | static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold) | |
398 | { | |
399 | int err; | |
400 | snd_pcm_sw_params_t *sw_params; | |
401 | ||
402 | snd_pcm_sw_params_alloca (&sw_params); | |
403 | ||
404 | err = snd_pcm_sw_params_current (handle, sw_params); | |
405 | if (err < 0) { | |
c0fe3827 | 406 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
407 | alsa_logerr (err, "Failed to get current software parameters\n"); |
408 | return; | |
409 | } | |
410 | ||
411 | err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold); | |
412 | if (err < 0) { | |
c0fe3827 | 413 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
414 | alsa_logerr (err, "Failed to set software threshold to %ld\n", |
415 | threshold); | |
416 | return; | |
417 | } | |
418 | ||
419 | err = snd_pcm_sw_params (handle, sw_params); | |
420 | if (err < 0) { | |
c0fe3827 | 421 | dolog ("Could not fully initialize DAC\n"); |
1d14ffa9 FB |
422 | alsa_logerr (err, "Failed to set software parameters\n"); |
423 | return; | |
424 | } | |
425 | } | |
426 | ||
a93f3281 KZ |
427 | static int alsa_open(bool in, struct alsa_params_req *req, |
428 | struct alsa_params_obt *obt, snd_pcm_t **handlep, | |
429 | Audiodev *dev) | |
1d14ffa9 | 430 | { |
a93f3281 KZ |
431 | AudiodevAlsaOptions *aopts = &dev->u.alsa; |
432 | AudiodevAlsaPerDirectionOptions *apdo = in ? aopts->in : aopts->out; | |
1d14ffa9 FB |
433 | snd_pcm_t *handle; |
434 | snd_pcm_hw_params_t *hw_params; | |
60fe76f3 TS |
435 | int err; |
436 | unsigned int freq, nchannels; | |
a93f3281 | 437 | const char *pcm_name = apdo->has_dev ? apdo->dev : "default"; |
1d14ffa9 FB |
438 | snd_pcm_uframes_t obt_buffer_size; |
439 | const char *typ = in ? "ADC" : "DAC"; | |
ca9cc28c | 440 | snd_pcm_format_t obtfmt; |
1d14ffa9 FB |
441 | |
442 | freq = req->freq; | |
1d14ffa9 FB |
443 | nchannels = req->nchannels; |
444 | ||
445 | snd_pcm_hw_params_alloca (&hw_params); | |
446 | ||
447 | err = snd_pcm_open ( | |
448 | &handle, | |
449 | pcm_name, | |
450 | in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK, | |
451 | SND_PCM_NONBLOCK | |
452 | ); | |
453 | if (err < 0) { | |
454 | alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name); | |
455 | return -1; | |
456 | } | |
457 | ||
458 | err = snd_pcm_hw_params_any (handle, hw_params); | |
459 | if (err < 0) { | |
460 | alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n"); | |
461 | goto err; | |
462 | } | |
463 | ||
464 | err = snd_pcm_hw_params_set_access ( | |
465 | handle, | |
466 | hw_params, | |
467 | SND_PCM_ACCESS_RW_INTERLEAVED | |
468 | ); | |
469 | if (err < 0) { | |
470 | alsa_logerr2 (err, typ, "Failed to set access type\n"); | |
471 | goto err; | |
472 | } | |
473 | ||
474 | err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt); | |
fbb7ef56 | 475 | if (err < 0) { |
1d14ffa9 | 476 | alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt); |
1d14ffa9 FB |
477 | } |
478 | ||
479 | err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0); | |
480 | if (err < 0) { | |
481 | alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq); | |
482 | goto err; | |
483 | } | |
484 | ||
485 | err = snd_pcm_hw_params_set_channels_near ( | |
486 | handle, | |
487 | hw_params, | |
488 | &nchannels | |
489 | ); | |
490 | if (err < 0) { | |
491 | alsa_logerr2 (err, typ, "Failed to set number of channels %d\n", | |
492 | req->nchannels); | |
493 | goto err; | |
494 | } | |
495 | ||
496 | if (nchannels != 1 && nchannels != 2) { | |
497 | alsa_logerr2 (err, typ, | |
498 | "Can not handle obtained number of channels %d\n", | |
499 | nchannels); | |
500 | goto err; | |
501 | } | |
502 | ||
a93f3281 KZ |
503 | if (apdo->buffer_length) { |
504 | int dir = 0; | |
505 | unsigned int btime = apdo->buffer_length; | |
f3b52983 | 506 | |
a93f3281 KZ |
507 | err = snd_pcm_hw_params_set_buffer_time_near( |
508 | handle, hw_params, &btime, &dir); | |
1d14ffa9 | 509 | |
7a24c800 | 510 | if (err < 0) { |
a93f3281 KZ |
511 | alsa_logerr2(err, typ, "Failed to set buffer time to %" PRId32 "\n", |
512 | apdo->buffer_length); | |
7a24c800 | 513 | goto err; |
514 | } | |
f3b52983 | 515 | |
a93f3281 KZ |
516 | if (apdo->has_buffer_length && btime != apdo->buffer_length) { |
517 | dolog("Requested buffer time %" PRId32 | |
518 | " was rejected, using %u\n", apdo->buffer_length, btime); | |
519 | } | |
7a24c800 | 520 | } |
521 | ||
a93f3281 KZ |
522 | if (apdo->period_length) { |
523 | int dir = 0; | |
524 | unsigned int ptime = apdo->period_length; | |
f3b52983 | 525 | |
a93f3281 KZ |
526 | err = snd_pcm_hw_params_set_period_time_near(handle, hw_params, &ptime, |
527 | &dir); | |
7a24c800 | 528 | |
529 | if (err < 0) { | |
a93f3281 KZ |
530 | alsa_logerr2(err, typ, "Failed to set period time to %" PRId32 "\n", |
531 | apdo->period_length); | |
7a24c800 | 532 | goto err; |
533 | } | |
f3b52983 | 534 | |
a93f3281 KZ |
535 | if (apdo->has_period_length && ptime != apdo->period_length) { |
536 | dolog("Requested period time %" PRId32 " was rejected, using %d\n", | |
537 | apdo->period_length, ptime); | |
538 | } | |
1d14ffa9 FB |
539 | } |
540 | ||
541 | err = snd_pcm_hw_params (handle, hw_params); | |
542 | if (err < 0) { | |
543 | alsa_logerr2 (err, typ, "Failed to apply audio parameters\n"); | |
544 | goto err; | |
545 | } | |
546 | ||
547 | err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size); | |
548 | if (err < 0) { | |
549 | alsa_logerr2 (err, typ, "Failed to get buffer size\n"); | |
550 | goto err; | |
551 | } | |
552 | ||
ca9cc28c AZ |
553 | err = snd_pcm_hw_params_get_format (hw_params, &obtfmt); |
554 | if (err < 0) { | |
555 | alsa_logerr2 (err, typ, "Failed to get format\n"); | |
556 | goto err; | |
557 | } | |
558 | ||
559 | if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) { | |
560 | dolog ("Invalid format was returned %d\n", obtfmt); | |
561 | goto err; | |
562 | } | |
563 | ||
1d14ffa9 FB |
564 | err = snd_pcm_prepare (handle); |
565 | if (err < 0) { | |
c0fe3827 | 566 | alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle); |
1d14ffa9 FB |
567 | goto err; |
568 | } | |
569 | ||
a93f3281 KZ |
570 | if (!in && aopts->has_threshold && aopts->threshold) { |
571 | struct audsettings as = { .freq = freq }; | |
572 | alsa_set_threshold( | |
573 | handle, | |
574 | audio_buffer_frames(qapi_AudiodevAlsaPerDirectionOptions_base(apdo), | |
575 | &as, aopts->threshold)); | |
1d14ffa9 FB |
576 | } |
577 | ||
1d14ffa9 FB |
578 | obt->nchannels = nchannels; |
579 | obt->freq = freq; | |
c0fe3827 | 580 | obt->samples = obt_buffer_size; |
ca9cc28c | 581 | |
1d14ffa9 FB |
582 | *handlep = handle; |
583 | ||
fbb7ef56 | 584 | if (obtfmt != req->fmt || |
ca9cc28c | 585 | obt->nchannels != req->nchannels || |
fbb7ef56 | 586 | obt->freq != req->freq) { |
f093feb7 | 587 | dolog ("Audio parameters for %s\n", typ); |
a93f3281 | 588 | alsa_dump_info(req, obt, obtfmt, apdo); |
1d14ffa9 FB |
589 | } |
590 | ||
591 | #ifdef DEBUG | |
a93f3281 | 592 | alsa_dump_info(req, obt, obtfmt, pdo); |
1d14ffa9 FB |
593 | #endif |
594 | return 0; | |
595 | ||
596 | err: | |
6ebfda13 | 597 | alsa_anal_close1 (&handle); |
1d14ffa9 FB |
598 | return -1; |
599 | } | |
600 | ||
286a5d20 | 601 | static size_t alsa_write(HWVoiceOut *hw, void *buf, size_t len) |
571ec3d6 | 602 | { |
286a5d20 KZ |
603 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; |
604 | size_t pos = 0; | |
605 | size_t len_frames = len >> hw->info.shift; | |
606 | ||
607 | while (len_frames) { | |
608 | char *src = advance(buf, pos); | |
609 | snd_pcm_sframes_t written; | |
610 | ||
611 | written = snd_pcm_writei(alsa->handle, src, len_frames); | |
612 | ||
613 | if (written <= 0) { | |
614 | switch (written) { | |
615 | case 0: | |
616 | trace_alsa_wrote_zero(len_frames); | |
617 | return pos; | |
618 | ||
619 | case -EPIPE: | |
620 | if (alsa_recover(alsa->handle)) { | |
621 | alsa_logerr(written, "Failed to write %zu frames\n", | |
622 | len_frames); | |
623 | return pos; | |
624 | } | |
625 | trace_alsa_xrun_out(); | |
626 | continue; | |
627 | ||
628 | case -ESTRPIPE: | |
629 | /* | |
630 | * stream is suspended and waiting for an application | |
631 | * recovery | |
632 | */ | |
633 | if (alsa_resume(alsa->handle)) { | |
634 | alsa_logerr(written, "Failed to write %zu frames\n", | |
635 | len_frames); | |
636 | return pos; | |
637 | } | |
638 | trace_alsa_resume_out(); | |
639 | continue; | |
571ec3d6 | 640 | |
286a5d20 KZ |
641 | case -EAGAIN: |
642 | return pos; | |
571ec3d6 | 643 | |
286a5d20 KZ |
644 | default: |
645 | alsa_logerr(written, "Failed to write %zu frames from %p\n", | |
646 | len, src); | |
647 | return pos; | |
1d14ffa9 | 648 | } |
4787c71d | 649 | } |
541ba4e7 | 650 | |
286a5d20 KZ |
651 | pos += written << hw->info.shift; |
652 | if (written < len_frames) { | |
653 | break; | |
654 | } | |
655 | len_frames -= written; | |
541ba4e7 | 656 | } |
657 | ||
286a5d20 | 658 | return pos; |
1d14ffa9 FB |
659 | } |
660 | ||
661 | static void alsa_fini_out (HWVoiceOut *hw) | |
662 | { | |
663 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; | |
664 | ||
665 | ldebug ("alsa_fini\n"); | |
6ebfda13 | 666 | alsa_anal_close (&alsa->handle, &alsa->pollhlp); |
1d14ffa9 FB |
667 | } |
668 | ||
5706db1d KZ |
669 | static int alsa_init_out(HWVoiceOut *hw, struct audsettings *as, |
670 | void *drv_opaque) | |
1d14ffa9 FB |
671 | { |
672 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; | |
673 | struct alsa_params_req req; | |
674 | struct alsa_params_obt obt; | |
1d14ffa9 | 675 | snd_pcm_t *handle; |
1ea879e5 | 676 | struct audsettings obt_as; |
a93f3281 | 677 | Audiodev *dev = drv_opaque; |
1d14ffa9 | 678 | |
d66bddd7 | 679 | req.fmt = aud_to_alsafmt (as->fmt, as->endianness); |
c0fe3827 FB |
680 | req.freq = as->freq; |
681 | req.nchannels = as->nchannels; | |
a93f3281 KZ |
682 | |
683 | if (alsa_open(0, &req, &obt, &handle, dev)) { | |
1d14ffa9 FB |
684 | return -1; |
685 | } | |
686 | ||
c0fe3827 FB |
687 | obt_as.freq = obt.freq; |
688 | obt_as.nchannels = obt.nchannels; | |
ca9cc28c AZ |
689 | obt_as.fmt = obt.fmt; |
690 | obt_as.endianness = obt.endianness; | |
c0fe3827 | 691 | |
d929eba5 | 692 | audio_pcm_init_info (&hw->info, &obt_as); |
c0fe3827 | 693 | hw->samples = obt.samples; |
1d14ffa9 | 694 | |
18e2c177 | 695 | alsa->pollhlp.s = hw->s; |
1d14ffa9 | 696 | alsa->handle = handle; |
a93f3281 | 697 | alsa->dev = dev; |
1d14ffa9 FB |
698 | return 0; |
699 | } | |
700 | ||
38cc9b60 JM |
701 | #define VOICE_CTL_PAUSE 0 |
702 | #define VOICE_CTL_PREPARE 1 | |
703 | #define VOICE_CTL_START 2 | |
704 | ||
705 | static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int ctl) | |
1d14ffa9 FB |
706 | { |
707 | int err; | |
571ec3d6 | 708 | |
38cc9b60 | 709 | if (ctl == VOICE_CTL_PAUSE) { |
571ec3d6 FB |
710 | err = snd_pcm_drop (handle); |
711 | if (err < 0) { | |
32d448c4 | 712 | alsa_logerr (err, "Could not stop %s\n", typ); |
571ec3d6 FB |
713 | return -1; |
714 | } | |
715 | } | |
716 | else { | |
717 | err = snd_pcm_prepare (handle); | |
718 | if (err < 0) { | |
32d448c4 | 719 | alsa_logerr (err, "Could not prepare handle for %s\n", typ); |
571ec3d6 FB |
720 | return -1; |
721 | } | |
38cc9b60 JM |
722 | if (ctl == VOICE_CTL_START) { |
723 | err = snd_pcm_start(handle); | |
724 | if (err < 0) { | |
725 | alsa_logerr (err, "Could not start handle for %s\n", typ); | |
726 | return -1; | |
727 | } | |
728 | } | |
571ec3d6 FB |
729 | } |
730 | ||
731 | return 0; | |
732 | } | |
733 | ||
734 | static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...) | |
735 | { | |
1d14ffa9 | 736 | ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; |
a93f3281 | 737 | AudiodevAlsaPerDirectionOptions *apdo = alsa->dev->u.alsa.out; |
1d14ffa9 FB |
738 | |
739 | switch (cmd) { | |
740 | case VOICE_ENABLE: | |
301901b5 | 741 | { |
a93f3281 | 742 | bool poll_mode = apdo->try_poll; |
301901b5 | 743 | |
744 | ldebug ("enabling voice\n"); | |
745 | if (poll_mode && alsa_poll_out (hw)) { | |
746 | poll_mode = 0; | |
747 | } | |
748 | hw->poll_mode = poll_mode; | |
38cc9b60 | 749 | return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PREPARE); |
8b438ba3 | 750 | } |
1d14ffa9 FB |
751 | |
752 | case VOICE_DISABLE: | |
753 | ldebug ("disabling voice\n"); | |
22d948a2 JM |
754 | if (hw->poll_mode) { |
755 | hw->poll_mode = 0; | |
756 | alsa_fini_poll (&alsa->pollhlp); | |
757 | } | |
38cc9b60 | 758 | return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PAUSE); |
1d14ffa9 | 759 | } |
571ec3d6 FB |
760 | |
761 | return -1; | |
1d14ffa9 FB |
762 | } |
763 | ||
5706db1d | 764 | static int alsa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque) |
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; |
1ea879e5 | 770 | struct audsettings obt_as; |
a93f3281 | 771 | Audiodev *dev = drv_opaque; |
1d14ffa9 | 772 | |
d66bddd7 | 773 | req.fmt = aud_to_alsafmt (as->fmt, as->endianness); |
c0fe3827 FB |
774 | req.freq = as->freq; |
775 | req.nchannels = as->nchannels; | |
a93f3281 KZ |
776 | |
777 | if (alsa_open(1, &req, &obt, &handle, dev)) { | |
1d14ffa9 FB |
778 | return -1; |
779 | } | |
780 | ||
c0fe3827 FB |
781 | obt_as.freq = obt.freq; |
782 | obt_as.nchannels = obt.nchannels; | |
ca9cc28c AZ |
783 | obt_as.fmt = obt.fmt; |
784 | obt_as.endianness = obt.endianness; | |
c0fe3827 | 785 | |
d929eba5 | 786 | audio_pcm_init_info (&hw->info, &obt_as); |
c0fe3827 FB |
787 | hw->samples = obt.samples; |
788 | ||
18e2c177 | 789 | alsa->pollhlp.s = hw->s; |
1d14ffa9 | 790 | alsa->handle = handle; |
a93f3281 | 791 | alsa->dev = dev; |
1d14ffa9 FB |
792 | return 0; |
793 | } | |
794 | ||
795 | static void alsa_fini_in (HWVoiceIn *hw) | |
796 | { | |
797 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
798 | ||
6ebfda13 | 799 | alsa_anal_close (&alsa->handle, &alsa->pollhlp); |
1d14ffa9 FB |
800 | } |
801 | ||
286a5d20 | 802 | static size_t alsa_read(HWVoiceIn *hw, void *buf, size_t len) |
1d14ffa9 FB |
803 | { |
804 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; | |
286a5d20 | 805 | size_t pos = 0; |
1d14ffa9 | 806 | |
286a5d20 KZ |
807 | while (len) { |
808 | void *dst = advance(buf, pos); | |
809 | snd_pcm_sframes_t nread; | |
571ec3d6 | 810 | |
286a5d20 | 811 | nread = snd_pcm_readi(alsa->handle, dst, len >> hw->info.shift); |
571ec3d6 | 812 | |
286a5d20 KZ |
813 | if (nread <= 0) { |
814 | switch (nread) { | |
815 | case 0: | |
816 | trace_alsa_read_zero(len); | |
817 | return pos;; | |
1d14ffa9 | 818 | |
286a5d20 KZ |
819 | case -EPIPE: |
820 | if (alsa_recover(alsa->handle)) { | |
821 | alsa_logerr(nread, "Failed to read %zu frames\n", len); | |
822 | return pos; | |
1d14ffa9 | 823 | } |
286a5d20 KZ |
824 | trace_alsa_xrun_in(); |
825 | continue; | |
1d14ffa9 | 826 | |
286a5d20 KZ |
827 | case -EAGAIN: |
828 | return pos; | |
1d14ffa9 | 829 | |
286a5d20 KZ |
830 | default: |
831 | alsa_logerr(nread, "Failed to read %zu frames to %p\n", | |
832 | len, dst); | |
833 | return pos;; | |
834 | } | |
1d14ffa9 | 835 | } |
286a5d20 KZ |
836 | |
837 | pos += nread << hw->info.shift; | |
838 | len -= nread << hw->info.shift; | |
1d14ffa9 FB |
839 | } |
840 | ||
286a5d20 | 841 | return pos; |
1d14ffa9 FB |
842 | } |
843 | ||
1d14ffa9 FB |
844 | static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...) |
845 | { | |
571ec3d6 | 846 | ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; |
a93f3281 | 847 | AudiodevAlsaPerDirectionOptions *apdo = alsa->dev->u.alsa.in; |
571ec3d6 FB |
848 | |
849 | switch (cmd) { | |
850 | case VOICE_ENABLE: | |
a628b869 | 851 | { |
a93f3281 | 852 | bool poll_mode = apdo->try_poll; |
a628b869 | 853 | |
854 | ldebug ("enabling voice\n"); | |
855 | if (poll_mode && alsa_poll_in (hw)) { | |
856 | poll_mode = 0; | |
857 | } | |
858 | hw->poll_mode = poll_mode; | |
859 | ||
38cc9b60 | 860 | return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_START); |
a628b869 | 861 | } |
571ec3d6 FB |
862 | |
863 | case VOICE_DISABLE: | |
864 | ldebug ("disabling voice\n"); | |
8b438ba3 | 865 | if (hw->poll_mode) { |
866 | hw->poll_mode = 0; | |
867 | alsa_fini_poll (&alsa->pollhlp); | |
868 | } | |
38cc9b60 | 869 | return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_PAUSE); |
571ec3d6 FB |
870 | } |
871 | ||
872 | return -1; | |
1d14ffa9 FB |
873 | } |
874 | ||
a93f3281 KZ |
875 | static void alsa_init_per_direction(AudiodevAlsaPerDirectionOptions *apdo) |
876 | { | |
877 | if (!apdo->has_try_poll) { | |
878 | apdo->try_poll = true; | |
879 | apdo->has_try_poll = true; | |
880 | } | |
881 | } | |
765b37da | 882 | |
71830221 | 883 | static void *alsa_audio_init(Audiodev *dev) |
1d14ffa9 | 884 | { |
a93f3281 KZ |
885 | AudiodevAlsaOptions *aopts; |
886 | assert(dev->driver == AUDIODEV_DRIVER_ALSA); | |
887 | ||
888 | aopts = &dev->u.alsa; | |
889 | alsa_init_per_direction(aopts->in); | |
890 | alsa_init_per_direction(aopts->out); | |
891 | ||
892 | /* | |
893 | * need to define them, as otherwise alsa produces no sound | |
894 | * doesn't set has_* so alsa_open can identify it wasn't set by the user | |
895 | */ | |
896 | if (!dev->u.alsa.out->has_period_length) { | |
897 | /* 1024 frames assuming 44100Hz */ | |
898 | dev->u.alsa.out->period_length = 1024 * 1000000 / 44100; | |
899 | } | |
900 | if (!dev->u.alsa.out->has_buffer_length) { | |
901 | /* 4096 frames assuming 44100Hz */ | |
902 | dev->u.alsa.out->buffer_length = 4096ll * 1000000 / 44100; | |
903 | } | |
904 | ||
905 | /* | |
906 | * OptsVisitor sets unspecified optional fields to zero, but do not depend | |
907 | * on it... | |
908 | */ | |
909 | if (!dev->u.alsa.in->has_period_length) { | |
910 | dev->u.alsa.in->period_length = 0; | |
911 | } | |
912 | if (!dev->u.alsa.in->has_buffer_length) { | |
913 | dev->u.alsa.in->buffer_length = 0; | |
914 | } | |
915 | ||
916 | return dev; | |
1d14ffa9 FB |
917 | } |
918 | ||
919 | static void alsa_audio_fini (void *opaque) | |
920 | { | |
1d14ffa9 FB |
921 | } |
922 | ||
35f4b58c | 923 | static struct audio_pcm_ops alsa_pcm_ops = { |
1dd3e4d1 JQ |
924 | .init_out = alsa_init_out, |
925 | .fini_out = alsa_fini_out, | |
286a5d20 | 926 | .write = alsa_write, |
1dd3e4d1 JQ |
927 | .ctl_out = alsa_ctl_out, |
928 | ||
929 | .init_in = alsa_init_in, | |
930 | .fini_in = alsa_fini_in, | |
286a5d20 | 931 | .read = alsa_read, |
8b438ba3 | 932 | .ctl_in = alsa_ctl_in, |
1d14ffa9 FB |
933 | }; |
934 | ||
d3893a39 | 935 | static struct audio_driver alsa_audio_driver = { |
bee37f32 JQ |
936 | .name = "alsa", |
937 | .descr = "ALSA http://www.alsa-project.org", | |
bee37f32 JQ |
938 | .init = alsa_audio_init, |
939 | .fini = alsa_audio_fini, | |
940 | .pcm_ops = &alsa_pcm_ops, | |
941 | .can_be_default = 1, | |
942 | .max_voices_out = INT_MAX, | |
943 | .max_voices_in = INT_MAX, | |
944 | .voice_size_out = sizeof (ALSAVoiceOut), | |
945 | .voice_size_in = sizeof (ALSAVoiceIn) | |
1d14ffa9 | 946 | }; |
d3893a39 GH |
947 | |
948 | static void register_audio_alsa(void) | |
949 | { | |
950 | audio_driver_register(&alsa_audio_driver); | |
951 | } | |
952 | type_init(register_audio_alsa); |