gst/rtp/gstrtpceltpay.c

   1 /* GStreamer
   2  * Copyright (C) <2009> 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., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <gst/rtp/gstrtpbuffer.h>
  27
  28 #include "gstrtpceltpay.h"
  29
  30 GST_DEBUG_CATEGORY_STATIC (rtpceltpay_debug);
  31 #define GST_CAT_DEFAULT (rtpceltpay_debug)
  32
  33 static GstStaticPadTemplate gst_rtp_celt_pay_sink_template =
  34 GST_STATIC_PAD_TEMPLATE ("sink",
  35     GST_PAD_SINK,
  36     GST_PAD_ALWAYS,
  37     GST_STATIC_CAPS ("audio/x-celt, "
  38         "rate = (int) [ 32000, 64000 ], "
  39         "channels = (int) [1, 2], " "frame-size = (int) [ 64, 512 ]")
  40     );
  41
  42 static GstStaticPadTemplate gst_rtp_celt_pay_src_template =
  43 GST_STATIC_PAD_TEMPLATE ("src",
  44     GST_PAD_SRC,
  45     GST_PAD_ALWAYS,
  46     GST_STATIC_CAPS ("application/x-rtp, "
  47         "media = (string) \"audio\", "
  48         "payload = (int) " GST_RTP_PAYLOAD_DYNAMIC_STRING ", "
  49         "clock-rate =  (int) [ 32000, 48000 ], "
  50         "encoding-name = (string) \"CELT\"")
  51     );
  52
  53 static void gst_rtp_celt_pay_finalize (GObject * object);
  54
  55 static GstStateChangeReturn gst_rtp_celt_pay_change_state (GstElement *
  56     element, GstStateChange transition);
  57
  58 static gboolean gst_rtp_celt_pay_setcaps (GstRTPBasePayload * payload,
  59     GstCaps * caps);
  60 static GstCaps *gst_rtp_celt_pay_getcaps (GstRTPBasePayload * payload,
  61     GstPad * pad, GstCaps * filter);
  62 static GstFlowReturn gst_rtp_celt_pay_handle_buffer (GstRTPBasePayload *
  63     payload, GstBuffer * buffer);
  64
  65 #define gst_rtp_celt_pay_parent_class parent_class
  66 G_DEFINE_TYPE (GstRtpCELTPay, gst_rtp_celt_pay, GST_TYPE_RTP_BASE_PAYLOAD);
  67
  68 static void
  69 gst_rtp_celt_pay_class_init (GstRtpCELTPayClass * klass)
  70 {
  71   GObjectClass *gobject_class;
  72   GstElementClass *gstelement_class;
  73   GstRTPBasePayloadClass *gstrtpbasepayload_class;
  74
  75   GST_DEBUG_CATEGORY_INIT (rtpceltpay_debug, "rtpceltpay", 0,
  76       "CELT RTP Payloader");
  77
  78   gobject_class = (GObjectClass *) klass;
  79   gstelement_class = (GstElementClass *) klass;
  80   gstrtpbasepayload_class = (GstRTPBasePayloadClass *) klass;
  81
  82   gobject_class->finalize = gst_rtp_celt_pay_finalize;
  83
  84   gstelement_class->change_state = gst_rtp_celt_pay_change_state;
  85
  86   gst_element_class_add_pad_template (gstelement_class,
  87       gst_static_pad_template_get (&gst_rtp_celt_pay_sink_template));
  88   gst_element_class_add_pad_template (gstelement_class,
  89       gst_static_pad_template_get (&gst_rtp_celt_pay_src_template));
  90
  91   gst_element_class_set_details_simple (gstelement_class, "RTP CELT payloader",
  92       "Codec/Payloader/Network/RTP",
  93       "Payload-encodes CELT audio into a RTP packet",
  94       "Wim Taymans <wim.taymans@gmail.com>");
  95
  96   gstrtpbasepayload_class->set_caps = gst_rtp_celt_pay_setcaps;
  97   gstrtpbasepayload_class->get_caps = gst_rtp_celt_pay_getcaps;
  98   gstrtpbasepayload_class->handle_buffer = gst_rtp_celt_pay_handle_buffer;
  99 }
 100
 101 static void
 102 gst_rtp_celt_pay_init (GstRtpCELTPay * rtpceltpay)
 103 {
 104   rtpceltpay->queue = g_queue_new ();
 105 }
 106
 107 static void
 108 gst_rtp_celt_pay_finalize (GObject * object)
 109 {
 110   GstRtpCELTPay *rtpceltpay;
 111
 112   rtpceltpay = GST_RTP_CELT_PAY (object);
 113
 114   g_queue_free (rtpceltpay->queue);
 115
 116   G_OBJECT_CLASS (parent_class)->finalize (object);
 117 }
 118
 119 static void
 120 gst_rtp_celt_pay_clear_queued (GstRtpCELTPay * rtpceltpay)
 121 {
 122   GstBuffer *buf;
 123
 124   while ((buf = g_queue_pop_head (rtpceltpay->queue)))
 125     gst_buffer_unref (buf);
 126
 127   rtpceltpay->bytes = 0;
 128   rtpceltpay->sbytes = 0;
 129   rtpceltpay->qduration = 0;
 130 }
 131
 132 static void
 133 gst_rtp_celt_pay_add_queued (GstRtpCELTPay * rtpceltpay, GstBuffer * buffer,
 134     guint ssize, guint size, GstClockTime duration)
 135 {
 136   g_queue_push_tail (rtpceltpay->queue, buffer);
 137   rtpceltpay->sbytes += ssize;
 138   rtpceltpay->bytes += size;
 139   /* only add durations when we have a valid previous duration */
 140   if (rtpceltpay->qduration != -1) {
 141     if (duration != -1)
 142       /* only add valid durations */
 143       rtpceltpay->qduration += duration;
 144     else
 145       /* if we add a buffer without valid duration, our total queued duration
 146        * becomes unknown */
 147       rtpceltpay->qduration = -1;
 148   }
 149 }
 150
 151 static gboolean
 152 gst_rtp_celt_pay_setcaps (GstRTPBasePayload * payload, GstCaps * caps)
 153 {
 154   /* don't configure yet, we wait for the ident packet */
 155   return TRUE;
 156 }
 157
 158
 159 static GstCaps *
 160 gst_rtp_celt_pay_getcaps (GstRTPBasePayload * payload, GstPad * pad,
 161     GstCaps * filter)
 162 {
 163   GstCaps *otherpadcaps;
 164   GstCaps *caps;
 165   const gchar *params;
 166
 167   otherpadcaps = gst_pad_get_allowed_caps (payload->srcpad);
 168   caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
 169
 170   if (otherpadcaps) {
 171     if (!gst_caps_is_empty (otherpadcaps)) {
 172       GstStructure *ps = gst_caps_get_structure (otherpadcaps, 0);
 173       GstStructure *s = gst_caps_get_structure (caps, 0);
 174       gint clock_rate = 0, frame_size = 0, channels = 1;
 175
 176       if (gst_structure_get_int (ps, "clock-rate", &clock_rate)) {
 177         gst_structure_fixate_field_nearest_int (s, "rate", clock_rate);
 178       }
 179
 180       if ((params = gst_structure_get_string (ps, "frame-size")))
 181         frame_size = atoi (params);
 182       if (frame_size)
 183         gst_structure_set (s, "frame-size", G_TYPE_INT, frame_size, NULL);
 184
 185       if ((params = gst_structure_get_string (ps, "encoding-params"))) {
 186         channels = atoi (params);
 187         gst_structure_fixate_field_nearest_int (s, "channels", channels);
 188       }
 189
 190       GST_DEBUG_OBJECT (payload, "clock-rate=%d frame-size=%d channels=%d",
 191           clock_rate, frame_size, channels);
 192     }
 193     gst_caps_unref (otherpadcaps);
 194   }
 195
 196   return caps;
 197 }
 198
 199 static gboolean
 200 gst_rtp_celt_pay_parse_ident (GstRtpCELTPay * rtpceltpay,
 201     const guint8 * data, guint size)
 202 {
 203   guint32 version, header_size, rate, nb_channels, frame_size, overlap;
 204   guint32 bytes_per_packet;
 205   GstRTPBasePayload *payload;
 206   gchar *cstr, *fsstr;
 207   gboolean res;
 208
 209   /* we need the header string (8), the version string (20), the version
 210    * and the header length. */
 211   if (size < 36)
 212     goto too_small;
 213
 214   if (!g_str_has_prefix ((const gchar *) data, "CELT    "))
 215     goto wrong_header;
 216
 217   /* skip header and version string */
 218   data += 28;
 219
 220   version = GST_READ_UINT32_LE (data);
 221   GST_DEBUG_OBJECT (rtpceltpay, "version %08x", version);
 222 #if 0
 223   if (version != 1)
 224     goto wrong_version;
 225 #endif
 226
 227   data += 4;
 228   /* ensure sizes */
 229   header_size = GST_READ_UINT32_LE (data);
 230   if (header_size < 56)
 231     goto header_too_small;
 232
 233   if (size < header_size)
 234     goto payload_too_small;
 235
 236   data += 4;
 237   rate = GST_READ_UINT32_LE (data);
 238   data += 4;
 239   nb_channels = GST_READ_UINT32_LE (data);
 240   data += 4;
 241   frame_size = GST_READ_UINT32_LE (data);
 242   data += 4;
 243   overlap = GST_READ_UINT32_LE (data);
 244   data += 4;
 245   bytes_per_packet = GST_READ_UINT32_LE (data);
 246
 247   GST_DEBUG_OBJECT (rtpceltpay, "rate %d, nb_channels %d, frame_size %d",
 248       rate, nb_channels, frame_size);
 249   GST_DEBUG_OBJECT (rtpceltpay, "overlap %d, bytes_per_packet %d",
 250       overlap, bytes_per_packet);
 251
 252   payload = GST_RTP_BASE_PAYLOAD (rtpceltpay);
 253
 254   gst_rtp_base_payload_set_options (payload, "audio", FALSE, "CELT", rate);
 255   cstr = g_strdup_printf ("%d", nb_channels);
 256   fsstr = g_strdup_printf ("%d", frame_size);
 257   res = gst_rtp_base_payload_set_outcaps (payload, "encoding-params",
 258       G_TYPE_STRING, cstr, "frame-size", G_TYPE_STRING, fsstr, NULL);
 259   g_free (cstr);
 260   g_free (fsstr);
 261
 262   return res;
 263
 264   /* ERRORS */
 265 too_small:
 266   {
 267     GST_DEBUG_OBJECT (rtpceltpay,
 268         "ident packet too small, need at least 32 bytes");
 269     return FALSE;
 270   }
 271 wrong_header:
 272   {
 273     GST_DEBUG_OBJECT (rtpceltpay,
 274         "ident packet does not start with \"CELT    \"");
 275     return FALSE;
 276   }
 277 #if 0
 278 wrong_version:
 279   {
 280     GST_DEBUG_OBJECT (rtpceltpay, "can only handle version 1, have version %d",
 281         version);
 282     return FALSE;
 283   }
 284 #endif
 285 header_too_small:
 286   {
 287     GST_DEBUG_OBJECT (rtpceltpay,
 288         "header size too small, need at least 80 bytes, " "got only %d",
 289         header_size);
 290     return FALSE;
 291   }
 292 payload_too_small:
 293   {
 294     GST_DEBUG_OBJECT (rtpceltpay,
 295         "payload too small, need at least %d bytes, got only %d", header_size,
 296         size);
 297     return FALSE;
 298   }
 299 }
 300
 301 static GstFlowReturn
 302 gst_rtp_celt_pay_flush_queued (GstRtpCELTPay * rtpceltpay)
 303 {
 304   GstFlowReturn ret;
 305   GstBuffer *buf, *outbuf;
 306   guint8 *payload, *spayload;
 307   guint payload_len;
 308   GstClockTime duration;
 309   GstRTPBuffer rtp = { NULL, };
 310
 311   payload_len = rtpceltpay->bytes + rtpceltpay->sbytes;
 312   duration = rtpceltpay->qduration;
 313
 314   GST_DEBUG_OBJECT (rtpceltpay, "flushing out %u, duration %" GST_TIME_FORMAT,
 315       payload_len, GST_TIME_ARGS (rtpceltpay->qduration));
 316
 317   /* get a big enough packet for the sizes + payloads */
 318   outbuf = gst_rtp_buffer_new_allocate (payload_len, 0, 0);
 319
 320   GST_BUFFER_DURATION (outbuf) = duration;
 321
 322   gst_rtp_buffer_map (outbuf, GST_MAP_WRITE, &rtp);
 323
 324   /* point to the payload for size headers and data */
 325   spayload = gst_rtp_buffer_get_payload (&rtp);
 326   payload = spayload + rtpceltpay->sbytes;
 327
 328   while ((buf = g_queue_pop_head (rtpceltpay->queue))) {
 329     guint size;
 330
 331     /* copy first timestamp to output */
 332     if (GST_BUFFER_TIMESTAMP (outbuf) == -1)
 333       GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
 334
 335     /* write the size to the header */
 336     size = gst_buffer_get_size (buf);
 337     while (size > 0xff) {
 338       *spayload++ = 0xff;
 339       size -= 0xff;
 340     }
 341     *spayload++ = size;
 342
 343     /* copy payload */
 344     size = gst_buffer_get_size (buf);
 345     gst_buffer_extract (buf, 0, payload, size);
 346     payload += size;
 347
 348     gst_buffer_unref (buf);
 349   }
 350   gst_rtp_buffer_unmap (&rtp);
 351
 352   /* we consumed it all */
 353   rtpceltpay->bytes = 0;
 354   rtpceltpay->sbytes = 0;
 355   rtpceltpay->qduration = 0;
 356
 357   ret = gst_rtp_base_payload_push (GST_RTP_BASE_PAYLOAD (rtpceltpay), outbuf);
 358
 359   return ret;
 360 }
 361
 362 static GstFlowReturn
 363 gst_rtp_celt_pay_handle_buffer (GstRTPBasePayload * basepayload,
 364     GstBuffer * buffer)
 365 {
 366   GstFlowReturn ret;
 367   GstRtpCELTPay *rtpceltpay;
 368   gsize payload_len;
 369   GstMapInfo map;
 370   GstClockTime duration, packet_dur;
 371   guint i, ssize, packet_len;
 372
 373   rtpceltpay = GST_RTP_CELT_PAY (basepayload);
 374
 375   ret = GST_FLOW_OK;
 376
 377   gst_buffer_map (buffer, &map, GST_MAP_READ);
 378
 379   switch (rtpceltpay->packet) {
 380     case 0:
 381       /* ident packet. We need to parse the headers to construct the RTP
 382        * properties. */
 383       if (!gst_rtp_celt_pay_parse_ident (rtpceltpay, map.data, map.size))
 384         goto parse_error;
 385
 386       goto cleanup;
 387     case 1:
 388       /* comment packet, we ignore it */
 389       goto cleanup;
 390     default:
 391       /* other packets go in the payload */
 392       break;
 393   }
 394   gst_buffer_unmap (buffer, &map);
 395
 396   duration = GST_BUFFER_DURATION (buffer);
 397
 398   GST_LOG_OBJECT (rtpceltpay,
 399       "got buffer of duration %" GST_TIME_FORMAT ", size %" G_GSIZE_FORMAT,
 400       GST_TIME_ARGS (duration), map.size);
 401
 402   /* calculate the size of the size field and the payload */
 403   ssize = 1;
 404   for (i = map.size; i > 0xff; i -= 0xff)
 405     ssize++;
 406
 407   GST_DEBUG_OBJECT (rtpceltpay, "bytes for size %u", ssize);
 408
 409   /* calculate what the new size and duration would be of the packet */
 410   payload_len = ssize + map.size + rtpceltpay->bytes + rtpceltpay->sbytes;
 411   if (rtpceltpay->qduration != -1 && duration != -1)
 412     packet_dur = rtpceltpay->qduration + duration;
 413   else
 414     packet_dur = 0;
 415
 416   packet_len = gst_rtp_buffer_calc_packet_len (payload_len, 0, 0);
 417
 418   if (gst_rtp_base_payload_is_filled (basepayload, packet_len, packet_dur)) {
 419     /* size or duration would overflow the packet, flush the queued data */
 420     ret = gst_rtp_celt_pay_flush_queued (rtpceltpay);
 421   }
 422
 423   /* queue the packet */
 424   gst_rtp_celt_pay_add_queued (rtpceltpay, buffer, ssize, map.size, duration);
 425
 426 done:
 427   rtpceltpay->packet++;
 428
 429   return ret;
 430
 431   /* ERRORS */
 432 cleanup:
 433   {
 434     gst_buffer_unmap (buffer, &map);
 435     goto done;
 436   }
 437 parse_error:
 438   {
 439     GST_ELEMENT_ERROR (rtpceltpay, STREAM, DECODE, (NULL),
 440         ("Error parsing first identification packet."));
 441     gst_buffer_unmap (buffer, &map);
 442     return GST_FLOW_ERROR;
 443   }
 444 }
 445
 446 static GstStateChangeReturn
 447 gst_rtp_celt_pay_change_state (GstElement * element, GstStateChange transition)
 448 {
 449   GstRtpCELTPay *rtpceltpay;
 450   GstStateChangeReturn ret;
 451
 452   rtpceltpay = GST_RTP_CELT_PAY (element);
 453
 454   switch (transition) {
 455     case GST_STATE_CHANGE_NULL_TO_READY:
 456       break;
 457     case GST_STATE_CHANGE_READY_TO_PAUSED:
 458       rtpceltpay->packet = 0;
 459       break;
 460     default:
 461       break;
 462   }
 463
 464   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 465
 466   switch (transition) {
 467     case GST_STATE_CHANGE_PAUSED_TO_READY:
 468       gst_rtp_celt_pay_clear_queued (rtpceltpay);
 469       break;
 470     case GST_STATE_CHANGE_READY_TO_NULL:
 471       break;
 472     default:
 473       break;
 474   }
 475   return ret;
 476 }
 477
 478 gboolean
 479 gst_rtp_celt_pay_plugin_init (GstPlugin * plugin)
 480 {
 481   return gst_element_register (plugin, "rtpceltpay",
 482       GST_RANK_SECONDARY, GST_TYPE_RTP_CELT_PAY);
 483 }