Update Radio plugin, Media plugin

Radio and Media plugins are now ported to the new API
and build again.

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

10 files changed, 337 insertions, 295 deletions

diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
index 20d27b81..ba3432b4 100644
--- a/plugins/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -2,5 +2,5 @@ ADD_SUBDIRECTORY(afm-main-plugin)
 ADD_SUBDIRECTORY(session)
 ADD_SUBDIRECTORY(samples)
 ADD_SUBDIRECTORY(audio)
-#ADD_SUBDIRECTORY(radio)
-#ADD_SUBDIRECTORY(media)
+ADD_SUBDIRECTORY(radio)
+ADD_SUBDIRECTORY(media)
diff --git a/plugins/audio/audio-api.c b/plugins/audio/audio-api.c
index f8c51cca..a043dce9 100644
--- a/plugins/audio/audio-api.c
+++ b/plugins/audio/audio-api.c
@@ -182,8 +182,7 @@ static void init (struct afb_req request) {        /* AFB_SESSION_CHECK */
 static void volume (struct afb_req request) {      /* AFB_SESSION_CHECK */
 
     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
-    struct afb_arg arg = afb_req_get (request, "value");
-    const char *value = arg.value;
+    const char *value = afb_req_value (request, "value");
     json_object *jresp;
     unsigned int volume[8], i;
     char *volume_i;
@@ -240,8 +239,7 @@ static void volume (struct afb_req request) {      /* AFB_SESSION_CHECK */
 static void channels (struct afb_req request) {    /* AFB_SESSION_CHECK */
 
     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
-    struct afb_arg arg = afb_req_get (request, "value");
-    const char *value = arg.value;
+    const char *value = afb_req_value (request, "value");
     json_object *jresp = json_object_new_object();
     char channels_str[256];
 
@@ -266,8 +264,7 @@ static void channels (struct afb_req request) {    /* AFB_SESSION_CHECK */
 static void mute (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
-    struct afb_arg arg = afb_req_get (request, "value");
-    const char *value = arg.value;
+    const char *value = afb_req_value (request, "value");
     json_object *jresp = json_object_new_object();
 
     /* no "?value=" parameter : return current state */
@@ -300,8 +297,7 @@ static void mute (struct afb_req request) {        /* AFB_SESSION_CHECK */
 static void play (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
-    struct afb_arg arg = afb_req_get (request, "value");
-    const char *value = arg.value;
+    const char *value = afb_req_value (request, "value");
     json_object *jresp = json_object_new_object();
 
     /* no "?value=" parameter : return current state */
diff --git a/plugins/media/media-api.c b/plugins/media/media-api.c
index 7260d3fb..3351ab33 100644
--- a/plugins/media/media-api.c
+++ b/plugins/media/media-api.c
@@ -15,12 +15,21 @@
  * limitations under the License.
  */
 
+#define _GNU_SOURCE
+#include <json-c/json.h>
+
 #include "media-api.h"
+#include "media-rygel.h"
+
+#include "afb-plugin.h"
+#include "afb-req-itf.h"
+
+json_object* _rygel_list (mediaCtxHandleT *);
 
 /* ------ LOCAL HELPER FUNCTIONS --------- */
 
 /* private client context creation ; default values */
-STATIC mediaCtxHandleT* initMediaCtx () {
+static mediaCtxHandleT* initMediaCtx () {
 
     mediaCtxHandleT *ctx;
 
@@ -31,51 +40,47 @@ STATIC mediaCtxHandleT* initMediaCtx () {
     return ctx;
 }
 
-/* called when client session dies [e.g. client quits for more than 15mns] */
-STATIC void freeMedia (void *context) {
-
-    free (context);
-}
-
 /* ------ PUBLIC PLUGIN FUNCTIONS --------- */
 
-STATIC json_object* init (AFB_request *request) {        /* AFB_SESSION_CHECK */
+static void init (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    mediaCtxHandleT *ctx;
+    mediaCtxHandleT *ctx = (mediaCtxHandleT*) afb_req_context_get(request);
     json_object *jresp;
 
     /* create a private client context */
-    if (!request->context)
-        request->context = initMediaCtx();
-
-    ctx = (mediaCtxHandleT*)request->context;
+    if (!ctx) {
+        ctx = initMediaCtx();
+        afb_req_context_set (request, ctx, free);
+    }
 
     /* initialize server connection */
     if (!ctx->media_server)
-      _rygel_init (request->context);
+      _rygel_init (ctx);
 
-    jresp = json_object_new_object();
-    json_object_object_add(jresp, "info", json_object_new_string ("Media initialized"));
-    return jresp;
+    jresp = json_object_new_object ();
+    json_object_object_add (jresp, "init", json_object_new_string ("success"));
+    afb_req_success (request, jresp, "Media - Initialized");
 }
 
-STATIC json_object* list (AFB_request *request) {        /* AFB_SESSION_CHECK */
+static void list (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    mediaCtxHandleT *ctx = (mediaCtxHandleT*)request->context;
+    mediaCtxHandleT *ctx = (mediaCtxHandleT*) afb_req_context_get(request);
     json_object *jresp;
 
     jresp = _rygel_list (ctx);
 
-    if (!jresp)
-      return jsonNewMessage(AFB_FAIL, "No content found in media server");
+    if (!jresp) {
+      afb_req_fail (request, "failed", "no content found in media server");
+      return;
+    }
 
-    return jresp;
+    afb_req_success (request, jresp, "Media - Listed");
 }
 
-STATIC json_object* selecting (AFB_request *request) {   /* AFB_SESSION_CHECK */
+static void selecting (struct afb_req request) {   /* AFB_SESSION_CHECK */
 
-    mediaCtxHandleT *ctx = (mediaCtxHandleT*)request->context;
-    const char *value = getQueryValue (request, "value");
+    mediaCtxHandleT *ctx = (mediaCtxHandleT*) afb_req_context_get(request);
+    const char *value = afb_req_value (request, "value");
     json_object *jresp;
     unsigned int index;
     char index_str[5];
@@ -88,15 +93,19 @@ STATIC json_object* selecting (AFB_request *request) {   /* AFB_SESSION_CHECK */
     }
 
     /* "?value=" parameter is negative */
-    else if (atoi(value) < 0)
-        return jsonNewMessage(AFB_FAIL, "Chosen index cannot be negative");
+    else if (atoi(value) < 0) {
+        afb_req_fail (request, "failed", "chosen index cannot be negatuve");
+        return;
+    }
 
     /* "?value=" parameter is positive */
     else if (atoi(value) >= 0) {
         index = (unsigned int) atoi(value);
 
-        if (!_rygel_select (ctx, index))
-          return jsonNewMessage(AFB_FAIL, "Chosen index superior to current media count");
+        if (!_rygel_select (ctx, index)) {
+          afb_req_fail (request, "failed", "chosen index superior to current media count");
+          return;
+        }
 
         ctx->index = index;
         jresp = json_object_new_object();
@@ -105,57 +114,80 @@ STATIC json_object* selecting (AFB_request *request) {   /* AFB_SESSION_CHECK */
     else
         jresp = NULL;
 
-    return jresp;
+    afb_req_success (request, jresp, "Media - Listed");
 }
 
-STATIC json_object* play (AFB_request *request) {        /* AFB_SESSION_CHECK */
+static void play (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    mediaCtxHandleT *ctx = (mediaCtxHandleT*)request->context;
+    mediaCtxHandleT *ctx = (mediaCtxHandleT*) afb_req_context_get(request);
+    json_object *jresp;
 
-    if (!_rygel_do (ctx, PLAY, NULL))
-      return jsonNewMessage(AFB_FAIL, "Could not play chosen media");
+    if (!_rygel_do (ctx, PLAY, NULL)) {
+      afb_req_fail (request, "failed", "could not play chosen media");
+      return;
+    }
 
-    return jsonNewMessage(AFB_SUCCESS, "PLaying media");
+    jresp = json_object_new_object ();
+    json_object_object_add (jresp, "play", json_object_new_string ("success"));
+    afb_req_success (request, jresp, "Media - Listed");
 }
 
-STATIC json_object* stop (AFB_request *request) {        /* AFB_SESSION_CHECK */
+static void stop (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    mediaCtxHandleT *ctx = (mediaCtxHandleT*)request->context;
+    mediaCtxHandleT *ctx = (mediaCtxHandleT*) afb_req_context_get(request);
+    json_object *jresp;
 
-    if (!_rygel_do (ctx, STOP, NULL))
-      return jsonNewMessage(AFB_FAIL, "Could not stop chosen media");
+    if (!_rygel_do (ctx, STOP, NULL)) {
+      afb_req_fail (request, "failed", "could not stop chosen media");
+      return;
+    }
 
-    return jsonNewMessage(AFB_SUCCESS, "Stopped media");
+    jresp = json_object_new_object ();
+    json_object_object_add (jresp, "stop", json_object_new_string ("success"));
+    afb_req_success (request, jresp, "Media - Stopped");
 }
 
-STATIC json_object* pausing (AFB_request *request) {     /* AFB_SESSION_CHECK */
+static void pausing (struct afb_req request) {     /* AFB_SESSION_CHECK */
 
-    mediaCtxHandleT *ctx = (mediaCtxHandleT*)request->context;
+    mediaCtxHandleT *ctx = (mediaCtxHandleT*) afb_req_context_get(request);
+    json_object *jresp;
 
-    if (!_rygel_do (ctx, PAUSE, NULL))
-      return jsonNewMessage(AFB_FAIL, "Could not pause chosen media");
+    if (!_rygel_do (ctx, PAUSE, NULL)) {
+      afb_req_fail (request, "failed", "could not pause chosen media");
+      return;
+    }
 
-    return jsonNewMessage(AFB_SUCCESS, "Paused media");
+    jresp = json_object_new_object();
+    json_object_object_add (jresp, "pause", json_object_new_string ("success"));
+    afb_req_success (request, jresp, "Media - Paused");
 }
 
-STATIC json_object* seek (AFB_request *request) {        /* AFB_SESSION_CHECK */
+static void seek (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    mediaCtxHandleT *ctx = (mediaCtxHandleT*)request->context;
-    const char *value = getQueryValue (request, "value");
+    mediaCtxHandleT *ctx = (mediaCtxHandleT*) afb_req_context_get(request);
+    const char *value = afb_req_value (request, "value");
+    json_object *jresp;
 
     /* no "?value=" parameter : return error */
-    if (!value)
-      return jsonNewMessage(AFB_FAIL, "You must provide a time");
+    if (!value) {
+      afb_req_fail (request, "failed", "you must provide a time");
+      return;
+    }
 
-    if (!_rygel_do (ctx, SEEK, value))
-      return jsonNewMessage(AFB_FAIL, "Could not seek chosen media");
+    if (!_rygel_do (ctx, SEEK, (char *)value)) {
+      afb_req_fail (request, "failed", "could not seek chosen media");
+      return;
+    }
 
-    return jsonNewMessage(AFB_SUCCESS, "Seeked media");
+    jresp = json_object_new_object();
+    json_object_object_add (jresp, "seek", json_object_new_string ("success"));
+    afb_req_success (request, jresp, "Media - Sought");
 }
 
-STATIC json_object* upload (AFB_request *request, AFB_PostItem *item) { /* AFB_SESSION_CHECK */
+#if 0
+static void upload (AFB_request *request, AFB_PostItem *item) { /* AFB_SESSION_CHECK */
 
-    mediaCtxHandleT *ctx = (mediaCtxHandleT*)request->context;
+    mediaCtxHandleT *ctx = (mediaCtxHandleT*) afb_req_context_get(request);
     AFB_PostCtx *postFileCtx;
     json_object *jresp;
     char *path;
@@ -183,34 +215,34 @@ STATIC json_object* upload (AFB_request *request, AFB_PostItem *item) { /* AFB_S
     /* finalizes file transfer */
     return getPostFile (request, item, NULL);
 }
+#endif
 
-STATIC json_object* ping (AFB_request *request) {         /* AFB_SESSION_NONE */
-    return jsonNewMessage(AFB_SUCCESS, "Ping Binder Daemon - Media API");
+static void ping (struct afb_req request) {         /* AFB_SESSION_NONE */
+    afb_req_success (request, NULL, "Media - Ping succeeded");
 }
 
 
-STATIC AFB_restapi pluginApis[]= {
-  {"init"   , AFB_SESSION_CHECK,  (AFB_apiCB)init       , "Media API - init"   },
-  {"list"   , AFB_SESSION_CHECK,  (AFB_apiCB)list       , "Media API - list"   },
-  {"select" , AFB_SESSION_CHECK,  (AFB_apiCB)selecting  , "Media API - select" },
-  {"play"   , AFB_SESSION_CHECK,  (AFB_apiCB)play       , "Media API - play"   },
-  {"stop"   , AFB_SESSION_CHECK,  (AFB_apiCB)stop       , "Media API - stop"   },
-  {"pause"  , AFB_SESSION_CHECK,  (AFB_apiCB)pausing    , "Media API - pause"  },
-  {"seek"   , AFB_SESSION_CHECK,  (AFB_apiCB)seek       , "Media API - seek"   },
-  {"upload" , AFB_SESSION_CHECK,  (AFB_apiCB)upload     , "Media API - upload" },
-  {"ping"   , AFB_SESSION_NONE,   (AFB_apiCB)ping       , "Media API - ping"   },
+static const struct AFB_restapi pluginApis[]= {
+  {"init"   , AFB_SESSION_CHECK,  init       , "Media API - init"   },
+  {"list"   , AFB_SESSION_CHECK,  list       , "Media API - list"   },
+  {"select" , AFB_SESSION_CHECK,  selecting  , "Media API - select" },
+  {"play"   , AFB_SESSION_CHECK,  play       , "Media API - play"   },
+  {"stop"   , AFB_SESSION_CHECK,  stop       , "Media API - stop"   },
+  {"pause"  , AFB_SESSION_CHECK,  pausing    , "Media API - pause"  },
+  {"seek"   , AFB_SESSION_CHECK,  seek       , "Media API - seek"   },
+//  {"upload" , AFB_SESSION_CHECK,  (AFB_apiCB)upload     , "Media API - upload" },
+  {"ping"   , AFB_SESSION_NONE,   ping       , "Media API - ping"   },
   {NULL}
 };
 
-PUBLIC AFB_plugin* pluginRegister () {
-    AFB_plugin *plugin = malloc (sizeof(AFB_plugin));
-    plugin->type  = AFB_PLUGIN_JSON;
-    plugin->info  = "Application Framework Binder - Media plugin";
-    plugin->prefix  = "media";
-    plugin->apis  = pluginApis;
-
-    /*plugin->handle = initRadioPlugin();*/
-    plugin->freeCtxCB = (AFB_freeCtxCB)freeMedia;
-
-    return (plugin);
+static const struct AFB_plugin pluginDesc = {
+    .type  = AFB_PLUGIN_JSON,
+    .info  = "Application Framework Binder - Media plugin",
+    .prefix  = "media",
+    .apis  = pluginApis
 };
+
+const struct AFB_plugin *pluginRegister (const struct AFB_interface *itf)
+{
+	return &pluginDesc;
+}
diff --git a/plugins/media/media-api.h b/plugins/media/media-api.h
index c545e5d3..c1d764c2 100644
--- a/plugins/media/media-api.h
+++ b/plugins/media/media-api.h
@@ -18,8 +18,6 @@
 #ifndef MEDIA_API_H
 #define MEDIA_API_H
 
-#include "media-rygel.h"
-
 /* -------------- PLUGIN DEFINITIONS ----------------- */
 
 /* private client context [will be destroyed when client leaves] */
@@ -28,6 +26,4 @@ typedef struct {
   unsigned int index;          /* currently selected media file       */
 } mediaCtxHandleT;
 
-PUBLIC json_object* _rygel_list (mediaCtxHandleT *);
-
 #endif /* MEDIA_API_H */
diff --git a/plugins/media/media-rygel.c b/plugins/media/media-rygel.c
index 93a5bce7..66e2901a 100644
--- a/plugins/media/media-rygel.c
+++ b/plugins/media/media-rygel.c
@@ -15,13 +15,18 @@
  * limitations under the License.
  */
 
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <string.h>
+
 #include "media-api.h"
+#include "media-rygel.h"
 
 /* -------------- MEDIA RYGEL IMPLEMENTATION ---------------- */
 
 /* --- PUBLIC FUNCTIONS --- */
 
-PUBLIC unsigned char _rygel_init (mediaCtxHandleT *ctx) {
+unsigned char _rygel_init (mediaCtxHandleT *ctx) {
 
     GMainContext *loop;
     GUPnPContext *context;
@@ -72,7 +77,7 @@ PUBLIC unsigned char _rygel_init (mediaCtxHandleT *ctx) {
     return 1;
 }
 
-PUBLIC void _rygel_free (mediaCtxHandleT *ctx) {
+void _rygel_free (mediaCtxHandleT *ctx) {
 
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)ctx->media_server;
 
@@ -87,7 +92,7 @@ PUBLIC void _rygel_free (mediaCtxHandleT *ctx) {
     dev_ctx_c->content_res = NULL;
 }
 
-PUBLIC json_object* _rygel_list (mediaCtxHandleT *ctx) {
+json_object* _rygel_list (mediaCtxHandleT *ctx) {
 
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)ctx->media_server;
     json_object *json_o, *json_a;
@@ -138,7 +143,7 @@ PUBLIC json_object* _rygel_list (mediaCtxHandleT *ctx) {
     return json_o;
 }
 
-PUBLIC unsigned char _rygel_select (mediaCtxHandleT *ctx, unsigned int index) {
+unsigned char _rygel_select (mediaCtxHandleT *ctx, unsigned int index) {
 
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)ctx->media_server;
     unsigned int count;
@@ -156,7 +161,7 @@ PUBLIC unsigned char _rygel_select (mediaCtxHandleT *ctx, unsigned int index) {
     return 1;
 }
 
-PUBLIC unsigned char _rygel_upload (mediaCtxHandleT *ctx, char *path) {
+unsigned char _rygel_upload (mediaCtxHandleT *ctx, char *path) {
 
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)ctx->media_server;
     char *raw, *upload_id;
@@ -174,7 +179,7 @@ PUBLIC unsigned char _rygel_upload (mediaCtxHandleT *ctx, char *path) {
     return _rygel_start_uploading (dev_ctx_c, path, upload_id);
 }
 
-PUBLIC unsigned char _rygel_do (mediaCtxHandleT *ctx, State state, char *args) {
+unsigned char _rygel_do (mediaCtxHandleT *ctx, State state, char *args) {
 
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)ctx->media_server;
     unsigned int index = ctx->index;
@@ -197,7 +202,7 @@ PUBLIC unsigned char _rygel_do (mediaCtxHandleT *ctx, State state, char *args) {
 
 /* --- LOCAL HELPER FUNCTIONS --- */
 
-STATIC char* _rygel_list_raw (dev_ctx_T* dev_ctx_c, unsigned int *count) {
+char* _rygel_list_raw (dev_ctx_T* dev_ctx_c, unsigned int *count) {
 
     GUPnPServiceProxy *content_dir_proxy;
     struct timeval tv_start, tv_now;
@@ -230,7 +235,7 @@ STATIC char* _rygel_list_raw (dev_ctx_T* dev_ctx_c, unsigned int *count) {
     return dev_ctx_c->content_res;
 }
 
-STATIC char* _rygel_find_upload_id (dev_ctx_T* dev_ctx_c, char *raw) {
+char* _rygel_find_upload_id (dev_ctx_T* dev_ctx_c, char *raw) {
 
     char *found;
     char id[33];
@@ -245,7 +250,7 @@ STATIC char* _rygel_find_upload_id (dev_ctx_T* dev_ctx_c, char *raw) {
     return strdup (id);
 }
 
-STATIC char* _rygel_find_id_for_index (dev_ctx_T* dev_ctx_c, char *raw, unsigned int index) {
+char* _rygel_find_id_for_index (dev_ctx_T* dev_ctx_c, char *raw, unsigned int index) {
 
     char *found = raw;
     char id[33];
@@ -265,7 +270,7 @@ STATIC char* _rygel_find_id_for_index (dev_ctx_T* dev_ctx_c, char *raw, unsigned
     return strdup (id);
 }
 
-STATIC char* _rygel_find_metadata_for_id (dev_ctx_T* dev_ctx_c, char *id) {
+char* _rygel_find_metadata_for_id (dev_ctx_T* dev_ctx_c, char *id) {
 
     GUPnPServiceProxy *content_dir_proxy;
     struct timeval tv_start, tv_now;
@@ -297,7 +302,7 @@ STATIC char* _rygel_find_metadata_for_id (dev_ctx_T* dev_ctx_c, char *id) {
     return dev_ctx_c->content_res;
 }
 
-STATIC char* _rygel_find_uri_for_metadata (dev_ctx_T* dev_ctx_c, char *metadata) {
+char* _rygel_find_uri_for_metadata (dev_ctx_T* dev_ctx_c, char *metadata) {
 
     char *start, *end, *uri = NULL;
     int length;
@@ -325,7 +330,7 @@ STATIC char* _rygel_find_uri_for_metadata (dev_ctx_T* dev_ctx_c, char *metadata)
     return uri;
 }
 
-STATIC char * _rygel_time_for_string (char *string) {
+char * _rygel_time_for_string (char *string) {
 
     int total_seconds;
     unsigned int hours, minutes, seconds;
@@ -341,7 +346,7 @@ STATIC char * _rygel_time_for_string (char *string) {
     return time;
 }
 
-STATIC unsigned char _rygel_start_uploading (dev_ctx_T* dev_ctx_c, char *path, char *upload_id) {
+unsigned char _rygel_start_uploading (dev_ctx_T* dev_ctx_c, char *path, char *upload_id) {
 
     GUPnPServiceProxy *content_dir_proxy;
     GUPnPDIDLLiteWriter *didl_writer;
@@ -396,7 +401,7 @@ STATIC unsigned char _rygel_start_uploading (dev_ctx_T* dev_ctx_c, char *path, c
     return 1;
 }
 
-STATIC unsigned char _rygel_start_doing (dev_ctx_T* dev_ctx_c, char *uri, char *metadata, State state, char *args) {
+unsigned char _rygel_start_doing (dev_ctx_T* dev_ctx_c, char *uri, char *metadata, State state, char *args) {
 
     GUPnPServiceProxy *av_transport_proxy;
     struct timeval tv_start, tv_now;
@@ -431,7 +436,7 @@ STATIC unsigned char _rygel_start_doing (dev_ctx_T* dev_ctx_c, char *uri, char *
     return 1;
 }
 
-STATIC unsigned char _rygel_find_av_transport (dev_ctx_T* dev_ctx_c) {
+unsigned char _rygel_find_av_transport (dev_ctx_T* dev_ctx_c) {
 
     GUPnPControlPoint *control_point;
     gint handler_cb;
@@ -465,7 +470,7 @@ STATIC unsigned char _rygel_find_av_transport (dev_ctx_T* dev_ctx_c) {
 
  /* ---- LOCAL CALLBACK FUNCTIONS ---- */
 
-STATIC void _rygel_device_cb (GUPnPControlPoint *point, GUPnPDeviceProxy *proxy,
+static void _rygel_device_cb (GUPnPControlPoint *point, GUPnPDeviceProxy *proxy,
                               gpointer data) {
 
     mediaCtxHandleT *ctx = (mediaCtxHandleT*)data;
@@ -497,7 +502,7 @@ STATIC void _rygel_device_cb (GUPnPControlPoint *point, GUPnPDeviceProxy *proxy,
     ctx->media_server = (void*)dev_ctx[client_count];
 }
 
-STATIC void _rygel_av_transport_cb (GUPnPControlPoint *point, GUPnPDeviceProxy *proxy,
+static void _rygel_av_transport_cb (GUPnPControlPoint *point, GUPnPDeviceProxy *proxy,
                                     gpointer data) {
 
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)data;
@@ -510,7 +515,7 @@ STATIC void _rygel_av_transport_cb (GUPnPControlPoint *point, GUPnPDeviceProxy *
     dev_ctx_c->av_transport = av_transport;
 }
 
-STATIC void _rygel_content_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyAction *action,
+static void _rygel_content_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyAction *action,
                                gpointer data) {
 
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)data;
@@ -553,7 +558,7 @@ STATIC void _rygel_content_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxy
     }
 }
 
-STATIC void _rygel_metadata_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyAction *action,
+static void _rygel_metadata_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyAction *action,
                                 gpointer data) {
 
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)data;
@@ -567,7 +572,7 @@ STATIC void _rygel_metadata_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProx
     dev_ctx_c->content_res = result;
 }
 
-STATIC void _rygel_select_cb (GUPnPServiceProxy *av_transport, GUPnPServiceProxyAction *action,
+static void _rygel_select_cb (GUPnPServiceProxy *av_transport, GUPnPServiceProxyAction *action,
                               gpointer data)
 {
 
@@ -621,7 +626,7 @@ STATIC void _rygel_select_cb (GUPnPServiceProxy *av_transport, GUPnPServiceProxy
     }
 }
 
-STATIC void _rygel_upload_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyAction *action,
+static void _rygel_upload_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyAction *action,
                               gpointer data)
 {
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)data;
@@ -675,7 +680,7 @@ STATIC void _rygel_upload_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyA
     }
 }
 
-STATIC void _rygel_transfer_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyAction *action,
+static void _rygel_transfer_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProxyAction *action,
                                 gpointer data)
 {
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)data;
@@ -690,7 +695,7 @@ STATIC void _rygel_transfer_cb (GUPnPServiceProxy *content_dir, GUPnPServiceProx
     dev_ctx_c->transfer_started = 1;
 }
 
-STATIC void _rygel_do_cb (GUPnPServiceProxy *av_transport, GUPnPServiceProxyAction *action,
+static void _rygel_do_cb (GUPnPServiceProxy *av_transport, GUPnPServiceProxyAction *action,
                           gpointer data)
 {
     dev_ctx_T *dev_ctx_c = (dev_ctx_T*)data;
diff --git a/plugins/media/media-rygel.h b/plugins/media/media-rygel.h
index 1c097378..0cc84011 100644
--- a/plugins/media/media-rygel.h
+++ b/plugins/media/media-rygel.h
@@ -21,10 +21,11 @@
 /* --------------- MEDIA RYGEL DEFINITIONS ------------------ */
 
 #include <sys/time.h>
+#include <json-c/json.h>
 #include <libgupnp/gupnp-control-point.h>
 #include <libgupnp-av/gupnp-av.h>
 
-#include "local-def.h"
+#include "media-api.h"
 
 #define URN_MEDIA_SERVER   "urn:schemas-upnp-org:device:MediaServer:1"
 #define URN_MEDIA_RENDERER "urn:schemas-upnp-org:device:MediaRenderer:1"
@@ -49,22 +50,29 @@ struct dev_ctx {
     unsigned char transfer_started;
 };
 
-STATIC char* _rygel_list_raw (dev_ctx_T *, unsigned int *);
-STATIC char* _rygel_find_upload_id (dev_ctx_T *, char *);
-STATIC char* _rygel_find_id_for_index (dev_ctx_T *, char *, unsigned int);
-STATIC char* _rygel_find_metadata_for_id (dev_ctx_T *, char *);
-STATIC char* _rygel_find_uri_for_metadata (dev_ctx_T *, char *);
-STATIC unsigned char _rygel_start_uploading (dev_ctx_T *, char *, char *);
-STATIC unsigned char _rygel_start_doing (dev_ctx_T *, char *, char *, State, char *);
-STATIC unsigned char _rygel_find_av_transport (dev_ctx_T *);
-STATIC void _rygel_device_cb (GUPnPControlPoint *, GUPnPDeviceProxy *, gpointer);
-STATIC void _rygel_av_transport_cb (GUPnPControlPoint *, GUPnPDeviceProxy *, gpointer);
-STATIC void _rygel_content_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
-STATIC void _rygel_metadata_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
-STATIC void _rygel_select_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
-STATIC void _rygel_upload_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
-STATIC void _rygel_transfer_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
-STATIC void _rygel_do_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
+unsigned char _rygel_init (mediaCtxHandleT *);
+void _rygel_free (mediaCtxHandleT *);
+json_object* _rygel_list (mediaCtxHandleT *);
+unsigned char _rygel_select (mediaCtxHandleT *, unsigned int);
+unsigned char _rygel_upload (mediaCtxHandleT *, char *);
+unsigned char _rygel_do (mediaCtxHandleT *, State, char *);
+
+char* _rygel_list_raw (dev_ctx_T *, unsigned int *);
+char* _rygel_find_upload_id (dev_ctx_T *, char *);
+char* _rygel_find_id_for_index (dev_ctx_T *, char *, unsigned int);
+char* _rygel_find_metadata_for_id (dev_ctx_T *, char *);
+char* _rygel_find_uri_for_metadata (dev_ctx_T *, char *);
+unsigned char _rygel_start_uploading (dev_ctx_T *, char *, char *);
+unsigned char _rygel_start_doing (dev_ctx_T *, char *, char *, State, char *);
+unsigned char _rygel_find_av_transport (dev_ctx_T *);
+static void _rygel_device_cb (GUPnPControlPoint *, GUPnPDeviceProxy *, gpointer);
+static void _rygel_av_transport_cb (GUPnPControlPoint *, GUPnPDeviceProxy *, gpointer);
+static void _rygel_content_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
+static void _rygel_metadata_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
+static void _rygel_select_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
+static void _rygel_upload_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
+static void _rygel_transfer_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
+static void _rygel_do_cb (GUPnPServiceProxy *, GUPnPServiceProxyAction *, gpointer);
 
 static unsigned int client_count = 0;
 static struct dev_ctx **dev_ctx = NULL;
diff --git a/plugins/radio/radio-api.c b/plugins/radio/radio-api.c
index b2a22902..d3d04ae8 100644
--- a/plugins/radio/radio-api.c
+++ b/plugins/radio/radio-api.c
@@ -17,6 +17,7 @@
 
 #define _GNU_SOURCE
 #include <strings.h>
+#include <json-c/json.h>
 
 #include "radio-api.h"
 #include "radio-rtlsdr.h"
@@ -35,7 +36,7 @@
 static pluginHandleT *the_radio = NULL;
 
 /* detect new radio devices */
-STATIC void updateRadioDevList(pluginHandleT *handle) {
+void updateRadioDevList(pluginHandleT *handle) {
 
   int idx;  
 
@@ -49,24 +50,22 @@ STATIC void updateRadioDevList(pluginHandleT *handle) {
 }
 
 /* global plugin context creation ; at loading time [radio devices might not be visible] */
-STATIC pluginHandleT* initRadioPlugin() {
+static void initRadioPlugin() {
 
-  pluginHandleT *handle;
+  pluginHandleT *handle = the_radio;
 
   handle = calloc (1, sizeof(pluginHandleT));
   updateRadioDevList (handle);
-
-  return handle;
 }
 
 /* private client context creation ; default values */
-STATIC radioCtxHandleT* initRadioCtx () {
+static radioCtxHandleT* initRadioCtx () {
 
     radioCtxHandleT *ctx;
 
     ctx = malloc (sizeof(radioCtxHandleT));
     ctx->radio = NULL;
-    //ctx->idx = -1;
+    ctx->idx = -1;
     ctx->mode = FM;
     ctx->freq = 100.0;
     ctx->mute = 0;
@@ -76,7 +75,7 @@ STATIC radioCtxHandleT* initRadioCtx () {
 }
 
 /* reserve a radio device for requesting client, power it on */
-STATIC AFB_error reserveRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
+unsigned char reserveRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
     unsigned int idx;
 
     /* loop on all devices, find an unused one */
@@ -84,7 +83,7 @@ STATIC AFB_error reserveRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
         if (idx == MAX_RADIO) break;
         if (handle->radios[idx]->used == FALSE) goto found_radio; /* found one */
     }
-    return AFB_FAIL;
+    return 0;
 
    found_radio:
     /* try to power it on, passing client context info such as frequency... */
@@ -98,11 +97,11 @@ STATIC AFB_error reserveRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
     ctx->radio = handle->radios[idx];
     ctx->idx = idx;
 
-    return AFB_SUCCESS;
+    return 1;
 }
 
 /* free a radio device from requesting client, power it off */
-STATIC AFB_error releaseRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
+unsigned char releaseRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
 
     /* stop playing if it was doing this (blocks otherwise) */
     if (ctx->is_playing) {
@@ -118,13 +117,13 @@ STATIC AFB_error releaseRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
 
     /* clean client context */
     ctx->radio = NULL;
-    //ctx->idx = -1;
+    ctx->idx = -1;
 
-    return AFB_SUCCESS;
+    return 1;
 }
 
 /* called when client session dies [e.g. client quits for more than 15mns] */
-STATIC void freeRadio (void *context) {
+static void freeRadio (void *context) {
 
     releaseRadio (the_radio, context);
     free (context);
@@ -133,24 +132,27 @@ STATIC void freeRadio (void *context) {
 
 /* ------ PUBLIC PLUGIN FUNCTIONS --------- */
 
-STATIC void init (struct afb_req request) {        /* AFB_SESSION_CHECK */
+static void init (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
+    radioCtxHandleT *ctx = (radioCtxHandleT*) afb_req_context_get(request);
     json_object *jresp;
 
     /* create a private client context */
-    if (!request.context)
-        request.context = initRadioCtx();
+    if (!ctx) {
+        ctx = initRadioCtx();
+        afb_req_context_set (request, ctx, free);
+    }
 
     jresp = json_object_new_object();
-    json_object_object_add(jresp, "info", json_object_new_string ("Radio initialized"));
+    json_object_object_add(jresp, "init", json_object_new_string ("success"));
     afb_req_success (request, jresp, "Radio - Initialized");
 }
 
-STATIC void power (struct afb_req request) {       /* AFB_SESSION_CHECK */
+static void power (struct afb_req request) {       /* AFB_SESSION_CHECK */
 
     pluginHandleT *handle = the_radio;
-    radioCtxHandleT *ctx = (radioCtxHandleT*)request.context;
-    const char *value = afb_req_argument (request, "value");
+    radioCtxHandleT *ctx = (radioCtxHandleT*) afb_req_context_get(request);
+    const char *value = afb_req_value (request, "value");
     json_object *jresp;
 
     /* no "?value=" parameter : return current state */
@@ -164,10 +166,9 @@ STATIC void power (struct afb_req request) {       /* AFB_SESSION_CHECK */
     /* "?value=" parameter is "1" or "true" */
     else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) {
         if (!ctx->radio) {
-            if (reserveRadio (handle, ctx) == AFB_FAIL) {
-                //request->errcode = MHD_HTTP_SERVICE_UNAVAILABLE;
-                afb_req_fail (request, "failed", "No more radio devices available");
-		return;
+            if (!reserveRadio (handle, ctx)) {
+                afb_req_fail (request, "failed", "no more radio devices available");
+		        return;
             }
         }
         jresp = json_object_new_object();
@@ -177,10 +178,9 @@ STATIC void power (struct afb_req request) {       /* AFB_SESSION_CHECK */
     /* "?value=" parameter is "0" or "false" */
     else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) {
         if (ctx->radio) {
-            if (releaseRadio (handle, ctx) == AFB_FAIL) {
-                //request->errcode = MHD_HTTP_SERVICE_UNAVAILABLE;
+            if (!releaseRadio (handle, ctx)) {
                 afb_req_fail (request, "failed", "Unable to release radio device");
-		return;
+		        return;
             }
         }
         jresp = json_object_new_object();
@@ -192,10 +192,10 @@ STATIC void power (struct afb_req request) {       /* AFB_SESSION_CHECK */
     afb_req_success (request, jresp, "Radio - Power set");
 }
 
-STATIC void mode (struct afb_req request) {        /* AFB_SESSION_CHECK */
+static void mode (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    radioCtxHandleT *ctx = (radioCtxHandleT*)request.context;
-    const char *value = afb_req_argument (request, "value");
+    radioCtxHandleT *ctx = (radioCtxHandleT*) afb_req_context_get(request);
+    const char *value = afb_req_value (request, "value");
     json_object *jresp = json_object_new_object();
 
     /* no "?value=" parameter : return current state */
@@ -222,10 +222,10 @@ STATIC void mode (struct afb_req request) {        /* AFB_SESSION_CHECK */
     afb_req_success (request, jresp, "Radio - Mode set");
 }
 
-STATIC void freq (struct afb_req request) {        /* AFB_SESSION_CHECK */
+static void freq (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    radioCtxHandleT *ctx = (radioCtxHandleT*)request.context;
-    const char *value = afb_req_argument (request, "value");
+    radioCtxHandleT *ctx = (radioCtxHandleT*) afb_req_context_get(request);
+    const char *value = afb_req_value (request, "value");
     json_object *jresp = json_object_new_object();
     double freq;
     char freq_str[256];
@@ -249,12 +249,11 @@ STATIC void freq (struct afb_req request) {        /* AFB_SESSION_CHECK */
     afb_req_success (request, jresp, "Radio - Frequency Set");
 }
 
-STATIC void mute (struct afb_req request) {        /* AFB_SESSION_CHECK */
+static void mute (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    radioCtxHandleT *ctx = (radioCtxHandleT*)request.context;
-    const char *value = afb_req_argument (request, "value");
+    radioCtxHandleT *ctx = (radioCtxHandleT*) afb_req_context_get(request);
+    const char *value = afb_req_value (request, "value");
     json_object *jresp = json_object_new_object();
-    //char *mute_str;
 
     /* no "?value=" parameter : return current state */
     if (!value || !ctx->radio) {
@@ -280,10 +279,10 @@ STATIC void mute (struct afb_req request) {        /* AFB_SESSION_CHECK */
     afb_req_success (request, jresp, "Radio - Mute set"); 
 }
 
-STATIC void play (struct afb_req request) {        /* AFB_SESSION_CHECK */
+static void play (struct afb_req request) {        /* AFB_SESSION_CHECK */
 
-    radioCtxHandleT *ctx = (radioCtxHandleT*)request.context;
-    const char *value = afb_req_argument (request, "value");
+    radioCtxHandleT *ctx = (radioCtxHandleT*) afb_req_context_get(request);
+    const char *value = afb_req_value (request, "value");
     json_object *jresp = json_object_new_object();
     
     /* no "?value=" parameter : return current state */
@@ -312,12 +311,12 @@ STATIC void play (struct afb_req request) {        /* AFB_SESSION_CHECK */
     afb_req_success (request, jresp, "Radio - Play succeeded");
 }
 
-STATIC void ping (struct afb_req request) {         /* AFB_SESSION_NONE */
+static void ping (struct afb_req request) {         /* AFB_SESSION_NONE */
     afb_req_success (request, NULL, "Radio - Ping succeeded");
 }
 
 
-STATIC const struct AFB_restapi pluginApis[]= {
+static const struct AFB_restapi pluginApis[]= {
   {"init"   , AFB_SESSION_CHECK,  init       , "Radio API - init"},
   {"power"  , AFB_SESSION_CHECK,  power      , "Radio API - power"},
   {"mode"   , AFB_SESSION_CHECK,  mode       , "Radio API - mode"},
@@ -328,11 +327,15 @@ STATIC const struct AFB_restapi pluginApis[]= {
   {NULL}
 };
 
-STATIC const struct AFB_plugin plug_desc = {
+static const struct AFB_plugin pluginDesc = {
     .type  = AFB_PLUGIN_JSON,
     .info  = "Application Framework Binder - Radio plugin",
     .prefix  = "radio",
-    .apis  = pluginApis,
-    //plugin->freeCtxCB = (AFB_freeCtxCB)freeRadio;
-    //the_radio = initRadioPlugin();
+    .apis  = pluginApis
 };
+
+const struct AFB_plugin *pluginRegister (const struct AFB_interface *itf)
+{
+    initRadioPlugin();
+	return &pluginDesc;
+}
diff --git a/plugins/radio/radio-api.h b/plugins/radio/radio-api.h
index a08198ac..162bd5df 100644
--- a/plugins/radio/radio-api.h
+++ b/plugins/radio/radio-api.h
@@ -39,7 +39,7 @@ typedef struct {
 /* private client context [will be destroyed when client leaves] */
 typedef struct {
     radioDevT *radio;         /* pointer to client radio            */
-    unsigned int idx;         /* radio index within global array    */
+    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)      */
diff --git a/plugins/radio/radio-rtlsdr.c b/plugins/radio/radio-rtlsdr.c
index 45db7f7b..49efd2b9 100644
--- a/plugins/radio/radio-rtlsdr.c
+++ b/plugins/radio/radio-rtlsdr.c
@@ -16,25 +16,30 @@
  */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 #include "radio-api.h"
 #include "radio-rtlsdr.h"
 
+static unsigned int init_dev_count = 0;
+static struct dev_ctx **dev_ctx = NULL;
+
 /* ------------- 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) {
+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 = (dev_ctx_T**) realloc (dev_ctx, init_dev_count * sizeof(dev_ctx_T*));           
     }
 
     dev_ctx[num] = (dev_ctx_T*) malloc (sizeof(dev_ctx_T));
@@ -46,95 +51,95 @@ PUBLIC unsigned char _radio_on (unsigned int num, radioCtxHandleT *ctx) {
     dev_ctx[num]->dongle = NULL;
     dev_ctx[num]->demod = NULL;
     dev_ctx[num]->output = NULL;
-    _radio_dev_init(dev_ctx[num], num);
+    _radio_dev_init (dev_ctx[num], num);
 
     return 1;
 }
 
-PUBLIC void _radio_off (unsigned int num) {
+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]);
+        _radio_dev_free (dev_ctx[num]);
+        free (dev_ctx[num]);
     }
     
     /* free(dev_ctx); */
 }
 
-PUBLIC void _radio_set_mode (unsigned int num, Mode mode) {
+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]);
+    _radio_apply_params (dev_ctx[num]);
 }
 
-PUBLIC void _radio_set_freq (unsigned int num, double freq) {
+void _radio_set_freq (unsigned int num, double freq) {
     if (!dev_ctx || !dev_ctx[num])
         return;
 
     dev_ctx[num]->freq = (float)freq;
-    _radio_apply_params(dev_ctx[num]);
+    _radio_apply_params (dev_ctx[num]);
 }
 
-PUBLIC void _radio_set_mute (unsigned int num, unsigned char mute) {
+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]);
+    _radio_apply_params (dev_ctx[num]);
 }
 
-PUBLIC void _radio_play (unsigned int num) {
+void _radio_play (unsigned int num) {
     if (!dev_ctx || !dev_ctx[num])
         return;
 
-    _radio_start_threads(dev_ctx[num]);
+    _radio_start_threads (dev_ctx[num]);
 }
 
-PUBLIC void _radio_stop (unsigned int num) {
+void _radio_stop (unsigned int num) {
     if (!dev_ctx || !dev_ctx[num])
         return;
 
-    _radio_stop_threads(dev_ctx[num]);
+    _radio_stop_threads (dev_ctx[num]);
 }
 
-PUBLIC unsigned int _radio_dev_count () {
+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);
+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) {
+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)
+    if (rtlsdr_open (&dev, num) < 0)
         return 0;
 
-    rtlsdr_set_tuner_gain_mode(dev, 0);
+    rtlsdr_set_tuner_gain_mode (dev, 0);
 
-    if (rtlsdr_reset_buffer(dev) < 0)
+    if (rtlsdr_reset_buffer (dev) < 0)
         return 0;
 
     dev_ctx->dev = dev;
 
-    _radio_apply_params(dev_ctx);
+    _radio_apply_params (dev_ctx);
 
     return 1;
 }
 
-STATIC unsigned char _radio_dev_free (dev_ctx_T *dev_ctx) {
+unsigned char _radio_dev_free (dev_ctx_T *dev_ctx) {
     rtlsdr_dev_t *dev = dev_ctx->dev;
 
-    if (rtlsdr_close(dev) < 0)
+    if (rtlsdr_close (dev) < 0)
         return 0;
     dev = NULL;
 
@@ -143,7 +148,7 @@ STATIC unsigned char _radio_dev_free (dev_ctx_T *dev_ctx) {
     return 1;
 }
 
-STATIC void _radio_apply_params (dev_ctx_T *dev_ctx) {
+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;
@@ -156,48 +161,47 @@ STATIC void _radio_apply_params (dev_ctx_T *dev_ctx) {
         freq += 16000;
     freq += rate / 4;
 
-    rtlsdr_set_center_freq(dev, freq);
-    rtlsdr_set_sample_rate(dev, rate);
+    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));
+void _radio_start_threads (dev_ctx_T *dev_ctx) {
+    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);
+    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);
+    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);
+    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);
+    pthread_create (&output->thr, NULL, _output_thread_fn, (void*)dev_ctx);
 }
 
-STATIC void _radio_stop_threads (dev_ctx_T *dev_ctx) {
+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;
@@ -209,33 +213,33 @@ STATIC void _radio_stop_threads (dev_ctx_T *dev_ctx) {
      /* 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);
+    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;
+        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) {
+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;
@@ -264,24 +268,24 @@ STATIC void _rtlsdr_callback (unsigned char *buf, uint32_t len, void *ctx) {
         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);
+       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);
+       pthread_rwlock_unlock (&demod->lck);
+       pthread_signal (&demod->ok, &demod->ok_m);
 }
  /**/
-STATIC void* _dongle_thread_fn (void *ctx) {
+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);
+    rtlsdr_read_async (dev_ctx->dev, _rtlsdr_callback, dev_ctx, 0, 0);
 
     dongle->thr_finished = 1;
     return 0;
 }
 
-STATIC void _lowpass_demod (void *ctx) {
+static void _lowpass_demod (void *ctx) {
     demod_ctx *demod = (demod_ctx *)ctx;
     int i=0, i2=0;
 
@@ -301,7 +305,7 @@ STATIC void _lowpass_demod (void *ctx) {
     demod->buf_len = i2;
 }
  /**/
-STATIC void _lowpassreal_demod (void *ctx) {
+static void _lowpassreal_demod (void *ctx) {
     demod_ctx *demod = (demod_ctx *)ctx;
     int i=0, i2=0;
     int fast = 200000;
@@ -321,30 +325,30 @@ STATIC void _lowpassreal_demod (void *ctx) {
     demod->res_len = i2;
 }
  /**/
-STATIC void _multiply (int ar, int aj, int br, int bj, int *cr, int *cj) {
+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) {
+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);
+    _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) {
+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);
+    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]);
+        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];
@@ -352,7 +356,7 @@ STATIC void _fm_demod (void *ctx) {
     demod->res_len = buf_len/2;
 }
  /**/
-STATIC void _am_demod (void *ctx) {
+static void _am_demod (void *ctx) {
     demod_ctx *demod = (demod_ctx *)ctx;
     int16_t *buf = demod->buf;
     int buf_len = demod->buf_len;
@@ -366,35 +370,35 @@ STATIC void _am_demod (void *ctx) {
     demod->res_len = buf_len/2;
 }
  /**/
-STATIC void* _demod_thread_fn (void *ctx) {
+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);
+            pthread_wait (&demod->ok, &demod->ok_m);
+            pthread_rwlock_wrlock (&demod->lck);
+        _lowpass_demod (demod);
         if (dev_ctx->mode == FM)
-            _fm_demod(demod);
+            _fm_demod (demod);
         else
-            _am_demod(demod);
-        _lowpassreal_demod(demod);
-           pthread_rwlock_unlock(&demod->lck);
+            _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);
+           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);
+           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) {
+static void* _output_thread_fn (void *ctx) {
     dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
     output_ctx *output = dev_ctx->output;
     FILE *file;
@@ -402,14 +406,14 @@ STATIC void* _output_thread_fn (void *ctx) {
     file = fopen (AUDIO_BUFFER, "wb");
 
     while (dev_ctx->should_run) {
-           pthread_wait(&output->ok, &output->ok_m);
-           pthread_rwlock_rdlock(&output->lck);
+           pthread_wait (&output->ok, &output->ok_m);
+           pthread_rwlock_rdlock (&output->lck);
            if (!dev_ctx->mute && file) {
                fwrite (output->buf, 2, output->buf_len, file);
                fflush (file);
                fseek (file, 0, SEEK_SET);
            }
-           pthread_rwlock_unlock(&output->lck);
+           pthread_rwlock_unlock (&output->lck);
     }
     if (file) fclose(file);
     unlink (AUDIO_BUFFER);
diff --git a/plugins/radio/radio-rtlsdr.h b/plugins/radio/radio-rtlsdr.h
index 3d003924..ba39211e 100644
--- a/plugins/radio/radio-rtlsdr.h
+++ b/plugins/radio/radio-rtlsdr.h
@@ -25,11 +25,11 @@
 #include <rtl-sdr.h>
 
 #include "radio-api.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
+#define AUDIO_BUFFER "/tmp/audio_buf"
 
 typedef struct dongle_ctx dongle_ctx;
 typedef struct demod_ctx demod_ctx;
@@ -80,27 +80,25 @@ struct dev_ctx {
     output_ctx *output;
 };
 
-PUBLIC unsigned int _radio_dev_count (void);
-PUBLIC const char* _radio_dev_name (unsigned int);
+unsigned int _radio_dev_count (void);
+const char* _radio_dev_name (unsigned int);
 
-PUBLIC unsigned char _radio_on (unsigned int, radioCtxHandleT *);
-PUBLIC void _radio_off (unsigned int);
-PUBLIC void _radio_stop (unsigned int);
-PUBLIC void _radio_play (unsigned int);
-PUBLIC void _radio_set_mode (unsigned int, Mode);
-PUBLIC void _radio_set_freq (unsigned int, double);
-PUBLIC void _radio_set_mute (unsigned int, unsigned char);
+unsigned char _radio_on (unsigned int, radioCtxHandleT *);
+void _radio_off (unsigned int);
+void _radio_stop (unsigned int);
+void _radio_play (unsigned int);
+void _radio_set_mode (unsigned int, Mode);
+void _radio_set_freq (unsigned int, double);
+void _radio_set_mute (unsigned int, unsigned char);
 
-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 *);
+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 = 0;
-static struct dev_ctx **dev_ctx = NULL;
+static void* _dongle_thread_fn (void *);
+static void* _demod_thread_fn (void *);
+static void* _output_thread_fn (void *);
 
 #endif /* RADIO_RTLSDR_H */