2 * Copyright (C) 2016 "IoT.bzh"
3 * Author "Manuel Bachmann"
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
21 #include "audio-api.h"
22 #include "audio-pulse.h"
24 static struct alsa_info **alsa_info = NULL;
25 static struct dev_ctx_pulse **dev_ctx_p = NULL;
26 static unsigned int client_count = 0;
29 unsigned char _pulse_init (const char *name, audioCtxHandleT *ctx) {
32 pa_mainloop_api *pa_api;
33 pa_context *pa_context;
35 pa_sample_spec *pa_spec;
36 struct timeval tv_start, tv_now;
39 pa_loop = pa_mainloop_new ();
40 pa_api = pa_mainloop_get_api (pa_loop);
41 pa_context = pa_context_new (pa_api, "afb-audio-plugin");
43 /* allocate the global array if it hasn't been done */
45 dev_ctx_p = (dev_ctx_pulse_T**) malloc (sizeof(dev_ctx_pulse_T*));
47 /* create a temporary device, to be held until sink gets discovered */
48 dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T*) malloc (sizeof(dev_ctx_pulse_T));
49 dev_ctx_p_t->sink_name = NULL;
50 dev_ctx_p_t->card_name = (char**) malloc (sizeof(char*));
51 dev_ctx_p_t->card_name[0] = strdup (name);
52 dev_ctx_p_t->pa_loop = pa_loop;
53 dev_ctx_p_t->pa_context = pa_context;
55 pa_context_set_state_callback (pa_context, _pulse_context_cb, (void*)dev_ctx_p_t);
56 pa_context_connect (pa_context, NULL, 0, NULL);
58 /* 1 second should be sufficient to retrieve sink info */
59 gettimeofday (&tv_start, NULL);
60 gettimeofday (&tv_now, NULL);
61 while (tv_now.tv_sec - tv_start.tv_sec <= 2) {
62 pa_mainloop_iterate (pa_loop, 0, &ret);
64 if (ret == -1) { /* generic error */
65 fprintf (stderr, "Stopping PulseAudio backend...\n");
69 if ((ret > 0)&&(ret < 100)) { /* 0 and >100 are PulseAudio codes */
70 /* found a matching sink from callback */
71 fprintf (stderr, "Success : using sink n.%d\n", ret-1);
72 ctx->audio_dev = (void*)dev_ctx_p[ret-1];
75 gettimeofday (&tv_now, NULL);
77 /* fail if we found no matching sink */
81 /* make the client context aware of current card state */
82 ctx->mute = (unsigned char)dev_ctx_p[ret-1]->mute;
83 ctx->channels = (unsigned int)dev_ctx_p[ret-1]->volume.channels;
84 for (i = 0; i < ctx->channels; i++)
85 ctx->volume[i] = dev_ctx_p[ret-1]->volume.values[i];
88 /* open matching sink for playback */
89 pa_spec = (pa_sample_spec*) malloc (sizeof(pa_sample_spec));
90 pa_spec->format = PA_SAMPLE_S16LE;
91 pa_spec->rate = 22050;
92 pa_spec->channels = (uint8_t)ctx->channels;
94 if (!(pa = pa_simple_new (NULL, "afb-audio-plugin", PA_STREAM_PLAYBACK, dev_ctx_p[ret-1]->sink_name,
95 "afb-audio-output", pa_spec, NULL, NULL, &error))) {
96 fprintf (stderr, "Error opening PulseAudio sink %s : %s\n",
97 dev_ctx_p[ret-1]->sink_name, pa_strerror(error));
100 dev_ctx_p[ret-1]->pa = pa;
105 fprintf (stderr, "Successfully initialized PulseAudio backend.\n");
110 void _pulse_free (audioCtxHandleT *ctx) {
115 if (client_count > 0) return;
117 for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T*)); num++) {
119 for (i = 0; num < (sizeof(dev_ctx_p[num]->card_name)/sizeof(char*)); i++) {
120 free (dev_ctx_p[num]->card_name[i]);
121 dev_ctx_p[num]->card_name[i] = NULL;
123 pa_context_disconnect (dev_ctx_p[num]->pa_context);
124 pa_context_unref (dev_ctx_p[num]->pa_context);
125 pa_mainloop_free (dev_ctx_p[num]->pa_loop);
126 pa_simple_free (dev_ctx_p[num]->pa);
127 free (dev_ctx_p[num]->sink_name);
128 dev_ctx_p[num]->pa_context = NULL;
129 dev_ctx_p[num]->pa_loop = NULL;
130 dev_ctx_p[num]->pa = NULL;
131 dev_ctx_p[num]->sink_name = NULL;
132 free (dev_ctx_p[num]);
136 void _pulse_play (audioCtxHandleT *ctx) {
138 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
140 if (!dev_ctx_p_c || dev_ctx_p_c->thr_should_run || access (AUDIO_BUFFER, F_OK) == -1)
143 dev_ctx_p_c->thr_should_run = 1;
144 dev_ctx_p_c->thr_finished = 0;
145 pthread_create (&dev_ctx_p_c->thr, NULL, _pulse_play_thread_fn, (void*)dev_ctx_p_c);
148 void _pulse_stop (audioCtxHandleT *ctx) {
150 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
152 if (!dev_ctx_p_c || !dev_ctx_p_c->thr_should_run)
155 dev_ctx_p_c->thr_should_run = 0;
156 while (!dev_ctx_p_c->thr_finished)
158 pthread_join (dev_ctx_p_c->thr, NULL);
161 unsigned int _pulse_get_volume (audioCtxHandleT *ctx, unsigned int channel) {
163 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
168 _pulse_refresh_sink (dev_ctx_p_c);
170 return (dev_ctx_p_c->volume.values[channel]*100)/PA_VOLUME_NORM;
173 void _pulse_set_volume (audioCtxHandleT *ctx, unsigned int channel, unsigned int vol) {
175 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
176 struct pa_cvolume volume;
181 volume = dev_ctx_p_c->volume;
182 volume.values[channel] = (vol*PA_VOLUME_NORM)/100;
184 pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
185 &volume, NULL, NULL);
186 _pulse_refresh_sink (dev_ctx_p_c);
189 void _pulse_set_volume_all (audioCtxHandleT *ctx, unsigned int vol) {
191 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
192 struct pa_cvolume volume;
197 pa_cvolume_init (&volume);
198 pa_cvolume_set (&volume, dev_ctx_p_c->volume.channels, vol);
200 pa_context_set_sink_volume_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
201 &volume, NULL, NULL);
202 _pulse_refresh_sink (dev_ctx_p_c);
205 unsigned char _pulse_get_mute (audioCtxHandleT *ctx) {
207 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
212 _pulse_refresh_sink (dev_ctx_p_c);
214 return (unsigned char)dev_ctx_p_c->mute;
217 void _pulse_set_mute (audioCtxHandleT *ctx, unsigned char mute) {
219 dev_ctx_pulse_T* dev_ctx_p_c = (dev_ctx_pulse_T*)ctx->audio_dev;
224 pa_context_set_sink_mute_by_name (dev_ctx_p_c->pa_context, dev_ctx_p_c->sink_name,
225 (int)mute, NULL, NULL);
226 _pulse_refresh_sink (dev_ctx_p_c);
229 /* ---- LOCAL HELPER FUNCTIONS ---- */
231 void _pulse_refresh_sink (dev_ctx_pulse_T* dev_ctx_p_c) {
233 pa_mainloop_api *pa_api;
235 dev_ctx_p_c->pa_loop = pa_mainloop_new ();
236 pa_api = pa_mainloop_get_api (dev_ctx_p_c->pa_loop);
237 dev_ctx_p_c->pa_context = pa_context_new (pa_api, "afb-audio-plugin");
239 dev_ctx_p_c->refresh = 1;
241 switch (pa_context_get_state (dev_ctx_p_c->pa_context)) {
242 case PA_CONTEXT_READY:
243 pa_context_get_sink_info_by_name (dev_ctx_p_c->pa_context,
244 dev_ctx_p_c->sink_name,
245 _pulse_sink_info_cb, (void*)dev_ctx_p_c);
251 while (dev_ctx_p_c->refresh)
252 pa_mainloop_iterate (dev_ctx_p_c->pa_loop, 0, NULL);
255 void _pulse_enumerate_cards () {
257 void **cards, **card;
258 char *name, *found, *alsa_name, *card_name;
259 int new_info, i, num = 0;
261 /* allocate the global alsa array */
262 alsa_info = (alsa_info_T**) malloc (sizeof(alsa_info_T*));
263 alsa_info[0] = (alsa_info_T*) malloc (sizeof(alsa_info_T));
264 alsa_info[0]->device = NULL;
265 alsa_info[0]->synonyms = NULL;
267 /* we use ALSA to enumerate cards */
268 snd_device_name_hint (-1, "pcm", &cards);
271 for (; *card != NULL; card++) {
272 name = snd_device_name_get_hint (*card, "NAME");
275 /* alsa name is before ':' (if ':' misses, then it has no card) */
276 found = strstr (name, ":");
277 if (!found) continue;
279 alsa_name = (char*) malloc (found-name+1);
280 strncpy (alsa_name, name, found-name);
281 alsa_name[found-name] = '\0';
283 /* card name is the invariant between "CARD=" and ',' */
284 found = strstr (name, "CARD=");
285 if (!found) continue;
288 card_name = strdup (found);
289 found = strstr (card_name, ",");
290 if (found) card_name[found-card_name] = '\0';
292 /* was the card name already listed in the global alsa array ? */
293 for (i = 0; i < (sizeof(alsa_info)/sizeof(alsa_info_T*)); i++) {
295 if (alsa_info[i]->device &&
296 !strcmp (alsa_info[i]->device, card_name)) {
297 /* it was ; add the alsa name as a new synonym */
298 asprintf (&alsa_info[i]->synonyms, "%s:%s", alsa_info[i]->synonyms, alsa_name);
303 /* it was not ; create it */
305 alsa_info = (alsa_info_T**) realloc (alsa_info, (num+1)*sizeof(alsa_info_T*));
306 alsa_info[num] = (alsa_info_T*) malloc (sizeof(alsa_info_T));
307 alsa_info[num]->device = strdup (card_name);
308 asprintf (&alsa_info[num]->synonyms, ":%s", alsa_name);
316 char** _pulse_find_cards (const char *name) {
319 char *needle, *found, *next;
323 _pulse_enumerate_cards ();
325 asprintf (&needle, ":%s", name);
327 for (num = 0; num < (sizeof(alsa_info)/sizeof(alsa_info_T*)); num++) {
329 found = strstr (alsa_info[num]->synonyms, needle);
331 /* if next character is not ':' or '\0', we are wrong */
332 if ((found[strlen(name)+1] != ':') && (found[strlen(name)+1] != '\0')) {
333 found = strstr (found+1, needle);
336 /* found it ; now return all the "synonym" cards */
337 found = strstr (alsa_info[num]->synonyms, ":");
339 next = strstr (found+1, ":");
341 cards = (char**) realloc (cards, (i+1)*sizeof(char*));
342 cards[i] = (char*) malloc (next-found+1);
343 strncpy (cards[i], found+1, next-found);
344 cards[i][next-found-1] = '\0';
354 /* ---- LOCAL CALLBACK FUNCTIONS ---- */
356 void _pulse_context_cb (pa_context *context, void *data) {
358 pa_context_state_t state = pa_context_get_state (context);
359 dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data;
361 if (state == PA_CONTEXT_FAILED) {
362 fprintf (stderr, "Could not connect to PulseAudio !\n");
363 pa_mainloop_quit (dev_ctx_p_t->pa_loop, -1);
364 pa_context_disconnect (dev_ctx_p_t->pa_context);
365 pa_context_unref (dev_ctx_p_t->pa_context);
366 pa_mainloop_free (dev_ctx_p_t->pa_loop);
369 if (state == PA_CONTEXT_READY)
370 pa_context_get_sink_info_list (context, _pulse_sink_list_cb, (void*)dev_ctx_p_t);
373 void _pulse_sink_list_cb (pa_context *context, const pa_sink_info *info,
374 int eol, void *data) {
376 dev_ctx_pulse_T *dev_ctx_p_t = (dev_ctx_pulse_T *)data;
377 const char *device_string;
378 char *device, *found;
385 device_string = pa_proplist_gets (info->proplist, "device.string");
386 /* ignore sinks with no cards */
390 /* was a sink with similar name already found ? */
391 for (num = 0; num < (sizeof(dev_ctx_p)/sizeof(dev_ctx_pulse_T*)); num++) {
392 if (dev_ctx_p[num]->sink_name &&
393 !strcmp (dev_ctx_p[num]->sink_name, info->name)) {
395 /* yet it was, did it have the required card ? */
396 cards = dev_ctx_p[num]->card_name;
397 for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) {
398 if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) {
399 /* it did : stop there and succeed */
400 fprintf (stderr, "Found matching sink : %s\n", info->name);
401 /* we return num+1 because '0' is already used */
402 pa_mainloop_quit (dev_ctx_p_t->pa_loop, num+1);
403 pa_context_disconnect (dev_ctx_p_t->pa_context);
404 pa_context_unref (dev_ctx_p_t->pa_context);
405 pa_mainloop_free (dev_ctx_p_t->pa_loop);
408 /* it did not, ignore and return */
414 /* remove ending ":0",":1"... in device name */
415 device = strdup (device_string);
416 found = strstr (device, ":");
417 if (found) device[found-device] = '\0';
419 /* new sink, find all the cards it manages, fail if none */
420 cards = _pulse_find_cards (device);
425 /* everything is well, register it in global array */
426 dev_ctx_p_t->sink_name = strdup (info->name);
427 dev_ctx_p_t->card_name = cards;
428 dev_ctx_p_t->mute = info->mute;
429 dev_ctx_p_t->volume = info->volume;
430 dev_ctx_p_t->thr_should_run = 0;
431 dev_ctx_p_t->thr_finished = 0;
432 dev_ctx_p[num] = dev_ctx_p_t;
434 /* does this new sink have the card we are looking for ? */ /* TODO : factorize this */
435 for (i = 0; i < (sizeof(cards)/sizeof(char*)); i++) {
436 if (!strcmp (cards[i], dev_ctx_p_t->card_name[0])) {
437 /* it did : stop there and succeed */
438 fprintf (stderr, "Found matching sink : %s\n", info->name);
439 /* we return num+1 because '0' is already used */
440 pa_mainloop_quit (dev_ctx_p_t->pa_loop, num+1);
441 pa_context_disconnect (dev_ctx_p_t->pa_context);
442 pa_context_unref (dev_ctx_p_t->pa_context);
443 pa_mainloop_free (dev_ctx_p_t->pa_loop);
448 void _pulse_sink_info_cb (pa_context *context, const pa_sink_info *info,
449 int eol, void *data) {
451 dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)data;
456 dev_ctx_p_c->refresh = 0;
457 dev_ctx_p_c->mute = info->mute;
458 dev_ctx_p_c->volume = info->volume;
461 /* ---- LOCAL THREADED FUNCTIONS ---- */
463 void* _pulse_play_thread_fn (void *ctx) {
465 dev_ctx_pulse_T *dev_ctx_p_c = (dev_ctx_pulse_T *)ctx;
471 file = fopen (AUDIO_BUFFER, "rb");
473 while (dev_ctx_p_c->thr_should_run && file && (access (AUDIO_BUFFER, F_OK) != -1) ) {
474 fseek (file, 0, SEEK_END);
476 buf = (char*) realloc (buf, size * sizeof(char));
478 fseek (file, 0, SEEK_SET);
479 fread (buf, 1, size, file);
482 if (pa_simple_write (dev_ctx_p_c->pa, buf, size*2, &error) < 0)
483 fprintf (stderr, "Error writing to PulseAudio : %s\n", pa_strerror (error));
484 /* pa_simple_drain (dev_ctx_p_c->pa); */
487 if (file) fclose(file);
489 dev_ctx_p_c->thr_finished = 1;