1 /* GStreamer

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

     3  *

     4  * gstoggdemux.c: ogg stream demuxer

     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  * SECTION:element-oggdemux

    24  * @short_description: a demuxer for ogg files

    25  *

    26  * <refsect2>

    27  * <para>

    28  * This element demuxes ogg files into their encoded audio and video components.

    29  * </para>

    30  * <title>Example pipelines</title>

    31  * <para>

    32  * <programlisting>

    33  * gst-launch -v filesrc location=test.ogg ! oggdemux ! vorbisdec ! audioconvert ! alsasink

    34  * </programlisting>

    35  * Decodes the vorbis audio stored inside an ogg container.

    36  * </para>

    37  * </refsect2>

    38  *

    39  * Last reviewed on 2006-12-30 (0.10.5)

    40  */

    41 

    42 

    43 #ifdef HAVE_CONFIG_H

    44 #include "config.h"

    45 #endif

    46 #include <string.h>

    47 #include <gst/gst-i18n-plugin.h>

    48 #include <gst/base/gsttypefindhelper.h>

    49 

    50 #include "gstoggdemux.h"

    51 

    52 static const GstElementDetails gst_ogg_demux_details =

    53 GST_ELEMENT_DETAILS ("Ogg demuxer",

    54     "Codec/Demuxer",

    55     "demux ogg streams (info about ogg: http://xiph.org)",

    56     "Wim Taymans <wim@fluendo.com>");

    57 

    58 #define CHUNKSIZE (8500)        /* this is out of vorbisfile */

    59 #define SKELETON_FISHEAD_SIZE 64

    60 #define SKELETON_FISBONE_MIN_SIZE 52

    61 

    62 #define GST_FLOW_LIMIT GST_FLOW_CUSTOM_ERROR

    63 

    64 GST_DEBUG_CATEGORY_STATIC (gst_ogg_demux_debug);

    65 GST_DEBUG_CATEGORY_STATIC (gst_ogg_demux_setup_debug);

    66 #define GST_CAT_DEFAULT gst_ogg_demux_debug

    67 

    68 static ogg_page *

    69 gst_ogg_page_copy (ogg_page * page)

    70 {

    71   ogg_page *p = g_new0 (ogg_page, 1);

    72 

    73   /* make a copy of the page */

    74   p->header = g_memdup (page->header, page->header_len);

    75   p->header_len = page->header_len;

    76   p->body = g_memdup (page->body, page->body_len);

    77   p->body_len = page->body_len;

    78 

    79   return p;

    80 }

    81 

    82 static void

    83 gst_ogg_page_free (ogg_page * page)

    84 {

    85   g_free (page->header);

    86   g_free (page->body);

    87   g_free (page);

    88 }

    89 

    90 static GstStaticPadTemplate internaltemplate =

    91 GST_STATIC_PAD_TEMPLATE ("internal",

    92     GST_PAD_SINK,

    93     GST_PAD_ALWAYS,

    94     GST_STATIC_CAPS_ANY);

    95 

    96 static gboolean gst_ogg_demux_collect_chain_info (GstOggDemux * ogg,

    97     GstOggChain * chain);

    98 static gboolean gst_ogg_demux_activate_chain (GstOggDemux * ogg,

    99     GstOggChain * chain, GstEvent * event);

   100 static void gst_ogg_chain_mark_discont (GstOggChain * chain);

   101 

   102 static gboolean gst_ogg_demux_perform_seek (GstOggDemux * ogg,

   103     GstEvent * event);

   104 static gboolean gst_ogg_demux_receive_event (GstElement * element,

   105     GstEvent * event);

   106 

   107 static void gst_ogg_pad_class_init (GstOggPadClass * klass);

   108 static void gst_ogg_pad_init (GstOggPad * pad);

   109 static void gst_ogg_pad_dispose (GObject * object);

   110 static void gst_ogg_pad_finalize (GObject * object);

   111 

   112 #if 0

   113 static const GstFormat *gst_ogg_pad_formats (GstPad * pad);

   114 static const GstEventMask *gst_ogg_pad_event_masks (GstPad * pad);

   115 #endif

   116 static const GstQueryType *gst_ogg_pad_query_types (GstPad * pad);

   117 static gboolean gst_ogg_pad_src_query (GstPad * pad, GstQuery * query);

   118 static gboolean gst_ogg_pad_event (GstPad * pad, GstEvent * event);

   119 static GstCaps *gst_ogg_pad_getcaps (GstPad * pad);

   120 static GstOggPad *gst_ogg_chain_get_stream (GstOggChain * chain,

   121     glong serialno);

   122 

   123 static gboolean gst_ogg_pad_query_convert (GstOggPad * pad,

   124     GstFormat src_format, gint64 src_val,

   125     GstFormat * dest_format, gint64 * dest_val);

   126 static GstClockTime gst_annodex_granule_to_time (gint64 granulepos,

   127     gint64 granulerate_n, gint64 granulerate_d, guint8 granuleshift);

   128 

   129 static GstFlowReturn gst_ogg_demux_combine_flows (GstOggDemux * ogg,

   130     GstOggPad * pad, GstFlowReturn ret);

   131 

   132 static GstPadClass *ogg_pad_parent_class = NULL;

   133 

   134 static GType

   135 gst_ogg_pad_get_type (void)

   136 {

   137   static GType ogg_pad_type = 0;

   138 

   139   if (!ogg_pad_type) {

   140     static const GTypeInfo ogg_pad_info = {

   141       sizeof (GstOggPadClass),

   142       NULL,

   143       NULL,

   144       (GClassInitFunc) gst_ogg_pad_class_init,

   145       NULL,

   146       NULL,

   147       sizeof (GstOggPad),

   148       0,

   149       (GInstanceInitFunc) gst_ogg_pad_init,

   150     };

   151 

   152     ogg_pad_type =

   153         g_type_register_static (GST_TYPE_PAD, "GstOggPad", &ogg_pad_info, 0);

   154   }

   155   return ogg_pad_type;

   156 }

   157 

   158 static void

   159 gst_ogg_pad_class_init (GstOggPadClass * klass)

   160 {

   161   GObjectClass *gobject_class;

   162 

   163   gobject_class = (GObjectClass *) klass;

   164 

   165   ogg_pad_parent_class = g_type_class_peek_parent (klass);

   166 

   167   gobject_class->dispose = gst_ogg_pad_dispose;

   168   gobject_class->finalize = gst_ogg_pad_finalize;

   169 }

   170 

   171 static void

   172 gst_ogg_pad_init (GstOggPad * pad)

   173 {

   174   gst_pad_set_event_function (GST_PAD (pad),

   175       GST_DEBUG_FUNCPTR (gst_ogg_pad_event));

   176   gst_pad_set_getcaps_function (GST_PAD (pad),

   177       GST_DEBUG_FUNCPTR (gst_ogg_pad_getcaps));

   178   gst_pad_set_query_type_function (GST_PAD (pad),

   179       GST_DEBUG_FUNCPTR (gst_ogg_pad_query_types));

   180   gst_pad_set_query_function (GST_PAD (pad),

   181       GST_DEBUG_FUNCPTR (gst_ogg_pad_src_query));

   182 

   183   pad->mode = GST_OGG_PAD_MODE_INIT;

   184 

   185   pad->first_granule = -1;

   186   pad->current_granule = -1;

   187 

   188   pad->start_time = GST_CLOCK_TIME_NONE;

   189   pad->first_time = GST_CLOCK_TIME_NONE;

   190 

   191   pad->have_type = FALSE;

   192   pad->continued = NULL;

   193   pad->headers = NULL;

   194 }

   195 

   196 static void

   197 gst_ogg_pad_dispose (GObject * object)

   198 {

   199   GstOggPad *pad = GST_OGG_PAD (object);

   200   GstPad **elem_pad_p;

   201   GstElement **element_p;

   202   GstPad **elem_out_p;

   203 

   204   if (pad->element)

   205     gst_element_set_state (pad->element, GST_STATE_NULL);

   206 

   207   elem_pad_p = &pad->elem_pad;

   208   element_p = &pad->element;

   209   elem_out_p = &pad->elem_out;

   210   gst_object_replace ((GstObject **) elem_pad_p, NULL);

   211   gst_object_replace ((GstObject **) element_p, NULL);

   212   gst_object_replace ((GstObject **) elem_out_p, NULL);

   213 

   214   pad->chain = NULL;

   215   pad->ogg = NULL;

   216 

   217   g_list_foreach (pad->headers, (GFunc) gst_mini_object_unref, NULL);

   218   g_list_free (pad->headers);

   219   pad->headers = NULL;

   220 

   221   /* clear continued pages */

   222   g_list_foreach (pad->continued, (GFunc) gst_ogg_page_free, NULL);

   223   g_list_free (pad->continued);

   224   pad->continued = NULL;

   225 

   226   ogg_stream_reset (&pad->stream);

   227 

   228   G_OBJECT_CLASS (ogg_pad_parent_class)->dispose (object);

   229 }

   230 

   231 static void

   232 gst_ogg_pad_finalize (GObject * object)

   233 {

   234   GstOggPad *pad = GST_OGG_PAD (object);

   235 

   236   ogg_stream_clear (&pad->stream);

   237 

   238   G_OBJECT_CLASS (ogg_pad_parent_class)->finalize (object);

   239 }

   240 

   241 #if 0

   242 static const GstFormat *

   243 gst_ogg_pad_formats (GstPad * pad)

   244 {

   245   static GstFormat src_formats[] = {

   246     GST_FORMAT_DEFAULT,         /* time */

   247     GST_FORMAT_TIME,            /* granulepos */

   248     0

   249   };

   250   static GstFormat sink_formats[] = {

   251     GST_FORMAT_BYTES,

   252     GST_FORMAT_DEFAULT,         /* bytes */

   253     0

   254   };

   255 

   256   return (GST_PAD_IS_SRC (pad) ? src_formats : sink_formats);

   257 }

   258 #endif

   259 

   260 #if 0

   261 static const GstEventMask *

   262 gst_ogg_pad_event_masks (GstPad * pad)

   263 {

   264   static const GstEventMask src_event_masks[] = {

   265     {GST_EVENT_SEEK, GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH},

   266     {0,}

   267   };

   268 

   269   return src_event_masks;

   270 }

   271 #endif

   272 

   273 static const GstQueryType *

   274 gst_ogg_pad_query_types (GstPad * pad)

   275 {

   276   static const GstQueryType query_types[] = {

   277     GST_QUERY_DURATION,

   278     GST_QUERY_SEEKING,

   279     0

   280   };

   281 

   282   return query_types;

   283 }

   284 

   285 static GstCaps *

   286 gst_ogg_pad_getcaps (GstPad * pad)

   287 {

   288   return gst_caps_ref (GST_PAD_CAPS (pad));

   289 }

   290 

   291 static gboolean

   292 gst_ogg_pad_src_query (GstPad * pad, GstQuery * query)

   293 {

   294   gboolean res = TRUE;

   295   GstOggDemux *ogg;

   296   GstOggPad *cur;

   297 

   298   ogg = GST_OGG_DEMUX (gst_pad_get_parent (pad));

   299   cur = GST_OGG_PAD (pad);

   300 

   301   switch (GST_QUERY_TYPE (query)) {

   302     case GST_QUERY_DURATION:

   303     {

   304       GstFormat format;

   305 

   306       gst_query_parse_duration (query, &format, NULL);

   307       /* can only get position in time */

   308       if (format != GST_FORMAT_TIME)

   309         goto wrong_format;

   310 

   311       /* can only return the total time position */

   312       /* FIXME, return time for this specific stream */

   313       gst_query_set_duration (query, GST_FORMAT_TIME, ogg->total_time);

   314       break;

   315     }

   316     case GST_QUERY_SEEKING:

   317     {

   318       GstFormat format;

   319 

   320       gst_query_parse_seeking (query, &format, NULL, NULL, NULL);

   321       if (format == GST_FORMAT_TIME) {

   322         gst_query_set_seeking (query, GST_FORMAT_TIME, ogg->seekable,

   323             0, ogg->total_time);

   324       } else {

   325         res = FALSE;

   326       }

   327       break;

   328     }

   329 

   330     default:

   331       res = gst_pad_query_default (pad, query);

   332       break;

   333   }

   334 done:

   335   gst_object_unref (ogg);

   336 

   337   return res;

   338 

   339   /* ERRORS */

   340 wrong_format:

   341   {

   342     GST_DEBUG_OBJECT (ogg, "only query duration on TIME is supported");

   343     res = FALSE;

   344     goto done;

   345   }

   346 }

   347 

   348 static gboolean

   349 gst_ogg_demux_receive_event (GstElement * element, GstEvent * event)

   350 {

   351   gboolean res;

   352   GstOggDemux *ogg;

   353 

   354   ogg = GST_OGG_DEMUX (element);

   355 

   356   switch (GST_EVENT_TYPE (event)) {

   357     case GST_EVENT_SEEK:

   358       /* can't seek if we are not seekable, FIXME could pass the

   359        * seek query upstream after converting it to bytes using

   360        * the average bitrate of the stream. */

   361       if (!ogg->seekable) {

   362         GST_DEBUG_OBJECT (ogg, "seek on non seekable stream");

   363         goto error;

   364       }

   365 

   366       /* now do the seek */

   367       res = gst_ogg_demux_perform_seek (ogg, event);

   368       gst_event_unref (event);

   369       break;

   370     default:

   371       GST_DEBUG_OBJECT (ogg, "We only handle seek events here");

   372       goto error;

   373   }

   374 

   375   return res;

   376 

   377   /* ERRORS */

   378 error:

   379   {

   380     GST_DEBUG_OBJECT (ogg, "error handling event");

   381     gst_event_unref (event);

   382     return FALSE;

   383   }

   384 }

   385 

   386 static gboolean

   387 gst_ogg_pad_event (GstPad * pad, GstEvent * event)

   388 {

   389   gboolean res;

   390   GstOggDemux *ogg;

   391   GstOggPad *cur;

   392 

   393   ogg = GST_OGG_DEMUX (gst_pad_get_parent (pad));

   394   cur = GST_OGG_PAD (pad);

   395 

   396   switch (GST_EVENT_TYPE (event)) {

   397     case GST_EVENT_SEEK:

   398       /* can't seek if we are not seekable, FIXME could pass the

   399        * seek query upstream after converting it to bytes using

   400        * the average bitrate of the stream. */

   401       if (!ogg->seekable) {

   402         GST_DEBUG_OBJECT (ogg, "seek on non seekable stream");

   403         goto error;

   404       }

   405 

   406       /* now do the seek */

   407       res = gst_ogg_demux_perform_seek (ogg, event);

   408       gst_event_unref (event);

   409       break;

   410     default:

   411       res = gst_pad_event_default (pad, event);

   412       break;

   413   }

   414 done:

   415   gst_object_unref (ogg);

   416 

   417   return res;

   418 

   419   /* ERRORS */

   420 error:

   421   {

   422     GST_DEBUG_OBJECT (ogg, "error handling event");

   423     gst_event_unref (event);

   424     res = FALSE;

   425     goto done;

   426   }

   427 }

   428 

   429 static void

   430 gst_ogg_pad_reset (GstOggPad * pad)

   431 {

   432   ogg_stream_reset (&pad->stream);

   433 

   434   /* clear continued pages */

   435   g_list_foreach (pad->continued, (GFunc) gst_ogg_page_free, NULL);

   436   g_list_free (pad->continued);

   437   pad->continued = NULL;

   438 

   439   pad->last_ret = GST_FLOW_OK;

   440 }

   441 

   442 /* the filter function for selecting the elements we can use in

   443  * autoplugging */

   444 static gboolean

   445 gst_ogg_demux_factory_filter (GstPluginFeature * feature, GstCaps * caps)

   446 {

   447   guint rank;

   448   const gchar *klass;

   449 

   450   /* we only care about element factories */

   451   if (!GST_IS_ELEMENT_FACTORY (feature))

   452     return FALSE;

   453 

   454   klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature));

   455   /* only demuxers and decoders can play */

   456   if (strstr (klass, "Demux") == NULL &&

   457       strstr (klass, "Decoder") == NULL && strstr (klass, "Parse") == NULL) {

   458     return FALSE;

   459   }

   460 

   461   /* only select elements with autoplugging rank */

   462   rank = gst_plugin_feature_get_rank (feature);

   463   if (rank < GST_RANK_MARGINAL)

   464     return FALSE;

   465 

   466   GST_DEBUG ("checking factory %s", GST_PLUGIN_FEATURE_NAME (feature));

   467   /* now see if it is compatible with the caps */

   468   {

   469     GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);

   470     const GList *templates;

   471     GList *walk;

   472 

   473     /* get the templates from the element factory */

   474     templates = gst_element_factory_get_static_pad_templates (factory);

   475 

   476     for (walk = (GList *) templates; walk; walk = g_list_next (walk)) {

   477       GstStaticPadTemplate *templ = walk->data;

   478 

   479       /* we only care about the sink templates */

   480       if (templ->direction == GST_PAD_SINK) {

   481         GstCaps *intersect;

   482         GstCaps *scaps;

   483         gboolean empty;

   484 

   485         /* try to intersect the caps with the caps of the template */

   486         scaps = gst_static_caps_get (&templ->static_caps);

   487         intersect = gst_caps_intersect (caps, scaps);

   488         gst_caps_unref (scaps);

   489 

   490         empty = gst_caps_is_empty (intersect);

   491         gst_caps_unref (intersect);

   492 

   493         /* check if the intersection is empty */

   494         if (!empty) {

   495           /* non empty intersection, we can use this element */

   496           goto found;

   497         }

   498       }

   499     }

   500   }

   501   return FALSE;

   502 

   503 found:

   504   return TRUE;

   505 }

   506 

   507 /* function used to sort element features */

   508 static gint

   509 compare_ranks (GstPluginFeature * f1, GstPluginFeature * f2)

   510 {

   511   gint diff;

   512 

   513   diff = gst_plugin_feature_get_rank (f2) - gst_plugin_feature_get_rank (f1);

   514   if (diff != 0)

   515     return diff;

   516   return strcmp (gst_plugin_feature_get_name (f2),

   517       gst_plugin_feature_get_name (f1));

   518 }

   519 

   520 /* called when the skeleton fishead is found. Caller ensures the packet is

   521  * precisely the correct size; we don't re-check this here. */

   522 static void

   523 gst_ogg_pad_parse_skeleton_fishead (GstOggPad * pad, ogg_packet * packet)

   524 {

   525   GstOggDemux *ogg = pad->ogg;

   526   guint8 *data = packet->packet;

   527   guint16 major, minor;

   528   gint64 prestime_n, prestime_d;

   529   gint64 basetime_n, basetime_d;

   530 

   531   /* skip "fishead\0" */

   532   data += 8;

   533   major = GST_READ_UINT16_LE (data);

   534   data += 2;

   535   minor = GST_READ_UINT16_LE (data);

   536   data += 2;

   537   prestime_n = (gint64) GST_READ_UINT64_LE (data);

   538   data += 8;

   539   prestime_d = (gint64) GST_READ_UINT64_LE (data);

   540   data += 8;

   541   basetime_n = (gint64) GST_READ_UINT64_LE (data);

   542   data += 8;

   543   basetime_d = (gint64) GST_READ_UINT64_LE (data);

   544   data += 8;

   545 

   546   ogg->basetime = gst_util_uint64_scale (GST_SECOND, basetime_n, basetime_d);

   547   ogg->have_fishead = TRUE;

   548   pad->is_skeleton = TRUE;

   549   pad->start_time = GST_CLOCK_TIME_NONE;

   550   pad->first_granule = -1;

   551   pad->first_time = GST_CLOCK_TIME_NONE;

   552   GST_INFO_OBJECT (ogg, "skeleton fishead parsed (basetime: %"

   553       GST_TIME_FORMAT ")", GST_TIME_ARGS (ogg->basetime));

   554 }

   555 

   556 /* function called when a skeleton fisbone is found. Caller ensures that

   557  * the packet length is sufficient */

   558 static void

   559 gst_ogg_pad_parse_skeleton_fisbone (GstOggPad * pad, ogg_packet * packet)

   560 {

   561   GstOggPad *fisbone_pad;

   562   gint64 start_granule;

   563   guint32 serialno;

   564   guint8 *data = packet->packet;

   565 

   566   /* skip "fisbone\0" */

   567   data += 8;

   568   /* skip headers offset */

   569   data += 4;

   570   serialno = GST_READ_UINT32_LE (data);

   571 

   572   fisbone_pad = gst_ogg_chain_get_stream (pad->chain, serialno);

   573   if (fisbone_pad) {

   574     if (fisbone_pad->have_fisbone)

   575       /* already parsed */

   576       return;

   577 

   578     fisbone_pad->have_fisbone = TRUE;

   579 

   580     data += 4;

   581     /* skip number of headers */

   582     data += 4;

   583     fisbone_pad->granulerate_n = GST_READ_UINT64_LE (data);

   584     data += 8;

   585     fisbone_pad->granulerate_d = GST_READ_UINT64_LE (data);

   586     data += 8;

   587     start_granule = GST_READ_UINT64_LE (data);

   588     data += 8;

   589     fisbone_pad->preroll = GST_READ_UINT32_LE (data);

   590     data += 4;

   591     fisbone_pad->granuleshift = GST_READ_UINT8 (data);

   592     data += 1;

   593     /* padding */

   594     data += 3;

   595 

   596     fisbone_pad->start_time = gst_annodex_granule_to_time (start_granule,

   597         fisbone_pad->granulerate_n, fisbone_pad->granulerate_d,

   598         fisbone_pad->granuleshift);

   599 

   600     GST_INFO_OBJECT (pad->ogg, "skeleton fisbone parsed "

   601         "(serialno: %08x start time: %" GST_TIME_FORMAT

   602         " granulerate_n: %" G_GINT64_FORMAT " granulerate_d: %" G_GINT64_FORMAT

   603         " preroll: %" G_GUINT32_FORMAT " granuleshift: %d)",

   604         serialno, GST_TIME_ARGS (fisbone_pad->start_time),

   605         fisbone_pad->granulerate_n, fisbone_pad->granulerate_d,

   606         fisbone_pad->preroll, fisbone_pad->granuleshift);

   607   } else {

   608     GST_WARNING_OBJECT (pad->ogg,

   609         "found skeleton fisbone for an unknown stream %" G_GUINT32_FORMAT,

   610         serialno);

   611   }

   612 }

   613 

   614 /* function called to convert a granulepos to a timestamp */

   615 static gboolean

   616 gst_ogg_pad_query_convert (GstOggPad * pad, GstFormat src_format,

   617     gint64 src_val, GstFormat * dest_format, gint64 * dest_val)

   618 {

   619   gboolean res;

   620 

   621   if (src_val == -1) {

   622     *dest_val = -1;

   623     return TRUE;

   624   }

   625 

   626   if (!pad->have_fisbone && pad->elem_pad == NULL)

   627     return FALSE;

   628 

   629   switch (src_format) {

   630     case GST_FORMAT_DEFAULT:

   631       if (pad->have_fisbone && *dest_format == GST_FORMAT_TIME) {

   632         *dest_val = gst_annodex_granule_to_time (src_val,

   633             pad->granulerate_n, pad->granulerate_d, pad->granuleshift);

   634 

   635         res = TRUE;

   636       } else {

   637         if (pad->elem_pad == NULL)

   638           res = FALSE;

   639         else

   640           res = gst_pad_query_convert (pad->elem_pad, src_format, src_val,

   641               dest_format, dest_val);

   642       }

   643 

   644       break;

   645     default:

   646       if (pad->elem_pad == NULL)

   647         res = FALSE;

   648       else

   649         res = gst_pad_query_convert (pad->elem_pad, src_format, src_val,

   650             dest_format, dest_val);

   651   }

   652 

   653   return res;

   654 }

   655 

   656 /* function called by the internal decoder elements when it outputs

   657  * a buffer. We use it to get the first timestamp of the stream 

   658  */

   659 static GstFlowReturn

   660 gst_ogg_pad_internal_chain (GstPad * pad, GstBuffer * buffer)

   661 {

   662   GstOggPad *oggpad;

   663   GstOggDemux *ogg;

   664   GstClockTime timestamp;

   665 

   666   oggpad = gst_pad_get_element_private (pad);

   667   ogg = GST_OGG_DEMUX (oggpad->ogg);

   668 

   669   timestamp = GST_BUFFER_TIMESTAMP (buffer);

   670   GST_DEBUG_OBJECT (oggpad, "received buffer from internal pad, TS=%"

   671       GST_TIME_FORMAT "=%" G_GINT64_FORMAT, GST_TIME_ARGS (timestamp),

   672       timestamp);

   673 

   674   if (oggpad->start_time == GST_CLOCK_TIME_NONE) {

   675     oggpad->start_time = timestamp;

   676     GST_DEBUG_OBJECT (oggpad, "new start time: %" GST_TIME_FORMAT,

   677         GST_TIME_ARGS (timestamp));

   678   }

   679 

   680   gst_buffer_unref (buffer);

   681 

   682   return GST_FLOW_OK;

   683 }

   684 

   685 static void

   686 internal_element_pad_added_cb (GstElement * element, GstPad * pad,

   687     GstOggPad * oggpad)

   688 {

   689   if (GST_PAD_DIRECTION (pad) == GST_PAD_SRC) {

   690     if (!(gst_pad_link (pad, oggpad->elem_out) == GST_PAD_LINK_OK)) {

   691       GST_ERROR ("Really couldn't find a valid pad");

   692     }

   693     oggpad->dynamic = FALSE;

   694     g_signal_handler_disconnect (element, oggpad->padaddedid);

   695     oggpad->padaddedid = 0;

   696   }

   697 }

   698 

   699 /* runs typefind on the packet, which is assumed to be the first

   700  * packet in the stream.

   701  * 

   702  * Based on the type returned from the typefind function, an element

   703  * is created to help in conversion between granulepos and timestamps

   704  * so that we can do decent seeking.

   705  */

   706 static gboolean

   707 gst_ogg_pad_typefind (GstOggPad * pad, ogg_packet * packet)

   708 {

   709   GstBuffer *buf;

   710   GstCaps *caps;

   711   GstElement *element = NULL;

   712 

   713 #ifndef GST_DISABLE_GST_DEBUG

   714   GstOggDemux *ogg = pad->ogg;

   715 #endif

   716 

   717   if (GST_PAD_CAPS (pad) != NULL)

   718     return TRUE;

   719 

   720   /* The ogg spec defines that the first packet of an ogg stream must identify

   721    * the stream. Therefore ogg can use a simplified approach to typefinding

   722    * and only needs to check the first packet */

   723   buf = gst_buffer_new ();

   724   GST_BUFFER_DATA (buf) = packet->packet;

   725   GST_BUFFER_SIZE (buf) = packet->bytes;

   726   GST_BUFFER_OFFSET (buf) = 0;

   727 

   728   caps = gst_type_find_helper_for_buffer (GST_OBJECT (pad), buf, NULL);

   729   gst_buffer_unref (buf);

   730 

   731   if (caps == NULL) {

   732     GST_WARNING_OBJECT (ogg,

   733         "couldn't find caps for stream with serial %08x", pad->serialno);

   734     caps = gst_caps_new_simple ("application/octet-stream", NULL);

   735   } else {

   736     /* ogg requires you to use a decoder element to define the

   737      * meaning of granulepos etc so we make one. We also do this if

   738      * we are in the streaming mode to calculate the first timestamp. */

   739     GList *factories;

   740 

   741     GST_LOG_OBJECT (ogg, "found caps: %" GST_PTR_FORMAT, caps);

   742 

   743     /* first filter out the interesting element factories */

   744     factories = gst_default_registry_feature_filter (

   745         (GstPluginFeatureFilter) gst_ogg_demux_factory_filter, FALSE, caps);

   746 

   747     /* sort them according to their ranks */

   748     factories = g_list_sort (factories, (GCompareFunc) compare_ranks);

   749 

   750     /* then pick the first factory to create an element */

   751     if (factories) {

   752       element =

   753           gst_element_factory_create (GST_ELEMENT_FACTORY (factories->data),

   754           NULL);

   755       if (element) {

   756         GstPadTemplate *template;

   757 

   758         /* this is ours */

   759         gst_object_ref (element);

   760         gst_object_sink (GST_OBJECT (element));

   761 

   762         /* FIXME, it might not be named "sink" */

   763         pad->elem_pad = gst_element_get_pad (element, "sink");

   764         gst_element_set_state (element, GST_STATE_PAUSED);

   765         template = gst_static_pad_template_get (&internaltemplate);

   766         pad->elem_out = gst_pad_new_from_template (template, "internal");

   767         gst_pad_set_chain_function (pad->elem_out, gst_ogg_pad_internal_chain);

   768         gst_pad_set_element_private (pad->elem_out, pad);

   769         gst_pad_set_active (pad->elem_out, TRUE);

   770         gst_object_unref (template);

   771 

   772         /* and this pad may not be named src.. */

   773         /* And it might also not exist at this time... */

   774         {

   775           GstPad *p;

   776 

   777           p = gst_element_get_pad (element, "src");

   778           if (p) {

   779             gst_pad_link (p, pad->elem_out);

   780             gst_object_unref (p);

   781           } else {

   782             pad->dynamic = TRUE;

   783             pad->padaddedid = g_signal_connect (G_OBJECT (element),

   784                 "pad-added", G_CALLBACK (internal_element_pad_added_cb), pad);

   785           }

   786         }

   787       }

   788     }

   789     g_list_free (factories);

   790   }

   791   pad->element = element;

   792 

   793   gst_pad_set_caps (GST_PAD (pad), caps);

   794   gst_caps_unref (caps);

   795 

   796   return TRUE;

   797 }

   798 

   799 /* send packet to internal element */

   800 static GstFlowReturn

   801 gst_ogg_demux_chain_elem_pad (GstOggPad * pad, ogg_packet * packet)

   802 {

   803   GstBuffer *buf;

   804   GstFlowReturn ret;

   805 

   806 #ifndef GST_DISABLE_GST_DEBUG

   807   GstOggDemux *ogg = pad->ogg;

   808 #endif

   809 

   810   /* initialize our internal decoder with packets */

   811   if (!pad->elem_pad)

   812     goto no_decoder;

   813 

   814   GST_DEBUG_OBJECT (ogg, "%p init decoder serial %08x", pad, pad->serialno);

   815 

   816   buf = gst_buffer_new_and_alloc (packet->bytes);

   817   memcpy (GST_BUFFER_DATA (buf), packet->packet, packet->bytes);

   818   gst_buffer_set_caps (buf, GST_PAD_CAPS (pad));

   819   GST_BUFFER_OFFSET (buf) = -1;

   820   GST_BUFFER_OFFSET_END (buf) = packet->granulepos;

   821 

   822   ret = gst_pad_chain (pad->elem_pad, buf);

   823   if (GST_FLOW_IS_FATAL (ret))

   824     goto decoder_error;

   825 

   826   return ret;

   827 

   828 no_decoder:

   829   {

   830     GST_WARNING_OBJECT (ogg,

   831         "pad %p does not have elem_pad, no decoder ?", pad);

   832     return GST_FLOW_ERROR;

   833   }

   834 decoder_error:

   835   {

   836     GST_WARNING_OBJECT (ogg, "internal decoder error");

   837     return GST_FLOW_ERROR;

   838   }

   839 }

   840 

   841 /* queue data, basically takes the packet, puts it in a buffer and store the

   842  * buffer in the headers list.

   843  */

   844 static GstFlowReturn

   845 gst_ogg_demux_queue_data (GstOggPad * pad, ogg_packet * packet)

   846 {

   847   GstBuffer *buf;

   848 

   849 #ifndef GST_DISABLE_GST_DEBUG

   850   GstOggDemux *ogg = pad->ogg;

   851 #endif

   852 

   853   GST_DEBUG_OBJECT (ogg, "%p queueing data serial %08x", pad, pad->serialno);

   854 

   855   buf = gst_buffer_new_and_alloc (packet->bytes);

   856   memcpy (buf->data, packet->packet, packet->bytes);

   857   GST_BUFFER_OFFSET (buf) = -1;

   858   GST_BUFFER_OFFSET_END (buf) = packet->granulepos;

   859   pad->headers = g_list_append (pad->headers, buf);

   860 

   861   /* we are ok now */

   862   return GST_FLOW_OK;

   863 }

   864 

   865 /* send packet to internal element */

   866 static GstFlowReturn

   867 gst_ogg_demux_chain_peer (GstOggPad * pad, ogg_packet * packet)

   868 {

   869   GstBuffer *buf;

   870   GstFlowReturn ret, cret;

   871   GstOggDemux *ogg = pad->ogg;

   872   GstFormat format;

   873   gint64 current_time;

   874   GstOggChain *chain;

   875 

   876   GST_DEBUG_OBJECT (ogg,

   877       "%p streaming to peer serial %08x", pad, pad->serialno);

   878 

   879   ret =

   880       gst_pad_alloc_buffer_and_set_caps (GST_PAD_CAST (pad),

   881       GST_BUFFER_OFFSET_NONE, packet->bytes, GST_PAD_CAPS (pad), &buf);

   882 

   883   /* combine flows */

   884   cret = gst_ogg_demux_combine_flows (ogg, pad, ret);

   885   if (ret != GST_FLOW_OK)

   886     goto no_buffer;

   887 

   888   /* copy packet in buffer */

   889   memcpy (buf->data, packet->packet, packet->bytes);

   890 

   891   GST_BUFFER_OFFSET (buf) = -1;

   892   GST_BUFFER_OFFSET_END (buf) = packet->granulepos;

   893 

   894   /* Mark discont on the buffer */

   895   if (pad->discont) {

   896     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);

   897     pad->discont = FALSE;

   898   }

   899 

   900   ret = gst_pad_push (GST_PAD_CAST (pad), buf);

   901 

   902   /* combine flows */

   903   cret = gst_ogg_demux_combine_flows (ogg, pad, ret);

   904 

   905   /* we're done with skeleton stuff */

   906   if (pad->is_skeleton)

   907     goto done;

   908 

   909   /* check if valid granulepos, then we can calculate the current

   910    * position */

   911   if (packet->granulepos < 0)

   912     goto done;

   913 

   914   /* store current granule pos */

   915   ogg->current_granule = packet->granulepos;

   916 

   917   /* convert to time */

   918   format = GST_FORMAT_TIME;

   919   if (!gst_ogg_pad_query_convert (pad,

   920           GST_FORMAT_DEFAULT, packet->granulepos, &format,

   921           (gint64 *) & current_time))

   922     goto convert_failed;

   923 

   924   /* convert to stream time */

   925   if ((chain = pad->chain))

   926     current_time = current_time - chain->segment_start + chain->begin_time;

   927 

   928   /* and store as the current position */

   929   gst_segment_set_last_stop (&ogg->segment, GST_FORMAT_TIME, current_time);

   930 

   931   GST_DEBUG_OBJECT (ogg, "ogg current time %" GST_TIME_FORMAT,

   932       GST_TIME_ARGS (current_time));

   933 

   934 done:

   935   /* return combined flow result */

   936   return cret;

   937 

   938   /* special cases */

   939 no_buffer:

   940   {

   941     GST_DEBUG_OBJECT (ogg,

   942         "%p could not get buffer from peer %08x, %d (%s), combined %d (%s)",

   943         pad, pad->serialno, ret, gst_flow_get_name (ret),

   944         cret, gst_flow_get_name (cret));

   945     goto done;

   946   }

   947 convert_failed:

   948   {

   949     GST_WARNING_OBJECT (ogg, "could not convert granulepos to time");

   950     goto done;

   951   }

   952 }

   953 

   954 /* submit a packet to the oggpad, this function will run the

   955  * typefind code for the pad if this is the first packet for this

   956  * stream 

   957  */

   958 static GstFlowReturn

   959 gst_ogg_pad_submit_packet (GstOggPad * pad, ogg_packet * packet)

   960 {

   961   gint64 granule;

   962   GstFlowReturn ret;

   963 

   964   GstOggDemux *ogg = pad->ogg;

   965 

   966   GST_DEBUG_OBJECT (ogg, "%p submit packet serial %08x", pad, pad->serialno);

   967 

   968   if (!pad->have_type) {

   969     if (!ogg->have_fishead && packet->bytes == SKELETON_FISHEAD_SIZE &&

   970         !memcmp (packet->packet, "fishead\0", 8)) {

   971       gst_ogg_pad_parse_skeleton_fishead (pad, packet);

   972     }

   973     gst_ogg_pad_typefind (pad, packet);

   974     pad->have_type = TRUE;

   975   }

   976 

   977   if (ogg->have_fishead && packet->bytes >= SKELETON_FISBONE_MIN_SIZE &&

   978       !memcmp (packet->packet, "fisbone\0", 8)) {

   979     gst_ogg_pad_parse_skeleton_fisbone (pad, packet);

   980   }

   981 

   982   granule = packet->granulepos;

   983   if (granule != -1) {

   984     GST_DEBUG_OBJECT (ogg, "%p has granulepos %" G_GINT64_FORMAT, pad, granule);

   985     ogg->current_granule = granule;

   986     pad->current_granule = granule;

   987     /* granulepos 0 and -1 are considered header packets.

   988      * Note that since theora is busted, it can create non-header

   989      * packets with 0 granulepos. We will correct for this when our

   990      * internal decoder produced a frame and we don't have a

   991      * granulepos because in that case the granulpos must have been 0 */

   992     if (pad->first_granule == -1 && granule != 0) {

   993       GST_DEBUG_OBJECT (ogg, "%p found first granulepos %" G_GINT64_FORMAT, pad,

   994           granule);

   995       pad->first_granule = granule;

   996     }

   997   }

   998 

   999   if (granule != -1 && memcmp (packet->packet, "KW-DIRAC", 8) == 0) {

  1000     return GST_FLOW_OK;

  1001   }

  1002 

  1003   /* no start time known, stream to internal plugin to

  1004    * get time. always stream to the skeleton decoder */

  1005   if (pad->start_time == GST_CLOCK_TIME_NONE || pad->is_skeleton) {

  1006     ret = gst_ogg_demux_chain_elem_pad (pad, packet);

  1007   }

  1008   /* we know the start_time of the pad data, see if we

  1009    * can activate the complete chain if this is a dynamic

  1010    * chain. */

  1011   if (pad->start_time != GST_CLOCK_TIME_NONE) {

  1012     GstOggChain *chain = pad->chain;

  1013 

  1014     /* correction for busted ogg, if the internal decoder outputed

  1015      * a timestamp but we did not get a granulepos, it must have

  1016      * been 0 and the time is therefore also 0 */

  1017     if (pad->first_granule == -1) {

  1018       GST_DEBUG_OBJECT (ogg, "%p found start time without granulepos", pad);

  1019       pad->first_granule = 0;

  1020       pad->first_time = 0;

  1021     }

  1022 

  1023     /* check if complete chain has start time */

  1024     if (chain == ogg->building_chain) {

  1025 

  1026       /* see if we have enough info to activate the chain, we have enough info

  1027        * when all streams have a valid start time. */

  1028       if (gst_ogg_demux_collect_chain_info (ogg, chain)) {

  1029         GstEvent *event;

  1030 

  1031         GST_DEBUG_OBJECT (ogg, "segment_start: %" GST_TIME_FORMAT,

  1032             GST_TIME_ARGS (chain->segment_start));

  1033         GST_DEBUG_OBJECT (ogg, "segment_stop:  %" GST_TIME_FORMAT,

  1034             GST_TIME_ARGS (chain->segment_stop));

  1035         GST_DEBUG_OBJECT (ogg, "segment_time:  %" GST_TIME_FORMAT,

  1036             GST_TIME_ARGS (chain->begin_time));

  1037 

  1038         /* create the newsegment event we are going to send out */

  1039         event = gst_event_new_new_segment (FALSE, ogg->segment.rate,

  1040             GST_FORMAT_TIME, chain->segment_start, chain->segment_stop,

  1041             chain->begin_time);

  1042 

  1043         gst_ogg_demux_activate_chain (ogg, chain, event);

  1044 

  1045         ogg->building_chain = NULL;

  1046       }

  1047     }

  1048   }

  1049 

  1050   /* if we are building a chain, store buffer for when we activate

  1051    * it. This path is taken if we operate in streaming mode. */

  1052   if (ogg->building_chain) {

  1053     ret = gst_ogg_demux_queue_data (pad, packet);

  1054   }

  1055   /* else we are completely streaming to the peer */

  1056   else {

  1057     ret = gst_ogg_demux_chain_peer (pad, packet);

  1058   }

  1059   return ret;

  1060 }

  1061 

  1062 /* flush at most @npackets from the stream layer. All packets if 

  1063  * @npackets is 0;

  1064  */

  1065 static GstFlowReturn

  1066 gst_ogg_pad_stream_out (GstOggPad * pad, gint npackets)

  1067 {

  1068   GstFlowReturn result = GST_FLOW_OK;

  1069   gboolean done = FALSE;

  1070   GstOggDemux *ogg;

  1071 

  1072   ogg = pad->ogg;

  1073 

  1074   while (!done) {

  1075     int ret;

  1076     ogg_packet packet;

  1077 

  1078     ret = ogg_stream_packetout (&pad->stream, &packet);

  1079     switch (ret) {

  1080       case 0:

  1081         GST_LOG_OBJECT (ogg, "packetout done");

  1082         done = TRUE;

  1083         break;

  1084       case -1:

  1085         GST_LOG_OBJECT (ogg, "packetout discont");

  1086         gst_ogg_chain_mark_discont (pad->chain);

  1087         break;

  1088       case 1:

  1089         GST_LOG_OBJECT (ogg, "packetout gave packet of size %ld", packet.bytes);

  1090         result = gst_ogg_pad_submit_packet (pad, &packet);

  1091         if (GST_FLOW_IS_FATAL (result))

  1092           goto could_not_submit;

  1093         break;

  1094       default:

  1095         GST_WARNING_OBJECT (ogg,

  1096             "invalid return value %d for ogg_stream_packetout, resetting stream",

  1097             ret);

  1098         gst_ogg_pad_reset (pad);

  1099         break;

  1100     }

  1101     if (npackets > 0) {

  1102       npackets--;

  1103       done = (npackets == 0);

  1104     }

  1105   }

  1106   return result;

  1107 

  1108   /* ERRORS */

  1109 could_not_submit:

  1110   {

  1111     GST_WARNING_OBJECT (ogg,

  1112         "could not submit packet for stream %08x, error: %d", pad->serialno,

  1113         result);

  1114     gst_ogg_pad_reset (pad);

  1115     return result;

  1116   }

  1117 }

  1118 

  1119 /* submit a page to an oggpad, this function will then submit all

  1120  * the packets in the page.

  1121  */

  1122 static GstFlowReturn

  1123 gst_ogg_pad_submit_page (GstOggPad * pad, ogg_page * page)

  1124 {

  1125   GstFlowReturn result = GST_FLOW_OK;

  1126   GstOggDemux *ogg;

  1127   gboolean continued = FALSE;

  1128 

  1129   ogg = pad->ogg;

  1130 

  1131   /* for negative rates we read pages backwards and must therefore be carefull

  1132    * with continued pages */

  1133   if (ogg->segment.rate < 0.0) {

  1134     gint npackets;