gst-libs/gst/rtp/gstbasertppayload.c

   1 /* GStreamer
   2  * Copyright (C) <2005> Wim Taymans <wim@fluendo.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more
  13  */
  14
  15 /**
  16  * SECTION:gstbasertppayload
  17  * @short_description: Base class for RTP payloader
  18  *
  19  * Provides a base class for RTP payloaders
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <string.h>
  27
  28 #include <gst/rtp/gstrtpbuffer.h>
  29
  30 #include "gstbasertppayload.h"
  31
  32 GST_DEBUG_CATEGORY_STATIC (basertppayload_debug);
  33 #define GST_CAT_DEFAULT (basertppayload_debug)
  34
  35 #define GST_BASE_RTP_PAYLOAD_GET_PRIVATE(obj)  \
  36    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_RTP_PAYLOAD, GstBaseRTPPayloadPrivate))
  37
  38 struct _GstBaseRTPPayloadPrivate
  39 {
  40   gboolean ts_offset_random;
  41   gboolean seqnum_offset_random;
  42   gboolean ssrc_random;
  43   guint16 next_seqnum;
  44   gboolean perfect_rtptime;
  45   gint notified_first_timestamp;
  46
  47   guint64 base_offset;
  48   gint64 base_rtime;
  49
  50   gint64 prop_max_ptime;
  51   gint64 caps_max_ptime;
  52 };
  53
  54 /* BaseRTPPayload signals and args */
  55 enum
  56 {
  57   /* FILL ME */
  58   LAST_SIGNAL
  59 };
  60
  61 /* FIXME 0.11, a better default is the Ethernet MTU of
  62  * 1500 - sizeof(headers) as pointed out by marcelm in IRC:
  63  * So an Ethernet MTU of 1500, minus 60 for the max IP, minus 8 for UDP, gives
  64  * 1432 bytes or so.  And that should be adjusted downward further for other
  65  * encapsulations like PPPoE, so 1400 at most.
  66  */
  67 #define DEFAULT_MTU                     1400
  68 #define DEFAULT_PT                      96
  69 #define DEFAULT_SSRC                    -1
  70 #define DEFAULT_TIMESTAMP_OFFSET        -1
  71 #define DEFAULT_SEQNUM_OFFSET           -1
  72 #define DEFAULT_MAX_PTIME               -1
  73 #define DEFAULT_MIN_PTIME               0
  74 #define DEFAULT_PERFECT_RTPTIME         TRUE
  75 #define DEFAULT_PTIME_MULTIPLE          0
  76
  77 enum
  78 {
  79   PROP_0,
  80   PROP_MTU,
  81   PROP_PT,
  82   PROP_SSRC,
  83   PROP_TIMESTAMP_OFFSET,
  84   PROP_SEQNUM_OFFSET,
  85   PROP_MAX_PTIME,
  86   PROP_MIN_PTIME,
  87   PROP_TIMESTAMP,
  88   PROP_SEQNUM,
  89   PROP_PERFECT_RTPTIME,
  90   PROP_PTIME_MULTIPLE,
  91   PROP_LAST
  92 };
  93
  94 static void gst_basertppayload_class_init (GstBaseRTPPayloadClass * klass);
  95 static void gst_basertppayload_base_init (GstBaseRTPPayloadClass * klass);
  96 static void gst_basertppayload_init (GstBaseRTPPayload * basertppayload,
  97     gpointer g_class);
  98 static void gst_basertppayload_finalize (GObject * object);
  99
 100 static gboolean gst_basertppayload_sink_setcaps (GstPad * pad, GstCaps * caps);
 101 static GstCaps *gst_basertppayload_sink_getcaps (GstPad * pad);
 102 static gboolean gst_basertppayload_event (GstPad * pad, GstEvent * event);
 103 static GstFlowReturn gst_basertppayload_chain (GstPad * pad,
 104     GstBuffer * buffer);
 105
 106 static void gst_basertppayload_set_property (GObject * object, guint prop_id,
 107     const GValue * value, GParamSpec * pspec);
 108 static void gst_basertppayload_get_property (GObject * object, guint prop_id,
 109     GValue * value, GParamSpec * pspec);
 110
 111 static GstStateChangeReturn gst_basertppayload_change_state (GstElement *
 112     element, GstStateChange transition);
 113
 114 static GstElementClass *parent_class = NULL;
 115
 116 /* FIXME 0.11: API should be changed to gst_base_typ_payload_xyz */
 117
 118 GType
 119 gst_basertppayload_get_type (void)
 120 {
 121   static GType basertppayload_type = 0;
 122
 123   if (!basertppayload_type) {
 124     static const GTypeInfo basertppayload_info = {
 125       sizeof (GstBaseRTPPayloadClass),
 126       (GBaseInitFunc) gst_basertppayload_base_init,
 127       NULL,
 128       (GClassInitFunc) gst_basertppayload_class_init,
 129       NULL,
 130       NULL,
 131       sizeof (GstBaseRTPPayload),
 132       0,
 133       (GInstanceInitFunc) gst_basertppayload_init,
 134     };
 135
 136     basertppayload_type =
 137         g_type_register_static (GST_TYPE_ELEMENT, "GstBaseRTPPayload",
 138         &basertppayload_info, G_TYPE_FLAG_ABSTRACT);
 139   }
 140   return basertppayload_type;
 141 }
 142
 143 static void
 144 gst_basertppayload_base_init (GstBaseRTPPayloadClass * klass)
 145 {
 146 }
 147
 148 static void
 149 gst_basertppayload_class_init (GstBaseRTPPayloadClass * klass)
 150 {
 151   GObjectClass *gobject_class;
 152   GstElementClass *gstelement_class;
 153
 154   gobject_class = (GObjectClass *) klass;
 155   gstelement_class = (GstElementClass *) klass;
 156
 157   g_type_class_add_private (klass, sizeof (GstBaseRTPPayloadPrivate));
 158
 159   parent_class = g_type_class_peek_parent (klass);
 160
 161   gobject_class->finalize = gst_basertppayload_finalize;
 162
 163   gobject_class->set_property = gst_basertppayload_set_property;
 164   gobject_class->get_property = gst_basertppayload_get_property;
 165
 166   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MTU,
 167       g_param_spec_uint ("mtu", "MTU",
 168           "Maximum size of one packet",
 169           28, G_MAXUINT, DEFAULT_MTU,
 170           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 171   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PT,
 172       g_param_spec_uint ("pt", "payload type",
 173           "The payload type of the packets", 0, 0x80, DEFAULT_PT,
 174           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 175   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SSRC,
 176       g_param_spec_uint ("ssrc", "SSRC",
 177           "The SSRC of the packets (default == random)", 0, G_MAXUINT32,
 178           DEFAULT_SSRC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 179   g_object_class_install_property (G_OBJECT_CLASS (klass),
 180       PROP_TIMESTAMP_OFFSET, g_param_spec_uint ("timestamp-offset",
 181           "Timestamp Offset",
 182           "Offset to add to all outgoing timestamps (default = random)", 0,
 183           G_MAXUINT32, DEFAULT_TIMESTAMP_OFFSET,
 184           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 185   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SEQNUM_OFFSET,
 186       g_param_spec_int ("seqnum-offset", "Sequence number Offset",
 187           "Offset to add to all outgoing seqnum (-1 = random)", -1, G_MAXUINT16,
 188           DEFAULT_SEQNUM_OFFSET, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 189   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MAX_PTIME,
 190       g_param_spec_int64 ("max-ptime", "Max packet time",
 191           "Maximum duration of the packet data in ns (-1 = unlimited up to MTU)",
 192           -1, G_MAXINT64, DEFAULT_MAX_PTIME,
 193           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 194   /**
 195    * GstBaseRTPAudioPayload:min-ptime:
 196    *
 197    * Minimum duration of the packet data in ns (can't go above MTU)
 198    *
 199    * Since: 0.10.13
 200    **/
 201   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MIN_PTIME,
 202       g_param_spec_int64 ("min-ptime", "Min packet time",
 203           "Minimum duration of the packet data in ns (can't go above MTU)",
 204           0, G_MAXINT64, DEFAULT_MIN_PTIME,
 205           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 206
 207   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TIMESTAMP,
 208       g_param_spec_uint ("timestamp", "Timestamp",
 209           "The RTP timestamp of the last processed packet",
 210           0, G_MAXUINT32, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 211   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SEQNUM,
 212       g_param_spec_uint ("seqnum", "Sequence number",
 213           "The RTP sequence number of the last processed packet",
 214           0, G_MAXUINT16, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 215
 216   /**
 217    * GstBaseRTPAudioPayload:perfect-rtptime:
 218    *
 219    * Try to use the offset fields to generate perfect RTP timestamps. when this
 220    * option is disabled, RTP timestamps are generated from the GStreamer
 221    * timestamps, which could result in RTP timestamps that don't increment with
 222    * the amount of data in the packet.
 223    *
 224    * Since: 0.10.25
 225    */
 226   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PERFECT_RTPTIME,
 227       g_param_spec_boolean ("perfect-rtptime", "Perfect RTP Time",
 228           "Generate perfect RTP timestamps when possible",
 229           DEFAULT_PERFECT_RTPTIME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 230   /**
 231    * GstBaseRTPAudioPayload:ptime-multiple:
 232    *
 233    * Force buffers to be multiples of this duration in ns (0 disables)
 234    *
 235    * Since: 0.10.29
 236    **/
 237   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PTIME_MULTIPLE,
 238       g_param_spec_int64 ("ptime-multiple", "Packet time multiple",
 239           "Force buffers to be multiples of this duration in ns (0 disables)",
 240           0, G_MAXINT64, DEFAULT_PTIME_MULTIPLE,
 241           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 242
 243   gstelement_class->change_state = gst_basertppayload_change_state;
 244
 245   GST_DEBUG_CATEGORY_INIT (basertppayload_debug, "basertppayload", 0,
 246       "Base class for RTP Payloaders");
 247 }
 248
 249 static void
 250 gst_basertppayload_init (GstBaseRTPPayload * basertppayload, gpointer g_class)
 251 {
 252   GstPadTemplate *templ;
 253   GstBaseRTPPayloadPrivate *priv;
 254
 255   basertppayload->priv = priv =
 256       GST_BASE_RTP_PAYLOAD_GET_PRIVATE (basertppayload);
 257
 258   templ =
 259       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "src");
 260   g_return_if_fail (templ != NULL);
 261
 262   basertppayload->srcpad = gst_pad_new_from_template (templ, "src");
 263   gst_element_add_pad (GST_ELEMENT (basertppayload), basertppayload->srcpad);
 264
 265   templ =
 266       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "sink");
 267   g_return_if_fail (templ != NULL);
 268
 269   basertppayload->sinkpad = gst_pad_new_from_template (templ, "sink");
 270   gst_pad_set_setcaps_function (basertppayload->sinkpad,
 271       gst_basertppayload_sink_setcaps);
 272   gst_pad_set_getcaps_function (basertppayload->sinkpad,
 273       gst_basertppayload_sink_getcaps);
 274   gst_pad_set_event_function (basertppayload->sinkpad,
 275       gst_basertppayload_event);
 276   gst_pad_set_chain_function (basertppayload->sinkpad,
 277       gst_basertppayload_chain);
 278   gst_element_add_pad (GST_ELEMENT (basertppayload), basertppayload->sinkpad);
 279
 280   basertppayload->seq_rand = g_rand_new_with_seed (g_random_int ());
 281   basertppayload->ssrc_rand = g_rand_new_with_seed (g_random_int ());
 282   basertppayload->ts_rand = g_rand_new_with_seed (g_random_int ());
 283
 284   basertppayload->mtu = DEFAULT_MTU;
 285   basertppayload->pt = DEFAULT_PT;
 286   basertppayload->seqnum_offset = DEFAULT_SEQNUM_OFFSET;
 287   basertppayload->ssrc = DEFAULT_SSRC;
 288   basertppayload->ts_offset = DEFAULT_TIMESTAMP_OFFSET;
 289   priv->seqnum_offset_random = (basertppayload->seqnum_offset == -1);
 290   priv->ts_offset_random = (basertppayload->ts_offset == -1);
 291   priv->ssrc_random = (basertppayload->ssrc == -1);
 292
 293   basertppayload->max_ptime = DEFAULT_MAX_PTIME;
 294   basertppayload->min_ptime = DEFAULT_MIN_PTIME;
 295   basertppayload->priv->perfect_rtptime = DEFAULT_PERFECT_RTPTIME;
 296   basertppayload->abidata.ABI.ptime_multiple = DEFAULT_PTIME_MULTIPLE;
 297   basertppayload->priv->base_offset = GST_BUFFER_OFFSET_NONE;
 298   basertppayload->priv->base_rtime = GST_BUFFER_OFFSET_NONE;
 299
 300   basertppayload->media = NULL;
 301   basertppayload->encoding_name = NULL;
 302
 303   basertppayload->clock_rate = 0;
 304
 305   basertppayload->priv->caps_max_ptime = DEFAULT_MAX_PTIME;
 306   basertppayload->priv->prop_max_ptime = DEFAULT_MAX_PTIME;
 307 }
 308
 309 static void
 310 gst_basertppayload_finalize (GObject * object)
 311 {
 312   GstBaseRTPPayload *basertppayload;
 313
 314   basertppayload = GST_BASE_RTP_PAYLOAD (object);
 315
 316   g_rand_free (basertppayload->seq_rand);
 317   basertppayload->seq_rand = NULL;
 318   g_rand_free (basertppayload->ssrc_rand);
 319   basertppayload->ssrc_rand = NULL;
 320   g_rand_free (basertppayload->ts_rand);
 321   basertppayload->ts_rand = NULL;
 322
 323   g_free (basertppayload->media);
 324   basertppayload->media = NULL;
 325   g_free (basertppayload->encoding_name);
 326   basertppayload->encoding_name = NULL;
 327
 328   G_OBJECT_CLASS (parent_class)->finalize (object);
 329 }
 330
 331 static gboolean
 332 gst_basertppayload_sink_setcaps (GstPad * pad, GstCaps * caps)
 333 {
 334   GstBaseRTPPayload *basertppayload;
 335   GstBaseRTPPayloadClass *basertppayload_class;
 336   gboolean ret = TRUE;
 337
 338   GST_DEBUG_OBJECT (pad, "setting caps %" GST_PTR_FORMAT, caps);
 339   basertppayload = GST_BASE_RTP_PAYLOAD (gst_pad_get_parent (pad));
 340   basertppayload_class = GST_BASE_RTP_PAYLOAD_GET_CLASS (basertppayload);
 341
 342   if (basertppayload_class->set_caps)
 343     ret = basertppayload_class->set_caps (basertppayload, caps);
 344
 345   gst_object_unref (basertppayload);
 346
 347   return ret;
 348 }
 349
 350 static GstCaps *
 351 gst_basertppayload_sink_getcaps (GstPad * pad)
 352 {
 353   GstBaseRTPPayload *basertppayload;
 354   GstBaseRTPPayloadClass *basertppayload_class;
 355   GstCaps *caps = NULL;
 356
 357   GST_DEBUG_OBJECT (pad, "getting caps");
 358
 359   basertppayload = GST_BASE_RTP_PAYLOAD (gst_pad_get_parent (pad));
 360   basertppayload_class = GST_BASE_RTP_PAYLOAD_GET_CLASS (basertppayload);
 361
 362   if (basertppayload_class->get_caps)
 363     caps = basertppayload_class->get_caps (basertppayload, pad);
 364
 365   if (!caps) {
 366     caps = GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (pad));
 367     GST_DEBUG_OBJECT (pad,
 368         "using pad template %p with caps %p %" GST_PTR_FORMAT,
 369         GST_PAD_PAD_TEMPLATE (pad), caps, caps);
 370
 371     caps = gst_caps_ref (caps);
 372   }
 373
 374   gst_object_unref (basertppayload);
 375
 376   return caps;
 377 }
 378
 379 static gboolean
 380 gst_basertppayload_event (GstPad * pad, GstEvent * event)
 381 {
 382   GstBaseRTPPayload *basertppayload;
 383   GstBaseRTPPayloadClass *basertppayload_class;
 384   gboolean res;
 385
 386   basertppayload = GST_BASE_RTP_PAYLOAD (gst_pad_get_parent (pad));
 387   if (G_UNLIKELY (basertppayload == NULL)) {
 388     gst_event_unref (event);
 389     return FALSE;
 390   }
 391   basertppayload_class = GST_BASE_RTP_PAYLOAD_GET_CLASS (basertppayload);
 392
 393   if (basertppayload_class->handle_event) {
 394     res = basertppayload_class->handle_event (pad, event);
 395     if (res)
 396       goto done;
 397   }
 398
 399   switch (GST_EVENT_TYPE (event)) {
 400     case GST_EVENT_FLUSH_START:
 401       res = gst_pad_event_default (pad, event);
 402       break;
 403     case GST_EVENT_FLUSH_STOP:
 404       res = gst_pad_event_default (pad, event);
 405       gst_segment_init (&basertppayload->segment, GST_FORMAT_UNDEFINED);
 406       break;
 407     case GST_EVENT_NEWSEGMENT:
 408     {
 409       gboolean update;
 410       gdouble rate, arate;
 411       GstFormat fmt;
 412       gint64 start, stop, position;
 413       GstSegment *segment;
 414
 415       segment = &basertppayload->segment;
 416
 417       gst_event_parse_new_segment_full (event, &update, &rate, &arate, &fmt,
 418           &start, &stop, &position);
 419       gst_segment_set_newsegment_full (segment, update, rate, arate, fmt, start,
 420           stop, position);
 421
 422       basertppayload->priv->base_offset = GST_BUFFER_OFFSET_NONE;
 423
 424       GST_DEBUG_OBJECT (basertppayload,
 425           "configured NEWSEGMENT update %d, rate %lf, applied rate %lf, "
 426           "format %d, "
 427           "%" G_GINT64_FORMAT " -- %" G_GINT64_FORMAT ", time %"
 428           G_GINT64_FORMAT ", accum %" G_GINT64_FORMAT, update, rate, arate,
 429           segment->format, segment->start, segment->stop, segment->time,
 430           segment->accum);
 431       /* fallthrough */
 432     }
 433     default:
 434       res = gst_pad_event_default (pad, event);
 435       break;
 436   }
 437
 438 done:
 439   gst_object_unref (basertppayload);
 440
 441   return res;
 442 }
 443
 444
 445 static GstFlowReturn
 446 gst_basertppayload_chain (GstPad * pad, GstBuffer * buffer)
 447 {
 448   GstBaseRTPPayload *basertppayload;
 449   GstBaseRTPPayloadClass *basertppayload_class;
 450   GstFlowReturn ret;
 451
 452   basertppayload = GST_BASE_RTP_PAYLOAD (gst_pad_get_parent (pad));
 453   basertppayload_class = GST_BASE_RTP_PAYLOAD_GET_CLASS (basertppayload);
 454
 455   if (!basertppayload_class->handle_buffer)
 456     goto no_function;
 457
 458   ret = basertppayload_class->handle_buffer (basertppayload, buffer);
 459
 460   gst_object_unref (basertppayload);
 461
 462   return ret;
 463
 464   /* ERRORS */
 465 no_function:
 466   {
 467     GST_ELEMENT_ERROR (basertppayload, STREAM, NOT_IMPLEMENTED, (NULL),
 468         ("subclass did not implement handle_buffer function"));
 469     gst_object_unref (basertppayload);
 470     gst_buffer_unref (buffer);
 471     return GST_FLOW_ERROR;
 472   }
 473 }
 474
 475 /**
 476  * gst_basertppayload_set_options:
 477  * @payload: a #GstBaseRTPPayload
 478  * @media: the media type (typically "audio" or "video")
 479  * @dynamic: if the payload type is dynamic
 480  * @encoding_name: the encoding name
 481  * @clock_rate: the clock rate of the media
 482  *
 483  * Set the rtp options of the payloader. These options will be set in the caps
 484  * of the payloader. Subclasses must call this method before calling
 485  * gst_basertppayload_push() or gst_basertppayload_set_outcaps().
 486  */
 487 void
 488 gst_basertppayload_set_options (GstBaseRTPPayload * payload,
 489     const gchar * media, gboolean dynamic, const gchar * encoding_name,
 490     guint32 clock_rate)
 491 {
 492   g_return_if_fail (payload != NULL);
 493   g_return_if_fail (clock_rate != 0);
 494
 495   g_free (payload->media);
 496   payload->media = g_strdup (media);
 497   payload->dynamic = dynamic;
 498   g_free (payload->encoding_name);
 499   payload->encoding_name = g_strdup (encoding_name);
 500   payload->clock_rate = clock_rate;
 501 }
 502
 503 static gboolean
 504 copy_fixed (GQuark field_id, const GValue * value, GstStructure * dest)
 505 {
 506   if (gst_value_is_fixed (value)) {
 507     gst_structure_id_set_value (dest, field_id, value);
 508   }
 509   return TRUE;
 510 }
 511
 512 static void
 513 update_max_ptime (GstBaseRTPPayload * basertppayload)
 514 {
 515   if (basertppayload->priv->caps_max_ptime != -1 &&
 516       basertppayload->priv->prop_max_ptime != -1)
 517     basertppayload->max_ptime = MIN (basertppayload->priv->caps_max_ptime,
 518         basertppayload->priv->prop_max_ptime);
 519   else if (basertppayload->priv->caps_max_ptime != -1)
 520     basertppayload->max_ptime = basertppayload->priv->caps_max_ptime;
 521   else if (basertppayload->priv->prop_max_ptime != -1)
 522     basertppayload->max_ptime = basertppayload->priv->prop_max_ptime;
 523   else
 524     basertppayload->max_ptime = DEFAULT_MAX_PTIME;
 525 }
 526
 527 /**
 528  * gst_basertppayload_set_outcaps:
 529  * @payload: a #GstBaseRTPPayload
 530  * @fieldname: the first field name or %NULL
 531  * @...: field values
 532  *
 533  * Configure the output caps with the optional parameters.
 534  *
 535  * Variable arguments should be in the form field name, field type
 536  * (as a GType), value(s).  The last variable argument should be NULL.
 537  *
 538  * Returns: %TRUE if the caps could be set.
 539  */
 540 gboolean
 541 gst_basertppayload_set_outcaps (GstBaseRTPPayload * payload,
 542     const gchar * fieldname, ...)
 543 {
 544   GstCaps *srccaps, *peercaps;
 545   gboolean res;
 546
 547   /* fill in the defaults, their properties cannot be negotiated. */
 548   srccaps = gst_caps_new_simple ("application/x-rtp",
 549       "media", G_TYPE_STRING, payload->media,
 550       "clock-rate", G_TYPE_INT, payload->clock_rate,
 551       "encoding-name", G_TYPE_STRING, payload->encoding_name, NULL);
 552
 553   GST_DEBUG_OBJECT (payload, "defaults: %" GST_PTR_FORMAT, srccaps);
 554
 555   if (fieldname) {
 556     va_list varargs;
 557
 558     /* override with custom properties */
 559     va_start (varargs, fieldname);
 560     gst_caps_set_simple_valist (srccaps, fieldname, varargs);
 561     va_end (varargs);
 562
 563     GST_DEBUG_OBJECT (payload, "custom added: %" GST_PTR_FORMAT, srccaps);
 564   }
 565
 566   payload->priv->caps_max_ptime = DEFAULT_MAX_PTIME;
 567   payload->abidata.ABI.ptime = 0;
 568
 569   /* the peer caps can override some of the defaults */
 570   peercaps = gst_pad_peer_get_caps (payload->srcpad);
 571   if (peercaps == NULL) {
 572     /* no peer caps, just add the other properties */
 573     gst_caps_set_simple (srccaps,
 574         "payload", G_TYPE_INT, GST_BASE_RTP_PAYLOAD_PT (payload),
 575         "ssrc", G_TYPE_UINT, payload->current_ssrc,
 576         "clock-base", G_TYPE_UINT, payload->ts_base,
 577         "seqnum-base", G_TYPE_UINT, payload->seqnum_base, NULL);
 578
 579     GST_DEBUG_OBJECT (payload, "no peer caps: %" GST_PTR_FORMAT, srccaps);
 580   } else {
 581     GstCaps *temp;
 582     GstStructure *s, *d;
 583     const GValue *value;
 584     gint pt;
 585     guint max_ptime, ptime;
 586
 587     /* peer provides caps we can use to fixate, intersect. This always returns a
 588      * writable caps. */
 589     temp = gst_caps_intersect (srccaps, peercaps);
 590     gst_caps_unref (srccaps);
 591     gst_caps_unref (peercaps);
 592
 593     if (gst_caps_is_empty (temp)) {
 594       gst_caps_unref (temp);
 595       return FALSE;
 596     }
 597
 598     /* now fixate, start by taking the first caps */
 599     gst_caps_truncate (temp);
 600
 601     /* get first structure */
 602     s = gst_caps_get_structure (temp, 0);
 603
 604     if (gst_structure_get_uint (s, "maxptime", &max_ptime))
 605       payload->priv->caps_max_ptime = max_ptime * GST_MSECOND;
 606
 607     if (gst_structure_get_uint (s, "ptime", &ptime))
 608       payload->abidata.ABI.ptime = ptime * GST_MSECOND;
 609
 610     if (gst_structure_get_int (s, "payload", &pt)) {
 611       /* use peer pt */
 612       GST_BASE_RTP_PAYLOAD_PT (payload) = pt;
 613       GST_LOG_OBJECT (payload, "using peer pt %d", pt);
 614     } else {
 615       if (gst_structure_has_field (s, "payload")) {
 616         /* can only fixate if there is a field */
 617         gst_structure_fixate_field_nearest_int (s, "payload",
 618             GST_BASE_RTP_PAYLOAD_PT (payload));
 619         gst_structure_get_int (s, "payload", &pt);
 620         GST_LOG_OBJECT (payload, "using peer pt %d", pt);
 621       } else {
 622         /* no pt field, use the internal pt */
 623         pt = GST_BASE_RTP_PAYLOAD_PT (payload);
 624         gst_structure_set (s, "payload", G_TYPE_INT, pt, NULL);
 625         GST_LOG_OBJECT (payload, "using internal pt %d", pt);
 626       }
 627     }
 628
 629     if (gst_structure_has_field_typed (s, "ssrc", G_TYPE_UINT)) {
 630       value = gst_structure_get_value (s, "ssrc");
 631       payload->current_ssrc = g_value_get_uint (value);
 632       GST_LOG_OBJECT (payload, "using peer ssrc %08x", payload->current_ssrc);
 633     } else {
 634       /* FIXME, fixate_nearest_uint would be even better */
 635       gst_structure_set (s, "ssrc", G_TYPE_UINT, payload->current_ssrc, NULL);
 636       GST_LOG_OBJECT (payload, "using internal ssrc %08x",
 637           payload->current_ssrc);
 638     }
 639
 640     if (gst_structure_has_field_typed (s, "clock-base", G_TYPE_UINT)) {
 641       value = gst_structure_get_value (s, "clock-base");
 642       payload->ts_base = g_value_get_uint (value);
 643       GST_LOG_OBJECT (payload, "using peer clock-base %u", payload->ts_base);
 644     } else {
 645       /* FIXME, fixate_nearest_uint would be even better */
 646       gst_structure_set (s, "clock-base", G_TYPE_UINT, payload->ts_base, NULL);
 647       GST_LOG_OBJECT (payload, "using internal clock-base %u",
 648           payload->ts_base);
 649     }
 650     if (gst_structure_has_field_typed (s, "seqnum-base", G_TYPE_UINT)) {
 651       value = gst_structure_get_value (s, "seqnum-base");
 652       payload->seqnum_base = g_value_get_uint (value);
 653       GST_LOG_OBJECT (payload, "using peer seqnum-base %u",
 654           payload->seqnum_base);
 655     } else {
 656       /* FIXME, fixate_nearest_uint would be even better */
 657       gst_structure_set (s, "seqnum-base", G_TYPE_UINT, payload->seqnum_base,
 658           NULL);
 659       GST_LOG_OBJECT (payload, "using internal seqnum-base %u",
 660           payload->seqnum_base);
 661     }
 662
 663     /* make the target caps by copying over all the fixed caps, removing the
 664      * unfixed caps. */
 665     srccaps = gst_caps_new_simple (gst_structure_get_name (s), NULL);
 666     d = gst_caps_get_structure (srccaps, 0);
 667
 668     gst_structure_foreach (s, (GstStructureForeachFunc) copy_fixed, d);
 669
 670     gst_caps_unref (temp);
 671
 672     GST_DEBUG_OBJECT (payload, "with peer caps: %" GST_PTR_FORMAT, srccaps);
 673   }
 674
 675   update_max_ptime (payload);
 676
 677   res = gst_pad_set_caps (GST_BASE_RTP_PAYLOAD_SRCPAD (payload), srccaps);
 678   gst_caps_unref (srccaps);
 679
 680   return res;
 681 }
 682
 683 /**
 684  * gst_basertppayload_is_filled:
 685  * @payload: a #GstBaseRTPPayload
 686  * @size: the size of the packet
 687  * @duration: the duration of the packet
 688  *
 689  * Check if the packet with @size and @duration would exceed the configured
 690  * maximum size.
 691  *
 692  * Returns: %TRUE if the packet of @size and @duration would exceed the
 693  * configured MTU or max_ptime.
 694  */
 695 gboolean
 696 gst_basertppayload_is_filled (GstBaseRTPPayload * payload,
 697     guint size, GstClockTime duration)
 698 {
 699   if (size > payload->mtu)
 700     return TRUE;
 701
 702   if (payload->max_ptime != -1 && duration >= payload->max_ptime)
 703     return TRUE;
 704
 705   return FALSE;
 706 }
 707
 708 typedef struct
 709 {
 710   GstBaseRTPPayload *payload;
 711   guint32 ssrc;
 712   guint16 seqnum;
 713   guint8 pt;
 714   GstCaps *caps;
 715   GstClockTime timestamp;
 716   guint64 offset;
 717   guint32 rtptime;
 718 } HeaderData;
 719
 720 static GstBufferListItem
 721 find_timestamp (GstBuffer ** buffer, guint group, guint idx, HeaderData * data)
 722 {
 723   data->timestamp = GST_BUFFER_TIMESTAMP (*buffer);
 724   data->offset = GST_BUFFER_OFFSET (*buffer);
 725
 726   /* stop when we find a timestamp. We take whatever offset is associated with
 727    * the timestamp (if any) to do perfect timestamps when we need to. */
 728   if (data->timestamp != -1)
 729     return GST_BUFFER_LIST_END;
 730   else
 731     return GST_BUFFER_LIST_CONTINUE;
 732 }
 733
 734 static GstBufferListItem
 735 set_headers (GstBuffer ** buffer, guint group, guint idx, HeaderData * data)
 736 {
 737   gst_rtp_buffer_set_ssrc (*buffer, data->ssrc);
 738   gst_rtp_buffer_set_payload_type (*buffer, data->pt);
 739   gst_rtp_buffer_set_seq (*buffer, data->seqnum);
 740   gst_rtp_buffer_set_timestamp (*buffer, data->rtptime);
 741   gst_buffer_set_caps (*buffer, data->caps);
 742   /* increment the seqnum for each buffer */
 743   data->seqnum++;
 744
 745   return GST_BUFFER_LIST_SKIP_GROUP;
 746 }
 747
 748 /* Updates the SSRC, payload type, seqnum and timestamp of the RTP buffer
 749  * before the buffer is pushed. */
 750 static GstFlowReturn
 751 gst_basertppayload_prepare_push (GstBaseRTPPayload * payload,
 752     gpointer obj, gboolean is_list)
 753 {
 754   GstBaseRTPPayloadPrivate *priv;
 755   HeaderData data;
 756
 757   if (payload->clock_rate == 0)
 758     goto no_rate;
 759
 760   priv = payload->priv;
 761
 762   /* update first, so that the property is set to the last
 763    * seqnum pushed */
 764   payload->seqnum = priv->next_seqnum;
 765
 766   /* fill in the fields we want to set on all headers */
 767   data.payload = payload;
 768   data.seqnum = payload->seqnum;
 769   data.ssrc = payload->current_ssrc;
 770   data.pt = payload->pt;
 771   data.caps = GST_PAD_CAPS (payload->srcpad);
 772
 773   /* find the first buffer with a timestamp */
 774   if (is_list) {
 775     data.timestamp = -1;
 776     data.offset = GST_BUFFER_OFFSET_NONE;
 777     gst_buffer_list_foreach (GST_BUFFER_LIST_CAST (obj),
 778         (GstBufferListFunc) find_timestamp, &data);
 779   } else {
 780     data.timestamp = GST_BUFFER_TIMESTAMP (GST_BUFFER_CAST (obj));
 781     data.offset = GST_BUFFER_OFFSET (GST_BUFFER_CAST (obj));
 782   }
 783
 784   /* convert to RTP time */
 785   if (priv->perfect_rtptime && data.offset != GST_BUFFER_OFFSET_NONE &&
 786       priv->base_offset != GST_BUFFER_OFFSET_NONE) {
 787     /* if we have an offset, use that for making an RTP timestamp */
 788     data.rtptime = payload->ts_base + priv->base_rtime +
 789         data.offset - priv->base_offset;
 790     GST_LOG_OBJECT (payload,
 791         "Using offset %" G_GUINT64_FORMAT " for RTP timestamp", data.offset);
 792   } else if (GST_CLOCK_TIME_IS_VALID (data.timestamp)) {
 793     gint64 rtime;
 794
 795     /* no offset, use the gstreamer timestamp */
 796     rtime = gst_segment_to_running_time (&payload->segment, GST_FORMAT_TIME,
 797         data.timestamp);
 798
 799     if (rtime == -1) {
 800       GST_LOG_OBJECT (payload, "Clipped timestamp, using base RTP timestamp");
 801       rtime = 0;
 802     } else {
 803       GST_LOG_OBJECT (payload,
 804           "Using running_time %" GST_TIME_FORMAT " for RTP timestamp",
 805           GST_TIME_ARGS (rtime));
 806       rtime =
 807           gst_util_uint64_scale_int (rtime, payload->clock_rate, GST_SECOND);
 808       priv->base_offset = data.offset;
 809       priv->base_rtime = rtime;
 810     }
 811     /* add running_time in clock-rate units to the base timestamp */
 812     data.rtptime = payload->ts_base + rtime;
 813   } else {
 814     GST_LOG_OBJECT (payload,
 815         "Using previous RTP timestamp %" G_GUINT32_FORMAT, payload->timestamp);
 816     /* no timestamp to convert, take previous timestamp */
 817     data.rtptime = payload->timestamp;
 818   }
 819
 820   /* set ssrc, payload type, seq number, caps and rtptime */
 821   if (is_list) {
 822     gst_buffer_list_foreach (GST_BUFFER_LIST_CAST (obj),
 823         (GstBufferListFunc) set_headers, &data);
 824   } else {
 825     GstBuffer *buf = GST_BUFFER_CAST (obj);
 826     set_headers (&buf, 0, 0, &data);
 827   }
 828
 829   priv->next_seqnum = data.seqnum;
 830   payload->timestamp = data.rtptime;
 831
 832   GST_LOG_OBJECT (payload,
 833       "Preparing to push packet with size %d, seq=%d, rtptime=%u, timestamp %"
 834       GST_TIME_FORMAT, (is_list) ? -1 :
 835       GST_BUFFER_SIZE (GST_BUFFER (obj)), payload->seqnum, data.rtptime,
 836       GST_TIME_ARGS (data.timestamp));
 837
 838   if (g_atomic_int_compare_and_exchange (&payload->
 839           priv->notified_first_timestamp, 1, 0)) {
 840     g_object_notify (G_OBJECT (payload), "timestamp");
 841     g_object_notify (G_OBJECT (payload), "seqnum");
 842   }
 843
 844   return GST_FLOW_OK;
 845
 846   /* ERRORS */
 847 no_rate:
 848   {
 849     GST_ELEMENT_ERROR (payload, STREAM, NOT_IMPLEMENTED, (NULL),
 850         ("subclass did not specify clock-rate"));
 851     return GST_FLOW_ERROR;
 852   }
 853 }
 854
 855 /**
 856  * gst_basertppayload_push_list:
 857  * @payload: a #GstBaseRTPPayload
 858  * @list: a #GstBufferList
 859  *
 860  * Push @list to the peer element of the payloader. The SSRC, payload type,
 861  * seqnum and timestamp of the RTP buffer will be updated first.
 862  *
 863  * This function takes ownership of @list.
 864  *
 865  * Returns: a #GstFlowReturn.
 866  *
 867  * Since: 0.10.24
 868  */
 869 GstFlowReturn
 870 gst_basertppayload_push_list (GstBaseRTPPayload * payload, GstBufferList * list)
 871 {
 872   GstFlowReturn res;
 873
 874   res = gst_basertppayload_prepare_push (payload, list, TRUE);
 875
 876   if (G_LIKELY (res == GST_FLOW_OK))
 877     res = gst_pad_push_list (payload->srcpad, list);
 878   else
 879     gst_buffer_list_unref (list);
 880
 881   return res;
 882 }
 883
 884 /**
 885  * gst_basertppayload_push:
 886  * @payload: a #GstBaseRTPPayload
 887  * @buffer: a #GstBuffer
 888  *
 889  * Push @buffer to the peer element of the payloader. The SSRC, payload type,
 890  * seqnum and timestamp of the RTP buffer will be updated first.
 891  *
 892  * This function takes ownership of @buffer.
 893  *
 894  * Returns: a #GstFlowReturn.
 895  */
 896 GstFlowReturn
 897 gst_basertppayload_push (GstBaseRTPPayload * payload, GstBuffer * buffer)
 898 {
 899   GstFlowReturn res;
 900
 901   res = gst_basertppayload_prepare_push (payload, buffer, FALSE);
 902
 903   if (G_LIKELY (res == GST_FLOW_OK))
 904     res = gst_pad_push (payload->srcpad, buffer);
 905   else
 906     gst_buffer_unref (buffer);
 907
 908   return res;
 909 }
 910
 911 static void
 912 gst_basertppayload_set_property (GObject * object, guint prop_id,
 913     const GValue * value, GParamSpec * pspec)
 914 {
 915   GstBaseRTPPayload *basertppayload;
 916   GstBaseRTPPayloadPrivate *priv;
 917   gint64 val;
 918
 919   basertppayload = GST_BASE_RTP_PAYLOAD (object);
 920   priv = basertppayload->priv;
 921
 922   switch (prop_id) {
 923     case PROP_MTU:
 924       basertppayload->mtu = g_value_get_uint (value);
 925       break;
 926     case PROP_PT:
 927       basertppayload->pt = g_value_get_uint (value);
 928       break;
 929     case PROP_SSRC:
 930       val = g_value_get_uint (value);
 931       basertppayload->ssrc = val;
 932       priv->ssrc_random = FALSE;
 933       break;
 934     case PROP_TIMESTAMP_OFFSET:
 935       val = g_value_get_uint (value);
 936       basertppayload->ts_offset = val;
 937       priv->ts_offset_random = FALSE;
 938       break;
 939     case PROP_SEQNUM_OFFSET:
 940       val = g_value_get_int (value);
 941       basertppayload->seqnum_offset = val;
 942       priv->seqnum_offset_random = (val == -1);
 943       GST_DEBUG_OBJECT (basertppayload, "seqnum offset 0x%04x, random %d",
 944           basertppayload->seqnum_offset, priv->seqnum_offset_random);
 945       break;
 946     case PROP_MAX_PTIME:
 947       basertppayload->priv->prop_max_ptime = g_value_get_int64 (value);
 948       update_max_ptime (basertppayload);
 949       break;
 950     case PROP_MIN_PTIME:
 951       basertppayload->min_ptime = g_value_get_int64 (value);
 952       break;
 953     case PROP_PERFECT_RTPTIME:
 954       priv->perfect_rtptime = g_value_get_boolean (value);
 955       break;
 956     case PROP_PTIME_MULTIPLE:
 957       basertppayload->abidata.ABI.ptime_multiple = g_value_get_int64 (value);
 958       break;
 959     default:
 960       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 961       break;
 962   }
 963 }
 964
 965 static void
 966 gst_basertppayload_get_property (GObject * object, guint prop_id,
 967     GValue * value, GParamSpec * pspec)
 968 {
 969   GstBaseRTPPayload *basertppayload;
 970   GstBaseRTPPayloadPrivate *priv;
 971
 972   basertppayload = GST_BASE_RTP_PAYLOAD (object);
 973   priv = basertppayload->priv;
 974
 975   switch (prop_id) {
 976     case PROP_MTU:
 977       g_value_set_uint (value, basertppayload->mtu);
 978       break;
 979     case PROP_PT:
 980       g_value_set_uint (value, basertppayload->pt);
 981       break;
 982     case PROP_SSRC:
 983       if (priv->ssrc_random)
 984         g_value_set_uint (value, -1);
 985       else
 986         g_value_set_uint (value, basertppayload->ssrc);
 987       break;
 988     case PROP_TIMESTAMP_OFFSET:
 989       if (priv->ts_offset_random)
 990         g_value_set_uint (value, -1);
 991       else
 992         g_value_set_uint (value, (guint32) basertppayload->ts_offset);
 993       break;
 994     case PROP_SEQNUM_OFFSET:
 995       if (priv->seqnum_offset_random)
 996         g_value_set_int (value, -1);
 997       else
 998         g_value_set_int (value, (guint16) basertppayload->seqnum_offset);
 999       break;
1000     case PROP_MAX_PTIME:
1001       g_value_set_int64 (value, basertppayload->max_ptime);
1002       break;
1003     case PROP_MIN_PTIME:
1004       g_value_set_int64 (value, basertppayload->min_ptime);
1005       break;
1006     case PROP_TIMESTAMP:
1007       g_value_set_uint (value, basertppayload->timestamp);
1008       break;
1009     case PROP_SEQNUM:
1010       g_value_set_uint (value, basertppayload->seqnum);
1011       break;
1012     case PROP_PERFECT_RTPTIME:
1013       g_value_set_boolean (value, priv->perfect_rtptime);
1014       break;
1015     case PROP_PTIME_MULTIPLE:
1016       g_value_set_int64 (value, basertppayload->abidata.ABI.ptime_multiple);
1017       break;
1018     default:
1019       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1020       break;
1021   }
1022 }
1023
1024 static GstStateChangeReturn
1025 gst_basertppayload_change_state (GstElement * element,
1026     GstStateChange transition)
1027 {
1028   GstBaseRTPPayload *basertppayload;
1029   GstBaseRTPPayloadPrivate *priv;
1030   GstStateChangeReturn ret;
1031
1032   basertppayload = GST_BASE_RTP_PAYLOAD (element);
1033   priv = basertppayload->priv;
1034
1035   switch (transition) {
1036     case GST_STATE_CHANGE_NULL_TO_READY:
1037       break;
1038     case GST_STATE_CHANGE_READY_TO_PAUSED:
1039       gst_segment_init (&basertppayload->segment, GST_FORMAT_UNDEFINED);
1040
1041       if (priv->seqnum_offset_random)
1042         basertppayload->seqnum_base = g_random_int_range (0, G_MAXUINT16);
1043       else
1044         basertppayload->seqnum_base = basertppayload->seqnum_offset;
1045       priv->next_seqnum = basertppayload->seqnum_base;
1046       basertppayload->seqnum = basertppayload->seqnum_base;
1047
1048       if (priv->ssrc_random)
1049         basertppayload->current_ssrc = g_random_int ();
1050       else
1051         basertppayload->current_ssrc = basertppayload->ssrc;
1052
1053       if (priv->ts_offset_random)
1054         basertppayload->ts_base = g_random_int ();
1055       else
1056         basertppayload->ts_base = basertppayload->ts_offset;
1057       basertppayload->timestamp = basertppayload->ts_base;
1058       g_atomic_int_set (&basertppayload->priv->notified_first_timestamp, 1);
1059       priv->base_offset = GST_BUFFER_OFFSET_NONE;
1060       break;
1061     default:
1062       break;
1063   }
1064
1065   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1066
1067   switch (transition) {
1068     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1069       g_atomic_int_set (&basertppayload->priv->notified_first_timestamp, 1);
1070       break;
1071     case GST_STATE_CHANGE_READY_TO_NULL:
1072       break;
1073     default:
1074       break;
1075   }
1076   return ret;
1077 }