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("output-%s+input-%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_sprintf_malloc("output-%s", sink->name);
  97         t = pa_sprintf_malloc("Output %s", sink->description);
  98     } else {
  99         pa_assert(source);
 100         n = pa_sprintf_malloc("input-%s", 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->priority = (sink ? sink->priority : 0)*100 + (source ? source->priority : 0);
 112     p->n_sinks = !!sink;
 113     p->n_sources = !!source;
 114
 115     if (sink)
 116         p->max_sink_channels = sink->map.channels;
 117     if (source)
 118         p->max_source_channels = source->map.channels;
 119
 120     d = PA_CARD_PROFILE_DATA(p);
 121
 122     d->sink = sink;
 123     d->source = source;
 124
 125     pa_hashmap_put(profiles, p->name, p);
 126 }
 127
 128 static void add_disabled_profile(pa_hashmap *profiles) {
 129     pa_card_profile *p;
 130     struct profile_data *d;
 131
 132     p = pa_card_profile_new("off", "Off", sizeof(struct profile_data));
 133
 134     d = PA_CARD_PROFILE_DATA(p);
 135     d->sink = d->source = NULL;
 136
 137     pa_hashmap_put(profiles, p->name, p);
 138 }
 139
 140 int pa__init(pa_module*m) {
 141     pa_card_new_data data;
 142     pa_modargs *ma;
 143     int alsa_card_index;
 144     struct userdata *u;
 145
 146     pa_alsa_redirect_errors_inc();
 147
 148     pa_assert(m);
 149
 150     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 151         pa_log("Failed to parse module arguments");
 152         goto fail;
 153     }
 154
 155     m->userdata = u = pa_xnew0(struct userdata, 1);
 156     u->core = m->core;
 157     u->module = m;
 158     u->device_id = pa_xstrdup(pa_modargs_get_value(ma, "device_id", DEFAULT_DEVICE_ID));
 159
 160     if ((alsa_card_index = snd_card_get_index(u->device_id)) < 0) {
 161         pa_log("Card '%s' doesn't exist: %s", u->device_id, snd_strerror(alsa_card_index));
 162         goto fail;
 163     }
 164
 165     pa_card_new_data_init(&data);
 166     data.driver = __FILE__;
 167     data.module = m;
 168     pa_alsa_init_proplist_card(data.proplist, alsa_card_index);
 169     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_id);
 170     pa_card_new_data_set_name(&data, pa_modargs_get_value(ma, "name", u->device_id));
 171
 172     data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 173     if (pa_alsa_probe_profiles(u->device_id, &m->core->default_sample_spec, enumerate_cb, data.profiles) < 0) {
 174         pa_card_new_data_done(&data);
 175         goto fail;
 176     }
 177
 178     if (pa_hashmap_isempty(data.profiles)) {
 179         pa_log("Failed to find a working profile.");
 180         pa_card_new_data_done(&data);
 181         goto fail;
 182     }
 183
 184     add_disabled_profile(data.profiles);
 185
 186     u->card = pa_card_new(m->core, &data);
 187     pa_card_new_data_done(&data);
 188
 189     return 0;
 190
 191 fail:
 192
 193     if (ma)
 194         pa_modargs_free(ma);
 195
 196     pa__done(m);
 197     return -1;
 198 }
 199
 200 void pa__done(pa_module*m) {
 201     struct userdata *u;
 202
 203     pa_assert(m);
 204
 205     if (!(u = m->userdata))
 206         goto finish;
 207
 208     if (u->card)
 209         pa_card_free(u->card);
 210
 211     pa_xfree(u->device_id);
 212     pa_xfree(u);
 213
 214 finish:
 215     snd_config_update_free_global();
 216     pa_alsa_redirect_errors_dec();
 217 }