summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--audio/gsta2dpsink.c744
-rw-r--r--audio/gsta2dpsink.h28
-rw-r--r--audio/gstbluetooth.c2
-rw-r--r--audio/sink.c2
4 files changed, 703 insertions, 73 deletions
diff --git a/audio/gsta2dpsink.c b/audio/gsta2dpsink.c
index 8a6a44f1..0e8c8e02 100644
--- a/audio/gsta2dpsink.c
+++ b/audio/gsta2dpsink.c
@@ -28,22 +28,128 @@
#include <unistd.h>
#include <sys/un.h>
#include <sys/socket.h>
+#include <fcntl.h>
+#include <pthread.h>
+
+#include <netinet/in.h>
+
+#include <bluetooth/bluetooth.h>
#include "ipc.h"
+#include "sbc.h"
#include "gsta2dpsink.h"
GST_DEBUG_CATEGORY_STATIC(a2dp_sink_debug);
#define GST_CAT_DEFAULT a2dp_sink_debug
-#define DEFAULT_DEVICE "default"
+#define BUFFER_SIZE 2048
+
+#define GST_A2DP_SINK_MUTEX_LOCK(s) G_STMT_START { \
+ g_mutex_lock (s->sink_lock); \
+ } G_STMT_END
+
+#define GST_A2DP_SINK_MUTEX_UNLOCK(s) G_STMT_START { \
+ g_mutex_unlock (s->sink_lock); \
+ } G_STMT_END
+
+#define GST_A2DP_SINK_WAIT_CON_END(s) G_STMT_START { \
+ s->waiting_con_conf = TRUE; \
+ g_cond_wait (s->con_conf_end, s->sink_lock); \
+ s->waiting_con_conf = FALSE; \
+ } G_STMT_END
+
+#define GST_A2DP_SINK_CONFIGURATION_FAIL(s) G_STMT_START { \
+ s->con_state = NOT_CONFIGURED; \
+ g_cond_signal (s->con_conf_end); \
+ } G_STMT_END
+
+#define GST_A2DP_SINK_CONFIGURATION_SUCCESS(s) G_STMT_START { \
+ s->con_state = CONFIGURED; \
+ g_cond_signal (s->con_conf_end); \
+ } G_STMT_END
+
+struct bluetooth_a2dp {
+ sbc_t sbc; /* Codec data */
+ int codesize; /* SBC codesize */
+ int samples; /* Number of encoded samples */
+ uint8_t buffer[BUFFER_SIZE]; /* Codec transfer buffer */
+ int count; /* Codec transfer buffer counter */
+
+ int nsamples; /* Cumulative number of codec samples */
+ uint16_t seq_num; /* Cumulative packet sequence */
+ int frame_count; /* Current frames in buffer*/
+};
+struct bluetooth_data {
+ struct ipc_data_cfg cfg; /* Bluetooth device config */
+ uint8_t buffer[BUFFER_SIZE]; /* Encoded transfer buffer */
+ int count; /* Transfer buffer counter */
+ struct bluetooth_a2dp a2dp; /* A2DP data */
+};
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+struct rtp_header {
+ uint8_t cc:4;
+ uint8_t x:1;
+ uint8_t p:1;
+ uint8_t v:2;
+
+ uint8_t pt:7;
+ uint8_t m:1;
+
+ uint16_t sequence_number;
+ uint32_t timestamp;
+ uint32_t ssrc;
+ uint32_t csrc[0];
+} __attribute__ ((packed));
+
+struct rtp_payload {
+ uint8_t frame_count:4;
+ uint8_t rfa0:1;
+ uint8_t is_last_fragment:1;
+ uint8_t is_first_fragment:1;
+ uint8_t is_fragmented:1;
+} __attribute__ ((packed));
+
+#elif __BYTE_ORDER == __BIG_ENDIAN
+
+struct rtp_header {
+ uint8_t v:2;
+ uint8_t p:1;
+ uint8_t x:1;
+ uint8_t cc:4;
+
+ uint8_t m:1;
+ uint8_t pt:7;
+
+ uint16_t sequence_number;
+ uint32_t timestamp;
+ uint32_t ssrc;
+ uint32_t csrc[0];
+} __attribute__ ((packed));
+
+struct rtp_payload {
+ uint8_t is_fragmented:1;
+ uint8_t is_first_fragment:1;
+ uint8_t is_last_fragment:1;
+ uint8_t rfa0:1;
+ uint8_t frame_count:4;
+} __attribute__ ((packed));
+
+#else
+#error "Unknown byte order"
+#endif
+
+#define IS_SBC(n) (strcmp(n, "audio/x-sbc") == 0)
+#define IS_MPEG(n) (strcmp(n, "audio/mpeg") == 0)
enum {
PROP_0,
PROP_DEVICE,
};
-GST_BOILERPLATE(GstA2dpSink, gst_a2dp_sink, GstAudioSink, GST_TYPE_AUDIO_SINK);
+GST_BOILERPLATE(GstA2dpSink, gst_a2dp_sink, GstBaseSink, GST_TYPE_BASE_SINK);
static const GstElementDetails a2dp_sink_details =
GST_ELEMENT_DETAILS("Bluetooth A2DP sink",
@@ -60,7 +166,6 @@ static GstStaticPadTemplate a2dp_sink_factory =
"blocks = (int) { 4, 8, 12, 16 }, "
"subbands = (int) { 4, 8 }, "
"allocation = (string) { snr, loudness }; "
-
"audio/mpeg, "
"mpegversion = (int) 1, "
"layer = (int) [ 1, 3 ], "
@@ -77,13 +182,54 @@ static void gst_a2dp_sink_base_init(gpointer g_class)
gst_element_class_set_details(element_class, &a2dp_sink_details);
}
+static gboolean gst_a2dp_sink_stop(GstBaseSink *basesink)
+{
+ GstA2dpSink *self = GST_A2DP_SINK(basesink);
+ struct bluetooth_a2dp *a2dp = &self->data->a2dp;
+
+ self->con_state = NOT_CONFIGURED;
+ self->total = 0;
+
+ if (self->stream) {
+ g_io_channel_close(self->stream);
+ g_io_channel_unref(self->stream);
+ self->stream = NULL;
+ }
+
+ if (self->server) {
+ g_io_channel_close(self->server);
+ g_io_channel_unref(self->server);
+ self->stream = NULL;
+ }
+
+ if (self->data->cfg.codec == CFG_CODEC_SBC)
+ sbc_finish(&a2dp->sbc);
+
+ if (self->data) {
+ g_free(self->data);
+ self->data = NULL;
+ }
+
+ return TRUE;
+}
+
static void gst_a2dp_sink_finalize(GObject *object)
{
- GstA2dpSink *sink = GST_A2DP_SINK(object);
+ GstA2dpSink *self = GST_A2DP_SINK(object);
+
+ if (self->data)
+ gst_a2dp_sink_stop (GST_BASE_SINK (self));
+
+ if (self->device)
+ g_free(self->device);
- g_io_channel_close(sink->server);
+ /* unlock any thread waiting for this signal */
+ GST_A2DP_SINK_MUTEX_LOCK(self);
+ GST_A2DP_SINK_CONFIGURATION_FAIL(self);
+ GST_A2DP_SINK_MUTEX_UNLOCK(self);
- g_free(sink->device);
+ g_cond_free(self->con_conf_end);
+ g_mutex_free(self->sink_lock);
G_OBJECT_CLASS(parent_class)->finalize(object);
}
@@ -95,11 +241,9 @@ static void gst_a2dp_sink_set_property(GObject *object, guint prop_id,
switch (prop_id) {
case PROP_DEVICE:
- g_free(sink->device);
+ if (sink->device)
+ g_free(sink->device);
sink->device = g_value_dup_string(value);
-
- if (sink->device == NULL)
- sink->device = g_strdup(DEFAULT_DEVICE);
break;
default:
@@ -124,114 +268,580 @@ static void gst_a2dp_sink_get_property(GObject *object, guint prop_id,
}
}
-static gboolean gst_a2dp_sink_open(GstAudioSink *self)
+static gint gst_a2dp_sink_bluetooth_recvmsg_fd(GstA2dpSink *sink)
{
- GstA2dpSink *sink = GST_A2DP_SINK(self);
+ char cmsg_b[CMSG_SPACE(sizeof(int))], m;
+ int err, ret, stream_fd;
+ struct iovec iov = { &m, sizeof(m) };
+ struct msghdr msgh;
+ struct cmsghdr *cmsg;
+
+ memset(&msgh, 0, sizeof(msgh));
+ msgh.msg_iov = &iov;
+ msgh.msg_iovlen = 1;
+ msgh.msg_control = &cmsg_b;
+ msgh.msg_controllen = CMSG_LEN(sizeof(int));
+
+ ret = recvmsg(g_io_channel_unix_get_fd(sink->server), &msgh, 0);
+ if (ret < 0) {
+ err = errno;
+ GST_ERROR_OBJECT(sink, "Unable to receive fd: %s (%d)",
+ strerror(err), err);
+ return -err;
+ }
- printf("device %s\n", sink->device);
- printf("open\n");
+ /* Receive auxiliary data in msgh */
+ for (cmsg = CMSG_FIRSTHDR(&msgh); cmsg != NULL;
+ cmsg = CMSG_NXTHDR(&msgh, cmsg)) {
+ if (cmsg->cmsg_level == SOL_SOCKET
+ && cmsg->cmsg_type == SCM_RIGHTS) {
+ stream_fd = (*(int *) CMSG_DATA(cmsg));
+ sink->stream = g_io_channel_unix_new(stream_fd);
+ GST_DEBUG_OBJECT(sink, "stream_fd=%d", stream_fd);
+ return 0;
+ }
+ }
- return TRUE;
+ return -EINVAL;
}
-static gboolean gst_a2dp_sink_prepare(GstAudioSink *self,
- GstRingBufferSpec *spec)
+static int gst_a2dp_sink_bluetooth_a2dp_init(GstA2dpSink *sink,
+ struct ipc_codec_sbc *sbc)
{
- printf("perpare\n");
- printf("rate %d\n", spec->rate);
- printf("channels %d\n", spec->channels);
+ struct bluetooth_a2dp *a2dp = &sink->data->a2dp;
+ struct ipc_data_cfg *cfg = &sink->data->cfg;
- return TRUE;
+ if (cfg == NULL) {
+ GST_ERROR_OBJECT(sink, "Error getting codec parameters");
+ return -1;
+ }
+
+ if (cfg->codec != CFG_CODEC_SBC)
+ return -1;
+
+ /* FIXME: init using flags? */
+ sbc_init(&a2dp->sbc, 0);
+ a2dp->sbc.rate = cfg->rate;
+ a2dp->sbc.channels = cfg->mode == CFG_MODE_MONO ? 1 : 2;
+ if (cfg->mode == CFG_MODE_MONO || cfg->mode == CFG_MODE_JOINT_STEREO)
+ a2dp->sbc.joint = 1;
+ a2dp->sbc.allocation = sbc->allocation;
+ a2dp->sbc.subbands = sbc->subbands;
+ a2dp->sbc.blocks = sbc->blocks;
+ a2dp->sbc.bitpool = sbc->bitpool;
+ a2dp->codesize = a2dp->sbc.subbands * a2dp->sbc.blocks *
+ a2dp->sbc.channels * 2;
+ a2dp->count = sizeof(struct rtp_header) + sizeof(struct rtp_payload);
+
+ GST_DEBUG_OBJECT(sink, "Codec parameters: \
+ \tallocation=%u\n\tsubbands=%u\n \
+ \tblocks=%u\n\tbitpool=%u\n",
+ a2dp->sbc.allocation, a2dp->sbc.subbands,
+ a2dp->sbc.blocks, a2dp->sbc.bitpool);
+
+ return 0;
}
-static gboolean gst_a2dp_sink_unprepare(GstAudioSink *self)
+static gboolean gst_a2dp_sink_init_pkt_conf(GstA2dpSink *sink,
+ GstCaps *caps,
+ struct ipc_packet *pkt)
{
- printf("unprepare\n");
+
+ struct ipc_data_cfg *cfg = (void *) pkt->data;
+ struct ipc_codec_sbc *sbc = (void *) cfg->data;
+ const GValue *value = NULL;
+ const char *pref, *name;
+ GstStructure *structure = gst_caps_get_structure(caps,0);
+
+ name = gst_structure_get_name(structure);
+ /* FIXME only sbc supported here, should suport mp3 */
+ if (!(IS_SBC(name))) {
+ GST_ERROR_OBJECT(sink, "Unsupported format %s", name);
+ return FALSE;
+ }
+
+ if (sink->device)
+ strncpy(pkt->device, sink->device, 18);
+
+ pkt->role = PKT_ROLE_HIFI;
+
+ value = gst_structure_get_value(structure, "rate");
+ cfg->rate = g_value_get_int(value);
+
+ value = gst_structure_get_value(structure, "mode");
+ pref = g_value_get_string(value);
+ if (strcmp(pref, "auto") == 0)
+ cfg->mode = CFG_MODE_AUTO;
+ else if (strcmp(pref, "mono") == 0)
+ cfg->mode = CFG_MODE_MONO;
+ else if (strcmp(pref, "dual") == 0)
+ cfg->mode = CFG_MODE_DUAL_CHANNEL;
+ else if (strcmp(pref, "stereo") == 0)
+ cfg->mode = CFG_MODE_STEREO;
+ else if (strcmp(pref, "joint") == 0)
+ cfg->mode = CFG_MODE_JOINT_STEREO;
+ else {
+ GST_ERROR_OBJECT(sink, "Invalid mode %s", pref);
+ return FALSE;
+ }
+
+ value = gst_structure_get_value(structure, "allocation");
+ pref = g_value_get_string(value);
+ if (strcmp(pref, "auto") == 0)
+ sbc->allocation = CFG_ALLOCATION_AUTO;
+ else if (strcmp(pref, "loudness") == 0)
+ sbc->allocation = CFG_ALLOCATION_LOUDNESS;
+ else if (strcmp(pref, "snr") == 0)
+ sbc->allocation = CFG_ALLOCATION_SNR;
+ else {
+ GST_ERROR_OBJECT(sink, "Invalid allocation: %s", pref);
+ return FALSE;
+ }
+
+ value = gst_structure_get_value(structure, "subbands");
+ sbc->subbands = g_value_get_int(value);
+
+ value = gst_structure_get_value(structure, "blocks");
+ sbc->blocks = g_value_get_int(value);
+/* FIXME how can I obtain the bitpool ?
+ if (strcmp(id, "bitpool") == 0) {
+ if (snd_config_get_string(n, &bitpool) < 0) {
+ SNDERR("Invalid type for %s", id);
+ return -EINVAL;
+ }
+
+ sbc->bitpool = atoi(bitpool);
+ continue;
+ }
+
+ SNDERR("Unknown field %s", id);
+ return -EINVAL;
+ }
+*/
+ sbc->bitpool = 32;
+
+ pkt->length = sizeof(*cfg) + sizeof(*sbc);
+ pkt->type = PKT_TYPE_CFG_REQ;
+ pkt->error = PKT_ERROR_NONE;
return TRUE;
+
}
-static gboolean gst_a2dp_sink_close(GstAudioSink *self)
+static gboolean gst_a2dp_sink_conf_resp(GstA2dpSink *sink)
{
- printf("close\n");
+ gchar buf[IPC_MTU];
+ GIOError io_error;
+ guint ret;
+ struct ipc_packet *pkt = (void *) buf;
+ struct ipc_data_cfg *cfg = (void *) pkt->data;
+
+ memset(buf, 0, sizeof(buf));
+
+ io_error = g_io_channel_read(sink->server, (gchar*)buf,
+ sizeof(*pkt) + sizeof(*cfg), &ret);
+ if (io_error != G_IO_ERROR_NONE && ret > 0) {
+ GST_ERROR_OBJECT(sink, "Error ocurred while receiving \
+ configurarion packet answer");
+ return FALSE;
+ }
+
+ sink->total = ret;
+ if (pkt->type != PKT_TYPE_CFG_RSP) {
+ GST_ERROR_OBJECT(sink, "Unexpected packet type %d \
+ received", pkt->type);
+ return FALSE;
+ }
+
+ if (pkt->error != PKT_ERROR_NONE) {
+ GST_ERROR_OBJECT(sink, "Error %d while configuring \
+ device", pkt->error);
+ return FALSE;
+ }
+
+ if (cfg->codec != CFG_CODEC_SBC) {
+ GST_ERROR_OBJECT(sink, "Unsupported format");
+ return FALSE;
+ }
return TRUE;
}
-static guint gst_a2dp_sink_write(GstAudioSink *self,
- gpointer data, guint length)
+static gboolean gst_a2dp_sink_conf_recv_dev_conf(GstA2dpSink *sink)
{
- return 0;
+ gchar buf[IPC_MTU];
+ GIOError io_error;
+ guint ret=0;
+ struct ipc_packet *pkt = (void *) buf;
+ struct ipc_data_cfg *cfg = (void *) pkt->data;
+ struct ipc_codec_sbc *sbc = (void *) cfg->data;
+
+ io_error = g_io_channel_read(sink->server, (gchar*) sbc,
+ sizeof(*sbc), &ret);
+ if (io_error != G_IO_ERROR_NONE) {
+ GST_ERROR_OBJECT(sink, "Error while reading data from socket \
+ %s (%d)", strerror(errno), errno);
+ return FALSE;
+ } else if (ret == 0) {
+ GST_ERROR_OBJECT(sink, "Read 0 bytes from socket");
+ return FALSE;
+ }
+
+ sink->total += ret;
+ GST_DEBUG_OBJECT(sink, "OK - %d bytes received", sink->total);
+
+ if (pkt->length != (sink->total - sizeof(struct ipc_packet))) {
+ GST_ERROR_OBJECT(sink, "Error while configuring device: \
+ packet size doesn't match");
+ return FALSE;
+ }
+
+ memcpy(&sink->data->cfg, cfg, sizeof(*cfg));
+
+ GST_DEBUG_OBJECT(sink, "Device configuration:\n\tchannel=%p\n\t\
+ fd_opt=%u\n\tpkt_len=%u\n\tsample_size=%u\n\trate=%u",
+ sink->stream, sink->data->cfg.fd_opt, \
+ sink->data->cfg.pkt_len, sink->data->cfg.sample_size, \
+ sink->data->cfg.rate);
+
+ if (sink->data->cfg.codec == CFG_CODEC_SBC) {
+ ret = gst_a2dp_sink_bluetooth_a2dp_init(sink, sbc);
+ if (ret < 0)
+ return FALSE;
+
+ }
+ return TRUE;
}
-static guint gst_a2dp_sink_delay(GstAudioSink *audiosink)
+static gboolean gst_a2dp_sink_conf_recv_stream_fd(GstA2dpSink *sink)
{
- printf("delay\n");
+ gint ret;
+ GIOError err;
+ gsize read;
+
+ ret = gst_a2dp_sink_bluetooth_recvmsg_fd(sink);
+ if (ret < 0)
+ return FALSE;
+
+ if (!sink->stream) {
+ GST_ERROR_OBJECT(sink, "Error while configuring device: \
+ could not acquire audio socket");
+ return FALSE;
+ }
- return 0;
+ /* It is possible there is some outstanding
+ data in the pipe - we have to empty it */
+ while (TRUE) {
+ err = g_io_channel_read(sink->stream,
+ (gchar *) sink->data->buffer,
+ (gsize) sink->data->cfg.pkt_len,
+ &read);
+ if (err != G_IO_ERROR_NONE || read <= 0)
+ break;
+ }
+
+ memset(sink->data->buffer, 0, sizeof(sink->data->buffer));
+
+ return TRUE;
}
-static void gst_a2dp_sink_reset(GstAudioSink *audiosink)
+static void gst_a2dp_sink_conf_recv_data(GstA2dpSink *sink)
{
- printf("reset\n");
+ /*
+ * We hold the lock, since we can send a signal.
+ * It is a good practice, according to the glib api.
+ */
+ GST_A2DP_SINK_MUTEX_LOCK(sink);
+
+ switch (sink->con_state) {
+ case CONFIGURING_SENT_CONF:
+ if (gst_a2dp_sink_conf_resp(sink))
+ sink->con_state = CONFIGURING_RCVD_CONF_RSP;
+ else
+ GST_A2DP_SINK_CONFIGURATION_FAIL(sink);
+ break;
+ case CONFIGURING_RCVD_CONF_RSP:
+ if (gst_a2dp_sink_conf_recv_dev_conf(sink))
+ sink->con_state = CONFIGURING_RCVD_DEV_CONF;
+ else
+ GST_A2DP_SINK_CONFIGURATION_FAIL(sink);
+ case CONFIGURING_RCVD_DEV_CONF:
+ if (gst_a2dp_sink_conf_recv_stream_fd(sink))
+ GST_A2DP_SINK_CONFIGURATION_SUCCESS(sink);
+ else
+ GST_A2DP_SINK_CONFIGURATION_FAIL(sink);
+ break;
+ }
+
+ GST_A2DP_SINK_MUTEX_UNLOCK(sink);
}
+
static gboolean server_callback(GIOChannel *chan,
GIOCondition cond, gpointer data)
{
- printf("callback\n");
+ GstA2dpSink *sink = GST_A2DP_SINK(data);
+
+ switch (cond) {
+ case G_IO_IN:
+ if (sink->con_state != NOT_CONFIGURED &&
+ sink->con_state != CONFIGURED)
+ gst_a2dp_sink_conf_recv_data(sink);
+ else
+ GST_WARNING_OBJECT(sink, "Unexpected data received");
+ break;
+ case G_IO_HUP:
+ return FALSE;
+ break;
+ case G_IO_ERR:
+ GST_WARNING_OBJECT(sink, "Untreated callback G_IO_ERR");
+ break;
+ case G_IO_NVAL:
+ return FALSE;
+ break;
+ default:
+ GST_WARNING_OBJECT(sink, "Unexpected callback call");
+ break;
+ }
return TRUE;
}
+static gboolean gst_a2dp_sink_start(GstBaseSink *basesink)
+{
+ GstA2dpSink *self = GST_A2DP_SINK(basesink);
+ struct sockaddr_un addr = { AF_UNIX, IPC_SOCKET_NAME };
+ gint sk;
+ gint err;
+
+ sk = socket(PF_LOCAL, SOCK_STREAM, 0);
+ if (sk < 0) {
+ err = errno;
+ GST_ERROR_OBJECT(self, "Cannot open socket: %s (%d)",
+ strerror(err), err);
+ return FALSE;
+ }
+
+ if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ err = errno;
+ GST_ERROR_OBJECT(self, "Connection fail %s (%d)",
+ strerror(err), err);
+ close(sk);
+ return FALSE;
+ }
+
+ self->server = g_io_channel_unix_new(sk);
+
+ g_io_add_watch(self->server, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ server_callback, self);
+
+ self->data = g_new0(struct bluetooth_data, 1);
+ memset(self->data, 0, sizeof(struct bluetooth_data));
+
+ return TRUE;
+}
+
+static gboolean gst_a2dp_sink_send_conf_pkt(GstA2dpSink *sink, GstCaps *caps)
+{
+ gchar buf[IPC_MTU];
+ struct ipc_packet *pkt = (void *) buf;
+ gboolean ret;
+ guint bytes_sent;
+ GIOError io_error;
+
+ g_assert(sink->con_state == NOT_CONFIGURED);
+
+ memset (pkt, 0, sizeof(buf));
+ ret = gst_a2dp_sink_init_pkt_conf(sink, caps, pkt);
+ if (!ret) {
+ GST_ERROR_OBJECT(sink, "Couldn't initialize parse caps \
+ to packet configuration");
+ return FALSE;
+ }
+
+ sink->con_state = CONFIGURING_INIT;
+
+ io_error = g_io_channel_write(sink->server, (gchar*)pkt,
+ sizeof(*pkt) + pkt->length, &bytes_sent);
+ if (io_error != G_IO_ERROR_NONE) {
+ GST_ERROR_OBJECT(sink, "Error ocurred while sending \
+ configurarion packet");
+ sink->con_state = NOT_CONFIGURED;
+ return FALSE;
+ }
+
+ GST_DEBUG_OBJECT(sink, "%d bytes sent", bytes_sent);
+ sink->con_state = CONFIGURING_SENT_CONF;
+
+ return TRUE;
+}
+
+static gboolean gst_a2dp_sink_start_dev_conf(GstA2dpSink *sink, GstCaps *caps)
+{
+ gboolean ret;
+
+ g_assert(sink->con_state == NOT_CONFIGURED);
+
+ GST_DEBUG_OBJECT(sink, "starting device configuration");
+
+ ret = gst_a2dp_sink_send_conf_pkt(sink, caps);
+
+ return ret;
+}
+
+static GstFlowReturn gst_a2dp_sink_preroll(GstBaseSink *basesink,
+ GstBuffer *buffer)
+{
+ GstA2dpSink *sink = GST_A2DP_SINK(basesink);
+
+ GST_A2DP_SINK_MUTEX_LOCK(sink);
+
+ if (sink->con_state == NOT_CONFIGURED)
+ gst_a2dp_sink_start_dev_conf(sink, GST_BUFFER_CAPS(buffer));
+
+ /* wait for the connection process to finish */
+ if (sink->con_state != CONFIGURED)
+ GST_A2DP_SINK_WAIT_CON_END(sink);
+
+ GST_A2DP_SINK_MUTEX_UNLOCK(sink);
+
+ if (sink->con_state != CONFIGURED)
+ return GST_FLOW_ERROR;
+
+ return GST_FLOW_OK;
+}
+
+static int gst_a2dp_sink_avdtp_write(GstA2dpSink *sink)
+{
+ int ret = 0;
+ struct bluetooth_data *data;
+ struct rtp_header *header;
+ struct rtp_payload *payload;
+ struct bluetooth_a2dp *a2dp;
+ GIOError err;
+
+ data = sink->data;
+ a2dp = &data->a2dp;
+
+ header = (void *) a2dp->buffer;
+ payload = (void *) (a2dp->buffer + sizeof(*header));
+
+ memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
+
+ payload->frame_count = a2dp->frame_count;
+ header->v = 2;
+ header->pt = 1;
+ header->sequence_number = htons(a2dp->seq_num);
+ header->timestamp = htonl(a2dp->nsamples);
+ header->ssrc = htonl(1);
+
+ while (TRUE) {
+ err = g_io_channel_write(sink->stream, (const char *) a2dp->buffer,
+ (gsize) a2dp->count, (gsize *) &ret);
+
+ if (err == G_IO_ERROR_AGAIN) {
+ usleep (100);
+ continue;
+ }
+
+ break;
+ }
+
+ /* Reset buffer of data to send */
+ a2dp->count = sizeof(struct rtp_header) + sizeof(struct rtp_payload);
+ a2dp->frame_count = 0;
+ a2dp->samples = 0;
+ a2dp->seq_num++;
+
+ return ret;
+}
+
+static GstFlowReturn gst_a2dp_sink_render(GstBaseSink *basesink,
+ GstBuffer *buffer)
+{
+ GstA2dpSink *sink;
+ struct bluetooth_data *data;
+ struct bluetooth_a2dp *a2dp;
+ gint encoded, frame_size=1024;
+ gint ret=0;
+
+ sink = GST_A2DP_SINK(basesink);
+ data = (struct bluetooth_data*) sink->data;
+ a2dp = &data->a2dp;
+
+ encoded = GST_BUFFER_SIZE(buffer);
+
+ if (a2dp->count + encoded >= data->cfg.pkt_len) {
+ ret = gst_a2dp_sink_avdtp_write(sink);
+ if (ret < 0)
+ return GST_FLOW_ERROR;
+ }
+
+ memcpy(a2dp->buffer + a2dp->count, GST_BUFFER_DATA(buffer), encoded);
+ a2dp->count += encoded;
+ a2dp->frame_count++;
+ a2dp->samples += encoded / frame_size;
+ a2dp->nsamples += encoded / frame_size;
+
+ return GST_FLOW_OK;
+}
+
+static gboolean gst_a2dp_sink_set_caps(GstBaseSink *basesink, GstCaps *caps)
+{
+ GstA2dpSink *self = GST_A2DP_SINK(basesink);
+
+ GST_A2DP_SINK_MUTEX_LOCK(self);
+ if (self->con_state == NOT_CONFIGURED)
+ gst_a2dp_sink_start_dev_conf(self, caps);
+ GST_A2DP_SINK_MUTEX_UNLOCK(self);
+
+ return TRUE;
+}
+
+static gboolean gst_a2dp_sink_unlock(GstBaseSink *basesink)
+{
+ return TRUE;
+}
+
static void gst_a2dp_sink_class_init(GstA2dpSinkClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
- GstAudioSinkClass *audiosink_class = GST_AUDIO_SINK_CLASS(klass);
+ GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS(klass);
parent_class = g_type_class_peek_parent(klass);
object_class->finalize = GST_DEBUG_FUNCPTR(gst_a2dp_sink_finalize);
- object_class->set_property = GST_DEBUG_FUNCPTR(gst_a2dp_sink_set_property);
- object_class->get_property = GST_DEBUG_FUNCPTR(gst_a2dp_sink_get_property);
-
- audiosink_class->open = GST_DEBUG_FUNCPTR(gst_a2dp_sink_open);
- audiosink_class->prepare = GST_DEBUG_FUNCPTR(gst_a2dp_sink_prepare);
- audiosink_class->unprepare = GST_DEBUG_FUNCPTR(gst_a2dp_sink_unprepare);
- audiosink_class->close = GST_DEBUG_FUNCPTR(gst_a2dp_sink_close);
- audiosink_class->write = GST_DEBUG_FUNCPTR(gst_a2dp_sink_write);
- audiosink_class->delay = GST_DEBUG_FUNCPTR(gst_a2dp_sink_delay);
- audiosink_class->reset = GST_DEBUG_FUNCPTR(gst_a2dp_sink_reset);
+ object_class->set_property = GST_DEBUG_FUNCPTR(
+ gst_a2dp_sink_set_property);
+ object_class->get_property = GST_DEBUG_FUNCPTR(
+ gst_a2dp_sink_get_property);
+
+ basesink_class->start = GST_DEBUG_FUNCPTR(gst_a2dp_sink_start);
+ basesink_class->stop = GST_DEBUG_FUNCPTR(gst_a2dp_sink_stop);
+ basesink_class->render = GST_DEBUG_FUNCPTR(gst_a2dp_sink_render);
+ basesink_class->preroll = GST_DEBUG_FUNCPTR(gst_a2dp_sink_preroll);
+ basesink_class->set_caps = GST_DEBUG_FUNCPTR(gst_a2dp_sink_set_caps);
+ basesink_class->unlock = GST_DEBUG_FUNCPTR(gst_a2dp_sink_unlock);
g_object_class_install_property(object_class, PROP_DEVICE,
- g_param_spec_string("device", "Device",
- "Bluetooth remote device",
- DEFAULT_DEVICE, G_PARAM_READWRITE));
+ g_param_spec_string("device", "Device",
+ "Bluetooth remote device address",
+ NULL, G_PARAM_READWRITE));
GST_DEBUG_CATEGORY_INIT(a2dp_sink_debug, "a2dpsink", 0,
- "A2DP sink element");
+ "A2DP sink element");
}
static void gst_a2dp_sink_init(GstA2dpSink *self, GstA2dpSinkClass *klass)
{
- struct sockaddr_un addr = { AF_UNIX, IPC_SOCKET_NAME };
- int sk;
+ self->device = NULL;
+ self->data = NULL;
- self->device = g_strdup(DEFAULT_DEVICE);
-
- sk = socket(PF_LOCAL, SOCK_STREAM, 0);
- if (sk < 0)
- return;
-
- if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
- close(sk);
- return;
- }
-
- self->server = g_io_channel_unix_new(sk);
-
- g_io_add_watch(self->server, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
- server_callback, self);
+ self->stream = NULL;
+ self->con_state = NOT_CONFIGURED;
+ self->total = 0;
- g_io_channel_unref(self->server);
+ self->con_conf_end = g_cond_new();
+ self->waiting_con_conf = FALSE;
+ self->sink_lock = g_mutex_new();
}
diff --git a/audio/gsta2dpsink.h b/audio/gsta2dpsink.h
index c83ec66c..6c7cfe2a 100644
--- a/audio/gsta2dpsink.h
+++ b/audio/gsta2dpsink.h
@@ -22,7 +22,7 @@
*/
#include <gst/gst.h>
-#include <gst/audio/gstaudiosink.h>
+#include <gst/base/gstbasesink.h>
G_BEGIN_DECLS
@@ -37,19 +37,41 @@ G_BEGIN_DECLS
#define GST_IS_A2DP_SINK_CLASS(obj) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_A2DP_SINK))
+enum {
+ NOT_CONFIGURED,
+ CONFIGURING_INIT,
+ CONFIGURING_SENT_CONF,
+ CONFIGURING_RCVD_CONF_RSP,
+ CONFIGURING_RCVD_DEV_CONF,
+ CONFIGURED
+};
+
typedef struct _GstA2dpSink GstA2dpSink;
typedef struct _GstA2dpSinkClass GstA2dpSinkClass;
+struct bluetooth_data;
+
struct _GstA2dpSink {
- GstAudioSink sink;
+ GstBaseSink sink;
gchar *device;
+ GIOChannel *stream;
+ struct bluetooth_data *data;
GIOChannel *server;
+
+ gint con_state;
+
+ GCond *con_conf_end;
+ gboolean waiting_con_conf;
+ GMutex *sink_lock;
+
+ gint total;
+
};
struct _GstA2dpSinkClass {
- GstAudioSinkClass parent_class;
+ GstBaseSinkClass parent_class;
};
GType gst_a2dp_sink_get_type(void);
diff --git a/audio/gstbluetooth.c b/audio/gstbluetooth.c
index ce065820..593a311e 100644
--- a/audio/gstbluetooth.c
+++ b/audio/gstbluetooth.c
@@ -67,11 +67,9 @@ static gboolean plugin_init(GstPlugin *plugin)
GST_RANK_PRIMARY, GST_TYPE_SBC_PARSE) == FALSE)
return FALSE;
-#if 0
if (gst_element_register(plugin, "a2dpsink",
GST_RANK_PRIMARY, GST_TYPE_A2DP_SINK) == FALSE)
return FALSE;
-#endif
return TRUE;
}
diff --git a/audio/sink.c b/audio/sink.c
index 0c5391f3..2515c968 100644
--- a/audio/sink.c
+++ b/audio/sink.c
@@ -177,7 +177,7 @@ static void stream_setup_complete(struct avdtp *session, struct a2dp_sep *sep,
sink->session = NULL;
if (avdtp_error_type(err) == AVDTP_ERROR_ERRNO
&& avdtp_error_posix_errno(err) != EHOSTDOWN) {
- debug("connect:connect XCASE detected");
+ debug("connect:connect XCASE detected");
g_timeout_add(STREAM_SETUP_RETRY_TIMER,
stream_setup_retry, sink);
} else {