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("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_xstrdup(source->name);
 101         n = pa_sprintf_malloc("input-%s", source->name);
 102         t = pa_sprintf_malloc("Input %s", source->description);
 103     }
 104
 105     pa_log_info("Found output profile '%s'", t);
 106
 107     p = pa_card_profile_new(n, t, sizeof(struct profile_data));
 108
 109     pa_xfree(t);
 110     pa_xfree(n);
 111
 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 int pa__init(pa_module*m) {
 129     pa_card_new_data data;
 130     pa_modargs *ma;
 131     int alsa_card_index;
 132     struct userdata *u;
 133
 134     pa_alsa_redirect_errors_inc();
 135
 136     pa_assert(m);
 137
 138     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 139         pa_log("Failed to parse module arguments");
 140         goto fail;
 141     }
 142
 143     m->userdata = u = pa_xnew0(struct userdata, 1);
 144     u->core = m->core;
 145     u->module = m;
 146     u->device_id = pa_xstrdup(pa_modargs_get_value(ma, "device_id", DEFAULT_DEVICE_ID));
 147
 148     if ((alsa_card_index = snd_card_get_index(u->device_id)) < 0) {
 149         pa_log("Card '%s' doesn't exist: %s", u->device_id, snd_strerror(alsa_card_index));
 150         goto fail;
 151     }
 152
 153     pa_card_new_data_init(&data);
 154     data.driver = __FILE__;
 155     data.module = m;
 156     pa_alsa_init_proplist_card(data.proplist, alsa_card_index);
 157     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_id);
 158     pa_card_new_data_set_name(&data, pa_modargs_get_value(ma, "name", u->device_id));
 159
 160     data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 161     if (pa_alsa_probe_profiles(u->device_id, &m->core->default_sample_spec, enumerate_cb, data.profiles) < 0) {
 162         pa_card_new_data_done(&data);
 163         goto fail;
 164     }
 165
 166     u->card = pa_card_new(m->core, &data);
 167     pa_card_new_data_done(&data);
 168
 169     return 0;
 170
 171 fail:
 172
 173     if (ma)
 174         pa_modargs_free(ma);
 175
 176     pa__done(m);
 177     return -1;
 178 }
 179
 180 void pa__done(pa_module*m) {
 181     struct userdata *u;
 182
 183     pa_assert(m);
 184
 185     if (!(u = m->userdata))
 186         goto finish;
 187
 188     if (u->card)
 189         pa_card_free(u->card);
 190
 191     pa_xfree(u->device_id);
 192     pa_xfree(u);
 193
 194 finish:
 195     snd_config_update_free_global();
 196     pa_alsa_redirect_errors_dec();
 197 }