Fix plugins loading, cleanup and dispatch Radio API code

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

7 files changed, 627 insertions, 549 deletions

diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
index 417321e4..0ddaf453 100644
--- a/plugins/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -1,8 +1,11 @@
-SET(PLUGINS_SOURCES audio/audio-api.c session/token-api.c samples/HelloWorld.c)
-
+SET(AUDIO_PLUGIN audio/audio-api.c)
+SET(SESSION_PLUGIN session/token-api.c)
+SET(SAMPLE_PLUGINS samples/HelloWorld.c)
 IF(librtlsdr_FOUND)
-  SET(PLUGINS_SOURCES ${PLUGINS_SOURCES} radio/radio-api.c)
+  SET(RADIO_PLUGIN radio/radio-rtlsdr.c radio/radio-api.c)
 ENDIF(librtlsdr_FOUND)
 
+SET(PLUGINS_SOURCES ${AUDIO_PLUGIN} ${SESSION_PLUGIN} ${RADIO_PLUGIN} ${SAMPLE_PLUGINS})
+
 ADD_LIBRARY(plugins OBJECT ${PLUGINS_SOURCES})
 INCLUDE_DIRECTORIES(${include_dirs})
diff --git a/plugins/radio/radio-api.c b/plugins/radio/radio-api.c
index 57e3872c..02f6330c 100644
--- a/plugins/radio/radio-api.c
+++ b/plugins/radio/radio-api.c
@@ -1,6 +1,5 @@
 /*
  * 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
@@ -16,494 +15,8 @@
  * 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;
-typedef struct dev_ctx dev_ctx_T;
-
-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 {
-    int used;  // radio is free ???
-    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;
-};
-
-#define MAX_RADIO 10
-
-// Structure holding existing radio with current usage status
-typedef struct {
-    int   idx;
-    char *name;
-    int  used;
-} radioDevT;
-
-// Radio plugin handle should store everething API may need
-typedef struct {
-  radioDevT *radios[MAX_RADIO];  // pointer to existing radio
-  int devCount;
-} pluginHandleT;
-
-/* private client context [will be destroyed when client leaves] */
-typedef struct {
-    radioDevT *radio;       /* pointer to client radio            */
-    int idx;                /* radio index within global array    */
-    Mode mode;              /* radio mode: AM/FM                  */
-    float freq;             /* radio frequency (Mhz)              */
-    unsigned char mute;     /* radio muted: 0(false)/1(true)      */
-} radioCtxHandleT;
-
-
-STATIC void* _dongle_thread_fn (void *);
-STATIC void* _demod_thread_fn (void *);
-STATIC void* _output_thread_fn (void *);
-STATIC unsigned int _radio_dev_count (void);
-STATIC const char* _radio_dev_name (unsigned int);
-STATIC unsigned char _radio_dev_init (struct dev_ctx *, unsigned int);
-STATIC unsigned char _radio_dev_free (struct dev_ctx *);
-STATIC void _radio_apply_params (struct dev_ctx *);
-STATIC void _radio_start_threads (struct dev_ctx *);
-STATIC void _radio_stop_threads (struct dev_ctx *);
-
-static unsigned int init_dev_count = 0;
-static struct dev_ctx **dev_ctx = NULL;
-
-/* ------------- RADIO IMPLEMENTATION ----------------- */
-
-
-// Radio initialization should be done only when user start the radio and not at plugin initialization
-// Making this call too early would impose to restart the binder to detect a radio.
-STATIC unsigned char _radio_on (unsigned int num, radioCtxHandleT *ctx) {
- 
-    if (num >= _radio_dev_count())
-        return 0;
-    
-    if (init_dev_count < _radio_dev_count()) {
-        init_dev_count = _radio_dev_count();
-        dev_ctx = (dev_ctx_T**) realloc (dev_ctx, init_dev_count * sizeof(dev_ctx_T));           
-    }
-
-    dev_ctx[num] = (dev_ctx_T*) malloc (sizeof(dev_ctx_T));
-    dev_ctx[num]->dev = NULL;
-    dev_ctx[num]->mode = ctx->mode;
-    dev_ctx[num]->freq = ctx->freq;
-    dev_ctx[num]->mute = ctx->mute;
-    dev_ctx[num]->should_run = 0;
-    dev_ctx[num]->dongle = NULL;
-    dev_ctx[num]->demod = NULL;
-    dev_ctx[num]->output = NULL;
-    _radio_dev_init(dev_ctx[num], num);
-    
-    return 1;
-}
-
-STATIC void _radio_off (unsigned int num) {
-
-    if (num >= _radio_dev_count())
-        return;
-
-    if (dev_ctx[num]) {
-        _radio_dev_free(dev_ctx[num]);
-        free(dev_ctx[num]);
-    }
-    /* free(dev_ctx); */
-}
-
-STATIC void _radio_set_mode (unsigned int num, Mode mode) {
-    if (!dev_ctx || !dev_ctx[num])
-        return;
-
-    dev_ctx[num]->mode = mode;
-    _radio_apply_params(dev_ctx[num]);
-}
-
-STATIC void _radio_set_freq (unsigned int num, float freq) {
-    if (!dev_ctx || !dev_ctx[num])
-        return;
-
-    dev_ctx[num]->freq = freq;
-    _radio_apply_params(dev_ctx[num]);
-}
-
-STATIC void _radio_set_mute (unsigned int num, unsigned char mute) {
-    if (!dev_ctx || !dev_ctx[num])
-        return;
-
-    dev_ctx[num]->mute = mute;
-    _radio_apply_params(dev_ctx[num]);
-}
-
-STATIC void _radio_play (unsigned int num) {
-    if (!dev_ctx || !dev_ctx[num])
-        return;
-
-    _radio_start_threads(dev_ctx[num]);
-}
-
-STATIC void _radio_stop (unsigned int num) {
-    if (!dev_ctx || !dev_ctx[num])
-        return;
-
-    _radio_stop_threads(dev_ctx[num]);
-}
-
- /* --- HELPER FUNCTIONS --- */
-
-STATIC unsigned int _radio_dev_count () {
-    return rtlsdr_get_device_count();
-}
-
-STATIC const char* _radio_dev_name (unsigned int num) {
-    return rtlsdr_get_device_name(num);
-}
-
-STATIC unsigned char _radio_dev_init (dev_ctx_T *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;
-
-    _radio_apply_params(dev_ctx);
-
-    return 1;
-}
-
-STATIC unsigned char _radio_dev_free (dev_ctx_T *dev_ctx) {
-    rtlsdr_dev_t *dev = dev_ctx->dev;
-
-    if (rtlsdr_close(dev) < 0)
-        return 0;
-    dev = NULL;
-
-    dev_ctx->dev = dev;
-
-    return 1;
-}
-
-STATIC void _radio_apply_params (dev_ctx_T *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;
-}
-
-STATIC void _radio_start_threads (dev_ctx_T *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);
-}
-
-STATIC void _radio_stop_threads (dev_ctx_T *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) {
-    dev_ctx_T *dev_ctx = (dev_ctx_T *)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);
-}
- /**/
-STATIC void* _dongle_thread_fn (void *ctx) {
-    dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
-    dongle_ctx *dongle = dev_ctx->dongle;
-
-    rtlsdr_read_async(dev_ctx->dev, _rtlsdr_callback, dev_ctx, 0, 0);
-
-    dongle->thr_finished = 1;
-    return 0;
-}
-
-STATIC 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;
-}
- /**/
-STATIC 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;
-}
- /**/
-STATIC void _multiply (int ar, int aj, int br, int bj, int *cr, int *cj) {
-    *cr = ar*br - aj*bj;
-    *cj = aj*br + ar*bj;
-}
- /**/
-STATIC 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));
-}
- /**/
-STATIC 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;
-}
- /**/
-STATIC 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;
-}
- /**/
-STATIC void* _demod_thread_fn (void *ctx) {
-    dev_ctx_T *dev_ctx = (dev_ctx_T *)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;
-}
-
-STATIC void* _output_thread_fn (void *ctx) {
-    dev_ctx_T *dev_ctx = (dev_ctx_T *)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;
-}
-
+#include "radio-api.h"
+#include "radio-rtlsdr.h"
 
 /* ********************************************************
 
@@ -511,21 +24,23 @@ STATIC void* _output_thread_fn (void *ctx) {
 
    ******************************************************** */
 
-// It his was not a demo only, it should be smarter to enable hot plug/unplug
+/* ------ LOCAL HELPER FUNCTIONS --------- */
+
+/* detect new radio devices */
 STATIC void updateRadioDevList(pluginHandleT *handle) {
+
   int idx;  
 
   // loop on existing radio if any
   for (idx = 0; idx < _radio_dev_count(); idx++) {
       if (idx == MAX_RADIO) break;
-      handle->radios[idx] = calloc(1, sizeof(radioDevT)); // use calloc to set used to FALSE
+      handle->radios[idx] = calloc(1, sizeof(radioDevT)); /* use calloc to set used to FALSE */
       handle->radios[idx]->name = (char *) _radio_dev_name(idx); 
   }
   handle->devCount = _radio_dev_count();
 }
 
-
-/* global plugin context creation ; at loading time [radio devices might still not be visible] */
+/* global plugin context creation ; at loading time [radio devices might not be visible] */
 STATIC pluginHandleT* initRadioPlugin() {
 
   pluginHandleT *handle;
@@ -536,7 +51,6 @@ STATIC pluginHandleT* initRadioPlugin() {
   return handle;
 }
 
-
 /* private client context creation ; default values */
 STATIC radioCtxHandleT* initRadioCtx () {
 
@@ -548,12 +62,12 @@ STATIC radioCtxHandleT* initRadioCtx () {
     ctx->mode = FM;
     ctx->freq = 100.0;
     ctx->mute = 0;
+    ctx->is_playing = 0;
 
     return ctx;
 }
 
-
-/* reserve a radio device to requesting client, start it */
+/* reserve a radio device for requesting client, power it on */
 STATIC AFB_error reserveRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
     int idx;
 
@@ -579,26 +93,34 @@ STATIC AFB_error reserveRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
     return AFB_SUCCESS;
 }
 
-/* free a radio device from requesting client, stop it */
+/* free a radio device from requesting client, power it off */
 STATIC AFB_error releaseRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
 
+   /* power it off */
+   _radio_off (ctx->idx);
+
    /* globally mark it as free */
    handle->radios[ctx->idx]->used = FALSE;
 
-   /* power it off */
-   _radio_off (ctx->idx);
+   /* clean client context */
+   ctx->radio = NULL;
+   ctx->idx = -1;
 
    return AFB_SUCCESS;
 }
 
-// This is called when client session died [ex; client quit for more than 15mn]
-STATIC json_object* freeRadio () {
+/* called when client session dies [e.g. client quits for more than 15mns] */
+STATIC json_object* freeRadio (AFB_clientCtx *client) {
+
+    releaseRadio (client->plugin->handle, client->ctx);
+    free (client->ctx);
     
-    //releaseRadio (client->handle, client);
-    //free (client);
+    return jsonNewMessage (AFB_SUCCESS, "Released radio and client context");
 }
 
 
+/* ------ PUBLIC PLUGIN FUNCTIONS --------- */
+
 STATIC json_object* power (AFB_request *request) {      /* AFB_SESSION_CREATE */
     
     pluginHandleT *handle = request->client->plugin->handle; 
@@ -626,7 +148,7 @@ STATIC json_object* power (AFB_request *request) {      /* AFB_SESSION_CREATE */
             }
         }
         jresp = json_object_new_object();
-        json_object_object_add (jresp, "power-on", json_object_new_string ("ok"));
+        json_object_object_add (jresp, "power", json_object_new_string ("on"));
     }
 
     /* "?value=" parameter is "0" or "off" */
@@ -638,7 +160,7 @@ STATIC json_object* power (AFB_request *request) {      /* AFB_SESSION_CREATE */
             }
         }
         jresp = json_object_new_object();
-        json_object_object_add (jresp, "power-off", json_object_new_string ("ok"));
+        json_object_object_add (jresp, "power", json_object_new_string ("off"));
     }
 
     return jresp;
@@ -649,7 +171,6 @@ STATIC json_object* mode (AFB_request *request) {        /* AFB_SESSION_CHECK */
     radioCtxHandleT *ctx = (radioCtxHandleT*)request->client->ctx;
     const char *value = getQueryValue (request, "value");
     json_object *jresp;
-    char *mode_str;
 
     /* no "?value=" parameter : return current state */
     if (!value) {
@@ -661,25 +182,21 @@ STATIC json_object* mode (AFB_request *request) {        /* AFB_SESSION_CHECK */
 
     /* "?value=" parameter is "1" or "on" */
     else if ( atoi(value) == 1 || !strcasecmp(value, "AM") ) {
-        mode_str = strdup ("mode-AM");
         ctx->mode = AM;
+        _radio_set_mode (ctx->idx, ctx->mode);
+
+        jresp = json_object_new_object();
+        json_object_object_add (jresp, "mode", json_object_new_string ("AM"));
     }
 
     /* "?value=" parameter is "0" or "off" */
     else if ( atoi(value) == 0 || !strcasecmp(value, "FM") ) {
-        mode_str = strdup ("mode-FM");
         ctx->mode = FM;
-    }
+        _radio_set_mode (ctx->idx, ctx->mode);
 
-    else {
-        request->errcode = MHD_HTTP_SERVICE_UNAVAILABLE;
-        return (jsonNewMessage (AFB_FAIL, "Invalid value for mode"));
+        jresp = json_object_new_object();
+        json_object_object_add (jresp, "mode", json_object_new_string ("FM"));
     }
-       
-    _radio_set_mode (ctx->idx, ctx->mode);
-        
-    jresp = json_object_new_object();
-    json_object_object_add (jresp, mode_str, json_object_new_string ("ok"));
     
     return jresp;
 }
@@ -689,21 +206,21 @@ STATIC json_object* freq (AFB_request *request) {        /* AFB_SESSION_CHECK */
     radioCtxHandleT *ctx = (radioCtxHandleT*)request->client->ctx;
     const char *value = getQueryValue (request, "value");
     json_object *jresp = json_object_new_object();
-    char *freq_str;
+    char freq_str[256];
 
     /* no "?value=" parameter : return current state */
     if (!value) {
-        asprintf (&freq_str, "%f", ctx->freq);
+        snprintf (freq_str, sizeof(freq_str), "%f", ctx->freq);
         json_object_object_add (jresp, "freq", json_object_new_string (freq_str));
     }
 
     /* "?value=" parameter, set frequency */
     else {
-        ctx->freq = strtof(value, NULL);
+        ctx->freq = strtof (value, NULL);
         _radio_set_freq (ctx->idx, ctx->freq);
         
-        asprintf (&freq_str, "freq-%f", ctx->freq);
-        json_object_object_add (jresp, freq_str, json_object_new_string ("ok"));
+        snprintf (freq_str, sizeof(freq_str), "%f", ctx->freq);
+        json_object_object_add (jresp, "freq", json_object_new_string (freq_str));
     }
     
     return jresp;
@@ -718,29 +235,28 @@ STATIC json_object* mute (AFB_request *request) {        /* AFB_SESSION_CHECK */
 
     /* no "?value=" parameter : return current state */
     if (!value) {
-        asprintf (&mute_str, "%d", ctx->mute);
-        jresp = json_object_new_object();
-        json_object_object_add (jresp, "mute", json_object_new_string (mute_str));
+        ctx->mute ?
+            json_object_object_add (jresp, "mute", json_object_new_string ("on"))
+          : json_object_object_add (jresp, "mute", json_object_new_string ("off"));
     }
 
     /* "?value=" parameter is "1" or "on" */
-    else if ( atoi(value) == 1 || !strcasecmp(value, "on") )
+    else if ( atoi(value) == 1 || !strcasecmp(value, "on") ) {
         ctx->mute = 1;
+        _radio_set_mute (ctx->idx, ctx->mute);
+        
+        jresp = json_object_new_object();
+        json_object_object_add (jresp, "mute", json_object_new_string ("on"));
+    }
 
     /* "?value=" parameter is "0" or "off" */
-    else if ( atoi(value) == 0 || !strcasecmp(value, "off") )
+    else if ( atoi(value) == 0 || !strcasecmp(value, "off") ) {
         ctx->mute = 0;
+        _radio_set_mute (ctx->idx, ctx->mute);
         
-    else {
-        request->errcode = MHD_HTTP_SERVICE_UNAVAILABLE;
-        return (jsonNewMessage (AFB_FAIL, "Invalid value for mute"));
+        jresp = json_object_new_object();
+        json_object_object_add (jresp, "mute", json_object_new_string ("off"));
     }
-       
-    _radio_set_mute (ctx->idx, ctx->mute);
-        
-    asprintf (&mute_str, "mute-%d", ctx->mute);
-    jresp = json_object_new_object();
-    json_object_object_add (jresp, mute_str, json_object_new_string ("ok"));
     
     return jresp;
 }
@@ -751,25 +267,31 @@ STATIC json_object* play (AFB_request *request) {        /* AFB_SESSION_CHECK */
     const char *value = getQueryValue (request, "value");
     json_object *jresp;
     
-    if (!ctx->radio) {
-        request->errcode = MHD_HTTP_SERVICE_UNAVAILABLE;
-        return (jsonNewMessage (AFB_FAIL, "Radio device not powered on"));
+    /* no "?value=" parameter : return current state */
+    if (!value) {
+        ctx->is_playing ?
+            json_object_object_add (jresp, "play", json_object_new_string ("on"))
+          : json_object_object_add (jresp, "play", json_object_new_string ("off"));
     }
 
     /* "?value=" parameter is "1" or "on" */
     else if ( atoi(value) == 1 || !strcasecmp(value, "on") ) {
         /* radio playback */
+        ctx->is_playing = 1;
         _radio_play (ctx->idx);
+
         jresp = json_object_new_object();
-        json_object_object_add (jresp, "play-on", json_object_new_string ("ok"));
+        json_object_object_add (jresp, "play", json_object_new_string ("on"));
     }
 
     /* "?value=" parameter is "0" or "off" */
     else if ( atoi(value) == 0 || !strcasecmp(value, "off") ) {
         /* radio stop */
+        ctx->is_playing = 0;
         _radio_stop (ctx->idx);
+
         jresp = json_object_new_object();
-        json_object_object_add (jresp, "play-on", json_object_new_string ("ok"));
+        json_object_object_add (jresp, "play-on", json_object_new_string ("off"));
     }
 
     return jresp;
@@ -790,7 +312,7 @@ STATIC AFB_restapi pluginApis[]= {
   {NULL}
 };
 
-PUBLIC AFB_plugin* radioRegister (AFB_session *session) {
+PUBLIC AFB_plugin* radioRegister () {
     AFB_plugin *plugin = malloc (sizeof(AFB_plugin));
     plugin->type  = AFB_PLUGIN_JSON;
     plugin->info  = "Application Framework Binder - Radio plugin";
diff --git a/plugins/radio/radio-api.h b/plugins/radio/radio-api.h
new file mode 100644
index 00000000..3645fff8
--- /dev/null
+++ b/plugins/radio/radio-api.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ *
+ * 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/>.
+ */
+
+#ifndef RADIO_API_H
+#define RADIO_API_H
+
+#include "radio-rtlsdr.h"
+
+/* -------------- PLUGIN DEFINITIONS ----------------- */
+
+#define MAX_RADIO 10
+
+/* structure holding one radio device with current usage status */
+typedef struct {
+    int   idx;
+    char *name;
+    int  used;
+} radioDevT;
+
+/* global plugin handle, should store everything we may need */
+typedef struct {
+  radioDevT *radios[MAX_RADIO];  // pointer to existing radio
+  int devCount;
+} pluginHandleT;
+
+/* private client context [will be destroyed when client leaves] */
+typedef struct {
+    radioDevT *radio;         /* pointer to client radio            */
+    int idx;                  /* radio index within global array    */
+    Mode mode;                /* radio mode: AM/FM                  */
+    float freq;               /* radio frequency (Mhz)              */
+    unsigned char mute;       /* radio muted: 0(false)/1(true)      */
+    unsigned char is_playing; /* radio is playing: 0(false)/1(true) */
+} radioCtxHandleT;
+
+#endif /* RADIO_API_H */
\ No newline at end of file
diff --git a/plugins/radio/radio-rtlsdr.c b/plugins/radio/radio-rtlsdr.c
new file mode 100644
index 00000000..bf4fcea5
--- /dev/null
+++ b/plugins/radio/radio-rtlsdr.c
@@ -0,0 +1,407 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ *
+ * 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 "radio-api.h"
+#include "radio-rtlsdr.h"
+
+/* ------------- RADIO RTLSDR IMPLEMENTATION ---------------- */
+
+/* --- PUBLIC FUNCTIONS --- */
+
+/* Radio initialization should be done only when user start the radio and not at plugin initialization
+   Making this call too early would impose to restart the binder to detect a radio */
+PUBLIC unsigned char _radio_on (unsigned int num, radioCtxHandleT *ctx) {
+ 
+    if (num >= _radio_dev_count())
+        return 0;
+    
+    if (init_dev_count < _radio_dev_count()) {
+        init_dev_count = _radio_dev_count();
+        dev_ctx = (dev_ctx_T**) realloc (dev_ctx, init_dev_count * sizeof(dev_ctx_T));           
+    }
+
+    dev_ctx[num] = (dev_ctx_T*) malloc (sizeof(dev_ctx_T));
+    dev_ctx[num]->dev = NULL;
+    dev_ctx[num]->mode = ctx->mode;
+    dev_ctx[num]->freq = ctx->freq;
+    dev_ctx[num]->mute = ctx->mute;
+    dev_ctx[num]->should_run = 0;
+    dev_ctx[num]->dongle = NULL;
+    dev_ctx[num]->demod = NULL;
+    dev_ctx[num]->output = NULL;
+    _radio_dev_init(dev_ctx[num], num);
+    
+    return 1;
+}
+
+PUBLIC void _radio_off (unsigned int num) {
+
+    if (num >= _radio_dev_count())
+        return;
+
+    if (dev_ctx[num]) {
+        _radio_dev_free(dev_ctx[num]);
+        free(dev_ctx[num]);
+    }
+    /* free(dev_ctx); */
+}
+
+PUBLIC void _radio_set_mode (unsigned int num, Mode mode) {
+    if (!dev_ctx || !dev_ctx[num])
+        return;
+
+    dev_ctx[num]->mode = mode;
+    _radio_apply_params(dev_ctx[num]);
+}
+
+PUBLIC void _radio_set_freq (unsigned int num, float freq) {
+    if (!dev_ctx || !dev_ctx[num])
+        return;
+
+    dev_ctx[num]->freq = freq;
+    _radio_apply_params(dev_ctx[num]);
+}
+
+PUBLIC void _radio_set_mute (unsigned int num, unsigned char mute) {
+    if (!dev_ctx || !dev_ctx[num])
+        return;
+
+    dev_ctx[num]->mute = mute;
+    _radio_apply_params(dev_ctx[num]);
+}
+
+PUBLIC void _radio_play (unsigned int num) {
+    if (!dev_ctx || !dev_ctx[num])
+        return;
+
+    _radio_start_threads(dev_ctx[num]);
+}
+
+PUBLIC void _radio_stop (unsigned int num) {
+    if (!dev_ctx || !dev_ctx[num])
+        return;
+
+    _radio_stop_threads(dev_ctx[num]);
+}
+
+PUBLIC unsigned int _radio_dev_count () {
+    return rtlsdr_get_device_count();
+}
+
+PUBLIC const char* _radio_dev_name (unsigned int num) {
+    return rtlsdr_get_device_name(num);
+}
+
+
+/* --- LOCAL HELPER FUNCTIONS --- */
+
+STATIC unsigned char _radio_dev_init (dev_ctx_T *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;
+
+    _radio_apply_params(dev_ctx);
+
+    return 1;
+}
+
+STATIC unsigned char _radio_dev_free (dev_ctx_T *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+
+    if (rtlsdr_close(dev) < 0)
+        return 0;
+    dev = NULL;
+
+    dev_ctx->dev = dev;
+
+    return 1;
+}
+
+STATIC void _radio_apply_params (dev_ctx_T *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;
+}
+
+STATIC void _radio_start_threads (dev_ctx_T *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);
+}
+
+STATIC void _radio_stop_threads (dev_ctx_T *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) {
+    dev_ctx_T *dev_ctx = (dev_ctx_T *)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);
+}
+ /**/
+STATIC void* _dongle_thread_fn (void *ctx) {
+    dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
+    dongle_ctx *dongle = dev_ctx->dongle;
+
+    rtlsdr_read_async(dev_ctx->dev, _rtlsdr_callback, dev_ctx, 0, 0);
+
+    dongle->thr_finished = 1;
+    return 0;
+}
+
+STATIC 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;
+}
+ /**/
+STATIC 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;
+}
+ /**/
+STATIC void _multiply (int ar, int aj, int br, int bj, int *cr, int *cj) {
+    *cr = ar*br - aj*bj;
+    *cj = aj*br + ar*bj;
+}
+ /**/
+STATIC 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));
+}
+ /**/
+STATIC 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;
+}
+ /**/
+STATIC 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;
+}
+ /**/
+STATIC void* _demod_thread_fn (void *ctx) {
+    dev_ctx_T *dev_ctx = (dev_ctx_T *)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;
+}
+
+STATIC void* _output_thread_fn (void *ctx) {
+    dev_ctx_T *dev_ctx = (dev_ctx_T *)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;
+}
diff --git a/plugins/radio/radio-rtlsdr.h b/plugins/radio/radio-rtlsdr.h
new file mode 100644
index 00000000..f3e2f454
--- /dev/null
+++ b/plugins/radio/radio-rtlsdr.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ *
+ * 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/>.
+ */
+
+#ifndef RADIO_RTLSDR_H
+#define RADIO_RTLSDR_H
+
+/* -------------- RADIO RTLSDR DEFINITIONS ------------------ */
+
+#include <math.h>
+#include <pthread.h>
+#include <rtl-sdr.h>
+
+#include "local-def.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;
+typedef struct dev_ctx dev_ctx_T;
+
+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 {
+    int used;  // radio is free ???
+    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;
+};
+
+PUBLIC unsigned int _radio_dev_count (void);
+PUBLIC const char* _radio_dev_name (unsigned int);
+
+STATIC void* _dongle_thread_fn (void *);
+STATIC void* _demod_thread_fn (void *);
+STATIC void* _output_thread_fn (void *);
+STATIC unsigned char _radio_dev_init (struct dev_ctx *, unsigned int);
+STATIC unsigned char _radio_dev_free (struct dev_ctx *);
+STATIC void _radio_apply_params (struct dev_ctx *);
+STATIC void _radio_start_threads (struct dev_ctx *);
+STATIC void _radio_stop_threads (struct dev_ctx *);
+
+static unsigned int init_dev_count = 0;
+static struct dev_ctx **dev_ctx = NULL;
+
+#endif /* RADIO_RTLSDR_H */
\ No newline at end of file
diff --git a/plugins/samples/HelloWorld.c b/plugins/samples/HelloWorld.c
index 70de03f0..619c075a 100644
--- a/plugins/samples/HelloWorld.c
+++ b/plugins/samples/HelloWorld.c
@@ -79,13 +79,11 @@ STATIC  AFB_restapi pluginApis[]= {
   {"pingnull" , AFB_SESSION_NONE, (AFB_apiCB)pingFail    , "Return NULL"},
   {"pingbug"  , AFB_SESSION_NONE, (AFB_apiCB)pingBug     , "Do a Memory Violation"},
   {"pingJson" , AFB_SESSION_NONE, (AFB_apiCB)pingJson    , "Return a JSON object"},
-  {"ctx-store", AFB_SESSION_NONE, (AFB_apiCB)pingSample  , "Verbose Mode"},
-  {"ctx-load" , AFB_SESSION_NONE, (AFB_apiCB)pingSample  , "Verbose Mode"},
   {NULL}
 };
 
 
-PUBLIC AFB_plugin *dbusRegister () {
+PUBLIC AFB_plugin *helloWorldRegister () {
     AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
     plugin->type  = AFB_PLUGIN_JSON;
     plugin->info  = "Application Framework Binder Service";
diff --git a/plugins/session/token-api.c b/plugins/session/token-api.c
index 75883d3e..3b49d2e4 100644
--- a/plugins/session/token-api.c
+++ b/plugins/session/token-api.c
@@ -181,7 +181,7 @@ STATIC  AFB_restapi pluginApis[]= {
   {NULL}
 };
 
-PUBLIC AFB_plugin *afsvRegister () {
+PUBLIC AFB_plugin *tokenRegister () {
     AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
     plugin->type  = AFB_PLUGIN_JSON; 
     plugin->info  = "Application Framework Binder Service";