code.delx.au - pulseaudio/blob - src/modules/bluetooth/module-bluetooth-policy.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2006 Lennart Poettering
   5   Copyright 2009 Canonical Ltd
   6   Copyright (C) 2012 Intel Corporation
   7
   8   PulseAudio is free software; you can redistribute it and/or modify
   9   it under the terms of the GNU Lesser General Public License as published
  10   by the Free Software Foundation; either version 2.1 of the License,
  11   or (at your option) any later version.
  12
  13   PulseAudio is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with PulseAudio; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21   USA.
  22 ***/
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <pulse/xmalloc.h>
  29
  30 #include <pulsecore/core.h>
  31 #include <pulsecore/modargs.h>
  32 #include <pulsecore/source-output.h>
  33 #include <pulsecore/source.h>
  34 #include <pulsecore/core-util.h>
  35
  36 #include "module-bluetooth-policy-symdef.h"
  37
  38 PA_MODULE_AUTHOR("Frédéric Dalleau");
  39 PA_MODULE_DESCRIPTION("When a bluetooth sink or source is added, load module-loopback");
  40 PA_MODULE_VERSION(PACKAGE_VERSION);
  41 PA_MODULE_LOAD_ONCE(TRUE);
  42 PA_MODULE_USAGE(
  43         "a2dp_source=<Handle a2dp_source card profile (sink role)?> "
  44         "hfgw=<Handle hfgw card profile (headset role)?>");
  45
  46 static const char* const valid_modargs[] = {
  47     "a2dp_source",
  48     "hfgw",
  49     NULL
  50 };
  51
  52 struct userdata {
  53     bool enable_a2dp_source;
  54     bool enable_hfgw;
  55     pa_hook_slot *source_put_slot;
  56     pa_hook_slot *sink_put_slot;
  57     pa_hook_slot *port_available_changed_slot;
  58 };
  59
  60 /* When a source is created, loopback it to default sink */
  61 static pa_hook_result_t source_put_hook_callback(pa_core *c, pa_source *source, void *userdata) {
  62     struct userdata *u = userdata;
  63     const char *s;
  64     const char *role;
  65     char *args;
  66
  67     pa_assert(c);
  68     pa_assert(source);
  69
  70     /* Only consider bluetooth sinks and sources */
  71     s = pa_proplist_gets(source->proplist, PA_PROP_DEVICE_BUS);
  72     if (!s)
  73         return PA_HOOK_OK;
  74
  75     if (!pa_streq(s, "bluetooth"))
  76         return PA_HOOK_OK;
  77
  78     s = pa_proplist_gets(source->proplist, "bluetooth.protocol");
  79     if (!s)
  80         return PA_HOOK_OK;
  81
  82     if (u->enable_a2dp_source && pa_streq(s, "a2dp_source")) /* A2DP profile (we're doing sink role) */
  83         role = "music";
  84     else if (u->enable_hfgw && pa_streq(s, "hfgw")) /* HFP profile (we're doing headset role) */
  85         role = "phone";
  86     else {
  87         pa_log_debug("Profile %s cannot be selected for loopback", s);
  88         return PA_HOOK_OK;
  89     }
  90
  91     /* Load module-loopback */
  92     args = pa_sprintf_malloc("source=\"%s\" source_dont_move=\"true\" sink_input_properties=\"media.role=%s\"", source->name, role);
  93     (void) pa_module_load(c, "module-loopback", args);
  94     pa_xfree(args);
  95
  96     return PA_HOOK_OK;
  97 }
  98
  99 /* When a sink is created, loopback it to default source */
 100 static pa_hook_result_t sink_put_hook_callback(pa_core *c, pa_sink *sink, void *userdata) {
 101     struct userdata *u = userdata;
 102     const char *s;
 103     const char *role;
 104     char *args;
 105
 106     pa_assert(c);
 107     pa_assert(sink);
 108
 109     /* Only consider bluetooth sinks and sources */
 110     s = pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_BUS);
 111     if (!s)
 112         return PA_HOOK_OK;
 113
 114     if (!pa_streq(s, "bluetooth"))
 115         return PA_HOOK_OK;
 116
 117     s = pa_proplist_gets(sink->proplist, "bluetooth.protocol");
 118     if (!s)
 119         return PA_HOOK_OK;
 120
 121     if (u->enable_hfgw && pa_streq(s, "hfgw")) /* HFP profile (we're doing headset role) */
 122         role = "phone";
 123     else {
 124         pa_log_debug("Profile %s cannot be selected for loopback", s);
 125         return PA_HOOK_OK;
 126     }
 127
 128     /* Load module-loopback */
 129     args = pa_sprintf_malloc("sink=\"%s\" sink_dont_move=\"true\" source_output_properties=\"media.role=%s\"", sink->name, role);
 130     (void) pa_module_load(c, "module-loopback", args);
 131     pa_xfree(args);
 132
 133     return PA_HOOK_OK;
 134 }
 135
 136 static pa_device_port* find_best_port(pa_hashmap *ports) {
 137     void *state;
 138     pa_device_port *port;
 139     pa_device_port *result = NULL;
 140
 141     PA_HASHMAP_FOREACH(port, ports, state) {
 142         if (port->available != PA_PORT_AVAILABLE_YES)
 143             continue;
 144
 145         if (result == NULL || port->priority > result->priority)
 146             result = port;
 147     }
 148
 149     return result;
 150 }
 151
 152 static void set_port_profile(pa_card *card, pa_device_port *port) {
 153     void *state;
 154     pa_card_profile *profile;
 155
 156     PA_HASHMAP_FOREACH(profile, port->profiles, state) {
 157         if (card->active_profile == profile)
 158             return;
 159
 160         pa_log_debug("Setting card '%s' to profile '%s'", card->name, profile->name);
 161
 162         if (pa_card_set_profile(card, profile->name, FALSE) != 0)
 163             pa_log_warn("Could not set profile '%s'", profile->name);
 164
 165         return;
 166     }
 167 }
 168
 169 static pa_hook_result_t port_available_hook_callback(pa_core *c, pa_device_port *port, void *userdata) {
 170     pa_card *card;
 171     const char *s;
 172     uint32_t state;
 173     pa_bool_t is_active_profile;
 174     pa_device_port *port2;
 175
 176     PA_IDXSET_FOREACH(card, c->cards, state)
 177         if (port == pa_hashmap_get(card->ports, port->name))
 178             break;
 179
 180     if (!card) {
 181         pa_log_warn("Did not find port %s in array of cards", port->name);
 182         return PA_HOOK_OK;
 183     }
 184
 185     /* Only consider bluetooth cards */
 186     s = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_BUS);
 187     if (!s || !pa_streq(s, "bluetooth"))
 188         return PA_HOOK_OK;
 189
 190     is_active_profile = card->active_profile == pa_hashmap_get(port->profiles, card->active_profile->name);
 191
 192     if (is_active_profile && port->available == PA_PORT_AVAILABLE_YES)
 193         return PA_HOOK_OK;
 194
 195     if (!is_active_profile && port->available != PA_PORT_AVAILABLE_YES)
 196         return PA_HOOK_OK;
 197
 198     if ((port2 = find_best_port(card->ports)) == NULL)
 199         return PA_HOOK_OK;
 200
 201     set_port_profile(card, port2);
 202
 203     return PA_HOOK_OK;
 204 }
 205
 206 static void handle_all_ports(pa_core *core) {
 207     pa_card *card;
 208     uint32_t state;
 209
 210     PA_IDXSET_FOREACH(card, core->cards, state) {
 211         pa_device_port *port;
 212         void *state2;
 213
 214         PA_HASHMAP_FOREACH(port, card->ports, state2)
 215             port_available_hook_callback(core, port, NULL);
 216     }
 217 }
 218
 219 int pa__init(pa_module *m) {
 220     pa_modargs *ma;
 221     struct userdata *u;
 222
 223     pa_assert(m);
 224
 225     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 226         pa_log_error("Failed to parse module arguments");
 227         return -1;
 228     }
 229
 230     m->userdata = u = pa_xnew0(struct userdata, 1);
 231
 232     u->enable_a2dp_source = TRUE;
 233     if (pa_modargs_get_value_boolean(ma, "a2dp_source", &u->enable_a2dp_source) < 0) {
 234         pa_log("Failed to parse a2dp_source argument.");
 235         goto fail;
 236     }
 237
 238     u->enable_hfgw = TRUE;
 239     if (pa_modargs_get_value_boolean(ma, "hfgw", &u->enable_hfgw) < 0) {
 240         pa_log("Failed to parse hfgw argument.");
 241         goto fail;
 242     }
 243
 244     u->source_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], PA_HOOK_NORMAL, (pa_hook_cb_t) source_put_hook_callback, u);
 245
 246     u->sink_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_put_hook_callback, u);
 247
 248     u->port_available_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_PORT_AVAILABLE_CHANGED],
 249                                        PA_HOOK_NORMAL, (pa_hook_cb_t) port_available_hook_callback, u);
 250
 251     handle_all_ports(m->core);
 252
 253     pa_modargs_free(ma);
 254     return 0;
 255
 256 fail:
 257     pa_modargs_free(ma);
 258     return -1;
 259 }
 260
 261 void pa__done(pa_module *m) {
 262     struct userdata *u;
 263
 264     pa_assert(m);
 265
 266     if (!(u = m->userdata))
 267         return;
 268
 269     if (u->source_put_slot)
 270         pa_hook_slot_free(u->source_put_slot);
 271
 272     if (u->sink_put_slot)
 273         pa_hook_slot_free(u->sink_put_slot);
 274
 275     if (u->port_available_changed_slot)
 276         pa_hook_slot_free(u->port_available_changed_slot);
 277
 278     pa_xfree(u);
 279 }