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