2 * Copyright (C) 2016 "IoT.bzh"
3 * Author "Manuel Bachmann"
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 #include "audio-api.h"
20 #include "audio-pulse.h"
22 PUBLIC unsigned char _pulse_init (const char *name, audioCtxHandleT *ctx) {
25 pa_mainloop_api *pa_api;
26 pa_context *pa_context;
28 pa_sample_spec *pa_spec;
29 struct timeval tv_start, tv_now;
32 pa_loop = pa_mainloop_new ();
33 pa_api = pa_mainloop_get_api (pa_loop);
34 pa_context = pa_context_new (pa_api, "afb-audio-plugin");
36 /* allocate the global array if it hasn't been done */
38 dev_ctx_p = (dev_ctx_pulse_T**) malloc (sizeof(dev_ctx_pulse_T));
40 /* create a temporary device, to be held until sink gets discovered */
41 dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T*) malloc (sizeof(dev_ctx_pulse_T));
42 dev_ctx_p_t->sink_name = NULL;
43 dev_ctx_p_t->card_name = (char**) malloc (sizeof(char*));
44 dev_ctx_p_t->card_name[0] = strdup (name);
45 dev_ctx_p_t->pa_loop = pa_loop;
46 dev_ctx_p_t->pa_context = pa_context;
48 pa_context_set_state_callback (pa_context, _pulse_context_cb, (void*)dev_ctx_p_t);
49 pa_context_connect (pa_context, NULL, 0, NULL);
51 /* 1 second should be sufficient to retrieve sink info */
52 gettimeofday (&tv_start, NULL);
53 gettimeofday (&tv_now, NULL);
54 while (tv_now.tv_sec - tv_start.tv_sec <= 1) {
55 pa_mainloop_iterate (pa_loop, 0, &ret);
58 if (verbose) fprintf (stderr, "Stopping PulseAudio backend...\n");
62 /* found a matching sink from callback */
63 if (verbose) fprintf (stderr, "Success : using sink n.%d\n", error);
64 ctx->audio_dev = (void*)dev_ctx_p[ret];
67 gettimeofday (&tv_now, NULL);
69 /* fail if we found no matching sink */
73 /* make the client context aware of current card state */
74 ctx->mute = (unsigned char)dev_ctx_p[ret]->mute;
75 ctx->channels = (unsigned int)dev_ctx_p[ret]->volume.channels;
76 for (i = 0; i < ctx->channels; i++)
77 ctx->volume[i] = (int)dev_ctx_p[ret]->volume.values[i];
80 /* open matching sink for playback */
81 pa_spec = (pa_sample_spec*) malloc (sizeof(pa_sample_spec));
82 pa_spec->format = PA_SAMPLE_S16LE;
83 pa_spec->rate = 22050;
84 pa_spec->channels = ctx->channels;
86 if (!(pa = pa_simple_new (NULL, "afb-audio-plugin", PA_STREAM_PLAYBACK, dev_ctx_p[ret]->sink_name,
87 "afb-audio-output", pa_spec, NULL, NULL, &error))) {
88 fprintf (stderr, "Error opening PulseAudio sink %s : %s\n",
89 dev_ctx_p[ret]->sink_name, pa_strerror(error));
92 dev_ctx_p[ret]->pa = pa;
100 PUBLIC void _pulse_free (audioCtxHandleT *ctx) {
105 if (client_count > 0) return;
107 for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T)); num++) {
109 for (i = 0; num < (sizeof(dev_ctx_p[num]->card_name)/sizeof(char*)); i++) {
110 free (dev_ctx_p[num]->card_name[i]);
111 dev_ctx_p[num]->card_name[i] = NULL;
113 pa_context_disconnect (dev_ctx_p[num]->pa_context);
114 pa_context_unref (dev_ctx_p[num]->pa_context);
115 pa_mainloop_free (dev_ctx_p[num]->pa_loop);
116 pa_simple_free (dev_ctx_p[num]->pa);
117 free (dev_ctx_p[num]->sink_name);
118 dev_ctx_p[num]->pa_context = NULL;
119 dev_ctx_p[num]->pa_loop = NULL;
120 dev_ctx_p[num]->pa = NULL;
121 dev_ctx_p[num]->sink_name = NULL;
122 free (dev_ctx_p[num]);
126 PUBLIC void _pulse_play (audioCtxHandleT *ctx) {
128 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
130 if (!dev_ctx_p_c || dev_ctx_p_c->thr_should_run || access (AUDIO_BUFFER, F_OK) == -1)
133 dev_ctx_p_c->thr_should_run = 1;
134 dev_ctx_p_c->thr_finished = 0;
135 pthread_create (&dev_ctx_p_c->thr, NULL, _pulse_play_thread_fn, (void*)dev_ctx_p_c);
138 PUBLIC void _pulse_stop (audioCtxHandleT *ctx) {
140 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
142 if (!dev_ctx_p_c || !dev_ctx_p_c->thr_should_run)
145 dev_ctx_p_c->thr_should_run = 0;
146 while (!dev_ctx_p_c->thr_finished)
148 pthread_join (dev_ctx_p_c->thr, NULL);
151 PUBLIC int _pulse_get_volume (audioCtxHandleT *ctx, unsigned int channel) {
153 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
158 _pulse_refresh_sink (dev_ctx_p_c);
160 return (int)dev_ctx_p_c->volume.values[channel];
163 PUBLIC void _pulse_set_volume (audioCtxHandleT *ctx, unsigned int channel, int vol) {
165 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
166 struct pa_cvolume volume;
171 volume = dev_ctx_p_c->volume;
172 volume.values[channel] = vol;
174 pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
175 &volume, NULL, NULL);
176 _pulse_refresh_sink (dev_ctx_p_c);
179 PUBLIC void _pulse_set_volume_all (audioCtxHandleT *ctx, int vol) {
181 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
182 struct pa_cvolume volume;
187 pa_cvolume_init (&volume);
188 pa_cvolume_set (&volume, dev_ctx_p_c->volume.channels, vol);
190 pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
191 &volume, NULL, NULL);
192 _pulse_refresh_sink (dev_ctx_p_c);
195 PUBLIC unsigned char _pulse_get_mute (audioCtxHandleT *ctx) {
197 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
202 _pulse_refresh_sink (dev_ctx_p_c);
204 return (unsigned char)dev_ctx_p_c->mute;
207 PUBLIC void _pulse_set_mute (audioCtxHandleT *ctx, unsigned char mute) {
209 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
214 pa_context_set_sink_mute_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
215 (int)mute, NULL, NULL);
216 _pulse_refresh_sink (dev_ctx_p_c);
219 /* ---- LOCAL HELPER FUNCTIONS ---- */
221 void _pulse_refresh_sink (dev_ctx_pulse_T* dev_ctx_p_c) {
223 dev_ctx_p_c->refresh = 1;
225 pa_context_get_sink_info_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
226 _pulse_sink_info_cb, (void*)dev_ctx_p_c);
228 while (dev_ctx_p_c->refresh)
229 pa_mainloop_iterate (dev_ctx_p_c->pa_loop, 0, NULL);
232 void _pulse_enumerate_cards () {
234 void **cards, **card;
235 char *name, *found, *alsa_name, *card_name;
236 int new_info, i, num = 0;
238 /* allocate the global alsa array */
239 alsa_info = (alsa_info_T**) malloc (sizeof(alsa_info_T));
240 alsa_info[0] = (alsa_info_T*) malloc (sizeof(alsa_info_T));
241 alsa_info[0]->device = NULL;
242 alsa_info[0]->synonyms = NULL;
244 /* we use ALSA to enumerate cards */
245 snd_device_name_hint (-1, "pcm", &cards);
248 for (; *card != NULL; card++) {
249 name = snd_device_name_get_hint (*card, "NAME");
252 /* alsa name is before ':' (if ':' misses, then it has no card) */
253 found = strstr (name, ":");
254 if (!found) continue;
256 alsa_name = (char*) malloc (found-name+1);
257 strncpy (alsa_name, name, found-name);
258 alsa_name[found-name] = '\0';
260 /* card name is the invariant between "CARD=" and ',' */
261 found = strstr (name, "CARD=");
262 if (!found) continue;
265 card_name = strdup (found);
266 found = strstr (card_name, ",");
267 if (found) card_name[found-card_name] = '\0';
269 /* was the card name already listed in the global alsa array ? */
270 for (i = 0; i < (sizeof(alsa_info)/sizeof(alsa_info_T)); i++) {
272 if (alsa_info[i]->device &&
273 !strcmp (alsa_info[i]->device, card_name)) {
274 /* it was ; add the alsa name as a new synonym */
275 asprintf (&alsa_info[i]->synonyms, "%s:%s", alsa_info[i]->synonyms, alsa_name);
280 /* it was not ; create it */
282 alsa_info = (alsa_info_T**) realloc (alsa_info, (num+1)*sizeof(alsa_info_T));
283 alsa_info[num]->device = strdup (card_name);
284 asprintf (&alsa_info[num]->synonyms, ":%s", alsa_name);
292 char** _pulse_find_cards (const char *name) {
295 char *needle, *found, *next;
299 _pulse_enumerate_cards ();
301 asprintf (&needle, ":%s", name);
303 for (num = 0; num < (sizeof(alsa_info)/sizeof(alsa_info_T)); num++) {
305 found = strstr (alsa_info[num]->synonyms, needle);
307 /* if next character is not ':' or '\0', we are wrong */
308 if ((found[strlen(name)] != ':') && (found[strlen(name)] != '\0')) {
309 found = strstr (found+1, needle);
312 /* found it ; now return all the "synonym" cards */
313 found = strstr (alsa_info[num]->synonyms, ":");
315 next = strstr (found+1, ":");
316 cards = (char**) realloc (cards, (i+1)*sizeof(char*));
317 cards[i] = (char*) malloc (next-found+1);
318 strncpy (cards[i], found+1, next-found);
319 cards[i][next-found] = '\0';
329 /* ---- LOCAL CALLBACK FUNCTIONS ---- */
331 STATIC void _pulse_context_cb (pa_context *context, void *data) {
333 pa_context_state_t state = pa_context_get_state (context);
334 dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data;
336 if (state == PA_CONTEXT_FAILED) {
337 fprintf (stderr, "Could not connect to PulseAudio !\n");
338 pa_mainloop_quit (dev_ctx_p_t->pa_loop, -1);
341 if (state == PA_CONTEXT_READY)
342 pa_context_get_sink_info_list (context, _pulse_sink_list_cb, (void*)dev_ctx_p_t);
345 STATIC void _pulse_sink_list_cb (pa_context *context, const pa_sink_info *info,
346 int eol, void *data) {
348 dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data;
349 const char *device_string;
356 /* ignore sinks with no cards */
357 if (!pa_proplist_contains (info->proplist, "device.string"))
360 device_string = pa_proplist_gets (info->proplist, "device.string");
362 /* was a sink with similar name already found ? */
363 for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T)); num++) {
364 if (dev_ctx_p[num]->sink_name &&
365 !strcmp (dev_ctx_p[num]->sink_name, info->name)) {
367 /* yet it was, did it have the required card ? */
368 cards = dev_ctx_p[num]->card_name;
369 for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) {
370 if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) {
371 /* it did : stop there and succeed */
372 if (verbose) fprintf (stderr, "Found matching sink : %s\n", info->name);
373 pa_mainloop_quit (dev_ctx_p_t->pa_loop, num);
376 /* it did not, ignore and return */
382 /* new sink, find all the cards it manages, fail if none */
383 cards = _pulse_find_cards (device_string);
386 /* everything is well, register it in global array */
387 dev_ctx_p_t->sink_name = strdup (info->name);
388 dev_ctx_p_t->card_name = cards;
389 dev_ctx_p_t->mute = info->mute;
390 dev_ctx_p_t->volume = info->volume;
391 dev_ctx_p_t->thr_should_run = 0;
392 dev_ctx_p_t->thr_finished = 0;
393 dev_ctx_p[num] = dev_ctx_p_t;
395 /* does this new sink have the card we are looking for ? */ /* TODO : factorize this */
396 for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) {
397 if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) {
398 /* it did : stop there and succeed */
399 if (verbose) fprintf (stderr, "Found matching sink : %s\n", info->name);
400 pa_mainloop_quit (dev_ctx_p_t->pa_loop, num);
405 STATIC void _pulse_sink_info_cb (pa_context *context, const pa_sink_info *info,
406 int eol, void *data) {
408 dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)data;
413 dev_ctx_p_c->refresh = 0;
414 dev_ctx_p_c->mute = info->mute;
415 dev_ctx_p_c->volume = info->volume;
418 /* ---- LOCAL THREADED FUNCTIONS ---- */
420 STATIC void* _pulse_play_thread_fn (void *ctx) {
422 dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)ctx;
428 file = fopen (AUDIO_BUFFER, "rb");
430 while (dev_ctx_p_c->thr_should_run && file && (access (AUDIO_BUFFER, F_OK) != -1) ) {
431 fseek (file, 0, SEEK_END);
433 buf = (char*) realloc (buf, size * sizeof(char));
435 fseek (file, 0, SEEK_SET);
436 fread (buf, 1, size, file);
439 if (pa_simple_write (dev_ctx_p_c->pa, buf, size*2, &error) < 0)
440 fprintf (stderr, "Error writing to PulseAudio : %s\n", pa_strerror (error));
441 /* pa_simple_drain (dev_ctx_p_c->pa); */
444 if (file) fclose(file);
446 dev_ctx_p_c->thr_finished = 1;