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 #define GLIB_DISABLE_DEPRECATION_WARNINGS
29
30 /* FIXME: check which includes are really required */
31 #include <unistd.h>
32 #include <sys/un.h>
33 #include <sys/socket.h>
34 #include <fcntl.h>
35 #include <netinet/in.h>
36
37 #include "a2dp-codecs.h"
38
39 #include "gstavdtpsink.h"
40
41 #include <gst/rtp/rtp.h>
42
43 GST_DEBUG_CATEGORY_STATIC (avdtp_sink_debug);
44 #define GST_CAT_DEFAULT avdtp_sink_debug
45
46 #define CRC_PROTECTED 1
47 #define CRC_UNPROTECTED 0
48
49 #define DEFAULT_AUTOCONNECT TRUE
50
51 #define GST_AVDTP_SINK_MUTEX_LOCK(s) G_STMT_START { \
52 g_mutex_lock(&s->sink_lock); \
53 } G_STMT_END
54
55 #define GST_AVDTP_SINK_MUTEX_UNLOCK(s) G_STMT_START { \
56 g_mutex_unlock(&s->sink_lock); \
57 } G_STMT_END
58
59 #define IS_SBC(n) (strcmp((n), "audio/x-sbc") == 0)
60 #define IS_MPEG_AUDIO(n) (strcmp((n), "audio/mpeg") == 0)
61
62 enum
63 {
64 PROP_0,
65 PROP_DEVICE,
66 PROP_AUTOCONNECT,
67 PROP_TRANSPORT
68 };
69
70 #define parent_class gst_avdtp_sink_parent_class
71 G_DEFINE_TYPE (GstAvdtpSink, gst_avdtp_sink, GST_TYPE_BASE_SINK);
72
73 static GstStaticPadTemplate avdtp_sink_factory =
74 GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
75 GST_STATIC_CAPS ("application/x-rtp, "
76 "media = (string) \"audio\","
77 "payload = (int) "
78 GST_RTP_PAYLOAD_DYNAMIC_STRING ", "
79 "clock-rate = (int) { 16000, 32000, "
80 "44100, 48000 }, "
81 "encoding-name = (string) \"SBC\"; "
82 "application/x-rtp, "
83 "media = (string) \"audio\", "
84 "payload = (int) "
85 GST_RTP_PAYLOAD_MPA_STRING ", "
86 "clock-rate = (int) 90000; "
87 "application/x-rtp, "
88 "media = (string) \"audio\", "
89 "payload = (int) "
90 GST_RTP_PAYLOAD_DYNAMIC_STRING ", "
91 "clock-rate = (int) 90000, " "encoding-name = (string) \"MPA\""));
92
93 static gboolean
gst_avdtp_sink_stop(GstBaseSink * basesink)94 gst_avdtp_sink_stop (GstBaseSink * basesink)
95 {
96 GstAvdtpSink *self = GST_AVDTP_SINK (basesink);
97
98 GST_INFO_OBJECT (self, "stop");
99
100 if (self->watch_id != 0) {
101 g_source_remove (self->watch_id);
102 self->watch_id = 0;
103 }
104
105 gst_avdtp_connection_release (&self->conn);
106
107 if (self->stream_caps) {
108 gst_caps_unref (self->stream_caps);
109 self->stream_caps = NULL;
110 }
111
112 if (self->dev_caps) {
113 gst_caps_unref (self->dev_caps);
114 self->dev_caps = NULL;
115 }
116
117 return TRUE;
118 }
119
120 static void
gst_avdtp_sink_finalize(GObject * object)121 gst_avdtp_sink_finalize (GObject * object)
122 {
123 GstAvdtpSink *self = GST_AVDTP_SINK (object);
124
125 gst_avdtp_sink_stop (GST_BASE_SINK (self));
126
127 gst_avdtp_connection_reset (&self->conn);
128
129 g_mutex_clear (&self->sink_lock);
130
131 G_OBJECT_CLASS (parent_class)->finalize (object);
132 }
133
134 static void
gst_avdtp_sink_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)135 gst_avdtp_sink_set_property (GObject * object, guint prop_id,
136 const GValue * value, GParamSpec * pspec)
137 {
138 GstAvdtpSink *sink = GST_AVDTP_SINK (object);
139
140 switch (prop_id) {
141 case PROP_DEVICE:
142 gst_avdtp_connection_set_device (&sink->conn, g_value_get_string (value));
143 break;
144
145 case PROP_AUTOCONNECT:
146 sink->autoconnect = g_value_get_boolean (value);
147 break;
148
149 case PROP_TRANSPORT:
150 gst_avdtp_connection_set_transport (&sink->conn,
151 g_value_get_string (value));
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_avdtp_sink_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)161 gst_avdtp_sink_get_property (GObject * object, guint prop_id,
162 GValue * value, GParamSpec * pspec)
163 {
164 GstAvdtpSink *sink = GST_AVDTP_SINK (object);
165
166 switch (prop_id) {
167 case PROP_DEVICE:
168 g_value_set_string (value, sink->conn.device);
169 break;
170
171 case PROP_AUTOCONNECT:
172 g_value_set_boolean (value, sink->autoconnect);
173 break;
174
175 case PROP_TRANSPORT:
176 g_value_set_string (value, sink->conn.transport);
177 break;
178
179 default:
180 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
181 break;
182 }
183 }
184
185 static gint
gst_avdtp_sink_get_channel_mode(const gchar * mode)186 gst_avdtp_sink_get_channel_mode (const gchar * mode)
187 {
188 if (strcmp (mode, "stereo") == 0)
189 return SBC_CHANNEL_MODE_STEREO;
190 else if (strcmp (mode, "joint-stereo") == 0)
191 return SBC_CHANNEL_MODE_JOINT_STEREO;
192 else if (strcmp (mode, "dual-channel") == 0)
193 return SBC_CHANNEL_MODE_DUAL_CHANNEL;
194 else if (strcmp (mode, "mono") == 0)
195 return SBC_CHANNEL_MODE_MONO;
196 else
197 return -1;
198 }
199
200 static void
gst_avdtp_sink_tag(const GstTagList * taglist,const gchar * tag,gpointer user_data)201 gst_avdtp_sink_tag (const GstTagList * taglist,
202 const gchar * tag, gpointer user_data)
203 {
204 gboolean crc;
205 gchar *channel_mode = NULL;
206 GstAvdtpSink *self = GST_AVDTP_SINK (user_data);
207
208 if (strcmp (tag, "has-crc") == 0) {
209
210 if (!gst_tag_list_get_boolean (taglist, tag, &crc)) {
211 GST_WARNING_OBJECT (self, "failed to get crc tag");
212 return;
213 }
214
215 gst_avdtp_sink_set_crc (self, crc);
216
217 } else if (strcmp (tag, "channel-mode") == 0) {
218
219 if (!gst_tag_list_get_string (taglist, tag, &channel_mode)) {
220 GST_WARNING_OBJECT (self, "failed to get channel-mode tag");
221 return;
222 }
223
224 self->channel_mode = gst_avdtp_sink_get_channel_mode (channel_mode);
225 if (self->channel_mode == -1)
226 GST_WARNING_OBJECT (self, "Received invalid channel "
227 "mode: %s", channel_mode);
228 g_free (channel_mode);
229
230 } else
231 GST_DEBUG_OBJECT (self, "received unused tag: %s", tag);
232 }
233
234 static gboolean
gst_avdtp_sink_event(GstBaseSink * basesink,GstEvent * event)235 gst_avdtp_sink_event (GstBaseSink * basesink, GstEvent * event)
236 {
237 GstAvdtpSink *self = GST_AVDTP_SINK (basesink);
238 GstTagList *taglist = NULL;
239
240 if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) {
241 /* we check the tags, mp3 has tags that are importants and
242 * are outside caps */
243 gst_event_parse_tag (event, &taglist);
244 gst_tag_list_foreach (taglist, gst_avdtp_sink_tag, self);
245 }
246
247 return GST_BASE_SINK_CLASS (parent_class)->event (basesink, event);
248 }
249
250 static gboolean
gst_avdtp_sink_start(GstBaseSink * basesink)251 gst_avdtp_sink_start (GstBaseSink * basesink)
252 {
253 GstAvdtpSink *self = GST_AVDTP_SINK (basesink);
254
255 GST_INFO_OBJECT (self, "start");
256
257 self->stream_caps = NULL;
258 self->mp3_using_crc = -1;
259 self->channel_mode = -1;
260
261 if (self->conn.transport == NULL)
262 return FALSE;
263
264 if (!gst_avdtp_connection_acquire (&self->conn, FALSE)) {
265 GST_ERROR_OBJECT (self, "Failed to acquire connection");
266 return FALSE;
267 }
268
269 if (!gst_avdtp_connection_get_properties (&self->conn)) {
270 GST_ERROR_OBJECT (self, "Failed to get transport properties");
271 return FALSE;
272 }
273
274 if (self->dev_caps)
275 gst_caps_unref (self->dev_caps);
276
277 self->dev_caps = gst_avdtp_connection_get_caps (&self->conn);
278
279 if (!self->dev_caps) {
280 GST_ERROR_OBJECT (self, "Failed to get device caps");
281 return FALSE;
282 }
283
284 GST_DEBUG_OBJECT (self, "Got connection caps: %" GST_PTR_FORMAT,
285 self->dev_caps);
286
287 return TRUE;
288 }
289
290 static GstFlowReturn
gst_avdtp_sink_preroll(GstBaseSink * basesink,GstBuffer * buffer)291 gst_avdtp_sink_preroll (GstBaseSink * basesink, GstBuffer * buffer)
292 {
293 GstAvdtpSink *sink = GST_AVDTP_SINK (basesink);
294 gboolean ret;
295
296 GST_AVDTP_SINK_MUTEX_LOCK (sink);
297
298 ret = gst_avdtp_connection_conf_recv_stream_fd (&sink->conn);
299
300 GST_AVDTP_SINK_MUTEX_UNLOCK (sink);
301
302 if (!ret)
303 return GST_FLOW_ERROR;
304
305 return GST_FLOW_OK;
306 }
307
308 static GstFlowReturn
gst_avdtp_sink_render(GstBaseSink * basesink,GstBuffer * buffer)309 gst_avdtp_sink_render (GstBaseSink * basesink, GstBuffer * buffer)
310 {
311 GstFlowReturn flow_ret = GST_FLOW_OK;
312 GstAvdtpSink *self = GST_AVDTP_SINK (basesink);
313 GstMapInfo map;
314 ssize_t ret;
315 int fd;
316
317 if (!gst_buffer_map (buffer, &map, GST_MAP_READ))
318 return GST_FLOW_ERROR;
319
320 /* FIXME: temporary sanity check */
321 g_assert (!(g_io_channel_get_flags (self->conn.stream) & G_IO_FLAG_NONBLOCK));
322
323 /* FIXME: why not use g_io_channel_write_chars() instead? */
324 fd = g_io_channel_unix_get_fd (self->conn.stream);
325 ret = write (fd, map.data, map.size);
326 if (ret < 0) {
327 /* FIXME: since this is probably fatal, shouldn't we post an error here? */
328 GST_ERROR_OBJECT (self, "Error writing to socket: %s", g_strerror (errno));
329 flow_ret = GST_FLOW_ERROR;
330 }
331
332 gst_buffer_unmap (buffer, &map);
333 return flow_ret;
334 }
335
336 static gboolean
gst_avdtp_sink_unlock(GstBaseSink * basesink)337 gst_avdtp_sink_unlock (GstBaseSink * basesink)
338 {
339 GstAvdtpSink *self = GST_AVDTP_SINK (basesink);
340
341 if (self->conn.stream != NULL)
342 g_io_channel_flush (self->conn.stream, NULL);
343
344 return TRUE;
345 }
346
347 static void
gst_avdtp_sink_class_init(GstAvdtpSinkClass * klass)348 gst_avdtp_sink_class_init (GstAvdtpSinkClass * klass)
349 {
350 GObjectClass *object_class = G_OBJECT_CLASS (klass);
351 GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
352 GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS (klass);
353
354 parent_class = g_type_class_peek_parent (klass);
355
356 object_class->finalize = GST_DEBUG_FUNCPTR (gst_avdtp_sink_finalize);
357 object_class->set_property = GST_DEBUG_FUNCPTR (gst_avdtp_sink_set_property);
358 object_class->get_property = GST_DEBUG_FUNCPTR (gst_avdtp_sink_get_property);
359
360 basesink_class->start = GST_DEBUG_FUNCPTR (gst_avdtp_sink_start);
361 basesink_class->stop = GST_DEBUG_FUNCPTR (gst_avdtp_sink_stop);
362 basesink_class->render = GST_DEBUG_FUNCPTR (gst_avdtp_sink_render);
363 basesink_class->preroll = GST_DEBUG_FUNCPTR (gst_avdtp_sink_preroll);
364 basesink_class->unlock = GST_DEBUG_FUNCPTR (gst_avdtp_sink_unlock);
365 basesink_class->event = GST_DEBUG_FUNCPTR (gst_avdtp_sink_event);
366
367 g_object_class_install_property (object_class, PROP_DEVICE,
368 g_param_spec_string ("device", "Device",
369 "Bluetooth remote device address", NULL, G_PARAM_READWRITE));
370
371 g_object_class_install_property (object_class, PROP_AUTOCONNECT,
372 g_param_spec_boolean ("auto-connect",
373 "Auto-connect",
374 "Automatically attempt to connect "
375 "to device", DEFAULT_AUTOCONNECT, G_PARAM_READWRITE));
376
377 g_object_class_install_property (object_class, PROP_TRANSPORT,
378 g_param_spec_string ("transport",
379 "Transport", "Use configured transport", NULL, G_PARAM_READWRITE));
380
381 GST_DEBUG_CATEGORY_INIT (avdtp_sink_debug, "avdtpsink", 0,
382 "A2DP headset sink element");
383
384 gst_element_class_add_static_pad_template (element_class,
385 &avdtp_sink_factory);
386
387 gst_element_class_set_static_metadata (element_class, "Bluetooth AVDTP sink",
388 "Sink/Audio", "Plays audio to an A2DP device",
389 "Marcel Holtmann <marcel@holtmann.org>");
390 }
391
392 static void
gst_avdtp_sink_init(GstAvdtpSink * self)393 gst_avdtp_sink_init (GstAvdtpSink * self)
394 {
395 self->conn.device = NULL;
396 self->conn.transport = NULL;
397
398 self->conn.stream = NULL;
399
400 self->dev_caps = NULL;
401
402 self->autoconnect = DEFAULT_AUTOCONNECT;
403
404 g_mutex_init (&self->sink_lock);
405
406 /* FIXME this is for not synchronizing with clock, should be tested
407 * with devices to see the behaviour
408 gst_base_sink_set_sync(GST_BASE_SINK(self), FALSE);
409 */
410 }
411
412 gboolean
gst_avdtp_sink_plugin_init(GstPlugin * plugin)413 gst_avdtp_sink_plugin_init (GstPlugin * plugin)
414 {
415 return gst_element_register (plugin, "avdtpsink", GST_RANK_NONE,
416 GST_TYPE_AVDTP_SINK);
417 }
418
419
420 /* public functions */
421 GstCaps *
gst_avdtp_sink_get_device_caps(GstAvdtpSink * sink)422 gst_avdtp_sink_get_device_caps (GstAvdtpSink * sink)
423 {
424 if (sink->dev_caps == NULL)
425 return NULL;
426
427 return gst_caps_copy (sink->dev_caps);
428 }
429
430 guint
gst_avdtp_sink_get_link_mtu(GstAvdtpSink * sink)431 gst_avdtp_sink_get_link_mtu (GstAvdtpSink * sink)
432 {
433 return sink->conn.data.link_mtu;
434 }
435
436 void
gst_avdtp_sink_set_device(GstAvdtpSink * self,const gchar * dev)437 gst_avdtp_sink_set_device (GstAvdtpSink * self, const gchar * dev)
438 {
439 g_free (self->conn.device);
440
441 GST_LOG_OBJECT (self, "Setting device: %s", dev);
442 self->conn.device = g_strdup (dev);
443 }
444
445 void
gst_avdtp_sink_set_transport(GstAvdtpSink * self,const gchar * trans)446 gst_avdtp_sink_set_transport (GstAvdtpSink * self, const gchar * trans)
447 {
448 g_free (self->conn.transport);
449
450 GST_LOG_OBJECT (self, "Setting transport: %s", trans);
451 self->conn.transport = g_strdup (trans);
452 }
453
454 gchar *
gst_avdtp_sink_get_device(GstAvdtpSink * self)455 gst_avdtp_sink_get_device (GstAvdtpSink * self)
456 {
457 return g_strdup (self->conn.device);
458 }
459
460 gchar *
gst_avdtp_sink_get_transport(GstAvdtpSink * self)461 gst_avdtp_sink_get_transport (GstAvdtpSink * self)
462 {
463 return g_strdup (self->conn.transport);
464 }
465
466 void
gst_avdtp_sink_set_crc(GstAvdtpSink * self,gboolean crc)467 gst_avdtp_sink_set_crc (GstAvdtpSink * self, gboolean crc)
468 {
469 gint new_crc;
470
471 new_crc = crc ? CRC_PROTECTED : CRC_UNPROTECTED;
472
473 /* test if we already received a different crc */
474 if (self->mp3_using_crc != -1 && new_crc != self->mp3_using_crc) {
475 GST_WARNING_OBJECT (self, "crc changed during stream");
476 return;
477 }
478 self->mp3_using_crc = new_crc;
479
480 }
481
482 void
gst_avdtp_sink_set_channel_mode(GstAvdtpSink * self,const gchar * mode)483 gst_avdtp_sink_set_channel_mode (GstAvdtpSink * self, const gchar * mode)
484 {
485 gint new_mode;
486
487 new_mode = gst_avdtp_sink_get_channel_mode (mode);
488
489 if (self->channel_mode != -1 && new_mode != self->channel_mode) {
490 GST_WARNING_OBJECT (self, "channel mode changed during stream");
491 return;
492 }
493
494 self->channel_mode = new_mode;
495 if (self->channel_mode == -1)
496 GST_WARNING_OBJECT (self, "Received invalid channel mode: %s", mode);
497 }
498