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   /* subclass might queue frames/data internally if it needs more
2228    * frames to decide on the format, or might request us to queue here. */
2229   if (frame->flags & GST_BASE_PARSE_FRAME_FLAG_DROP) {
2230     gst_buffer_replace (&frame->buffer, NULL);
2231     goto exit;
2232   } else if (frame->flags & GST_BASE_PARSE_FRAME_FLAG_QUEUE) {
2233     GstBaseParseFrame *copy;
2234
2235     copy = gst_base_parse_frame_copy (frame);
2236     copy->flags &= ~GST_BASE_PARSE_FRAME_FLAG_QUEUE;
2237     gst_base_parse_queue_frame (parse, copy);
2238     goto exit;
2239   }
2240
2241   ret = gst_base_parse_handle_and_push_frame (parse, frame);
2242
2243 exit:
2244   return ret;
2245 }
2246
2247 /* gst_base_parse_drain:
2248  *
2249  * Drains the adapter until it is empty. It decreases the min_frame_size to
2250  * match the current adapter size and calls chain method until the adapter
2251  * is emptied or chain returns with error.
2252  */
2253 static void
2254 gst_base_parse_drain (GstBaseParse * parse)
2255 {
2256   guint avail;
2257
2258   GST_DEBUG_OBJECT (parse, "draining");
2259   parse->priv->drain = TRUE;
2260
2261   for (;;) {
2262     avail = gst_adapter_available (parse->priv->adapter);
2263     if (!avail)
2264       break;
2265
2266     if (gst_base_parse_chain (parse->sinkpad, GST_OBJECT_CAST (parse),
2267             NULL) != GST_FLOW_OK) {
2268       break;
2269     }
2270
2271     /* nothing changed, maybe due to truncated frame; break infinite loop */
2272     if (avail == gst_adapter_available (parse->priv->adapter)) {
2273       GST_DEBUG_OBJECT (parse, "no change during draining; flushing");
2274       gst_adapter_clear (parse->priv->adapter);
2275     }
2276   }
2277
2278   parse->priv->drain = FALSE;
2279 }
2280
2281 /* gst_base_parse_send_buffers
2282  *
2283  * Sends buffers collected in send_buffers downstream, and ensures that list
2284  * is empty at the end (errors or not).
2285  */
2286 static GstFlowReturn
2287 gst_base_parse_send_buffers (GstBaseParse * parse)
2288 {
2289   GSList *send = NULL;
2290   GstBuffer *buf;
2291   GstFlowReturn ret = GST_FLOW_OK;
2292
2293   send = parse->priv->buffers_send;
2294
2295   /* send buffers */
2296   while (send) {
2297     buf = GST_BUFFER_CAST (send->data);
2298     GST_LOG_OBJECT (parse, "pushing buffer %p, timestamp %"
2299         GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT
2300         ", offset %" G_GINT64_FORMAT, buf,
2301         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
2302         GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_BUFFER_OFFSET (buf));
2303
2304     /* iterate output queue an push downstream */
2305     ret = gst_pad_push (parse->srcpad, buf);
2306     send = g_slist_delete_link (send, send);
2307
2308     /* clear any leftover if error */
2309     if (G_UNLIKELY (ret != GST_FLOW_OK)) {
2310       while (send) {
2311         buf = GST_BUFFER_CAST (send->data);
2312         gst_buffer_unref (buf);
2313         send = g_slist_delete_link (send, send);
2314       }
2315     }
2316   }
2317
2318   parse->priv->buffers_send = send;
2319
2320   return ret;
2321 }
2322
2323 /* gst_base_parse_start_fragment:
2324  *
2325  * Prepares for processing a reverse playback (forward) fragment
2326  * by (re)setting proper state variables.
2327  */
2328 static GstFlowReturn
2329 gst_base_parse_start_fragment (GstBaseParse * parse)
2330 {
2331   GST_LOG_OBJECT (parse, "starting fragment");
2332
2333   /* invalidate so no fall-back timestamping is performed;
2334    * ok if taken from subclass or upstream */
2335   parse->priv->next_ts = GST_CLOCK_TIME_NONE;
2336   parse->priv->prev_ts = GST_CLOCK_TIME_NONE;
2337   /* prevent it hanging around stop all the time */
2338   parse->segment.position = GST_CLOCK_TIME_NONE;
2339   /* mark next run */
2340   parse->priv->discont = TRUE;
2341
2342   /* head of previous fragment is now pending tail of current fragment */
2343   parse->priv->buffers_pending = parse->priv->buffers_head;
2344   parse->priv->buffers_head = NULL;
2345
2346   return GST_FLOW_OK;
2347 }
2348
2349
2350 /* gst_base_parse_finish_fragment:
2351  *
2352  * Processes a reverse playback (forward) fragment:
2353  * - append head of last fragment that was skipped to current fragment data
2354  * - drain the resulting current fragment data (i.e. repeated chain)
2355  * - add time/duration (if needed) to frames queued by chain
2356  * - push queued data
2357  */
2358 static GstFlowReturn
2359 gst_base_parse_finish_fragment (GstBaseParse * parse, gboolean prev_head)
2360 {
2361   GstBuffer *buf;
2362   GstFlowReturn ret = GST_FLOW_OK;
2363   gboolean seen_key = FALSE, seen_delta = FALSE;
2364
2365   GST_LOG_OBJECT (parse, "finishing fragment");
2366
2367   /* restore order */
2368   parse->priv->buffers_pending = g_slist_reverse (parse->priv->buffers_pending);
2369   while (parse->priv->buffers_pending) {
2370     buf = GST_BUFFER_CAST (parse->priv->buffers_pending->data);
2371     if (prev_head) {
2372       GST_LOG_OBJECT (parse, "adding pending buffer (size %" G_GSIZE_FORMAT ")",
2373           gst_buffer_get_size (buf));
2374       gst_adapter_push (parse->priv->adapter, buf);
2375     } else {
2376       GST_LOG_OBJECT (parse, "discarding head buffer");
2377       gst_buffer_unref (buf);
2378     }
2379     parse->priv->buffers_pending =
2380         g_slist_delete_link (parse->priv->buffers_pending,
2381         parse->priv->buffers_pending);
2382   }
2383
2384   /* chain looks for frames and queues resulting ones (in stead of pushing) */
2385   /* initial skipped data is added to buffers_pending */
2386   gst_base_parse_drain (parse);
2387
2388   if (parse->priv->buffers_send) {
2389     buf = GST_BUFFER_CAST (parse->priv->buffers_send->data);
2390     seen_key |= !GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
2391   }
2392
2393   /* add metadata (if needed to queued buffers */
2394   GST_LOG_OBJECT (parse, "last timestamp: %" GST_TIME_FORMAT,
2395       GST_TIME_ARGS (parse->priv->last_ts));
2396   while (parse->priv->buffers_queued) {
2397     buf = GST_BUFFER_CAST (parse->priv->buffers_queued->data);
2398
2399     /* no touching if upstream or parsing provided time */
2400     if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
2401       GST_LOG_OBJECT (parse, "buffer has time %" GST_TIME_FORMAT,
2402           GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
2403     } else if (GST_CLOCK_TIME_IS_VALID (parse->priv->last_ts) &&
2404         GST_BUFFER_DURATION_IS_VALID (buf)) {
2405       if (G_LIKELY (GST_BUFFER_DURATION (buf) <= parse->priv->last_ts))
2406         parse->priv->last_ts -= GST_BUFFER_DURATION (buf);
2407       else
2408         parse->priv->last_ts = 0;
2409       GST_BUFFER_TIMESTAMP (buf) = parse->priv->last_ts;
2410       GST_LOG_OBJECT (parse, "applied time %" GST_TIME_FORMAT,
2411           GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
2412     } else {
2413       /* no idea, very bad */
2414       GST_WARNING_OBJECT (parse, "could not determine time for buffer");
2415     }
2416
2417     parse->priv->last_ts = GST_BUFFER_TIMESTAMP (buf);
2418
2419     /* reverse order for ascending sending */
2420     /* send downstream at keyframe not preceded by a keyframe
2421      * (e.g. that should identify start of collection of IDR nals) */
2422     if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT)) {
2423       if (seen_key) {
2424         ret = gst_base_parse_send_buffers (parse);
2425         /* if a problem, throw all to sending */
2426         if (ret != GST_FLOW_OK) {
2427           parse->priv->buffers_send =
2428               g_slist_reverse (parse->priv->buffers_queued);
2429           parse->priv->buffers_queued = NULL;
2430           break;
2431         }
2432         seen_key = FALSE;
2433       }
2434       seen_delta = TRUE;
2435     } else {
2436       seen_key = TRUE;
2437     }
2438
2439     parse->priv->buffers_send =
2440         g_slist_prepend (parse->priv->buffers_send, buf);
2441     parse->priv->buffers_queued =
2442         g_slist_delete_link (parse->priv->buffers_queued,
2443         parse->priv->buffers_queued);
2444   }
2445
2446   /* audio may have all marked as keyframe, so arrange to send here */
2447   if (!seen_delta)
2448     ret = gst_base_parse_send_buffers (parse);
2449
2450   /* any trailing unused no longer usable (ideally none) */
2451   if (G_UNLIKELY (gst_adapter_available (parse->priv->adapter))) {
2452     GST_DEBUG_OBJECT (parse, "discarding %" G_GSIZE_FORMAT " trailing bytes",
2453         gst_adapter_available (parse->priv->adapter));
2454     gst_adapter_clear (parse->priv->adapter);
2455   }
2456
2457   return ret;
2458 }
2459
2460 /* small helper that checks whether we have been trying to resync too long */
2461 static inline GstFlowReturn
2462 gst_base_parse_check_sync (GstBaseParse * parse)
2463 {
2464   if (G_UNLIKELY (parse->priv->discont &&
2465           parse->priv->offset - parse->priv->sync_offset > 2 * 1024 * 1024)) {
2466     GST_ELEMENT_ERROR (parse, STREAM, DECODE,
2467         ("Failed to parse stream"), (NULL));
2468     return GST_FLOW_ERROR;
2469   }
2470
2471   return GST_FLOW_OK;
2472 }
2473
2474 static GstFlowReturn
2475 gst_base_parse_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
2476 {
2477   GstBaseParseClass *bclass;
2478   GstBaseParse *parse;
2479   GstFlowReturn ret = GST_FLOW_OK;
2480   GstBuffer *tmpbuf = NULL;
2481   guint fsize = 1;
2482   gint skip = -1;
2483   const guint8 *data;
2484   guint min_size, av;
2485   GstClockTime timestamp;
2486
2487   parse = GST_BASE_PARSE (parent);
2488   bclass = GST_BASE_PARSE_GET_CLASS (parse);
2489
2490   if (parse->priv->detecting) {
2491     GstBuffer *detect_buf;
2492
2493     if (parse->priv->detect_buffers_size == 0) {
2494       detect_buf = gst_buffer_ref (buffer);
2495     } else {
2496       GList *l;
2497       guint offset = 0;
2498
2499       detect_buf = gst_buffer_new ();
2500
2501       for (l = parse->priv->detect_buffers; l; l = l->next) {
2502         gsize tmpsize = gst_buffer_get_size (l->data);
2503
2504         gst_buffer_copy_into (detect_buf, GST_BUFFER_CAST (l->data),
2505             GST_BUFFER_COPY_MEMORY, offset, tmpsize);
2506         offset += tmpsize;
2507       }
2508       if (buffer)
2509         gst_buffer_copy_into (detect_buf, buffer, GST_BUFFER_COPY_MEMORY,
2510             offset, gst_buffer_get_size (buffer));
2511     }
2512
2513     ret = bclass->detect (parse, detect_buf);
2514     gst_buffer_unref (detect_buf);
2515
2516     if (ret == GST_FLOW_OK) {
2517       GList *l;
2518
2519       /* Detected something */
2520       parse->priv->detecting = FALSE;
2521
2522       for (l = parse->priv->detect_buffers; l; l = l->next) {
2523         if (ret == GST_FLOW_OK && !parse->priv->flushing)
2524           ret =
2525               gst_base_parse_chain (GST_BASE_PARSE_SINK_PAD (parse),
2526               parent, GST_BUFFER_CAST (l->data));
2527         else
2528           gst_buffer_unref (GST_BUFFER_CAST (l->data));
2529       }
2530       g_list_free (parse->priv->detect_buffers);
2531       parse->priv->detect_buffers = NULL;
2532       parse->priv->detect_buffers_size = 0;
2533
2534       if (ret != GST_FLOW_OK) {
2535         return ret;
2536       }
2537
2538       /* Handle the current buffer */
2539     } else if (ret == GST_FLOW_NOT_NEGOTIATED) {
2540       /* Still detecting, append buffer or error out if draining */
2541
2542       if (parse->priv->drain) {
2543         GST_DEBUG_OBJECT (parse, "Draining but did not detect format yet");
2544         return GST_FLOW_ERROR;
2545       } else if (parse->priv->flushing) {
2546         g_list_foreach (parse->priv->detect_buffers, (GFunc) gst_buffer_unref,
2547             NULL);
2548         g_list_free (parse->priv->detect_buffers);
2549         parse->priv->detect_buffers = NULL;
2550         parse->priv->detect_buffers_size = 0;
2551       } else {
2552         parse->priv->detect_buffers =
2553             g_list_append (parse->priv->detect_buffers, buffer);
2554         parse->priv->detect_buffers_size += gst_buffer_get_size (buffer);
2555         return GST_FLOW_OK;
2556       }
2557     } else {
2558       /* Something went wrong, subclass responsible for error reporting */
2559       return ret;
2560     }
2561
2562     /* And now handle the current buffer if detection worked */
2563   }
2564
2565   if (G_LIKELY (buffer)) {
2566     GST_LOG_OBJECT (parse,
2567         "buffer size: %" G_GSIZE_FORMAT ", offset = %" G_GINT64_FORMAT,
2568         gst_buffer_get_size (buffer), GST_BUFFER_OFFSET (buffer));
2569     if (G_UNLIKELY (parse->priv->passthrough)) {
2570       GstBaseParseFrame frame;
2571
2572       gst_base_parse_frame_init (&frame);
2573       frame.buffer = gst_buffer_make_writable (buffer);
2574       ret = gst_base_parse_push_frame (parse, &frame);
2575       gst_base_parse_frame_free (&frame);
2576       return ret;
2577     }
2578     /* upstream feeding us in reverse playback;
2579      * finish previous fragment and start new upon DISCONT */
2580     if (parse->segment.rate < 0.0) {
2581       if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))) {
2582         GST_DEBUG_OBJECT (parse, "buffer starts new reverse playback fragment");
2583         ret = gst_base_parse_finish_fragment (parse, TRUE);
2584         gst_base_parse_start_fragment (parse);
2585       }
2586     }
2587     gst_adapter_push (parse->priv->adapter, buffer);
2588   }
2589
2590   /* Parse and push as many frames as possible */
2591   /* Stop either when adapter is empty or we are flushing */
2592   while (!parse->priv->flushing) {
2593     gint flush = 0;
2594
2595     /* note: if subclass indicates MAX fsize,
2596      * this will not likely be available anyway ... */
2597     min_size = MAX (parse->priv->min_frame_size, fsize);
2598     av = gst_adapter_available (parse->priv->adapter);
2599
2600     if (G_UNLIKELY (parse->priv->drain)) {
2601       min_size = av;
2602       GST_DEBUG_OBJECT (parse, "draining, data left: %d", min_size);
2603       if (G_UNLIKELY (!min_size)) {
2604         goto done;
2605       }
2606     }
2607
2608     /* Collect at least min_frame_size bytes */
2609     if (av < min_size) {
2610       GST_DEBUG_OBJECT (parse, "not enough data available (only %d bytes)", av);
2611       goto done;
2612     }
2613
2614     /* move along with upstream timestamp (if any),
2615      * but interpolate in between */
2616     timestamp = gst_adapter_prev_timestamp (parse->priv->adapter, NULL);
2617     if (GST_CLOCK_TIME_IS_VALID (timestamp) &&
2618         (parse->priv->prev_ts != timestamp)) {
2619       parse->priv->prev_ts = parse->priv->next_ts = timestamp;
2620     }
2621
2622     /* always pass all available data */
2623     data = gst_adapter_map (parse->priv->adapter, av);
2624     /* arrange for actual data to be copied if subclass tries to,
2625      * since what is passed is tied to the adapter */
2626     tmpbuf = gst_buffer_new ();
2627     gst_buffer_take_memory (tmpbuf, -1,
2628         gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY |
2629             GST_MEMORY_FLAG_NO_SHARE, (gpointer) data, NULL, av, 0, av));
2630
2631     /* keep the adapter mapped, so keep track of what has to be flushed */
2632     ret = gst_base_parse_handle_buffer (parse, tmpbuf, &skip, &flush);
2633     tmpbuf = NULL;
2634
2635     /* probably already implicitly unmapped due to adapter operation,
2636      * but for good measure ... */
2637     gst_adapter_unmap (parse->priv->adapter);
2638     if (ret != GST_FLOW_OK) {
2639       goto done;
2640     }
2641     if (skip == 0 && flush == 0) {
2642       GST_LOG_OBJECT (parse, "nothing skipped and no frames finished, "
2643           "breaking to get more data");
2644       goto done;
2645     }
2646   }
2647
2648 done:
2649   GST_LOG_OBJECT (parse, "chain leaving");
2650   return ret;
2651 }
2652
2653 /* pull @size bytes at current offset,
2654  * i.e. at least try to and possibly return a shorter buffer if near the end */
2655 static GstFlowReturn
2656 gst_base_parse_pull_range (GstBaseParse * parse, guint size,
2657     GstBuffer ** buffer)
2658 {
2659   GstFlowReturn ret = GST_FLOW_OK;
2660
2661   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
2662
2663   /* Caching here actually makes much less difference than one would expect.
2664    * We do it mainly to avoid pulling buffers of 1 byte all the time */
2665   if (parse->priv->cache) {
2666     gint64 cache_offset = GST_BUFFER_OFFSET (parse->priv->cache);
2667     gint cache_size = gst_buffer_get_size (parse->priv->cache);
2668
2669     if (cache_offset <= parse->priv->offset &&
2670         (parse->priv->offset + size) <= (cache_offset + cache_size)) {
2671       *buffer = gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL,
2672           parse->priv->offset - cache_offset, size);
2673       GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
2674       return GST_FLOW_OK;
2675     }
2676     /* not enough data in the cache, free cache and get a new one */
2677     gst_buffer_unref (parse->priv->cache);
2678     parse->priv->cache = NULL;
2679   }
2680
2681   /* refill the cache */
2682   ret =
2683       gst_pad_pull_range (parse->sinkpad, parse->priv->offset, MAX (size,
2684           64 * 1024), &parse->priv->cache);
2685   if (ret != GST_FLOW_OK) {
2686     parse->priv->cache = NULL;
2687     return ret;
2688   }
2689
2690   if (gst_buffer_get_size (parse->priv->cache) >= size) {
2691     *buffer =
2692         gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL, 0,
2693         size);
2694     GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
2695     return GST_FLOW_OK;
2696   }
2697
2698   /* Not possible to get enough data, try a last time with
2699    * requesting exactly the size we need */
2700   gst_buffer_unref (parse->priv->cache);
2701   parse->priv->cache = NULL;
2702
2703   ret = gst_pad_pull_range (parse->sinkpad, parse->priv->offset, size,
2704       &parse->priv->cache);
2705
2706   if (ret != GST_FLOW_OK) {
2707     GST_DEBUG_OBJECT (parse, "pull_range returned %d", ret);
2708     *buffer = NULL;
2709     return ret;
2710   }
2711
2712   if (gst_buffer_get_size (parse->priv->cache) < size) {
2713     GST_DEBUG_OBJECT (parse, "Returning short buffer at offset %"
2714         G_GUINT64_FORMAT ": wanted %u bytes, got %" G_GSIZE_FORMAT " bytes",
2715         parse->priv->offset, size, gst_buffer_get_size (parse->priv->cache));
2716
2717     *buffer = parse->priv->cache;
2718     parse->priv->cache = NULL;
2719
2720     return GST_FLOW_OK;
2721   }
2722
2723   *buffer =
2724       gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL, 0, size);
2725   GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
2726
2727   return GST_FLOW_OK;
2728 }
2729
2730 static GstFlowReturn
2731 gst_base_parse_handle_previous_fragment (GstBaseParse * parse)
2732 {
2733   gint64 offset = 0;
2734   GstClockTime ts = 0;
2735   GstBuffer *buffer;
2736   GstFlowReturn ret;
2737
2738   GST_DEBUG_OBJECT (parse, "fragment ended; last_ts = %" GST_TIME_FORMAT
2739       ", last_offset = %" G_GINT64_FORMAT, GST_TIME_ARGS (parse->priv->last_ts),
2740       parse->priv->last_offset);
2741
2742   if (!parse->priv->last_offset || parse->priv->last_ts <= parse->segment.start) {
2743     GST_DEBUG_OBJECT (parse, "past start of segment %" GST_TIME_FORMAT,
2744         GST_TIME_ARGS (parse->segment.start));
2745     ret = GST_FLOW_EOS;
2746     goto exit;
2747   }
2748
2749   /* last fragment started at last_offset / last_ts;
2750    * seek back 10s capped at 1MB */
2751   if (parse->priv->last_ts >= 10 * GST_SECOND)
2752     ts = parse->priv->last_ts - 10 * GST_SECOND;
2753   /* if we are exact now, we will be more so going backwards */
2754   if (parse->priv->exact_position) {
2755     offset = gst_base_parse_find_offset (parse, ts, TRUE, NULL);
2756   } else {
2757     if (!gst_pad_query_convert (parse->srcpad, GST_FORMAT_TIME, ts,
2758             GST_FORMAT_BYTES, &offset)) {
2759       GST_DEBUG_OBJECT (parse, "conversion failed, only BYTE based");
2760     }
2761   }
2762   offset = CLAMP (offset, parse->priv->last_offset - 1024 * 1024,
2763       parse->priv->last_offset - 1024);
2764   offset = MAX (0, offset);
2765
2766   GST_DEBUG_OBJECT (parse, "next fragment from offset %" G_GINT64_FORMAT,
2767       offset);
2768   parse->priv->offset = offset;
2769
2770   ret = gst_base_parse_pull_range (parse, parse->priv->last_offset - offset,
2771       &buffer);
2772   if (ret != GST_FLOW_OK)
2773     goto exit;
2774
2775   /* offset will increase again as fragment is processed/parsed */
2776   parse->priv->last_offset = offset;
2777
2778   gst_base_parse_start_fragment (parse);
2779   gst_adapter_push (parse->priv->adapter, buffer);
2780   ret = gst_base_parse_finish_fragment (parse, TRUE);
2781   if (ret != GST_FLOW_OK)
2782     goto exit;
2783
2784   /* force previous fragment */
2785   parse->priv->offset = -1;
2786
2787 exit:
2788   return ret;
2789 }
2790
2791 /* PULL mode:
2792  * pull and scan for next frame starting from current offset
2793  * ajusts sync, drain and offset going along */
2794 static GstFlowReturn
2795 gst_base_parse_scan_frame (GstBaseParse * parse, GstBaseParseClass * klass,
2796     gboolean full)
2797 {
2798   GstBuffer *buffer;
2799   GstFlowReturn ret = GST_FLOW_OK;
2800   guint fsize, min_size;
2801   gint flushed = 0;
2802   gint skip = 0;
2803
2804   GST_LOG_OBJECT (parse, "scanning for frame at offset %" G_GUINT64_FORMAT
2805       " (%#" G_GINT64_MODIFIER "x)", parse->priv->offset, parse->priv->offset);
2806
2807   /* let's make this efficient for all subclass once and for all;
2808    * maybe it does not need this much, but in the latter case, we know we are
2809    * in pull mode here and might as well try to read and supply more anyway
2810    * (so does the buffer caching mechanism) */
2811   fsize = 64 * 1024;
2812
2813   while (TRUE) {
2814     min_size = MAX (parse->priv->min_frame_size, fsize);
2815
2816     GST_LOG_OBJECT (parse, "reading buffer size %u", min_size);
2817
2818     ret = gst_base_parse_pull_range (parse, min_size, &buffer);
2819     if (ret != GST_FLOW_OK)
2820       goto done;
2821
2822     /* if we got a short read, inform subclass we are draining leftover
2823      * and no more is to be expected */
2824     if (gst_buffer_get_size (buffer) < min_size) {
2825       GST_LOG_OBJECT (parse, "... but did not get that; marked draining");
2826       parse->priv->drain = TRUE;
2827     }
2828
2829     if (parse->priv->detecting) {
2830       ret = klass->detect (parse, buffer);
2831       if (ret == GST_FLOW_NOT_NEGOTIATED) {
2832         /* If draining we error out, otherwise request a buffer
2833          * with 64kb more */
2834         if (parse->priv->drain) {
2835           gst_buffer_unref (buffer);
2836           GST_ERROR_OBJECT (parse, "Failed to detect format but draining");
2837           return GST_FLOW_ERROR;
2838         } else {
2839           fsize += 64 * 1024;
2840           gst_buffer_unref (buffer);
2841           continue;
2842         }
2843       } else if (ret != GST_FLOW_OK) {
2844         gst_buffer_unref (buffer);
2845         GST_ERROR_OBJECT (parse, "detect() returned %s",
2846             gst_flow_get_name (ret));
2847         return ret;
2848       }
2849
2850       /* Else handle this buffer normally */
2851     }
2852
2853     ret = gst_base_parse_handle_buffer (parse, buffer, &skip, &flushed);
2854     if (ret != GST_FLOW_OK)
2855       break;
2856
2857     /* something flushed means something happened,
2858      * and we should bail out of this loop so as not to occupy
2859      * the task thread indefinitely */
2860     if (flushed) {
2861       GST_LOG_OBJECT (parse, "frame finished, breaking loop");
2862       break;
2863     }
2864     /* nothing flushed, no skip and draining, so nothing left to do */
2865     if (!skip && parse->priv->drain) {
2866       GST_LOG_OBJECT (parse, "no activity or result when draining; "
2867           "breaking loop and marking EOS");
2868       ret = GST_FLOW_EOS;
2869       break;
2870     }
2871     /* otherwise, get some more data
2872      * note that is checked this does not happen indefinitely */
2873     if (!skip) {
2874       GST_LOG_OBJECT (parse, "getting some more data");
2875       fsize += 64 * 1024;
2876     }
2877     parse->priv->drain = FALSE;
2878   }
2879
2880 done:
2881   return ret;
2882 }
2883
2884 /* Loop that is used in pull mode to retrieve data from upstream */
2885 static void
2886 gst_base_parse_loop (GstPad * pad)
2887 {
2888   GstBaseParse *parse;
2889   GstBaseParseClass *klass;
2890   GstFlowReturn ret = GST_FLOW_OK;
2891
2892   parse = GST_BASE_PARSE (gst_pad_get_parent (pad));
2893   klass = GST_BASE_PARSE_GET_CLASS (parse);
2894
2895   /* reverse playback:
2896    * first fragment (closest to stop time) is handled normally below,
2897    * then we pull in fragments going backwards */
2898   if (parse->segment.rate < 0.0) {
2899     /* check if we jumped back to a previous fragment,
2900      * which is a post-first fragment */
2901     if (parse->priv->offset < 0) {
2902       ret = gst_base_parse_handle_previous_fragment (parse);
2903       goto done;
2904     }
2905   }
2906
2907   ret = gst_base_parse_scan_frame (parse, klass, TRUE);
2908   if (ret != GST_FLOW_OK)
2909     goto done;
2910
2911   /* eat expected eos signalling past segment in reverse playback */
2912   if (parse->segment.rate < 0.0 && ret == GST_FLOW_EOS &&
2913       parse->segment.position >= parse->segment.stop) {
2914     GST_DEBUG_OBJECT (parse, "downstream has reached end of segment");
2915     /* push what was accumulated during loop run */
2916     gst_base_parse_finish_fragment (parse, FALSE);
2917     /* force previous fragment */
2918     parse->priv->offset = -1;
2919     ret = GST_FLOW_OK;
2920   }
2921
2922 done:
2923   if (ret == GST_FLOW_EOS)
2924     goto eos;
2925   else if (ret != GST_FLOW_OK)
2926     goto pause;
2927
2928   gst_object_unref (parse);
2929   return;
2930
2931   /* ERRORS */
2932 eos:
2933   {
2934     ret = GST_FLOW_EOS;
2935     GST_DEBUG_OBJECT (parse, "eos");
2936     /* fall-through */
2937   }
2938 pause:
2939   {
2940     gboolean push_eos = FALSE;
2941
2942     GST_DEBUG_OBJECT (parse, "pausing task, reason %s",
2943         gst_flow_get_name (ret));
2944     gst_pad_pause_task (parse->sinkpad);
2945
2946     if (ret == GST_FLOW_EOS) {
2947       /* handle end-of-stream/segment */
2948       if (parse->segment.flags & GST_SEEK_FLAG_SEGMENT) {
2949         gint64 stop;
2950
2951         if ((stop = parse->segment.stop) == -1)
2952           stop = parse->segment.duration;
2953
2954         GST_DEBUG_OBJECT (parse, "sending segment_done");
2955
2956         gst_element_post_message
2957             (GST_ELEMENT_CAST (parse),
2958             gst_message_new_segment_done (GST_OBJECT_CAST (parse),
2959                 GST_FORMAT_TIME, stop));
2960       } else {
2961         /* If we STILL have zero frames processed, fire an error */
2962         if (parse->priv->framecount == 0) {
2963           GST_ELEMENT_ERROR (parse, STREAM, WRONG_TYPE,
2964               ("No valid frames found before end of stream"), (NULL));
2965         }
2966         push_eos = TRUE;
2967       }
2968     } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
2969       /* for fatal errors we post an error message, wrong-state is
2970        * not fatal because it happens due to flushes and only means
2971        * that we should stop now. */
2972       GST_ELEMENT_ERROR (parse, STREAM, FAILED, (NULL),
2973           ("streaming stopped, reason %s", gst_flow_get_name (ret)));
2974       push_eos = TRUE;
2975     }
2976     if (push_eos) {
2977       /* newsegment before eos */
2978       if (parse->priv->pending_segment) {
2979         gst_pad_push_event (parse->srcpad, parse->priv->pending_segment);
2980         parse->priv->pending_segment = NULL;
2981       }
2982       gst_pad_push_event (parse->srcpad, gst_event_new_eos ());
2983     }
2984     gst_object_unref (parse);
2985   }
2986 }
2987
2988 static gboolean
2989 gst_base_parse_sink_activate (GstPad * sinkpad, GstObject * parent)
2990 {
2991   GstBaseParse *parse;
2992   gboolean result = TRUE;
2993   GstQuery *query;
2994   gboolean pull_mode;
2995
2996   parse = GST_BASE_PARSE (parent);
2997
2998   GST_DEBUG_OBJECT (parse, "sink activate");
2999
3000   query = gst_query_new_scheduling ();
3001   result = gst_pad_peer_query (sinkpad, query);
3002   if (result) {
3003     pull_mode = gst_query_has_scheduling_mode (query, GST_PAD_MODE_PULL);
3004   } else {
3005     pull_mode = FALSE;
3006   }
3007   gst_query_unref (query);
3008
3009   if (pull_mode) {
3010     GST_DEBUG_OBJECT (parse, "trying to activate in pull mode");
3011     result = gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
3012   } else {
3013     GST_DEBUG_OBJECT (parse, "trying to activate in push mode");
3014     result = gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
3015   }
3016
3017   GST_DEBUG_OBJECT (parse, "sink activate return %d", result);
3018   return result;
3019 }
3020
3021 static gboolean
3022 gst_base_parse_activate (GstBaseParse * parse, gboolean active)
3023 {
3024   GstBaseParseClass *klass;
3025   gboolean result = TRUE;
3026
3027   GST_DEBUG_OBJECT (parse, "activate %d", active);
3028
3029   klass = GST_BASE_PARSE_GET_CLASS (parse);
3030
3031   if (active) {
3032     if (parse->priv->pad_mode == GST_PAD_MODE_NONE && klass->start)
3033       result = klass->start (parse);
3034
3035     /* If the subclass implements ::detect we want to
3036      * call it for the first buffers now */
3037     parse->priv->detecting = (klass->detect != NULL);
3038   } else {
3039     /* We must make sure streaming has finished before resetting things
3040      * and calling the ::stop vfunc */
3041     GST_PAD_STREAM_LOCK (parse->sinkpad);
3042     GST_PAD_STREAM_UNLOCK (parse->sinkpad);
3043
3044     if (parse->priv->pad_mode != GST_PAD_MODE_NONE && klass->stop)
3045       result = klass->stop (parse);
3046
3047     parse->priv->pad_mode = GST_PAD_MODE_NONE;
3048   }
3049   GST_DEBUG_OBJECT (parse, "activate return: %d", result);
3050   return result;
3051 }
3052
3053 static gboolean
3054 gst_base_parse_sink_activate_mode (GstPad * pad, GstObject * parent,
3055     GstPadMode mode, gboolean active)
3056 {
3057   gboolean result = TRUE;
3058   GstBaseParse *parse;
3059
3060   parse = GST_BASE_PARSE (parent);
3061
3062   GST_DEBUG_OBJECT (parse, "sink activate mode %d, %d", mode, active);
3063
3064   result = gst_base_parse_activate (parse, active);
3065
3066   if (result) {
3067     switch (mode) {
3068       case GST_PAD_MODE_PULL:
3069         if (active) {
3070           parse->priv->pending_segment =
3071               gst_event_new_segment (&parse->segment);
3072           result &=
3073               gst_pad_start_task (pad, (GstTaskFunction) gst_base_parse_loop,
3074               pad);
3075         } else {
3076           result &= gst_pad_stop_task (pad);
3077         }
3078         break;
3079       default:
3080         break;
3081     }
3082   }
3083   if (result)
3084     parse->priv->pad_mode = active ? mode : GST_PAD_MODE_NONE;
3085
3086   GST_DEBUG_OBJECT (parse, "sink activate return: %d", result);
3087
3088   return result;
3089 }
3090
3091 /**
3092  * gst_base_parse_set_duration:
3093  * @parse: #GstBaseParse.
3094  * @fmt: #GstFormat.
3095  * @duration: duration value.
3096  * @interval: how often to update the duration estimate based on bitrate, or 0.
3097  *
3098  * Sets the duration of the currently playing media. Subclass can use this
3099  * when it is able to determine duration and/or notices a change in the media
3100  * duration.  Alternatively, if @interval is non-zero (default), then stream
3101  * duration is determined based on estimated bitrate, and updated every @interval
3102  * frames.
3103  *
3104  * Since: 0.10.33
3105  */
3106 void
3107 gst_base_parse_set_duration (GstBaseParse * parse,
3108     GstFormat fmt, gint64 duration, gint interval)
3109 {
3110   g_return_if_fail (parse != NULL);
3111
3112   if (parse->priv->upstream_has_duration) {
3113     GST_DEBUG_OBJECT (parse, "using upstream duration; discarding update");
3114     goto exit;
3115   }
3116
3117   if (duration != parse->priv->duration) {
3118     GstMessage *m;
3119
3120     m = gst_message_new_duration (GST_OBJECT (parse), fmt, duration);
3121     gst_element_post_message (GST_ELEMENT (parse), m);
3122
3123     /* TODO: what about duration tag? */
3124   }
3125   parse->priv->duration = duration;
3126   parse->priv->duration_fmt = fmt;
3127   GST_DEBUG_OBJECT (parse, "set duration: %" G_GINT64_FORMAT, duration);
3128   if (fmt == GST_FORMAT_TIME && GST_CLOCK_TIME_IS_VALID (duration)) {
3129     if (interval != 0) {
3130       GST_DEBUG_OBJECT (parse, "valid duration provided, disabling estimate");
3131       interval = 0;
3132     }
3133   }
3134   GST_DEBUG_OBJECT (parse, "set update interval: %d", interval);
3135   parse->priv->update_interval = interval;
3136 exit:
3137   return;
3138 }
3139
3140 /**
3141  * gst_base_parse_set_average_bitrate:
3142  * @parse: #GstBaseParse.
3143  * @bitrate: average bitrate in bits/second
3144  *
3145  * Optionally sets the average bitrate detected in media (if non-zero),
3146  * e.g. based on metadata, as it will be posted to the application.
3147  *
3148  * By default, announced average bitrate is estimated. The average bitrate
3149  * is used to estimate the total duration of the stream and to estimate
3150  * a seek position, if there's no index and the format is syncable
3151  * (see gst_base_parse_set_syncable()).
3152  *
3153  * Since: 0.10.33
3154  */
3155 void
3156 gst_base_parse_set_average_bitrate (GstBaseParse * parse, guint bitrate)
3157 {
3158   parse->priv->bitrate = bitrate;
3159   GST_DEBUG_OBJECT (parse, "bitrate %u", bitrate);
3160 }
3161
3162 /**
3163  * gst_base_parse_set_min_frame_size:
3164  * @parse: #GstBaseParse.
3165  * @min_size: Minimum size of the data that this base class should give to
3166  *            subclass.
3167  *
3168  * Subclass can use this function to tell the base class that it needs to
3169  * give at least #min_size buffers.
3170  *
3171  * Since: 0.10.33
3172  */
3173 void
3174 gst_base_parse_set_min_frame_size (GstBaseParse * parse, guint min_size)
3175 {
3176   g_return_if_fail (parse != NULL);
3177
3178   parse->priv->min_frame_size = min_size;
3179   GST_LOG_OBJECT (parse, "set frame_min_size: %d", min_size);
3180 }
3181
3182 /**
3183  * gst_base_parse_set_frame_rate:
3184  * @parse: the #GstBaseParse to set
3185  * @fps_num: frames per second (numerator).
3186  * @fps_den: frames per second (denominator).
3187  * @lead_in: frames needed before a segment for subsequent decode
3188  * @lead_out: frames needed after a segment
3189  *
3190  * If frames per second is configured, parser can take care of buffer duration
3191  * and timestamping.  When performing segment clipping, or seeking to a specific
3192  * location, a corresponding decoder might need an initial @lead_in and a
3193  * following @lead_out number of frames to ensure the desired segment is
3194  * entirely filled upon decoding.
3195  *
3196  * Since: 0.10.33
3197  */
3198 void
3199 gst_base_parse_set_frame_rate (GstBaseParse * parse, guint fps_num,
3200     guint fps_den, guint lead_in, guint lead_out)
3201 {
3202   g_return_if_fail (parse != NULL);
3203
3204   parse->priv->fps_num = fps_num;
3205   parse->priv->fps_den = fps_den;
3206   if (!fps_num || !fps_den) {
3207     GST_DEBUG_OBJECT (parse, "invalid fps (%d/%d), ignoring parameters",
3208         fps_num, fps_den);
3209     fps_num = fps_den = 0;
3210     parse->priv->frame_duration = GST_CLOCK_TIME_NONE;
3211     parse->priv->lead_in = parse->priv->lead_out = 0;
3212     parse->priv->lead_in_ts = parse->priv->lead_out_ts = 0;
3213   } else {
3214     parse->priv->frame_duration =
3215         gst_util_uint64_scale (GST_SECOND, fps_den, fps_num);
3216     parse->priv->lead_in = lead_in;
3217     parse->priv->lead_out = lead_out;
3218     parse->priv->lead_in_ts =
3219         gst_util_uint64_scale (GST_SECOND, fps_den * lead_in, fps_num);
3220     parse->priv->lead_out_ts =
3221         gst_util_uint64_scale (GST_SECOND, fps_den * lead_out, fps_num);
3222     /* aim for about 1.5s to estimate duration */
3223     if (parse->priv->update_interval < 0) {
3224       parse->priv->update_interval = fps_num * 3 / (fps_den * 2);
3225       GST_LOG_OBJECT (parse, "estimated update interval to %d frames",
3226           parse->priv->update_interval);
3227     }
3228   }
3229   GST_LOG_OBJECT (parse, "set fps: %d/%d => duration: %" G_GINT64_FORMAT " ms",
3230       fps_num, fps_den, parse->priv->frame_duration / GST_MSECOND);
3231   GST_LOG_OBJECT (parse, "set lead in: %d frames = %" G_GUINT64_FORMAT " ms, "
3232       "lead out: %d frames = %" G_GUINT64_FORMAT " ms",
3233       lead_in, parse->priv->lead_in_ts / GST_MSECOND,
3234       lead_out, parse->priv->lead_out_ts / GST_MSECOND);
3235 }
3236
3237 /**
3238  * gst_base_parse_set_has_timing_info:
3239  * @parse: a #GstBaseParse
3240  * @has_timing: whether frames carry timing information
3241  *
3242  * Set if frames carry timing information which the subclass can (generally)
3243  * parse and provide.  In particular, intrinsic (rather than estimated) time
3244  * can be obtained following a seek.
3245  *
3246  * Since: 0.10.33
3247  */
3248 void
3249 gst_base_parse_set_has_timing_info (GstBaseParse * parse, gboolean has_timing)
3250 {
3251   parse->priv->has_timing_info = has_timing;
3252   GST_INFO_OBJECT (parse, "has_timing: %s", (has_timing) ? "yes" : "no");
3253 }
3254
3255 /**
3256  * gst_base_parse_set_syncable:
3257  * @parse: a #GstBaseParse
3258  * @syncable: set if frame starts can be identified
3259  *
3260  * Set if frame starts can be identified. This is set by default and
3261  * determines whether seeking based on bitrate averages
3262  * is possible for a format/stream.
3263  *
3264  * Since: 0.10.33
3265  */
3266 void
3267 gst_base_parse_set_syncable (GstBaseParse * parse, gboolean syncable)
3268 {
3269   parse->priv->syncable = syncable;
3270   GST_INFO_OBJECT (parse, "syncable: %s", (syncable) ? "yes" : "no");
3271 }
3272
3273 /**
3274  * gst_base_parse_set_passthrough:
3275  * @parse: a #GstBaseParse
3276  * @passthrough: %TRUE if parser should run in passthrough mode
3277  *
3278  * Set if the nature of the format or configuration does not allow (much)
3279  * parsing, and the parser should operate in passthrough mode (which only
3280  * applies when operating in push mode). That is, incoming buffers are
3281  * pushed through unmodified, i.e. no @check_valid_frame or @parse_frame
3282  * callbacks will be invoked, but @pre_push_frame will still be invoked,
3283  * so subclass can perform as much or as little is appropriate for
3284  * passthrough semantics in @pre_push_frame.
3285  *
3286  * Since: 0.10.33
3287  */
3288 void
3289 gst_base_parse_set_passthrough (GstBaseParse * parse, gboolean passthrough)
3290 {
3291   parse->priv->passthrough = passthrough;
3292   GST_INFO_OBJECT (parse, "passthrough: %s", (passthrough) ? "yes" : "no");
3293 }
3294
3295 /**
3296  * gst_base_parse_set_latency:
3297  * @parse: a #GstBaseParse
3298  * @min_latency: minimum parse latency
3299  * @max_latency: maximum parse latency
3300  *
3301  * Sets the minimum and maximum (which may likely be equal) latency introduced
3302  * by the parsing process.  If there is such a latency, which depends on the
3303  * particular parsing of the format, it typically corresponds to 1 frame duration.
3304  *
3305  * Since: 0.10.36
3306  */
3307 void
3308 gst_base_parse_set_latency (GstBaseParse * parse, GstClockTime min_latency,
3309     GstClockTime max_latency)
3310 {
3311   GST_OBJECT_LOCK (parse);
3312   parse->priv->min_latency = min_latency;
3313   parse->priv->max_latency = max_latency;
3314   GST_OBJECT_UNLOCK (parse);
3315   GST_INFO_OBJECT (parse, "min/max latency %" GST_TIME_FORMAT ", %"
3316       GST_TIME_FORMAT, GST_TIME_ARGS (min_latency),
3317       GST_TIME_ARGS (max_latency));
3318 }
3319
3320 static gboolean
3321 gst_base_parse_get_duration (GstBaseParse * parse, GstFormat format,
3322     GstClockTime * duration)
3323 {
3324   gboolean res = FALSE;
3325
3326   g_return_val_if_fail (duration != NULL, FALSE);
3327
3328   *duration = GST_CLOCK_TIME_NONE;
3329   if (parse->priv->duration != -1 && format == parse->priv->duration_fmt) {
3330     GST_LOG_OBJECT (parse, "using provided duration");
3331     *duration = parse->priv->duration;
3332     res = TRUE;
3333   } else if (parse->priv->duration != -1) {
3334     GST_LOG_OBJECT (parse, "converting provided duration");
3335     res = gst_base_parse_convert (parse, parse->priv->duration_fmt,
3336         parse->priv->duration, format, (gint64 *) duration);
3337   } else if (format == GST_FORMAT_TIME && parse->priv->estimated_duration != -1) {
3338     GST_LOG_OBJECT (parse, "using estimated duration");
3339     *duration = parse->priv->estimated_duration;
3340     res = TRUE;
3341   } else {
3342     GST_LOG_OBJECT (parse, "cannot estimate duration");
3343   }
3344
3345   GST_LOG_OBJECT (parse, "res: %d, duration %" GST_TIME_FORMAT, res,
3346       GST_TIME_ARGS (*duration));
3347   return res;
3348 }
3349
3350 static gboolean
3351 gst_base_parse_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
3352 {
3353   GstBaseParse *parse;
3354   gboolean res = FALSE;
3355
3356   parse = GST_BASE_PARSE (parent);
3357
3358   GST_LOG_OBJECT (parse, "handling query: %" GST_PTR_FORMAT, query);
3359
3360   switch (GST_QUERY_TYPE (query)) {
3361     case GST_QUERY_POSITION:
3362     {
3363       gint64 dest_value;
3364       GstFormat format;
3365
3366       GST_DEBUG_OBJECT (parse, "position query");
3367       gst_query_parse_position (query, &format, NULL);
3368
3369       /* try upstream first */
3370       res = gst_pad_query_default (pad, parent, query);
3371       if (!res) {
3372         /* Fall back on interpreting segment */
3373         GST_OBJECT_LOCK (parse);
3374         if (format == GST_FORMAT_BYTES) {
3375           dest_value = parse->priv->offset;
3376           res = TRUE;
3377         } else if (format == parse->segment.format &&
3378             GST_CLOCK_TIME_IS_VALID (parse->segment.position)) {
3379           dest_value = gst_segment_to_stream_time (&parse->segment,
3380               parse->segment.format, parse->segment.position);
3381           res = TRUE;
3382         }
3383         GST_OBJECT_UNLOCK (parse);
3384         if (!res) {
3385           /* no precise result, upstream no idea either, then best estimate */
3386           /* priv->offset is updated in both PUSH/PULL modes */
3387           res = gst_base_parse_convert (parse,
3388               GST_FORMAT_BYTES, parse->priv->offset, format, &dest_value);
3389         }
3390         if (res)
3391           gst_query_set_position (query, format, dest_value);
3392       }
3393       break;
3394     }
3395     case GST_QUERY_DURATION:
3396     {
3397       GstFormat format;
3398       GstClockTime duration;
3399
3400       GST_DEBUG_OBJECT (parse, "duration query");
3401       gst_query_parse_duration (query, &format, NULL);
3402
3403       /* consult upstream */
3404       res = gst_pad_query_default (pad, parent, query);
3405
3406       /* otherwise best estimate from us */
3407       if (!res) {
3408         res = gst_base_parse_get_duration (parse, format, &duration);
3409         if (res)
3410           gst_query_set_duration (query, format, duration);
3411       }
3412       break;
3413     }
3414     case GST_QUERY_SEEKING:
3415     {
3416       GstFormat fmt;
3417       GstClockTime duration = GST_CLOCK_TIME_NONE;
3418       gboolean seekable = FALSE;
3419
3420       GST_DEBUG_OBJECT (parse, "seeking query");
3421       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
3422
3423       /* consult upstream */
3424       res = gst_pad_query_default (pad, parent, query);
3425
3426       /* we may be able to help if in TIME */
3427       if (fmt == GST_FORMAT_TIME && gst_base_parse_is_seekable (parse)) {
3428         gst_query_parse_seeking (query, &fmt, &seekable, NULL, NULL);
3429         /* already OK if upstream takes care */
3430         GST_LOG_OBJECT (parse, "upstream handled %d, seekable %d",
3431             res, seekable);
3432         if (!(res && seekable)) {
3433           if (!gst_base_parse_get_duration (parse, GST_FORMAT_TIME, &duration)
3434               || duration == -1) {
3435             /* seekable if we still have a chance to get duration later on */
3436             seekable =
3437                 parse->priv->upstream_seekable && parse->priv->update_interval;
3438           } else {
3439             seekable = parse->priv->upstream_seekable;
3440             GST_LOG_OBJECT (parse, "already determine upstream seekabled: %d",
3441                 seekable);
3442           }
3443           gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0, duration);
3444           res = TRUE;
3445         }
3446       }
3447       break;
3448     }
3449     case GST_QUERY_FORMATS:
3450       gst_query_set_formatsv (query, 3, fmtlist);
3451       res = TRUE;
3452       break;
3453     case GST_QUERY_CONVERT:
3454     {
3455       GstFormat src_format, dest_format;
3456       gint64 src_value, dest_value;
3457
3458       gst_query_parse_convert (query, &src_format, &src_value,
3459           &dest_format, &dest_value);
3460
3461       res = gst_base_parse_convert (parse, src_format, src_value,
3462           dest_format, &dest_value);
3463       if (res) {
3464         gst_query_set_convert (query, src_format, src_value,
3465             dest_format, dest_value);
3466       }
3467       break;
3468     }
3469     case GST_QUERY_LATENCY:
3470     {
3471       if ((res = gst_pad_peer_query (parse->sinkpad, query))) {
3472         gboolean live;
3473         GstClockTime min_latency, max_latency;
3474
3475         gst_query_parse_latency (query, &live, &min_latency, &max_latency);
3476         GST_DEBUG_OBJECT (parse, "Peer latency: live %d, min %"
3477             GST_TIME_FORMAT " max %" GST_TIME_FORMAT, live,
3478             GST_TIME_ARGS (min_latency), GST_TIME_ARGS (max_latency));
3479
3480         GST_OBJECT_LOCK (parse);
3481         /* add our latency */
3482         if (min_latency != -1)
3483           min_latency += parse->priv->min_latency;
3484         if (max_latency != -1)
3485           max_latency += parse->priv->max_latency;
3486         GST_OBJECT_UNLOCK (parse);
3487
3488         gst_query_set_latency (query, live, min_latency, max_latency);
3489       }
3490       break;
3491     }
3492     default:
3493       res = gst_pad_query_default (pad, parent, query);
3494       break;
3495   }
3496   return res;
3497 }
3498
3499 /* scans for a cluster start from @pos,
3500  * return GST_FLOW_OK and frame position/time in @pos/@time if found */
3501 static GstFlowReturn
3502 gst_base_parse_find_frame (GstBaseParse * parse, gint64 * pos,
3503     GstClockTime * time, GstClockTime * duration)
3504 {
3505   GstBaseParseClass *klass;
3506   gint64 orig_offset;
3507   gboolean orig_drain, orig_discont;
3508   GstFlowReturn ret = GST_FLOW_OK;
3509   GstBuffer *buf = NULL;
3510   GstBaseParseFrame *sframe = NULL;
3511
3512   g_return_val_if_fail (pos != NULL, GST_FLOW_ERROR);
3513   g_return_val_if_fail (time != NULL, GST_FLOW_ERROR);
3514   g_return_val_if_fail (duration != NULL, GST_FLOW_ERROR);
3515
3516   klass = GST_BASE_PARSE_GET_CLASS (parse);
3517
3518   *time = GST_CLOCK_TIME_NONE;
3519   *duration = GST_CLOCK_TIME_NONE;
3520
3521   /* save state */
3522   orig_offset = parse->priv->offset;
3523   orig_discont = parse->priv->discont;
3524   orig_drain = parse->priv->drain;
3525
3526   GST_DEBUG_OBJECT (parse, "scanning for frame starting at %" G_GINT64_FORMAT
3527       " (%#" G_GINT64_MODIFIER "x)", *pos, *pos);
3528
3529   /* jump elsewhere and locate next frame */
3530   parse->priv->offset = *pos;
3531   /* mark as scanning so frames don't get processed all the way */
3532   parse->priv->scanning = TRUE;
3533   ret = gst_base_parse_scan_frame (parse, klass, FALSE);
3534   parse->priv->scanning = FALSE;
3535   /* retrieve frame found during scan */
3536   sframe = parse->priv->scanned_frame;
3537   parse->priv->scanned_frame = NULL;
3538
3539   if (ret != GST_FLOW_OK || !sframe)
3540     goto done;
3541
3542   /* get offset first, subclass parsing might dump other stuff in there */
3543   *pos = sframe->offset;
3544   buf = sframe->buffer;
3545   g_assert (buf);
3546
3547   /* but it should provide proper time */
3548   *time = GST_BUFFER_TIMESTAMP (buf);
3549   *duration = GST_BUFFER_DURATION (buf);
3550
3551   GST_LOG_OBJECT (parse,
3552       "frame with time %" GST_TIME_FORMAT " at offset %" G_GINT64_FORMAT,
3553       GST_TIME_ARGS (*time), *pos);
3554
3555 done:
3556   if (sframe)
3557     gst_base_parse_frame_free (sframe);
3558
3559   /* restore state */
3560   parse->priv->offset = orig_offset;
3561   parse->priv->discont = orig_discont;
3562   parse->priv->drain = orig_drain;
3563
3564   return ret;
3565 }
3566
3567 /* bisect and scan through file for frame starting before @time,
3568  * returns OK and @time/@offset if found, NONE and/or error otherwise
3569  * If @time == G_MAXINT64, scan for duration ( == last frame) */
3570 static GstFlowReturn
3571 gst_base_parse_locate_time (GstBaseParse * parse, GstClockTime * _time,
3572     gint64 * _offset)
3573 {
3574   GstFlowReturn ret = GST_FLOW_OK;
3575   gint64 lpos, hpos, newpos;
3576   GstClockTime time, ltime, htime, newtime, dur;
3577   gboolean cont = TRUE;
3578   const GstClockTime tolerance = TARGET_DIFFERENCE;
3579   const guint chunk = 4 * 1024;
3580
3581   g_return_val_if_fail (_time != NULL, GST_FLOW_ERROR);
3582   g_return_val_if_fail (_offset != NULL, GST_FLOW_ERROR);
3583
3584   GST_DEBUG_OBJECT (parse, "Bisecting for time %" GST_TIME_FORMAT,
3585       GST_TIME_ARGS (*_time));
3586
3587   /* TODO also make keyframe aware if useful some day */
3588
3589   time = *_time;
3590
3591   /* basic cases */
3592   if (time == 0) {
3593     *_offset = 0;
3594     return GST_FLOW_OK;
3595   }
3596
3597   if (time == -1) {
3598     *_offset = -1;
3599     return GST_FLOW_OK;
3600   }
3601
3602   /* do not know at first */
3603   *_offset = -1;
3604   *_time = GST_CLOCK_TIME_NONE;
3605
3606   /* need initial positions; start and end */
3607   lpos = parse->priv->first_frame_offset;
3608   ltime = parse->priv->first_frame_ts;
3609   if (!gst_base_parse_get_duration (parse, GST_FORMAT_TIME, &htime)) {
3610     GST_DEBUG_OBJECT (parse, "Unknown time duration, cannot bisect");
3611     return GST_FLOW_ERROR;
3612   }
3613   hpos = parse->priv->upstream_size;
3614
3615   GST_DEBUG_OBJECT (parse,
3616       "Bisection initial bounds: bytes %" G_GINT64_FORMAT " %" G_GINT64_FORMAT
3617       ", times %" GST_TIME_FORMAT " %" GST_TIME_FORMAT, lpos, htime,
3618       GST_TIME_ARGS (ltime), GST_TIME_ARGS (htime));
3619
3620   /* check preconditions are satisfied;
3621    * start and end are needed, except for special case where we scan for
3622    * last frame to determine duration */
3623   if (parse->priv->pad_mode != GST_PAD_MODE_PULL || !hpos ||
3624       !GST_CLOCK_TIME_IS_VALID (ltime) ||
3625       (!GST_CLOCK_TIME_IS_VALID (htime) && time != G_MAXINT64)) {
3626     return GST_FLOW_OK;
3627   }
3628
3629   /* shortcut cases */
3630   if (time < ltime) {
3631     goto exit;
3632   } else if (time < ltime + tolerance) {
3633     *_offset = lpos;
3634     *_time = ltime;
3635     goto exit;
3636   } else if (time >= htime) {
3637     *_offset = hpos;
3638     *_time = htime;
3639     goto exit;
3640   }
3641
3642   while (htime > ltime && cont) {
3643     GST_LOG_OBJECT (parse,
3644         "lpos: %" G_GUINT64_FORMAT ", ltime: %" GST_TIME_FORMAT, lpos,
3645         GST_TIME_ARGS (ltime));
3646     GST_LOG_OBJECT (parse,
3647         "hpos: %" G_GUINT64_FORMAT ", htime: %" GST_TIME_FORMAT, hpos,
3648         GST_TIME_ARGS (htime));
3649     if (G_UNLIKELY (time == G_MAXINT64)) {
3650       newpos = hpos;
3651     } else if (G_LIKELY (hpos > lpos)) {
3652       newpos =
3653           gst_util_uint64_scale (hpos - lpos, time - ltime, htime - ltime) +
3654           lpos - chunk;
3655     } else {
3656       /* should mean lpos == hpos, since lpos <= hpos is invariant */
3657       newpos = lpos;
3658       /* we check this case once, but not forever, so break loop */
3659       cont = FALSE;
3660     }
3661
3662     /* ensure */
3663     newpos = CLAMP (newpos, lpos, hpos);
3664     GST_LOG_OBJECT (parse,
3665         "estimated _offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT,
3666         GST_TIME_ARGS (time), newpos);
3667
3668     ret = gst_base_parse_find_frame (parse, &newpos, &newtime, &dur);
3669     if (ret == GST_FLOW_EOS) {
3670       /* heuristic HACK */
3671       hpos = MAX (lpos, hpos - chunk);
3672       continue;
3673     } else if (ret != GST_FLOW_OK) {
3674       goto exit;
3675     }
3676
3677     if (newtime == -1 || newpos == -1) {
3678       GST_DEBUG_OBJECT (parse, "subclass did not provide metadata; aborting");
3679       break;
3680     }
3681
3682     if (G_UNLIKELY (time == G_MAXINT64)) {
3683       *_offset = newpos;
3684       *_time = newtime;
3685       if (GST_CLOCK_TIME_IS_VALID (dur))
3686         *_time += dur;
3687       break;
3688     } else if (newtime > time) {
3689       /* overshoot */
3690       hpos = (newpos >= hpos) ? MAX (lpos, hpos - chunk) : MAX (lpos, newpos);
3691       htime = newtime;
3692     } else if (newtime + tolerance > time) {
3693       /* close enough undershoot */
3694       *_offset = newpos;
3695       *_time = newtime;
3696       break;
3697     } else if (newtime < ltime) {
3698       /* so a position beyond lpos resulted in earlier time than ltime ... */
3699       GST_DEBUG_OBJECT (parse, "non-ascending time; aborting");
3700       break;
3701     } else {
3702       /* undershoot too far */
3703       newpos += newpos == lpos ? chunk : 0;
3704       lpos = CLAMP (newpos, lpos, hpos);
3705       ltime = newtime;
3706     }
3707   }
3708
3709 exit:
3710   GST_LOG_OBJECT (parse, "return offset %" G_GINT64_FORMAT ", time %"
3711       GST_TIME_FORMAT, *_offset, GST_TIME_ARGS (*_time));
3712   return ret;
3713 }
3714
3715 static gint64
3716 gst_base_parse_find_offset (GstBaseParse * parse, GstClockTime time,
3717     gboolean before, GstClockTime * _ts)
3718 {
3719   gint64 bytes = 0, ts = 0;
3720   GstIndexEntry *entry = NULL;
3721
3722   if (time == GST_CLOCK_TIME_NONE) {
3723     ts = time;
3724     bytes = -1;
3725     goto exit;
3726   }
3727
3728   GST_BASE_PARSE_INDEX_LOCK (parse);
3729   if (parse->priv->index) {
3730     /* Let's check if we have an index entry for that time */
3731     entry = gst_index_get_assoc_entry (parse->priv->index,
3732         parse->priv->index_id,
3733         before ? GST_INDEX_LOOKUP_BEFORE : GST_INDEX_LOOKUP_AFTER,
3734         GST_INDEX_ASSOCIATION_FLAG_KEY_UNIT, GST_FORMAT_TIME, time);
3735   }
3736
3737   if (entry) {
3738     gst_index_entry_assoc_map (entry, GST_FORMAT_BYTES, &bytes);
3739     gst_index_entry_assoc_map (entry, GST_FORMAT_TIME, &ts);
3740
3741     GST_DEBUG_OBJECT (parse, "found index entry for %" GST_TIME_FORMAT
3742         " at %" GST_TIME_FORMAT ", offset %" G_GINT64_FORMAT,
3743         GST_TIME_ARGS (time), GST_TIME_ARGS (ts), bytes);
3744   } else {
3745     GST_DEBUG_OBJECT (parse, "no index entry found for %" GST_TIME_FORMAT,
3746         GST_TIME_ARGS (time));
3747     if (!before) {
3748       bytes = -1;
3749       ts = GST_CLOCK_TIME_NONE;
3750     }
3751   }
3752   GST_BASE_PARSE_INDEX_UNLOCK (parse);
3753
3754 exit:
3755   if (_ts)
3756     *_ts = ts;
3757
3758   return bytes;
3759 }
3760
3761 /* returns TRUE if seek succeeded */
3762 static gboolean
3763 gst_base_parse_handle_seek (GstBaseParse * parse, GstEvent * event)
3764 {
3765   gdouble rate;
3766   GstFormat format;
3767   GstSeekFlags flags;
3768   GstSeekType cur_type = GST_SEEK_TYPE_NONE, stop_type;
3769   gboolean flush, update, res = TRUE, accurate;
3770   gint64 cur, stop, seekpos, seekstop;
3771   GstSegment seeksegment = { 0, };
3772   GstClockTime start_ts;
3773
3774   gst_event_parse_seek (event, &rate, &format, &flags,
3775       &cur_type, &cur, &stop_type, &stop);
3776
3777   GST_DEBUG_OBJECT (parse, "seek to format %s, rate %f, "
3778       "start type %d at %" GST_TIME_FORMAT ", end type %d at %"
3779       GST_TIME_FORMAT, gst_format_get_name (format), rate,
3780       cur_type, GST_TIME_ARGS (cur), stop_type, GST_TIME_ARGS (stop));
3781
3782   /* no negative rates in push mode */
3783   if (rate < 0.0 && parse->priv->pad_mode == GST_PAD_MODE_PUSH)
3784     goto negative_rate;
3785
3786   if (cur_type != GST_SEEK_TYPE_SET ||
3787       (stop_type != GST_SEEK_TYPE_SET && stop_type != GST_SEEK_TYPE_NONE))
3788     goto wrong_type;
3789
3790   /* For any format other than TIME, see if upstream handles
3791    * it directly or fail. For TIME, try upstream, but do it ourselves if
3792    * it fails upstream */
3793   res = gst_pad_push_event (parse->sinkpad, event);
3794   if (format != GST_FORMAT_TIME || res)
3795     goto done;
3796
3797   /* get flush flag */
3798   flush = flags & GST_SEEK_FLAG_FLUSH;
3799
3800   /* copy segment, we need this because we still need the old
3801    * segment when we close the current segment. */
3802   gst_segment_copy_into (&parse->segment, &seeksegment);
3803
3804   GST_DEBUG_OBJECT (parse, "configuring seek");
3805   gst_segment_do_seek (&seeksegment, rate, format, flags,
3806       cur_type, cur, stop_type, stop, &update);
3807
3808   /* accurate seeking implies seek tables are used to obtain position,
3809    * and the requested segment is maintained exactly, not adjusted any way */
3810   accurate = flags & GST_SEEK_FLAG_ACCURATE;
3811
3812   /* maybe we can be accurate for (almost) free */
3813   gst_base_parse_find_offset (parse, seeksegment.position, TRUE, &start_ts);
3814   if (seeksegment.position <= start_ts + TARGET_DIFFERENCE) {
3815     GST_DEBUG_OBJECT (parse, "accurate seek possible");
3816     accurate = TRUE;
3817   }
3818   if (accurate) {
3819     GstClockTime startpos = seeksegment.position;
3820
3821     /* accurate requested, so ... seek a bit before target */
3822     if (startpos < parse->priv->lead_in_ts)
3823       startpos = 0;
3824     else
3825       startpos -= parse->priv->lead_in_ts;
3826     seekpos = gst_base_parse_find_offset (parse, startpos, TRUE, &start_ts);
3827     seekstop = gst_base_parse_find_offset (parse, seeksegment.stop, FALSE,
3828         NULL);
3829   } else {
3830     start_ts = seeksegment.position;
3831     if (!gst_pad_query_convert (parse->srcpad, format, seeksegment.position,
3832             GST_FORMAT_BYTES, &seekpos))
3833       goto convert_failed;
3834     if (!gst_pad_query_convert (parse->srcpad, format, seeksegment.stop,
3835             GST_FORMAT_BYTES, &seekstop))
3836       goto convert_failed;
3837   }
3838
3839   GST_DEBUG_OBJECT (parse,
3840       "seek position %" G_GINT64_FORMAT " in bytes: %" G_GINT64_FORMAT,
3841       start_ts, seekpos);
3842   GST_DEBUG_OBJECT (parse,
3843       "seek stop %" G_GINT64_FORMAT " in bytes: %" G_GINT64_FORMAT,
3844       seeksegment.stop, seekstop);
3845
3846   if (parse->priv->pad_mode == GST_PAD_MODE_PULL) {
3847     gint64 last_stop;
3848
3849     GST_DEBUG_OBJECT (parse, "seek in PULL mode");
3850
3851     if (flush) {
3852       if (parse->srcpad) {
3853         GST_DEBUG_OBJECT (parse, "sending flush start");
3854         gst_pad_push_event (parse->srcpad, gst_event_new_flush_start ());
3855         /* unlock upstream pull_range */
3856         gst_pad_push_event (parse->sinkpad, gst_event_new_flush_start ());
3857       }
3858     } else {
3859       gst_pad_pause_task (parse->sinkpad);
3860     }
3861
3862     /* we should now be able to grab the streaming thread because we stopped it
3863      * with the above flush/pause code */
3864     GST_PAD_STREAM_LOCK (parse->sinkpad);
3865
3866     /* save current position */
3867     last_stop = parse->segment.position;
3868     GST_DEBUG_OBJECT (parse, "stopped streaming at %" G_GINT64_FORMAT,
3869         last_stop);
3870
3871     /* now commit to new position */
3872
3873     /* prepare for streaming again */
3874     if (flush) {
3875       GST_DEBUG_OBJECT (parse, "sending flush stop");
3876       gst_pad_push_event (parse->srcpad, gst_event_new_flush_stop (TRUE));
3877       gst_pad_push_event (parse->sinkpad, gst_event_new_flush_stop (TRUE));
3878       gst_base_parse_clear_queues (parse);
3879     } else {
3880       /* keep track of our position */
3881       seeksegment.base = gst_segment_to_running_time (&seeksegment,
3882           seeksegment.format, parse->segment.position);
3883     }
3884
3885     memcpy (&parse->segment, &seeksegment, sizeof (GstSegment));
3886
3887     /* store the newsegment event so it can be sent from the streaming thread. */
3888     if (parse->priv->pending_segment)
3889       gst_event_unref (parse->priv->pending_segment);
3890
3891     /* This will be sent later in _loop() */
3892     parse->priv->pending_segment = gst_event_new_segment (&parse->segment);
3893
3894     GST_DEBUG_OBJECT (parse, "Created newseg format %d, "
3895         "start = %" GST_TIME_FORMAT ", stop = %" GST_TIME_FORMAT
3896         ", pos = %" GST_TIME_FORMAT, format,
3897         GST_TIME_ARGS (parse->segment.start),
3898         GST_TIME_ARGS (parse->segment.stop),
3899         GST_TIME_ARGS (parse->segment.start));
3900
3901     /* one last chance in pull mode to stay accurate;
3902      * maybe scan and subclass can find where to go */
3903     if (!accurate) {
3904       gint64 scanpos;
3905       GstClockTime ts = seeksegment.position;
3906
3907       gst_base_parse_locate_time (parse, &ts, &scanpos);
3908       if (scanpos >= 0) {
3909         accurate = TRUE;
3910         seekpos = scanpos;
3911         /* running collected index now consists of several intervals,
3912          * so optimized check no longer possible */
3913         parse->priv->index_last_valid = FALSE;
3914         parse->priv->index_last_offset = 0;
3915         parse->priv->index_last_ts = 0;
3916       }
3917     }
3918
3919     /* mark discont if we are going to stream from another position. */
3920     if (seekpos != parse->priv->offset) {
3921       GST_DEBUG_OBJECT (parse,
3922           "mark DISCONT, we did a seek to another position");
3923       parse->priv->offset = seekpos;
3924       parse->priv->last_offset = seekpos;
3925       parse->priv->seen_keyframe = FALSE;
3926       parse->priv->discont = TRUE;
3927       parse->priv->next_ts = start_ts;
3928       parse->priv->last_ts = GST_CLOCK_TIME_NONE;
3929       parse->priv->sync_offset = seekpos;
3930       parse->priv->exact_position = accurate;
3931     }
3932
3933     /* Start streaming thread if paused */
3934     gst_pad_start_task (parse->sinkpad,
3935         (GstTaskFunction) gst_base_parse_loop, parse->sinkpad);
3936
3937     GST_PAD_STREAM_UNLOCK (parse->sinkpad);
3938
3939     /* handled seek */
3940     res = TRUE;
3941   } else {
3942     GstEvent *new_event;
3943     GstBaseParseSeek *seek;
3944     GstSeekFlags flags = (flush ? GST_SEEK_FLAG_FLUSH : GST_SEEK_FLAG_NONE);
3945
3946     /* The only thing we need to do in PUSH-mode is to send the
3947        seek event (in bytes) to upstream. Segment / flush handling happens
3948        in corresponding src event handlers */
3949     GST_DEBUG_OBJECT (parse, "seek in PUSH mode");
3950     if (seekstop >= 0 && seekstop <= seekpos)
3951       seekstop = seekpos;
3952     new_event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags,
3953         GST_SEEK_TYPE_SET, seekpos, stop_type, seekstop);
3954
3955     /* store segment info so its precise details can be reconstructed when
3956      * receiving newsegment;
3957      * this matters for all details when accurate seeking,
3958      * is most useful to preserve NONE stop time otherwise */
3959     seek = g_new0 (GstBaseParseSeek, 1);
3960     seek->segment = seeksegment;
3961     seek->accurate = accurate;
3962     seek->offset = seekpos;
3963     seek->start_ts = start_ts;
3964     GST_OBJECT_LOCK (parse);
3965     /* less optimal, but preserves order */
3966     parse->priv->pending_seeks =
3967         g_slist_append (parse->priv->pending_seeks, seek);
3968     GST_OBJECT_UNLOCK (parse);
3969
3970     res = gst_pad_push_event (parse->sinkpad, new_event);
3971
3972     if (!res) {
3973       GST_OBJECT_LOCK (parse);
3974       parse->priv->pending_seeks =
3975           g_slist_remove (parse->priv->pending_seeks, seek);
3976       GST_OBJECT_UNLOCK (parse);
3977       g_free (seek);
3978     }
3979   }
3980
3981 done:
3982   return res;
3983
3984   /* ERRORS */
3985 negative_rate:
3986   {
3987     GST_DEBUG_OBJECT (parse, "negative playback rates delegated upstream.");
3988     res = FALSE;
3989     goto done;
3990   }
3991 wrong_type:
3992   {
3993     GST_DEBUG_OBJECT (parse, "unsupported seek type.");
3994     res = FALSE;
3995     goto done;
3996   }
3997 convert_failed:
3998   {
3999     GST_DEBUG_OBJECT (parse, "conversion TIME to BYTES failed.");
4000     res = FALSE;
4001     goto done;
4002   }
4003 }
4004
4005 /* Checks if bitrates are available from upstream tags so that we don't
4006  * override them later
4007  */
4008 static void
4009 gst_base_parse_handle_tag (GstBaseParse * parse, GstEvent * event)
4010 {
4011   GstTagList *taglist = NULL;
4012   guint tmp;
4013
4014   gst_event_parse_tag (event, &taglist);
4015
4016   if (gst_tag_list_get_uint (taglist, GST_TAG_MINIMUM_BITRATE, &tmp)) {
4017     GST_DEBUG_OBJECT (parse, "upstream min bitrate %d", tmp);
4018     parse->priv->post_min_bitrate = FALSE;
4019   }
4020   if (gst_tag_list_get_uint (taglist, GST_TAG_BITRATE, &tmp)) {
4021     GST_DEBUG_OBJECT (parse, "upstream avg bitrate %d", tmp);
4022     parse->priv->post_avg_bitrate = FALSE;
4023   }
4024   if (gst_tag_list_get_uint (taglist, GST_TAG_MAXIMUM_BITRATE, &tmp)) {
4025     GST_DEBUG_OBJECT (parse, "upstream max bitrate %d", tmp);
4026     parse->priv->post_max_bitrate = FALSE;
4027   }
4028 }
4029
4030 #if 0
4031 static void
4032 gst_base_parse_set_index (GstElement * element, GstIndex * index)
4033 {
4034   GstBaseParse *parse = GST_BASE_PARSE (element);
4035
4036   GST_BASE_PARSE_INDEX_LOCK (parse);
4037   if (parse->priv->index)
4038     gst_object_unref (parse->priv->index);
4039   if (index) {
4040     parse->priv->index = gst_object_ref (index);
4041     gst_index_get_writer_id (index, GST_OBJECT_CAST (element),
4042         &parse->priv->index_id);
4043     parse->priv->own_index = FALSE;
4044   } else {
4045     parse->priv->index = NULL;
4046   }
4047   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4048 }
4049
4050 static GstIndex *
4051 gst_base_parse_get_index (GstElement * element)
4052 {
4053   GstBaseParse *parse = GST_BASE_PARSE (element);
4054   GstIndex *result = NULL;
4055
4056   GST_BASE_PARSE_INDEX_LOCK (parse);
4057   if (parse->priv->index)
4058     result = gst_object_ref (parse->priv->index);
4059   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4060
4061   return result;
4062 }
4063 #endif
4064
4065 static GstStateChangeReturn
4066 gst_base_parse_change_state (GstElement * element, GstStateChange transition)
4067 {
4068   GstBaseParse *parse;
4069   GstStateChangeReturn result;
4070
4071   parse = GST_BASE_PARSE (element);
4072
4073   switch (transition) {
4074     case GST_STATE_CHANGE_READY_TO_PAUSED:
4075       /* If this is our own index destroy it as the
4076        * old entries might be wrong for the new stream */
4077       GST_BASE_PARSE_INDEX_LOCK (parse);
4078       if (parse->priv->own_index) {
4079         gst_object_unref (parse->priv->index);
4080         parse->priv->index = NULL;
4081         parse->priv->own_index = FALSE;
4082       }
4083
4084       /* If no index was created, generate one */
4085       if (G_UNLIKELY (!parse->priv->index)) {
4086         GST_DEBUG_OBJECT (parse, "no index provided creating our own");
4087
4088         parse->priv->index = g_object_new (gst_mem_index_get_type (), NULL);
4089         gst_index_get_writer_id (parse->priv->index, GST_OBJECT (parse),
4090             &parse->priv->index_id);
4091         parse->priv->own_index = TRUE;
4092       }
4093       GST_BASE_PARSE_INDEX_UNLOCK (parse);
4094       break;
4095     default:
4096       break;
4097   }
4098
4099   result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
4100
4101   switch (transition) {
4102     case GST_STATE_CHANGE_PAUSED_TO_READY:
4103       gst_base_parse_reset (parse);
4104       break;
4105     default:
4106       break;
4107   }
4108
4109   return result;
4110 }