Add Radio API plugin

Add Radio API plugin source code, build with CMake.

Signed-off-by: Manuel Bachmann <manuel.bachmann@iot.bzh>

6 files changed, 548 insertions, 8 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d7805884..b297cbfc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,8 +35,17 @@ ENDIF(CMAKE_BUILD_TYPE MATCHES Debug)
 INCLUDE(FindPkgConfig)
 PKG_CHECK_MODULES(json-c REQUIRED json-c)
 PKG_CHECK_MODULES(libmicrohttpd REQUIRED libmicrohttpd)
+# Optional plugin dependencies
+PKG_CHECK_MODULES(librtlsdr librtlsdr>=0.5.0)
 
-SET(include_dirs ${INCLUDE_DIRS} ${CMAKE_SOURCE_DIR}/include ${json-c_INCLUDE_DIRS} ${libmicrohttpd_INCLUDE_DIRS})
-SET(link_libraries ${json-c_LIBRARIES} ${libmicrohttpd_LIBRARIES} ${libefence_LIBRARIES} -lmagic)
+IF(librtlsdr_FOUND)
+  MESSAGE(STATUS "librtlsdr found ; will compile Radio plugin... (PLUGIN)")
+ENDIF(librtlsdr_FOUND)
+
+INCLUDE(FindThreads)
+FIND_PACKAGE(Threads)
+
+SET(include_dirs ${INCLUDE_DIRS} ${CMAKE_SOURCE_DIR}/include ${json-c_INCLUDE_DIRS} ${libmicrohttpd_INCLUDE_DIRS} ${librtlsdr_INCLUDE_DIRS})
+SET(link_libraries ${json-c_LIBRARIES} ${libmicrohttpd_LIBRARIES} ${librtlsdr_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${libefence_LIBRARIES} -lmagic -lm)
 
 ADD_SUBDIRECTORY(src)
diff --git a/README.md b/README.md
index d04e247e..e5c55603 100644
--- a/README.md
+++ b/README.md
@@ -10,12 +10,23 @@ industry requirementsas the primary target for this code is AGL.
 
 ### Building
  Building Application Framework Binder requires the following libraries:
+
  * libmagic ("libmagic-dev" under Debian/Ubuntu, "file-devel" under OpenSUSE);
  * libmicrohttpd ("libmicrohttpd-dev/devel");
  * json-c ("libjson-c-dev/devel");
+
+ optionally, for plugins :
+
+ * rtl-sdr >= 0.5.0 (fetch and build from "git://git.osmocom.org/rtl-sdr");
+
  and the following tools:
+
  * pkg-config;
- * CMake >= 2.8.
+ * cmake >= 2.8.
+
+To install all dependencies under OpenSUSE (except rtl-sdr), please type:
+
+$ zypper in file-devel libmicrohttpd-devel libjson-c-devel pkg-config cmake
 
  To build from the root directory, please type:
 
diff --git a/include/proto-def.h b/include/proto-def.h
index cc372bf7..f5b9f79c 100644
--- a/include/proto-def.h
+++ b/include/proto-def.h
@@ -36,6 +36,7 @@ typedef AFB_plugin* (*AFB_pluginCB)(AFB_session *session);
 PUBLIC  AFB_plugin* afsvRegister (AFB_session *session);
 PUBLIC  AFB_plugin* dbusRegister (AFB_session *session);
 PUBLIC  AFB_plugin* alsaRegister (AFB_session *session);
+PUBLIC  AFB_plugin* radioRegister (AFB_session *session);
 
 
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 434332b4..663a7917 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,5 +1,11 @@
 SET(AFB-DAEMON_HEADERS local-def.h proto-def.h)
 SET(AFB-DAEMON_SOURCES main.c config.c session.c http-svc.c afbs-api.c dbus-api.c rest-api.c alsa-api.c)
+
+IF(librtlsdr_FOUND)
+  ADD_DEFINITIONS(-DWITH_RADIO_PLUGIN=1)
+  SET(AFB-DAEMON_SOURCES ${AFB-DAEMON_SOURCES} radio-api.c)
+ENDIF(librtlsdr_FOUND)
+
 ADD_EXECUTABLE(afb-daemon ${AFB-DAEMON_SOURCES})
 
 include_directories(${include_dirs})
diff --git a/src/radio-api.c b/src/radio-api.c
new file mode 100644
index 00000000..37da4ebc
--- /dev/null
+++ b/src/radio-api.c
@@ -0,0 +1,509 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ * Author "Manuel Bachmann"
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "local-def.h"
+
+/* -------------- RADIO DEFINITIONS ------------------ */
+
+#include <math.h>
+#include <pthread.h>
+#include <rtl-sdr.h>
+
+#define pthread_signal(n, m) pthread_mutex_lock(m); pthread_cond_signal(n); pthread_mutex_unlock(m)
+#define pthread_wait(n, m) pthread_mutex_lock(m); pthread_cond_wait(n, m); pthread_mutex_unlock(m)
+#define BUF_LEN 16*16384
+
+typedef enum { FM, AM } Mode;
+typedef struct dongle_ctx dongle_ctx;
+typedef struct demod_ctx demod_ctx;
+typedef struct output_ctx output_ctx;
+
+struct dongle_ctx {
+    pthread_t thr;
+    unsigned char thr_finished;
+    uint16_t buf[BUF_LEN];
+    uint32_t buf_len;
+};
+
+struct demod_ctx {
+    pthread_t thr;
+    unsigned char thr_finished;
+    pthread_rwlock_t lck;
+    pthread_cond_t ok;
+    pthread_mutex_t ok_m;
+    int pre_r, pre_j, now_r, now_j, index;
+    int pre_index, now_index;
+    int16_t buf[BUF_LEN];
+    int buf_len;
+    int16_t res[BUF_LEN];
+    int res_len;
+};
+
+struct output_ctx {
+    pthread_t thr;
+    unsigned char thr_finished;
+    pthread_rwlock_t lck;
+    pthread_cond_t ok;
+    pthread_mutex_t ok_m;
+    int16_t buf[BUF_LEN];
+    int buf_len;
+};
+
+struct dev_ctx {
+    rtlsdr_dev_t* dev;
+    Mode mode;
+    float freq;
+    unsigned char mute;
+    unsigned char should_run;
+     /* thread contexts */
+    dongle_ctx *dongle;
+    demod_ctx *demod;
+    output_ctx *output;
+};
+
+
+void* _dongle_thread_fn (void *);
+void* _demod_thread_fn (void *);
+void* _output_thread_fn (void *);
+unsigned int _radio_dev_count (void);
+const char* _radio_dev_name (unsigned int);
+unsigned char _radio_dev_init (struct dev_ctx *, unsigned int);
+unsigned char _radio_dev_free (struct dev_ctx *);
+void _radio_apply_params (struct dev_ctx *);
+void _radio_start_threads (struct dev_ctx *);
+void _radio_stop_threads (struct dev_ctx *);
+
+static unsigned int init_dev_count;
+static struct dev_ctx **dev_ctx;
+
+/* ------------- RADIO IMPLEMENTATION ----------------- */
+
+ /* ---- PUBLIC FUNCTIONS --- */
+
+void radio_on () {
+    init_dev_count = _radio_dev_count();
+    int i;
+
+    dev_ctx = (struct dev_ctx**) malloc(init_dev_count * sizeof(struct dev_ctx));
+
+    for (i = 0; i < init_dev_count; i++) {
+        dev_ctx[i] = (struct dev_ctx*) malloc(sizeof(struct dev_ctx));
+        dev_ctx[i]->dev = NULL;
+        dev_ctx[i]->mode = FM;
+        dev_ctx[i]->freq = 100.0;
+        dev_ctx[i]->mute = 0;
+        dev_ctx[i]->should_run = 0;
+        dev_ctx[i]->dongle = NULL;
+        dev_ctx[i]->demod = NULL;
+        dev_ctx[i]->output = NULL;
+        _radio_dev_init(dev_ctx[i], i);
+    }
+}
+
+void radio_off () {
+    int i;
+
+    for (i = 0; i < init_dev_count; i++) {
+        _radio_dev_free(dev_ctx[i]);
+        free(dev_ctx[i]);
+    }
+    free(dev_ctx);
+}
+
+void radio_set_mode (struct dev_ctx *dev_ctx, Mode mode) {
+    dev_ctx->mode = mode;
+    _radio_apply_params(dev_ctx);
+}
+
+void radio_set_freq (struct dev_ctx *dev_ctx, float freq) {
+    dev_ctx->freq = freq;
+    _radio_apply_params(dev_ctx);
+}
+
+void radio_set_mute (struct dev_ctx *dev_ctx, unsigned char mute) {
+    dev_ctx->mute = mute;
+    _radio_apply_params(dev_ctx);
+}
+
+void radio_play (struct dev_ctx *dev_ctx) {
+    _radio_start_threads(dev_ctx);
+}
+
+void radio_stop (struct dev_ctx *dev_ctx) {
+    _radio_stop_threads(dev_ctx);
+}
+
+ /* --- HELPER FUNCTIONS --- */
+
+unsigned int _radio_dev_count () {
+    return rtlsdr_get_device_count();
+}
+
+const char* _radio_dev_name (unsigned int num) {
+    return rtlsdr_get_device_name(num);
+}
+
+unsigned char _radio_dev_init (struct dev_ctx *dev_ctx, unsigned int num) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+
+    if (rtlsdr_open(&dev, num) < 0)
+        return 0;
+
+    rtlsdr_set_tuner_gain_mode(dev, 0);
+
+    if (rtlsdr_reset_buffer(dev) < 0)
+        return 0;
+
+    // dev_ctx->dev = dev; REQUIRED IN C TOO ? TEST !
+
+    _radio_apply_params(dev_ctx);
+
+    return 1;
+}
+
+unsigned char _radio_dev_free (struct dev_ctx *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+
+    if (rtlsdr_close(dev) < 0)
+        return 0;
+    dev = NULL;
+
+    return 1;
+}
+
+void _radio_apply_params (struct dev_ctx *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+    Mode mode = dev_ctx->mode;
+    float freq = dev_ctx->freq;
+    int rate;
+
+    freq *= 1000000;
+    rate = ((1000000 / 200000) + 1) * 200000;
+
+    if (mode == FM)
+        freq += 16000;
+    freq += rate / 4;
+
+    rtlsdr_set_center_freq(dev, freq);
+    rtlsdr_set_sample_rate(dev, rate);
+
+    // dev_ctx->dev = dev; REQUIRED IN C TOO ? TEST !
+}
+
+void _radio_start_threads (struct dev_ctx *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+    dev_ctx->dongle = (dongle_ctx*) malloc(sizeof(dongle_ctx));
+    dev_ctx->demod = (demod_ctx*) malloc(sizeof(demod_ctx));
+    dev_ctx->output = (output_ctx*) malloc(sizeof(output_ctx));
+
+    dongle_ctx *dongle = dev_ctx->dongle;
+    demod_ctx *demod = dev_ctx->demod;
+    output_ctx *output = dev_ctx->output;
+
+    pthread_rwlock_init(&demod->lck, NULL);
+    pthread_cond_init(&demod->ok, NULL);
+    pthread_mutex_init(&demod->ok_m, NULL);
+    pthread_rwlock_init(&output->lck, NULL);
+    pthread_cond_init(&output->ok, NULL);
+    pthread_mutex_init(&output->ok_m, NULL);
+
+    dev_ctx->should_run = 1;
+
+     /* dongle thread */
+    dongle->thr_finished = 0;
+    pthread_create(&dongle->thr, NULL, _dongle_thread_fn, (void*)dev_ctx);
+
+     /* demod thread */
+    demod->pre_r = demod->pre_j = 0;
+    demod->now_r = demod->now_j = 0;
+    demod->index = demod->pre_index = demod->now_index = 0;
+    demod->thr_finished = 0;
+    pthread_create(&demod->thr, NULL, _demod_thread_fn, (void*)dev_ctx);
+
+     /* output thread */
+    output->thr_finished = 0;
+    pthread_create(&output->thr, NULL, _output_thread_fn, (void*)dev_ctx);
+}
+
+void _radio_stop_threads (struct dev_ctx *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+    dongle_ctx *dongle = dev_ctx->dongle;
+    demod_ctx *demod = dev_ctx->demod;
+    output_ctx *output = dev_ctx->output;
+
+    if (!dongle || !demod || !output)
+        return;
+
+     /* stop each "while" loop in threads */
+    dev_ctx->should_run = 0;
+
+    rtlsdr_cancel_async(dev);
+    pthread_signal(&demod->ok, &demod->ok_m);
+    pthread_signal(&output->ok, &output->ok_m);
+
+    while (!dongle->thr_finished ||
+           !demod->thr_finished ||
+           !output->thr_finished)
+        usleep(100000);
+
+    pthread_join(dongle->thr, NULL);
+    pthread_join(demod->thr, NULL);
+    pthread_join(output->thr, NULL);
+    pthread_rwlock_destroy(&demod->lck);
+    pthread_cond_destroy(&demod->ok);
+    pthread_mutex_destroy(&demod->ok_m);
+    pthread_rwlock_destroy(&output->lck);
+    pthread_cond_destroy(&output->ok);
+    pthread_mutex_destroy(&output->ok_m);
+
+    free(dongle); dev_ctx->dongle = NULL;
+    free(demod); dev_ctx->demod = NULL;
+    free(output); dev_ctx->output = NULL;
+}
+
+ /* ---- LOCAL THREADED FUNCTIONS ---- */
+
+static void _rtlsdr_callback (unsigned char *buf, uint32_t len, void *ctx) {
+    struct dev_ctx *dev_ctx = (struct dev_ctx *)ctx;
+    dongle_ctx *dongle = dev_ctx->dongle;
+    demod_ctx *demod = dev_ctx->demod;
+    unsigned char tmp;
+    int i;
+
+    if (!dev_ctx->should_run)
+        return;
+
+     /* rotate 90° */
+    for (i = 0; i < (int)len; i += 8) {
+        tmp = 255 - buf[i+3];
+        buf[i+3] = buf[i+2];
+        buf[i+2] = tmp;
+
+        buf[i+4] = 255 - buf[i+4];
+        buf[i+5] = 255 - buf[i+5];
+
+        tmp = 255 - buf[i+6];
+        buf[i+6] = buf[i+7];
+        buf[i+7] = tmp;
+    }
+
+     /* write data */
+    for (i = 0; i < (int)len; i++)
+        dongle->buf[i] = (int16_t)buf[i] - 127;
+
+     /* lock demod thread, write to it, unlock */
+       pthread_rwlock_wrlock(&demod->lck);
+    memcpy(demod->buf, dongle->buf, 2 * len);
+    demod->buf_len = len;
+       pthread_rwlock_unlock(&demod->lck);
+       pthread_signal(&demod->ok, &demod->ok_m);
+}
+ /**/
+void* _dongle_thread_fn (void *ctx) {
+    struct dev_ctx *dev_ctx = (struct dev_ctx *)ctx;
+    struct dongle_ctx *dongle = dev_ctx->dongle;
+
+    rtlsdr_read_async(dev_ctx->dev, _rtlsdr_callback, dev_ctx, 0, 0);
+
+    dongle->thr_finished = 1;
+    return 0;
+}
+
+void _lowpass_demod (void *ctx) {
+    demod_ctx *demod = (demod_ctx *)ctx;
+    int i=0, i2=0;
+
+    while (i < demod->buf_len) {
+        demod->now_r += demod->buf[i];
+        demod->now_j += demod->buf[i+1];
+        i += 2;
+        demod->index++;
+        if (demod->index < ((1000000 / 200000) + 1))
+            continue;
+        demod->buf[i2] = demod->now_r;
+        demod->buf[i2+1] = demod->now_j;
+        demod->index = 0;
+        demod->now_r = demod->now_j = 0;
+        i2 += 2;
+    }
+    demod->buf_len = i2;
+}
+ /**/
+void _lowpassreal_demod (void *ctx) {
+    demod_ctx *demod = (demod_ctx *)ctx;
+    int i=0, i2=0;
+    int fast = 200000;
+    int slow = 48000;
+
+    while (i < demod->res_len) {
+        demod->now_index += demod->res[i];
+        i++;
+        demod->pre_index += slow;
+        if (demod->pre_index < fast)
+            continue;
+        demod->res[i2] = (int16_t)(demod->now_index / (fast/slow));
+        demod->pre_index -= fast;
+        demod->now_index = 0;
+        i2 += 1;
+    }
+    demod->res_len = i2;
+}
+ /**/
+void _multiply (int ar, int aj, int br, int bj, int *cr, int *cj) {
+    *cr = ar*br - aj*bj;
+    *cj = aj*br + ar*bj;
+}
+ /**/
+int _polar_discriminant (int ar, int aj, int br, int bj) {
+    int cr, cj;
+    double angle;
+    _multiply(ar, aj, br, -bj, &cr, &cj);
+    angle = atan2((double)cj, (double)cr);
+    return (int)(angle / 3.14159 * (1<<14));
+}
+ /**/
+void _fm_demod (void *ctx) {
+    demod_ctx *demod = (demod_ctx *)ctx;
+    int16_t *buf = demod->buf;
+    int buf_len = demod->buf_len;
+    int pcm, i;
+
+    pcm = _polar_discriminant(buf[0], buf[1], demod->pre_r, demod->pre_j);
+    demod->res[0] = (int16_t)pcm;
+
+    for (i = 2; i < (buf_len-1); i += 2) {
+        pcm = _polar_discriminant(buf[i], buf[i+1], buf[i-2], buf[i-1]);
+        demod->res[i/2] = (int16_t)pcm;
+    }
+    demod->pre_r = buf[buf_len - 2];
+    demod->pre_j = buf[buf_len - 1];
+    demod->res_len = buf_len/2;
+}
+ /**/
+void _am_demod (void *ctx) {
+    demod_ctx *demod = (demod_ctx *)ctx;
+    int16_t *buf = demod->buf;
+    int buf_len = demod->buf_len;
+    int pcm, i;
+
+    for (i = 0; i < buf_len; i += 2) {
+        pcm = buf[i] * buf[i];
+        pcm += buf[i+1] * buf[i+1];
+        demod->res[i/2] = (int16_t)sqrt(pcm);
+    }
+    demod->res_len = buf_len/2;
+}
+ /**/
+void* _demod_thread_fn (void *ctx) {
+    struct dev_ctx *dev_ctx = (struct dev_ctx *)ctx;
+    demod_ctx *demod = dev_ctx->demod;
+    output_ctx *output = dev_ctx->output;
+
+    while(dev_ctx->should_run) {
+            pthread_wait(&demod->ok, &demod->ok_m);
+            pthread_rwlock_wrlock(&demod->lck);
+        _lowpass_demod(demod);
+        if (dev_ctx->mode == FM)
+            _fm_demod(demod);
+        else
+            _am_demod(demod);
+        _lowpassreal_demod(demod);
+           pthread_rwlock_unlock(&demod->lck);
+
+         /* lock demod thread, write to it, unlock */
+           pthread_rwlock_wrlock(&output->lck);
+        memcpy(output->buf, demod->res, 2 * demod->res_len);
+        output->buf_len = demod->res_len;
+           pthread_rwlock_unlock(&output->lck);
+           pthread_signal(&output->ok, &output->ok_m);
+    }
+
+    demod->thr_finished = 1;
+    return 0;
+}
+
+void* _output_thread_fn (void *ctx) {
+    struct dev_ctx *dev_ctx = (struct dev_ctx *)ctx;
+    output_ctx *output = dev_ctx->output;
+
+    while (dev_ctx->should_run) {
+           pthread_wait(&output->ok, &output->ok_m);
+           pthread_rwlock_rdlock(&output->lck);
+        //if (!dev_ctx->mute)
+        //    mRadio->PlayAlsa((void*)&output->buf, output->buf_len);
+           pthread_rwlock_unlock(&output->lck);
+    }
+
+    output->thr_finished = 1;
+    return 0;
+}
+
+/* -------------- PLUGIN BINDING ------------------- */
+
+STATIC json_object* start (AFB_session *session, AFB_request *request, void* handle) {
+    json_object *response;
+    char query [512];
+
+    // request all query key/value
+    getQueryAll (request, query, sizeof(query));
+
+    // check if we have some post data
+    if (request->post == NULL)  request->post="NoData";
+
+    // return response to caller
+    response = jsonNewMessage(AFB_SUCCESS, "Start Radio plugin query={%s} PostData: \'%s\' ", query, request->post);
+
+    //if (verbose) fprintf(stderr, "%d: \n", pingcount);
+    return (response);
+}
+
+STATIC json_object* stop (AFB_session *session, AFB_request *request, void* handle) {
+    json_object *response;
+    char query [512];
+
+    getQueryAll (request, query, sizeof(query));
+
+    if (request->post == NULL)  request->post="NoData";
+
+    response = jsonNewMessage(AFB_SUCCESS, "Stop Radio plugin query={%s} PostData: \'%s\' ", query, request->post);
+
+    return (response);
+}
+
+
+STATIC struct {
+    void * somedata;
+} handle;
+
+
+STATIC  AFB_restapi pluginApis[]= {
+  {"start"    , (AFB_apiCB)start      , "Ping Application Framework", NULL},
+  {"stop"     , (AFB_apiCB)stop       , "Ping Application Framework", NULL},
+  {0,0,0}
+};
+
+PUBLIC AFB_plugin *radioRegister (AFB_session *session) {
+    AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
+    plugin->type  = AFB_PLUGIN;
+    plugin->info  = "Application Framework Binder - Radio plugin";
+    plugin->prefix  = "radio";
+    plugin->apis  = pluginApis;
+
+    return (plugin);
+};
diff --git a/src/rest-api.c b/src/rest-api.c
index b3b1c258..b06d70ad 100644
--- a/src/rest-api.c
+++ b/src/rest-api.c
@@ -368,11 +368,15 @@ STATIC AFB_plugin ** RegisterPlugins(AFB_plugin **plugins) {
 void initPlugins(AFB_session *session) {
     static AFB_plugin * plugins[10];
     afbJsonType = json_object_new_string (AFB_MSG_JTYPE);
-    
-    plugins[0] = afsvRegister(session),
-            plugins[1] = dbusRegister(session),
-            plugins[2] = alsaRegister(session),
-            plugins[3] = NULL;
+    int i = 0;
+
+    plugins[i] = afsvRegister(session),
+    plugins[i++] = dbusRegister(session),
+    plugins[i++] = alsaRegister(session),
+#ifdef HAVE_RADIO_PLUGIN
+    plugins[i++] = radioRegister(session),
+#endif
+    plugins[i++] = NULL;
 
     // complete plugins and save them within current sessions    
     session->plugins = RegisterPlugins(plugins);