libs/gst/base/gstbaseparse.c

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