gstreamer/sys/bluez/gsta2dpsink.c

/*
 *
 *  BlueZ - Bluetooth protocol stack for Linux
 *
 *  Copyright (C) 2004-2007  Marcel Holtmann <marcel@holtmann.org>
 *
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <unistd.h>
#include <pthread.h>

#include "gstsbcutil.h"
#include "gsta2dpsink.h"

GST_DEBUG_CATEGORY_STATIC (gst_a2dp_sink_debug);
#define GST_CAT_DEFAULT gst_a2dp_sink_debug

#define A2DP_SBC_RTP_PAYLOAD_TYPE 1
#define TEMPLATE_MAX_BITPOOL_STR "64"

enum
{
  PROP_0,
  PROP_DEVICE
};

GST_BOILERPLATE (GstA2dpSink, gst_a2dp_sink, GstBin, GST_TYPE_BIN);

static const GstElementDetails gst_a2dp_sink_details =
GST_ELEMENT_DETAILS ("Bluetooth A2DP sink",
    "Sink/Audio",
    "Plays audio to an A2DP device",
    "Marcel Holtmann <marcel@holtmann.org>");

static GstStaticPadTemplate gst_a2dp_sink_factory =
    GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("audio/x-sbc, "
        "rate = (int) { 16000, 32000, 44100, 48000 }, "
        "channels = (int) [ 1, 2 ], "
        "mode = (string) { mono, dual, stereo, joint }, "
        "blocks = (int) { 4, 8, 12, 16 }, "
        "subbands = (int) { 4, 8 }, "
        "allocation = (string) { snr, loudness }, "
        "bitpool = (int) [ 2, " TEMPLATE_MAX_BITPOOL_STR " ]; "));

static void
gst_a2dp_sink_base_init (gpointer g_class)
{
  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_set_details (element_class, &gst_a2dp_sink_details);
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&gst_a2dp_sink_factory));
}

static void
gst_a2dp_sink_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstA2dpSink *self = GST_A2DP_SINK (object);

  switch (prop_id) {
    case PROP_DEVICE:
      if (self->sink != NULL)
        gst_a2dp_sender_sink_set_device (self->sink,
            g_value_get_string (value));

      if (self->device != NULL)
        g_free (self->device);
      self->device = g_value_dup_string (value);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_a2dp_sink_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstA2dpSink *self = GST_A2DP_SINK (object);
  gchar *device;

  switch (prop_id) {
    case PROP_DEVICE:
      if (self->sink != NULL) {
        device = gst_a2dp_sender_sink_get_device (self->sink);
        if (device != NULL)
          g_value_take_string (value, device);
      }
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static GstStateChangeReturn
gst_a2dp_sink_change_state (GstElement * element, GstStateChange transition)
{
  GstA2dpSink *self = GST_A2DP_SINK (element);

  switch (transition) {
    case GST_STATE_CHANGE_NULL_TO_READY:
      gst_element_set_state (GST_ELEMENT (self->sink), GST_STATE_READY);
      break;

    case GST_STATE_CHANGE_READY_TO_NULL:
      if (self->newseg_event != NULL) {
        gst_event_unref (self->newseg_event);
        self->newseg_event = NULL;
      }
      break;

    default:
      break;
  }

  return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
}

static void
gst_a2dp_sink_class_init (GstA2dpSinkClass * klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  object_class->set_property = GST_DEBUG_FUNCPTR (gst_a2dp_sink_set_property);
  object_class->get_property = GST_DEBUG_FUNCPTR (gst_a2dp_sink_get_property);

  element_class->change_state = GST_DEBUG_FUNCPTR (gst_a2dp_sink_change_state);

  g_object_class_install_property (object_class, PROP_DEVICE,
      g_param_spec_string ("device", "Device",
          "Bluetooth remote device address", NULL, G_PARAM_READWRITE));

  GST_DEBUG_CATEGORY_INIT (gst_a2dp_sink_debug, "a2dpsink", 0,
      "A2DP sink element");
}

static GstCaps *
gst_a2dp_sink_get_device_caps (GstA2dpSink * self)
{
  return gst_a2dp_sender_sink_get_device_caps (self->sink);
}

static GstCaps *
gst_a2dp_sink_get_caps (GstPad * pad)
{
  GstCaps *caps;
  GstCaps *caps_aux;
  GstA2dpSink *self = GST_A2DP_SINK (GST_PAD_PARENT (pad));

  if (self->sink == NULL) {
    GST_DEBUG_OBJECT (self, "a2dpsink isn't initialized "
        "returning template caps");
    caps = gst_static_pad_template_get_caps (&gst_a2dp_sink_factory);
  } else {
    GST_LOG_OBJECT (self, "Getting device caps");
    caps = gst_a2dp_sink_get_device_caps (self);
    if (caps == NULL)
      caps = gst_static_pad_template_get_caps (&gst_a2dp_sink_factory);
  }
  caps_aux = gst_caps_copy (caps);
  g_object_set (self->capsfilter, "caps", caps_aux, NULL);
  gst_caps_unref (caps_aux);
  return caps;
}

static gboolean
gst_a2dp_sink_init_sender_sink (GstA2dpSink * self)
{
  GstElement *sink;

  if (self->sink == NULL)
    sink = gst_element_factory_make ("a2dpsendersink", "sendersink");
  else
    sink = GST_ELEMENT (self->sink);

  if (sink == NULL) {
    GST_ERROR_OBJECT (self, "Couldn't create a2dpsendersink");
    return FALSE;
  }

  if (!gst_bin_add (GST_BIN (self), sink)) {
    GST_ERROR_OBJECT (self, "failed to add a2dpsendersink " "to the bin");
    goto cleanup_and_fail;
  }

  if (gst_element_set_state (sink, GST_STATE_READY) == GST_STATE_CHANGE_FAILURE) {
    GST_ERROR_OBJECT (self, "a2dpsendersink failed to go to ready");
    goto remove_element_and_fail;
  }

  if (!gst_element_link (GST_ELEMENT (self->rtp), sink)) {
    GST_ERROR_OBJECT (self, "couldn't link rtpsbcpay " "to a2dpsendersink");
    goto remove_element_and_fail;
  }

  self->sink = GST_A2DP_SENDER_SINK (sink);
  g_object_set (G_OBJECT (self->sink), "device", self->device, NULL);

  gst_element_set_state (sink, GST_STATE_PAUSED);

  return TRUE;

remove_element_and_fail:
  gst_element_set_state (sink, GST_STATE_NULL);
  gst_bin_remove (GST_BIN (self), sink);
  return FALSE;

cleanup_and_fail:
  if (sink != NULL)
    g_object_unref (G_OBJECT (sink));

  return FALSE;
}

static gboolean
gst_a2dp_sink_init_rtp_sbc_element (GstA2dpSink * self)
{
  GstElement *rtppay;

  rtppay = gst_element_factory_make ("rtpsbcpay", "rtp");
  if (rtppay == NULL) {
    GST_ERROR_OBJECT (self, "Couldn't create rtpsbcpay");
    return FALSE;
  }

  if (!gst_bin_add (GST_BIN (self), rtppay)) {
    GST_ERROR_OBJECT (self, "failed to add rtp sbc pay to the bin");
    goto cleanup_and_fail;
  }

  if (gst_element_set_state (rtppay, GST_STATE_READY) ==
      GST_STATE_CHANGE_FAILURE) {
    GST_ERROR_OBJECT (self, "rtpsbcpay failed to go to ready");
    goto remove_element_and_fail;
  }

  if (!gst_element_link (self->capsfilter, rtppay)) {
    GST_ERROR_OBJECT (self, "couldn't link capsfilter " "to rtpsbcpay");
    goto remove_element_and_fail;
  }

  self->rtp = GST_BASE_RTP_PAYLOAD (rtppay);
  g_object_set (G_OBJECT (self->rtp), "min-frames", -1, NULL);

  gst_element_set_state (rtppay, GST_STATE_PAUSED);

  return TRUE;

remove_element_and_fail:
  gst_element_set_state (rtppay, GST_STATE_NULL);
  gst_bin_remove (GST_BIN (self), rtppay);
  return FALSE;

cleanup_and_fail:
  if (rtppay != NULL)
    g_object_unref (G_OBJECT (rtppay));

  return FALSE;
}

static gboolean
gst_a2dp_sink_set_caps (GstPad * pad, GstCaps * caps)
{
  GstA2dpSink *self;
  GstStructure *structure;

  self = GST_A2DP_SINK (GST_PAD_PARENT (pad));
  GST_INFO_OBJECT (self, "setting caps");

  structure = gst_caps_get_structure (caps, 0);

  /* first, we need to create our rtp payloader */
  if (gst_structure_has_name (structure, "audio/x-sbc"))
    gst_a2dp_sink_init_rtp_sbc_element (self);
  else {
    GST_ERROR_OBJECT (self, "Unexpected media type");
    return FALSE;
  }

  if (!gst_a2dp_sink_init_sender_sink (self))
    return FALSE;

  if (!gst_a2dp_sender_sink_set_device_caps (self->sink, caps))
    return FALSE;

  g_object_set (G_OBJECT (self->rtp), "mtu",
      gst_a2dp_sender_sink_get_link_mtu (self->sink), NULL);

  /* we forward our new segment here if we have one */
  gst_pad_send_event (GST_BASE_RTP_PAYLOAD_SINKPAD (self->rtp),
      self->newseg_event);
  self->newseg_event = NULL;

  return self->ghostpad_setcapsfunc (GST_PAD (self->ghostpad), caps);
}

/* used for catching newsegment events while we don't have a sink, for
 * later forwarding it to the sink */
static gboolean
gst_a2dp_sink_handle_event (GstPad * pad, GstEvent * event)
{
  GstA2dpSink *self;

  self = GST_A2DP_SINK (GST_PAD_PARENT (pad));

  if (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT &&
      gst_element_get_parent (GST_ELEMENT (self->sink)) !=
      GST_OBJECT_CAST (self)) {
    if (self->newseg_event != NULL)
      gst_event_unref (self->newseg_event);
    self->newseg_event = gst_event_ref (event);
  }

  return self->ghostpad_eventfunc (GST_PAD (self->ghostpad), event);
}

static gboolean
gst_a2dp_sink_init_caps_filter (GstA2dpSink * self)
{
  GstElement *element;

  element = gst_element_factory_make ("capsfilter", "filter");
  if (element == NULL)
    goto failed;

  if (!gst_bin_add (GST_BIN (self), element))
    goto failed;

  self->capsfilter = element;
  return TRUE;

failed:
  GST_ERROR_OBJECT (self, "Failed to initialize caps filter");
  return FALSE;
}

static void
gst_a2dp_sink_init (GstA2dpSink * self, GstA2dpSinkClass * klass)
{
  GstPad *capsfilter_pad;

  self->sink = NULL;
  self->rtp = NULL;
  self->device = NULL;
  self->capsfilter = NULL;
  self->newseg_event = NULL;

  /* we initialize our capsfilter */
  gst_a2dp_sink_init_caps_filter (self);
  g_object_set (self->capsfilter, "caps",
      gst_static_pad_template_get_caps (&gst_a2dp_sink_factory), NULL);

  /* we search for the capsfilter sinkpad */
  capsfilter_pad = gst_element_get_static_pad (self->capsfilter, "sink");

  /* now we add a ghostpad */
  self->ghostpad = GST_GHOST_PAD (gst_ghost_pad_new ("sink", capsfilter_pad));
  g_object_unref (capsfilter_pad);

  /* the getcaps of our ghostpad must reflect the device caps */
  gst_pad_set_getcaps_function (GST_PAD (self->ghostpad),
      gst_a2dp_sink_get_caps);
  self->ghostpad_setcapsfunc = GST_PAD_SETCAPSFUNC (self->ghostpad);
  gst_pad_set_setcaps_function (GST_PAD (self->ghostpad),
      GST_DEBUG_FUNCPTR (gst_a2dp_sink_set_caps));

  /* we need to handle events on our own and we also need the eventfunc
   * of the ghostpad for forwarding calls */
  self->ghostpad_eventfunc = GST_PAD_EVENTFUNC (GST_PAD (self->ghostpad));
  gst_pad_set_event_function (GST_PAD (self->ghostpad),
      gst_a2dp_sink_handle_event);

  if (!gst_element_add_pad (GST_ELEMENT (self), GST_PAD (self->ghostpad)))
    GST_ERROR_OBJECT (self, "failed to add ghostpad");

  self->sink =
      GST_A2DP_SENDER_SINK (gst_element_factory_make ("a2dpsendersink",
          "sendersink"));
  if (self->sink == NULL)
    GST_WARNING_OBJECT (self, "failed to create a2dpsendersink");
}

gboolean
gst_a2dp_sink_plugin_init (GstPlugin * plugin)
{
  return gst_element_register (plugin, "a2dpsink",
      GST_RANK_PRIMARY, GST_TYPE_A2DP_SINK);
}