/* GStreamer

 * Copyright (C) <2005> Wim Taymans <wim@fluendo.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 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

 * Library General Public License for more

 */

/**

 * SECTION:gstrtpbasepayload

 * @title: GstRTPBasePayload

 * @short_description: Base class for RTP payloader

 *

 * Provides a base class for RTP payloaders

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <gst/rtp/gstrtpbuffer.h>

#include "gstrtpbasepayload.h"

GST_DEBUG_CATEGORY_STATIC (rtpbasepayload_debug);

#define GST_CAT_DEFAULT (rtpbasepayload_debug)

#define GST_RTP_BASE_PAYLOAD_GET_PRIVATE(obj)  \

   (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_BASE_PAYLOAD, GstRTPBasePayloadPrivate))

struct _GstRTPBasePayloadPrivate

{

  gboolean ts_offset_random;

  gboolean seqnum_offset_random;

  gboolean ssrc_random;

  guint16 next_seqnum;

  gboolean perfect_rtptime;

  gint notified_first_timestamp;

  gboolean pt_set;

  guint64 base_offset;

  gint64 base_rtime;

  guint64 base_rtime_hz;

  guint64 running_time;

  gint64 prop_max_ptime;

  gint64 caps_max_ptime;

  gboolean negotiated;

  gboolean delay_segment;

  GstEvent *pending_segment;

  GstCaps *subclass_srccaps;

  GstCaps *sinkcaps;

};

/* RTPBasePayload signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

/* FIXME 0.11, a better default is the Ethernet MTU of

 * 1500 - sizeof(headers) as pointed out by marcelm in IRC:

 * So an Ethernet MTU of 1500, minus 60 for the max IP, minus 8 for UDP, gives

 * 1432 bytes or so.  And that should be adjusted downward further for other

 * encapsulations like PPPoE, so 1400 at most.

 */

#define DEFAULT_MTU                     1400

#define DEFAULT_PT                      96

#define DEFAULT_SSRC                    -1

#define DEFAULT_TIMESTAMP_OFFSET        -1

#define DEFAULT_SEQNUM_OFFSET           -1

#define DEFAULT_MAX_PTIME               -1

#define DEFAULT_MIN_PTIME               0

#define DEFAULT_PERFECT_RTPTIME         TRUE

#define DEFAULT_PTIME_MULTIPLE          0

#define DEFAULT_RUNNING_TIME            GST_CLOCK_TIME_NONE

enum

{

  PROP_0,

  PROP_MTU,

  PROP_PT,

  PROP_SSRC,

  PROP_TIMESTAMP_OFFSET,

  PROP_SEQNUM_OFFSET,

  PROP_MAX_PTIME,

  PROP_MIN_PTIME,

  PROP_TIMESTAMP,

  PROP_SEQNUM,

  PROP_PERFECT_RTPTIME,

  PROP_PTIME_MULTIPLE,

  PROP_STATS,

  PROP_LAST

};

static void gst_rtp_base_payload_class_init (GstRTPBasePayloadClass * klass);

static void gst_rtp_base_payload_init (GstRTPBasePayload * rtpbasepayload,

    gpointer g_class);

static void gst_rtp_base_payload_finalize (GObject * object);

static GstCaps *gst_rtp_base_payload_getcaps_default (GstRTPBasePayload *

    rtpbasepayload, GstPad * pad, GstCaps * filter);

static gboolean gst_rtp_base_payload_sink_event_default (GstRTPBasePayload *

    rtpbasepayload, GstEvent * event);

static gboolean gst_rtp_base_payload_sink_event (GstPad * pad,

    GstObject * parent, GstEvent * event);

static gboolean gst_rtp_base_payload_src_event_default (GstRTPBasePayload *

    rtpbasepayload, GstEvent * event);

static gboolean gst_rtp_base_payload_src_event (GstPad * pad,

    GstObject * parent, GstEvent * event);

static gboolean gst_rtp_base_payload_query_default (GstRTPBasePayload *

    rtpbasepayload, GstPad * pad, GstQuery * query);

static gboolean gst_rtp_base_payload_query (GstPad * pad, GstObject * parent,

    GstQuery * query);

static GstFlowReturn gst_rtp_base_payload_chain (GstPad * pad,

    GstObject * parent, GstBuffer * buffer);

static void gst_rtp_base_payload_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_rtp_base_payload_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static GstStateChangeReturn gst_rtp_base_payload_change_state (GstElement *

    element, GstStateChange transition);

static gboolean gst_rtp_base_payload_negotiate (GstRTPBasePayload * payload);

static GstElementClass *parent_class = NULL;

GType

gst_rtp_base_payload_get_type (void)

{

  static GType rtpbasepayload_type = 0;

  if (g_once_init_enter ((gsize *) & rtpbasepayload_type)) {

    static const GTypeInfo rtpbasepayload_info = {

      sizeof (GstRTPBasePayloadClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_rtp_base_payload_class_init,

      NULL,

      NULL,

      sizeof (GstRTPBasePayload),

      0,

      (GInstanceInitFunc) gst_rtp_base_payload_init,

    };

    g_once_init_leave ((gsize *) & rtpbasepayload_type,

        g_type_register_static (GST_TYPE_ELEMENT, "GstRTPBasePayload",

            &rtpbasepayload_info, G_TYPE_FLAG_ABSTRACT));

  }

  return rtpbasepayload_type;

}

static void

gst_rtp_base_payload_class_init (GstRTPBasePayloadClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;

  gstelement_class = (GstElementClass *) klass;

  g_type_class_add_private (klass, sizeof (GstRTPBasePayloadPrivate));

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->finalize = gst_rtp_base_payload_finalize;

  gobject_class->set_property = gst_rtp_base_payload_set_property;

  gobject_class->get_property = gst_rtp_base_payload_get_property;

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MTU,

      g_param_spec_uint ("mtu", "MTU",

          "Maximum size of one packet",

          28, G_MAXUINT, DEFAULT_MTU,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PT,

      g_param_spec_uint ("pt", "payload type",

          "The payload type of the packets", 0, 0x7f, DEFAULT_PT,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SSRC,

      g_param_spec_uint ("ssrc", "SSRC",

          "The SSRC of the packets (default == random)", 0, G_MAXUINT32,

          DEFAULT_SSRC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass),

      PROP_TIMESTAMP_OFFSET, g_param_spec_uint ("timestamp-offset",

          "Timestamp Offset",

          "Offset to add to all outgoing timestamps (default = random)", 0,

          G_MAXUINT32, DEFAULT_TIMESTAMP_OFFSET,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SEQNUM_OFFSET,

      g_param_spec_int ("seqnum-offset", "Sequence number Offset",

          "Offset to add to all outgoing seqnum (-1 = random)", -1, G_MAXUINT16,

          DEFAULT_SEQNUM_OFFSET, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MAX_PTIME,

      g_param_spec_int64 ("max-ptime", "Max packet time",

          "Maximum duration of the packet data in ns (-1 = unlimited up to MTU)",

          -1, G_MAXINT64, DEFAULT_MAX_PTIME,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstRTPBasePayload:min-ptime:

   *

   * Minimum duration of the packet data in ns (can't go above MTU)

   **/

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MIN_PTIME,

      g_param_spec_int64 ("min-ptime", "Min packet time",

          "Minimum duration of the packet data in ns (can't go above MTU)",

          0, G_MAXINT64, DEFAULT_MIN_PTIME,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TIMESTAMP,

      g_param_spec_uint ("timestamp", "Timestamp",

          "The RTP timestamp of the last processed packet",

          0, G_MAXUINT32, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SEQNUM,

      g_param_spec_uint ("seqnum", "Sequence number",

          "The RTP sequence number of the last processed packet",

          0, G_MAXUINT16, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

  /**

   * GstRTPBasePayload:perfect-rtptime:

   *

   * Try to use the offset fields to generate perfect RTP timestamps. When this

   * option is disabled, RTP timestamps are generated from GST_BUFFER_PTS of

   * each payloaded buffer. The PTSes of buffers may not necessarily increment

   * with the amount of data in each input buffer, consider e.g. the case where

   * the buffer arrives from a network which means that the PTS is unrelated to

   * the amount of data. Because the RTP timestamps are generated from

   * GST_BUFFER_PTS this can result in RTP timestamps that also don't increment

   * with the amount of data in the payloaded packet. To circumvent this it is

   * possible to set the perfect rtptime option enabled. When this option is

   * enabled the payloader will increment the RTP timestamps based on

   * GST_BUFFER_OFFSET which relates to the amount of data in each packet

   * rather than the GST_BUFFER_PTS of each buffer and therefore the RTP

   * timestamps will more closely correlate with the amount of data in each

   * buffer. Currently GstRTPBasePayload is limited to handling perfect RTP

   * timestamps for audio streams.

   */

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PERFECT_RTPTIME,

      g_param_spec_boolean ("perfect-rtptime", "Perfect RTP Time",

          "Generate perfect RTP timestamps when possible",

          DEFAULT_PERFECT_RTPTIME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstRTPBasePayload:ptime-multiple:

   *

   * Force buffers to be multiples of this duration in ns (0 disables)

   **/

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PTIME_MULTIPLE,

      g_param_spec_int64 ("ptime-multiple", "Packet time multiple",

          "Force buffers to be multiples of this duration in ns (0 disables)",

          0, G_MAXINT64, DEFAULT_PTIME_MULTIPLE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstRTPBasePayload:stats:

   *

   * Various payloader statistics retrieved atomically (and are therefore

   * synchroized with each other), these can be used e.g. to generate an

   * RTP-Info header. This property return a GstStructure named

   * application/x-rtp-payload-stats containing the following fields relating to

   * the last processed buffer and current state of the stream being payloaded:

   *

   *   * `clock-rate` :#G_TYPE_UINT, clock-rate of the stream

   *   * `running-time` :#G_TYPE_UINT64, running time

   *   * `seqnum` :#G_TYPE_UINT, sequence number, same as #GstRTPBasePayload:seqnum

   *   * `timestamp` :#G_TYPE_UINT, RTP timestamp, same as #GstRTPBasePayload:timestamp

   *   * `ssrc` :#G_TYPE_UINT, The SSRC in use

   *   * `pt` :#G_TYPE_UINT, The Payload type in use, same as #GstRTPBasePayload:pt

   *   * `seqnum-offset` :#G_TYPE_UINT, The current offset added to the seqnum

   *   * `timestamp-offset` :#G_TYPE_UINT, The current offset added to the timestamp

   **/

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_STATS,

      g_param_spec_boxed ("stats", "Statistics", "Various statistics",

          GST_TYPE_STRUCTURE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

  gstelement_class->change_state = gst_rtp_base_payload_change_state;

  klass->get_caps = gst_rtp_base_payload_getcaps_default;

  klass->sink_event = gst_rtp_base_payload_sink_event_default;

  klass->src_event = gst_rtp_base_payload_src_event_default;

  klass->query = gst_rtp_base_payload_query_default;

  GST_DEBUG_CATEGORY_INIT (rtpbasepayload_debug, "rtpbasepayload", 0,

      "Base class for RTP Payloaders");

}

static void

gst_rtp_base_payload_init (GstRTPBasePayload * rtpbasepayload, gpointer g_class)

{

  GstPadTemplate *templ;

  GstRTPBasePayloadPrivate *priv;

  rtpbasepayload->priv = priv =

      GST_RTP_BASE_PAYLOAD_GET_PRIVATE (rtpbasepayload);

  templ =

      gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "src");

  g_return_if_fail (templ != NULL);

  rtpbasepayload->srcpad = gst_pad_new_from_template (templ, "src");

  gst_pad_set_event_function (rtpbasepayload->srcpad,

      gst_rtp_base_payload_src_event);

  gst_element_add_pad (GST_ELEMENT (rtpbasepayload), rtpbasepayload->srcpad);

  templ =

      gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "sink");

  g_return_if_fail (templ != NULL);

  rtpbasepayload->sinkpad = gst_pad_new_from_template (templ, "sink");

  gst_pad_set_chain_function (rtpbasepayload->sinkpad,

      gst_rtp_base_payload_chain);

  gst_pad_set_event_function (rtpbasepayload->sinkpad,

      gst_rtp_base_payload_sink_event);

  gst_pad_set_query_function (rtpbasepayload->sinkpad,

      gst_rtp_base_payload_query);

  gst_element_add_pad (GST_ELEMENT (rtpbasepayload), rtpbasepayload->sinkpad);

  rtpbasepayload->mtu = DEFAULT_MTU;

  rtpbasepayload->pt = DEFAULT_PT;

  rtpbasepayload->seqnum_offset = DEFAULT_SEQNUM_OFFSET;

  rtpbasepayload->ssrc = DEFAULT_SSRC;

  rtpbasepayload->ts_offset = DEFAULT_TIMESTAMP_OFFSET;

  priv->running_time = DEFAULT_RUNNING_TIME;

  priv->seqnum_offset_random = (rtpbasepayload->seqnum_offset == -1);

  priv->ts_offset_random = (rtpbasepayload->ts_offset == -1);

  priv->ssrc_random = (rtpbasepayload->ssrc == -1);

  priv->pt_set = FALSE;

  rtpbasepayload->max_ptime = DEFAULT_MAX_PTIME;

  rtpbasepayload->min_ptime = DEFAULT_MIN_PTIME;

  rtpbasepayload->priv->perfect_rtptime = DEFAULT_PERFECT_RTPTIME;

  rtpbasepayload->ptime_multiple = DEFAULT_PTIME_MULTIPLE;

  rtpbasepayload->priv->base_offset = GST_BUFFER_OFFSET_NONE;

  rtpbasepayload->priv->base_rtime_hz = GST_BUFFER_OFFSET_NONE;

  rtpbasepayload->media = NULL;

  rtpbasepayload->encoding_name = NULL;

  rtpbasepayload->clock_rate = 0;

  rtpbasepayload->priv->caps_max_ptime = DEFAULT_MAX_PTIME;

  rtpbasepayload->priv->prop_max_ptime = DEFAULT_MAX_PTIME;

}

static void

gst_rtp_base_payload_finalize (GObject * object)

{

  GstRTPBasePayload *rtpbasepayload;

  rtpbasepayload = GST_RTP_BASE_PAYLOAD (object);

  g_free (rtpbasepayload->media);

  rtpbasepayload->media = NULL;

  g_free (rtpbasepayload->encoding_name);

  rtpbasepayload->encoding_name = NULL;

  gst_caps_replace (&rtpbasepayload->priv->subclass_srccaps, NULL);

  gst_caps_replace (&rtpbasepayload->priv->sinkcaps, NULL);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static GstCaps *

gst_rtp_base_payload_getcaps_default (GstRTPBasePayload * rtpbasepayload,

    GstPad * pad, GstCaps * filter)

{

  GstCaps *caps;

  caps = GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (pad));

  GST_DEBUG_OBJECT (pad,

      "using pad template %p with caps %p %" GST_PTR_FORMAT,

      GST_PAD_PAD_TEMPLATE (pad), caps, caps);

  if (filter)

    caps = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);

  else

    caps = gst_caps_ref (caps);

  return caps;

}

static gboolean

gst_rtp_base_payload_sink_event_default (GstRTPBasePayload * rtpbasepayload,

    GstEvent * event)

{

  GstObject *parent = GST_OBJECT_CAST (rtpbasepayload);

  gboolean res = FALSE;

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_FLUSH_START:

      res = gst_pad_event_default (rtpbasepayload->sinkpad, parent, event);

      break;

    case GST_EVENT_FLUSH_STOP:

      res = gst_pad_event_default (rtpbasepayload->sinkpad, parent, event);

      gst_segment_init (&rtpbasepayload->segment, GST_FORMAT_UNDEFINED);

      gst_event_replace (&rtpbasepayload->priv->pending_segment, NULL);

      break;

    case GST_EVENT_CAPS:

    {

      GstRTPBasePayloadClass *rtpbasepayload_class;

      GstCaps *caps;

      gst_event_parse_caps (event, &caps);

      GST_DEBUG_OBJECT (rtpbasepayload, "setting caps %" GST_PTR_FORMAT, caps);

      gst_caps_replace (&rtpbasepayload->priv->sinkcaps, caps);

      rtpbasepayload_class = GST_RTP_BASE_PAYLOAD_GET_CLASS (rtpbasepayload);

      if (rtpbasepayload_class->set_caps)

        res = rtpbasepayload_class->set_caps (rtpbasepayload, caps);

      else

        res = gst_rtp_base_payload_negotiate (rtpbasepayload);

      rtpbasepayload->priv->negotiated = res;

      gst_event_unref (event);

      break;

    }

    case GST_EVENT_SEGMENT:

    {

      GstSegment *segment;

      segment = &rtpbasepayload->segment;

      gst_event_copy_segment (event, segment);

      rtpbasepayload->priv->base_offset = GST_BUFFER_OFFSET_NONE;

      GST_DEBUG_OBJECT (rtpbasepayload,

          "configured SEGMENT %" GST_SEGMENT_FORMAT, segment);

      if (rtpbasepayload->priv->delay_segment) {

        gst_event_replace (&rtpbasepayload->priv->pending_segment, event);

        gst_event_unref (event);

        res = TRUE;

      } else {

        res = gst_pad_event_default (rtpbasepayload->sinkpad, parent, event);

      }

      break;

    }

    default:

      res = gst_pad_event_default (rtpbasepayload->sinkpad, parent, event);

      break;

  }

  return res;

}

static gboolean

gst_rtp_base_payload_sink_event (GstPad * pad, GstObject * parent,

    GstEvent * event)

{

  GstRTPBasePayload *rtpbasepayload;

  GstRTPBasePayloadClass *rtpbasepayload_class;

  gboolean res = FALSE;

  rtpbasepayload = GST_RTP_BASE_PAYLOAD (parent);

  rtpbasepayload_class = GST_RTP_BASE_PAYLOAD_GET_CLASS (rtpbasepayload);

  if (rtpbasepayload_class->sink_event)

    res = rtpbasepayload_class->sink_event (rtpbasepayload, event);

  else

    gst_event_unref (event);

  return res;

}

static gboolean

gst_rtp_base_payload_src_event_default (GstRTPBasePayload * rtpbasepayload,

    GstEvent * event)

{

  GstObject *parent = GST_OBJECT_CAST (rtpbasepayload);

  gboolean res = TRUE, forward = TRUE;

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_CUSTOM_UPSTREAM:

    {

      const GstStructure *s = gst_event_get_structure (event);

      if (gst_structure_has_name (s, "GstRTPCollision")) {

        guint ssrc = 0;

        if (!gst_structure_get_uint (s, "ssrc", &ssrc))

          ssrc = -1;

        GST_DEBUG_OBJECT (rtpbasepayload, "collided ssrc: %" G_GUINT32_FORMAT,

            ssrc);

        /* choose another ssrc for our stream */

        if (ssrc == rtpbasepayload->current_ssrc) {

          GstCaps *caps;

          guint suggested_ssrc = 0;

          if (gst_structure_get_uint (s, "suggested-ssrc", &suggested_ssrc))

            rtpbasepayload->current_ssrc = suggested_ssrc;

          while (ssrc == rtpbasepayload->current_ssrc)

            rtpbasepayload->current_ssrc = g_random_int ();

          caps = gst_pad_get_current_caps (rtpbasepayload->srcpad);

          if (caps) {

            caps = gst_caps_make_writable (caps);

            gst_caps_set_simple (caps,

                "ssrc", G_TYPE_UINT, rtpbasepayload->current_ssrc, NULL);

            res = gst_pad_set_caps (rtpbasepayload->srcpad, caps);

            gst_caps_unref (caps);

          }

          /* the event was for us */

          forward = FALSE;

        }

      }

      break;

    }

    default:

      break;

  }

  if (forward)

    res = gst_pad_event_default (rtpbasepayload->srcpad, parent, event);

  else

    gst_event_unref (event);

  return res;

}

static gboolean

gst_rtp_base_payload_src_event (GstPad * pad, GstObject * parent,

    GstEvent * event)

{

  GstRTPBasePayload *rtpbasepayload;

  GstRTPBasePayloadClass *rtpbasepayload_class;

  gboolean res = FALSE;

  rtpbasepayload = GST_RTP_BASE_PAYLOAD (parent);

  rtpbasepayload_class = GST_RTP_BASE_PAYLOAD_GET_CLASS (rtpbasepayload);

  if (rtpbasepayload_class->src_event)

    res = rtpbasepayload_class->src_event (rtpbasepayload, event);

  else

    gst_event_unref (event);

  return res;

}

static gboolean

gst_rtp_base_payload_query_default (GstRTPBasePayload * rtpbasepayload,

    GstPad * pad, GstQuery * query)

{

  gboolean res = FALSE;

  switch (GST_QUERY_TYPE (query)) {

    case GST_QUERY_CAPS:

    {

      GstRTPBasePayloadClass *rtpbasepayload_class;

      GstCaps *filter, *caps;

      gst_query_parse_caps (query, &filter);

      GST_DEBUG_OBJECT (rtpbasepayload, "getting caps with filter %"

          GST_PTR_FORMAT, filter);

      rtpbasepayload_class = GST_RTP_BASE_PAYLOAD_GET_CLASS (rtpbasepayload);

      if (rtpbasepayload_class->get_caps) {

        caps = rtpbasepayload_class->get_caps (rtpbasepayload, pad, filter);

        gst_query_set_caps_result (query, caps);

        gst_caps_unref (caps);

        res = TRUE;

      }

      break;

    }

    default:

      res =

          gst_pad_query_default (pad, GST_OBJECT_CAST (rtpbasepayload), query);

      break;

  }

  return res;

}

static gboolean

gst_rtp_base_payload_query (GstPad * pad, GstObject * parent, GstQuery * query)

{

  GstRTPBasePayload *rtpbasepayload;

  GstRTPBasePayloadClass *rtpbasepayload_class;

  gboolean res = FALSE;

  rtpbasepayload = GST_RTP_BASE_PAYLOAD (parent);

  rtpbasepayload_class = GST_RTP_BASE_PAYLOAD_GET_CLASS (rtpbasepayload);

  if (rtpbasepayload_class->query)

    res = rtpbasepayload_class->query (rtpbasepayload, pad, query);

  return res;

}

static GstFlowReturn

gst_rtp_base_payload_chain (GstPad * pad, GstObject * parent,

    GstBuffer * buffer)

{

  GstRTPBasePayload *rtpbasepayload;

  GstRTPBasePayloadClass *rtpbasepayload_class;

  GstFlowReturn ret;

  rtpbasepayload = GST_RTP_BASE_PAYLOAD (parent);

  rtpbasepayload_class = GST_RTP_BASE_PAYLOAD_GET_CLASS (rtpbasepayload);

  if (!rtpbasepayload_class->handle_buffer)

    goto no_function;

  if (!rtpbasepayload->priv->negotiated)

    goto not_negotiated;

  if (gst_pad_check_reconfigure (GST_RTP_BASE_PAYLOAD_SRCPAD (rtpbasepayload))) {

    if (!gst_rtp_base_payload_negotiate (rtpbasepayload)) {

      gst_pad_mark_reconfigure (GST_RTP_BASE_PAYLOAD_SRCPAD (rtpbasepayload));

      if (GST_PAD_IS_FLUSHING (GST_RTP_BASE_PAYLOAD_SRCPAD (rtpbasepayload))) {

        goto flushing;

      } else {

        goto negotiate_failed;

      }

    }

  }

  ret = rtpbasepayload_class->handle_buffer (rtpbasepayload, buffer);

  return ret;

  /* ERRORS */

no_function:

  {

    GST_ELEMENT_ERROR (rtpbasepayload, STREAM, NOT_IMPLEMENTED, (NULL),

        ("subclass did not implement handle_buffer function"));

    gst_buffer_unref (buffer);

    return GST_FLOW_ERROR;

  }

not_negotiated:

  {

    GST_ELEMENT_ERROR (rtpbasepayload, CORE, NEGOTIATION, (NULL),

        ("No input format was negotiated, i.e. no caps event was received. "

            "Perhaps you need a parser or typefind element before the payloader"));

    gst_buffer_unref (buffer);

    return GST_FLOW_NOT_NEGOTIATED;

  }

negotiate_failed:

  {

    GST_DEBUG_OBJECT (rtpbasepayload, "Not negotiated");

    gst_buffer_unref (buffer);

    return GST_FLOW_NOT_NEGOTIATED;

  }

flushing:

  {

    GST_DEBUG_OBJECT (rtpbasepayload, "we are flushing");

    gst_buffer_unref (buffer);

    return GST_FLOW_FLUSHING;

  }

}

/**

 * gst_rtp_base_payload_set_options:

 * @payload: a #GstRTPBasePayload

 * @media: the media type (typically "audio" or "video")

 * @dynamic: if the payload type is dynamic

 * @encoding_name: the encoding name

 * @clock_rate: the clock rate of the media

 *

 * Set the rtp options of the payloader. These options will be set in the caps

 * of the payloader. Subclasses must call this method before calling

 * gst_rtp_base_payload_push() or gst_rtp_base_payload_set_outcaps().

 */

void

gst_rtp_base_payload_set_options (GstRTPBasePayload * payload,

    const gchar * media, gboolean dynamic, const gchar * encoding_name,

    guint32 clock_rate)

{

  g_return_if_fail (payload != NULL);

  g_return_if_fail (clock_rate != 0);

  g_free (payload->media);

  payload->media = g_strdup (media);

  payload->dynamic = dynamic;

  g_free (payload->encoding_name);

  payload->encoding_name = g_strdup (encoding_name);

  payload->clock_rate = clock_rate;

}

static gboolean

copy_fixed (GQuark field_id, const GValue * value, GstStructure * dest)

{

  if (gst_value_is_fixed (value)) {

    gst_structure_id_set_value (dest, field_id, value);

  }

  return TRUE;

}

static void

update_max_ptime (GstRTPBasePayload * rtpbasepayload)

{

  if (rtpbasepayload->priv->caps_max_ptime != -1 &&

      rtpbasepayload->priv->prop_max_ptime != -1)

    rtpbasepayload->max_ptime = MIN (rtpbasepayload->priv->caps_max_ptime,

        rtpbasepayload->priv->prop_max_ptime);

  else if (rtpbasepayload->priv->caps_max_ptime != -1)

    rtpbasepayload->max_ptime = rtpbasepayload->priv->caps_max_ptime;

  else if (rtpbasepayload->priv->prop_max_ptime != -1)

    rtpbasepayload->max_ptime = rtpbasepayload->priv->prop_max_ptime;

  else

    rtpbasepayload->max_ptime = DEFAULT_MAX_PTIME;

}

/**

 * gst_rtp_base_payload_set_outcaps:

 * @payload: a #GstRTPBasePayload

 * @fieldname: the first field name or %NULL

 * @...: field values

 *

 * Configure the output caps with the optional parameters.

 *

 * Variable arguments should be in the form field name, field type

 * (as a GType), value(s).  The last variable argument should be NULL.

 *

 * Returns: %TRUE if the caps could be set.

 */

gboolean

gst_rtp_base_payload_set_outcaps (GstRTPBasePayload * payload,

    const gchar * fieldname, ...)

{

  GstCaps *srccaps;

  /* fill in the defaults, their properties cannot be negotiated. */

  srccaps = gst_caps_new_simple ("application/x-rtp",

      "media", G_TYPE_STRING, payload->media,

      "clock-rate", G_TYPE_INT, payload->clock_rate,

      "encoding-name", G_TYPE_STRING, payload->encoding_name, NULL);

  GST_DEBUG_OBJECT (payload, "defaults: %" GST_PTR_FORMAT, srccaps);

  if (fieldname) {

    va_list varargs;

    /* override with custom properties */

    va_start (varargs, fieldname);

    gst_caps_set_simple_valist (srccaps, fieldname, varargs);

    va_end (varargs);

    GST_DEBUG_OBJECT (payload, "custom added: %" GST_PTR_FORMAT, srccaps);

  }

  gst_caps_replace (&payload->priv->subclass_srccaps, srccaps);

  gst_caps_unref (srccaps);

  return gst_rtp_base_payload_negotiate (payload);

}

static gboolean

gst_rtp_base_payload_negotiate (GstRTPBasePayload * payload)

{

  GstCaps *templ, *peercaps, *srccaps;

  GstStructure *s, *d;

  gboolean res;

  payload->priv->caps_max_ptime = DEFAULT_MAX_PTIME;

  payload->ptime = 0;

  gst_pad_check_reconfigure (payload->srcpad);

  templ = gst_pad_get_pad_template_caps (payload->srcpad);

  if (payload->priv->subclass_srccaps) {

    GstCaps *tmp = gst_caps_intersect (payload->priv->subclass_srccaps,

        templ);

    gst_caps_unref (templ);

    templ = tmp;

  }

  peercaps = gst_pad_peer_query_caps (payload->srcpad, templ);

  if (peercaps == NULL) {

    /* no peer caps, just add the other properties */

    srccaps = gst_caps_copy (templ);

    gst_caps_set_simple (srccaps,

        "payload", G_TYPE_INT, GST_RTP_BASE_PAYLOAD_PT (payload),

        "ssrc", G_TYPE_UINT, payload->current_ssrc,

        "timestamp-offset", G_TYPE_UINT, payload->ts_base,

        "seqnum-offset", G_TYPE_UINT, payload->seqnum_base, NULL);

    GST_DEBUG_OBJECT (payload, "no peer caps: %" GST_PTR_FORMAT, srccaps);

  } else {

    GstCaps *temp;

    const GValue *value;

    gboolean have_pt = FALSE;

    gboolean have_ts_offset = FALSE;

    gboolean have_seqnum_offset = FALSE;

    guint max_ptime, ptime;

    /* peer provides caps we can use to fixate. They are already intersected

     * with our srccaps, just make them writable */

    temp = gst_caps_make_writable (peercaps);

    peercaps = NULL;

    if (gst_caps_is_empty (temp)) {

      gst_caps_unref (temp);

      gst_caps_unref (templ);

      res = FALSE;

      goto out;

    }

    /* We prefer the pt, timestamp-offset, seqnum-offset from the

     * property (if set), or any previously configured value over what

     * downstream prefers. Only if downstream can't accept that, or the

     * properties were not set, we fall back to choosing downstream's

     * preferred value

     *

     * For ssrc we prefer any value downstream suggests, otherwise

     * the property value or as a last resort a random value.

     * This difference for ssrc is implemented for retaining backwards

     * compatibility with changing rtpsession's internal-ssrc property.

     *

     * FIXME 2.0: All these properties should go away and be negotiated

     * via caps only!

     */

    /* try to use the previously set pt, or the one from the property */

    if (payload->priv->pt_set || gst_pad_has_current_caps (payload->srcpad)) {

      GstCaps *probe_caps = gst_caps_copy (templ);

      GstCaps *intersection;

      gst_caps_set_simple (probe_caps, "payload", G_TYPE_INT,

          GST_RTP_BASE_PAYLOAD_PT (payload), NULL);

      intersection = gst_caps_intersect (probe_caps, temp);

      if (!gst_caps_is_empty (intersection)) {

        GST_LOG_OBJECT (payload, "Using selected pt %d",

            GST_RTP_BASE_PAYLOAD_PT (payload));

        have_pt = TRUE;

        gst_caps_unref (temp);

        temp = intersection;

      } else {

        GST_WARNING_OBJECT (payload, "Can't use selected pt %d",

            GST_RTP_BASE_PAYLOAD_PT (payload));

        gst_caps_unref (intersection);

      }

      gst_caps_unref (probe_caps);

    }

    /* If we got no pt above, select one now */

    if (!have_pt) {

      gint pt;

      /* get first structure */

      s = gst_caps_get_structure (temp, 0);

      if (gst_structure_get_int (s, "payload", &pt)) {

        /* use peer pt */

        GST_RTP_BASE_PAYLOAD_PT (payload) = pt;

        GST_LOG_OBJECT (payload, "using peer pt %d", pt);

      } else {

        if (gst_structure_has_field (s, "payload")) {

          /* can only fixate if there is a field */

          gst_structure_fixate_field_nearest_int (s, "payload",

              GST_RTP_BASE_PAYLOAD_PT (payload));

          gst_structure_get_int (s, "payload", &pt;;

          GST_RTP_BASE_PAYLOAD_PT (payload) = pt;

          GST_LOG_OBJECT (payload, "using peer pt %d", pt);

        } else {

          /* no pt field, use the internal pt */