gst/rtp/gstrtpvorbispay.c

   1 /* GStreamer
   2  * Copyright (C) <2006> Wim Taymans <wim.taymans@gmail.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 details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include <string.h>
  25
  26 #include <gst/rtp/gstrtpbuffer.h>
  27 #include <gst/audio/audio.h>
  28
  29 #include "fnv1hash.h"
  30 #include "gstrtpvorbispay.h"
  31 #include "gstrtputils.h"
  32
  33 GST_DEBUG_CATEGORY_STATIC (rtpvorbispay_debug);
  34 #define GST_CAT_DEFAULT (rtpvorbispay_debug)
  35
  36 /* references:
  37  * http://www.rfc-editor.org/rfc/rfc5215.txt
  38  */
  39
  40 static GstStaticPadTemplate gst_rtp_vorbis_pay_src_template =
  41 GST_STATIC_PAD_TEMPLATE ("src",
  42     GST_PAD_SRC,
  43     GST_PAD_ALWAYS,
  44     GST_STATIC_CAPS ("application/x-rtp, "
  45         "media = (string) \"audio\", "
  46         "payload = (int) " GST_RTP_PAYLOAD_DYNAMIC_STRING ", "
  47         "clock-rate = (int) [1, MAX ], " "encoding-name = (string) \"VORBIS\""
  48         /* All required parameters
  49          *
  50          * "encoding-params = (string) <num channels>"
  51          * "configuration = (string) ANY"
  52          */
  53     )
  54     );
  55
  56 static GstStaticPadTemplate gst_rtp_vorbis_pay_sink_template =
  57 GST_STATIC_PAD_TEMPLATE ("sink",
  58     GST_PAD_SINK,
  59     GST_PAD_ALWAYS,
  60     GST_STATIC_CAPS ("audio/x-vorbis")
  61     );
  62
  63 #define DEFAULT_CONFIG_INTERVAL 0
  64
  65 enum
  66 {
  67   PROP_0,
  68   PROP_CONFIG_INTERVAL
  69 };
  70
  71 #define gst_rtp_vorbis_pay_parent_class parent_class
  72 G_DEFINE_TYPE (GstRtpVorbisPay, gst_rtp_vorbis_pay, GST_TYPE_RTP_BASE_PAYLOAD);
  73
  74 static gboolean gst_rtp_vorbis_pay_setcaps (GstRTPBasePayload * basepayload,
  75     GstCaps * caps);
  76 static GstStateChangeReturn gst_rtp_vorbis_pay_change_state (GstElement *
  77     element, GstStateChange transition);
  78 static GstFlowReturn gst_rtp_vorbis_pay_handle_buffer (GstRTPBasePayload * pad,
  79     GstBuffer * buffer);
  80 static gboolean gst_rtp_vorbis_pay_sink_event (GstRTPBasePayload * payload,
  81     GstEvent * event);
  82
  83 static gboolean gst_rtp_vorbis_pay_parse_id (GstRTPBasePayload * basepayload,
  84     guint8 * data, guint size);
  85 static gboolean gst_rtp_vorbis_pay_finish_headers (GstRTPBasePayload *
  86     basepayload);
  87
  88 static void gst_rtp_vorbis_pay_set_property (GObject * object, guint prop_id,
  89     const GValue * value, GParamSpec * pspec);
  90 static void gst_rtp_vorbis_pay_get_property (GObject * object, guint prop_id,
  91     GValue * value, GParamSpec * pspec);
  92
  93 static void
  94 gst_rtp_vorbis_pay_class_init (GstRtpVorbisPayClass * klass)
  95 {
  96   GObjectClass *gobject_class;
  97   GstElementClass *gstelement_class;
  98   GstRTPBasePayloadClass *gstrtpbasepayload_class;
  99
 100   gobject_class = (GObjectClass *) klass;
 101   gstelement_class = (GstElementClass *) klass;
 102   gstrtpbasepayload_class = (GstRTPBasePayloadClass *) klass;
 103
 104   gstelement_class->change_state = gst_rtp_vorbis_pay_change_state;
 105
 106   gstrtpbasepayload_class->set_caps = gst_rtp_vorbis_pay_setcaps;
 107   gstrtpbasepayload_class->handle_buffer = gst_rtp_vorbis_pay_handle_buffer;
 108   gstrtpbasepayload_class->sink_event = gst_rtp_vorbis_pay_sink_event;
 109
 110   gobject_class->set_property = gst_rtp_vorbis_pay_set_property;
 111   gobject_class->get_property = gst_rtp_vorbis_pay_get_property;
 112
 113   gst_element_class_add_static_pad_template (gstelement_class,
 114       &gst_rtp_vorbis_pay_src_template);
 115   gst_element_class_add_static_pad_template (gstelement_class,
 116       &gst_rtp_vorbis_pay_sink_template);
 117
 118   gst_element_class_set_static_metadata (gstelement_class,
 119       "RTP Vorbis payloader",
 120       "Codec/Payloader/Network/RTP",
 121       "Payload-encode Vorbis audio into RTP packets (RFC 5215)",
 122       "Wim Taymans <wim.taymans@gmail.com>");
 123
 124   GST_DEBUG_CATEGORY_INIT (rtpvorbispay_debug, "rtpvorbispay", 0,
 125       "Vorbis RTP Payloader");
 126
 127   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_CONFIG_INTERVAL,
 128       g_param_spec_uint ("config-interval", "Config Send Interval",
 129           "Send Config Insertion Interval in seconds (configuration headers "
 130           "will be multiplexed in the data stream when detected.) (0 = disabled)",
 131           0, 3600, DEFAULT_CONFIG_INTERVAL,
 132           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
 133       );
 134 }
 135
 136 static void
 137 gst_rtp_vorbis_pay_init (GstRtpVorbisPay * rtpvorbispay)
 138 {
 139   rtpvorbispay->last_config = GST_CLOCK_TIME_NONE;
 140 }
 141
 142 static void
 143 gst_rtp_vorbis_pay_clear_packet (GstRtpVorbisPay * rtpvorbispay)
 144 {
 145   if (rtpvorbispay->packet)
 146     gst_buffer_unref (rtpvorbispay->packet);
 147   rtpvorbispay->packet = NULL;
 148   g_list_free_full (rtpvorbispay->packet_buffers,
 149       (GDestroyNotify) gst_buffer_unref);
 150   rtpvorbispay->packet_buffers = NULL;
 151 }
 152
 153 static void
 154 gst_rtp_vorbis_pay_cleanup (GstRtpVorbisPay * rtpvorbispay)
 155 {
 156   gst_rtp_vorbis_pay_clear_packet (rtpvorbispay);
 157   g_list_free_full (rtpvorbispay->headers, (GDestroyNotify) gst_buffer_unref);
 158   rtpvorbispay->headers = NULL;
 159   g_free (rtpvorbispay->config_data);
 160   rtpvorbispay->config_data = NULL;
 161   rtpvorbispay->last_config = GST_CLOCK_TIME_NONE;
 162 }
 163
 164 static gboolean
 165 gst_rtp_vorbis_pay_setcaps (GstRTPBasePayload * basepayload, GstCaps * caps)
 166 {
 167   GstRtpVorbisPay *rtpvorbispay;
 168   GstStructure *s;
 169   const GValue *array;
 170   gint asize, i;
 171   GstBuffer *buf;
 172   GstMapInfo map;
 173
 174   rtpvorbispay = GST_RTP_VORBIS_PAY (basepayload);
 175
 176   s = gst_caps_get_structure (caps, 0);
 177
 178   rtpvorbispay->need_headers = TRUE;
 179
 180   if ((array = gst_structure_get_value (s, "streamheader")) == NULL)
 181     goto done;
 182
 183   if (G_VALUE_TYPE (array) != GST_TYPE_ARRAY)
 184     goto done;
 185
 186   if ((asize = gst_value_array_get_size (array)) < 3)
 187     goto done;
 188
 189   for (i = 0; i < asize; i++) {
 190     const GValue *value;
 191
 192     value = gst_value_array_get_value (array, i);
 193     if ((buf = gst_value_get_buffer (value)) == NULL)
 194       goto null_buffer;
 195
 196     gst_buffer_map (buf, &map, GST_MAP_READ);
 197     if (map.size < 1)
 198       goto invalid_streamheader;
 199
 200     /* no data packets allowed */
 201     if ((map.data[0] & 1) == 0)
 202       goto invalid_streamheader;
 203
 204     /* we need packets with id 1, 3, 5 */
 205     if (map.data[0] != (i * 2) + 1)
 206       goto invalid_streamheader;
 207
 208     if (i == 0) {
 209       /* identification, we need to parse this in order to get the clock rate. */
 210       if (G_UNLIKELY (!gst_rtp_vorbis_pay_parse_id (basepayload, map.data,
 211                   map.size)))
 212         goto parse_id_failed;
 213     }
 214     GST_DEBUG_OBJECT (rtpvorbispay, "collecting header %d", i);
 215     rtpvorbispay->headers =
 216         g_list_append (rtpvorbispay->headers, gst_buffer_ref (buf));
 217     gst_buffer_unmap (buf, &map);
 218   }
 219   if (!gst_rtp_vorbis_pay_finish_headers (basepayload))
 220     goto finish_failed;
 221
 222 done:
 223   return TRUE;
 224
 225   /* ERRORS */
 226 null_buffer:
 227   {
 228     GST_WARNING_OBJECT (rtpvorbispay, "streamheader with null buffer received");
 229     return FALSE;
 230   }
 231 invalid_streamheader:
 232   {
 233     GST_WARNING_OBJECT (rtpvorbispay, "unable to parse initial header");
 234     gst_buffer_unmap (buf, &map);
 235     return FALSE;
 236   }
 237 parse_id_failed:
 238   {
 239     GST_WARNING_OBJECT (rtpvorbispay, "unable to parse initial header");
 240     gst_buffer_unmap (buf, &map);
 241     return FALSE;
 242   }
 243 finish_failed:
 244   {
 245     GST_WARNING_OBJECT (rtpvorbispay, "unable to finish headers");
 246     return FALSE;
 247   }
 248 }
 249
 250 static void
 251 gst_rtp_vorbis_pay_reset_packet (GstRtpVorbisPay * rtpvorbispay, guint8 VDT)
 252 {
 253   guint payload_len;
 254   GstRTPBuffer rtp = { NULL };
 255
 256   GST_LOG_OBJECT (rtpvorbispay, "reset packet");
 257
 258   rtpvorbispay->payload_pos = 4;
 259   gst_rtp_buffer_map (rtpvorbispay->packet, GST_MAP_READ, &rtp);
 260   payload_len = gst_rtp_buffer_get_payload_len (&rtp);
 261   gst_rtp_buffer_unmap (&rtp);
 262   rtpvorbispay->payload_left = payload_len - 4;
 263   rtpvorbispay->payload_duration = 0;
 264   rtpvorbispay->payload_F = 0;
 265   rtpvorbispay->payload_VDT = VDT;
 266   rtpvorbispay->payload_pkts = 0;
 267 }
 268
 269 static void
 270 gst_rtp_vorbis_pay_init_packet (GstRtpVorbisPay * rtpvorbispay, guint8 VDT,
 271     GstClockTime timestamp)
 272 {
 273   GST_LOG_OBJECT (rtpvorbispay, "starting new packet, VDT: %d", VDT);
 274
 275   gst_rtp_vorbis_pay_clear_packet (rtpvorbispay);
 276
 277   /* new packet allocate max packet size */
 278   rtpvorbispay->packet =
 279       gst_rtp_buffer_new_allocate_len (GST_RTP_BASE_PAYLOAD_MTU
 280       (rtpvorbispay), 0, 0);
 281   gst_rtp_vorbis_pay_reset_packet (rtpvorbispay, VDT);
 282
 283   GST_BUFFER_PTS (rtpvorbispay->packet) = timestamp;
 284 }
 285
 286 static GstFlowReturn
 287 gst_rtp_vorbis_pay_flush_packet (GstRtpVorbisPay * rtpvorbispay)
 288 {
 289   GstFlowReturn ret;
 290   guint8 *payload;
 291   guint hlen;
 292   GstRTPBuffer rtp = { NULL };
 293   GList *l;
 294
 295   /* check for empty packet */
 296   if (!rtpvorbispay->packet || rtpvorbispay->payload_pos <= 4)
 297     return GST_FLOW_OK;
 298
 299   GST_LOG_OBJECT (rtpvorbispay, "flushing packet");
 300
 301   gst_rtp_buffer_map (rtpvorbispay->packet, GST_MAP_WRITE, &rtp);
 302
 303   /* fix header */
 304   payload = gst_rtp_buffer_get_payload (&rtp);
 305   /*
 306    *  0                   1                   2                   3
 307    *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 308    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 309    * |                     Ident                     | F |VDT|# pkts.|
 310    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 311    *
 312    * F: Fragment type (0=none, 1=start, 2=cont, 3=end)
 313    * VDT: Vorbis data type (0=vorbis, 1=config, 2=comment, 3=reserved)
 314    * pkts: number of packets.
 315    */
 316   payload[0] = (rtpvorbispay->payload_ident >> 16) & 0xff;
 317   payload[1] = (rtpvorbispay->payload_ident >> 8) & 0xff;
 318   payload[2] = (rtpvorbispay->payload_ident) & 0xff;
 319   payload[3] = (rtpvorbispay->payload_F & 0x3) << 6 |
 320       (rtpvorbispay->payload_VDT & 0x3) << 4 |
 321       (rtpvorbispay->payload_pkts & 0xf);
 322
 323   gst_rtp_buffer_unmap (&rtp);
 324
 325   /* shrink the buffer size to the last written byte */
 326   hlen = gst_rtp_buffer_calc_header_len (0);
 327   gst_buffer_resize (rtpvorbispay->packet, 0, hlen + rtpvorbispay->payload_pos);
 328
 329   GST_BUFFER_DURATION (rtpvorbispay->packet) = rtpvorbispay->payload_duration;
 330
 331   for (l = g_list_last (rtpvorbispay->packet_buffers); l; l = l->prev) {
 332     GstBuffer *buf = GST_BUFFER_CAST (l->data);
 333     gst_rtp_copy_meta (GST_ELEMENT_CAST (rtpvorbispay), rtpvorbispay->packet,
 334         buf, g_quark_from_static_string (GST_META_TAG_AUDIO_STR));
 335     gst_buffer_unref (buf);
 336   }
 337   g_list_free (rtpvorbispay->packet_buffers);
 338   rtpvorbispay->packet_buffers = NULL;
 339
 340   /* push, this gives away our ref to the packet, so clear it. */
 341   ret =
 342       gst_rtp_base_payload_push (GST_RTP_BASE_PAYLOAD (rtpvorbispay),
 343       rtpvorbispay->packet);
 344   rtpvorbispay->packet = NULL;
 345
 346   return ret;
 347 }
 348
 349 static gboolean
 350 gst_rtp_vorbis_pay_finish_headers (GstRTPBasePayload * basepayload)
 351 {
 352   GstRtpVorbisPay *rtpvorbispay = GST_RTP_VORBIS_PAY (basepayload);
 353   GList *walk;
 354   guint length, size, n_headers, configlen, extralen;
 355   gchar *cstr, *configuration;
 356   guint8 *data, *config;
 357   guint32 ident;
 358   gboolean res;
 359
 360   GST_DEBUG_OBJECT (rtpvorbispay, "finish headers");
 361
 362   if (!rtpvorbispay->headers)
 363     goto no_headers;
 364
 365   /* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 366    * |                     Number of packed headers                  |
 367    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 368    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 369    * |                          Packed header                        |
 370    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 371    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 372    * |                          Packed header                        |
 373    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 374    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 375    * |                          ....                                 |
 376    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 377    *
 378    * We only construct a config containing 1 packed header like this:
 379    *
 380    *  0                   1                   2                   3
 381    *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 382    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 383    * |                   Ident                       | length       ..
 384    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 385    * ..              | n. of headers |    length1    |    length2   ..
 386    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 387    * ..              |             Identification Header            ..
 388    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 389    * .................................................................
 390    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 391    * ..              |         Comment Header                       ..
 392    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 393    * .................................................................
 394    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 395    * ..                        Comment Header                        |
 396    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 397    * |                          Setup Header                        ..
 398    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 399    * .................................................................
 400    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 401    * ..                         Setup Header                         |
 402    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 403    */
 404
 405   /* we need 4 bytes for the number of headers (which is always 1), 3 bytes for
 406    * the ident, 2 bytes for length, 1 byte for n. of headers. */
 407   size = 4 + 3 + 2 + 1;
 408
 409   /* count the size of the headers first and update the hash */
 410   length = 0;
 411   n_headers = 0;
 412   ident = fnv1_hash_32_new ();
 413   extralen = 1;
 414   for (walk = rtpvorbispay->headers; walk; walk = g_list_next (walk)) {
 415     GstBuffer *buf = GST_BUFFER_CAST (walk->data);
 416     GstMapInfo map;
 417     guint bsize;
 418
 419     bsize = gst_buffer_get_size (buf);
 420     length += bsize;
 421     n_headers++;
 422
 423     /* count number of bytes needed for length fields, we don't need this for
 424      * the last header. */
 425     if (g_list_next (walk)) {
 426       do {
 427         size++;
 428         extralen++;
 429         bsize >>= 7;
 430       } while (bsize);
 431     }
 432     /* update hash */
 433     gst_buffer_map (buf, &map, GST_MAP_READ);
 434     ident = fnv1_hash_32_update (ident, map.data, map.size);
 435     gst_buffer_unmap (buf, &map);
 436   }
 437
 438   /* packet length is header size + packet length */
 439   configlen = size + length;
 440   config = data = g_malloc (configlen);
 441
 442   /* number of packed headers, we only pack 1 header */
 443   data[0] = 0;
 444   data[1] = 0;
 445   data[2] = 0;
 446   data[3] = 1;
 447
 448   ident = fnv1_hash_32_to_24 (ident);
 449   rtpvorbispay->payload_ident = ident;
 450   GST_DEBUG_OBJECT (rtpvorbispay, "ident 0x%08x", ident);
 451
 452   /* take lower 3 bytes */
 453   data[4] = (ident >> 16) & 0xff;
 454   data[5] = (ident >> 8) & 0xff;
 455   data[6] = ident & 0xff;
 456
 457   /* store length of all vorbis headers */
 458   data[7] = ((length) >> 8) & 0xff;
 459   data[8] = (length) & 0xff;
 460
 461   /* store number of headers minus one. */
 462   data[9] = n_headers - 1;
 463   data += 10;
 464
 465   /* store length for each header */
 466   for (walk = rtpvorbispay->headers; walk; walk = g_list_next (walk)) {
 467     GstBuffer *buf = GST_BUFFER_CAST (walk->data);
 468     guint bsize, size, temp;
 469     guint flag;
 470
 471     /* only need to store the length when it's not the last header */
 472     if (!g_list_next (walk))
 473       break;
 474
 475     bsize = gst_buffer_get_size (buf);
 476
 477     /* calc size */
 478     size = 0;
 479     do {
 480       size++;
 481       bsize >>= 7;
 482     } while (bsize);
 483     temp = size;
 484
 485     bsize = gst_buffer_get_size (buf);
 486     /* write the size backwards */
 487     flag = 0;
 488     while (size) {
 489       size--;
 490       data[size] = (bsize & 0x7f) | flag;
 491       bsize >>= 7;
 492       flag = 0x80;              /* Flag bit on all bytes of the length except the last */
 493     }
 494     data += temp;
 495   }
 496
 497   /* copy header data */
 498   for (walk = rtpvorbispay->headers; walk; walk = g_list_next (walk)) {
 499     GstBuffer *buf = GST_BUFFER_CAST (walk->data);
 500
 501     gst_buffer_extract (buf, 0, data, gst_buffer_get_size (buf));
 502     data += gst_buffer_get_size (buf);
 503   }
 504   rtpvorbispay->need_headers = FALSE;
 505
 506   /* serialize to base64 */
 507   configuration = g_base64_encode (config, configlen);
 508
 509   /* store for later re-sending */
 510   g_free (rtpvorbispay->config_data);
 511   rtpvorbispay->config_size = configlen - 4 - 3 - 2;
 512   rtpvorbispay->config_data = g_malloc (rtpvorbispay->config_size);
 513   rtpvorbispay->config_extra_len = extralen;
 514   memcpy (rtpvorbispay->config_data, config + 4 + 3 + 2,
 515       rtpvorbispay->config_size);
 516
 517   g_free (config);
 518
 519   /* configure payloader settings */
 520   cstr = g_strdup_printf ("%d", rtpvorbispay->channels);
 521   gst_rtp_base_payload_set_options (basepayload, "audio", TRUE, "VORBIS",
 522       rtpvorbispay->rate);
 523   res =
 524       gst_rtp_base_payload_set_outcaps (basepayload, "encoding-params",
 525       G_TYPE_STRING, cstr, "configuration", G_TYPE_STRING, configuration, NULL);
 526   g_free (cstr);
 527   g_free (configuration);
 528
 529   return res;
 530
 531   /* ERRORS */
 532 no_headers:
 533   {
 534     GST_DEBUG_OBJECT (rtpvorbispay, "finish headers");
 535     return FALSE;
 536   }
 537 }
 538
 539 static gboolean
 540 gst_rtp_vorbis_pay_parse_id (GstRTPBasePayload * basepayload, guint8 * data,
 541     guint size)
 542 {
 543   GstRtpVorbisPay *rtpvorbispay = GST_RTP_VORBIS_PAY (basepayload);
 544   guint8 channels;
 545   gint32 rate, version;
 546
 547   if (G_UNLIKELY (size < 16))
 548     goto too_short;
 549
 550   if (G_UNLIKELY (memcmp (data, "\001vorbis", 7)))
 551     goto invalid_start;
 552   data += 7;
 553
 554   if (G_UNLIKELY ((version = GST_READ_UINT32_LE (data)) != 0))
 555     goto invalid_version;
 556   data += 4;
 557
 558   if (G_UNLIKELY ((channels = *data++) < 1))
 559     goto invalid_channels;
 560
 561   if (G_UNLIKELY ((rate = GST_READ_UINT32_LE (data)) < 1))
 562     goto invalid_rate;
 563
 564   /* all fine, store the values */
 565   rtpvorbispay->channels = channels;
 566   rtpvorbispay->rate = rate;
 567
 568   return TRUE;
 569
 570   /* ERRORS */
 571 too_short:
 572   {
 573     GST_ELEMENT_ERROR (basepayload, STREAM, DECODE,
 574         ("Identification packet is too short, need at least 16, got %d", size),
 575         (NULL));
 576     return FALSE;
 577   }
 578 invalid_start:
 579   {
 580     GST_ELEMENT_ERROR (basepayload, STREAM, DECODE,
 581         ("Invalid header start in identification packet"), (NULL));
 582     return FALSE;
 583   }
 584 invalid_version:
 585   {
 586     GST_ELEMENT_ERROR (basepayload, STREAM, DECODE,
 587         ("Invalid version, expected 0, got %d", version), (NULL));
 588     return FALSE;
 589   }
 590 invalid_rate:
 591   {
 592     GST_ELEMENT_ERROR (basepayload, STREAM, DECODE,
 593         ("Invalid rate %d", rate), (NULL));
 594     return FALSE;
 595   }
 596 invalid_channels:
 597   {
 598     GST_ELEMENT_ERROR (basepayload, STREAM, DECODE,
 599         ("Invalid channels %d", channels), (NULL));
 600     return FALSE;
 601   }
 602 }
 603
 604 static GstFlowReturn
 605 gst_rtp_vorbis_pay_payload_buffer (GstRtpVorbisPay * rtpvorbispay, guint8 VDT,
 606     GstBuffer * buffer, guint8 * data, guint size, GstClockTime timestamp,
 607     GstClockTime duration, guint not_in_length)
 608 {
 609   GstFlowReturn ret = GST_FLOW_OK;
 610   guint newsize;
 611   guint packet_len;
 612   GstClockTime newduration;
 613   gboolean flush;
 614   guint plen;
 615   guint8 *ppos, *payload;
 616   gboolean fragmented;
 617   GstRTPBuffer rtp = { NULL };
 618
 619   /* size increases with packet length and 2 bytes size eader. */
 620   newduration = rtpvorbispay->payload_duration;
 621   if (duration != GST_CLOCK_TIME_NONE)
 622     newduration += duration;
 623
 624   newsize = rtpvorbispay->payload_pos + 2 + size;
 625   packet_len = gst_rtp_buffer_calc_packet_len (newsize, 0, 0);
 626
 627   /* check buffer filled against length and max latency */
 628   flush = gst_rtp_base_payload_is_filled (GST_RTP_BASE_PAYLOAD (rtpvorbispay),
 629       packet_len, newduration);
 630   /* we can store up to 15 vorbis packets in one RTP packet. */
 631   flush |= (rtpvorbispay->payload_pkts == 15);
 632   /* flush if we have a new VDT */
 633   if (rtpvorbispay->packet)
 634     flush |= (rtpvorbispay->payload_VDT != VDT);
 635   if (flush)
 636     ret = gst_rtp_vorbis_pay_flush_packet (rtpvorbispay);
 637
 638   if (ret != GST_FLOW_OK)
 639     goto done;
 640
 641   /* create new packet if we must */
 642   if (!rtpvorbispay->packet) {
 643     gst_rtp_vorbis_pay_init_packet (rtpvorbispay, VDT, timestamp);
 644   }
 645
 646   gst_rtp_buffer_map (rtpvorbispay->packet, GST_MAP_WRITE, &rtp);
 647   payload = gst_rtp_buffer_get_payload (&rtp);
 648   ppos = payload + rtpvorbispay->payload_pos;
 649   fragmented = FALSE;
 650
 651   /* put buffer in packet, it either fits completely or needs to be fragmented
 652    * over multiple RTP packets. */
 653   do {
 654     plen = MIN (rtpvorbispay->payload_left - 2, size);
 655
 656     GST_LOG_OBJECT (rtpvorbispay, "append %u bytes", plen);
 657
 658     /* data is copied in the payload with a 2 byte length header */
 659     ppos[0] = ((plen - not_in_length) >> 8) & 0xff;
 660     ppos[1] = ((plen - not_in_length) & 0xff);
 661     if (plen)
 662       memcpy (&ppos[2], data, plen);
 663
 664     if (buffer) {
 665       if (!rtpvorbispay->packet_buffers
 666           || rtpvorbispay->packet_buffers->data != (gpointer) buffer)
 667         rtpvorbispay->packet_buffers =
 668             g_list_prepend (rtpvorbispay->packet_buffers,
 669             gst_buffer_ref (buffer));
 670     } else {
 671       GList *l;
 672
 673       for (l = rtpvorbispay->headers; l; l = l->next)
 674         rtpvorbispay->packet_buffers =
 675             g_list_prepend (rtpvorbispay->packet_buffers,
 676             gst_buffer_ref (l->data));
 677     }
 678
 679     /* only first (only) configuration cuts length field */
 680     /* NOTE: spec (if any) is not clear on this ... */
 681     not_in_length = 0;
 682
 683     size -= plen;
 684     data += plen;
 685
 686     rtpvorbispay->payload_pos += plen + 2;
 687     rtpvorbispay->payload_left -= plen + 2;
 688
 689     if (fragmented) {
 690       if (size == 0)
 691         /* last fragment, set F to 0x3. */
 692         rtpvorbispay->payload_F = 0x3;
 693       else
 694         /* fragment continues, set F to 0x2. */
 695         rtpvorbispay->payload_F = 0x2;
 696     } else {
 697       if (size > 0) {
 698         /* fragmented packet starts, set F to 0x1, mark ourselves as
 699          * fragmented. */
 700         rtpvorbispay->payload_F = 0x1;
 701         fragmented = TRUE;
 702       }
 703     }
 704     if (fragmented) {
 705       gst_rtp_buffer_unmap (&rtp);
 706       /* fragmented packets are always flushed and have ptks of 0 */
 707       rtpvorbispay->payload_pkts = 0;
 708       ret = gst_rtp_vorbis_pay_flush_packet (rtpvorbispay);
 709
 710       if (size > 0) {
 711         /* start new packet and get pointers. VDT stays the same. */
 712         gst_rtp_vorbis_pay_init_packet (rtpvorbispay,
 713             rtpvorbispay->payload_VDT, timestamp);
 714         gst_rtp_buffer_map (rtpvorbispay->packet, GST_MAP_WRITE, &rtp);
 715         payload = gst_rtp_buffer_get_payload (&rtp);
 716         ppos = payload + rtpvorbispay->payload_pos;
 717       }
 718     } else {
 719       /* unfragmented packet, update stats for next packet, size == 0 and we
 720        * exit the while loop */
 721       rtpvorbispay->payload_pkts++;
 722       if (duration != GST_CLOCK_TIME_NONE)
 723         rtpvorbispay->payload_duration += duration;
 724     }
 725   } while (size && ret == GST_FLOW_OK);
 726
 727   if (rtp.buffer)
 728     gst_rtp_buffer_unmap (&rtp);
 729
 730 done:
 731
 732   return ret;
 733 }
 734
 735 static GstFlowReturn
 736 gst_rtp_vorbis_pay_handle_buffer (GstRTPBasePayload * basepayload,
 737     GstBuffer * buffer)
 738 {
 739   GstRtpVorbisPay *rtpvorbispay;
 740   GstFlowReturn ret;
 741   GstMapInfo map;
 742   gsize size;
 743   guint8 *data;
 744   GstClockTime duration, timestamp;
 745   guint8 VDT;
 746
 747   rtpvorbispay = GST_RTP_VORBIS_PAY (basepayload);
 748
 749   gst_buffer_map (buffer, &map, GST_MAP_READ);
 750   data = map.data;
 751   size = map.size;
 752   duration = GST_BUFFER_DURATION (buffer);
 753   timestamp = GST_BUFFER_PTS (buffer);
 754
 755   GST_LOG_OBJECT (rtpvorbispay, "size %" G_GSIZE_FORMAT
 756       ", duration %" GST_TIME_FORMAT, size, GST_TIME_ARGS (duration));
 757
 758   if (G_UNLIKELY (size < 1))
 759     goto wrong_size;
 760
 761   /* find packet type */
 762   if (data[0] & 1) {
 763     /* header */
 764     if (data[0] == 1) {
 765       /* identification, we need to parse this in order to get the clock rate. */
 766       if (G_UNLIKELY (!gst_rtp_vorbis_pay_parse_id (basepayload, data, size)))
 767         goto parse_id_failed;
 768       VDT = 1;
 769     } else if (data[0] == 3) {
 770       /* comment */
 771       VDT = 2;
 772     } else if (data[0] == 5) {
 773       /* setup */
 774       VDT = 1;
 775     } else
 776       goto unknown_header;
 777   } else
 778     /* data */
 779     VDT = 0;
 780
 781   /* we need to collect the headers and construct a config string from them */
 782   if (VDT != 0) {
 783     rtpvorbispay->need_headers = TRUE;
 784     if (!rtpvorbispay->need_headers && VDT == 1) {
 785       GST_INFO_OBJECT (rtpvorbispay, "getting new headers, replace existing");
 786       g_list_free_full (rtpvorbispay->headers,
 787           (GDestroyNotify) gst_buffer_unref);
 788       rtpvorbispay->headers = NULL;
 789     }
 790     GST_DEBUG_OBJECT (rtpvorbispay, "collecting header");
 791     /* append header to the list of headers, or replace
 792      * if the same type of header was already in there.
 793      *
 794      * This prevents storing an infinite amount of e.g. comment headers, there
 795      * must only be one */
 796     gst_buffer_unmap (buffer, &map);
 797
 798     if (rtpvorbispay->headers) {
 799       gboolean found = FALSE;
 800       GList *l;
 801       guint8 new_header_type;
 802
 803       gst_buffer_extract (buffer, 0, &new_header_type, 1);
 804
 805       for (l = rtpvorbispay->headers; l; l = l->next) {
 806         GstBuffer *header = l->data;
 807         guint8 header_type;
 808
 809         if (gst_buffer_extract (header, 0, &header_type, 1)
 810             && header_type == new_header_type) {
 811           found = TRUE;
 812           gst_buffer_unref (header);
 813           l->data = buffer;
 814           break;
 815         }
 816       }
 817       if (!found)
 818         rtpvorbispay->headers = g_list_append (rtpvorbispay->headers, buffer);
 819     } else {
 820       rtpvorbispay->headers = g_list_append (rtpvorbispay->headers, buffer);
 821     }
 822
 823     ret = GST_FLOW_OK;
 824     goto done;
 825   } else if (rtpvorbispay->headers && rtpvorbispay->need_headers) {
 826     if (!gst_rtp_vorbis_pay_finish_headers (basepayload))
 827       goto header_error;
 828   }
 829
 830   /* there is a config request, see if we need to insert it */
 831   if (rtpvorbispay->config_interval > 0 && rtpvorbispay->config_data) {
 832     gboolean send_config = FALSE;
 833
 834     if (rtpvorbispay->last_config != -1) {
 835       guint64 diff;
 836
 837       GST_LOG_OBJECT (rtpvorbispay,
 838           "now %" GST_TIME_FORMAT ", last config %" GST_TIME_FORMAT,
 839           GST_TIME_ARGS (timestamp), GST_TIME_ARGS (rtpvorbispay->last_config));
 840
 841       /* calculate diff between last config in milliseconds */
 842       if (timestamp > rtpvorbispay->last_config) {
 843         diff = timestamp - rtpvorbispay->last_config;
 844       } else {
 845         diff = 0;
 846       }
 847
 848       GST_DEBUG_OBJECT (rtpvorbispay,
 849           "interval since last config %" GST_TIME_FORMAT, GST_TIME_ARGS (diff));
 850
 851       /* bigger than interval, queue config */
 852       /* FIXME should convert timestamps to running time */
 853       if (GST_TIME_AS_SECONDS (diff) >= rtpvorbispay->config_interval) {
 854         GST_DEBUG_OBJECT (rtpvorbispay, "time to send config");
 855         send_config = TRUE;
 856       }
 857     } else {
 858       /* no known previous config time, send now */
 859       GST_DEBUG_OBJECT (rtpvorbispay, "no previous config time, send now");
 860       send_config = TRUE;
 861     }
 862
 863     if (send_config) {
 864       /* we need to send config now first */
 865       /* different TDT type forces flush */
 866       gst_rtp_vorbis_pay_payload_buffer (rtpvorbispay, 1,
 867           NULL, rtpvorbispay->config_data, rtpvorbispay->config_size,
 868           timestamp, GST_CLOCK_TIME_NONE, rtpvorbispay->config_extra_len);
 869
 870       if (timestamp != -1) {
 871         rtpvorbispay->last_config = timestamp;
 872       }
 873     }
 874   }
 875
 876   ret =
 877       gst_rtp_vorbis_pay_payload_buffer (rtpvorbispay, VDT, buffer, data, size,
 878       timestamp, duration, 0);
 879
 880   gst_buffer_unmap (buffer, &map);
 881   gst_buffer_unref (buffer);
 882
 883 done:
 884   return ret;
 885
 886   /* ERRORS */
 887 wrong_size:
 888   {
 889     GST_ELEMENT_WARNING (rtpvorbispay, STREAM, DECODE,
 890         ("Invalid packet size (1 < %" G_GSIZE_FORMAT ")", size), (NULL));
 891     gst_buffer_unmap (buffer, &map);
 892     gst_buffer_unref (buffer);
 893     return GST_FLOW_OK;
 894   }
 895 parse_id_failed:
 896   {
 897     gst_buffer_unmap (buffer, &map);
 898     gst_buffer_unref (buffer);
 899     return GST_FLOW_ERROR;
 900   }
 901 unknown_header:
 902   {
 903     GST_ELEMENT_WARNING (rtpvorbispay, STREAM, DECODE,
 904         (NULL), ("Ignoring unknown header received"));
 905     gst_buffer_unmap (buffer, &map);
 906     gst_buffer_unref (buffer);
 907     return GST_FLOW_OK;
 908   }
 909 header_error:
 910   {
 911     GST_ELEMENT_WARNING (rtpvorbispay, STREAM, DECODE,
 912         (NULL), ("Error initializing header config"));
 913     gst_buffer_unmap (buffer, &map);
 914     gst_buffer_unref (buffer);
 915     return GST_FLOW_OK;
 916   }
 917 }
 918
 919 static gboolean
 920 gst_rtp_vorbis_pay_sink_event (GstRTPBasePayload * payload, GstEvent * event)
 921 {
 922   GstRtpVorbisPay *rtpvorbispay = GST_RTP_VORBIS_PAY (payload);
 923
 924   switch (GST_EVENT_TYPE (event)) {
 925     case GST_EVENT_FLUSH_STOP:
 926       gst_rtp_vorbis_pay_clear_packet (rtpvorbispay);
 927       break;
 928     default:
 929       break;
 930   }
 931   /* false to let parent handle event as well */
 932   return GST_RTP_BASE_PAYLOAD_CLASS (parent_class)->sink_event (payload, event);
 933 }
 934
 935 static GstStateChangeReturn
 936 gst_rtp_vorbis_pay_change_state (GstElement * element,
 937     GstStateChange transition)
 938 {
 939   GstRtpVorbisPay *rtpvorbispay;
 940   GstStateChangeReturn ret;
 941
 942   rtpvorbispay = GST_RTP_VORBIS_PAY (element);
 943
 944   switch (transition) {
 945     default:
 946       break;
 947   }
 948
 949   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 950
 951   switch (transition) {
 952     case GST_STATE_CHANGE_PAUSED_TO_READY:
 953       gst_rtp_vorbis_pay_cleanup (rtpvorbispay);
 954       break;
 955     default:
 956       break;
 957   }
 958   return ret;
 959 }
 960
 961 static void
 962 gst_rtp_vorbis_pay_set_property (GObject * object, guint prop_id,
 963     const GValue * value, GParamSpec * pspec)
 964 {
 965   GstRtpVorbisPay *rtpvorbispay;
 966
 967   rtpvorbispay = GST_RTP_VORBIS_PAY (object);
 968
 969   switch (prop_id) {
 970     case PROP_CONFIG_INTERVAL:
 971       rtpvorbispay->config_interval = g_value_get_uint (value);
 972       break;
 973     default:
 974       break;
 975   }
 976 }
 977
 978 static void
 979 gst_rtp_vorbis_pay_get_property (GObject * object, guint prop_id,
 980     GValue * value, GParamSpec * pspec)
 981 {
 982   GstRtpVorbisPay *rtpvorbispay;
 983
 984   rtpvorbispay = GST_RTP_VORBIS_PAY (object);
 985
 986   switch (prop_id) {
 987     case PROP_CONFIG_INTERVAL:
 988       g_value_set_uint (value, rtpvorbispay->config_interval);
 989       break;
 990     default:
 991       break;
 992   }
 993 }
 994
 995 gboolean
 996 gst_rtp_vorbis_pay_plugin_init (GstPlugin * plugin)
 997 {
 998   return gst_element_register (plugin, "rtpvorbispay",
 999       GST_RANK_SECONDARY, GST_TYPE_RTP_VORBIS_PAY);
1000 }