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

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2009 Lennart Poettering
   5
   6   PulseAudio 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   PulseAudio 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 PulseAudio; 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 <pulse/xmalloc.h>
  27 #include <pulsecore/core-util.h>
  28 #include <pulsecore/modargs.h>
  29
  30 #include "alsa-util.h"
  31 #include "module-alsa-card-symdef.h"
  32
  33 PA_MODULE_AUTHOR("Lennart Poettering");
  34 PA_MODULE_DESCRIPTION("ALSA Card");
  35 PA_MODULE_VERSION(PACKAGE_VERSION);
  36 PA_MODULE_LOAD_ONCE(FALSE);
  37 PA_MODULE_USAGE(
  38         "name=<name for the sink/source> "
  39         "device_id=<ALSA card index> "
  40         "format=<sample format> "
  41         "rate=<sample rate> "
  42         "fragments=<number of fragments> "
  43         "fragment_size=<fragment size> "
  44         "mmap=<enable memory mapping?> "
  45         "tsched=<enable system timer based scheduling mode?> "
  46         "tsched_buffer_size=<buffer size when using timer based scheduling> "
  47         "tsched_buffer_watermark=<lower fill watermark> "
  48         "profile=<profile name>");
  49
  50 static const char* const valid_modargs[] = {
  51     "sink_name",
  52     "device",
  53     "device_id",
  54     "format",
  55     "rate",
  56     "channels",
  57     "channel_map",
  58     "fragments",
  59     "fragment_size",
  60     "mmap",
  61     "tsched",
  62     "tsched_buffer_size",
  63     "tsched_buffer_watermark",
  64     NULL
  65 };
  66
  67 #define DEFAULT_DEVICE_ID "0"
  68
  69 struct userdata {
  70     pa_core *core;
  71     pa_module *module;
  72
  73     char *device_id;
  74
  75     pa_card *card;
  76 };
  77
  78 struct profile_data {
  79     const pa_alsa_profile_info *sink, *source;
  80 };
  81
  82 static void enumerate_cb(
  83         const pa_alsa_profile_info *sink,
  84         const pa_alsa_profile_info *source,
  85         void *userdata) {
  86
  87     pa_hashmap *profiles = (pa_hashmap *) userdata;
  88     char *t, *n;
  89     pa_card_profile *p;
  90     struct profile_data *d;
  91
  92     if (sink && source) {
  93         n = pa_sprintf_malloc("%s+%s", sink->name, source->name);
  94         t = pa_sprintf_malloc("Output %s + Input %s", sink->description, source->description);
  95     } else if (sink) {
  96         n = pa_xstrdup(sink->name);
  97         t = pa_sprintf_malloc("Output %s", sink->description);
  98     } else {
  99         pa_assert(source);
 100         n = pa_xstrdup(source->name);
 101         t = pa_sprintf_malloc("Input %s", source->description);
 102     }
 103
 104     pa_log_info("Found output profile '%s'", t);
 105
 106     p = pa_card_profile_new(n, t, sizeof(struct profile_data));
 107
 108     pa_xfree(t);
 109     pa_xfree(n);
 110
 111     p->n_sinks = !!sink;
 112     p->n_sources = !!source;
 113
 114     if (sink)
 115         p->max_sink_channels = sink->map.channels;
 116     if (source)
 117         p->max_source_channels = source->map.channels;
 118
 119     d = PA_CARD_PROFILE_DATA(p);
 120
 121     d->sink = sink;
 122     d->source = source;
 123
 124     pa_hashmap_put(profiles, p->name, p);
 125 }
 126
 127 int pa__init(pa_module*m) {
 128     pa_card_new_data data;
 129     pa_modargs *ma;
 130     int alsa_card_index;
 131     struct userdata *u;
 132
 133     pa_alsa_redirect_errors_inc();
 134
 135     pa_assert(m);
 136
 137     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 138         pa_log("Failed to parse module arguments");
 139         goto fail;
 140     }
 141
 142     m->userdata = u = pa_xnew0(struct userdata, 1);
 143     u->core = m->core;
 144     u->module = m;
 145     u->device_id = pa_xstrdup(pa_modargs_get_value(ma, "device_id", DEFAULT_DEVICE_ID));
 146
 147     if ((alsa_card_index = snd_card_get_index(u->device_id)) < 0) {
 148         pa_log("Card '%s' doesn't exist: %s", u->device_id, snd_strerror(alsa_card_index));
 149         goto fail;
 150     }
 151
 152     pa_card_new_data_init(&data);
 153     data.driver = __FILE__;
 154     data.module = m;
 155     pa_alsa_init_proplist_card(data.proplist, alsa_card_index);
 156     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_id);
 157     pa_card_new_data_set_name(&data, pa_modargs_get_value(ma, "name", u->device_id));
 158
 159     data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 160     if (pa_alsa_probe_profiles(u->device_id, &m->core->default_sample_spec, enumerate_cb, data.profiles) < 0) {
 161         pa_card_new_data_done(&data);
 162         goto fail;
 163     }
 164
 165     u->card = pa_card_new(m->core, &data);
 166     pa_card_new_data_done(&data);
 167
 168     return 0;
 169
 170 fail:
 171
 172     if (ma)
 173         pa_modargs_free(ma);
 174
 175     pa__done(m);
 176     return -1;
 177 }
 178
 179 void pa__done(pa_module*m) {
 180     struct userdata *u;
 181
 182     pa_assert(m);
 183
 184     if (!(u = m->userdata))
 185         goto finish;
 186
 187     if (u->card)
 188         pa_card_free(u->card);
 189
 190     pa_xfree(u->device_id);
 191     pa_xfree(u);
 192
 193 finish:
 194     snd_config_update_free_global();
 195     pa_alsa_redirect_errors_dec();
 196 }