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 *
gst_a2dp_sink_init_element(GstA2dpSink * self,const gchar * elementname,const gchar * name)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
gst_a2dp_sink_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)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
gst_a2dp_sink_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)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
gst_a2dp_sink_init_ghost_pad(GstA2dpSink * self)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
gst_a2dp_sink_remove_dynamic_elements(GstA2dpSink * self)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
gst_a2dp_sink_change_state(GstElement * element,GstStateChange transition)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
gst_a2dp_sink_class_init(GstA2dpSinkClass * klass)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 *
gst_a2dp_sink_get_device_caps(GstA2dpSink * self)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 *
gst_a2dp_sink_get_caps(GstA2dpSink * self)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
gst_a2dp_sink_init_avdtp_sink(GstA2dpSink * self)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
gst_a2dp_sink_init_rtp_sbc_element(GstA2dpSink * self)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
gst_a2dp_sink_init_rtp_mpeg_element(GstA2dpSink * self)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
gst_a2dp_sink_init_rtp_ldac_element(GstA2dpSink * self)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
gst_a2dp_sink_init_dynamic_elements(GstA2dpSink * self,GstCaps * caps)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
gst_a2dp_sink_handle_event(GstPad * pad,GstObject * pad_parent,GstEvent * event)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
gst_a2dp_sink_query(GstPad * pad,GstObject * parent,GstQuery * query)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
gst_a2dp_sink_init(GstA2dpSink * self)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 }
556