vocabulary: moving from 'plugin' to 'binding'

Change-Id: Ic9e118df2bede1fefbb591f8ae7887266b7324ca
Signed-off-by: José Bollo <jose.bollo@iot.bzh>

1 files changed, 491 insertions, 0 deletions

diff --git a/bindings/audio/audio-pulse.c b/bindings/audio/audio-pulse.c
new file mode 100644
index 00000000..34643603
--- /dev/null
+++ b/bindings/audio/audio-pulse.c
@@ -0,0 +1,491 @@
+/*
+ * Copyright (C) 2016 "IoT.bzh"
+ * Author "Manuel Bachmann"
+ *
+ * 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 "audio-api.h"
+#include "audio-pulse.h"
+
+static struct alsa_info **alsa_info = NULL;
+static struct dev_ctx_pulse **dev_ctx_p = NULL;
+static unsigned int client_count = 0;
+
+
+unsigned char _pulse_init (const char *name, audioCtxHandleT *ctx) {
+
+    pa_mainloop *pa_loop;
+    pa_mainloop_api *pa_api;
+    pa_context *pa_context;
+    pa_simple *pa;
+    pa_sample_spec *pa_spec;
+    struct timeval tv_start, tv_now;
+    int ret, error, i;
+
+    pa_loop = pa_mainloop_new ();
+    pa_api = pa_mainloop_get_api (pa_loop);
+    pa_context = pa_context_new (pa_api, "afb-audio-plugin");
+
+    /* allocate the global array if it hasn't been done */
+    if (!dev_ctx_p)
+        dev_ctx_p = (dev_ctx_pulse_T**) malloc (sizeof(dev_ctx_pulse_T*));
+
+    /* create a temporary device, to be held until sink gets discovered */
+    dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T*) malloc (sizeof(dev_ctx_pulse_T));
+    dev_ctx_p_t->sink_name = NULL;
+    dev_ctx_p_t->card_name = (char**) malloc (sizeof(char*));
+    dev_ctx_p_t->card_name[0] = strdup (name);
+    dev_ctx_p_t->pa_loop = pa_loop;
+    dev_ctx_p_t->pa_context = pa_context;
+
+    pa_context_set_state_callback (pa_context, _pulse_context_cb, (void*)dev_ctx_p_t);
+    pa_context_connect (pa_context, NULL, 0, NULL);
+
+    /* 1 second should be sufficient to retrieve sink info */
+    gettimeofday (&tv_start, NULL);
+    gettimeofday (&tv_now, NULL);
+    while (tv_now.tv_sec - tv_start.tv_sec <= 2) {
+        pa_mainloop_iterate (pa_loop, 0, &ret);
+
+        if (ret == -1) { /* generic error */
+            fprintf (stderr, "Stopping PulseAudio backend...\n");
+            return 0;
+        }
+
+        if ((ret > 0)&&(ret < 100)) { /* 0 and >100 are PulseAudio codes */
+            /* found a matching sink from callback */
+            fprintf (stderr, "Success : using sink n.%d\n", ret-1);
+            ctx->audio_dev = (void*)dev_ctx_p[ret-1];
+            break;
+        }
+        gettimeofday (&tv_now, NULL);
+    }
+    /* fail if we found no matching sink */
+    if (!ctx->audio_dev)
+      return 0;
+
+    /* make the client context aware of current card state */
+    ctx->mute = (unsigned char)dev_ctx_p[ret-1]->mute;
+    ctx->channels = (unsigned int)dev_ctx_p[ret-1]->volume.channels;
+    for (i = 0; i < ctx->channels; i++)
+        ctx->volume[i] = dev_ctx_p[ret-1]->volume.values[i];
+    ctx->idx = ret-1;
+
+    /* open matching sink for playback */
+    pa_spec = (pa_sample_spec*) malloc (sizeof(pa_sample_spec));
+    pa_spec->format = PA_SAMPLE_S16LE;
+    pa_spec->rate = 22050;
+    pa_spec->channels = (uint8_t)ctx->channels;
+
+    if (!(pa = pa_simple_new (NULL, "afb-audio-plugin", PA_STREAM_PLAYBACK, dev_ctx_p[ret-1]->sink_name,
+                              "afb-audio-output", pa_spec, NULL, NULL, &error))) {
+        fprintf (stderr, "Error opening PulseAudio sink %s : %s\n",
+                          dev_ctx_p[ret-1]->sink_name, pa_strerror(error));
+        return 0;
+    }
+    dev_ctx_p[ret-1]->pa = pa;
+    free (pa_spec);
+
+    client_count++;
+
+    fprintf (stderr, "Successfully initialized PulseAudio backend.\n");
+
+    return 1;
+}
+
+void _pulse_free (audioCtxHandleT *ctx) {
+
+    int num, i;
+
+    client_count--;
+    if (client_count > 0) return;
+
+    for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T*)); num++) {
+
+         for (i = 0; num < (sizeof(dev_ctx_p[num]->card_name)/sizeof(char*)); i++) {
+             free (dev_ctx_p[num]->card_name[i]);
+             dev_ctx_p[num]->card_name[i] = NULL;
+         }
+         pa_context_disconnect (dev_ctx_p[num]->pa_context);
+         pa_context_unref (dev_ctx_p[num]->pa_context);
+         pa_mainloop_free (dev_ctx_p[num]->pa_loop);
+         pa_simple_free (dev_ctx_p[num]->pa);
+         free (dev_ctx_p[num]->sink_name);
+         dev_ctx_p[num]->pa_context = NULL;
+         dev_ctx_p[num]->pa_loop = NULL;
+         dev_ctx_p[num]->pa = NULL;
+         dev_ctx_p[num]->sink_name = NULL;
+         free (dev_ctx_p[num]);
+    }
+}
+
+void _pulse_play (audioCtxHandleT *ctx) {
+
+    dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
+
+    if (!dev_ctx_p_c || dev_ctx_p_c->thr_should_run || access (AUDIO_BUFFER, F_OK) == -1)
+        return;
+
+    dev_ctx_p_c->thr_should_run = 1;
+    dev_ctx_p_c->thr_finished = 0;
+    pthread_create (&dev_ctx_p_c->thr, NULL, _pulse_play_thread_fn, (void*)dev_ctx_p_c);
+}
+
+void _pulse_stop (audioCtxHandleT *ctx) {
+
+    dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
+
+    if (!dev_ctx_p_c || !dev_ctx_p_c->thr_should_run)
+        return;
+
+    dev_ctx_p_c->thr_should_run = 0;
+    while (!dev_ctx_p_c->thr_finished)
+        usleep(100000);
+    pthread_join (dev_ctx_p_c->thr, NULL);
+}
+
+unsigned int _pulse_get_volume (audioCtxHandleT *ctx, unsigned int channel) {
+
+    dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
+
+    if (!dev_ctx_p_c)
+        return 0;
+
+    _pulse_refresh_sink (dev_ctx_p_c);
+
+    return (dev_ctx_p_c->volume.values[channel]*100)/PA_VOLUME_NORM;
+}
+
+void _pulse_set_volume (audioCtxHandleT *ctx, unsigned int channel, unsigned int vol) {
+
+    dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
+    struct pa_cvolume volume;
+
+    if (!dev_ctx_p_c)
+        return;
+
+    volume = dev_ctx_p_c->volume;
+    volume.values[channel] = (vol*PA_VOLUME_NORM)/100;
+
+    pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
+                                        &volume, NULL, NULL);
+    _pulse_refresh_sink (dev_ctx_p_c);
+}
+
+void _pulse_set_volume_all (audioCtxHandleT *ctx, unsigned int vol) {
+
+    dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
+    struct pa_cvolume volume;
+
+    if (!dev_ctx_p_c)
+        return;
+
+    pa_cvolume_init (&volume);
+    pa_cvolume_set (&volume, dev_ctx_p_c->volume.channels, vol);
+
+    pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
+                                        &volume, NULL, NULL);
+    _pulse_refresh_sink (dev_ctx_p_c);
+}
+
+unsigned char _pulse_get_mute (audioCtxHandleT *ctx) {
+
+    dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
+
+    if (!dev_ctx_p_c)
+        return 0;
+
+    _pulse_refresh_sink (dev_ctx_p_c);
+
+    return (unsigned char)dev_ctx_p_c->mute;
+}
+
+void _pulse_set_mute (audioCtxHandleT *ctx, unsigned char mute) {
+
+    dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
+
+    if (!dev_ctx_p_c)
+        return;
+
+    pa_context_set_sink_mute_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
+                                      (int)mute, NULL, NULL);
+    _pulse_refresh_sink (dev_ctx_p_c);
+}
+
+ /* ---- LOCAL HELPER FUNCTIONS ---- */
+
+void _pulse_refresh_sink (dev_ctx_pulse_T* dev_ctx_p_c) {
+
+    pa_mainloop_api *pa_api;
+
+    dev_ctx_p_c->pa_loop = pa_mainloop_new ();
+    pa_api = pa_mainloop_get_api (dev_ctx_p_c->pa_loop);
+    dev_ctx_p_c->pa_context = pa_context_new (pa_api, "afb-audio-plugin");
+
+    dev_ctx_p_c->refresh = 1;
+
+    switch (pa_context_get_state (dev_ctx_p_c->pa_context)) {
+      case PA_CONTEXT_READY:
+        pa_context_get_sink_info_by_name (dev_ctx_p_c->pa_context,
+                                          dev_ctx_p_c->sink_name,
+                                          _pulse_sink_info_cb, (void*)dev_ctx_p_c);
+        break;
+      default:
+        return;
+    }
+
+    while (dev_ctx_p_c->refresh)
+        pa_mainloop_iterate (dev_ctx_p_c->pa_loop, 0, NULL);
+}
+
+void _pulse_enumerate_cards () {
+
+    void **cards, **card;
+    char *name, *found, *alsa_name, *card_name;
+    int new_info, i, num = 0;
+
+    /* allocate the global alsa array */
+    alsa_info = (alsa_info_T**) malloc (sizeof(alsa_info_T*));
+    alsa_info[0] = (alsa_info_T*) malloc (sizeof(alsa_info_T));
+    alsa_info[0]->device = NULL;
+    alsa_info[0]->synonyms = NULL;
+
+    /* we use ALSA to enumerate cards */
+    snd_device_name_hint (-1, "pcm", &cards);
+    card = cards;
+
+    for (; *card != NULL; card++) {
+        name = snd_device_name_get_hint (*card, "NAME");
+        new_info = 1;
+
+        /* alsa name is before ':' (if ':' misses, then it has no card) */
+        found = strstr (name, ":");
+        if (!found) continue;
+        /* */
+        alsa_name = (char*) malloc (found-name+1);
+        strncpy (alsa_name, name, found-name);
+        alsa_name[found-name] = '\0';
+
+        /* card name is the invariant between "CARD=" and ',' */
+        found = strstr (name, "CARD=");
+        if (!found) continue;
+        /* */
+        found += 5;
+        card_name = strdup (found);
+        found = strstr (card_name, ",");
+        if (found) card_name[found-card_name] = '\0';
+
+        /* was the card name already listed in the global alsa array ? */
+        for (i = 0; i < (sizeof(alsa_info)/sizeof(alsa_info_T*)); i++) {
+
+            if (alsa_info[i]->device &&
+                !strcmp (alsa_info[i]->device, card_name)) {
+                /* it was ; add the alsa name as a new synonym */
+                asprintf (&alsa_info[i]->synonyms, "%s:%s", alsa_info[i]->synonyms, alsa_name);
+                new_info = 0;
+                break;
+            }            
+        }
+        /* it was not ; create it */
+        if (new_info) {
+            alsa_info = (alsa_info_T**) realloc (alsa_info, (num+1)*sizeof(alsa_info_T*));
+            alsa_info[num] = (alsa_info_T*) malloc (sizeof(alsa_info_T));
+            alsa_info[num]->device = strdup (card_name);
+            asprintf (&alsa_info[num]->synonyms, ":%s", alsa_name);
+            num++;
+        }
+        free (alsa_name);
+        free (card_name);
+    }
+}
+
+char** _pulse_find_cards (const char *name) {
+
+    char **cards = NULL;
+    char *needle, *found, *next;
+    int num, i = 0;
+
+    if (!alsa_info)
+      _pulse_enumerate_cards ();
+
+    asprintf (&needle, ":%s", name);
+
+    for (num = 0; num < (sizeof(alsa_info)/sizeof(alsa_info_T*)); num++) {
+
+        found = strstr (alsa_info[num]->synonyms, needle);
+        while (found) {
+            /* if next character is not ':' or '\0', we are wrong */
+            if ((found[strlen(name)+1] != ':') && (found[strlen(name)+1] != '\0')) {
+                found = strstr (found+1, needle);
+                continue;
+            }
+            /* found it ; now return all the "synonym" cards */
+            found = strstr (alsa_info[num]->synonyms, ":");
+            while (found) {
+                next = strstr (found+1, ":");
+                if (!next) break;
+                cards = (char**) realloc (cards, (i+1)*sizeof(char*));
+                cards[i] = (char*) malloc (next-found+1);
+                strncpy (cards[i], found+1, next-found);
+                cards[i][next-found-1] = '\0';
+                found = next; i++;
+            }
+        }
+    }
+    free (needle);
+
+    return cards;
+}
+
+ /* ---- LOCAL CALLBACK FUNCTIONS ---- */
+
+void _pulse_context_cb (pa_context *context, void *data) {
+
+    pa_context_state_t state = pa_context_get_state (context);
+    dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data;
+
+    if (state == PA_CONTEXT_FAILED) {
+        fprintf (stderr, "Could not connect to PulseAudio !\n");
+        pa_mainloop_quit (dev_ctx_p_t->pa_loop, -1);
+        pa_context_disconnect (dev_ctx_p_t->pa_context);
+        pa_context_unref (dev_ctx_p_t->pa_context);
+        pa_mainloop_free (dev_ctx_p_t->pa_loop);
+    }
+
+    if (state == PA_CONTEXT_READY)
+        pa_context_get_sink_info_list (context, _pulse_sink_list_cb, (void*)dev_ctx_p_t);
+}
+
+void _pulse_sink_list_cb (pa_context *context, const pa_sink_info *info,
+				 int eol, void *data) {
+
+    dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data;
+    const char *device_string;
+    char *device, *found;
+    char **cards;
+    int num, i;
+
+    if (eol != 0)
+        return;
+
+    device_string = pa_proplist_gets (info->proplist, "device.string");
+    /* ignore sinks with no cards */
+    if (!device_string)
+        return;
+
+    /* was a sink with similar name already found ? */
+    for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T*)); num++) {
+        if (dev_ctx_p[num]->sink_name &&
+           !strcmp (dev_ctx_p[num]->sink_name, info->name)) {
+
+            /* yet it was, did it have the required card ? */
+            cards = dev_ctx_p[num]->card_name;
+            for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) {
+                if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) {
+                    /* it did : stop there and succeed */
+                    fprintf (stderr, "Found matching sink : %s\n", info->name);
+                    /* we return num+1 because '0' is already used */
+                    pa_mainloop_quit (dev_ctx_p_t->pa_loop, num+1);
+                    pa_context_disconnect (dev_ctx_p_t->pa_context);
+                    pa_context_unref (dev_ctx_p_t->pa_context);
+                    pa_mainloop_free (dev_ctx_p_t->pa_loop);
+                }
+            }
+            /* it did not, ignore and return */
+            return;
+        }
+    }
+    num++;
+
+    /* remove ending ":0",":1"... in device name */
+    device = strdup (device_string);
+    found = strstr (device, ":");
+    if (found) device[found-device] = '\0';
+
+    /* new sink, find all the cards it manages, fail if none */
+    cards = _pulse_find_cards (device);
+    free (device);
+    if (!cards)
+        return;
+
+    /* everything is well, register it in global array */
+    dev_ctx_p_t->sink_name = strdup (info->name);
+    dev_ctx_p_t->card_name = cards;
+    dev_ctx_p_t->mute = info->mute;
+    dev_ctx_p_t->volume = info->volume;
+    dev_ctx_p_t->thr_should_run = 0;
+    dev_ctx_p_t->thr_finished = 0;
+    dev_ctx_p[num] = dev_ctx_p_t;
+
+    /* does this new sink have the card we are looking for ? */ /* TODO : factorize this */
+    for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) {
+        if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) {
+             /* it did : stop there and succeed */
+             fprintf (stderr, "Found matching sink : %s\n", info->name);
+             /* we return num+1 because '0' is already used */
+             pa_mainloop_quit (dev_ctx_p_t->pa_loop, num+1);
+             pa_context_disconnect (dev_ctx_p_t->pa_context);
+             pa_context_unref (dev_ctx_p_t->pa_context);
+             pa_mainloop_free (dev_ctx_p_t->pa_loop);
+        }
+    }
+}
+
+void _pulse_sink_info_cb (pa_context *context, const pa_sink_info *info,
+				 int eol, void *data) {
+
+    dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)data;
+
+    if (eol != 0)
+        return;
+
+    dev_ctx_p_c->refresh = 0;
+    dev_ctx_p_c->mute = info->mute;
+    dev_ctx_p_c->volume = info->volume;
+}
+
+ /* ---- LOCAL THREADED FUNCTIONS ---- */
+
+void* _pulse_play_thread_fn (void *ctx) {
+
+    dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)ctx;
+    FILE *file = NULL;
+    char *buf = NULL;
+    long size;
+    int error;
+
+    file = fopen (AUDIO_BUFFER, "rb");
+
+    while (dev_ctx_p_c->thr_should_run && file && (access (AUDIO_BUFFER, F_OK) != -1) ) {
+        fseek (file, 0, SEEK_END);
+        size = ftell (file);
+        buf = (char*) realloc (buf, size * sizeof(char));
+
+        fseek (file, 0, SEEK_SET);
+        fread (buf, 1, size, file);
+        fflush (file);
+
+        if (pa_simple_write (dev_ctx_p_c->pa, buf, size*2, &error) < 0)
+            fprintf (stderr, "Error writing to PulseAudio : %s\n", pa_strerror (error));
+        /* pa_simple_drain (dev_ctx_p_c->pa); */
+    }
+    if (buf) free(buf);
+    if (file) fclose(file);
+
+    dev_ctx_p_c->thr_finished = 1;
+    return 0;
+}