[4A/bluez-alsa]: use temporary solution pcm alsa-proxy

This plugin always keeps the opened PCM in a consistent state
for the sound application, despite of bluez-alsa server or
device disconnection.

Bug: SPEC-1679

Change-Id: I0caaa6abe6fb9133b4d43479d452e542a04620c3
Signed-off-by: Ronan Le Martret <ronan.lemartret@iot.bzh>
Signed-off-by: Stephane Desneux <stephane.desneux@iot.bzh>

2 files changed, 1021 insertions, 0 deletions

diff --git a/meta-audio-4a-framework/recipes-connectivity/bluez-alsa/bluez-alsa/0001-Added-a-connection-proxy-plugin.patch b/meta-audio-4a-framework/recipes-connectivity/bluez-alsa/bluez-alsa/0001-Added-a-connection-proxy-plugin.patch
new file mode 100644
index 00000000..fd0f4ea8
--- /dev/null
+++ b/meta-audio-4a-framework/recipes-connectivity/bluez-alsa/bluez-alsa/0001-Added-a-connection-proxy-plugin.patch
@@ -0,0 +1,1010 @@
+From e730ec274c16d5ba390cb1cd29a8ada16204dd44 Mon Sep 17 00:00:00 2001
+From: Thierry Bultel <thierry.bultel@iot.bzh>
+Date: Wed, 29 Aug 2018 17:02:52 +0200
+Subject: [PATCH] Added a connection proxy plugin
+
+Introduces a new ioplug plugin for alsa.
+This plugin always keeps the opened PCM in a consitent state
+for the sound application, despite of bluealsa server or
+or device disconnection.
+For now, only playback is supported, and only one PCM per application
+is allowed.
+The sound application is in charge of telling the plugin what device
+to use; the bluealsa_proxy_set_remote_device can be opened through
+snd_dlopen. Please see the provided README.md for more details.
+
+Signed-off-by: Stephane Desneux <stephane.desneux@iot.bzh>
+---
+ src/asound/20-bluealsa_proxy.conf |  41 ++
+ src/asound/Makefile.am            |  19 +-
+ src/asound/README.md              |  61 +++
+ src/asound/bluealsa-pcm-proxy.c   | 811 ++++++++++++++++++++++++++++++++++++++
+ 4 files changed, 931 insertions(+), 1 deletion(-)
+ create mode 100644 src/asound/20-bluealsa_proxy.conf
+ create mode 100644 src/asound/README.md
+ create mode 100644 src/asound/bluealsa-pcm-proxy.c
+
+diff --git a/src/asound/20-bluealsa_proxy.conf b/src/asound/20-bluealsa_proxy.conf
+new file mode 100644
+index 0000000..dec1cd8
+--- /dev/null
++++ b/src/asound/20-bluealsa_proxy.conf
+@@ -0,0 +1,41 @@
++# BlueALSA integration setup
++
++defaults.bluealsa.interface "hci0"
++defaults.bluealsa.profile "a2dp"
++defaults.bluealsa.delay 20000
++defaults.bluealsa.battery "yes"
++
++ctl.bluealsa {
++	@args [ HCI BAT ]
++	@args.HCI {
++		type string
++		default {
++			@func refer
++			name defaults.bluealsa.interface
++		}
++	}
++	@args.BAT {
++		type string
++		default {
++			@func refer
++			name defaults.bluealsa.battery
++		}
++	}
++	type bluealsa
++	interface $HCI
++	battery $BAT
++}
++
++pcm.bluealsa_proxy {
++	type plug
++	slave.pcm {
++		type bluealsa_proxy
++	}
++	hint {
++		show {
++			@func refer
++			name defaults.namehint.extended
++		}
++		description "Bluetooth Audio Hub Proxy"
++	}
++}
+diff --git a/src/asound/Makefile.am b/src/asound/Makefile.am
+index 75a2dc3..d3b2dfd 100644
+--- a/src/asound/Makefile.am
++++ b/src/asound/Makefile.am
+@@ -5,22 +5,34 @@ EXTRA_DIST = 20-bluealsa.conf
+ 
+ asound_module_ctl_LTLIBRARIES = libasound_module_ctl_bluealsa.la
+ asound_module_pcm_LTLIBRARIES = libasound_module_pcm_bluealsa.la
+-asound_module_data_DATA = 20-bluealsa.conf
++asound_module_pcm_proxy_LTLIBRARIES = libasound_module_pcm_bluealsa_proxy.la
++
++asound_module_data_DATA = 20-bluealsa.conf 20-bluealsa_proxy.conf
+ 
+ libasound_module_ctl_bluealsa_la_SOURCES = \
+ 	../shared/ctl-client.c \
+ 	../shared/log.c \
+ 	bluealsa-ctl.c
++	
+ libasound_module_pcm_bluealsa_la_SOURCES = \
+ 	../shared/ctl-client.c \
+ 	../shared/log.c \
+ 	../shared/rt.c \
+ 	bluealsa-pcm.c
+ 
++libasound_module_pcm_bluealsa_proxy_la_SOURCES = \
++	../shared/ctl-client.c \
++	../shared/log.c \
++	../shared/rt.c \
++	bluealsa-pcm-proxy.c
++
++
+ asound_module_ctldir = @ALSA_PLUGIN_DIR@
+ asound_module_pcmdir = @ALSA_PLUGIN_DIR@
++asound_module_pcm_proxydir = @ALSA_PLUGIN_DIR@
+ asound_module_datadir = @ALSA_DATA_DIR@/alsa.conf.d
+ 
++
+ AM_CFLAGS = \
+ 	-I$(top_srcdir)/src \
+ 	@ALSA_CFLAGS@ \
+@@ -34,3 +46,8 @@ libasound_module_ctl_bluealsa_la_LIBADD = \
+ libasound_module_pcm_bluealsa_la_LIBADD = \
+ 	@ALSA_LIBS@ \
+ 	@BLUEZ_LIBS@
++libasound_module_pcm_bluealsa_proxy_la_LIBADD = \
++	@ALSA_LIBS@ \
++	@BLUEZ_LIBS@
++
++	
+\ No newline at end of file
+diff --git a/src/asound/README.md b/src/asound/README.md
+new file mode 100644
+index 0000000..8ab52a8
+--- /dev/null
++++ b/src/asound/README.md
+@@ -0,0 +1,61 @@
++# ioplug proxy
++
++The ioplug proxy maintains a consitent state of the opened PCM.
++
++The application can call snd_pcm_open giving "bluealsa_proxy" as a card name.
++Only one PCM of this type can be opened by the application, and for now the
++hci interface is assumed to be hci0.
++
++To change to another one, just modify this line in 20-blualsa_proxu.conf
++defaults.bluealsa.interface "hci0"
++
++One the PCM is opened, which always succeeds regardless of the fact that there is 
++a bluetooth device connected or not, the application can set it dynamically using
++the bluealsa_proxy_set_remote_device function, like in this example code:
++
++```
++#define ALSA_BLUEZ_PROXY_LIB "/usr/lib/alsa-lib/libasound_module_pcm_bluealsa_proxy.so"
++#define ALSA_BLUEZ_PROXY_SETDEVICE "bluealsa_proxy_set_remote_device"
++
++typedef	int (*bluealsa_set_remote_device_ptr) (const char * interface, const char * device, const char * profile);
++
++static bluealsa_set_remote_device_ptr bluealsa_proxy_set_remote_device = NULL;
++
++void alsa_bluez_init() {
++	static bool initialized = false;
++	if (initialized)
++		goto failed;
++
++	char errbuf[256];
++	void * dl = snd_dlopen(ALSA_BLUEZ_PROXY_LIB, RTLD_NOW, errbuf, 256);
++	if (!dl) {
++		printf("Failed to open bluealsa proxy plugin\n");
++		goto failed;
++	}
++
++	void * func = snd_dlsym(dl, ALSA_BLUEZ_PROXY_SETDEVICE, SND_DLSYM_VERSION(SND_PCM_DLSYM_VERSION));
++	if (!func) {
++		printf("Unable to find %s symbol\n", ALSA_BLUEZ_PROXY_SETDEVICE);
++		goto failed;
++	}
++
++	bluealsa_proxy_set_remote_device = func;
++	initialized = true;
++
++failed:
++	return;
++}
++
++int alsa_bluez_set_device(const char * interface, const char * device, const char * profile) {
++	if (!bluealsa_proxy_set_remote_device)
++		return -1;
++
++	return bluealsa_proxy_set_remote_device(interface,device,profile);
++}
++
++...
++alsa_bluez_set_device("hci0","XX.XX.XX.XX.XX", "a2dp");	
++...
++
++```
++
+diff --git a/src/asound/bluealsa-pcm-proxy.c b/src/asound/bluealsa-pcm-proxy.c
+new file mode 100644
+index 0000000..4abab2b
+--- /dev/null
++++ b/src/asound/bluealsa-pcm-proxy.c
+@@ -0,0 +1,811 @@
++/*
++ * bluealsa-proxy-pcm.c
++ * Copyright (c) 2018 Thierry Bultel
++ *
++ * This file is a part of bluez-alsa.
++ *
++ * This project is licensed under the terms of the MIT license.
++ *
++ */
++
++#define _GNU_SOURCE
++#include <errno.h>
++#include <poll.h>
++#include <pthread.h>
++#include <signal.h>
++#include <stdbool.h>
++#include <stdlib.h>
++#include <string.h>
++#include <unistd.h>
++#include <sys/eventfd.h>
++#include <sys/ioctl.h>
++
++#include <alsa/asoundlib.h>
++#include <alsa/pcm_external.h>
++
++#include "shared/ctl-client.h"
++#include "shared/ctl-proto.h"
++#include "shared/log.h"
++#include "shared/rt.h"
++
++#undef debug
++#define debug printf
++
++#define INTERFACE_STR_MAXLEN	256
++#define BDADDR_STR_LEN			18
++#define PROFILE_STR_MAXLEN		16
++
++struct bluealsa_pcm {
++	snd_pcm_ioplug_t io;
++
++	/* bluealsa socket */
++	int fd;
++
++	/* event file descriptor */
++	int event_fd;
++
++	/* requested transport */
++	struct msg_transport * transport;
++	size_t pcm_buffer_size;
++
++	int pcm_fd;
++
++	/* virtual hardware - ring buffer */
++	snd_pcm_uframes_t io_ptr;
++	pthread_t io_thread;
++	bool io_started;
++
++	/* communication and encoding/decoding delay */
++	snd_pcm_sframes_t delay;
++	/* user provided extra delay component */
++	snd_pcm_sframes_t delay_ex;
++
++	/* ALSA operates on frames, we on bytes */
++	size_t frame_size;
++
++	/* In order to see whether the PCM has reached under-run (or over-run), we
++	 * have to know the exact position of the hardware and software pointers.
++	 * To do so, we could use the HW pointer provided by the IO plug structure.
++	 * This pointer is updated by the snd_pcm_hwsync() function, which is not
++	 * thread-safe (total disaster is guaranteed). Since we can not call this
++	 * function, we are going to use our own HW pointer, which can be updated
++	 * safely in our IO thread. */
++	snd_pcm_uframes_t io_hw_boundary;
++	snd_pcm_uframes_t io_hw_ptr;
++
++	char interface[INTERFACE_STR_MAXLEN];
++	bdaddr_t addr;
++	char profile[PROFILE_STR_MAXLEN];
++	enum pcm_type type;
++	enum pcm_stream stream;
++
++};
++
++typedef struct bluealsa_pcm bluealsa_pcm_t;
++
++static bluealsa_pcm_t * the_pcm = NULL;
++
++static int close_bluez_connection();
++static int open_bluez_connection();
++
++
++/**
++ * Helper function for closing PCM transport. */
++static int close_transport(struct bluealsa_pcm *pcm) {
++
++	debug("%s ...\n", __func__);
++	if (pcm->transport == NULL)
++		return 0;
++
++	int rv = bluealsa_close_transport(pcm->fd, pcm->transport);
++	int err = errno;
++
++	close(pcm->pcm_fd);
++	pcm->pcm_fd = -1;
++	errno = err;
++	return rv;
++}
++
++/**
++ * IO thread, which facilitates ring buffer. */
++static void *io_thread(void *arg) {
++	snd_pcm_ioplug_t *io = (snd_pcm_ioplug_t *)arg;
++
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	sigset_t sigset;
++	sigemptyset(&sigset);
++
++	/* Block signal, which will be used for pause/resume actions. */
++	sigaddset(&sigset, SIGIO);
++	/* Block SIGPIPE, so we could receive EPIPE while writing to the pipe
++	 * whose reading end has been closed. This will allow clean playback
++	 * termination. */
++	sigaddset(&sigset, SIGPIPE);
++
++	if ((errno = pthread_sigmask(SIG_BLOCK, &sigset, NULL)) != 0) {
++		SNDERR("Thread signal mask error: %s", strerror(errno));
++		goto final;
++	}
++
++wait_pcm_fd:
++
++	debug("PLUGIN io-thread: wait for pcm_fd\n");
++
++	/* In the capture mode, the PCM FIFO is opened in the non-blocking mode.
++	 * So right now, we have to synchronize write and read sides, otherwise
++	 * reading might return 0, which will be incorrectly recognized as FIFO
++	 * close signal, but in fact it means, that it was not opened yet. */
++	if (io->stream == SND_PCM_STREAM_CAPTURE) {
++
++		/* Is the data fd ready ? */
++		if (pcm->pcm_fd == -1) {
++			usleep(100*1000);	// TODO This should be replaced by a semaphore
++			goto wait_pcm_fd;
++		}
++
++		/* check both fd status */
++
++		struct pollfd pfds[2] = {
++				{ pcm->pcm_fd, POLLIN, 0 },
++				{ pcm->fd, 	POLLIN|POLLPRI, 0 }};
++
++		int ret = poll(pfds, 2, -1);
++		if (ret == -1) {
++			SNDERR("PCM FIFO poll error: %s", strerror(errno));
++			goto final;
++		}
++
++		short int evt0 = pfds[0].revents;
++		short int evt1 = pfds[1].revents;
++
++		if (evt1 & POLLHUP) {
++			debug("Server closed the connection\n");
++			close_bluez_connection();
++			open_bluez_connection();
++			usleep(100*1000); /* avoid spinning too fast /*/
++			goto wait_pcm_fd;
++		}
++
++		if (evt0 & POLLHUP) {
++			debug("Remote device disconnected\n");
++			close_bluez_connection();
++			open_bluez_connection();
++			usleep(100*1000);
++			goto wait_pcm_fd;
++		}
++	}
++
++	const snd_pcm_channel_area_t *areas = snd_pcm_ioplug_mmap_areas(io);
++
++	struct asrsync asrs;
++	asrsync_init(asrs, io->rate);
++
++	for (;;) {
++
++		int tmp;
++		switch (io->state) {
++		case SND_PCM_STATE_RUNNING:
++		case SND_PCM_STATE_DRAINING:
++			break;
++		case SND_PCM_STATE_DISCONNECTED:
++			debug("PLUGIN: DISCONNECTED\n");
++			goto final;
++		default:
++			sigwait(&sigset, &tmp);
++			asrsync_init(asrs, io->rate);
++		}
++
++		snd_pcm_uframes_t io_ptr = pcm->io_ptr;
++		snd_pcm_uframes_t io_buffer_size = io->buffer_size;
++		snd_pcm_uframes_t io_hw_ptr = pcm->io_hw_ptr;
++		snd_pcm_uframes_t io_hw_boundary = pcm->io_hw_boundary;
++		snd_pcm_uframes_t frames = io->period_size;
++		char *buffer = areas->addr + (areas->first + areas->step * io_ptr) / 8;
++		char *head = buffer;
++		ssize_t ret = 0;
++		size_t len;
++
++		/* If the leftover in the buffer is less than a whole period sizes,
++		 * adjust the number of frames which should be transfered. It has
++		 * turned out, that the buffer might contain fractional number of
++		 * periods - it could be an ALSA bug, though, it has to be handled. */
++		if (io_buffer_size - io_ptr < frames)
++			frames = io_buffer_size - io_ptr;
++
++		/* IO operation size in bytes */
++		len = frames * pcm->frame_size;
++		io_ptr += frames;
++
++		if (io_ptr >= io_buffer_size)
++			io_ptr -= io_buffer_size;
++
++		io_hw_ptr += frames;
++		if (io_hw_ptr >= io_hw_boundary)
++			io_hw_ptr -= io_hw_boundary;
++
++		if (io->stream == SND_PCM_STREAM_CAPTURE) {
++
++			/* Read the whole period "atomically". This will assure, that frames
++			 * are not fragmented, so the pointer can be correctly updated. */
++			while (len != 0 && (ret = read(pcm->pcm_fd, head, len)) != 0) {
++				if (ret == -1) {
++					if (errno == EINTR)
++						continue;
++
++					SNDERR("PCM FIFO read error: %s", strerror(errno));
++					goto final;
++				}
++				head += ret;
++				len -= ret;
++			}
++
++			/* something went wrong. this can be a server,
++			 * or device disconnection, or a device change request
++			 * from the client application */
++
++			if (ret == 0)
++				goto wait_pcm_fd;
++
++		}
++		else {
++
++			/* check for under-run and act accordingly */
++			if (io_hw_ptr > io->appl_ptr) {
++				io->state = SND_PCM_STATE_XRUN;
++				io_ptr = -1;
++				goto sync;
++			}
++
++			/* Perform atomic write - see the explanation above. */
++			do {
++				if ((ret = write(pcm->pcm_fd, head, len)) == -1) {
++					if (errno == EINTR)
++						continue;
++					SNDERR("PCM FIFO write error: %s", strerror(errno));
++					goto final;
++				}
++				head += ret;
++				len -= ret;
++			}
++			while (len != 0);
++
++			/* synchronize playback time */
++			asrsync_sync(&asrs, frames);
++		}
++
++sync:
++		pcm->io_ptr = io_ptr;
++		pcm->io_hw_ptr = io_hw_ptr;
++
++		eventfd_write(pcm->event_fd, 1);
++	}
++
++final:
++
++	debug("PLUGIN: io_thread exiting\n");
++
++	close_transport(pcm);
++	eventfd_write(pcm->event_fd, 0xDEAD0000);
++
++	return NULL;
++}
++
++static int bluealsa_proxy_start(snd_pcm_ioplug_t *io) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	debug("%s ...\n", __func__);
++
++	/* If the IO thread is already started, skip thread creation. Otherwise,
++	 * we might end up with a bunch of IO threads reading or writing to the
++	 * same FIFO simultaneously. Instead, just send resume signal. */
++	if (pcm->io_started) {
++		io->state = SND_PCM_STATE_RUNNING;
++		pthread_kill(pcm->io_thread, SIGIO);
++		return 0;
++	}
++
++	/* initialize delay calculation */
++	pcm->delay = 0;
++
++	if (pcm->transport && bluealsa_pause_transport(pcm->fd, pcm->transport, false) == -1) {
++		debug("Couldn't start PCM: %s\n", strerror(errno));
++		return -errno;
++	}
++
++	/* State has to be updated before the IO thread is created - if the state
++	 * does not indicate "running", the IO thread will be suspended until the
++	 * "resume" signal is delivered. This requirement is only (?) theoretical,
++	 * anyhow forewarned is forearmed. */
++	snd_pcm_state_t prev_state = io->state;
++	io->state = SND_PCM_STATE_RUNNING;
++
++	pcm->io_started = true;
++
++	return 0;
++}
++
++static int bluealsa_proxy_stop(snd_pcm_ioplug_t *io) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	debug("Stopping");
++	if (pcm->io_started) {
++		pcm->io_started = false;
++		pthread_cancel(pcm->io_thread);
++		pthread_join(pcm->io_thread, NULL);
++	}
++	return 0;
++}
++
++static snd_pcm_sframes_t bluealsa_proxy_pointer(snd_pcm_ioplug_t *io) {
++	struct bluealsa_pcm *pcm = io->private_data;
++	if (pcm->pcm_fd == -1)
++		return -ENODEV;
++
++	return pcm->io_ptr;
++}
++
++static int bluealsa_proxy_close(snd_pcm_ioplug_t *io) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	debug("Closing plugin\n");
++	close(pcm->fd);
++	close(pcm->event_fd);
++	free(pcm);
++
++	the_pcm = NULL;
++
++	return 0;
++}
++
++static int bluealsa_proxy_hw_params(snd_pcm_ioplug_t *io, snd_pcm_hw_params_t *params) {
++	struct bluealsa_pcm *pcm = io->private_data;
++	(void)params;
++
++	pcm->frame_size = (snd_pcm_format_physical_width(io->format) * io->channels) / 8;
++
++	/* Indicate that our PCM is ready for writing, even though is is not 100%
++	 * true - IO thread is not running yet. Some weird implementations might
++	 * require PCM to be writable before the snd_pcm_start() call. */
++	if (io->stream == SND_PCM_STREAM_PLAYBACK)
++		eventfd_write(pcm->event_fd, 1);
++
++	if (pcm->io.stream == SND_PCM_STREAM_PLAYBACK) {
++		/* By default, the size of the pipe buffer is set to a too large value for
++		 * our purpose. On modern Linux system it is 65536 bytes. Large buffer in
++		 * the playback mode might contribute to an unnecessary audio delay. Since
++		 * it is possible to modify the size of this buffer we will set is to some
++		 * low value, but big enough to prevent audio tearing. Note, that the size
++		 * will be rounded up to the page size (typically 4096 bytes). */
++		pcm->pcm_buffer_size = fcntl(pcm->pcm_fd, F_SETPIPE_SZ, 2048);
++		debug("FIFO buffer size: %zd", pcm->pcm_buffer_size);
++	}
++
++	debug("Selected HW buffer: %zd periods x %zd bytes %c= %zd bytes\n",
++			io->buffer_size / io->period_size, pcm->frame_size * io->period_size,
++			io->period_size * (io->buffer_size / io->period_size) == io->buffer_size ? '=' : '<',
++			io->buffer_size * pcm->frame_size);
++
++	return 0;
++}
++
++static int bluealsa_proxy_hw_free(snd_pcm_ioplug_t *io) {
++	struct bluealsa_pcm *pcm = io->private_data;
++	debug("Freeing HW");
++
++	if (close_transport(pcm) == -1)
++		return -errno;
++	return 0;
++}
++
++static int bluealsa_proxy_sw_params(snd_pcm_ioplug_t *io, snd_pcm_sw_params_t *params) {
++	struct bluealsa_pcm *pcm = io->private_data;
++	snd_pcm_sw_params_get_boundary(params, &pcm->io_hw_boundary);
++	return 0;
++}
++
++static int bluealsa_proxy_prepare(snd_pcm_ioplug_t *io) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	/* initialize ring buffer */
++	pcm->io_hw_ptr = 0;
++	pcm->io_ptr = 0;
++
++	return 0;
++}
++
++static int bluealsa_proxy_drain(snd_pcm_ioplug_t *io) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	if (bluealsa_drain_transport(pcm->fd, pcm->transport) == -1)
++		return -errno;
++	return 0;
++}
++
++static int bluealsa_proxy_pause(snd_pcm_ioplug_t *io, int enable) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	if (bluealsa_pause_transport(pcm->fd, pcm->transport, enable) == -1)
++		return -errno;
++
++	if (enable == 0) {
++		io->state = SND_PCM_STATE_RUNNING;
++		pthread_kill(pcm->io_thread, SIGIO);
++	}
++
++	/* Even though PCM transport is paused, our IO thread is still running. If
++	 * the implementer relies on the PCM file descriptor readiness, we have to
++	 * bump our internal event trigger. Otherwise, client might stuck forever
++	 * in the poll/select system call. */
++	eventfd_write(pcm->event_fd, 1);
++
++	return 0;
++}
++
++static void bluealsa_proxy_dump(snd_pcm_ioplug_t *io, snd_output_t *out) {
++	struct bluealsa_pcm *pcm = io->private_data;
++	char addr[18];
++
++	if (pcm->transport == NULL) {
++		snd_output_printf(out, "Bluetooth Proxy: no transport yet\n");
++		return;
++	}
++
++	ba2str(&pcm->transport->addr, addr);
++	snd_output_printf(out, "Bluetooth Proxy device: %s\n", addr);
++	snd_output_printf(out, "Bluetooth Proxy profile: %d\n", pcm->transport->type);
++	snd_output_printf(out, "Bluetooth Proxy codec: %d\n", pcm->transport->codec);
++
++}
++
++static int bluealsa_proxy_delay(snd_pcm_ioplug_t *io, snd_pcm_sframes_t *delayp) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	if (pcm->pcm_fd == -1)
++		return -ENODEV;
++
++	/* Exact calculation of the PCM delay is very hard, if not impossible. For
++	 * the sake of simplicity we will make few assumptions and approximations.
++	 * In general, the delay is proportional to the number of bytes queued in
++	 * the FIFO buffer, the time required to encode data, Bluetooth transfer
++	 * latency and the time required by the device to decode and play audio. */
++
++	static int counter = 0;
++	snd_pcm_sframes_t delay = 0;
++	unsigned int size;
++
++	/* bytes queued in the PCM ring buffer */
++	delay += io->appl_ptr - io->hw_ptr;
++
++	/* bytes queued in the FIFO buffer */
++	if (ioctl(pcm->pcm_fd, FIONREAD, &size) != -1)
++		delay += size / pcm->frame_size;
++
++	/* On the server side, the delay stat will not be available until the PCM
++	 * data transfer is started. Do not make an unnecessary call then. */
++	if ((io->state == SND_PCM_STATE_RUNNING || io->state == SND_PCM_STATE_DRAINING)) {
++
++		/* data transfer (communication) and encoding/decoding */
++		if (io->stream == SND_PCM_STREAM_PLAYBACK &&
++				(pcm->delay == 0 || ++counter % (io->rate / 10) == 0)) {
++
++			unsigned int tmp;
++			if ((tmp = bluealsa_get_transport_delay(pcm->fd, pcm->transport)) != -1) {
++				pcm->delay = (io->rate / 100) * tmp / 100;
++				debug("BlueALSA delay: %.1f ms (%ld frames)", (float)tmp / 10, pcm->delay);
++			}
++
++		}
++
++	}
++
++	*delayp = delay + pcm->delay + pcm->delay_ex;
++	return 0;
++}
++
++static int bluealsa_proxy_poll_descriptors_count(snd_pcm_ioplug_t *io) {
++	(void)io;
++	return 1;
++}
++
++static int bluealsa_proxy_poll_descriptors(snd_pcm_ioplug_t *io, struct pollfd *pfd,
++		unsigned int space) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	if (space != 1)
++		return -EINVAL;
++
++	pfd[0].fd = pcm->event_fd;
++	pfd[0].events = POLLIN;
++
++	return 1;
++}
++
++static int bluealsa_proxy_poll_revents(snd_pcm_ioplug_t *io, struct pollfd *pfd,
++		unsigned int nfds, unsigned short *revents) {
++	struct bluealsa_pcm *pcm = io->private_data;
++
++	if (nfds != 1) {
++		return -EINVAL;
++	}
++
++	if (pcm->pcm_fd == -1) {
++		return -ENODEV;
++	}
++
++	if (pfd[0].revents & POLLIN) {
++
++		eventfd_t event;
++		eventfd_read(pcm->event_fd, &event);
++
++		if (event & 0xDEAD0000) {
++			goto fail;
++		}
++
++		/* If the event was triggered prematurely, wait for another one.
++		 * This causes a deadlock if */
++		if (!snd_pcm_avail_update(io->pcm)) {
++			return *revents = 0;
++		}
++
++		/* ALSA expects that the event will match stream direction, e.g.
++		 * playback will not start if the event is for reading. */
++		*revents = io->stream == SND_PCM_STREAM_CAPTURE ? POLLIN : POLLOUT;
++
++	}
++	else
++		*revents = 0;
++
++	return 0;
++
++fail:
++	*revents = POLLERR | POLLHUP;
++	return -ENODEV;
++}
++
++static const snd_pcm_ioplug_callback_t bluealsa_proxy_callback = {
++	.start = bluealsa_proxy_start,
++	.stop = bluealsa_proxy_stop,
++	.pointer = bluealsa_proxy_pointer,
++	.close = bluealsa_proxy_close,
++	.hw_params = bluealsa_proxy_hw_params,
++	.hw_free = bluealsa_proxy_hw_free,
++	.sw_params = bluealsa_proxy_sw_params,
++	.prepare = bluealsa_proxy_prepare,
++	.drain = bluealsa_proxy_drain,
++	.pause = bluealsa_proxy_pause,
++	.dump = bluealsa_proxy_dump,
++	.delay = bluealsa_proxy_delay,
++	.poll_descriptors_count = bluealsa_proxy_poll_descriptors_count,
++	.poll_descriptors = bluealsa_proxy_poll_descriptors,
++	.poll_revents = bluealsa_proxy_poll_revents,
++};
++
++static enum pcm_type bluealsa_proxy_parse_profile(const char *profile) {
++
++	if (profile == NULL)
++		return PCM_TYPE_NULL;
++
++	if (strcasecmp(profile, "a2dp") == 0)
++		return PCM_TYPE_A2DP;
++	else if (strcasecmp(profile, "sco") == 0)
++		return PCM_TYPE_SCO;
++
++	return PCM_TYPE_NULL;
++}
++
++/* This must be called when a transport is available */
++
++static int bluealsa_proxy_set_hw_constraint(struct bluealsa_pcm *pcm) {
++	snd_pcm_ioplug_t *io = &pcm->io;
++
++	static const snd_pcm_access_t accesses[] = {
++		SND_PCM_ACCESS_MMAP_INTERLEAVED,
++		SND_PCM_ACCESS_RW_INTERLEAVED,
++	};
++	static const unsigned int formats[] = {
++		SND_PCM_FORMAT_S16_LE,
++	};
++
++	int err;
++
++	debug("Setting constraints\n");
++
++	if ((err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_ACCESS,
++					sizeof(accesses) / sizeof(*accesses), accesses)) < 0)
++		return err;
++
++	if ((err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_FORMAT,
++					sizeof(formats) / sizeof(*formats), formats)) < 0)
++		return err;
++
++	if ((err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIODS,
++					2, 1024)) < 0)
++		return err;
++
++	/* In order to prevent audio tearing and minimize CPU utilization, we're
++	 * going to setup buffer size constraints. These limits are derived from
++	 * the transport sampling rate and the number of channels, so the buffer
++	 * "time" size will be constant. The minimal period size and buffer size
++	 * are respectively 10 ms and 200 ms. Upper limits are not constraint. */
++	unsigned int min_p = pcm->transport->sampling * 10 / 1000 * pcm->transport->channels * 2;
++	unsigned int min_b = pcm->transport->sampling * 200 / 1000 * pcm->transport->channels * 2;
++
++	if ((err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIOD_BYTES,
++					min_p, 1024 * 16)) < 0)
++		return err;
++
++	if ((err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_BUFFER_BYTES,
++					min_b, 1024 * 1024 * 16)) < 0)
++		return err;
++
++	if ((err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_CHANNELS,
++					pcm->transport->channels, pcm->transport->channels)) < 0)
++		return err;
++
++	if ((err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_RATE,
++					pcm->transport->sampling, pcm->transport->sampling)) < 0)
++		return err;
++
++	return 0;
++}
++
++
++SND_PCM_PLUGIN_DEFINE_FUNC(bluealsa_proxy) {
++	(void)root;
++
++	struct bluealsa_pcm *pcm;
++	long delay = 0;
++	int ret;
++
++	if ((pcm = calloc(1, sizeof(*pcm))) == NULL)
++		return -ENOMEM;
++
++	pcm->fd = -1;
++	pcm->event_fd = -1;
++	pcm->pcm_fd = -1;
++	pcm->delay_ex = delay;
++
++	if ((pcm->event_fd = eventfd(0, EFD_CLOEXEC)) == -1) {
++		ret = -errno;
++		goto fail;
++	}
++
++	pcm->io.version = SND_PCM_IOPLUG_VERSION;
++	pcm->io.name = "BlueALSA";
++	pcm->io.flags = SND_PCM_IOPLUG_FLAG_LISTED;
++	pcm->io.mmap_rw = 1;
++	pcm->io.callback = &bluealsa_proxy_callback;
++	pcm->io.private_data = pcm;
++	pcm->transport = NULL;
++
++	enum pcm_stream _stream = stream == SND_PCM_STREAM_PLAYBACK ?
++			PCM_STREAM_PLAYBACK : PCM_STREAM_CAPTURE;
++
++	pcm->stream = stream;
++
++	if ((ret = snd_pcm_ioplug_create(&pcm->io, name, stream, mode)) < 0)
++		goto fail;
++
++	*pcmp = pcm->io.pcm;
++
++	// Remember PCM
++	the_pcm = pcm;
++
++	if ((errno = pthread_create(&pcm->io_thread, NULL, io_thread, &pcm->io)) != 0) {
++		debug("Couldn't create IO thread: %s", strerror(errno));
++		pcm->io_started = false;
++
++		ret = -errno;
++		goto fail;
++	}
++
++	pthread_setname_np(pcm->io_thread, "pcm-io");
++	return 0;
++
++fail:
++	if (pcm->fd != -1)
++		close(pcm->fd);
++	if (pcm->event_fd != -1)
++		close(pcm->event_fd);
++	free(pcm);
++	return ret;
++}
++
++SND_PCM_PLUGIN_SYMBOL(bluealsa_proxy);
++
++static int open_bluez_connection() {
++	int ret = 0;
++	bluealsa_pcm_t * pcm = the_pcm;
++
++	char addr[256];
++	ba2str(&pcm->addr, addr);
++
++	debug("%s interface %s addr %s type %d\n", __func__, pcm->interface, addr, pcm->type);
++
++	if ((pcm->fd = bluealsa_open(pcm->interface)) == -1) {
++		SNDERR("BlueALSA connection failed: %s", strerror(errno));
++		ret = -errno;
++		goto fail;
++	}
++
++	if ((pcm->transport = bluealsa_get_transport(pcm->fd, pcm->addr, pcm->type, pcm->stream)) == NULL) {
++		SNDERR("Couldn't get BlueALSA transport: %s", strerror(errno));
++		ret = -errno;
++		goto fail;
++	}
++
++	if ((ret = bluealsa_proxy_set_hw_constraint(pcm)) < 0) {
++		snd_pcm_ioplug_delete(&pcm->io);
++		goto fail;
++	}
++
++	pcm->transport->stream = pcm->stream;
++
++	if ((pcm->pcm_fd = bluealsa_open_transport(pcm->fd, pcm->transport)) == -1) {
++		debug("Couldn't open PCM FIFO: %s", strerror(errno));
++		return -errno;
++	}
++
++	debug("PLUGIN: starting transport\n");
++
++	if (bluealsa_pause_transport(pcm->fd, pcm->transport, false) == -1) {
++		debug("Couldn't start PCM: %s", strerror(errno));
++		return -errno;
++	}
++
++	debug("PLUGIN: connection ready !\n");
++
++	return 0;
++
++fail:
++	return ret;
++}
++
++static int close_bluez_connection() {
++	int ret = 0;
++	bluealsa_pcm_t * pcm = the_pcm;
++	close_transport(pcm);
++	close(pcm->fd);
++	return ret;
++}
++
++/* This is an exported function, to be loaded by clients via dlsym */
++
++int bluealsa_proxy_set_remote_device(const char * interface, const char * device, const char * profile) {
++	int ret  = -1;
++
++	debug("PLUGIN: %s: interface %s device %s profile %s\n", __func__, interface, device, profile);
++
++	if (the_pcm == NULL) {
++		SNDERR("No current opened connection to bluezalsa server\n");
++		goto failed;
++	}
++
++	enum pcm_type type;
++
++	if (device == NULL || str2ba(device, &the_pcm->addr) != 0) {
++		SNDERR("Invalid BT device address: %s", device);
++		ret = -EINVAL;
++		goto failed;
++	}
++
++	if ((type = bluealsa_proxy_parse_profile(profile)) == PCM_TYPE_NULL) {
++		SNDERR("Invalid BT profile [a2dp, sco]: %s", profile);
++		ret = -EINVAL;
++		goto failed;
++	}
++
++	strncpy(the_pcm->profile, profile, PROFILE_STR_MAXLEN);
++	strncpy(the_pcm->interface, interface, INTERFACE_STR_MAXLEN);
++
++	the_pcm->type = type;
++
++	close_bluez_connection();
++	ret = open_bluez_connection();
++
++failed:
++	return ret;
++}
++
++SND_DLSYM_BUILD_VERSION(bluealsa_proxy_set_remote_device, SND_PCM_DLSYM_VERSION);
+-- 
+2.1.4
+
diff --git a/meta-audio-4a-framework/recipes-connectivity/bluez-alsa/bluez-alsa_git.bbappend b/meta-audio-4a-framework/recipes-connectivity/bluez-alsa/bluez-alsa_git.bbappend
new file mode 100644
index 00000000..0c2ddee4
--- /dev/null
+++ b/meta-audio-4a-framework/recipes-connectivity/bluez-alsa/bluez-alsa_git.bbappend
@@ -0,0 +1,11 @@
+# THIS IS A TEMPORARY WORKAROUND TO IMPLEMENT PERSISTENT PCMS FOR SOFTMIXER
+
+FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"
+
+SRC_URI += "file://0001-Added-a-connection-proxy-plugin.patch"
+
+FILES_${PN} += "\
+  ${libdir}/alsa-lib/libasound_module_pcm_bluealsa_proxy.so\
+  ${datadir}/alsa/alsa.conf.d/20-bluealsa_proxy.conf\
+"
+