diff options
Diffstat (limited to 'plugins/lib/bluealsa')
| -rw-r--r-- | plugins/lib/bluealsa/CMakeLists.txt | 51 | ||||
| -rw-r--r-- | plugins/lib/bluealsa/hal-bluealsa-transports.c | 153 | ||||
| -rw-r--r-- | plugins/lib/bluealsa/hal-bluealsa-transports.h | 53 | ||||
| -rw-r--r-- | plugins/lib/bluealsa/hal-bluealsa-watch.h | 29 | ||||
| -rw-r--r-- | plugins/lib/bluealsa/hal-bluealsa.c | 723 | ||||
| -rw-r--r-- | plugins/lib/bluealsa/hal-bluealsa.h | 21 |
6 files changed, 1030 insertions, 0 deletions
diff --git a/plugins/lib/bluealsa/CMakeLists.txt b/plugins/lib/bluealsa/CMakeLists.txt new file mode 100644 index 0000000..699ccc4 --- /dev/null +++ b/plugins/lib/bluealsa/CMakeLists.txt @@ -0,0 +1,51 @@ +########################################################################### +# Copyright 2018 IoT.bzh +# +# author: Thierry Bultel <thierry.bultel@iot.bzh> +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +########################################################################### + + +PROJECT_TARGET_ADD(hal-bluealsa) + + pkg_check_modules(BLUEALSA REQUIRED bluealsa>=1.3.1) + + # Define targets + ADD_LIBRARY(${TARGET_NAME} MODULE + hal-bluealsa.c + hal-bluealsa-transports.c + ) + + # Alsa Plugin properties + SET_TARGET_PROPERTIES(${TARGET_NAME} PROPERTIES + LABELS "PLUGIN" + PREFIX "" + SUFFIX ".ctlso" + OUTPUT_NAME ${TARGET_NAME} + ) + + # Library dependencies (include updates automatically) + TARGET_LINK_LIBRARIES(${TARGET_NAME} + afb-helpers + ctl-utilities + ${BLUEALSA_LIBRARIES} + ${link_libraries} + ) + + TARGET_COMPILE_OPTIONS(${TARGET_NAME} PUBLIC ${BLUEALSA_CFLAGS}) + + target_include_directories(${TARGET_NAME} + PRIVATE "${CMAKE_SOURCE_DIR}/app-controller/ctl-lib" + PRIVATE "${CMAKE_SOURCE_DIR}/4a-hal/4a-hal-utilities" + ) diff --git a/plugins/lib/bluealsa/hal-bluealsa-transports.c b/plugins/lib/bluealsa/hal-bluealsa-transports.c new file mode 100644 index 0000000..2c58023 --- /dev/null +++ b/plugins/lib/bluealsa/hal-bluealsa-transports.c @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2018 "IoT.bzh" + * Author : Thierry Bultel <thierry.bultel@iot.bzh> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <malloc.h> + +#include "hal-bluealsa-transports.h" + + +static bool halBlueAlsaTransportMatch( + const struct ba_msg_transport * transport1, + const struct ba_msg_transport * transport2); + +int halBlueAlsaTransportsInit(bluealsa_transport_t * list) { + CDS_INIT_LIST_HEAD(&list->list); + return 0; +} + +bluealsa_transport_t * halBlueAlsaTransportsAdd( + const bluealsa_watch * watch, + bluealsa_transport_t * list, + const struct ba_msg_transport * transport) { + + bluealsa_transport_t * newTransport = (bluealsa_transport_t*) calloc(1, sizeof(bluealsa_transport_t)); + if (newTransport == NULL) + goto fail; + + memcpy(&newTransport->transport, transport, sizeof(struct ba_msg_transport)); + + newTransport->watch = watch; + + CDS_INIT_LIST_HEAD(&newTransport->list); + cds_list_add(&newTransport->list, &list->list); + + return newTransport; +fail: + return NULL; + +} + +bool halBlueAlsaTransportFind( + const bluealsa_watch * watch, + bluealsa_transport_t * list, + const struct ba_msg_transport * transport) { + + bluealsa_transport_t *tmp; + bool found = false; + cds_list_for_each_entry(tmp, &list->list, list) { + struct ba_msg_transport * _transport = &tmp->transport; + + if (watch != tmp->watch) + continue; + + if (!halBlueAlsaTransportMatch(_transport, transport)) + continue; + + found = true; + break; + } + return found; +} + + +int halBlueAlsaTransportUpdate( + const bluealsa_watch * watch, + bluealsa_transport_t * list, + const struct ba_msg_transport *transports, + size_t nb, + transport_destructor destructor) { + + bluealsa_transport_t *transport, *sav; + + cds_list_for_each_entry_safe(transport, sav, &list->list, list) { + struct ba_msg_transport * ba_transport1 = &transport->transport; + + if (watch != transport->watch) + continue; + + bool found = false; + + for (int ix = 0; ix<nb; ix++) { + const struct ba_msg_transport * ba_transport2 = &transports[ix]; + + if (halBlueAlsaTransportMatch(ba_transport1, ba_transport2)) { + found = true; + break; + } + } + + if (found) + continue; + + char transportS[HAL_BLUEALSA_TRANSPORT_LEN_MAX]; + + AFB_ApiInfo(watch->plugin->api, + "Unregister transport %s", + halBlueAlsaTransportAsString(transportS, HAL_BLUEALSA_TRANSPORT_LEN_MAX, &transport->transport)); + + cds_list_del(&transport->list); + if (destructor) { + destructor(transport); + } + + free(transport->transactionUidS); + free(transport); + + } + + return 0; +} + + +static bool halBlueAlsaTransportMatch(const struct ba_msg_transport * transport1, const struct ba_msg_transport * transport2) { + bool ret = false; + + if (transport1->type != transport2->type) + goto done; + + if (transport1->stream != transport2->stream) + goto done; + + if (bacmp(&transport1->addr, &transport2->addr) != 0) { + goto done; + } + ret = true; +done: + return ret; +} + + +char * halBlueAlsaTransportAsString(char * buff, size_t len, const struct ba_msg_transport * transport) { + char addr[18]; + + ba2str(&transport->addr, addr); + snprintf(buff, len, "%s,%s,%s", addr, + transport->type == BA_PCM_TYPE_A2DP?"a2dp":"sco", + transport->stream == BA_PCM_STREAM_PLAYBACK?"playback":"capture"); + + return buff; +} diff --git a/plugins/lib/bluealsa/hal-bluealsa-transports.h b/plugins/lib/bluealsa/hal-bluealsa-transports.h new file mode 100644 index 0000000..0c5d6a4 --- /dev/null +++ b/plugins/lib/bluealsa/hal-bluealsa-transports.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2018 "IoT.bzh" + * Author : Thierry Bultel <thierry.bultel@iot.bzh> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __INC_HAL_BLUEALSA_TRANSPORT_H +#define __INC_HAL_BLUEALSA_TRANSPORT_H + +#include <bluealsa/bluealsa.h> +#include <stdbool.h> +#include <urcu/list.h> + +#include "afb-definitions.h" +#include "hal-bluealsa-watch.h" + +typedef struct { + const bluealsa_watch * watch; /* owner */ + struct cds_list_head list; + struct ba_msg_transport transport; + char * transactionUidS; +} bluealsa_transport_t; + +extern int halBlueAlsaTransportsInit(bluealsa_transport_t * list); + +extern bluealsa_transport_t * halBlueAlsaTransportsAdd(const bluealsa_watch * watch, bluealsa_transport_t * list, const struct ba_msg_transport * transport); +extern bool halBlueAlsaTransportFind(const bluealsa_watch * watch, bluealsa_transport_t * list, const struct ba_msg_transport * transport); + +typedef int (*transport_destructor)(bluealsa_transport_t *); + +extern int halBlueAlsaTransportUpdate( + const bluealsa_watch * watch, + bluealsa_transport_t * list, + const struct ba_msg_transport *transports, + size_t nb, + transport_destructor); + +#define HAL_BLUEALSA_TRANSPORT_LEN_MAX 64 + +extern char * halBlueAlsaTransportAsString(char * s, size_t len, const struct ba_msg_transport * ); + +#endif /* __INC_HAL_BLUEALSA_TRANSPORT_H */ diff --git a/plugins/lib/bluealsa/hal-bluealsa-watch.h b/plugins/lib/bluealsa/hal-bluealsa-watch.h new file mode 100644 index 0000000..114f515 --- /dev/null +++ b/plugins/lib/bluealsa/hal-bluealsa-watch.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2018 "IoT.bzh" + * Author : Thierry Bultel <thierry.bultel@iot.bzh> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __INC_HAL_BLUEALSA_WATCH_H +#define __INC_HAL_BLUEALSA_WATCH_H + +#include <ctl-config.h> + +typedef struct { + int fd; + const char * interface; + CtlPluginT * plugin; +} bluealsa_watch; + +#endif /* __INC_HAL_BLUEALSA_WATCH_H */ diff --git a/plugins/lib/bluealsa/hal-bluealsa.c b/plugins/lib/bluealsa/hal-bluealsa.c new file mode 100644 index 0000000..c8cfe98 --- /dev/null +++ b/plugins/lib/bluealsa/hal-bluealsa.c @@ -0,0 +1,723 @@ +/* + * Copyright (C) 2018 "IoT.bzh" + * Author : Thierry Bultel <thierry.bultel@iot.bzh> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE +#include <stdio.h> +#include <unistd.h> + +#include <wrap-json.h> + +#include <errno.h> +#include <ctl-config.h> +#include <systemd/sd-event.h> +#include <bluealsa/bluealsa.h> + +#include "hal-bluealsa.h" + +#define HAL_BLUEALSA_PLUGIN_NAME "hal-bluealsa" + +#define SCO_TALK_RATE 44100 +#define SCO_TALK_FORMAT "S16_LE" + +#define SCO_TALK_ZONE "sco_talk_zone" +#define SCO_CHANNEL_MONO "sco-mono" + +/* forward static declarations */ +static int halBlueAlsaTransportEventCB(sd_event_source* src, int fd, uint32_t revents, void* userData); +static int halBlueAlsaFetchTransports(bluealsa_watch * plugin); +static int halBlueAlsaRegisterAll(CtlPluginT* plugin); +static int halBlueAlsaRegister(CtlPluginT* plugin, const char * interface); + +CTLP_CAPI_REGISTER(HAL_BLUEALSA_PLUGIN_NAME) + + +// Call at initialization time ('requires' are forbidden at this stage) +CTLP_ONLOAD(plugin, callbacks) +{ + AFB_ApiNotice(plugin->api, "%s Plugin Registered correctly: uid='%s' 'info='%s'", HAL_BLUEALSA_PLUGIN_NAME, plugin->uid, plugin->info); + return 0; +} + + +CTLP_INIT(plugin, callbacks) +{ + json_object *actionsToAdd = NULL; + CtlConfigT *ctrlConfig; + + wrap_json_pack(&actionsToAdd, "{s:s s:s s:s}", + "uid", "init-bluealsa-plugin", + "info", "Init Bluez-Alsa hal plugin", + "action", "plugin://hal-bluealsa#init"); + + if (!(ctrlConfig = (CtlConfigT *) AFB_ApiGetUserData(plugin->api))) { + AFB_ApiError(plugin->api, "Can't get current hal controller config"); + goto fail; + } + + int idx = 0; + while (ctrlConfig->sections[idx].key && strcasecmp(ctrlConfig->sections[idx].key, "onload")) + idx++; + + if (!ctrlConfig->sections[idx].key) { + AFB_ApiError(plugin->api, "Wasn't able to add '%s' as a new onload, 'onload' section not found", json_object_get_string(actionsToAdd)); + goto fail; + } + + if(AddActionsToSection(plugin->api, &ctrlConfig->sections[idx], actionsToAdd, 0)) { + AFB_ApiError(plugin->api, "Wasn't able to add '%s' as a new onload to %s", json_object_get_string(actionsToAdd), ctrlConfig->sections[idx].uid); + goto fail; + } + + AFB_ApiNotice(plugin->api, "Plugin initialization of %s plugin correctly done", HAL_BLUEALSA_PLUGIN_NAME); + + return 0; +fail: + json_object_put(actionsToAdd); + return -1; +} + + +// Call at controller onload time +CTLP_CAPI(init, source, argsJ, queryJ) +{ + AFB_ApiNotice(source->api, "Controller onload event"); + + CtlPluginT * plugin = source->plugin; + + hal_bluealsa_plugin_data_t * pluginData = (hal_bluealsa_plugin_data_t*) calloc(1, sizeof(hal_bluealsa_plugin_data_t)); + int error; + + /* + * "params": { + "sco": { + "mic": "2CH-GENERIC-USB", + "zone": "full-stereo", + "delayms": 300 + }, + "a2dp": { + "zone": "full-stereo", + "delayms": 1000 + } + } + */ + + json_object * scoParamsJ = NULL; + json_object * a2dpParamsJ = NULL; + + error = wrap_json_unpack(plugin->paramsJ, "{s?o,s?o !}", + "sco", &scoParamsJ, + "a2dp", &a2dpParamsJ); + + if (error) { + AFB_ApiError(plugin->api, "%s: wrong parameters", __func__); + goto fail; + } + + if (scoParamsJ) { + AFB_ApiInfo(plugin->api, "%s: sco parameters: %s", __func__, json_object_get_string(scoParamsJ)); + error = wrap_json_unpack(scoParamsJ, "{s:s,s:s,s?i !}", + "mic", &pluginData->sco.mic, + "zone", &pluginData->sco.speaker, + "delayms", &pluginData->sco.delayms); + if (error) { + AFB_ApiError(plugin->api, "%s: wrong sco parameters: err %s", __func__, wrap_json_get_error_string(error)); + goto fail; + } + } + + if (a2dpParamsJ) { + AFB_ApiInfo(plugin->api, "%s: a2dp parameters: %s", __func__, json_object_get_string(a2dpParamsJ)); + error = wrap_json_unpack(a2dpParamsJ, "{s:s,s?i !}", + "zone", &pluginData->a2dp.zone, + "delayms", &pluginData->a2dp.delayms); + if (error) { + AFB_ApiError(plugin->api, "%s: wrong a2dp parameters: err=%s", __func__, wrap_json_get_error_string(error)); + goto fail; + } + } + + halBlueAlsaTransportsInit(&pluginData->transport_list); + + setPluginContext(plugin, pluginData); + + if (halBlueAlsaRegisterAll(plugin) != 0) + goto fail; + + return 0; +fail: + return -1; +} + + +static int halBlueAlsaTransportEventCB(sd_event_source* src, int fd, uint32_t revents, void* userData) { + + bluealsa_watch * watch = (bluealsa_watch *)userData; + CtlPluginT * plugin = watch->plugin; + + struct ba_msg_event event; + ssize_t ret; + + AFB_ApiDebug(plugin->api, "--- %s ----!", __func__); + + if ((revents & EPOLLIN) == 0) + goto done; + + if (revents & EPOLLHUP) { + AFB_ApiInfo(plugin->api, "Lost connection with bluealsa on interface %s", watch->interface); + sd_event_source_unref(src); + close(fd); + halBlueAlsaRegister(plugin, watch->interface); + goto done; + } + + while ((ret = recv(watch->fd, &event, sizeof(event), MSG_DONTWAIT)) == -1 && errno == EINTR) + continue; + + if (ret != sizeof(event)) { + AFB_ApiError(plugin->api, "Couldn't read event: %s", strerror(ret == -1 ? errno : EBADMSG)); + goto done; + } + + halBlueAlsaFetchTransports(watch); + +done: + return 0; +} + + +/* + * + * The following function builds that kind of json data and send it to smixer + * + * A2DP Case: + * + * { + "uid":"a2dp_F6:32:15:2A:80:70", + "captures": + { + "uid":"a2dp_listen_capture", + "pcmplug_params" : "bluealsa:HCI=hci0,DEV=F6:32:15:2A:80:70,PROFILE=a2dp", + "source" : { + "channels": [ + { + "uid": "a2dp-right", + "port": 0 + }, + { + "uid": "a2dp-left", + "port": 1 + } + ] + } + }, + "streams": + { + "uid" : "a2dp_listen_stream", + "source":"a2dp_listen_capture", + "zone": "full-stereo" + } + } + * + *----------------------------------------------------------------------------------- + * + * SCO Case: + * + * { + "uid":"sco_F6:32:15:2A:80:70",", + "captures": + { + "uid":"sco_listen_capture", + "pcmplug_params" : "bluealsa:HCI=hci0,DEV=F6:32:15:2A:80:70,PROFILE=sco", + "source" : { + "channels": [ + { + "uid": "sco-right", + "port": 0 + }, + { + "uid": "sco-left", + "port": 1 + } + ] + } + }, + "playbacks" : + { + "uid"="sco_talk_playback", + "pcmplug_params" : "bluealsa:HCI=hci0,DEV=F6:32:15:2A:80:70,PROFILE=sco", + "params": { + "rate": 44100, + "format": "S16_LE", + }, + "sink": { + "channels": [ + { + "uid": "sco-mono" + } + ] + } + }, + "zones" : [ + { + "uid": "sco_talk_zone", + "sink": [ + { + "target": "sco-mono", + "channel": 0, + "volume": 0.5 + }, + { + "target": "sco-mono", + "channel": 1, + "volume": 0.5 + } + ] + } + ] , + "streams": [ + { + "uid" : "sco_listen_stream", + "source":"sco_listen_capture", + "zone": "full-stereo", + "delayms": 300 + }, + { + "uid" : "sco_talk_stream", + "source": "2CH-GENERIC-USB", + "zone": "sco_talk_zone", + "delayms": 300 + } + ] + } + * + * */ + +static json_object* halBlueAlsaA2DPTransportChannels(const char * transportTypeS) { + json_object* channelRightJ; + json_object* channelLeftJ; + json_object* channelsJ = json_object_new_array(); + char * channelRightS; + char * channelLeftS; + + channelRightJ = json_object_new_object(); + if (asprintf(&channelRightS, "%s-right", transportTypeS) == -1) + goto fail; + + json_object_object_add(channelRightJ, "uid", json_object_new_string(channelRightS)); + json_object_object_add(channelRightJ, "port", json_object_new_int(0)); + + channelLeftJ = json_object_new_object(); + if (asprintf(&channelLeftS, "%s-left", transportTypeS) == -1) + goto fail; + + json_object_object_add(channelLeftJ, "uid", json_object_new_string(channelLeftS)); + json_object_object_add(channelLeftJ, "port", json_object_new_int(1)); + + json_object_array_add(channelsJ, channelRightJ); + json_object_array_add(channelsJ, channelLeftJ); +fail: + return channelsJ; +} + + +static json_object* halBlueAlsaSCOTransportChannels(const char * transportTypeS) { + json_object* channelMonoJ; + + json_object* channelsJ = json_object_new_array(); + char * channelMonoS; + + channelMonoJ = json_object_new_object(); + if (asprintf(&channelMonoS, "%s-mono", transportTypeS) == -1) + goto fail; + + json_object_object_add(channelMonoJ, "uid", json_object_new_string(channelMonoS)); + json_object_object_add(channelMonoJ, "port", json_object_new_int(0)); + + json_object_array_add(channelsJ, channelMonoJ); + +fail: + return channelsJ; +} + + +static json_object* halBlueAlsaPcmPlugParams(const char * interface, const char * addr, const char * transportTypeS) { + char * pcmplug_paramsS = NULL; + if (asprintf(&pcmplug_paramsS, "bluealsa:HCI=%s,DEV=%s,PROFILE=%s", interface, addr, transportTypeS) == -1) + goto fail; + return json_object_new_string(pcmplug_paramsS); +fail: + return NULL; +} + + +static json_object* halBlueAlsaListenCapture( + const char * listenCaptureS, + json_object * pcmplugParamsJ, + json_object * sourceJ) { + + json_object * captureJ = json_object_new_object(); + + json_object_object_add(captureJ, "uid", json_object_new_string(listenCaptureS)); + json_object_object_add(captureJ, "pcmplug_params", pcmplugParamsJ); + json_object_object_add(captureJ, "source", sourceJ); + + return captureJ; +} + +static json_object * halBlueAlsaTalkPlayback( + const char * talkPlaybackS, + json_object* pcmplugParamsJ, + json_object* paramsJ, + json_object* sinkJ ) { + + json_object * playbackJ = json_object_new_object(); + + json_object_object_add(playbackJ, "uid", json_object_new_string(talkPlaybackS)); + json_object_object_add(playbackJ, "pcmplug_params", pcmplugParamsJ); + json_object_object_add(playbackJ, "params", paramsJ); + json_object_object_add(playbackJ, "sink", sinkJ); + + return playbackJ; +} + +static json_object * halBlueAlsaScoTalkParamsJ() { + json_object * paramsJ = json_object_new_object(); + + json_object_object_add(paramsJ, "rate", json_object_new_int(SCO_TALK_RATE)); + json_object_object_add(paramsJ, "format", json_object_new_string(SCO_TALK_FORMAT)); + return paramsJ; +} + +static json_object * halBlueAlsaScoZone() { + json_object * zoneJ = json_object_new_object(); + json_object * sinkJ = json_object_new_array(); + json_object_object_add(zoneJ, "uid", json_object_new_string(SCO_TALK_ZONE)); + + json_object * channel1J = json_object_new_object(); + json_object_object_add(channel1J, "target" , json_object_new_string(SCO_CHANNEL_MONO)); + json_object_object_add(channel1J, "channel", json_object_new_int(0)); + json_object_object_add(channel1J, "volume", json_object_new_double(0.5)); + + json_object * channel2J = json_object_new_object(); + json_object_object_add(channel2J, "target" , json_object_new_string(SCO_CHANNEL_MONO)); + json_object_object_add(channel2J, "channel", json_object_new_int(1)); + json_object_object_add(channel2J, "volume", json_object_new_double(0.5)); + + json_object_array_add(sinkJ, channel1J); + json_object_array_add(sinkJ, channel2J); + + json_object_object_add(zoneJ, "sink", sinkJ); + + return zoneJ; +} + +static int halBlueAlsaAttachTransportStreams(bluealsa_transport_t * transport) { + int ret = -1; + const char* transportTypeS; + + struct ba_msg_transport * ba_transport = &transport->transport; + const bluealsa_watch * watch = transport->watch; + + CtlPluginT* plugin = watch->plugin; + hal_bluealsa_plugin_data_t * pluginData=getPluginContext(plugin); + + json_object* requestJ = NULL; + json_object* returnJ = NULL; + + json_object* sourceJ = NULL; + json_object* playbackJ = NULL; + + json_object* pcmplugParamsJ, *pcmplugParamsJ2 = NULL; + + json_object* streamsJ = NULL; + json_object* streamJ = NULL; + + json_object* zonesJ = NULL; + + char * playbackZoneS; + uint32_t delayms; + + if (ba_transport->type == BA_PCM_TYPE_SCO) { + transportTypeS = "sco"; + delayms = pluginData->sco.delayms; + playbackZoneS = pluginData->sco.speaker; + } + else if (ba_transport->type == BA_PCM_TYPE_A2DP) { + transportTypeS = "a2dp"; + delayms = pluginData->a2dp.delayms; + playbackZoneS = pluginData->a2dp.zone; + } else { + AFB_ApiError(plugin->api, "%s: unsupported transport type", __func__ ); + goto fail; + } + + char * captureS = NULL; + if (asprintf(&captureS, "%s_listen_capture", transportTypeS) == -1) + goto fail; + + // for SCO only + char * playbackS = NULL; + if (asprintf(&playbackS, "%s_talk_playback", transportTypeS) == -1) + goto fail; + + char * transactionUidS = NULL; + char * streamS = NULL; + + char addr[18]; + ba2str(&ba_transport->addr, addr); + + requestJ = json_object_new_object(); + if (!requestJ) + goto fail; + + if (asprintf(&transactionUidS, "%s_%s", transportTypeS, addr) == -1) + goto fail; + + json_object_object_add(requestJ, "uid", json_object_new_string(transactionUidS)); + + pcmplugParamsJ = halBlueAlsaPcmPlugParams(watch->interface, addr, transportTypeS); + + sourceJ = json_object_new_object(); + if (ba_transport->type == BA_PCM_TYPE_A2DP) + json_object_object_add(sourceJ, "channels", halBlueAlsaA2DPTransportChannels(transportTypeS)); + else + json_object_object_add(sourceJ, "channels", halBlueAlsaSCOTransportChannels(transportTypeS)); + + json_object_object_add(requestJ, "captures", halBlueAlsaListenCapture(captureS, pcmplugParamsJ, sourceJ)); + + if (ba_transport->type == BA_PCM_TYPE_SCO) { + playbackJ = json_object_new_object(); + // that is a shame that deep copy in not available in the current json-c version + pcmplugParamsJ2 = halBlueAlsaPcmPlugParams(watch->interface, addr, transportTypeS); + json_object * paramsJ = halBlueAlsaScoTalkParamsJ(); + + json_object_object_add(playbackJ, "channels", halBlueAlsaSCOTransportChannels(transportTypeS)); + json_object_object_add(requestJ, "playbacks", halBlueAlsaTalkPlayback(playbackS, pcmplugParamsJ2, paramsJ, playbackJ)); + + } + + /* ZONES */ + + if (ba_transport->type == BA_PCM_TYPE_SCO) { + zonesJ = json_object_new_array(); + json_object_array_add(zonesJ, halBlueAlsaScoZone()); + json_object_object_add(requestJ, "zones", zonesJ); + } + + /* STREAMS */ + + /* Build the array of streams */ + streamsJ = json_object_new_array(); + + streamJ = json_object_new_object(); + if (asprintf(&streamS, "%s_listen_stream", transportTypeS) == -1) + goto fail; + + json_object_object_add(streamJ, "uid", json_object_new_string(streamS)); + json_object_object_add(streamJ, "source", json_object_new_string(captureS)); + json_object_object_add(streamJ, "zone", json_object_new_string(playbackZoneS)); + if (delayms != 0) { + json_object_object_add(streamJ, "delayms", json_object_new_int(delayms)); + } + + json_object_array_add(streamsJ, streamJ); + + /* In case of SCO, to have full-duplex, we instantiate a stream for talk */ + if (ba_transport->type == BA_PCM_TYPE_SCO ) { + + streamJ = json_object_new_object(); + if (asprintf(&streamS, "%s_talk_stream", transportTypeS) == -1) + goto fail; + + json_object_object_add(streamJ, "uid", json_object_new_string(streamS)); + json_object_object_add(streamJ, "source", json_object_new_string(pluginData->sco.mic)); + json_object_object_add(streamJ, "zone", json_object_new_string(SCO_TALK_ZONE)); + if (delayms != 0) + json_object_object_add(streamJ, "delayms", json_object_new_int(delayms)); + json_object_array_add(streamsJ, streamJ); + } + + json_object_object_add(requestJ, "streams", streamsJ); + + /* In softmixer, this will create a transaction verb (whose name is transactionUidS), + * will be used later to destroy all the created objects upon transport removal */ + + if (AFB_ServiceSync(plugin->api, SMIXER_API_NAME, "attach", requestJ, &returnJ)) { + AFB_ApiError(plugin->api, "Error calling attach verb of mixer" ); + goto done; + } + + transport->transactionUidS = transactionUidS; + + if (returnJ) + json_object_put(returnJ); + + ret = 0; + goto done; + +fail: + return -1; +done: + AFB_ApiDebug(plugin->api, "DONE."); + return ret; +} + + +static int halBluezAlsaRemoveTransportStream(bluealsa_transport_t * transport) { + + CtlPluginT * plugin = transport->watch->plugin; + json_object* requestJ = NULL; + json_object* returnJ = NULL; + + AFB_ApiInfo(plugin->api, "Call transaction detach verb %s", transport->transactionUidS); + if (transport->transactionUidS == NULL) + goto fail; + + requestJ = json_object_new_object(); + if (!requestJ) + goto fail; + + json_object_object_add(requestJ, "action", json_object_new_string("remove")); + + if (AFB_ServiceSync(plugin->api, SMIXER_API_NAME, transport->transactionUidS, requestJ, &returnJ)) { + AFB_ApiError(plugin->api, "Error calling attach verb of mixer" ); + goto fail; + } + + if (returnJ) + json_object_put(returnJ); + + return 0; + +fail: + return -1; +} + +static int halBlueAlsaFetchTransports(bluealsa_watch * watch) { + ssize_t nbTransports; + struct ba_msg_transport *transports; + CtlPluginT * plugin = watch->plugin; + + hal_bluealsa_plugin_data_t * pluginData = (hal_bluealsa_plugin_data_t*)getPluginContext(plugin); + bluealsa_transport_t * transport_list = &pluginData->transport_list; + bluealsa_transport_t * transport = NULL; + + AFB_ApiDebug(plugin->api, "Fetching available transports of interface %s", watch->interface); + + if ((nbTransports = bluealsa_get_transports(watch->fd, &transports)) == -1) { + AFB_ApiError(plugin->api, "Couldn't get transports: %s", strerror(errno)); + goto done; + } + + AFB_ApiDebug(plugin->api, "Got %zu transport(s)", nbTransports); + + for (int ix=0; ix<nbTransports; ix++) { + char addr[18]; + struct ba_msg_transport * ba_transport = &transports[ix]; + ba2str(&ba_transport->addr, addr); + const char * typeS; + if (ba_transport->type == BA_PCM_TYPE_SCO) + typeS = "sco"; + else if (ba_transport->type == BA_PCM_TYPE_A2DP) + typeS = "a2dp"; + else + typeS = "unknown"; + + AFB_ApiDebug(plugin->api, "Transport %d: type %s, dev %s", ix, typeS, addr); + + if (halBlueAlsaTransportFind(watch, transport_list, ba_transport)) { + AFB_ApiDebug(plugin->api, "This transport is already streamed"); + continue; + } + + AFB_ApiInfo(plugin->api, "Registering transport type %s, dev %s", typeS, addr); + transport = halBlueAlsaTransportsAdd(watch, transport_list, ba_transport); + if (transport == NULL) { + AFB_ApiError(plugin->api, "Failed to register this transport"); + goto done; + } + + // Do the softmixer stuff + if (halBlueAlsaAttachTransportStreams(transport) != 0) { + AFB_ApiError(plugin->api, "Failed create transport streams"); + goto done; + } + + AFB_ApiDebug(plugin->api, "%s: transaction id %s", __func__, transport->transactionUidS); + + } + + halBlueAlsaTransportUpdate(watch, transport_list, transports, nbTransports , halBluezAlsaRemoveTransportStream); + +done: + free(transports); + return 0; +} + +static int halBlueAlsaRegister(CtlPluginT* plugin, const char * interface) { + int ret; + sd_event *sdLoop; + sd_event_source* evtsrc; + + sdLoop = AFB_GetEventLoop(plugin->api); + + enum ba_event transport_mask = BA_EVENT_TRANSPORT_ADDED | +// BA_EVENT_TRANSPORT_CHANGED | + BA_EVENT_TRANSPORT_REMOVED; + + bluealsa_watch * watch = (bluealsa_watch *)malloc(sizeof(bluealsa_watch)); + if (watch == NULL) + goto fail; + + watch->interface = interface; + watch->plugin = plugin; + + if ((watch->fd = bluealsa_open(interface)) == -1) { + AFB_ApiError(plugin->api, "BlueALSA connection failed: %s", strerror(errno)); + goto fail; + } + + halBlueAlsaFetchTransports(watch); + + if (bluealsa_subscribe(watch->fd, transport_mask) == -1) { + AFB_ApiError(plugin->api, "BlueALSA subscription failed: %s", strerror(errno)); + goto fail; + } + + // Register sound event to the main loop of the binder + if ((ret = sd_event_add_io(sdLoop, &evtsrc, watch->fd, EPOLLIN, halBlueAlsaTransportEventCB, watch)) < 0) { + AFB_ApiError(plugin->api, + "%s: Failed to register event fd to io loop", + __func__); + goto fail; + } + return 0; + +fail: + if (watch->fd) + close(watch->fd); + if (watch) + free(watch); + return -1; +} + + +static int halBlueAlsaRegisterAll(CtlPluginT* plugin) { + /* TODO add a watch to all the available interfaces */ + halBlueAlsaRegister(plugin, "hci0"); + return 0; +} diff --git a/plugins/lib/bluealsa/hal-bluealsa.h b/plugins/lib/bluealsa/hal-bluealsa.h new file mode 100644 index 0000000..86fe45a --- /dev/null +++ b/plugins/lib/bluealsa/hal-bluealsa.h @@ -0,0 +1,21 @@ +#ifndef __INC_HAL_BLUEALSA_H +#define __INC_HAL_BLUEALSA_H + +#include "hal-bluealsa-transports.h" + +typedef struct { + bluealsa_transport_t transport_list; + struct { + char * mic; // capture for talking + char * speaker; // playback zone + uint32_t delayms; + } sco; + struct { + char * zone; + uint32_t delayms; + } a2dp; +} hal_bluealsa_plugin_data_t; + +#define SMIXER_API_NAME "smixer" + +#endif /* __INC_HAL_BLUEALSA_H */ |