diff options
Diffstat (limited to 'spa/plugins/bluez5/bluez5-device.c')
| -rw-r--r-- | spa/plugins/bluez5/bluez5-device.c | 2398 |
1 files changed, 2398 insertions, 0 deletions
diff --git a/spa/plugins/bluez5/bluez5-device.c b/spa/plugins/bluez5/bluez5-device.c new file mode 100644 index 0000000..dcdfeaf --- /dev/null +++ b/spa/plugins/bluez5/bluez5-device.c @@ -0,0 +1,2398 @@ +/* Spa Bluez5 Device + * + * Copyright © 2018 Wim Taymans + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include <stddef.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <poll.h> +#include <errno.h> + +#include <spa/support/log.h> +#include <spa/utils/type.h> +#include <spa/utils/keys.h> +#include <spa/utils/names.h> +#include <spa/utils/string.h> +#include <spa/node/node.h> +#include <spa/support/loop.h> +#include <spa/support/plugin.h> +#include <spa/support/i18n.h> +#include <spa/monitor/device.h> +#include <spa/monitor/utils.h> +#include <spa/monitor/event.h> +#include <spa/pod/filter.h> +#include <spa/pod/parser.h> +#include <spa/param/param.h> +#include <spa/param/audio/raw.h> +#include <spa/param/bluetooth/audio.h> +#include <spa/param/bluetooth/type-info.h> +#include <spa/debug/pod.h> +#include <spa/debug/log.h> + +#include "defs.h" +#include "media-codecs.h" + +static struct spa_log_topic log_topic = SPA_LOG_TOPIC(0, "spa.bluez5.device"); +#undef SPA_LOG_TOPIC_DEFAULT +#define SPA_LOG_TOPIC_DEFAULT &log_topic + +#define MAX_DEVICES 64 + +#define DEVICE_ID_SOURCE 0 +#define DEVICE_ID_SINK 1 +#define DYNAMIC_NODE_ID_FLAG 0x1000 + +static struct spa_i18n *_i18n; + +#define _(_str) spa_i18n_text(_i18n,(_str)) +#define N_(_str) (_str) + +enum { + DEVICE_PROFILE_OFF = 0, + DEVICE_PROFILE_AG = 1, + DEVICE_PROFILE_A2DP = 2, + DEVICE_PROFILE_HSP_HFP = 3, + DEVICE_PROFILE_BAP = 4, + DEVICE_PROFILE_LAST = DEVICE_PROFILE_BAP, +}; + +struct props { + enum spa_bluetooth_audio_codec codec; + bool offload_active; +}; + +static void reset_props(struct props *props) +{ + props->codec = 0; + props->offload_active = false; +} + +struct impl; + +struct node { + struct impl *impl; + struct spa_bt_transport *transport; + struct spa_hook transport_listener; + uint32_t id; + unsigned int active:1; + unsigned int mute:1; + unsigned int save:1; + unsigned int a2dp_duplex:1; + unsigned int offload_acquired:1; + uint32_t n_channels; + int64_t latency_offset; + uint32_t channels[SPA_AUDIO_MAX_CHANNELS]; + float volumes[SPA_AUDIO_MAX_CHANNELS]; + float soft_volumes[SPA_AUDIO_MAX_CHANNELS]; +}; + +struct dynamic_node +{ + struct impl *impl; + struct spa_bt_transport *transport; + struct spa_hook transport_listener; + uint32_t id; + const char *factory_name; + bool a2dp_duplex; +}; + +struct impl { + struct spa_handle handle; + struct spa_device device; + + struct spa_log *log; + + uint32_t info_all; + struct spa_device_info info; +#define IDX_EnumProfile 0 +#define IDX_Profile 1 +#define IDX_EnumRoute 2 +#define IDX_Route 3 +#define IDX_PropInfo 4 +#define IDX_Props 5 + struct spa_param_info params[6]; + + struct spa_hook_list hooks; + + struct props props; + + struct spa_bt_device *bt_dev; + struct spa_hook bt_dev_listener; + + uint32_t profile; + unsigned int switching_codec:1; + unsigned int save_profile:1; + uint32_t prev_bt_connected_profiles; + + const struct media_codec **supported_codecs; + size_t supported_codec_count; + + struct dynamic_node dyn_media_source; + struct dynamic_node dyn_media_sink; + struct dynamic_node dyn_sco_source; + struct dynamic_node dyn_sco_sink; + +#define MAX_SETTINGS 32 + struct spa_dict_item setting_items[MAX_SETTINGS]; + struct spa_dict setting_dict; + + struct node nodes[2]; +}; + +static void init_node(struct impl *this, struct node *node, uint32_t id) +{ + uint32_t i; + + spa_zero(*node); + node->id = id; + for (i = 0; i < SPA_AUDIO_MAX_CHANNELS; i++) { + node->volumes[i] = 1.0f; + node->soft_volumes[i] = 1.0f; + } +} + +static void get_media_codecs(struct impl *this, enum spa_bluetooth_audio_codec id, const struct media_codec **codecs, size_t size) +{ + const struct media_codec * const *c; + + spa_assert(size > 0); + spa_assert(this->supported_codecs); + + for (c = this->supported_codecs; *c && size > 1; ++c) { + if ((*c)->id == id || id == 0) { + *codecs++ = *c; + --size; + } + } + + *codecs = NULL; +} + +static const struct media_codec *get_supported_media_codec(struct impl *this, enum spa_bluetooth_audio_codec id, size_t *idx) +{ + const struct media_codec *media_codec = NULL; + size_t i; + for (i = 0; i < this->supported_codec_count; ++i) { + if (this->supported_codecs[i]->id == id) { + media_codec = this->supported_codecs[i]; + if (idx) + *idx = i; + } + } + return media_codec; +} + +static unsigned int get_hfp_codec(enum spa_bluetooth_audio_codec id) +{ + switch (id) { + case SPA_BLUETOOTH_AUDIO_CODEC_CVSD: + return HFP_AUDIO_CODEC_CVSD; + case SPA_BLUETOOTH_AUDIO_CODEC_MSBC: + return HFP_AUDIO_CODEC_MSBC; + default: + return 0; + } +} + +static enum spa_bluetooth_audio_codec get_hfp_codec_id(unsigned int codec) +{ + switch (codec) { + case HFP_AUDIO_CODEC_MSBC: + return SPA_BLUETOOTH_AUDIO_CODEC_MSBC; + case HFP_AUDIO_CODEC_CVSD: + return SPA_BLUETOOTH_AUDIO_CODEC_CVSD; + } + return SPA_ID_INVALID; +} + +static const char *get_hfp_codec_description(unsigned int codec) +{ + switch (codec) { + case HFP_AUDIO_CODEC_MSBC: + return "mSBC"; + case HFP_AUDIO_CODEC_CVSD: + return "CVSD"; + } + return "unknown"; +} + +static const char *get_hfp_codec_name(unsigned int codec) +{ + switch (codec) { + case HFP_AUDIO_CODEC_MSBC: + return "msbc"; + case HFP_AUDIO_CODEC_CVSD: + return "cvsd"; + } + return "unknown"; +} + +static const char *get_codec_name(struct spa_bt_transport *t, bool a2dp_duplex) +{ + if (t->media_codec != NULL) { + if (a2dp_duplex && t->media_codec->duplex_codec) + return t->media_codec->duplex_codec->name; + return t->media_codec->name; + } + return get_hfp_codec_name(t->codec); +} + +static void transport_destroy(void *userdata) +{ + struct node *node = userdata; + node->transport = NULL; +} + +static void emit_node_props(struct impl *this, struct node *node, bool full) +{ + struct spa_event *event; + uint8_t buffer[4096]; + struct spa_pod_builder b = { 0 }; + struct spa_pod_frame f[1]; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + spa_pod_builder_push_object(&b, &f[0], + SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ObjectConfig); + spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Object, 0); + spa_pod_builder_int(&b, node->id); + spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0); + spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props, + SPA_PROP_channelVolumes, SPA_POD_Array(sizeof(float), + SPA_TYPE_Float, node->n_channels, node->volumes), + SPA_PROP_softVolumes, SPA_POD_Array(sizeof(float), + SPA_TYPE_Float, node->n_channels, node->soft_volumes), + SPA_PROP_channelMap, SPA_POD_Array(sizeof(uint32_t), + SPA_TYPE_Id, node->n_channels, node->channels)); + if (full) { + spa_pod_builder_add(&b, + SPA_PROP_mute, SPA_POD_Bool(node->mute), + SPA_PROP_softMute, SPA_POD_Bool(node->mute), + SPA_PROP_latencyOffsetNsec, SPA_POD_Long(node->latency_offset), + 0); + } + event = spa_pod_builder_pop(&b, &f[0]); + + spa_device_emit_event(&this->hooks, event); +} + +static void emit_volume(struct impl *this, struct node *node) +{ + emit_node_props(this, node, false); +} + +static void emit_info(struct impl *this, bool full); + +static float get_soft_volume_boost(struct node *node) +{ + const struct media_codec *codec = node->transport ? node->transport->media_codec : NULL; + + /* + * For A2DP duplex, the duplex microphone channel sometimes does not appear + * to have hardware gain, and input volume is very low. + * + * Work around this by boosting the software volume level, i.e. adjust + * the scale on the user-visible volume control to something more sensible. + * If this causes clipping, the user can just reduce the mic volume to + * bring SW gain below 1. + */ + if (node->a2dp_duplex && node->transport && codec && codec->info && + spa_atob(spa_dict_lookup(codec->info, "duplex.boost")) && + node->id == DEVICE_ID_SOURCE && + !node->transport->volumes[SPA_BT_VOLUME_ID_RX].active) + return 10.0f; /* 20 dB boost */ + + /* In all other cases, no boost */ + return 1.0f; +} + +static float node_get_hw_volume(struct node *node) +{ + uint32_t i; + float hw_volume = 0.0f; + for (i = 0; i < node->n_channels; i++) + hw_volume = SPA_MAX(node->volumes[i], hw_volume); + return SPA_MIN(hw_volume, 1.0f); +} + +static void node_update_soft_volumes(struct node *node, float hw_volume) +{ + for (uint32_t i = 0; i < node->n_channels; ++i) { + node->soft_volumes[i] = hw_volume > 0.0f + ? node->volumes[i] / hw_volume + : 0.0f; + } +} + +static bool node_update_volume_from_transport(struct node *node, bool reset) +{ + struct impl *impl = node->impl; + struct spa_bt_transport_volume *t_volume; + float prev_hw_volume; + + if (!node->transport || !spa_bt_transport_volume_enabled(node->transport)) + return false; + + /* PW is the controller for remote device. */ + if (impl->profile != DEVICE_PROFILE_A2DP + && impl->profile != DEVICE_PROFILE_BAP + && impl->profile != DEVICE_PROFILE_HSP_HFP) + return false; + + t_volume = &node->transport->volumes[node->id]; + + if (!t_volume->active) + return false; + + prev_hw_volume = node_get_hw_volume(node); + + if (!reset) { + for (uint32_t i = 0; i < node->n_channels; ++i) { + node->volumes[i] = prev_hw_volume > 0.0f + ? node->volumes[i] * t_volume->volume / prev_hw_volume + : t_volume->volume; + } + } else { + for (uint32_t i = 0; i < node->n_channels; ++i) + node->volumes[i] = t_volume->volume; + } + + node_update_soft_volumes(node, t_volume->volume); + + /* + * Consider volume changes from the headset as requested + * by the user, and to be saved by the SM. + */ + node->save = true; + + return true; +} + +static void volume_changed(void *userdata) +{ + struct node *node = userdata; + struct impl *impl = node->impl; + + if (!node_update_volume_from_transport(node, false)) + return; + + emit_volume(impl, node); + + impl->info.change_mask |= SPA_DEVICE_CHANGE_MASK_PARAMS; + impl->params[IDX_Route].flags ^= SPA_PARAM_INFO_SERIAL; + emit_info(impl, false); +} + +static const struct spa_bt_transport_events transport_events = { + SPA_VERSION_BT_DEVICE_EVENTS, + .destroy = transport_destroy, + .volume_changed = volume_changed, +}; + +static int node_offload_set_active(struct node *node, bool active) +{ + int res = 0; + + if (node->transport == NULL || !node->active) + return -ENOTSUP; + + if (active && !node->offload_acquired) + res = spa_bt_transport_acquire(node->transport, false); + else if (!active && node->offload_acquired) + res = spa_bt_transport_release(node->transport); + + if (res >= 0) + node->offload_acquired = active; + + return res; +} + +static void get_channels(struct spa_bt_transport *t, bool a2dp_duplex, uint32_t *n_channels, uint32_t *channels) +{ + const struct media_codec *codec; + struct spa_audio_info info = { 0 }; + + if (!a2dp_duplex || !t->media_codec || !t->media_codec->duplex_codec) { + *n_channels = t->n_channels; + memcpy(channels, t->channels, t->n_channels * sizeof(uint32_t)); + return; + } + + codec = t->media_codec->duplex_codec; + + if (!codec->validate_config || + codec->validate_config(codec, 0, + t->configuration, t->configuration_len, + &info) < 0) { + *n_channels = 1; + channels[0] = SPA_AUDIO_CHANNEL_MONO; + return; + } + + *n_channels = info.info.raw.channels; + memcpy(channels, info.info.raw.position, + info.info.raw.channels * sizeof(uint32_t)); +} + +static void emit_node(struct impl *this, struct spa_bt_transport *t, + uint32_t id, const char *factory_name, bool a2dp_duplex) +{ + struct spa_bt_device *device = this->bt_dev; + struct spa_device_object_info info; + struct spa_dict_item items[8]; + uint32_t n_items = 0; + char transport[32], str_id[32]; + bool is_dyn_node = SPA_FLAG_IS_SET(id, DYNAMIC_NODE_ID_FLAG); + + snprintf(transport, sizeof(transport), "pointer:%p", t); + items[0] = SPA_DICT_ITEM_INIT(SPA_KEY_API_BLUEZ5_TRANSPORT, transport); + items[1] = SPA_DICT_ITEM_INIT(SPA_KEY_API_BLUEZ5_PROFILE, spa_bt_profile_name(t->profile)); + items[2] = SPA_DICT_ITEM_INIT(SPA_KEY_API_BLUEZ5_CODEC, get_codec_name(t, a2dp_duplex)); + items[3] = SPA_DICT_ITEM_INIT(SPA_KEY_API_BLUEZ5_ADDRESS, device->address); + items[4] = SPA_DICT_ITEM_INIT("device.routes", "1"); + n_items = 5; + if (!is_dyn_node) { + snprintf(str_id, sizeof(str_id), "%d", id); + items[5] = SPA_DICT_ITEM_INIT("card.profile.device", str_id); + n_items++; + } + if (spa_streq(spa_bt_profile_name(t->profile), "headset-head-unit")) { + items[n_items] = SPA_DICT_ITEM_INIT("device.intended-roles", "Communication"); + n_items++; + } + if (a2dp_duplex) { + items[n_items] = SPA_DICT_ITEM_INIT("api.bluez5.a2dp-duplex", "true"); + n_items++; + } + + info = SPA_DEVICE_OBJECT_INFO_INIT(); + info.type = SPA_TYPE_INTERFACE_Node; + info.factory_name = factory_name; + info.change_mask = SPA_DEVICE_OBJECT_CHANGE_MASK_PROPS; + info.props = &SPA_DICT_INIT(items, n_items); + + SPA_FLAG_CLEAR(id, DYNAMIC_NODE_ID_FLAG); + spa_device_emit_object_info(&this->hooks, id, &info); + + if (!is_dyn_node) { + uint32_t prev_channels = this->nodes[id].n_channels; + float boost; + + this->nodes[id].impl = this; + this->nodes[id].active = true; + this->nodes[id].offload_acquired = false; + this->nodes[id].a2dp_duplex = a2dp_duplex; + get_channels(t, a2dp_duplex, &this->nodes[id].n_channels, this->nodes[id].channels); + if (this->nodes[id].transport) + spa_hook_remove(&this->nodes[id].transport_listener); + this->nodes[id].transport = t; + spa_bt_transport_add_listener(t, &this->nodes[id].transport_listener, &transport_events, &this->nodes[id]); + + if (prev_channels > 0) { + size_t i; + /* + * Spread mono volume to all channels, if we had switched HFP -> A2DP. + * XXX: we should also use different route for hfp and a2dp + */ + for (i = prev_channels; i < this->nodes[id].n_channels; ++i) + this->nodes[id].volumes[i] = this->nodes[id].volumes[i % prev_channels]; + } + + node_update_volume_from_transport(&this->nodes[id], true); + + boost = get_soft_volume_boost(&this->nodes[id]); + if (boost != 1.0f) { + size_t i; + for (i = 0; i < this->nodes[id].n_channels; ++i) + this->nodes[id].soft_volumes[i] = this->nodes[id].volumes[i] * boost; + } + + emit_node_props(this, &this->nodes[id], true); + } +} + +static struct spa_bt_transport *find_transport(struct impl *this, int profile, enum spa_bluetooth_audio_codec codec) +{ + struct spa_bt_device *device = this->bt_dev; + struct spa_bt_transport *t; + + spa_list_for_each(t, &device->transport_list, device_link) { + bool codec_ok = codec == 0 || + (t->media_codec != NULL && t->media_codec->id == codec) || + get_hfp_codec_id(t->codec) == codec; + + if ((t->profile & device->connected_profiles) && + (t->profile & profile) == t->profile && + codec_ok) + return t; + } + + return NULL; +} + +static void dynamic_node_transport_destroy(void *data) +{ + struct dynamic_node *this = data; + spa_log_debug(this->impl->log, "transport %p destroy", this->transport); + this->transport = NULL; +} + +static void dynamic_node_transport_state_changed(void *data, + enum spa_bt_transport_state old, + enum spa_bt_transport_state state) +{ + struct dynamic_node *this = data; + struct impl *impl = this->impl; + struct spa_bt_transport *t = this->transport; + + spa_log_debug(impl->log, "transport %p state %d->%d", t, old, state); + + if (state >= SPA_BT_TRANSPORT_STATE_PENDING && old < SPA_BT_TRANSPORT_STATE_PENDING) { + if (!SPA_FLAG_IS_SET(this->id, DYNAMIC_NODE_ID_FLAG)) { + SPA_FLAG_SET(this->id, DYNAMIC_NODE_ID_FLAG); + spa_bt_transport_keepalive(t, true); + emit_node(impl, t, this->id, this->factory_name, this->a2dp_duplex); + } + } else if (state < SPA_BT_TRANSPORT_STATE_PENDING && old >= SPA_BT_TRANSPORT_STATE_PENDING) { + if (SPA_FLAG_IS_SET(this->id, DYNAMIC_NODE_ID_FLAG)) { + SPA_FLAG_CLEAR(this->id, DYNAMIC_NODE_ID_FLAG); + spa_bt_transport_keepalive(t, false); + spa_device_emit_object_info(&impl->hooks, this->id, NULL); + } + } +} + +static void dynamic_node_volume_changed(void *data) +{ + struct dynamic_node *node = data; + struct impl *impl = node->impl; + struct spa_event *event; + uint8_t buffer[4096]; + struct spa_pod_builder b = { 0 }; + struct spa_pod_frame f[1]; + struct spa_bt_transport_volume *t_volume; + int id = node->id, volume_id; + + SPA_FLAG_CLEAR(id, DYNAMIC_NODE_ID_FLAG); + + /* Remote device is the controller */ + if (!node->transport || impl->profile != DEVICE_PROFILE_AG + || !spa_bt_transport_volume_enabled(node->transport)) + return; + + if (id == 0 || id == 2) + volume_id = SPA_BT_VOLUME_ID_RX; + else if (id == 1) + volume_id = SPA_BT_VOLUME_ID_TX; + else + return; + + t_volume = &node->transport->volumes[volume_id]; + if (!t_volume->active) + return; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + spa_pod_builder_push_object(&b, &f[0], + SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ObjectConfig); + spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Object, 0); + spa_pod_builder_int(&b, id); + spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0); + spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props, + SPA_PROP_volume, SPA_POD_Float(t_volume->volume)); + event = spa_pod_builder_pop(&b, &f[0]); + + spa_log_debug(impl->log, "dynamic node %p: volume %d changed %f, profile %d", + node, volume_id, t_volume->volume, node->transport->profile); + + /* Dynamic node doesn't has route, we can only set volume on adaptar node. */ + spa_device_emit_event(&impl->hooks, event); +} + +static const struct spa_bt_transport_events dynamic_node_transport_events = { + SPA_VERSION_BT_TRANSPORT_EVENTS, + .destroy = dynamic_node_transport_destroy, + .state_changed = dynamic_node_transport_state_changed, + .volume_changed = dynamic_node_volume_changed, +}; + +static void emit_dynamic_node(struct dynamic_node *this, struct impl *impl, + struct spa_bt_transport *t, uint32_t id, const char *factory_name, bool a2dp_duplex) +{ + spa_log_debug(impl->log, "dynamic node, transport: %p->%p id: %08x->%08x", + this->transport, t, this->id, id); + + if (this->transport) { + /* Session manager don't really handles transport ptr changing. */ + spa_assert(this->transport == t); + spa_hook_remove(&this->transport_listener); + } + + this->impl = impl; + this->transport = t; + this->id = id; + this->factory_name = factory_name; + this->a2dp_duplex = a2dp_duplex; + + spa_bt_transport_add_listener(this->transport, + &this->transport_listener, &dynamic_node_transport_events, this); + + /* emits the node if the state is already pending */ + dynamic_node_transport_state_changed (this, SPA_BT_TRANSPORT_STATE_IDLE, t->state); +} + +static void remove_dynamic_node(struct dynamic_node *this) +{ + if (this->transport == NULL) + return; + + /* destroy the node, if it exists */ + dynamic_node_transport_state_changed (this, this->transport->state, + SPA_BT_TRANSPORT_STATE_IDLE); + + spa_hook_remove(&this->transport_listener); + this->impl = NULL; + this->transport = NULL; + this->id = 0; + this->factory_name = NULL; +} + +static int emit_nodes(struct impl *this) +{ + struct spa_bt_transport *t; + + switch (this->profile) { + case DEVICE_PROFILE_OFF: + break; + case DEVICE_PROFILE_AG: + if (this->bt_dev->connected_profiles & SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY) { + t = find_transport(this, SPA_BT_PROFILE_HFP_AG, 0); + if (!t) + t = find_transport(this, SPA_BT_PROFILE_HSP_AG, 0); + if (t) { + if (t->profile == SPA_BT_PROFILE_HSP_AG) + this->props.codec = 0; + else + this->props.codec = get_hfp_codec_id(t->codec); + emit_dynamic_node(&this->dyn_sco_source, this, t, + 0, SPA_NAME_API_BLUEZ5_SCO_SOURCE, false); + emit_dynamic_node(&this->dyn_sco_sink, this, t, + 1, SPA_NAME_API_BLUEZ5_SCO_SINK, false); + } + } + if (this->bt_dev->connected_profiles & (SPA_BT_PROFILE_A2DP_SOURCE)) { + t = find_transport(this, SPA_BT_PROFILE_A2DP_SOURCE, 0); + if (t) { + this->props.codec = t->media_codec->id; + emit_dynamic_node(&this->dyn_media_source, this, t, + 2, SPA_NAME_API_BLUEZ5_A2DP_SOURCE, false); + + if (t->media_codec->duplex_codec) { + emit_dynamic_node(&this->dyn_media_sink, this, t, + 3, SPA_NAME_API_BLUEZ5_A2DP_SINK, true); + } + } + } + break; + case DEVICE_PROFILE_A2DP: + if (this->bt_dev->connected_profiles & SPA_BT_PROFILE_A2DP_SOURCE) { + t = find_transport(this, SPA_BT_PROFILE_A2DP_SOURCE, 0); + if (t) { + this->props.codec = t->media_codec->id; + emit_dynamic_node(&this->dyn_media_source, this, t, + DEVICE_ID_SOURCE, SPA_NAME_API_BLUEZ5_A2DP_SOURCE, false); + + if (t->media_codec->duplex_codec) { + emit_node(this, t, + DEVICE_ID_SINK, SPA_NAME_API_BLUEZ5_A2DP_SINK, true); + } + } + } + + if (this->bt_dev->connected_profiles & SPA_BT_PROFILE_A2DP_SINK) { + t = find_transport(this, SPA_BT_PROFILE_A2DP_SINK, this->props.codec); + if (t) { + this->props.codec = t->media_codec->id; + emit_node(this, t, DEVICE_ID_SINK, SPA_NAME_API_BLUEZ5_A2DP_SINK, false); + + if (t->media_codec->duplex_codec) { + emit_node(this, t, + DEVICE_ID_SOURCE, SPA_NAME_API_BLUEZ5_A2DP_SOURCE, true); + } + } + } + + if (get_supported_media_codec(this, this->props.codec, NULL) == NULL) + this->props.codec = 0; + break; + case DEVICE_PROFILE_BAP: + if (this->bt_dev->connected_profiles & (SPA_BT_PROFILE_BAP_SOURCE)) { + t = find_transport(this, SPA_BT_PROFILE_BAP_SOURCE, 0); + if (t) { + this->props.codec = t->media_codec->id; + if (t->bap_initiator) + emit_node(this, t, DEVICE_ID_SOURCE, SPA_NAME_API_BLUEZ5_MEDIA_SOURCE, false); + else + emit_dynamic_node(&this->dyn_media_source, this, t, + DEVICE_ID_SOURCE, SPA_NAME_API_BLUEZ5_MEDIA_SOURCE, false); + } + } + + if (this->bt_dev->connected_profiles & (SPA_BT_PROFILE_BAP_SINK)) { + t = find_transport(this, SPA_BT_PROFILE_BAP_SINK, this->props.codec); + if (t) { + this->props.codec = t->media_codec->id; + if (t->bap_initiator) + emit_node(this, t, DEVICE_ID_SINK, SPA_NAME_API_BLUEZ5_MEDIA_SINK, false); + else + emit_dynamic_node(&this->dyn_media_sink, this, t, + DEVICE_ID_SINK, SPA_NAME_API_BLUEZ5_MEDIA_SINK, false); + } + } + + if (get_supported_media_codec(this, this->props.codec, NULL) == NULL) + this->props.codec = 0; + break; + case DEVICE_PROFILE_HSP_HFP: + if (this->bt_dev->connected_profiles & SPA_BT_PROFILE_HEADSET_HEAD_UNIT) { + t = find_transport(this, SPA_BT_PROFILE_HFP_HF, this->props.codec); + if (!t) + t = find_transport(this, SPA_BT_PROFILE_HSP_HS, 0); + if (t) { + if (t->profile == SPA_BT_PROFILE_HSP_HS) + this->props.codec = 0; + else + this->props.codec = get_hfp_codec_id(t->codec); + emit_node(this, t, DEVICE_ID_SOURCE, SPA_NAME_API_BLUEZ5_SCO_SOURCE, false); + emit_node(this, t, DEVICE_ID_SINK, SPA_NAME_API_BLUEZ5_SCO_SINK, false); + } + } + + if (spa_bt_device_supports_hfp_codec(this->bt_dev, get_hfp_codec(this->props.codec)) != 1) + this->props.codec = 0; + break; + default: + return -EINVAL; + } + return 0; +} + +static const struct spa_dict_item info_items[] = { + { SPA_KEY_DEVICE_API, "bluez5" }, + { SPA_KEY_DEVICE_BUS, "bluetooth" }, + { SPA_KEY_MEDIA_CLASS, "Audio/Device" }, +}; + +static void emit_info(struct impl *this, bool full) +{ + uint64_t old = full ? this->info.change_mask : 0; + if (full) + this->info.change_mask = this->info_all; + if (this->info.change_mask) { + this->info.props = &SPA_DICT_INIT_ARRAY(info_items); + + spa_device_emit_info(&this->hooks, &this->info); + this->info.change_mask = old; + } +} + +static void emit_remove_nodes(struct impl *this) +{ + remove_dynamic_node (&this->dyn_media_source); + remove_dynamic_node (&this->dyn_media_sink); + remove_dynamic_node (&this->dyn_sco_source); + remove_dynamic_node (&this->dyn_sco_sink); + + for (uint32_t i = 0; i < 2; i++) { + struct node * node = &this->nodes[i]; + node_offload_set_active(node, false); + if (node->transport) { + spa_hook_remove(&node->transport_listener); + node->transport = NULL; + } + if (node->active) { + spa_device_emit_object_info(&this->hooks, i, NULL); + node->active = false; + } + } + + this->props.offload_active = false; +} + +static bool validate_profile(struct impl *this, uint32_t profile, + enum spa_bluetooth_audio_codec codec); + +static int set_profile(struct impl *this, uint32_t profile, enum spa_bluetooth_audio_codec codec, bool save) +{ + if (!validate_profile(this, profile, codec)) { + spa_log_warn(this->log, "trying to set invalid profile %d, codec %d, %08x %08x", + profile, codec, + this->bt_dev->profiles, this->bt_dev->connected_profiles); + return -EINVAL; + } + + this->save_profile = save; + + if (this->profile == profile && + (this->profile != DEVICE_PROFILE_A2DP || codec == this->props.codec) && + (this->profile != DEVICE_PROFILE_BAP || codec == this->props.codec) && + (this->profile != DEVICE_PROFILE_HSP_HFP || codec == this->props.codec)) + return 0; + + emit_remove_nodes(this); + + spa_bt_device_release_transports(this->bt_dev); + + this->profile = profile; + this->prev_bt_connected_profiles = this->bt_dev->connected_profiles; + this->props.codec = codec; + + /* + * A2DP/BAP: ensure there's a transport with the selected codec (0 means any). + * Don't try to switch codecs when the device is in the A2DP source role, since + * devices do not appear to like that. + */ + if ((profile == DEVICE_PROFILE_A2DP || profile == DEVICE_PROFILE_BAP) + && !(this->bt_dev->connected_profiles & SPA_BT_PROFILE_A2DP_SOURCE)) { + int ret; + const struct media_codec *codecs[64]; + + get_media_codecs(this, codec, codecs, SPA_N_ELEMENTS(codecs)); + + this->switching_codec = true; + + ret = spa_bt_device_ensure_media_codec(this->bt_dev, codecs); + if (ret < 0) { + if (ret != -ENOTSUP) + spa_log_error(this->log, "failed to switch codec (%d), setting basic profile", ret); + } else { + return 0; + } + } else if (profile == DEVICE_PROFILE_HSP_HFP && get_hfp_codec(codec) && !(this->bt_dev->connected_profiles & SPA_BT_PROFILE_HFP_AG)) { + int ret; + + this->switching_codec = true; + + ret = spa_bt_device_ensure_hfp_codec(this->bt_dev, get_hfp_codec(codec)); + if (ret < 0) { + if (ret != -ENOTSUP) + spa_log_error(this->log, "failed to switch codec (%d), setting basic profile", ret); + } else { + return 0; + } + } + + this->switching_codec = false; + this->props.codec = 0; + emit_nodes(this); + + this->info.change_mask |= SPA_DEVICE_CHANGE_MASK_PARAMS; + this->params[IDX_Profile].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_Route].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_EnumRoute].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_Props].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_PropInfo].flags ^= SPA_PARAM_INFO_SERIAL; + emit_info(this, false); + + return 0; +} + +static void codec_switched(void *userdata, int status) +{ + struct impl *this = userdata; + + spa_log_debug(this->log, "codec switched (status %d)", status); + + this->switching_codec = false; + + if (status < 0) { + /* Failed to switch: return to a fallback profile */ + spa_log_error(this->log, "failed to switch codec (%d), setting fallback profile", status); + if (this->profile == DEVICE_PROFILE_A2DP && this->props.codec != 0) { + this->props.codec = 0; + } else if (this->profile == DEVICE_PROFILE_BAP && this->props.codec != 0) { + this->props.codec = 0; + } else if (this->profile == DEVICE_PROFILE_HSP_HFP && this->props.codec != 0) { + this->props.codec = 0; + } else { + this->profile = DEVICE_PROFILE_OFF; + } + } + + emit_remove_nodes(this); + emit_nodes(this); + + this->info.change_mask |= SPA_DEVICE_CHANGE_MASK_PARAMS; + if (this->prev_bt_connected_profiles != this->bt_dev->connected_profiles) + this->params[IDX_EnumProfile].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_Profile].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_Route].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_EnumRoute].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_Props].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_PropInfo].flags ^= SPA_PARAM_INFO_SERIAL; + emit_info(this, false); +} + +static void profiles_changed(void *userdata, uint32_t prev_profiles, uint32_t prev_connected_profiles) +{ + struct impl *this = userdata; + uint32_t connected_change; + bool nodes_changed = false; + + connected_change = (this->bt_dev->connected_profiles ^ prev_connected_profiles); + + /* Profiles changed. We have to re-emit device information. */ + spa_log_info(this->log, "profiles changed to %08x %08x (prev %08x %08x, change %08x)" + " switching_codec:%d", + this->bt_dev->profiles, this->bt_dev->connected_profiles, + prev_profiles, prev_connected_profiles, connected_change, + this->switching_codec); + + if (this->switching_codec) + return; + + if (this->bt_dev->connected_profiles & SPA_BT_PROFILE_MEDIA_SINK) { + free(this->supported_codecs); + this->supported_codecs = spa_bt_device_get_supported_media_codecs( + this->bt_dev, &this->supported_codec_count, true); + } + + switch (this->profile) { + case DEVICE_PROFILE_OFF: + /* Noop */ + nodes_changed = false; + break; + case DEVICE_PROFILE_AG: + nodes_changed = (connected_change & (SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY | + SPA_BT_PROFILE_MEDIA_SOURCE)); + spa_log_debug(this->log, "profiles changed: AG nodes changed: %d", + nodes_changed); + break; + case DEVICE_PROFILE_A2DP: + case DEVICE_PROFILE_BAP: + if (get_supported_media_codec(this, this->props.codec, NULL) == NULL) + this->props.codec = 0; + nodes_changed = (connected_change & (SPA_BT_PROFILE_MEDIA_SINK | + SPA_BT_PROFILE_MEDIA_SOURCE)); + spa_log_debug(this->log, "profiles changed: media nodes changed: %d", + nodes_changed); + break; + case DEVICE_PROFILE_HSP_HFP: + if (spa_bt_device_supports_hfp_codec(this->bt_dev, get_hfp_codec(this->props.codec)) != 1) + this->props.codec = 0; + nodes_changed = (connected_change & SPA_BT_PROFILE_HEADSET_HEAD_UNIT); + spa_log_debug(this->log, "profiles changed: HSP/HFP nodes changed: %d", + nodes_changed); + break; + } + + if (nodes_changed) { + emit_remove_nodes(this); + emit_nodes(this); + } + + this->info.change_mask |= SPA_DEVICE_CHANGE_MASK_PARAMS; + this->params[IDX_Profile].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_EnumProfile].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_Route].flags ^= SPA_PARAM_INFO_SERIAL; /* Profile changes may affect routes */ + this->params[IDX_EnumRoute].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_Props].flags ^= SPA_PARAM_INFO_SERIAL; + this->params[IDX_PropInfo].flags ^= SPA_PARAM_INFO_SERIAL; + emit_info(this, false); +} + +static void set_initial_profile(struct impl *this); + +static void device_connected(void *userdata, bool connected) { + struct impl *this = userdata; + + spa_log_debug(this->log, "connected: %d", connected); + + if (connected ^ (this->profile != DEVICE_PROFILE_OFF)) + set_initial_profile(this); +} + +static const struct spa_bt_device_events bt_dev_events = { + SPA_VERSION_BT_DEVICE_EVENTS, + .connected = device_connected, + .codec_switched = codec_switched, + .profiles_changed = profiles_changed, +}; + +static int impl_add_listener(void *object, + struct spa_hook *listener, + const struct spa_device_events *events, + void *data) +{ + struct impl *this = object; + struct spa_hook_list save; + + spa_return_val_if_fail(this != NULL, -EINVAL); + spa_return_val_if_fail(events != NULL, -EINVAL); + + spa_hook_list_isolate(&this->hooks, &save, listener, events, data); + + if (events->info) + emit_info(this, true); + + if (events->object_info) + emit_nodes(this); + + spa_hook_list_join(&this->hooks, &save); + + return 0; +} + +static int impl_sync(void *object, int seq) +{ + struct impl *this = object; + + spa_return_val_if_fail(this != NULL, -EINVAL); + + spa_device_emit_result(&this->hooks, seq, 0, 0, NULL); + + return 0; +} + +static uint32_t profile_direction_mask(struct impl *this, uint32_t index, enum spa_bluetooth_audio_codec codec) +{ + struct spa_bt_device *device = this->bt_dev; + uint32_t mask; + bool have_output = false, have_input = false; + const struct media_codec *media_codec; + + switch (index) { + case DEVICE_PROFILE_A2DP: + case DEVICE_PROFILE_BAP: + if (device->connected_profiles & SPA_BT_PROFILE_MEDIA_SINK) + have_output = true; + + media_codec = get_supported_media_codec(this, codec, NULL); + if (media_codec && media_codec->duplex_codec) + have_input = true; + break; + case DEVICE_PROFILE_HSP_HFP: + if (device->connected_profiles & SPA_BT_PROFILE_HEADSET_HEAD_UNIT) + have_output = have_input = true; + break; + default: + break; + } + + mask = 0; + if (have_output) + mask |= 1 << SPA_DIRECTION_OUTPUT; + if (have_input) + mask |= 1 << SPA_DIRECTION_INPUT; + return mask; +} + +static uint32_t get_profile_from_index(struct impl *this, uint32_t index, uint32_t *next, enum spa_bluetooth_audio_codec *codec) +{ + /* + * XXX: The codecs should probably become a separate param, and not have + * XXX: separate profiles for each one. + */ + + *codec = 0; + *next = index + 1; + + if (index <= DEVICE_PROFILE_LAST) { + return index; + } else if (index != SPA_ID_INVALID) { + const struct spa_type_info *info; + uint32_t profile; + + *codec = index - DEVICE_PROFILE_LAST; + *next = SPA_ID_INVALID; + + for (info = spa_type_bluetooth_audio_codec; info->type; ++info) + if (info->type > *codec) + *next = SPA_MIN(info->type + DEVICE_PROFILE_LAST, *next); + + if (get_hfp_codec(*codec)) + profile = DEVICE_PROFILE_HSP_HFP; + else if (*codec == SPA_BLUETOOTH_AUDIO_CODEC_LC3) + profile = DEVICE_PROFILE_BAP; + else + profile = DEVICE_PROFILE_A2DP; + + return profile; + } + + *next = SPA_ID_INVALID; + return SPA_ID_INVALID; +} + +static uint32_t get_index_from_profile(struct impl *this, uint32_t profile, enum spa_bluetooth_audio_codec codec) +{ + if (profile == DEVICE_PROFILE_OFF || profile == DEVICE_PROFILE_AG) + return profile; + + if (profile == DEVICE_PROFILE_A2DP) { + if (codec == 0 || (this->bt_dev->connected_profiles & SPA_BT_PROFILE_MEDIA_SOURCE)) + return profile; + + return codec + DEVICE_PROFILE_LAST; + } + + if (profile == DEVICE_PROFILE_BAP) { + if (codec == 0) + return profile; + + return codec + DEVICE_PROFILE_LAST; + } + + if (profile == DEVICE_PROFILE_HSP_HFP) { + if (codec == 0 || (this->bt_dev->connected_profiles & SPA_BT_PROFILE_HFP_AG)) + return profile; + + return codec + DEVICE_PROFILE_LAST; + } + + return SPA_ID_INVALID; +} + +static bool set_initial_hsp_hfp_profile(struct impl *this) +{ + struct spa_bt_transport *t; + int i; + + for (i = SPA_BT_PROFILE_HSP_HS; i <= SPA_BT_PROFILE_HFP_AG; i <<= 1) { + if (!(this->bt_dev->connected_profiles & i)) + continue; + + t = find_transport(this, i, 0); + if (t) { + this->profile = (i & SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY) ? + DEVICE_PROFILE_AG : DEVICE_PROFILE_HSP_HFP; + this->props.codec = get_hfp_codec_id(t->codec); + + spa_log_debug(this->log, "initial profile HSP/HFP profile:%d codec:%d", + this->profile, this->props.codec); + return true; + } + } + return false; +} + +static void set_initial_profile(struct impl *this) +{ + struct spa_bt_transport *t; + int i; + + this->switching_codec = false; + + if (this->supported_codecs) + free(this->supported_codecs); + this->supported_codecs = spa_bt_device_get_supported_media_codecs( + this->bt_dev, &this->supported_codec_count, true); + + /* Prefer BAP, then A2DP, then HFP, then null, but select AG if the device + appears not to have BAP_SINK, A2DP_SINK or any HEAD_UNIT profile */ + + /* If default profile is set to HSP/HFP, first try those and exit if found. */ + if (this->bt_dev->settings != NULL) { + const char *str = spa_dict_lookup(this->bt_dev->settings, "bluez5.profile"); + if (spa_streq(str, "off")) + goto off; + if (spa_streq(str, "headset-head-unit") && set_initial_hsp_hfp_profile(this)) + return; + } + + for (i = SPA_BT_PROFILE_BAP_SINK; i <= SPA_BT_PROFILE_A2DP_SOURCE; i <<= 1) { + if (!(this->bt_dev->connected_profiles & i)) + continue; + + t = find_transport(this, i, 0); + if (t) { + if (i == SPA_BT_PROFILE_A2DP_SOURCE || i == SPA_BT_PROFILE_BAP_SOURCE) + this->profile = DEVICE_PROFILE_AG; + else if (i == SPA_BT_PROFILE_BAP_SINK) + this->profile = DEVICE_PROFILE_BAP; + else + this->profile = DEVICE_PROFILE_A2DP; + this->props.codec = t->media_codec->id; + spa_log_debug(this->log, "initial profile media profile:%d codec:%d", + this->profile, this->props.codec); + return; + } + } + + if (set_initial_hsp_hfp_profile(this)) + return; + +off: + spa_log_debug(this->log, "initial profile off"); + + this->profile = DEVICE_PROFILE_OFF; + this->props.codec = 0; +} + +static struct spa_pod *build_profile(struct impl *this, struct spa_pod_builder *b, + uint32_t id, uint32_t index, uint32_t profile_index, enum spa_bluetooth_audio_codec codec, + bool current) +{ + struct spa_bt_device *device = this->bt_dev; + struct spa_pod_frame f[2]; + const char *name, *desc; + char *name_and_codec = NULL; + char *desc_and_codec = NULL; + uint32_t n_source = 0, n_sink = 0; + uint32_t capture[1] = { DEVICE_ID_SOURCE }, playback[1] = { DEVICE_ID_SINK }; + int priority; + + switch (profile_index) { + case DEVICE_PROFILE_OFF: + name = "off"; + desc = _("Off"); + priority = 0; + break; + case DEVICE_PROFILE_AG: + { + uint32_t profile = device->connected_profiles & + (SPA_BT_PROFILE_A2DP_SOURCE | SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY); + if (profile == 0) { + return NULL; + } else { + name = "audio-gateway"; + desc = _("Audio Gateway (A2DP Source & HSP/HFP AG)"); + } + priority = 256; + break; + } + case DEVICE_PROFILE_A2DP: + { + /* make this device profile visible only if there is an A2DP sink */ + uint32_t profile = device->connected_profiles & + (SPA_BT_PROFILE_A2DP_SINK | SPA_BT_PROFILE_A2DP_SOURCE); + if (!(profile & SPA_BT_PROFILE_A2DP_SINK)) { + return NULL; + } + name = spa_bt_profile_name(profile); + n_sink++; + if (codec) { + size_t idx; + const struct media_codec *media_codec = get_supported_media_codec(this, codec, &idx); + if (media_codec == NULL) { + errno = EINVAL; + return NULL; + } + name_and_codec = spa_aprintf("%s-%s", name, media_codec->name); + name = name_and_codec; + if (profile == SPA_BT_PROFILE_A2DP_SINK && !media_codec->duplex_codec) { + desc_and_codec = spa_aprintf(_("High Fidelity Playback (A2DP Sink, codec %s)"), + media_codec->description); + } else { + desc_and_codec = spa_aprintf(_("High Fidelity Duplex (A2DP Source/Sink, codec %s)"), + media_codec->description); + + } + desc = desc_and_codec; + priority = 16 + this->supported_codec_count - idx; /* order as in codec list */ + } else { + if (profile == SPA_BT_PROFILE_A2DP_SINK) { + desc = _("High Fidelity Playback (A2DP Sink)"); + } else { + desc = _("High Fidelity Duplex (A2DP Source/Sink)"); + } + priority = 16; + } + break; + } + case DEVICE_PROFILE_BAP: + { + uint32_t profile = device->connected_profiles & + (SPA_BT_PROFILE_BAP_SINK | SPA_BT_PROFILE_BAP_SOURCE); + size_t idx; + const struct media_codec *media_codec; + + if (profile == 0) + return NULL; + + if (!codec) { + errno = EINVAL; + return NULL; + } + + if (profile & (SPA_BT_PROFILE_BAP_SINK)) + n_sink++; + if (profile & (SPA_BT_PROFILE_BAP_SOURCE)) + n_source++; + + name = spa_bt_profile_name(profile); + + media_codec = get_supported_media_codec(this, codec, &idx); + if (media_codec == NULL) { + errno = EINVAL; + return NULL; + } + name_and_codec = spa_aprintf("%s-%s", name, media_codec->name); + name = name_and_codec; + switch (profile) { + case SPA_BT_PROFILE_BAP_SINK: + desc_and_codec = spa_aprintf(_("High Fidelity Playback (BAP Sink, codec %s)"), + media_codec->description); + break; + case SPA_BT_PROFILE_BAP_SOURCE: + desc_and_codec = spa_aprintf(_("High Fidelity Input (BAP Source, codec %s)"), + media_codec->description); + break; + default: + desc_and_codec = spa_aprintf(_("High Fidelity Duplex (BAP Source/Sink, codec %s)"), + media_codec->description); + } + desc = desc_and_codec; + priority = 128 + this->supported_codec_count - idx; /* order as in codec list */ + break; + } + case DEVICE_PROFILE_HSP_HFP: + { + /* make this device profile visible only if there is a head unit */ + uint32_t profile = device->connected_profiles & + SPA_BT_PROFILE_HEADSET_HEAD_UNIT; + if (profile == 0) { + return NULL; + } + name = spa_bt_profile_name(profile); + n_source++; + n_sink++; + if (codec) { + bool codec_ok = !(profile & SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY); + unsigned int hfp_codec = get_hfp_codec(codec); + if (spa_bt_device_supports_hfp_codec(this->bt_dev, hfp_codec) != 1) + codec_ok = false; + if (!codec_ok) { + errno = EINVAL; + return NULL; + } + name_and_codec = spa_aprintf("%s-%s", name, get_hfp_codec_name(hfp_codec)); + name = name_and_codec; + desc_and_codec = spa_aprintf(_("Headset Head Unit (HSP/HFP, codec %s)"), + get_hfp_codec_description(hfp_codec)); + desc = desc_and_codec; + priority = 1 + hfp_codec; /* prefer msbc over cvsd */ + } else { + desc = _("Headset Head Unit (HSP/HFP)"); + priority = 1; + } + break; + } + default: + errno = EINVAL; + return NULL; + } + + spa_pod_builder_push_object(b, &f[0], SPA_TYPE_OBJECT_ParamProfile, id); + spa_pod_builder_add(b, + SPA_PARAM_PROFILE_index, SPA_POD_Int(index), + SPA_PARAM_PROFILE_name, SPA_POD_String(name), + SPA_PARAM_PROFILE_description, SPA_POD_String(desc), + SPA_PARAM_PROFILE_available, SPA_POD_Id(SPA_PARAM_AVAILABILITY_yes), + SPA_PARAM_PROFILE_priority, SPA_POD_Int(priority), + 0); + if (n_source > 0 || n_sink > 0) { + spa_pod_builder_prop(b, SPA_PARAM_PROFILE_classes, 0); + spa_pod_builder_push_struct(b, &f[1]); + if (n_source > 0) { + spa_pod_builder_add_struct(b, + SPA_POD_String("Audio/Source"), + SPA_POD_Int(n_source), + SPA_POD_String("card.profile.devices"), + SPA_POD_Array(sizeof(uint32_t), SPA_TYPE_Int, 1, capture)); + } + if (n_sink > 0) { + spa_pod_builder_add_struct(b, + SPA_POD_String("Audio/Sink"), + SPA_POD_Int(n_sink), + SPA_POD_String("card.profile.devices"), + SPA_POD_Array(sizeof(uint32_t), SPA_TYPE_Int, 1, playback)); + } + spa_pod_builder_pop(b, &f[1]); + } + if (current) { + spa_pod_builder_prop(b, SPA_PARAM_PROFILE_save, 0); + spa_pod_builder_bool(b, this->save_profile); + } + + if (name_and_codec) + free(name_and_codec); + if (desc_and_codec) + free(desc_and_codec); + + return spa_pod_builder_pop(b, &f[0]); +} + +static bool validate_profile(struct impl *this, uint32_t profile, + enum spa_bluetooth_audio_codec codec) +{ + struct spa_pod_builder b = { 0 }; + uint8_t buffer[1024]; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + return (build_profile(this, &b, 0, 0, profile, codec, false) != NULL); +} + +static struct spa_pod *build_route(struct impl *this, struct spa_pod_builder *b, + uint32_t id, uint32_t port, uint32_t profile) +{ + struct spa_bt_device *device = this->bt_dev; + struct spa_pod_frame f[2]; + enum spa_direction direction; + const char *name_prefix, *description, *hfp_description, *port_type; + enum spa_bt_form_factor ff; + enum spa_bluetooth_audio_codec codec; + char name[128]; + uint32_t i, j, mask, next; + uint32_t dev = SPA_ID_INVALID, enum_dev; + + ff = spa_bt_form_factor_from_class(device->bluetooth_class); + + switch (ff) { + case SPA_BT_FORM_FACTOR_HEADSET: + name_prefix = "headset"; + description = _("Headset"); + hfp_description = _("Handsfree"); + port_type = "headset"; + break; + case SPA_BT_FORM_FACTOR_HANDSFREE: + name_prefix = "handsfree"; + description = _("Handsfree"); + hfp_description = _("Handsfree (HFP)"); + port_type = "handsfree"; + break; + case SPA_BT_FORM_FACTOR_MICROPHONE: + name_prefix = "microphone"; + description = _("Microphone"); + hfp_description = _("Handsfree"); + port_type = "mic"; + break; + case SPA_BT_FORM_FACTOR_SPEAKER: + name_prefix = "speaker"; + description = _("Speaker"); + hfp_description = _("Handsfree"); + port_type = "speaker"; + break; + case SPA_BT_FORM_FACTOR_HEADPHONE: + name_prefix = "headphone"; + description = _("Headphone"); + hfp_description = _("Handsfree"); + port_type = "headphones"; + break; + case SPA_BT_FORM_FACTOR_PORTABLE: + name_prefix = "portable"; + description = _("Portable"); + hfp_description = _("Handsfree"); + port_type = "portable"; + break; + case SPA_BT_FORM_FACTOR_CAR: + name_prefix = "car"; + description = _("Car"); + hfp_description = _("Handsfree"); + port_type = "car"; + break; + case SPA_BT_FORM_FACTOR_HIFI: + name_prefix = "hifi"; + description = _("HiFi"); + hfp_description = _("Handsfree"); + port_type = "hifi"; + break; + case SPA_BT_FORM_FACTOR_PHONE: + name_prefix = "phone"; + description = _("Phone"); + hfp_description = _("Handsfree"); + port_type = "phone"; + break; + case SPA_BT_FORM_FACTOR_UNKNOWN: + default: + name_prefix = "bluetooth"; + description = _("Bluetooth"); + hfp_description = _("Bluetooth (HFP)"); + port_type = "bluetooth"; + break; + } + + switch (port) { + case 0: + direction = SPA_DIRECTION_INPUT; + snprintf(name, sizeof(name), "%s-input", name_prefix); + enum_dev = DEVICE_ID_SOURCE; + if (profile == DEVICE_PROFILE_A2DP) + dev = enum_dev; + else if (profile != SPA_ID_INVALID) + enum_dev = SPA_ID_INVALID; + break; + case 1: + direction = SPA_DIRECTION_OUTPUT; + snprintf(name, sizeof(name), "%s-output", name_prefix); + enum_dev = DEVICE_ID_SINK; + if (profile == DEVICE_PROFILE_A2DP) + dev = enum_dev; + else if (profile != SPA_ID_INVALID) + enum_dev = SPA_ID_INVALID; + break; + case 2: + direction = SPA_DIRECTION_INPUT; + snprintf(name, sizeof(name), "%s-hf-input", name_prefix); + description = hfp_description; + enum_dev = DEVICE_ID_SOURCE; + if (profile == DEVICE_PROFILE_HSP_HFP) + dev = enum_dev; + else if (profile != SPA_ID_INVALID) + enum_dev = SPA_ID_INVALID; + break; + case 3: + direction = SPA_DIRECTION_OUTPUT; + snprintf(name, sizeof(name), "%s-hf-output", name_prefix); + description = hfp_description; + enum_dev = DEVICE_ID_SINK; + if (profile == DEVICE_PROFILE_HSP_HFP) + dev = enum_dev; + else if (profile != SPA_ID_INVALID) + enum_dev = SPA_ID_INVALID; + break; + default: + errno = EINVAL; + return NULL; + } + + if (enum_dev == SPA_ID_INVALID) { + errno = EINVAL; + return NULL; + } + + spa_pod_builder_push_object(b, &f[0], SPA_TYPE_OBJECT_ParamRoute, id); + spa_pod_builder_add(b, + SPA_PARAM_ROUTE_index, SPA_POD_Int(port), + SPA_PARAM_ROUTE_direction, SPA_POD_Id(direction), + SPA_PARAM_ROUTE_name, SPA_POD_String(name), + SPA_PARAM_ROUTE_description, SPA_POD_String(description), + SPA_PARAM_ROUTE_priority, SPA_POD_Int(0), + SPA_PARAM_ROUTE_available, SPA_POD_Id(SPA_PARAM_AVAILABILITY_yes), + 0); + spa_pod_builder_prop(b, SPA_PARAM_ROUTE_info, 0); + spa_pod_builder_push_struct(b, &f[1]); + spa_pod_builder_int(b, 1); + spa_pod_builder_add(b, + SPA_POD_String("port.type"), + SPA_POD_String(port_type), + NULL); + spa_pod_builder_pop(b, &f[1]); + spa_pod_builder_prop(b, SPA_PARAM_ROUTE_profiles, 0); + spa_pod_builder_push_array(b, &f[1]); + + mask = 0; + for (i = 1; (j = get_profile_from_index(this, i, &next, &codec)) != SPA_ID_INVALID; i = next) { + uint32_t profile_mask; + + if (j == DEVICE_PROFILE_A2DP && !(port == 0 || port == 1)) + continue; + if (j == DEVICE_PROFILE_HSP_HFP && !(port == 2 || port == 3)) + continue; + + profile_mask = profile_direction_mask(this, j, codec); + if (!(profile_mask & (1 << direction))) + continue; + + /* Check the profile actually exists */ + if (!validate_profile(this, j, codec)) + continue; + + mask |= profile_mask; + spa_pod_builder_int(b, i); + } + spa_pod_builder_pop(b, &f[1]); + + if (!(mask & (1 << direction))) { + /* No profile has route direction */ + return NULL; + } + + if (dev != SPA_ID_INVALID) { + struct node *node = &this->nodes[dev]; + struct spa_bt_transport_volume *t_volume; + + mask = profile_direction_mask(this, this->profile, this->props.codec); + if (!(mask & (1 << direction))) + return NULL; + + t_volume = node->transport + ? &node->transport->volumes[node->id] + : NULL; + + spa_pod_builder_prop(b, SPA_PARAM_ROUTE_device, 0); + spa_pod_builder_int(b, dev); + + spa_pod_builder_prop(b, SPA_PARAM_ROUTE_props, 0); + spa_pod_builder_push_object(b, &f[1], SPA_TYPE_OBJECT_Props, id); + + spa_pod_builder_prop(b, SPA_PROP_mute, 0); + spa_pod_builder_bool(b, node->mute); + + spa_pod_builder_prop(b, SPA_PROP_channelVolumes, + (t_volume && t_volume->active) ? SPA_POD_PROP_FLAG_HARDWARE : 0); + spa_pod_builder_array(b, sizeof(float), SPA_TYPE_Float, + node->n_channels, node->volumes); + + if (t_volume && t_volume->active) { + spa_pod_builder_prop(b, SPA_PROP_volumeStep, SPA_POD_PROP_FLAG_READONLY); + spa_pod_builder_float(b, 1.0f / (t_volume->hw_volume_max + 1)); + } + + spa_pod_builder_prop(b, SPA_PROP_channelMap, 0); + spa_pod_builder_array(b, sizeof(uint32_t), SPA_TYPE_Id, + node->n_channels, node->channels); + + if ((this->profile == DEVICE_PROFILE_A2DP || this->profile == DEVICE_PROFILE_BAP) && + dev == DEVICE_ID_SINK) { + spa_pod_builder_prop(b, SPA_PROP_latencyOffsetNsec, 0); + spa_pod_builder_long(b, node->latency_offset); + } + + spa_pod_builder_pop(b, &f[1]); + + spa_pod_builder_prop(b, SPA_PARAM_ROUTE_save, 0); + spa_pod_builder_bool(b, node->save); + } + + spa_pod_builder_prop(b, SPA_PARAM_ROUTE_devices, 0); + spa_pod_builder_push_array(b, &f[1]); + spa_pod_builder_int(b, enum_dev); + spa_pod_builder_pop(b, &f[1]); + + if (profile != SPA_ID_INVALID) { + spa_pod_builder_prop(b, SPA_PARAM_ROUTE_profile, 0); + spa_pod_builder_int(b, profile); + } + return spa_pod_builder_pop(b, &f[0]); +} + +static bool iterate_supported_media_codecs(struct impl *this, int *j, const struct media_codec **codec) +{ + int i; + +next: + *j = *j + 1; + spa_assert(*j >= 0); + if ((size_t)*j >= this->supported_codec_count) + return false; + + for (i = 0; i < *j; ++i) + if (this->supported_codecs[i]->id == this->supported_codecs[*j]->id) + goto next; + + *codec = this->supported_codecs[*j]; + return true; +} + +static struct spa_pod *build_prop_info_codec(struct impl *this, struct spa_pod_builder *b, uint32_t id) +{ + struct spa_pod_frame f[2]; + struct spa_pod_choice *choice; + const struct media_codec *codec; + size_t n; + int j; + +#define FOR_EACH_MEDIA_CODEC(j, codec) \ + for (j = -1; iterate_supported_media_codecs(this, &j, &codec);) +#define FOR_EACH_HFP_CODEC(j) \ + for (j = HFP_AUDIO_CODEC_MSBC; j >= HFP_AUDIO_CODEC_CVSD; --j) \ + if (spa_bt_device_supports_hfp_codec(this->bt_dev, j) == 1) + + spa_pod_builder_push_object(b, &f[0], SPA_TYPE_OBJECT_PropInfo, id); + + /* + * XXX: the ids in principle should use builder_id, not builder_int, + * XXX: but the type info for _type and _labels doesn't work quite right now. + */ + + /* Transport codec */ + spa_pod_builder_prop(b, SPA_PROP_INFO_id, 0); + spa_pod_builder_id(b, SPA_PROP_bluetoothAudioCodec); + spa_pod_builder_prop(b, SPA_PROP_INFO_description, 0); + spa_pod_builder_string(b, "Air codec"); + spa_pod_builder_prop(b, SPA_PROP_INFO_type, 0); + spa_pod_builder_push_choice(b, &f[1], SPA_CHOICE_Enum, 0); + choice = (struct spa_pod_choice *)spa_pod_builder_frame(b, &f[1]); + n = 0; + if (this->profile == DEVICE_PROFILE_A2DP || this->profile == DEVICE_PROFILE_BAP) { + FOR_EACH_MEDIA_CODEC(j, codec) { + if (n == 0) + spa_pod_builder_int(b, codec->id); + spa_pod_builder_int(b, codec->id); + ++n; + } + } else if (this->profile == DEVICE_PROFILE_HSP_HFP) { + FOR_EACH_HFP_CODEC(j) { + if (n == 0) + spa_pod_builder_int(b, get_hfp_codec_id(j)); + spa_pod_builder_int(b, get_hfp_codec_id(j)); + ++n; + } + } + if (n == 0) + choice->body.type = SPA_CHOICE_None; + spa_pod_builder_pop(b, &f[1]); + spa_pod_builder_prop(b, SPA_PROP_INFO_labels, 0); + spa_pod_builder_push_struct(b, &f[1]); + if (this->profile == DEVICE_PROFILE_A2DP || this->profile == DEVICE_PROFILE_BAP) { + FOR_EACH_MEDIA_CODEC(j, codec) { + spa_pod_builder_int(b, codec->id); + spa_pod_builder_string(b, codec->description); + } + } else if (this->profile == DEVICE_PROFILE_HSP_HFP) { + FOR_EACH_HFP_CODEC(j) { + spa_pod_builder_int(b, get_hfp_codec_id(j)); + spa_pod_builder_string(b, get_hfp_codec_description(j)); + } + } + spa_pod_builder_pop(b, &f[1]); + return spa_pod_builder_pop(b, &f[0]); + +#undef FOR_EACH_MEDIA_CODEC +#undef FOR_EACH_HFP_CODEC +} + +static struct spa_pod *build_props(struct impl *this, struct spa_pod_builder *b, uint32_t id) +{ + struct props *p = &this->props; + + return spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_Props, id, + SPA_PROP_bluetoothAudioCodec, SPA_POD_Id(p->codec), + SPA_PROP_bluetoothOffloadActive, SPA_POD_Bool(p->offload_active)); +} + +static int impl_enum_params(void *object, int seq, + uint32_t id, uint32_t start, uint32_t num, + const struct spa_pod *filter) +{ + struct impl *this = object; + struct spa_pod *param; + struct spa_pod_builder b = { 0 }; + uint8_t buffer[2048]; + struct spa_result_device_params result; + uint32_t count = 0; + + spa_return_val_if_fail(this != NULL, -EINVAL); + spa_return_val_if_fail(num != 0, -EINVAL); + + result.id = id; + result.next = start; + next: + result.index = result.next++; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + + switch (id) { + case SPA_PARAM_EnumProfile: + { + uint32_t profile; + enum spa_bluetooth_audio_codec codec; + + profile = get_profile_from_index(this, result.index, &result.next, &codec); + + switch (profile) { + case DEVICE_PROFILE_OFF: + case DEVICE_PROFILE_AG: + case DEVICE_PROFILE_A2DP: + case DEVICE_PROFILE_BAP: + case DEVICE_PROFILE_HSP_HFP: + param = build_profile(this, &b, id, result.index, profile, codec, false); + if (param == NULL) + goto next; + break; + default: + return 0; + } + break; + } + case SPA_PARAM_Profile: + { + uint32_t index; + + switch (result.index) { + case 0: + index = get_index_from_profile(this, this->profile, this->props.codec); + param = build_profile(this, &b, id, index, this->profile, this->props.codec, true); + if (param == NULL) + return 0; + break; + default: + return 0; + } + break; + } + case SPA_PARAM_EnumRoute: + { + switch (result.index) { + case 0: case 1: case 2: case 3: + param = build_route(this, &b, id, result.index, SPA_ID_INVALID); + if (param == NULL) + goto next; + break; + default: + return 0; + } + break; + } + case SPA_PARAM_Route: + { + switch (result.index) { + case 0: case 1: case 2: case 3: + param = build_route(this, &b, id, result.index, this->profile); + if (param == NULL) + goto next; + break; + default: + return 0; + } + break; + } + case SPA_PARAM_PropInfo: + { + switch (result.index) { + case 0: + param = build_prop_info_codec(this, &b, id); + break; + case 1: + param = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_PropInfo, id, + SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_bluetoothOffloadActive), + SPA_PROP_INFO_description, SPA_POD_String("Bluetooth audio offload active"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_Bool(false)); + break; + default: + return 0; + } + break; + } + case SPA_PARAM_Props: + { + switch (result.index) { + case 0: + param = build_props(this, &b, id); + break; + default: + return 0; + } + break; + } + default: + return -ENOENT; + } + + if (spa_pod_filter(&b, &result.param, param, filter) < 0) + goto next; + + spa_device_emit_result(&this->hooks, seq, 0, + SPA_RESULT_TYPE_DEVICE_PARAMS, &result); + + if (++count != num) + goto next; + + return 0; +} + +static int node_set_volume(struct impl *this, struct node *node, float volumes[], uint32_t n_volumes) +{ + uint32_t i; + int changed = 0; + struct spa_bt_transport_volume *t_volume; + + if (n_volumes == 0) + return -EINVAL; + + spa_log_info(this->log, "node %p volume %f", node, volumes[0]); + + for (i = 0; i < node->n_channels; i++) { + if (node->volumes[i] == volumes[i % n_volumes]) + continue; + ++changed; + node->volumes[i] = volumes[i % n_volumes]; + } + + t_volume = node->transport ? &node->transport->volumes[node->id]: NULL; + + if (t_volume && t_volume->active + && spa_bt_transport_volume_enabled(node->transport)) { + float hw_volume = node_get_hw_volume(node); + spa_log_debug(this->log, "node %p hardware volume %f", node, hw_volume); + + node_update_soft_volumes(node, hw_volume); + spa_bt_transport_set_volume(node->transport, node->id, hw_volume); + } else { + float boost = get_soft_volume_boost(node); + for (uint32_t i = 0; i < node->n_channels; ++i) + node->soft_volumes[i] = node->volumes[i] * boost; + } + + emit_volume(this, node); + + return changed; +} + +static int node_set_mute(struct impl *this, struct node *node, bool mute) +{ + struct spa_event *event; + uint8_t buffer[4096]; + struct spa_pod_builder b = { 0 }; + struct spa_pod_frame f[1]; + int changed = 0; + + spa_log_info(this->log, "node %p mute %d", node, mute); + + changed = (node->mute != mute); + node->mute = mute; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + spa_pod_builder_push_object(&b, &f[0], + SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ObjectConfig); + spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Object, 0); + spa_pod_builder_int(&b, node->id); + spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0); + + spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props, + SPA_PROP_mute, SPA_POD_Bool(mute), + SPA_PROP_softMute, SPA_POD_Bool(mute)); + event = spa_pod_builder_pop(&b, &f[0]); + + spa_device_emit_event(&this->hooks, event); + + return changed; +} + +static int node_set_latency_offset(struct impl *this, struct node *node, int64_t latency_offset) +{ + struct spa_event *event; + uint8_t buffer[4096]; + struct spa_pod_builder b = { 0 }; + struct spa_pod_frame f[1]; + int changed = 0; + + spa_log_info(this->log, "node %p latency offset %"PRIi64" nsec", node, latency_offset); + + changed = (node->latency_offset != latency_offset); + node->latency_offset = latency_offset; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + spa_pod_builder_push_object(&b, &f[0], + SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ObjectConfig); + spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Object, 0); + spa_pod_builder_int(&b, node->id); + spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0); + + spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props, + SPA_PROP_latencyOffsetNsec, SPA_POD_Long(latency_offset)); + event = spa_pod_builder_pop(&b, &f[0]); + + spa_device_emit_event(&this->hooks, event); + + return changed; +} + +static int apply_device_props(struct impl *this, struct node *node, struct spa_pod *props) +{ + float volume = 0; + bool mute = 0; + struct spa_pod_prop *prop; + struct spa_pod_object *obj = (struct spa_pod_object *) props; + int changed = 0; + float volumes[SPA_AUDIO_MAX_CHANNELS]; + uint32_t channels[SPA_AUDIO_MAX_CHANNELS]; + uint32_t n_volumes = 0, SPA_UNUSED n_channels = 0; + int64_t latency_offset = 0; + + if (!spa_pod_is_object_type(props, SPA_TYPE_OBJECT_Props)) + return -EINVAL; + + SPA_POD_OBJECT_FOREACH(obj, prop) { + switch (prop->key) { + case SPA_PROP_volume: + if (spa_pod_get_float(&prop->value, &volume) == 0) { + int res = node_set_volume(this, node, &volume, 1); + if (res > 0) + ++changed; + } + break; + case SPA_PROP_mute: + if (spa_pod_get_bool(&prop->value, &mute) == 0) { + int res = node_set_mute(this, node, mute); + if (res > 0) + ++changed; + } + break; + case SPA_PROP_channelVolumes: + n_volumes = spa_pod_copy_array(&prop->value, SPA_TYPE_Float, + volumes, SPA_AUDIO_MAX_CHANNELS); + break; + case SPA_PROP_channelMap: + n_channels = spa_pod_copy_array(&prop->value, SPA_TYPE_Id, + channels, SPA_AUDIO_MAX_CHANNELS); + break; + case SPA_PROP_latencyOffsetNsec: + if (spa_pod_get_long(&prop->value, &latency_offset) == 0) { + int res = node_set_latency_offset(this, node, latency_offset); + if (res > 0) + ++changed; + } + } + } + if (n_volumes > 0) { + int res = node_set_volume(this, node, volumes, n_volumes); + if (res > 0) + ++changed; + } + + return changed; +} + +static void apply_prop_offload_active(struct impl *this, bool active) +{ + bool old_value = this->props.offload_active; + + this->props.offload_active = active; + + for (int i = 0; i < 2; i++) { + node_offload_set_active(&this->nodes[i], active); + if (!this->nodes[i].offload_acquired) + this->props.offload_active = false; + } + + if (this->props.offload_active != old_value) { + this->info.change_mask |= SPA_DEVICE_CHANGE_MASK_PARAMS; + this->params[IDX_Props].flags ^= SPA_PARAM_INFO_SERIAL; + emit_info(this, false); + } +} + +static int impl_set_param(void *object, + uint32_t id, uint32_t flags, + const struct spa_pod *param) +{ + struct impl *this = object; + int res; + + spa_return_val_if_fail(this != NULL, -EINVAL); + + switch (id) { + case SPA_PARAM_Profile: + { + uint32_t idx, next; + uint32_t profile; + enum spa_bluetooth_audio_codec codec; + bool save = false; + + if (param == NULL) + return -EINVAL; + + if ((res = spa_pod_parse_object(param, + SPA_TYPE_OBJECT_ParamProfile, NULL, + SPA_PARAM_PROFILE_index, SPA_POD_Int(&idx), + SPA_PARAM_PROFILE_save, SPA_POD_OPT_Bool(&save))) < 0) { + spa_log_warn(this->log, "can't parse profile"); + spa_debug_log_pod(this->log, SPA_LOG_LEVEL_DEBUG, 0, NULL, param); + return res; + } + + profile = get_profile_from_index(this, idx, &next, &codec); + if (profile == SPA_ID_INVALID) + return -EINVAL; + + spa_log_debug(this->log, "setting profile %d codec:%d save:%d", profile, codec, (int)save); + return set_profile(this, profile, codec, save); + } + case SPA_PARAM_Route: + { + uint32_t idx, device; + struct spa_pod *props = NULL; + struct node *node; + bool save = false; + + if (param == NULL) + return -EINVAL; + + if ((res = spa_pod_parse_object(param, + SPA_TYPE_OBJECT_ParamRoute, NULL, + SPA_PARAM_ROUTE_index, SPA_POD_Int(&idx), + SPA_PARAM_ROUTE_device, SPA_POD_Int(&device), + SPA_PARAM_ROUTE_props, SPA_POD_OPT_Pod(&props), + SPA_PARAM_ROUTE_save, SPA_POD_OPT_Bool(&save))) < 0) { + spa_log_warn(this->log, "can't parse route"); + spa_debug_log_pod(this->log, SPA_LOG_LEVEL_DEBUG, 0, NULL, param); + return res; + } + if (device > 1 || !this->nodes[device].active) + return -EINVAL; + + node = &this->nodes[device]; + node->save = save; + if (props) { + int changed = apply_device_props(this, node, props); + if (changed > 0) { + this->info.change_mask |= SPA_DEVICE_CHANGE_MASK_PARAMS; + this->params[IDX_Route].flags ^= SPA_PARAM_INFO_SERIAL; + } + emit_info(this, false); + } + break; + } + case SPA_PARAM_Props: + { + uint32_t codec_id = SPA_ID_INVALID; + bool offload_active = this->props.offload_active; + + if (param == NULL) + return 0; + + if ((res = spa_pod_parse_object(param, + SPA_TYPE_OBJECT_Props, NULL, + SPA_PROP_bluetoothAudioCodec, SPA_POD_OPT_Id(&codec_id), + SPA_PROP_bluetoothOffloadActive, SPA_POD_OPT_Bool(&offload_active))) < 0) { + spa_log_warn(this->log, "can't parse props"); + spa_debug_log_pod(this->log, SPA_LOG_LEVEL_DEBUG, 0, NULL, param); + return res; + } + + spa_log_debug(this->log, "setting props codec:%d offload:%d", (int)codec_id, (int)offload_active); + + apply_prop_offload_active(this, offload_active); + + if (codec_id == SPA_ID_INVALID) + return 0; + + if (this->profile == DEVICE_PROFILE_A2DP || this->profile == DEVICE_PROFILE_BAP) { + size_t j; + for (j = 0; j < this->supported_codec_count; ++j) { + if (this->supported_codecs[j]->id == codec_id) { + return set_profile(this, this->profile, codec_id, true); + } + } + } else if (this->profile == DEVICE_PROFILE_HSP_HFP) { + if (codec_id == SPA_BLUETOOTH_AUDIO_CODEC_CVSD && + spa_bt_device_supports_hfp_codec(this->bt_dev, HFP_AUDIO_CODEC_CVSD) == 1) { + return set_profile(this, this->profile, codec_id, true); + } else if (codec_id == SPA_BLUETOOTH_AUDIO_CODEC_MSBC && + spa_bt_device_supports_hfp_codec(this->bt_dev, HFP_AUDIO_CODEC_MSBC) == 1) { + return set_profile(this, this->profile, codec_id, true); + } + } + return -EINVAL; + } + default: + return -ENOENT; + } + return 0; +} + +static const struct spa_device_methods impl_device = { + SPA_VERSION_DEVICE_METHODS, + .add_listener = impl_add_listener, + .sync = impl_sync, + .enum_params = impl_enum_params, + .set_param = impl_set_param, +}; + +static int impl_get_interface(struct spa_handle *handle, const char *type, void **interface) +{ + struct impl *this; + + spa_return_val_if_fail(handle != NULL, -EINVAL); + spa_return_val_if_fail(interface != NULL, -EINVAL); + + this = (struct impl *) handle; + + if (spa_streq(type, SPA_TYPE_INTERFACE_Device)) + *interface = &this->device; + else + return -ENOENT; + + return 0; +} + +static int impl_clear(struct spa_handle *handle) +{ + struct impl *this = (struct impl *) handle; + const struct spa_dict_item *it; + + emit_remove_nodes(this); + + free(this->supported_codecs); + if (this->bt_dev) { + this->bt_dev->settings = NULL; + spa_hook_remove(&this->bt_dev_listener); + } + + spa_dict_for_each(it, &this->setting_dict) { + if(it->key) + free((void *)it->key); + if(it->value) + free((void *)it->value); + } + + return 0; +} + +static size_t +impl_get_size(const struct spa_handle_factory *factory, + const struct spa_dict *params) +{ + return sizeof(struct impl); +} + +static const struct spa_dict* +filter_bluez_device_setting(struct impl *this, const struct spa_dict *dict) +{ + uint32_t n_items = 0; + for (uint32_t i = 0 + ; i < dict->n_items && n_items < SPA_N_ELEMENTS(this->setting_items) + ; i++) + { + const struct spa_dict_item *it = &dict->items[i]; + if (it->key != NULL && strncmp(it->key, "bluez", 5) == 0 && it->value != NULL) { + this->setting_items[n_items++] = + SPA_DICT_ITEM_INIT(strdup(it->key), strdup(it->value)); + } + } + this->setting_dict = SPA_DICT_INIT(this->setting_items, n_items); + return &this->setting_dict; +} + +static int +impl_init(const struct spa_handle_factory *factory, + struct spa_handle *handle, + const struct spa_dict *info, + const struct spa_support *support, + uint32_t n_support) +{ + struct impl *this; + const char *str; + + spa_return_val_if_fail(factory != NULL, -EINVAL); + spa_return_val_if_fail(handle != NULL, -EINVAL); + + handle->get_interface = impl_get_interface; + handle->clear = impl_clear; + + this = (struct impl *) handle; + + this->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log); + _i18n = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_I18N); + + spa_log_topic_init(this->log, &log_topic); + + if (info && (str = spa_dict_lookup(info, SPA_KEY_API_BLUEZ5_DEVICE))) + sscanf(str, "pointer:%p", &this->bt_dev); + + if (this->bt_dev == NULL) { + spa_log_error(this->log, "a device is needed"); + return -EINVAL; + } + + if (info) { + int profiles; + this->bt_dev->settings = filter_bluez_device_setting(this, info); + + if ((str = spa_dict_lookup(info, "bluez5.auto-connect")) != NULL) { + if ((profiles = spa_bt_profiles_from_json_array(str)) >= 0) + this->bt_dev->reconnect_profiles = profiles; + } + + if ((str = spa_dict_lookup(info, "bluez5.hw-volume")) != NULL) { + if ((profiles = spa_bt_profiles_from_json_array(str)) >= 0) + this->bt_dev->hw_volume_profiles = profiles; + } + } + + this->device.iface = SPA_INTERFACE_INIT( + SPA_TYPE_INTERFACE_Device, + SPA_VERSION_DEVICE, + &impl_device, this); + + spa_hook_list_init(&this->hooks); + + reset_props(&this->props); + + init_node(this, &this->nodes[0], 0); + init_node(this, &this->nodes[1], 1); + + this->info = SPA_DEVICE_INFO_INIT(); + this->info_all = SPA_DEVICE_CHANGE_MASK_PROPS | + SPA_DEVICE_CHANGE_MASK_PARAMS; + + this->params[IDX_EnumProfile] = SPA_PARAM_INFO(SPA_PARAM_EnumProfile, SPA_PARAM_INFO_READ); + this->params[IDX_Profile] = SPA_PARAM_INFO(SPA_PARAM_Profile, SPA_PARAM_INFO_READWRITE); + this->params[IDX_EnumRoute] = SPA_PARAM_INFO(SPA_PARAM_EnumRoute, SPA_PARAM_INFO_READ); + this->params[IDX_Route] = SPA_PARAM_INFO(SPA_PARAM_Route, SPA_PARAM_INFO_READWRITE); + this->params[IDX_PropInfo] = SPA_PARAM_INFO(SPA_PARAM_PropInfo, SPA_PARAM_INFO_READ); + this->params[IDX_Props] = SPA_PARAM_INFO(SPA_PARAM_Props, SPA_PARAM_INFO_READWRITE); + this->info.params = this->params; + this->info.n_params = 6; + + spa_bt_device_add_listener(this->bt_dev, &this->bt_dev_listener, &bt_dev_events, this); + + set_initial_profile(this); + + return 0; +} + +static const struct spa_interface_info impl_interfaces[] = { + {SPA_TYPE_INTERFACE_Device,}, +}; + +static int +impl_enum_interface_info(const struct spa_handle_factory *factory, + const struct spa_interface_info **info, + uint32_t *index) +{ + spa_return_val_if_fail(factory != NULL, -EINVAL); + spa_return_val_if_fail(info != NULL, -EINVAL); + spa_return_val_if_fail(index != NULL, -EINVAL); + + if (*index >= SPA_N_ELEMENTS(impl_interfaces)) + return 0; + + *info = &impl_interfaces[(*index)++]; + return 1; +} + +static const struct spa_dict_item handle_info_items[] = { + { SPA_KEY_FACTORY_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" }, + { SPA_KEY_FACTORY_DESCRIPTION, "A bluetooth device" }, + { SPA_KEY_FACTORY_USAGE, SPA_KEY_API_BLUEZ5_DEVICE"=<device>" }, +}; + +static const struct spa_dict handle_info = SPA_DICT_INIT_ARRAY(handle_info_items); + +const struct spa_handle_factory spa_bluez5_device_factory = { + SPA_VERSION_HANDLE_FACTORY, + SPA_NAME_API_BLUEZ5_DEVICE, + &handle_info, + impl_get_size, + impl_init, + impl_enum_interface_info, +}; |