blob: 3652a7b5fa9f534c3680e4e3cb9e55c2e846e7b3 [file] [log] [blame]
bellard1d14ffa2005-10-30 18:58:22 +00001/*
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 */
Peter Maydell6086a562016-01-18 17:33:52 +000024#include "qemu/osdep.h"
bellard1d14ffa2005-10-30 18:58:22 +000025#include <alsa/asoundlib.h>
pbrook749bc4b2007-11-17 17:35:54 +000026#include "qemu-common.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010027#include "qemu/main-loop.h"
pbrook749bc4b2007-11-17 17:35:54 +000028#include "audio.h"
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +020029#include "trace.h"
bellard1d14ffa2005-10-30 18:58:22 +000030
malc26378722009-07-17 05:57:04 +040031#if QEMU_GNUC_PREREQ(4, 3)
32#pragma GCC diagnostic ignored "-Waddress"
33#endif
34
bellard1d14ffa2005-10-30 18:58:22 +000035#define AUDIO_CAP "alsa"
36#include "audio_int.h"
37
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +020038typedef struct ALSAConf {
39 int size_in_usec_in;
40 int size_in_usec_out;
41 const char *pcm_name_in;
42 const char *pcm_name_out;
43 unsigned int buffer_size_in;
44 unsigned int period_size_in;
45 unsigned int buffer_size_out;
46 unsigned int period_size_out;
47 unsigned int threshold;
48
49 int buffer_size_in_overridden;
50 int period_size_in_overridden;
51
52 int buffer_size_out_overridden;
53 int period_size_out_overridden;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +020054} ALSAConf;
55
malc8b438ba2009-09-12 02:29:25 +040056struct pollhlp {
57 snd_pcm_t *handle;
58 struct pollfd *pfds;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +020059 ALSAConf *conf;
malc8b438ba2009-09-12 02:29:25 +040060 int count;
malcb4f763b2009-09-14 03:53:25 +040061 int mask;
malc8b438ba2009-09-12 02:29:25 +040062};
63
bellard1d14ffa2005-10-30 18:58:22 +000064typedef struct ALSAVoiceOut {
65 HWVoiceOut hw;
malc541ba4e2009-09-18 10:59:50 +040066 int wpos;
67 int pending;
bellard1d14ffa2005-10-30 18:58:22 +000068 void *pcm_buf;
69 snd_pcm_t *handle;
malc8b438ba2009-09-12 02:29:25 +040070 struct pollhlp pollhlp;
bellard1d14ffa2005-10-30 18:58:22 +000071} ALSAVoiceOut;
72
73typedef struct ALSAVoiceIn {
74 HWVoiceIn hw;
75 snd_pcm_t *handle;
76 void *pcm_buf;
malc8b438ba2009-09-12 02:29:25 +040077 struct pollhlp pollhlp;
bellard1d14ffa2005-10-30 18:58:22 +000078} ALSAVoiceIn;
79
bellard1d14ffa2005-10-30 18:58:22 +000080struct alsa_params_req {
balrogca9cc282008-01-14 04:24:29 +000081 int freq;
82 snd_pcm_format_t fmt;
83 int nchannels;
malc7a24c802008-06-21 17:14:57 +000084 int size_in_usec;
malc64333892008-07-09 19:25:28 +000085 int override_mask;
bellard1d14ffa2005-10-30 18:58:22 +000086 unsigned int buffer_size;
87 unsigned int period_size;
88};
89
90struct alsa_params_obt {
91 int freq;
92 audfmt_e fmt;
balrogca9cc282008-01-14 04:24:29 +000093 int endianness;
bellard1d14ffa2005-10-30 18:58:22 +000094 int nchannels;
bellardc0fe3822005-11-05 18:55:28 +000095 snd_pcm_uframes_t samples;
bellard1d14ffa2005-10-30 18:58:22 +000096};
97
98static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
99{
100 va_list ap;
101
102 va_start (ap, fmt);
103 AUD_vlog (AUDIO_CAP, fmt, ap);
104 va_end (ap);
105
106 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
107}
108
109static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (
110 int err,
111 const char *typ,
112 const char *fmt,
113 ...
114 )
115{
116 va_list ap;
117
bellardc0fe3822005-11-05 18:55:28 +0000118 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
bellard1d14ffa2005-10-30 18:58:22 +0000119
120 va_start (ap, fmt);
121 AUD_vlog (AUDIO_CAP, fmt, ap);
122 va_end (ap);
123
124 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
125}
126
malc6ebfda12009-09-14 03:51:48 +0400127static void alsa_fini_poll (struct pollhlp *hlp)
128{
129 int i;
130 struct pollfd *pfds = hlp->pfds;
131
132 if (pfds) {
133 for (i = 0; i < hlp->count; ++i) {
134 qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);
135 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500136 g_free (pfds);
malc6ebfda12009-09-14 03:51:48 +0400137 }
138 hlp->pfds = NULL;
139 hlp->count = 0;
140 hlp->handle = NULL;
141}
142
143static void alsa_anal_close1 (snd_pcm_t **handlep)
bellard1d14ffa2005-10-30 18:58:22 +0000144{
145 int err = snd_pcm_close (*handlep);
146 if (err) {
147 alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep);
148 }
149 *handlep = NULL;
150}
151
malc6ebfda12009-09-14 03:51:48 +0400152static void alsa_anal_close (snd_pcm_t **handlep, struct pollhlp *hlp)
153{
154 alsa_fini_poll (hlp);
155 alsa_anal_close1 (handlep);
156}
157
malc8b438ba2009-09-12 02:29:25 +0400158static int alsa_recover (snd_pcm_t *handle)
159{
160 int err = snd_pcm_prepare (handle);
161 if (err < 0) {
162 alsa_logerr (err, "Failed to prepare handle %p\n", handle);
163 return -1;
164 }
165 return 0;
166}
167
168static int alsa_resume (snd_pcm_t *handle)
169{
170 int err = snd_pcm_resume (handle);
171 if (err < 0) {
172 alsa_logerr (err, "Failed to resume handle %p\n", handle);
173 return -1;
174 }
175 return 0;
176}
177
178static void alsa_poll_handler (void *opaque)
179{
180 int err, count;
181 snd_pcm_state_t state;
182 struct pollhlp *hlp = opaque;
183 unsigned short revents;
184
185 count = poll (hlp->pfds, hlp->count, 0);
186 if (count < 0) {
187 dolog ("alsa_poll_handler: poll %s\n", strerror (errno));
188 return;
189 }
190
191 if (!count) {
192 return;
193 }
194
195 /* XXX: ALSA example uses initial count, not the one returned by
196 poll, correct? */
197 err = snd_pcm_poll_descriptors_revents (hlp->handle, hlp->pfds,
198 hlp->count, &revents);
199 if (err < 0) {
200 alsa_logerr (err, "snd_pcm_poll_descriptors_revents");
201 return;
202 }
203
malcb4f763b2009-09-14 03:53:25 +0400204 if (!(revents & hlp->mask)) {
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200205 trace_alsa_revents(revents);
malc8b438ba2009-09-12 02:29:25 +0400206 return;
207 }
208
209 state = snd_pcm_state (hlp->handle);
210 switch (state) {
malcd9812b02010-02-28 18:34:21 +0300211 case SND_PCM_STATE_SETUP:
212 alsa_recover (hlp->handle);
213 break;
214
malc8b438ba2009-09-12 02:29:25 +0400215 case SND_PCM_STATE_XRUN:
216 alsa_recover (hlp->handle);
217 break;
218
219 case SND_PCM_STATE_SUSPENDED:
220 alsa_resume (hlp->handle);
221 break;
222
223 case SND_PCM_STATE_PREPARED:
224 audio_run ("alsa run (prepared)");
225 break;
226
227 case SND_PCM_STATE_RUNNING:
228 audio_run ("alsa run (running)");
229 break;
230
231 default:
232 dolog ("Unexpected state %d\n", state);
233 }
234}
235
malcb4f763b2009-09-14 03:53:25 +0400236static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask)
malc8b438ba2009-09-12 02:29:25 +0400237{
238 int i, count, err;
239 struct pollfd *pfds;
240
241 count = snd_pcm_poll_descriptors_count (handle);
242 if (count <= 0) {
243 dolog ("Could not initialize poll mode\n"
244 "Invalid number of poll descriptors %d\n", count);
245 return -1;
246 }
247
248 pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds));
249 if (!pfds) {
250 dolog ("Could not initialize poll mode\n");
251 return -1;
252 }
253
254 err = snd_pcm_poll_descriptors (handle, pfds, count);
255 if (err < 0) {
256 alsa_logerr (err, "Could not initialize poll mode\n"
257 "Could not obtain poll descriptors\n");
Anthony Liguori7267c092011-08-20 22:09:37 -0500258 g_free (pfds);
malc8b438ba2009-09-12 02:29:25 +0400259 return -1;
260 }
261
262 for (i = 0; i < count; ++i) {
263 if (pfds[i].events & POLLIN) {
Fam Zhengbe93f212015-06-04 14:45:20 +0800264 qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler, NULL, hlp);
malc8b438ba2009-09-12 02:29:25 +0400265 }
266 if (pfds[i].events & POLLOUT) {
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200267 trace_alsa_pollout(i, pfds[i].fd);
Fam Zhengbe93f212015-06-04 14:45:20 +0800268 qemu_set_fd_handler (pfds[i].fd, NULL, alsa_poll_handler, hlp);
malc8b438ba2009-09-12 02:29:25 +0400269 }
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200270 trace_alsa_set_handler(pfds[i].events, i, pfds[i].fd, err);
malc8b438ba2009-09-12 02:29:25 +0400271
malc8b438ba2009-09-12 02:29:25 +0400272 }
273 hlp->pfds = pfds;
274 hlp->count = count;
275 hlp->handle = handle;
malcb4f763b2009-09-14 03:53:25 +0400276 hlp->mask = mask;
malc8b438ba2009-09-12 02:29:25 +0400277 return 0;
278}
279
280static int alsa_poll_out (HWVoiceOut *hw)
281{
282 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
283
malcb4f763b2009-09-14 03:53:25 +0400284 return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLOUT);
malc8b438ba2009-09-12 02:29:25 +0400285}
286
287static int alsa_poll_in (HWVoiceIn *hw)
288{
289 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
290
malcb4f763b2009-09-14 03:53:25 +0400291 return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLIN);
malc8b438ba2009-09-12 02:29:25 +0400292}
293
bellard1d14ffa2005-10-30 18:58:22 +0000294static int alsa_write (SWVoiceOut *sw, void *buf, int len)
295{
296 return audio_pcm_sw_write (sw, buf, len);
297}
298
Michael Walled66bddd2011-01-08 17:53:30 +0100299static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt, int endianness)
bellard1d14ffa2005-10-30 18:58:22 +0000300{
301 switch (fmt) {
302 case AUD_FMT_S8:
303 return SND_PCM_FORMAT_S8;
304
305 case AUD_FMT_U8:
306 return SND_PCM_FORMAT_U8;
307
308 case AUD_FMT_S16:
Michael Walled66bddd2011-01-08 17:53:30 +0100309 if (endianness) {
310 return SND_PCM_FORMAT_S16_BE;
311 }
312 else {
313 return SND_PCM_FORMAT_S16_LE;
314 }
bellard1d14ffa2005-10-30 18:58:22 +0000315
316 case AUD_FMT_U16:
Michael Walled66bddd2011-01-08 17:53:30 +0100317 if (endianness) {
318 return SND_PCM_FORMAT_U16_BE;
319 }
320 else {
321 return SND_PCM_FORMAT_U16_LE;
322 }
bellard1d14ffa2005-10-30 18:58:22 +0000323
thsf941aa22007-02-17 22:19:29 +0000324 case AUD_FMT_S32:
Michael Walled66bddd2011-01-08 17:53:30 +0100325 if (endianness) {
326 return SND_PCM_FORMAT_S32_BE;
327 }
328 else {
329 return SND_PCM_FORMAT_S32_LE;
330 }
thsf941aa22007-02-17 22:19:29 +0000331
332 case AUD_FMT_U32:
Michael Walled66bddd2011-01-08 17:53:30 +0100333 if (endianness) {
334 return SND_PCM_FORMAT_U32_BE;
335 }
336 else {
337 return SND_PCM_FORMAT_U32_LE;
338 }
thsf941aa22007-02-17 22:19:29 +0000339
bellard1d14ffa2005-10-30 18:58:22 +0000340 default:
341 dolog ("Internal logic error: Bad audio format %d\n", fmt);
342#ifdef DEBUG_AUDIO
343 abort ();
344#endif
345 return SND_PCM_FORMAT_U8;
346 }
347}
348
balrogca9cc282008-01-14 04:24:29 +0000349static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt,
350 int *endianness)
bellard1d14ffa2005-10-30 18:58:22 +0000351{
352 switch (alsafmt) {
353 case SND_PCM_FORMAT_S8:
354 *endianness = 0;
355 *fmt = AUD_FMT_S8;
356 break;
357
358 case SND_PCM_FORMAT_U8:
359 *endianness = 0;
360 *fmt = AUD_FMT_U8;
361 break;
362
363 case SND_PCM_FORMAT_S16_LE:
364 *endianness = 0;
365 *fmt = AUD_FMT_S16;
366 break;
367
368 case SND_PCM_FORMAT_U16_LE:
369 *endianness = 0;
370 *fmt = AUD_FMT_U16;
371 break;
372
373 case SND_PCM_FORMAT_S16_BE:
374 *endianness = 1;
375 *fmt = AUD_FMT_S16;
376 break;
377
378 case SND_PCM_FORMAT_U16_BE:
379 *endianness = 1;
380 *fmt = AUD_FMT_U16;
381 break;
382
thsf941aa22007-02-17 22:19:29 +0000383 case SND_PCM_FORMAT_S32_LE:
384 *endianness = 0;
385 *fmt = AUD_FMT_S32;
386 break;
387
388 case SND_PCM_FORMAT_U32_LE:
389 *endianness = 0;
390 *fmt = AUD_FMT_U32;
391 break;
392
393 case SND_PCM_FORMAT_S32_BE:
394 *endianness = 1;
395 *fmt = AUD_FMT_S32;
396 break;
397
398 case SND_PCM_FORMAT_U32_BE:
399 *endianness = 1;
400 *fmt = AUD_FMT_U32;
401 break;
402
bellard1d14ffa2005-10-30 18:58:22 +0000403 default:
404 dolog ("Unrecognized audio format %d\n", alsafmt);
405 return -1;
406 }
407
408 return 0;
409}
410
bellard1d14ffa2005-10-30 18:58:22 +0000411static void alsa_dump_info (struct alsa_params_req *req,
malc8bb414d2010-04-21 15:40:23 +0400412 struct alsa_params_obt *obt,
413 snd_pcm_format_t obtfmt)
bellard1d14ffa2005-10-30 18:58:22 +0000414{
415 dolog ("parameter | requested value | obtained value\n");
malc8bb414d2010-04-21 15:40:23 +0400416 dolog ("format | %10d | %10d\n", req->fmt, obtfmt);
bellard1d14ffa2005-10-30 18:58:22 +0000417 dolog ("channels | %10d | %10d\n",
418 req->nchannels, obt->nchannels);
419 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq);
420 dolog ("============================================\n");
421 dolog ("requested: buffer size %d period size %d\n",
422 req->buffer_size, req->period_size);
bellardc0fe3822005-11-05 18:55:28 +0000423 dolog ("obtained: samples %ld\n", obt->samples);
bellard1d14ffa2005-10-30 18:58:22 +0000424}
bellard1d14ffa2005-10-30 18:58:22 +0000425
426static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold)
427{
428 int err;
429 snd_pcm_sw_params_t *sw_params;
430
431 snd_pcm_sw_params_alloca (&sw_params);
432
433 err = snd_pcm_sw_params_current (handle, sw_params);
434 if (err < 0) {
bellardc0fe3822005-11-05 18:55:28 +0000435 dolog ("Could not fully initialize DAC\n");
bellard1d14ffa2005-10-30 18:58:22 +0000436 alsa_logerr (err, "Failed to get current software parameters\n");
437 return;
438 }
439
440 err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold);
441 if (err < 0) {
bellardc0fe3822005-11-05 18:55:28 +0000442 dolog ("Could not fully initialize DAC\n");
bellard1d14ffa2005-10-30 18:58:22 +0000443 alsa_logerr (err, "Failed to set software threshold to %ld\n",
444 threshold);
445 return;
446 }
447
448 err = snd_pcm_sw_params (handle, sw_params);
449 if (err < 0) {
bellardc0fe3822005-11-05 18:55:28 +0000450 dolog ("Could not fully initialize DAC\n");
bellard1d14ffa2005-10-30 18:58:22 +0000451 alsa_logerr (err, "Failed to set software parameters\n");
452 return;
453 }
454}
455
456static int alsa_open (int in, struct alsa_params_req *req,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200457 struct alsa_params_obt *obt, snd_pcm_t **handlep,
458 ALSAConf *conf)
bellard1d14ffa2005-10-30 18:58:22 +0000459{
460 snd_pcm_t *handle;
461 snd_pcm_hw_params_t *hw_params;
ths60fe76f2007-12-16 03:02:09 +0000462 int err;
malc7a24c802008-06-21 17:14:57 +0000463 int size_in_usec;
ths60fe76f2007-12-16 03:02:09 +0000464 unsigned int freq, nchannels;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200465 const char *pcm_name = in ? conf->pcm_name_in : conf->pcm_name_out;
bellard1d14ffa2005-10-30 18:58:22 +0000466 snd_pcm_uframes_t obt_buffer_size;
467 const char *typ = in ? "ADC" : "DAC";
balrogca9cc282008-01-14 04:24:29 +0000468 snd_pcm_format_t obtfmt;
bellard1d14ffa2005-10-30 18:58:22 +0000469
470 freq = req->freq;
bellard1d14ffa2005-10-30 18:58:22 +0000471 nchannels = req->nchannels;
malc7a24c802008-06-21 17:14:57 +0000472 size_in_usec = req->size_in_usec;
bellard1d14ffa2005-10-30 18:58:22 +0000473
474 snd_pcm_hw_params_alloca (&hw_params);
475
476 err = snd_pcm_open (
477 &handle,
478 pcm_name,
479 in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
480 SND_PCM_NONBLOCK
481 );
482 if (err < 0) {
483 alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name);
484 return -1;
485 }
486
487 err = snd_pcm_hw_params_any (handle, hw_params);
488 if (err < 0) {
489 alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n");
490 goto err;
491 }
492
493 err = snd_pcm_hw_params_set_access (
494 handle,
495 hw_params,
496 SND_PCM_ACCESS_RW_INTERLEAVED
497 );
498 if (err < 0) {
499 alsa_logerr2 (err, typ, "Failed to set access type\n");
500 goto err;
501 }
502
503 err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt);
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200504 if (err < 0) {
bellard1d14ffa2005-10-30 18:58:22 +0000505 alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt);
bellard1d14ffa2005-10-30 18:58:22 +0000506 }
507
508 err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0);
509 if (err < 0) {
510 alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq);
511 goto err;
512 }
513
514 err = snd_pcm_hw_params_set_channels_near (
515 handle,
516 hw_params,
517 &nchannels
518 );
519 if (err < 0) {
520 alsa_logerr2 (err, typ, "Failed to set number of channels %d\n",
521 req->nchannels);
522 goto err;
523 }
524
525 if (nchannels != 1 && nchannels != 2) {
526 alsa_logerr2 (err, typ,
527 "Can not handle obtained number of channels %d\n",
528 nchannels);
529 goto err;
530 }
531
malc7a24c802008-06-21 17:14:57 +0000532 if (req->buffer_size) {
malcf3b52982008-06-21 20:09:32 +0000533 unsigned long obt;
534
malc7a24c802008-06-21 17:14:57 +0000535 if (size_in_usec) {
536 int dir = 0;
537 unsigned int btime = req->buffer_size;
bellard1d14ffa2005-10-30 18:58:22 +0000538
539 err = snd_pcm_hw_params_set_buffer_time_near (
540 handle,
541 hw_params,
malc7a24c802008-06-21 17:14:57 +0000542 &btime,
543 &dir
bellardc0fe3822005-11-05 18:55:28 +0000544 );
malcf3b52982008-06-21 20:09:32 +0000545 obt = btime;
bellard1d14ffa2005-10-30 18:58:22 +0000546 }
547 else {
malc7a24c802008-06-21 17:14:57 +0000548 snd_pcm_uframes_t bsize = req->buffer_size;
bellard1d14ffa2005-10-30 18:58:22 +0000549
malc7a24c802008-06-21 17:14:57 +0000550 err = snd_pcm_hw_params_set_buffer_size_near (
bellard1d14ffa2005-10-30 18:58:22 +0000551 handle,
552 hw_params,
malc7a24c802008-06-21 17:14:57 +0000553 &bsize
bellard1d14ffa2005-10-30 18:58:22 +0000554 );
malcf3b52982008-06-21 20:09:32 +0000555 obt = bsize;
malc7a24c802008-06-21 17:14:57 +0000556 }
557 if (err < 0) {
558 alsa_logerr2 (err, typ, "Failed to set buffer %s to %d\n",
559 size_in_usec ? "time" : "size", req->buffer_size);
560 goto err;
bellard1d14ffa2005-10-30 18:58:22 +0000561 }
malcf3b52982008-06-21 20:09:32 +0000562
malc64333892008-07-09 19:25:28 +0000563 if ((req->override_mask & 2) && (obt - req->buffer_size))
malcf3b52982008-06-21 20:09:32 +0000564 dolog ("Requested buffer %s %u was rejected, using %lu\n",
565 size_in_usec ? "time" : "size", req->buffer_size, obt);
bellard1d14ffa2005-10-30 18:58:22 +0000566 }
malc7a24c802008-06-21 17:14:57 +0000567
568 if (req->period_size) {
malcf3b52982008-06-21 20:09:32 +0000569 unsigned long obt;
570
malc7a24c802008-06-21 17:14:57 +0000571 if (size_in_usec) {
572 int dir = 0;
573 unsigned int ptime = req->period_size;
574
575 err = snd_pcm_hw_params_set_period_time_near (
576 handle,
577 hw_params,
578 &ptime,
579 &dir
580 );
malcf3b52982008-06-21 20:09:32 +0000581 obt = ptime;
malc7a24c802008-06-21 17:14:57 +0000582 }
583 else {
malca7bb29b2008-07-09 19:25:24 +0000584 int dir = 0;
malc7a24c802008-06-21 17:14:57 +0000585 snd_pcm_uframes_t psize = req->period_size;
586
malca7bb29b2008-07-09 19:25:24 +0000587 err = snd_pcm_hw_params_set_period_size_near (
malc7a24c802008-06-21 17:14:57 +0000588 handle,
589 hw_params,
malca7bb29b2008-07-09 19:25:24 +0000590 &psize,
591 &dir
malc7a24c802008-06-21 17:14:57 +0000592 );
malcf3b52982008-06-21 20:09:32 +0000593 obt = psize;
malc7a24c802008-06-21 17:14:57 +0000594 }
595
596 if (err < 0) {
597 alsa_logerr2 (err, typ, "Failed to set period %s to %d\n",
598 size_in_usec ? "time" : "size", req->period_size);
599 goto err;
600 }
malcf3b52982008-06-21 20:09:32 +0000601
malc541ba4e2009-09-18 10:59:50 +0400602 if (((req->override_mask & 1) && (obt - req->period_size)))
malcf3b52982008-06-21 20:09:32 +0000603 dolog ("Requested period %s %u was rejected, using %lu\n",
604 size_in_usec ? "time" : "size", req->period_size, obt);
bellard1d14ffa2005-10-30 18:58:22 +0000605 }
606
607 err = snd_pcm_hw_params (handle, hw_params);
608 if (err < 0) {
609 alsa_logerr2 (err, typ, "Failed to apply audio parameters\n");
610 goto err;
611 }
612
613 err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size);
614 if (err < 0) {
615 alsa_logerr2 (err, typ, "Failed to get buffer size\n");
616 goto err;
617 }
618
balrogca9cc282008-01-14 04:24:29 +0000619 err = snd_pcm_hw_params_get_format (hw_params, &obtfmt);
620 if (err < 0) {
621 alsa_logerr2 (err, typ, "Failed to get format\n");
622 goto err;
623 }
624
625 if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) {
626 dolog ("Invalid format was returned %d\n", obtfmt);
627 goto err;
628 }
629
bellard1d14ffa2005-10-30 18:58:22 +0000630 err = snd_pcm_prepare (handle);
631 if (err < 0) {
bellardc0fe3822005-11-05 18:55:28 +0000632 alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle);
bellard1d14ffa2005-10-30 18:58:22 +0000633 goto err;
634 }
635
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200636 if (!in && conf->threshold) {
bellard1d14ffa2005-10-30 18:58:22 +0000637 snd_pcm_uframes_t threshold;
638 int bytes_per_sec;
639
balrogca9cc282008-01-14 04:24:29 +0000640 bytes_per_sec = freq << (nchannels == 2);
641
642 switch (obt->fmt) {
643 case AUD_FMT_S8:
644 case AUD_FMT_U8:
645 break;
646
647 case AUD_FMT_S16:
648 case AUD_FMT_U16:
649 bytes_per_sec <<= 1;
650 break;
651
652 case AUD_FMT_S32:
653 case AUD_FMT_U32:
654 bytes_per_sec <<= 2;
655 break;
656 }
bellard1d14ffa2005-10-30 18:58:22 +0000657
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200658 threshold = (conf->threshold * bytes_per_sec) / 1000;
bellard1d14ffa2005-10-30 18:58:22 +0000659 alsa_set_threshold (handle, threshold);
660 }
661
bellard1d14ffa2005-10-30 18:58:22 +0000662 obt->nchannels = nchannels;
663 obt->freq = freq;
bellardc0fe3822005-11-05 18:55:28 +0000664 obt->samples = obt_buffer_size;
balrogca9cc282008-01-14 04:24:29 +0000665
bellard1d14ffa2005-10-30 18:58:22 +0000666 *handlep = handle;
667
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200668 if (obtfmt != req->fmt ||
balrogca9cc282008-01-14 04:24:29 +0000669 obt->nchannels != req->nchannels ||
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200670 obt->freq != req->freq) {
Vagrant Cascadianf093feb2010-02-26 13:39:46 -0800671 dolog ("Audio parameters for %s\n", typ);
malc8bb414d2010-04-21 15:40:23 +0400672 alsa_dump_info (req, obt, obtfmt);
bellard1d14ffa2005-10-30 18:58:22 +0000673 }
674
675#ifdef DEBUG
malc8bb414d2010-04-21 15:40:23 +0400676 alsa_dump_info (req, obt, obtfmt);
bellard1d14ffa2005-10-30 18:58:22 +0000677#endif
678 return 0;
679
680 err:
malc6ebfda12009-09-14 03:51:48 +0400681 alsa_anal_close1 (&handle);
bellard1d14ffa2005-10-30 18:58:22 +0000682 return -1;
683}
684
bellard571ec3d2005-11-20 16:24:34 +0000685static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
686{
687 snd_pcm_sframes_t avail;
688
689 avail = snd_pcm_avail_update (handle);
690 if (avail < 0) {
691 if (avail == -EPIPE) {
692 if (!alsa_recover (handle)) {
693 avail = snd_pcm_avail_update (handle);
694 }
695 }
696
697 if (avail < 0) {
698 alsa_logerr (avail,
699 "Could not obtain number of available frames\n");
700 return -1;
701 }
702 }
703
704 return avail;
705}
706
malc541ba4e2009-09-18 10:59:50 +0400707static void alsa_write_pending (ALSAVoiceOut *alsa)
708{
709 HWVoiceOut *hw = &alsa->hw;
710
711 while (alsa->pending) {
712 int left_till_end_samples = hw->samples - alsa->wpos;
713 int len = audio_MIN (alsa->pending, left_till_end_samples);
714 char *src = advance (alsa->pcm_buf, alsa->wpos << hw->info.shift);
715
716 while (len) {
717 snd_pcm_sframes_t written;
718
719 written = snd_pcm_writei (alsa->handle, src, len);
720
721 if (written <= 0) {
722 switch (written) {
723 case 0:
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200724 trace_alsa_wrote_zero(len);
malc541ba4e2009-09-18 10:59:50 +0400725 return;
726
727 case -EPIPE:
728 if (alsa_recover (alsa->handle)) {
729 alsa_logerr (written, "Failed to write %d frames\n",
730 len);
731 return;
732 }
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200733 trace_alsa_xrun_out();
malc541ba4e2009-09-18 10:59:50 +0400734 continue;
735
736 case -ESTRPIPE:
737 /* stream is suspended and waiting for an
738 application recovery */
739 if (alsa_resume (alsa->handle)) {
740 alsa_logerr (written, "Failed to write %d frames\n",
741 len);
742 return;
743 }
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +0200744 trace_alsa_resume_out();
malc541ba4e2009-09-18 10:59:50 +0400745 continue;
746
747 case -EAGAIN:
748 return;
749
750 default:
751 alsa_logerr (written, "Failed to write %d frames from %p\n",
752 len, src);
753 return;
754 }
755 }
756
757 alsa->wpos = (alsa->wpos + written) % hw->samples;
758 alsa->pending -= written;
759 len -= written;
760 }
761 }
762}
763
malcbdff2532009-09-18 11:37:39 +0400764static int alsa_run_out (HWVoiceOut *hw, int live)
bellard1d14ffa2005-10-30 18:58:22 +0000765{
766 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
malcbdff2532009-09-18 11:37:39 +0400767 int decr;
bellard1d14ffa2005-10-30 18:58:22 +0000768 snd_pcm_sframes_t avail;
769
bellard571ec3d2005-11-20 16:24:34 +0000770 avail = alsa_get_avail (alsa->handle);
bellard1d14ffa2005-10-30 18:58:22 +0000771 if (avail < 0) {
bellard571ec3d2005-11-20 16:24:34 +0000772 dolog ("Could not get number of available playback frames\n");
bellard1d14ffa2005-10-30 18:58:22 +0000773 return 0;
774 }
775
bellard1d14ffa2005-10-30 18:58:22 +0000776 decr = audio_MIN (live, avail);
malc541ba4e2009-09-18 10:59:50 +0400777 decr = audio_pcm_hw_clip_out (hw, alsa->pcm_buf, decr, alsa->pending);
778 alsa->pending += decr;
779 alsa_write_pending (alsa);
bellard1d14ffa2005-10-30 18:58:22 +0000780 return decr;
781}
782
783static void alsa_fini_out (HWVoiceOut *hw)
784{
785 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
786
787 ldebug ("alsa_fini\n");
malc6ebfda12009-09-14 03:51:48 +0400788 alsa_anal_close (&alsa->handle, &alsa->pollhlp);
bellard1d14ffa2005-10-30 18:58:22 +0000789
Markus Armbrusterfb7da622014-06-06 18:35:13 +0200790 g_free(alsa->pcm_buf);
791 alsa->pcm_buf = NULL;
bellard1d14ffa2005-10-30 18:58:22 +0000792}
793
Kővágó, Zoltán5706db12015-06-03 23:03:47 +0200794static int alsa_init_out(HWVoiceOut *hw, struct audsettings *as,
795 void *drv_opaque)
bellard1d14ffa2005-10-30 18:58:22 +0000796{
797 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
798 struct alsa_params_req req;
799 struct alsa_params_obt obt;
bellard1d14ffa2005-10-30 18:58:22 +0000800 snd_pcm_t *handle;
malc1ea879e2008-12-03 22:48:44 +0000801 struct audsettings obt_as;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200802 ALSAConf *conf = drv_opaque;
bellard1d14ffa2005-10-30 18:58:22 +0000803
Michael Walled66bddd2011-01-08 17:53:30 +0100804 req.fmt = aud_to_alsafmt (as->fmt, as->endianness);
bellardc0fe3822005-11-05 18:55:28 +0000805 req.freq = as->freq;
806 req.nchannels = as->nchannels;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200807 req.period_size = conf->period_size_out;
808 req.buffer_size = conf->buffer_size_out;
809 req.size_in_usec = conf->size_in_usec_out;
Gerd Hoffmann97f155d2009-06-17 13:51:20 +0200810 req.override_mask =
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200811 (conf->period_size_out_overridden ? 1 : 0) |
812 (conf->buffer_size_out_overridden ? 2 : 0);
bellard1d14ffa2005-10-30 18:58:22 +0000813
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200814 if (alsa_open (0, &req, &obt, &handle, conf)) {
bellard1d14ffa2005-10-30 18:58:22 +0000815 return -1;
816 }
817
bellardc0fe3822005-11-05 18:55:28 +0000818 obt_as.freq = obt.freq;
819 obt_as.nchannels = obt.nchannels;
balrogca9cc282008-01-14 04:24:29 +0000820 obt_as.fmt = obt.fmt;
821 obt_as.endianness = obt.endianness;
bellardc0fe3822005-11-05 18:55:28 +0000822
bellardd929eba2006-07-04 21:47:22 +0000823 audio_pcm_init_info (&hw->info, &obt_as);
bellardc0fe3822005-11-05 18:55:28 +0000824 hw->samples = obt.samples;
bellard1d14ffa2005-10-30 18:58:22 +0000825
bellardc0fe3822005-11-05 18:55:28 +0000826 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);
bellard1d14ffa2005-10-30 18:58:22 +0000827 if (!alsa->pcm_buf) {
bellard4787c712005-11-11 00:06:10 +0000828 dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
829 hw->samples, 1 << hw->info.shift);
malc6ebfda12009-09-14 03:51:48 +0400830 alsa_anal_close1 (&handle);
bellard1d14ffa2005-10-30 18:58:22 +0000831 return -1;
832 }
833
834 alsa->handle = handle;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200835 alsa->pollhlp.conf = conf;
bellard571ec3d2005-11-20 16:24:34 +0000836 return 0;
837}
838
Jindrich Makovicka38cc9b62010-10-17 20:17:19 +0200839#define VOICE_CTL_PAUSE 0
840#define VOICE_CTL_PREPARE 1
841#define VOICE_CTL_START 2
842
843static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int ctl)
bellard571ec3d2005-11-20 16:24:34 +0000844{
845 int err;
846
Jindrich Makovicka38cc9b62010-10-17 20:17:19 +0200847 if (ctl == VOICE_CTL_PAUSE) {
bellard571ec3d2005-11-20 16:24:34 +0000848 err = snd_pcm_drop (handle);
849 if (err < 0) {
bellard32d448c2005-11-20 18:53:05 +0000850 alsa_logerr (err, "Could not stop %s\n", typ);
bellard571ec3d2005-11-20 16:24:34 +0000851 return -1;
852 }
853 }
854 else {
855 err = snd_pcm_prepare (handle);
856 if (err < 0) {
bellard32d448c2005-11-20 18:53:05 +0000857 alsa_logerr (err, "Could not prepare handle for %s\n", typ);
bellard571ec3d2005-11-20 16:24:34 +0000858 return -1;
859 }
Jindrich Makovicka38cc9b62010-10-17 20:17:19 +0200860 if (ctl == VOICE_CTL_START) {
861 err = snd_pcm_start(handle);
862 if (err < 0) {
863 alsa_logerr (err, "Could not start handle for %s\n", typ);
864 return -1;
865 }
866 }
bellard571ec3d2005-11-20 16:24:34 +0000867 }
868
bellard1d14ffa2005-10-30 18:58:22 +0000869 return 0;
870}
871
872static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
873{
bellard1d14ffa2005-10-30 18:58:22 +0000874 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
875
876 switch (cmd) {
877 case VOICE_ENABLE:
malc301901b2009-10-02 02:37:40 +0400878 {
879 va_list ap;
880 int poll_mode;
881
882 va_start (ap, cmd);
883 poll_mode = va_arg (ap, int);
884 va_end (ap);
885
886 ldebug ("enabling voice\n");
887 if (poll_mode && alsa_poll_out (hw)) {
888 poll_mode = 0;
889 }
890 hw->poll_mode = poll_mode;
Jindrich Makovicka38cc9b62010-10-17 20:17:19 +0200891 return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PREPARE);
malc8b438ba2009-09-12 02:29:25 +0400892 }
bellard1d14ffa2005-10-30 18:58:22 +0000893
894 case VOICE_DISABLE:
895 ldebug ("disabling voice\n");
Jindrich Makovicka22d948a2010-10-17 19:28:14 +0200896 if (hw->poll_mode) {
897 hw->poll_mode = 0;
898 alsa_fini_poll (&alsa->pollhlp);
899 }
Jindrich Makovicka38cc9b62010-10-17 20:17:19 +0200900 return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PAUSE);
bellard1d14ffa2005-10-30 18:58:22 +0000901 }
bellard571ec3d2005-11-20 16:24:34 +0000902
903 return -1;
bellard1d14ffa2005-10-30 18:58:22 +0000904}
905
Kővágó, Zoltán5706db12015-06-03 23:03:47 +0200906static int alsa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
bellard1d14ffa2005-10-30 18:58:22 +0000907{
908 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
909 struct alsa_params_req req;
910 struct alsa_params_obt obt;
bellard1d14ffa2005-10-30 18:58:22 +0000911 snd_pcm_t *handle;
malc1ea879e2008-12-03 22:48:44 +0000912 struct audsettings obt_as;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200913 ALSAConf *conf = drv_opaque;
bellard1d14ffa2005-10-30 18:58:22 +0000914
Michael Walled66bddd2011-01-08 17:53:30 +0100915 req.fmt = aud_to_alsafmt (as->fmt, as->endianness);
bellardc0fe3822005-11-05 18:55:28 +0000916 req.freq = as->freq;
917 req.nchannels = as->nchannels;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200918 req.period_size = conf->period_size_in;
919 req.buffer_size = conf->buffer_size_in;
920 req.size_in_usec = conf->size_in_usec_in;
Gerd Hoffmann97f155d2009-06-17 13:51:20 +0200921 req.override_mask =
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200922 (conf->period_size_in_overridden ? 1 : 0) |
923 (conf->buffer_size_in_overridden ? 2 : 0);
bellard1d14ffa2005-10-30 18:58:22 +0000924
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200925 if (alsa_open (1, &req, &obt, &handle, conf)) {
bellard1d14ffa2005-10-30 18:58:22 +0000926 return -1;
927 }
928
bellardc0fe3822005-11-05 18:55:28 +0000929 obt_as.freq = obt.freq;
930 obt_as.nchannels = obt.nchannels;
balrogca9cc282008-01-14 04:24:29 +0000931 obt_as.fmt = obt.fmt;
932 obt_as.endianness = obt.endianness;
bellardc0fe3822005-11-05 18:55:28 +0000933
bellardd929eba2006-07-04 21:47:22 +0000934 audio_pcm_init_info (&hw->info, &obt_as);
bellardc0fe3822005-11-05 18:55:28 +0000935 hw->samples = obt.samples;
936
937 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
bellard1d14ffa2005-10-30 18:58:22 +0000938 if (!alsa->pcm_buf) {
bellard4787c712005-11-11 00:06:10 +0000939 dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
940 hw->samples, 1 << hw->info.shift);
malc6ebfda12009-09-14 03:51:48 +0400941 alsa_anal_close1 (&handle);
bellard1d14ffa2005-10-30 18:58:22 +0000942 return -1;
943 }
944
945 alsa->handle = handle;
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +0200946 alsa->pollhlp.conf = conf;
bellard1d14ffa2005-10-30 18:58:22 +0000947 return 0;
948}
949
950static void alsa_fini_in (HWVoiceIn *hw)
951{
952 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
953
malc6ebfda12009-09-14 03:51:48 +0400954 alsa_anal_close (&alsa->handle, &alsa->pollhlp);
bellard1d14ffa2005-10-30 18:58:22 +0000955
Markus Armbrusterfb7da622014-06-06 18:35:13 +0200956 g_free(alsa->pcm_buf);
957 alsa->pcm_buf = NULL;
bellard1d14ffa2005-10-30 18:58:22 +0000958}
959
960static int alsa_run_in (HWVoiceIn *hw)
961{
962 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
963 int hwshift = hw->info.shift;
964 int i;
965 int live = audio_pcm_hw_get_live_in (hw);
966 int dead = hw->samples - live;
bellard571ec3d2005-11-20 16:24:34 +0000967 int decr;
bellard1d14ffa2005-10-30 18:58:22 +0000968 struct {
969 int add;
970 int len;
971 } bufs[2] = {
malc98f9f482009-08-11 20:48:02 +0400972 { .add = hw->wpos, .len = 0 },
973 { .add = 0, .len = 0 }
bellard1d14ffa2005-10-30 18:58:22 +0000974 };
bellard571ec3d2005-11-20 16:24:34 +0000975 snd_pcm_sframes_t avail;
bellard1d14ffa2005-10-30 18:58:22 +0000976 snd_pcm_uframes_t read_samples = 0;
977
978 if (!dead) {
979 return 0;
980 }
981
bellard571ec3d2005-11-20 16:24:34 +0000982 avail = alsa_get_avail (alsa->handle);
983 if (avail < 0) {
984 dolog ("Could not get number of captured frames\n");
985 return 0;
bellard1d14ffa2005-10-30 18:58:22 +0000986 }
987
Bjørn Mork86635822009-07-30 09:44:26 +0200988 if (!avail) {
989 snd_pcm_state_t state;
990
991 state = snd_pcm_state (alsa->handle);
992 switch (state) {
993 case SND_PCM_STATE_PREPARED:
994 avail = hw->samples;
995 break;
996 case SND_PCM_STATE_SUSPENDED:
997 /* stream is suspended and waiting for an application recovery */
998 if (alsa_resume (alsa->handle)) {
999 dolog ("Failed to resume suspended input stream\n");
1000 return 0;
1001 }
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +02001002 trace_alsa_resume_in();
Bjørn Mork86635822009-07-30 09:44:26 +02001003 break;
1004 default:
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +02001005 trace_alsa_no_frames(state);
Bjørn Mork86635822009-07-30 09:44:26 +02001006 return 0;
1007 }
bellard571ec3d2005-11-20 16:24:34 +00001008 }
1009
1010 decr = audio_MIN (dead, avail);
1011 if (!decr) {
1012 return 0;
1013 }
1014
1015 if (hw->wpos + decr > hw->samples) {
1016 bufs[0].len = (hw->samples - hw->wpos);
1017 bufs[1].len = (decr - (hw->samples - hw->wpos));
1018 }
1019 else {
1020 bufs[0].len = decr;
1021 }
bellard1d14ffa2005-10-30 18:58:22 +00001022
1023 for (i = 0; i < 2; ++i) {
1024 void *src;
malc1ea879e2008-12-03 22:48:44 +00001025 struct st_sample *dst;
bellard1d14ffa2005-10-30 18:58:22 +00001026 snd_pcm_sframes_t nread;
1027 snd_pcm_uframes_t len;
1028
1029 len = bufs[i].len;
1030
1031 src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
1032 dst = hw->conv_buf + bufs[i].add;
1033
1034 while (len) {
1035 nread = snd_pcm_readi (alsa->handle, src, len);
1036
bellard571ec3d2005-11-20 16:24:34 +00001037 if (nread <= 0) {
bellard1d14ffa2005-10-30 18:58:22 +00001038 switch (nread) {
bellard571ec3d2005-11-20 16:24:34 +00001039 case 0:
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +02001040 trace_alsa_read_zero(len);
bellard1d14ffa2005-10-30 18:58:22 +00001041 goto exit;
1042
bellard571ec3d2005-11-20 16:24:34 +00001043 case -EPIPE:
1044 if (alsa_recover (alsa->handle)) {
1045 alsa_logerr (nread, "Failed to read %ld frames\n", len);
1046 goto exit;
1047 }
Kővágó, Zoltánfbb7ef52015-06-12 14:33:06 +02001048 trace_alsa_xrun_in();
bellard1d14ffa2005-10-30 18:58:22 +00001049 continue;
1050
bellard571ec3d2005-11-20 16:24:34 +00001051 case -EAGAIN:
1052 goto exit;
1053
bellard1d14ffa2005-10-30 18:58:22 +00001054 default:
1055 alsa_logerr (
1056 nread,
1057 "Failed to read %ld frames from %p\n",
1058 len,
1059 src
1060 );
1061 goto exit;
1062 }
1063 }
1064
Michael Walle00e07672011-01-05 01:05:47 +01001065 hw->conv (dst, src, nread);
bellard1d14ffa2005-10-30 18:58:22 +00001066
1067 src = advance (src, nread << hwshift);
1068 dst += nread;
1069
1070 read_samples += nread;
1071 len -= nread;
1072 }
1073 }
1074
1075 exit:
1076 hw->wpos = (hw->wpos + read_samples) % hw->samples;
1077 return read_samples;
1078}
1079
1080static int alsa_read (SWVoiceIn *sw, void *buf, int size)
1081{
1082 return audio_pcm_sw_read (sw, buf, size);
1083}
1084
1085static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
1086{
bellard571ec3d2005-11-20 16:24:34 +00001087 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
1088
1089 switch (cmd) {
1090 case VOICE_ENABLE:
malca628b862009-10-03 03:30:06 +04001091 {
1092 va_list ap;
1093 int poll_mode;
malc8b438ba2009-09-12 02:29:25 +04001094
malca628b862009-10-03 03:30:06 +04001095 va_start (ap, cmd);
1096 poll_mode = va_arg (ap, int);
1097 va_end (ap);
1098
1099 ldebug ("enabling voice\n");
1100 if (poll_mode && alsa_poll_in (hw)) {
1101 poll_mode = 0;
1102 }
1103 hw->poll_mode = poll_mode;
1104
Jindrich Makovicka38cc9b62010-10-17 20:17:19 +02001105 return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_START);
malca628b862009-10-03 03:30:06 +04001106 }
bellard571ec3d2005-11-20 16:24:34 +00001107
1108 case VOICE_DISABLE:
1109 ldebug ("disabling voice\n");
malc8b438ba2009-09-12 02:29:25 +04001110 if (hw->poll_mode) {
1111 hw->poll_mode = 0;
1112 alsa_fini_poll (&alsa->pollhlp);
1113 }
Jindrich Makovicka38cc9b62010-10-17 20:17:19 +02001114 return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_PAUSE);
bellard571ec3d2005-11-20 16:24:34 +00001115 }
1116
1117 return -1;
bellard1d14ffa2005-10-30 18:58:22 +00001118}
1119
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001120static ALSAConf glob_conf = {
1121 .buffer_size_out = 4096,
1122 .period_size_out = 1024,
1123 .pcm_name_out = "default",
1124 .pcm_name_in = "default",
1125};
1126
bellard1d14ffa2005-10-30 18:58:22 +00001127static void *alsa_audio_init (void)
1128{
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001129 ALSAConf *conf = g_malloc(sizeof(ALSAConf));
1130 *conf = glob_conf;
1131 return conf;
bellard1d14ffa2005-10-30 18:58:22 +00001132}
1133
1134static void alsa_audio_fini (void *opaque)
1135{
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001136 g_free(opaque);
bellard1d14ffa2005-10-30 18:58:22 +00001137}
1138
1139static struct audio_option alsa_options[] = {
malc98f9f482009-08-11 20:48:02 +04001140 {
1141 .name = "DAC_SIZE_IN_USEC",
1142 .tag = AUD_OPT_BOOL,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001143 .valp = &glob_conf.size_in_usec_out,
malc98f9f482009-08-11 20:48:02 +04001144 .descr = "DAC period/buffer size in microseconds (otherwise in frames)"
1145 },
1146 {
1147 .name = "DAC_PERIOD_SIZE",
1148 .tag = AUD_OPT_INT,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001149 .valp = &glob_conf.period_size_out,
malc98f9f482009-08-11 20:48:02 +04001150 .descr = "DAC period size (0 to go with system default)",
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001151 .overriddenp = &glob_conf.period_size_out_overridden
malc98f9f482009-08-11 20:48:02 +04001152 },
1153 {
1154 .name = "DAC_BUFFER_SIZE",
1155 .tag = AUD_OPT_INT,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001156 .valp = &glob_conf.buffer_size_out,
malc98f9f482009-08-11 20:48:02 +04001157 .descr = "DAC buffer size (0 to go with system default)",
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001158 .overriddenp = &glob_conf.buffer_size_out_overridden
malc98f9f482009-08-11 20:48:02 +04001159 },
1160 {
1161 .name = "ADC_SIZE_IN_USEC",
1162 .tag = AUD_OPT_BOOL,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001163 .valp = &glob_conf.size_in_usec_in,
malc98f9f482009-08-11 20:48:02 +04001164 .descr =
1165 "ADC period/buffer size in microseconds (otherwise in frames)"
1166 },
1167 {
1168 .name = "ADC_PERIOD_SIZE",
1169 .tag = AUD_OPT_INT,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001170 .valp = &glob_conf.period_size_in,
malc98f9f482009-08-11 20:48:02 +04001171 .descr = "ADC period size (0 to go with system default)",
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001172 .overriddenp = &glob_conf.period_size_in_overridden
malc98f9f482009-08-11 20:48:02 +04001173 },
1174 {
1175 .name = "ADC_BUFFER_SIZE",
1176 .tag = AUD_OPT_INT,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001177 .valp = &glob_conf.buffer_size_in,
malc98f9f482009-08-11 20:48:02 +04001178 .descr = "ADC buffer size (0 to go with system default)",
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001179 .overriddenp = &glob_conf.buffer_size_in_overridden
malc98f9f482009-08-11 20:48:02 +04001180 },
1181 {
1182 .name = "THRESHOLD",
1183 .tag = AUD_OPT_INT,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001184 .valp = &glob_conf.threshold,
malc98f9f482009-08-11 20:48:02 +04001185 .descr = "(undocumented)"
1186 },
1187 {
1188 .name = "DAC_DEV",
1189 .tag = AUD_OPT_STR,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001190 .valp = &glob_conf.pcm_name_out,
malc98f9f482009-08-11 20:48:02 +04001191 .descr = "DAC device name (for instance dmix)"
1192 },
1193 {
1194 .name = "ADC_DEV",
1195 .tag = AUD_OPT_STR,
Kővágó, Zoltán765b37d2015-06-03 23:03:48 +02001196 .valp = &glob_conf.pcm_name_in,
malc98f9f482009-08-11 20:48:02 +04001197 .descr = "ADC device name"
1198 },
Juan Quintela2700efa2009-08-11 02:31:16 +02001199 { /* End of list */ }
bellard1d14ffa2005-10-30 18:58:22 +00001200};
1201
blueswir135f4b582008-10-06 18:08:30 +00001202static struct audio_pcm_ops alsa_pcm_ops = {
Juan Quintela1dd3e4d2009-08-11 02:31:15 +02001203 .init_out = alsa_init_out,
1204 .fini_out = alsa_fini_out,
1205 .run_out = alsa_run_out,
1206 .write = alsa_write,
1207 .ctl_out = alsa_ctl_out,
bellard1d14ffa2005-10-30 18:58:22 +00001208
Juan Quintela1dd3e4d2009-08-11 02:31:15 +02001209 .init_in = alsa_init_in,
1210 .fini_in = alsa_fini_in,
1211 .run_in = alsa_run_in,
1212 .read = alsa_read,
malc8b438ba2009-09-12 02:29:25 +04001213 .ctl_in = alsa_ctl_in,
bellard1d14ffa2005-10-30 18:58:22 +00001214};
1215
1216struct audio_driver alsa_audio_driver = {
Juan Quintelabee37f32009-08-11 02:31:14 +02001217 .name = "alsa",
1218 .descr = "ALSA http://www.alsa-project.org",
1219 .options = alsa_options,
1220 .init = alsa_audio_init,
1221 .fini = alsa_audio_fini,
1222 .pcm_ops = &alsa_pcm_ops,
1223 .can_be_default = 1,
1224 .max_voices_out = INT_MAX,
1225 .max_voices_in = INT_MAX,
1226 .voice_size_out = sizeof (ALSAVoiceOut),
1227 .voice_size_in = sizeof (ALSAVoiceIn)
bellard1d14ffa2005-10-30 18:58:22 +00001228};