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 #include <sys/un.h>
30 #include <sys/socket.h>
31 #include <fcntl.h>
32 #include <pthread.h>
33
34 #include <netinet/in.h>
35
36 #include <bluetooth/bluetooth.h>
37
38 #include <gst/rtp/gstrtpbuffer.h>
39
40 #include <dbus/dbus.h>
41
42 #include "ipc.h"
43 #include "rtp.h"
44 #include "a2dp-codecs.h"
45
46 #include "gstpragma.h"
47 #include "gstavdtpsink.h"
48
49 GST_DEBUG_CATEGORY_STATIC(avdtp_sink_debug);
50 #define GST_CAT_DEFAULT avdtp_sink_debug
51
52 #define BUFFER_SIZE 2048
53 #define TEMPLATE_MAX_BITPOOL 64
54 #define CRC_PROTECTED 1
55 #define CRC_UNPROTECTED 0
56
57 #define DEFAULT_AUTOCONNECT TRUE
58
59 #define GST_AVDTP_SINK_MUTEX_LOCK(s) G_STMT_START { \
60 g_mutex_lock(s->sink_lock); \
61 } G_STMT_END
62
63 #define GST_AVDTP_SINK_MUTEX_UNLOCK(s) G_STMT_START { \
64 g_mutex_unlock(s->sink_lock); \
65 } G_STMT_END
66
67 #ifndef DBUS_TYPE_UNIX_FD
68 #define DBUS_TYPE_UNIX_FD -1
69 #endif
70
71 struct bluetooth_data {
72 struct bt_get_capabilities_rsp *caps; /* Bluetooth device caps */
73 guint link_mtu;
74
75 DBusConnection *conn;
76 guint8 codec; /* Bluetooth transport configuration */
77 gchar *uuid;
78 guint8 *config;
79 gint config_size;
80
81 gchar buffer[BUFFER_SIZE]; /* Codec transfer buffer */
82 };
83
84 #define IS_SBC(n) (strcmp((n), "audio/x-sbc") == 0)
85 #define IS_MPEG_AUDIO(n) (strcmp((n), "audio/mpeg") == 0)
86
87 enum {
88 PROP_0,
89 PROP_DEVICE,
90 PROP_AUTOCONNECT,
91 PROP_TRANSPORT
92 };
93
94 GST_BOILERPLATE(GstAvdtpSink, gst_avdtp_sink, GstBaseSink,
95 GST_TYPE_BASE_SINK);
96
97 static const GstElementDetails avdtp_sink_details =
98 GST_ELEMENT_DETAILS("Bluetooth AVDTP sink",
99 "Sink/Audio",
100 "Plays audio to an A2DP device",
101 "Marcel Holtmann <marcel@holtmann.org>");
102
103 static GstStaticPadTemplate avdtp_sink_factory =
104 GST_STATIC_PAD_TEMPLATE("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
105 GST_STATIC_CAPS("application/x-rtp, "
106 "media = (string) \"audio\","
107 "payload = (int) "
108 GST_RTP_PAYLOAD_DYNAMIC_STRING ", "
109 "clock-rate = (int) { 16000, 32000, "
110 "44100, 48000 }, "
111 "encoding-name = (string) \"SBC\"; "
112 "application/x-rtp, "
113 "media = (string) \"audio\", "
114 "payload = (int) "
115 GST_RTP_PAYLOAD_MPA_STRING ", "
116 "clock-rate = (int) 90000; "
117 "application/x-rtp, "
118 "media = (string) \"audio\", "
119 "payload = (int) "
120 GST_RTP_PAYLOAD_DYNAMIC_STRING ", "
121 "clock-rate = (int) 90000, "
122 "encoding-name = (string) \"MPA\""
123 ));
124
125 static int gst_avdtp_sink_audioservice_send(GstAvdtpSink *self,
126 const bt_audio_msg_header_t *msg);
127 static int gst_avdtp_sink_audioservice_expect(GstAvdtpSink *self,
128 bt_audio_msg_header_t *outmsg,
129 guint8 expected_name);
130
131
gst_avdtp_sink_base_init(gpointer g_class)132 static void gst_avdtp_sink_base_init(gpointer g_class)
133 {
134 GstElementClass *element_class = GST_ELEMENT_CLASS(g_class);
135
136 gst_element_class_add_pad_template(element_class,
137 gst_static_pad_template_get(&avdtp_sink_factory));
138
139 gst_element_class_set_details(element_class, &avdtp_sink_details);
140 }
141
gst_avdtp_sink_transport_release(GstAvdtpSink * self)142 static void gst_avdtp_sink_transport_release(GstAvdtpSink *self)
143 {
144 DBusMessage *msg;
145 const char *access_type = "w";
146
147 msg = dbus_message_new_method_call("org.bluez", self->transport,
148 "org.bluez.MediaTransport",
149 "Release");
150
151 dbus_message_append_args(msg, DBUS_TYPE_STRING, &access_type,
152 DBUS_TYPE_INVALID);
153
154 dbus_connection_send(self->data->conn, msg, NULL);
155
156 dbus_message_unref(msg);
157 }
158
gst_avdtp_sink_stop(GstBaseSink * basesink)159 static gboolean gst_avdtp_sink_stop(GstBaseSink *basesink)
160 {
161 GstAvdtpSink *self = GST_AVDTP_SINK(basesink);
162
163 GST_INFO_OBJECT(self, "stop");
164
165 if (self->watch_id != 0) {
166 g_source_remove(self->watch_id);
167 self->watch_id = 0;
168 }
169
170 if (self->server) {
171 bt_audio_service_close(g_io_channel_unix_get_fd(self->server));
172 g_io_channel_unref(self->server);
173 self->server = NULL;
174 }
175
176 if (self->stream) {
177 g_io_channel_shutdown(self->stream, TRUE, NULL);
178 g_io_channel_unref(self->stream);
179 self->stream = NULL;
180 }
181
182 if (self->data) {
183 if (self->transport)
184 gst_avdtp_sink_transport_release(self);
185 if (self->data->conn)
186 dbus_connection_unref(self->data->conn);
187 g_free(self->data);
188 self->data = NULL;
189 }
190
191 if (self->stream_caps) {
192 gst_caps_unref(self->stream_caps);
193 self->stream_caps = NULL;
194 }
195
196 if (self->dev_caps) {
197 gst_caps_unref(self->dev_caps);
198 self->dev_caps = NULL;
199 }
200
201 return TRUE;
202 }
203
gst_avdtp_sink_finalize(GObject * object)204 static void gst_avdtp_sink_finalize(GObject *object)
205 {
206 GstAvdtpSink *self = GST_AVDTP_SINK(object);
207
208 if (self->data)
209 gst_avdtp_sink_stop(GST_BASE_SINK(self));
210
211 if (self->device)
212 g_free(self->device);
213
214 if (self->transport)
215 g_free(self->transport);
216
217 g_mutex_free(self->sink_lock);
218
219 G_OBJECT_CLASS(parent_class)->finalize(object);
220 }
221
gst_avdtp_sink_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)222 static void gst_avdtp_sink_set_property(GObject *object, guint prop_id,
223 const GValue *value, GParamSpec *pspec)
224 {
225 GstAvdtpSink *sink = GST_AVDTP_SINK(object);
226
227 switch (prop_id) {
228 case PROP_DEVICE:
229 if (sink->device)
230 g_free(sink->device);
231 sink->device = g_value_dup_string(value);
232 break;
233
234 case PROP_AUTOCONNECT:
235 sink->autoconnect = g_value_get_boolean(value);
236 break;
237
238 case PROP_TRANSPORT:
239 if (sink->transport)
240 g_free(sink->transport);
241 sink->transport = g_value_dup_string(value);
242 break;
243
244 default:
245 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
246 break;
247 }
248 }
249
gst_avdtp_sink_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)250 static void gst_avdtp_sink_get_property(GObject *object, guint prop_id,
251 GValue *value, GParamSpec *pspec)
252 {
253 GstAvdtpSink *sink = GST_AVDTP_SINK(object);
254
255 switch (prop_id) {
256 case PROP_DEVICE:
257 g_value_set_string(value, sink->device);
258 break;
259
260 case PROP_AUTOCONNECT:
261 g_value_set_boolean(value, sink->autoconnect);
262 break;
263
264 case PROP_TRANSPORT:
265 g_value_set_string(value, sink->transport);
266 break;
267
268 default:
269 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
270 break;
271 }
272 }
273
gst_avdtp_sink_bluetooth_recvmsg_fd(GstAvdtpSink * sink)274 static gint gst_avdtp_sink_bluetooth_recvmsg_fd(GstAvdtpSink *sink)
275 {
276 int err, ret;
277
278 ret = bt_audio_service_get_data_fd(
279 g_io_channel_unix_get_fd(sink->server));
280
281 if (ret < 0) {
282 err = errno;
283 GST_ERROR_OBJECT(sink, "Unable to receive fd: %s (%d)",
284 strerror(err), err);
285 return -err;
286 }
287
288 sink->stream = g_io_channel_unix_new(ret);
289 g_io_channel_set_encoding(sink->stream, NULL, NULL);
290 GST_DEBUG_OBJECT(sink, "stream_fd=%d", ret);
291
292 return 0;
293 }
294
gst_avdtp_find_caps(GstAvdtpSink * sink,uint8_t codec_type)295 static codec_capabilities_t *gst_avdtp_find_caps(GstAvdtpSink *sink,
296 uint8_t codec_type)
297 {
298 struct bt_get_capabilities_rsp *rsp = sink->data->caps;
299 codec_capabilities_t *codec = (void *) rsp->data;
300 int bytes_left = rsp->h.length - sizeof(*rsp);
301
302 while (bytes_left > 0) {
303 if ((codec->type == codec_type) &&
304 !(codec->lock & BT_WRITE_LOCK))
305 break;
306
307 bytes_left -= codec->length;
308 codec = (void *) codec + codec->length;
309 }
310
311 if (bytes_left <= 0)
312 return NULL;
313
314 return codec;
315 }
316
gst_avdtp_sink_init_sbc_pkt_conf(GstAvdtpSink * sink,GstCaps * caps,sbc_capabilities_t * pkt)317 static gboolean gst_avdtp_sink_init_sbc_pkt_conf(GstAvdtpSink *sink,
318 GstCaps *caps,
319 sbc_capabilities_t *pkt)
320 {
321 sbc_capabilities_t *cfg;
322 const GValue *value = NULL;
323 const char *pref, *name;
324 gint rate, subbands, blocks;
325 GstStructure *structure = gst_caps_get_structure(caps, 0);
326
327 cfg = (void *) gst_avdtp_find_caps(sink, BT_A2DP_SBC_SINK);
328 name = gst_structure_get_name(structure);
329
330 if (!(IS_SBC(name))) {
331 GST_ERROR_OBJECT(sink, "Unexpected format %s, "
332 "was expecting sbc", name);
333 return FALSE;
334 }
335
336 value = gst_structure_get_value(structure, "rate");
337 rate = g_value_get_int(value);
338 if (rate == 44100)
339 cfg->frequency = BT_SBC_SAMPLING_FREQ_44100;
340 else if (rate == 48000)
341 cfg->frequency = BT_SBC_SAMPLING_FREQ_48000;
342 else if (rate == 32000)
343 cfg->frequency = BT_SBC_SAMPLING_FREQ_32000;
344 else if (rate == 16000)
345 cfg->frequency = BT_SBC_SAMPLING_FREQ_16000;
346 else {
347 GST_ERROR_OBJECT(sink, "Invalid rate while setting caps");
348 return FALSE;
349 }
350
351 value = gst_structure_get_value(structure, "mode");
352 pref = g_value_get_string(value);
353 if (strcmp(pref, "mono") == 0)
354 cfg->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
355 else if (strcmp(pref, "dual") == 0)
356 cfg->channel_mode = BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL;
357 else if (strcmp(pref, "stereo") == 0)
358 cfg->channel_mode = BT_A2DP_CHANNEL_MODE_STEREO;
359 else if (strcmp(pref, "joint") == 0)
360 cfg->channel_mode = BT_A2DP_CHANNEL_MODE_JOINT_STEREO;
361 else {
362 GST_ERROR_OBJECT(sink, "Invalid mode %s", pref);
363 return FALSE;
364 }
365
366 value = gst_structure_get_value(structure, "allocation");
367 pref = g_value_get_string(value);
368 if (strcmp(pref, "loudness") == 0)
369 cfg->allocation_method = BT_A2DP_ALLOCATION_LOUDNESS;
370 else if (strcmp(pref, "snr") == 0)
371 cfg->allocation_method = BT_A2DP_ALLOCATION_SNR;
372 else {
373 GST_ERROR_OBJECT(sink, "Invalid allocation: %s", pref);
374 return FALSE;
375 }
376
377 value = gst_structure_get_value(structure, "subbands");
378 subbands = g_value_get_int(value);
379 if (subbands == 8)
380 cfg->subbands = BT_A2DP_SUBBANDS_8;
381 else if (subbands == 4)
382 cfg->subbands = BT_A2DP_SUBBANDS_4;
383 else {
384 GST_ERROR_OBJECT(sink, "Invalid subbands %d", subbands);
385 return FALSE;
386 }
387
388 value = gst_structure_get_value(structure, "blocks");
389 blocks = g_value_get_int(value);
390 if (blocks == 16)
391 cfg->block_length = BT_A2DP_BLOCK_LENGTH_16;
392 else if (blocks == 12)
393 cfg->block_length = BT_A2DP_BLOCK_LENGTH_12;
394 else if (blocks == 8)
395 cfg->block_length = BT_A2DP_BLOCK_LENGTH_8;
396 else if (blocks == 4)
397 cfg->block_length = BT_A2DP_BLOCK_LENGTH_4;
398 else {
399 GST_ERROR_OBJECT(sink, "Invalid blocks %d", blocks);
400 return FALSE;
401 }
402
403 value = gst_structure_get_value(structure, "bitpool");
404 cfg->max_bitpool = cfg->min_bitpool = g_value_get_int(value);
405
406 memcpy(pkt, cfg, sizeof(*pkt));
407
408 return TRUE;
409 }
410
gst_avdtp_sink_conf_recv_stream_fd(GstAvdtpSink * self)411 static gboolean gst_avdtp_sink_conf_recv_stream_fd(
412 GstAvdtpSink *self)
413 {
414 struct bluetooth_data *data = self->data;
415 gint ret;
416 GError *gerr = NULL;
417 GIOStatus status;
418 GIOFlags flags;
419 int fd;
420
421 /* Proceed if stream was already acquired */
422 if (self->stream != NULL)
423 goto proceed;
424
425 ret = gst_avdtp_sink_bluetooth_recvmsg_fd(self);
426 if (ret < 0)
427 return FALSE;
428
429 if (!self->stream) {
430 GST_ERROR_OBJECT(self, "Error while configuring device: "
431 "could not acquire audio socket");
432 return FALSE;
433 }
434
435 proceed:
436 /* set stream socket to nonblock */
437 GST_LOG_OBJECT(self, "setting stream socket to nonblock");
438 flags = g_io_channel_get_flags(self->stream);
439 flags |= G_IO_FLAG_NONBLOCK;
440 status = g_io_channel_set_flags(self->stream, flags, &gerr);
441 if (status != G_IO_STATUS_NORMAL) {
442 if (gerr)
443 GST_WARNING_OBJECT(self, "Error while "
444 "setting server socket to nonblock: "
445 "%s", gerr->message);
446 else
447 GST_WARNING_OBJECT(self, "Error while "
448 "setting server "
449 "socket to nonblock");
450 }
451
452 fd = g_io_channel_unix_get_fd(self->stream);
453
454 /* It is possible there is some outstanding
455 data in the pipe - we have to empty it */
456 GST_LOG_OBJECT(self, "emptying stream pipe");
457 while (1) {
458 ssize_t bread = read(fd, data->buffer, data->link_mtu);
459 if (bread <= 0)
460 break;
461 }
462
463 /* set stream socket to block */
464 GST_LOG_OBJECT(self, "setting stream socket to block");
465 flags = g_io_channel_get_flags(self->stream);
466 flags &= ~G_IO_FLAG_NONBLOCK;
467 status = g_io_channel_set_flags(self->stream, flags, &gerr);
468 if (status != G_IO_STATUS_NORMAL) {
469 if (gerr)
470 GST_WARNING_OBJECT(self, "Error while "
471 "setting server socket to block:"
472 "%s", gerr->message);
473 else
474 GST_WARNING_OBJECT(self, "Error while "
475 "setting server "
476 "socket to block");
477 }
478
479 memset(data->buffer, 0, sizeof(data->buffer));
480
481 return TRUE;
482 }
483
server_callback(GIOChannel * chan,GIOCondition cond,gpointer data)484 static gboolean server_callback(GIOChannel *chan,
485 GIOCondition cond, gpointer data)
486 {
487 if (cond & G_IO_HUP || cond & G_IO_NVAL)
488 return FALSE;
489 else if (cond & G_IO_ERR)
490 GST_WARNING_OBJECT(GST_AVDTP_SINK(data),
491 "Untreated callback G_IO_ERR");
492
493 return TRUE;
494 }
495
gst_avdtp_sink_parse_sbc_caps(GstAvdtpSink * self,sbc_capabilities_t * sbc)496 static GstStructure *gst_avdtp_sink_parse_sbc_caps(
497 GstAvdtpSink *self, sbc_capabilities_t *sbc)
498 {
499 GstStructure *structure;
500 GValue *value;
501 GValue *list;
502 gboolean mono, stereo;
503
504 if (sbc == NULL)
505 return NULL;
506
507 structure = gst_structure_empty_new("audio/x-sbc");
508 value = g_value_init(g_new0(GValue, 1), G_TYPE_STRING);
509
510 /* mode */
511 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
512 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
513 g_value_set_static_string(value, "mono");
514 gst_value_list_prepend_value(list, value);
515 }
516 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) {
517 g_value_set_static_string(value, "stereo");
518 gst_value_list_prepend_value(list, value);
519 }
520 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) {
521 g_value_set_static_string(value, "dual");
522 gst_value_list_prepend_value(list, value);
523 }
524 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO) {
525 g_value_set_static_string(value, "joint");
526 gst_value_list_prepend_value(list, value);
527 }
528 g_value_unset(value);
529 if (list) {
530 gst_structure_set_value(structure, "mode", list);
531 g_free(list);
532 list = NULL;
533 }
534
535 /* subbands */
536 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
537 value = g_value_init(value, G_TYPE_INT);
538 if (sbc->subbands & BT_A2DP_SUBBANDS_4) {
539 g_value_set_int(value, 4);
540 gst_value_list_prepend_value(list, value);
541 }
542 if (sbc->subbands & BT_A2DP_SUBBANDS_8) {
543 g_value_set_int(value, 8);
544 gst_value_list_prepend_value(list, value);
545 }
546 g_value_unset(value);
547 if (list) {
548 gst_structure_set_value(structure, "subbands", list);
549 g_free(list);
550 list = NULL;
551 }
552
553 /* blocks */
554 value = g_value_init(value, G_TYPE_INT);
555 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
556 if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_16) {
557 g_value_set_int(value, 16);
558 gst_value_list_prepend_value(list, value);
559 }
560 if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_12) {
561 g_value_set_int(value, 12);
562 gst_value_list_prepend_value(list, value);
563 }
564 if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_8) {
565 g_value_set_int(value, 8);
566 gst_value_list_prepend_value(list, value);
567 }
568 if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_4) {
569 g_value_set_int(value, 4);
570 gst_value_list_prepend_value(list, value);
571 }
572 g_value_unset(value);
573 if (list) {
574 gst_structure_set_value(structure, "blocks", list);
575 g_free(list);
576 list = NULL;
577 }
578
579 /* allocation */
580 g_value_init(value, G_TYPE_STRING);
581 list = g_value_init(g_new0(GValue,1), GST_TYPE_LIST);
582 if (sbc->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS) {
583 g_value_set_static_string(value, "loudness");
584 gst_value_list_prepend_value(list, value);
585 }
586 if (sbc->allocation_method & BT_A2DP_ALLOCATION_SNR) {
587 g_value_set_static_string(value, "snr");
588 gst_value_list_prepend_value(list, value);
589 }
590 g_value_unset(value);
591 if (list) {
592 gst_structure_set_value(structure, "allocation", list);
593 g_free(list);
594 list = NULL;
595 }
596
597 /* rate */
598 g_value_init(value, G_TYPE_INT);
599 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
600 if (sbc->frequency & BT_SBC_SAMPLING_FREQ_48000) {
601 g_value_set_int(value, 48000);
602 gst_value_list_prepend_value(list, value);
603 }
604 if (sbc->frequency & BT_SBC_SAMPLING_FREQ_44100) {
605 g_value_set_int(value, 44100);
606 gst_value_list_prepend_value(list, value);
607 }
608 if (sbc->frequency & BT_SBC_SAMPLING_FREQ_32000) {
609 g_value_set_int(value, 32000);
610 gst_value_list_prepend_value(list, value);
611 }
612 if (sbc->frequency & BT_SBC_SAMPLING_FREQ_16000) {
613 g_value_set_int(value, 16000);
614 gst_value_list_prepend_value(list, value);
615 }
616 g_value_unset(value);
617 if (list) {
618 gst_structure_set_value(structure, "rate", list);
619 g_free(list);
620 list = NULL;
621 }
622
623 /* bitpool */
624 value = g_value_init(value, GST_TYPE_INT_RANGE);
625 gst_value_set_int_range(value,
626 MIN(sbc->min_bitpool, TEMPLATE_MAX_BITPOOL),
627 MIN(sbc->max_bitpool, TEMPLATE_MAX_BITPOOL));
628 gst_structure_set_value(structure, "bitpool", value);
629 g_value_unset(value);
630
631 /* channels */
632 mono = FALSE;
633 stereo = FALSE;
634 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO)
635 mono = TRUE;
636 if ((sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) ||
637 (sbc->channel_mode &
638 BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) ||
639 (sbc->channel_mode &
640 BT_A2DP_CHANNEL_MODE_JOINT_STEREO))
641 stereo = TRUE;
642
643 if (mono && stereo) {
644 g_value_init(value, GST_TYPE_INT_RANGE);
645 gst_value_set_int_range(value, 1, 2);
646 } else {
647 g_value_init(value, G_TYPE_INT);
648 if (mono)
649 g_value_set_int(value, 1);
650 else if (stereo)
651 g_value_set_int(value, 2);
652 else {
653 GST_ERROR_OBJECT(self,
654 "Unexpected number of channels");
655 g_value_set_int(value, 0);
656 }
657 }
658
659 gst_structure_set_value(structure, "channels", value);
660 g_free(value);
661
662 return structure;
663 }
664
gst_avdtp_sink_parse_mpeg_caps(GstAvdtpSink * self,mpeg_capabilities_t * mpeg)665 static GstStructure *gst_avdtp_sink_parse_mpeg_caps(
666 GstAvdtpSink *self, mpeg_capabilities_t *mpeg)
667 {
668 GstStructure *structure;
669 GValue *value;
670 GValue *list;
671 gboolean valid_layer = FALSE;
672 gboolean mono, stereo;
673
674 if (!mpeg)
675 return NULL;
676
677 GST_LOG_OBJECT(self, "parsing mpeg caps");
678
679 structure = gst_structure_empty_new("audio/mpeg");
680 value = g_new0(GValue, 1);
681 g_value_init(value, G_TYPE_INT);
682
683 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
684 g_value_set_int(value, 1);
685 gst_value_list_prepend_value(list, value);
686 g_value_set_int(value, 2);
687 gst_value_list_prepend_value(list, value);
688 gst_structure_set_value(structure, "mpegversion", list);
689 g_free(list);
690
691 /* layer */
692 GST_LOG_OBJECT(self, "setting mpeg layer");
693 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
694 if (mpeg->layer & BT_MPEG_LAYER_1) {
695 g_value_set_int(value, 1);
696 gst_value_list_prepend_value(list, value);
697 valid_layer = TRUE;
698 }
699 if (mpeg->layer & BT_MPEG_LAYER_2) {
700 g_value_set_int(value, 2);
701 gst_value_list_prepend_value(list, value);
702 valid_layer = TRUE;
703 }
704 if (mpeg->layer & BT_MPEG_LAYER_3) {
705 g_value_set_int(value, 3);
706 gst_value_list_prepend_value(list, value);
707 valid_layer = TRUE;
708 }
709 if (list) {
710 gst_structure_set_value(structure, "layer", list);
711 g_free(list);
712 list = NULL;
713 }
714
715 if (!valid_layer) {
716 gst_structure_free(structure);
717 g_free(value);
718 return NULL;
719 }
720
721 /* rate */
722 GST_LOG_OBJECT(self, "setting mpeg rate");
723 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
724 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_48000) {
725 g_value_set_int(value, 48000);
726 gst_value_list_prepend_value(list, value);
727 }
728 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_44100) {
729 g_value_set_int(value, 44100);
730 gst_value_list_prepend_value(list, value);
731 }
732 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_32000) {
733 g_value_set_int(value, 32000);
734 gst_value_list_prepend_value(list, value);
735 }
736 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_24000) {
737 g_value_set_int(value, 24000);
738 gst_value_list_prepend_value(list, value);
739 }
740 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_22050) {
741 g_value_set_int(value, 22050);
742 gst_value_list_prepend_value(list, value);
743 }
744 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_16000) {
745 g_value_set_int(value, 16000);
746 gst_value_list_prepend_value(list, value);
747 }
748 g_value_unset(value);
749 if (list) {
750 gst_structure_set_value(structure, "rate", list);
751 g_free(list);
752 list = NULL;
753 }
754
755 /* channels */
756 GST_LOG_OBJECT(self, "setting mpeg channels");
757 mono = FALSE;
758 stereo = FALSE;
759 if (mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_MONO)
760 mono = TRUE;
761 if ((mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) ||
762 (mpeg->channel_mode &
763 BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) ||
764 (mpeg->channel_mode &
765 BT_A2DP_CHANNEL_MODE_JOINT_STEREO))
766 stereo = TRUE;
767
768 if (mono && stereo) {
769 g_value_init(value, GST_TYPE_INT_RANGE);
770 gst_value_set_int_range(value, 1, 2);
771 } else {
772 g_value_init(value, G_TYPE_INT);
773 if (mono)
774 g_value_set_int(value, 1);
775 else if (stereo)
776 g_value_set_int(value, 2);
777 else {
778 GST_ERROR_OBJECT(self,
779 "Unexpected number of channels");
780 g_value_set_int(value, 0);
781 }
782 }
783 gst_structure_set_value(structure, "channels", value);
784 g_free(value);
785
786 return structure;
787 }
788
gst_avdtp_sink_parse_sbc_raw(GstAvdtpSink * self)789 static GstStructure *gst_avdtp_sink_parse_sbc_raw(GstAvdtpSink *self)
790 {
791 a2dp_sbc_t *sbc = (a2dp_sbc_t *) self->data->config;
792 GstStructure *structure;
793 GValue *value;
794 GValue *list;
795 gboolean mono, stereo;
796
797 structure = gst_structure_empty_new("audio/x-sbc");
798 value = g_value_init(g_new0(GValue, 1), G_TYPE_STRING);
799
800 /* mode */
801 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
802 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
803 g_value_set_static_string(value, "mono");
804 gst_value_list_prepend_value(list, value);
805 }
806 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) {
807 g_value_set_static_string(value, "stereo");
808 gst_value_list_prepend_value(list, value);
809 }
810 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) {
811 g_value_set_static_string(value, "dual");
812 gst_value_list_prepend_value(list, value);
813 }
814 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO) {
815 g_value_set_static_string(value, "joint");
816 gst_value_list_prepend_value(list, value);
817 }
818 g_value_unset(value);
819 if (list) {
820 gst_structure_set_value(structure, "mode", list);
821 g_free(list);
822 list = NULL;
823 }
824
825 /* subbands */
826 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
827 value = g_value_init(value, G_TYPE_INT);
828 if (sbc->subbands & BT_A2DP_SUBBANDS_4) {
829 g_value_set_int(value, 4);
830 gst_value_list_prepend_value(list, value);
831 }
832 if (sbc->subbands & BT_A2DP_SUBBANDS_8) {
833 g_value_set_int(value, 8);
834 gst_value_list_prepend_value(list, value);
835 }
836 g_value_unset(value);
837 if (list) {
838 gst_structure_set_value(structure, "subbands", list);
839 g_free(list);
840 list = NULL;
841 }
842
843 /* blocks */
844 value = g_value_init(value, G_TYPE_INT);
845 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
846 if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_16) {
847 g_value_set_int(value, 16);
848 gst_value_list_prepend_value(list, value);
849 }
850 if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_12) {
851 g_value_set_int(value, 12);
852 gst_value_list_prepend_value(list, value);
853 }
854 if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_8) {
855 g_value_set_int(value, 8);
856 gst_value_list_prepend_value(list, value);
857 }
858 if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_4) {
859 g_value_set_int(value, 4);
860 gst_value_list_prepend_value(list, value);
861 }
862 g_value_unset(value);
863 if (list) {
864 gst_structure_set_value(structure, "blocks", list);
865 g_free(list);
866 list = NULL;
867 }
868
869 /* allocation */
870 g_value_init(value, G_TYPE_STRING);
871 list = g_value_init(g_new0(GValue,1), GST_TYPE_LIST);
872 if (sbc->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS) {
873 g_value_set_static_string(value, "loudness");
874 gst_value_list_prepend_value(list, value);
875 }
876 if (sbc->allocation_method & BT_A2DP_ALLOCATION_SNR) {
877 g_value_set_static_string(value, "snr");
878 gst_value_list_prepend_value(list, value);
879 }
880 g_value_unset(value);
881 if (list) {
882 gst_structure_set_value(structure, "allocation", list);
883 g_free(list);
884 list = NULL;
885 }
886
887 /* rate */
888 g_value_init(value, G_TYPE_INT);
889 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
890 if (sbc->frequency & BT_SBC_SAMPLING_FREQ_48000) {
891 g_value_set_int(value, 48000);
892 gst_value_list_prepend_value(list, value);
893 }
894 if (sbc->frequency & BT_SBC_SAMPLING_FREQ_44100) {
895 g_value_set_int(value, 44100);
896 gst_value_list_prepend_value(list, value);
897 }
898 if (sbc->frequency & BT_SBC_SAMPLING_FREQ_32000) {
899 g_value_set_int(value, 32000);
900 gst_value_list_prepend_value(list, value);
901 }
902 if (sbc->frequency & BT_SBC_SAMPLING_FREQ_16000) {
903 g_value_set_int(value, 16000);
904 gst_value_list_prepend_value(list, value);
905 }
906 g_value_unset(value);
907 if (list) {
908 gst_structure_set_value(structure, "rate", list);
909 g_free(list);
910 list = NULL;
911 }
912
913 /* bitpool */
914 value = g_value_init(value, GST_TYPE_INT_RANGE);
915 gst_value_set_int_range(value,
916 MIN(sbc->min_bitpool, TEMPLATE_MAX_BITPOOL),
917 MIN(sbc->max_bitpool, TEMPLATE_MAX_BITPOOL));
918 gst_structure_set_value(structure, "bitpool", value);
919 g_value_unset(value);
920
921 /* channels */
922 mono = FALSE;
923 stereo = FALSE;
924 if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO)
925 mono = TRUE;
926 if ((sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) ||
927 (sbc->channel_mode &
928 BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) ||
929 (sbc->channel_mode &
930 BT_A2DP_CHANNEL_MODE_JOINT_STEREO))
931 stereo = TRUE;
932
933 if (mono && stereo) {
934 g_value_init(value, GST_TYPE_INT_RANGE);
935 gst_value_set_int_range(value, 1, 2);
936 } else {
937 g_value_init(value, G_TYPE_INT);
938 if (mono)
939 g_value_set_int(value, 1);
940 else if (stereo)
941 g_value_set_int(value, 2);
942 else {
943 GST_ERROR_OBJECT(self,
944 "Unexpected number of channels");
945 g_value_set_int(value, 0);
946 }
947 }
948
949 gst_structure_set_value(structure, "channels", value);
950 g_free(value);
951
952 return structure;
953 }
954
gst_avdtp_sink_parse_mpeg_raw(GstAvdtpSink * self)955 static GstStructure *gst_avdtp_sink_parse_mpeg_raw(GstAvdtpSink *self)
956 {
957 a2dp_mpeg_t *mpeg = (a2dp_mpeg_t *) self->data->config;
958 GstStructure *structure;
959 GValue *value;
960 GValue *list;
961 gboolean valid_layer = FALSE;
962 gboolean mono, stereo;
963
964 GST_LOG_OBJECT(self, "parsing mpeg caps");
965
966 structure = gst_structure_empty_new("audio/mpeg");
967 value = g_new0(GValue, 1);
968 g_value_init(value, G_TYPE_INT);
969
970 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
971 g_value_set_int(value, 1);
972 gst_value_list_prepend_value(list, value);
973 g_value_set_int(value, 2);
974 gst_value_list_prepend_value(list, value);
975 gst_structure_set_value(structure, "mpegversion", list);
976 g_free(list);
977
978 /* layer */
979 GST_LOG_OBJECT(self, "setting mpeg layer");
980 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
981 if (mpeg->layer & BT_MPEG_LAYER_1) {
982 g_value_set_int(value, 1);
983 gst_value_list_prepend_value(list, value);
984 valid_layer = TRUE;
985 }
986 if (mpeg->layer & BT_MPEG_LAYER_2) {
987 g_value_set_int(value, 2);
988 gst_value_list_prepend_value(list, value);
989 valid_layer = TRUE;
990 }
991 if (mpeg->layer & BT_MPEG_LAYER_3) {
992 g_value_set_int(value, 3);
993 gst_value_list_prepend_value(list, value);
994 valid_layer = TRUE;
995 }
996 if (list) {
997 gst_structure_set_value(structure, "layer", list);
998 g_free(list);
999 list = NULL;
1000 }
1001
1002 if (!valid_layer) {
1003 gst_structure_free(structure);
1004 g_free(value);
1005 return NULL;
1006 }
1007
1008 /* rate */
1009 GST_LOG_OBJECT(self, "setting mpeg rate");
1010 list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
1011 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_48000) {
1012 g_value_set_int(value, 48000);
1013 gst_value_list_prepend_value(list, value);
1014 }
1015 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_44100) {
1016 g_value_set_int(value, 44100);
1017 gst_value_list_prepend_value(list, value);
1018 }
1019 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_32000) {
1020 g_value_set_int(value, 32000);
1021 gst_value_list_prepend_value(list, value);
1022 }
1023 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_24000) {
1024 g_value_set_int(value, 24000);
1025 gst_value_list_prepend_value(list, value);
1026 }
1027 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_22050) {
1028 g_value_set_int(value, 22050);
1029 gst_value_list_prepend_value(list, value);
1030 }
1031 if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_16000) {
1032 g_value_set_int(value, 16000);
1033 gst_value_list_prepend_value(list, value);
1034 }
1035 g_value_unset(value);
1036 if (list) {
1037 gst_structure_set_value(structure, "rate", list);
1038 g_free(list);
1039 list = NULL;
1040 }
1041
1042 /* channels */
1043 GST_LOG_OBJECT(self, "setting mpeg channels");
1044 mono = FALSE;
1045 stereo = FALSE;
1046 if (mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_MONO)
1047 mono = TRUE;
1048 if ((mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) ||
1049 (mpeg->channel_mode &
1050 BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) ||
1051 (mpeg->channel_mode &
1052 BT_A2DP_CHANNEL_MODE_JOINT_STEREO))
1053 stereo = TRUE;
1054
1055 if (mono && stereo) {
1056 g_value_init(value, GST_TYPE_INT_RANGE);
1057 gst_value_set_int_range(value, 1, 2);
1058 } else {
1059 g_value_init(value, G_TYPE_INT);
1060 if (mono)
1061 g_value_set_int(value, 1);
1062 else if (stereo)
1063 g_value_set_int(value, 2);
1064 else {
1065 GST_ERROR_OBJECT(self,
1066 "Unexpected number of channels");
1067 g_value_set_int(value, 0);
1068 }
1069 }
1070 gst_structure_set_value(structure, "channels", value);
1071 g_free(value);
1072
1073 return structure;
1074 }
1075
gst_avdtp_sink_update_config(GstAvdtpSink * self)1076 static gboolean gst_avdtp_sink_update_config(GstAvdtpSink *self)
1077 {
1078 GstStructure *structure;
1079 gchar *tmp;
1080
1081 switch (self->data->codec) {
1082 case A2DP_CODEC_SBC:
1083 structure = gst_avdtp_sink_parse_sbc_raw(self);
1084 break;
1085 case A2DP_CODEC_MPEG12:
1086 structure = gst_avdtp_sink_parse_mpeg_raw(self);
1087 break;
1088 default:
1089 GST_ERROR_OBJECT(self, "Unsupported configuration");
1090 return FALSE;
1091 }
1092
1093 if (structure == NULL)
1094 return FALSE;
1095
1096 if (self->dev_caps != NULL)
1097 gst_caps_unref(self->dev_caps);
1098
1099 self->dev_caps = gst_caps_new_full(structure, NULL);
1100
1101 tmp = gst_caps_to_string(self->dev_caps);
1102 GST_DEBUG_OBJECT(self, "Transport configuration: %s", tmp);
1103 g_free(tmp);
1104
1105 return TRUE;
1106 }
1107
gst_avdtp_sink_update_caps(GstAvdtpSink * self)1108 static gboolean gst_avdtp_sink_update_caps(GstAvdtpSink *self)
1109 {
1110 sbc_capabilities_t *sbc;
1111 mpeg_capabilities_t *mpeg;
1112 GstStructure *sbc_structure;
1113 GstStructure *mpeg_structure;
1114 gchar *tmp;
1115
1116 GST_LOG_OBJECT(self, "updating device caps");
1117
1118 if (self->data->config_size != 0 && self->data->config != NULL)
1119 return gst_avdtp_sink_update_config(self);
1120
1121 sbc = (void *) gst_avdtp_find_caps(self, BT_A2DP_SBC_SINK);
1122 mpeg = (void *) gst_avdtp_find_caps(self, BT_A2DP_MPEG12_SINK);
1123
1124 sbc_structure = gst_avdtp_sink_parse_sbc_caps(self, sbc);
1125 mpeg_structure = gst_avdtp_sink_parse_mpeg_caps(self, mpeg);
1126
1127 if (self->dev_caps != NULL)
1128 gst_caps_unref(self->dev_caps);
1129 self->dev_caps = gst_caps_new_full(sbc_structure, NULL);
1130 if (mpeg_structure != NULL)
1131 gst_caps_append_structure(self->dev_caps, mpeg_structure);
1132
1133 tmp = gst_caps_to_string(self->dev_caps);
1134 GST_DEBUG_OBJECT(self, "Device capabilities: %s", tmp);
1135 g_free(tmp);
1136
1137 return TRUE;
1138 }
1139
gst_avdtp_sink_get_capabilities(GstAvdtpSink * self)1140 static gboolean gst_avdtp_sink_get_capabilities(GstAvdtpSink *self)
1141 {
1142 gchar *buf[BT_SUGGESTED_BUFFER_SIZE];
1143 struct bt_get_capabilities_req *req = (void *) buf;
1144 struct bt_get_capabilities_rsp *rsp = (void *) buf;
1145 int err;
1146
1147 memset(req, 0, BT_SUGGESTED_BUFFER_SIZE);
1148
1149 req->h.type = BT_REQUEST;
1150 req->h.name = BT_GET_CAPABILITIES;
1151 req->h.length = sizeof(*req);
1152
1153 if (self->device == NULL)
1154 return FALSE;
1155 strncpy(req->destination, self->device, 18);
1156 if (self->autoconnect)
1157 req->flags |= BT_FLAG_AUTOCONNECT;
1158
1159 err = gst_avdtp_sink_audioservice_send(self, &req->h);
1160 if (err < 0) {
1161 GST_ERROR_OBJECT(self, "Error while asking device caps");
1162 return FALSE;
1163 }
1164
1165 rsp->h.length = 0;
1166 err = gst_avdtp_sink_audioservice_expect(self,
1167 &rsp->h, BT_GET_CAPABILITIES);
1168 if (err < 0) {
1169 GST_ERROR_OBJECT(self, "Error while getting device caps");
1170 return FALSE;
1171 }
1172
1173 self->data->caps = g_malloc0(rsp->h.length);
1174 memcpy(self->data->caps, rsp, rsp->h.length);
1175 if (!gst_avdtp_sink_update_caps(self)) {
1176 GST_WARNING_OBJECT(self, "failed to update capabilities");
1177 return FALSE;
1178 }
1179
1180 return TRUE;
1181 }
1182
gst_avdtp_sink_get_channel_mode(const gchar * mode)1183 static gint gst_avdtp_sink_get_channel_mode(const gchar *mode)
1184 {
1185 if (strcmp(mode, "stereo") == 0)
1186 return BT_A2DP_CHANNEL_MODE_STEREO;
1187 else if (strcmp(mode, "joint-stereo") == 0)
1188 return BT_A2DP_CHANNEL_MODE_JOINT_STEREO;
1189 else if (strcmp(mode, "dual-channel") == 0)
1190 return BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL;
1191 else if (strcmp(mode, "mono") == 0)
1192 return BT_A2DP_CHANNEL_MODE_MONO;
1193 else
1194 return -1;
1195 }
1196
gst_avdtp_sink_tag(const GstTagList * taglist,const gchar * tag,gpointer user_data)1197 static void gst_avdtp_sink_tag(const GstTagList *taglist,
1198 const gchar *tag, gpointer user_data)
1199 {
1200 gboolean crc;
1201 gchar *channel_mode = NULL;
1202 GstAvdtpSink *self = GST_AVDTP_SINK(user_data);
1203
1204 if (strcmp(tag, "has-crc") == 0) {
1205
1206 if (!gst_tag_list_get_boolean(taglist, tag, &crc)) {
1207 GST_WARNING_OBJECT(self, "failed to get crc tag");
1208 return;
1209 }
1210
1211 gst_avdtp_sink_set_crc(self, crc);
1212
1213 } else if (strcmp(tag, "channel-mode") == 0) {
1214
1215 if (!gst_tag_list_get_string(taglist, tag, &channel_mode)) {
1216 GST_WARNING_OBJECT(self,
1217 "failed to get channel-mode tag");
1218 return;
1219 }
1220
1221 self->channel_mode = gst_avdtp_sink_get_channel_mode(
1222 channel_mode);
1223 if (self->channel_mode == -1)
1224 GST_WARNING_OBJECT(self, "Received invalid channel "
1225 "mode: %s", channel_mode);
1226 g_free(channel_mode);
1227
1228 } else
1229 GST_DEBUG_OBJECT(self, "received unused tag: %s", tag);
1230 }
1231
gst_avdtp_sink_event(GstBaseSink * basesink,GstEvent * event)1232 static gboolean gst_avdtp_sink_event(GstBaseSink *basesink,
1233 GstEvent *event)
1234 {
1235 GstAvdtpSink *self = GST_AVDTP_SINK(basesink);
1236 GstTagList *taglist = NULL;
1237
1238 if (GST_EVENT_TYPE(event) == GST_EVENT_TAG) {
1239 /* we check the tags, mp3 has tags that are importants and
1240 * are outside caps */
1241 gst_event_parse_tag(event, &taglist);
1242 gst_tag_list_foreach(taglist, gst_avdtp_sink_tag, self);
1243 }
1244
1245 return TRUE;
1246 }
1247
gst_avdtp_sink_transport_parse_property(GstAvdtpSink * self,DBusMessageIter * i)1248 static gboolean gst_avdtp_sink_transport_parse_property(GstAvdtpSink *self,
1249 DBusMessageIter *i)
1250 {
1251 const char *key;
1252 DBusMessageIter variant_i;
1253
1254 if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING) {
1255 GST_ERROR_OBJECT(self, "Property name not a string.");
1256 return FALSE;
1257 }
1258
1259 dbus_message_iter_get_basic(i, &key);
1260
1261 if (!dbus_message_iter_next(i)) {
1262 GST_ERROR_OBJECT(self, "Property value missing");
1263 return FALSE;
1264 }
1265
1266 if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_VARIANT) {
1267 GST_ERROR_OBJECT(self, "Property value not a variant.");
1268 return FALSE;
1269 }
1270
1271 dbus_message_iter_recurse(i, &variant_i);
1272
1273 switch (dbus_message_iter_get_arg_type(&variant_i)) {
1274 case DBUS_TYPE_BYTE: {
1275 uint8_t value;
1276 dbus_message_iter_get_basic(&variant_i, &value);
1277
1278 if (g_str_equal(key, "Codec") == TRUE)
1279 self->data->codec = value;
1280
1281 break;
1282 }
1283 case DBUS_TYPE_STRING: {
1284 const char *value;
1285 dbus_message_iter_get_basic(&variant_i, &value);
1286
1287 if (g_str_equal(key, "UUID") == TRUE) {
1288 g_free(self->data->uuid);
1289 self->data->uuid = g_strdup(value);
1290 }
1291
1292 break;
1293 }
1294 case DBUS_TYPE_ARRAY: {
1295 DBusMessageIter array_i;
1296 char *value;
1297 int size;
1298
1299 dbus_message_iter_recurse(&variant_i, &array_i);
1300 dbus_message_iter_get_fixed_array(&array_i, &value, &size);
1301
1302 if (g_str_equal(key, "Configuration")) {
1303 g_free(self->data->config);
1304 self->data->config = g_new0(guint8, size);
1305 self->data->config_size = size;
1306 memcpy(self->data->config, value, size);
1307 }
1308
1309 break;
1310 }
1311 }
1312
1313 return TRUE;
1314 }
1315
gst_avdtp_sink_transport_acquire(GstAvdtpSink * self)1316 static gboolean gst_avdtp_sink_transport_acquire(GstAvdtpSink *self)
1317 {
1318 DBusMessage *msg, *reply;
1319 DBusError err;
1320 const char *access_type = "w";
1321 int fd;
1322 uint16_t imtu, omtu;
1323
1324 dbus_error_init(&err);
1325
1326 if (self->data->conn == NULL)
1327 self->data->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
1328
1329 msg = dbus_message_new_method_call("org.bluez", self->transport,
1330 "org.bluez.MediaTransport",
1331 "Acquire");
1332
1333 dbus_message_append_args(msg, DBUS_TYPE_STRING, &access_type,
1334 DBUS_TYPE_INVALID);
1335
1336 reply = dbus_connection_send_with_reply_and_block(self->data->conn,
1337 msg, -1, &err);
1338
1339 if (dbus_error_is_set(&err))
1340 goto fail;
1341
1342 if (dbus_message_get_args(reply, &err, DBUS_TYPE_UNIX_FD, &fd,
1343 DBUS_TYPE_UINT16, &imtu,
1344 DBUS_TYPE_UINT16, &omtu,
1345 DBUS_TYPE_INVALID) == FALSE)
1346 goto fail;
1347
1348 dbus_message_unref(reply);
1349
1350 self->stream = g_io_channel_unix_new(fd);
1351 g_io_channel_set_encoding(self->stream, NULL, NULL);
1352 g_io_channel_set_close_on_unref(self->stream, TRUE);
1353 self->data->link_mtu = omtu;
1354 GST_DEBUG_OBJECT(self, "stream_fd=%d mtu=%d", fd, omtu);
1355
1356 return TRUE;
1357
1358 fail:
1359 GST_ERROR_OBJECT(self, "Failed to acquire transport stream: %s",
1360 err.message);
1361
1362 dbus_error_free(&err);
1363
1364 if (reply)
1365 dbus_message_unref(msg);
1366
1367 return FALSE;
1368 }
1369
gst_avdtp_sink_transport_get_properties(GstAvdtpSink * self)1370 static gboolean gst_avdtp_sink_transport_get_properties(GstAvdtpSink *self)
1371 {
1372 DBusMessage *msg, *reply;
1373 DBusMessageIter arg_i, ele_i;
1374 DBusError err;
1375
1376 dbus_error_init(&err);
1377
1378 /* Transport need to be acquire first to make sure the MTUs are
1379 available */
1380 if (gst_avdtp_sink_transport_acquire(self) == FALSE)
1381 return FALSE;
1382
1383 msg = dbus_message_new_method_call("org.bluez", self->transport,
1384 "org.bluez.MediaTransport",
1385 "GetProperties");
1386 reply = dbus_connection_send_with_reply_and_block(self->data->conn,
1387 msg, -1, &err);
1388
1389 if (dbus_error_is_set(&err) || reply == NULL) {
1390 GST_ERROR_OBJECT(self, "Failed to get transport properties: %s",
1391 err.message);
1392 goto fail;
1393 }
1394
1395 if (!dbus_message_iter_init(reply, &arg_i)) {
1396 GST_ERROR_OBJECT(self, "GetProperties reply has no arguments.");
1397 goto fail;
1398 }
1399
1400 if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
1401 GST_ERROR_OBJECT(self, "GetProperties argument is not an array.");
1402 goto fail;
1403 }
1404
1405 dbus_message_iter_recurse(&arg_i, &ele_i);
1406 while (dbus_message_iter_get_arg_type(&ele_i) != DBUS_TYPE_INVALID) {
1407
1408 if (dbus_message_iter_get_arg_type(&ele_i) ==
1409 DBUS_TYPE_DICT_ENTRY) {
1410 DBusMessageIter dict_i;
1411
1412 dbus_message_iter_recurse(&ele_i, &dict_i);
1413
1414 gst_avdtp_sink_transport_parse_property(self, &dict_i);
1415 }
1416
1417 if (!dbus_message_iter_next(&ele_i))
1418 break;
1419 }
1420
1421 return gst_avdtp_sink_update_caps(self);
1422
1423 fail:
1424 dbus_message_unref(msg);
1425 dbus_message_unref(reply);
1426 return FALSE;
1427
1428 }
1429
gst_avdtp_sink_start(GstBaseSink * basesink)1430 static gboolean gst_avdtp_sink_start(GstBaseSink *basesink)
1431 {
1432 GstAvdtpSink *self = GST_AVDTP_SINK(basesink);
1433 gint sk;
1434 gint err;
1435
1436 GST_INFO_OBJECT(self, "start");
1437
1438 self->data = g_new0(struct bluetooth_data, 1);
1439
1440 self->stream = NULL;
1441 self->stream_caps = NULL;
1442 self->mp3_using_crc = -1;
1443 self->channel_mode = -1;
1444
1445 if (self->transport != NULL)
1446 return gst_avdtp_sink_transport_get_properties(self);
1447
1448 self->watch_id = 0;
1449
1450 sk = bt_audio_service_open();
1451 if (sk <= 0) {
1452 err = errno;
1453 GST_ERROR_OBJECT(self, "Cannot open connection to bt "
1454 "audio service: %s %d", strerror(err), err);
1455 goto failed;
1456 }
1457
1458 self->server = g_io_channel_unix_new(sk);
1459 g_io_channel_set_encoding(self->server, NULL, NULL);
1460 self->watch_id = g_io_add_watch(self->server, G_IO_HUP | G_IO_ERR |
1461 G_IO_NVAL, server_callback, self);
1462
1463 if (!gst_avdtp_sink_get_capabilities(self)) {
1464 GST_ERROR_OBJECT(self, "failed to get capabilities "
1465 "from device");
1466 goto failed;
1467 }
1468
1469 return TRUE;
1470
1471 failed:
1472 bt_audio_service_close(sk);
1473 return FALSE;
1474 }
1475
gst_avdtp_sink_stream_start(GstAvdtpSink * self)1476 static gboolean gst_avdtp_sink_stream_start(GstAvdtpSink *self)
1477 {
1478 gchar buf[BT_SUGGESTED_BUFFER_SIZE];
1479 struct bt_start_stream_req *req = (void *) buf;
1480 struct bt_start_stream_rsp *rsp = (void *) buf;
1481 struct bt_new_stream_ind *ind = (void *) buf;
1482 int err;
1483
1484 if (self->transport != NULL)
1485 return gst_avdtp_sink_conf_recv_stream_fd(self);
1486
1487 memset(req, 0, sizeof(buf));
1488 req->h.type = BT_REQUEST;
1489 req->h.name = BT_START_STREAM;
1490 req->h.length = sizeof(*req);
1491
1492 err = gst_avdtp_sink_audioservice_send(self, &req->h);
1493 if (err < 0) {
1494 GST_ERROR_OBJECT(self, "Error ocurred while sending "
1495 "start packet");
1496 return FALSE;
1497 }
1498
1499 rsp->h.length = sizeof(*rsp);
1500 err = gst_avdtp_sink_audioservice_expect(self, &rsp->h,
1501 BT_START_STREAM);
1502 if (err < 0) {
1503 GST_ERROR_OBJECT(self, "Error while stream "
1504 "start confirmation");
1505 return FALSE;
1506 }
1507
1508 ind->h.length = sizeof(*ind);
1509 err = gst_avdtp_sink_audioservice_expect(self, &ind->h,
1510 BT_NEW_STREAM);
1511 if (err < 0) {
1512 GST_ERROR_OBJECT(self, "Error while receiving "
1513 "stream filedescriptor");
1514 return FALSE;
1515 }
1516
1517 if (!gst_avdtp_sink_conf_recv_stream_fd(self))
1518 return FALSE;
1519
1520 return TRUE;
1521 }
1522
gst_avdtp_sink_init_mp3_pkt_conf(GstAvdtpSink * self,GstCaps * caps,mpeg_capabilities_t * pkt)1523 static gboolean gst_avdtp_sink_init_mp3_pkt_conf(
1524 GstAvdtpSink *self, GstCaps *caps,
1525 mpeg_capabilities_t *pkt)
1526 {
1527 const GValue *value = NULL;
1528 gint rate, layer;
1529 const gchar *name;
1530 GstStructure *structure = gst_caps_get_structure(caps, 0);
1531
1532 name = gst_structure_get_name(structure);
1533
1534 if (!(IS_MPEG_AUDIO(name))) {
1535 GST_ERROR_OBJECT(self, "Unexpected format %s, "
1536 "was expecting mp3", name);
1537 return FALSE;
1538 }
1539
1540 /* layer */
1541 value = gst_structure_get_value(structure, "layer");
1542 layer = g_value_get_int(value);
1543 if (layer == 1)
1544 pkt->layer = BT_MPEG_LAYER_1;
1545 else if (layer == 2)
1546 pkt->layer = BT_MPEG_LAYER_2;
1547 else if (layer == 3)
1548 pkt->layer = BT_MPEG_LAYER_3;
1549 else {
1550 GST_ERROR_OBJECT(self, "Unexpected layer: %d", layer);
1551 return FALSE;
1552 }
1553
1554 /* crc */
1555 if (self->mp3_using_crc != -1)
1556 pkt->crc = self->mp3_using_crc;
1557 else {
1558 GST_ERROR_OBJECT(self, "No info about crc was received, "
1559 " can't proceed");
1560 return FALSE;
1561 }
1562
1563 /* channel mode */
1564 if (self->channel_mode != -1)
1565 pkt->channel_mode = self->channel_mode;
1566 else {
1567 GST_ERROR_OBJECT(self, "No info about channel mode "
1568 "received, can't proceed");
1569 return FALSE;
1570 }
1571
1572 /* mpf - we will only use the mandatory one */
1573 pkt->mpf = 0;
1574
1575 value = gst_structure_get_value(structure, "rate");
1576 rate = g_value_get_int(value);
1577 if (rate == 44100)
1578 pkt->frequency = BT_MPEG_SAMPLING_FREQ_44100;
1579 else if (rate == 48000)
1580 pkt->frequency = BT_MPEG_SAMPLING_FREQ_48000;
1581 else if (rate == 32000)
1582 pkt->frequency = BT_MPEG_SAMPLING_FREQ_32000;
1583 else if (rate == 24000)
1584 pkt->frequency = BT_MPEG_SAMPLING_FREQ_24000;
1585 else if (rate == 22050)
1586 pkt->frequency = BT_MPEG_SAMPLING_FREQ_22050;
1587 else if (rate == 16000)
1588 pkt->frequency = BT_MPEG_SAMPLING_FREQ_16000;
1589 else {
1590 GST_ERROR_OBJECT(self, "Invalid rate while setting caps");
1591 return FALSE;
1592 }
1593
1594 /* vbr - we always say its vbr, we don't have how to know it */
1595 pkt->bitrate = 0x8000;
1596
1597 return TRUE;
1598 }
1599
gst_avdtp_sink_configure(GstAvdtpSink * self,GstCaps * caps)1600 static gboolean gst_avdtp_sink_configure(GstAvdtpSink *self,
1601 GstCaps *caps)
1602 {
1603 gchar buf[BT_SUGGESTED_BUFFER_SIZE];
1604 struct bt_open_req *open_req = (void *) buf;
1605 struct bt_open_rsp *open_rsp = (void *) buf;
1606 struct bt_set_configuration_req *req = (void *) buf;
1607 struct bt_set_configuration_rsp *rsp = (void *) buf;
1608 gboolean ret;
1609 gchar *temp;
1610 GstStructure *structure;
1611 codec_capabilities_t *codec = NULL;
1612 int err;
1613
1614 temp = gst_caps_to_string(caps);
1615 GST_DEBUG_OBJECT(self, "configuring device with caps: %s", temp);
1616 g_free(temp);
1617
1618 /* Transport already configured */
1619 if (self->transport != NULL)
1620 return TRUE;
1621
1622 structure = gst_caps_get_structure(caps, 0);
1623
1624 if (gst_structure_has_name(structure, "audio/x-sbc"))
1625 codec = (void *) gst_avdtp_find_caps(self, BT_A2DP_SBC_SINK);
1626 else if (gst_structure_has_name(structure, "audio/mpeg"))
1627 codec = (void *) gst_avdtp_find_caps(self, BT_A2DP_MPEG12_SINK);
1628
1629 if (codec == NULL) {
1630 GST_ERROR_OBJECT(self, "Couldn't parse caps "
1631 "to packet configuration");
1632 return FALSE;
1633 }
1634
1635 memset(req, 0, BT_SUGGESTED_BUFFER_SIZE);
1636 open_req->h.type = BT_REQUEST;
1637 open_req->h.name = BT_OPEN;
1638 open_req->h.length = sizeof(*open_req);
1639
1640 strncpy(open_req->destination, self->device, 18);
1641 open_req->seid = codec->seid;
1642 open_req->lock = BT_WRITE_LOCK;
1643
1644 err = gst_avdtp_sink_audioservice_send(self, &open_req->h);
1645 if (err < 0) {
1646 GST_ERROR_OBJECT(self, "Error ocurred while sending "
1647 "open packet");
1648 return FALSE;
1649 }
1650
1651 open_rsp->h.length = sizeof(*open_rsp);
1652 err = gst_avdtp_sink_audioservice_expect(self, &open_rsp->h,
1653 BT_OPEN);
1654 if (err < 0) {
1655 GST_ERROR_OBJECT(self, "Error while receiving device "
1656 "confirmation");
1657 return FALSE;
1658 }
1659
1660 memset(req, 0, sizeof(buf));
1661 req->h.type = BT_REQUEST;
1662 req->h.name = BT_SET_CONFIGURATION;
1663 req->h.length = sizeof(*req);
1664 memcpy(&req->codec, codec, sizeof(req->codec));
1665
1666 if (codec->type == BT_A2DP_SBC_SINK)
1667 ret = gst_avdtp_sink_init_sbc_pkt_conf(self, caps,
1668 (void *) &req->codec);
1669 else
1670 ret = gst_avdtp_sink_init_mp3_pkt_conf(self, caps,
1671 (void *) &req->codec);
1672
1673 if (!ret) {
1674 GST_ERROR_OBJECT(self, "Couldn't parse caps "
1675 "to packet configuration");
1676 return FALSE;
1677 }
1678
1679 req->h.length += req->codec.length - sizeof(req->codec);
1680 err = gst_avdtp_sink_audioservice_send(self, &req->h);
1681 if (err < 0) {
1682 GST_ERROR_OBJECT(self, "Error ocurred while sending "
1683 "configurarion packet");
1684 return FALSE;
1685 }
1686
1687 rsp->h.length = sizeof(*rsp);
1688 err = gst_avdtp_sink_audioservice_expect(self, &rsp->h,
1689 BT_SET_CONFIGURATION);
1690 if (err < 0) {
1691 GST_ERROR_OBJECT(self, "Error while receiving device "
1692 "confirmation");
1693 return FALSE;
1694 }
1695
1696 self->data->link_mtu = rsp->link_mtu;
1697
1698 return TRUE;
1699 }
1700
gst_avdtp_sink_preroll(GstBaseSink * basesink,GstBuffer * buffer)1701 static GstFlowReturn gst_avdtp_sink_preroll(GstBaseSink *basesink,
1702 GstBuffer *buffer)
1703 {
1704 GstAvdtpSink *sink = GST_AVDTP_SINK(basesink);
1705 gboolean ret;
1706
1707 GST_AVDTP_SINK_MUTEX_LOCK(sink);
1708
1709 ret = gst_avdtp_sink_stream_start(sink);
1710
1711 GST_AVDTP_SINK_MUTEX_UNLOCK(sink);
1712
1713 if (!ret)
1714 return GST_FLOW_ERROR;
1715
1716 return GST_FLOW_OK;
1717 }
1718
gst_avdtp_sink_render(GstBaseSink * basesink,GstBuffer * buffer)1719 static GstFlowReturn gst_avdtp_sink_render(GstBaseSink *basesink,
1720 GstBuffer *buffer)
1721 {
1722 GstAvdtpSink *self = GST_AVDTP_SINK(basesink);
1723 ssize_t ret;
1724 int fd;
1725
1726 fd = g_io_channel_unix_get_fd(self->stream);
1727
1728 ret = write(fd, GST_BUFFER_DATA(buffer), GST_BUFFER_SIZE(buffer));
1729 if (ret < 0) {
1730 GST_ERROR_OBJECT(self, "Error while writting to socket: %s",
1731 strerror(errno));
1732 return GST_FLOW_ERROR;
1733 }
1734
1735 return GST_FLOW_OK;
1736 }
1737
gst_avdtp_sink_unlock(GstBaseSink * basesink)1738 static gboolean gst_avdtp_sink_unlock(GstBaseSink *basesink)
1739 {
1740 GstAvdtpSink *self = GST_AVDTP_SINK(basesink);
1741
1742 if (self->stream != NULL)
1743 g_io_channel_flush(self->stream, NULL);
1744
1745 return TRUE;
1746 }
1747
gst_avdtp_sink_buffer_alloc(GstBaseSink * basesink,guint64 offset,guint size,GstCaps * caps,GstBuffer ** buf)1748 static GstFlowReturn gst_avdtp_sink_buffer_alloc(GstBaseSink *basesink,
1749 guint64 offset, guint size, GstCaps *caps,
1750 GstBuffer **buf)
1751 {
1752 GstAvdtpSink *self = GST_AVDTP_SINK(basesink);
1753
1754 *buf = gst_buffer_new_and_alloc(size);
1755 if (!(*buf)) {
1756 GST_ERROR_OBJECT(self, "buffer allocation failed");
1757 return GST_FLOW_ERROR;
1758 }
1759
1760 gst_buffer_set_caps(*buf, caps);
1761
1762 GST_BUFFER_OFFSET(*buf) = offset;
1763
1764 return GST_FLOW_OK;
1765 }
1766
gst_avdtp_sink_class_init(GstAvdtpSinkClass * klass)1767 static void gst_avdtp_sink_class_init(GstAvdtpSinkClass *klass)
1768 {
1769 GObjectClass *object_class = G_OBJECT_CLASS(klass);
1770 GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS(klass);
1771
1772 parent_class = g_type_class_peek_parent(klass);
1773
1774 object_class->finalize = GST_DEBUG_FUNCPTR(
1775 gst_avdtp_sink_finalize);
1776 object_class->set_property = GST_DEBUG_FUNCPTR(
1777 gst_avdtp_sink_set_property);
1778 object_class->get_property = GST_DEBUG_FUNCPTR(
1779 gst_avdtp_sink_get_property);
1780
1781 basesink_class->start = GST_DEBUG_FUNCPTR(gst_avdtp_sink_start);
1782 basesink_class->stop = GST_DEBUG_FUNCPTR(gst_avdtp_sink_stop);
1783 basesink_class->render = GST_DEBUG_FUNCPTR(
1784 gst_avdtp_sink_render);
1785 basesink_class->preroll = GST_DEBUG_FUNCPTR(
1786 gst_avdtp_sink_preroll);
1787 basesink_class->unlock = GST_DEBUG_FUNCPTR(
1788 gst_avdtp_sink_unlock);
1789 basesink_class->event = GST_DEBUG_FUNCPTR(
1790 gst_avdtp_sink_event);
1791
1792 basesink_class->buffer_alloc =
1793 GST_DEBUG_FUNCPTR(gst_avdtp_sink_buffer_alloc);
1794
1795 g_object_class_install_property(object_class, PROP_DEVICE,
1796 g_param_spec_string("device", "Device",
1797 "Bluetooth remote device address",
1798 NULL, G_PARAM_READWRITE));
1799
1800 g_object_class_install_property(object_class, PROP_AUTOCONNECT,
1801 g_param_spec_boolean("auto-connect",
1802 "Auto-connect",
1803 "Automatically attempt to connect "
1804 "to device", DEFAULT_AUTOCONNECT,
1805 G_PARAM_READWRITE));
1806
1807 g_object_class_install_property(object_class, PROP_TRANSPORT,
1808 g_param_spec_string("transport",
1809 "Transport",
1810 "Use configured transport",
1811 NULL, G_PARAM_READWRITE));
1812
1813 GST_DEBUG_CATEGORY_INIT(avdtp_sink_debug, "avdtpsink", 0,
1814 "A2DP headset sink element");
1815 }
1816
gst_avdtp_sink_init(GstAvdtpSink * self,GstAvdtpSinkClass * klass)1817 static void gst_avdtp_sink_init(GstAvdtpSink *self,
1818 GstAvdtpSinkClass *klass)
1819 {
1820 self->device = NULL;
1821 self->transport = NULL;
1822 self->data = NULL;
1823
1824 self->stream = NULL;
1825
1826 self->dev_caps = NULL;
1827
1828 self->autoconnect = DEFAULT_AUTOCONNECT;
1829
1830 self->sink_lock = g_mutex_new();
1831
1832 /* FIXME this is for not synchronizing with clock, should be tested
1833 * with devices to see the behaviour
1834 gst_base_sink_set_sync(GST_BASE_SINK(self), FALSE);
1835 */
1836 }
1837
gst_avdtp_sink_audioservice_send(GstAvdtpSink * self,const bt_audio_msg_header_t * msg)1838 static int gst_avdtp_sink_audioservice_send(GstAvdtpSink *self,
1839 const bt_audio_msg_header_t *msg)
1840 {
1841 ssize_t written;
1842 const char *type, *name;
1843 uint16_t length;
1844 int fd;
1845
1846 length = msg->length ? msg->length : BT_SUGGESTED_BUFFER_SIZE;
1847
1848 fd = g_io_channel_unix_get_fd(self->server);
1849
1850 written = write(fd, msg, length);
1851 if (written < 0) {
1852 GST_ERROR_OBJECT(self, "Error sending data to audio service:"
1853 " %s", strerror(errno));
1854 return -errno;
1855 }
1856
1857 type = bt_audio_strtype(msg->type);
1858 name = bt_audio_strname(msg->name);
1859
1860 GST_DEBUG_OBJECT(self, "sent: %s -> %s", type, name);
1861
1862 return 0;
1863 }
1864
gst_avdtp_sink_audioservice_recv(GstAvdtpSink * self,bt_audio_msg_header_t * inmsg)1865 static int gst_avdtp_sink_audioservice_recv(GstAvdtpSink *self,
1866 bt_audio_msg_header_t *inmsg)
1867 {
1868 ssize_t bytes_read;
1869 const char *type, *name;
1870 uint16_t length;
1871 int fd, err = 0;
1872
1873 length = inmsg->length ? inmsg->length : BT_SUGGESTED_BUFFER_SIZE;
1874
1875 fd = g_io_channel_unix_get_fd(self->server);
1876
1877 bytes_read = read(fd, inmsg, length);
1878 if (bytes_read < 0) {
1879 GST_ERROR_OBJECT(self, "Error receiving data from "
1880 "audio service: %s", strerror(errno));
1881 return -errno;
1882 }
1883
1884 type = bt_audio_strtype(inmsg->type);
1885 if (!type) {
1886 err = -EINVAL;
1887 GST_ERROR_OBJECT(self, "Bogus message type %d "
1888 "received from audio service",
1889 inmsg->type);
1890 }
1891
1892 name = bt_audio_strname(inmsg->name);
1893 if (!name) {
1894 err = -EINVAL;
1895 GST_ERROR_OBJECT(self, "Bogus message name %d "
1896 "received from audio service",
1897 inmsg->name);
1898 }
1899
1900 if (inmsg->type == BT_ERROR) {
1901 bt_audio_error_t *msg = (void *) inmsg;
1902 err = -EINVAL;
1903 GST_ERROR_OBJECT(self, "%s failed : "
1904 "%s(%d)",
1905 name,
1906 strerror(msg->posix_errno),
1907 msg->posix_errno);
1908 }
1909
1910 GST_DEBUG_OBJECT(self, "received: %s <- %s", type, name);
1911
1912 return err;
1913 }
1914
gst_avdtp_sink_audioservice_expect(GstAvdtpSink * self,bt_audio_msg_header_t * outmsg,guint8 expected_name)1915 static int gst_avdtp_sink_audioservice_expect(GstAvdtpSink *self,
1916 bt_audio_msg_header_t *outmsg,
1917 guint8 expected_name)
1918 {
1919 int err;
1920
1921 err = gst_avdtp_sink_audioservice_recv(self, outmsg);
1922 if (err < 0)
1923 return err;
1924
1925 if (outmsg->name != expected_name)
1926 return -EINVAL;
1927
1928 return 0;
1929 }
1930
gst_avdtp_sink_plugin_init(GstPlugin * plugin)1931 gboolean gst_avdtp_sink_plugin_init(GstPlugin *plugin)
1932 {
1933 return gst_element_register(plugin, "avdtpsink", GST_RANK_NONE,
1934 GST_TYPE_AVDTP_SINK);
1935 }
1936
1937
1938 /* public functions */
gst_avdtp_sink_get_device_caps(GstAvdtpSink * sink)1939 GstCaps *gst_avdtp_sink_get_device_caps(GstAvdtpSink *sink)
1940 {
1941 if (sink->dev_caps == NULL)
1942 return NULL;
1943
1944 return gst_caps_copy(sink->dev_caps);
1945 }
1946
gst_avdtp_sink_set_device_caps(GstAvdtpSink * self,GstCaps * caps)1947 gboolean gst_avdtp_sink_set_device_caps(GstAvdtpSink *self,
1948 GstCaps *caps)
1949 {
1950 gboolean ret;
1951
1952 GST_DEBUG_OBJECT(self, "setting device caps");
1953 GST_AVDTP_SINK_MUTEX_LOCK(self);
1954 ret = gst_avdtp_sink_configure(self, caps);
1955
1956 if (self->stream_caps)
1957 gst_caps_unref(self->stream_caps);
1958 self->stream_caps = gst_caps_ref(caps);
1959
1960 GST_AVDTP_SINK_MUTEX_UNLOCK(self);
1961
1962 return ret;
1963 }
1964
gst_avdtp_sink_get_link_mtu(GstAvdtpSink * sink)1965 guint gst_avdtp_sink_get_link_mtu(GstAvdtpSink *sink)
1966 {
1967 return sink->data->link_mtu;
1968 }
1969
gst_avdtp_sink_set_device(GstAvdtpSink * self,const gchar * dev)1970 void gst_avdtp_sink_set_device(GstAvdtpSink *self, const gchar *dev)
1971 {
1972 if (self->device != NULL)
1973 g_free(self->device);
1974
1975 GST_LOG_OBJECT(self, "Setting device: %s", dev);
1976 self->device = g_strdup(dev);
1977 }
1978
gst_avdtp_sink_set_transport(GstAvdtpSink * self,const gchar * trans)1979 void gst_avdtp_sink_set_transport(GstAvdtpSink *self, const gchar *trans)
1980 {
1981 if (self->transport != NULL)
1982 g_free(self->transport);
1983
1984 GST_LOG_OBJECT(self, "Setting transport: %s", trans);
1985 self->transport = g_strdup(trans);
1986 }
1987
gst_avdtp_sink_get_device(GstAvdtpSink * self)1988 gchar *gst_avdtp_sink_get_device(GstAvdtpSink *self)
1989 {
1990 return g_strdup(self->device);
1991 }
1992
gst_avdtp_sink_get_transport(GstAvdtpSink * self)1993 gchar *gst_avdtp_sink_get_transport(GstAvdtpSink *self)
1994 {
1995 return g_strdup(self->transport);
1996 }
1997
gst_avdtp_sink_set_crc(GstAvdtpSink * self,gboolean crc)1998 void gst_avdtp_sink_set_crc(GstAvdtpSink *self, gboolean crc)
1999 {
2000 gint new_crc;
2001
2002 new_crc = crc ? CRC_PROTECTED : CRC_UNPROTECTED;
2003
2004 /* test if we already received a different crc */
2005 if (self->mp3_using_crc != -1 && new_crc != self->mp3_using_crc) {
2006 GST_WARNING_OBJECT(self, "crc changed during stream");
2007 return;
2008 }
2009 self->mp3_using_crc = new_crc;
2010
2011 }
2012
gst_avdtp_sink_set_channel_mode(GstAvdtpSink * self,const gchar * mode)2013 void gst_avdtp_sink_set_channel_mode(GstAvdtpSink *self,
2014 const gchar *mode)
2015 {
2016 gint new_mode;
2017
2018 new_mode = gst_avdtp_sink_get_channel_mode(mode);
2019
2020 if (self->channel_mode != -1 && new_mode != self->channel_mode) {
2021 GST_WARNING_OBJECT(self, "channel mode changed during stream");
2022 return;
2023 }
2024
2025 self->channel_mode = new_mode;
2026 if (self->channel_mode == -1)
2027 GST_WARNING_OBJECT(self, "Received invalid channel "
2028 "mode: %s", mode);
2029 }
2030