4 This file is part of PulseAudio.
6 Copyright 2004-2006 Lennart Poettering
7 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
9 PulseAudio is free software; you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License as published
11 by the Free Software Foundation; either version 2 of the License,
12 or (at your option) any later version.
14 PulseAudio is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU Lesser General Public License
20 along with PulseAudio; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <sys/types.h>
30 #include <asoundlib.h>
32 #include <pulse/sample.h>
33 #include <pulse/xmalloc.h>
35 #include <pulsecore/log.h>
37 #include "alsa-util.h"
39 struct pa_alsa_fdlist {
42 /* This is a temporary buffer used to avoid lots of mallocs */
43 struct pollfd *work_fds;
49 pa_defer_event *defer;
54 void (*cb)(void *userdata);
58 static void io_cb(pa_mainloop_api*a, pa_io_event* e, PA_GCC_UNUSED int fd, pa_io_event_flags_t events, void *userdata) {
59 struct pa_alsa_fdlist *fdl = (struct pa_alsa_fdlist*)userdata;
61 unsigned short revents;
63 assert(a && fdl && (fdl->pcm || fdl->mixer) && fdl->fds && fdl->work_fds);
70 memcpy(fdl->work_fds, fdl->fds, sizeof(struct pollfd) * fdl->num_fds);
72 for (i = 0;i < fdl->num_fds;i++) {
73 if (e == fdl->ios[i]) {
74 if (events & PA_IO_EVENT_INPUT)
75 fdl->work_fds[i].revents |= POLLIN;
76 if (events & PA_IO_EVENT_OUTPUT)
77 fdl->work_fds[i].revents |= POLLOUT;
78 if (events & PA_IO_EVENT_ERROR)
79 fdl->work_fds[i].revents |= POLLERR;
80 if (events & PA_IO_EVENT_HANGUP)
81 fdl->work_fds[i].revents |= POLLHUP;
86 assert(i != fdl->num_fds);
89 err = snd_pcm_poll_descriptors_revents(fdl->pcm, fdl->work_fds, fdl->num_fds, &revents);
91 err = snd_mixer_poll_descriptors_revents(fdl->mixer, fdl->work_fds, fdl->num_fds, &revents);
94 pa_log_error("Unable to get poll revent: %s",
99 a->defer_enable(fdl->defer, 1);
103 fdl->cb(fdl->userdata);
105 snd_mixer_handle_events(fdl->mixer);
109 static void defer_cb(pa_mainloop_api*a, PA_GCC_UNUSED pa_defer_event* e, void *userdata) {
110 struct pa_alsa_fdlist *fdl = (struct pa_alsa_fdlist*)userdata;
114 assert(a && fdl && (fdl->pcm || fdl->mixer));
116 a->defer_enable(fdl->defer, 0);
119 num_fds = snd_pcm_poll_descriptors_count(fdl->pcm);
121 num_fds = snd_mixer_poll_descriptors_count(fdl->mixer);
124 if (num_fds != fdl->num_fds) {
128 pa_xfree(fdl->work_fds);
129 fdl->fds = pa_xmalloc0(sizeof(struct pollfd) * num_fds);
130 fdl->work_fds = pa_xmalloc(sizeof(struct pollfd) * num_fds);
133 memset(fdl->work_fds, 0, sizeof(struct pollfd) * num_fds);
136 err = snd_pcm_poll_descriptors(fdl->pcm, fdl->work_fds, num_fds);
138 err = snd_mixer_poll_descriptors(fdl->mixer, fdl->work_fds, num_fds);
141 pa_log_error("Unable to get poll descriptors: %s",
148 if (memcmp(fdl->fds, fdl->work_fds, sizeof(struct pollfd) * num_fds) == 0)
152 for (i = 0;i < fdl->num_fds;i++)
153 a->io_free(fdl->ios[i]);
154 if (num_fds != fdl->num_fds) {
156 fdl->ios = pa_xmalloc(sizeof(pa_io_event*) * num_fds);
160 fdl->ios = pa_xmalloc(sizeof(pa_io_event*) * num_fds);
165 temp = fdl->work_fds;
166 fdl->work_fds = fdl->fds;
169 fdl->num_fds = num_fds;
171 for (i = 0;i < num_fds;i++) {
172 fdl->ios[i] = a->io_new(a, fdl->fds[i].fd,
173 ((fdl->fds[i].events & POLLIN) ? PA_IO_EVENT_INPUT : 0) |
174 ((fdl->fds[i].events & POLLOUT) ? PA_IO_EVENT_OUTPUT : 0),
180 struct pa_alsa_fdlist *pa_alsa_fdlist_new(void) {
181 struct pa_alsa_fdlist *fdl;
183 fdl = pa_xmalloc(sizeof(struct pa_alsa_fdlist));
187 fdl->work_fds = NULL;
201 void pa_alsa_fdlist_free(struct pa_alsa_fdlist *fdl) {
206 fdl->m->defer_free(fdl->defer);
212 for (i = 0;i < fdl->num_fds;i++)
213 fdl->m->io_free(fdl->ios[i]);
220 pa_xfree(fdl->work_fds);
225 int pa_alsa_fdlist_init_pcm(struct pa_alsa_fdlist *fdl, snd_pcm_t *pcm_handle, pa_mainloop_api* m, void (*cb)(void *userdata), void *userdata) {
226 assert(fdl && pcm_handle && m && !fdl->m && cb);
228 fdl->pcm = pcm_handle;
231 fdl->defer = m->defer_new(m, defer_cb, fdl);
235 fdl->userdata = userdata;
240 int pa_alsa_fdlist_init_mixer(struct pa_alsa_fdlist *fdl, snd_mixer_t *mixer_handle, pa_mainloop_api* m) {
241 assert(fdl && mixer_handle && m && !fdl->m);
243 fdl->mixer = mixer_handle;
246 fdl->defer = m->defer_new(m, defer_cb, fdl);
252 static int set_format(snd_pcm_t *pcm_handle, snd_pcm_hw_params_t *hwparams, pa_sample_format_t *f) {
254 static const snd_pcm_format_t format_trans[] = {
255 [PA_SAMPLE_U8] = SND_PCM_FORMAT_U8,
256 [PA_SAMPLE_ALAW] = SND_PCM_FORMAT_A_LAW,
257 [PA_SAMPLE_ULAW] = SND_PCM_FORMAT_MU_LAW,
258 [PA_SAMPLE_S16LE] = SND_PCM_FORMAT_S16_LE,
259 [PA_SAMPLE_S16BE] = SND_PCM_FORMAT_S16_BE,
260 [PA_SAMPLE_FLOAT32LE] = SND_PCM_FORMAT_FLOAT_LE,
261 [PA_SAMPLE_FLOAT32BE] = SND_PCM_FORMAT_FLOAT_BE,
264 static const pa_sample_format_t try_order[] = {
280 if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
283 if (*f == PA_SAMPLE_FLOAT32BE)
284 *f = PA_SAMPLE_FLOAT32LE;
285 else if (*f == PA_SAMPLE_FLOAT32LE)
286 *f = PA_SAMPLE_FLOAT32BE;
287 else if (*f == PA_SAMPLE_S16BE)
288 *f = PA_SAMPLE_S16LE;
289 else if (*f == PA_SAMPLE_S16LE)
290 *f = PA_SAMPLE_S16BE;
294 if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
299 for (i = 0; try_order[i] != PA_SAMPLE_INVALID; i++) {
302 if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
309 /* Set the hardware parameters of the given ALSA device. Returns the
310 * selected fragment settings in *period and *period_size */
311 int pa_alsa_set_hw_params(snd_pcm_t *pcm_handle, pa_sample_spec *ss, uint32_t *periods, snd_pcm_uframes_t *period_size) {
313 snd_pcm_uframes_t buffer_size;
314 unsigned int r = ss->rate;
315 unsigned int c = ss->channels;
316 pa_sample_format_t f = ss->format;
317 snd_pcm_hw_params_t *hwparams;
324 buffer_size = *periods * *period_size;
326 if ((ret = snd_pcm_hw_params_malloc(&hwparams)) < 0 ||
327 (ret = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0 ||
328 (ret = snd_pcm_hw_params_set_rate_resample(pcm_handle, hwparams, 0)) < 0 ||
329 (ret = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
332 if ((ret = set_format(pcm_handle, hwparams, &f)) < 0)
335 if ((ret = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &r, NULL)) < 0)
338 if ((ret = snd_pcm_hw_params_set_channels_near(pcm_handle, hwparams, &c)) < 0)
341 if ((*period_size > 0 && (ret = snd_pcm_hw_params_set_period_size_near(pcm_handle, hwparams, period_size, NULL)) < 0) ||
342 (*periods > 0 && (ret = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hwparams, &buffer_size)) < 0))
345 if ((ret = snd_pcm_hw_params(pcm_handle, hwparams)) < 0)
349 pa_log_warn("device doesn't support %u Hz, changed to %u Hz.", ss->rate, r);
351 /* If the sample rate deviates too much, we need to resample */
352 if (r < ss->rate*.95 || r > ss->rate*1.05)
356 if (ss->channels != c) {
357 pa_log_warn("device doesn't support %u channels, changed to %u.", ss->channels, c);
361 if (ss->format != f) {
362 pa_log_warn("device doesn't support sample format %s, changed to %s.", pa_sample_format_to_string(ss->format), pa_sample_format_to_string(f));
366 if ((ret = snd_pcm_prepare(pcm_handle)) < 0)
369 if ((ret = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size)) < 0 ||
370 (ret = snd_pcm_hw_params_get_period_size(hwparams, period_size, NULL)) < 0)
373 assert(buffer_size > 0);
374 assert(*period_size > 0);
375 *periods = buffer_size / *period_size;
376 assert(*periods > 0);
382 snd_pcm_hw_params_free(hwparams);
387 int pa_alsa_prepare_mixer(snd_mixer_t *mixer, const char *dev) {
390 assert(mixer && dev);
392 if ((err = snd_mixer_attach(mixer, dev)) < 0) {
393 pa_log_warn("Unable to attach to mixer %s: %s", dev, snd_strerror(err));
397 if ((err = snd_mixer_selem_register(mixer, NULL, NULL)) < 0) {
398 pa_log_warn("Unable to register mixer: %s", snd_strerror(err));
402 if ((err = snd_mixer_load(mixer)) < 0) {
403 pa_log_warn("Unable to load mixer: %s", snd_strerror(err));
410 snd_mixer_elem_t *pa_alsa_find_elem(snd_mixer_t *mixer, const char *name, const char *fallback) {
411 snd_mixer_elem_t *elem;
412 snd_mixer_selem_id_t *sid = NULL;
413 snd_mixer_selem_id_alloca(&sid);
418 snd_mixer_selem_id_set_name(sid, name);
420 if (!(elem = snd_mixer_find_selem(mixer, sid))) {
421 pa_log_warn("Cannot find mixer control \"%s\".", snd_mixer_selem_id_get_name(sid));
424 snd_mixer_selem_id_set_name(sid, fallback);
426 if (!(elem = snd_mixer_find_selem(mixer, sid)))
427 pa_log_warn("Cannot find fallback mixer control \"%s\".", snd_mixer_selem_id_get_name(sid));
432 pa_log_info("Using mixer control \"%s\".", snd_mixer_selem_id_get_name(sid));