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., 51 Franklin St, Fifth Floor,
  21  * Boston, MA 02110-1301, 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 (SEGMENT/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_frame_size() could also be used if a
  92  *       very 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 overridden) 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 #define MAX_INDEX_ENTRIES          4096
 222
 223 GST_DEBUG_CATEGORY_STATIC (gst_base_parse_debug);
 224 #define GST_CAT_DEFAULT gst_base_parse_debug
 225
 226 /* Supported formats */
 227 static const GstFormat fmtlist[] = {
 228   GST_FORMAT_DEFAULT,
 229   GST_FORMAT_BYTES,
 230   GST_FORMAT_TIME,
 231   GST_FORMAT_UNDEFINED
 232 };
 233
 234 #define GST_BASE_PARSE_GET_PRIVATE(obj)  \
 235     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_PARSE, GstBaseParsePrivate))
 236
 237 struct _GstBaseParsePrivate
 238 {
 239   GstPadMode pad_mode;
 240
 241   GstAdapter *adapter;
 242
 243   gint64 duration;
 244   GstFormat duration_fmt;
 245   gint64 estimated_duration;
 246   gint64 estimated_drift;
 247
 248   guint min_frame_size;
 249   gboolean disable_passthrough;
 250   gboolean passthrough;
 251   gboolean pts_interpolate;
 252   gboolean infer_ts;
 253   gboolean syncable;
 254   gboolean has_timing_info;
 255   guint fps_num, fps_den;
 256   gint update_interval;
 257   guint bitrate;
 258   guint lead_in, lead_out;
 259   GstClockTime lead_in_ts, lead_out_ts;
 260   GstClockTime min_latency, max_latency;
 261
 262   gboolean discont;
 263   gboolean flushing;
 264   gboolean drain;
 265   gboolean saw_gaps;
 266
 267   gint64 offset;
 268   gint64 sync_offset;
 269   GstClockTime next_pts;
 270   GstClockTime next_dts;
 271   GstClockTime prev_pts;
 272   GstClockTime prev_dts;
 273   GstClockTime frame_duration;
 274   gboolean seen_keyframe;
 275   gboolean is_video;
 276   gint flushed;
 277
 278   guint64 framecount;
 279   guint64 bytecount;
 280   guint64 data_bytecount;
 281   guint64 acc_duration;
 282   GstClockTime first_frame_pts;
 283   GstClockTime first_frame_dts;
 284   gint64 first_frame_offset;
 285
 286   gboolean post_min_bitrate;
 287   gboolean post_avg_bitrate;
 288   gboolean post_max_bitrate;
 289
 290   guint min_bitrate;
 291   guint avg_bitrate;
 292   guint max_bitrate;
 293   guint posted_avg_bitrate;
 294
 295   /* frames/buffers that are queued and ready to go on OK */
 296   GQueue queued_frames;
 297
 298   GstBuffer *cache;
 299
 300   /* index entry storage, either ours or provided */
 301   GstIndex *index;
 302   gint index_id;
 303   gboolean own_index;
 304   GMutex index_lock;
 305
 306   /* seek table entries only maintained if upstream is BYTE seekable */
 307   gboolean upstream_seekable;
 308   gboolean upstream_has_duration;
 309   gint64 upstream_size;
 310   GstFormat upstream_format;
 311   /* minimum distance between two index entries */
 312   GstClockTimeDiff idx_interval;
 313   guint64 idx_byte_interval;
 314   /* ts and offset of last entry added */
 315   GstClockTime index_last_ts;
 316   gint64 index_last_offset;
 317   gboolean index_last_valid;
 318
 319   /* timestamps currently produced are accurate, e.g. started from 0 onwards */
 320   gboolean exact_position;
 321   /* seek events are temporarily kept to match them with newsegments */
 322   GSList *pending_seeks;
 323
 324   /* reverse playback */
 325   GSList *buffers_pending;
 326   GSList *buffers_head;
 327   GSList *buffers_queued;
 328   GSList *buffers_send;
 329   GstClockTime last_pts;
 330   GstClockTime last_dts;
 331   gint64 last_offset;
 332
 333   /* Pending serialized events */
 334   GList *pending_events;
 335
 336   /* If baseparse has checked the caps to identify if it is
 337    * handling video or audio */
 338   gboolean checked_media;
 339
 340   /* offset of last parsed frame/data */
 341   gint64 prev_offset;
 342   /* force a new frame, regardless of offset */
 343   gboolean new_frame;
 344   /* whether we are merely scanning for a frame */
 345   gboolean scanning;
 346   /* ... and resulting frame, if any */
 347   GstBaseParseFrame *scanned_frame;
 348
 349   /* TRUE if we're still detecting the format, i.e.
 350    * if ::detect() is still called for future buffers */
 351   gboolean detecting;
 352   GList *detect_buffers;
 353   guint detect_buffers_size;
 354
 355   /* True when no buffers have been received yet */
 356   gboolean first_buffer;
 357
 358   /* if TRUE, a STREAM_START event needs to be pushed */
 359   gboolean push_stream_start;
 360
 361   /* When we need to skip more data than we have currently */
 362   guint skip;
 363
 364   /* Tag handling (stream tags only, global tags are passed through as-is) */
 365   GstTagList *upstream_tags;
 366   GstTagList *parser_tags;
 367   GstTagMergeMode parser_tags_merge_mode;
 368   gboolean tags_changed;
 369 #ifdef GST_BASEPARSE_MODIFICATION
 370   /* to get pad mode early */
 371   GstPadMode expected_pad_mode;
 372   /* check first frame in base parser */
 373   gboolean first_frame;
 374   /* remove zero padding */
 375   gint64 remove_from_total;
 376   gboolean accurate_index_seek;
 377 #endif
 378 };
 379
 380 typedef struct _GstBaseParseSeek
 381 {
 382   GstSegment segment;
 383   gboolean accurate;
 384   gint64 offset;
 385   GstClockTime start_ts;
 386 } GstBaseParseSeek;
 387
 388 #define DEFAULT_DISABLE_PASSTHROUGH        FALSE
 389
 390 enum
 391 {
 392   PROP_0,
 393   PROP_DISABLE_PASSTHROUGH,
 394   PROP_LAST
 395 };
 396
 397 #define GST_BASE_PARSE_INDEX_LOCK(parse) \
 398   g_mutex_lock (&parse->priv->index_lock);
 399 #define GST_BASE_PARSE_INDEX_UNLOCK(parse) \
 400   g_mutex_unlock (&parse->priv->index_lock);
 401
 402 static GstElementClass *parent_class = NULL;
 403
 404 static void gst_base_parse_class_init (GstBaseParseClass * klass);
 405 static void gst_base_parse_init (GstBaseParse * parse,
 406     GstBaseParseClass * klass);
 407
 408 GType
 409 gst_base_parse_get_type (void)
 410 {
 411   static volatile gsize base_parse_type = 0;
 412
 413   if (g_once_init_enter (&base_parse_type)) {
 414     static const GTypeInfo base_parse_info = {
 415       sizeof (GstBaseParseClass),
 416       (GBaseInitFunc) NULL,
 417       (GBaseFinalizeFunc) NULL,
 418       (GClassInitFunc) gst_base_parse_class_init,
 419       NULL,
 420       NULL,
 421       sizeof (GstBaseParse),
 422       0,
 423       (GInstanceInitFunc) gst_base_parse_init,
 424     };
 425     GType _type;
 426
 427     _type = g_type_register_static (GST_TYPE_ELEMENT,
 428         "GstBaseParse", &base_parse_info, G_TYPE_FLAG_ABSTRACT);
 429     g_once_init_leave (&base_parse_type, _type);
 430   }
 431   return (GType) base_parse_type;
 432 }
 433
 434 static void gst_base_parse_finalize (GObject * object);
 435
 436 static GstStateChangeReturn gst_base_parse_change_state (GstElement * element,
 437     GstStateChange transition);
 438 static void gst_base_parse_reset (GstBaseParse * parse);
 439
 440 #if 0
 441 static void gst_base_parse_set_index (GstElement * element, GstIndex * index);
 442 static GstIndex *gst_base_parse_get_index (GstElement * element);
 443 #endif
 444
 445 static gboolean gst_base_parse_sink_activate (GstPad * sinkpad,
 446     GstObject * parent);
 447 static gboolean gst_base_parse_sink_activate_mode (GstPad * pad,
 448     GstObject * parent, GstPadMode mode, gboolean active);
 449 static gboolean gst_base_parse_handle_seek (GstBaseParse * parse,
 450     GstEvent * event);
 451 static void gst_base_parse_set_upstream_tags (GstBaseParse * parse,
 452     GstTagList * taglist);
 453
 454 static void gst_base_parse_set_property (GObject * object, guint prop_id,
 455     const GValue * value, GParamSpec * pspec);
 456 static void gst_base_parse_get_property (GObject * object, guint prop_id,
 457     GValue * value, GParamSpec * pspec);
 458
 459 static gboolean gst_base_parse_src_event (GstPad * pad, GstObject * parent,
 460     GstEvent * event);
 461 static gboolean gst_base_parse_src_query (GstPad * pad, GstObject * parent,
 462     GstQuery * query);
 463
 464 static gboolean gst_base_parse_sink_event (GstPad * pad, GstObject * parent,
 465     GstEvent * event);
 466 static gboolean gst_base_parse_sink_query (GstPad * pad, GstObject * parent,
 467     GstQuery * query);
 468
 469 static GstFlowReturn gst_base_parse_chain (GstPad * pad, GstObject * parent,
 470     GstBuffer * buffer);
 471 static void gst_base_parse_loop (GstPad * pad);
 472
 473 static GstFlowReturn gst_base_parse_parse_frame (GstBaseParse * parse,
 474     GstBaseParseFrame * frame);
 475
 476 static gboolean gst_base_parse_sink_event_default (GstBaseParse * parse,
 477     GstEvent * event);
 478
 479 static gboolean gst_base_parse_src_event_default (GstBaseParse * parse,
 480     GstEvent * event);
 481
 482 static gboolean gst_base_parse_sink_query_default (GstBaseParse * parse,
 483     GstQuery * query);
 484 static gboolean gst_base_parse_src_query_default (GstBaseParse * parse,
 485     GstQuery * query);
 486
 487 static void gst_base_parse_drain (GstBaseParse * parse);
 488
 489 static gint64 gst_base_parse_find_offset (GstBaseParse * parse,
 490     GstClockTime time, gboolean before, GstClockTime * _ts);
 491 static GstFlowReturn gst_base_parse_locate_time (GstBaseParse * parse,
 492     GstClockTime * _time, gint64 * _offset);
 493
 494 static GstFlowReturn gst_base_parse_start_fragment (GstBaseParse * parse);
 495 static GstFlowReturn gst_base_parse_finish_fragment (GstBaseParse * parse,
 496     gboolean prev_head);
 497 static GstFlowReturn gst_base_parse_send_buffers (GstBaseParse * parse);
 498
 499 static inline GstFlowReturn gst_base_parse_check_sync (GstBaseParse * parse);
 500
 501 static gboolean gst_base_parse_is_seekable (GstBaseParse * parse);
 502
 503 static void gst_base_parse_push_pending_events (GstBaseParse * parse);
 504
 505 static void
 506 gst_base_parse_clear_queues (GstBaseParse * parse)
 507 {
 508   g_slist_foreach (parse->priv->buffers_queued, (GFunc) gst_buffer_unref, NULL);
 509   g_slist_free (parse->priv->buffers_queued);
 510   parse->priv->buffers_queued = NULL;
 511   g_slist_foreach (parse->priv->buffers_pending, (GFunc) gst_buffer_unref,
 512       NULL);
 513   g_slist_free (parse->priv->buffers_pending);
 514   parse->priv->buffers_pending = NULL;
 515   g_slist_foreach (parse->priv->buffers_head, (GFunc) gst_buffer_unref, NULL);
 516   g_slist_free (parse->priv->buffers_head);
 517   parse->priv->buffers_head = NULL;
 518   g_slist_foreach (parse->priv->buffers_send, (GFunc) gst_buffer_unref, NULL);
 519   g_slist_free (parse->priv->buffers_send);
 520   parse->priv->buffers_send = NULL;
 521
 522   g_list_foreach (parse->priv->detect_buffers, (GFunc) gst_buffer_unref, NULL);
 523   g_list_free (parse->priv->detect_buffers);
 524   parse->priv->detect_buffers = NULL;
 525   parse->priv->detect_buffers_size = 0;
 526
 527   g_queue_foreach (&parse->priv->queued_frames,
 528       (GFunc) gst_base_parse_frame_free, NULL);
 529   g_queue_clear (&parse->priv->queued_frames);
 530
 531   gst_buffer_replace (&parse->priv->cache, NULL);
 532
 533   g_list_foreach (parse->priv->pending_events, (GFunc) gst_event_unref, NULL);
 534   g_list_free (parse->priv->pending_events);
 535   parse->priv->pending_events = NULL;
 536
 537   parse->priv->checked_media = FALSE;
 538 }
 539
 540 static void
 541 gst_base_parse_finalize (GObject * object)
 542 {
 543   GstBaseParse *parse = GST_BASE_PARSE (object);
 544
 545   g_object_unref (parse->priv->adapter);
 546
 547   if (parse->priv->index) {
 548     gst_object_unref (parse->priv->index);
 549     parse->priv->index = NULL;
 550   }
 551   g_mutex_clear (&parse->priv->index_lock);
 552
 553   gst_base_parse_clear_queues (parse);
 554
 555   G_OBJECT_CLASS (parent_class)->finalize (object);
 556 }
 557
 558 static void
 559 gst_base_parse_class_init (GstBaseParseClass * klass)
 560 {
 561   GObjectClass *gobject_class;
 562   GstElementClass *gstelement_class;
 563
 564   gobject_class = G_OBJECT_CLASS (klass);
 565   g_type_class_add_private (klass, sizeof (GstBaseParsePrivate));
 566   parent_class = g_type_class_peek_parent (klass);
 567
 568   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_base_parse_finalize);
 569   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_base_parse_set_property);
 570   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_base_parse_get_property);
 571
 572   /**
 573    * GstBaseParse:disable-passthrough:
 574    *
 575    * If set to %TRUE, baseparse will unconditionally force parsing of the
 576    * incoming data. This can be required in the rare cases where the incoming
 577    * side-data (caps, pts, dts, ...) is not trusted by the user and wants to
 578    * force validation and parsing of the incoming data.
 579    * If set to %FALSE, decision of whether to parse the data or not is up to
 580    * the implementation (standard behaviour).
 581    */
 582   g_object_class_install_property (gobject_class, PROP_DISABLE_PASSTHROUGH,
 583       g_param_spec_boolean ("disable-passthrough", "Disable passthrough",
 584           "Force processing (disables passthrough)",
 585           DEFAULT_DISABLE_PASSTHROUGH,
 586           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 587
 588   gstelement_class = (GstElementClass *) klass;
 589   gstelement_class->change_state =
 590       GST_DEBUG_FUNCPTR (gst_base_parse_change_state);
 591
 592 #if 0
 593   gstelement_class->set_index = GST_DEBUG_FUNCPTR (gst_base_parse_set_index);
 594   gstelement_class->get_index = GST_DEBUG_FUNCPTR (gst_base_parse_get_index);
 595 #endif
 596
 597   /* Default handlers */
 598   klass->sink_event = gst_base_parse_sink_event_default;
 599   klass->src_event = gst_base_parse_src_event_default;
 600   klass->sink_query = gst_base_parse_sink_query_default;
 601   klass->src_query = gst_base_parse_src_query_default;
 602   klass->convert = gst_base_parse_convert_default;
 603
 604   GST_DEBUG_CATEGORY_INIT (gst_base_parse_debug, "baseparse", 0,
 605       "baseparse element");
 606 }
 607
 608 static void
 609 gst_base_parse_init (GstBaseParse * parse, GstBaseParseClass * bclass)
 610 {
 611   GstPadTemplate *pad_template;
 612
 613   GST_DEBUG_OBJECT (parse, "gst_base_parse_init");
 614
 615   parse->priv = GST_BASE_PARSE_GET_PRIVATE (parse);
 616
 617   pad_template =
 618       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "sink");
 619   g_return_if_fail (pad_template != NULL);
 620   parse->sinkpad = gst_pad_new_from_template (pad_template, "sink");
 621   gst_pad_set_event_function (parse->sinkpad,
 622       GST_DEBUG_FUNCPTR (gst_base_parse_sink_event));
 623   gst_pad_set_query_function (parse->sinkpad,
 624       GST_DEBUG_FUNCPTR (gst_base_parse_sink_query));
 625   gst_pad_set_chain_function (parse->sinkpad,
 626       GST_DEBUG_FUNCPTR (gst_base_parse_chain));
 627   gst_pad_set_activate_function (parse->sinkpad,
 628       GST_DEBUG_FUNCPTR (gst_base_parse_sink_activate));
 629   gst_pad_set_activatemode_function (parse->sinkpad,
 630       GST_DEBUG_FUNCPTR (gst_base_parse_sink_activate_mode));
 631   GST_PAD_SET_PROXY_ALLOCATION (parse->sinkpad);
 632   gst_element_add_pad (GST_ELEMENT (parse), parse->sinkpad);
 633
 634   GST_DEBUG_OBJECT (parse, "sinkpad created");
 635
 636   pad_template =
 637       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "src");
 638   g_return_if_fail (pad_template != NULL);
 639   parse->srcpad = gst_pad_new_from_template (pad_template, "src");
 640   gst_pad_set_event_function (parse->srcpad,
 641       GST_DEBUG_FUNCPTR (gst_base_parse_src_event));
 642   gst_pad_set_query_function (parse->srcpad,
 643       GST_DEBUG_FUNCPTR (gst_base_parse_src_query));
 644   gst_pad_use_fixed_caps (parse->srcpad);
 645   gst_element_add_pad (GST_ELEMENT (parse), parse->srcpad);
 646   GST_DEBUG_OBJECT (parse, "src created");
 647
 648   g_queue_init (&parse->priv->queued_frames);
 649
 650   parse->priv->adapter = gst_adapter_new ();
 651
 652   parse->priv->pad_mode = GST_PAD_MODE_NONE;
 653
 654 #ifdef GST_BASEPARSE_MODIFICATION
 655   parse->priv->expected_pad_mode = GST_PAD_MODE_NONE;
 656 #endif
 657
 658   g_mutex_init (&parse->priv->index_lock);
 659
 660   /* init state */
 661   gst_base_parse_reset (parse);
 662   GST_DEBUG_OBJECT (parse, "init ok");
 663
 664   GST_OBJECT_FLAG_SET (parse, GST_ELEMENT_FLAG_INDEXABLE);
 665
 666   parse->priv->upstream_tags = NULL;
 667   parse->priv->parser_tags = NULL;
 668   parse->priv->parser_tags_merge_mode = GST_TAG_MERGE_APPEND;
 669 }
 670
 671 static void
 672 gst_base_parse_set_property (GObject * object, guint prop_id,
 673     const GValue * value, GParamSpec * pspec)
 674 {
 675   GstBaseParse *parse = GST_BASE_PARSE (object);
 676
 677   switch (prop_id) {
 678     case PROP_DISABLE_PASSTHROUGH:
 679       parse->priv->disable_passthrough = g_value_get_boolean (value);
 680       break;
 681     default:
 682       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 683       break;
 684   }
 685 }
 686
 687 static void
 688 gst_base_parse_get_property (GObject * object, guint prop_id, GValue * value,
 689     GParamSpec * pspec)
 690 {
 691   GstBaseParse *parse = GST_BASE_PARSE (object);
 692
 693   switch (prop_id) {
 694     case PROP_DISABLE_PASSTHROUGH:
 695       g_value_set_boolean (value, parse->priv->disable_passthrough);
 696       break;
 697     default:
 698       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 699       break;
 700   }
 701 }
 702
 703 static GstBaseParseFrame *
 704 gst_base_parse_frame_copy (GstBaseParseFrame * frame)
 705 {
 706   GstBaseParseFrame *copy;
 707
 708   copy = g_slice_dup (GstBaseParseFrame, frame);
 709   copy->buffer = gst_buffer_ref (frame->buffer);
 710   copy->_private_flags &= ~GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC;
 711
 712   GST_TRACE ("copied frame %p -> %p", frame, copy);
 713
 714   return copy;
 715 }
 716
 717 void
 718 gst_base_parse_frame_free (GstBaseParseFrame * frame)
 719 {
 720   GST_TRACE ("freeing frame %p", frame);
 721
 722   if (frame->buffer) {
 723     gst_buffer_unref (frame->buffer);
 724     frame->buffer = NULL;
 725   }
 726
 727   if (!(frame->_private_flags & GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC)) {
 728     g_slice_free (GstBaseParseFrame, frame);
 729   } else {
 730     memset (frame, 0, sizeof (*frame));
 731   }
 732 }
 733
 734 G_DEFINE_BOXED_TYPE (GstBaseParseFrame, gst_base_parse_frame,
 735     (GBoxedCopyFunc) gst_base_parse_frame_copy,
 736     (GBoxedFreeFunc) gst_base_parse_frame_free);
 737
 738 /**
 739  * gst_base_parse_frame_init:
 740  * @frame: #GstBaseParseFrame.
 741  *
 742  * Sets a #GstBaseParseFrame to initial state.  Currently this means
 743  * all public fields are zero-ed and a private flag is set to make
 744  * sure gst_base_parse_frame_free() only frees the contents but not
 745  * the actual frame. Use this function to initialise a #GstBaseParseFrame
 746  * allocated on the stack.
 747  */
 748 void
 749 gst_base_parse_frame_init (GstBaseParseFrame * frame)
 750 {
 751   memset (frame, 0, sizeof (GstBaseParseFrame));
 752   frame->_private_flags = GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC;
 753   GST_TRACE ("inited frame %p", frame);
 754 }
 755
 756 /**
 757  * gst_base_parse_frame_new:
 758  * @buffer: (transfer none): a #GstBuffer
 759  * @flags: the flags
 760  * @overhead: number of bytes in this frame which should be counted as
 761  *     metadata overhead, ie. not used to calculate the average bitrate.
 762  *     Set to -1 to mark the entire frame as metadata. If in doubt, set to 0.
 763  *
 764  * Allocates a new #GstBaseParseFrame. This function is mainly for bindings,
 765  * elements written in C should usually allocate the frame on the stack and
 766  * then use gst_base_parse_frame_init() to initialise it.
 767  *
 768  * Returns: a newly-allocated #GstBaseParseFrame. Free with
 769  *     gst_base_parse_frame_free() when no longer needed.
 770  */
 771 GstBaseParseFrame *
 772 gst_base_parse_frame_new (GstBuffer * buffer, GstBaseParseFrameFlags flags,
 773     gint overhead)
 774 {
 775   GstBaseParseFrame *frame;
 776
 777   frame = g_slice_new0 (GstBaseParseFrame);
 778   frame->buffer = gst_buffer_ref (buffer);
 779
 780   GST_TRACE ("created frame %p", frame);
 781   return frame;
 782 }
 783
 784 static inline void
 785 gst_base_parse_update_flags (GstBaseParse * parse)
 786 {
 787   parse->flags = 0;
 788
 789   /* set flags one by one for clarity */
 790   if (G_UNLIKELY (parse->priv->drain))
 791     parse->flags |= GST_BASE_PARSE_FLAG_DRAINING;
 792
 793   /* losing sync is pretty much a discont (and vice versa), no ? */
 794   if (G_UNLIKELY (parse->priv->discont))
 795     parse->flags |= GST_BASE_PARSE_FLAG_LOST_SYNC;
 796 }
 797
 798 static inline void
 799 gst_base_parse_update_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
 800 {
 801   if (G_UNLIKELY (parse->priv->discont)) {
 802     GST_DEBUG_OBJECT (parse, "marking DISCONT");
 803     GST_BUFFER_FLAG_SET (frame->buffer, GST_BUFFER_FLAG_DISCONT);
 804   }
 805
 806   if (parse->priv->prev_offset != parse->priv->offset || parse->priv->new_frame) {
 807     GST_LOG_OBJECT (parse, "marking as new frame");
 808     frame->flags |= GST_BASE_PARSE_FRAME_FLAG_NEW_FRAME;
 809   }
 810
 811   frame->offset = parse->priv->prev_offset = parse->priv->offset;
 812 }
 813
 814 static void
 815 gst_base_parse_reset (GstBaseParse * parse)
 816 {
 817   GST_OBJECT_LOCK (parse);
 818   gst_segment_init (&parse->segment, GST_FORMAT_TIME);
 819   parse->priv->duration = -1;
 820   parse->priv->min_frame_size = 1;
 821   parse->priv->discont = TRUE;
 822   parse->priv->flushing = FALSE;
 823   parse->priv->saw_gaps = FALSE;
 824   parse->priv->offset = 0;
 825   parse->priv->sync_offset = 0;
 826   parse->priv->update_interval = -1;
 827   parse->priv->fps_num = parse->priv->fps_den = 0;
 828   parse->priv->frame_duration = GST_CLOCK_TIME_NONE;
 829   parse->priv->lead_in = parse->priv->lead_out = 0;
 830   parse->priv->lead_in_ts = parse->priv->lead_out_ts = 0;
 831   parse->priv->bitrate = 0;
 832   parse->priv->framecount = 0;
 833   parse->priv->bytecount = 0;
 834   parse->priv->acc_duration = 0;
 835   parse->priv->first_frame_pts = GST_CLOCK_TIME_NONE;
 836   parse->priv->first_frame_dts = GST_CLOCK_TIME_NONE;
 837   parse->priv->first_frame_offset = -1;
 838   parse->priv->estimated_duration = -1;
 839   parse->priv->estimated_drift = 0;
 840   parse->priv->next_pts = GST_CLOCK_TIME_NONE;
 841   parse->priv->next_dts = 0;
 842   parse->priv->syncable = TRUE;
 843   parse->priv->disable_passthrough = DEFAULT_DISABLE_PASSTHROUGH;
 844   parse->priv->passthrough = FALSE;
 845   parse->priv->pts_interpolate = TRUE;
 846   parse->priv->infer_ts = TRUE;
 847   parse->priv->has_timing_info = FALSE;
 848   parse->priv->min_bitrate = G_MAXUINT;
 849   parse->priv->max_bitrate = 0;
 850   parse->priv->avg_bitrate = 0;
 851   parse->priv->posted_avg_bitrate = 0;
 852
 853   parse->priv->index_last_ts = GST_CLOCK_TIME_NONE;
 854   parse->priv->index_last_offset = -1;
 855   parse->priv->index_last_valid = TRUE;
 856   parse->priv->upstream_seekable = FALSE;
 857   parse->priv->upstream_size = 0;
 858   parse->priv->upstream_has_duration = FALSE;
 859   parse->priv->upstream_format = GST_FORMAT_UNDEFINED;
 860   parse->priv->idx_interval = 0;
 861   parse->priv->idx_byte_interval = 0;
 862   parse->priv->exact_position = TRUE;
 863   parse->priv->seen_keyframe = FALSE;
 864   parse->priv->checked_media = FALSE;
 865
 866   parse->priv->last_dts = GST_CLOCK_TIME_NONE;
 867   parse->priv->last_pts = GST_CLOCK_TIME_NONE;
 868   parse->priv->last_offset = 0;
 869
 870   parse->priv->skip = 0;
 871
 872 #ifdef GST_BASEPARSE_MODIFICATION
 873   parse->priv->first_frame = TRUE;
 874   parse->priv->remove_from_total = 0;
 875   parse->priv->accurate_index_seek = TRUE;
 876 #endif
 877
 878   g_list_foreach (parse->priv->pending_events, (GFunc) gst_mini_object_unref,
 879       NULL);
 880   g_list_free (parse->priv->pending_events);
 881   parse->priv->pending_events = NULL;
 882
 883   if (parse->priv->cache) {
 884     gst_buffer_unref (parse->priv->cache);
 885     parse->priv->cache = NULL;
 886   }
 887
 888   g_slist_foreach (parse->priv->pending_seeks, (GFunc) g_free, NULL);
 889   g_slist_free (parse->priv->pending_seeks);
 890   parse->priv->pending_seeks = NULL;
 891
 892   if (parse->priv->adapter)
 893     gst_adapter_clear (parse->priv->adapter);
 894
 895   gst_base_parse_set_upstream_tags (parse, NULL);
 896
 897   if (parse->priv->parser_tags) {
 898     gst_tag_list_unref (parse->priv->parser_tags);
 899     parse->priv->parser_tags = NULL;
 900   }
 901   parse->priv->parser_tags_merge_mode = GST_TAG_MERGE_APPEND;
 902
 903   parse->priv->new_frame = TRUE;
 904
 905   parse->priv->first_buffer = TRUE;
 906
 907   g_list_foreach (parse->priv->detect_buffers, (GFunc) gst_buffer_unref, NULL);
 908   g_list_free (parse->priv->detect_buffers);
 909   parse->priv->detect_buffers = NULL;
 910   parse->priv->detect_buffers_size = 0;
 911 #ifdef GST_BASEPARSE_MODIFICATION
 912   parse->priv->accurate_index_seek = TRUE;
 913 #endif
 914   GST_OBJECT_UNLOCK (parse);
 915 }
 916
 917 static gboolean
 918 gst_base_parse_check_bitrate_tag (GstBaseParse * parse, const gchar * tag)
 919 {
 920   gboolean got_tag = FALSE;
 921   guint n = 0;
 922
 923   if (parse->priv->upstream_tags != NULL)
 924     got_tag = gst_tag_list_get_uint (parse->priv->upstream_tags, tag, &n);
 925
 926   if (!got_tag && parse->priv->parser_tags != NULL)
 927     got_tag = gst_tag_list_get_uint (parse->priv->parser_tags, tag, &n);
 928
 929   return got_tag;
 930 }
 931
 932 /* check if upstream or subclass tags contain bitrates already */
 933 static void
 934 gst_base_parse_check_bitrate_tags (GstBaseParse * parse)
 935 {
 936   parse->priv->post_min_bitrate =
 937       !gst_base_parse_check_bitrate_tag (parse, GST_TAG_MINIMUM_BITRATE);
 938   parse->priv->post_avg_bitrate =
 939       !gst_base_parse_check_bitrate_tag (parse, GST_TAG_BITRATE);
 940   parse->priv->post_max_bitrate =
 941       !gst_base_parse_check_bitrate_tag (parse, GST_TAG_MAXIMUM_BITRATE);
 942 }
 943
 944 /* Queues new tag event with the current combined state of the stream tags
 945  * (i.e. upstream tags merged with subclass tags and current baseparse tags) */
 946 static void
 947 gst_base_parse_queue_tag_event_update (GstBaseParse * parse)
 948 {
 949   GstTagList *merged_tags;
 950
 951   GST_LOG_OBJECT (parse, "upstream : %" GST_PTR_FORMAT,
 952       parse->priv->upstream_tags);
 953   GST_LOG_OBJECT (parse, "parser   : %" GST_PTR_FORMAT,
 954       parse->priv->parser_tags);
 955   GST_LOG_OBJECT (parse, "mode     : %d", parse->priv->parser_tags_merge_mode);
 956
 957   merged_tags =
 958       gst_tag_list_merge (parse->priv->upstream_tags, parse->priv->parser_tags,
 959       parse->priv->parser_tags_merge_mode);
 960
 961   GST_DEBUG_OBJECT (parse, "merged   : %" GST_PTR_FORMAT, merged_tags);
 962
 963   if (merged_tags == NULL)
 964     return;
 965
 966   if (gst_tag_list_is_empty (merged_tags)) {
 967     gst_tag_list_unref (merged_tags);
 968     return;
 969   }
 970
 971   /* only add bitrate tags to non-empty taglists for now, and only if neither
 972    * upstream tags nor the subclass sets the bitrate tag in question already */
 973   if (parse->priv->min_bitrate != G_MAXUINT && parse->priv->post_min_bitrate) {
 974     GST_LOG_OBJECT (parse, "adding min bitrate %u", parse->priv->min_bitrate);
 975     gst_tag_list_add (merged_tags, GST_TAG_MERGE_KEEP, GST_TAG_MINIMUM_BITRATE,
 976         parse->priv->min_bitrate, NULL);
 977   }
 978   if (parse->priv->max_bitrate != 0 && parse->priv->post_max_bitrate) {
 979     GST_LOG_OBJECT (parse, "adding max bitrate %u", parse->priv->max_bitrate);
 980     gst_tag_list_add (merged_tags, GST_TAG_MERGE_KEEP, GST_TAG_MAXIMUM_BITRATE,
 981         parse->priv->max_bitrate, NULL);
 982   }
 983   if (parse->priv->avg_bitrate != 0 && parse->priv->post_avg_bitrate) {
 984     parse->priv->posted_avg_bitrate = parse->priv->avg_bitrate;
 985     GST_LOG_OBJECT (parse, "adding avg bitrate %u", parse->priv->avg_bitrate);
 986     gst_tag_list_add (merged_tags, GST_TAG_MERGE_KEEP, GST_TAG_BITRATE,
 987         parse->priv->avg_bitrate, NULL);
 988   }
 989
 990   parse->priv->pending_events =
 991       g_list_prepend (parse->priv->pending_events,
 992       gst_event_new_tag (merged_tags));
 993 }
 994
 995 /* gst_base_parse_parse_frame:
 996  * @parse: #GstBaseParse.
 997  * @buffer: #GstBuffer.
 998  *
 999  * Default callback for parse_frame.
1000  */
1001 static GstFlowReturn
1002 gst_base_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1003 {
1004   GstBuffer *buffer = frame->buffer;
1005
1006   if (!GST_BUFFER_PTS_IS_VALID (buffer) &&
1007       GST_CLOCK_TIME_IS_VALID (parse->priv->next_pts)) {
1008     GST_BUFFER_PTS (buffer) = parse->priv->next_pts;
1009   }
1010   if (!GST_BUFFER_DTS_IS_VALID (buffer) &&
1011       GST_CLOCK_TIME_IS_VALID (parse->priv->next_dts)) {
1012     GST_BUFFER_DTS (buffer) = parse->priv->next_dts;
1013   }
1014   if (!GST_BUFFER_DURATION_IS_VALID (buffer) &&
1015       GST_CLOCK_TIME_IS_VALID (parse->priv->frame_duration)) {
1016     GST_BUFFER_DURATION (buffer) = parse->priv->frame_duration;
1017   }
1018   return GST_FLOW_OK;
1019 }
1020
1021 /* gst_base_parse_convert:
1022  * @parse: #GstBaseParse.
1023  * @src_format: #GstFormat describing the source format.
1024  * @src_value: Source value to be converted.
1025  * @dest_format: #GstFormat defining the converted format.
1026  * @dest_value: Pointer where the conversion result will be put.
1027  *
1028  * Converts using configured "convert" vmethod in #GstBaseParse class.
1029  *
1030  * Returns: %TRUE if conversion was successful.
1031  */
1032 static gboolean
1033 gst_base_parse_convert (GstBaseParse * parse,
1034     GstFormat src_format,
1035     gint64 src_value, GstFormat dest_format, gint64 * dest_value)
1036 {
1037   GstBaseParseClass *klass = GST_BASE_PARSE_GET_CLASS (parse);
1038   gboolean ret;
1039
1040   g_return_val_if_fail (dest_value != NULL, FALSE);
1041
1042   if (!klass->convert)
1043     return FALSE;
1044
1045   ret = klass->convert (parse, src_format, src_value, dest_format, dest_value);
1046
1047 #ifndef GST_DISABLE_GST_DEBUG
1048   {
1049     if (ret) {
1050       if (src_format == GST_FORMAT_TIME && dest_format == GST_FORMAT_BYTES) {
1051         GST_LOG_OBJECT (parse,
1052             "TIME -> BYTES: %" GST_TIME_FORMAT " -> %" G_GINT64_FORMAT,
1053             GST_TIME_ARGS (src_value), *dest_value);
1054       } else if (dest_format == GST_FORMAT_TIME &&
1055           src_format == GST_FORMAT_BYTES) {
1056         GST_LOG_OBJECT (parse,
1057             "BYTES -> TIME: %" G_GINT64_FORMAT " -> %" GST_TIME_FORMAT,
1058             src_value, GST_TIME_ARGS (*dest_value));
1059       } else {
1060         GST_LOG_OBJECT (parse,
1061             "%s -> %s: %" G_GINT64_FORMAT " -> %" G_GINT64_FORMAT,
1062             GST_STR_NULL (gst_format_get_name (src_format)),
1063             GST_STR_NULL (gst_format_get_name (dest_format)),
1064             src_value, *dest_value);
1065       }
1066     } else {
1067       GST_DEBUG_OBJECT (parse, "conversion failed");
1068     }
1069   }
1070 #endif
1071
1072   return ret;
1073 }
1074
1075 /* gst_base_parse_sink_event:
1076  * @pad: #GstPad that received the event.
1077  * @event: #GstEvent to be handled.
1078  *
1079  * Handler for sink pad events.
1080  *
1081  * Returns: %TRUE if the event was handled.
1082  */
1083 static gboolean
1084 gst_base_parse_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
1085 {
1086   GstBaseParse *parse = GST_BASE_PARSE (parent);
1087   GstBaseParseClass *bclass = GST_BASE_PARSE_GET_CLASS (parse);
1088   gboolean ret;
1089
1090   ret = bclass->sink_event (parse, event);
1091
1092   return ret;
1093 }
1094
1095
1096 /* gst_base_parse_sink_event_default:
1097  * @parse: #GstBaseParse.
1098  * @event: #GstEvent to be handled.
1099  *
1100  * Element-level event handler function.
1101  *
1102  * The event will be unreffed only if it has been handled and this
1103  * function returns %TRUE
1104  *
1105  * Returns: %TRUE if the event was handled and not need forwarding.
1106  */
1107 static gboolean
1108 gst_base_parse_sink_event_default (GstBaseParse * parse, GstEvent * event)
1109 {
1110   GstBaseParseClass *klass = GST_BASE_PARSE_GET_CLASS (parse);
1111   gboolean ret = FALSE;
1112   gboolean forward_immediate = FALSE;
1113
1114   GST_DEBUG_OBJECT (parse, "handling event %d, %s", GST_EVENT_TYPE (event),
1115       GST_EVENT_TYPE_NAME (event));
1116
1117   switch (GST_EVENT_TYPE (event)) {
1118     case GST_EVENT_CAPS:
1119     {
1120       GstCaps *caps;
1121
1122       gst_event_parse_caps (event, &caps);
1123       GST_DEBUG_OBJECT (parse, "caps: %" GST_PTR_FORMAT, caps);
1124
1125       if (klass->set_sink_caps)
1126         ret = klass->set_sink_caps (parse, caps);
1127       else
1128         ret = TRUE;
1129
1130       /* will send our own caps downstream */
1131       gst_event_unref (event);
1132       event = NULL;
1133       break;
1134     }
1135     case GST_EVENT_SEGMENT:
1136     {
1137       const GstSegment *in_segment;
1138       GstSegment out_segment;
1139       gint64 offset = 0, next_dts;
1140       guint32 seqnum = gst_event_get_seqnum (event);
1141
1142       gst_event_parse_segment (event, &in_segment);
1143       gst_segment_init (&out_segment, GST_FORMAT_TIME);
1144       out_segment.rate = in_segment->rate;
1145       out_segment.applied_rate = in_segment->applied_rate;
1146
1147       GST_DEBUG_OBJECT (parse, "segment %" GST_SEGMENT_FORMAT, in_segment);
1148
1149       parse->priv->upstream_format = in_segment->format;
1150       if (in_segment->format == GST_FORMAT_BYTES) {
1151         GstBaseParseSeek *seek = NULL;
1152         GSList *node;
1153
1154         /* stop time is allowed to be open-ended, but not start & pos */
1155         offset = in_segment->time;
1156
1157         GST_OBJECT_LOCK (parse);
1158         for (node = parse->priv->pending_seeks; node; node = node->next) {
1159           GstBaseParseSeek *tmp = node->data;
1160
1161           if (tmp->offset == offset) {
1162             seek = tmp;
1163             break;
1164           }
1165         }
1166         parse->priv->pending_seeks =
1167             g_slist_remove (parse->priv->pending_seeks, seek);
1168         GST_OBJECT_UNLOCK (parse);
1169
1170         if (seek) {
1171           GST_DEBUG_OBJECT (parse,
1172               "Matched newsegment to%s seek: %" GST_SEGMENT_FORMAT,
1173               seek->accurate ? " accurate" : "", &seek->segment);
1174
1175           out_segment.start = seek->segment.start;
1176           out_segment.stop = seek->segment.stop;
1177           out_segment.time = seek->segment.start;
1178
1179           next_dts = seek->start_ts;
1180           parse->priv->exact_position = seek->accurate;
1181           g_free (seek);
1182         } else {
1183           /* best attempt convert */
1184           /* as these are only estimates, stop is kept open-ended to avoid
1185            * premature cutting */
1186           gst_base_parse_convert (parse, GST_FORMAT_BYTES, in_segment->start,
1187               GST_FORMAT_TIME, (gint64 *) & next_dts);
1188
1189           out_segment.start = next_dts;
1190           out_segment.stop = GST_CLOCK_TIME_NONE;
1191           out_segment.time = next_dts;
1192
1193           parse->priv->exact_position = (in_segment->start == 0);
1194         }
1195
1196         gst_event_unref (event);
1197
1198         event = gst_event_new_segment (&out_segment);
1199         gst_event_set_seqnum (event, seqnum);
1200
1201         GST_DEBUG_OBJECT (parse, "Converted incoming segment to TIME. %"
1202             GST_SEGMENT_FORMAT, in_segment);
1203
1204       } else if (in_segment->format != GST_FORMAT_TIME) {
1205         /* Unknown incoming segment format. Output a default open-ended
1206          * TIME segment */
1207         gst_event_unref (event);
1208
1209         out_segment.start = 0;
1210         out_segment.stop = GST_CLOCK_TIME_NONE;
1211         out_segment.time = 0;
1212
1213         event = gst_event_new_segment (&out_segment);
1214         gst_event_set_seqnum (event, seqnum);
1215
1216         next_dts = 0;
1217       } else {
1218         /* not considered BYTE seekable if it is talking to us in TIME,
1219          * whatever else it might claim */
1220         parse->priv->upstream_seekable = FALSE;
1221         next_dts = in_segment->start;
1222         gst_event_copy_segment (event, &out_segment);
1223       }
1224
1225       memcpy (&parse->segment, &out_segment, sizeof (GstSegment));
1226
1227       /*
1228          gst_segment_set_newsegment (&parse->segment, update, rate,
1229          applied_rate, format, start, stop, start);
1230        */
1231
1232       ret = TRUE;
1233
1234       /* save the segment for later, right before we push a new buffer so that
1235        * the caps are fixed and the next linked element can receive
1236        * the segment but finish the current segment */
1237       GST_DEBUG_OBJECT (parse, "draining current segment");
1238       if (in_segment->rate > 0.0)
1239         gst_base_parse_drain (parse);
1240       else
1241         gst_base_parse_finish_fragment (parse, FALSE);
1242       gst_adapter_clear (parse->priv->adapter);
1243
1244       parse->priv->offset = offset;
1245       parse->priv->sync_offset = offset;
1246       parse->priv->next_dts = next_dts;
1247       parse->priv->next_pts = GST_CLOCK_TIME_NONE;
1248       parse->priv->last_pts = GST_CLOCK_TIME_NONE;
1249       parse->priv->last_dts = GST_CLOCK_TIME_NONE;
1250       parse->priv->prev_pts = GST_CLOCK_TIME_NONE;
1251       parse->priv->prev_dts = GST_CLOCK_TIME_NONE;
1252       parse->priv->discont = TRUE;
1253       parse->priv->seen_keyframe = FALSE;
1254       parse->priv->skip = 0;
1255       break;
1256     }
1257
1258     case GST_EVENT_SEGMENT_DONE:
1259       /* need to drain now, rather than upon a new segment,
1260        * since that would have SEGMENT_DONE come before potential
1261        * delayed last part of the current segment */
1262       GST_DEBUG_OBJECT (parse, "draining current segment");
1263       if (parse->segment.rate > 0.0)
1264         gst_base_parse_drain (parse);
1265       else
1266         gst_base_parse_finish_fragment (parse, FALSE);
1267       /* Also forward event immediately, there might be no new data
1268        * coming afterwards that would allow us to forward it later */
1269       forward_immediate = TRUE;
1270       break;
1271
1272     case GST_EVENT_FLUSH_START:
1273       GST_OBJECT_LOCK (parse);
1274       parse->priv->flushing = TRUE;
1275       GST_OBJECT_UNLOCK (parse);
1276       break;
1277
1278     case GST_EVENT_FLUSH_STOP:
1279       gst_adapter_clear (parse->priv->adapter);
1280       gst_base_parse_clear_queues (parse);
1281       parse->priv->flushing = FALSE;
1282       parse->priv->discont = TRUE;
1283       parse->priv->last_pts = GST_CLOCK_TIME_NONE;
1284       parse->priv->last_dts = GST_CLOCK_TIME_NONE;
1285       parse->priv->new_frame = TRUE;
1286       parse->priv->skip = 0;
1287
1288       forward_immediate = TRUE;
1289       break;
1290
1291     case GST_EVENT_EOS:
1292       if (parse->segment.rate > 0.0)
1293         gst_base_parse_drain (parse);
1294       else
1295         gst_base_parse_finish_fragment (parse, TRUE);
1296
1297       /* If we STILL have zero frames processed, fire an error */
1298       if (parse->priv->framecount == 0 && !parse->priv->saw_gaps &&
1299           !parse->priv->first_buffer) {
1300         GST_ELEMENT_ERROR (parse, STREAM, WRONG_TYPE,
1301             ("No valid frames found before end of stream"), (NULL));
1302       }
1303
1304       if (!parse->priv->saw_gaps
1305           && parse->priv->framecount < MIN_FRAMES_TO_POST_BITRATE) {
1306         /* We've not posted bitrate tags yet - do so now */
1307         gst_base_parse_queue_tag_event_update (parse);
1308       }
1309
1310       /* newsegment and other serialized events before eos */
1311       gst_base_parse_push_pending_events (parse);
1312
1313       forward_immediate = TRUE;
1314       break;
1315     case GST_EVENT_CUSTOM_DOWNSTREAM:{
1316       /* FIXME: Code duplicated from libgstvideo because core can't depend on -base */
1317 #ifndef GST_VIDEO_EVENT_STILL_STATE_NAME
1318 #define GST_VIDEO_EVENT_STILL_STATE_NAME "GstEventStillFrame"
1319 #endif
1320
1321       const GstStructure *s;
1322       gboolean ev_still_state;
1323
1324       s = gst_event_get_structure (event);
1325       if (s != NULL &&
1326           gst_structure_has_name (s, GST_VIDEO_EVENT_STILL_STATE_NAME) &&
1327           gst_structure_get_boolean (s, "still-state", &ev_still_state)) {
1328         if (ev_still_state) {
1329           GST_DEBUG_OBJECT (parse, "draining current data for still-frame");
1330           if (parse->segment.rate > 0.0)
1331             gst_base_parse_drain (parse);
1332           else
1333             gst_base_parse_finish_fragment (parse, TRUE);
1334         }
1335         forward_immediate = TRUE;
1336       }
1337       break;
1338     }
1339     case GST_EVENT_GAP:
1340     {
1341       GST_DEBUG_OBJECT (parse, "draining current data due to gap event");
1342
1343       gst_base_parse_push_pending_events (parse);
1344
1345       if (parse->segment.rate > 0.0)
1346         gst_base_parse_drain (parse);
1347       else
1348         gst_base_parse_finish_fragment (parse, TRUE);
1349       forward_immediate = TRUE;
1350       parse->priv->saw_gaps = TRUE;
1351       break;
1352     }
1353     case GST_EVENT_TAG:
1354     {
1355       GstTagList *tags = NULL;
1356
1357       gst_event_parse_tag (event, &tags);
1358
1359       /* We only care about stream tags here, global tags we just forward */
1360       if (gst_tag_list_get_scope (tags) != GST_TAG_SCOPE_STREAM)
1361         break;
1362
1363       gst_base_parse_set_upstream_tags (parse, tags);
1364       gst_base_parse_queue_tag_event_update (parse);
1365       parse->priv->tags_changed = FALSE;
1366       gst_event_unref (event);
1367       event = NULL;
1368       ret = TRUE;
1369       break;
1370     }
1371     case GST_EVENT_STREAM_START:
1372     {
1373       if (parse->priv->pad_mode != GST_PAD_MODE_PULL)
1374         forward_immediate = TRUE;
1375
1376       gst_base_parse_set_upstream_tags (parse, NULL);
1377       parse->priv->tags_changed = TRUE;
1378       break;
1379     }
1380     default:
1381       break;
1382   }
1383
1384   /* Forward non-serialized events and EOS/FLUSH_STOP immediately.
1385    * For EOS this is required because no buffer or serialized event
1386    * will come after EOS and nothing could trigger another
1387    * _finish_frame() call.   *
1388    * If the subclass handles sending of EOS manually it can return
1389    * _DROPPED from ::finish() and all other subclasses should have
1390    * decoded/flushed all remaining data before this
1391    *
1392    * For FLUSH_STOP this is required because it is expected
1393    * to be forwarded immediately and no buffers are queued anyway.
1394    */
1395   if (event) {
1396     if (!GST_EVENT_IS_SERIALIZED (event) || forward_immediate) {
1397       ret = gst_pad_push_event (parse->srcpad, event);
1398     } else {
1399       parse->priv->pending_events =
1400           g_list_prepend (parse->priv->pending_events, event);
1401       ret = TRUE;
1402     }
1403   }
1404
1405   GST_DEBUG_OBJECT (parse, "event handled");
1406
1407   return ret;
1408 }
1409
1410 static gboolean
1411 gst_base_parse_sink_query_default (GstBaseParse * parse, GstQuery * query)
1412 {
1413   GstPad *pad;
1414   gboolean res;
1415
1416   pad = GST_BASE_PARSE_SINK_PAD (parse);
1417
1418   switch (GST_QUERY_TYPE (query)) {
1419     case GST_QUERY_CAPS:
1420     {
1421       GstBaseParseClass *bclass;
1422
1423       bclass = GST_BASE_PARSE_GET_CLASS (parse);
1424
1425       if (bclass->get_sink_caps) {
1426         GstCaps *caps, *filter;
1427
1428         gst_query_parse_caps (query, &filter);
1429         caps = bclass->get_sink_caps (parse, filter);
1430         GST_LOG_OBJECT (parse, "sink getcaps returning caps %" GST_PTR_FORMAT,
1431             caps);
1432         gst_query_set_caps_result (query, caps);
1433         gst_caps_unref (caps);
1434
1435         res = TRUE;
1436       } else {
1437         GstCaps *caps, *template_caps, *filter;
1438
1439         gst_query_parse_caps (query, &filter);
1440         template_caps = gst_pad_get_pad_template_caps (pad);
1441         if (filter != NULL) {
1442           caps =
1443               gst_caps_intersect_full (filter, template_caps,
1444               GST_CAPS_INTERSECT_FIRST);
1445           gst_caps_unref (template_caps);
1446         } else {
1447           caps = template_caps;
1448         }
1449         gst_query_set_caps_result (query, caps);
1450         gst_caps_unref (caps);
1451
1452         res = TRUE;
1453       }
1454       break;
1455     }
1456     default:
1457     {
1458       res = gst_pad_query_default (pad, GST_OBJECT_CAST (parse), query);
1459       break;
1460     }
1461   }
1462
1463   return res;
1464 }
1465
1466 static gboolean
1467 gst_base_parse_sink_query (GstPad * pad, GstObject * parent, GstQuery * query)
1468 {
1469   GstBaseParseClass *bclass;
1470   GstBaseParse *parse;
1471   gboolean ret;
1472
1473   parse = GST_BASE_PARSE (parent);
1474   bclass = GST_BASE_PARSE_GET_CLASS (parse);
1475
1476   GST_DEBUG_OBJECT (parse, "%s query", GST_QUERY_TYPE_NAME (query));
1477
1478   if (bclass->sink_query)
1479     ret = bclass->sink_query (parse, query);
1480   else
1481     ret = FALSE;
1482
1483   GST_LOG_OBJECT (parse, "%s query result: %d %" GST_PTR_FORMAT,
1484       GST_QUERY_TYPE_NAME (query), ret, query);
1485
1486   return ret;
1487 }
1488
1489 static gboolean
1490 gst_base_parse_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
1491 {
1492   GstBaseParseClass *bclass;
1493   GstBaseParse *parse;
1494   gboolean ret;
1495
1496   parse = GST_BASE_PARSE (parent);
1497   bclass = GST_BASE_PARSE_GET_CLASS (parse);
1498
1499   GST_DEBUG_OBJECT (parse, "%s query: %" GST_PTR_FORMAT,
1500       GST_QUERY_TYPE_NAME (query), query);
1501
1502   if (bclass->src_query)
1503     ret = bclass->src_query (parse, query);
1504   else
1505     ret = FALSE;
1506
1507   GST_LOG_OBJECT (parse, "%s query result: %d %" GST_PTR_FORMAT,
1508       GST_QUERY_TYPE_NAME (query), ret, query);
1509
1510   return ret;
1511 }
1512
1513 /* gst_base_parse_src_event:
1514  * @pad: #GstPad that received the event.
1515  * @event: #GstEvent that was received.
1516  *
1517  * Handler for source pad events.
1518  *
1519  * Returns: %TRUE if the event was handled.
1520  */
1521 static gboolean
1522 gst_base_parse_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
1523 {
1524   GstBaseParse *parse;
1525   GstBaseParseClass *bclass;
1526   gboolean ret = TRUE;
1527
1528   parse = GST_BASE_PARSE (parent);
1529   bclass = GST_BASE_PARSE_GET_CLASS (parse);
1530
1531   GST_DEBUG_OBJECT (parse, "event %d, %s", GST_EVENT_TYPE (event),
1532       GST_EVENT_TYPE_NAME (event));
1533
1534   if (bclass->src_event)
1535     ret = bclass->src_event (parse, event);
1536   else
1537     gst_event_unref (event);
1538
1539   return ret;
1540 }
1541
1542 static gboolean
1543 gst_base_parse_is_seekable (GstBaseParse * parse)
1544 {
1545   /* FIXME: could do more here, e.g. check index or just send data from 0
1546    * in pull mode and let decoder/sink clip */
1547   return parse->priv->syncable;
1548 }
1549
1550 /* gst_base_parse_src_event_default:
1551  * @parse: #GstBaseParse.
1552  * @event: #GstEvent that was received.
1553  *
1554  * Default srcpad event handler.
1555  *
1556  * Returns: %TRUE if the event was handled and can be dropped.
1557  */
1558 static gboolean
1559 gst_base_parse_src_event_default (GstBaseParse * parse, GstEvent * event)
1560 {
1561   gboolean res = FALSE;
1562
1563   switch (GST_EVENT_TYPE (event)) {
1564     case GST_EVENT_SEEK:
1565       if (gst_base_parse_is_seekable (parse))
1566         res = gst_base_parse_handle_seek (parse, event);
1567       break;
1568     default:
1569       res = gst_pad_event_default (parse->srcpad, GST_OBJECT_CAST (parse),
1570           event);
1571       break;
1572   }
1573   return res;
1574 }
1575
1576
1577 /**
1578  * gst_base_parse_convert_default:
1579  * @parse: #GstBaseParse.
1580  * @src_format: #GstFormat describing the source format.
1581  * @src_value: Source value to be converted.
1582  * @dest_format: #GstFormat defining the converted format.
1583  * @dest_value: Pointer where the conversion result will be put.
1584  *
1585  * Default implementation of "convert" vmethod in #GstBaseParse class.
1586  *
1587  * Returns: %TRUE if conversion was successful.
1588  */
1589 gboolean
1590 gst_base_parse_convert_default (GstBaseParse * parse,
1591     GstFormat src_format,
1592     gint64 src_value, GstFormat dest_format, gint64 * dest_value)
1593 {
1594   gboolean ret = FALSE;
1595   guint64 bytes, duration;
1596
1597   if (G_UNLIKELY (src_format == dest_format)) {
1598     *dest_value = src_value;
1599     return TRUE;
1600   }
1601
1602   if (G_UNLIKELY (src_value == -1)) {
1603     *dest_value = -1;
1604     return TRUE;
1605   }
1606
1607   if (G_UNLIKELY (src_value == 0)) {
1608     *dest_value = 0;
1609     return TRUE;
1610   }
1611
1612   /* need at least some frames */
1613   if (!parse->priv->framecount)
1614     goto no_framecount;
1615
1616 #ifdef GST_BASEPARSE_MODIFICATION
1617   duration = parse->priv->acc_duration / GST_USECOND;
1618 #else
1619   duration = parse->priv->acc_duration / GST_MSECOND;
1620 #endif
1621   bytes = parse->priv->bytecount;
1622
1623   if (G_UNLIKELY (!duration || !bytes))
1624     goto no_duration_bytes;
1625
1626   if (src_format == GST_FORMAT_BYTES) {
1627     if (dest_format == GST_FORMAT_TIME) {
1628       /* BYTES -> TIME conversion */
1629       GST_DEBUG_OBJECT (parse, "converting bytes -> time");
1630 #ifdef GST_BASEPARSE_MODIFICATION
1631       src_value = src_value - parse->priv->remove_from_total;
1632 #endif
1633       *dest_value = gst_util_uint64_scale (src_value, duration, bytes);
1634 #ifdef GST_BASEPARSE_MODIFICATION
1635       *dest_value /= GST_USECOND;
1636 #endif
1637       *dest_value *= GST_MSECOND;
1638       GST_DEBUG_OBJECT (parse, "conversion result: %" G_GINT64_FORMAT " ms",
1639           *dest_value / GST_MSECOND);
1640       ret = TRUE;
1641     } else {
1642       GST_DEBUG_OBJECT (parse, "converting bytes -> other not implemented");
1643     }
1644   } else if (src_format == GST_FORMAT_TIME) {
1645     if (dest_format == GST_FORMAT_BYTES) {
1646       GST_DEBUG_OBJECT (parse, "converting time -> bytes");
1647 #ifdef GST_BASEPARSE_MODIFICATION
1648       *dest_value = gst_util_uint64_scale (src_value / GST_USECOND, bytes,
1649           duration);
1650 #else
1651       *dest_value = gst_util_uint64_scale (src_value / GST_MSECOND, bytes,
1652           duration);
1653 #endif
1654       GST_DEBUG_OBJECT (parse,
1655           "time %" G_GINT64_FORMAT " ms in bytes = %" G_GINT64_FORMAT,
1656           src_value / GST_MSECOND, *dest_value);
1657       ret = TRUE;
1658     } else {
1659       GST_DEBUG_OBJECT (parse, "converting time -> other not implemented");
1660     }
1661   } else if (src_format == GST_FORMAT_DEFAULT) {
1662     /* DEFAULT == frame-based */
1663     if (dest_format == GST_FORMAT_TIME) {
1664       GST_DEBUG_OBJECT (parse, "converting default -> time");
1665       if (parse->priv->fps_den) {
1666         *dest_value = gst_util_uint64_scale (src_value,
1667             GST_SECOND * parse->priv->fps_den, parse->priv->fps_num);
1668         ret = TRUE;
1669       }
1670     } else {
1671       GST_DEBUG_OBJECT (parse, "converting default -> other not implemented");
1672     }
1673   } else {
1674     GST_DEBUG_OBJECT (parse, "conversion not implemented");
1675   }
1676   return ret;
1677
1678   /* ERRORS */
1679 no_framecount:
1680   {
1681     GST_DEBUG_OBJECT (parse, "no framecount");
1682     return FALSE;
1683   }
1684 no_duration_bytes:
1685   {
1686     GST_DEBUG_OBJECT (parse, "no duration %" G_GUINT64_FORMAT ", bytes %"
1687         G_GUINT64_FORMAT, duration, bytes);
1688     return FALSE;
1689   }
1690
1691 }
1692
1693 static void
1694 gst_base_parse_update_duration (GstBaseParse * parse)
1695 {
1696   gint64 ptot, dest_value;
1697
1698   if (!gst_pad_peer_query_duration (parse->sinkpad, GST_FORMAT_BYTES, &ptot))
1699     return;
1700
1701   if (!gst_base_parse_convert (parse, GST_FORMAT_BYTES, ptot,
1702           GST_FORMAT_TIME, &dest_value))
1703     return;
1704
1705   /* inform if duration changed, but try to avoid spamming */
1706   parse->priv->estimated_drift += dest_value - parse->priv->estimated_duration;
1707
1708   parse->priv->estimated_duration = dest_value;
1709   GST_LOG_OBJECT (parse,
1710       "updated estimated duration to %" GST_TIME_FORMAT,
1711       GST_TIME_ARGS (dest_value));
1712
1713   if (parse->priv->estimated_drift > GST_SECOND ||
1714       parse->priv->estimated_drift < -GST_SECOND) {
1715     gst_element_post_message (GST_ELEMENT (parse),
1716         gst_message_new_duration_changed (GST_OBJECT (parse)));
1717     parse->priv->estimated_drift = 0;
1718   }
1719 }
1720
1721 /* gst_base_parse_update_bitrates:
1722  * @parse: #GstBaseParse.
1723  * @buffer: Current frame as a #GstBuffer
1724  *
1725  * Keeps track of the minimum and maximum bitrates, and also maintains a
1726  * running average bitrate of the stream so far.
1727  */
1728 static void
1729 gst_base_parse_update_bitrates (GstBaseParse * parse, GstBaseParseFrame * frame)
1730 {
1731   /* Only update the tag on a 10 kbps delta */
1732   static const gint update_threshold = 10000;
1733
1734   guint64 data_len, frame_dur;
1735   gint overhead, frame_bitrate, old_avg_bitrate;
1736   GstBuffer *buffer = frame->buffer;
1737
1738   overhead = frame->overhead;
1739   if (overhead == -1)
1740     return;
1741
1742   data_len = gst_buffer_get_size (buffer) - overhead;
1743   parse->priv->data_bytecount += data_len;
1744
1745   /* duration should be valid by now,
1746    * either set by subclass or maybe based on fps settings */
1747   if (GST_BUFFER_DURATION_IS_VALID (buffer) && parse->priv->acc_duration != 0) {
1748     /* Calculate duration of a frame from buffer properties */
1749     frame_dur = GST_BUFFER_DURATION (buffer);
1750     parse->priv->avg_bitrate = (8 * parse->priv->data_bytecount * GST_SECOND) /
1751         parse->priv->acc_duration;
1752
1753   } else {
1754     /* No way to figure out frame duration (is this even possible?) */
1755     return;
1756   }
1757
1758   /* override if subclass provided bitrate, e.g. metadata based */
1759   if (parse->priv->bitrate) {
1760     parse->priv->avg_bitrate = parse->priv->bitrate;
1761     /* spread this (confirmed) info ASAP */
1762     if (parse->priv->posted_avg_bitrate != parse->priv->avg_bitrate)
1763       parse->priv->tags_changed = TRUE;
1764   }
1765
1766   if (frame_dur)
1767     frame_bitrate = (8 * data_len * GST_SECOND) / frame_dur;
1768   else
1769     return;
1770
1771   GST_LOG_OBJECT (parse, "frame bitrate %u, avg bitrate %u", frame_bitrate,
1772       parse->priv->avg_bitrate);
1773
1774   if (parse->priv->framecount < MIN_FRAMES_TO_POST_BITRATE)
1775     return;
1776
1777   if (parse->priv->framecount == MIN_FRAMES_TO_POST_BITRATE &&
1778       (parse->priv->post_min_bitrate || parse->priv->post_avg_bitrate
1779           || parse->priv->post_max_bitrate))
1780     parse->priv->tags_changed = TRUE;
1781
1782   if (G_LIKELY (parse->priv->framecount >= MIN_FRAMES_TO_POST_BITRATE)) {
1783     if (frame_bitrate < parse->priv->min_bitrate) {
1784       parse->priv->min_bitrate = frame_bitrate;
1785       if (parse->priv->post_min_bitrate)
1786         parse->priv->tags_changed = TRUE;
1787     }
1788
1789     if (frame_bitrate > parse->priv->max_bitrate) {
1790       parse->priv->max_bitrate = frame_bitrate;
1791       if (parse->priv->post_max_bitrate)
1792         parse->priv->tags_changed = TRUE;
1793     }
1794
1795     old_avg_bitrate = parse->priv->posted_avg_bitrate;
1796     if (((gint) (old_avg_bitrate - parse->priv->avg_bitrate) > update_threshold
1797             || (gint) (parse->priv->avg_bitrate - old_avg_bitrate) >
1798             update_threshold) && parse->priv->post_avg_bitrate)
1799       parse->priv->tags_changed = TRUE;
1800   }
1801 }
1802
1803 /**
1804  * gst_base_parse_add_index_entry:
1805  * @parse: #GstBaseParse.
1806  * @offset: offset of entry
1807  * @ts: timestamp associated with offset
1808  * @key: whether entry refers to keyframe
1809  * @force: add entry disregarding sanity checks
1810  *
1811  * Adds an entry to the index associating @offset to @ts.  It is recommended
1812  * to only add keyframe entries.  @force allows to bypass checks, such as
1813  * whether the stream is (upstream) seekable, another entry is already "close"
1814  * to the new entry, etc.
1815  *
1816  * Returns: #gboolean indicating whether entry was added
1817  */
1818 gboolean
1819 gst_base_parse_add_index_entry (GstBaseParse * parse, guint64 offset,
1820     GstClockTime ts, gboolean key, gboolean force)
1821 {
1822   gboolean ret = FALSE;
1823   GstIndexAssociation associations[2];
1824
1825   GST_LOG_OBJECT (parse, "Adding key=%d index entry %" GST_TIME_FORMAT
1826       " @ offset 0x%08" G_GINT64_MODIFIER "x", key, GST_TIME_ARGS (ts), offset);
1827
1828   if (G_LIKELY (!force)) {
1829
1830     if (!parse->priv->upstream_seekable) {
1831       GST_DEBUG_OBJECT (parse, "upstream not seekable; discarding");
1832       goto exit;
1833     }
1834
1835     /* FIXME need better helper data structure that handles these issues
1836      * related to ongoing collecting of index entries */
1837     if (parse->priv->index_last_offset + parse->priv->idx_byte_interval >=
1838         (gint64) offset) {
1839       GST_LOG_OBJECT (parse,
1840           "already have entries up to offset 0x%08" G_GINT64_MODIFIER "x",
1841           parse->priv->index_last_offset + parse->priv->idx_byte_interval);
1842       goto exit;
1843     }
1844
1845     if (GST_CLOCK_TIME_IS_VALID (parse->priv->index_last_ts) &&
1846         GST_CLOCK_DIFF (parse->priv->index_last_ts, ts) <
1847         parse->priv->idx_interval) {
1848       GST_LOG_OBJECT (parse, "entry too close to last time %" GST_TIME_FORMAT,
1849           GST_TIME_ARGS (parse->priv->index_last_ts));
1850       goto exit;
1851     }
1852
1853     /* if last is not really the last one */
1854     if (!parse->priv->index_last_valid) {
1855       GstClockTime prev_ts;
1856
1857       gst_base_parse_find_offset (parse, ts, TRUE, &prev_ts);
1858       if (GST_CLOCK_DIFF (prev_ts, ts) < parse->priv->idx_interval) {
1859         GST_LOG_OBJECT (parse,
1860             "entry too close to existing entry %" GST_TIME_FORMAT,
1861             GST_TIME_ARGS (prev_ts));
1862         parse->priv->index_last_offset = offset;
1863         parse->priv->index_last_ts = ts;
1864         goto exit;
1865       }
1866     }
1867   }
1868
1869   associations[0].format = GST_FORMAT_TIME;
1870   associations[0].value = ts;
1871   associations[1].format = GST_FORMAT_BYTES;
1872   associations[1].value = offset;
1873
1874   /* index might change on-the-fly, although that would be nutty app ... */
1875   GST_BASE_PARSE_INDEX_LOCK (parse);
1876   gst_index_add_associationv (parse->priv->index, parse->priv->index_id,
1877       (key) ? GST_INDEX_ASSOCIATION_FLAG_KEY_UNIT :
1878       GST_INDEX_ASSOCIATION_FLAG_DELTA_UNIT, 2,
1879       (const GstIndexAssociation *) &associations);
1880   GST_BASE_PARSE_INDEX_UNLOCK (parse);
1881
1882   if (key) {
1883     parse->priv->index_last_offset = offset;
1884     parse->priv->index_last_ts = ts;
1885   }
1886
1887   ret = TRUE;
1888
1889 exit:
1890   return ret;
1891 }
1892
1893 /* check for seekable upstream, above and beyond a mere query */
1894 static void
1895 gst_base_parse_check_seekability (GstBaseParse * parse)
1896 {
1897   GstQuery *query;
1898   gboolean seekable = FALSE;
1899   gint64 start = -1, stop = -1;
1900   guint idx_interval = 0;
1901   guint64 idx_byte_interval = 0;
1902
1903   query = gst_query_new_seeking (GST_FORMAT_BYTES);
1904   if (!gst_pad_peer_query (parse->sinkpad, query)) {
1905     GST_DEBUG_OBJECT (parse, "seeking query failed");
1906     goto done;
1907   }
1908
1909   gst_query_parse_seeking (query, NULL, &seekable, &start, &stop);
1910
1911   /* try harder to query upstream size if we didn't get it the first time */
1912   if (seekable && stop == -1) {
1913     GST_DEBUG_OBJECT (parse, "doing duration query to fix up unset stop");
1914     gst_pad_peer_query_duration (parse->sinkpad, GST_FORMAT_BYTES, &stop);
1915   }
1916
1917   /* if upstream doesn't know the size, it's likely that it's not seekable in
1918    * practice even if it technically may be seekable */
1919   if (seekable && (start != 0 || stop <= start)) {
1920     GST_DEBUG_OBJECT (parse, "seekable but unknown start/stop -> disable");
1921     seekable = FALSE;
1922   }
1923
1924   /* let's not put every single frame into our index */
1925   if (seekable) {
1926     if (stop < 10 * 1024 * 1024)
1927       idx_interval = 100;
1928     else if (stop < 100 * 1024 * 1024)
1929       idx_interval = 500;
1930     else
1931       idx_interval = 1000;
1932
1933     /* ensure that even for large files (e.g. very long audio files), the index
1934      * stays reasonably-size, with some arbitrary limit to the total number of
1935      * index entries */
1936     idx_byte_interval = (stop - start) / MAX_INDEX_ENTRIES;
1937     GST_DEBUG_OBJECT (parse,
1938         "Limiting index entries to %d, indexing byte interval %"
1939         G_GUINT64_FORMAT " bytes", MAX_INDEX_ENTRIES, idx_byte_interval);
1940   }
1941
1942 done:
1943   gst_query_unref (query);
1944
1945   GST_DEBUG_OBJECT (parse, "seekable: %d (%" G_GUINT64_FORMAT " - %"
1946       G_GUINT64_FORMAT ")", seekable, start, stop);
1947   parse->priv->upstream_seekable = seekable;
1948   parse->priv->upstream_size = seekable ? stop : 0;
1949
1950   GST_DEBUG_OBJECT (parse, "idx_interval: %ums", idx_interval);
1951   parse->priv->idx_interval = idx_interval * GST_MSECOND;
1952   parse->priv->idx_byte_interval = idx_byte_interval;
1953 }
1954
1955 /* some misc checks on upstream */
1956 static void
1957 gst_base_parse_check_upstream (GstBaseParse * parse)
1958 {
1959   gint64 stop;
1960
1961   if (gst_pad_peer_query_duration (parse->sinkpad, GST_FORMAT_TIME, &stop))
1962     if (GST_CLOCK_TIME_IS_VALID (stop) && stop) {
1963       /* upstream has one, accept it also, and no further updates */
1964       gst_base_parse_set_duration (parse, GST_FORMAT_TIME, stop, 0);
1965       parse->priv->upstream_has_duration = TRUE;
1966     }
1967
1968   GST_DEBUG_OBJECT (parse, "upstream_has_duration: %d",
1969       parse->priv->upstream_has_duration);
1970 }
1971
1972 /* checks src caps to determine if dealing with audio or video */
1973 /* TODO maybe forego automagic stuff and let subclass configure it ? */
1974 static void
1975 gst_base_parse_check_media (GstBaseParse * parse)
1976 {
1977   GstCaps *caps;
1978   GstStructure *s;
1979
1980   caps = gst_pad_get_current_caps (parse->srcpad);
1981   if (G_LIKELY (caps) && (s = gst_caps_get_structure (caps, 0))) {
1982     parse->priv->is_video =
1983         g_str_has_prefix (gst_structure_get_name (s), "video");
1984   } else {
1985     /* historical default */
1986     parse->priv->is_video = FALSE;
1987   }
1988   if (caps)
1989     gst_caps_unref (caps);
1990
1991   parse->priv->checked_media = TRUE;
1992   GST_DEBUG_OBJECT (parse, "media is video: %d", parse->priv->is_video);
1993 }
1994
1995 /* takes ownership of frame */
1996 static void
1997 gst_base_parse_queue_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1998 {
1999   if (!(frame->_private_flags & GST_BASE_PARSE_FRAME_PRIVATE_FLAG_NOALLOC)) {
2000     /* frame allocated on the heap, we can just take ownership */
2001     g_queue_push_tail (&parse->priv->queued_frames, frame);
2002     GST_TRACE ("queued frame %p", frame);
2003   } else {
2004     GstBaseParseFrame *copy;
2005
2006     /* probably allocated on the stack, must make a proper copy */
2007     copy = gst_base_parse_frame_copy (frame);
2008     g_queue_push_tail (&parse->priv->queued_frames, copy);
2009     GST_TRACE ("queued frame %p (copy of %p)", copy, frame);
2010     gst_base_parse_frame_free (frame);
2011   }
2012 }
2013
2014 /* makes sure that @buf is properly prepared and decorated for passing
2015  * to baseclass, and an equally setup frame is returned setup with @buf.
2016  * Takes ownership of @buf. */
2017 static GstBaseParseFrame *
2018 gst_base_parse_prepare_frame (GstBaseParse * parse, GstBuffer * buffer)
2019 {
2020   GstBaseParseFrame *frame = NULL;
2021
2022   buffer = gst_buffer_make_writable (buffer);
2023
2024   GST_LOG_OBJECT (parse,
2025       "preparing frame at offset %" G_GUINT64_FORMAT
2026       " (%#" G_GINT64_MODIFIER "x) of size %" G_GSIZE_FORMAT,
2027       GST_BUFFER_OFFSET (buffer), GST_BUFFER_OFFSET (buffer),
2028       gst_buffer_get_size (buffer));
2029
2030   GST_BUFFER_OFFSET (buffer) = parse->priv->offset;
2031
2032   gst_base_parse_update_flags (parse);
2033
2034   frame = gst_base_parse_frame_new (buffer, 0, 0);
2035   gst_buffer_unref (buffer);
2036   gst_base_parse_update_frame (parse, frame);
2037
2038   /* clear flags for next frame */
2039   parse->priv->discont = FALSE;
2040   parse->priv->new_frame = FALSE;
2041
2042   /* use default handler to provide initial (upstream) metadata */
2043   gst_base_parse_parse_frame (parse, frame);
2044
2045   return frame;
2046 }
2047
2048 /* Wraps buffer in a frame and dispatches to subclass.
2049  * Also manages data skipping and offset handling (including adapter flushing).
2050  * Takes ownership of @buffer */
2051 static GstFlowReturn
2052 gst_base_parse_handle_buffer (GstBaseParse * parse, GstBuffer * buffer,
2053     gint * skip, gint * flushed)
2054 {
2055   GstBaseParseClass *klass = GST_BASE_PARSE_GET_CLASS (parse);
2056   GstBaseParseFrame *frame;
2057   GstFlowReturn ret;
2058
2059   g_return_val_if_fail (skip != NULL || flushed != NULL, GST_FLOW_ERROR);
2060
2061   GST_LOG_OBJECT (parse,
2062       "handling buffer of size %" G_GSIZE_FORMAT " with dts %" GST_TIME_FORMAT
2063       ", pts %" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT,
2064       gst_buffer_get_size (buffer), GST_TIME_ARGS (GST_BUFFER_DTS (buffer)),
2065       GST_TIME_ARGS (GST_BUFFER_PTS (buffer)),
2066       GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)));
2067
2068   /* track what is being flushed during this single round of frame processing */
2069   parse->priv->flushed = 0;
2070   *skip = 0;
2071
2072   /* make it easy for _finish_frame to pick up input data */
2073   if (parse->priv->pad_mode == GST_PAD_MODE_PULL) {
2074     gst_buffer_ref (buffer);
2075     gst_adapter_push (parse->priv->adapter, buffer);
2076   }
2077
2078 #ifdef GST_BASEPARSE_MODIFICATION
2079   /* some one-time start-up */
2080   if (G_UNLIKELY (parse->priv->framecount == 0)) {
2081     gst_base_parse_check_seekability (parse);
2082     gst_base_parse_check_upstream (parse);
2083   }
2084 #endif
2085
2086   frame = gst_base_parse_prepare_frame (parse, buffer);
2087   ret = klass->handle_frame (parse, frame, skip);
2088
2089   *flushed = parse->priv->flushed;
2090
2091   GST_LOG_OBJECT (parse, "handle_frame skipped %d, flushed %d",
2092       *skip, *flushed);
2093
2094   /* subclass can only do one of these, or semantics are too unclear */
2095   g_assert (*skip == 0 || *flushed == 0);
2096
2097   /* track skipping */
2098   if (*skip > 0) {
2099     GstClockTime pts, dts;
2100     GstBuffer *outbuf;
2101
2102     GST_LOG_OBJECT (parse, "finding sync, skipping %d bytes", *skip);
2103     if (parse->segment.rate < 0.0 && !parse->priv->buffers_queued) {
2104       /* reverse playback, and no frames found yet, so we are skipping
2105        * the leading part of a fragment, which may form the tail of
2106        * fragment coming later, hopefully subclass skips efficiently ... */
2107       pts = gst_adapter_prev_pts (parse->priv->adapter, NULL);
2108       dts = gst_adapter_prev_dts (parse->priv->adapter, NULL);
2109       outbuf = gst_adapter_take_buffer (parse->priv->adapter, *skip);
2110       outbuf = gst_buffer_make_writable (outbuf);
2111       GST_BUFFER_PTS (outbuf) = pts;
2112       GST_BUFFER_DTS (outbuf) = dts;
2113       parse->priv->buffers_head =
2114           g_slist_prepend (parse->priv->buffers_head, outbuf);
2115       outbuf = NULL;
2116     } else {
2117       /* If we're asked to skip more than is available in the adapter,
2118          we need to remember what we need to skip for next iteration */
2119       gsize av = gst_adapter_available (parse->priv->adapter);
2120       GST_DEBUG ("Asked to skip %u (%" G_GSIZE_FORMAT " available)", *skip, av);
2121       if (av >= *skip) {
2122         gst_adapter_flush (parse->priv->adapter, *skip);
2123       } else {
2124         GST_DEBUG
2125             ("This is more than available, flushing %" G_GSIZE_FORMAT
2126             ", storing %u to skip", av, (guint) (*skip - av));
2127         parse->priv->skip = *skip - av;
2128         gst_adapter_flush (parse->priv->adapter, av);
2129         *skip = av;
2130       }
2131     }
2132     if (!parse->priv->discont)
2133       parse->priv->sync_offset = parse->priv->offset;
2134     parse->priv->offset += *skip;
2135     parse->priv->discont = TRUE;
2136     /* check for indefinite skipping */
2137     if (ret == GST_FLOW_OK)
2138       ret = gst_base_parse_check_sync (parse);
2139   }
2140
2141   parse->priv->offset += *flushed;
2142
2143   if (parse->priv->pad_mode == GST_PAD_MODE_PULL) {
2144     gst_adapter_clear (parse->priv->adapter);
2145   }
2146
2147   gst_base_parse_frame_free (frame);
2148
2149   return ret;
2150 }
2151
2152 /* gst_base_parse_push_pending_events:
2153  * @parse: #GstBaseParse
2154  *
2155  * Pushes the pending events
2156  */
2157 static void
2158 gst_base_parse_push_pending_events (GstBaseParse * parse)
2159 {
2160   if (G_UNLIKELY (parse->priv->pending_events)) {
2161     GList *r = g_list_reverse (parse->priv->pending_events);
2162     GList *l;
2163
2164     parse->priv->pending_events = NULL;
2165     for (l = r; l != NULL; l = l->next) {
2166       gst_pad_push_event (parse->srcpad, GST_EVENT_CAST (l->data));
2167     }
2168     g_list_free (r);
2169   }
2170 }
2171
2172 /* gst_base_parse_handle_and_push_frame:
2173  * @parse: #GstBaseParse.
2174  * @klass: #GstBaseParseClass.
2175  * @frame: (transfer full): a #GstBaseParseFrame
2176  *
2177  * Parses the frame from given buffer and pushes it forward. Also performs
2178  * timestamp handling and checks the segment limits.
2179  *
2180  * This is called with srcpad STREAM_LOCK held.
2181  *
2182  * Returns: #GstFlowReturn
2183  */
2184 static GstFlowReturn
2185 gst_base_parse_handle_and_push_frame (GstBaseParse * parse,
2186     GstBaseParseFrame * frame)
2187 {
2188   gint64 offset;
2189   GstBuffer *buffer;
2190
2191   g_return_val_if_fail (frame != NULL, GST_FLOW_ERROR);
2192
2193   buffer = frame->buffer;
2194   offset = frame->offset;
2195
2196   /* check if subclass/format can provide ts.
2197    * If so, that allows and enables extra seek and duration determining options */
2198   if (G_UNLIKELY (parse->priv->first_frame_offset < 0)) {
2199     if (GST_BUFFER_PTS_IS_VALID (buffer) && parse->priv->has_timing_info
2200         && parse->priv->pad_mode == GST_PAD_MODE_PULL) {
2201       parse->priv->first_frame_offset = offset;
2202       parse->priv->first_frame_pts = GST_BUFFER_PTS (buffer);
2203       parse->priv->first_frame_dts = GST_BUFFER_DTS (buffer);
2204       GST_DEBUG_OBJECT (parse, "subclass provided dts %" GST_TIME_FORMAT
2205           ", pts %" GST_TIME_FORMAT " for first frame at offset %"
2206           G_GINT64_FORMAT, GST_TIME_ARGS (parse->priv->first_frame_dts),
2207           GST_TIME_ARGS (parse->priv->first_frame_pts),
2208           parse->priv->first_frame_offset);
2209       if (!GST_CLOCK_TIME_IS_VALID (parse->priv->duration)) {
2210         gint64 off;
2211         GstClockTime last_ts = G_MAXINT64;
2212
2213         GST_DEBUG_OBJECT (parse, "no duration; trying scan to determine");
2214         gst_base_parse_locate_time (parse, &last_ts, &off);
2215         if (GST_CLOCK_TIME_IS_VALID (last_ts))
2216           gst_base_parse_set_duration (parse, GST_FORMAT_TIME, last_ts, 0);
2217       }
2218     } else {
2219       /* disable further checks */
2220       parse->priv->first_frame_offset = 0;
2221     }
2222   }
2223
2224   /* track upstream time if provided, not subclass' internal notion of it */
2225   if (parse->priv->upstream_format == GST_FORMAT_TIME) {
2226     GST_BUFFER_PTS (frame->buffer) = GST_CLOCK_TIME_NONE;
2227     GST_BUFFER_DTS (frame->buffer) = GST_CLOCK_TIME_NONE;
2228   }
2229
2230   /* interpolating and no valid pts yet,
2231    * start with dts and carry on from there */
2232   if (parse->priv->infer_ts && parse->priv->pts_interpolate
2233       && !GST_CLOCK_TIME_IS_VALID (parse->priv->next_pts))
2234     parse->priv->next_pts = parse->priv->next_dts;
2235
2236   /* again use default handler to add missing metadata;
2237    * we may have new information on frame properties */
2238   gst_base_parse_parse_frame (parse, frame);
2239
2240 #ifdef GST_BASEPARSE_MODIFICATION
2241   if (parse->priv->first_frame) {
2242     parse->priv->remove_from_total = GST_BUFFER_OFFSET (buffer);
2243     GST_DEBUG_OBJECT (parse, "first frame has offset %" G_GINT64_FORMAT ". remove from total",
2244         parse->priv->remove_from_total);
2245     parse->priv->first_frame = FALSE;
2246   }
2247 #endif
2248
2249   parse->priv->next_pts = GST_CLOCK_TIME_NONE;
2250   if (GST_BUFFER_DTS_IS_VALID (buffer) && GST_BUFFER_DURATION_IS_VALID (buffer)) {
2251     parse->priv->next_dts =
2252         GST_BUFFER_DTS (buffer) + GST_BUFFER_DURATION (buffer);
2253     if (parse->priv->pts_interpolate && GST_BUFFER_PTS_IS_VALID (buffer)) {
2254       GstClockTime next_pts =
2255           GST_BUFFER_PTS (buffer) + GST_BUFFER_DURATION (buffer);
2256       if (next_pts >= parse->priv->next_dts)
2257         parse->priv->next_pts = next_pts;
2258     }
2259   } else {
2260     /* we lost track, do not produce bogus time next time around
2261      * (probably means parser subclass has given up on parsing as well) */
2262     GST_DEBUG_OBJECT (parse, "no next fallback timestamp");
2263     parse->priv->next_dts = GST_CLOCK_TIME_NONE;
2264   }
2265
2266   if (parse->priv->upstream_seekable && parse->priv->exact_position &&
2267       GST_BUFFER_PTS_IS_VALID (buffer))
2268     gst_base_parse_add_index_entry (parse, offset,
2269         GST_BUFFER_PTS (buffer),
2270         !GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT), FALSE);
2271
2272   /* All OK, push queued frames if there are any */
2273   if (G_UNLIKELY (!g_queue_is_empty (&parse->priv->queued_frames))) {
2274     GstBaseParseFrame *queued_frame;
2275
2276     while ((queued_frame = g_queue_pop_head (&parse->priv->queued_frames))) {
2277       gst_base_parse_push_frame (parse, queued_frame);
2278       gst_base_parse_frame_free (queued_frame);
2279     }
2280   }
2281
2282   return gst_base_parse_push_frame (parse, frame);
2283 }
2284
2285 /**
2286  * gst_base_parse_push_frame:
2287  * @parse: #GstBaseParse.
2288  * @frame: (transfer none): a #GstBaseParseFrame
2289  *
2290  * Pushes the frame's buffer downstream, sends any pending events and
2291  * does some timestamp and segment handling. Takes ownership of
2292  * frame's buffer, though caller retains ownership of @frame.
2293  *
2294  * This must be called with sinkpad STREAM_LOCK held.
2295  *
2296  * Returns: #GstFlowReturn
2297  */
2298 GstFlowReturn
2299 gst_base_parse_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
2300 {
2301   GstFlowReturn ret = GST_FLOW_OK;
2302   GstClockTime last_start = GST_CLOCK_TIME_NONE;
2303   GstClockTime last_stop = GST_CLOCK_TIME_NONE;
2304   GstBaseParseClass *klass = GST_BASE_PARSE_GET_CLASS (parse);
2305   GstBuffer *buffer;
2306   gsize size;
2307
2308   g_return_val_if_fail (frame != NULL, GST_FLOW_ERROR);
2309   g_return_val_if_fail (frame->buffer != NULL, GST_FLOW_ERROR);
2310
2311   GST_TRACE_OBJECT (parse, "pushing frame %p", frame);
2312
2313   buffer = frame->buffer;
2314
2315   GST_LOG_OBJECT (parse,
2316       "processing buffer of size %" G_GSIZE_FORMAT " with dts %" GST_TIME_FORMAT
2317       ", pts %" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT,
2318       gst_buffer_get_size (buffer),
2319       GST_TIME_ARGS (GST_BUFFER_DTS (buffer)),
2320       GST_TIME_ARGS (GST_BUFFER_PTS (buffer)),
2321       GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)));
2322
2323   /* update stats */
2324   parse->priv->bytecount += frame->size;
2325   if (G_LIKELY (!(frame->flags & GST_BASE_PARSE_FRAME_FLAG_NO_FRAME))) {
2326     parse->priv->framecount++;
2327     if (GST_BUFFER_DURATION_IS_VALID (buffer)) {
2328       parse->priv->acc_duration += GST_BUFFER_DURATION (buffer);
2329     }
2330   }
2331   /* 0 means disabled */
2332   if (parse->priv->update_interval < 0)
2333     parse->priv->update_interval = 50;
2334   else if (parse->priv->update_interval > 0 &&
2335 #ifdef GST_BASEPARSE_MODIFICATION
2336       ((parse->priv->framecount - 1) % parse->priv->update_interval) == 0)
2337 #else
2338       (parse->priv->framecount % parse->priv->update_interval) == 0)
2339 #endif
2340     gst_base_parse_update_duration (parse);
2341
2342   if (GST_BUFFER_PTS_IS_VALID (buffer))
2343     last_start = last_stop = GST_BUFFER_PTS (buffer);
2344   if (last_start != GST_CLOCK_TIME_NONE
2345       && GST_BUFFER_DURATION_IS_VALID (buffer))
2346     last_stop = last_start + GST_BUFFER_DURATION (buffer);
2347
2348   /* should have caps by now */
2349   if (!gst_pad_has_current_caps (parse->srcpad))
2350     goto no_caps;
2351
2352   if (G_UNLIKELY (!parse->priv->checked_media)) {
2353     /* have caps; check identity */
2354     gst_base_parse_check_media (parse);
2355   }
2356
2357   if (parse->priv->tags_changed) {
2358     gst_base_parse_queue_tag_event_update (parse);
2359     parse->priv->tags_changed = FALSE;
2360   }
2361
2362   /* Push pending events, including SEGMENT events */
2363   gst_base_parse_push_pending_events (parse);
2364
2365   /* segment adjustment magic; only if we are running the whole show */
2366   if (!parse->priv->passthrough && parse->segment.rate > 0.0 &&
2367       (parse->priv->pad_mode == GST_PAD_MODE_PULL ||
2368           parse->priv->upstream_seekable)) {
2369     /* handle gaps */
2370     if (GST_CLOCK_TIME_IS_VALID (parse->segment.position) &&
2371         GST_CLOCK_TIME_IS_VALID (last_start)) {
2372       GstClockTimeDiff diff;
2373
2374       /* only send newsegments with increasing start times,
2375        * otherwise if these go back and forth downstream (sinks) increase
2376        * accumulated time and running_time */
2377       diff = GST_CLOCK_DIFF (parse->segment.position, last_start);
2378       if (G_UNLIKELY (diff > 2 * GST_SECOND
2379               && last_start > parse->segment.start
2380               && (!GST_CLOCK_TIME_IS_VALID (parse->segment.stop)
2381                   || last_start < parse->segment.stop))) {
2382
2383         GST_DEBUG_OBJECT (parse,
2384             "Gap of %" G_GINT64_FORMAT " ns detected in stream " "(%"
2385             GST_TIME_FORMAT " -> %" GST_TIME_FORMAT "). "
2386             "Sending updated SEGMENT events", diff,
2387             GST_TIME_ARGS (parse->segment.position),
2388             GST_TIME_ARGS (last_start));
2389
2390         /* skip gap FIXME */
2391         gst_pad_push_event (parse->srcpad,
2392             gst_event_new_segment (&parse->segment));
2393
2394         parse->segment.position = last_start;
2395       }
2396     }
2397   }
2398
2399   /* update bitrates and optionally post corresponding tags
2400    * (following newsegment) */
2401   gst_base_parse_update_bitrates (parse, frame);
2402
2403   if (klass->pre_push_frame) {
2404     ret = klass->pre_push_frame (parse, frame);
2405   } else {
2406     frame->flags |= GST_BASE_PARSE_FRAME_FLAG_CLIP;
2407   }
2408
2409   /* take final ownership of frame buffer */
2410   if (frame->out_buffer) {
2411     buffer = frame->out_buffer;
2412     frame->out_buffer = NULL;
2413     gst_buffer_replace (&frame->buffer, NULL);
2414   } else {
2415     buffer = frame->buffer;
2416     frame->buffer = NULL;
2417   }
2418
2419   /* subclass must play nice */
2420   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
2421
2422   size = gst_buffer_get_size (buffer);
2423
2424   parse->priv->seen_keyframe |= parse->priv->is_video &&
2425       !GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
2426
2427   if (frame->flags & GST_BASE_PARSE_FRAME_FLAG_CLIP) {
2428     if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer) &&
2429         GST_CLOCK_TIME_IS_VALID (parse->segment.stop) &&
2430         GST_BUFFER_TIMESTAMP (buffer) >
2431         parse->segment.stop + parse->priv->lead_out_ts) {
2432       GST_LOG_OBJECT (parse, "Dropped frame, after segment");
2433       ret = GST_FLOW_EOS;
2434     } else if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer) &&
2435         GST_BUFFER_DURATION_IS_VALID (buffer) &&
2436         GST_CLOCK_TIME_IS_VALID (parse->segment.start) &&
2437         GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer) +
2438         parse->priv->lead_in_ts < parse->segment.start) {
2439       if (parse->priv->seen_keyframe) {
2440         GST_LOG_OBJECT (parse, "Frame before segment, after keyframe");
2441         ret = GST_FLOW_OK;
2442       } else {
2443         GST_LOG_OBJECT (parse, "Dropped frame, before segment");
2444         ret = GST_BASE_PARSE_FLOW_DROPPED;
2445       }
2446     } else {
2447       ret = GST_FLOW_OK;
2448     }
2449   }
2450
2451   if (ret == GST_BASE_PARSE_FLOW_DROPPED) {
2452     GST_LOG_OBJECT (parse, "frame (%" G_GSIZE_FORMAT " bytes) dropped", size);
2453     gst_buffer_unref (buffer);
2454     ret = GST_FLOW_OK;
2455   } else if (ret == GST_FLOW_OK) {
2456     if (parse->segment.rate > 0.0) {
2457       GST_LOG_OBJECT (parse, "pushing frame (%" G_GSIZE_FORMAT " bytes) now..",
2458           size);
2459       ret = gst_pad_push (parse->srcpad, buffer);
2460       GST_LOG_OBJECT (parse, "frame pushed, flow %s", gst_flow_get_name (ret));
2461     } else if (!parse->priv->disable_passthrough && parse->priv->passthrough) {
2462
2463       /* in backwards playback mode, if on passthrough we need to push buffers
2464        * directly without accumulating them into the buffers_queued as baseparse
2465        * will never check for a DISCONT while on passthrough and those buffers
2466        * will never be pushed.
2467        *
2468        * also, as we are on reverse playback, it might be possible that
2469        * passthrough might have just been enabled, so make sure to drain the
2470        * buffers_queued list */
2471       if (G_UNLIKELY (parse->priv->buffers_queued != NULL)) {
2472         gst_base_parse_finish_fragment (parse, TRUE);
2473         ret = gst_base_parse_send_buffers (parse);
2474       }
2475
2476       if (ret == GST_FLOW_OK) {
2477         GST_LOG_OBJECT (parse,
2478             "pushing frame (%" G_GSIZE_FORMAT " bytes) now..", size);
2479         ret = gst_pad_push (parse->srcpad, buffer);
2480         GST_LOG_OBJECT (parse, "frame pushed, flow %s",
2481             gst_flow_get_name (ret));
2482       } else {
2483         GST_LOG_OBJECT (parse,
2484             "frame (%" G_GSIZE_FORMAT " bytes) not pushed: %s", size,
2485             gst_flow_get_name (ret));
2486         gst_buffer_unref (buffer);
2487       }
2488
2489     } else {
2490       GST_LOG_OBJECT (parse, "frame (%" G_GSIZE_FORMAT " bytes) queued for now",
2491           size);
2492       parse->priv->buffers_queued =
2493           g_slist_prepend (parse->priv->buffers_queued, buffer);
2494       ret = GST_FLOW_OK;
2495     }
2496   } else {
2497     GST_LOG_OBJECT (parse, "frame (%" G_GSIZE_FORMAT " bytes) not pushed: %s",
2498         size, gst_flow_get_name (ret));
2499     gst_buffer_unref (buffer);
2500     /* if we are not sufficiently in control, let upstream decide on EOS */
2501     if (ret == GST_FLOW_EOS && !parse->priv->disable_passthrough &&
2502         (parse->priv->passthrough ||
2503             (parse->priv->pad_mode == GST_PAD_MODE_PUSH &&
2504                 !parse->priv->upstream_seekable)))
2505       ret = GST_FLOW_OK;
2506   }
2507
2508   /* Update current running segment position */
2509   if ((ret == GST_FLOW_OK || ret == GST_FLOW_NOT_LINKED)
2510       && last_stop != GST_CLOCK_TIME_NONE
2511       && parse->segment.position < last_stop)
2512     parse->segment.position = last_stop;
2513
2514   return ret;
2515
2516   /* ERRORS */
2517 no_caps:
2518   {
2519     if (GST_PAD_IS_FLUSHING (parse->srcpad))
2520       return GST_FLOW_FLUSHING;
2521
2522     GST_ELEMENT_ERROR (parse, STREAM, DECODE, ("No caps set"), (NULL));
2523     return GST_FLOW_ERROR;
2524   }
2525 }
2526
2527 /**
2528  * gst_base_parse_finish_frame:
2529  * @parse: a #GstBaseParse
2530  * @frame: a #GstBaseParseFrame
2531  * @size: consumed input data represented by frame
2532  *
2533  * Collects parsed data and pushes this downstream.
2534  * Source pad caps must be set when this is called.
2535  *
2536  * If @frame's out_buffer is set, that will be used as subsequent frame data.
2537  * Otherwise, @size samples will be taken from the input and used for output,
2538  * and the output's metadata (timestamps etc) will be taken as (optionally)
2539  * set by the subclass on @frame's (input) buffer (which is otherwise
2540  * ignored for any but the above purpose/information).
2541  *
2542  * Note that the latter buffer is invalidated by this call, whereas the
2543  * caller retains ownership of @frame.
2544  *
2545  * Returns: a #GstFlowReturn that should be escalated to caller (of caller)
2546  */
2547 GstFlowReturn
2548 gst_base_parse_finish_frame (GstBaseParse * parse, GstBaseParseFrame * frame,
2549     gint size)
2550 {
2551   GstFlowReturn ret = GST_FLOW_OK;
2552
2553   g_return_val_if_fail (frame != NULL, GST_FLOW_ERROR);
2554   g_return_val_if_fail (frame->buffer != NULL, GST_FLOW_ERROR);
2555   g_return_val_if_fail (size > 0 || frame->out_buffer, GST_FLOW_ERROR);
2556   g_return_val_if_fail (gst_adapter_available (parse->priv->adapter) >= size,
2557       GST_FLOW_ERROR);
2558
2559   GST_LOG_OBJECT (parse, "finished frame at offset %" G_GUINT64_FORMAT ", "
2560       "flushing size %d", frame->offset, size);
2561
2562   /* some one-time start-up */
2563   if (G_UNLIKELY (parse->priv->framecount == 0)) {
2564     gst_base_parse_check_seekability (parse);
2565     gst_base_parse_check_upstream (parse);
2566   }
2567
2568   parse->priv->flushed += size;
2569
2570   if (parse->priv->scanning && frame->buffer) {
2571     if (!parse->priv->scanned_frame) {
2572       parse->priv->scanned_frame = gst_base_parse_frame_copy (frame);
2573     }
2574     goto exit;
2575   }
2576
2577   /* either PUSH or PULL mode arranges for adapter data */
2578   /* ensure output buffer */
2579   if (!frame->out_buffer) {
2580     GstBuffer *src, *dest;
2581
2582     frame->out_buffer = gst_adapter_take_buffer (parse->priv->adapter, size);
2583     dest = frame->out_buffer;
2584     src = frame->buffer;
2585     GST_BUFFER_PTS (dest) = GST_BUFFER_PTS (src);
2586     GST_BUFFER_DTS (dest) = GST_BUFFER_DTS (src);
2587     GST_BUFFER_OFFSET (dest) = GST_BUFFER_OFFSET (src);
2588     GST_BUFFER_DURATION (dest) = GST_BUFFER_DURATION (src);
2589     GST_BUFFER_OFFSET_END (dest) = GST_BUFFER_OFFSET_END (src);
2590     GST_MINI_OBJECT_FLAGS (dest) = GST_MINI_OBJECT_FLAGS (src);
2591   } else {
2592     gst_adapter_flush (parse->priv->adapter, size);
2593   }
2594
2595   /* use as input for subsequent processing */
2596   gst_buffer_replace (&frame->buffer, frame->out_buffer);
2597   gst_buffer_unref (frame->out_buffer);
2598   frame->out_buffer = NULL;
2599
2600   /* mark input size consumed */
2601   frame->size = size;
2602
2603   /* subclass might queue frames/data internally if it needs more
2604    * frames to decide on the format, or might request us to queue here. */
2605   if (frame->flags & GST_BASE_PARSE_FRAME_FLAG_DROP) {
2606     gst_buffer_replace (&frame->buffer, NULL);
2607     goto exit;
2608   } else if (frame->flags & GST_BASE_PARSE_FRAME_FLAG_QUEUE) {
2609     GstBaseParseFrame *copy;
2610
2611     copy = gst_base_parse_frame_copy (frame);
2612     copy->flags &= ~GST_BASE_PARSE_FRAME_FLAG_QUEUE;
2613     gst_base_parse_queue_frame (parse, copy);
2614     goto exit;
2615   }
2616
2617   ret = gst_base_parse_handle_and_push_frame (parse, frame);
2618
2619 exit:
2620   return ret;
2621 }
2622
2623 /* gst_base_parse_drain:
2624  *
2625  * Drains the adapter until it is empty. It decreases the min_frame_size to
2626  * match the current adapter size and calls chain method until the adapter
2627  * is emptied or chain returns with error.
2628  */
2629 static void
2630 gst_base_parse_drain (GstBaseParse * parse)
2631 {
2632   guint avail;
2633
2634   GST_DEBUG_OBJECT (parse, "draining");
2635   parse->priv->drain = TRUE;
2636
2637   for (;;) {
2638     avail = gst_adapter_available (parse->priv->adapter);
2639     if (!avail)
2640       break;
2641
2642     if (gst_base_parse_chain (parse->sinkpad, GST_OBJECT_CAST (parse),
2643             NULL) != GST_FLOW_OK) {
2644       break;
2645     }
2646
2647     /* nothing changed, maybe due to truncated frame; break infinite loop */
2648     if (avail == gst_adapter_available (parse->priv->adapter)) {
2649       GST_DEBUG_OBJECT (parse, "no change during draining; flushing");
2650       gst_adapter_clear (parse->priv->adapter);
2651     }
2652   }
2653
2654   parse->priv->drain = FALSE;
2655 }
2656
2657 /* gst_base_parse_send_buffers
2658  *
2659  * Sends buffers collected in send_buffers downstream, and ensures that list
2660  * is empty at the end (errors or not).
2661  */
2662 static GstFlowReturn
2663 gst_base_parse_send_buffers (GstBaseParse * parse)
2664 {
2665   GSList *send = NULL;
2666   GstBuffer *buf;
2667   GstFlowReturn ret = GST_FLOW_OK;
2668   gboolean first = TRUE;
2669
2670   send = parse->priv->buffers_send;
2671
2672   /* send buffers */
2673   while (send) {
2674     buf = GST_BUFFER_CAST (send->data);
2675     GST_LOG_OBJECT (parse, "pushing buffer %p, dts %"
2676         GST_TIME_FORMAT ", pts %" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT
2677         ", offset %" G_GINT64_FORMAT, buf,
2678         GST_TIME_ARGS (GST_BUFFER_DTS (buf)),
2679         GST_TIME_ARGS (GST_BUFFER_PTS (buf)),
2680         GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_BUFFER_OFFSET (buf));
2681
2682     /* Make sure the first buffer is always DISCONT. If we split
2683      * GOPs inside the parser this is otherwise not guaranteed */
2684     if (first) {
2685       GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
2686       first = FALSE;
2687     }
2688
2689     /* iterate output queue an push downstream */
2690     ret = gst_pad_push (parse->srcpad, buf);
2691     send = g_slist_delete_link (send, send);
2692
2693     /* clear any leftover if error */
2694     if (G_UNLIKELY (ret != GST_FLOW_OK)) {
2695       while (send) {
2696         buf = GST_BUFFER_CAST (send->data);
2697         gst_buffer_unref (buf);
2698         send = g_slist_delete_link (send, send);
2699       }
2700     }
2701   }
2702
2703   parse->priv->buffers_send = send;
2704
2705   return ret;
2706 }
2707
2708 /* gst_base_parse_start_fragment:
2709  *
2710  * Prepares for processing a reverse playback (forward) fragment
2711  * by (re)setting proper state variables.
2712  */
2713 static GstFlowReturn
2714 gst_base_parse_start_fragment (GstBaseParse * parse)
2715 {
2716   GST_LOG_OBJECT (parse, "starting fragment");
2717
2718   /* invalidate so no fall-back timestamping is performed;
2719    * ok if taken from subclass or upstream */
2720   parse->priv->next_pts = GST_CLOCK_TIME_NONE;
2721   parse->priv->prev_pts = GST_CLOCK_TIME_NONE;
2722   parse->priv->next_dts = GST_CLOCK_TIME_NONE;
2723   parse->priv->prev_dts = GST_CLOCK_TIME_NONE;
2724   /* prevent it hanging around stop all the time */
2725   parse->segment.position = GST_CLOCK_TIME_NONE;
2726   /* mark next run */
2727   parse->priv->discont = TRUE;
2728
2729   /* head of previous fragment is now pending tail of current fragment */
2730   parse->priv->buffers_pending = parse->priv->buffers_head;
2731   parse->priv->buffers_head = NULL;
2732
2733   return GST_FLOW_OK;
2734 }
2735
2736
2737 /* gst_base_parse_finish_fragment:
2738  *
2739  * Processes a reverse playback (forward) fragment:
2740  * - append head of last fragment that was skipped to current fragment data
2741  * - drain the resulting current fragment data (i.e. repeated chain)
2742  * - add time/duration (if needed) to frames queued by chain
2743  * - push queued data
2744  */
2745 static GstFlowReturn
2746 gst_base_parse_finish_fragment (GstBaseParse * parse, gboolean prev_head)
2747 {
2748   GstBuffer *buf;
2749   GstFlowReturn ret = GST_FLOW_OK;
2750   gboolean seen_key = FALSE, seen_delta = FALSE;
2751
2752   GST_LOG_OBJECT (parse, "finishing fragment");
2753
2754   /* restore order */
2755   parse->priv->buffers_pending = g_slist_reverse (parse->priv->buffers_pending);
2756   while (parse->priv->buffers_pending) {
2757     buf = GST_BUFFER_CAST (parse->priv->buffers_pending->data);
2758     if (prev_head) {
2759       GST_LOG_OBJECT (parse, "adding pending buffer (size %" G_GSIZE_FORMAT ")",
2760           gst_buffer_get_size (buf));
2761       gst_adapter_push (parse->priv->adapter, buf);
2762     } else {
2763       GST_LOG_OBJECT (parse, "discarding head buffer");
2764       gst_buffer_unref (buf);
2765     }
2766     parse->priv->buffers_pending =
2767         g_slist_delete_link (parse->priv->buffers_pending,
2768         parse->priv->buffers_pending);
2769   }
2770
2771   /* chain looks for frames and queues resulting ones (in stead of pushing) */
2772   /* initial skipped data is added to buffers_pending */
2773   gst_base_parse_drain (parse);
2774
2775   if (parse->priv->buffers_send) {
2776     buf = GST_BUFFER_CAST (parse->priv->buffers_send->data);
2777     seen_key |= !GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
2778   }
2779
2780   /* add metadata (if needed to queued buffers */
2781   GST_LOG_OBJECT (parse, "last timestamp: %" GST_TIME_FORMAT,
2782       GST_TIME_ARGS (parse->priv->last_pts));
2783   while (parse->priv->buffers_queued) {
2784     buf = GST_BUFFER_CAST (parse->priv->buffers_queued->data);
2785
2786     /* no touching if upstream or parsing provided time */
2787     if (GST_BUFFER_PTS_IS_VALID (buf)) {
2788       GST_LOG_OBJECT (parse, "buffer has time %" GST_TIME_FORMAT,
2789           GST_TIME_ARGS (GST_BUFFER_PTS (buf)));
2790     } else if (GST_BUFFER_DURATION_IS_VALID (buf)) {
2791       if (GST_CLOCK_TIME_IS_VALID (parse->priv->last_pts)) {
2792         if (G_LIKELY (GST_BUFFER_DURATION (buf) <= parse->priv->last_pts))
2793           parse->priv->last_pts -= GST_BUFFER_DURATION (buf);
2794         else
2795           parse->priv->last_pts = 0;
2796         GST_BUFFER_PTS (buf) = parse->priv->last_pts;
2797         GST_LOG_OBJECT (parse, "applied time %" GST_TIME_FORMAT,
2798             GST_TIME_ARGS (GST_BUFFER_PTS (buf)));
2799       }
2800       if (GST_CLOCK_TIME_IS_VALID (parse->priv->last_dts)) {
2801         if (G_LIKELY (GST_BUFFER_DURATION (buf) <= parse->priv->last_dts))
2802           parse->priv->last_dts -= GST_BUFFER_DURATION (buf);
2803         else
2804           parse->priv->last_dts = 0;
2805         GST_BUFFER_DTS (buf) = parse->priv->last_dts;
2806         GST_LOG_OBJECT (parse, "applied dts %" GST_TIME_FORMAT,
2807             GST_TIME_ARGS (GST_BUFFER_DTS (buf)));
2808       }
2809     } else {
2810       /* no idea, very bad */
2811       GST_WARNING_OBJECT (parse, "could not determine time for buffer");
2812     }
2813
2814     parse->priv->last_pts = GST_BUFFER_PTS (buf);
2815     parse->priv->last_dts = GST_BUFFER_DTS (buf);
2816
2817     /* reverse order for ascending sending */
2818     /* send downstream at keyframe not preceded by a keyframe
2819      * (e.g. that should identify start of collection of IDR nals) */
2820     if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT)) {
2821       if (seen_key) {
2822         ret = gst_base_parse_send_buffers (parse);
2823         /* if a problem, throw all to sending */
2824         if (ret != GST_FLOW_OK) {
2825           parse->priv->buffers_send =
2826               g_slist_reverse (parse->priv->buffers_queued);
2827           parse->priv->buffers_queued = NULL;
2828           break;
2829         }
2830         seen_key = FALSE;
2831       }
2832       seen_delta = TRUE;
2833     } else {
2834       seen_key = TRUE;
2835     }
2836
2837     parse->priv->buffers_send =
2838         g_slist_prepend (parse->priv->buffers_send, buf);
2839     parse->priv->buffers_queued =
2840         g_slist_delete_link (parse->priv->buffers_queued,
2841         parse->priv->buffers_queued);
2842   }
2843
2844   /* audio may have all marked as keyframe, so arrange to send here. Also
2845    * we might have ended the loop above on a keyframe, in which case we
2846    * should */
2847   if (!seen_delta || seen_key)
2848     ret = gst_base_parse_send_buffers (parse);
2849
2850   /* any trailing unused no longer usable (ideally none) */
2851   if (G_UNLIKELY (gst_adapter_available (parse->priv->adapter))) {
2852     GST_DEBUG_OBJECT (parse, "discarding %" G_GSIZE_FORMAT " trailing bytes",
2853         gst_adapter_available (parse->priv->adapter));
2854     gst_adapter_clear (parse->priv->adapter);
2855   }
2856
2857   return ret;
2858 }
2859
2860 /* small helper that checks whether we have been trying to resync too long */
2861 static inline GstFlowReturn
2862 gst_base_parse_check_sync (GstBaseParse * parse)
2863 {
2864   if (G_UNLIKELY (parse->priv->discont &&
2865           parse->priv->offset - parse->priv->sync_offset > 2 * 1024 * 1024)) {
2866     GST_ELEMENT_ERROR (parse, STREAM, DECODE,
2867         ("Failed to parse stream"), (NULL));
2868     return GST_FLOW_ERROR;
2869   }
2870
2871   return GST_FLOW_OK;
2872 }
2873
2874 static GstFlowReturn
2875 gst_base_parse_process_streamheader (GstBaseParse * parse)
2876 {
2877   GstCaps *caps;
2878   GstStructure *str;
2879   const GValue *value;
2880   GstFlowReturn ret = GST_FLOW_OK;
2881
2882   caps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (parse));
2883   if (caps == NULL)
2884     goto notfound;
2885
2886   str = gst_caps_get_structure (caps, 0);
2887   value = gst_structure_get_value (str, "streamheader");
2888   if (value == NULL)
2889     goto notfound;
2890
2891   GST_DEBUG_OBJECT (parse, "Found streamheader field on input caps");
2892
2893   if (GST_VALUE_HOLDS_ARRAY (value)) {
2894     gint i;
2895     gsize len = gst_value_array_get_size (value);
2896
2897     for (i = 0; i < len; i++) {
2898       GstBuffer *buffer =
2899           gst_value_get_buffer (gst_value_array_get_value (value, i));
2900       ret =
2901           gst_base_parse_chain (GST_BASE_PARSE_SINK_PAD (parse),
2902           GST_OBJECT_CAST (parse), gst_buffer_ref (buffer));
2903     }
2904
2905   } else if (GST_VALUE_HOLDS_BUFFER (value)) {
2906     GstBuffer *buffer = gst_value_get_buffer (value);
2907     ret =
2908         gst_base_parse_chain (GST_BASE_PARSE_SINK_PAD (parse),
2909         GST_OBJECT_CAST (parse), gst_buffer_ref (buffer));
2910   }
2911
2912   gst_caps_unref (caps);
2913
2914   return ret;
2915
2916 notfound:
2917   {
2918     if (caps) {
2919       gst_caps_unref (caps);
2920     }
2921
2922     GST_DEBUG_OBJECT (parse, "No streamheader on caps");
2923     return GST_FLOW_OK;
2924   }
2925 }
2926
2927 static GstFlowReturn
2928 gst_base_parse_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
2929 {
2930   GstBaseParseClass *bclass;
2931   GstBaseParse *parse;
2932   GstFlowReturn ret = GST_FLOW_OK;
2933   GstFlowReturn old_ret = GST_FLOW_OK;
2934   GstBuffer *tmpbuf = NULL;
2935   guint fsize = 1;
2936   gint skip = -1;
2937   guint min_size, av;
2938   GstClockTime pts, dts;
2939
2940   parse = GST_BASE_PARSE (parent);
2941   bclass = GST_BASE_PARSE_GET_CLASS (parse);
2942   GST_DEBUG_OBJECT (parent, "chain");
2943
2944   /* early out for speed, if we need to skip */
2945   if (buffer && GST_BUFFER_IS_DISCONT (buffer))
2946     parse->priv->skip = 0;
2947   if (parse->priv->skip > 0) {
2948     gsize bsize = gst_buffer_get_size (buffer);
2949     GST_DEBUG ("Got %" G_GSIZE_FORMAT " buffer, need to skip %u", bsize,
2950         parse->priv->skip);
2951     if (parse->priv->skip >= bsize) {
2952       parse->priv->skip -= bsize;
2953       GST_DEBUG ("All the buffer is skipped");
2954       parse->priv->offset += bsize;
2955       parse->priv->sync_offset = parse->priv->offset;
2956       return GST_FLOW_OK;
2957     }
2958     buffer = gst_buffer_make_writable (buffer);
2959     gst_buffer_resize (buffer, parse->priv->skip, bsize - parse->priv->skip);
2960     parse->priv->offset += parse->priv->skip;
2961     GST_DEBUG ("Done skipping, we have %u left on this buffer",
2962         (unsigned) (bsize - parse->priv->skip));
2963     parse->priv->skip = 0;
2964     parse->priv->discont = TRUE;
2965   }
2966
2967   if (G_UNLIKELY (parse->priv->first_buffer)) {
2968     parse->priv->first_buffer = FALSE;
2969     if (!GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_HEADER)) {
2970       /* this stream has no header buffers, check if we just prepend the
2971        * streamheader from caps to the stream */
2972       GST_DEBUG_OBJECT (parse, "Looking for streamheader field on caps to "
2973           "prepend to the stream");
2974       gst_base_parse_process_streamheader (parse);
2975     } else {
2976       GST_DEBUG_OBJECT (parse, "Stream has header buffers, not prepending "
2977           "streamheader from caps");
2978     }
2979   }
2980
2981   if (parse->priv->detecting) {
2982     GstBuffer *detect_buf;
2983
2984     if (parse->priv->detect_buffers_size == 0) {
2985       detect_buf = gst_buffer_ref (buffer);
2986     } else {
2987       GList *l;
2988       guint offset = 0;
2989
2990       detect_buf = gst_buffer_new ();
2991
2992       for (l = parse->priv->detect_buffers; l; l = l->next) {
2993         gsize tmpsize = gst_buffer_get_size (l->data);
2994
2995         gst_buffer_copy_into (detect_buf, GST_BUFFER_CAST (l->data),
2996             GST_BUFFER_COPY_MEMORY, offset, tmpsize);
2997         offset += tmpsize;
2998       }
2999       if (buffer)
3000         gst_buffer_copy_into (detect_buf, buffer, GST_BUFFER_COPY_MEMORY,
3001             offset, gst_buffer_get_size (buffer));
3002     }
3003
3004     ret = bclass->detect (parse, detect_buf);
3005     gst_buffer_unref (detect_buf);
3006
3007     if (ret == GST_FLOW_OK) {
3008       GList *l;
3009
3010       /* Detected something */
3011       parse->priv->detecting = FALSE;
3012
3013       for (l = parse->priv->detect_buffers; l; l = l->next) {
3014         if (ret == GST_FLOW_OK && !parse->priv->flushing)
3015           ret =
3016               gst_base_parse_chain (GST_BASE_PARSE_SINK_PAD (parse),
3017               parent, GST_BUFFER_CAST (l->data));
3018         else
3019           gst_buffer_unref (GST_BUFFER_CAST (l->data));
3020       }
3021       g_list_free (parse->priv->detect_buffers);
3022       parse->priv->detect_buffers = NULL;
3023       parse->priv->detect_buffers_size = 0;
3024
3025       if (ret != GST_FLOW_OK) {
3026         return ret;
3027       }
3028
3029       /* Handle the current buffer */
3030     } else if (ret == GST_FLOW_NOT_NEGOTIATED) {
3031       /* Still detecting, append buffer or error out if draining */
3032
3033       if (parse->priv->drain) {
3034         GST_DEBUG_OBJECT (parse, "Draining but did not detect format yet");
3035         return GST_FLOW_ERROR;
3036       } else if (parse->priv->flushing) {
3037         g_list_foreach (parse->priv->detect_buffers, (GFunc) gst_buffer_unref,
3038             NULL);
3039         g_list_free (parse->priv->detect_buffers);
3040         parse->priv->detect_buffers = NULL;
3041         parse->priv->detect_buffers_size = 0;
3042       } else {
3043         parse->priv->detect_buffers =
3044             g_list_append (parse->priv->detect_buffers, buffer);
3045         parse->priv->detect_buffers_size += gst_buffer_get_size (buffer);
3046         return GST_FLOW_OK;
3047       }
3048     } else {
3049       /* Something went wrong, subclass responsible for error reporting */
3050       return ret;
3051     }
3052
3053     /* And now handle the current buffer if detection worked */
3054   }
3055
3056   if (G_LIKELY (buffer)) {
3057     GST_LOG_OBJECT (parse,
3058         "buffer size: %" G_GSIZE_FORMAT ", offset = %" G_GINT64_FORMAT
3059         ", dts %" GST_TIME_FORMAT ", pts %" GST_TIME_FORMAT,
3060         gst_buffer_get_size (buffer), GST_BUFFER_OFFSET (buffer),
3061         GST_TIME_ARGS (GST_BUFFER_DTS (buffer)),
3062         GST_TIME_ARGS (GST_BUFFER_PTS (buffer)));
3063
3064     if (G_UNLIKELY (!parse->priv->disable_passthrough
3065             && parse->priv->passthrough)) {
3066       GstBaseParseFrame frame;
3067
3068       gst_base_parse_frame_init (&frame);
3069       frame.buffer = gst_buffer_make_writable (buffer);
3070       ret = gst_base_parse_push_frame (parse, &frame);
3071       gst_base_parse_frame_free (&frame);
3072       return ret;
3073     }
3074     if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))) {
3075       /* upstream feeding us in reverse playback;
3076        * finish previous fragment and start new upon DISCONT */
3077       if (parse->segment.rate < 0.0) {
3078         GST_DEBUG_OBJECT (parse, "buffer starts new reverse playback fragment");
3079         ret = gst_base_parse_finish_fragment (parse, TRUE);
3080         gst_base_parse_start_fragment (parse);
3081       } else {
3082         /* discont in the stream, drain and mark discont for next output */
3083         gst_base_parse_drain (parse);
3084         parse->priv->discont = TRUE;
3085       }
3086     }
3087     gst_adapter_push (parse->priv->adapter, buffer);
3088   }
3089
3090   /* Parse and push as many frames as possible */
3091   /* Stop either when adapter is empty or we are flushing */
3092   while (!parse->priv->flushing) {
3093     gint flush = 0;
3094
3095     /* note: if subclass indicates MAX fsize,
3096      * this will not likely be available anyway ... */
3097     min_size = MAX (parse->priv->min_frame_size, fsize);
3098     av = gst_adapter_available (parse->priv->adapter);
3099
3100     if (G_UNLIKELY (parse->priv->drain)) {
3101       min_size = av;
3102       GST_DEBUG_OBJECT (parse, "draining, data left: %d", min_size);
3103       if (G_UNLIKELY (!min_size)) {
3104         goto done;
3105       }
3106     }
3107
3108     /* Collect at least min_frame_size bytes */
3109     if (av < min_size) {
3110       GST_DEBUG_OBJECT (parse, "not enough data available (only %d bytes)", av);
3111       goto done;
3112     }
3113
3114     /* move along with upstream timestamp (if any),
3115      * but interpolate in between */
3116     pts = gst_adapter_prev_pts (parse->priv->adapter, NULL);
3117     dts = gst_adapter_prev_dts (parse->priv->adapter, NULL);
3118     if (GST_CLOCK_TIME_IS_VALID (pts) && (parse->priv->prev_pts != pts))
3119       parse->priv->prev_pts = parse->priv->next_pts = pts;
3120
3121     if (GST_CLOCK_TIME_IS_VALID (dts) && (parse->priv->prev_dts != dts))
3122       parse->priv->prev_dts = parse->priv->next_dts = dts;
3123
3124     /* we can mess with, erm interpolate, timestamps,
3125      * and incoming stuff has PTS but no DTS seen so far,
3126      * then pick up DTS from PTS and hope for the best ... */
3127     if (parse->priv->infer_ts &&
3128         parse->priv->pts_interpolate &&
3129         !GST_CLOCK_TIME_IS_VALID (dts) &&
3130         !GST_CLOCK_TIME_IS_VALID (parse->priv->prev_dts) &&
3131         GST_CLOCK_TIME_IS_VALID (pts))
3132       parse->priv->next_dts = pts;
3133
3134     /* always pass all available data */
3135     tmpbuf = gst_adapter_get_buffer (parse->priv->adapter, av);
3136
3137     /* already inform subclass what timestamps we have planned,
3138      * at least if provided by time-based upstream */
3139     if (parse->priv->upstream_format == GST_FORMAT_TIME) {
3140       tmpbuf = gst_buffer_make_writable (tmpbuf);
3141       GST_BUFFER_PTS (tmpbuf) = parse->priv->next_pts;
3142       GST_BUFFER_DTS (tmpbuf) = parse->priv->next_dts;
3143       GST_BUFFER_DURATION (tmpbuf) = GST_CLOCK_TIME_NONE;
3144     }
3145
3146     /* keep the adapter mapped, so keep track of what has to be flushed */
3147     ret = gst_base_parse_handle_buffer (parse, tmpbuf, &skip, &flush);
3148     tmpbuf = NULL;
3149
3150     if (ret != GST_FLOW_OK && ret != GST_FLOW_NOT_LINKED) {
3151       goto done;
3152     }
3153     if (skip == 0 && flush == 0) {
3154       GST_LOG_OBJECT (parse, "nothing skipped and no frames finished, "
3155           "breaking to get more data");
3156       /* ignore this return as it produced no data */
3157       ret = old_ret;
3158       goto done;
3159     }
3160     old_ret = ret;
3161   }
3162
3163 done:
3164   GST_LOG_OBJECT (parse, "chain leaving");
3165   return ret;
3166 }
3167
3168 /* pull @size bytes at current offset,
3169  * i.e. at least try to and possibly return a shorter buffer if near the end */
3170 static GstFlowReturn
3171 gst_base_parse_pull_range (GstBaseParse * parse, guint size,
3172     GstBuffer ** buffer)
3173 {
3174   GstFlowReturn ret = GST_FLOW_OK;
3175
3176   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
3177
3178   /* Caching here actually makes much less difference than one would expect.
3179    * We do it mainly to avoid pulling buffers of 1 byte all the time */
3180   if (parse->priv->cache) {
3181     gint64 cache_offset = GST_BUFFER_OFFSET (parse->priv->cache);
3182     gint cache_size = gst_buffer_get_size (parse->priv->cache);
3183
3184     if (cache_offset <= parse->priv->offset &&
3185         (parse->priv->offset + size) <= (cache_offset + cache_size)) {
3186       *buffer = gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL,
3187           parse->priv->offset - cache_offset, size);
3188       GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
3189       return GST_FLOW_OK;
3190     }
3191     /* not enough data in the cache, free cache and get a new one */
3192     gst_buffer_unref (parse->priv->cache);
3193     parse->priv->cache = NULL;
3194   }
3195
3196   /* refill the cache */
3197   ret =
3198       gst_pad_pull_range (parse->sinkpad, parse->priv->offset, MAX (size,
3199           64 * 1024), &parse->priv->cache);
3200   if (ret != GST_FLOW_OK) {
3201     parse->priv->cache = NULL;
3202     return ret;
3203   }
3204
3205   if (gst_buffer_get_size (parse->priv->cache) >= size) {
3206     *buffer =
3207         gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL, 0,
3208         size);
3209     GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
3210     return GST_FLOW_OK;
3211   }
3212
3213   /* Not possible to get enough data, try a last time with
3214    * requesting exactly the size we need */
3215   gst_buffer_unref (parse->priv->cache);
3216   parse->priv->cache = NULL;
3217
3218   ret = gst_pad_pull_range (parse->sinkpad, parse->priv->offset, size,
3219       &parse->priv->cache);
3220
3221   if (ret != GST_FLOW_OK) {
3222     GST_DEBUG_OBJECT (parse, "pull_range returned %d", ret);
3223     *buffer = NULL;
3224     return ret;
3225   }
3226
3227   if (gst_buffer_get_size (parse->priv->cache) < size) {
3228     GST_DEBUG_OBJECT (parse, "Returning short buffer at offset %"
3229         G_GUINT64_FORMAT ": wanted %u bytes, got %" G_GSIZE_FORMAT " bytes",
3230         parse->priv->offset, size, gst_buffer_get_size (parse->priv->cache));
3231
3232     *buffer = parse->priv->cache;
3233     parse->priv->cache = NULL;
3234
3235     return GST_FLOW_OK;
3236   }
3237
3238   *buffer =
3239       gst_buffer_copy_region (parse->priv->cache, GST_BUFFER_COPY_ALL, 0, size);
3240   GST_BUFFER_OFFSET (*buffer) = parse->priv->offset;
3241
3242   return GST_FLOW_OK;
3243 }
3244
3245 static GstFlowReturn
3246 gst_base_parse_handle_previous_fragment (GstBaseParse * parse)
3247 {
3248   gint64 offset = 0;
3249   GstClockTime ts = 0;
3250   GstBuffer *buffer;
3251   GstFlowReturn ret;
3252
3253   GST_DEBUG_OBJECT (parse, "fragment ended; last_ts = %" GST_TIME_FORMAT
3254       ", last_offset = %" G_GINT64_FORMAT,
3255       GST_TIME_ARGS (parse->priv->last_pts), parse->priv->last_offset);
3256
3257   if (!parse->priv->last_offset
3258       || parse->priv->last_pts <= parse->segment.start) {
3259     GST_DEBUG_OBJECT (parse, "past start of segment %" GST_TIME_FORMAT,
3260         GST_TIME_ARGS (parse->segment.start));
3261     ret = GST_FLOW_EOS;
3262     goto exit;
3263   }
3264
3265   /* last fragment started at last_offset / last_ts;
3266    * seek back 10s capped at 1MB */
3267   if (parse->priv->last_pts >= 10 * GST_SECOND)
3268     ts = parse->priv->last_pts - 10 * GST_SECOND;
3269   /* if we are exact now, we will be more so going backwards */
3270   if (parse->priv->exact_position) {
3271     offset = gst_base_parse_find_offset (parse, ts, TRUE, NULL);
3272   } else {
3273     if (!gst_base_parse_convert (parse, GST_FORMAT_TIME, ts,
3274             GST_FORMAT_BYTES, &offset)) {
3275       GST_DEBUG_OBJECT (parse, "conversion failed, only BYTE based");
3276     }
3277   }
3278   offset = CLAMP (offset, parse->priv->last_offset - 1024 * 1024,
3279       parse->priv->last_offset - 1024);
3280   offset = MAX (0, offset);
3281
3282   GST_DEBUG_OBJECT (parse, "next fragment from offset %" G_GINT64_FORMAT,
3283       offset);
3284   parse->priv->offset = offset;
3285
3286   ret = gst_base_parse_pull_range (parse, parse->priv->last_offset - offset,
3287       &buffer);
3288   if (ret != GST_FLOW_OK)
3289     goto exit;
3290
3291   /* offset will increase again as fragment is processed/parsed */
3292   parse->priv->last_offset = offset;
3293
3294   gst_base_parse_start_fragment (parse);
3295   gst_adapter_push (parse->priv->adapter, buffer);
3296   ret = gst_base_parse_finish_fragment (parse, TRUE);
3297   if (ret != GST_FLOW_OK)
3298     goto exit;
3299
3300   /* force previous fragment */
3301   parse->priv->offset = -1;
3302
3303 exit:
3304   return ret;
3305 }
3306
3307 /* PULL mode:
3308  * pull and scan for next frame starting from current offset
3309  * ajusts sync, drain and offset going along */
3310 static GstFlowReturn
3311 gst_base_parse_scan_frame (GstBaseParse * parse, GstBaseParseClass * klass)
3312 {
3313   GstBuffer *buffer;
3314   GstFlowReturn ret = GST_FLOW_OK;
3315   guint fsize, min_size;
3316   gint flushed = 0;
3317   gint skip = 0;
3318
3319   GST_LOG_OBJECT (parse, "scanning for frame at offset %" G_GUINT64_FORMAT
3320       " (%#" G_GINT64_MODIFIER "x)", parse->priv->offset, parse->priv->offset);
3321
3322   /* let's make this efficient for all subclass once and for all;
3323    * maybe it does not need this much, but in the latter case, we know we are
3324    * in pull mode here and might as well try to read and supply more anyway
3325    * (so does the buffer caching mechanism) */
3326   fsize = 64 * 1024;
3327
3328   while (TRUE) {
3329     min_size = MAX (parse->priv->min_frame_size, fsize);
3330
3331     GST_LOG_OBJECT (parse, "reading buffer size %u", min_size);
3332
3333     ret = gst_base_parse_pull_range (parse, min_size, &buffer);
3334     if (ret != GST_FLOW_OK)
3335       goto done;
3336
3337     /* if we got a short read, inform subclass we are draining leftover
3338      * and no more is to be expected */
3339     if (gst_buffer_get_size (buffer) < min_size) {
3340       GST_LOG_OBJECT (parse, "... but did not get that; marked draining");
3341       parse->priv->drain = TRUE;
3342     }
3343
3344     if (parse->priv->detecting) {
3345       ret = klass->detect (parse, buffer);
3346       if (ret == GST_FLOW_NOT_NEGOTIATED) {
3347         /* If draining we error out, otherwise request a buffer
3348          * with 64kb more */
3349         if (parse->priv->drain) {
3350           gst_buffer_unref (buffer);
3351           GST_ERROR_OBJECT (parse, "Failed to detect format but draining");
3352           return GST_FLOW_ERROR;
3353         } else {
3354           fsize += 64 * 1024;
3355           gst_buffer_unref (buffer);
3356           continue;
3357         }
3358       } else if (ret != GST_FLOW_OK) {
3359         gst_buffer_unref (buffer);
3360         GST_ERROR_OBJECT (parse, "detect() returned %s",
3361             gst_flow_get_name (ret));
3362         return ret;
3363       }
3364
3365       /* Else handle this buffer normally */
3366     }
3367
3368     ret = gst_base_parse_handle_buffer (parse, buffer, &skip, &flushed);
3369     if (ret != GST_FLOW_OK)
3370       break;
3371
3372     /* If a large amount of data was requested to be skipped, _handle_buffer
3373        might have set the priv->skip flag to an extra amount on top of skip.
3374        In pull mode, we can just pull from the new offset directly. */
3375     parse->priv->offset += parse->priv->skip;
3376     parse->priv->skip = 0;
3377
3378     /* something flushed means something happened,
3379      * and we should bail out of this loop so as not to occupy
3380      * the task thread indefinitely */
3381     if (flushed) {
3382       GST_LOG_OBJECT (parse, "frame finished, breaking loop");
3383       break;
3384     }
3385     /* nothing flushed, no skip and draining, so nothing left to do */
3386     if (!skip && parse->priv->drain) {
3387       GST_LOG_OBJECT (parse, "no activity or result when draining; "
3388           "breaking loop and marking EOS");
3389       ret = GST_FLOW_EOS;
3390       break;
3391     }
3392     /* otherwise, get some more data
3393      * note that is checked this does not happen indefinitely */
3394     if (!skip) {
3395       GST_LOG_OBJECT (parse, "getting some more data");
3396       fsize += 64 * 1024;
3397     }
3398     parse->priv->drain = FALSE;
3399   }
3400
3401 done:
3402   return ret;
3403 }
3404
3405 /* Loop that is used in pull mode to retrieve data from upstream */
3406 static void
3407 gst_base_parse_loop (GstPad * pad)
3408 {
3409   GstBaseParse *parse;
3410   GstBaseParseClass *klass;
3411   GstFlowReturn ret = GST_FLOW_OK;
3412
3413   parse = GST_BASE_PARSE (gst_pad_get_parent (pad));
3414   klass = GST_BASE_PARSE_GET_CLASS (parse);
3415
3416   GST_LOG_OBJECT (parse, "Entering parse loop");
3417
3418   if (G_UNLIKELY (parse->priv->push_stream_start)) {
3419     gchar *stream_id;
3420     GstEvent *event;
3421
3422     stream_id =
3423         gst_pad_create_stream_id (parse->srcpad, GST_ELEMENT_CAST (parse),
3424         NULL);
3425
3426     event = gst_event_new_stream_start (stream_id);
3427     gst_event_set_group_id (event, gst_util_group_id_next ());
3428
3429     GST_DEBUG_OBJECT (parse, "Pushing STREAM_START");
3430     gst_pad_push_event (parse->srcpad, event);
3431     parse->priv->push_stream_start = FALSE;
3432     g_free (stream_id);
3433   }
3434
3435   /* reverse playback:
3436    * first fragment (closest to stop time) is handled normally below,
3437    * then we pull in fragments going backwards */
3438   if (parse->segment.rate < 0.0) {
3439     /* check if we jumped back to a previous fragment,
3440      * which is a post-first fragment */
3441     if (parse->priv->offset < 0) {
3442       ret = gst_base_parse_handle_previous_fragment (parse);
3443       goto done;
3444     }
3445   }
3446
3447   ret = gst_base_parse_scan_frame (parse, klass);
3448
3449   /* eat expected eos signalling past segment in reverse playback */
3450   if (parse->segment.rate < 0.0 && ret == GST_FLOW_EOS &&
3451       parse->segment.position >= parse->segment.stop) {
3452     GST_DEBUG_OBJECT (parse, "downstream has reached end of segment");
3453     /* push what was accumulated during loop run */
3454     gst_base_parse_finish_fragment (parse, FALSE);
3455     /* force previous fragment */
3456     parse->priv->offset = -1;
3457     goto eos;
3458   }
3459
3460   if (ret != GST_FLOW_OK)
3461     goto done;
3462
3463 done:
3464   if (ret == GST_FLOW_EOS)
3465     goto eos;
3466   else if (ret != GST_FLOW_OK)
3467     goto pause;
3468
3469   gst_object_unref (parse);
3470   return;
3471
3472   /* ERRORS */
3473 eos:
3474   {
3475     ret = GST_FLOW_EOS;
3476     GST_DEBUG_OBJECT (parse, "eos");
3477     /* fall-through */
3478   }
3479 pause:
3480   {
3481     gboolean push_eos = FALSE;
3482
3483     GST_DEBUG_OBJECT (parse, "pausing task, reason %s",
3484         gst_flow_get_name (ret));
3485     gst_pad_pause_task (parse->sinkpad);
3486
3487     if (ret == GST_FLOW_EOS) {
3488       /* handle end-of-stream/segment */
3489       if (parse->segment.flags & GST_SEGMENT_FLAG_SEGMENT) {
3490         gint64 stop;
3491
3492         if ((stop = parse->segment.stop) == -1)
3493           stop = parse->segment.duration;
3494
3495         GST_DEBUG_OBJECT (parse, "sending segment_done");
3496
3497         gst_element_post_message
3498             (GST_ELEMENT_CAST (parse),
3499             gst_message_new_segment_done (GST_OBJECT_CAST (parse),
3500                 GST_FORMAT_TIME, stop));
3501         gst_pad_push_event (parse->srcpad,
3502             gst_event_new_segment_done (GST_FORMAT_TIME, stop));
3503       } else {
3504         /* If we STILL have zero frames processed, fire an error */
3505         if (parse->priv->framecount == 0) {
3506           GST_ELEMENT_ERROR (parse, STREAM, WRONG_TYPE,
3507               ("No valid frames found before end of stream"), (NULL));
3508         }
3509         push_eos = TRUE;
3510       }
3511     } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
3512       /* for fatal errors we post an error message, wrong-state is
3513        * not fatal because it happens due to flushes and only means
3514        * that we should stop now. */
3515       GST_ELEMENT_ERROR (parse, STREAM, FAILED, (NULL),
3516           ("streaming stopped, reason %s", gst_flow_get_name (ret)));
3517       push_eos = TRUE;
3518     }
3519     if (push_eos) {
3520       if (parse->priv->estimated_duration <= 0) {
3521         gst_base_parse_update_duration (parse);
3522       }
3523       /* Push pending events, including SEGMENT events */
3524       gst_base_parse_push_pending_events (parse);
3525
3526       gst_pad_push_event (parse->srcpad, gst_event_new_eos ());
3527     }
3528     gst_object_unref (parse);
3529   }
3530 }
3531
3532 static gboolean
3533 gst_base_parse_sink_activate (GstPad * sinkpad, GstObject * parent)
3534 {
3535   GstSchedulingFlags sched_flags;
3536   GstBaseParse *parse;
3537   GstQuery *query;
3538   gboolean pull_mode;
3539
3540   parse = GST_BASE_PARSE (parent);
3541
3542   GST_DEBUG_OBJECT (parse, "sink activate");
3543
3544   query = gst_query_new_scheduling ();
3545   if (!gst_pad_peer_query (sinkpad, query)) {
3546     gst_query_unref (query);
3547     goto baseparse_push;
3548   }
3549
3550   gst_query_parse_scheduling (query, &sched_flags, NULL, NULL, NULL);
3551
3552   pull_mode = gst_query_has_scheduling_mode (query, GST_PAD_MODE_PULL)
3553       && ((sched_flags & GST_SCHEDULING_FLAG_SEEKABLE) != 0);
3554
3555   gst_query_unref (query);
3556
3557   if (!pull_mode)
3558     goto baseparse_push;
3559
3560   GST_DEBUG_OBJECT (parse, "trying to activate in pull mode");
3561   if (!gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE))
3562     goto baseparse_push;
3563
3564   parse->priv->push_stream_start = TRUE;
3565
3566   return gst_pad_start_task (sinkpad, (GstTaskFunction) gst_base_parse_loop,
3567       sinkpad, NULL);
3568   /* fallback */
3569 baseparse_push:
3570   {
3571     GST_DEBUG_OBJECT (parse, "trying to activate in push mode");
3572     return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
3573   }
3574 }
3575
3576 static gboolean
3577 gst_base_parse_activate (GstBaseParse * parse, gboolean active)
3578 {
3579   GstBaseParseClass *klass;
3580   gboolean result = TRUE;
3581
3582   GST_DEBUG_OBJECT (parse, "activate %d", active);
3583
3584   klass = GST_BASE_PARSE_GET_CLASS (parse);
3585
3586   if (active) {
3587     if (parse->priv->pad_mode == GST_PAD_MODE_NONE && klass->start)
3588       result = klass->start (parse);
3589
3590     /* If the subclass implements ::detect we want to
3591      * call it for the first buffers now */
3592     parse->priv->detecting = (klass->detect != NULL);
3593   } else {
3594     /* We must make sure streaming has finished before resetting things
3595      * and calling the ::stop vfunc */
3596     GST_PAD_STREAM_LOCK (parse->sinkpad);
3597     GST_PAD_STREAM_UNLOCK (parse->sinkpad);
3598
3599     if (parse->priv->pad_mode != GST_PAD_MODE_NONE && klass->stop)
3600       result = klass->stop (parse);
3601
3602     parse->priv->pad_mode = GST_PAD_MODE_NONE;
3603   }
3604   GST_DEBUG_OBJECT (parse, "activate return: %d", result);
3605   return result;
3606 }
3607
3608 static gboolean
3609 gst_base_parse_sink_activate_mode (GstPad * pad, GstObject * parent,
3610     GstPadMode mode, gboolean active)
3611 {
3612   gboolean result;
3613   GstBaseParse *parse;
3614
3615   parse = GST_BASE_PARSE (parent);
3616
3617   GST_DEBUG_OBJECT (parse, "sink %sactivate in %s mode",
3618       (active) ? "" : "de", gst_pad_mode_get_name (mode));
3619
3620 #ifdef GST_BASEPARSE_MODIFICATION
3621     /* to know early what is the mode */
3622     parse->priv->expected_pad_mode = active ? mode : GST_PAD_MODE_NONE;
3623 #endif
3624
3625   if (!gst_base_parse_activate (parse, active))
3626     goto activate_failed;
3627
3628   switch (mode) {
3629     case GST_PAD_MODE_PULL:
3630       if (active) {
3631         parse->priv->pending_events =
3632             g_list_prepend (parse->priv->pending_events,
3633             gst_event_new_segment (&parse->segment));
3634         result = TRUE;
3635       } else {
3636         result = gst_pad_stop_task (pad);
3637       }
3638       break;
3639     default:
3640       result = TRUE;
3641       break;
3642   }
3643   if (result)
3644     parse->priv->pad_mode = active ? mode : GST_PAD_MODE_NONE;
3645
3646   GST_DEBUG_OBJECT (parse, "sink activate return: %d", result);
3647
3648   return result;
3649
3650   /* ERRORS */
3651 activate_failed:
3652   {
3653     GST_DEBUG_OBJECT (parse, "activate failed");
3654     return FALSE;
3655   }
3656 }
3657
3658 /**
3659  * gst_base_parse_set_duration:
3660  * @parse: #GstBaseParse.
3661  * @fmt: #GstFormat.
3662  * @duration: duration value.
3663  * @interval: how often to update the duration estimate based on bitrate, or 0.
3664  *
3665  * Sets the duration of the currently playing media. Subclass can use this
3666  * when it is able to determine duration and/or notices a change in the media
3667  * duration.  Alternatively, if @interval is non-zero (default), then stream
3668  * duration is determined based on estimated bitrate, and updated every @interval
3669  * frames.
3670  */
3671 void
3672 gst_base_parse_set_duration (GstBaseParse * parse,
3673     GstFormat fmt, gint64 duration, gint interval)
3674 {
3675   g_return_if_fail (parse != NULL);
3676
3677   if (parse->priv->upstream_has_duration) {
3678     GST_DEBUG_OBJECT (parse, "using upstream duration; discarding update");
3679     goto exit;
3680   }
3681
3682   if (duration != parse->priv->duration) {
3683     GstMessage *m;
3684
3685     m = gst_message_new_duration_changed (GST_OBJECT (parse));
3686     gst_element_post_message (GST_ELEMENT (parse), m);
3687
3688     /* TODO: what about duration tag? */
3689   }
3690   parse->priv->duration = duration;
3691   parse->priv->duration_fmt = fmt;
3692   GST_DEBUG_OBJECT (parse, "set duration: %" G_GINT64_FORMAT, duration);
3693   if (fmt == GST_FORMAT_TIME && GST_CLOCK_TIME_IS_VALID (duration)) {
3694     if (interval != 0) {
3695       GST_DEBUG_OBJECT (parse, "valid duration provided, disabling estimate");
3696       interval = 0;
3697     }
3698   }
3699   GST_DEBUG_OBJECT (parse, "set update interval: %d", interval);
3700   parse->priv->update_interval = interval;
3701 exit:
3702   return;
3703 }
3704
3705 /**
3706  * gst_base_parse_set_average_bitrate:
3707  * @parse: #GstBaseParse.
3708  * @bitrate: average bitrate in bits/second
3709  *
3710  * Optionally sets the average bitrate detected in media (if non-zero),
3711  * e.g. based on metadata, as it will be posted to the application.
3712  *
3713  * By default, announced average bitrate is estimated. The average bitrate
3714  * is used to estimate the total duration of the stream and to estimate
3715  * a seek position, if there's no index and the format is syncable
3716  * (see gst_base_parse_set_syncable()).
3717  */
3718 void
3719 gst_base_parse_set_average_bitrate (GstBaseParse * parse, guint bitrate)
3720 {
3721   parse->priv->bitrate = bitrate;
3722   GST_DEBUG_OBJECT (parse, "bitrate %u", bitrate);
3723 }
3724
3725 /**
3726  * gst_base_parse_set_min_frame_size:
3727  * @parse: #GstBaseParse.
3728  * @min_size: Minimum size of the data that this base class should give to
3729  *            subclass.
3730  *
3731  * Subclass can use this function to tell the base class that it needs to
3732  * give at least #min_size buffers.
3733  */
3734 void
3735 gst_base_parse_set_min_frame_size (GstBaseParse * parse, guint min_size)
3736 {
3737   g_return_if_fail (parse != NULL);
3738
3739   parse->priv->min_frame_size = min_size;
3740   GST_LOG_OBJECT (parse, "set frame_min_size: %d", min_size);
3741 }
3742
3743 /**
3744  * gst_base_parse_set_frame_rate:
3745  * @parse: the #GstBaseParse to set
3746  * @fps_num: frames per second (numerator).
3747  * @fps_den: frames per second (denominator).
3748  * @lead_in: frames needed before a segment for subsequent decode
3749  * @lead_out: frames needed after a segment
3750  *
3751  * If frames per second is configured, parser can take care of buffer duration
3752  * and timestamping.  When performing segment clipping, or seeking to a specific
3753  * location, a corresponding decoder might need an initial @lead_in and a
3754  * following @lead_out number of frames to ensure the desired segment is
3755  * entirely filled upon decoding.
3756  */
3757 void
3758 gst_base_parse_set_frame_rate (GstBaseParse * parse, guint fps_num,
3759     guint fps_den, guint lead_in, guint lead_out)
3760 {
3761   g_return_if_fail (parse != NULL);
3762
3763   parse->priv->fps_num = fps_num;
3764   parse->priv->fps_den = fps_den;
3765   if (!fps_num || !fps_den) {
3766     GST_DEBUG_OBJECT (parse, "invalid fps (%d/%d), ignoring parameters",
3767         fps_num, fps_den);
3768     fps_num = fps_den = 0;
3769     parse->priv->frame_duration = GST_CLOCK_TIME_NONE;
3770     parse->priv->lead_in = parse->priv->lead_out = 0;
3771     parse->priv->lead_in_ts = parse->priv->lead_out_ts = 0;
3772   } else {
3773     parse->priv->frame_duration =
3774         gst_util_uint64_scale (GST_SECOND, fps_den, fps_num);
3775     parse->priv->lead_in = lead_in;
3776     parse->priv->lead_out = lead_out;
3777     parse->priv->lead_in_ts =
3778         gst_util_uint64_scale (GST_SECOND, fps_den * lead_in, fps_num);
3779     parse->priv->lead_out_ts =
3780         gst_util_uint64_scale (GST_SECOND, fps_den * lead_out, fps_num);
3781     /* aim for about 1.5s to estimate duration */
3782     if (parse->priv->update_interval < 0) {
3783       parse->priv->update_interval = fps_num * 3 / (fps_den * 2);
3784       GST_LOG_OBJECT (parse, "estimated update interval to %d frames",
3785           parse->priv->update_interval);
3786     }
3787   }
3788   GST_LOG_OBJECT (parse, "set fps: %d/%d => duration: %" G_GINT64_FORMAT " ms",
3789       fps_num, fps_den, parse->priv->frame_duration / GST_MSECOND);
3790   GST_LOG_OBJECT (parse, "set lead in: %d frames = %" G_GUINT64_FORMAT " ms, "
3791       "lead out: %d frames = %" G_GUINT64_FORMAT " ms",
3792       lead_in, parse->priv->lead_in_ts / GST_MSECOND,
3793       lead_out, parse->priv->lead_out_ts / GST_MSECOND);
3794 }
3795
3796 /**
3797  * gst_base_parse_set_has_timing_info:
3798  * @parse: a #GstBaseParse
3799  * @has_timing: whether frames carry timing information
3800  *
3801  * Set if frames carry timing information which the subclass can (generally)
3802  * parse and provide.  In particular, intrinsic (rather than estimated) time
3803  * can be obtained following a seek.
3804  */
3805 void
3806 gst_base_parse_set_has_timing_info (GstBaseParse * parse, gboolean has_timing)
3807 {
3808   parse->priv->has_timing_info = has_timing;
3809   GST_INFO_OBJECT (parse, "has_timing: %s", (has_timing) ? "yes" : "no");
3810 }
3811
3812 /**
3813  * gst_base_parse_set_syncable:
3814  * @parse: a #GstBaseParse
3815  * @syncable: set if frame starts can be identified
3816  *
3817  * Set if frame starts can be identified. This is set by default and
3818  * determines whether seeking based on bitrate averages
3819  * is possible for a format/stream.
3820  */
3821 void
3822 gst_base_parse_set_syncable (GstBaseParse * parse, gboolean syncable)
3823 {
3824   parse->priv->syncable = syncable;
3825   GST_INFO_OBJECT (parse, "syncable: %s", (syncable) ? "yes" : "no");
3826 }
3827
3828 /**
3829  * gst_base_parse_set_passthrough:
3830  * @parse: a #GstBaseParse
3831  * @passthrough: %TRUE if parser should run in passthrough mode
3832  *
3833  * Set if the nature of the format or configuration does not allow (much)
3834  * parsing, and the parser should operate in passthrough mode (which only
3835  * applies when operating in push mode). That is, incoming buffers are
3836  * pushed through unmodified, i.e. no @check_valid_frame or @parse_frame
3837  * callbacks will be invoked, but @pre_push_frame will still be invoked,
3838  * so subclass can perform as much or as little is appropriate for
3839  * passthrough semantics in @pre_push_frame.
3840  */
3841 void
3842 gst_base_parse_set_passthrough (GstBaseParse * parse, gboolean passthrough)
3843 {
3844   parse->priv->passthrough = passthrough;
3845   GST_INFO_OBJECT (parse, "passthrough: %s", (passthrough) ? "yes" : "no");
3846 }
3847
3848 /**
3849  * gst_base_parse_set_pts_interpolation:
3850  * @parse: a #GstBaseParse
3851  * @pts_interpolate: %TRUE if parser should interpolate PTS timestamps
3852  *
3853  * By default, the base class will guess PTS timestamps using a simple
3854  * interpolation (previous timestamp + duration), which is incorrect for
3855  * data streams with reordering, where PTS can go backward. Sub-classes
3856  * implementing such formats should disable PTS interpolation.
3857  */
3858 void
3859 gst_base_parse_set_pts_interpolation (GstBaseParse * parse,
3860     gboolean pts_interpolate)
3861 {
3862   parse->priv->pts_interpolate = pts_interpolate;
3863   GST_INFO_OBJECT (parse, "PTS interpolation: %s",
3864       (pts_interpolate) ? "yes" : "no");
3865 }
3866
3867 /**
3868  * gst_base_parse_set_infer_ts:
3869  * @parse: a #GstBaseParse
3870  * @infer_ts: %TRUE if parser should infer DTS/PTS from each other
3871  *
3872  * By default, the base class might try to infer PTS from DTS and vice
3873  * versa.  While this is generally correct for audio data, it may not
3874  * be otherwise. Sub-classes implementing such formats should disable
3875  * timestamp inferring.
3876  */
3877 void
3878 gst_base_parse_set_infer_ts (GstBaseParse * parse, gboolean infer_ts)
3879 {
3880   parse->priv->infer_ts = infer_ts;
3881   GST_INFO_OBJECT (parse, "TS inferring: %s", (infer_ts) ? "yes" : "no");
3882 }
3883
3884 /**
3885  * gst_base_parse_set_latency:
3886  * @parse: a #GstBaseParse
3887  * @min_latency: minimum parse latency
3888  * @max_latency: maximum parse latency
3889  *
3890  * Sets the minimum and maximum (which may likely be equal) latency introduced
3891  * by the parsing process.  If there is such a latency, which depends on the
3892  * particular parsing of the format, it typically corresponds to 1 frame duration.
3893  */
3894 void
3895 gst_base_parse_set_latency (GstBaseParse * parse, GstClockTime min_latency,
3896     GstClockTime max_latency)
3897 {
3898   g_return_if_fail (min_latency != GST_CLOCK_TIME_NONE);
3899   g_return_if_fail (min_latency <= max_latency);
3900
3901   GST_OBJECT_LOCK (parse);
3902   parse->priv->min_latency = min_latency;
3903   parse->priv->max_latency = max_latency;
3904   GST_OBJECT_UNLOCK (parse);
3905   GST_INFO_OBJECT (parse, "min/max latency %" GST_TIME_FORMAT ", %"
3906       GST_TIME_FORMAT, GST_TIME_ARGS (min_latency),
3907       GST_TIME_ARGS (max_latency));
3908 }
3909
3910 static gboolean
3911 gst_base_parse_get_duration (GstBaseParse * parse, GstFormat format,
3912     GstClockTime * duration)
3913 {
3914   gboolean res = FALSE;
3915
3916   g_return_val_if_fail (duration != NULL, FALSE);
3917
3918   *duration = GST_CLOCK_TIME_NONE;
3919   if (parse->priv->duration != -1 && format == parse->priv->duration_fmt) {
3920     GST_LOG_OBJECT (parse, "using provided duration");
3921     *duration = parse->priv->duration;
3922     res = TRUE;
3923   } else if (parse->priv->duration != -1) {
3924     GST_LOG_OBJECT (parse, "converting provided duration");
3925     res = gst_base_parse_convert (parse, parse->priv->duration_fmt,
3926         parse->priv->duration, format, (gint64 *) duration);
3927   } else if (format == GST_FORMAT_TIME && parse->priv->estimated_duration != -1) {
3928     GST_LOG_OBJECT (parse, "using estimated duration");
3929     *duration = parse->priv->estimated_duration;
3930     res = TRUE;
3931   } else {
3932     GST_LOG_OBJECT (parse, "cannot estimate duration");
3933   }
3934
3935   GST_LOG_OBJECT (parse, "res: %d, duration %" GST_TIME_FORMAT, res,
3936       GST_TIME_ARGS (*duration));
3937   return res;
3938 }
3939
3940 static gboolean
3941 gst_base_parse_src_query_default (GstBaseParse * parse, GstQuery * query)
3942 {
3943   gboolean res = FALSE;
3944   GstPad *pad;
3945
3946   pad = GST_BASE_PARSE_SRC_PAD (parse);
3947
3948   switch (GST_QUERY_TYPE (query)) {
3949     case GST_QUERY_POSITION:
3950     {
3951       gint64 dest_value;
3952       GstFormat format;
3953
3954       GST_DEBUG_OBJECT (parse, "position query");
3955       gst_query_parse_position (query, &format, NULL);
3956
3957       /* try upstream first */
3958       res = gst_pad_query_default (pad, GST_OBJECT_CAST (parse), query);
3959       if (!res) {
3960         /* Fall back on interpreting segment */
3961         GST_OBJECT_LOCK (parse);
3962         if (format == GST_FORMAT_BYTES) {
3963           dest_value = parse->priv->offset;
3964           res = TRUE;
3965         } else if (format == parse->segment.format &&
3966             GST_CLOCK_TIME_IS_VALID (parse->segment.position)) {
3967           dest_value = gst_segment_to_stream_time (&parse->segment,
3968               parse->segment.format, parse->segment.position);
3969           res = TRUE;
3970         }
3971         GST_OBJECT_UNLOCK (parse);
3972         if (!res) {
3973           /* no precise result, upstream no idea either, then best estimate */
3974           /* priv->offset is updated in both PUSH/PULL modes */
3975           res = gst_base_parse_convert (parse,
3976               GST_FORMAT_BYTES, parse->priv->offset, format, &dest_value);
3977         }
3978         if (res)
3979           gst_query_set_position (query, format, dest_value);
3980       }
3981       break;
3982     }
3983     case GST_QUERY_DURATION:
3984     {
3985       GstFormat format;
3986       GstClockTime duration;
3987
3988       GST_DEBUG_OBJECT (parse, "duration query");
3989       gst_query_parse_duration (query, &format, NULL);
3990
3991       /* consult upstream */
3992       res = gst_pad_query_default (pad, GST_OBJECT_CAST (parse), query);
3993
3994       /* otherwise best estimate from us */
3995       if (!res) {
3996         res = gst_base_parse_get_duration (parse, format, &duration);
3997         if (res)
3998           gst_query_set_duration (query, format, duration);
3999       }
4000       break;
4001     }
4002     case GST_QUERY_SEEKING:
4003     {
4004       GstFormat fmt;
4005       GstClockTime duration = GST_CLOCK_TIME_NONE;
4006       gboolean seekable = FALSE;
4007
4008       GST_DEBUG_OBJECT (parse, "seeking query");
4009       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
4010
4011       /* consult upstream */
4012       res = gst_pad_query_default (pad, GST_OBJECT_CAST (parse), query);
4013
4014       /* we may be able to help if in TIME */
4015       if (fmt == GST_FORMAT_TIME && gst_base_parse_is_seekable (parse)) {
4016         gst_query_parse_seeking (query, &fmt, &seekable, NULL, NULL);
4017         /* already OK if upstream takes care */
4018         GST_LOG_OBJECT (parse, "upstream handled %d, seekable %d",
4019             res, seekable);
4020         if (!(res && seekable)) {
4021           if (!gst_base_parse_get_duration (parse, GST_FORMAT_TIME, &duration)
4022               || duration == -1) {
4023             /* seekable if we still have a chance to get duration later on */
4024             seekable =
4025                 parse->priv->upstream_seekable && parse->priv->update_interval;
4026           } else {
4027             seekable = parse->priv->upstream_seekable;
4028             GST_LOG_OBJECT (parse, "already determine upstream seekabled: %d",
4029                 seekable);
4030           }
4031           gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0, duration);
4032           res = TRUE;
4033         }
4034       }
4035       break;
4036     }
4037     case GST_QUERY_FORMATS:
4038       gst_query_set_formatsv (query, 3, fmtlist);
4039       res = TRUE;
4040       break;
4041     case GST_QUERY_CONVERT:
4042     {
4043       GstFormat src_format, dest_format;
4044       gint64 src_value, dest_value;
4045
4046       gst_query_parse_convert (query, &src_format, &src_value,
4047           &dest_format, &dest_value);
4048
4049       res = gst_base_parse_convert (parse, src_format, src_value,
4050           dest_format, &dest_value);
4051       if (res) {
4052         gst_query_set_convert (query, src_format, src_value,
4053             dest_format, dest_value);
4054       }
4055       break;
4056     }
4057     case GST_QUERY_LATENCY:
4058     {
4059       if ((res = gst_pad_peer_query (parse->sinkpad, query))) {
4060         gboolean live;
4061         GstClockTime min_latency, max_latency;
4062
4063         gst_query_parse_latency (query, &live, &min_latency, &max_latency);
4064         GST_DEBUG_OBJECT (parse, "Peer latency: live %d, min %"
4065             GST_TIME_FORMAT " max %" GST_TIME_FORMAT, live,
4066             GST_TIME_ARGS (min_latency), GST_TIME_ARGS (max_latency));
4067
4068         GST_OBJECT_LOCK (parse);
4069         /* add our latency */
4070         min_latency += parse->priv->min_latency;
4071         if (max_latency == -1 || parse->priv->max_latency == -1)
4072           max_latency = -1;
4073         else
4074           max_latency += parse->priv->max_latency;
4075         GST_OBJECT_UNLOCK (parse);
4076
4077         gst_query_set_latency (query, live, min_latency, max_latency);
4078       }
4079       break;
4080     }
4081     case GST_QUERY_SEGMENT:
4082     {
4083       GstFormat format;
4084       gint64 start, stop;
4085
4086       format = parse->segment.format;
4087
4088       start =
4089           gst_segment_to_stream_time (&parse->segment, format,
4090           parse->segment.start);
4091       if ((stop = parse->segment.stop) == -1)
4092         stop = parse->segment.duration;
4093       else
4094         stop = gst_segment_to_stream_time (&parse->segment, format, stop);
4095
4096       gst_query_set_segment (query, parse->segment.rate, format, start, stop);
4097       res = TRUE;
4098       break;
4099     }
4100     default:
4101       res = gst_pad_query_default (pad, GST_OBJECT_CAST (parse), query);
4102       break;
4103   }
4104   return res;
4105 }
4106
4107 /* scans for a cluster start from @pos,
4108  * return GST_FLOW_OK and frame position/time in @pos/@time if found */
4109 static GstFlowReturn
4110 gst_base_parse_find_frame (GstBaseParse * parse, gint64 * pos,
4111     GstClockTime * time, GstClockTime * duration)
4112 {
4113   GstBaseParseClass *klass;
4114   gint64 orig_offset;
4115   gboolean orig_drain, orig_discont;
4116   GstFlowReturn ret = GST_FLOW_OK;
4117   GstBuffer *buf = NULL;
4118   GstBaseParseFrame *sframe = NULL;
4119
4120   g_return_val_if_fail (pos != NULL, GST_FLOW_ERROR);
4121   g_return_val_if_fail (time != NULL, GST_FLOW_ERROR);
4122   g_return_val_if_fail (duration != NULL, GST_FLOW_ERROR);
4123
4124   klass = GST_BASE_PARSE_GET_CLASS (parse);
4125
4126   *time = GST_CLOCK_TIME_NONE;
4127   *duration = GST_CLOCK_TIME_NONE;
4128
4129   /* save state */
4130   orig_offset = parse->priv->offset;
4131   orig_discont = parse->priv->discont;
4132   orig_drain = parse->priv->drain;
4133
4134   GST_DEBUG_OBJECT (parse, "scanning for frame starting at %" G_GINT64_FORMAT
4135       " (%#" G_GINT64_MODIFIER "x)", *pos, *pos);
4136
4137   /* jump elsewhere and locate next frame */
4138   parse->priv->offset = *pos;
4139   /* mark as scanning so frames don't get processed all the way */
4140   parse->priv->scanning = TRUE;
4141   ret = gst_base_parse_scan_frame (parse, klass);
4142   parse->priv->scanning = FALSE;
4143   /* retrieve frame found during scan */
4144   sframe = parse->priv->scanned_frame;
4145   parse->priv->scanned_frame = NULL;
4146
4147   if (ret != GST_FLOW_OK || !sframe)
4148     goto done;
4149
4150   /* get offset first, subclass parsing might dump other stuff in there */
4151   *pos = sframe->offset;
4152   buf = sframe->buffer;
4153   g_assert (buf);
4154
4155   /* but it should provide proper time */
4156   *time = GST_BUFFER_TIMESTAMP (buf);
4157   *duration = GST_BUFFER_DURATION (buf);
4158
4159   GST_LOG_OBJECT (parse,
4160       "frame with time %" GST_TIME_FORMAT " at offset %" G_GINT64_FORMAT,
4161       GST_TIME_ARGS (*time), *pos);
4162
4163 done:
4164   if (sframe)
4165     gst_base_parse_frame_free (sframe);
4166
4167   /* restore state */
4168   parse->priv->offset = orig_offset;
4169   parse->priv->discont = orig_discont;
4170   parse->priv->drain = orig_drain;
4171
4172   return ret;
4173 }
4174
4175 /* bisect and scan through file for frame starting before @time,
4176  * returns OK and @time/@offset if found, NONE and/or error otherwise
4177  * If @time == G_MAXINT64, scan for duration ( == last frame) */
4178 static GstFlowReturn
4179 gst_base_parse_locate_time (GstBaseParse * parse, GstClockTime * _time,
4180     gint64 * _offset)
4181 {
4182   GstFlowReturn ret = GST_FLOW_OK;
4183   gint64 lpos, hpos, newpos;
4184   GstClockTime time, ltime, htime, newtime, dur;
4185   gboolean cont = TRUE;
4186   const GstClockTime tolerance = TARGET_DIFFERENCE;
4187   const guint chunk = 4 * 1024;
4188
4189   g_return_val_if_fail (_time != NULL, GST_FLOW_ERROR);
4190   g_return_val_if_fail (_offset != NULL, GST_FLOW_ERROR);
4191
4192   GST_DEBUG_OBJECT (parse, "Bisecting for time %" GST_TIME_FORMAT,
4193       GST_TIME_ARGS (*_time));
4194
4195   /* TODO also make keyframe aware if useful some day */
4196
4197   time = *_time;
4198
4199   /* basic cases */
4200   if (time == 0) {
4201     *_offset = 0;
4202     return GST_FLOW_OK;
4203   }
4204
4205   if (time == -1) {
4206     *_offset = -1;
4207     return GST_FLOW_OK;
4208   }
4209
4210   /* do not know at first */
4211   *_offset = -1;
4212   *_time = GST_CLOCK_TIME_NONE;
4213
4214   /* need initial positions; start and end */
4215   lpos = parse->priv->first_frame_offset;
4216   ltime = parse->priv->first_frame_pts;
4217   /* try other one if no luck */
4218   if (!GST_CLOCK_TIME_IS_VALID (ltime))
4219     ltime = parse->priv->first_frame_dts;
4220   if (!gst_base_parse_get_duration (parse, GST_FORMAT_TIME, &htime)) {
4221     GST_DEBUG_OBJECT (parse, "Unknown time duration, cannot bisect");
4222     return GST_FLOW_ERROR;
4223   }
4224   hpos = parse->priv->upstream_size;
4225
4226   GST_DEBUG_OBJECT (parse,
4227       "Bisection initial bounds: bytes %" G_GINT64_FORMAT " %" G_GINT64_FORMAT
4228       ", times %" GST_TIME_FORMAT " %" GST_TIME_FORMAT, lpos, hpos,
4229       GST_TIME_ARGS (ltime), GST_TIME_ARGS (htime));
4230
4231   /* check preconditions are satisfied;
4232    * start and end are needed, except for special case where we scan for
4233    * last frame to determine duration */
4234   if (parse->priv->pad_mode != GST_PAD_MODE_PULL || !hpos ||
4235       !GST_CLOCK_TIME_IS_VALID (ltime) ||
4236       (!GST_CLOCK_TIME_IS_VALID (htime) && time != G_MAXINT64)) {
4237     return GST_FLOW_OK;
4238   }
4239
4240   /* shortcut cases */
4241   if (time < ltime) {
4242     goto exit;
4243   } else if (time < ltime + tolerance) {
4244     *_offset = lpos;
4245     *_time = ltime;
4246     goto exit;
4247   } else if (time >= htime) {
4248     *_offset = hpos;
4249     *_time = htime;
4250     goto exit;
4251   }
4252
4253   while (htime > ltime && cont) {
4254     GST_LOG_OBJECT (parse,
4255         "lpos: %" G_GUINT64_FORMAT ", ltime: %" GST_TIME_FORMAT, lpos,
4256         GST_TIME_ARGS (ltime));
4257     GST_LOG_OBJECT (parse,
4258         "hpos: %" G_GUINT64_FORMAT ", htime: %" GST_TIME_FORMAT, hpos,
4259         GST_TIME_ARGS (htime));
4260     if (G_UNLIKELY (time == G_MAXINT64)) {
4261       newpos = hpos;
4262     } else if (G_LIKELY (hpos > lpos)) {
4263       newpos =
4264           gst_util_uint64_scale (hpos - lpos, time - ltime, htime - ltime) +
4265           lpos - chunk;
4266     } else {
4267       /* should mean lpos == hpos, since lpos <= hpos is invariant */
4268       newpos = lpos;
4269       /* we check this case once, but not forever, so break loop */
4270       cont = FALSE;
4271     }
4272
4273     /* ensure */
4274     newpos = CLAMP (newpos, lpos, hpos);
4275     GST_LOG_OBJECT (parse,
4276         "estimated _offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT,
4277         GST_TIME_ARGS (time), newpos);
4278
4279     ret = gst_base_parse_find_frame (parse, &newpos, &newtime, &dur);
4280     if (ret == GST_FLOW_EOS) {
4281       /* heuristic HACK */
4282       hpos = MAX (lpos, hpos - chunk);
4283       continue;
4284     } else if (ret != GST_FLOW_OK) {
4285       goto exit;
4286     }
4287
4288     if (newtime == -1 || newpos == -1) {
4289       GST_DEBUG_OBJECT (parse, "subclass did not provide metadata; aborting");
4290       break;
4291     }
4292
4293     if (G_UNLIKELY (time == G_MAXINT64)) {
4294       *_offset = newpos;
4295       *_time = newtime;
4296       if (GST_CLOCK_TIME_IS_VALID (dur))
4297         *_time += dur;
4298       break;
4299     } else if (newtime > time) {
4300       /* overshoot */
4301       hpos = (newpos >= hpos) ? MAX (lpos, hpos - chunk) : MAX (lpos, newpos);
4302       htime = newtime;
4303     } else if (newtime + tolerance > time) {
4304       /* close enough undershoot */
4305       *_offset = newpos;
4306       *_time = newtime;
4307       break;
4308     } else if (newtime < ltime) {
4309       /* so a position beyond lpos resulted in earlier time than ltime ... */
4310       GST_DEBUG_OBJECT (parse, "non-ascending time; aborting");
4311       break;
4312     } else {
4313       /* undershoot too far */
4314       newpos += newpos == lpos ? chunk : 0;
4315       lpos = CLAMP (newpos, lpos, hpos);
4316       ltime = newtime;
4317     }
4318   }
4319
4320 exit:
4321   GST_LOG_OBJECT (parse, "return offset %" G_GINT64_FORMAT ", time %"
4322       GST_TIME_FORMAT, *_offset, GST_TIME_ARGS (*_time));
4323   return ret;
4324 }
4325
4326 static gint64
4327 gst_base_parse_find_offset (GstBaseParse * parse, GstClockTime time,
4328     gboolean before, GstClockTime * _ts)
4329 {
4330   gint64 bytes = 0, ts = 0;
4331   GstIndexEntry *entry = NULL;
4332
4333   if (time == GST_CLOCK_TIME_NONE) {
4334     ts = time;
4335     bytes = -1;
4336     goto exit;
4337   }
4338
4339   GST_BASE_PARSE_INDEX_LOCK (parse);
4340   if (parse->priv->index) {
4341     /* Let's check if we have an index entry for that time */
4342     entry = gst_index_get_assoc_entry (parse->priv->index,
4343         parse->priv->index_id,
4344         before ? GST_INDEX_LOOKUP_BEFORE : GST_INDEX_LOOKUP_AFTER,
4345         GST_INDEX_ASSOCIATION_FLAG_KEY_UNIT, GST_FORMAT_TIME, time);
4346   }
4347
4348   if (entry) {
4349     gst_index_entry_assoc_map (entry, GST_FORMAT_BYTES, &bytes);
4350     gst_index_entry_assoc_map (entry, GST_FORMAT_TIME, &ts);
4351
4352     GST_DEBUG_OBJECT (parse, "found index entry for %" GST_TIME_FORMAT
4353         " at %" GST_TIME_FORMAT ", offset %" G_GINT64_FORMAT,
4354         GST_TIME_ARGS (time), GST_TIME_ARGS (ts), bytes);
4355   } else {
4356     GST_DEBUG_OBJECT (parse, "no index entry found for %" GST_TIME_FORMAT,
4357         GST_TIME_ARGS (time));
4358     if (!before) {
4359       bytes = -1;
4360       ts = GST_CLOCK_TIME_NONE;
4361     }
4362   }
4363   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4364
4365 exit:
4366   if (_ts)
4367     *_ts = ts;
4368
4369   return bytes;
4370 }
4371
4372 /* returns TRUE if seek succeeded */
4373 static gboolean
4374 gst_base_parse_handle_seek (GstBaseParse * parse, GstEvent * event)
4375 {
4376   gdouble rate;
4377   GstFormat format;
4378   GstSeekFlags flags;
4379   GstSeekType start_type = GST_SEEK_TYPE_NONE, stop_type;
4380   gboolean flush, update, res = TRUE, accurate;
4381   gint64 start, stop, seekpos, seekstop;
4382   GstSegment seeksegment = { 0, };
4383   GstClockTime start_ts;
4384   guint32 seqnum;
4385   GstEvent *segment_event;
4386
4387   /* try upstream first, unless we're driving the streaming thread ourselves */
4388   if (parse->priv->pad_mode != GST_PAD_MODE_PULL) {
4389     res = gst_pad_push_event (parse->sinkpad, gst_event_ref (event));
4390     if (res)
4391       goto done;
4392   }
4393
4394   gst_event_parse_seek (event, &rate, &format, &flags,
4395       &start_type, &start, &stop_type, &stop);
4396   seqnum = gst_event_get_seqnum (event);
4397
4398   GST_DEBUG_OBJECT (parse, "seek to format %s, rate %f, "
4399       "start type %d at %" GST_TIME_FORMAT ", end type %d at %"
4400       GST_TIME_FORMAT, gst_format_get_name (format), rate,
4401       start_type, GST_TIME_ARGS (start), stop_type, GST_TIME_ARGS (stop));
4402
4403   /* we can only handle TIME, so check if subclass can convert
4404    * to TIME format if it's some other format (such as DEFAULT) */
4405   if (format != GST_FORMAT_TIME) {
4406     if (!gst_base_parse_convert (parse, format, start, GST_FORMAT_TIME, &start)
4407         || !gst_base_parse_convert (parse, format, stop, GST_FORMAT_TIME,
4408             &stop))
4409       goto no_convert_to_time;
4410
4411     GST_INFO_OBJECT (parse, "converted %s format to start time "
4412         "%" GST_TIME_FORMAT " and stop time %" GST_TIME_FORMAT,
4413         gst_format_get_name (format), GST_TIME_ARGS (start),
4414         GST_TIME_ARGS (stop));
4415
4416     format = GST_FORMAT_TIME;
4417   }
4418
4419   /* no negative rates in push mode (unless upstream takes care of that, but
4420    * we've already tried upstream and it didn't handle the seek request) */
4421   if (rate < 0.0 && parse->priv->pad_mode == GST_PAD_MODE_PUSH)
4422     goto negative_rate;
4423
4424   if (start_type != GST_SEEK_TYPE_SET ||
4425       (stop_type != GST_SEEK_TYPE_SET && stop_type != GST_SEEK_TYPE_NONE))
4426     goto wrong_type;
4427
4428   /* get flush flag */
4429   flush = flags & GST_SEEK_FLAG_FLUSH;
4430
4431   /* copy segment, we need this because we still need the old
4432    * segment when we close the current segment. */
4433   gst_segment_copy_into (&parse->segment, &seeksegment);
4434
4435   GST_DEBUG_OBJECT (parse, "configuring seek");
4436   gst_segment_do_seek (&seeksegment, rate, format, flags,
4437       start_type, start, stop_type, stop, &update);
4438
4439   /* accurate seeking implies seek tables are used to obtain position,
4440    * and the requested segment is maintained exactly, not adjusted any way */
4441   accurate = flags & GST_SEEK_FLAG_ACCURATE;
4442
4443   /* maybe we can be accurate for (almost) free */
4444   gst_base_parse_find_offset (parse, seeksegment.position, TRUE, &start_ts);
4445 #ifdef GST_BASEPARSE_MODIFICATION
4446   if (parse->priv->accurate_index_seek) {
4447     if (seeksegment.position <= start_ts + TARGET_DIFFERENCE) {
4448       GST_DEBUG_OBJECT (parse, "accurate seek possible");
4449       accurate = TRUE;
4450     }
4451   } else {
4452     GST_DEBUG_OBJECT (parse, "accurate seek NOT possible");
4453     accurate = FALSE;
4454   }
4455 #else
4456   if (seeksegment.position <= start_ts + TARGET_DIFFERENCE) {
4457     GST_DEBUG_OBJECT (parse, "accurate seek possible");
4458     accurate = TRUE;
4459   }
4460 #endif
4461
4462   if (accurate) {
4463     GstClockTime startpos;
4464     if (rate >= 0)
4465       startpos = seeksegment.position;
4466     else
4467       startpos = start;
4468
4469     /* accurate requested, so ... seek a bit before target */
4470     if (startpos < parse->priv->lead_in_ts)
4471       startpos = 0;
4472     else
4473       startpos -= parse->priv->lead_in_ts;
4474
4475     if (seeksegment.stop == -1 && seeksegment.duration != -1)
4476       seeksegment.stop = seeksegment.start + seeksegment.duration;
4477
4478     seekpos = gst_base_parse_find_offset (parse, startpos, TRUE, &start_ts);
4479     seekstop = gst_base_parse_find_offset (parse, seeksegment.stop, FALSE,
4480         NULL);
4481   } else {
4482     if (rate >= 0)
4483       start_ts = seeksegment.position;
4484     else
4485       start_ts = start;
4486
4487     if (seeksegment.stop == -1 && seeksegment.duration != -1)
4488       seeksegment.stop = seeksegment.start + seeksegment.duration;
4489
4490     if (!gst_base_parse_convert (parse, format, start_ts,
4491             GST_FORMAT_BYTES, &seekpos))
4492       goto convert_failed;
4493     if (!gst_base_parse_convert (parse, format, seeksegment.stop,
4494             GST_FORMAT_BYTES, &seekstop))
4495       goto convert_failed;
4496   }
4497
4498   GST_DEBUG_OBJECT (parse,
4499       "seek position %" G_GINT64_FORMAT " in bytes: %" G_GINT64_FORMAT,
4500       start_ts, seekpos);
4501   GST_DEBUG_OBJECT (parse,
4502       "seek stop %" G_GINT64_FORMAT " in bytes: %" G_GINT64_FORMAT,
4503       seeksegment.stop, seekstop);
4504
4505   if (parse->priv->pad_mode == GST_PAD_MODE_PULL) {
4506     gint64 last_stop;
4507
4508     GST_DEBUG_OBJECT (parse, "seek in PULL mode");
4509
4510     if (flush) {
4511       if (parse->srcpad) {
4512         GstEvent *fevent = gst_event_new_flush_start ();
4513         GST_DEBUG_OBJECT (parse, "sending flush start");
4514
4515         gst_event_set_seqnum (fevent, seqnum);
4516
4517         gst_pad_push_event (parse->srcpad, gst_event_ref (fevent));
4518         /* unlock upstream pull_range */
4519         gst_pad_push_event (parse->sinkpad, fevent);
4520       }
4521     } else {
4522       gst_pad_pause_task (parse->sinkpad);
4523     }
4524
4525     /* we should now be able to grab the streaming thread because we stopped it
4526      * with the above flush/pause code */
4527     GST_PAD_STREAM_LOCK (parse->sinkpad);
4528
4529     /* save current position */
4530     last_stop = parse->segment.position;
4531     GST_DEBUG_OBJECT (parse, "stopped streaming at %" G_GINT64_FORMAT,
4532         last_stop);
4533
4534     /* now commit to new position */
4535
4536     /* prepare for streaming again */
4537     if (flush) {
4538       GstEvent *fevent = gst_event_new_flush_stop (TRUE);
4539       GST_DEBUG_OBJECT (parse, "sending flush stop");
4540       gst_event_set_seqnum (fevent, seqnum);
4541       gst_pad_push_event (parse->srcpad, gst_event_ref (fevent));
4542       gst_pad_push_event (parse->sinkpad, fevent);
4543       gst_base_parse_clear_queues (parse);
4544     } else {
4545       /* keep track of our position */
4546       seeksegment.base = gst_segment_to_running_time (&seeksegment,
4547           seeksegment.format, parse->segment.position);
4548     }
4549
4550     memcpy (&parse->segment, &seeksegment, sizeof (GstSegment));
4551
4552     /* store the newsegment event so it can be sent from the streaming thread. */
4553     /* This will be sent later in _loop() */
4554     segment_event = gst_event_new_segment (&parse->segment);
4555     gst_event_set_seqnum (segment_event, seqnum);
4556     parse->priv->pending_events =
4557         g_list_prepend (parse->priv->pending_events, segment_event);
4558
4559     GST_DEBUG_OBJECT (parse, "Created newseg format %d, "
4560         "start = %" GST_TIME_FORMAT ", stop = %" GST_TIME_FORMAT
4561         ", time = %" GST_TIME_FORMAT, format,
4562         GST_TIME_ARGS (parse->segment.start),
4563         GST_TIME_ARGS (parse->segment.stop),
4564         GST_TIME_ARGS (parse->segment.time));
4565
4566     /* one last chance in pull mode to stay accurate;
4567      * maybe scan and subclass can find where to go */
4568     if (!accurate) {
4569       gint64 scanpos;
4570       GstClockTime ts = seeksegment.position;
4571
4572       gst_base_parse_locate_time (parse, &ts, &scanpos);
4573       if (scanpos >= 0) {
4574         accurate = TRUE;
4575         seekpos = scanpos;
4576         /* running collected index now consists of several intervals,
4577          * so optimized check no longer possible */
4578         parse->priv->index_last_valid = FALSE;
4579         parse->priv->index_last_offset = 0;
4580         parse->priv->index_last_ts = 0;
4581       }
4582     }
4583
4584     /* mark discont if we are going to stream from another position. */
4585     if (seekpos != parse->priv->offset) {
4586       GST_DEBUG_OBJECT (parse,
4587           "mark DISCONT, we did a seek to another position");
4588       parse->priv->offset = seekpos;
4589       parse->priv->last_offset = seekpos;
4590       parse->priv->seen_keyframe = FALSE;
4591       parse->priv->discont = TRUE;
4592       parse->priv->next_dts = start_ts;
4593       parse->priv->next_pts = GST_CLOCK_TIME_NONE;
4594       parse->priv->last_dts = GST_CLOCK_TIME_NONE;
4595       parse->priv->last_pts = GST_CLOCK_TIME_NONE;
4596       parse->priv->sync_offset = seekpos;
4597       parse->priv->exact_position = accurate;
4598     }
4599
4600     /* Start streaming thread if paused */
4601     gst_pad_start_task (parse->sinkpad,
4602         (GstTaskFunction) gst_base_parse_loop, parse->sinkpad, NULL);
4603
4604     GST_PAD_STREAM_UNLOCK (parse->sinkpad);
4605
4606     /* handled seek */
4607     res = TRUE;
4608   } else {
4609     GstEvent *new_event;
4610     GstBaseParseSeek *seek;
4611     GstSeekFlags flags = (flush ? GST_SEEK_FLAG_FLUSH : GST_SEEK_FLAG_NONE);
4612
4613     /* The only thing we need to do in PUSH-mode is to send the
4614        seek event (in bytes) to upstream. Segment / flush handling happens
4615        in corresponding src event handlers */
4616     GST_DEBUG_OBJECT (parse, "seek in PUSH mode");
4617     if (seekstop >= 0 && seekstop <= seekpos)
4618       seekstop = seekpos;
4619     new_event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags,
4620         GST_SEEK_TYPE_SET, seekpos, stop_type, seekstop);
4621     gst_event_set_seqnum (new_event, seqnum);
4622
4623     /* store segment info so its precise details can be reconstructed when
4624      * receiving newsegment;
4625      * this matters for all details when accurate seeking,
4626      * is most useful to preserve NONE stop time otherwise */
4627     seek = g_new0 (GstBaseParseSeek, 1);
4628     seek->segment = seeksegment;
4629     seek->accurate = accurate;
4630     seek->offset = seekpos;
4631     seek->start_ts = start_ts;
4632     GST_OBJECT_LOCK (parse);
4633     /* less optimal, but preserves order */
4634     parse->priv->pending_seeks =
4635         g_slist_append (parse->priv->pending_seeks, seek);
4636     GST_OBJECT_UNLOCK (parse);
4637
4638     res = gst_pad_push_event (parse->sinkpad, new_event);
4639
4640     if (!res) {
4641       GST_OBJECT_LOCK (parse);
4642       parse->priv->pending_seeks =
4643           g_slist_remove (parse->priv->pending_seeks, seek);
4644       GST_OBJECT_UNLOCK (parse);
4645       g_free (seek);
4646     }
4647   }
4648
4649 done:
4650   gst_event_unref (event);
4651   return res;
4652
4653   /* ERRORS */
4654 negative_rate:
4655   {
4656     GST_DEBUG_OBJECT (parse, "negative playback rates delegated upstream.");
4657     res = FALSE;
4658     goto done;
4659   }
4660 wrong_type:
4661   {
4662     GST_DEBUG_OBJECT (parse, "unsupported seek type.");
4663     res = FALSE;
4664     goto done;
4665   }
4666 no_convert_to_time:
4667   {
4668     GST_DEBUG_OBJECT (parse, "seek in %s format was requested, but subclass "
4669         "couldn't convert that into TIME format", gst_format_get_name (format));
4670     res = FALSE;
4671     goto done;
4672   }
4673 convert_failed:
4674   {
4675     GST_DEBUG_OBJECT (parse, "conversion TIME to BYTES failed.");
4676     res = FALSE;
4677     goto done;
4678   }
4679 }
4680
4681 static void
4682 gst_base_parse_set_upstream_tags (GstBaseParse * parse, GstTagList * taglist)
4683 {
4684   if (taglist == parse->priv->upstream_tags)
4685     return;
4686
4687   if (parse->priv->upstream_tags) {
4688     gst_tag_list_unref (parse->priv->upstream_tags);
4689     parse->priv->upstream_tags = NULL;
4690   }
4691
4692   GST_INFO_OBJECT (parse, "upstream tags: %" GST_PTR_FORMAT, taglist);
4693
4694   if (taglist != NULL)
4695     parse->priv->upstream_tags = gst_tag_list_ref (taglist);
4696
4697   gst_base_parse_check_bitrate_tags (parse);
4698 }
4699
4700 #if 0
4701 static void
4702 gst_base_parse_set_index (GstElement * element, GstIndex * index)
4703 {
4704   GstBaseParse *parse = GST_BASE_PARSE (element);
4705
4706   GST_BASE_PARSE_INDEX_LOCK (parse);
4707   if (parse->priv->index)
4708     gst_object_unref (parse->priv->index);
4709   if (index) {
4710     parse->priv->index = gst_object_ref (index);
4711     gst_index_get_writer_id (index, GST_OBJECT_CAST (element),
4712         &parse->priv->index_id);
4713     parse->priv->own_index = FALSE;
4714   } else {
4715     parse->priv->index = NULL;
4716   }
4717   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4718 }
4719
4720 static GstIndex *
4721 gst_base_parse_get_index (GstElement * element)
4722 {
4723   GstBaseParse *parse = GST_BASE_PARSE (element);
4724   GstIndex *result = NULL;
4725
4726   GST_BASE_PARSE_INDEX_LOCK (parse);
4727   if (parse->priv->index)
4728     result = gst_object_ref (parse->priv->index);
4729   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4730
4731   return result;
4732 }
4733 #endif
4734
4735 static GstStateChangeReturn
4736 gst_base_parse_change_state (GstElement * element, GstStateChange transition)
4737 {
4738   GstBaseParse *parse;
4739   GstStateChangeReturn result;
4740
4741   parse = GST_BASE_PARSE (element);
4742
4743   switch (transition) {
4744     case GST_STATE_CHANGE_READY_TO_PAUSED:
4745       /* If this is our own index destroy it as the
4746        * old entries might be wrong for the new stream */
4747       GST_BASE_PARSE_INDEX_LOCK (parse);
4748       if (parse->priv->own_index) {
4749         gst_object_unref (parse->priv->index);
4750         parse->priv->index = NULL;
4751         parse->priv->own_index = FALSE;
4752       }
4753
4754       /* If no index was created, generate one */
4755       if (G_UNLIKELY (!parse->priv->index)) {
4756         GST_DEBUG_OBJECT (parse, "no index provided creating our own");
4757
4758         parse->priv->index = g_object_new (gst_mem_index_get_type (), NULL);
4759         gst_index_get_writer_id (parse->priv->index, GST_OBJECT (parse),
4760             &parse->priv->index_id);
4761         parse->priv->own_index = TRUE;
4762       }
4763       GST_BASE_PARSE_INDEX_UNLOCK (parse);
4764       break;
4765     default:
4766       break;
4767   }
4768
4769   result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
4770
4771   switch (transition) {
4772     case GST_STATE_CHANGE_PAUSED_TO_READY:
4773       gst_base_parse_reset (parse);
4774       break;
4775     default:
4776       break;
4777   }
4778
4779   return result;
4780 }
4781
4782 /**
4783  * gst_base_parse_set_ts_at_offset:
4784  * @parse: a #GstBaseParse
4785  * @offset: offset into current buffer
4786  *
4787  * This function should only be called from a @handle_frame implementation.
4788  *
4789  * #GstBaseParse creates initial timestamps for frames by using the last
4790  * timestamp seen in the stream before the frame starts.  In certain
4791  * cases, the correct timestamps will occur in the stream after the
4792  * start of the frame, but before the start of the actual picture data.
4793  * This function can be used to set the timestamps based on the offset
4794  * into the frame data that the picture starts.
4795  *
4796  * Since: 1.2
4797  */
4798 void
4799 gst_base_parse_set_ts_at_offset (GstBaseParse * parse, gsize offset)
4800 {
4801   GstClockTime pts, dts;
4802
4803   g_return_if_fail (GST_IS_BASE_PARSE (parse));
4804
4805   pts = gst_adapter_prev_pts_at_offset (parse->priv->adapter, offset, NULL);
4806   dts = gst_adapter_prev_dts_at_offset (parse->priv->adapter, offset, NULL);
4807
4808   if (!GST_CLOCK_TIME_IS_VALID (pts) || !GST_CLOCK_TIME_IS_VALID (dts)) {
4809     GST_DEBUG_OBJECT (parse,
4810         "offset adapter timestamps dts=%" GST_TIME_FORMAT " pts=%"
4811         GST_TIME_FORMAT, GST_TIME_ARGS (dts), GST_TIME_ARGS (pts));
4812   }
4813   if (GST_CLOCK_TIME_IS_VALID (pts) && (parse->priv->prev_pts != pts))
4814     parse->priv->prev_pts = parse->priv->next_pts = pts;
4815
4816   if (GST_CLOCK_TIME_IS_VALID (dts) && (parse->priv->prev_dts != dts))
4817     parse->priv->prev_dts = parse->priv->next_dts = dts;
4818 }
4819
4820 /**
4821  * gst_base_parse_merge_tags:
4822  * @parse: a #GstBaseParse
4823  * @tags: (allow-none): a #GstTagList to merge, or NULL to unset
4824  *     previously-set tags
4825  * @mode: the #GstTagMergeMode to use, usually #GST_TAG_MERGE_REPLACE
4826  *
4827  * Sets the parser subclass's tags and how they should be merged with any
4828  * upstream stream tags. This will override any tags previously-set
4829  * with gst_base_parse_merge_tags().
4830  *
4831  * Note that this is provided for convenience, and the subclass is
4832  * not required to use this and can still do tag handling on its own.
4833  *
4834  * Since: 1.6
4835  */
4836 void
4837 gst_base_parse_merge_tags (GstBaseParse * parse, GstTagList * tags,
4838     GstTagMergeMode mode)
4839 {
4840   g_return_if_fail (GST_IS_BASE_PARSE (parse));
4841   g_return_if_fail (tags == NULL || GST_IS_TAG_LIST (tags));
4842   g_return_if_fail (tags == NULL || mode != GST_TAG_MERGE_UNDEFINED);
4843
4844   GST_OBJECT_LOCK (parse);
4845
4846   if (tags != parse->priv->parser_tags) {
4847     if (parse->priv->parser_tags) {
4848       gst_tag_list_unref (parse->priv->parser_tags);
4849       parse->priv->parser_tags = NULL;
4850       parse->priv->parser_tags_merge_mode = GST_TAG_MERGE_APPEND;
4851     }
4852     if (tags) {
4853       parse->priv->parser_tags = gst_tag_list_ref (tags);
4854       parse->priv->parser_tags_merge_mode = mode;
4855     }
4856
4857     GST_DEBUG_OBJECT (parse, "setting parser tags to %" GST_PTR_FORMAT
4858         " (mode %d)", tags, parse->priv->parser_tags_merge_mode);
4859
4860     gst_base_parse_check_bitrate_tags (parse);
4861     parse->priv->tags_changed = TRUE;
4862   }
4863
4864   GST_OBJECT_UNLOCK (parse);
4865 }
4866
4867 #ifdef GST_BASEPARSE_MODIFICATION
4868 void
4869 gst_base_parse_get_upstream_size (GstBaseParse * parse,
4870     gint64 * upstream_size)
4871 {
4872   GST_BASE_PARSE_INDEX_LOCK (parse);
4873   *upstream_size = parse->priv->upstream_size;
4874   GST_INFO_OBJECT (parse, "get upstream_size for child parser : (%"G_GUINT64_FORMAT")",
4875     parse->priv->upstream_size);
4876   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4877 }
4878
4879 void
4880 gst_base_parse_get_index_last_offset (GstBaseParse * parse,
4881     gint64 * index_last_offset)
4882 {
4883   GST_BASE_PARSE_INDEX_LOCK (parse);
4884   *index_last_offset = parse->priv->index_last_offset;
4885   GST_INFO_OBJECT (parse, "get index_last_offset for child parser : (%"G_GUINT64_FORMAT")",
4886     parse->priv->index_last_offset);
4887   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4888 }
4889
4890 void
4891 gst_base_parse_get_index_last_ts (GstBaseParse * parse,
4892     GstClockTime * index_last_ts)
4893 {
4894   GST_BASE_PARSE_INDEX_LOCK (parse);
4895   *index_last_ts = parse->priv->index_last_ts;
4896   GST_INFO_OBJECT (parse, "get index_last_ts for child parser : (%"GST_TIME_FORMAT")",
4897     GST_TIME_ARGS(parse->priv->index_last_ts));
4898   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4899 }
4900
4901 void
4902 gst_base_parse_get_pad_mode (GstBaseParse * parse,
4903     GstPadMode * pad_mode)
4904 {
4905   GST_BASE_PARSE_INDEX_LOCK (parse);
4906   *pad_mode = parse->priv->expected_pad_mode;
4907   GST_INFO_OBJECT (parse, "get pad_mode for child parse: mode num (%d)",
4908     parse->priv->expected_pad_mode);
4909   GST_BASE_PARSE_INDEX_UNLOCK (parse);
4910 }
4911 /*
4912  * Checks if accurate seek mode are avilable from sub-parse
4913  */
4914 void
4915 gst_base_parse_set_seek_mode (GstBaseParse * parse, gboolean seek_mode)
4916 {
4917   g_return_if_fail (parse != NULL);
4918   parse->priv->accurate_index_seek = seek_mode;
4919   if (seek_mode)
4920     GST_INFO_OBJECT (parse, "accurate seek mode ON");
4921   else
4922     GST_INFO_OBJECT (parse, "accurate seek mode OFF - for HTTP SEEK");
4923 }
4924 #endif