From: Manuel Bachmann Date: Mon, 11 Jan 2016 01:43:19 +0000 (+0100) Subject: Audio Plugin: add PulseAudio support X-Git-Tag: blowfish_2.0.1~303 X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?p=src%2Fapp-framework-binder.git;a=commitdiff_plain;h=f16675ed24fd331903b8d6ef5d8ac07f6acbd6b0 Audio Plugin: add PulseAudio support If PulseAudio development libraries are present, Audio plugin will now support it. It may still fall back to ALSA if a PulseAudio server is not found at runtime. PulseAudio backend supports multiple clients using one audio adapter. (+ various fixes and style improvements) Signed-off-by: Manuel Bachmann --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 7e9502bf..f37c44c3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ SET(CMAKE_POSITION_INDEPENDENT_CODE ON) SET(PROJECT_NAME "AFB Daemon") SET(PROJECT_PRETTY_NAME "Application Framework Binder Daemon") -SET(PROJECT_VERSION "0.1") +SET(PROJECT_VERSION "0.3") INCLUDE(FindPkgConfig) INCLUDE(CheckIncludeFiles) @@ -40,11 +40,17 @@ PKG_CHECK_MODULES(uuid REQUIRED uuid) PKG_CHECK_MODULES(dbus REQUIRED dbus-1) # Optional plugin dependencies PKG_CHECK_MODULES(alsa alsa) +PKG_CHECK_MODULES(pulseaudio libpulse libpulse-simple) PKG_CHECK_MODULES(librtlsdr librtlsdr>=0.5.0) IF(alsa_FOUND) MESSAGE(STATUS "ALSA found ; will compile Audio plugin... (PLUGIN)") + IF(pulseaudio_FOUND) + MESSAGE(STATUS "PulseAudio found ; Audio plugin will have PulseAudio support") + ADD_DEFINITIONS(-DHAVE_PULSE=1) + ENDIF(pulseaudio_FOUND) ENDIF(alsa_FOUND) + IF(librtlsdr_FOUND) MESSAGE(STATUS "librtlsdr found ; will compile Radio plugin... (PLUGIN)") ENDIF(librtlsdr_FOUND) @@ -52,8 +58,8 @@ ENDIF(librtlsdr_FOUND) INCLUDE(FindThreads) FIND_PACKAGE(Threads) -SET(include_dirs ${INCLUDE_DIRS} ${CMAKE_SOURCE_DIR}/include ${json-c_INCLUDE_DIRS} ${libmicrohttpd_INCLUDE_DIRS} ${uuid_INCLUDE_DIRS} ${dbus_INCLUDE_DIRS} ${alsa_INCLUDE_DIRS} ${librtlsdr_INCLUDE_DIRS}) -SET(link_libraries ${json-c_LIBRARIES} ${libmicrohttpd_LIBRARIES} ${uuid_LIBRARIES} ${dbus_LIBRARIES} ${alsa_LIBRARIES} ${librtlsdr_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${libefence_LIBRARIES} -lmagic -lm -ldl) +SET(include_dirs ${INCLUDE_DIRS} ${CMAKE_SOURCE_DIR}/include ${json-c_INCLUDE_DIRS} ${libmicrohttpd_INCLUDE_DIRS} ${uuid_INCLUDE_DIRS} ${dbus_INCLUDE_DIRS} ${alsa_INCLUDE_DIRS} ${pulseaudio_INCLUDE_DIRS} ${librtlsdr_INCLUDE_DIRS}) +SET(link_libraries ${json-c_LIBRARIES} ${libmicrohttpd_LIBRARIES} ${uuid_LIBRARIES} ${dbus_LIBRARIES} ${alsa_LIBRARIES} ${pulseaudio_LIBRARIES} ${librtlsdr_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${libefence_LIBRARIES} -lmagic -lm -ldl) SET(plugin_install_dir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/afb) ADD_DEFINITIONS(-DPLUGIN_INSTALL_DIR="${plugin_install_dir}") @@ -66,4 +72,4 @@ INCLUDE_DIRECTORIES(${include_dirs}) TARGET_LINK_LIBRARIES(afb-daemon ${link_libraries}) INSTALL(TARGETS afb-daemon - RUNTIME DESTINATION bin) + RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}) diff --git a/plugins/audio/CMakeLists.txt b/plugins/audio/CMakeLists.txt index 7fa1f75f..ee858b4c 100644 --- a/plugins/audio/CMakeLists.txt +++ b/plugins/audio/CMakeLists.txt @@ -1,6 +1,10 @@ IF(alsa_FOUND) - ADD_LIBRARY(audio-api MODULE audio-api.c audio-alsa.c) + IF(pulseaudio_FOUND) + SET(pulse_sources audio-pulse.c) + ENDIF(pulseaudio_FOUND) + + ADD_LIBRARY(audio-api MODULE audio-api.c audio-alsa.c ${pulse_sources}) SET_TARGET_PROPERTIES(audio-api PROPERTIES PREFIX "") TARGET_LINK_LIBRARIES(audio-api ${link_libraries}) INCLUDE_DIRECTORIES(${include_dirs}) diff --git a/plugins/audio/audio-alsa.c b/plugins/audio/audio-alsa.c index 51f49702..7310ea89 100644 --- a/plugins/audio/audio-alsa.c +++ b/plugins/audio/audio-alsa.c @@ -17,7 +17,6 @@ */ #include "audio-api.h" -#include "audio-alsa.h" snd_mixer_selem_channel_id_t SCHANNELS[8] = { SND_MIXER_SCHN_FRONT_LEFT, @@ -43,7 +42,7 @@ PUBLIC unsigned char _alsa_init (const char *name, audioCtxHandleT *ctx) { int num, i; if (snd_pcm_open (&dev, name, SND_PCM_STREAM_PLAYBACK, 0) < 0) - return 0; + return -1; snd_pcm_hw_params_malloc (¶ms); snd_pcm_hw_params_any (dev, params); @@ -53,14 +52,14 @@ PUBLIC unsigned char _alsa_init (const char *name, audioCtxHandleT *ctx) { snd_pcm_hw_params_set_channels (dev, params, ctx->channels); if (snd_pcm_hw_params (dev, params) < 0) { snd_pcm_hw_params_free (params); - return 0; + return -1; } snd_pcm_prepare (dev); snd_mixer_open (&mixer, 0); if (snd_mixer_attach (mixer, name) < 0) { snd_pcm_hw_params_free (params); - return 0; + return -1; } snd_mixer_selem_register (mixer, NULL, NULL); snd_mixer_load (mixer); @@ -97,33 +96,33 @@ PUBLIC unsigned char _alsa_init (const char *name, audioCtxHandleT *ctx) { } /* allocate the global array if it hasn't been done */ - if (!dev_ctx) { - dev_ctx = (dev_ctx_T**) malloc (sizeof(dev_ctx_T)); - dev_ctx[0] = (dev_ctx_T*) malloc (sizeof(dev_ctx_T)); - dev_ctx[0]->name = NULL; - dev_ctx[0]->dev = NULL; + if (!dev_ctx_a) { + dev_ctx_a = (dev_ctx_alsa_T**) malloc (sizeof(dev_ctx_alsa_T)); + dev_ctx_a[0] = (dev_ctx_alsa_T*) malloc (sizeof(dev_ctx_alsa_T)); + dev_ctx_a[0]->name = NULL; + dev_ctx_a[0]->dev = NULL; } /* is a card with similar name already opened ? */ - for (num = 0; num < (sizeof(dev_ctx)/sizeof(dev_ctx_T)); num++) { - if (dev_ctx[num]->name && - !strcmp (dev_ctx[num]->name, name)) - return 0; + for (num = 0; num < (sizeof(dev_ctx_a)/sizeof(dev_ctx_alsa_T)); num++) { + if (dev_ctx_a[num]->name && + !strcmp (dev_ctx_a[num]->name, name)) + return -1; } num++; /* it's not... let us add it to the global array */ - dev_ctx = (dev_ctx_T**) realloc (dev_ctx, (num+1)*sizeof(dev_ctx_T)); - dev_ctx[num] = (dev_ctx_T*) malloc (sizeof(dev_ctx_T)); - dev_ctx[num]->name = strdup (name); - dev_ctx[num]->dev = dev; - dev_ctx[num]->params = params; - dev_ctx[num]->mixer_elm = mixer_elm; - dev_ctx[num]->mixer_elm_m = mixer_elm_m; - dev_ctx[num]->vol_max = vol_max; - dev_ctx[num]->vol = vol; - dev_ctx[num]->thr_should_run = 0; - dev_ctx[num]->thr_finished = 0; + dev_ctx_a = (dev_ctx_alsa_T**) realloc (dev_ctx_a, (num+1)*sizeof(dev_ctx_alsa_T)); + dev_ctx_a[num] = (dev_ctx_alsa_T*) malloc (sizeof(dev_ctx_alsa_T)); + dev_ctx_a[num]->name = strdup (name); + dev_ctx_a[num]->dev = dev; + dev_ctx_a[num]->params = params; + dev_ctx_a[num]->mixer_elm = mixer_elm; + dev_ctx_a[num]->mixer_elm_m = mixer_elm_m; + dev_ctx_a[num]->vol_max = vol_max; + dev_ctx_a[num]->vol = vol; + dev_ctx_a[num]->thr_should_run = 0; + dev_ctx_a[num]->thr_finished = 0; /* make the client context aware of current card state */ for (i = 0; i < 8; i++) @@ -131,22 +130,22 @@ PUBLIC unsigned char _alsa_init (const char *name, audioCtxHandleT *ctx) { ctx->mute = _alsa_get_mute (num); ctx->idx = num; - return 1; + return 0; } PUBLIC void _alsa_free (const char *name) { int num; - for (num = 0; num < (sizeof(dev_ctx)/sizeof(dev_ctx_T)); num++) { - if (dev_ctx[num]->name && - !strcmp (dev_ctx[num]->name, name)) { - snd_pcm_close (dev_ctx[num]->dev); - snd_pcm_hw_params_free (dev_ctx[num]->params); - free (dev_ctx[num]->name); - dev_ctx[num]->name = NULL; - dev_ctx[num]->dev = NULL; - free(dev_ctx[num]); + for (num = 0; num < (sizeof(dev_ctx_a)/sizeof(dev_ctx_alsa_T)); num++) { + if (dev_ctx_a[num]->name && + !strcmp (dev_ctx_a[num]->name, name)) { + snd_pcm_close (dev_ctx_a[num]->dev); + snd_pcm_hw_params_free (dev_ctx_a[num]->params); + free (dev_ctx_a[num]->name); + dev_ctx_a[num]->dev = NULL; + dev_ctx_a[num]->name = NULL; + free (dev_ctx_a[num]); return; } } @@ -154,55 +153,55 @@ PUBLIC void _alsa_free (const char *name) { PUBLIC void _alsa_play (unsigned int num) { - if (!dev_ctx || !dev_ctx[num] || dev_ctx[num]->thr_should_run || + if (!dev_ctx_a || !dev_ctx_a[num] || dev_ctx_a[num]->thr_should_run || access (AUDIO_BUFFER, F_OK) == -1) return; - dev_ctx[num]->thr_should_run = 1; - dev_ctx[num]->thr_finished = 0; - pthread_create(&dev_ctx[num]->thr, NULL, _play_thread_fn, (void*)dev_ctx[num]); + dev_ctx_a[num]->thr_should_run = 1; + dev_ctx_a[num]->thr_finished = 0; + pthread_create (&dev_ctx_a[num]->thr, NULL, _alsa_play_thread_fn, (void*)dev_ctx_a[num]); } PUBLIC void _alsa_stop (unsigned int num) { - if (!dev_ctx || !dev_ctx[num] || !dev_ctx[num]->thr_should_run) + if (!dev_ctx_a || !dev_ctx_a[num] || !dev_ctx_a[num]->thr_should_run) return; /* stop the "while" loop in thread */ - dev_ctx[num]->thr_should_run = 0; + dev_ctx_a[num]->thr_should_run = 0; - while (!dev_ctx[num]->thr_finished) + while (!dev_ctx_a[num]->thr_finished) usleep(100000); - pthread_join(dev_ctx[num]->thr, NULL); + pthread_join (dev_ctx_a[num]->thr, NULL); } PUBLIC int _alsa_get_volume (unsigned int num, unsigned int channel) { - if (!dev_ctx || !dev_ctx[num] || !dev_ctx[num]->mixer_elm) + if (!dev_ctx_a || !dev_ctx_a[num] || !dev_ctx_a[num]->mixer_elm) return; - snd_mixer_selem_get_playback_volume (dev_ctx[num]->mixer_elm, SCHANNELS[channel], &dev_ctx[num]->vol); + snd_mixer_selem_get_playback_volume (dev_ctx_a[num]->mixer_elm, SCHANNELS[channel], &dev_ctx_a[num]->vol); - return (int)(dev_ctx[num]->vol*100)/dev_ctx[num]->vol_max; + return (int)(dev_ctx_a[num]->vol*100)/dev_ctx_a[num]->vol_max; } PUBLIC void _alsa_set_volume (unsigned int num, unsigned int channel, int vol) { - if (!dev_ctx || !dev_ctx[num] || !dev_ctx[num]->mixer_elm || + if (!dev_ctx_a || !dev_ctx_a[num] || !dev_ctx_a[num]->mixer_elm || 0 > vol > 100) return; - snd_mixer_selem_set_playback_volume (dev_ctx[num]->mixer_elm, SCHANNELS[channel], (vol*dev_ctx[num]->vol_max)/100); + snd_mixer_selem_set_playback_volume (dev_ctx_a[num]->mixer_elm, SCHANNELS[channel], (vol*dev_ctx_a[num]->vol_max)/100); } PUBLIC void _alsa_set_volume_all (unsigned int num, int vol) { - if (!dev_ctx || !dev_ctx[num] || !dev_ctx[num]->mixer_elm || + if (!dev_ctx_a || !dev_ctx_a[num] || !dev_ctx_a[num]->mixer_elm || 0 > vol > 100) - snd_mixer_selem_set_playback_volume_all (dev_ctx[num]->mixer_elm, (vol*dev_ctx[num]->vol_max)/100); + snd_mixer_selem_set_playback_volume_all (dev_ctx_a[num]->mixer_elm, (vol*dev_ctx_a[num]->vol_max)/100); } PUBLIC unsigned char _alsa_get_mute (unsigned int num) { @@ -210,18 +209,18 @@ PUBLIC unsigned char _alsa_get_mute (unsigned int num) { int mute = 0; snd_mixer_elem_t *elm_m; - if (!dev_ctx || !dev_ctx[num] || !dev_ctx[num]->mixer_elm) + if (!dev_ctx_a || !dev_ctx_a[num] || !dev_ctx_a[num]->mixer_elm) return; - dev_ctx[num]->mixer_elm_m ? (elm_m = dev_ctx[num]->mixer_elm_m) : - (elm_m = dev_ctx[num]->mixer_elm); + dev_ctx_a[num]->mixer_elm_m ? (elm_m = dev_ctx_a[num]->mixer_elm_m) : + (elm_m = dev_ctx_a[num]->mixer_elm); if (snd_mixer_selem_has_playback_switch (elm_m)) { snd_mixer_selem_get_playback_switch (elm_m, SND_MIXER_SCHN_FRONT_LEFT, &mute); snd_mixer_selem_get_playback_switch (elm_m, SND_MIXER_SCHN_FRONT_RIGHT, &mute); } - if (dev_ctx[num]->mixer_elm_m) + if (dev_ctx_a[num]->mixer_elm_m) return (unsigned char)mute; else return (unsigned char)!mute; @@ -232,14 +231,14 @@ PUBLIC void _alsa_set_mute (unsigned int num, unsigned char tomute) { snd_mixer_elem_t *elm_m; int mute; - if (!dev_ctx || !dev_ctx[num] || !dev_ctx[num]->mixer_elm || 1 < tomute < 0) + if (!dev_ctx_a || !dev_ctx_a[num] || !dev_ctx_a[num]->mixer_elm || 1 < tomute < 0) return; - if (dev_ctx[num]->mixer_elm_m) { - elm_m = dev_ctx[num]->mixer_elm_m; + if (dev_ctx_a[num]->mixer_elm_m) { + elm_m = dev_ctx_a[num]->mixer_elm_m; mute = (int)!tomute; } else { - elm_m = dev_ctx[num]->mixer_elm; + elm_m = dev_ctx_a[num]->mixer_elm; mute = (int)tomute; } @@ -249,25 +248,25 @@ PUBLIC void _alsa_set_mute (unsigned int num, unsigned char tomute) { PUBLIC void _alsa_set_rate (unsigned int num, unsigned int rate) { - if (!dev_ctx || !dev_ctx[num]) + if (!dev_ctx_a || !dev_ctx_a[num]) return; - snd_pcm_hw_params_set_rate_near (dev_ctx[num]->dev, dev_ctx[num]->params, &rate, 0); + snd_pcm_hw_params_set_rate_near (dev_ctx_a[num]->dev, dev_ctx_a[num]->params, &rate, 0); } PUBLIC void _alsa_set_channels (unsigned int num, unsigned int channels) { - if (!dev_ctx || !dev_ctx[num]) + if (!dev_ctx_a || !dev_ctx_a[num]) return; - snd_pcm_hw_params_set_channels (dev_ctx[num]->dev, dev_ctx[num]->params, channels); + snd_pcm_hw_params_set_channels (dev_ctx_a[num]->dev, dev_ctx_a[num]->params, channels); } /* ---- LOCAL THREADED FUNCTIONS ---- */ -STATIC void* _play_thread_fn (void *ctx) { +STATIC void* _alsa_play_thread_fn (void *ctx) { - dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx; + dev_ctx_alsa_T *dev_ctx_a = (dev_ctx_alsa_T *)ctx; FILE *file = NULL; char *buf = NULL; long size; @@ -275,7 +274,7 @@ STATIC void* _play_thread_fn (void *ctx) { file = fopen (AUDIO_BUFFER, "rb"); - while (dev_ctx->thr_should_run && file && (access (AUDIO_BUFFER, F_OK) != -1) ) { + while (dev_ctx_a->thr_should_run && file && (access (AUDIO_BUFFER, F_OK) != -1) ) { fseek (file, 0, SEEK_END); size = ftell (file); buf = (char*) realloc (buf, size * sizeof(char)); @@ -285,15 +284,15 @@ STATIC void* _play_thread_fn (void *ctx) { fread (buf, 1, size, file); fflush (file); - if ((res = snd_pcm_writei (dev_ctx->dev, buf, frames)) != frames) { - snd_pcm_recover (dev_ctx->dev, res, 0); - snd_pcm_prepare (dev_ctx->dev); + if ((res = snd_pcm_writei (dev_ctx_a->dev, buf, frames)) != frames) { + snd_pcm_recover (dev_ctx_a->dev, res, 0); + snd_pcm_prepare (dev_ctx_a->dev); } /* snd_pcm_drain (dev_ctx->dev); */ } if (buf) free(buf); if (file) fclose(file); - dev_ctx->thr_finished = 1; + dev_ctx_a->thr_finished = 1; return 0; } diff --git a/plugins/audio/audio-alsa.h b/plugins/audio/audio-alsa.h index 25292ad1..9b9ee21c 100644 --- a/plugins/audio/audio-alsa.h +++ b/plugins/audio/audio-alsa.h @@ -24,9 +24,9 @@ #include "local-def.h" -typedef struct dev_ctx dev_ctx_T; +typedef struct dev_ctx_alsa dev_ctx_alsa_T; -struct dev_ctx { +struct dev_ctx_alsa { char *name; snd_pcm_t *dev; snd_pcm_hw_params_t *params; @@ -39,10 +39,10 @@ struct dev_ctx { unsigned char thr_finished; }; -STATIC void* _play_thread_fn (void *); +STATIC void* _alsa_play_thread_fn (void *); PUBLIC int _alsa_get_volume (unsigned int, unsigned int); PUBLIC unsigned char _alsa_get_mute (unsigned int); -static struct dev_ctx **dev_ctx = NULL; +static struct dev_ctx_alsa **dev_ctx_a = NULL; #endif /* AUDIO_ALSA_H */ diff --git a/plugins/audio/audio-api.c b/plugins/audio/audio-api.c index 8350377d..4a8d0da1 100644 --- a/plugins/audio/audio-api.c +++ b/plugins/audio/audio-api.c @@ -17,8 +17,88 @@ */ #include "audio-api.h" -#include "audio-alsa.h" +/* ------ BACKEND FUNCTIONS ------- */ + +void _backend_init (const char *name, audioCtxHandleT *ctx) { + +# ifdef HAVE_PULSE + if (_pulse_init (name, ctx) < 0) +# endif + _alsa_init (name, ctx); +} + +void _backend_free (audioCtxHandleT *ctx) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) _pulse_free (ctx); else +# endif + _alsa_free (ctx->idx); +} + +void _backend_play (audioCtxHandleT *ctx) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) _pulse_play (ctx); else +# endif + _alsa_play (ctx->idx); +} + +void _backend_stop (audioCtxHandleT *ctx) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) _pulse_stop (ctx); else +# endif + _alsa_stop (ctx->idx); +} + +int _backend_get_volume (audioCtxHandleT *ctx, unsigned int channel) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) return _pulse_get_volume (ctx, channel); else +# endif + return _alsa_get_volume (ctx->idx, channel); +} + +void _backend_set_volume (audioCtxHandleT *ctx, unsigned int channel, int vol) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) _pulse_set_volume (ctx, channel, vol); else +# endif + _alsa_set_volume (ctx->idx, channel, vol); +} + +void _backend_set_volume_all (audioCtxHandleT *ctx, int vol) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) _pulse_set_volume_all (ctx, vol); else +# endif + _alsa_set_volume_all (ctx->idx, vol); +} + +unsigned char _backend_get_mute (audioCtxHandleT *ctx) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) return _pulse_get_mute (ctx); else +# endif + return _alsa_get_mute (ctx->idx); +} + +void _backend_set_mute (audioCtxHandleT *ctx, unsigned char mute) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) _pulse_set_mute (ctx, mute); else +# endif + _alsa_set_mute (ctx->idx, mute); +} + +void _backend_set_channels (audioCtxHandleT *ctx, unsigned int channels) { + +# ifdef HAVE_PULSE + if (ctx->audio_dev) return; else +# endif + _alsa_set_channels (ctx->idx, channels); +} /* ------ LOCAL HELPER FUNCTIONS --------- */ @@ -29,6 +109,7 @@ STATIC audioCtxHandleT* initAudioCtx () { int i; ctx = malloc (sizeof(audioCtxHandleT)); + ctx->audio_dev = NULL; ctx->idx = -1; for (i = 0; i < 8; i++) ctx->volume[i] = 25; @@ -42,7 +123,7 @@ STATIC audioCtxHandleT* initAudioCtx () { STATIC AFB_error releaseAudio (audioCtxHandleT *ctx) { /* power it off */ - _alsa_free (ctx->idx); + _backend_free (ctx); /* clean client context */ ctx->idx = -1; @@ -66,9 +147,9 @@ STATIC json_object* init (AFB_request *request) { /* AFB_SESSION_CHECK */ /* create a private client context */ if (!request->context) request->context = initAudioCtx(); - - _alsa_init("default", request->context); - + + _backend_init("default", request->context); + jresp = json_object_new_object(); json_object_object_add (jresp, "info", json_object_new_string ("Audio initialised")); return (jresp); @@ -87,7 +168,7 @@ STATIC json_object* volume (AFB_request *request) { /* AFB_SESSION_CHECK */ /* no "?value=" parameter : return current state */ if (!value) { for (i = 0; i < 8; i++) { - ctx->volume[i] = _alsa_get_volume (ctx->idx, i); + ctx->volume[i] = _backend_get_volume (ctx, i); snprintf (volume_str+len_str, sizeof(volume_str)-len_str, "%d,", ctx->volume[i]); len_str = strlen(volume_str); } @@ -107,19 +188,19 @@ STATIC json_object* volume (AFB_request *request) { /* AFB_SESSION_CHECK */ return (jsonNewMessage (AFB_FAIL, "Volume must be between 0 and 100")); } ctx->volume[0] = volume[0]; - _alsa_set_volume (ctx->idx, 0, ctx->volume[0]); + _backend_set_volume (ctx, 0, ctx->volume[0]); snprintf (volume_str, sizeof(volume_str), "%d,", ctx->volume[0]); for (i = 1; i < 8; i++) { volume_i = strtok (NULL, ","); /* if there is only one value, set all channels to this one */ if (!volume_i && i == 1) - _alsa_set_volume_all (ctx->idx, ctx->volume[0]); + _backend_set_volume_all (ctx, ctx->volume[0]); if (!volume_i || 100 < atoi(volume_i) < 0) { - ctx->volume[i] = _alsa_get_volume (ctx->idx, i); + ctx->volume[i] = _backend_get_volume (ctx, i); } else { ctx->volume[i] = atoi(volume_i); - _alsa_set_volume (ctx->idx, i, ctx->volume[i]); + _backend_set_volume (ctx, i, ctx->volume[i]); } len_str = strlen(volume_str); snprintf (volume_str+len_str, sizeof(volume_str)-len_str, "%d,", ctx->volume[i]); @@ -147,7 +228,7 @@ STATIC json_object* channels (AFB_request *request) { /* AFB_SESSION_CHECK */ /* "?value=" parameter, set channels */ else { ctx->channels = atoi (value); - _alsa_set_channels (ctx->idx, ctx->channels); + _backend_set_channels (ctx, ctx->channels); snprintf (channels_str, sizeof(channels_str), "%d", ctx->channels); json_object_object_add (jresp, "channels", json_object_new_string (channels_str)); @@ -164,7 +245,7 @@ STATIC json_object* mute (AFB_request *request) { /* AFB_SESSION_CHECK */ /* no "?value=" parameter : return current state */ if (!value) { - ctx->mute = _alsa_get_mute (ctx->idx); + ctx->mute = _backend_get_mute (ctx); ctx->mute ? json_object_object_add (jresp, "mute", json_object_new_string ("on")) : json_object_object_add (jresp, "mute", json_object_new_string ("off")); @@ -173,7 +254,7 @@ STATIC json_object* mute (AFB_request *request) { /* AFB_SESSION_CHECK */ /* "?value=" parameter is "1" or "true" */ else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) { ctx->mute = 1; - _alsa_set_mute (ctx->idx, ctx->mute); + _backend_set_mute (ctx, ctx->mute); json_object_object_add (jresp, "mute", json_object_new_string ("on")); } @@ -181,7 +262,7 @@ STATIC json_object* mute (AFB_request *request) { /* AFB_SESSION_CHECK */ /* "?value=" parameter is "0" or "false" */ else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) { ctx->mute = 0; - _alsa_set_mute (ctx->idx, ctx->mute); + _backend_set_mute (ctx, ctx->mute); json_object_object_add (jresp, "mute", json_object_new_string ("off")); } @@ -205,7 +286,7 @@ STATIC json_object* play (AFB_request *request) { /* AFB_SESSION_CHECK */ /* "?value=" parameter is "1" or "true" */ else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) { ctx->is_playing = 1; - _alsa_play (ctx->idx); + _backend_play (ctx); json_object_object_add (jresp, "play", json_object_new_string ("on")); } @@ -213,7 +294,7 @@ STATIC json_object* play (AFB_request *request) { /* AFB_SESSION_CHECK */ /* "?value=" parameter is "0" or "false" */ else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) { ctx->is_playing = 0; - _alsa_stop (ctx->idx); + _backend_stop (ctx); json_object_object_add (jresp, "play", json_object_new_string ("off")); } diff --git a/plugins/audio/audio-api.h b/plugins/audio/audio-api.h index b6669ec9..77d6e152 100644 --- a/plugins/audio/audio-api.h +++ b/plugins/audio/audio-api.h @@ -20,26 +20,23 @@ #define AUDIO_API_H #include "audio-alsa.h" +#ifdef HAVE_PULSE +#include "audio-pulse.h" +#endif /* global plugin handle, should store everything we may need */ typedef struct { int devCount; } pluginHandleT; - -/* structure holding one audio card with current usage status */ -typedef struct { - char *name; - void *handle; /* handle to implementation (ALSA, PulseAudio...) */ - } audioDevT; /* private client context [will be destroyed when client leaves] */ typedef struct { - audioDevT *radio; /* pointer to client audio card */ - int idx; /* audio card index within global array */ - int volume[8]; /* audio volume (8 channels) : 0-100 */ - unsigned int channels; /* audio channels : 1(mono)/2(stereo)... */ - unsigned char mute; /* audio muted : 0(false)/1(true) */ - unsigned char is_playing; /* audio is playing: 0(false)/1(true) */ + void *audio_dev; /* handle to implementation (ALSA, PulseAudio...) */ + int idx; /* audio card index within global array */ + int volume[8]; /* audio volume (8 channels) : 0-100 */ + unsigned int channels; /* audio channels : 1(mono)/2(stereo)... */ + unsigned char mute; /* audio muted : 0(false)/1(true) */ + unsigned char is_playing; /* audio is playing: 0(false)/1(true) */ } audioCtxHandleT; diff --git a/plugins/audio/audio-pulse.c b/plugins/audio/audio-pulse.c new file mode 100644 index 00000000..4caf3db5 --- /dev/null +++ b/plugins/audio/audio-pulse.c @@ -0,0 +1,448 @@ +/* + * Copyright (C) 2016 "IoT.bzh" + * Author "Manuel Bachmann" + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "audio-api.h" +#include "audio-pulse.h" + +PUBLIC unsigned char _pulse_init (const char *name, audioCtxHandleT *ctx) { + + pa_mainloop *pa_loop; + pa_mainloop_api *pa_api; + pa_context *pa_context; + pa_simple *pa; + pa_sample_spec *pa_spec; + struct timeval tv_start, tv_now; + int ret, error, i; + + pa_loop = pa_mainloop_new (); + pa_api = pa_mainloop_get_api (pa_loop); + pa_context = pa_context_new (pa_api, "afb-audio-plugin"); + + /* allocate the global array if it hasn't been done */ + if (!dev_ctx_p) + dev_ctx_p = (dev_ctx_pulse_T**) malloc (sizeof(dev_ctx_pulse_T)); + + /* create a temporary device, to be held until sink gets discovered */ + dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T*) malloc (sizeof(dev_ctx_pulse_T)); + dev_ctx_p_t->sink_name = NULL; + dev_ctx_p_t->card_name = (char**) malloc (sizeof(char*)); + dev_ctx_p_t->card_name[0] = strdup (name); + dev_ctx_p_t->pa_loop = pa_loop; + dev_ctx_p_t->pa_context = pa_context; + + pa_context_set_state_callback (pa_context, _pulse_context_cb, (void*)dev_ctx_p_t); + pa_context_connect (pa_context, NULL, 0, NULL); + + /* 1 second should be sufficient to retrieve sink info */ + gettimeofday (&tv_start, NULL); + gettimeofday (&tv_now, NULL); + while (tv_now.tv_sec - tv_start.tv_sec <= 1) { + pa_mainloop_iterate (pa_loop, 0, &ret); + + if (ret == -1) { + if (verbose) fprintf (stderr, "Stopping PulseAudio backend...\n"); + return -1; + } + if (ret >= 0) { + /* found a matching sink from callback */ + if (verbose) fprintf (stderr, "Success : using sink n.%d\n", error); + ctx->audio_dev = (void*)dev_ctx_p[ret]; + break; + } + gettimeofday (&tv_now, NULL); + } + /* fail if we found no matching sink */ + if (!ctx->audio_dev) + return -1; + + /* make the client context aware of current card state */ + ctx->mute = (unsigned char)dev_ctx_p[ret]->mute; + ctx->channels = (unsigned int)dev_ctx_p[ret]->volume.channels; + for (i = 0; i < ctx->channels; i++) + ctx->volume[i] = (int)dev_ctx_p[ret]->volume.values[i]; + ctx->idx = ret; + + /* open matching sink for playback */ + pa_spec = (pa_sample_spec*) malloc (sizeof(pa_sample_spec)); + pa_spec->format = PA_SAMPLE_S16LE; + pa_spec->rate = 22050; + pa_spec->channels = ctx->channels; + + if (!(pa = pa_simple_new (NULL, "afb-audio-plugin", PA_STREAM_PLAYBACK, dev_ctx_p[ret]->sink_name, + "afb-audio-output", pa_spec, NULL, NULL, &error))) { + fprintf (stderr, "Error opening PulseAudio sink %s : %s\n", + dev_ctx_p[ret]->sink_name, pa_strerror(error)); + return -1; + } + dev_ctx_p[ret]->pa = pa; + free (pa_spec); + + client_count++; + + return 0; +} + +PUBLIC void _pulse_free (audioCtxHandleT *ctx) { + + int num, i; + + client_count--; + if (client_count > 0) return; + + for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T)); num++) { + + for (i = 0; num < (sizeof(dev_ctx_p[num]->card_name)/sizeof(char*)); i++) { + free (dev_ctx_p[num]->card_name[i]); + dev_ctx_p[num]->card_name[i] = NULL; + } + pa_context_disconnect (dev_ctx_p[num]->pa_context); + pa_context_unref (dev_ctx_p[num]->pa_context); + pa_mainloop_free (dev_ctx_p[num]->pa_loop); + pa_simple_free (dev_ctx_p[num]->pa); + free (dev_ctx_p[num]->sink_name); + dev_ctx_p[num]->pa_context = NULL; + dev_ctx_p[num]->pa_loop = NULL; + dev_ctx_p[num]->pa = NULL; + dev_ctx_p[num]->sink_name = NULL; + free (dev_ctx_p[num]); + } +} + +PUBLIC void _pulse_play (audioCtxHandleT *ctx) { + + dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev; + + if (!dev_ctx_p_c || dev_ctx_p_c->thr_should_run || access (AUDIO_BUFFER, F_OK) == -1) + return; + + dev_ctx_p_c->thr_should_run = 1; + dev_ctx_p_c->thr_finished = 0; + pthread_create (&dev_ctx_p_c->thr, NULL, _pulse_play_thread_fn, (void*)dev_ctx_p_c); +} + +PUBLIC void _pulse_stop (audioCtxHandleT *ctx) { + + dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev; + + if (!dev_ctx_p_c || !dev_ctx_p_c->thr_should_run) + return; + + dev_ctx_p_c->thr_should_run = 0; + while (!dev_ctx_p_c->thr_finished) + usleep(100000); + pthread_join (dev_ctx_p_c->thr, NULL); +} + +PUBLIC int _pulse_get_volume (audioCtxHandleT *ctx, unsigned int channel) { + + dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev; + + if (!dev_ctx_p_c) + return; + + _pulse_refresh_sink (dev_ctx_p_c); + + return (int)dev_ctx_p_c->volume.values[channel]; +} + +PUBLIC void _pulse_set_volume (audioCtxHandleT *ctx, unsigned int channel, int vol) { + + dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev; + struct pa_cvolume volume; + + if (!dev_ctx_p_c) + return; + + volume = dev_ctx_p_c->volume; + volume.values[channel] = vol; + + pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name, + &volume, NULL, NULL); + _pulse_refresh_sink (dev_ctx_p_c); +} + +PUBLIC void _pulse_set_volume_all (audioCtxHandleT *ctx, int vol) { + + dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev; + struct pa_cvolume volume; + + if (!dev_ctx_p_c) + return; + + pa_cvolume_init (&volume); + pa_cvolume_set (&volume, dev_ctx_p_c->volume.channels, vol); + + pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name, + &volume, NULL, NULL); + _pulse_refresh_sink (dev_ctx_p_c); +} + +PUBLIC unsigned char _pulse_get_mute (audioCtxHandleT *ctx) { + + dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev; + + if (!dev_ctx_p_c) + return; + + _pulse_refresh_sink (dev_ctx_p_c); + + return (unsigned char)dev_ctx_p_c->mute; +} + +PUBLIC void _pulse_set_mute (audioCtxHandleT *ctx, unsigned char mute) { + + dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev; + + if (!dev_ctx_p_c) + return; + + pa_context_set_sink_mute_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name, + (int)mute, NULL, NULL); + _pulse_refresh_sink (dev_ctx_p_c); +} + + /* ---- LOCAL HELPER FUNCTIONS ---- */ + +void _pulse_refresh_sink (dev_ctx_pulse_T* dev_ctx_p_c) { + + dev_ctx_p_c->refresh = 1; + + pa_context_get_sink_info_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name, + _pulse_sink_info_cb, (void*)dev_ctx_p_c); + + while (dev_ctx_p_c->refresh) + pa_mainloop_iterate (dev_ctx_p_c->pa_loop, 0, NULL); +} + +void _pulse_enumerate_cards () { + + void **cards, **card; + char *name, *found, *alsa_name, *card_name; + int new_info, i, num = 0; + + /* allocate the global alsa array */ + alsa_info = (alsa_info_T**) malloc (sizeof(alsa_info_T)); + alsa_info[0] = (alsa_info_T*) malloc (sizeof(alsa_info_T)); + alsa_info[0]->device = NULL; + alsa_info[0]->synonyms = NULL; + + /* we use ALSA to enumerate cards */ + snd_device_name_hint (-1, "pcm", &cards); + card = cards; + + for (; *card != NULL; card++) { + name = snd_device_name_get_hint (*card, "NAME"); + new_info = 1; + + /* alsa name is before ':' (if ':' misses, then it has no card) */ + found = strstr (name, ":"); + if (!found) continue; + /* */ + alsa_name = (char*) malloc (found-name+1); + strncpy (alsa_name, name, found-name); + alsa_name[found-name] = '\0'; + + /* card name is the invariant between "CARD=" and ',' */ + found = strstr (name, "CARD="); + if (!found) continue; + /* */ + found += 5; + card_name = strdup (found); + found = strstr (card_name, ","); + if (found) card_name[found-card_name] = '\0'; + + /* was the card name already listed in the global alsa array ? */ + for (i = 0; i < (sizeof(alsa_info)/sizeof(alsa_info_T)); i++) { + + if (alsa_info[i]->device && + !strcmp (alsa_info[i]->device, card_name)) { + /* it was ; add the alsa name as a new synonym */ + asprintf (&alsa_info[i]->synonyms, "%s:%s", alsa_info[i]->synonyms, alsa_name); + new_info = 0; + break; + } + } + /* it was not ; create it */ + if (new_info) { + alsa_info = (alsa_info_T**) realloc (alsa_info, (num+1)*sizeof(alsa_info_T)); + alsa_info[num]->device = strdup (card_name); + asprintf (&alsa_info[num]->synonyms, ":%s", alsa_name); + num++; + } + free (alsa_name); + free (card_name); + } +} + +char** _pulse_find_cards (const char *name) { + + char **cards = NULL; + char *needle, *found, *next; + int num, i = 0; + + if (!alsa_info) + _pulse_enumerate_cards (); + + asprintf (&needle, ":%s", name); + + for (num = 0; num < (sizeof(alsa_info)/sizeof(alsa_info_T)); num++) { + + found = strstr (alsa_info[num]->synonyms, needle); + while (found) { + /* if next character is not ':' or '\0', we are wrong */ + if ((found[strlen(name)] != ':') && (found[strlen(name)] != '\0')) { + found = strstr (found+1, needle); + continue; + } + /* found it ; now return all the "synonym" cards */ + found = strstr (alsa_info[num]->synonyms, ":"); + while (found) { + next = strstr (found+1, ":"); + cards = (char**) realloc (cards, (i+1)*sizeof(char*)); + cards[i] = (char*) malloc (next-found+1); + strncpy (cards[i], found+1, next-found); + cards[i][next-found] = '\0'; + i++; + } + } + } + free (needle); + + return cards; +} + + /* ---- LOCAL CALLBACK FUNCTIONS ---- */ + +STATIC void _pulse_context_cb (pa_context *context, void *data) { + + pa_context_state_t state = pa_context_get_state (context); + dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data; + + if (state == PA_CONTEXT_FAILED) { + fprintf (stderr, "Could not connect to PulseAudio !\n"); + pa_mainloop_quit (dev_ctx_p_t->pa_loop, -1); + } + + if (state == PA_CONTEXT_READY) + pa_context_get_sink_info_list (context, _pulse_sink_list_cb, (void*)dev_ctx_p_t); +} + +STATIC void _pulse_sink_list_cb (pa_context *context, const pa_sink_info *info, + int eol, void *data) { + + dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data; + const char *device_string; + char **cards; + int num, i; + + if (eol != 0) + return; + + /* ignore sinks with no cards */ + if (!pa_proplist_contains (info->proplist, "device.string")) + return; + + device_string = pa_proplist_gets (info->proplist, "device.string"); + + /* was a sink with similar name already found ? */ + for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T)); num++) { + if (dev_ctx_p[num]->sink_name && + !strcmp (dev_ctx_p[num]->sink_name, info->name)) { + + /* yet it was, did it have the required card ? */ + cards = dev_ctx_p[num]->card_name; + for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) { + if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) { + /* it did : stop there and succeed */ + if (verbose) fprintf (stderr, "Found matching sink : %s\n", info->name); + pa_mainloop_quit (dev_ctx_p_t->pa_loop, num); + } + } + /* it did not, ignore and return */ + return; + } + } + num++; + + /* new sink, find all the cards it manages, fail if none */ + cards = _pulse_find_cards (device_string); + if (!cards) return; + + /* everything is well, register it in global array */ + dev_ctx_p_t->sink_name = strdup (info->name); + dev_ctx_p_t->card_name = cards; + dev_ctx_p_t->mute = info->mute; + dev_ctx_p_t->volume = info->volume; + dev_ctx_p_t->thr_should_run = 0; + dev_ctx_p_t->thr_finished = 0; + dev_ctx_p[num] = dev_ctx_p_t; + + /* does this new sink have the card we are looking for ? */ /* TODO : factorize this */ + for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) { + if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) { + /* it did : stop there and succeed */ + if (verbose) fprintf (stderr, "Found matching sink : %s\n", info->name); + pa_mainloop_quit (dev_ctx_p_t->pa_loop, num); + } + } +} + +STATIC void _pulse_sink_info_cb (pa_context *context, const pa_sink_info *info, + int eol, void *data) { + + dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)data; + + if (eol != 0) + return; + + dev_ctx_p_c->refresh = 0; + dev_ctx_p_c->mute = info->mute; + dev_ctx_p_c->volume = info->volume; +} + + /* ---- LOCAL THREADED FUNCTIONS ---- */ + +STATIC void* _pulse_play_thread_fn (void *ctx) { + + dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)ctx; + FILE *file = NULL; + char *buf = NULL; + long size; + int error; + + file = fopen (AUDIO_BUFFER, "rb"); + + while (dev_ctx_p_c->thr_should_run && file && (access (AUDIO_BUFFER, F_OK) != -1) ) { + fseek (file, 0, SEEK_END); + size = ftell (file); + buf = (char*) realloc (buf, size * sizeof(char)); + + fseek (file, 0, SEEK_SET); + fread (buf, 1, size, file); + fflush (file); + + if (pa_simple_write (dev_ctx_p_c->pa, buf, size*2, &error) < 0) + fprintf (stderr, "Error writing to PulseAudio : %s\n", pa_strerror (error)); + /* pa_simple_drain (dev_ctx_p_c->pa); */ + } + if (buf) free(buf); + if (file) fclose(file); + + dev_ctx_p_c->thr_finished = 1; + return 0; +} diff --git a/plugins/audio/audio-pulse.h b/plugins/audio/audio-pulse.h new file mode 100644 index 00000000..fc18d9c0 --- /dev/null +++ b/plugins/audio/audio-pulse.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2016 "IoT.bzh" + * Author "Manuel Bachmann" + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef AUDIO_PULSE_H +#define AUDIO_PULSE_H + +#include +#include +#include +#include + +#include "audio-alsa.h" +#include "local-def.h" + +typedef struct dev_ctx_pulse dev_ctx_pulse_T; +typedef struct alsa_info alsa_info_T; + +struct dev_ctx_pulse { + char *sink_name; + char **card_name; + pa_mainloop *pa_loop; + pa_context *pa_context; + pa_simple *pa; + pa_cvolume volume; + int mute; + unsigned char refresh; + pthread_t thr; + unsigned char thr_should_run; + unsigned char thr_finished; +}; + +struct alsa_info { + char *device; + char *synonyms; +}; + +STATIC void _pulse_context_cb (pa_context *, void *); +STATIC void _pulse_sink_list_cb (pa_context *, const pa_sink_info *, int, void *); +STATIC void _pulse_sink_info_cb (pa_context *, const pa_sink_info *, int, void *); +STATIC void* _pulse_play_thread_fn (void *); +PUBLIC void _pulse_refresh_sink (dev_ctx_pulse_T *); + +static struct alsa_info **alsa_info = NULL; +static struct dev_ctx_pulse **dev_ctx_p = NULL; +static unsigned int client_count = 0; + +#endif /* AUDIO_PULSE_H */ diff --git a/plugins/radio/radio-api.c b/plugins/radio/radio-api.c index d6855fea..919a875f 100644 --- a/plugins/radio/radio-api.c +++ b/plugins/radio/radio-api.c @@ -17,7 +17,6 @@ */ #include "radio-api.h" -#include "radio-rtlsdr.h" /* ******************************************************** diff --git a/plugins/radio/radio-rtlsdr.c b/plugins/radio/radio-rtlsdr.c index a8c15faa..b99cf9b7 100644 --- a/plugins/radio/radio-rtlsdr.c +++ b/plugins/radio/radio-rtlsdr.c @@ -17,7 +17,6 @@ */ #include "radio-api.h" -#include "radio-rtlsdr.h" /* ------------- RADIO RTLSDR IMPLEMENTATION ---------------- */ diff --git a/plugins/radio/radio-rtlsdr.h b/plugins/radio/radio-rtlsdr.h index 74049a9b..b0c22de0 100644 --- a/plugins/radio/radio-rtlsdr.h +++ b/plugins/radio/radio-rtlsdr.h @@ -69,7 +69,7 @@ struct output_ctx { }; struct dev_ctx { - int used; // radio is free ??? + int used; /* TODO: radio is free ??? */ rtlsdr_dev_t* dev; Mode mode; float freq; diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 6f7117dc..aad78e16 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,9 +1,2 @@ -IF(alsa_FOUND) - ADD_DEFINITIONS(-DHAVE_AUDIO_PLUGIN=1) -ENDIF(alsa_FOUND) -IF(librtlsdr_FOUND) - ADD_DEFINITIONS(-DHAVE_RADIO_PLUGIN=1) -ENDIF(librtlsdr_FOUND) - ADD_LIBRARY(src OBJECT main.c config.c session.c http-svc.c rest-api.c helper-api.c) INCLUDE_DIRECTORIES(${include_dirs})