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