ext/ogg/gstoggaviparse.c

   1 /* GStreamer
   2  * Copyright (C) 2006 Wim Taymans <wim@fluendo.com>
   3  *
   4  * gstoggaviparse.c: ogg avi stream parser
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /*
  23  * Ogg in AVI is mostly done for vorbis audio. In the codec_data we receive the
  24  * first 3 packets of the raw vorbis data. On the sinkpad we receive full-blown Ogg
  25  * pages.
  26  * Before extracting the packets out of the ogg pages, we push the raw vorbis
  27  * header packets to the decoder.
  28  * We don't use the incomming timestamps but use the ganulepos on the ogg pages
  29  * directly.
  30  * This parser only does ogg/vorbis for now.
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36 #include <gst/gst.h>
  37 #include <ogg/ogg.h>
  38 #include <string.h>
  39
  40 static const GstElementDetails gst_ogg_avi_parse_details =
  41 GST_ELEMENT_DETAILS ("Ogg AVI parser",
  42     "Codec/Parser",
  43     "parse an ogg avi stream into pages (info about ogg: http://xiph.org)",
  44     "Wim Taymans <wim@fluendo.com>");
  45
  46 GST_DEBUG_CATEGORY_STATIC (gst_ogg_avi_parse_debug);
  47 #define GST_CAT_DEFAULT gst_ogg_avi_parse_debug
  48
  49 #define GST_TYPE_OGG_AVI_PARSE (gst_ogg_avi_parse_get_type())
  50 #define GST_OGG_AVI_PARSE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OGG_AVI_PARSE, GstOggAviParse))
  51 #define GST_OGG_AVI_PARSE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OGG_AVI_PARSE, GstOggAviParse))
  52 #define GST_IS_OGG_AVI_PARSE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OGG_AVI_PARSE))
  53 #define GST_IS_OGG_AVI_PARSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OGG_AVI_PARSE))
  54
  55 static GType gst_ogg_avi_parse_get_type (void);
  56
  57 typedef struct _GstOggAviParse GstOggAviParse;
  58 typedef struct _GstOggAviParseClass GstOggAviParseClass;
  59
  60 struct _GstOggAviParse
  61 {
  62   GstElement element;
  63
  64   GstPad *sinkpad;
  65   GstPad *srcpad;
  66
  67   gboolean discont;
  68   gint serial;
  69
  70   ogg_sync_state sync;
  71   ogg_stream_state stream;
  72 };
  73
  74 struct _GstOggAviParseClass
  75 {
  76   GstElementClass parent_class;
  77 };
  78
  79 static void gst_ogg_avi_parse_base_init (gpointer g_class);
  80 static void gst_ogg_avi_parse_class_init (GstOggAviParseClass * klass);
  81 static void gst_ogg_avi_parse_init (GstOggAviParse * ogg);
  82 static GstElementClass *parent_class = NULL;
  83
  84 static GType
  85 gst_ogg_avi_parse_get_type (void)
  86 {
  87   static GType ogg_avi_parse_type = 0;
  88
  89   if (!ogg_avi_parse_type) {
  90     static const GTypeInfo ogg_avi_parse_info = {
  91       sizeof (GstOggAviParseClass),
  92       gst_ogg_avi_parse_base_init,
  93       NULL,
  94       (GClassInitFunc) gst_ogg_avi_parse_class_init,
  95       NULL,
  96       NULL,
  97       sizeof (GstOggAviParse),
  98       0,
  99       (GInstanceInitFunc) gst_ogg_avi_parse_init,
 100     };
 101
 102     ogg_avi_parse_type =
 103         g_type_register_static (GST_TYPE_ELEMENT, "GstOggAviParse",
 104         &ogg_avi_parse_info, 0);
 105   }
 106   return ogg_avi_parse_type;
 107 }
 108
 109 enum
 110 {
 111   PROP_0
 112 };
 113
 114 static GstStaticPadTemplate ogg_avi_parse_src_template_factory =
 115 GST_STATIC_PAD_TEMPLATE ("src",
 116     GST_PAD_SRC,
 117     GST_PAD_ALWAYS,
 118     GST_STATIC_CAPS ("audio/x-vorbis")
 119     );
 120
 121 static GstStaticPadTemplate ogg_avi_parse_sink_template_factory =
 122 GST_STATIC_PAD_TEMPLATE ("sink",
 123     GST_PAD_SINK,
 124     GST_PAD_ALWAYS,
 125     GST_STATIC_CAPS ("application/x-ogg-avi")
 126     );
 127
 128 static void gst_ogg_avi_parse_finalize (GObject * object);
 129 static GstStateChangeReturn gst_ogg_avi_parse_change_state (GstElement *
 130     element, GstStateChange transition);
 131 static gboolean gst_ogg_avi_parse_event (GstPad * pad, GstEvent * event);
 132 static GstFlowReturn gst_ogg_avi_parse_chain (GstPad * pad, GstBuffer * buffer);
 133 static gboolean gst_ogg_avi_parse_setcaps (GstPad * pad, GstCaps * caps);
 134
 135 static void
 136 gst_ogg_avi_parse_base_init (gpointer g_class)
 137 {
 138   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 139
 140   gst_element_class_set_details (element_class, &gst_ogg_avi_parse_details);
 141
 142   gst_element_class_add_pad_template (element_class,
 143       gst_static_pad_template_get (&ogg_avi_parse_sink_template_factory));
 144   gst_element_class_add_pad_template (element_class,
 145       gst_static_pad_template_get (&ogg_avi_parse_src_template_factory));
 146 }
 147
 148 static void
 149 gst_ogg_avi_parse_class_init (GstOggAviParseClass * klass)
 150 {
 151   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
 152   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 153
 154   parent_class = g_type_class_peek_parent (klass);
 155
 156   gstelement_class->change_state = gst_ogg_avi_parse_change_state;
 157
 158   gobject_class->finalize = gst_ogg_avi_parse_finalize;
 159 }
 160
 161 static void
 162 gst_ogg_avi_parse_init (GstOggAviParse * ogg)
 163 {
 164   /* create the sink and source pads */
 165   ogg->sinkpad =
 166       gst_pad_new_from_static_template (&ogg_avi_parse_sink_template_factory,
 167       "sink");
 168   gst_pad_set_setcaps_function (ogg->sinkpad, gst_ogg_avi_parse_setcaps);
 169   gst_pad_set_event_function (ogg->sinkpad, gst_ogg_avi_parse_event);
 170   gst_pad_set_chain_function (ogg->sinkpad, gst_ogg_avi_parse_chain);
 171   gst_element_add_pad (GST_ELEMENT (ogg), ogg->sinkpad);
 172
 173   ogg->srcpad =
 174       gst_pad_new_from_static_template (&ogg_avi_parse_src_template_factory,
 175       "src");
 176   gst_pad_use_fixed_caps (ogg->srcpad);
 177   gst_element_add_pad (GST_ELEMENT (ogg), ogg->srcpad);
 178 }
 179
 180 static void
 181 gst_ogg_avi_parse_finalize (GObject * object)
 182 {
 183   GstOggAviParse *ogg = GST_OGG_AVI_PARSE (object);
 184
 185   GST_LOG_OBJECT (ogg, "Disposing of object %p", ogg);
 186
 187   ogg_sync_clear (&ogg->sync);
 188   ogg_stream_clear (&ogg->stream);
 189
 190   G_OBJECT_CLASS (parent_class)->finalize (object);
 191 }
 192
 193 static gboolean
 194 gst_ogg_avi_parse_setcaps (GstPad * pad, GstCaps * caps)
 195 {
 196   GstOggAviParse *ogg;
 197   GstStructure *structure;
 198   const GValue *codec_data;
 199   GstBuffer *buffer;
 200   guint8 *data;
 201   guint size;
 202   guint32 sizes[3];
 203   GstCaps *outcaps;
 204   gint i, offs;
 205
 206   ogg = GST_OGG_AVI_PARSE (GST_OBJECT_PARENT (pad));
 207
 208   structure = gst_caps_get_structure (caps, 0);
 209
 210   /* take codec data */
 211   codec_data = gst_structure_get_value (structure, "codec_data");
 212   if (codec_data == NULL)
 213     goto no_data;
 214
 215   /* only buffers are valid */
 216   if (G_VALUE_TYPE (codec_data) != GST_TYPE_BUFFER)
 217     goto wrong_format;
 218
 219   /* Now parse the data */
 220   buffer = gst_value_get_buffer (codec_data);
 221
 222   /* first 22 bytes are bits_per_sample, channel_mask, GUID
 223    * Then we get 3 LE guint32 with the 3 header sizes
 224    * then we get the bytes of the 3 headers. */
 225   data = GST_BUFFER_DATA (buffer);
 226   size = GST_BUFFER_SIZE (buffer);
 227
 228   GST_LOG_OBJECT (ogg, "configuring codec_data of size %u", size);
 229
 230   /* skip headers */
 231   data += 22;
 232   size -= 22;
 233
 234   /* we need at least 12 bytes for the packet sizes of the 3 headers */
 235   if (size < 12)
 236     goto buffer_too_small;
 237
 238   /* read sizes of the 3 headers */
 239   sizes[0] = GST_READ_UINT32_LE (data);
 240   sizes[1] = GST_READ_UINT32_LE (data + 4);
 241   sizes[2] = GST_READ_UINT32_LE (data + 8);
 242
 243   GST_DEBUG_OBJECT (ogg, "header sizes: %u %u %u", sizes[0], sizes[1],
 244       sizes[2]);
 245
 246   data += 12;
 247   size -= 12;
 248
 249   /* and we need at least enough data for all the headers */
 250   if (size < sizes[0] + sizes[1] + sizes[2])
 251     goto buffer_too_small;
 252
 253   /* set caps */
 254   outcaps = gst_caps_new_simple ("audio/x-vorbis", NULL);
 255   gst_pad_set_caps (ogg->srcpad, outcaps);
 256
 257   /* copy header data */
 258   offs = 34;
 259   for (i = 0; i < 3; i++) {
 260     GstBuffer *out;
 261
 262     /* now output the raw vorbis header packets */
 263     out = gst_buffer_create_sub (buffer, offs, sizes[i]);
 264     gst_buffer_set_caps (out, outcaps);
 265     gst_pad_push (ogg->srcpad, out);
 266
 267     offs += sizes[i];
 268   }
 269   gst_caps_unref (outcaps);
 270
 271   return TRUE;
 272
 273   /* ERRORS */
 274 no_data:
 275   {
 276     GST_DEBUG_OBJECT (ogg, "no codec_data found in caps");
 277     return FALSE;
 278   }
 279 wrong_format:
 280   {
 281     GST_DEBUG_OBJECT (ogg, "codec_data is not a buffer");
 282     return FALSE;
 283   }
 284 buffer_too_small:
 285   {
 286     GST_DEBUG_OBJECT (ogg, "codec_data is too small");
 287     return FALSE;
 288   }
 289 }
 290
 291 static gboolean
 292 gst_ogg_avi_parse_event (GstPad * pad, GstEvent * event)
 293 {
 294   GstOggAviParse *ogg;
 295   gboolean ret;
 296
 297   ogg = GST_OGG_AVI_PARSE (GST_OBJECT_PARENT (pad));
 298
 299   switch (GST_EVENT_TYPE (event)) {
 300     case GST_EVENT_FLUSH_START:
 301       ret = gst_pad_push_event (ogg->srcpad, event);
 302       break;
 303     case GST_EVENT_FLUSH_STOP:
 304       ogg_sync_reset (&ogg->sync);
 305       ogg_stream_reset (&ogg->stream);
 306       ogg->discont = TRUE;
 307       ret = gst_pad_push_event (ogg->srcpad, event);
 308       break;
 309     default:
 310       ret = gst_pad_push_event (ogg->srcpad, event);
 311       break;
 312   }
 313   return ret;
 314 }
 315
 316 static GstFlowReturn
 317 gst_ogg_avi_parse_push_packet (GstOggAviParse * ogg, ogg_packet * packet)
 318 {
 319   GstBuffer *buffer;
 320   GstFlowReturn result;
 321
 322   /* allocate space for header and body */
 323   buffer = gst_buffer_new_and_alloc (packet->bytes);
 324   memcpy (GST_BUFFER_DATA (buffer), packet->packet, packet->bytes);
 325
 326   GST_LOG_OBJECT (ogg, "created buffer %p from page", buffer);
 327
 328   GST_BUFFER_OFFSET_END (buffer) = packet->granulepos;
 329
 330   if (ogg->discont) {
 331     GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
 332     ogg->discont = FALSE;
 333   }
 334
 335   result = gst_pad_push (ogg->srcpad, buffer);
 336
 337   return result;
 338 }
 339
 340 static GstFlowReturn
 341 gst_ogg_avi_parse_chain (GstPad * pad, GstBuffer * buffer)
 342 {
 343   GstFlowReturn result = GST_FLOW_OK;
 344   GstOggAviParse *ogg;
 345   guint8 *data;
 346   guint size;
 347   gchar *oggbuf;
 348   gint ret = -1;
 349
 350   ogg = GST_OGG_AVI_PARSE (GST_OBJECT_PARENT (pad));
 351
 352   data = GST_BUFFER_DATA (buffer);
 353   size = GST_BUFFER_SIZE (buffer);
 354
 355   GST_LOG_OBJECT (ogg, "Chain function received buffer of size %d", size);
 356
 357   if (GST_BUFFER_IS_DISCONT (buffer)) {
 358     ogg_sync_reset (&ogg->sync);
 359     ogg->discont = TRUE;
 360   }
 361
 362   /* write data to sync layer */
 363   oggbuf = ogg_sync_buffer (&ogg->sync, size);
 364   memcpy (oggbuf, data, size);
 365   ogg_sync_wrote (&ogg->sync, size);
 366   gst_buffer_unref (buffer);
 367
 368   /* try to get as many packets out of the stream as possible */
 369   do {
 370     ogg_page page;
 371
 372     /* try to swap out a page */
 373     ret = ogg_sync_pageout (&ogg->sync, &page);
 374     if (ret == 0) {
 375       GST_DEBUG_OBJECT (ogg, "need more data");
 376       break;
 377     } else if (ret == -1) {
 378       GST_DEBUG_OBJECT (ogg, "discont in pages");
 379       ogg->discont = TRUE;
 380     } else {
 381       /* new unknown stream, init the ogg stream with the serial number of the
 382        * page. */
 383       if (ogg->serial == -1) {
 384         ogg->serial = ogg_page_serialno (&page);
 385         ogg_stream_init (&ogg->stream, ogg->serial);
 386       }
 387
 388       /* submit page */
 389       if (ogg_stream_pagein (&ogg->stream, &page) != 0) {
 390         GST_WARNING_OBJECT (ogg, "ogg stream choked on page resetting stream");
 391         ogg_sync_reset (&ogg->sync);
 392         ogg->discont = TRUE;
 393         continue;
 394       }
 395
 396       /* try to get as many packets as possible out of the page */
 397       do {
 398         ogg_packet packet;
 399
 400         ret = ogg_stream_packetout (&ogg->stream, &packet);
 401         GST_LOG_OBJECT (ogg, "packetout gave %d", ret);
 402         switch (ret) {
 403           case 0:
 404             break;
 405           case -1:
 406             /* out of sync, We mark a DISCONT. */
 407             ogg->discont = TRUE;
 408             break;
 409           case 1:
 410             result = gst_ogg_avi_parse_push_packet (ogg, &packet);
 411             if (GST_FLOW_IS_FATAL (result))
 412               goto done;
 413             break;
 414           default:
 415             GST_WARNING_OBJECT (ogg,
 416                 "invalid return value %d for ogg_stream_packetout, resetting stream",
 417                 ret);
 418             break;
 419         }
 420       }
 421       while (ret != 0);
 422     }
 423   }
 424   while (ret != 0);
 425
 426 done:
 427   return result;
 428 }
 429
 430 static GstStateChangeReturn
 431 gst_ogg_avi_parse_change_state (GstElement * element, GstStateChange transition)
 432 {
 433   GstOggAviParse *ogg;
 434   GstStateChangeReturn result = GST_STATE_CHANGE_FAILURE;
 435
 436   ogg = GST_OGG_AVI_PARSE (element);
 437
 438   switch (transition) {
 439     case GST_STATE_CHANGE_NULL_TO_READY:
 440       ogg_sync_init (&ogg->sync);
 441       break;
 442     case GST_STATE_CHANGE_READY_TO_PAUSED:
 443       ogg_sync_reset (&ogg->sync);
 444       ogg_stream_reset (&ogg->stream);
 445       ogg->serial = -1;
 446       ogg->discont = TRUE;
 447       break;
 448     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 449       break;
 450     default:
 451       break;
 452   }
 453
 454   result = parent_class->change_state (element, transition);
 455
 456   switch (transition) {
 457     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 458       break;
 459     case GST_STATE_CHANGE_PAUSED_TO_READY:
 460       break;
 461     case GST_STATE_CHANGE_READY_TO_NULL:
 462       ogg_sync_clear (&ogg->sync);
 463       break;
 464     default:
 465       break;
 466   }
 467   return result;
 468 }
 469
 470 gboolean
 471 gst_ogg_avi_parse_plugin_init (GstPlugin * plugin)
 472 {
 473   GST_DEBUG_CATEGORY_INIT (gst_ogg_avi_parse_debug, "oggaviparse", 0,
 474       "ogg avi parser");
 475
 476   return gst_element_register (plugin, "oggaviparse", GST_RANK_PRIMARY,
 477       GST_TYPE_OGG_AVI_PARSE);
 478 }