/*
|
* bluealsa-ctl.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.
|
*
|
*/
|
|
#include <ctype.h>
|
#include <errno.h>
|
#include <stdbool.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <sys/socket.h>
|
#include <sys/types.h>
|
|
#include <alsa/asoundlib.h>
|
#include <alsa/control_external.h>
|
|
#include "shared/ctl-client.h"
|
#include "shared/ctl-proto.h"
|
#include "shared/log.h"
|
|
|
enum ctl_elem_type {
|
CTL_ELEM_TYPE_BATTERY,
|
CTL_ELEM_TYPE_SWITCH,
|
CTL_ELEM_TYPE_VOLUME,
|
};
|
|
struct ctl_elem {
|
enum ctl_elem_type type;
|
struct ba_msg_device *device;
|
struct ba_msg_transport *transport;
|
char name[44 /* internal ALSA constraint */ + 1];
|
/* if true, element is a playback control */
|
bool playback;
|
};
|
|
struct ctl_elem_update {
|
char name[sizeof(((struct ctl_elem *)0)->name)];
|
unsigned int event_mask;
|
struct ctl_elem *_elem;
|
};
|
|
struct bluealsa_ctl {
|
snd_ctl_ext_t ext;
|
|
/* bluealsa sockets */
|
int fd;
|
int event_fd;
|
|
/* if true, show battery meter */
|
bool battery;
|
|
/* list of all BT devices */
|
struct ba_msg_device *devices;
|
size_t devices_count;
|
|
/* list of all transports */
|
struct ba_msg_transport *transports;
|
size_t transports_count;
|
|
/* list of control elements */
|
struct ctl_elem *elems;
|
size_t elems_count;
|
|
/* list of control element update events */
|
struct ctl_elem_update *updates;
|
size_t updates_count;
|
|
};
|
|
|
/**
|
* Get device ID number.
|
*
|
* @param ctl An address to the bluealsa ctl structure.
|
* @param device An address to the device structure.
|
* @return The device ID number, or -1 upon error. */
|
static int bluealsa_get_device_id(const struct bluealsa_ctl *ctl,
|
const struct ba_msg_device *device) {
|
|
size_t i;
|
|
for (i = 0; i < ctl->devices_count; i++)
|
if (bacmp(&ctl->devices[i].addr, &device->addr) == 0)
|
return i;
|
|
return -1;
|
}
|
|
/**
|
* Set element name within the element structure.
|
*
|
* @param elem An address to the element structure.
|
* @param id Device ID number. If the ID is other than -1, it will be
|
* attached to the element name in order to prevent duplications. */
|
static void bluealsa_set_elem_name(struct ctl_elem *elem, int id) {
|
|
const enum ctl_elem_type type = elem->type;
|
const struct ba_msg_device *device = elem->device;
|
const struct ba_msg_transport *transport = elem->transport;
|
|
int len = sizeof(elem->name) - 16 - 1;
|
char no[8] = "";
|
|
if (id != -1) {
|
sprintf(no, " #%u", id + 1);
|
len -= strlen(no);
|
}
|
|
if (type == CTL_ELEM_TYPE_BATTERY) {
|
len -= 10;
|
while (isspace(device->name[len - 1]))
|
len--;
|
sprintf(elem->name, "%.*s%s | Battery", len, device->name, no);
|
}
|
else if (transport != NULL) {
|
/* avoid name duplication by adding profile suffixes */
|
switch (transport->type) {
|
case BA_PCM_TYPE_NULL:
|
break;
|
case BA_PCM_TYPE_A2DP:
|
len -= 7;
|
while (isspace(device->name[len - 1]))
|
len--;
|
sprintf(elem->name, "%.*s%s - A2DP", len, device->name, no);
|
break;
|
case BA_PCM_TYPE_SCO:
|
len -= 6;
|
while (isspace(device->name[len - 1]))
|
len--;
|
sprintf(elem->name, "%.*s%s - SCO", len, device->name, no);
|
break;
|
}
|
}
|
|
/* ALSA library determines the element type by checking it's
|
* name suffix. This feature is not well documented, though. */
|
|
strcat(elem->name, elem->playback ? " Playback" : " Capture");
|
|
switch (type) {
|
case CTL_ELEM_TYPE_SWITCH:
|
strcat(elem->name, " Switch");
|
break;
|
case CTL_ELEM_TYPE_BATTERY:
|
case CTL_ELEM_TYPE_VOLUME:
|
strcat(elem->name, " Volume");
|
break;
|
}
|
|
}
|
|
/**
|
* Compare two control element structures.
|
*
|
* @param e1 Pointer to control element structure.
|
* @param e2 Pointer to control element structure.
|
* @return It returns an integer equal to, or greater than zero if e1 is
|
* found, respectively, to match, or be different than e2. */
|
static int bluealsa_ctl_elem_cmp(const struct ctl_elem *e1, const struct ctl_elem *e2) {
|
|
const struct ba_msg_device *d1 = e1->device;
|
const struct ba_msg_device *d2 = e2->device;
|
const struct ba_msg_transport *t1 = e1->transport;
|
const struct ba_msg_transport *t2 = e2->transport;
|
bool updated = false;
|
|
switch (e1->type) {
|
case CTL_ELEM_TYPE_BATTERY:
|
updated |= d1->battery_level != d2->battery_level;
|
break;
|
case CTL_ELEM_TYPE_SWITCH:
|
switch (t1->type) {
|
case BA_PCM_TYPE_NULL:
|
return -EINVAL;
|
case BA_PCM_TYPE_A2DP:
|
updated |= t1->ch1_muted != t2->ch1_muted;
|
if (t1->channels == 2)
|
updated |= t1->ch2_muted != t2->ch2_muted;
|
break;
|
case BA_PCM_TYPE_SCO:
|
if (e1->playback)
|
updated |= t1->ch1_muted != t2->ch1_muted;
|
else
|
updated |= t1->ch2_muted != t2->ch2_muted;
|
break;
|
}
|
break;
|
case CTL_ELEM_TYPE_VOLUME:
|
switch (t1->type) {
|
case BA_PCM_TYPE_NULL:
|
return -EINVAL;
|
case BA_PCM_TYPE_A2DP:
|
updated |= t1->ch1_volume != t2->ch1_volume;
|
if (t1->channels == 2)
|
updated |= t1->ch2_volume != t2->ch2_volume;
|
break;
|
case BA_PCM_TYPE_SCO:
|
if (e1->playback)
|
updated |= t1->ch1_volume != t2->ch1_volume;
|
else
|
updated |= t1->ch2_volume != t2->ch2_volume;
|
break;
|
}
|
break;
|
}
|
|
return updated;
|
}
|
|
static int bluealsa_ctl_elem_update_cmp(const void *p1, const void *p2) {
|
return strcmp(((struct ctl_elem_update *)p1)->name, ((struct ctl_elem_update *)p2)->name);
|
}
|
|
static void bluealsa_close(snd_ctl_ext_t *ext) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
close(ctl->fd);
|
close(ctl->event_fd);
|
free(ctl->devices);
|
free(ctl->transports);
|
free(ctl->elems);
|
free(ctl->updates);
|
free(ctl);
|
}
|
|
static int bluealsa_elem_count(snd_ctl_ext_t *ext) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
|
size_t count = 0;
|
ssize_t cnt;
|
size_t i;
|
|
if ((cnt = bluealsa_get_devices(ctl->fd, &ctl->devices)) == -1)
|
return -errno;
|
ctl->devices_count = cnt;
|
|
if ((cnt = bluealsa_get_transports(ctl->fd, &ctl->transports)) == -1)
|
return -errno;
|
ctl->transports_count = cnt;
|
|
for (i = 0; i < ctl->devices_count; i++) {
|
/* add additional element for battery level */
|
if (ctl->battery && ctl->devices[i].battery)
|
count++;
|
}
|
|
for (i = 0; i < ctl->transports_count; i++) {
|
/* Every stream has two controls associated to itself - volume adjustment
|
* and mute switch. A2DP transport contains only one stream. However, SCO
|
* transport represent both streams - playback and capture. */
|
switch (ctl->transports[i].type) {
|
case BA_PCM_TYPE_NULL:
|
continue;
|
case BA_PCM_TYPE_A2DP:
|
count += 2;
|
break;
|
case BA_PCM_TYPE_SCO:
|
count += 4;
|
break;
|
}
|
}
|
|
ctl->elems = malloc(sizeof(*ctl->elems) * count);
|
ctl->elems_count = count;
|
count = 0;
|
|
/* construct control elements based on received transports */
|
for (i = 0; i < ctl->transports_count; i++) {
|
|
struct ba_msg_transport *transport = &ctl->transports[i];
|
struct ba_msg_device *device = NULL;
|
size_t ii;
|
|
/* get device structure for given transport */
|
for (ii = 0; ii < ctl->devices_count; ii++) {
|
if (bacmp(&ctl->devices[ii].addr, &transport->addr) == 0) {
|
device = &ctl->devices[ii];
|
break;
|
}
|
}
|
|
/* If the timing is right, the device list might not contain all devices.
|
* It will happen, when between the get devices and get transports calls
|
* a new BT device has been connected. */
|
if (device == NULL)
|
continue;
|
|
switch (transport->type) {
|
case BA_PCM_TYPE_NULL:
|
break;
|
|
case BA_PCM_TYPE_A2DP:
|
|
ctl->elems[count].type = CTL_ELEM_TYPE_VOLUME;
|
ctl->elems[count].device = device;
|
ctl->elems[count].transport = transport;
|
ctl->elems[count].playback = transport->stream == BA_PCM_STREAM_PLAYBACK;
|
bluealsa_set_elem_name(&ctl->elems[count], -1);
|
count++;
|
|
ctl->elems[count].type = CTL_ELEM_TYPE_SWITCH;
|
ctl->elems[count].device = device;
|
ctl->elems[count].transport = transport;
|
ctl->elems[count].playback = transport->stream == BA_PCM_STREAM_PLAYBACK;
|
bluealsa_set_elem_name(&ctl->elems[count], -1);
|
count++;
|
|
break;
|
|
case BA_PCM_TYPE_SCO:
|
|
ctl->elems[count].type = CTL_ELEM_TYPE_VOLUME;
|
ctl->elems[count].device = device;
|
ctl->elems[count].transport = transport;
|
ctl->elems[count].playback = true;
|
bluealsa_set_elem_name(&ctl->elems[count], -1);
|
count++;
|
|
ctl->elems[count].type = CTL_ELEM_TYPE_SWITCH;
|
ctl->elems[count].device = device;
|
ctl->elems[count].transport = transport;
|
ctl->elems[count].playback = true;
|
bluealsa_set_elem_name(&ctl->elems[count], -1);
|
count++;
|
|
ctl->elems[count].type = CTL_ELEM_TYPE_VOLUME;
|
ctl->elems[count].device = device;
|
ctl->elems[count].transport = transport;
|
ctl->elems[count].playback = false;
|
bluealsa_set_elem_name(&ctl->elems[count], -1);
|
count++;
|
|
ctl->elems[count].type = CTL_ELEM_TYPE_SWITCH;
|
ctl->elems[count].device = device;
|
ctl->elems[count].transport = transport;
|
ctl->elems[count].playback = false;
|
bluealsa_set_elem_name(&ctl->elems[count], -1);
|
count++;
|
|
break;
|
|
}
|
|
}
|
|
/* construct device specific elements */
|
for (i = 0; i < ctl->devices_count; i++) {
|
/* add additional element for battery level */
|
if (ctl->battery && ctl->devices[i].battery) {
|
ctl->elems[count].type = CTL_ELEM_TYPE_BATTERY;
|
ctl->elems[count].device = &ctl->devices[i];
|
ctl->elems[count].transport = NULL;
|
ctl->elems[count].playback = true;
|
bluealsa_set_elem_name(&ctl->elems[count], -1);
|
count++;
|
}
|
}
|
|
/* Detect element name duplicates and annotate them with the consecutive
|
* device ID number - which will make ALSA library happy. */
|
for (i = 0; i < ctl->elems_count; i++) {
|
|
bool duplicated = false;
|
size_t ii;
|
|
for (ii = i + 1; ii < ctl->elems_count; ii++)
|
if (strcmp(ctl->elems[i].name, ctl->elems[ii].name) == 0) {
|
bluealsa_set_elem_name(&ctl->elems[ii],
|
bluealsa_get_device_id(ctl, ctl->elems[ii].device));
|
duplicated = true;
|
}
|
|
if (duplicated)
|
bluealsa_set_elem_name(&ctl->elems[i],
|
bluealsa_get_device_id(ctl, ctl->elems[i].device));
|
|
}
|
|
return count;
|
}
|
|
static int bluealsa_elem_list(snd_ctl_ext_t *ext, unsigned int offset, snd_ctl_elem_id_t *id) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
|
if (offset > ctl->elems_count)
|
return -EINVAL;
|
|
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
|
snd_ctl_elem_id_set_name(id, ctl->elems[offset].name);
|
|
return 0;
|
}
|
|
static snd_ctl_ext_key_t bluealsa_find_elem(snd_ctl_ext_t *ext, const snd_ctl_elem_id_t *id) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
|
unsigned int numid = snd_ctl_elem_id_get_numid(id);
|
|
if (numid > 0 && numid <= ctl->elems_count)
|
return numid - 1;
|
|
const char *name = snd_ctl_elem_id_get_name(id);
|
size_t i;
|
|
for (i = 0; i < ctl->elems_count; i++)
|
if (strcmp(ctl->elems[i].name, name) == 0)
|
return i;
|
|
return SND_CTL_EXT_KEY_NOT_FOUND;
|
}
|
|
static int bluealsa_get_attribute(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
|
int *type, unsigned int *acc, unsigned int *count) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
|
if (key > ctl->elems_count)
|
return -EINVAL;
|
|
const struct ctl_elem *elem = &ctl->elems[key];
|
const struct ba_msg_transport *transport = elem->transport;
|
|
switch (elem->type) {
|
case CTL_ELEM_TYPE_BATTERY:
|
*acc = SND_CTL_EXT_ACCESS_READ;
|
*type = SND_CTL_ELEM_TYPE_INTEGER;
|
*count = 1;
|
break;
|
case CTL_ELEM_TYPE_SWITCH:
|
*acc = SND_CTL_EXT_ACCESS_READWRITE;
|
*type = SND_CTL_ELEM_TYPE_BOOLEAN;
|
*count = transport->channels;
|
break;
|
case CTL_ELEM_TYPE_VOLUME:
|
*acc = SND_CTL_EXT_ACCESS_READWRITE;
|
*type = SND_CTL_ELEM_TYPE_INTEGER;
|
*count = transport->channels;
|
break;
|
}
|
|
return 0;
|
}
|
|
static int bluealsa_get_integer_info(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
|
long *imin, long *imax, long *istep) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
|
if (key > ctl->elems_count)
|
return -EINVAL;
|
|
const struct ctl_elem *elem = &ctl->elems[key];
|
const struct ba_msg_transport *transport = elem->transport;
|
|
switch (elem->type) {
|
case CTL_ELEM_TYPE_BATTERY:
|
*imin = 0;
|
*imax = 100;
|
*istep = 1;
|
break;
|
case CTL_ELEM_TYPE_SWITCH:
|
return -EINVAL;
|
case CTL_ELEM_TYPE_VOLUME:
|
switch (transport->type) {
|
case BA_PCM_TYPE_NULL:
|
return -EINVAL;
|
case BA_PCM_TYPE_A2DP:
|
*imax = 127;
|
break;
|
case BA_PCM_TYPE_SCO:
|
*imax = 15;
|
break;
|
}
|
*imin = 0;
|
*istep = 1;
|
break;
|
}
|
|
return 0;
|
}
|
|
static int bluealsa_read_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
|
if (key > ctl->elems_count)
|
return -EINVAL;
|
|
const struct ctl_elem *elem = &ctl->elems[key];
|
const struct ba_msg_device *device = elem->device;
|
const struct ba_msg_transport *transport = elem->transport;
|
|
switch (elem->type) {
|
case CTL_ELEM_TYPE_BATTERY:
|
value[0] = device->battery_level;
|
break;
|
case CTL_ELEM_TYPE_SWITCH:
|
switch (transport->type) {
|
case BA_PCM_TYPE_NULL:
|
return -EINVAL;
|
case BA_PCM_TYPE_A2DP:
|
value[0] = !transport->ch1_muted;
|
if (transport->channels == 2)
|
value[1] = !transport->ch2_muted;
|
break;
|
case BA_PCM_TYPE_SCO:
|
if (elem->playback)
|
value[0] = !transport->ch1_muted;
|
else
|
value[0] = !transport->ch2_muted;
|
break;
|
}
|
break;
|
case CTL_ELEM_TYPE_VOLUME:
|
switch (transport->type) {
|
case BA_PCM_TYPE_NULL:
|
return -EINVAL;
|
case BA_PCM_TYPE_A2DP:
|
value[0] = transport->ch1_volume;
|
if (transport->channels == 2)
|
value[1] = transport->ch2_volume;
|
break;
|
case BA_PCM_TYPE_SCO:
|
if (elem->playback)
|
value[0] = transport->ch1_volume;
|
else
|
value[0] = transport->ch2_volume;
|
break;
|
}
|
break;
|
}
|
|
return 0;
|
}
|
|
static int bluealsa_write_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
|
if (key > ctl->elems_count)
|
return -EINVAL;
|
|
struct ctl_elem *elem = &ctl->elems[key];
|
struct ba_msg_transport *transport = elem->transport;
|
|
if (transport == NULL)
|
return -EINVAL;
|
|
switch (elem->type) {
|
case CTL_ELEM_TYPE_BATTERY:
|
/* this element should be read-only */
|
return -EINVAL;
|
case CTL_ELEM_TYPE_SWITCH:
|
switch (transport->type) {
|
case BA_PCM_TYPE_NULL:
|
return -EINVAL;
|
case BA_PCM_TYPE_A2DP:
|
transport->ch1_muted = !value[0];
|
if (transport->channels == 2)
|
transport->ch2_muted = !value[1];
|
break;
|
case BA_PCM_TYPE_SCO:
|
if (elem->playback)
|
transport->ch1_muted = !value[0];
|
else
|
transport->ch2_muted = !value[0];
|
break;
|
}
|
break;
|
case CTL_ELEM_TYPE_VOLUME:
|
switch (transport->type) {
|
case BA_PCM_TYPE_NULL:
|
return -EINVAL;
|
case BA_PCM_TYPE_A2DP:
|
transport->ch1_volume = value[0];
|
if (transport->channels == 2)
|
transport->ch2_volume = value[1];
|
break;
|
case BA_PCM_TYPE_SCO:
|
if (elem->playback)
|
transport->ch1_volume = value[0];
|
else
|
transport->ch2_volume = value[0];
|
break;
|
}
|
break;
|
}
|
|
if (bluealsa_set_transport_volume(ctl->fd, transport,
|
transport->ch1_muted, transport->ch1_volume,
|
transport->ch2_muted, transport->ch2_volume) == -1)
|
return -errno;
|
return 0;
|
}
|
|
static void bluealsa_subscribe_events(snd_ctl_ext_t *ext, int subscribe) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
if (bluealsa_subscribe(ctl->event_fd, subscribe ? 0xFFFF : 0) == -1)
|
SNDERR("BlueALSA subscription failed: %s", strerror(errno));
|
}
|
|
static int bluealsa_read_event(snd_ctl_ext_t *ext, snd_ctl_elem_id_t *id, unsigned int *event_mask) {
|
struct bluealsa_ctl *ctl = (struct bluealsa_ctl *)ext->private_data;
|
|
if (ctl->updates_count) {
|
ctl->updates_count--;
|
|
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
|
snd_ctl_elem_id_set_name(id, ctl->updates[ctl->updates_count].name);
|
*event_mask = ctl->updates[ctl->updates_count].event_mask;
|
|
if (ctl->updates_count == 0) {
|
free(ctl->updates);
|
ctl->updates = NULL;
|
}
|
|
return 1;
|
}
|
|
struct ba_msg_event event;
|
ssize_t ret;
|
|
/* This code reads events from the socket until the EAGAIN is returned.
|
* Since EAGAIN is returned when operation would block (there is no more
|
* data to read), we are compliant with the ALSA specification. */
|
while ((ret = recv(ctl->event_fd, &event, sizeof(event), MSG_DONTWAIT)) == -1 && errno == EINTR)
|
continue;
|
if (ret == -1)
|
return -errno;
|
|
/* Upon server disconnection, our socket file descriptor is in the ready for
|
* reading state. However, there is no data to be read. In such a case, we
|
* have to indicate, that the controller has been unplugged. Since, it is not
|
* possible to manipulate revents - snd_mixer_poll_descriptors_revents() does
|
* not call poll_revents() callback - we are going to close our socket, which
|
* (at least for alsamixer) seems to do the trick. Anyhow, there is a caveat.
|
* If some other thread opens new file descriptor... we are doomed. */
|
if (ret == 0) {
|
close(ext->poll_fd);
|
return -ENODEV;
|
}
|
|
/* Save current control elements for later usage. The call to the
|
* bluealsa_elem_count() will overwrite these pointers. */
|
struct ba_msg_device *devices = ctl->devices;
|
struct ba_msg_transport *transports = ctl->transports;
|
struct ctl_elem *elems = ctl->elems;
|
size_t count = ctl->elems_count;
|
|
if ((ret = bluealsa_elem_count(ext)) < 0)
|
return ret;
|
|
/* This part is kinda tricky, however not very complicated. We are going
|
* to allocate buffer, which will store references to our previous control
|
* elements and to the new ones. Then, we are going to sort these elements
|
* alphabetically by name - name acts as a unique identifier. Finally, we
|
* are going to compare adjacent elements, and if names do match (the same
|
* element), we will check if such an element should be marked for update.
|
* Otherwise, element is added or removed. */
|
|
ctl->updates_count = count + ctl->elems_count;
|
ctl->updates = malloc(sizeof(*ctl->updates) * ctl->updates_count);
|
|
struct ctl_elem_update *_tmp = ctl->updates;
|
size_t i;
|
|
for (i = 0; i < count; i++, _tmp++) {
|
strcpy(_tmp->name, elems[i].name);
|
_tmp->event_mask = SND_CTL_EVENT_MASK_REMOVE;
|
_tmp->_elem = &elems[i];
|
}
|
for (i = 0; i < ctl->elems_count; i++, _tmp++) {
|
strcpy(_tmp->name, ctl->elems[i].name);
|
_tmp->event_mask = SND_CTL_EVENT_MASK_ADD;
|
_tmp->_elem = &ctl->elems[i];
|
}
|
|
qsort(ctl->updates, ctl->updates_count, sizeof(*ctl->updates), bluealsa_ctl_elem_update_cmp);
|
|
for (i = 0; i + 1 < ctl->updates_count; i++)
|
if (strcmp(ctl->updates[i].name, ctl->updates[i + 1].name) == 0) {
|
ctl->updates[i].event_mask = ctl->updates[i + 1].event_mask = 0;
|
if (bluealsa_ctl_elem_cmp(ctl->updates[i]._elem, ctl->updates[i + 1]._elem) != 0)
|
ctl->updates[i].event_mask = SND_CTL_EVENT_MASK_VALUE;
|
i++;
|
}
|
|
free(devices);
|
free(transports);
|
free(elems);
|
|
return bluealsa_read_event(ext, id, event_mask);
|
}
|
|
static const snd_ctl_ext_callback_t bluealsa_snd_ctl_ext_callback = {
|
.close = bluealsa_close,
|
.elem_count = bluealsa_elem_count,
|
.elem_list = bluealsa_elem_list,
|
.find_elem = bluealsa_find_elem,
|
.get_attribute = bluealsa_get_attribute,
|
.get_integer_info = bluealsa_get_integer_info,
|
.read_integer = bluealsa_read_integer,
|
.write_integer = bluealsa_write_integer,
|
.subscribe_events = bluealsa_subscribe_events,
|
.read_event = bluealsa_read_event,
|
};
|
|
SND_CTL_PLUGIN_DEFINE_FUNC(bluealsa) {
|
(void)root;
|
|
snd_config_iterator_t i, next;
|
const char *interface = "hci0";
|
const char *battery = "no";
|
struct bluealsa_ctl *ctl;
|
int ret;
|
|
snd_config_for_each(i, next, conf) {
|
snd_config_t *n = snd_config_iterator_entry(i);
|
|
const char *id;
|
if (snd_config_get_id(n, &id) < 0)
|
continue;
|
|
if (strcmp(id, "comment") == 0 ||
|
strcmp(id, "type") == 0 ||
|
strcmp(id, "hint") == 0)
|
continue;
|
|
if (strcmp(id, "interface") == 0) {
|
if (snd_config_get_string(n, &interface) < 0) {
|
SNDERR("Invalid type for %s", id);
|
return -EINVAL;
|
}
|
continue;
|
}
|
if (strcmp(id, "battery") == 0) {
|
if (snd_config_get_string(n, &battery) < 0) {
|
SNDERR("Invalid type for %s", id);
|
return -EINVAL;
|
}
|
continue;
|
}
|
|
SNDERR("Unknown field %s", id);
|
return -EINVAL;
|
}
|
|
if ((ctl = calloc(1, sizeof(*ctl))) == NULL)
|
return -ENOMEM;
|
|
if ((ctl->fd = bluealsa_open(interface)) == -1 ||
|
(ctl->event_fd = bluealsa_open(interface)) == -1) {
|
SNDERR("BlueALSA connection failed: %s", strerror(errno));
|
ret = -errno;
|
goto fail;
|
}
|
|
ctl->ext.version = SND_CTL_EXT_VERSION;
|
ctl->ext.card_idx = 0;
|
strncpy(ctl->ext.id, "bluealsa", sizeof(ctl->ext.id) - 1);
|
strncpy(ctl->ext.driver, "BlueALSA", sizeof(ctl->ext.driver) - 1);
|
strncpy(ctl->ext.name, "BlueALSA", sizeof(ctl->ext.name) - 1);
|
strncpy(ctl->ext.longname, "Bluetooth Audio Hub Controller", sizeof(ctl->ext.longname) - 1);
|
strncpy(ctl->ext.mixername, "BlueALSA Plugin", sizeof(ctl->ext.mixername) - 1);
|
ctl->battery = strcmp(battery, "yes") == 0;
|
|
ctl->ext.callback = &bluealsa_snd_ctl_ext_callback;
|
ctl->ext.private_data = ctl;
|
ctl->ext.poll_fd = ctl->event_fd;
|
|
if ((ret = snd_ctl_ext_create(&ctl->ext, name, mode)) < 0)
|
goto fail;
|
|
*handlep = ctl->ext.handle;
|
return 0;
|
|
fail:
|
if (ctl->fd != -1)
|
close(ctl->fd);
|
if (ctl->event_fd != -1)
|
close(ctl->event_fd);
|
free(ctl);
|
return ret;
|
}
|
|
SND_CTL_PLUGIN_SYMBOL(bluealsa);
|
