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;
97 if (verbose) fprintf (stderr, "Successfully initialized PulseAudio backend.\n");
102 PUBLIC void _pulse_free (audioCtxHandleT *ctx) {
107 if (client_count > 0) return;
109 for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T)); num++) {
111 for (i = 0; num < (sizeof(dev_ctx_p[num]->card_name)/sizeof(char*)); i++) {
112 free (dev_ctx_p[num]->card_name[i]);
113 dev_ctx_p[num]->card_name[i] = NULL;
115 pa_context_disconnect (dev_ctx_p[num]->pa_context);
116 pa_context_unref (dev_ctx_p[num]->pa_context);
117 pa_mainloop_free (dev_ctx_p[num]->pa_loop);
118 pa_simple_free (dev_ctx_p[num]->pa);
119 free (dev_ctx_p[num]->sink_name);
120 dev_ctx_p[num]->pa_context = NULL;
121 dev_ctx_p[num]->pa_loop = NULL;
122 dev_ctx_p[num]->pa = NULL;
123 dev_ctx_p[num]->sink_name = NULL;
124 free (dev_ctx_p[num]);
128 PUBLIC void _pulse_play (audioCtxHandleT *ctx) {
130 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
132 if (!dev_ctx_p_c || dev_ctx_p_c->thr_should_run || access (AUDIO_BUFFER, F_OK) == -1)
135 dev_ctx_p_c->thr_should_run = 1;
136 dev_ctx_p_c->thr_finished = 0;
137 pthread_create (&dev_ctx_p_c->thr, NULL, _pulse_play_thread_fn, (void*)dev_ctx_p_c);
140 PUBLIC void _pulse_stop (audioCtxHandleT *ctx) {
142 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
144 if (!dev_ctx_p_c || !dev_ctx_p_c->thr_should_run)
147 dev_ctx_p_c->thr_should_run = 0;
148 while (!dev_ctx_p_c->thr_finished)
150 pthread_join (dev_ctx_p_c->thr, NULL);
153 PUBLIC int _pulse_get_volume (audioCtxHandleT *ctx, unsigned int channel) {
155 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
160 _pulse_refresh_sink (dev_ctx_p_c);
162 return (int)dev_ctx_p_c->volume.values[channel];
165 PUBLIC void _pulse_set_volume (audioCtxHandleT *ctx, unsigned int channel, int vol) {
167 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
168 struct pa_cvolume volume;
173 volume = dev_ctx_p_c->volume;
174 volume.values[channel] = vol;
176 pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
177 &volume, NULL, NULL);
178 _pulse_refresh_sink (dev_ctx_p_c);
181 PUBLIC void _pulse_set_volume_all (audioCtxHandleT *ctx, int vol) {
183 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
184 struct pa_cvolume volume;
189 pa_cvolume_init (&volume);
190 pa_cvolume_set (&volume, dev_ctx_p_c->volume.channels, vol);
192 pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
193 &volume, NULL, NULL);
194 _pulse_refresh_sink (dev_ctx_p_c);
197 PUBLIC unsigned char _pulse_get_mute (audioCtxHandleT *ctx) {
199 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
204 _pulse_refresh_sink (dev_ctx_p_c);
206 return (unsigned char)dev_ctx_p_c->mute;
209 PUBLIC void _pulse_set_mute (audioCtxHandleT *ctx, unsigned char mute) {
211 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
216 pa_context_set_sink_mute_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
217 (int)mute, NULL, NULL);
218 _pulse_refresh_sink (dev_ctx_p_c);
221 /* ---- LOCAL HELPER FUNCTIONS ---- */
223 void _pulse_refresh_sink (dev_ctx_pulse_T* dev_ctx_p_c) {
225 dev_ctx_p_c->refresh = 1;
227 pa_context_get_sink_info_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
228 _pulse_sink_info_cb, (void*)dev_ctx_p_c);
230 while (dev_ctx_p_c->refresh)
231 pa_mainloop_iterate (dev_ctx_p_c->pa_loop, 0, NULL);
234 void _pulse_enumerate_cards () {
236 void **cards, **card;
237 char *name, *found, *alsa_name, *card_name;
238 int new_info, i, num = 0;
240 /* allocate the global alsa array */
241 alsa_info = (alsa_info_T**) malloc (sizeof(alsa_info_T));
242 alsa_info[0] = (alsa_info_T*) malloc (sizeof(alsa_info_T));
243 alsa_info[0]->device = NULL;
244 alsa_info[0]->synonyms = NULL;
246 /* we use ALSA to enumerate cards */
247 snd_device_name_hint (-1, "pcm", &cards);
250 for (; *card != NULL; card++) {
251 name = snd_device_name_get_hint (*card, "NAME");
254 /* alsa name is before ':' (if ':' misses, then it has no card) */
255 found = strstr (name, ":");
256 if (!found) continue;
258 alsa_name = (char*) malloc (found-name+1);
259 strncpy (alsa_name, name, found-name);
260 alsa_name[found-name] = '\0';
262 /* card name is the invariant between "CARD=" and ',' */
263 found = strstr (name, "CARD=");
264 if (!found) continue;
267 card_name = strdup (found);
268 found = strstr (card_name, ",");
269 if (found) card_name[found-card_name] = '\0';
271 /* was the card name already listed in the global alsa array ? */
272 for (i = 0; i < (sizeof(alsa_info)/sizeof(alsa_info_T)); i++) {
274 if (alsa_info[i]->device &&
275 !strcmp (alsa_info[i]->device, card_name)) {
276 /* it was ; add the alsa name as a new synonym */
277 asprintf (&alsa_info[i]->synonyms, "%s:%s", alsa_info[i]->synonyms, alsa_name);
282 /* it was not ; create it */
284 alsa_info = (alsa_info_T**) realloc (alsa_info, (num+1)*sizeof(alsa_info_T));
285 alsa_info[num]->device = strdup (card_name);
286 asprintf (&alsa_info[num]->synonyms, ":%s", alsa_name);
294 char** _pulse_find_cards (const char *name) {
297 char *needle, *found, *next;
301 _pulse_enumerate_cards ();
303 asprintf (&needle, ":%s", name);
305 for (num = 0; num < (sizeof(alsa_info)/sizeof(alsa_info_T)); num++) {
307 found = strstr (alsa_info[num]->synonyms, needle);
309 /* if next character is not ':' or '\0', we are wrong */
310 if ((found[strlen(name)] != ':') && (found[strlen(name)] != '\0')) {
311 found = strstr (found+1, needle);
314 /* found it ; now return all the "synonym" cards */
315 found = strstr (alsa_info[num]->synonyms, ":");
317 next = strstr (found+1, ":");
318 cards = (char**) realloc (cards, (i+1)*sizeof(char*));
319 cards[i] = (char*) malloc (next-found+1);
320 strncpy (cards[i], found+1, next-found);
321 cards[i][next-found] = '\0';
331 /* ---- LOCAL CALLBACK FUNCTIONS ---- */
333 STATIC void _pulse_context_cb (pa_context *context, void *data) {
335 pa_context_state_t state = pa_context_get_state (context);
336 dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data;
338 if (state == PA_CONTEXT_FAILED) {
339 fprintf (stderr, "Could not connect to PulseAudio !\n");
340 pa_mainloop_quit (dev_ctx_p_t->pa_loop, -1);
343 if (state == PA_CONTEXT_READY)
344 pa_context_get_sink_info_list (context, _pulse_sink_list_cb, (void*)dev_ctx_p_t);
347 STATIC void _pulse_sink_list_cb (pa_context *context, const pa_sink_info *info,
348 int eol, void *data) {
350 dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data;
351 const char *device_string;
358 /* ignore sinks with no cards */
359 if (!pa_proplist_contains (info->proplist, "device.string"))
362 device_string = pa_proplist_gets (info->proplist, "device.string");
364 /* was a sink with similar name already found ? */
365 for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T)); num++) {
366 if (dev_ctx_p[num]->sink_name &&
367 !strcmp (dev_ctx_p[num]->sink_name, info->name)) {
369 /* yet it was, did it have the required card ? */
370 cards = dev_ctx_p[num]->card_name;
371 for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) {
372 if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) {
373 /* it did : stop there and succeed */
374 if (verbose) fprintf (stderr, "Found matching sink : %s\n", info->name);
375 pa_mainloop_quit (dev_ctx_p_t->pa_loop, num);
378 /* it did not, ignore and return */
384 /* new sink, find all the cards it manages, fail if none */
385 cards = _pulse_find_cards (device_string);
388 /* everything is well, register it in global array */
389 dev_ctx_p_t->sink_name = strdup (info->name);
390 dev_ctx_p_t->card_name = cards;
391 dev_ctx_p_t->mute = info->mute;
392 dev_ctx_p_t->volume = info->volume;
393 dev_ctx_p_t->thr_should_run = 0;
394 dev_ctx_p_t->thr_finished = 0;
395 dev_ctx_p[num] = dev_ctx_p_t;
397 /* does this new sink have the card we are looking for ? */ /* TODO : factorize this */
398 for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) {
399 if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) {
400 /* it did : stop there and succeed */
401 if (verbose) fprintf (stderr, "Found matching sink : %s\n", info->name);
402 pa_mainloop_quit (dev_ctx_p_t->pa_loop, num);
407 STATIC void _pulse_sink_info_cb (pa_context *context, const pa_sink_info *info,
408 int eol, void *data) {
410 dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)data;
415 dev_ctx_p_c->refresh = 0;
416 dev_ctx_p_c->mute = info->mute;
417 dev_ctx_p_c->volume = info->volume;
420 /* ---- LOCAL THREADED FUNCTIONS ---- */
422 STATIC void* _pulse_play_thread_fn (void *ctx) {
424 dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)ctx;
430 file = fopen (AUDIO_BUFFER, "rb");
432 while (dev_ctx_p_c->thr_should_run && file && (access (AUDIO_BUFFER, F_OK) != -1) ) {
433 fseek (file, 0, SEEK_END);
435 buf = (char*) realloc (buf, size * sizeof(char));
437 fseek (file, 0, SEEK_SET);
438 fread (buf, 1, size, file);
441 if (pa_simple_write (dev_ctx_p_c->pa, buf, size*2, &error) < 0)
442 fprintf (stderr, "Error writing to PulseAudio : %s\n", pa_strerror (error));
443 /* pa_simple_drain (dev_ctx_p_c->pa); */
446 if (file) fclose(file);
448 dev_ctx_p_c->thr_finished = 1;