code.delx.au - pulseaudio/blob - src/modules/alsa-util.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of polypaudio.
   5
   6   polypaudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   polypaudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with polypaudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <sys/types.h>
  27 #include <asoundlib.h>
  28
  29 #include <polyp/sample.h>
  30 #include <polypcore/xmalloc.h>
  31 #include <polypcore/log.h>
  32
  33 #include "alsa-util.h"
  34
  35 struct pa_alsa_fdlist {
  36     int num_fds;
  37     struct pollfd *fds;
  38     /* This is a temporary buffer used to avoid lots of mallocs */
  39     struct pollfd *work_fds;
  40
  41     snd_pcm_t *pcm;
  42     snd_mixer_t *mixer;
  43
  44     pa_mainloop_api *m;
  45     pa_defer_event *defer;
  46     pa_io_event **ios;
  47
  48     int polled;
  49
  50     void (*cb)(void *userdata);
  51     void *userdata;
  52 };
  53
  54 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) {
  55     struct pa_alsa_fdlist *fdl = (struct pa_alsa_fdlist*)userdata;
  56     int err, i;
  57     unsigned short revents;
  58
  59     assert(a && fdl && (fdl->pcm || fdl->mixer) && fdl->fds && fdl->work_fds);
  60
  61     if (fdl->polled)
  62         return;
  63
  64     fdl->polled = 1;
  65
  66     memcpy(fdl->work_fds, fdl->fds, sizeof(struct pollfd) * fdl->num_fds);
  67
  68     for (i = 0;i < fdl->num_fds;i++) {
  69         if (e == fdl->ios[i]) {
  70             if (events & PA_IO_EVENT_INPUT)
  71                 fdl->work_fds[i].revents |= POLLIN;
  72             if (events & PA_IO_EVENT_OUTPUT)
  73                 fdl->work_fds[i].revents |= POLLOUT;
  74             if (events & PA_IO_EVENT_ERROR)
  75                 fdl->work_fds[i].revents |= POLLERR;
  76             if (events & PA_IO_EVENT_HANGUP)
  77                 fdl->work_fds[i].revents |= POLLHUP;
  78             break;
  79         }
  80     }
  81
  82     assert(i != fdl->num_fds);
  83
  84     if (fdl->pcm)
  85         err = snd_pcm_poll_descriptors_revents(fdl->pcm, fdl->work_fds, fdl->num_fds, &revents);
  86     else
  87         err = snd_mixer_poll_descriptors_revents(fdl->mixer, fdl->work_fds, fdl->num_fds, &revents);
  88
  89     if (err < 0) {
  90         pa_log_error(__FILE__": Unable to get poll revent: %s",
  91             snd_strerror(err));
  92         return;
  93     }
  94
  95     if (revents) {
  96         if (fdl->pcm)
  97             fdl->cb(fdl->userdata);
  98         else
  99             snd_mixer_handle_events(fdl->mixer);
 100     }
 101
 102     a->defer_enable(fdl->defer, 1);
 103 }
 104
 105 static void defer_cb(pa_mainloop_api*a, PA_GCC_UNUSED pa_defer_event* e, void *userdata) {
 106     struct pa_alsa_fdlist *fdl = (struct pa_alsa_fdlist*)userdata;
 107     int num_fds, i, err;
 108     struct pollfd *temp;
 109
 110     assert(a && fdl && (fdl->pcm || fdl->mixer));
 111
 112     a->defer_enable(fdl->defer, 0);
 113
 114     if (fdl->pcm)
 115         num_fds = snd_pcm_poll_descriptors_count(fdl->pcm);
 116     else
 117         num_fds = snd_mixer_poll_descriptors_count(fdl->mixer);
 118     assert(num_fds > 0);
 119
 120     if (num_fds != fdl->num_fds) {
 121         if (fdl->fds)
 122             pa_xfree(fdl->fds);
 123         if (fdl->work_fds)
 124             pa_xfree(fdl->work_fds);
 125         fdl->fds = pa_xmalloc0(sizeof(struct pollfd) * num_fds);
 126         fdl->work_fds = pa_xmalloc(sizeof(struct pollfd) * num_fds);
 127     }
 128
 129     memset(fdl->work_fds, 0, sizeof(struct pollfd) * num_fds);
 130
 131     if (fdl->pcm)
 132         err = snd_pcm_poll_descriptors(fdl->pcm, fdl->work_fds, num_fds);
 133     else
 134         err = snd_mixer_poll_descriptors(fdl->mixer, fdl->work_fds, num_fds);
 135
 136     if (err < 0) {
 137         pa_log_error(__FILE__": Unable to get poll descriptors: %s",
 138             snd_strerror(err));
 139         return;
 140     }
 141
 142     fdl->polled = 0;
 143
 144     if (memcmp(fdl->fds, fdl->work_fds, sizeof(struct pollfd) * num_fds) == 0)
 145         return;
 146
 147     if (fdl->ios) {
 148         for (i = 0;i < fdl->num_fds;i++)
 149             a->io_free(fdl->ios[i]);
 150         if (num_fds != fdl->num_fds) {
 151             pa_xfree(fdl->ios);
 152             fdl->ios = pa_xmalloc(sizeof(pa_io_event*) * num_fds);
 153             assert(fdl->ios);
 154         }
 155     } else {
 156         fdl->ios = pa_xmalloc(sizeof(pa_io_event*) * num_fds);
 157         assert(fdl->ios);
 158     }
 159
 160     /* Swap pointers */
 161     temp = fdl->work_fds;
 162     fdl->work_fds = fdl->fds;
 163     fdl->fds = temp;
 164
 165     fdl->num_fds = num_fds;
 166
 167     for (i = 0;i < num_fds;i++) {
 168         fdl->ios[i] = a->io_new(a, fdl->fds[i].fd,
 169             ((fdl->fds[i].events & POLLIN) ? PA_IO_EVENT_INPUT : 0) |
 170             ((fdl->fds[i].events & POLLOUT) ? PA_IO_EVENT_OUTPUT : 0),
 171             io_cb, fdl);
 172         assert(fdl->ios[i]);
 173     }
 174 }
 175
 176 struct pa_alsa_fdlist *pa_alsa_fdlist_new(void) {
 177     struct pa_alsa_fdlist *fdl;
 178
 179     fdl = pa_xmalloc(sizeof(struct pa_alsa_fdlist));
 180     assert(fdl);
 181
 182     fdl->num_fds = 0;
 183     fdl->fds = NULL;
 184     fdl->work_fds = NULL;
 185
 186     fdl->pcm = NULL;
 187     fdl->mixer = NULL;
 188
 189     fdl->m = NULL;
 190     fdl->defer = NULL;
 191     fdl->ios = NULL;
 192
 193     fdl->polled = 0;
 194
 195     return fdl;
 196 }
 197
 198 void pa_alsa_fdlist_free(struct pa_alsa_fdlist *fdl) {
 199     assert(fdl);
 200
 201     if (fdl->defer) {
 202         assert(fdl->m);
 203         fdl->m->defer_free(fdl->defer);
 204     }
 205
 206     if (fdl->ios) {
 207         int i;
 208         assert(fdl->m);
 209         for (i = 0;i < fdl->num_fds;i++)
 210             fdl->m->io_free(fdl->ios[0]);
 211         pa_xfree(fdl->ios);
 212     }
 213
 214     if (fdl->fds)
 215         pa_xfree(fdl->fds);
 216     if (fdl->work_fds)
 217         pa_xfree(fdl->work_fds);
 218
 219     pa_xfree(fdl);
 220 }
 221
 222 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) {
 223     assert(fdl && pcm_handle && m && !fdl->m && cb);
 224
 225     fdl->pcm = pcm_handle;
 226     fdl->m = m;
 227
 228     fdl->defer = m->defer_new(m, defer_cb, fdl);
 229     assert(fdl->defer);
 230
 231     fdl->cb = cb;
 232     fdl->userdata = userdata;
 233
 234     return 0;
 235 }
 236
 237 int pa_alsa_fdlist_init_mixer(struct pa_alsa_fdlist *fdl, snd_mixer_t *mixer_handle, pa_mainloop_api* m) {
 238     assert(fdl && mixer_handle && m && !fdl->m);
 239
 240     fdl->mixer = mixer_handle;
 241     fdl->m = m;
 242
 243     fdl->defer = m->defer_new(m, defer_cb, fdl);
 244     assert(fdl->defer);
 245
 246     return 0;
 247 }
 248
 249 /* Set the hardware parameters of the given ALSA device. Returns the
 250  * selected fragment settings in *period and *period_size */
 251 int pa_alsa_set_hw_params(snd_pcm_t *pcm_handle, const pa_sample_spec *ss, uint32_t *periods, snd_pcm_uframes_t *period_size) {
 252     int ret = -1;
 253     snd_pcm_uframes_t buffer_size;
 254     snd_pcm_hw_params_t *hwparams = NULL;
 255     unsigned int r = ss->rate;
 256
 257     static const snd_pcm_format_t format_trans[] = {
 258         [PA_SAMPLE_U8] = SND_PCM_FORMAT_U8,
 259         [PA_SAMPLE_ALAW] = SND_PCM_FORMAT_A_LAW,
 260         [PA_SAMPLE_ULAW] = SND_PCM_FORMAT_MU_LAW,
 261         [PA_SAMPLE_S16LE] = SND_PCM_FORMAT_S16_LE,
 262         [PA_SAMPLE_S16BE] = SND_PCM_FORMAT_S16_BE,
 263         [PA_SAMPLE_FLOAT32LE] = SND_PCM_FORMAT_FLOAT_LE,
 264         [PA_SAMPLE_FLOAT32BE] = SND_PCM_FORMAT_FLOAT_BE,
 265     };
 266     assert(pcm_handle && ss && periods && period_size);
 267
 268     buffer_size = *periods * *period_size;
 269
 270     if ((ret = snd_pcm_hw_params_malloc(&hwparams)) < 0 ||
 271         (ret = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0 ||
 272         (ret = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0 ||
 273         (ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[ss->format])) < 0 ||
 274         (ret = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &r, NULL)) < 0 ||
 275         (ret = snd_pcm_hw_params_set_channels(pcm_handle, hwparams, ss->channels)) < 0 ||
 276         (*period_size > 0 && (ret = snd_pcm_hw_params_set_period_size_near(pcm_handle, hwparams, period_size, NULL)) < 0) ||
 277         (*periods > 0 && (ret = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hwparams, &buffer_size)) < 0) ||
 278         (ret = snd_pcm_hw_params(pcm_handle, hwparams)) < 0)
 279         goto finish;
 280
 281     if (ss->rate != r)
 282         pa_log_info(__FILE__": device doesn't support %u Hz, changed to %u Hz.", ss->rate, r);
 283
 284     if ((ret = snd_pcm_prepare(pcm_handle)) < 0)
 285         goto finish;
 286
 287     if ((ret = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size)) < 0 ||
 288         (ret = snd_pcm_hw_params_get_period_size(hwparams, period_size, NULL)) < 0)
 289         goto finish;
 290
 291     assert(buffer_size > 0);
 292     assert(*period_size > 0);
 293     *periods = buffer_size / *period_size;
 294     assert(*periods > 0);
 295
 296     ret = 0;
 297
 298 finish:
 299     if (hwparams)
 300         snd_pcm_hw_params_free(hwparams);
 301
 302     return ret;
 303 }
 304
 305 int pa_alsa_prepare_mixer(snd_mixer_t *mixer, const char *dev) {
 306     int err;
 307
 308     assert(mixer && dev);
 309
 310     if ((err = snd_mixer_attach(mixer, dev)) < 0) {
 311         pa_log_warn(__FILE__": Unable to attach to mixer %s: %s", dev, snd_strerror(err));
 312         return -1;
 313     }
 314
 315     if ((err = snd_mixer_selem_register(mixer, NULL, NULL)) < 0) {
 316         pa_log_warn(__FILE__": Unable to register mixer: %s", snd_strerror(err));
 317         return -1;
 318     }
 319
 320     if ((err = snd_mixer_load(mixer)) < 0) {
 321         pa_log_warn(__FILE__": Unable to load mixer: %s", snd_strerror(err));
 322         return -1;
 323     }
 324
 325     return 0;
 326 }
 327
 328 snd_mixer_elem_t *pa_alsa_find_elem(snd_mixer_t *mixer, const char *name) {
 329     snd_mixer_elem_t *elem;
 330     snd_mixer_selem_id_t *sid;
 331     snd_mixer_selem_id_alloca(&sid);
 332
 333     assert(mixer && name);
 334
 335     snd_mixer_selem_id_set_name(sid, name);
 336
 337     elem = snd_mixer_find_selem(mixer, sid);
 338     if (!elem)
 339         pa_log_warn(__FILE__": Cannot find mixer control %s", snd_mixer_selem_id_get_name(sid));
 340
 341     return elem;
 342 }
 343
 344 pa_channel_map* pa_alsa_channel_map_init_auto(pa_channel_map *m, unsigned channels) {
 345     assert(m);
 346     assert(channels > 0);
 347     assert(channels <= PA_CHANNELS_MAX);
 348
 349     pa_channel_map_init(m);
 350
 351     m->channels = channels;
 352
 353     /* The standard ALSA channel order */
 354
 355     switch (channels) {
 356         case 1:
 357             m->map[0] = PA_CHANNEL_POSITION_MONO;
 358             return m;
 359
 360         case 8:
 361             m->map[6] = PA_CHANNEL_POSITION_SIDE_LEFT;
 362             m->map[7] = PA_CHANNEL_POSITION_SIDE_RIGHT;
 363             /* Fall through */
 364
 365         case 6:
 366             m->map[5] = PA_CHANNEL_POSITION_LFE;
 367             /* Fall through */
 368
 369         case 5:
 370             m->map[4] = PA_CHANNEL_POSITION_FRONT_CENTER;
 371             /* Fall through */
 372
 373         case 4:
 374             m->map[2] = PA_CHANNEL_POSITION_REAR_LEFT;
 375             m->map[3] = PA_CHANNEL_POSITION_REAR_RIGHT;
 376             /* Fall through */
 377
 378         case 2:
 379             m->map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
 380             m->map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
 381             return m;
 382
 383         default:
 384             return NULL;
 385     }
 386 }