#include <gst/rtp/gstrtpbuffer.h>
+#include <dbus/dbus.h>
+
#include "ipc.h"
#include "rtp.h"
+#include "a2dp-codecs.h"
#include "gstpragma.h"
#include "gstavdtpsink.h"
g_mutex_unlock(s->sink_lock); \
} G_STMT_END
+#ifndef DBUS_TYPE_UNIX_FD
+#define DBUS_TYPE_UNIX_FD -1
+#endif
struct bluetooth_data
{
struct bt_get_capabilities_rsp *caps; /* Bluetooth device caps */
guint link_mtu;
+ DBusConnection *conn;
+ guint8 codec; /* Bluetooth transport configuration */
+ gchar *uuid;
+ guint8 *config;
+ gint config_size;
+
gchar buffer[BUFFER_SIZE]; /* Codec transfer buffer */
};
{
PROP_0,
PROP_DEVICE,
- PROP_AUTOCONNECT
+ PROP_AUTOCONNECT,
+ PROP_TRANSPORT
};
GST_BOILERPLATE (GstAvdtpSink, gst_avdtp_sink, GstBaseSink, GST_TYPE_BASE_SINK);
gst_element_class_set_details (element_class, &avdtp_sink_details);
}
+static void
+gst_avdtp_sink_transport_release (GstAvdtpSink * self)
+{
+ DBusMessage *msg;
+ const char *access_type = "w";
+
+ msg = dbus_message_new_method_call ("org.bluez", self->transport,
+ "org.bluez.MediaTransport", "Release");
+
+ dbus_message_append_args (msg, DBUS_TYPE_STRING, &access_type,
+ DBUS_TYPE_INVALID);
+
+ dbus_connection_send (self->data->conn, msg, NULL);
+
+ dbus_message_unref (msg);
+}
+
static gboolean
gst_avdtp_sink_stop (GstBaseSink * basesink)
{
}
if (self->data) {
+ if (self->transport)
+ gst_avdtp_sink_transport_release (self);
+ if (self->data->conn)
+ dbus_connection_unref (self->data->conn);
g_free (self->data);
self->data = NULL;
}
if (self->device)
g_free (self->device);
+ if (self->transport)
+ g_free (self->transport);
+
g_mutex_free (self->sink_lock);
G_OBJECT_CLASS (parent_class)->finalize (object);
case PROP_AUTOCONNECT:
sink->autoconnect = g_value_get_boolean (value);
break;
+
+ case PROP_TRANSPORT:
+ if (sink->transport)
+ g_free (sink->transport);
+ sink->transport = g_value_dup_string (value);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
case PROP_AUTOCONNECT:
g_value_set_boolean (value, sink->autoconnect);
break;
+
+ case PROP_TRANSPORT:
+ g_value_set_string (value, sink->transport);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
GIOFlags flags;
gsize read;
+ /* Proceed if stream was already acquired */
+ if (self->stream != NULL)
+ goto proceed;
+
ret = gst_avdtp_sink_bluetooth_recvmsg_fd (self);
if (ret < 0)
return FALSE;
return FALSE;
}
+proceed:
/* set stream socket to nonblock */
GST_LOG_OBJECT (self, "setting stream socket to nonblock");
flags = g_io_channel_get_flags (self->stream);
return structure;
}
+static GstStructure *
+gst_avdtp_sink_parse_sbc_raw (GstAvdtpSink * self)
+{
+ a2dp_sbc_t *sbc = (a2dp_sbc_t *) self->data->config;
+ GstStructure *structure;
+ GValue *value;
+ GValue *list;
+ gboolean mono, stereo;
+
+ structure = gst_structure_empty_new ("audio/x-sbc");
+ value = g_value_init (g_new0 (GValue, 1), G_TYPE_STRING);
+
+ /* mode */
+ list = g_value_init (g_new0 (GValue, 1), GST_TYPE_LIST);
+ if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
+ g_value_set_static_string (value, "mono");
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) {
+ g_value_set_static_string (value, "stereo");
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) {
+ g_value_set_static_string (value, "dual");
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO) {
+ g_value_set_static_string (value, "joint");
+ gst_value_list_prepend_value (list, value);
+ }
+ g_value_unset (value);
+ if (list) {
+ gst_structure_set_value (structure, "mode", list);
+ g_free (list);
+ list = NULL;
+ }
+
+ /* subbands */
+ list = g_value_init (g_new0 (GValue, 1), GST_TYPE_LIST);
+ value = g_value_init (value, G_TYPE_INT);
+ if (sbc->subbands & BT_A2DP_SUBBANDS_4) {
+ g_value_set_int (value, 4);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->subbands & BT_A2DP_SUBBANDS_8) {
+ g_value_set_int (value, 8);
+ gst_value_list_prepend_value (list, value);
+ }
+ g_value_unset (value);
+ if (list) {
+ gst_structure_set_value (structure, "subbands", list);
+ g_free (list);
+ list = NULL;
+ }
+
+ /* blocks */
+ value = g_value_init (value, G_TYPE_INT);
+ list = g_value_init (g_new0 (GValue, 1), GST_TYPE_LIST);
+ if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_16) {
+ g_value_set_int (value, 16);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_12) {
+ g_value_set_int (value, 12);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_8) {
+ g_value_set_int (value, 8);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_4) {
+ g_value_set_int (value, 4);
+ gst_value_list_prepend_value (list, value);
+ }
+ g_value_unset (value);
+ if (list) {
+ gst_structure_set_value (structure, "blocks", list);
+ g_free (list);
+ list = NULL;
+ }
+
+ /* allocation */
+ g_value_init (value, G_TYPE_STRING);
+ list = g_value_init (g_new0 (GValue, 1), GST_TYPE_LIST);
+ if (sbc->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS) {
+ g_value_set_static_string (value, "loudness");
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->allocation_method & BT_A2DP_ALLOCATION_SNR) {
+ g_value_set_static_string (value, "snr");
+ gst_value_list_prepend_value (list, value);
+ }
+ g_value_unset (value);
+ if (list) {
+ gst_structure_set_value (structure, "allocation", list);
+ g_free (list);
+ list = NULL;
+ }
+
+ /* rate */
+ g_value_init (value, G_TYPE_INT);
+ list = g_value_init (g_new0 (GValue, 1), GST_TYPE_LIST);
+ if (sbc->frequency & BT_SBC_SAMPLING_FREQ_48000) {
+ g_value_set_int (value, 48000);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->frequency & BT_SBC_SAMPLING_FREQ_44100) {
+ g_value_set_int (value, 44100);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->frequency & BT_SBC_SAMPLING_FREQ_32000) {
+ g_value_set_int (value, 32000);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (sbc->frequency & BT_SBC_SAMPLING_FREQ_16000) {
+ g_value_set_int (value, 16000);
+ gst_value_list_prepend_value (list, value);
+ }
+ g_value_unset (value);
+ if (list) {
+ gst_structure_set_value (structure, "rate", list);
+ g_free (list);
+ list = NULL;
+ }
+
+ /* bitpool */
+ value = g_value_init (value, GST_TYPE_INT_RANGE);
+ gst_value_set_int_range (value,
+ MIN (sbc->min_bitpool, TEMPLATE_MAX_BITPOOL),
+ MIN (sbc->max_bitpool, TEMPLATE_MAX_BITPOOL));
+ gst_structure_set_value (structure, "bitpool", value);
+ g_value_unset (value);
+
+ /* channels */
+ mono = FALSE;
+ stereo = FALSE;
+ if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO)
+ mono = TRUE;
+ if ((sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) ||
+ (sbc->channel_mode &
+ BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) ||
+ (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO))
+ stereo = TRUE;
+
+ if (mono && stereo) {
+ g_value_init (value, GST_TYPE_INT_RANGE);
+ gst_value_set_int_range (value, 1, 2);
+ } else {
+ g_value_init (value, G_TYPE_INT);
+ if (mono)
+ g_value_set_int (value, 1);
+ else if (stereo)
+ g_value_set_int (value, 2);
+ else {
+ GST_ERROR_OBJECT (self, "Unexpected number of channels");
+ g_value_set_int (value, 0);
+ }
+ }
+
+ gst_structure_set_value (structure, "channels", value);
+ g_free (value);
+
+ return structure;
+}
+
+static GstStructure *
+gst_avdtp_sink_parse_mpeg_raw (GstAvdtpSink * self)
+{
+ a2dp_mpeg_t *mpeg = (a2dp_mpeg_t *) self->data->config;
+ GstStructure *structure;
+ GValue *value;
+ GValue *list;
+ gboolean valid_layer = FALSE;
+ gboolean mono, stereo;
+
+ GST_LOG_OBJECT (self, "parsing mpeg caps");
+
+ structure = gst_structure_empty_new ("audio/mpeg");
+ value = g_new0 (GValue, 1);
+ g_value_init (value, G_TYPE_INT);
+
+ list = g_value_init (g_new0 (GValue, 1), GST_TYPE_LIST);
+ g_value_set_int (value, 1);
+ gst_value_list_prepend_value (list, value);
+ g_value_set_int (value, 2);
+ gst_value_list_prepend_value (list, value);
+ gst_structure_set_value (structure, "mpegversion", list);
+ g_free (list);
+
+ /* layer */
+ GST_LOG_OBJECT (self, "setting mpeg layer");
+ list = g_value_init (g_new0 (GValue, 1), GST_TYPE_LIST);
+ if (mpeg->layer & BT_MPEG_LAYER_1) {
+ g_value_set_int (value, 1);
+ gst_value_list_prepend_value (list, value);
+ valid_layer = TRUE;
+ }
+ if (mpeg->layer & BT_MPEG_LAYER_2) {
+ g_value_set_int (value, 2);
+ gst_value_list_prepend_value (list, value);
+ valid_layer = TRUE;
+ }
+ if (mpeg->layer & BT_MPEG_LAYER_3) {
+ g_value_set_int (value, 3);
+ gst_value_list_prepend_value (list, value);
+ valid_layer = TRUE;
+ }
+ if (list) {
+ gst_structure_set_value (structure, "layer", list);
+ g_free (list);
+ list = NULL;
+ }
+
+ if (!valid_layer) {
+ gst_structure_free (structure);
+ g_free (value);
+ return NULL;
+ }
+
+ /* rate */
+ GST_LOG_OBJECT (self, "setting mpeg rate");
+ list = g_value_init (g_new0 (GValue, 1), GST_TYPE_LIST);
+ if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_48000) {
+ g_value_set_int (value, 48000);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_44100) {
+ g_value_set_int (value, 44100);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_32000) {
+ g_value_set_int (value, 32000);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_24000) {
+ g_value_set_int (value, 24000);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_22050) {
+ g_value_set_int (value, 22050);
+ gst_value_list_prepend_value (list, value);
+ }
+ if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_16000) {
+ g_value_set_int (value, 16000);
+ gst_value_list_prepend_value (list, value);
+ }
+ g_value_unset (value);
+ if (list) {
+ gst_structure_set_value (structure, "rate", list);
+ g_free (list);
+ list = NULL;
+ }
+
+ /* channels */
+ GST_LOG_OBJECT (self, "setting mpeg channels");
+ mono = FALSE;
+ stereo = FALSE;
+ if (mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_MONO)
+ mono = TRUE;
+ if ((mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) ||
+ (mpeg->channel_mode &
+ BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) ||
+ (mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO))
+ stereo = TRUE;
+
+ if (mono && stereo) {
+ g_value_init (value, GST_TYPE_INT_RANGE);
+ gst_value_set_int_range (value, 1, 2);
+ } else {
+ g_value_init (value, G_TYPE_INT);
+ if (mono)
+ g_value_set_int (value, 1);
+ else if (stereo)
+ g_value_set_int (value, 2);
+ else {
+ GST_ERROR_OBJECT (self, "Unexpected number of channels");
+ g_value_set_int (value, 0);
+ }
+ }
+ gst_structure_set_value (structure, "channels", value);
+ g_free (value);
+
+ return structure;
+}
+
+static gboolean
+gst_avdtp_sink_update_config (GstAvdtpSink * self)
+{
+ GstStructure *structure;
+ gchar *tmp;
+
+ switch (self->data->codec) {
+ case A2DP_CODEC_SBC:
+ structure = gst_avdtp_sink_parse_sbc_raw (self);
+ break;
+ case A2DP_CODEC_MPEG12:
+ structure = gst_avdtp_sink_parse_mpeg_raw (self);
+ break;
+ default:
+ GST_ERROR_OBJECT (self, "Unsupported configuration");
+ return FALSE;
+ }
+
+ if (structure == NULL)
+ return FALSE;
+
+ if (self->dev_caps != NULL)
+ gst_caps_unref (self->dev_caps);
+
+ self->dev_caps = gst_caps_new_full (structure, NULL);
+
+ tmp = gst_caps_to_string (self->dev_caps);
+ GST_DEBUG_OBJECT (self, "Transport configuration: %s", tmp);
+ g_free (tmp);
+
+ return TRUE;
+}
+
static gboolean
gst_avdtp_sink_update_caps (GstAvdtpSink * self)
{
GST_LOG_OBJECT (self, "updating device caps");
+ if (self->data->config_size != 0 && self->data->config != NULL)
+ return gst_avdtp_sink_update_config (self);
+
sbc = (void *) gst_avdtp_find_caps (self, BT_A2DP_SBC_SINK);
mpeg = (void *) gst_avdtp_find_caps (self, BT_A2DP_MPEG12_SINK);
}
static gboolean
+gst_avdtp_sink_transport_parse_property (GstAvdtpSink * self,
+ DBusMessageIter * i)
+{
+ const char *key;
+ DBusMessageIter variant_i;
+
+ if (dbus_message_iter_get_arg_type (i) != DBUS_TYPE_STRING) {
+ GST_ERROR_OBJECT (self, "Property name not a string.");
+ return FALSE;
+ }
+
+ dbus_message_iter_get_basic (i, &key);
+
+ if (!dbus_message_iter_next (i)) {
+ GST_ERROR_OBJECT (self, "Property value missing");
+ return FALSE;
+ }
+
+ if (dbus_message_iter_get_arg_type (i) != DBUS_TYPE_VARIANT) {
+ GST_ERROR_OBJECT (self, "Property value not a variant.");
+ return FALSE;
+ }
+
+ dbus_message_iter_recurse (i, &variant_i);
+
+ switch (dbus_message_iter_get_arg_type (&variant_i)) {
+ case DBUS_TYPE_BYTE:{
+ uint8_t value;
+ dbus_message_iter_get_basic (&variant_i, &value);
+
+ if (g_str_equal (key, "Codec") == TRUE)
+ self->data->codec = value;
+
+ break;
+ }
+ case DBUS_TYPE_UINT16:{
+ uint16_t value;
+ dbus_message_iter_get_basic (&variant_i, &value);
+
+ if (g_str_equal (key, "OMTU") == TRUE)
+ self->data->link_mtu = value;
+
+ break;
+ }
+ case DBUS_TYPE_STRING:{
+ const char *value;
+ dbus_message_iter_get_basic (&variant_i, &value);
+
+ if (g_str_equal (key, "UUID") == TRUE) {
+ g_free (self->data->uuid);
+ self->data->uuid = g_strdup (value);
+ }
+
+ break;
+ }
+ case DBUS_TYPE_ARRAY:{
+ DBusMessageIter array_i;
+ char *value;
+ int size;
+
+ dbus_message_iter_recurse (&variant_i, &array_i);
+ dbus_message_iter_get_fixed_array (&array_i, &value, &size);
+
+ if (g_str_equal (key, "Configuration")) {
+ g_free (self->data->config);
+ self->data->config = g_new0 (guint8, size);
+ self->data->config_size = size;
+ memcpy (self->data->config, value, size);
+ }
+
+ break;
+ }
+ }
+
+ return TRUE;
+}
+
+static gboolean
+gst_avdtp_sink_transport_acquire (GstAvdtpSink * self)
+{
+ DBusMessage *msg, *reply;
+ DBusError err;
+ const char *access_type = "w";
+ int fd;
+
+ dbus_error_init (&err);
+
+ if (self->data->conn == NULL)
+ self->data->conn = dbus_bus_get (DBUS_BUS_SYSTEM, &err);
+
+ msg = dbus_message_new_method_call ("org.bluez", self->transport,
+ "org.bluez.MediaTransport", "Acquire");
+
+ dbus_message_append_args (msg, DBUS_TYPE_STRING, &access_type,
+ DBUS_TYPE_INVALID);
+
+ reply = dbus_connection_send_with_reply_and_block (self->data->conn,
+ msg, -1, &err);
+
+ if (dbus_error_is_set (&err))
+ goto fail;
+
+ if (dbus_message_get_args (reply, &err, DBUS_TYPE_UNIX_FD, &fd,
+ DBUS_TYPE_INVALID) == FALSE)
+ goto fail;
+
+ dbus_message_unref (reply);
+
+ self->stream = g_io_channel_unix_new (fd);
+ g_io_channel_set_close_on_unref (self->stream, TRUE);
+ GST_DEBUG_OBJECT (self, "stream_fd=%d", fd);
+
+ return TRUE;
+
+fail:
+ GST_ERROR_OBJECT (self, "Failed to acquire transport stream: %s",
+ err.message);
+
+ dbus_error_free (&err);
+
+ if (reply)
+ dbus_message_unref (msg);
+
+ return FALSE;
+}
+
+static gboolean
+gst_avdtp_sink_transport_get_properties (GstAvdtpSink * self)
+{
+ DBusMessage *msg, *reply;
+ DBusMessageIter arg_i, ele_i;
+ DBusError err;
+
+ dbus_error_init (&err);
+
+ /* Transport need to be acquire first to make sure the MTUs are
+ available */
+ if (gst_avdtp_sink_transport_acquire (self) == FALSE)
+ return FALSE;
+
+ msg = dbus_message_new_method_call ("org.bluez", self->transport,
+ "org.bluez.MediaTransport", "GetProperties");
+ reply = dbus_connection_send_with_reply_and_block (self->data->conn,
+ msg, -1, &err);
+
+ if (dbus_error_is_set (&err) || reply == NULL) {
+ GST_ERROR_OBJECT (self, "Failed to get transport properties: %s",
+ err.message);
+ goto fail;
+ }
+
+ if (!dbus_message_iter_init (reply, &arg_i)) {
+ GST_ERROR_OBJECT (self, "GetProperties reply has no arguments.");
+ goto fail;
+ }
+
+ if (dbus_message_iter_get_arg_type (&arg_i) != DBUS_TYPE_ARRAY) {
+ GST_ERROR_OBJECT (self, "GetProperties argument is not an array.");
+ goto fail;
+ }
+
+ dbus_message_iter_recurse (&arg_i, &ele_i);
+ while (dbus_message_iter_get_arg_type (&ele_i) != DBUS_TYPE_INVALID) {
+
+ if (dbus_message_iter_get_arg_type (&ele_i) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter dict_i;
+
+ dbus_message_iter_recurse (&ele_i, &dict_i);
+
+ gst_avdtp_sink_transport_parse_property (self, &dict_i);
+ }
+
+ if (!dbus_message_iter_next (&ele_i))
+ break;
+ }
+
+ return gst_avdtp_sink_update_caps (self);
+
+fail:
+ dbus_message_unref (msg);
+ dbus_message_unref (reply);
+ return FALSE;
+
+}
+
+static gboolean
gst_avdtp_sink_start (GstBaseSink * basesink)
{
GstAvdtpSink *self = GST_AVDTP_SINK (basesink);
GST_INFO_OBJECT (self, "start");
+ self->data = g_new0 (struct bluetooth_data, 1);
+
+ self->stream = NULL;
+ self->stream_caps = NULL;
+ self->mp3_using_crc = -1;
+ self->channel_mode = -1;
+
+ if (self->transport != NULL)
+ return gst_avdtp_sink_transport_get_properties (self);
+
self->watch_id = 0;
sk = bt_audio_service_open ();
self->watch_id = g_io_add_watch (self->server, G_IO_HUP | G_IO_ERR |
G_IO_NVAL, server_callback, self);
- self->data = g_new0 (struct bluetooth_data, 1);
-
- self->stream = NULL;
- self->stream_caps = NULL;
- self->mp3_using_crc = -1;
- self->channel_mode = -1;
-
if (!gst_avdtp_sink_get_capabilities (self)) {
GST_ERROR_OBJECT (self, "failed to get capabilities " "from device");
goto failed;
struct bt_new_stream_ind *ind = (void *) buf;
GIOError io_error;
+ if (self->transport != NULL)
+ return gst_avdtp_sink_conf_recv_stream_fd (self);
+
memset (req, 0, sizeof (buf));
req->h.type = BT_REQUEST;
req->h.name = BT_START_STREAM;
GST_DEBUG_OBJECT (self, "configuring device with caps: %s", temp);
g_free (temp);
+ /* Transport already configured */
+ if (self->transport != NULL)
+ return TRUE;
+
structure = gst_caps_get_structure (caps, 0);
if (gst_structure_has_name (structure, "audio/x-sbc"))
"Automatically attempt to connect "
"to device", DEFAULT_AUTOCONNECT, G_PARAM_READWRITE));
+ g_object_class_install_property (object_class, PROP_TRANSPORT,
+ g_param_spec_string ("transport",
+ "Transport", "Use configured transport", NULL, G_PARAM_READWRITE));
+
GST_DEBUG_CATEGORY_INIT (avdtp_sink_debug, "avdtpsink", 0,
"A2DP headset sink element");
}
gst_avdtp_sink_init (GstAvdtpSink * self, GstAvdtpSinkClass * klass)
{
self->device = NULL;
+ self->transport = NULL;
self->data = NULL;
self->stream = NULL;
self->device = g_strdup (dev);
}
+void
+gst_avdtp_sink_set_transport (GstAvdtpSink * self, const gchar * trans)
+{
+ if (self->transport != NULL)
+ g_free (self->transport);
+
+ GST_LOG_OBJECT (self, "Setting transport: %s", trans);
+ self->transport = g_strdup (trans);
+}
+
gchar *
gst_avdtp_sink_get_device (GstAvdtpSink * self)
{
return g_strdup (self->device);
}
+gchar *
+gst_avdtp_sink_get_transport (GstAvdtpSink * self)
+{
+ return g_strdup (self->transport);
+}
+
void
gst_avdtp_sink_set_crc (GstAvdtpSink * self, gboolean crc)
{
projects / platform / upstream / gstreamer.git / commitdiff