libs/gst/base/gstbaseparse.c

   1 /* GStreamer
   2  * Copyright (C) 2008 Nokia Corporation. All rights reserved.
   3  *   Contact: Stefan Kost <stefan.kost@nokia.com>
   4  * Copyright (C) 2008 Sebastian Dröge <sebastian.droege@collabora.co.uk>.
   5  * Copyright (C) 2011, Hewlett-Packard Development Company, L.P.
   6  *   Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>, Collabora Ltd.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /**
  25  * SECTION:gstbaseparse
  26  * @short_description: Base class for stream parsers
  27  * @see_also: #GstBaseTransform
  28  *
  29  * This base class is for parser elements that process data and splits it
  30  * into separate audio/video/whatever frames.
  31  *
  32  * It provides for:
  33  * <itemizedlist>
  34  *   <listitem><para>provides one sink pad and one source pad</para></listitem>
  35  *   <listitem><para>handles state changes</para></listitem>
  36  *   <listitem><para>can operate in pull mode or push mode</para></listitem>
  37  *   <listitem><para>handles seeking in both modes</para></listitem>
  38  *   <listitem><para>handles events (NEWSEGMENT/EOS/FLUSH)</para></listitem>
  39  *   <listitem><para>
  40  *        handles queries (POSITION/DURATION/SEEKING/FORMAT/CONVERT)
  41  *   </para></listitem>
  42  *   <listitem><para>handles flushing</para></listitem>
  43  * </itemizedlist>
  44  *
  45  * The purpose of this base class is to provide the basic functionality of
  46  * a parser and share a lot of rather complex code.
  47  *
  48  * Description of the parsing mechanism:
  49  * <orderedlist>
  50  * <listitem>
  51  *   <itemizedlist><title>Set-up phase</title>
  52  *   <listitem><para>
  53  *     GstBaseParse calls @start to inform subclass that data processing is
  54  *     about to start now.
  55  *   </para></listitem>
  56  *   <listitem><para>
  57  *     GstBaseParse class calls @set_sink_caps to inform the subclass about
  58  *     incoming sinkpad caps. Subclass could already set the srcpad caps
  59  *     accordingly, but this might be delayed until calling
  60  *     gst_base_parse_finish_frame() with a non-queued frame.
  61  *   </para></listitem>
  62  *   <listitem><para>
  63  *      At least at this point subclass needs to tell the GstBaseParse class
  64  *      how big data chunks it wants to receive (min_frame_size). It can do
  65  *      this with gst_base_parse_set_min_frame_size().
  66  *   </para></listitem>
  67  *   <listitem><para>
  68  *      GstBaseParse class sets up appropriate data passing mode (pull/push)
  69  *      and starts to process the data.
  70  *   </para></listitem>
  71  *   </itemizedlist>
  72  * </listitem>
  73  * <listitem>
  74  *   <itemizedlist>
  75  *   <title>Parsing phase</title>
  76  *     <listitem><para>
  77  *       GstBaseParse gathers at least min_frame_size bytes of data either
  78  *       by pulling it from upstream or collecting buffers in an internal
  79  *       #GstAdapter.
  80  *     </para></listitem>
  81  *     <listitem><para>
  82  *       A buffer of (at least) min_frame_size bytes is passed to subclass with
  83  *       @handle_frame. Subclass checks the contents and can optionally
  84  *       return GST_FLOW_OK along with an amount of data to be skipped to find
  85  *       a valid frame (which will result in a subsequent DISCONT).
  86  *       If, otherwise, the buffer does not hold a complete frame,
  87  *       @handle_frame can merely return and will be called again when additional
  88  *       data is available.  In push mode this amounts to an
  89  *       additional input buffer (thus minimal additional latency), in pull mode
  90  *       this amounts to some arbitrary reasonable buffer size increase.
  91  *       Of course, gst_base_parse_set_min_size() could also be used if a very
  92  *       specific known amount of additional data is required.
  93  *       If, however, the buffer holds a complete valid frame, it can pass
  94  *       the size of this frame to gst_base_parse_finish_frame().
  95  *       If acting as a converter, it can also merely indicate consumed input data
  96  *       while simultaneously providing custom output data.
  97  *       Note that baseclass performs some processing (such as tracking
  98  *       overall consumed data rate versus duration) for each finished frame,
  99  *       but other state is only updated upon each call to @handle_frame
 100  *       (such as tracking upstream input timestamp).
 101  *       </para><para>
 102  *       Subclass is also responsible for setting the buffer metadata
 103  *       (e.g. buffer timestamp and duration, or keyframe if applicable).
 104  *       (although the latter can also be done by GstBaseParse if it is
 105  *       appropriately configured, see below).  Frame is provided with
 106  *       timestamp derived from upstream (as much as generally possible),
 107  *       duration obtained from configuration (see below), and offset
 108  *       if meaningful (in pull mode).
 109  *       </para><para>
 110  *       Note that @check_valid_frame might receive any small
 111  *       amount of input data when leftover data is being drained (e.g. at EOS).
 112  *     </para></listitem>
 113  *     <listitem><para>
 114  *       As part of finish frame processing,
 115  *       just prior to actually pushing the buffer in question,
 116  *       it is passed to @pre_push_frame which gives subclass yet one
 117  *       last chance to examine buffer metadata, or to send some custom (tag)
 118  *       events, or to perform custom (segment) filtering.
 119  *     </para></listitem>
 120  *     <listitem><para>
 121  *       During the parsing process GstBaseParseClass will handle both srcpad
 122  *       and sinkpad events. They will be passed to subclass if @event or
 123  *       @src_event callbacks have been provided.
 124  *     </para></listitem>
 125  *   </itemizedlist>
 126  * </listitem>
 127  * <listitem>
 128  *   <itemizedlist><title>Shutdown phase</title>
 129  *   <listitem><para>
 130  *     GstBaseParse class calls @stop to inform the subclass that data
 131  *     parsing will be stopped.
 132  *   </para></listitem>
 133  *   </itemizedlist>
 134  * </listitem>
 135  * </orderedlist>
 136  *
 137  * Subclass is responsible for providing pad template caps for
 138  * source and sink pads. The pads need to be named "sink" and "src". It also
 139  * needs to set the fixed caps on srcpad, when the format is ensured (e.g.
 140  * when base class calls subclass' @set_sink_caps function).
 141  *
 142  * This base class uses #GST_FORMAT_DEFAULT as a meaning of frames. So,
 143  * subclass conversion routine needs to know that conversion from
 144  * #GST_FORMAT_TIME to #GST_FORMAT_DEFAULT must return the
 145  * frame number that can be found from the given byte position.
 146  *
 147  * GstBaseParse uses subclasses conversion methods also for seeking (or
 148  * otherwise uses its own default one, see also below).
 149  *
 150  * Subclass @start and @stop functions will be called to inform the beginning
 151  * and end of data processing.
 152  *
 153  * Things that subclass need to take care of:
 154  * <itemizedlist>
 155  *   <listitem><para>Provide pad templates</para></listitem>
 156  *   <listitem><para>
 157  *      Fixate the source pad caps when appropriate
 158  *   </para></listitem>
 159  *   <listitem><para>
 160  *      Inform base class how big data chunks should be retrieved. This is
 161  *      done with gst_base_parse_set_min_frame_size() function.
 162  *   </para></listitem>
 163  *   <listitem><para>
 164  *      Examine data chunks passed to subclass with @handle_frame and pass
 165  *      proper frame(s) to gst_base_parse_finish_frame(), and setting src pad
 166  *      caps and timestamps on frame.
 167  *   </para></listitem>
 168  *   <listitem><para>Provide conversion functions</para></listitem>
 169  *   <listitem><para>
 170  *      Update the duration information with gst_base_parse_set_duration()
 171  *   </para></listitem>
 172  *   <listitem><para>
 173  *      Optionally passthrough using gst_base_parse_set_passthrough()
 174  *   </para></listitem>
 175  *   <listitem><para>
 176  *      Configure various baseparse parameters using
 177  *      gst_base_parse_set_average_bitrate(), gst_base_parse_set_syncable()
 178  *      and gst_base_parse_set_frame_rate().
 179  *   </para></listitem>
 180  *   <listitem><para>
 181  *      In particular, if subclass is unable to determine a duration, but
 182  *      parsing (or specs) yields a frames per seconds rate, then this can be
 183  *      provided to GstBaseParse to enable it to cater for
 184  *      buffer time metadata (which will be taken from upstream as much as
 185  *      possible). Internally keeping track of frame durations and respective
 186  *      sizes that have been pushed provides GstBaseParse with an estimated
 187  *      bitrate. A default @convert (used if not overriden) will then use these
 188  *      rates to perform obvious conversions.  These rates are also used to
 189  *      update (estimated) duration at regular frame intervals.
 190  *   </para></listitem>
 191  * </itemizedlist>
 192  *
 193  */
 194
 195 /* TODO:
 196  *  - In push mode provide a queue of adapter-"queued" buffers for upstream
 197  *    buffer metadata
 198  *  - Queue buffers/events until caps are set
 199  */
 200
 201 #ifdef HAVE_CONFIG_H
 202 #  include "config.h"
 203 #endif
 204
 205 #include <stdlib.h>
 206 #include <string.h>
 207
 208 #include <gst/base/gstadapter.h>
 209
 210 #include "gstbaseparse.h"
 211
 212 /* FIXME: get rid of old GstIndex code */
 213 #include "gstindex.h"
 214 #include "gstindex.c"
 215 #include "gstmemindex.c"
 216
 217 #define GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC  (1 << 0)
 218
 219 #define MIN_FRAMES_TO_POST_BITRATE 10
 220 #define TARGET_DIFFERENCE          (20 * GST_SECOND)
 221
 222 GST_DEBUG_CATEGORY_STATIC (gst_base_parse_debug);
 223 #define GST_CAT_DEFAULT gst_base_parse_debug
 224
 225 /* Supported formats */
 226 static const GstFormat fmtlist[] = {
 227   GST_FORMAT_DEFAULT,
 228   GST_FORMAT_BYTES,
 229   GST_FORMAT_TIME,
 230   GST_FORMAT_UNDEFINED
 231 };
 232
 233 #define GST_BASE_PARSE_GET_PRIVATE(obj)  \
 234     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_PARSE, GstBaseParsePrivate))
 235
 236 struct _GstBaseParsePrivate
 237 {
 238   GstPadMode pad_mode;
 239
 240   GstAdapter *adapter;
 241
 242   gint64 duration;
 243   GstFormat duration_fmt;
 244   gint64 estimated_duration;
 245   gint64 estimated_drift;
 246
 247   guint min_frame_size;
 248   gboolean passthrough;
 249   gboolean syncable;
 250   gboolean has_timing_info;
 251   guint fps_num, fps_den;
 252   gint update_interval;
 253   guint bitrate;
 254   guint lead_in, lead_out;
 255   GstClockTime lead_in_ts, lead_out_ts;
 256   GstClockTime min_latency, max_latency;
 257
 258   gboolean discont;
 259   gboolean flushing;
 260   gboolean drain;
 261
 262   gint64 offset;
 263   gint64 sync_offset;
 264   GstClockTime next_ts;
 265   GstClockTime prev_ts;
 266   GstClockTime frame_duration;
 267   gboolean seen_keyframe;
 268   gboolean is_video;
 269   gint flushed;
 270
 271   guint64 framecount;
 272   guint64 bytecount;
 273   guint64 data_bytecount;
 274   guint64 acc_duration;
 275   GstClockTime first_frame_ts;
 276   gint64 first_frame_offset;
 277
 278   gboolean post_min_bitrate;
 279   gboolean post_avg_bitrate;
 280   gboolean post_max_bitrate;
 281   guint min_bitrate;
 282   guint avg_bitrate;
 283   guint max_bitrate;
 284   guint posted_avg_bitrate;
 285
 286   GList *pending_events;
 287
 288   /* frames/buffers that are queued and ready to go on OK */
 289   GQueue queued_frames;
 290
 291   GstBuffer *cache;
 292
 293   /* index entry storage, either ours or provided */
 294   GstIndex *index;
 295   gint index_id;
 296   gboolean own_index;
 297   GMutex index_lock;
 298
 299   /* seek table entries only maintained if upstream is BYTE seekable */
 300   gboolean upstream_seekable;
 301   gboolean upstream_has_duration;
 302   gint64 upstream_size;
 303   /* minimum distance between two index entries */
 304   GstClockTimeDiff idx_interval;
 305   /* ts and offset of last entry added */
 306   GstClockTime index_last_ts;
 307   gint64 index_last_offset;
 308   gboolean index_last_valid;
 309
 310   /* timestamps currently produced are accurate, e.g. started from 0 onwards */
 311   gboolean exact_position;
 312   /* seek events are temporarily kept to match them with newsegments */
 313   GSList *pending_seeks;
 314
 315   /* reverse playback */
 316   GSList *buffers_pending;
 317   GSList *buffers_head;
 318   GSList *buffers_queued;
 319   GSList *buffers_send;
 320   GstClockTime last_ts;
 321   gint64 last_offset;
 322
 323   /* Newsegment event to be sent after SEEK */
 324   GstEvent *pending_segment;
 325
 326   /* frame previously passed to subclass (might be re-used) */
 327   GstBaseParseFrame *prev_frame;
 328   /* offset corresponding to above frame */
 329   gint64 prev_offset;
 330   /* whether we are merely scanning for a frame */
 331   gboolean scanning;
 332   /* ... and resulting frame, if any */
 333   GstBaseParseFrame *scanned_frame;
 334
 335   /* TRUE if we're still detecting the format, i.e.
 336    * if ::detect() is still called for future buffers */
 337   gboolean detecting;
 338   GList *detect_buffers;
 339   guint detect_buffers_size;
 340 };
 341
 342 typedef struct _GstBaseParseSeek
 343 {
 344   GstSegment segment;
 345   gboolean accurate;
 346   gint64 offset;
 347   GstClockTime start_ts;
 348 } GstBaseParseSeek;
 349
 350 #define GST_BASE_PARSE_INDEX_LOCK(parse) \
 351   g_mutex_lock (&parse->priv->index_lock);
 352 #define GST_BASE_PARSE_INDEX_UNLOCK(parse) \
 353   g_mutex_unlock (&parse->priv->index_lock);
 354
 355 static GstElementClass *parent_class = NULL;
 356
 357 static void gst_base_parse_class_init (GstBaseParseClass * klass);
 358 static void gst_base_parse_init (GstBaseParse * parse,
 359     GstBaseParseClass * klass);
 360
 361 GType
 362 gst_base_parse_get_type (void)
 363 {
 364   static volatile gsize base_parse_type = 0;
 365
 366   if (g_once_init_enter (&base_parse_type)) {
 367     static const GTypeInfo base_parse_info = {
 368       sizeof (GstBaseParseClass),
 369       (GBaseInitFunc) NULL,
 370       (GBaseFinalizeFunc) NULL,
 371       (GClassInitFunc) gst_base_parse_class_init,
 372       NULL,
 373       NULL,
 374       sizeof (GstBaseParse),
 375       0,
 376       (GInstanceInitFunc) gst_base_parse_init,
 377     };
 378     GType _type;
 379
 380     _type = g_type_register_static (GST_TYPE_ELEMENT,
 381         "GstBaseParse", &base_parse_info, G_TYPE_FLAG_ABSTRACT);
 382     g_once_init_leave (&base_parse_type, _type);
 383   }
 384   return (GType) base_parse_type;
 385 }
 386
 387 static void gst_base_parse_finalize (GObject * object);
 388
 389 static GstStateChangeReturn gst_base_parse_change_state (GstElement * element,
 390     GstStateChange transition);
 391 static void gst_base_parse_reset (GstBaseParse * parse);
 392
 393 #if 0
 394 static void gst_base_parse_set_index (GstElement * element, GstIndex * index);
 395 static GstIndex *gst_base_parse_get_index (GstElement * element);
 396 #endif
 397
 398 static gboolean gst_base_parse_sink_activate (GstPad * sinkpad,
 399     GstObject * parent);
 400 static gboolean gst_base_parse_sink_activate_mode (GstPad * pad,
 401     GstObject * parent, GstPadMode mode, gboolean active);
 402 static gboolean gst_base_parse_handle_seek (GstBaseParse * parse,
 403     GstEvent * event);
 404 static void gst_base_parse_handle_tag (GstBaseParse * parse, GstEvent * event);
 405
 406 static gboolean gst_base_parse_src_event (GstPad * pad, GstObject * parent,
 407     GstEvent * event);
 408 static gboolean gst_base_parse_src_query (GstPad * pad, GstObject * parent,
 409     GstQuery * query);
 410
 411 static gboolean gst_base_parse_sink_event (GstPad * pad, GstObject * parent,
 412     GstEvent * event);
 413 static gboolean gst_base_parse_sink_query (GstPad * pad, GstObject * parent,
 414     GstQuery * query);
 415
 416 static GstFlowReturn gst_base_parse_chain (GstPad * pad, GstObject * parent,
 417     GstBuffer * buffer);
 418 static void gst_base_parse_loop (GstPad * pad);
 419
 420 static GstFlowReturn gst_base_parse_parse_frame (GstBaseParse * parse,
 421     GstBaseParseFrame * frame);
 422
 423 static gboolean gst_base_parse_sink_eventfunc (GstBaseParse * parse,
 424     GstEvent * event);
 425
 426 static gboolean gst_base_parse_src_eventfunc (GstBaseParse * parse,
 427     GstEvent * event);
 428
 429 static void gst_base_parse_drain (GstBaseParse * parse);
 430
 431 static void gst_base_parse_post_bitrates (GstBaseParse * parse,
 432     gboolean post_min, gboolean post_avg, gboolean post_max);
 433
 434 static gint64 gst_base_parse_find_offset (GstBaseParse * parse,
 435     GstClockTime time, gboolean before, GstClockTime * _ts);
 436 static GstFlowReturn gst_base_parse_locate_time (GstBaseParse * parse,
 437     GstClockTime * _time, gint64 * _offset);
 438
 439 static GstFlowReturn gst_base_parse_start_fragment (GstBaseParse * parse);
 440 static GstFlowReturn gst_base_parse_finish_fragment (GstBaseParse * parse,
 441     gboolean prev_head);
 442
 443 static inline GstFlowReturn gst_base_parse_check_sync (GstBaseParse * parse);
 444
 445 static gboolean gst_base_parse_is_seekable (GstBaseParse * parse);
 446
 447 static void
 448 gst_base_parse_clear_queues (GstBaseParse * parse)
 449 {
 450   g_slist_foreach (parse->priv->buffers_queued, (GFunc) gst_buffer_unref, NULL);
 451   g_slist_free (parse->priv->buffers_queued);
 452   parse->priv->buffers_queued = NULL;
 453   g_slist_foreach (parse->priv->buffers_pending, (GFunc) gst_buffer_unref,
 454       NULL);
 455   g_slist_free (parse->priv->buffers_pending);
 456   parse->priv->buffers_pending = NULL;
 457   g_slist_foreach (parse->priv->buffers_head, (GFunc) gst_buffer_unref, NULL);
 458   g_slist_free (parse->priv->buffers_head);
 459   parse->priv->buffers_head = NULL;
 460   g_slist_foreach (parse->priv->buffers_send, (GFunc) gst_buffer_unref, NULL);
 461   g_slist_free (parse->priv->buffers_send);
 462   parse->priv->buffers_send = NULL;
 463
 464   g_list_foreach (parse->priv->detect_buffers, (GFunc) gst_buffer_unref, NULL);
 465   g_list_free (parse->priv->detect_buffers);
 466   parse->priv->detect_buffers = NULL;
 467   parse->priv->detect_buffers_size = 0;
 468
 469   g_queue_foreach (&parse->priv->queued_frames,
 470       (GFunc) gst_base_parse_frame_free, NULL);
 471   g_queue_clear (&parse->priv->queued_frames);
 472 }
 473
 474 static void
 475 gst_base_parse_finalize (GObject * object)
 476 {
 477   GstBaseParse *parse = GST_BASE_PARSE (object);
 478   GstEvent **p_ev;
 479
 480   g_object_unref (parse->priv->adapter);
 481
 482   if (parse->priv->pending_segment) {
 483     p_ev = &parse->priv->pending_segment;
 484     gst_event_replace (p_ev, NULL);
 485   }
 486
 487   if (parse->priv->cache) {
 488     gst_buffer_unref (parse->priv->cache);
 489     parse->priv->cache = NULL;
 490   }
 491
 492   g_list_foreach (parse->priv->pending_events, (GFunc) gst_mini_object_unref,
 493       NULL);
 494   g_list_free (parse->priv->pending_events);
 495   parse->priv->pending_events = NULL;
 496
 497   if (parse->priv->index) {
 498     gst_object_unref (parse->priv->index);
 499     parse->priv->index = NULL;
 500   }
 501   g_mutex_clear (&parse->priv->index_lock);
 502
 503   gst_base_parse_clear_queues (parse);
 504
 505   G_OBJECT_CLASS (parent_class)->finalize (object);
 506 }
 507
 508 static void
 509 gst_base_parse_class_init (GstBaseParseClass * klass)
 510 {
 511   GObjectClass *gobject_class;
 512   GstElementClass *gstelement_class;
 513
 514   gobject_class = G_OBJECT_CLASS (klass);
 515   g_type_class_add_private (klass, sizeof (GstBaseParsePrivate));
 516   parent_class = g_type_class_peek_parent (klass);
 517   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_base_parse_finalize);
 518
 519   gstelement_class = (GstElementClass *) klass;
 520   gstelement_class->change_state =
 521       GST_DEBUG_FUNCPTR (gst_base_parse_change_state);
 522
 523 #if 0
 524   gstelement_class->set_index = GST_DEBUG_FUNCPTR (gst_base_parse_set_index);
 525   gstelement_class->get_index = GST_DEBUG_FUNCPTR (gst_base_parse_get_index);
 526 #endif
 527
 528   /* Default handlers */
 529   klass->src_event = gst_base_parse_src_eventfunc;
 530   klass->convert = gst_base_parse_convert_default;
 531
 532   GST_DEBUG_CATEGORY_INIT (gst_base_parse_debug, "baseparse", 0,
 533       "baseparse element");
 534 }
 535
 536 static void
 537 gst_base_parse_init (GstBaseParse * parse, GstBaseParseClass * bclass)
 538 {
 539   GstPadTemplate *pad_template;
 540
 541   GST_DEBUG_OBJECT (parse, "gst_base_parse_init");
 542
 543   parse->priv = GST_BASE_PARSE_GET_PRIVATE (parse);
 544
 545   pad_template =
 546       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "sink");
 547   g_return_if_fail (pad_template != NULL);
 548   parse->sinkpad = gst_pad_new_from_template (pad_template, "sink");
 549   gst_pad_set_event_function (parse->sinkpad,
 550       GST_DEBUG_FUNCPTR (gst_base_parse_sink_event));
 551   gst_pad_set_query_function (parse->sinkpad,
 552       GST_DEBUG_FUNCPTR (gst_base_parse_sink_query));
 553   gst_pad_set_chain_function (parse->sinkpad,
 554       GST_DEBUG_FUNCPTR (gst_base_parse_chain));
 555   gst_pad_set_activate_function (parse->sinkpad,
 556       GST_DEBUG_FUNCPTR (gst_base_parse_sink_activate));
 557   gst_pad_set_activatemode_function (parse->sinkpad,
 558       GST_DEBUG_FUNCPTR (gst_base_parse_sink_activate_mode));
 559   gst_element_add_pad (GST_ELEMENT (parse), parse->sinkpad);
 560
 561   GST_DEBUG_OBJECT (parse, "sinkpad created");
 562
 563   pad_template =
 564       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "src");
 565   g_return_if_fail (pad_template != NULL);
 566   parse->srcpad = gst_pad_new_from_template (pad_template, "src");
 567   gst_pad_set_event_function (parse->srcpad,
 568       GST_DEBUG_FUNCPTR (gst_base_parse_src_event));
 569   gst_pad_set_query_function (parse->srcpad,
 570       GST_DEBUG_FUNCPTR (gst_base_parse_src_query));
 571   gst_pad_use_fixed_caps (parse->srcpad);
 572   gst_element_add_pad (GST_ELEMENT (parse), parse->srcpad);
 573   GST_DEBUG_OBJECT (parse, "src created");
 574
 575   g_queue_init (&parse->priv->queued_frames);
 576
 577   parse->priv->adapter = gst_adapter_new ();
 578
 579   parse->priv->pad_mode = GST_PAD_MODE_NONE;
 580
 581   g_mutex_init (&parse->priv->index_lock);
 582
 583   /* init state */
 584   gst_base_parse_reset (parse);
 585   GST_DEBUG_OBJECT (parse, "init ok");
 586
 587   GST_OBJECT_FLAG_SET (parse, GST_ELEMENT_FLAG_INDEXABLE);
 588 }
 589
 590 static GstBaseParseFrame *
 591 gst_base_parse_frame_copy (GstBaseParseFrame * frame)
 592 {
 593   GstBaseParseFrame *copy;
 594
 595   copy = g_slice_dup (GstBaseParseFrame, frame);
 596   copy->buffer = gst_buffer_ref (frame->buffer);
 597   copy->_private_flags &= ~GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC;
 598
 599   GST_TRACE ("copied frame %p -> %p", frame, copy);
 600
 601   return copy;
 602 }
 603
 604 void
 605 gst_base_parse_frame_free (GstBaseParseFrame * frame)
 606 {
 607   GST_TRACE ("freeing frame %p", frame);
 608
 609   if (frame->buffer) {
 610     gst_buffer_unref (frame->buffer);
 611     frame->buffer = NULL;
 612   }
 613
 614   if (!(frame->_private_flags & GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC)) {
 615     g_slice_free (GstBaseParseFrame, frame);
 616   } else {
 617     memset (frame, 0, sizeof (*frame));
 618   }
 619 }
 620
 621 G_DEFINE_BOXED_TYPE (GstBaseParseFrame, gst_base_parse_frame,
 622     (GBoxedCopyFunc) gst_base_parse_frame_copy,
 623     (GBoxedFreeFunc) gst_base_parse_frame_free);
 624
 625 /**
 626  * gst_base_parse_frame_init:
 627  * @frame: #GstBaseParseFrame.
 628  *
 629  * Sets a #GstBaseParseFrame to initial state.  Currently this means
 630  * all public fields are zero-ed and a private flag is set to make
 631  * sure gst_base_parse_frame_free() only frees the contents but not
 632  * the actual frame. Use this function to initialise a #GstBaseParseFrame
 633  * allocated on the stack.
 634  *
 635  * Since: 0.10.33
 636  */
 637 void
 638 gst_base_parse_frame_init (GstBaseParseFrame * frame)
 639 {
 640   memset (frame, 0, sizeof (GstBaseParseFrame));
 641   frame->_private_flags = GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC;
 642   GST_TRACE ("inited frame %p", frame);
 643 }
 644
 645 /**
 646  * gst_base_parse_frame_new:
 647  * @buffer: (transfer none): a #GstBuffer
 648  * @flags: the flags
 649  * @overhead: number of bytes in this frame which should be counted as
 650  *     metadata overhead, ie. not used to calculate the average bitrate.
 651  *     Set to -1 to mark the entire frame as metadata. If in doubt, set to 0.
 652  *
 653  * Allocates a new #GstBaseParseFrame. This function is mainly for bindings,
 654  * elements written in C should usually allocate the frame on the stack and
 655  * then use gst_base_parse_frame_init() to initialise it.
 656  *
 657  * Returns: a newly-allocated #GstBaseParseFrame. Free with
 658  *     gst_base_parse_frame_free() when no longer needed, unless you gave
 659  *     away ownership to gst_base_parse_push_frame().
 660  *
 661  * Since: 0.10.33
 662  */
 663 GstBaseParseFrame *
 664 gst_base_parse_frame_new (GstBuffer * buffer, GstBaseParseFrameFlags flags,
 665     gint overhead)
 666 {
 667   GstBaseParseFrame *frame;
 668
 669   frame = g_slice_new0 (GstBaseParseFrame);
 670   frame->buffer = gst_buffer_ref (buffer);
 671
 672   GST_TRACE ("created frame %p", frame);
 673   return frame;
 674 }
 675
 676 static inline void
 677 gst_base_parse_frame_update (GstBaseParse * parse, GstBaseParseFrame * frame,
 678     GstBuffer * buf)
 679 {
 680   gst_buffer_replace (&frame->buffer, buf);
 681
 682   parse->flags = 0;
 683
 684   /* set flags one by one for clarity */
 685   if (G_UNLIKELY (parse->priv->drain))
 686     parse->flags |= GST_BASE_PARSE_FLAG_DRAINING;
 687
 688   /* losing sync is pretty much a discont (and vice versa), no ? */
 689   if (G_UNLIKELY (parse->priv->discont))
 690     parse->flags |= GST_BASE_PARSE_FLAG_LOST_SYNC;
 691 }
 692
 693 static void
 694 gst_base_parse_reset (GstBaseParse * parse)
 695 {
 696   GST_OBJECT_LOCK (parse);
 697   gst_segment_init (&parse->segment, GST_FORMAT_TIME);
 698   parse->priv->duration = -1;
 699   parse->priv->min_frame_size = 1;
 700   parse->priv->discont = TRUE;
 701   parse->priv->flushing = FALSE;
 702   parse->priv->offset = 0;
 703   parse->priv->sync_offset = 0;
 704   parse->priv->update_interval = -1;
 705   parse->priv->fps_num = parse->priv->fps_den = 0;
 706   parse->priv->frame_duration = GST_CLOCK_TIME_NONE;
 707   parse->priv->lead_in = parse->priv->lead_out = 0;
 708   parse->priv->lead_in_ts = parse->priv->lead_out_ts = 0;
 709   parse->priv->bitrate = 0;
 710   parse->priv->framecount = 0;
 711   parse->priv->bytecount = 0;
 712   parse->priv->acc_duration = 0;
 713   parse->priv->first_frame_ts = GST_CLOCK_TIME_NONE;
 714   parse->priv->first_frame_offset = -1;
 715   parse->priv->estimated_duration = -1;
 716   parse->priv->estimated_drift = 0;
 717   parse->priv->next_ts = 0;
 718   parse->priv->syncable = TRUE;
 719   parse->priv->passthrough = FALSE;
 720   parse->priv->has_timing_info = FALSE;
 721   parse->priv->post_min_bitrate = TRUE;
 722   parse->priv->post_avg_bitrate = TRUE;
 723   parse->priv->post_max_bitrate = TRUE;
 724   parse->priv->min_bitrate = G_MAXUINT;
 725   parse->priv->max_bitrate = 0;
 726   parse->priv->avg_bitrate = 0;
 727   parse->priv->posted_avg_bitrate = 0;
 728
 729   parse->priv->index_last_ts = GST_CLOCK_TIME_NONE;
 730   parse->priv->index_last_offset = -1;
 731   parse->priv->index_last_valid = TRUE;
 732   parse->priv->upstream_seekable = FALSE;
 733   parse->priv->upstream_size = 0;
 734   parse->priv->upstream_has_duration = FALSE;
 735   parse->priv->idx_interval = 0;
 736   parse->priv->exact_position = TRUE;
 737   parse->priv->seen_keyframe = FALSE;
 738
 739   parse->priv->last_ts = GST_CLOCK_TIME_NONE;
 740   parse->priv->last_offset = 0;
 741
 742   if (parse->priv->pending_segment) {
 743     gst_event_unref (parse->priv->pending_segment);
 744     parse->priv->pending_segment = NULL;
 745   }
 746
 747   g_list_foreach (parse->priv->pending_events, (GFunc) gst_mini_object_unref,
 748       NULL);
 749   g_list_free (parse->priv->pending_events);
 750   parse->priv->pending_events = NULL;
 751
 752   if (parse->priv->cache) {
 753     gst_buffer_unref (parse->priv->cache);
 754     parse->priv->cache = NULL;
 755   }
 756
 757   g_slist_foreach (parse->priv->pending_seeks, (GFunc) g_free, NULL);
 758   g_slist_free (parse->priv->pending_seeks);
 759   parse->priv->pending_seeks = NULL;
 760
 761   if (parse->priv->adapter)
 762     gst_adapter_clear (parse->priv->adapter);
 763
 764   /* we know it is not alloc'ed, but maybe other stuff to free, some day ... */
 765   if (parse->priv->prev_frame) {
 766     gst_base_parse_frame_free (parse->priv->prev_frame);
 767     parse->priv->prev_frame = NULL;
 768   }
 769
 770   g_list_foreach (parse->priv->detect_buffers, (GFunc) gst_buffer_unref, NULL);
 771   g_list_free (parse->priv->detect_buffers);
 772   parse->priv->detect_buffers = NULL;
 773   parse->priv->detect_buffers_size = 0;
 774   GST_OBJECT_UNLOCK (parse);
 775 }
 776
 777 /* gst_base_parse_parse_frame:
 778  * @parse: #GstBaseParse.
 779  * @buffer: #GstBuffer.
 780  *
 781  * Default callback for parse_frame.
 782  */
 783 static GstFlowReturn
 784 gst_base_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
 785 {
 786   GstBuffer *buffer = frame->buffer;
 787
 788   if (!GST_BUFFER_TIMESTAMP_IS_VALID (buffer) &&
 789       GST_CLOCK_TIME_IS_VALID (parse->priv->next_ts)) {
 790     GST_BUFFER_TIMESTAMP (buffer) = parse->priv->next_ts;
 791   }
 792   if (!GST_BUFFER_DURATION_IS_VALID (buffer) &&
 793       GST_CLOCK_TIME_IS_VALID (parse->priv->frame_duration)) {
 794     GST_BUFFER_DURATION (buffer) = parse->priv->frame_duration;
 795   }
 796   return GST_FLOW_OK;
 797 }
 798
 799 /* gst_base_parse_convert:
 800  * @parse: #GstBaseParse.
 801  * @src_format: #GstFormat describing the source format.
 802  * @src_value: Source value to be converted.
 803  * @dest_format: #GstFormat defining the converted format.
 804  * @dest_value: Pointer where the conversion result will be put.
 805  *
 806  * Converts using configured "convert" vmethod in #GstBaseParse class.
 807  *
 808  * Returns: TRUE if conversion was successful.
 809  */
 810 static gboolean
 811 gst_base_parse_convert (GstBaseParse * parse,
 812     GstFormat src_format,
 813     gint64 src_value, GstFormat dest_format, gint64 * dest_value)
 814 {
 815   GstBaseParseClass *klass = GST_BASE_PARSE_GET_CLASS (parse);
 816   gboolean ret;
 817
 818   g_return_val_if_fail (dest_value != NULL, FALSE);
 819
 820   if (!klass->convert)
 821     return FALSE;
 822
 823   ret = klass->convert (parse, src_format, src_value, dest_format, dest_value);
 824
 825 #ifndef GST_DISABLE_GST_DEBUG
 826   {
 827     if (ret) {
 828       if (src_format == GST_FORMAT_TIME && dest_format == GST_FORMAT_BYTES) {
 829         GST_LOG_OBJECT (parse,
 830             "TIME -> BYTES: %" GST_TIME_FORMAT " -> %" G_GINT64_FORMAT,
 831             GST_TIME_ARGS (src_value), *dest_value);
 832       } else if (dest_format == GST_FORMAT_TIME &&
 833           src_format == GST_FORMAT_BYTES) {
 834         GST_LOG_OBJECT (parse,
 835             "BYTES -> TIME: %" G_GINT64_FORMAT " -> %" GST_TIME_FORMAT,
 836             src_value, GST_TIME_ARGS (*dest_value));
 837       } else {
 838         GST_LOG_OBJECT (parse,
 839             "%s -> %s: %" G_GINT64_FORMAT " -> %" G_GINT64_FORMAT,
 840             GST_STR_NULL (gst_format_get_name (src_format)),
 841             GST_STR_NULL (gst_format_get_name (dest_format)),
 842             src_value, *dest_value);
 843       }
 844     } else {
 845       GST_DEBUG_OBJECT (parse, "conversion failed");
 846     }
 847   }
 848 #endif
 849
 850   return ret;
 851 }
 852
 853 /* gst_base_parse_sink_event:
 854  * @pad: #GstPad that received the event.
 855  * @event: #GstEvent to be handled.
 856  *
 857  * Handler for sink pad events.
 858  *
 859  * Returns: TRUE if the event was handled.
 860  */
 861 static gboolean
 862 gst_base_parse_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
 863 {
 864   GstBaseParse *parse;
 865   GstBaseParseClass *bclass;
 866   gboolean handled = FALSE;
 867   gboolean ret = TRUE;
 868
 869   parse = GST_BASE_PARSE (parent);
 870   bclass = GST_BASE_PARSE_GET_CLASS (parse);
 871
 872   GST_DEBUG_OBJECT (parse, "handling event %d, %s", GST_EVENT_TYPE (event),
 873       GST_EVENT_TYPE_NAME (event));
 874
 875   /* Cache all events except EOS, SEGMENT and FLUSH_STOP if we have a
 876    * pending segment */
 877   if (parse->priv->pending_segment && GST_EVENT_TYPE (event) != GST_EVENT_EOS
 878       && GST_EVENT_TYPE (event) != GST_EVENT_SEGMENT
 879       && GST_EVENT_TYPE (event) != GST_EVENT_FLUSH_START
 880       && GST_EVENT_TYPE (event) != GST_EVENT_FLUSH_STOP
 881       && GST_EVENT_TYPE (event) != GST_EVENT_CAPS) {
 882
 883     if (GST_EVENT_TYPE (event) == GST_EVENT_TAG)
 884       /* See if any bitrate tags were posted */
 885       gst_base_parse_handle_tag (parse, event);
 886
 887     parse->priv->pending_events =
 888         g_list_append (parse->priv->pending_events, event);
 889     ret = TRUE;
 890   } else {
 891
 892     if (GST_EVENT_TYPE (event) == GST_EVENT_EOS &&
 893         parse->priv->framecount < MIN_FRAMES_TO_POST_BITRATE)
 894       /* We've not posted bitrate tags yet - do so now */
 895       gst_base_parse_post_bitrates (parse, TRUE, TRUE, TRUE);
 896
 897     if (bclass->event)
 898       handled = bclass->event (parse, event);
 899
 900     if (!handled)
 901       handled = gst_base_parse_sink_eventfunc (parse, event);
 902
 903     if (!handled)
 904       ret = gst_pad_event_default (pad, parent, event);
 905   }
 906
 907   GST_DEBUG_OBJECT (parse, "event handled");
 908
 909   return ret;
 910 }
 911
 912
 913 /* gst_base_parse_sink_eventfunc:
 914  * @parse: #GstBaseParse.
 915  * @event: #GstEvent to be handled.
 916  *
 917  * Element-level event handler function.
 918  *
 919  * The event will be unreffed only if it has been handled and this
 920  * function returns %TRUE
 921  *
 922  * Returns: %TRUE if the event was handled and not need forwarding.
 923  */
 924 static gboolean
 925 gst_base_parse_sink_eventfunc (GstBaseParse * parse, GstEvent * event)
 926 {
 927   gboolean handled = FALSE;
 928   GstEvent **eventp;
 929
 930   switch (GST_EVENT_TYPE (event)) {
 931     case GST_EVENT_CAPS:
 932     {
 933       GstCaps *caps;
 934       GstBaseParseClass *klass;
 935
 936       klass = GST_BASE_PARSE_GET_CLASS (parse);
 937
 938       gst_event_parse_caps (event, &caps);
 939       GST_DEBUG_OBJECT (parse, "caps: %" GST_PTR_FORMAT, caps);
 940
 941       if (klass->set_sink_caps)
 942         klass->set_sink_caps (parse, caps);
 943
 944       /* will send our own caps downstream */
 945       gst_event_unref (event);
 946       handled = TRUE;
 947       break;
 948     }
 949     case GST_EVENT_SEGMENT:
 950     {
 951       const GstSegment *in_segment;
 952       GstSegment out_segment;
 953       gint64 offset = 0, next_ts;
 954
 955 #if 0
 956       gdouble rate, applied_rate;
 957       GstFormat format;
 958       gint64 start, stop, pos, next_ts;
 959       gboolean update;
 960 #endif
 961
 962       gst_event_parse_segment (event, &in_segment);
 963       gst_segment_init (&out_segment, GST_FORMAT_TIME);
 964
 965       GST_DEBUG_OBJECT (parse, "segment %" GST_SEGMENT_FORMAT, in_segment);
 966
 967       if (in_segment->format == GST_FORMAT_BYTES) {
 968         GstBaseParseSeek *seek = NULL;
 969         GSList *node;
 970
 971         /* stop time is allowed to be open-ended, but not start & pos */
 972         offset = in_segment->time;
 973
 974         GST_OBJECT_LOCK (parse);
 975         for (node = parse->priv->pending_seeks; node; node = node->next) {
 976           GstBaseParseSeek *tmp = node->data;
 977
 978           if (tmp->offset == offset) {
 979             seek = tmp;
 980             break;
 981           }
 982         }
 983         parse->priv->pending_seeks =
 984             g_slist_remove (parse->priv->pending_seeks, seek);
 985         GST_OBJECT_UNLOCK (parse);
 986
 987         if (seek) {
 988           GST_DEBUG_OBJECT (parse,
 989               "Matched newsegment to%s seek: %" GST_SEGMENT_FORMAT,
 990               seek->accurate ? " accurate" : "", &seek->segment);
 991
 992           out_segment.start = seek->segment.start;
 993           out_segment.stop = seek->segment.stop;
 994           out_segment.time = seek->segment.start;
 995
 996           next_ts = seek->start_ts;
 997           parse->priv->exact_position = seek->accurate;
 998           g_free (seek);
 999         } else {
1000           /* best attempt convert */
1001           /* as these are only estimates, stop is kept open-ended to avoid
1002            * premature cutting */
1003           gst_base_parse_convert (parse, GST_FORMAT_BYTES, in_segment->start,
1004               GST_FORMAT_TIME, (gint64 *) & next_ts);
1005
1006           out_segment.start = next_ts;
1007           out_segment.stop = GST_CLOCK_TIME_NONE;
1008           out_segment.time = next_ts;
1009
1010           parse->priv->exact_position = (in_segment->start == 0);
1011         }
1012
1013         gst_event_unref (event);
1014
1015         event = gst_event_new_segment (&out_segment);
1016
1017         GST_DEBUG_OBJECT (parse, "Converted incoming segment to TIME. %"
1018             GST_SEGMENT_FORMAT, in_segment);
1019
1020       } else if (in_segment->format != GST_FORMAT_TIME) {
1021         /* Unknown incoming segment format. Output a default open-ended
1022          * TIME segment */
1023         gst_event_unref (event);
1024
1025         out_segment.start = 0;
1026         out_segment.stop = GST_CLOCK_TIME_NONE;
1027         out_segment.time = 0;
1028
1029         event = gst_event_new_segment (&out_segment);
1030
1031         next_ts = 0;
1032       } else {
1033         /* not considered BYTE seekable if it is talking to us in TIME,
1034          * whatever else it might claim */
1035         parse->priv->upstream_seekable = FALSE;
1036         next_ts = in_segment->start;
1037       }
1038
1039       memcpy (&parse->segment, &out_segment, sizeof (GstSegment));
1040
1041       /*
1042          gst_segment_set_newsegment (&parse->segment, update, rate,
1043          applied_rate, format, start, stop, start);
1044        */
1045
1046       /* save the segment for later, right before we push a new buffer so that
1047        * the caps are fixed and the next linked element can receive
1048        * the segment. */
1049       eventp = &parse->priv->pending_segment;
1050       gst_event_replace (eventp, event);
1051       gst_event_unref (event);
1052       handled = TRUE;
1053
1054       /* but finish the current segment */
1055       GST_DEBUG_OBJECT (parse, "draining current segment");
1056       if (in_segment->rate > 0.0)
1057         gst_base_parse_drain (parse);
1058       else
1059         gst_base_parse_finish_fragment (parse, FALSE);
1060       gst_adapter_clear (parse->priv->adapter);
1061
1062       parse->priv->offset = offset;
1063       parse->priv->sync_offset = offset;
1064       parse->priv->next_ts = next_ts;
1065       parse->priv->last_ts = GST_CLOCK_TIME_NONE;
1066       parse->priv->discont = TRUE;
1067       parse->priv->seen_keyframe = FALSE;
1068       break;
1069     }
1070
1071     case GST_EVENT_FLUSH_START:
1072       parse->priv->flushing = TRUE;
1073       handled = gst_pad_push_event (parse->srcpad, gst_event_ref (event));
1074       if (handled)
1075         gst_event_unref (event);
1076       /* Wait for _chain() to exit by taking the srcpad STREAM_LOCK */
1077       GST_PAD_STREAM_LOCK (parse->srcpad);
1078       GST_PAD_STREAM_UNLOCK (parse->srcpad);
1079
1080       break;
1081
1082     case GST_EVENT_FLUSH_STOP:
1083       gst_adapter_clear (parse->priv->adapter);
1084       gst_base_parse_clear_queues (parse);
1085       parse->priv->flushing = FALSE;
1086       parse->priv->discont = TRUE;
1087       parse->priv->last_ts = GST_CLOCK_TIME_NONE;
1088       if (parse->priv->prev_frame) {
1089         gst_base_parse_frame_free (parse->priv->prev_frame);
1090         parse->priv->prev_frame = NULL;
1091       }
1092       break;
1093
1094     case GST_EVENT_EOS:
1095       if (parse->segment.rate > 0.0)
1096         gst_base_parse_drain (parse);
1097       else
1098         gst_base_parse_finish_fragment (parse, TRUE);
1099
1100       /* If we STILL have zero frames processed, fire an error */
1101       if (parse->priv->framecount == 0) {
1102         GST_ELEMENT_ERROR (parse, STREAM, WRONG_TYPE,
1103             ("No valid frames found before end of stream"), (NULL));
1104       }
1105       /* newsegment before eos */
1106       if (parse->priv->pending_segment) {
1107         gst_pad_push_event (parse->srcpad, parse->priv->pending_segment);
1108         parse->priv->pending_segment = NULL;
1109       }
1110       break;
1111
1112     default:
1113       break;
1114   }
1115
1116   return handled;
1117 }
1118
1119 static gboolean
1120 gst_base_parse_sink_query (GstPad * pad, GstObject * parent, GstQuery * query)
1121 {
1122   GstBaseParse *parse;
1123   GstBaseParseClass *bclass;
1124   gboolean res;
1125
1126   parse = GST_BASE_PARSE (parent);
1127   bclass = GST_BASE_PARSE_GET_CLASS (parse);
1128
1129   switch (GST_QUERY_TYPE (query)) {
1130     case GST_QUERY_CAPS:
1131     {
1132       if (bclass->get_sink_caps) {
1133         GstCaps *caps, *filter;
1134
1135         gst_query_parse_caps (query, &filter);
1136         caps = bclass->get_sink_caps (parse, filter);
1137         GST_LOG_OBJECT (parse, "sink getcaps returning caps %" GST_PTR_FORMAT,
1138             caps);
1139         gst_query_set_caps_result (query, caps);
1140         gst_caps_unref (caps);
1141
1142         res = TRUE;
1143       } else {
1144         GstCaps *caps, *template_caps, *filter;
1145
1146         gst_query_parse_caps (query, &filter);
1147         template_caps = gst_pad_get_pad_template_caps (pad);
1148         if (filter != NULL) {
1149           caps =
1150               gst_caps_intersect_full (filter, template_caps,
1151               GST_CAPS_INTERSECT_FIRST);
1152           gst_caps_unref (template_caps);
1153         } else {
1154           caps = template_caps;
1155         }
1156         gst_query_set_caps_result (query, caps);
1157         gst_caps_unref (caps);
1158
1159         res = TRUE;
1160       }
1161       break;
1162     }
1163     default:
1164     {
1165       res = gst_pad_query_default (pad, parent, query);
1166       break;
1167     }
1168   }
1169
1170   return res;
1171 }
1172
1173
1174 /* gst_base_parse_src_event:
1175  * @pad: #GstPad that received the event.
1176  * @event: #GstEvent that was received.
1177  *
1178  * Handler for source pad events.
1179  *
1180  * Returns: TRUE if the event was handled.
1181  */
1182 static gboolean
1183 gst_base_parse_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
1184 {
1185   GstBaseParse *parse;
1186   GstBaseParseClass *bclass;
1187   gboolean handled = FALSE;
1188   gboolean ret = TRUE;
1189
1190   parse = GST_BASE_PARSE (parent);
1191   bclass = GST_BASE_PARSE_GET_CLASS (parse);
1192
1193   GST_DEBUG_OBJECT (parse, "event %d, %s", GST_EVENT_TYPE (event),
1194       GST_EVENT_TYPE_NAME (event));
1195
1196   if (bclass->src_event)
1197     handled = bclass->src_event (parse, event);
1198
1199   if (!handled)
1200     ret = gst_pad_event_default (pad, parent, event);
1201
1202   return ret;
1203 }
1204
1205 static gboolean
1206 gst_base_parse_is_seekable (GstBaseParse * parse)
1207 {
1208   /* FIXME: could do more here, e.g. check index or just send data from 0
1209    * in pull mode and let decoder/sink clip */
1210   return parse->priv->syncable;
1211 }
1212
1213 /* gst_base_parse_src_eventfunc:
1214  * @parse: #GstBaseParse.
1215  * @event: #GstEvent that was received.
1216  *
1217  * Default srcpad event handler.
1218  *
1219  * Returns: TRUE if the event was handled and can be dropped.
1220  */
1221 static gboolean
1222 gst_base_parse_src_eventfunc (GstBaseParse * parse, GstEvent * event)
1223 {
1224   gboolean handled = FALSE;
1225
1226   switch (GST_EVENT_TYPE (event)) {
1227     case GST_EVENT_SEEK:
1228     {
1229       if (gst_base_parse_is_seekable (parse)) {
1230         handled = gst_base_parse_handle_seek (parse, event);
1231       }
1232       break;
1233     }
1234     default:
1235       break;
1236   }
1237   return handled;
1238 }
1239
1240
1241 /**
1242  * gst_base_parse_convert_default:
1243  * @parse: #GstBaseParse.
1244  * @src_format: #GstFormat describing the source format.
1245  * @src_value: Source value to be converted.
1246  * @dest_format: #GstFormat defining the converted format.
1247  * @dest_value: Pointer where the conversion result will be put.
1248  *
1249  * Default implementation of "convert" vmethod in #GstBaseParse class.
1250  *
1251  * Returns: TRUE if conversion was successful.
1252  *
1253  * Since: 0.10.33
1254  */
1255 gboolean
1256 gst_base_parse_convert_default (GstBaseParse * parse,
1257     GstFormat src_format,
1258     gint64 src_value, GstFormat dest_format, gint64 * dest_value)
1259 {
1260   gboolean ret = FALSE;
1261   guint64 bytes, duration;
1262
1263   if (G_UNLIKELY (src_format == dest_format)) {
1264     *dest_value = src_value;
1265     return TRUE;
1266   }
1267
1268   if (G_UNLIKELY (src_value == -1)) {
1269     *dest_value = -1;
1270     return TRUE;
1271   }
1272
1273   if (G_UNLIKELY (src_value == 0)) {
1274     *dest_value = 0;
1275     return TRUE;
1276   }
1277
1278   /* need at least some frames */
1279   if (!parse->priv->framecount)
1280     return FALSE;
1281
1282   duration = parse->priv->acc_duration / GST_MSECOND;
1283   bytes = parse->priv->bytecount;
1284
1285   if (G_UNLIKELY (!duration || !bytes))
1286     return FALSE;
1287
1288   if (src_format == GST_FORMAT_BYTES) {
1289     if (dest_format == GST_FORMAT_TIME) {
1290       /* BYTES -> TIME conversion */
1291       GST_DEBUG_OBJECT (parse, "converting bytes -> time");
1292       *dest_value = gst_util_uint64_scale (src_value, duration, bytes);
1293       *dest_value *= GST_MSECOND;
1294       GST_DEBUG_OBJECT (parse, "conversion result: %" G_GINT64_FORMAT " ms",
1295           *dest_value / GST_MSECOND);
1296       ret = TRUE;
1297     }
1298   } else if (src_format == GST_FORMAT_TIME) {
1299     if (dest_format == GST_FORMAT_BYTES) {
1300       GST_DEBUG_OBJECT (parse, "converting time -> bytes");
1301       *dest_value = gst_util_uint64_scale (src_value / GST_MSECOND, bytes,
1302           duration);
1303       GST_DEBUG_OBJECT (parse,
1304           "time %" G_GINT64_FORMAT " ms in bytes = %" G_GINT64_FORMAT,
1305           src_value / GST_MSECOND, *dest_value);
1306       ret = TRUE;
1307     }
1308   } else if (src_format == GST_FORMAT_DEFAULT) {
1309     /* DEFAULT == frame-based */
1310     if (dest_format == GST_FORMAT_TIME) {
1311       if (parse->priv->fps_den) {
1312         *dest_value = gst_util_uint64_scale (src_value,
1313             GST_SECOND * parse->priv->fps_den, parse->priv->fps_num);
1314         ret = TRUE;
1315       }
1316     } else if (dest_format == GST_FORMAT_BYTES) {
1317     }
1318   }
1319
1320   return ret;
1321 }
1322
1323 static void
1324 gst_base_parse_update_duration (GstBaseParse * baseparse)
1325 {
1326   GstPad *peer;
1327   GstBaseParse *parse;
1328
1329   parse = GST_BASE_PARSE (baseparse);
1330
1331   peer = gst_pad_get_peer (parse->sinkpad);
1332   if (peer) {
1333     gboolean qres = FALSE;
1334     gint64 ptot, dest_value;
1335
1336     qres = gst_pad_query_duration (peer, GST_FORMAT_BYTES, &ptot);
1337     gst_object_unref (GST_OBJECT (peer));
1338     if (qres) {
1339       if (gst_base_parse_convert (parse, GST_FORMAT_BYTES, ptot,
1340               GST_FORMAT_TIME, &dest_value)) {
1341
1342         /* inform if duration changed, but try to avoid spamming */
1343         parse->priv->estimated_drift +=
1344             dest_value - parse->priv->estimated_duration;
1345         if (parse->priv->estimated_drift > GST_SECOND ||
1346             parse->priv->estimated_drift < -GST_SECOND) {
1347           gst_element_post_message (GST_ELEMENT (parse),
1348               gst_message_new_duration (GST_OBJECT (parse),
1349                   GST_FORMAT_TIME, dest_value));
1350           parse->priv->estimated_drift = 0;
1351         }
1352         parse->priv->estimated_duration = dest_value;
1353         GST_LOG_OBJECT (parse,
1354             "updated estimated duration to %" GST_TIME_FORMAT,
1355             GST_TIME_ARGS (dest_value));
1356       }
1357     }
1358   }
1359 }
1360
1361 static void
1362 gst_base_parse_post_bitrates (GstBaseParse * parse, gboolean post_min,
1363     gboolean post_avg, gboolean post_max)
1364 {
1365   GstTagList *taglist = NULL;
1366
1367   if (post_min && parse->priv->post_min_bitrate) {
1368     taglist = gst_tag_list_new_empty ();
1369
1370     gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE,
1371         GST_TAG_MINIMUM_BITRATE, parse->priv->min_bitrate, NULL);
1372   }
1373
1374   if (post_avg && parse->priv->post_avg_bitrate) {
1375     if (taglist == NULL)
1376       taglist = gst_tag_list_new_empty ();
1377
1378     parse->priv->posted_avg_bitrate = parse->priv->avg_bitrate;
1379     gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_BITRATE,
1380         parse->priv->avg_bitrate, NULL);
1381   }
1382
1383   if (post_max && parse->priv->post_max_bitrate) {
1384     if (taglist == NULL)
1385       taglist = gst_tag_list_new_empty ();
1386
1387     gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE,
1388         GST_TAG_MAXIMUM_BITRATE, parse->priv->max_bitrate, NULL);
1389   }
1390
1391   GST_DEBUG_OBJECT (parse, "Updated bitrates. Min: %u, Avg: %u, Max: %u",
1392       parse->priv->min_bitrate, parse->priv->avg_bitrate,
1393       parse->priv->max_bitrate);
1394
1395   if (taglist != NULL) {
1396     gst_pad_push_event (parse->srcpad, gst_event_new_tag (taglist));
1397   }
1398 }
1399
1400 /* gst_base_parse_update_bitrates:
1401  * @parse: #GstBaseParse.
1402  * @buffer: Current frame as a #GstBuffer
1403  *
1404  * Keeps track of the minimum and maximum bitrates, and also maintains a
1405  * running average bitrate of the stream so far.
1406  */
1407 static void
1408 gst_base_parse_update_bitrates (GstBaseParse * parse, GstBaseParseFrame * frame)
1409 {
1410   /* Only update the tag on a 10 kbps delta */
1411   static const gint update_threshold = 10000;
1412
1413   guint64 data_len, frame_dur;
1414   gint overhead, frame_bitrate, old_avg_bitrate;
1415   gboolean update_min = FALSE, update_avg = FALSE, update_max = FALSE;
1416   GstBuffer *buffer = frame->buffer;
1417
1418   overhead = frame->overhead;
1419   if (overhead == -1)
1420     return;
1421
1422   data_len = gst_buffer_get_size (buffer) - overhead;
1423   parse->priv->data_bytecount += data_len;
1424
1425   /* duration should be valid by now,
1426    * either set by subclass or maybe based on fps settings */
1427   if (GST_BUFFER_DURATION_IS_VALID (buffer) && parse->priv->acc_duration != 0) {
1428     /* Calculate duration of a frame from buffer properties */
1429     frame_dur = GST_BUFFER_DURATION (buffer);
1430     parse->priv->avg_bitrate = (8 * parse->priv->data_bytecount * GST_SECOND) /
1431         parse->priv->acc_duration;
1432
1433   } else {
1434     /* No way to figure out frame duration (is this even possible?) */
1435     return;
1436   }
1437
1438   /* override if subclass provided bitrate, e.g. metadata based */
1439   if (parse->priv->bitrate) {
1440     parse->priv->avg_bitrate = parse->priv->bitrate;
1441     /* spread this (confirmed) info ASAP */
1442     if (parse->priv->posted_avg_bitrate != parse->priv->avg_bitrate)
1443       gst_base_parse_post_bitrates (parse, FALSE, TRUE, FALSE);
1444   }
1445
1446   if (frame_dur)
1447     frame_bitrate = (8 * data_len * GST_SECOND) / frame_dur;
1448   else
1449     return;
1450
1451   GST_LOG_OBJECT (parse, "frame bitrate %u, avg bitrate %u", frame_bitrate,
1452       parse->priv->avg_bitrate);
1453
1454   if (parse->priv->framecount < MIN_FRAMES_TO_POST_BITRATE) {
1455     goto exit;
1456   } else if (parse->priv->framecount == MIN_FRAMES_TO_POST_BITRATE) {
1457     /* always post all at threshold time */
1458     update_min = update_max = update_avg = TRUE;
1459   }
1460
1461   if (G_LIKELY (parse->priv->framecount >= MIN_FRAMES_TO_POST_BITRATE)) {
1462     if (frame_bitrate < parse->priv->min_bitrate) {
1463       parse->priv->min_bitrate = frame_bitrate;
1464       update_min = TRUE;
1465     }
1466
1467     if (frame_bitrate > parse->priv->max_bitrate) {
1468       parse->priv->max_bitrate = frame_bitrate;
1469       update_max = TRUE;
1470     }
1471
1472     old_avg_bitrate = parse->priv->posted_avg_bitrate;
1473     if ((gint) (old_avg_bitrate - parse->priv->avg_bitrate) > update_threshold
1474         || (gint) (parse->priv->avg_bitrate - old_avg_bitrate) >
1475         update_threshold)
1476       update_avg = TRUE;
1477   }
1478
1479   if ((update_min || update_avg || update_max))
1480     gst_base_parse_post_bitrates (parse, update_min, update_avg, update_max);
1481
1482 exit:
1483   return;
1484 }
1485
1486 /**
1487  * gst_base_parse_add_index_entry:
1488  * @parse: #GstBaseParse.
1489  * @offset: offset of entry
1490  * @ts: timestamp associated with offset
1491  * @key: whether entry refers to keyframe
1492  * @force: add entry disregarding sanity checks
1493  *
1494  * Adds an entry to the index associating @offset to @ts.  It is recommended
1495  * to only add keyframe entries.  @force allows to bypass checks, such as
1496  * whether the stream is (upstream) seekable, another entry is already "close"
1497  * to the new entry, etc.
1498  *
1499  * Returns: #gboolean indicating whether entry was added
1500  *
1501  * Since: 0.10.33
1502  */
1503 gboolean
1504 gst_base_parse_add_index_entry (GstBaseParse * parse, guint64 offset,
1505     GstClockTime ts, gboolean key, gboolean force)
1506 {
1507   gboolean ret = FALSE;
1508   GstIndexAssociation associations[2];
1509
1510   GST_LOG_OBJECT (parse, "Adding key=%d index entry %" GST_TIME_FORMAT
1511       " @ offset 0x%08" G_GINT64_MODIFIER "x", key, GST_TIME_ARGS (ts), offset);
1512
1513   if (G_LIKELY (!force)) {
1514
1515     if (!parse->priv->upstream_seekable) {
1516       GST_DEBUG_OBJECT (parse, "upstream not seekable; discarding");
1517       goto exit;
1518     }
1519
1520     /* FIXME need better helper data structure that handles these issues
1521      * related to ongoing collecting of index entries */
1522     if (parse->priv->index_last_offset >= (gint64) offset) {
1523       GST_DEBUG_OBJECT (parse, "already have entries up to offset "
1524           "0x%08" G_GINT64_MODIFIER "x", parse->priv->index_last_offset);
1525       goto exit;
1526     }
1527
1528     if (GST_CLOCK_TIME_IS_VALID (parse->priv->index_last_ts) &&
1529         GST_CLOCK_DIFF (parse->priv->index_last_ts, ts) <
1530         parse->priv->idx_interval) {
1531       GST_DEBUG_OBJECT (parse, "entry too close to last time %" GST_TIME_FORMAT,
1532           GST_TIME_ARGS (parse->priv->index_last_ts));
1533       goto exit;
1534     }
1535
1536     /* if last is not really the last one */
1537     if (!parse->priv->index_last_valid) {
1538       GstClockTime prev_ts;
1539
1540       gst_base_parse_find_offset (parse, ts, TRUE, &prev_ts);
1541       if (GST_CLOCK_DIFF (prev_ts, ts) < parse->priv->idx_interval) {
1542         GST_DEBUG_OBJECT (parse,
1543             "entry too close to existing entry %" GST_TIME_FORMAT,
1544             GST_TIME_ARGS (prev_ts));
1545         parse->priv->index_last_offset = offset;
1546         parse->priv->index_last_ts = ts;
1547         goto exit;
1548       }
1549     }
1550   }
1551
1552   associations[0].format = GST_FORMAT_TIME;
1553   associations[0].value = ts;
1554   associations[1].format = GST_FORMAT_BYTES;
1555   associations[1].value = offset;
1556
1557   /* index might change on-the-fly, although that would be nutty app ... */
1558   GST_BASE_PARSE_INDEX_LOCK (parse);
1559   gst_index_add_associationv (parse->priv->index, parse->priv->index_id,
1560       (key) ? GST_INDEX_ASSOCIATION_FLAG_KEY_UNIT :
1561       GST_INDEX_ASSOCIATION_FLAG_DELTA_UNIT, 2,
1562       (const GstIndexAssociation *) &associations);
1563   GST_BASE_PARSE_INDEX_UNLOCK (parse);
1564
1565   if (key) {
1566     parse->priv->index_last_offset = offset;
1567     parse->priv->index_last_ts = ts;
1568   }
1569
1570   ret = TRUE;
1571
1572 exit:
1573   return ret;
1574 }
1575
1576 /* check for seekable upstream, above and beyond a mere query */
1577 static void
1578 gst_base_parse_check_seekability (GstBaseParse * parse)
1579 {
1580   GstQuery *query;
1581   gboolean seekable = FALSE;
1582   gint64 start = -1, stop = -1;
1583   guint idx_interval = 0;
1584
1585   query = gst_query_new_seeking (GST_FORMAT_BYTES);
1586   if (!gst_pad_peer_query (parse->sinkpad, query)) {
1587     GST_DEBUG_OBJECT (parse, "seeking query failed");
1588     goto done;
1589   }
1590
1591   gst_query_parse_seeking (query, NULL, &seekable, &start, &stop);
1592
1593   /* try harder to query upstream size if we didn't get it the first time */
1594   if (seekable && stop == -1) {
1595     GST_DEBUG_OBJECT (parse, "doing duration query to fix up unset stop");
1596     gst_pad_peer_query_duration (parse->sinkpad, GST_FORMAT_BYTES, &stop);
1597   }
1598
1599   /* if upstream doesn't know the size, it's likely that it's not seekable in
1600    * practice even if it technically may be seekable */
1601   if (seekable && (start != 0 || stop <= start)) {
1602     GST_DEBUG_OBJECT (parse, "seekable but unknown start/stop -> disable");
1603     seekable = FALSE;
1604   }
1605
1606   /* let's not put every single frame into our index */
1607   if (seekable) {
1608     if (stop < 10 * 1024 * 1024)
1609       idx_interval = 100;
1610     else if (stop < 100 * 1024 * 1024)
1611       idx_interval = 500;
1612     else
1613       idx_interval = 1000;
1614   }
1615
1616 done:
1617   gst_query_unref (query);
1618
1619   GST_DEBUG_OBJECT (parse, "seekable: %d (%" G_GUINT64_FORMAT " - %"
1620       G_GUINT64_FORMAT ")", seekable, start, stop);
1621   parse->priv->upstream_seekable = seekable;
1622   parse->priv->upstream_size = seekable ? stop : 0;
1623
1624   GST_DEBUG_OBJECT (parse, "idx_interval: %ums", idx_interval);
1625   parse->priv->idx_interval = idx_interval * GST_MSECOND;
1626 }
1627
1628 /* some misc checks on upstream */
1629 static void
1630 gst_base_parse_check_upstream (GstBaseParse * parse)
1631 {
1632   gint64 stop;
1633
1634   if (gst_pad_peer_query_duration (parse->sinkpad, GST_FORMAT_TIME, &stop))
1635     if (GST_CLOCK_TIME_IS_VALID (stop) && stop) {
1636       /* upstream has one, accept it also, and no further updates */
1637       gst_base_parse_set_duration (parse, GST_FORMAT_TIME, stop, 0);
1638       parse->priv->upstream_has_duration = TRUE;
1639     }
1640
1641   GST_DEBUG_OBJECT (parse, "upstream_has_duration: %d",
1642       parse->priv->upstream_has_duration);
1643 }
1644
1645 /* checks src caps to determine if dealing with audio or video */
1646 /* TODO maybe forego automagic stuff and let subclass configure it ? */
1647 static void
1648 gst_base_parse_check_media (GstBaseParse * parse)
1649 {
1650   GstCaps *caps;
1651   GstStructure *s;
1652
1653   caps = gst_pad_get_current_caps (parse->srcpad);
1654   if (G_LIKELY (caps) && (s = gst_caps_get_structure (caps, 0))) {
1655     parse->priv->is_video =
1656         g_str_has_prefix (gst_structure_get_name (s), "video");
1657   } else {
1658     /* historical default */
1659     parse->priv->is_video = FALSE;
1660   }
1661   if (caps)
1662     gst_caps_unref (caps);
1663
1664   GST_DEBUG_OBJECT (parse, "media is video: %d", parse->priv->is_video);
1665 }
1666
1667 /* takes ownership of frame */
1668 static void
1669 gst_base_parse_queue_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1670 {
1671   if (!(frame->_private_flags & GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC)) {
1672     /* frame allocated on the heap, we can just take ownership */
1673     g_queue_push_tail (&parse->priv->queued_frames, frame);
1674     GST_TRACE ("queued frame %p", frame);
1675   } else {
1676     GstBaseParseFrame *copy;
1677
1678     /* probably allocated on the stack, must make a proper copy */
1679     copy = gst_base_parse_frame_copy (frame);
1680     g_queue_push_tail (&parse->priv->queued_frames, copy);
1681     GST_TRACE ("queued frame %p (copy of %p)", copy, frame);
1682     gst_base_parse_frame_free (frame);
1683   }
1684 }
1685
1686 /* makes sure that @buf is properly prepared and decorated for passing
1687  * to baseclass, and an equally setup frame is returned setup with @buf.
1688  * Takes ownership of @buf. */
1689 static GstBaseParseFrame *
1690 gst_base_parse_prepare_frame (GstBaseParse * parse, GstBuffer * buffer)
1691 {
1692   GstBaseParseFrame *frame = NULL;
1693
1694   buffer = gst_buffer_make_writable (buffer);
1695
1696   GST_LOG_OBJECT (parse,
1697       "preparing frame at offset %" G_GUINT64_FORMAT
1698       " (%#" G_GINT64_MODIFIER "x) of size %" G_GSIZE_FORMAT,
1699       GST_BUFFER_OFFSET (buffer), GST_BUFFER_OFFSET (buffer),
1700       gst_buffer_get_size (buffer));
1701
1702   if (parse->priv->discont) {
1703     GST_DEBUG_OBJECT (parse, "marking DISCONT");
1704     GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
1705     parse->priv->discont = FALSE;
1706   }
1707
1708   GST_BUFFER_OFFSET (buffer) = parse->priv->offset;
1709
1710   if (parse->priv->prev_frame) {
1711     if (parse->priv->prev_offset == parse->priv->offset) {
1712       frame = parse->priv->prev_frame;
1713     } else {
1714       gst_base_parse_frame_free (parse->priv->prev_frame);
1715     }
1716     parse->priv->prev_frame = NULL;
1717   }
1718
1719   if (!frame) {
1720     frame = gst_base_parse_frame_new (buffer, 0, 0);
1721   }
1722
1723   /* also ensure to update state flags */
1724   gst_base_parse_frame_update (parse, frame, buffer);
1725   gst_buffer_unref (buffer);
1726
1727   frame->offset = parse->priv->prev_offset = parse->priv->offset;
1728
1729   /* use default handler to provide initial (upstream) metadata */
1730   gst_base_parse_parse_frame (parse, frame);
1731
1732   return frame;
1733 }
1734
1735 static void
1736 gst_base_parse_unprepare_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1737 {
1738   g_assert (parse->priv->prev_frame == NULL);
1739
1740   parse->priv->prev_frame = frame;
1741   gst_base_parse_frame_update (parse, frame, NULL);
1742 }
1743
1744 /* Wraps buffer in a frame and dispatches to subclass.
1745  * Also manages data skipping and offset handling (including adapter flushing).
1746  * Takes ownership of @buffer */
1747 static GstFlowReturn
1748 gst_base_parse_handle_buffer (GstBaseParse * parse, GstBuffer * buffer,
1749     gint * skip, gint * flushed)
1750 {
1751   GstBaseParseClass *klass = GST_BASE_PARSE_GET_CLASS (parse);
1752   GstBaseParseFrame *frame;
1753   GstFlowReturn ret;
1754
1755   g_return_val_if_fail (skip != NULL || flushed != NULL, GST_FLOW_ERROR);
1756
1757   GST_LOG_OBJECT (parse,
1758       "handling buffer of size %" G_GSIZE_FORMAT " with ts %" GST_TIME_FORMAT
1759       ", duration %" GST_TIME_FORMAT, gst_buffer_get_size (buffer),
1760       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
1761       GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)));
1762
1763   /* track what is being flushed during this single round of frame processing */
1764   parse->priv->flushed = 0;
1765   *skip = 0;
1766
1767   /* make it easy for _finish_frame to pick up input data */
1768   if (parse->priv->pad_mode == GST_PAD_MODE_PULL) {
1769     gst_buffer_ref (buffer);
1770     gst_adapter_push (parse->priv->adapter, buffer);
1771   }
1772
1773   frame = gst_base_parse_prepare_frame (parse, buffer);
1774   ret = klass->handle_frame (parse, frame, skip);
1775   gst_base_parse_unprepare_frame (parse, frame);
1776
1777   *flushed = parse->priv->flushed;
1778
1779   GST_LOG_OBJECT (parse, "handle_frame skipped %d, flushed %d",
1780       *skip, *flushed);
1781
1782   if (ret != GST_FLOW_OK) {
1783     GST_DEBUG_OBJECT (parse, "handle_frame returned %d", ret);
1784     goto exit;
1785   }
1786
1787   /* subclass can only do one of these, or semantics are too unclear */
1788   g_assert (*skip == 0 || *flushed == 0);
1789
1790   /* if it did something, clear frame state,
1791    * though this should also trigger the offset check anyway */
1792   if (*skip != 0 || *flushed != 0) {
1793     GST_LOG_OBJECT (parse, "clearing prev frame");
1794     gst_base_parse_frame_free (parse->priv->prev_frame);
1795     parse->priv->prev_frame = NULL;
1796   }
1797
1798   /* track skipping */
1799   if (*skip > 0) {
1800     GstClockTime timestamp;
1801     GstBuffer *outbuf;
1802
1803     GST_LOG_OBJECT (parse, "finding sync, skipping %d bytes", *skip);
1804     if (parse->segment.rate < 0.0 && !parse->priv->buffers_queued) {
1805       /* reverse playback, and no frames found yet, so we are skipping
1806        * the leading part of a fragment, which may form the tail of
1807        * fragment coming later, hopefully subclass skips efficiently ... */
1808       timestamp = gst_adapter_prev_timestamp (parse->priv->adapter, NULL);
1809       outbuf = gst_adapter_take_buffer (parse->priv->adapter, *skip);
1810       outbuf = gst_buffer_make_writable (outbuf);
1811       GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
1812       parse->priv->buffers_head =
1813           g_slist_prepend (parse->priv->buffers_head, outbuf);
1814       outbuf = NULL;
1815     } else {
1816       gst_adapter_flush (parse->priv->adapter, *skip);
1817     }
1818     if (!parse->priv->discont)
1819       parse->priv->sync_offset = parse->priv->offset;
1820     parse->priv->offset += *skip;
1821     parse->priv->discont = TRUE;
1822     /* check for indefinite skipping */
1823     if (ret == GST_FLOW_OK)
1824       ret = gst_base_parse_check_sync (parse);
1825   }
1826
1827   parse->priv->offset += *flushed;
1828
1829 exit:
1830   if (parse->priv->pad_mode == GST_PAD_MODE_PULL) {
1831     gst_adapter_clear (parse->priv->adapter);
1832   }
1833
1834   return ret;
1835 }
1836
1837 /* gst_base_parse_handle_and_push_buffer:
1838  * @parse: #GstBaseParse.
1839  * @klass: #GstBaseParseClass.
1840  * @frame: (transfer full): a #GstBaseParseFrame
1841  *
1842  * Parses the frame from given buffer and pushes it forward. Also performs
1843  * timestamp handling and checks the segment limits.
1844  *
1845  * This is called with srcpad STREAM_LOCK held.
1846  *
1847  * Returns: #GstFlowReturn
1848  */
1849 static GstFlowReturn
1850 gst_base_parse_handle_and_push_frame (GstBaseParse * parse,
1851     GstBaseParseFrame * frame)
1852 {
1853   gint64 offset;
1854   GstBuffer *buffer;
1855
1856   g_return_val_if_fail (frame != NULL, GST_FLOW_ERROR);
1857
1858   /* some one-time start-up */
1859   if (G_UNLIKELY (!parse->priv->framecount)) {
1860     gst_base_parse_check_seekability (parse);
1861     gst_base_parse_check_upstream (parse);
1862   }
1863
1864   buffer = frame->buffer;
1865   offset = frame->offset;
1866
1867   /* check if subclass/format can provide ts.
1868    * If so, that allows and enables extra seek and duration determining options */
1869   if (G_UNLIKELY (parse->priv->first_frame_offset < 0)) {
1870     if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer) && parse->priv->has_timing_info
1871         && parse->priv->pad_mode == GST_PAD_MODE_PULL) {
1872       parse->priv->first_frame_offset = offset;
1873       parse->priv->first_frame_ts = GST_BUFFER_TIMESTAMP (buffer);
1874       GST_DEBUG_OBJECT (parse, "subclass provided ts %" GST_TIME_FORMAT
1875           " for first frame at offset %" G_GINT64_FORMAT,
1876           GST_TIME_ARGS (parse->priv->first_frame_ts),
1877           parse->priv->first_frame_offset);
1878       if (!GST_CLOCK_TIME_IS_VALID (parse->priv->duration)) {
1879         gint64 off;
1880         GstClockTime last_ts = G_MAXINT64;
1881
1882         GST_DEBUG_OBJECT (parse, "no duration; trying scan to determine");
1883         gst_base_parse_locate_time (parse, &last_ts, &off);
1884         if (GST_CLOCK_TIME_IS_VALID (last_ts))
1885           gst_base_parse_set_duration (parse, GST_FORMAT_TIME, last_ts, 0);
1886       }
1887     } else {
1888       /* disable further checks */
1889       parse->priv->first_frame_offset = 0;
1890     }
1891   }
1892
1893   /* again use default handler to add missing metadata;
1894    * we may have new information on frame properties */
1895   gst_base_parse_parse_frame (parse, frame);
1896   if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer) &&
1897       GST_BUFFER_DURATION_IS_VALID (buffer)) {
1898     parse->priv->next_ts =
1899         GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer);
1900   } else {
1901     /* we lost track, do not produce bogus time next time around
1902      * (probably means parser subclass has given up on parsing as well) */
1903     GST_DEBUG_OBJECT (parse, "no next fallback timestamp");
1904     parse->priv->next_ts = GST_CLOCK_TIME_NONE;
1905   }
1906
1907   if (parse->priv->upstream_seekable && parse->priv->exact_position &&
1908       GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
1909     gst_base_parse_add_index_entry (parse, offset,
1910         GST_BUFFER_TIMESTAMP (buffer),
1911         !GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT), FALSE);
1912
1913   /* All OK, push queued frames if there are any */
1914   if (G_UNLIKELY (!g_queue_is_empty (&parse->priv->queued_frames))) {
1915     GstBaseParseFrame *queued_frame;
1916
1917     while ((queued_frame = g_queue_pop_head (&parse->priv->queued_frames))) {
1918       gst_base_parse_push_frame (parse, queued_frame);
1919     }
1920   }
1921
1922   return gst_base_parse_push_frame (parse, frame);
1923 }
1924
1925 /**
1926  * gst_base_parse_push_frame:
1927  * @parse: #GstBaseParse.
1928  * @frame: (transfer none): a #GstBaseParseFrame
1929  *
1930  * Pushes the frame's buffer downstream, sends any pending events and
1931  * does some timestamp and segment handling. Takes ownership of
1932  * frame's buffer, though caller retains ownership of @frame.
1933  *
1934  * This must be called with sinkpad STREAM_LOCK held.
1935  *
1936  * Returns: #GstFlowReturn
1937  *
1938  * Since: 0.10.33
1939  */
1940 GstFlowReturn
1941 gst_base_parse_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1942 {
1943   GstFlowReturn ret = GST_FLOW_OK;
1944   GstClockTime last_start = GST_CLOCK_TIME_NONE;
1945   GstClockTime last_stop = GST_CLOCK_TIME_NONE;
1946   GstBaseParseClass *klass = GST_BASE_PARSE_GET_CLASS (parse);
1947   GstBuffer *buffer;
1948   gsize size;
1949
1950   g_return_val_if_fail (frame != NULL, GST_FLOW_ERROR);
1951   g_return_val_if_fail (frame->buffer != NULL, GST_FLOW_ERROR);
1952
1953   GST_TRACE_OBJECT (parse, "pushing frame %p", frame);
1954
1955   buffer = frame->buffer;
1956
1957   GST_LOG_OBJECT (parse,
1958       "processing buffer of size %" G_GSIZE_FORMAT " with ts %" GST_TIME_FORMAT
1959       ", duration %" GST_TIME_FORMAT, gst_buffer_get_size (buffer),
1960       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
1961       GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)));
1962
1963   /* update stats */
1964   parse->priv->bytecount += frame->size;
1965   if (G_LIKELY (!(frame->flags & GST_BASE_PARSE_FRAME_FLAG_NO_FRAME))) {
1966     parse->priv->framecount++;
1967     if (GST_BUFFER_DURATION_IS_VALID (buffer)) {
1968       parse->priv->acc_duration += GST_BUFFER_DURATION (buffer);
1969     }
1970   }
1971   /* 0 means disabled */
1972   if (parse->priv->update_interval < 0)
1973     parse->priv->update_interval = 50;
1974   else if (parse->priv->update_interval > 0 &&
1975       (parse->priv->framecount % parse->priv->update_interval) == 0)
1976     gst_base_parse_update_duration (parse);
1977
1978   if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
1979     last_start = last_stop = GST_BUFFER_TIMESTAMP (buffer);
1980   if (last_start != GST_CLOCK_TIME_NONE
1981       && GST_BUFFER_DURATION_IS_VALID (buffer))
1982     last_stop = last_start + GST_BUFFER_DURATION (buffer);
1983
1984   /* should have caps by now */
1985   if (!gst_pad_has_current_caps (parse->srcpad))
1986     goto no_caps;
1987
1988   /* segment adjustment magic; only if we are running the whole show */
1989   if (!parse->priv->passthrough && parse->segment.rate > 0.0 &&
1990       (parse->priv->pad_mode == GST_PAD_MODE_PULL ||
1991           parse->priv->upstream_seekable)) {
1992     /* segment times are typically estimates,
1993      * actual frame data might lead subclass to different timestamps,
1994      * so override segment start from what is supplied there */
1995     if (G_UNLIKELY (parse->priv->pending_segment && !parse->priv->exact_position
1996             && GST_CLOCK_TIME_IS_VALID (last_start))) {
1997       gst_event_unref (parse->priv->pending_segment);
1998       parse->segment.start =
1999           MIN ((guint64) last_start, (guint64) parse->segment.stop);
2000
2001       GST_DEBUG_OBJECT (parse,
2002           "adjusting pending segment start to %" GST_TIME_FORMAT,
2003           GST_TIME_ARGS (parse->segment.start));
2004
2005       parse->priv->pending_segment = gst_event_new_segment (&parse->segment);
2006     }
2007     /* handle gaps, e.g. non-zero start-time, in as much not handled by above */
2008     if (GST_CLOCK_TIME_IS_VALID (parse->segment.position) &&
2009         GST_CLOCK_TIME_IS_VALID (last_start)) {
2010       GstClockTimeDiff diff;
2011
2012       /* only send newsegments with increasing start times,
2013        * otherwise if these go back and forth downstream (sinks) increase
2014        * accumulated time and running_time */
2015       diff = GST_CLOCK_DIFF (parse->segment.position, last_start);
2016       if (G_UNLIKELY (diff > 2 * GST_SECOND
2017               && last_start > parse->segment.start
2018               && (!GST_CLOCK_TIME_IS_VALID (parse->segment.stop)
2019                   || last_start < parse->segment.stop))) {
2020
2021         GST_DEBUG_OBJECT (parse,
2022             "Gap of %" G_GINT64_FORMAT " ns detected in stream " "(%"
2023             GST_TIME_FORMAT " -> %" GST_TIME_FORMAT "). "
2024             "Sending updated NEWSEGMENT events", diff,
2025             GST_TIME_ARGS (parse->segment.position),
2026             GST_TIME_ARGS (last_start));
2027
2028         if (G_UNLIKELY (parse->priv->pending_segment)) {
2029           gst_event_unref (parse->priv->pending_segment);
2030           parse->segment.start = last_start;
2031           parse->segment.time = last_start;
2032           parse->priv->pending_segment =
2033               gst_event_new_segment (&parse->segment);
2034         } else {
2035           /* skip gap FIXME */
2036           gst_pad_push_event (parse->srcpad,
2037               gst_event_new_segment (&parse->segment));
2038         }
2039         parse->segment.position = last_start;
2040       }
2041     }
2042   }
2043
2044   if (G_UNLIKELY (parse->priv->pending_segment)) {
2045     GstEvent *pending_segment;
2046
2047     pending_segment = parse->priv->pending_segment;
2048     parse->priv->pending_segment = NULL;
2049
2050     GST_DEBUG_OBJECT (parse, "%s push pending segment",
2051         parse->priv->pad_mode == GST_PAD_MODE_PULL ? "loop" : "chain");
2052     gst_pad_push_event (parse->srcpad, pending_segment);
2053
2054     /* have caps; check identity */
2055     gst_base_parse_check_media (parse);
2056   }
2057
2058   /* update bitrates and optionally post corresponding tags
2059    * (following newsegment) */
2060   gst_base_parse_update_bitrates (parse, frame);
2061
2062   if (G_UNLIKELY (parse->priv->pending_events)) {
2063     GList *l;
2064
2065     for (l = parse->priv->pending_events; l != NULL; l = l->next) {
2066       gst_pad_push_event (parse->srcpad, GST_EVENT (l->data));
2067     }
2068     g_list_free (parse->priv->pending_events);
2069     parse->priv->pending_events = NULL;
2070   }
2071
2072   if (klass->pre_push_frame) {
2073     ret = klass->pre_push_frame (parse, frame);
2074   } else {
2075     frame->flags |= GST_BASE_PARSE_FRAME_FLAG_CLIP;
2076   }
2077
2078   /* take final ownership of frame buffer */
2079   if (frame->out_buffer) {
2080     buffer = frame->out_buffer;
2081     frame->out_buffer = NULL;
2082     gst_buffer_replace (&frame->buffer, NULL);
2083   } else {
2084     buffer = frame->buffer;
2085     frame->buffer = NULL;
2086   }
2087
2088   /* subclass must play nice */
2089   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
2090
2091   size = gst_buffer_get_size (buffer);
2092
2093   parse->priv->seen_keyframe |= parse->priv->is_video &&
2094       !GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
2095
2096   if (frame->flags & GST_BASE_PARSE_FRAME_FLAG_CLIP) {
2097     if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer) &&
2098         GST_CLOCK_TIME_IS_VALID (parse->segment.stop) &&
2099         GST_BUFFER_TIMESTAMP (buffer) >
2100         parse->segment.stop + parse->priv->lead_out_ts) {
2101       GST_LOG_OBJECT (parse, "Dropped frame, after segment");
2102       ret = GST_FLOW_EOS;
2103     } else if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer) &&
2104         GST_BUFFER_DURATION_IS_VALID (buffer) &&
2105         GST_CLOCK_TIME_IS_VALID (parse->segment.start) &&
2106         GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer) +
2107         parse->priv->lead_in_ts < parse->segment.start) {
2108       if (parse->priv->seen_keyframe) {
2109         GST_LOG_OBJECT (parse, "Frame before segment, after keyframe");
2110         ret = GST_FLOW_OK;
2111       } else {
2112         GST_LOG_OBJECT (parse, "Dropped frame, before segment");
2113         ret = GST_BASE_PARSE_FLOW_DROPPED;
2114       }
2115     } else {
2116       ret = GST_FLOW_OK;
2117     }
2118   }
2119
2120   if (ret == GST_BASE_PARSE_FLOW_DROPPED) {
2121     GST_LOG_OBJECT (parse, "frame (%" G_GSIZE_FORMAT " bytes) dropped", size);
2122     gst_buffer_unref (buffer);
2123     ret = GST_FLOW_OK;
2124   } else if (ret == GST_FLOW_OK) {
2125     if (parse->segment.rate > 0.0) {
2126       GST_LOG_OBJECT (parse, "pushing frame (%" G_GSIZE_FORMAT " bytes) now..",
2127           size);
2128       ret = gst_pad_push (parse->srcpad, buffer);
2129       GST_LOG_OBJECT (parse, "frame pushed, flow %s", gst_flow_get_name (ret));
2130     } else {
2131       GST_LOG_OBJECT (parse, "frame (%" G_GSIZE_FORMAT " bytes) queued for now",
2132           size);
2133       parse->priv->buffers_queued =
2134           g_slist_prepend (parse->priv->buffers_queued, buffer);
2135       ret = GST_FLOW_OK;
2136     }
2137   } else {
2138     GST_LOG_OBJECT (parse, "frame (%" G_GSIZE_FORMAT " bytes) not pushed: %s",
2139         size, gst_flow_get_name (ret));
2140     gst_buffer_unref (buffer);
2141     /* if we are not sufficiently in control, let upstream decide on EOS */
2142     if (ret == GST_FLOW_EOS &&
2143         (parse->priv->passthrough ||
2144             (parse->priv->pad_mode == GST_PAD_MODE_PUSH &&
2145                 !parse->priv->upstream_seekable)))
2146       ret = GST_FLOW_OK;
2147   }
2148
2149   /* Update current running segment position */
2150   if (ret == GST_FLOW_OK && last_stop != GST_CLOCK_TIME_NONE &&
2151       parse->segment.position < last_stop)
2152     parse->segment.position = last_stop;
2153
2154   return ret;
2155
2156   /* ERRORS */
2157 no_caps:
2158   {
2159     GST_ELEMENT_ERROR (parse, STREAM, DECODE, ("No caps set"), (NULL));
2160     return GST_FLOW_ERROR;
2161   }
2162 }
2163
2164 /**
2165  * gst_base_parse_finish_frame:
2166  * @parse: a #GstBaseParse
2167  * @frame: a #GstBaseParseFrame
2168  * @size: consumed input data represented by frame
2169  *
2170  * Collects parsed data and pushes this downstream.
2171  * Source pad caps must be set when this is called.
2172  *
2173  * If @frame's out_buffer is set, that will be used as subsequent frame data.
2174  * Otherwise, @size samples will be taken from the input and used for output,
2175  * and the output's metadata (timestamps etc) will be taken as (optionally)
2176  * set by the subclass on @frame's (input) buffer.
2177  *
2178  * Note that the latter buffer is invalidated by this call, whereas the
2179  * caller retains ownership of @frame.
2180  *
2181  * Returns: a #GstFlowReturn that should be escalated to caller (of caller)
2182  *
2183  * Since: 0.11.1
2184  */
2185 GstFlowReturn
2186 gst_base_parse_finish_frame (GstBaseParse * parse, GstBaseParseFrame * frame,
2187     gint size)
2188 {
2189   GstFlowReturn ret = GST_FLOW_OK;
2190
2191   g_return_val_if_fail (frame != NULL, GST_FLOW_ERROR);
2192   g_return_val_if_fail (frame->buffer != NULL, GST_FLOW_ERROR);
2193   g_return_val_if_fail (size > 0 || frame->out_buffer, GST_FLOW_ERROR);
2194   g_return_val_if_fail (gst_adapter_available (parse->priv->adapter) >= size,
2195       GST_FLOW_ERROR);
2196
2197   GST_LOG_OBJECT (parse, "finished frame at offset %" G_GUINT64_FORMAT ", "
2198       "flushing size %d", frame->offset, size);
2199
2200   if (parse->priv->scanning && frame->buffer) {
2201     if (!parse->priv->scanned_frame) {
2202       parse->priv->scanned_frame = gst_base_parse_frame_copy (frame);
2203     }
2204     goto exit;
2205   }
2206
2207   parse->priv->flushed += size;
2208
2209   /* either PUSH or PULL mode arranges for adapter data */
2210   /* ensure output buffer */
2211   if (!frame->out_buffer) {
2212     GstBuffer *src, *dest;
2213
2214     frame->out_buffer = gst_adapter_take_buffer (parse->priv->adapter, size);
2215     dest = frame->out_buffer;
2216     src = frame->buffer;
2217     GST_BUFFER_PTS (dest) = GST_BUFFER_PTS (src);
2218     GST_BUFFER_DTS (dest) = GST_BUFFER_DTS (src);
2219     GST_BUFFER_OFFSET (dest) = GST_BUFFER_OFFSET (src);
2220     GST_BUFFER_DURATION (dest) = GST_BUFFER_DURATION (src);
2221     GST_BUFFER_OFFSET_END (dest) = GST_BUFFER_OFFSET_END (src);
2222     GST_MINI_OBJECT_FLAGS (dest) = GST_MINI_OBJECT_FLAGS (src);
2223   } else {
2224     gst_adapter_flush (parse->priv->adapter, size);
2225   }
2226
2227   /* use as input for subsequent processing */
2228   gst_buffer_replace (&frame->buffer, frame->out_buffer);
2229   gst_buffer_unref (frame->out_buffer);
2230   frame->out_buffer = NULL;
2231
2232   /* subclass might queue frames/data internally if it needs more
2233    * frames to decide on the format, or might request us to queue here. */
2234   if (frame->flags & GST_BASE_PARSE_FRAME_FLAG_DROP) {
2235     gst_buffer_replace (&frame->buffer, NULL);
2236     goto exit;
2237   } else if (frame->flags & GST_BASE_PARSE_FRAME_FLAG_QUEUE) {
2238     GstBaseParseFrame *copy;
2239
2240     copy = gst_base_parse_frame_copy (frame);
2241     copy->flags &= ~GST_BASE_PARSE_FRAME_FLAG_QUEUE;
2242     gst_base_parse_queue_frame (parse, copy);
2243     goto exit;
2244   }
2245
2246   ret = gst_base_parse_handle_and_push_frame (parse, frame);
2247
2248 exit:
2249   return ret;
2250 }
2251
2252 /* gst_base_parse_drain:
2253  *
2254  * Drains the adapter until it is empty. It decreases the min_frame_size to
2255  * match the current adapter size and calls chain method until the adapter
2256  * is emptied or chain returns with error.
2257  */
2258 static void
2259 gst_base_parse_drain (GstBaseParse * parse)
2260 {
2261   guint avail;
2262
2263   GST_DEBUG_OBJECT (parse, "draining");
2264   parse->priv->drain = TRUE;
2265
2266   for (;;) {
2267     avail = gst_adapter_available (parse->priv->adapter);
2268     if (!avail)
2269       break;
2270
2271     if (gst_base_parse_chain (parse->sinkpad, GST_OBJECT_CAST (parse),
2272             NULL) != GST_FLOW_OK) {
2273       break;
2274     }
2275
2276     /* nothing changed, maybe due to truncated frame; break infinite loop */
2277     if (avail == gst_adapter_available (parse->priv->adapter)) {
2278       GST_DEBUG_OBJECT (parse, "no change during draining; flushing");
2279       gst_adapter_clear (parse->priv->adapter);
2280     }
2281   }
2282
2283   parse->priv->drain = FALSE;
2284 }
2285
2286 /* gst_base_parse_send_buffers
2287  *
2288  * Sends buffers collected in send_buffers downstream, and ensures that list
2289  * is empty at the end (errors or not).
2290  */
2291 static GstFlowReturn
2292 gst_base_parse_send_buffers (GstBaseParse * parse)
2293 {
2294   GSList *send = NULL;
2295   GstBuffer *buf;
2296   GstFlowReturn ret = GST_FLOW_OK;
2297
2298   send = parse->priv->buffers_send;
2299
2300   /* send buffers */
2301   while (send) {
2302     buf = GST_BUFFER_CAST (send->data);
2303     GST_LOG_OBJECT (parse, "pushing buffer %p, timestamp %"
2304         GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT
2305         ", offset %" G_GINT64_FORMAT, buf,
2306         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
2307         GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_BUFFER_OFFSET (buf));
2308
2309     /* iterate output queue an push downstream */
2310     ret = gst_pad_push (parse->srcpad, buf);
2311     send = g_slist_delete_link (send, send);
2312
2313     /* clear any leftover if error */
2314     if (G_UNLIKELY (ret != GST_FLOW_OK)) {
2315       while (send) {
2316         buf = GST_BUFFER_CAST (send->data);
2317         gst_buffer_unref (buf);
2318         send = g_slist_delete_link (send, send);
2319       }
2320     }
2321   }
2322
2323   parse->priv->buffers_send = send;
2324
2325   return ret;
2326 }
2327
2328 /* gst_base_parse_start_fragment:
2329  *
2330  * Prepares for processing a reverse playback (forward) fragment
2331  * by (re)setting proper state variables.
2332  */
2333 static GstFlowReturn
2334 gst_base_parse_start_fragment (GstBaseParse * parse)
2335 {
2336   GST_LOG_OBJECT (parse, "starting fragment");
2337
2338   /* invalidate so no fall-back timestamping is performed;
2339    * ok if taken from subclass or upstream */
2340   parse->priv->next_ts = GST_CLOCK_TIME_NONE;
2341   parse->priv->prev_ts = GST_CLOCK_TIME_NONE;
2342   /* prevent it hanging around stop all the time */
2343   parse->segment.position = GST_CLOCK_TIME_NONE;
2344   /* mark next run */
2345   parse->priv->discont = TRUE;
2346
2347   /* head of previous fragment is now pending tail of current fragment */
2348   parse->priv->buffers_pending = parse->priv->buffers_head;
2349   parse->priv->buffers_head = NULL;
2350
2351   return GST_FLOW_OK;
2352 }
2353
2354
2355 /* gst_base_parse_finish_fragment:
2356  *
2357  * Processes a reverse playback (forward) fragment:
2358  * - append head of last fragment that was skipped to current fragment data
2359  * - drain the resulting current fragment data (i.e. repeated chain)
2360  * - add time/duration (if needed) to frames queued by chain
2361  * - push queued data
2362  */
2363 static GstFlowReturn
2364 gst_base_parse_finish_fragment (GstBaseParse * parse, gboolean prev_head)
2365 {
2366   GstBuffer *buf;
2367   GstFlowReturn ret = GST_FLOW_OK;
2368   gboolean seen_key = FALSE, seen_delta = FALSE;
2369
2370   GST_LOG_OBJECT (parse, "finishing fragment");
2371
2372   /* restore order */
2373   parse->priv->buffers_pending = g_slist_reverse (parse->priv->buffers_pending);
2374   while (parse->priv->buffers_pending) {
2375     buf = GST_BUFFER_CAST (parse->priv->buffers_pending->data);
2376     if (prev_head) {
2377       GST_LOG_OBJECT (parse, "adding pending buffer (size %" G_GSIZE_FORMAT ")",
2378           gst_buffer_get_size (buf));
2379       gst_adapter_push (parse->priv->adapter, buf);
2380     } else {
2381       GST_LOG_OBJECT (parse, "discarding head buffer");
2382       gst_buffer_unref (buf);
2383     }
2384     parse->priv->buffers_pending =
2385         g_slist_delete_link (parse->priv->buffers_pending,
2386         parse->priv->buffers_pending);
2387   }
2388
2389   /* chain looks for frames and queues resulting ones (in stead of pushing) */
2390   /* initial skipped data is added to buffers_pending */
2391   gst_base_parse_drain (parse);
2392
2393   if (parse->priv->buffers_send) {
2394     buf = GST_BUFFER_CAST (parse->priv->buffers_send->data);
2395     seen_key |= !GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
2396   }
2397
2398   /* add metadata (if needed to queued buffers */
2399   GST_LOG_OBJECT (parse, "last timestamp: %" GST_TIME_FORMAT,
2400       GST_TIME_ARGS (parse->priv->last_ts));
2401   while (parse->priv->buffers_queued) {
2402     buf = GST_BUFFER_CAST (parse->priv->buffers_queued->data);
2403
2404     /* no touching if upstream or parsing provided time */
2405     if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
2406       GST_LOG_OBJECT (parse, "buffer has time %" GST_TIME_FORMAT,
2407           GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
2408     } else if (GST_CLOCK_TIME_IS_VALID (parse->priv->last_ts) &&
2409         GST_BUFFER_DURATION_IS_VALID (buf)) {
2410       if (G_LIKELY (GST_BUFFER_DURATION (buf) <= parse->priv->last_ts))
2411         parse->priv->last_ts -= GST_BUFFER_DURATION (buf);
2412       else
2413         parse->priv->last_ts = 0;
2414       GST_BUFFER_TIMESTAMP (buf) = parse->priv->last_ts;
2415       GST_LOG_OBJECT (parse, "applied time %" GST_TIME_FORMAT,
2416           GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
2417     } else {
2418       /* no idea, very bad */
2419       GST_WARNING_OBJECT (parse, "could not determine time for buffer");
2420     }
2421
2422     parse->priv->last_ts = GST_BUFFER_TIMESTAMP (buf);
2423
2424     /* reverse order for ascending sending */
2425     /* send downstream at keyframe not preceded by a keyframe
2426      * (e.g. that should identify start of collection of IDR nals) */
2427     if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT)) {
2428       if (seen_key) {
2429         ret = gst_base_parse_send_buffers (parse);
2430         /* if a problem, throw all to sending */
2431         if (ret != GST_FLOW_OK) {
2432           parse->priv->buffers_send =
2433               g_slist_reverse (parse->priv->buffers_queued);
2434           parse->priv->buffers_queued = NULL;
2435           break;
2436         }
2437         seen_key = FALSE;
2438       }
2439       seen_delta = TRUE;
2440     } else {
2441       seen_key = TRUE;
2442     }
2443
2444     parse->priv->buffers_send =
2445         g_slist_prepend (parse->priv->buffers_send, buf);
2446     parse->priv->buffers_queued =
2447         g_slist_delete_link (parse->priv->buffers_queued,
2448         parse->priv->buffers_queued);
2449   }
2450
2451   /* audio may have all marked as keyframe, so arrange to send here */
2452   if (!seen_delta)
2453     ret = gst_base_parse_send_buffers (parse);
2454
2455   /* any trailing unused no longer usable (ideally none) */
2456   if (G_UNLIKELY (gst_adapter_available (parse->priv->adapter))) {
2457     GST_DEBUG_OBJECT (parse, "discarding %" G_GSIZE_FORMAT " trailing bytes",
2458         gst_adapter_available (parse->priv->adapter));
2459     gst_adapter_clear (parse->priv->adapter);
2460   }
2461
2462   return ret;
2463 }
2464
2465 /* small helper that checks whether we have been trying to resync too long */
2466 static inline GstFlowReturn
2467 gst_base_parse_check_sync (GstBaseParse * parse)
2468 {
2469   if (G_UNLIKELY (parse->priv->discont &&
2470           parse->priv->offset - parse->priv->sync_offset > 2 * 1024 * 1024)) {
2471     GST_ELEMENT_ERROR (parse, STREAM, DECODE,
2472         ("Failed to parse stream"), (NULL));
2473     return GST_FLOW_ERROR;
2474   }
2475
2476   return GST_FLOW_OK;
2477 }
2478
2479 static GstFlowReturn
2480 gst_base_parse_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
2481 {
2482   GstBaseParseClass *bclass;
2483   GstBaseParse *parse;
2484   GstFlowReturn ret = GST_FLOW_OK;
2485   GstBuffer *tmpbuf = NULL;
2486   guint fsize = 1;
2487   gint skip = -1;
2488   const guint8 *data;
2489   guint min_size, av;
2490   GstClockTime timestamp;
2491
2492   parse = GST_BASE_PARSE (parent);
2493   bclass = GST_BASE_PARSE_GET_CLASS (parse);
2494
2495   if (parse->priv->detecting) {
2496     GstBuffer *detect_buf;
2497
2498     if (parse->priv->detect_buffers_size == 0) {
2499       detect_buf = gst_buffer_ref (buffer);
2500     } else {
2501       GList *l;
2502       guint offset = 0;
2503
2504       detect_buf = gst_buffer_new ();
2505
2506       for (l = parse->priv->detect_buffers; l; l = l->next) {
2507         gsize tmpsize = gst_buffer_get_size (l->data);
2508
2509         gst_buffer_copy_into (detect_buf, GST_BUFFER_CAST (l->data),
2510             GST_BUFFER_COPY_MEMORY, offset, tmpsize);
2511         offset += tmpsize;
2512       }
2513       if (buffer)
2514         gst_buffer_copy_into (detect_buf, buffer, GST_BUFFER_COPY_MEMORY,
2515             offset, gst_buffer_get_size (buffer));
2516     }
2517
2518     ret = bclass->detect (parse, detect_buf);
2519     gst_buffer_unref (detect_buf);
2520
2521     if (ret == GST_FLOW_OK) {
2522       GList *l;
2523
2524       /* Detected something */
2525       parse->priv->detecting = FALSE;
2526
2527       for (l = parse->priv->detect_buffers; l; l = l->next) {
2528         if (ret == GST_FLOW_OK && !parse->priv->flushing)
2529           ret =
2530               gst_base_parse_chain (GST_BASE_PARSE_SINK_PAD (parse),
2531               parent, GST_BUFFER_CAST (l->data));
2532         else
2533           gst_buffer_unref (GST_BUFFER_CAST (l->data));
2534       }
2535       g_list_free (parse->priv->detect_buffers);
2536       parse->priv->detect_buffers = NULL;
2537       parse->priv->detect_buffers_size = 0;
2538
2539       if (ret != GST_FLOW_OK) {
2540         return ret;
2541       }
2542
2543       /* Handle the current buffer */
2544     } else if (ret == GST_FLOW_NOT_NEGOTIATED) {
2545       /* Still detecting, append buffer or error out if draining */
2546
2547       if (parse->priv->drain) {
2548         GST_DEBUG_OBJECT (parse, "Draining but did not detect format yet");
2549         return GST_FLOW_ERROR;
2550       } else if (parse->priv->flushing) {
2551         g_list_foreach (parse->priv->detect_buffers, (GFunc) gst_buffer_unref,
2552             NULL);
2553         g_list_free (parse->priv->detect_buffers);
2554         parse->priv->detect_buffers = NULL;
2555         parse->priv->detect_buffers_size = 0;
2556       } else {
2557         parse->priv->detect_buffers =
2558             g_list_append (parse->priv->detect_buffers, buffer);
2559         parse->priv->detect_buffers_size += gst_buffer_get_size (buffer);
2560         return GST_FLOW_OK;
2561       }
2562     } else {
2563       /* Something went wrong, subclass responsible for error reporting */
2564       return ret;
2565     }
2566
2567     /* And now handle the current buffer if detection worked */
2568   }
2569
2570   if (G_LIKELY (buffer)) {
2571     GST_LOG_OBJECT (parse,
2572         "buffer size: %" G_GSIZE_FORMAT ", offset = %" G_GINT64_FORMAT,
2573         gst_buffer_get_size (buffer), GST_BUFFER_OFFSET (buffer));
2574     if (G_UNLIKELY (parse->priv->passthrough)) {
2575       GstBaseParseFrame frame;
2576
2577       gst_base_parse_frame_init (&frame);
2578       frame.buffer = gst_buffer_make_writable (buffer);
2579       ret = gst_base_parse_push_frame (parse, &frame);
2580       gst_base_parse_frame_free (&frame);
2581       return ret;
2582     }
2583     /* upstream feeding us in reverse playback;
2584      * finish previous fragment and start new upon DISCONT */
2585     if (parse->segment.rate < 0.0) {
2586       if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))) {
2587         GST_DEBUG_OBJECT (parse, "buffer starts new reverse playback fragment");
2588         ret = gst_base_parse_finish_fragment (parse, TRUE);
2589         gst_base_parse_start_fragment (parse);
2590       }
2591     }
2592     gst_adapter_push (parse->priv->adapter, buffer);
2593   }
2594
2595   /* Parse and push as many frames as possible */
2596   /* Stop either when adapter is empty or we are flushing */
2597   while (!parse->priv->flushing) {
2598     gint flush = 0;
2599
2600     /* note: if subclass indicates MAX fsize,
2601      * this will not likely be available anyway ... */
2602     min_size = MAX (parse->priv->min_frame_size, fsize);
2603     av = gst_adapter_available (parse->priv->adapter);
2604
2605     if (G_UNLIKELY (parse->priv->drain)) {
2606       min_size = av;
2607       GST_DEBUG_OBJECT (parse, "draining, data left: %d", min_size);
2608       if (G_UNLIKELY (!min_size)) {
2609         goto done;
2610       }
2611     }
2612
2613     /* Collect at least min_frame_size bytes */
2614     if (av < min_size) {
2615       GST_DEBUG_OBJECT (parse, "not enough data available (only %d bytes)", av);
2616       goto done;
2617     }
2618
2619     /* move along with upstream timestamp (if any),
2620      * but interpolate in between */
2621     timestamp = gst_adapter_prev_timestamp (parse->priv->adapter, NULL);
2622     if (GST_CLOCK_TIME_IS_VALID (timestamp) &&
2623         (parse->priv->prev_ts != timestamp)) {
2624       parse->priv->prev_ts = parse->priv->next_ts = timestamp;
2625     }
2626
2627     /* always pass all available data */
2628     data = gst_adapter_map (parse->priv->adapter, av);
2629     /* arrange for actual data to be copied if subclass tries to,
2630      * since what is passed is tied to the adapter */
2631     tmpbuf = gst_buffer_new ();
2632     gst_buffer_take_memory (tmpbuf, -1,
2633         gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY |
2634             GST_MEMORY_FLAG_NO_SHARE, (gpointer) data, NULL, av, 0, av));
2635     GST_BUFFER_TIMESTAMP (tmpbuf) = timestamp;
2636
2637     /* keep the adapter mapped, so keep track of what has to be flushed */
2638     ret = gst_base_parse_handle_buffer (parse, tmpbuf, &skip, &flush);
2639     tmpbuf = NULL;
2640
2641     /* probably already implicitly unmapped due to adapter operation,
2642      * but for good measure ... */
2643     gst_adapter_unmap (parse->priv->adapter);
2644     if (ret != GST_FLOW_OK) {
2645       goto done;
2646     }
2647     if (skip == 0 && flush == 0) {
2648       GST_LOG_OBJECT (parse, "nothing skipped and no frames finished, "
2649           "breaking to get more data");
2650       goto done;
2651     }
2652   }
2653
2654 done:
2655   GST_LOG_OBJECT (parse, "chain leaving");
2656   return ret;
2657 }
2658
2659 /* pull @size bytes at current offset,
2660  * i.e. at least try to and possibly return a shorter buffer if near the end */
2661 static GstFlowReturn
2662 gst_base_parse_pull_range (GstBaseParse * parse, guint size,
2663     GstBuffer ** buffer)
2664 {
2665   GstFlowReturn ret = GST_FLOW_OK;
2666
2667   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
2668
2669   /* Caching here actually makes much less difference than one would expect.
2670    * We do it mainly to avoid pulling buffers of 1 byte all the time */
2671   if (parse->priv->cache) {
2672     gint64 cache_offset = GST_BUFFER_OFFSET (parse->priv->cache);
2673     gint cache_size = gst_buffer_get_size (parse->priv->cache);
2674
2675     if (cache_offset <= parse->priv->offset &&
2676         (parse->priv->offset + size) <= (cache_offset + cache_size)) {
2677       *buffer = gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL,
2678           parse->priv->offset - cache_offset, size);
2679       GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
2680       return GST_FLOW_OK;
2681     }
2682     /* not enough data in the cache, free cache and get a new one */
2683     gst_buffer_unref (parse->priv->cache);
2684     parse->priv->cache = NULL;
2685   }
2686
2687   /* refill the cache */
2688   ret =
2689       gst_pad_pull_range (parse->sinkpad, parse->priv->offset, MAX (size,
2690           64 * 1024), &parse->priv->cache);
2691   if (ret != GST_FLOW_OK) {
2692     parse->priv->cache = NULL;
2693     return ret;
2694   }
2695
2696   if (gst_buffer_get_size (parse->priv->cache) >= size) {
2697     *buffer =
2698         gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL, 0,
2699         size);
2700     GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
2701     return GST_FLOW_OK;
2702   }
2703
2704   /* Not possible to get enough data, try a last time with
2705    * requesting exactly the size we need */
2706   gst_buffer_unref (parse->priv->cache);
2707   parse->priv->cache = NULL;
2708
2709   ret = gst_pad_pull_range (parse->sinkpad, parse->priv->offset, size,
2710       &parse->priv->cache);
2711
2712   if (ret != GST_FLOW_OK) {
2713     GST_DEBUG_OBJECT (parse, "pull_range returned %d", ret);
2714     *buffer = NULL;
2715     return ret;
2716   }
2717
2718   if (gst_buffer_get_size (parse->priv->cache) < size) {
2719     GST_DEBUG_OBJECT (parse, "Returning short buffer at offset %"
2720         G_GUINT64_FORMAT ": wanted %u bytes, got %" G_GSIZE_FORMAT " bytes",
2721         parse->priv->offset, size, gst_buffer_get_size (parse->priv->cache));
2722
2723     *buffer = parse->priv->cache;
2724     parse->priv->cache = NULL;
2725
2726     return GST_FLOW_OK;
2727   }
2728
2729   *buffer =
2730       gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL, 0, size);
2731   GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
2732
2733   return GST_FLOW_OK;
2734 }
2735
2736 static GstFlowReturn
2737 gst_base_parse_handle_previous_fragment (GstBaseParse * parse)
2738 {
2739   gint64 offset = 0;
2740   GstClockTime ts = 0;
2741   GstBuffer *buffer;
2742   GstFlowReturn ret;
2743
2744   GST_DEBUG_OBJECT (parse, "fragment ended; last_ts = %" GST_TIME_FORMAT
2745       ", last_offset = %" G_GINT64_FORMAT, GST_TIME_ARGS (parse->priv->last_ts),
2746       parse->priv->last_offset);
2747
2748   if (!parse->priv->last_offset || parse->priv->last_ts <= parse->segment.start) {
2749     GST_DEBUG_OBJECT (parse, "past start of segment %" GST_TIME_FORMAT,
2750         GST_TIME_ARGS (parse->segment.start));
2751     ret = GST_FLOW_EOS;
2752     goto exit;
2753   }
2754
2755   /* last fragment started at last_offset / last_ts;
2756    * seek back 10s capped at 1MB */
2757   if (parse->priv->last_ts >= 10 * GST_SECOND)
2758     ts = parse->priv->last_ts - 10 * GST_SECOND;
2759   /* if we are exact now, we will be more so going backwards */
2760   if (parse->priv->exact_position) {
2761     offset = gst_base_parse_find_offset (parse, ts, TRUE, NULL);
2762   } else {
2763     if (!gst_pad_query_convert (parse->srcpad, GST_FORMAT_TIME, ts,
2764             GST_FORMAT_BYTES, &offset)) {
2765       GST_DEBUG_OBJECT (parse, "conversion failed, only BYTE based");
2766     }
2767   }
2768   offset = CLAMP (offset, parse->priv->last_offset - 1024 * 1024,
2769       parse->priv->last_offset - 1024);
2770   offset = MAX (0, offset);
2771
2772   GST_DEBUG_OBJECT (parse, "next fragment from offset %" G_GINT64_FORMAT,
2773       offset);
2774   parse->priv->offset = offset;
2775
2776   ret = gst_base_parse_pull_range (parse, parse->priv->last_offset - offset,
2777       &buffer);
2778   if (ret != GST_FLOW_OK)
2779     goto exit;
2780
2781   /* offset will increase again as fragment is processed/parsed */
2782   parse->priv->last_offset = offset;
2783
2784   gst_base_parse_start_fragment (parse);
2785   gst_adapter_push (parse->priv->adapter, buffer);
2786   ret = gst_base_parse_finish_fragment (parse, TRUE);
2787   if (ret != GST_FLOW_OK)
2788     goto exit;
2789
2790   /* force previous fragment */
2791   parse->priv->offset = -1;
2792
2793 exit:
2794   return ret;
2795 }
2796
2797 /* PULL mode:
2798  * pull and scan for next frame starting from current offset
2799  * ajusts sync, drain and offset going along */
2800 static GstFlowReturn
2801 gst_base_parse_scan_frame (GstBaseParse * parse, GstBaseParseClass * klass,
2802     gboolean full)
2803 {
2804   GstBuffer *buffer;
2805   GstFlowReturn ret = GST_FLOW_OK;
2806   guint fsize, min_size;
2807   gint flushed = 0;
2808   gint skip = 0;
2809
2810   GST_LOG_OBJECT (parse, "scanning for frame at offset %" G_GUINT64_FORMAT
2811       " (%#" G_GINT64_MODIFIER "x)", parse->priv->offset, parse->priv->offset);
2812
2813   /* let's make this efficient for all subclass once and for all;
2814    * maybe it does not need this much, but in the latter case, we know we are
2815    * in pull mode here and might as well try to read and supply more anyway
2816    * (so does the buffer caching mechanism) */
2817   fsize = 64 * 1024;
2818
2819   while (TRUE) {
2820     min_size = MAX (parse->priv->min_frame_size, fsize);
2821
2822     GST_LOG_OBJECT (parse, "reading buffer size %u", min_size);
2823
2824     ret = gst_base_parse_pull_range (parse, min_size, &buffer);
2825     if (ret != GST_FLOW_OK)
2826       goto done;
2827
2828     /* if we got a short read, inform subclass we are draining leftover
2829      * and no more is to be expected */
2830     if (gst_buffer_get_size (buffer) < min_size) {
2831       GST_LOG_OBJECT (parse, "... but did not get that; marked draining");
2832       parse->priv->drain = TRUE;
2833     }
2834
2835     if (parse->priv->detecting) {
2836       ret = klass->detect (parse, buffer);
2837       if (ret == GST_FLOW_NOT_NEGOTIATED) {
2838         /* If draining we error out, otherwise request a buffer
2839          * with 64kb more */
2840         if (parse->priv->drain) {
2841           gst_buffer_unref (buffer);
2842           GST_ERROR_OBJECT (parse, "Failed to detect format but draining");
2843           return GST_FLOW_ERROR;
2844         } else {
2845           fsize += 64 * 1024;
2846           gst_buffer_unref (buffer);
2847           continue;
2848         }
2849       } else if (ret != GST_FLOW_OK) {
2850         gst_buffer_unref (buffer);
2851         GST_ERROR_OBJECT (parse, "detect() returned %s",
2852             gst_flow_get_name (ret));
2853         return ret;
2854       }
2855
2856       /* Else handle this buffer normally */
2857     }
2858
2859     ret = gst_base_parse_handle_buffer (parse, buffer, &skip, &flushed);
2860     if (ret != GST_FLOW_OK)
2861       break;
2862
2863     /* something flushed means something happened,
2864      * and we should bail out of this loop so as not to occupy
2865      * the task thread indefinitely */
2866     if (flushed) {
2867       GST_LOG_OBJECT (parse, "frame finished, breaking loop");
2868       break;
2869     }
2870     /* nothing flushed, no skip and draining, so nothing left to do */
2871     if (!skip && parse->priv->drain) {
2872       GST_LOG_OBJECT (parse, "no activity or result when draining; "
2873           "breaking loop and marking EOS");
2874       ret = GST_FLOW_EOS;
2875       break;
2876     }
2877     /* otherwise, get some more data
2878      * note that is checked this does not happen indefinitely */
2879     if (!skip) {
2880       GST_LOG_OBJECT (parse, "getting some more data");
2881       fsize += 64 * 1024;
2882     }
2883     parse->priv->drain = FALSE;
2884   }
2885
2886 done:
2887   return ret;
2888 }
2889
2890 /* Loop that is used in pull mode to retrieve data from upstream */
2891 static void
2892 gst_base_parse_loop (GstPad * pad)
2893 {
2894   GstBaseParse *parse;
2895   GstBaseParseClass *klass;
2896   GstFlowReturn ret = GST_FLOW_OK;
2897
2898   parse = GST_BASE_PARSE (gst_pad_get_parent (pad));
2899   klass = GST_BASE_PARSE_GET_CLASS (parse);
2900
2901   /* reverse playback:
2902    * first fragment (closest to stop time) is handled normally below,
2903    * then we pull in fragments going backwards */
2904   if (parse->segment.rate < 0.0) {
2905     /* check if we jumped back to a previous fragment,
2906      * which is a post-first fragment */
2907     if (parse->priv->offset < 0) {
2908       ret = gst_base_parse_handle_previous_fragment (parse);
2909       goto done;
2910     }
2911   }
2912
2913   ret = gst_base_parse_scan_frame (parse, klass, TRUE);
2914   if (ret != GST_FLOW_OK)
2915     goto done;
2916
2917   /* eat expected eos signalling past segment in reverse playback */
2918   if (parse->segment.rate < 0.0 && ret == GST_FLOW_EOS &&
2919       parse->segment.position >= parse->segment.stop) {
2920     GST_DEBUG_OBJECT (parse, "downstream has reached end of segment");
2921     /* push what was accumulated during loop run */
2922     gst_base_parse_finish_fragment (parse, FALSE);
2923     /* force previous fragment */
2924     parse->priv->offset = -1;
2925     ret = GST_FLOW_OK;
2926   }
2927
2928 done:
2929   if (ret == GST_FLOW_EOS)
2930     goto eos;
2931   else if (ret != GST_FLOW_OK)
2932     goto pause;
2933
2934   gst_object_unref (parse);
2935   return;
2936
2937   /* ERRORS */
2938 eos:
2939   {
2940     ret = GST_FLOW_EOS;
2941     GST_DEBUG_OBJECT (parse, "eos");
2942     /* fall-through */
2943   }
2944 pause:
2945   {
2946     gboolean push_eos = FALSE;
2947
2948     GST_DEBUG_OBJECT (parse, "pausing task, reason %s",
2949         gst_flow_get_name (ret));
2950     gst_pad_pause_task (parse->sinkpad);
2951
2952     if (ret == GST_FLOW_EOS) {
2953       /* handle end-of-stream/segment */
2954       if (parse->segment.flags & GST_SEEK_FLAG_SEGMENT) {
2955         gint64 stop;
2956
2957         if ((stop = parse->segment.stop) == -1)
2958           stop = parse->segment.duration;
2959
2960         GST_DEBUG_OBJECT (parse, "sending segment_done");
2961
2962         gst_element_post_message
2963             (GST_ELEMENT_CAST (parse),
2964             gst_message_new_segment_done (GST_OBJECT_CAST (parse),
2965                 GST_FORMAT_TIME, stop));
2966       } else {
2967         /* If we STILL have zero frames processed, fire an error */
2968         if (parse->priv->framecount == 0) {
2969           GST_ELEMENT_ERROR (parse, STREAM, WRONG_TYPE,
2970               ("No valid frames found before end of stream"), (NULL));
2971         }
2972         push_eos = TRUE;
2973       }
2974     } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
2975       /* for fatal errors we post an error message, wrong-state is
2976        * not fatal because it happens due to flushes and only means
2977        * that we should stop now. */
2978       GST_ELEMENT_ERROR (parse, STREAM, FAILED, (NULL),
2979           ("streaming stopped, reason %s", gst_flow_get_name (ret)));
2980       push_eos = TRUE;
2981     }
2982     if (push_eos) {
2983       /* newsegment before eos */
2984       if (parse->priv->pending_segment) {
2985         gst_pad_push_event (parse->srcpad, parse->priv->pending_segment);
2986         parse->priv->pending_segment = NULL;
2987       }
2988       gst_pad_push_event (parse->srcpad, gst_event_new_eos ());
2989     }
2990     gst_object_unref (parse);
2991   }
2992 }
2993
2994 static gboolean
2995 gst_base_parse_sink_activate (GstPad * sinkpad, GstObject * parent)
2996 {
2997   GstBaseParse *parse;
2998   gboolean result = TRUE;
2999   GstQuery *query;
3000   gboolean pull_mode;
3001
3002   parse = GST_BASE_PARSE (parent);
3003
3004   GST_DEBUG_OBJECT (parse, "sink activate");
3005
3006   query = gst_query_new_scheduling ();
3007   result = gst_pad_peer_query (sinkpad, query);
3008   if (result) {
3009     pull_mode = gst_query_has_scheduling_mode (query, GST_PAD_MODE_PULL);
3010   } else {
3011     pull_mode = FALSE;
3012   }
3013   gst_query_unref (query);
3014
3015   if (pull_mode) {
3016     GST_DEBUG_OBJECT (parse, "trying to activate in pull mode");
3017     result = gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
3018   } else {
3019     GST_DEBUG_OBJECT (parse, "trying to activate in push mode");
3020     result = gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
3021   }
3022
3023   GST_DEBUG_OBJECT (parse, "sink activate return %d", result);
3024   return result;
3025 }
3026
3027 static gboolean
3028 gst_base_parse_activate (GstBaseParse * parse, gboolean active)
3029 {
3030   GstBaseParseClass *klass;
3031   gboolean result = TRUE;
3032
3033   GST_DEBUG_OBJECT (parse, "activate %d", active);
3034
3035   klass = GST_BASE_PARSE_GET_CLASS (parse);
3036
3037   if (active) {
3038     if (parse->priv->pad_mode == GST_PAD_MODE_NONE && klass->start)
3039       result = klass->start (parse);
3040
3041     /* If the subclass implements ::detect we want to
3042      * call it for the first buffers now */
3043     parse->priv->detecting = (klass->detect != NULL);
3044   } else {
3045     /* We must make sure streaming has finished before resetting things
3046      * and calling the ::stop vfunc */
3047     GST_PAD_STREAM_LOCK (parse->sinkpad);
3048     GST_PAD_STREAM_UNLOCK (parse->sinkpad);
3049
3050     if (parse->priv->pad_mode != GST_PAD_MODE_NONE && klass->stop)
3051       result = klass->stop (parse);
3052
3053     parse->priv->pad_mode = GST_PAD_MODE_NONE;
3054   }
3055   GST_DEBUG_OBJECT (parse, "activate return: %d", result);
3056   return result;
3057 }
3058
3059 static gboolean
3060 gst_base_parse_sink_activate_mode (GstPad * pad, GstObject * parent,
3061     GstPadMode mode, gboolean active)
3062 {
3063   gboolean result = TRUE;
3064   GstBaseParse *parse;
3065
3066   parse = GST_BASE_PARSE (parent);
3067
3068   GST_DEBUG_OBJECT (parse, "sink activate mode %d, %d", mode, active);
3069
3070   result = gst_base_parse_activate (parse, active);
3071
3072   if (result) {
3073     switch (mode) {
3074       case GST_PAD_MODE_PULL:
3075         if (active) {
3076           parse->priv->pending_segment =
3077               gst_event_new_segment (&parse->segment);
3078           result &=
3079               gst_pad_start_task (pad, (GstTaskFunction) gst_base_parse_loop,
3080               pad);
3081         } else {
3082           result &= gst_pad_stop_task (pad);
3083         }
3084         break;
3085       default:
3086         break;
3087     }
3088   }
3089   if (result)
3090     parse->priv->pad_mode = active ? mode : GST_PAD_MODE_NONE;
3091
3092   GST_DEBUG_OBJECT (parse, "sink activate return: %d", result);
3093
3094   return result;
3095 }
3096
3097 /**
3098  * gst_base_parse_set_duration:
3099  * @parse: #GstBaseParse.
3100  * @fmt: #GstFormat.
3101  * @duration: duration value.
3102  * @interval: how often to update the duration estimate based on bitrate, or 0.
3103  *
3104  * Sets the duration of the currently playing media. Subclass can use this
3105  * when it is able to determine duration and/or notices a change in the media
3106  * duration.  Alternatively, if @interval is non-zero (default), then stream
3107  * duration is determined based on estimated bitrate, and updated every @interval
3108  * frames.
3109  *
3110  * Since: 0.10.33
3111  */
3112 void
3113 gst_base_parse_set_duration (GstBaseParse * parse,
3114     GstFormat fmt, gint64 duration, gint interval)
3115 {
3116   g_return_if_fail (parse != NULL);
3117
3118   if (parse->priv->upstream_has_duration) {
3119     GST_DEBUG_OBJECT (parse, "using upstream duration; discarding update");
3120     goto exit;
3121   }
3122
3123   if (duration != parse->priv->duration) {
3124     GstMessage *m;
3125
3126     m = gst_message_new_duration (GST_OBJECT (parse), fmt, duration);
3127     gst_element_post_message (GST_ELEMENT (parse), m);
3128
3129     /* TODO: what about duration tag? */
3130   }
3131   parse->priv->duration = duration;
3132   parse->priv->duration_fmt = fmt;
3133   GST_DEBUG_OBJECT (parse, "set duration: %" G_GINT64_FORMAT, duration);
3134   if (fmt == GST_FORMAT_TIME && GST_CLOCK_TIME_IS_VALID (duration)) {
3135     if (interval != 0) {
3136       GST_DEBUG_OBJECT (parse, "valid duration provided, disabling estimate");
3137       interval = 0;
3138     }
3139   }
3140   GST_DEBUG_OBJECT (parse, "set update interval: %d", interval);
3141   parse->priv->update_interval = interval;
3142 exit:
3143   return;
3144 }
3145
3146 /**
3147  * gst_base_parse_set_average_bitrate:
3148  * @parse: #GstBaseParse.
3149  * @bitrate: average bitrate in bits/second
3150  *
3151  * Optionally sets the average bitrate detected in media (if non-zero),
3152  * e.g. based on metadata, as it will be posted to the application.
3153  *
3154  * By default, announced average bitrate is estimated. The average bitrate
3155  * is used to estimate the total duration of the stream and to estimate
3156  * a seek position, if there's no index and the format is syncable
3157  * (see gst_base_parse_set_syncable()).
3158  *
3159  * Since: 0.10.33
3160  */
3161 void
3162 gst_base_parse_set_average_bitrate (GstBaseParse * parse, guint bitrate)
3163 {
3164   parse->priv->bitrate = bitrate;
3165   GST_DEBUG_OBJECT (parse, "bitrate %u", bitrate);
3166 }
3167
3168 /**
3169  * gst_base_parse_set_min_frame_size:
3170  * @parse: #GstBaseParse.
3171  * @min_size: Minimum size of the data that this base class should give to
3172  *            subclass.
3173  *
3174  * Subclass can use this function to tell the base class that it needs to
3175  * give at least #min_size buffers.
3176  *
3177  * Since: 0.10.33
3178  */
3179 void
3180 gst_base_parse_set_min_frame_size (GstBaseParse * parse, guint min_size)
3181 {
3182   g_return_if_fail (parse != NULL);
3183
3184   parse->priv->min_frame_size = min_size;
3185   GST_LOG_OBJECT (parse, "set frame_min_size: %d", min_size);
3186 }
3187
3188 /**
3189  * gst_base_parse_set_frame_rate:
3190  * @parse: the #GstBaseParse to set
3191  * @fps_num: frames per second (numerator).
3192  * @fps_den: frames per second (denominator).
3193  * @lead_in: frames needed before a segment for subsequent decode
3194  * @lead_out: frames needed after a segment
3195  *
3196  * If frames per second is configured, parser can take care of buffer duration
3197  * and timestamping.  When performing segment clipping, or seeking to a specific
3198  * location, a corresponding decoder might need an initial @lead_in and a
3199  * following @lead_out number of frames to ensure the desired segment is
3200  * entirely filled upon decoding.
3201  *
3202  * Since: 0.10.33
3203  */
3204 void
3205 gst_base_parse_set_frame_rate (GstBaseParse * parse, guint fps_num,
3206     guint fps_den, guint lead_in, guint lead_out)
3207 {
3208   g_return_if_fail (parse != NULL);
3209
3210   parse->priv->fps_num = fps_num;
3211   parse->priv->fps_den = fps_den;
3212   if (!fps_num || !fps_den) {
3213     GST_DEBUG_OBJECT (parse, "invalid fps (%d/%d), ignoring parameters",
3214         fps_num, fps_den);
3215     fps_num = fps_den = 0;
3216     parse->priv->frame_duration = GST_CLOCK_TIME_NONE;
3217     parse->priv->lead_in = parse->priv->lead_out = 0;
3218     parse->priv->lead_in_ts = parse->priv->lead_out_ts = 0;
3219   } else {
3220     parse->priv->frame_duration =
3221         gst_util_uint64_scale (GST_SECOND, fps_den, fps_num);
3222     parse->priv->lead_in = lead_in;
3223     parse->priv->lead_out = lead_out;
3224     parse->priv->lead_in_ts =
3225         gst_util_uint64_scale (GST_SECOND, fps_den * lead_in, fps_num);
3226     parse->priv->lead_out_ts =
3227         gst_util_uint64_scale (GST_SECOND, fps_den * lead_out, fps_num);
3228     /* aim for about 1.5s to estimate duration */
3229     if (parse->priv->update_interval < 0) {
3230       parse->priv->update_interval = fps_num * 3 / (fps_den * 2);
3231       GST_LOG_OBJECT (parse, "estimated update interval to %d frames",
3232           parse->priv->update_interval);
3233     }
3234   }
3235   GST_LOG_OBJECT (parse, "set fps: %d/%d => duration: %" G_GINT64_FORMAT " ms",
3236       fps_num, fps_den, parse->priv->frame_duration / GST_MSECOND);
3237   GST_LOG_OBJECT (parse, "set lead in: %d frames = %" G_GUINT64_FORMAT " ms, "
3238       "lead out: %d frames = %" G_GUINT64_FORMAT " ms",
3239       lead_in, parse->priv->lead_in_ts / GST_MSECOND,
3240       lead_out, parse->priv->lead_out_ts / GST_MSECOND);
3241 }
3242
3243 /**
3244  * gst_base_parse_set_has_timing_info:
3245  * @parse: a #GstBaseParse
3246  * @has_timing: whether frames carry timing information
3247  *
3248  * Set if frames carry timing information which the subclass can (generally)
3249  * parse and provide.  In particular, intrinsic (rather than estimated) time
3250  * can be obtained following a seek.
3251  *
3252  * Since: 0.10.33
3253  */
3254 void
3255 gst_base_parse_set_has_timing_info (GstBaseParse * parse, gboolean has_timing)
3256 {
3257   parse->priv->has_timing_info = has_timing;
3258   GST_INFO_OBJECT (parse, "has_timing: %s", (has_timing) ? "yes" : "no");
3259 }
3260
3261 /**
3262  * gst_base_parse_set_syncable:
3263  * @parse: a #GstBaseParse
3264  * @syncable: set if frame starts can be identified
3265  *
3266  * Set if frame starts can be identified. This is set by default and
3267  * determines whether seeking based on bitrate averages
3268  * is possible for a format/stream.
3269  *
3270  * Since: 0.10.33
3271  */
3272 void
3273 gst_base_parse_set_syncable (GstBaseParse * parse, gboolean syncable)
3274 {
3275   parse->priv->syncable = syncable;
3276   GST_INFO_OBJECT (parse, "syncable: %s", (syncable) ? "yes" : "no");
3277 }
3278
3279 /**
3280  * gst_base_parse_set_passthrough:
3281  * @parse: a #GstBaseParse
3282  * @passthrough: %TRUE if parser should run in passthrough mode
3283  *
3284  * Set if the nature of the format or configuration does not allow (much)
3285  * parsing, and the parser should operate in passthrough mode (which only
3286  * applies when operating in push mode). That is, incoming buffers are
3287  * pushed through unmodified, i.e. no @check_valid_frame or @parse_frame
3288  * callbacks will be invoked, but @pre_push_frame will still be invoked,
3289  * so subclass can perform as much or as little is appropriate for
3290  * passthrough semantics in @pre_push_frame.
3291  *
3292  * Since: 0.10.33
3293  */
3294 void
3295 gst_base_parse_set_passthrough (GstBaseParse * parse, gboolean passthrough)
3296 {
3297   parse->priv->passthrough = passthrough;
3298   GST_INFO_OBJECT (parse, "passthrough: %s", (passthrough) ? "yes" : "no");
3299 }
3300
3301 /**
3302  * gst_base_parse_set_latency:
3303  * @parse: a #GstBaseParse
3304  * @min_latency: minimum parse latency
3305  * @max_latency: maximum parse latency
3306  *
3307  * Sets the minimum and maximum (which may likely be equal) latency introduced
3308  * by the parsing process.  If there is such a latency, which depends on the
3309  * particular parsing of the format, it typically corresponds to 1 frame duration.
3310  *
3311  * Since: 0.10.36
3312  */
3313 void
3314 gst_base_parse_set_latency (GstBaseParse * parse, GstClockTime min_latency,
3315     GstClockTime max_latency)
3316 {
3317   GST_OBJECT_LOCK (parse);
3318   parse->priv->min_latency = min_latency;
3319   parse->priv->max_latency = max_latency;
3320   GST_OBJECT_UNLOCK (parse);
3321   GST_INFO_OBJECT (parse, "min/max latency %" GST_TIME_FORMAT ", %"
3322       GST_TIME_FORMAT, GST_TIME_ARGS (min_latency),
3323       GST_TIME_ARGS (max_latency));
3324 }
3325
3326 static gboolean
3327 gst_base_parse_get_duration (GstBaseParse * parse, GstFormat format,
3328     GstClockTime * duration)
3329 {
3330   gboolean res = FALSE;
3331
3332   g_return_val_if_fail (duration != NULL, FALSE);
3333
3334   *duration = GST_CLOCK_TIME_NONE;
3335   if (parse->priv->duration != -1 && format == parse->priv->duration_fmt) {
3336     GST_LOG_OBJECT (parse, "using provided duration");
3337     *duration = parse->priv->duration;
3338     res = TRUE;
3339   } else if (parse->priv->duration != -1) {
3340     GST_LOG_OBJECT (parse, "converting provided duration");
3341     res = gst_base_parse_convert (parse, parse->priv->duration_fmt,
3342         parse->priv->duration, format, (gint64 *) duration);
3343   } else if (format == GST_FORMAT_TIME && parse->priv->estimated_duration != -1) {
3344     GST_LOG_OBJECT (parse, "using estimated duration");
3345     *duration = parse->priv->estimated_duration;
3346     res = TRUE;
3347   }
3348
3349   GST_LOG_OBJECT (parse, "res: %d, duration %" GST_TIME_FORMAT, res,
3350       GST_TIME_ARGS (*duration));
3351   return res;
3352 }
3353
3354 static gboolean
3355 gst_base_parse_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
3356 {
3357   GstBaseParse *parse;
3358   gboolean res = FALSE;
3359
3360   parse = GST_BASE_PARSE (parent);
3361
3362   GST_LOG_OBJECT (parse, "handling query: %" GST_PTR_FORMAT, query);
3363
3364   switch (GST_QUERY_TYPE (query)) {
3365     case GST_QUERY_POSITION:
3366     {
3367       gint64 dest_value;
3368       GstFormat format;
3369
3370       GST_DEBUG_OBJECT (parse, "position query");
3371       gst_query_parse_position (query, &format, NULL);
3372
3373       /* try upstream first */
3374       res = gst_pad_query_default (pad, parent, query);
3375       if (!res) {
3376         /* Fall back on interpreting segment */
3377         GST_OBJECT_LOCK (parse);
3378         if (format == GST_FORMAT_BYTES) {
3379           dest_value = parse->priv->offset;
3380           res = TRUE;
3381         } else if (format == parse->segment.format &&
3382             GST_CLOCK_TIME_IS_VALID (parse->segment.position)) {
3383           dest_value = gst_segment_to_stream_time (&parse->segment,
3384               parse->segment.format, parse->segment.position);
3385           res = TRUE;
3386         }
3387         GST_OBJECT_UNLOCK (parse);
3388         if (!res) {
3389           /* no precise result, upstream no idea either, then best estimate */
3390           /* priv->offset is updated in both PUSH/PULL modes */
3391           res = gst_base_parse_convert (parse,
3392               GST_FORMAT_BYTES, parse->priv->offset, format, &dest_value);
3393         }
3394         if (res)
3395           gst_query_set_position (query, format, dest_value);
3396       }
3397       break;
3398     }
3399     case GST_QUERY_DURATION:
3400     {
3401       GstFormat format;
3402       GstClockTime duration;
3403
3404       GST_DEBUG_OBJECT (parse, "duration query");
3405       gst_query_parse_duration (query, &format, NULL);
3406
3407       /* consult upstream */
3408       res = gst_pad_query_default (pad, parent, query);
3409
3410       /* otherwise best estimate from us */
3411       if (!res) {
3412         res = gst_base_parse_get_duration (parse, format, &duration);
3413         if (res)
3414           gst_query_set_duration (query, format, duration);
3415       }
3416       break;
3417     }
3418     case GST_QUERY_SEEKING:
3419     {
3420       GstFormat fmt;
3421       GstClockTime duration = GST_CLOCK_TIME_NONE;
3422       gboolean seekable = FALSE;
3423
3424       GST_DEBUG_OBJECT (parse, "seeking query");
3425       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
3426
3427       /* consult upstream */
3428       res = gst_pad_query_default (pad, parent, query);
3429
3430       /* we may be able to help if in TIME */
3431       if (fmt == GST_FORMAT_TIME && gst_base_parse_is_seekable (parse)) {
3432         gst_query_parse_seeking (query, &fmt, &seekable, NULL, NULL);
3433         /* already OK if upstream takes care */
3434         GST_LOG_OBJECT (parse, "upstream handled %d, seekable %d",
3435             res, seekable);
3436         if (!(res && seekable)) {
3437           if (!gst_base_parse_get_duration (parse, GST_FORMAT_TIME, &duration)
3438               || duration == -1) {
3439             /* seekable if we still have a chance to get duration later on */
3440             seekable =
3441                 parse->priv->upstream_seekable && parse->priv->update_interval;
3442           } else {
3443             seekable = parse->priv->upstream_seekable;
3444             GST_LOG_OBJECT (parse, "already determine upstream seekabled: %d",
3445                 seekable);
3446           }
3447           gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0, duration);
3448           res = TRUE;
3449         }
3450       }
3451       break;
3452     }
3453     case GST_QUERY_FORMATS:
3454       gst_query_set_formatsv (query, 3, fmtlist);
3455       res = TRUE;
3456       break;
3457     case GST_QUERY_CONVERT:
3458     {
3459       GstFormat src_format, dest_format;
3460       gint64 src_value, dest_value;
3461
3462       gst_query_parse_convert (query, &src_format, &src_value,
3463           &dest_format, &dest_value);
3464
3465       res = gst_base_parse_convert (parse, src_format, src_value,
3466           dest_format, &dest_value);
3467       if (res) {
3468         gst_query_set_convert (query, src_format, src_value,
3469             dest_format, dest_value);
3470       }
3471       break;
3472     }
3473     case GST_QUERY_LATENCY:
3474     {
3475       if ((res = gst_pad_peer_query (parse->sinkpad, query))) {
3476         gboolean live;
3477         GstClockTime min_latency, max_latency;
3478
3479         gst_query_parse_latency (query, &live, &min_latency, &max_latency);
3480         GST_DEBUG_OBJECT (parse, "Peer latency: live %d, min %"
3481             GST_TIME_FORMAT " max %" GST_TIME_FORMAT, live,
3482             GST_TIME_ARGS (min_latency), GST_TIME_ARGS (max_latency));
3483
3484         GST_OBJECT_LOCK (parse);
3485         /* add our latency */
3486         if (min_latency != -1)
3487           min_latency += parse->priv->min_latency;
3488         if (max_latency != -1)
3489           max_latency += parse->priv->max_latency;
3490         GST_OBJECT_UNLOCK (parse);
3491
3492         gst_query_set_latency (query, live, min_latency, max_latency);
3493       }
3494       break;
3495     }
3496     default:
3497       res = gst_pad_query_default (pad, parent, query);
3498       break;
3499   }
3500   return res;
3501 }
3502
3503 /* scans for a cluster start from @pos,
3504  * return GST_FLOW_OK and frame position/time in @pos/@time if found */
3505 static GstFlowReturn
3506 gst_base_parse_find_frame (GstBaseParse * parse, gint64 * pos,
3507     GstClockTime * time, GstClockTime * duration)
3508 {
3509   GstBaseParseClass *klass;
3510   gint64 orig_offset;
3511   gboolean orig_drain, orig_discont;
3512   GstFlowReturn ret = GST_FLOW_OK;
3513   GstBuffer *buf = NULL;
3514   GstBaseParseFrame *sframe = NULL;
3515
3516   g_return_val_if_fail (pos != NULL, GST_FLOW_ERROR);
3517   g_return_val_if_fail (time != NULL, GST_FLOW_ERROR);
3518   g_return_val_if_fail (duration != NULL, GST_FLOW_ERROR);
3519
3520   klass = GST_BASE_PARSE_GET_CLASS (parse);
3521
3522   *time = GST_CLOCK_TIME_NONE;
3523   *duration = GST_CLOCK_TIME_NONE;
3524
3525   /* save state */
3526   orig_offset = parse->priv->offset;
3527   orig_discont = parse->priv->discont;
3528   orig_drain = parse->priv->drain;
3529
3530   GST_DEBUG_OBJECT (parse, "scanning for frame starting at %" G_GINT64_FORMAT
3531       " (%#" G_GINT64_MODIFIER "x)", *pos, *pos);
3532
3533   /* jump elsewhere and locate next frame */
3534   parse->priv->offset = *pos;
3535   /* mark as scanning so frames don't get processed all the way */
3536   parse->priv->scanning = TRUE;
3537   ret = gst_base_parse_scan_frame (parse, klass, FALSE);
3538   parse->priv->scanning = FALSE;
3539   /* retrieve frame found during scan */
3540   sframe = parse->priv->scanned_frame;
3541   parse->priv->scanned_frame = NULL;
3542
3543   if (ret != GST_FLOW_OK || !sframe)
3544     goto done;
3545
3546   /* get offset first, subclass parsing might dump other stuff in there */
3547   *pos = sframe->offset;
3548   buf = sframe->buffer;
3549   g_assert (buf);
3550
3551   /* but it should provide proper time */
3552   *time = GST_BUFFER_TIMESTAMP (buf);
3553   *duration = GST_BUFFER_DURATION (buf);
3554
3555   GST_LOG_OBJECT (parse,
3556       "frame with time %" GST_TIME_FORMAT " at offset %" G_GINT64_FORMAT,
3557       GST_TIME_ARGS (*time), *pos);
3558
3559 done:
3560   if (sframe)
3561     gst_base_parse_frame_free (sframe);
3562
3563   /* restore state */
3564   parse->priv->offset = orig_offset;
3565   parse->priv->discont = orig_discont;
3566   parse->priv->drain = orig_drain;
3567
3568   return ret;
3569 }
3570
3571 /* bisect and scan through file for frame starting before @time,
3572  * returns OK and @time/@offset if found, NONE and/or error otherwise
3573  * If @time == G_MAXINT64, scan for duration ( == last frame) */
3574 static GstFlowReturn
3575 gst_base_parse_locate_time (GstBaseParse * parse, GstClockTime * _time,
3576     gint64 * _offset)
3577 {
3578   GstFlowReturn ret = GST_FLOW_OK;
3579   gint64 lpos, hpos, newpos;
3580   GstClockTime time, ltime, htime, newtime, dur;
3581   gboolean cont = TRUE;
3582   const GstClockTime tolerance = TARGET_DIFFERENCE;
3583   const guint chunk = 4 * 1024;
3584
3585   g_return_val_if_fail (_time != NULL, GST_FLOW_ERROR);
3586   g_return_val_if_fail (_offset != NULL, GST_FLOW_ERROR);
3587
3588   GST_DEBUG_OBJECT (parse, "Bisecting for time %" GST_TIME_FORMAT,
3589       GST_TIME_ARGS (*_time));
3590
3591   /* TODO also make keyframe aware if useful some day */
3592
3593   time = *_time;
3594
3595   /* basic cases */
3596   if (time == 0) {
3597     *_offset = 0;
3598     return GST_FLOW_OK;
3599   }
3600
3601   if (time == -1) {
3602     *_offset = -1;
3603     return GST_FLOW_OK;
3604   }
3605
3606   /* do not know at first */
3607   *_offset = -1;
3608   *_time = GST_CLOCK_TIME_NONE;
3609
3610   /* need initial positions; start and end */
3611   lpos = parse->priv->first_frame_offset;
3612   ltime = parse->priv->first_frame_ts;
3613   if (!gst_base_parse_get_duration (parse, GST_FORMAT_TIME, &htime)) {
3614     GST_DEBUG_OBJECT (parse, "Unknown time duration, cannot bisect");
3615     return GST_FLOW_ERROR;
3616   }
3617   hpos = parse->priv->upstream_size;
3618
3619   GST_DEBUG_OBJECT (parse,
3620       "Bisection initial bounds: bytes %" G_GINT64_FORMAT " %" G_GINT64_FORMAT
3621       ", times %" GST_TIME_FORMAT " %" GST_TIME_FORMAT, lpos, htime,
3622       GST_TIME_ARGS (ltime), GST_TIME_ARGS (htime));
3623
3624   /* check preconditions are satisfied;
3625    * start and end are needed, except for special case where we scan for
3626    * last frame to determine duration */
3627   if (parse->priv->pad_mode != GST_PAD_MODE_PULL || !hpos ||
3628       !GST_CLOCK_TIME_IS_VALID (ltime) ||
3629       (!GST_CLOCK_TIME_IS_VALID (htime) && time != G_MAXINT64)) {
3630     return GST_FLOW_OK;
3631   }
3632
3633   /* shortcut cases */
3634   if (time < ltime) {
3635     goto exit;
3636   } else if (time < ltime + tolerance) {
3637     *_offset = lpos;
3638     *_time = ltime;
3639     goto exit;
3640   } else if (time >= htime) {
3641     *_offset = hpos;
3642     *_time = htime;
3643     goto exit;
3644   }
3645
3646   while (htime > ltime && cont) {
3647     GST_LOG_OBJECT (parse,
3648         "lpos: %" G_GUINT64_FORMAT ", ltime: %" GST_TIME_FORMAT, lpos,
3649         GST_TIME_ARGS (ltime));
3650     GST_LOG_OBJECT (parse,
3651         "hpos: %" G_GUINT64_FORMAT ", htime: %" GST_TIME_FORMAT, hpos,
3652         GST_TIME_ARGS (htime));
3653     if (G_UNLIKELY (time == G_MAXINT64)) {
3654       newpos = hpos;
3655     } else if (G_LIKELY (hpos > lpos)) {
3656       newpos =
3657           gst_util_uint64_scale (hpos - lpos, time - ltime, htime - ltime) +
3658           lpos - chunk;
3659     } else {
3660       /* should mean lpos == hpos, since lpos <= hpos is invariant */
3661       newpos = lpos;
3662       /* we check this case once, but not forever, so break loop */
3663       cont = FALSE;
3664     }
3665
3666     /* ensure */
3667     newpos = CLAMP (newpos, lpos, hpos);
3668     GST_LOG_OBJECT (parse,
3669         "estimated _offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT,
3670         GST_TIME_ARGS (time), newpos);
3671
3672     ret = gst_base_parse_find_frame (parse, &newpos, &newtime, &dur);
3673     if (ret == GST_FLOW_EOS) {
3674       /* heuristic HACK */
3675       hpos = MAX (lpos, hpos - chunk);
3676       continue;
3677     } else if (ret != GST_FLOW_OK) {
3678       goto exit;
3679     }
3680
3681     if (newtime == -1 || newpos == -1) {
3682       GST_DEBUG_OBJECT (parse, "subclass did not provide metadata; aborting");
3683       break;
3684     }
3685
3686     if (G_UNLIKELY (time == G_MAXINT64)) {
3687       *_offset = newpos;
3688       *_time = newtime;
3689       if (GST_CLOCK_TIME_IS_VALID (dur))
3690         *_time += dur;
3691       break;
3692     } else if (newtime > time) {
3693       /* overshoot */
3694       hpos = (newpos >= hpos) ? MAX (lpos, hpos - chunk) : MAX (lpos, newpos);
3695       htime = newtime;
3696     } else if (newtime + tolerance > time) {
3697       /* close enough undershoot */
3698       *_offset = newpos;
3699       *_time = newtime;
3700       break;
3701     } else if (newtime < ltime) {
3702       /* so a position beyond lpos resulted in earlier time than ltime ... */
3703       GST_DEBUG_OBJECT (parse, "non-ascending time; aborting");
3704       break;
3705     } else {
3706       /* undershoot too far */
3707       newpos += newpos == lpos ? chunk : 0;
3708       lpos = CLAMP (newpos, lpos, hpos);
3709       ltime = newtime;
3710     }
3711   }
3712
3713 exit:
3714   GST_LOG_OBJECT (parse, "return offset %" G_GINT64_FORMAT ", time %"
3715       GST_TIME_FORMAT, *_offset, GST_TIME_ARGS (*_time));
3716   return ret;
3717 }
3718
3719 static gint64
3720 gst_base_parse_find_offset (GstBaseParse * parse, GstClockTime time,
3721     gboolean before, GstClockTime * _ts)
3722 {
3723   gint64 bytes = 0, ts = 0;
3724   GstIndexEntry *entry = NULL;
3725
3726   if (time == GST_CLOCK_TIME_NONE) {
3727     ts = time;
3728     bytes = -1;
3729     goto exit;
3730   }
3731
3732   GST_BASE_PARSE_INDEX_LOCK (parse);
3733   if (parse->priv->index) {
3734     /* Let's check if we have an index entry for that time */
3735     entry = gst_index_get_assoc_entry (parse->priv->index,
3736         parse->priv->index_id,
3737         before ? GST_INDEX_LOOKUP_BEFORE : GST_INDEX_LOOKUP_AFTER,
3738         GST_INDEX_ASSOCIATION_FLAG_KEY_UNIT, GST_FORMAT_TIME, time);
3739   }
3740
3741   if (entry) {
3742     gst_index_entry_assoc_map (entry, GST_FORMAT_BYTES, &bytes);
3743     gst_index_entry_assoc_map (entry, GST_FORMAT_TIME, &ts);
3744
3745     GST_DEBUG_OBJECT (parse, "found index entry for %" GST_TIME_FORMAT
3746         " at %" GST_TIME_FORMAT ", offset %" G_GINT64_FORMAT,
3747         GST_TIME_ARGS (time), GST_TIME_ARGS (ts), bytes);
3748   } else {
3749     GST_DEBUG_OBJECT (parse, "no index entry found for %" GST_TIME_FORMAT,
3750         GST_TIME_ARGS (time));
3751     if (!before) {
3752       bytes = -1;
3753       ts = GST_CLOCK_TIME_NONE;
3754     }
3755   }
3756   GST_BASE_PARSE_INDEX_UNLOCK (parse);
3757
3758 exit:
3759   if (_ts)
3760     *_ts = ts;
3761
3762   return bytes;
3763 }
3764
3765 /* returns TRUE if seek succeeded */
3766 static gboolean
3767 gst_base_parse_handle_seek (GstBaseParse * parse, GstEvent * event)
3768 {
3769   gdouble rate;
3770   GstFormat format;
3771   GstSeekFlags flags;
3772   GstSeekType cur_type = GST_SEEK_TYPE_NONE, stop_type;
3773   gboolean flush, update, res = TRUE, accurate;
3774   gint64 cur, stop, seekpos, seekstop;
3775   GstSegment seeksegment = { 0, };
3776   GstClockTime start_ts;
3777
3778   gst_event_parse_seek (event, &rate, &format, &flags,
3779       &cur_type, &cur, &stop_type, &stop);
3780
3781   GST_DEBUG_OBJECT (parse, "seek to format %s, rate %f, "
3782       "start type %d at %" GST_TIME_FORMAT ", end type %d at %"
3783       GST_TIME_FORMAT, gst_format_get_name (format), rate,
3784       cur_type, GST_TIME_ARGS (cur), stop_type, GST_TIME_ARGS (stop));
3785
3786   /* no negative rates in push mode */
3787   if (rate < 0.0 && parse->priv->pad_mode == GST_PAD_MODE_PUSH)
3788     goto negative_rate;
3789
3790   if (cur_type != GST_SEEK_TYPE_SET ||
3791       (stop_type != GST_SEEK_TYPE_SET && stop_type != GST_SEEK_TYPE_NONE))
3792     goto wrong_type;
3793
3794   /* For any format other than TIME, see if upstream handles
3795    * it directly or fail. For TIME, try upstream, but do it ourselves if
3796    * it fails upstream */
3797   if (format != GST_FORMAT_TIME) {
3798     /* default action delegates to upstream */
3799     res = FALSE;
3800     goto done;
3801   } else {
3802     gst_event_ref (event);
3803     if ((res = gst_pad_push_event (parse->sinkpad, event))) {
3804       goto done;
3805     }
3806   }
3807
3808   /* get flush flag */
3809   flush = flags & GST_SEEK_FLAG_FLUSH;
3810
3811   /* copy segment, we need this because we still need the old
3812    * segment when we close the current segment. */
3813   gst_segment_copy_into (&parse->segment, &seeksegment);
3814
3815   GST_DEBUG_OBJECT (parse, "configuring seek");
3816   gst_segment_do_seek (&seeksegment, rate, format, flags,
3817       cur_type, cur, stop_type, stop, &update);
3818
3819   /* accurate seeking implies seek tables are used to obtain position,
3820    * and the requested segment is maintained exactly, not adjusted any way */
3821   accurate = flags & GST_SEEK_FLAG_ACCURATE;
3822
3823   /* maybe we can be accurate for (almost) free */
3824   gst_base_parse_find_offset (parse, seeksegment.position, TRUE, &start_ts);
3825   if (seeksegment.position <= start_ts + TARGET_DIFFERENCE) {
3826     GST_DEBUG_OBJECT (parse, "accurate seek possible");
3827     accurate = TRUE;
3828   }
3829   if (accurate) {
3830     GstClockTime startpos = seeksegment.position;
3831
3832     /* accurate requested, so ... seek a bit before target */
3833     if (startpos < parse->priv->lead_in_ts)
3834       startpos = 0;
3835     else
3836       startpos -= parse->priv->lead_in_ts;
3837     seekpos = gst_base_parse_find_offset (parse, startpos, TRUE, &start_ts);
3838     seekstop = gst_base_parse_find_offset (parse, seeksegment.stop, FALSE,
3839         NULL);
3840   } else {
3841     start_ts = seeksegment.position;
3842     if (!gst_pad_query_convert (parse->srcpad, format, seeksegment.position,
3843             GST_FORMAT_BYTES, &seekpos))
3844       goto convert_failed;
3845     if (!gst_pad_query_convert (parse->srcpad, format, seeksegment.stop,
3846             GST_FORMAT_BYTES, &seekstop))
3847       goto convert_failed;
3848   }
3849
3850   GST_DEBUG_OBJECT (parse,
3851       "seek position %" G_GINT64_FORMAT " in bytes: %" G_GINT64_FORMAT,
3852       start_ts, seekpos);
3853   GST_DEBUG_OBJECT (parse,
3854       "seek stop %" G_GINT64_FORMAT " in bytes: %" G_GINT64_FORMAT,
3855       seeksegment.stop, seekstop);
3856
3857   if (parse->priv->pad_mode == GST_PAD_MODE_PULL) {
3858     gint64 last_stop;
3859
3860     GST_DEBUG_OBJECT (parse, "seek in PULL mode");
3861
3862     if (flush) {
3863       if (parse->srcpad) {
3864         GST_DEBUG_OBJECT (parse, "sending flush start");
3865         gst_pad_push_event (parse->srcpad, gst_event_new_flush_start ());
3866         /* unlock upstream pull_range */
3867         gst_pad_push_event (parse->sinkpad, gst_event_new_flush_start ());
3868       }
3869     } else {
3870       gst_pad_pause_task (parse->sinkpad);
3871     }
3872
3873     /* we should now be able to grab the streaming thread because we stopped it
3874      * with the above flush/pause code */
3875     GST_PAD_STREAM_LOCK (parse->sinkpad);
3876
3877     /* save current position */
3878     last_stop = parse->segment.position;
3879     GST_DEBUG_OBJECT (parse, "stopped streaming at %" G_GINT64_FORMAT,
3880         last_stop);
3881
3882     /* now commit to new position */
3883
3884     /* prepare for streaming again */
3885     if (flush) {
3886       GST_DEBUG_OBJECT (parse, "sending flush stop");
3887       gst_pad_push_event (parse->srcpad, gst_event_new_flush_stop (TRUE));
3888       gst_pad_push_event (parse->sinkpad, gst_event_new_flush_stop (TRUE));
3889       gst_base_parse_clear_queues (parse);
3890     } else {
3891       /* keep track of our position */
3892       seeksegment.base = gst_segment_to_running_time (&seeksegment,
3893           seeksegment.format, parse->segment.position);
3894     }
3895
3896     memcpy (&parse->segment, &seeksegment, sizeof (GstSegment));
3897
3898     /* store the newsegment event so it can be sent from the streaming thread. */
3899     if (parse->priv->pending_segment)
3900       gst_event_unref (parse->priv->pending_segment);
3901
3902     /* This will be sent later in _loop() */
3903     parse->priv->pending_segment = gst_event_new_segment (&parse->segment);
3904
3905     GST_DEBUG_OBJECT (parse, "Created newseg format %d, "
3906         "start = %" GST_TIME_FORMAT ", stop = %" GST_TIME_FORMAT
3907         ", pos = %" GST_TIME_FORMAT, format,
3908         GST_TIME_ARGS (parse->segment.start),
3909         GST_TIME_ARGS (parse->segment.stop),
3910         GST_TIME_ARGS (parse->segment.start));
3911
3912     /* one last chance in pull mode to stay accurate;
3913      * maybe scan and subclass can find where to go */
3914     if (!accurate) {
3915       gint64 scanpos;
3916       GstClockTime ts = seeksegment.position;
3917
3918       gst_base_parse_locate_time (parse, &ts, &scanpos);
3919       if (scanpos >= 0) {
3920         accurate = TRUE;
3921         seekpos = scanpos;
3922         /* running collected index now consists of several intervals,
3923          * so optimized check no longer possible */
3924         parse->priv->index_last_valid = FALSE;
3925         parse->priv->index_last_offset = 0;
3926         parse->priv->index_last_ts = 0;
3927       }
3928     }
3929
3930     /* mark discont if we are going to stream from another position. */
3931     if (seekpos != parse->priv->offset) {
3932       GST_DEBUG_OBJECT (parse,
3933           "mark DISCONT, we did a seek to another position");
3934       parse->priv->offset = seekpos;
3935       parse->priv->last_offset = seekpos;
3936       parse->priv->seen_keyframe = FALSE;
3937       parse->priv->discont = TRUE;
3938       parse->priv->next_ts = start_ts;
3939       parse->priv->last_ts = GST_CLOCK_TIME_NONE;
3940       parse->priv->sync_offset = seekpos;
3941       parse->priv->exact_position = accurate;
3942     }
3943
3944     /* Start streaming thread if paused */
3945     gst_pad_start_task (parse->sinkpad,
3946         (GstTaskFunction) gst_base_parse_loop, parse->sinkpad);
3947
3948     GST_PAD_STREAM_UNLOCK (parse->sinkpad);
3949
3950     /* handled seek */
3951     res = TRUE;
3952   } else {
3953     GstEvent *new_event;
3954     GstBaseParseSeek *seek;
3955     GstSeekFlags flags = (flush ? GST_SEEK_FLAG_FLUSH : GST_SEEK_FLAG_NONE);
3956
3957     /* The only thing we need to do in PUSH-mode is to send the
3958        seek event (in bytes) to upstream. Segment / flush handling happens
3959        in corresponding src event handlers */
3960     GST_DEBUG_OBJECT (parse, "seek in PUSH mode");
3961     if (seekstop >= 0 && seekstop <= seekpos)
3962       seekstop = seekpos;
3963     new_event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags,
3964         GST_SEEK_TYPE_SET, seekpos, stop_type, seekstop);
3965
3966     /* store segment info so its precise details can be reconstructed when
3967      * receiving newsegment;
3968      * this matters for all details when accurate seeking,
3969      * is most useful to preserve NONE stop time otherwise */
3970     seek = g_new0 (GstBaseParseSeek, 1);
3971     seek->segment = seeksegment;
3972     seek->accurate = accurate;
3973     seek->offset = seekpos;
3974     seek->start_ts = start_ts;
3975     GST_OBJECT_LOCK (parse);
3976     /* less optimal, but preserves order */
3977     parse->priv->pending_seeks =
3978         g_slist_append (parse->priv->pending_seeks, seek);
3979     GST_OBJECT_UNLOCK (parse);
3980
3981     res = gst_pad_push_event (parse->sinkpad, new_event);
3982
3983     if (!res) {
3984       GST_OBJECT_LOCK (parse);
3985       parse->priv->pending_seeks =
3986           g_slist_remove (parse->priv->pending_seeks, seek);
3987       GST_OBJECT_UNLOCK (parse);
3988       g_free (seek);
3989     }
3990   }
3991
3992 done:
3993   /* handled event is ours to free */
3994   if (res)
3995     gst_event_unref (event);
3996   return res;
3997
3998   /* ERRORS */
3999 negative_rate:
4000   {
4001     GST_DEBUG_OBJECT (parse, "negative playback rates delegated upstream.");
4002     res = FALSE;
4003     goto done;
4004   }
4005 wrong_type:
4006   {
4007     GST_DEBUG_OBJECT (parse, "unsupported seek type.");
4008     res = FALSE;
4009     goto done;
4010   }
4011 convert_failed:
4012   {
4013     GST_DEBUG_OBJECT (parse, "conversion TIME to BYTES failed.");
4014     res = FALSE;
4015     goto done;
4016   }
4017 }
4018
4019 /* Checks if bitrates are available from upstream tags so that we don't
4020  * override them later
4021  */
4022 static void
4023 gst_base_parse_handle_tag (GstBaseParse * parse, GstEvent * event)
4024 {
4025   GstTagList *taglist = NULL;
4026   guint tmp;
4027
4028   gst_event_parse_tag (event, &taglist);
4029
4030   if (gst_tag_list_get_uint (taglist, GST_TAG_MINIMUM_BITRATE, &tmp)) {
4031     GST_DEBUG_OBJECT (parse, "upstream min bitrate %d", tmp);
4032     parse->priv->post_min_bitrate = FALSE;
4033   }
4034   if (gst_tag_list_get_uint (taglist, GST_TAG_BITRATE, &tmp)) {
4035     GST_DEBUG_OBJECT (parse, "upstream avg bitrate %d", tmp);
4036     parse->priv->post_avg_bitrate = FALSE;
4037   }
4038   if (gst_tag_list_get_uint (taglist, GST_TAG_MAXIMUM_BITRATE, &tmp)) {
4039     GST_DEBUG_OBJECT (parse, "upstream max bitrate %d", tmp);
4040     parse->priv->post_max_bitrate = FALSE;
4041   }
4042 }
4043
4044 #if 0
4045 static void
4046 gst_base_parse_set_index (GstElement * element, GstIndex * index)
4047 {
4048   GstBaseParse *parse = GST_BASE_PARSE (element);
4049
4050   GST_BASE_PARSE_INDEX_LOCK (parse);
4051   if (parse->priv->index)
4052     gst_object_unref (parse->priv->index);
4053   if (index) {
4054     parse->priv->index = gst_object_ref (index);
4055     gst_index_get_writer_id (index, GST_OBJECT_CAST (element),
4056         &parse->priv->index_id);
4057     parse->priv->own_index = FALSE;
4058   } else {
4059     parse->priv->index = NULL;
4060   }
4061   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4062 }
4063
4064 static GstIndex *
4065 gst_base_parse_get_index (GstElement * element)
4066 {
4067   GstBaseParse *parse = GST_BASE_PARSE (element);
4068   GstIndex *result = NULL;
4069
4070   GST_BASE_PARSE_INDEX_LOCK (parse);
4071   if (parse->priv->index)
4072     result = gst_object_ref (parse->priv->index);
4073   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4074
4075   return result;
4076 }
4077 #endif
4078
4079 static GstStateChangeReturn
4080 gst_base_parse_change_state (GstElement * element, GstStateChange transition)
4081 {
4082   GstBaseParse *parse;
4083   GstStateChangeReturn result;
4084
4085   parse = GST_BASE_PARSE (element);
4086
4087   switch (transition) {
4088     case GST_STATE_CHANGE_READY_TO_PAUSED:
4089       /* If this is our own index destroy it as the
4090        * old entries might be wrong for the new stream */
4091       GST_BASE_PARSE_INDEX_LOCK (parse);
4092       if (parse->priv->own_index) {
4093         gst_object_unref (parse->priv->index);
4094         parse->priv->index = NULL;
4095         parse->priv->own_index = FALSE;
4096       }
4097
4098       /* If no index was created, generate one */
4099       if (G_UNLIKELY (!parse->priv->index)) {
4100         GST_DEBUG_OBJECT (parse, "no index provided creating our own");
4101
4102         parse->priv->index = g_object_new (gst_mem_index_get_type (), NULL);
4103         gst_index_get_writer_id (parse->priv->index, GST_OBJECT (parse),
4104             &parse->priv->index_id);
4105         parse->priv->own_index = TRUE;
4106       }
4107       GST_BASE_PARSE_INDEX_UNLOCK (parse);
4108       break;
4109     default:
4110       break;
4111   }
4112
4113   result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
4114
4115   switch (transition) {
4116     case GST_STATE_CHANGE_PAUSED_TO_READY:
4117       gst_base_parse_reset (parse);
4118       break;
4119     default:
4120       break;
4121   }
4122
4123   return result;
4124 }