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)
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)
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}")
TARGET_LINK_LIBRARIES(afb-daemon ${link_libraries})
INSTALL(TARGETS afb-daemon
- RUNTIME DESTINATION bin)
+ RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR})
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})
*/
#include "audio-api.h"
-#include "audio-alsa.h"
snd_mixer_selem_channel_id_t SCHANNELS[8] = {
SND_MIXER_SCHN_FRONT_LEFT,
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);
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);
}
/* 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++)
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;
}
}
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) {
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;
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;
}
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;
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));
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;
}
#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;
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 */
*/
#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 --------- */
int i;
ctx = malloc (sizeof(audioCtxHandleT));
+ ctx->audio_dev = NULL;
ctx->idx = -1;
for (i = 0; i < 8; i++)
ctx->volume[i] = 25;
STATIC AFB_error releaseAudio (audioCtxHandleT *ctx) {
/* power it off */
- _alsa_free (ctx->idx);
+ _backend_free (ctx);
/* clean client context */
ctx->idx = -1;
/* 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);
/* 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);
}
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]);
/* "?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));
/* 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"));
/* "?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"));
}
/* "?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"));
}
/* "?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"));
}
/* "?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"));
}
#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;
--- /dev/null
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#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;
+}
--- /dev/null
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef AUDIO_PULSE_H
+#define AUDIO_PULSE_H
+
+#include <sys/time.h>
+#include <pulse/pulseaudio.h>
+#include <pulse/simple.h>
+#include <pulse/error.h>
+
+#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 */
*/
#include "radio-api.h"
-#include "radio-rtlsdr.h"
/* ********************************************************
*/
#include "radio-api.h"
-#include "radio-rtlsdr.h"
/* ------------- RADIO RTLSDR IMPLEMENTATION ---------------- */
};
struct dev_ctx {
- int used; // radio is free ???
+ int used; /* TODO: radio is free ??? */
rtlsdr_dev_t* dev;
Mode mode;
float freq;
-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})
Code Review / src / app-framework-binder.git / commitdiff