/*
|
* BlueALSA - transport.c
|
* Copyright (c) 2016-2018 Arkadiusz Bokowy
|
*
|
* This file is a part of bluez-alsa.
|
*
|
* This project is licensed under the terms of the MIT license.
|
*
|
*/
|
|
#define _GNU_SOURCE
|
#include "transport.h"
|
|
#include <errno.h>
|
#include <fcntl.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <unistd.h>
|
#include <sys/ioctl.h>
|
#include <sys/socket.h>
|
#include <sys/types.h>
|
|
#include <bluetooth/bluetooth.h>
|
#include <bluetooth/hci.h>
|
#include <bluetooth/hci_lib.h>
|
|
#include <gio/gunixfdlist.h>
|
|
#include "a2dp-codecs.h"
|
#include "bluealsa.h"
|
#include "ctl.h"
|
#include "hfp.h"
|
#include "io.h"
|
#include "rfcomm.h"
|
#include "utils.h"
|
#include "shared/log.h"
|
|
|
static const char *transport_type_to_string(enum ba_transport_type type) {
|
switch (type) {
|
case TRANSPORT_TYPE_A2DP:
|
return "A2DP";
|
case TRANSPORT_TYPE_RFCOMM:
|
return "RFCOMM";
|
case TRANSPORT_TYPE_SCO:
|
return "SCO";
|
}
|
return "N/A";
|
}
|
|
static int io_thread_create(struct ba_transport *t) {
|
|
void *(*routine)(void *) = NULL;
|
int ret;
|
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
if (t->profile == BLUETOOTH_PROFILE_A2DP_SOURCE)
|
switch (t->codec) {
|
case A2DP_CODEC_SBC:
|
routine = io_thread_a2dp_source_sbc;
|
break;
|
#if ENABLE_MPEG
|
case A2DP_CODEC_MPEG12:
|
break;
|
#endif
|
#if ENABLE_AAC
|
case A2DP_CODEC_MPEG24:
|
routine = io_thread_a2dp_source_aac;
|
break;
|
#endif
|
#if ENABLE_APTX
|
case A2DP_CODEC_VENDOR_APTX:
|
routine = io_thread_a2dp_source_aptx;
|
break;
|
#endif
|
#if ENABLE_LDAC
|
case A2DP_CODEC_VENDOR_LDAC:
|
routine = io_thread_a2dp_source_ldac;
|
break;
|
#endif
|
default:
|
warn("Codec not supported: %u", t->codec);
|
}
|
if (t->profile == BLUETOOTH_PROFILE_A2DP_SINK)
|
switch (t->codec) {
|
case A2DP_CODEC_SBC:
|
routine = io_thread_a2dp_sink_sbc;
|
break;
|
#if ENABLE_MPEG
|
case A2DP_CODEC_MPEG12:
|
break;
|
#endif
|
#if ENABLE_AAC
|
case A2DP_CODEC_MPEG24:
|
routine = io_thread_a2dp_sink_aac;
|
break;
|
#endif
|
default:
|
warn("Codec not supported: %u", t->codec);
|
}
|
break;
|
case TRANSPORT_TYPE_RFCOMM:
|
routine = rfcomm_thread;
|
break;
|
case TRANSPORT_TYPE_SCO:
|
routine = io_thread_sco;
|
break;
|
}
|
|
if (routine == NULL)
|
return -1;
|
|
if ((ret = pthread_create(&t->thread, NULL, routine, t)) != 0) {
|
error("Couldn't create IO thread: %s", strerror(ret));
|
t->thread = config.main_thread;
|
return -1;
|
}
|
|
pthread_setname_np(t->thread, "baio");
|
debug("Created new IO thread: %s: %s",
|
transport_type_to_string(t->type),
|
bluetooth_profile_to_string(t->profile));
|
return 0;
|
}
|
|
struct ba_device *device_new(int hci_dev_id, const bdaddr_t *addr, const char *name) {
|
|
struct ba_device *d;
|
|
if ((d = calloc(1, sizeof(*d))) == NULL)
|
return NULL;
|
|
d->hci_dev_id = hci_dev_id;
|
bacpy(&d->addr, addr);
|
|
strncpy(d->name, name, sizeof(d->name));
|
d->name[sizeof(d->name) - 1] = '\0';
|
|
d->transports = g_hash_table_new_full(g_str_hash, g_str_equal,
|
NULL, (GDestroyNotify)transport_free);
|
|
return d;
|
}
|
|
void device_free(struct ba_device *d) {
|
|
if (d == NULL)
|
return;
|
|
/* XXX: Modification-safe remove-all loop.
|
*
|
* By the usage of a standard g_hash_table_remove_all() function, one
|
* has to comply to the license warranty, which states that anything
|
* can happen. In our case it is true to the letter - SIGSEGV is 100%
|
* guaranteed.
|
*
|
* Our transport structure holds reference to some other transport
|
* structure within the same hash-table. Unfortunately, such a usage
|
* is not supported. Almost every GLib-2.0 function facilitates cache,
|
* which backfires at us if we modify hash-table from the inside of
|
* the destroy function. However, it is possible to "iterate" over
|
* a hash-table in a pop-like matter - reinitialize iterator after
|
* every modification. And voila - modification-safe remove loop. */
|
for (;;) {
|
|
GHashTableIter iter;
|
struct ba_transport *t;
|
|
g_hash_table_iter_init(&iter, d->transports);
|
if (!g_hash_table_iter_next(&iter, NULL, (gpointer)&t))
|
break;
|
|
transport_free(t);
|
}
|
|
g_hash_table_unref(d->transports);
|
free(d);
|
}
|
|
struct ba_device *device_get(GHashTable *devices, const char *key) {
|
|
struct ba_device *d;
|
char name[sizeof(d->name)];
|
GVariant *property;
|
bdaddr_t addr;
|
|
if ((d = g_hash_table_lookup(devices, key)) != NULL)
|
return d;
|
|
g_dbus_device_path_to_bdaddr(key, &addr);
|
ba2str(&addr, name);
|
|
/* get local (user editable) Bluetooth device name */
|
if ((property = g_dbus_get_property(config.dbus, "org.bluez", key,
|
"org.bluez.Device1", "Alias")) != NULL) {
|
strncpy(name, g_variant_get_string(property, NULL), sizeof(name) - 1);
|
name[sizeof(name) - 1] = '\0';
|
g_variant_unref(property);
|
}
|
|
d = device_new(config.hci_dev.dev_id, &addr, name);
|
g_hash_table_insert(devices, g_strdup(key), d);
|
return d;
|
}
|
|
struct ba_device *device_lookup(GHashTable *devices, const char *key) {
|
return g_hash_table_lookup(devices, key);
|
}
|
|
bool device_remove(GHashTable *devices, const char *key) {
|
return g_hash_table_remove(devices, key);
|
}
|
|
void device_set_battery_level(struct ba_device *d, uint8_t value) {
|
d->battery.enabled = true;
|
d->battery.level = value;
|
bluealsa_ctl_event(BA_EVENT_UPDATE_BATTERY);
|
}
|
|
/**
|
* Create new transport.
|
*
|
* @param device Pointer to the device structure.
|
* @param type Transport type.
|
* @param dbus_owner D-Bus service, which owns this transport.
|
* @param dbus_path D-Bus service path for this transport.
|
* @param profile Bluetooth profile.
|
* @param codec Used audio codec.
|
* @return On success, the pointer to the newly allocated transport structure
|
* is returned. If error occurs, NULL is returned and the errno variable is
|
* set to indicated the cause of the error. */
|
struct ba_transport *transport_new(
|
struct ba_device *device,
|
enum ba_transport_type type,
|
const char *dbus_owner,
|
const char *dbus_path,
|
enum bluetooth_profile profile,
|
uint16_t codec) {
|
|
struct ba_transport *t;
|
int err;
|
|
if ((t = calloc(1, sizeof(*t))) == NULL)
|
goto fail;
|
|
t->device = device;
|
t->type = type;
|
|
t->profile = profile;
|
t->codec = codec;
|
|
/* HSP supports CVSD only */
|
if (profile == BLUETOOTH_PROFILE_HSP_HS || profile == BLUETOOTH_PROFILE_HSP_AG)
|
t->codec = HFP_CODEC_CVSD;
|
|
pthread_mutex_init(&t->mutex, NULL);
|
|
t->state = TRANSPORT_IDLE;
|
t->thread = config.main_thread;
|
|
t->bt_fd = -1;
|
t->sig_fd[0] = -1;
|
t->sig_fd[1] = -1;
|
|
if ((t->dbus_owner = strdup(dbus_owner)) == NULL)
|
goto fail;
|
if ((t->dbus_path = strdup(dbus_path)) == NULL)
|
goto fail;
|
|
if (pipe(t->sig_fd) == -1)
|
goto fail;
|
|
g_hash_table_insert(device->transports, t->dbus_path, t);
|
return t;
|
|
fail:
|
err = errno;
|
transport_free(t);
|
errno = err;
|
return NULL;
|
}
|
|
struct ba_transport *transport_new_a2dp(
|
struct ba_device *device,
|
const char *dbus_owner,
|
const char *dbus_path,
|
enum bluetooth_profile profile,
|
uint16_t codec,
|
const uint8_t *config,
|
size_t config_size) {
|
|
struct ba_transport *t;
|
|
if ((t = transport_new(device, TRANSPORT_TYPE_A2DP,
|
dbus_owner, dbus_path, profile, codec)) == NULL)
|
return NULL;
|
|
t->a2dp.ch1_volume = 127;
|
t->a2dp.ch2_volume = 127;
|
|
if (config_size > 0) {
|
t->a2dp.cconfig = malloc(config_size);
|
t->a2dp.cconfig_size = config_size;
|
memcpy(t->a2dp.cconfig, config, config_size);
|
}
|
|
t->a2dp.pcm.fd = -1;
|
t->a2dp.pcm.client = -1;
|
pthread_cond_init(&t->a2dp.pcm.drained, NULL);
|
pthread_mutex_init(&t->a2dp.pcm.drained_mn, NULL);
|
|
bluealsa_ctl_event(BA_EVENT_TRANSPORT_ADDED);
|
return t;
|
}
|
|
struct ba_transport *transport_new_rfcomm(
|
struct ba_device *device,
|
const char *dbus_owner,
|
const char *dbus_path,
|
enum bluetooth_profile profile) {
|
|
gchar *dbus_path_sco = NULL;
|
struct ba_transport *t, *t_sco;
|
|
if ((t = transport_new(device, TRANSPORT_TYPE_RFCOMM,
|
dbus_owner, dbus_path, profile, -1)) == NULL)
|
goto fail;
|
|
dbus_path_sco = g_strdup_printf("%s/sco", dbus_path);
|
if ((t_sco = transport_new(device, TRANSPORT_TYPE_SCO,
|
dbus_owner, dbus_path_sco, profile, HFP_CODEC_UNDEFINED)) == NULL)
|
goto fail;
|
|
t->rfcomm.sco = t_sco;
|
t_sco->sco.rfcomm = t;
|
|
t_sco->sco.spk_gain = 15;
|
t_sco->sco.mic_gain = 15;
|
|
t_sco->sco.spk_pcm.fd = -1;
|
t_sco->sco.spk_pcm.client = -1;
|
pthread_cond_init(&t_sco->sco.spk_pcm.drained, NULL);
|
pthread_mutex_init(&t_sco->sco.spk_pcm.drained_mn, NULL);
|
|
t_sco->sco.mic_pcm.fd = -1;
|
t_sco->sco.mic_pcm.client = -1;
|
pthread_cond_init(&t_sco->sco.mic_pcm.drained, NULL);
|
pthread_mutex_init(&t_sco->sco.mic_pcm.drained_mn, NULL);
|
|
bluealsa_ctl_event(BA_EVENT_TRANSPORT_ADDED);
|
return t;
|
|
fail:
|
if (dbus_path_sco != NULL)
|
g_free(dbus_path_sco);
|
transport_free(t);
|
return NULL;
|
}
|
|
void transport_free(struct ba_transport *t) {
|
|
if (t == NULL || t->state == TRANSPORT_LIMBO)
|
return;
|
|
t->state = TRANSPORT_LIMBO;
|
debug("Freeing transport: %s: %s (%s)",
|
transport_type_to_string(t->type),
|
bluetooth_profile_to_string(t->profile),
|
bluetooth_a2dp_codec_to_string(t->codec));
|
|
/* If the transport is active, prior to releasing resources, we have to
|
* terminate the IO thread (or at least make sure it is not running any
|
* more). Not doing so might result in an undefined behavior or even a
|
* race condition (closed and reused file descriptor). */
|
transport_pthread_cancel(t->thread);
|
|
/* if possible, try to release resources gracefully */
|
if (t->release != NULL)
|
t->release(t);
|
|
if (t->bt_fd != -1)
|
close(t->bt_fd);
|
if (t->sig_fd[0] != -1)
|
close(t->sig_fd[0]);
|
if (t->sig_fd[1] != -1)
|
close(t->sig_fd[1]);
|
|
pthread_mutex_destroy(&t->mutex);
|
|
/* free type-specific resources */
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
transport_release_pcm(&t->a2dp.pcm);
|
pthread_cond_destroy(&t->a2dp.pcm.drained);
|
pthread_mutex_destroy(&t->a2dp.pcm.drained_mn);
|
free(t->a2dp.cconfig);
|
break;
|
case TRANSPORT_TYPE_RFCOMM:
|
memset(&t->device->battery, 0, sizeof(t->device->battery));
|
memset(&t->device->xapl, 0, sizeof(t->device->xapl));
|
transport_free(t->rfcomm.sco);
|
break;
|
case TRANSPORT_TYPE_SCO:
|
transport_release_pcm(&t->sco.spk_pcm);
|
pthread_cond_destroy(&t->sco.spk_pcm.drained);
|
pthread_mutex_destroy(&t->sco.spk_pcm.drained_mn);
|
transport_release_pcm(&t->sco.mic_pcm);
|
pthread_cond_destroy(&t->sco.mic_pcm.drained);
|
pthread_mutex_destroy(&t->sco.mic_pcm.drained_mn);
|
t->sco.rfcomm->rfcomm.sco = NULL;
|
break;
|
}
|
|
/* If the free action was called on the behalf of the destroy notification,
|
* removing a value from the hash-table shouldn't hurt - it would have been
|
* removed anyway. */
|
g_hash_table_steal(t->device->transports, t->dbus_path);
|
|
bluealsa_ctl_event(BA_EVENT_TRANSPORT_REMOVED);
|
|
free(t->dbus_owner);
|
free(t->dbus_path);
|
free(t);
|
}
|
|
struct ba_transport *transport_lookup(GHashTable *devices, const char *dbus_path) {
|
|
GHashTableIter iter;
|
struct ba_device *d;
|
struct ba_transport *t;
|
|
g_hash_table_iter_init(&iter, devices);
|
while (g_hash_table_iter_next(&iter, NULL, (gpointer)&d)) {
|
if ((t = g_hash_table_lookup(d->transports, dbus_path)) != NULL)
|
return t;
|
}
|
|
return NULL;
|
}
|
|
struct ba_transport *transport_lookup_pcm_client(GHashTable *devices, int client) {
|
|
GHashTableIter iter_d, iter_t;
|
struct ba_device *d;
|
struct ba_transport *t;
|
|
g_hash_table_iter_init(&iter_d, devices);
|
while (g_hash_table_iter_next(&iter_d, NULL, (gpointer)&d)) {
|
g_hash_table_iter_init(&iter_t, d->transports);
|
while (g_hash_table_iter_next(&iter_t, NULL, (gpointer)&t)) {
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
if (t->a2dp.pcm.client == client)
|
return t;
|
break;
|
case TRANSPORT_TYPE_RFCOMM:
|
break;
|
case TRANSPORT_TYPE_SCO:
|
if (t->sco.spk_pcm.client == client)
|
return t;
|
if (t->sco.mic_pcm.client == client)
|
return t;
|
break;
|
}
|
}
|
}
|
|
return NULL;
|
}
|
|
bool transport_remove(GHashTable *devices, const char *dbus_path) {
|
|
GHashTableIter iter;
|
struct ba_device *d;
|
struct ba_transport *t;
|
|
g_hash_table_iter_init(&iter, devices);
|
while (g_hash_table_iter_next(&iter, NULL, (gpointer)&d)) {
|
/* Disassociate D-Bus owner before further actions. This will ensure,
|
* that we will not generate errors by using non-existent interface. */
|
if ((t = g_hash_table_lookup(d->transports, dbus_path)) != NULL) {
|
free(t->dbus_owner);
|
t->dbus_owner = NULL;
|
}
|
if (g_hash_table_remove(d->transports, dbus_path)) {
|
if (g_hash_table_size(d->transports) == 0)
|
g_hash_table_iter_remove(&iter);
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
int transport_send_signal(struct ba_transport *t, enum ba_transport_signal sig) {
|
return write(t->sig_fd[1], &sig, sizeof(sig));
|
}
|
|
int transport_send_rfcomm(struct ba_transport *t, const char command[32]) {
|
|
char msg[sizeof(enum ba_transport_signal) + 32];
|
|
((enum ba_transport_signal *)msg)[0] = TRANSPORT_SEND_RFCOMM;
|
memcpy(&msg[sizeof(enum ba_transport_signal)], command, 32);
|
|
return write(t->sig_fd[1], msg, sizeof(msg));
|
}
|
|
unsigned int transport_get_channels(const struct ba_transport *t) {
|
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
switch (t->codec) {
|
case A2DP_CODEC_SBC:
|
switch (((a2dp_sbc_t *)t->a2dp.cconfig)->channel_mode) {
|
case SBC_CHANNEL_MODE_MONO:
|
return 1;
|
case SBC_CHANNEL_MODE_STEREO:
|
case SBC_CHANNEL_MODE_JOINT_STEREO:
|
case SBC_CHANNEL_MODE_DUAL_CHANNEL:
|
return 2;
|
}
|
break;
|
#if ENABLE_MPEG
|
case A2DP_CODEC_MPEG12:
|
switch (((a2dp_mpeg_t *)t->a2dp.cconfig)->channel_mode) {
|
case MPEG_CHANNEL_MODE_MONO:
|
return 1;
|
case MPEG_CHANNEL_MODE_STEREO:
|
case MPEG_CHANNEL_MODE_JOINT_STEREO:
|
case MPEG_CHANNEL_MODE_DUAL_CHANNEL:
|
return 2;
|
}
|
break;
|
#endif
|
#if ENABLE_AAC
|
case A2DP_CODEC_MPEG24:
|
switch (((a2dp_aac_t *)t->a2dp.cconfig)->channels) {
|
case AAC_CHANNELS_1:
|
return 1;
|
case AAC_CHANNELS_2:
|
return 2;
|
}
|
break;
|
#endif
|
#if ENABLE_APTX
|
case A2DP_CODEC_VENDOR_APTX:
|
switch (((a2dp_aptx_t *)t->a2dp.cconfig)->channel_mode) {
|
case APTX_CHANNEL_MODE_MONO:
|
return 1;
|
case APTX_CHANNEL_MODE_STEREO:
|
return 2;
|
}
|
break;
|
#endif
|
#if ENABLE_LDAC
|
case A2DP_CODEC_VENDOR_LDAC:
|
switch (((a2dp_ldac_t *)t->a2dp.cconfig)->channel_mode) {
|
case LDAC_CHANNEL_MODE_MONO:
|
return 1;
|
case LDAC_CHANNEL_MODE_STEREO:
|
case LDAC_CHANNEL_MODE_DUAL_CHANNEL:
|
return 2;
|
}
|
break;
|
#endif
|
}
|
break;
|
case TRANSPORT_TYPE_RFCOMM:
|
break;
|
case TRANSPORT_TYPE_SCO:
|
return 1;
|
}
|
|
/* the number of channels is unspecified */
|
return 0;
|
}
|
|
unsigned int transport_get_sampling(const struct ba_transport *t) {
|
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
switch (t->codec) {
|
case A2DP_CODEC_SBC:
|
switch (((a2dp_sbc_t *)t->a2dp.cconfig)->frequency) {
|
case SBC_SAMPLING_FREQ_16000:
|
return 16000;
|
case SBC_SAMPLING_FREQ_32000:
|
return 32000;
|
case SBC_SAMPLING_FREQ_44100:
|
return 44100;
|
case SBC_SAMPLING_FREQ_48000:
|
return 48000;
|
}
|
break;
|
#if ENABLE_MPEG
|
case A2DP_CODEC_MPEG12:
|
switch (((a2dp_mpeg_t *)t->a2dp.cconfig)->frequency) {
|
case MPEG_SAMPLING_FREQ_16000:
|
return 16000;
|
case MPEG_SAMPLING_FREQ_22050:
|
return 22050;
|
case MPEG_SAMPLING_FREQ_24000:
|
return 24000;
|
case MPEG_SAMPLING_FREQ_32000:
|
return 32000;
|
case MPEG_SAMPLING_FREQ_44100:
|
return 44100;
|
case MPEG_SAMPLING_FREQ_48000:
|
return 48000;
|
}
|
break;
|
#endif
|
#if ENABLE_AAC
|
case A2DP_CODEC_MPEG24:
|
switch (AAC_GET_FREQUENCY(*(a2dp_aac_t *)t->a2dp.cconfig)) {
|
case AAC_SAMPLING_FREQ_8000:
|
return 8000;
|
case AAC_SAMPLING_FREQ_11025:
|
return 11025;
|
case AAC_SAMPLING_FREQ_12000:
|
return 12000;
|
case AAC_SAMPLING_FREQ_16000:
|
return 16000;
|
case AAC_SAMPLING_FREQ_22050:
|
return 22050;
|
case AAC_SAMPLING_FREQ_24000:
|
return 24000;
|
case AAC_SAMPLING_FREQ_32000:
|
return 32000;
|
case AAC_SAMPLING_FREQ_44100:
|
return 44100;
|
case AAC_SAMPLING_FREQ_48000:
|
return 48000;
|
case AAC_SAMPLING_FREQ_64000:
|
return 64000;
|
case AAC_SAMPLING_FREQ_88200:
|
return 88200;
|
case AAC_SAMPLING_FREQ_96000:
|
return 96000;
|
}
|
break;
|
#endif
|
#if ENABLE_APTX
|
case A2DP_CODEC_VENDOR_APTX:
|
switch (((a2dp_aptx_t *)t->a2dp.cconfig)->frequency) {
|
case APTX_SAMPLING_FREQ_16000:
|
return 16000;
|
case APTX_SAMPLING_FREQ_32000:
|
return 32000;
|
case APTX_SAMPLING_FREQ_44100:
|
return 44100;
|
case APTX_SAMPLING_FREQ_48000:
|
return 48000;
|
}
|
break;
|
#endif
|
#if ENABLE_LDAC
|
case A2DP_CODEC_VENDOR_LDAC:
|
switch (((a2dp_ldac_t *)t->a2dp.cconfig)->frequency) {
|
case LDAC_SAMPLING_FREQ_44100:
|
return 44100;
|
case LDAC_SAMPLING_FREQ_48000:
|
return 48000;
|
case LDAC_SAMPLING_FREQ_88200:
|
return 88200;
|
case LDAC_SAMPLING_FREQ_96000:
|
return 96000;
|
case LDAC_SAMPLING_FREQ_176400:
|
return 176400;
|
case LDAC_SAMPLING_FREQ_192000:
|
return 192000;
|
}
|
break;
|
#endif
|
}
|
break;
|
case TRANSPORT_TYPE_RFCOMM:
|
break;
|
case TRANSPORT_TYPE_SCO:
|
switch (t->codec) {
|
case HFP_CODEC_CVSD:
|
return 8000;
|
case HFP_CODEC_MSBC:
|
return 16000;
|
default:
|
debug("Unsupported SCO codec: %#x", t->codec);
|
}
|
}
|
|
/* the sampling frequency is unspecified */
|
return 0;
|
}
|
|
int transport_set_volume(struct ba_transport *t, uint8_t ch1_muted, uint8_t ch2_muted,
|
uint8_t ch1_volume, uint8_t ch2_volume) {
|
|
debug("Setting volume for %s profile %d: %d<>%d [%c%c]", batostr_(&t->device->addr),
|
t->profile, ch1_volume, ch2_volume, ch1_muted ? 'M' : 'O', ch2_muted ? 'M' : 'O');
|
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
|
t->a2dp.ch1_muted = ch1_muted;
|
t->a2dp.ch2_muted = ch2_muted;
|
t->a2dp.ch1_volume = ch1_volume;
|
t->a2dp.ch2_volume = ch2_volume;
|
|
if (config.a2dp.volume) {
|
uint16_t volume = (ch1_muted | ch2_muted) ? 0 : MIN(ch1_volume, ch2_volume);
|
g_dbus_set_property(config.dbus, t->dbus_owner, t->dbus_path,
|
"org.bluez.MediaTransport1", "Volume", g_variant_new_uint16(volume));
|
}
|
|
break;
|
|
case TRANSPORT_TYPE_RFCOMM:
|
break;
|
|
case TRANSPORT_TYPE_SCO:
|
|
t->sco.spk_muted = ch1_muted;
|
t->sco.mic_muted = ch2_muted;
|
t->sco.spk_gain = ch1_volume;
|
t->sco.mic_gain = ch2_volume;
|
|
/* notify associated RFCOMM transport */
|
transport_send_signal(t->sco.rfcomm, TRANSPORT_SET_VOLUME);
|
|
break;
|
|
}
|
|
return 0;
|
}
|
|
int transport_set_state(struct ba_transport *t, enum ba_transport_state state) {
|
debug("State transition: %d -> %d", t->state, state);
|
|
if (t->state == state)
|
return 0;
|
|
/* For the A2DP sink profile, the IO thread can not be created until the
|
* BT transport is acquired, otherwise thread initialized will fail. */
|
if (t->profile == BLUETOOTH_PROFILE_A2DP_SINK &&
|
t->state == TRANSPORT_IDLE && state != TRANSPORT_PENDING)
|
return 0;
|
|
int ret = 0;
|
|
t->state = state;
|
|
switch (state) {
|
case TRANSPORT_IDLE:
|
transport_pthread_cancel(t->thread);
|
break;
|
case TRANSPORT_PENDING:
|
/* When transport is marked as pending, try to acquire transport, but only
|
* if we are handing A2DP sink profile. For source profile, transport has
|
* to be acquired by our controller (during the PCM open request). */
|
if (t->profile == BLUETOOTH_PROFILE_A2DP_SINK)
|
ret = transport_acquire_bt_a2dp(t);
|
break;
|
case TRANSPORT_ACTIVE:
|
case TRANSPORT_PAUSED:
|
if (pthread_equal(t->thread, config.main_thread))
|
ret = io_thread_create(t);
|
break;
|
case TRANSPORT_LIMBO:
|
break;
|
}
|
|
/* something went wrong, so go back to idle */
|
if (ret == -1)
|
return transport_set_state(t, TRANSPORT_IDLE);
|
|
return ret;
|
}
|
|
int transport_set_state_from_string(struct ba_transport *t, const char *state) {
|
|
if (strcmp(state, "idle") == 0)
|
transport_set_state(t, TRANSPORT_IDLE);
|
else if (strcmp(state, "pending") == 0)
|
transport_set_state(t, TRANSPORT_PENDING);
|
else if (strcmp(state, "active") == 0)
|
transport_set_state(t, TRANSPORT_ACTIVE);
|
else {
|
warn("Invalid state: %s", state);
|
return -1;
|
}
|
|
return 0;
|
}
|
|
int transport_drain_pcm(struct ba_transport *t) {
|
|
struct ba_pcm *pcm = NULL;
|
|
switch (t->profile) {
|
case BLUETOOTH_PROFILE_NULL:
|
case BLUETOOTH_PROFILE_A2DP_SINK:
|
break;
|
case BLUETOOTH_PROFILE_A2DP_SOURCE:
|
pcm = &t->a2dp.pcm;
|
break;
|
case BLUETOOTH_PROFILE_HSP_AG:
|
case BLUETOOTH_PROFILE_HFP_AG:
|
pcm = &t->sco.spk_pcm;
|
break;
|
case BLUETOOTH_PROFILE_HSP_HS:
|
case BLUETOOTH_PROFILE_HFP_HF:
|
break;
|
}
|
|
if (pcm == NULL || t->state != TRANSPORT_ACTIVE)
|
return 0;
|
|
pthread_mutex_lock(&pcm->drained_mn);
|
|
transport_send_signal(t, TRANSPORT_PCM_SYNC);
|
pthread_cond_wait(&pcm->drained, &pcm->drained_mn);
|
|
pthread_mutex_unlock(&pcm->drained_mn);
|
|
/* TODO: Asynchronous transport release.
|
*
|
* Unfortunately, BlueZ does not provide API for internal buffer drain.
|
* Also, there is no specification for Bluetooth playback drain. In order
|
* to make sure, that all samples are played out, we have to wait some
|
* arbitrary time before releasing transport. In order to make it right,
|
* there is a requirement for an asynchronous release mechanism, which
|
* is not implemented - it requires a little bit of refactoring. */
|
usleep(200000);
|
|
debug("PCM drained");
|
return 0;
|
}
|
|
int transport_acquire_bt_a2dp(struct ba_transport *t) {
|
|
GDBusMessage *msg, *rep;
|
GUnixFDList *fd_list;
|
GError *err = NULL;
|
|
/* Check whether transport is already acquired - keep-alive mode. */
|
if (t->bt_fd != -1) {
|
debug("Reusing transport: %d", t->bt_fd);
|
goto final;
|
}
|
|
msg = g_dbus_message_new_method_call(t->dbus_owner, t->dbus_path, "org.bluez.MediaTransport1",
|
t->state == TRANSPORT_PENDING ? "TryAcquire" : "Acquire");
|
|
if ((rep = g_dbus_connection_send_message_with_reply_sync(config.dbus, msg,
|
G_DBUS_SEND_MESSAGE_FLAGS_NONE, -1, NULL, NULL, &err)) == NULL)
|
goto fail;
|
|
if (g_dbus_message_get_message_type(rep) == G_DBUS_MESSAGE_TYPE_ERROR) {
|
g_dbus_message_to_gerror(rep, &err);
|
goto fail;
|
}
|
|
g_variant_get(g_dbus_message_get_body(rep), "(hqq)", (int32_t *)&t->bt_fd,
|
(uint16_t *)&t->mtu_read, (uint16_t *)&t->mtu_write);
|
|
fd_list = g_dbus_message_get_unix_fd_list(rep);
|
t->bt_fd = g_unix_fd_list_get(fd_list, 0, &err);
|
t->release = transport_release_bt_a2dp;
|
|
/* Minimize audio delay and increase responsiveness (seeking, stopping) by
|
* decreasing the BT socket output buffer. We will use a tripled write MTU
|
* value, in order to prevent tearing due to temporal heavy load. */
|
size_t size = t->mtu_write * 3;
|
if (setsockopt(t->bt_fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)) == -1)
|
warn("Couldn't set socket output buffer size: %s", strerror(errno));
|
|
if (ioctl(t->bt_fd, TIOCOUTQ, &t->a2dp.bt_fd_coutq_init) == -1)
|
warn("Couldn't get socket queued bytes: %s", strerror(errno));
|
|
debug("New transport: %d (MTU: R:%zu W:%zu)", t->bt_fd, t->mtu_read, t->mtu_write);
|
|
fail:
|
g_object_unref(msg);
|
if (rep != NULL)
|
g_object_unref(rep);
|
if (err != NULL) {
|
error("Couldn't acquire transport: %s", err->message);
|
g_error_free(err);
|
}
|
|
final:
|
return t->bt_fd;
|
}
|
|
int transport_release_bt_a2dp(struct ba_transport *t) {
|
|
GDBusMessage *msg = NULL, *rep = NULL;
|
GError *err = NULL;
|
int ret = -1;
|
|
/* If the transport has not been acquired, or it has been released already,
|
* there is no need to release it again. In fact, trying to release already
|
* closed transport will result in returning error message. */
|
if (t->bt_fd == -1)
|
return 0;
|
|
debug("Releasing transport: %s (%s)",
|
bluetooth_profile_to_string(t->profile),
|
bluetooth_a2dp_codec_to_string(t->codec));
|
|
/* If the state is idle, it means that either transport was not acquired, or
|
* was released by the BlueZ. In both cases there is no point in a explicit
|
* release request. It might even return error (e.g. not authorized). */
|
if (t->state != TRANSPORT_IDLE && t->dbus_owner != NULL) {
|
|
msg = g_dbus_message_new_method_call(t->dbus_owner, t->dbus_path,
|
"org.bluez.MediaTransport1", "Release");
|
|
if ((rep = g_dbus_connection_send_message_with_reply_sync(config.dbus, msg,
|
G_DBUS_SEND_MESSAGE_FLAGS_NONE, -1, NULL, NULL, &err)) == NULL)
|
goto fail;
|
|
if (g_dbus_message_get_message_type(rep) == G_DBUS_MESSAGE_TYPE_ERROR) {
|
g_dbus_message_to_gerror(rep, &err);
|
if (err->code == G_DBUS_ERROR_NO_REPLY) {
|
/* If BlueZ is already terminated (or is terminating), we won't receive
|
* any response. Do not treat such a case as an error - omit logging. */
|
g_error_free(err);
|
err = NULL;
|
}
|
else
|
goto fail;
|
}
|
|
}
|
|
debug("Closing BT: %d", t->bt_fd);
|
|
ret = 0;
|
t->release = NULL;
|
close(t->bt_fd);
|
t->bt_fd = -1;
|
|
fail:
|
if (msg != NULL)
|
g_object_unref(msg);
|
if (rep != NULL)
|
g_object_unref(rep);
|
if (err != NULL) {
|
error("Couldn't release transport: %s", err->message);
|
g_error_free(err);
|
}
|
return ret;
|
}
|
|
int transport_release_bt_rfcomm(struct ba_transport *t) {
|
|
if (t->bt_fd == -1)
|
return 0;
|
|
debug("Closing RFCOMM: %d", t->bt_fd);
|
|
t->release = NULL;
|
shutdown(t->bt_fd, SHUT_RDWR);
|
close(t->bt_fd);
|
t->bt_fd = -1;
|
|
/* BlueZ does not trigger profile disconnection signal when the Bluetooth
|
* link has been lost (e.g. device power down). However, it is required to
|
* remove transport from the transport pool before reconnecting. */
|
transport_free(t);
|
|
return 0;
|
}
|
|
int transport_acquire_bt_sco(struct ba_transport *t) {
|
|
struct hci_dev_info di;
|
|
if (t->bt_fd != -1)
|
return t->bt_fd;
|
|
if (hci_devinfo(t->device->hci_dev_id, &di) == -1) {
|
error("Couldn't get HCI device info: %s", strerror(errno));
|
return -1;
|
}
|
|
if ((t->bt_fd = hci_open_sco(&di, &t->device->addr, t->codec != HFP_CODEC_CVSD)) == -1) {
|
error("Couldn't open SCO link: %s", strerror(errno));
|
return -1;
|
}
|
|
t->mtu_read = di.sco_mtu;
|
t->mtu_write = di.sco_mtu;
|
t->release = transport_release_bt_sco;
|
|
/* XXX: It seems, that the MTU values returned by the HCI interface
|
* are incorrect (or our interpretation of them is incorrect). */
|
t->mtu_read = 48;
|
t->mtu_write = 48;
|
|
debug("New SCO link: %d (MTU: R:%zu W:%zu)", t->bt_fd, t->mtu_read, t->mtu_write);
|
|
return t->bt_fd;
|
}
|
|
int transport_acquire_bt_sco2(struct ba_transport *t, int asock)
|
{
|
|
struct hci_dev_info di;
|
|
if (t->bt_fd != -1)
|
return t->bt_fd;
|
|
t->bt_fd = asock;
|
|
if (hci_devinfo(t->device->hci_dev_id, &di) == -1) {
|
error("Couldn't get HCI device info: %s", strerror(errno));
|
return -1;
|
}
|
|
t->mtu_read = di.sco_mtu;
|
t->mtu_write = di.sco_mtu;
|
t->release = transport_release_bt_sco;
|
|
/* XXX: It seems, that the MTU values returned by the HCI interface
|
* are incorrect (or our interpretation of them is incorrect). */
|
t->mtu_read = 48;
|
t->mtu_write = 48;
|
|
debug("New SCO link: %d (MTU: R:%zu W:%zu)", t->bt_fd, t->mtu_read, t->mtu_write);
|
|
return t->bt_fd;
|
}
|
|
int transport_release_bt_sco(struct ba_transport *t) {
|
|
if (t->bt_fd == -1)
|
return 0;
|
|
debug("Closing SCO: %d", t->bt_fd);
|
|
t->release = NULL;
|
shutdown(t->bt_fd, SHUT_RDWR);
|
close(t->bt_fd);
|
t->bt_fd = -1;
|
|
return 0;
|
}
|
|
int transport_release_pcm(struct ba_pcm *pcm) {
|
|
int oldstate;
|
|
/* Transport IO workers are managed using thread cancellation mechanism,
|
* so we have to take into account a possibility of cancellation during the
|
* execution. In this release function it is important to perform actions
|
* atomically. Since close call is a cancellation point, it is required to
|
* temporally disable cancellation. For a better understanding of what is
|
* going on, see the io_thread_read_pcm() function. */
|
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
|
|
if (pcm->fd != -1) {
|
debug("Closing PCM: %d", pcm->fd);
|
close(pcm->fd);
|
pcm->fd = -1;
|
}
|
|
pthread_setcancelstate(oldstate, NULL);
|
return 0;
|
}
|
|
/**
|
* Synchronous transport thread cancellation. */
|
void transport_pthread_cancel(pthread_t thread) {
|
|
if (pthread_equal(thread, pthread_self()))
|
return;
|
if (pthread_equal(thread, config.main_thread))
|
return;
|
|
int err;
|
if ((err = pthread_cancel(thread)) != 0)
|
warn("Couldn't cancel transport thread: %s", strerror(err));
|
if ((err = pthread_join(thread, NULL)) != 0)
|
warn("Couldn't join transport thread: %s", strerror(err));
|
}
|
|
/**
|
* Wrapper for release callback, which can be used by the pthread cleanup.
|
*
|
* This function CAN be used with transport_pthread_cleanup_lock() in order
|
* to guard transport critical section during cleanup process. */
|
void transport_pthread_cleanup(struct ba_transport *t) {
|
|
/* During the normal operation mode, the release callback should not
|
* be NULL. Hence, we will relay on this callback - file descriptors
|
* are closed in it. */
|
if (t->release != NULL)
|
t->release(t);
|
|
/* Make sure, that after termination, this thread handler will not
|
* be used anymore. */
|
t->thread = config.main_thread;
|
|
transport_pthread_cleanup_unlock(t);
|
|
/* XXX: If the order of the cleanup push is right, this function will
|
* indicate the end of the IO/RFCOMM thread. */
|
debug("Exiting IO thread");
|
}
|
|
int transport_pthread_cleanup_lock(struct ba_transport *t) {
|
int ret = pthread_mutex_lock(&t->mutex);
|
t->cleanup_lock = true;
|
return ret;
|
}
|
|
int transport_pthread_cleanup_unlock(struct ba_transport *t) {
|
if (!t->cleanup_lock)
|
return 0;
|
t->cleanup_lock = false;
|
return pthread_mutex_unlock(&t->mutex);
|
}
|
