ext/pulse/pulsedeviceprovider.c

   1 /* GStreamer
   2  * Copyright (C) 2012 Olivier Crete <olivier.crete@collabora.com>
   3  *
   4  * gstv4l2deviceprovider.c: V4l2 device probing and monitoring
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include "pulsedeviceprovider.h"
  27
  28 #include <string.h>
  29
  30 #include <gst/gst.h>
  31
  32 #include "pulsesrc.h"
  33 #include "pulsesink.h"
  34 #include "pulseutil.h"
  35
  36
  37 GST_DEBUG_CATEGORY_EXTERN (pulse_debug);
  38 #define GST_CAT_DEFAULT pulse_debug
  39
  40
  41 static GstDevice *gst_pulse_device_new (guint id,
  42     const gchar * device_name, GstCaps * caps, const gchar * internal_name,
  43     GstPulseDeviceType type);
  44
  45 G_DEFINE_TYPE (GstPulseDeviceProvider, gst_pulse_device_provider,
  46     GST_TYPE_DEVICE_PROVIDER);
  47
  48 static void gst_pulse_device_provider_finalize (GObject * object);
  49 static void gst_pulse_device_provider_set_property (GObject * object,
  50     guint prop_id, const GValue * value, GParamSpec * pspec);
  51 static void gst_pulse_device_provider_get_property (GObject * object,
  52     guint prop_id, GValue * value, GParamSpec * pspec);
  53
  54
  55 static GList *gst_pulse_device_provider_probe (GstDeviceProvider * provider);
  56 static gboolean gst_pulse_device_provider_start (GstDeviceProvider * provider);
  57 static void gst_pulse_device_provider_stop (GstDeviceProvider * provider);
  58
  59 enum
  60 {
  61   PROP_0,
  62   PROP_SERVER,
  63   PROP_CLIENT_NAME,
  64   PROP_LAST
  65 };
  66
  67
  68 static void
  69 gst_pulse_device_provider_class_init (GstPulseDeviceProviderClass * klass)
  70 {
  71   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  72   GstDeviceProviderClass *dm_class = GST_DEVICE_PROVIDER_CLASS (klass);
  73   gchar *client_name;
  74
  75   gobject_class->set_property = gst_pulse_device_provider_set_property;
  76   gobject_class->get_property = gst_pulse_device_provider_get_property;
  77   gobject_class->finalize = gst_pulse_device_provider_finalize;
  78
  79   dm_class->probe = gst_pulse_device_provider_probe;
  80   dm_class->start = gst_pulse_device_provider_start;
  81   dm_class->stop = gst_pulse_device_provider_stop;
  82
  83   g_object_class_install_property (gobject_class,
  84       PROP_SERVER,
  85       g_param_spec_string ("server", "Server",
  86           "The PulseAudio server to connect to", NULL,
  87           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  88
  89   client_name = gst_pulse_client_name ();
  90   g_object_class_install_property (gobject_class,
  91       PROP_CLIENT_NAME,
  92       g_param_spec_string ("client-name", "Client Name",
  93           "The PulseAudio client_name_to_use", client_name,
  94           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
  95           GST_PARAM_MUTABLE_READY));
  96   g_free (client_name);
  97
  98   gst_device_provider_class_set_static_metadata (dm_class,
  99       "PulseAudio Device Provider", "Sink/Source/Audio",
 100       "List and provider PulseAudio source and sink devices",
 101       "Olivier Crete <olivier.crete@collabora.com>");
 102 }
 103
 104 static void
 105 gst_pulse_device_provider_init (GstPulseDeviceProvider * self)
 106 {
 107   self->client_name = gst_pulse_client_name ();
 108 }
 109
 110 static void
 111 gst_pulse_device_provider_finalize (GObject * object)
 112 {
 113   GstPulseDeviceProvider *self = GST_PULSE_DEVICE_PROVIDER (object);
 114
 115   g_free (self->client_name);
 116   g_free (self->server);
 117
 118   G_OBJECT_CLASS (gst_pulse_device_provider_parent_class)->finalize (object);
 119 }
 120
 121
 122 static void
 123 gst_pulse_device_provider_set_property (GObject * object,
 124     guint prop_id, const GValue * value, GParamSpec * pspec)
 125 {
 126   GstPulseDeviceProvider *self = GST_PULSE_DEVICE_PROVIDER (object);
 127
 128   switch (prop_id) {
 129     case PROP_SERVER:
 130       g_free (self->server);
 131       self->server = g_value_dup_string (value);
 132       break;
 133     case PROP_CLIENT_NAME:
 134       g_free (self->client_name);
 135       if (!g_value_get_string (value)) {
 136         GST_WARNING_OBJECT (self,
 137             "Empty PulseAudio client name not allowed. "
 138             "Resetting to default value");
 139         self->client_name = gst_pulse_client_name ();
 140       } else
 141         self->client_name = g_value_dup_string (value);
 142       break;
 143     default:
 144       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 145       break;
 146   }
 147 }
 148
 149 static void
 150 gst_pulse_device_provider_get_property (GObject * object,
 151     guint prop_id, GValue * value, GParamSpec * pspec)
 152 {
 153   GstPulseDeviceProvider *self = GST_PULSE_DEVICE_PROVIDER (object);
 154
 155   switch (prop_id) {
 156     case PROP_SERVER:
 157       g_value_set_string (value, self->server);
 158       break;
 159     case PROP_CLIENT_NAME:
 160       g_value_set_string (value, self->client_name);
 161       break;
 162     default:
 163       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 164       break;
 165   }
 166 }
 167
 168 static void
 169 context_state_cb (pa_context * c, void *userdata)
 170 {
 171   GstPulseDeviceProvider *self = userdata;
 172
 173   switch (pa_context_get_state (c)) {
 174     case PA_CONTEXT_READY:
 175     case PA_CONTEXT_TERMINATED:
 176     case PA_CONTEXT_FAILED:
 177       pa_threaded_mainloop_signal (self->mainloop, 0);
 178       break;
 179
 180     case PA_CONTEXT_UNCONNECTED:
 181     case PA_CONTEXT_CONNECTING:
 182     case PA_CONTEXT_AUTHORIZING:
 183     case PA_CONTEXT_SETTING_NAME:
 184       break;
 185   }
 186 }
 187
 188 static GstDevice *
 189 new_source (const pa_source_info * info)
 190 {
 191   GstCaps *caps;
 192   guint i;
 193
 194   caps = gst_caps_new_empty ();
 195
 196   for (i = 0; i < info->n_formats; i++)
 197     gst_caps_append (caps, gst_pulse_format_info_to_caps (info->formats[i]));
 198
 199   return gst_pulse_device_new (info->index, info->description,
 200       caps, info->name, GST_PULSE_DEVICE_TYPE_SOURCE);
 201 }
 202
 203 static GstDevice *
 204 new_sink (const pa_sink_info * info)
 205 {
 206   GstCaps *caps;
 207   guint i;
 208
 209   caps = gst_caps_new_empty ();
 210
 211   for (i = 0; i < info->n_formats; i++)
 212     gst_caps_append (caps, gst_pulse_format_info_to_caps (info->formats[i]));
 213
 214   return gst_pulse_device_new (info->index, info->description,
 215       caps, info->name, GST_PULSE_DEVICE_TYPE_SINK);
 216 }
 217
 218 static void
 219 get_source_info_cb (pa_context * context,
 220     const pa_source_info * info, int eol, void *userdata)
 221 {
 222   GstPulseDeviceProvider *self = userdata;
 223   GstDevice *dev;
 224
 225   if (eol) {
 226     pa_threaded_mainloop_signal (self->mainloop, 0);
 227     return;
 228   }
 229
 230   dev = new_source (info);
 231
 232   if (dev)
 233     gst_device_provider_device_add (GST_DEVICE_PROVIDER (self), dev);
 234 }
 235
 236 static void
 237 get_sink_info_cb (pa_context * context,
 238     const pa_sink_info * info, int eol, void *userdata)
 239 {
 240   GstPulseDeviceProvider *self = userdata;
 241   GstDevice *dev;
 242
 243   if (eol) {
 244     pa_threaded_mainloop_signal (self->mainloop, 0);
 245     return;
 246   }
 247
 248   dev = new_sink (info);
 249
 250   if (dev)
 251     gst_device_provider_device_add (GST_DEVICE_PROVIDER (self), dev);
 252 }
 253
 254 static void
 255 context_subscribe_cb (pa_context * context, pa_subscription_event_type_t type,
 256     uint32_t idx, void *userdata)
 257 {
 258   GstPulseDeviceProvider *self = userdata;
 259   GstDeviceProvider *provider = userdata;
 260   pa_subscription_event_type_t facility =
 261       type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK;
 262   pa_subscription_event_type_t event_type =
 263       type & PA_SUBSCRIPTION_EVENT_TYPE_MASK;
 264
 265   if (facility != PA_SUBSCRIPTION_EVENT_SOURCE &&
 266       facility != PA_SUBSCRIPTION_EVENT_SINK)
 267     return;
 268
 269   if (event_type == PA_SUBSCRIPTION_EVENT_NEW) {
 270     /* Microphone in the source output has changed */
 271
 272     if (facility == PA_SUBSCRIPTION_EVENT_SOURCE)
 273       pa_context_get_source_info_by_index (context, idx, get_source_info_cb,
 274           self);
 275     else if (facility == PA_SUBSCRIPTION_EVENT_SINK)
 276       pa_context_get_sink_info_by_index (context, idx, get_sink_info_cb, self);
 277   } else if (event_type == PA_SUBSCRIPTION_EVENT_REMOVE) {
 278     GstPulseDevice *dev = NULL;
 279     GList *item;
 280
 281     GST_OBJECT_LOCK (self);
 282     for (item = provider->devices; item; item = item->next) {
 283       dev = item->data;
 284
 285       if (((facility == PA_SUBSCRIPTION_EVENT_SOURCE &&
 286                   dev->type == GST_PULSE_DEVICE_TYPE_SOURCE) ||
 287               (facility == PA_SUBSCRIPTION_EVENT_SINK &&
 288                   dev->type == GST_PULSE_DEVICE_TYPE_SINK)) &&
 289           dev->device_index == idx) {
 290         gst_object_ref (dev);
 291         break;
 292       }
 293       dev = NULL;
 294     }
 295     GST_OBJECT_UNLOCK (self);
 296
 297     if (dev) {
 298       gst_device_provider_device_remove (GST_DEVICE_PROVIDER (self),
 299           GST_DEVICE (dev));
 300       gst_object_unref (dev);
 301     }
 302   }
 303 }
 304
 305 static void
 306 get_source_info_list_cb (pa_context * context, const pa_source_info * info,
 307     int eol, void *userdata)
 308 {
 309   GList **devices = userdata;
 310
 311   if (eol)
 312     return;
 313
 314   *devices = g_list_prepend (*devices, gst_object_ref_sink (new_source (info)));
 315 }
 316
 317 static void
 318 get_sink_info_list_cb (pa_context * context, const pa_sink_info * info,
 319     int eol, void *userdata)
 320 {
 321   GList **devices = userdata;
 322
 323   if (eol)
 324     return;
 325
 326   *devices = g_list_prepend (*devices, gst_object_ref_sink (new_sink (info)));
 327 }
 328
 329 static GList *
 330 gst_pulse_device_provider_probe (GstDeviceProvider * provider)
 331 {
 332   GstPulseDeviceProvider *self = GST_PULSE_DEVICE_PROVIDER (provider);
 333   GList *devices = NULL;
 334   pa_mainloop *m = NULL;
 335   pa_context *c = NULL;
 336   pa_operation *o;
 337
 338   if (!(m = pa_mainloop_new ()))
 339     return NULL;
 340
 341   if (!(c = pa_context_new (pa_mainloop_get_api (m), self->client_name))) {
 342     GST_ERROR_OBJECT (self, "Failed to create context");
 343     goto failed;
 344   }
 345
 346   if (pa_context_connect (c, self->server, 0, NULL) < 0) {
 347     GST_ERROR_OBJECT (self, "Failed to connect: %s",
 348         pa_strerror (pa_context_errno (self->context)));
 349     goto failed;
 350   }
 351
 352   for (;;) {
 353     pa_context_state_t state;
 354
 355     state = pa_context_get_state (c);
 356
 357     if (!PA_CONTEXT_IS_GOOD (state)) {
 358       GST_ELEMENT_ERROR (self, RESOURCE, FAILED, ("Failed to connect: %s",
 359               pa_strerror (pa_context_errno (c))), (NULL));
 360       goto failed;
 361     }
 362
 363     if (state == PA_CONTEXT_READY)
 364       break;
 365
 366     /* Wait until the context is ready */
 367     if (pa_mainloop_iterate (m, TRUE, NULL) < 0)
 368       goto failed;
 369
 370   }
 371   GST_DEBUG_OBJECT (self, "connected");
 372
 373   o = pa_context_get_sink_info_list (c, get_sink_info_list_cb, &devices);
 374   while (pa_operation_get_state (o) == PA_OPERATION_RUNNING &&
 375       pa_operation_get_state (o) == PA_OPERATION_RUNNING) {
 376     if (pa_mainloop_iterate (m, TRUE, NULL) < 0)
 377       break;
 378   }
 379   pa_operation_unref (o);
 380
 381   o = pa_context_get_source_info_list (c, get_source_info_list_cb, &devices);
 382   while (pa_operation_get_state (o) == PA_OPERATION_RUNNING &&
 383       pa_operation_get_state (o) == PA_OPERATION_RUNNING) {
 384     if (pa_mainloop_iterate (m, TRUE, NULL) < 0)
 385       break;
 386   }
 387   pa_operation_unref (o);
 388
 389   pa_context_disconnect (c);
 390   pa_mainloop_free (m);
 391
 392   return devices;
 393
 394 failed:
 395
 396   return NULL;
 397 }
 398
 399 static gboolean
 400 gst_pulse_device_provider_start (GstDeviceProvider * provider)
 401 {
 402   GstPulseDeviceProvider *self = GST_PULSE_DEVICE_PROVIDER (provider);
 403   pa_operation *initial_operation;
 404
 405   if (!(self->mainloop = pa_threaded_mainloop_new ())) {
 406     GST_ERROR_OBJECT (self, "Could not create pulseaudio mainloop");
 407     goto mainloop_failed;
 408   }
 409   if (pa_threaded_mainloop_start (self->mainloop) < 0) {
 410     GST_ERROR_OBJECT (self, "Could not start pulseaudio mainloop");
 411     pa_threaded_mainloop_free (self->mainloop);
 412     self->mainloop = NULL;
 413     goto mainloop_failed;
 414   }
 415
 416   pa_threaded_mainloop_lock (self->mainloop);
 417
 418   if (!(self->context =
 419           pa_context_new (pa_threaded_mainloop_get_api (self->mainloop),
 420               self->client_name))) {
 421     GST_ERROR_OBJECT (self, "Failed to create context");
 422     goto unlock_and_fail;
 423   }
 424
 425   pa_context_set_state_callback (self->context, context_state_cb, self);
 426   pa_context_set_subscribe_callback (self->context, context_subscribe_cb, self);
 427
 428
 429   GST_DEBUG_OBJECT (self, "connect to server %s", GST_STR_NULL (self->server));
 430
 431   if (pa_context_connect (self->context, self->server, 0, NULL) < 0) {
 432     GST_ERROR_OBJECT (self, "Failed to connect: %s",
 433         pa_strerror (pa_context_errno (self->context)));
 434     goto unlock_and_fail;
 435   }
 436
 437   for (;;) {
 438     pa_context_state_t state;
 439
 440     state = pa_context_get_state (self->context);
 441
 442     if (!PA_CONTEXT_IS_GOOD (state)) {
 443       GST_ERROR_OBJECT (self, "Failed to connect: %s",
 444           pa_strerror (pa_context_errno (self->context)));
 445       goto unlock_and_fail;
 446     }
 447
 448     if (state == PA_CONTEXT_READY)
 449       break;
 450
 451     /* Wait until the context is ready */
 452     pa_threaded_mainloop_wait (self->mainloop);
 453   }
 454   GST_DEBUG_OBJECT (self, "connected");
 455
 456   pa_context_subscribe (self->context,
 457       PA_SUBSCRIPTION_MASK_SOURCE | PA_SUBSCRIPTION_MASK_SINK, NULL, NULL);
 458
 459   initial_operation = pa_context_get_source_info_list (self->context,
 460       get_source_info_cb, self);
 461   while (pa_operation_get_state (initial_operation) == PA_OPERATION_RUNNING) {
 462     if (!PA_CONTEXT_IS_GOOD (pa_context_get_state ((self->context))))
 463       goto cancel_and_fail;
 464
 465     pa_threaded_mainloop_wait (self->mainloop);
 466   }
 467   pa_operation_unref (initial_operation);
 468
 469   initial_operation = pa_context_get_sink_info_list (self->context,
 470       get_sink_info_cb, self);
 471   if (!initial_operation)
 472     goto unlock_and_fail;
 473   while (pa_operation_get_state (initial_operation) == PA_OPERATION_RUNNING) {
 474     if (!PA_CONTEXT_IS_GOOD (pa_context_get_state ((self->context))))
 475       goto cancel_and_fail;
 476
 477     pa_threaded_mainloop_wait (self->mainloop);
 478   }
 479   pa_operation_unref (initial_operation);
 480
 481   pa_threaded_mainloop_unlock (self->mainloop);
 482
 483   return TRUE;
 484
 485 unlock_and_fail:
 486   pa_threaded_mainloop_unlock (self->mainloop);
 487   gst_pulse_device_provider_stop (provider);
 488   return FALSE;
 489
 490 mainloop_failed:
 491   return FALSE;
 492
 493 cancel_and_fail:
 494   pa_operation_cancel (initial_operation);
 495   pa_operation_unref (initial_operation);
 496   goto unlock_and_fail;
 497 }
 498
 499 static void
 500 gst_pulse_device_provider_stop (GstDeviceProvider * provider)
 501 {
 502   GstPulseDeviceProvider *self = GST_PULSE_DEVICE_PROVIDER (provider);
 503
 504   pa_threaded_mainloop_stop (self->mainloop);
 505
 506   if (self->context) {
 507     pa_context_disconnect (self->context);
 508
 509     /* Make sure we don't get any further callbacks */
 510     pa_context_set_state_callback (self->context, NULL, NULL);
 511     pa_context_set_subscribe_callback (self->context, NULL, NULL);
 512
 513     pa_context_unref (self->context);
 514     self->context = NULL;
 515   }
 516
 517   pa_threaded_mainloop_free (self->mainloop);
 518   self->mainloop = NULL;
 519 }
 520
 521 enum
 522 {
 523   PROP_INTERNAL_NAME = 1,
 524 };
 525
 526 G_DEFINE_TYPE (GstPulseDevice, gst_pulse_device, GST_TYPE_DEVICE);
 527
 528 static void gst_pulse_device_get_property (GObject * object, guint prop_id,
 529     GValue * value, GParamSpec * pspec);
 530 static void gst_pulse_device_set_property (GObject * object, guint prop_id,
 531     const GValue * value, GParamSpec * pspec);
 532 static void gst_pulse_device_finalize (GObject * object);
 533 static GstElement *gst_pulse_device_create_element (GstDevice * device,
 534     const gchar * name);
 535 static gboolean gst_pulse_device_reconfigure_element (GstDevice * device,
 536     GstElement * element);
 537
 538 static void
 539 gst_pulse_device_class_init (GstPulseDeviceClass * klass)
 540 {
 541   GstDeviceClass *dev_class = GST_DEVICE_CLASS (klass);
 542   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 543
 544   dev_class->create_element = gst_pulse_device_create_element;
 545   dev_class->reconfigure_element = gst_pulse_device_reconfigure_element;
 546
 547   object_class->get_property = gst_pulse_device_get_property;
 548   object_class->set_property = gst_pulse_device_set_property;
 549   object_class->finalize = gst_pulse_device_finalize;
 550
 551   g_object_class_install_property (object_class, PROP_INTERNAL_NAME,
 552       g_param_spec_string ("internal-name", "Internal PulseAudio device name",
 553           "The internal name of the PulseAudio device", "",
 554           G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 555 }
 556
 557 static void
 558 gst_pulse_device_init (GstPulseDevice * device)
 559 {
 560 }
 561
 562 static void
 563 gst_pulse_device_finalize (GObject * object)
 564 {
 565   GstPulseDevice *device = GST_PULSE_DEVICE (object);
 566
 567   g_free (device->internal_name);
 568
 569   G_OBJECT_CLASS (gst_pulse_device_parent_class)->finalize (object);
 570 }
 571
 572 static GstElement *
 573 gst_pulse_device_create_element (GstDevice * device, const gchar * name)
 574 {
 575   GstPulseDevice *pulse_dev = GST_PULSE_DEVICE (device);
 576   GstElement *elem;
 577
 578   elem = gst_element_factory_make (pulse_dev->element, name);
 579   g_object_set (elem, "device", pulse_dev->internal_name, NULL);
 580
 581   return elem;
 582 }
 583
 584 static gboolean
 585 gst_pulse_device_reconfigure_element (GstDevice * device, GstElement * element)
 586 {
 587   GstPulseDevice *pulse_dev = GST_PULSE_DEVICE (device);
 588
 589   if (!strcmp (pulse_dev->element, "pulsesrc")) {
 590     if (!GST_IS_PULSESRC (element))
 591       return FALSE;
 592   } else if (!strcmp (pulse_dev->element, "pulsesink")) {
 593     if (!GST_IS_PULSESINK (element))
 594       return FALSE;
 595   } else {
 596     g_assert_not_reached ();
 597   }
 598
 599   g_object_set (element, "device", pulse_dev->internal_name, NULL);
 600
 601   return TRUE;
 602 }
 603
 604 static GstDevice *
 605 gst_pulse_device_new (guint device_index, const gchar * device_name,
 606     GstCaps * caps, const gchar * internal_name, GstPulseDeviceType type)
 607 {
 608   GstPulseDevice *gstdev;
 609   const gchar *element;
 610   const gchar *klass;
 611
 612   g_return_val_if_fail (device_name, NULL);
 613   g_return_val_if_fail (internal_name, NULL);
 614   g_return_val_if_fail (caps, NULL);
 615
 616
 617   switch (type) {
 618     case GST_PULSE_DEVICE_TYPE_SOURCE:
 619       element = "pulsesrc";
 620       klass = "Audio/Source";
 621       break;
 622     case GST_PULSE_DEVICE_TYPE_SINK:
 623       element = "pulsesink";
 624       klass = "Audio/Sink";
 625       break;
 626     default:
 627       g_assert_not_reached ();
 628       break;
 629   }
 630
 631
 632   gstdev = g_object_new (GST_TYPE_PULSE_DEVICE,
 633       "display-name", device_name, "caps", caps, "device-class", klass,
 634       "internal-name", internal_name, NULL);
 635
 636   gstdev->type = type;
 637   gstdev->device_index = device_index;
 638   gstdev->element = element;
 639
 640   return GST_DEVICE (gstdev);
 641 }
 642
 643
 644 static void
 645 gst_pulse_device_get_property (GObject * object, guint prop_id,
 646     GValue * value, GParamSpec * pspec)
 647 {
 648   GstPulseDevice *device;
 649
 650   device = GST_PULSE_DEVICE_CAST (object);
 651
 652   switch (prop_id) {
 653     case PROP_INTERNAL_NAME:
 654       g_value_set_string (value, device->internal_name);
 655       break;
 656     default:
 657       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 658       break;
 659   }
 660 }
 661
 662
 663 static void
 664 gst_pulse_device_set_property (GObject * object, guint prop_id,
 665     const GValue * value, GParamSpec * pspec)
 666 {
 667   GstPulseDevice *device;
 668
 669   device = GST_PULSE_DEVICE_CAST (object);
 670
 671   switch (prop_id) {
 672     case PROP_INTERNAL_NAME:
 673       device->internal_name = g_value_dup_string (value);
 674       break;
 675     default:
 676       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 677       break;
 678   }
 679 }