subprojects/gst-plugins-bad/sys/bluez/gsta2dpsink.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   6  *
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2.1 of the License, or (at your option) any later version.
  12  *
  13  *  This library 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 GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Lesser General Public
  19  *  License along with this library; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <unistd.h>
  29
  30 #include "gstbluezelements.h"
  31 #include "gsta2dpsink.h"
  32
  33 #include <gst/rtp/gstrtpbasepayload.h>
  34
  35 GST_DEBUG_CATEGORY_STATIC (gst_a2dp_sink_debug);
  36 #define GST_CAT_DEFAULT gst_a2dp_sink_debug
  37
  38 #define A2DP_SBC_RTP_PAYLOAD_TYPE 1
  39
  40 #define DEFAULT_AUTOCONNECT TRUE
  41
  42 enum
  43 {
  44   PROP_0,
  45   PROP_DEVICE,
  46   PROP_AUTOCONNECT,
  47   PROP_TRANSPORT
  48 };
  49
  50 #define parent_class gst_a2dp_sink_parent_class
  51 G_DEFINE_TYPE (GstA2dpSink, gst_a2dp_sink, GST_TYPE_BIN);
  52 GST_ELEMENT_REGISTER_DEFINE_WITH_CODE (a2dpsink, "a2dpsink", GST_RANK_NONE,
  53     GST_TYPE_A2DP_SINK, bluez_element_init (plugin));
  54
  55 static GstStaticPadTemplate gst_a2dp_sink_factory =
  56     GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
  57     GST_STATIC_CAPS ("audio/x-sbc, "
  58         "rate = (int) { 16000, 32000, 44100, 48000 }, "
  59         "channels = (int) [ 1, 2 ], "
  60         "channel-mode = (string) { mono, dual, stereo, joint }, "
  61         "blocks = (int) { 4, 8, 12, 16 }, "
  62         "subbands = (int) { 4, 8 }, "
  63         "allocation-method = (string) { snr, loudness }, "
  64         "bitpool = (int) [ 2, " TEMPLATE_MAX_BITPOOL_STR " ]; "
  65         "audio/mpeg; " "audio/x-ldac"));
  66
  67 static gboolean gst_a2dp_sink_handle_event (GstPad * pad,
  68     GstObject * pad_parent, GstEvent * event);
  69 static gboolean gst_a2dp_sink_query (GstPad * pad, GstObject * parent,
  70     GstQuery * query);
  71 static GstCaps *gst_a2dp_sink_get_caps (GstA2dpSink * self);
  72
  73 /*
  74  * Helper function to create elements, add to the bin and link it
  75  * to another element.
  76  */
  77 static GstElement *
  78 gst_a2dp_sink_init_element (GstA2dpSink * self, const gchar * elementname,
  79     const gchar * name)
  80 {
  81   GstElement *element;
  82   GstPad *sinkpad;
  83
  84   GST_LOG_OBJECT (self, "Initializing %s", elementname);
  85
  86   element = gst_element_factory_make (elementname, name);
  87   if (element == NULL) {
  88     GST_DEBUG_OBJECT (self, "Couldn't create %s", elementname);
  89     return NULL;
  90   }
  91
  92   if (!gst_bin_add (GST_BIN (self), element)) {
  93     GST_DEBUG_OBJECT (self, "failed to add %s to the bin", elementname);
  94     goto cleanup_and_fail;
  95   }
  96
  97   sinkpad = gst_element_get_static_pad (element, "sink");
  98   if (!gst_ghost_pad_set_target (GST_GHOST_PAD (self->ghostpad), sinkpad)) {
  99     GST_ERROR_OBJECT (self, "Failed to set target for ghost pad");
 100     goto remove_element_and_fail;
 101   }
 102   gst_object_unref (sinkpad);
 103
 104   if (!gst_element_sync_state_with_parent (element)) {
 105     GST_DEBUG_OBJECT (self, "%s failed to go to playing", elementname);
 106     goto remove_element_and_fail;
 107   }
 108
 109   return element;
 110
 111 remove_element_and_fail:
 112   gst_object_unref (sinkpad);
 113   gst_element_set_state (element, GST_STATE_NULL);
 114   gst_bin_remove (GST_BIN (self), element);
 115   return NULL;
 116
 117 cleanup_and_fail:
 118   g_object_unref (G_OBJECT (element));
 119
 120   return NULL;
 121 }
 122
 123 static void
 124 gst_a2dp_sink_set_property (GObject * object, guint prop_id,
 125     const GValue * value, GParamSpec * pspec)
 126 {
 127   GstA2dpSink *self = GST_A2DP_SINK (object);
 128
 129   switch (prop_id) {
 130     case PROP_DEVICE:
 131       if (self->sink != NULL)
 132         gst_avdtp_sink_set_device (self->sink, g_value_get_string (value));
 133
 134       g_free (self->device);
 135       self->device = g_value_dup_string (value);
 136       break;
 137
 138     case PROP_TRANSPORT:
 139       if (self->sink != NULL)
 140         gst_avdtp_sink_set_transport (self->sink, g_value_get_string (value));
 141
 142       g_free (self->transport);
 143       self->transport = g_value_dup_string (value);
 144       break;
 145
 146     case PROP_AUTOCONNECT:
 147       self->autoconnect = g_value_get_boolean (value);
 148
 149       if (self->sink != NULL)
 150         g_object_set (G_OBJECT (self->sink), "auto-connect",
 151             self->autoconnect, NULL);
 152       break;
 153
 154     default:
 155       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 156       break;
 157   }
 158 }
 159
 160 static void
 161 gst_a2dp_sink_get_property (GObject * object, guint prop_id,
 162     GValue * value, GParamSpec * pspec)
 163 {
 164   GstA2dpSink *self = GST_A2DP_SINK (object);
 165   gchar *device, *transport;
 166
 167   switch (prop_id) {
 168     case PROP_DEVICE:
 169       if (self->sink != NULL) {
 170         device = gst_avdtp_sink_get_device (self->sink);
 171         if (device != NULL)
 172           g_value_take_string (value, device);
 173       }
 174       break;
 175     case PROP_AUTOCONNECT:
 176       if (self->sink != NULL)
 177         g_object_get (G_OBJECT (self->sink), "auto-connect",
 178             &self->autoconnect, NULL);
 179
 180       g_value_set_boolean (value, self->autoconnect);
 181       break;
 182     case PROP_TRANSPORT:
 183       if (self->sink != NULL) {
 184         transport = gst_avdtp_sink_get_transport (self->sink);
 185         if (transport != NULL)
 186           g_value_take_string (value, transport);
 187       }
 188       break;
 189     default:
 190       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 191       break;
 192   }
 193 }
 194
 195 static gboolean
 196 gst_a2dp_sink_init_ghost_pad (GstA2dpSink * self)
 197 {
 198   GstPadTemplate *templ;
 199
 200   /* now we add a ghostpad */
 201   templ = gst_static_pad_template_get (&gst_a2dp_sink_factory);
 202   self->ghostpad = gst_ghost_pad_new_no_target_from_template ("sink", templ);
 203   g_object_unref (templ);
 204
 205   /* the getcaps of our ghostpad must reflect the device caps */
 206   gst_pad_set_query_function (self->ghostpad, gst_a2dp_sink_query);
 207
 208   gst_pad_set_event_function (self->ghostpad, gst_a2dp_sink_handle_event);
 209
 210   if (!gst_element_add_pad (GST_ELEMENT (self), self->ghostpad))
 211     GST_ERROR_OBJECT (self, "failed to add ghostpad");
 212
 213   return TRUE;
 214 }
 215
 216 static void
 217 gst_a2dp_sink_remove_dynamic_elements (GstA2dpSink * self)
 218 {
 219   if (self->rtp) {
 220     GST_LOG_OBJECT (self, "removing rtp element from the bin");
 221     if (!gst_bin_remove (GST_BIN (self), GST_ELEMENT (self->rtp)))
 222       GST_WARNING_OBJECT (self, "failed to remove rtp " "element from bin");
 223     else
 224       self->rtp = NULL;
 225   }
 226 }
 227
 228 static GstStateChangeReturn
 229 gst_a2dp_sink_change_state (GstElement * element, GstStateChange transition)
 230 {
 231   GstStateChangeReturn ret;
 232   GstA2dpSink *self = GST_A2DP_SINK (element);
 233
 234   switch (transition) {
 235     case GST_STATE_CHANGE_READY_TO_PAUSED:
 236       self->taglist = gst_tag_list_new_empty ();
 237       break;
 238
 239     case GST_STATE_CHANGE_NULL_TO_READY:
 240       if (self->device != NULL)
 241         gst_avdtp_sink_set_device (self->sink, self->device);
 242
 243       if (self->transport != NULL)
 244         gst_avdtp_sink_set_transport (self->sink, self->transport);
 245
 246       g_object_set (G_OBJECT (self->sink), "auto-connect",
 247           self->autoconnect, NULL);
 248
 249       break;
 250
 251     default:
 252       break;
 253   }
 254
 255   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 256
 257   switch (transition) {
 258     case GST_STATE_CHANGE_PAUSED_TO_READY:
 259       if (self->taglist) {
 260         gst_tag_list_unref (self->taglist);
 261         self->taglist = NULL;
 262       }
 263       break;
 264
 265     case GST_STATE_CHANGE_READY_TO_NULL:
 266       gst_a2dp_sink_remove_dynamic_elements (self);
 267
 268       break;
 269     default:
 270       break;
 271   }
 272
 273   return ret;
 274 }
 275
 276 static void
 277 gst_a2dp_sink_class_init (GstA2dpSinkClass * klass)
 278 {
 279   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 280   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 281
 282   parent_class = g_type_class_peek_parent (klass);
 283
 284   object_class->set_property = GST_DEBUG_FUNCPTR (gst_a2dp_sink_set_property);
 285   object_class->get_property = GST_DEBUG_FUNCPTR (gst_a2dp_sink_get_property);
 286
 287   element_class->change_state = GST_DEBUG_FUNCPTR (gst_a2dp_sink_change_state);
 288
 289   g_object_class_install_property (object_class, PROP_DEVICE,
 290       g_param_spec_string ("device", "Device",
 291           "Bluetooth remote device address", NULL, G_PARAM_READWRITE));
 292
 293   g_object_class_install_property (object_class, PROP_AUTOCONNECT,
 294       g_param_spec_boolean ("auto-connect", "Auto-connect",
 295           "Automatically attempt to connect to device",
 296           DEFAULT_AUTOCONNECT, G_PARAM_READWRITE));
 297
 298   g_object_class_install_property (object_class, PROP_TRANSPORT,
 299       g_param_spec_string ("transport", "Transport",
 300           "Use configured transport", NULL, G_PARAM_READWRITE));
 301
 302   gst_element_class_set_static_metadata (element_class, "Bluetooth A2DP sink",
 303       "Sink/Audio", "Plays audio to an A2DP device",
 304       "Marcel Holtmann <marcel@holtmann.org>");
 305
 306   GST_DEBUG_CATEGORY_INIT (gst_a2dp_sink_debug, "a2dpsink", 0,
 307       "A2DP sink element");
 308
 309   gst_element_class_add_static_pad_template (element_class,
 310       &gst_a2dp_sink_factory);
 311 }
 312
 313 GstCaps *
 314 gst_a2dp_sink_get_device_caps (GstA2dpSink * self)
 315 {
 316   return gst_avdtp_sink_get_device_caps (self->sink);
 317 }
 318
 319 static GstCaps *
 320 gst_a2dp_sink_get_caps (GstA2dpSink * self)
 321 {
 322   GstCaps *caps = NULL;
 323
 324   if (self->sink != NULL) {
 325     caps = gst_a2dp_sink_get_device_caps (self);
 326     GST_LOG_OBJECT (self, "Got device caps %" GST_PTR_FORMAT, caps);
 327   }
 328
 329   if (!caps)
 330     caps = gst_static_pad_template_get_caps (&gst_a2dp_sink_factory);
 331
 332   return caps;
 333 }
 334
 335 static gboolean
 336 gst_a2dp_sink_init_avdtp_sink (GstA2dpSink * self)
 337 {
 338   GstElement *sink;
 339
 340   if (self->sink == NULL)
 341     sink = gst_element_factory_make ("avdtpsink", "avdtpsink");
 342   else
 343     sink = GST_ELEMENT (self->sink);
 344
 345   if (sink == NULL) {
 346     GST_ERROR_OBJECT (self, "Couldn't create avdtpsink");
 347     return FALSE;
 348   }
 349
 350   if (!gst_bin_add (GST_BIN (self), sink)) {
 351     GST_ERROR_OBJECT (self, "failed to add avdtpsink " "to the bin");
 352     goto cleanup_and_fail;
 353   }
 354
 355   self->sink = GST_AVDTP_SINK (sink);
 356   g_object_set (G_OBJECT (self->sink), "device", self->device, NULL);
 357   g_object_set (G_OBJECT (self->sink), "transport", self->transport, NULL);
 358
 359   gst_element_sync_state_with_parent (sink);
 360
 361   return TRUE;
 362
 363 cleanup_and_fail:
 364   if (sink != NULL)
 365     g_object_unref (G_OBJECT (sink));
 366
 367   return FALSE;
 368 }
 369
 370 static gboolean
 371 gst_a2dp_sink_init_rtp_sbc_element (GstA2dpSink * self)
 372 {
 373   GstElement *rtppay;
 374
 375   /* if we already have a rtp, we don't need a new one */
 376   if (self->rtp != NULL)
 377     return TRUE;
 378
 379   rtppay = gst_a2dp_sink_init_element (self, "rtpsbcpay", "rtp");
 380   if (rtppay == NULL)
 381     return FALSE;
 382
 383   self->rtp = rtppay;
 384   g_object_set (self->rtp, "min-frames", -1, NULL);
 385
 386   gst_element_set_state (rtppay, GST_STATE_PAUSED);
 387
 388   return TRUE;
 389 }
 390
 391 static gboolean
 392 gst_a2dp_sink_init_rtp_mpeg_element (GstA2dpSink * self)
 393 {
 394   GstElement *rtppay;
 395
 396   /* check if we don't need a new rtp */
 397   if (self->rtp)
 398     return TRUE;
 399
 400   GST_LOG_OBJECT (self, "Initializing rtp mpeg element");
 401
 402   rtppay = gst_a2dp_sink_init_element (self, "rtpmpapay", "rtp");
 403   if (rtppay == NULL)
 404     return FALSE;
 405
 406   self->rtp = rtppay;
 407
 408   gst_element_set_state (rtppay, GST_STATE_PAUSED);
 409
 410   return TRUE;
 411 }
 412
 413 static gboolean
 414 gst_a2dp_sink_init_rtp_ldac_element (GstA2dpSink * self)
 415 {
 416   GstElement *rtppay;
 417
 418   /* check if we don't need a new rtp */
 419   if (self->rtp)
 420     return TRUE;
 421
 422   GST_LOG_OBJECT (self, "Initializing rtp ldac element");
 423
 424   rtppay = gst_a2dp_sink_init_element (self, "rtpldacpay", "rtp");
 425   if (rtppay == NULL)
 426     return FALSE;
 427
 428   self->rtp = rtppay;
 429
 430   gst_element_set_state (rtppay, GST_STATE_PAUSED);
 431
 432   return TRUE;
 433 }
 434
 435 static gboolean
 436 gst_a2dp_sink_init_dynamic_elements (GstA2dpSink * self, GstCaps * caps)
 437 {
 438   GstStructure *structure;
 439   GstEvent *event;
 440   gboolean crc;
 441   gchar *mode = NULL;
 442   guint mtu;
 443
 444   structure = gst_caps_get_structure (caps, 0);
 445
 446   /* first, we need to create our rtp payloader */
 447   if (gst_structure_has_name (structure, "audio/x-sbc")) {
 448     GST_LOG_OBJECT (self, "sbc media received");
 449     if (!gst_a2dp_sink_init_rtp_sbc_element (self))
 450       return FALSE;
 451   } else if (gst_structure_has_name (structure, "audio/mpeg")) {
 452     GST_LOG_OBJECT (self, "mp3 media received");
 453     if (!gst_a2dp_sink_init_rtp_mpeg_element (self))
 454       return FALSE;
 455   } else if (gst_structure_has_name (structure, "audio/x-ldac")) {
 456     GST_LOG_OBJECT (self, "ldac media received");
 457     if (!gst_a2dp_sink_init_rtp_ldac_element (self))
 458       return FALSE;
 459   } else {
 460     GST_ERROR_OBJECT (self, "Unexpected media type");
 461     return FALSE;
 462   }
 463
 464   if (!gst_element_link (GST_ELEMENT (self->rtp), GST_ELEMENT (self->sink))) {
 465     GST_ERROR_OBJECT (self, "couldn't link rtp payloader to avdtpsink");
 466     return FALSE;
 467   }
 468
 469   /* check if we should push the taglist FIXME should we push this?
 470    * we can send the tags directly if needed */
 471   if (self->taglist != NULL && gst_structure_has_name (structure, "audio/mpeg")) {
 472
 473     event = gst_event_new_tag (self->taglist);
 474
 475     /* send directly the crc */
 476     if (gst_tag_list_get_boolean (self->taglist, "has-crc", &crc))
 477       gst_avdtp_sink_set_crc (self->sink, crc);
 478
 479     if (gst_tag_list_get_string (self->taglist, "channel-mode", &mode))
 480       gst_avdtp_sink_set_channel_mode (self->sink, mode);
 481
 482     gst_pad_send_event (self->ghostpad, event);
 483
 484     self->taglist = NULL;
 485     g_free (mode);
 486   }
 487
 488   mtu = gst_avdtp_sink_get_link_mtu (self->sink);
 489   GST_INFO_OBJECT (self, "Setting MTU to %u", mtu);
 490   g_object_set (self->rtp, "mtu", mtu, NULL);
 491
 492   return TRUE;
 493 }
 494
 495 static gboolean
 496 gst_a2dp_sink_handle_event (GstPad * pad, GstObject * pad_parent,
 497     GstEvent * event)
 498 {
 499   GstA2dpSink *self;
 500   GstTagList *taglist = NULL;
 501
 502   self = GST_A2DP_SINK (pad_parent);
 503
 504   if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) {
 505     if (self->taglist == NULL)
 506       gst_event_parse_tag (event, &self->taglist);
 507     else {
 508       gst_event_parse_tag (event, &taglist);
 509       gst_tag_list_insert (self->taglist, taglist, GST_TAG_MERGE_REPLACE);
 510     }
 511   } else if (GST_EVENT_TYPE (event) == GST_EVENT_CAPS) {
 512     GstCaps *caps = NULL;
 513
 514     gst_event_parse_caps (event, &caps);
 515     gst_a2dp_sink_init_dynamic_elements (self, caps);
 516   }
 517
 518   return gst_pad_event_default (pad, pad_parent, event);
 519 }
 520
 521 static gboolean
 522 gst_a2dp_sink_query (GstPad * pad, GstObject * parent, GstQuery * query)
 523 {
 524   GstA2dpSink *sink = GST_A2DP_SINK (parent);
 525   gboolean ret;
 526
 527   if (GST_QUERY_TYPE (query) == GST_QUERY_CAPS) {
 528     GstCaps *caps;
 529
 530     caps = gst_a2dp_sink_get_caps (sink);
 531     gst_query_set_caps_result (query, caps);
 532     gst_caps_unref (caps);
 533     ret = TRUE;
 534   } else {
 535     ret = gst_pad_query_default (pad, parent, query);
 536   }
 537
 538   return ret;
 539 }
 540
 541 static void
 542 gst_a2dp_sink_init (GstA2dpSink * self)
 543 {
 544   self->sink = NULL;
 545   self->rtp = NULL;
 546   self->device = NULL;
 547   self->transport = NULL;
 548   self->autoconnect = DEFAULT_AUTOCONNECT;
 549   self->taglist = NULL;
 550   self->ghostpad = NULL;
 551
 552   gst_a2dp_sink_init_ghost_pad (self);
 553
 554   gst_a2dp_sink_init_avdtp_sink (self);
 555 }