modules/services_discovery/pulse.c

   1 /**
   2  * @file pulse.c
   3  * @brief List of PulseAudio sources for VLC media player
   4  */
   5 /*****************************************************************************
   6  * Copyright © 2011 Rémi Denis-Courmont
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 #include <search.h>
  28 #include <assert.h>
  29
  30 #include <vlc_common.h>
  31 #include <vlc_plugin.h>
  32 #include <vlc_services_discovery.h>
  33 #include <pulse/pulseaudio.h>
  34 #include "audio_output/vlcpulse.h"
  35
  36 static int Open (vlc_object_t *);
  37 static void Close (vlc_object_t *);
  38
  39 VLC_SD_PROBE_HELPER("pulse", N_("Audio capture"), SD_CAT_DEVICES);
  40
  41 vlc_module_begin ()
  42     set_shortname (N_("Audio capture"))
  43     set_description (N_("Audio capture (PulseAudio)"))
  44     set_category (CAT_PLAYLIST)
  45     set_subcategory (SUBCAT_PLAYLIST_SD)
  46     set_capability ("services_discovery", 0)
  47     set_callbacks (Open, Close)
  48     add_shortcut ("pulse", "pa", "pulseaudio", "audio")
  49
  50     VLC_SD_PROBE_SUBMODULE
  51 vlc_module_end ()
  52
  53 struct services_discovery_sys_t
  54 {
  55     void                 *root;
  56     pa_context           *context;
  57     pa_threaded_mainloop *mainloop;
  58 };
  59
  60 static void SourceCallback(pa_context *, const pa_source_info *, int, void *);
  61 static void ContextCallback(pa_context *, pa_subscription_event_type_t,
  62                             uint32_t, void *);
  63
  64 static int Open (vlc_object_t *obj)
  65 {
  66     services_discovery_t *sd = (services_discovery_t *)obj;
  67     pa_operation *op;
  68     pa_context *ctx;
  69
  70     services_discovery_sys_t *sys = malloc (sizeof (*sys));
  71     if (unlikely(sys == NULL))
  72         return VLC_ENOMEM;
  73
  74     ctx = vlc_pa_connect (obj, &sys->mainloop);
  75     if (ctx == NULL)
  76     {
  77         free (sys);
  78         return VLC_EGENERIC;
  79     }
  80
  81     sd->p_sys = sys;
  82     sd->description = _("Audio capture");
  83     sys->context = ctx;
  84     sys->root = NULL;
  85
  86     /* Subscribe for source events */
  87     const pa_subscription_mask_t mask = PA_SUBSCRIPTION_MASK_SOURCE;
  88     pa_threaded_mainloop_lock (sys->mainloop);
  89     pa_context_set_subscribe_callback (ctx, ContextCallback, sd);
  90     op = pa_context_subscribe (ctx, mask, NULL, NULL);
  91     if (likely(op != NULL))
  92         pa_operation_unref (op);
  93
  94     /* Enumerate existing sources */
  95     op = pa_context_get_source_info_list (ctx, SourceCallback, sd);
  96     if (likely(op != NULL))
  97     {
  98         //while (pa_operation_get_state (op) == PA_OPERATION_RUNNING)
  99         //    pa_threaded_mainloop_wait (sys->mainloop);
 100         pa_operation_unref (op);
 101     }
 102     pa_threaded_mainloop_unlock (sys->mainloop);
 103     return VLC_SUCCESS;
 104 /*
 105 error:
 106     pa_threaded_mainloop_unlock (sys->mainloop);
 107     vlc_pa_disconnect (obj, ctx, sys->mainloop);
 108     free (sys);
 109     return VLC_EGENERIC;*/
 110 }
 111
 112 struct device
 113 {
 114     uint32_t index;
 115     input_item_t *item;
 116     services_discovery_t *sd;
 117 };
 118
 119 static void DestroySource (void *data)
 120 {
 121     struct device *d = data;
 122
 123     services_discovery_RemoveItem (d->sd, d->item);
 124     input_item_Release (d->item);
 125     free (d);
 126 }
 127
 128 /**
 129  * Compares two devices (to support binary search).
 130  */
 131 static int cmpsrc (const void *a, const void *b)
 132 {
 133     const uint32_t *pa = a, *pb = b;
 134     uint32_t idxa = *pa, idxb = *pb;
 135
 136     return (idxa != idxb) ? ((idxa < idxb) ? -1 : +1) : 0;
 137 }
 138
 139 /**
 140  * Adds a source.
 141  */
 142 static int AddSource (services_discovery_t *sd, const pa_source_info *info)
 143 {
 144     services_discovery_sys_t *sys = sd->p_sys;
 145
 146     msg_Dbg (sd, "adding %s (%s)", info->name, info->description);
 147
 148     char *mrl;
 149     if (unlikely(asprintf (&mrl, "pulse://%s", info->name) == -1))
 150         return -1;
 151
 152     input_item_t *item = input_item_NewCard (mrl, info->description);
 153     free (mrl);
 154     if (unlikely(item == NULL))
 155         return -1;
 156
 157     struct device *d = malloc (sizeof (*d));
 158     if (unlikely(d == NULL))
 159     {
 160         input_item_Release (item);
 161         return -1;
 162     }
 163     d->index = info->index;
 164     d->item = item;
 165
 166     struct device **dp = tsearch (d, &sys->root, cmpsrc);
 167     if (dp == NULL) /* Out-of-memory */
 168     {
 169         free (d);
 170         input_item_Release (item);
 171         return -1;
 172     }
 173     if (*dp != d) /* Update existing source */
 174     {
 175         free (d);
 176         d = *dp;
 177         input_item_SetURI (d->item, item->psz_uri);
 178         input_item_SetName (d->item, item->psz_name);
 179         input_item_Release (item);
 180         return 0;
 181     }
 182
 183     const char *card = pa_proplist_gets(info->proplist, "device.product.name");
 184     services_discovery_AddItemCat(sd, item,
 185                                   (card != NULL) ? card : N_("Generic"));
 186     d->sd = sd;
 187     return 0;
 188 }
 189
 190 static void SourceCallback(pa_context *ctx, const pa_source_info *i, int eol,
 191                            void *userdata)
 192 {
 193     services_discovery_t *sd = userdata;
 194
 195     if (eol)
 196         return;
 197     AddSource (sd, i);
 198     (void) ctx;
 199 }
 200
 201 /**
 202  * Removes a source (if present) by index.
 203  */
 204 static void RemoveSource (services_discovery_t *sd, uint32_t idx)
 205 {
 206     services_discovery_sys_t *sys = sd->p_sys;
 207
 208     struct device **dp = tfind (&idx, &sys->root, cmpsrc);
 209     if (dp == NULL)
 210         return;
 211
 212     struct device *d = *dp;
 213     tdelete (d, &sys->root, cmpsrc);
 214     DestroySource (d);
 215 }
 216
 217 static void ContextCallback(pa_context *ctx, pa_subscription_event_type_t type,
 218                             uint32_t idx, void *userdata)
 219 {
 220     services_discovery_t *sd = userdata;
 221     pa_operation *op;
 222
 223     assert ((type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK)
 224                                               == PA_SUBSCRIPTION_EVENT_SOURCE);
 225     switch (type & PA_SUBSCRIPTION_EVENT_TYPE_MASK)
 226     {
 227       case PA_SUBSCRIPTION_EVENT_NEW:
 228       case PA_SUBSCRIPTION_EVENT_CHANGE:
 229         op = pa_context_get_source_info_by_index(ctx, idx, SourceCallback, sd);
 230         if (likely(op != NULL))
 231             pa_operation_unref(op);
 232         break;
 233
 234       case PA_SUBSCRIPTION_EVENT_REMOVE:
 235         RemoveSource (sd, idx);
 236         break;
 237     }
 238 }
 239
 240 static void Close (vlc_object_t *obj)
 241 {
 242     services_discovery_t *sd = (services_discovery_t *)obj;
 243     services_discovery_sys_t *sys = sd->p_sys;
 244
 245     vlc_pa_disconnect (obj, sys->context, sys->mainloop);
 246     tdestroy (sys->root, DestroySource);
 247     free (sys);
 248 }