gst-libs/gst/video/gstvideodecoder.c

   1 /* GStreamer
   2  * Copyright (C) 2008 David Schleef <ds@schleef.org>
   3  * Copyright (C) 2011 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>.
   4  * Copyright (C) 2011 Nokia Corporation. All rights reserved.
   5  *   Contact: Stefan Kost <stefan.kost@nokia.com>
   6  * Copyright (C) 2012 Collabora Ltd.
   7  *      Author : Edward Hervey <edward@collabora.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 /**
  26  * SECTION:gstvideodecoder
  27  * @short_description: Base class for video decoders
  28  * @see_also:
  29  *
  30  * This base class is for video decoders turning encoded data into raw video
  31  * frames.
  32  *
  33  * The GstVideoDecoder base class and derived subclasses should cooperate as
  34  * follows:
  35  * <orderedlist>
  36  * <listitem>
  37  *   <itemizedlist><title>Configuration</title>
  38  *   <listitem><para>
  39  *     Initially, GstVideoDecoder calls @start when the decoder element
  40  *     is activated, which allows the subclass to perform any global setup.
  41  *   </para></listitem>
  42  *   <listitem><para>
  43  *     GstVideoDecoder calls @set_format to inform the subclass of caps
  44  *     describing input video data that it is about to receive, including
  45  *     possibly configuration data.
  46  *     While unlikely, it might be called more than once, if changing input
  47  *     parameters require reconfiguration.
  48  *   </para></listitem>
  49  *   <listitem><para>
  50  *     Incoming data buffers are processed as needed, described in Data
  51  *     Processing below.
  52  *   </para></listitem>
  53  *   <listitem><para>
  54  *     GstVideoDecoder calls @stop at end of all processing.
  55  *   </para></listitem>
  56  *   </itemizedlist>
  57  * </listitem>
  58  * <listitem>
  59  *   <itemizedlist>
  60  *   <title>Data processing</title>
  61  *     <listitem><para>
  62  *       The base class gathers input data, and optionally allows subclass
  63  *       to parse this into subsequently manageable chunks, typically
  64  *       corresponding to and referred to as 'frames'.
  65  *     </para></listitem>
  66  *     <listitem><para>
  67  *       Each input frame is provided in turn to the subclass' @handle_frame
  68  *       callback.
  69  *       The ownership of the frame is given to the @handle_frame callback.
  70  *     </para></listitem>
  71  *     <listitem><para>
  72  *       If codec processing results in decoded data, the subclass should call
  73  *       @gst_video_decoder_finish_frame to have decoded data pushed.
  74  *       downstream. Otherwise, the subclass must call
  75  *       @gst_video_decoder_drop_frame, to allow the base class to do timestamp
  76  *       and offset tracking, and possibly to requeue the frame for a later
  77  *       attempt in the case of reverse playback.
  78  *     </para></listitem>
  79  *   </itemizedlist>
  80  * </listitem>
  81  * <listitem>
  82  *   <itemizedlist><title>Shutdown phase</title>
  83  *   <listitem><para>
  84  *     The GstVideoDecoder class calls @stop to inform the subclass that data
  85  *     parsing will be stopped.
  86  *   </para></listitem>
  87  *   </itemizedlist>
  88  * </listitem>
  89  * <listitem>
  90  *   <itemizedlist><title>Additional Notes</title>
  91  *   <listitem>
  92  *     <itemizedlist><title>Seeking/Flushing</title>
  93  *     <listitem><para>
  94  *   When the pipeline is seeked or otherwise flushed, the subclass is
  95  *   informed via a call to its @reset callback, with the hard parameter
  96  *   set to true. This indicates the subclass should drop any internal data
  97  *   queues and timestamps and prepare for a fresh set of buffers to arrive
  98  *   for parsing and decoding.
  99  *     </para></listitem>
 100  *     </itemizedlist>
 101  *   </listitem>
 102  *   <listitem>
 103  *     <itemizedlist><title>End Of Stream</title>
 104  *     <listitem><para>
 105  *   At end-of-stream, the subclass @parse function may be called some final
 106  *   times with the at_eos parameter set to true, indicating that the element
 107  *   should not expect any more data to be arriving, and it should parse and
 108  *   remaining frames and call gst_video_decoder_have_frame() if possible.
 109  *     </para></listitem>
 110  *     </itemizedlist>
 111  *   </listitem>
 112  *   </itemizedlist>
 113  * </listitem>
 114  * </orderedlist>
 115  *
 116  * The subclass is responsible for providing pad template caps for
 117  * source and sink pads. The pads need to be named "sink" and "src". It also
 118  * needs to provide information about the ouptput caps, when they are known.
 119  * This may be when the base class calls the subclass' @set_format function,
 120  * though it might be during decoding, before calling
 121  * @gst_video_decoder_finish_frame. This is done via
 122  * @gst_video_decoder_set_output_state
 123  *
 124  * The subclass is also responsible for providing (presentation) timestamps
 125  * (likely based on corresponding input ones).  If that is not applicable
 126  * or possible, the base class provides limited framerate based interpolation.
 127  *
 128  * Similarly, the base class provides some limited (legacy) seeking support
 129  * if specifically requested by the subclass, as full-fledged support
 130  * should rather be left to upstream demuxer, parser or alike.  This simple
 131  * approach caters for seeking and duration reporting using estimated input
 132  * bitrates. To enable it, a subclass should call
 133  * @gst_video_decoder_set_estimate_rate to enable handling of incoming
 134  * byte-streams.
 135  *
 136  * The base class provides some support for reverse playback, in particular
 137  * in case incoming data is not packetized or upstream does not provide
 138  * fragments on keyframe boundaries.  However, the subclass should then be
 139  * prepared for the parsing and frame processing stage to occur separately
 140  * (in normal forward processing, the latter immediately follows the former),
 141  * The subclass also needs to ensure the parsing stage properly marks
 142  * keyframes, unless it knows the upstream elements will do so properly for
 143  * incoming data.
 144  *
 145  * The bare minimum that a functional subclass needs to implement is:
 146  * <itemizedlist>
 147  *   <listitem><para>Provide pad templates</para></listitem>
 148  *   <listitem><para>
 149  *      Inform the base class of output caps via
 150  *      @gst_video_decoder_set_output_state
 151  *   </para></listitem>
 152  *   <listitem><para>
 153  *      Parse input data, if it is not considered packetized from upstream
 154  *      Data will be provided to @parse which should invoke
 155  *      @gst_video_decoder_add_to_frame and @gst_video_decoder_have_frame to
 156  *      separate the data belonging to each video frame.
 157  *   </para></listitem>
 158  *   <listitem><para>
 159  *      Accept data in @handle_frame and provide decoded results to
 160  *      @gst_video_decoder_finish_frame, or call @gst_video_decoder_drop_frame.
 161  *   </para></listitem>
 162  * </itemizedlist>
 163  */
 164
 165 #ifdef HAVE_CONFIG_H
 166 #include "config.h"
 167 #endif
 168
 169 /* TODO
 170  *
 171  * * Add a flag/boolean for I-frame-only/image decoders so we can do extra
 172  *   features, like applying QoS on input (as opposed to after the frame is
 173  *   decoded).
 174  * * Add a flag/boolean for decoders that require keyframes, so the base
 175  *   class can automatically discard non-keyframes before one has arrived
 176  * * Detect reordered frame/timestamps and fix the pts/dts
 177  * * Support for GstIndex (or shall we not care ?)
 178  * * Calculate actual latency based on input/output timestamp/frame_number
 179  *   and if it exceeds the recorded one, save it and emit a GST_MESSAGE_LATENCY
 180  * * Emit latency message when it changes
 181  *
 182  */
 183
 184 /* Implementation notes:
 185  * The Video Decoder base class operates in 2 primary processing modes, depending
 186  * on whether forward or reverse playback is requested.
 187  *
 188  * Forward playback:
 189  *   * Incoming buffer -> @parse() -> add_to_frame()/have_frame() ->
 190  *     handle_frame() -> push downstream
 191  *
 192  * Reverse playback is more complicated, since it involves gathering incoming
 193  * data regions as we loop backwards through the upstream data. The processing
 194  * concept (using incoming buffers as containing one frame each to simplify
 195  * things) is:
 196  *
 197  * Upstream data we want to play:
 198  *  Buffer encoded order:  1  2  3  4  5  6  7  8  9  EOS
 199  *  Keyframe flag:            K        K
 200  *  Groupings:             AAAAAAA  BBBBBBB  CCCCCCC
 201  *
 202  * Input:
 203  *  Buffer reception order:  7  8  9  4  5  6  1  2  3  EOS
 204  *  Keyframe flag:                       K        K
 205  *  Discont flag:            D        D        D
 206  *
 207  * - Each Discont marks a discont in the decoding order.
 208  * - The keyframes mark where we can start decoding.
 209  *
 210  * Initially, we prepend incoming buffers to the gather queue. Whenever the
 211  * discont flag is set on an incoming buffer, the gather queue is flushed out
 212  * before the new buffer is collected.
 213  *
 214  * The above data will be accumulated in the gather queue like this:
 215  *
 216  *   gather queue:  9  8  7
 217  *                        D
 218  *
 219  * Whe buffer 4 is received (with a DISCONT), we flush the gather queue like
 220  * this:
 221  *
 222  *   while (gather)
 223  *     take head of queue and prepend to parse queue (this reverses the
 224  *     sequence, so parse queue is 7 -> 8 -> 9)
 225  *
 226  *   Next, we process the parse queue, which now contains all un-parsed packets
 227  *   (including any leftover ones from the previous decode section)
 228  *
 229  *   for each buffer now in the parse queue:
 230  *     Call the subclass parse function, prepending each resulting frame to
 231  *     the parse_gather queue. Buffers which precede the first one that
 232  *     produces a parsed frame are retained in the parse queue for
 233  *     re-processing on the next cycle of parsing.
 234  *
 235  *   The parse_gather queue now contains frame objects ready for decoding,
 236  *   in reverse order.
 237  *   parse_gather: 9 -> 8 -> 7
 238  *
 239  *   while (parse_gather)
 240  *     Take the head of the queue and prepend it to the decode queue
 241  *     If the frame was a keyframe, process the decode queue
 242  *   decode is now 7-8-9
 243  *
 244  *  Processing the decode queue results in frames with attached output buffers
 245  *  stored in the 'output_queue' ready for outputting in reverse order.
 246  *
 247  * After we flushed the gather queue and parsed it, we add 4 to the (now empty)
 248  * gather queue. We get the following situation:
 249  *
 250  *  gather queue:    4
 251  *  decode queue:    7  8  9
 252  *
 253  * After we received 5 (Keyframe) and 6:
 254  *
 255  *  gather queue:    6  5  4
 256  *  decode queue:    7  8  9
 257  *
 258  * When we receive 1 (DISCONT) which triggers a flush of the gather queue:
 259  *
 260  *   Copy head of the gather queue (6) to decode queue:
 261  *
 262  *    gather queue:    5  4
 263  *    decode queue:    6  7  8  9
 264  *
 265  *   Copy head of the gather queue (5) to decode queue. This is a keyframe so we
 266  *   can start decoding.
 267  *
 268  *    gather queue:    4
 269  *    decode queue:    5  6  7  8  9
 270  *
 271  *   Decode frames in decode queue, store raw decoded data in output queue, we
 272  *   can take the head of the decode queue and prepend the decoded result in the
 273  *   output queue:
 274  *
 275  *    gather queue:    4
 276  *    decode queue:
 277  *    output queue:    9  8  7  6  5
 278  *
 279  *   Now output all the frames in the output queue, picking a frame from the
 280  *   head of the queue.
 281  *
 282  *   Copy head of the gather queue (4) to decode queue, we flushed the gather
 283  *   queue and can now store input buffer in the gather queue:
 284  *
 285  *    gather queue:    1
 286  *    decode queue:    4
 287  *
 288  *  When we receive EOS, the queue looks like:
 289  *
 290  *    gather queue:    3  2  1
 291  *    decode queue:    4
 292  *
 293  *  Fill decode queue, first keyframe we copy is 2:
 294  *
 295  *    gather queue:    1
 296  *    decode queue:    2  3  4
 297  *
 298  *  Decoded output:
 299  *
 300  *    gather queue:    1
 301  *    decode queue:
 302  *    output queue:    4  3  2
 303  *
 304  *  Leftover buffer 1 cannot be decoded and must be discarded.
 305  */
 306
 307 #include "gstvideodecoder.h"
 308 #include "gstvideoutils.h"
 309 #include "gstvideoutilsprivate.h"
 310
 311 #include <gst/video/video.h>
 312 #include <gst/video/video-event.h>
 313 #include <gst/video/gstvideopool.h>
 314 #include <gst/video/gstvideometa.h>
 315 #include <string.h>
 316
 317 GST_DEBUG_CATEGORY (videodecoder_debug);
 318 #define GST_CAT_DEFAULT videodecoder_debug
 319
 320 #define GST_VIDEO_DECODER_GET_PRIVATE(obj)  \
 321     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_VIDEO_DECODER, \
 322         GstVideoDecoderPrivate))
 323
 324 struct _GstVideoDecoderPrivate
 325 {
 326   /* FIXME introduce a context ? */
 327
 328   GstBufferPool *pool;
 329   GstAllocator *allocator;
 330   GstAllocationParams params;
 331
 332   /* parse tracking */
 333   /* input data */
 334   GstAdapter *input_adapter;
 335   /* assembles current frame */
 336   GstAdapter *output_adapter;
 337
 338   /* Whether we attempt to convert newsegment from bytes to
 339    * time using a bitrate estimation */
 340   gboolean do_estimate_rate;
 341
 342   /* Whether input is considered packetized or not */
 343   gboolean packetized;
 344
 345   /* Error handling */
 346   gint max_errors;
 347   gint error_count;
 348   gboolean had_output_data;
 349   gboolean had_input_data;
 350
 351   gboolean needs_format;
 352   /* input_segment are output_segment identical */
 353   gboolean in_out_segment_sync;
 354
 355   /* ... being tracked here;
 356    * only available during parsing */
 357   GstVideoCodecFrame *current_frame;
 358   /* events that should apply to the current frame */
 359   GList *current_frame_events;
 360   /* events that should be pushed before the next frame */
 361   GList *pending_events;
 362
 363   /* relative offset of input data */
 364   guint64 input_offset;
 365   /* relative offset of frame */
 366   guint64 frame_offset;
 367   /* tracking ts and offsets */
 368   GList *timestamps;
 369
 370   /* last outgoing ts */
 371   GstClockTime last_timestamp_out;
 372   /* incoming pts - dts */
 373   GstClockTime pts_delta;
 374   gboolean reordered_output;
 375
 376   /* reverse playback */
 377   /* collect input */
 378   GList *gather;
 379   /* to-be-parsed */
 380   GList *parse;
 381   /* collected parsed frames */
 382   GList *parse_gather;
 383   /* frames to be handled == decoded */
 384   GList *decode;
 385   /* collected output - of buffer objects, not frames */
 386   GList *output_queued;
 387
 388
 389   /* base_picture_number is the picture number of the reference picture */
 390   guint64 base_picture_number;
 391   /* combine with base_picture_number, framerate and calcs to yield (presentation) ts */
 392   GstClockTime base_timestamp;
 393
 394   /* FIXME : reorder_depth is never set */
 395   int reorder_depth;
 396   int distance_from_sync;
 397
 398   guint32 system_frame_number;
 399   guint32 decode_frame_number;
 400
 401   GList *frames;                /* Protected with OBJECT_LOCK */
 402   GstVideoCodecState *input_state;
 403   GstVideoCodecState *output_state;     /* OBJECT_LOCK and STREAM_LOCK */
 404   gboolean output_state_changed;
 405
 406   /* QoS properties */
 407   gdouble proportion;           /* OBJECT_LOCK */
 408   GstClockTime earliest_time;   /* OBJECT_LOCK */
 409   GstClockTime qos_frame_duration;      /* OBJECT_LOCK */
 410   gboolean discont;
 411   /* qos messages: frames dropped/processed */
 412   guint dropped;
 413   guint processed;
 414
 415   /* Outgoing byte size ? */
 416   gint64 bytes_out;
 417   gint64 time;
 418
 419   gint64 min_latency;
 420   gint64 max_latency;
 421
 422   /* upstream stream tags (global tags are passed through as-is) */
 423   GstTagList *upstream_tags;
 424
 425   /* subclass tags */
 426   GstTagList *tags;
 427   GstTagMergeMode tags_merge_mode;
 428
 429   gboolean tags_changed;
 430
 431   /* flags */
 432   gboolean use_default_pad_acceptcaps;
 433 };
 434
 435 static GstElementClass *parent_class = NULL;
 436 static void gst_video_decoder_class_init (GstVideoDecoderClass * klass);
 437 static void gst_video_decoder_init (GstVideoDecoder * dec,
 438     GstVideoDecoderClass * klass);
 439
 440 static void gst_video_decoder_finalize (GObject * object);
 441
 442 static gboolean gst_video_decoder_setcaps (GstVideoDecoder * dec,
 443     GstCaps * caps);
 444 static gboolean gst_video_decoder_sink_event (GstPad * pad, GstObject * parent,
 445     GstEvent * event);
 446 static gboolean gst_video_decoder_src_event (GstPad * pad, GstObject * parent,
 447     GstEvent * event);
 448 static GstFlowReturn gst_video_decoder_chain (GstPad * pad, GstObject * parent,
 449     GstBuffer * buf);
 450 static gboolean gst_video_decoder_sink_query (GstPad * pad, GstObject * parent,
 451     GstQuery * query);
 452 static GstStateChangeReturn gst_video_decoder_change_state (GstElement *
 453     element, GstStateChange transition);
 454 static gboolean gst_video_decoder_src_query (GstPad * pad, GstObject * parent,
 455     GstQuery * query);
 456 static void gst_video_decoder_reset (GstVideoDecoder * decoder, gboolean full,
 457     gboolean flush_hard);
 458
 459 static GstFlowReturn gst_video_decoder_decode_frame (GstVideoDecoder * decoder,
 460     GstVideoCodecFrame * frame);
 461
 462 static void gst_video_decoder_push_event_list (GstVideoDecoder * decoder,
 463     GList * events);
 464 static GstClockTime gst_video_decoder_get_frame_duration (GstVideoDecoder *
 465     decoder, GstVideoCodecFrame * frame);
 466 static GstVideoCodecFrame *gst_video_decoder_new_frame (GstVideoDecoder *
 467     decoder);
 468 static GstFlowReturn gst_video_decoder_clip_and_push_buf (GstVideoDecoder *
 469     decoder, GstBuffer * buf);
 470 static GstFlowReturn gst_video_decoder_flush_parse (GstVideoDecoder * dec,
 471     gboolean at_eos);
 472
 473 static void gst_video_decoder_clear_queues (GstVideoDecoder * dec);
 474
 475 static gboolean gst_video_decoder_sink_event_default (GstVideoDecoder * decoder,
 476     GstEvent * event);
 477 static gboolean gst_video_decoder_src_event_default (GstVideoDecoder * decoder,
 478     GstEvent * event);
 479 static gboolean gst_video_decoder_decide_allocation_default (GstVideoDecoder *
 480     decoder, GstQuery * query);
 481 static gboolean gst_video_decoder_propose_allocation_default (GstVideoDecoder *
 482     decoder, GstQuery * query);
 483 static gboolean gst_video_decoder_negotiate_default (GstVideoDecoder * decoder);
 484 static GstFlowReturn gst_video_decoder_parse_available (GstVideoDecoder * dec,
 485     gboolean at_eos, gboolean new_buffer);
 486 static gboolean gst_video_decoder_negotiate_unlocked (GstVideoDecoder *
 487     decoder);
 488 static gboolean gst_video_decoder_sink_query_default (GstVideoDecoder * decoder,
 489     GstQuery * query);
 490 static gboolean gst_video_decoder_src_query_default (GstVideoDecoder * decoder,
 491     GstQuery * query);
 492
 493 static gboolean gst_video_decoder_transform_meta_default (GstVideoDecoder *
 494     decoder, GstVideoCodecFrame * frame, GstMeta * meta);
 495
 496 /* we can't use G_DEFINE_ABSTRACT_TYPE because we need the klass in the _init
 497  * method to get to the padtemplates */
 498 GType
 499 gst_video_decoder_get_type (void)
 500 {
 501   static volatile gsize type = 0;
 502
 503   if (g_once_init_enter (&type)) {
 504     GType _type;
 505     static const GTypeInfo info = {
 506       sizeof (GstVideoDecoderClass),
 507       NULL,
 508       NULL,
 509       (GClassInitFunc) gst_video_decoder_class_init,
 510       NULL,
 511       NULL,
 512       sizeof (GstVideoDecoder),
 513       0,
 514       (GInstanceInitFunc) gst_video_decoder_init,
 515     };
 516
 517     _type = g_type_register_static (GST_TYPE_ELEMENT,
 518         "GstVideoDecoder", &info, G_TYPE_FLAG_ABSTRACT);
 519     g_once_init_leave (&type, _type);
 520   }
 521   return type;
 522 }
 523
 524 static void
 525 gst_video_decoder_class_init (GstVideoDecoderClass * klass)
 526 {
 527   GObjectClass *gobject_class;
 528   GstElementClass *gstelement_class;
 529
 530   gobject_class = G_OBJECT_CLASS (klass);
 531   gstelement_class = GST_ELEMENT_CLASS (klass);
 532
 533   GST_DEBUG_CATEGORY_INIT (videodecoder_debug, "videodecoder", 0,
 534       "Base Video Decoder");
 535
 536   parent_class = g_type_class_peek_parent (klass);
 537   g_type_class_add_private (klass, sizeof (GstVideoDecoderPrivate));
 538
 539   gobject_class->finalize = gst_video_decoder_finalize;
 540
 541   gstelement_class->change_state =
 542       GST_DEBUG_FUNCPTR (gst_video_decoder_change_state);
 543
 544   klass->sink_event = gst_video_decoder_sink_event_default;
 545   klass->src_event = gst_video_decoder_src_event_default;
 546   klass->decide_allocation = gst_video_decoder_decide_allocation_default;
 547   klass->propose_allocation = gst_video_decoder_propose_allocation_default;
 548   klass->negotiate = gst_video_decoder_negotiate_default;
 549   klass->sink_query = gst_video_decoder_sink_query_default;
 550   klass->src_query = gst_video_decoder_src_query_default;
 551   klass->transform_meta = gst_video_decoder_transform_meta_default;
 552 }
 553
 554 static void
 555 gst_video_decoder_init (GstVideoDecoder * decoder, GstVideoDecoderClass * klass)
 556 {
 557   GstPadTemplate *pad_template;
 558   GstPad *pad;
 559
 560   GST_DEBUG_OBJECT (decoder, "gst_video_decoder_init");
 561
 562   decoder->priv = GST_VIDEO_DECODER_GET_PRIVATE (decoder);
 563
 564   pad_template =
 565       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "sink");
 566   g_return_if_fail (pad_template != NULL);
 567
 568   decoder->sinkpad = pad = gst_pad_new_from_template (pad_template, "sink");
 569
 570   gst_pad_set_chain_function (pad, GST_DEBUG_FUNCPTR (gst_video_decoder_chain));
 571   gst_pad_set_event_function (pad,
 572       GST_DEBUG_FUNCPTR (gst_video_decoder_sink_event));
 573   gst_pad_set_query_function (pad,
 574       GST_DEBUG_FUNCPTR (gst_video_decoder_sink_query));
 575   gst_element_add_pad (GST_ELEMENT (decoder), decoder->sinkpad);
 576
 577   pad_template =
 578       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "src");
 579   g_return_if_fail (pad_template != NULL);
 580
 581   decoder->srcpad = pad = gst_pad_new_from_template (pad_template, "src");
 582
 583   gst_pad_set_event_function (pad,
 584       GST_DEBUG_FUNCPTR (gst_video_decoder_src_event));
 585   gst_pad_set_query_function (pad,
 586       GST_DEBUG_FUNCPTR (gst_video_decoder_src_query));
 587   gst_element_add_pad (GST_ELEMENT (decoder), decoder->srcpad);
 588
 589   gst_segment_init (&decoder->input_segment, GST_FORMAT_TIME);
 590   gst_segment_init (&decoder->output_segment, GST_FORMAT_TIME);
 591
 592   g_rec_mutex_init (&decoder->stream_lock);
 593
 594   decoder->priv->input_adapter = gst_adapter_new ();
 595   decoder->priv->output_adapter = gst_adapter_new ();
 596   decoder->priv->packetized = TRUE;
 597   decoder->priv->needs_format = FALSE;
 598
 599   decoder->priv->min_latency = 0;
 600   decoder->priv->max_latency = 0;
 601
 602   gst_video_decoder_reset (decoder, TRUE, TRUE);
 603 }
 604
 605 static gboolean
 606 gst_video_rawvideo_convert (GstVideoCodecState * state,
 607     GstFormat src_format, gint64 src_value,
 608     GstFormat * dest_format, gint64 * dest_value)
 609 {
 610   gboolean res = FALSE;
 611   guint vidsize;
 612   guint fps_n, fps_d;
 613
 614   g_return_val_if_fail (dest_format != NULL, FALSE);
 615   g_return_val_if_fail (dest_value != NULL, FALSE);
 616
 617   if (src_format == *dest_format || src_value == 0 || src_value == -1) {
 618     *dest_value = src_value;
 619     return TRUE;
 620   }
 621
 622   vidsize = GST_VIDEO_INFO_SIZE (&state->info);
 623   fps_n = GST_VIDEO_INFO_FPS_N (&state->info);
 624   fps_d = GST_VIDEO_INFO_FPS_D (&state->info);
 625
 626   if (src_format == GST_FORMAT_BYTES &&
 627       *dest_format == GST_FORMAT_DEFAULT && vidsize) {
 628     /* convert bytes to frames */
 629     *dest_value = gst_util_uint64_scale_int (src_value, 1, vidsize);
 630     res = TRUE;
 631   } else if (src_format == GST_FORMAT_DEFAULT &&
 632       *dest_format == GST_FORMAT_BYTES && vidsize) {
 633     /* convert bytes to frames */
 634     *dest_value = src_value * vidsize;
 635     res = TRUE;
 636   } else if (src_format == GST_FORMAT_DEFAULT &&
 637       *dest_format == GST_FORMAT_TIME && fps_n) {
 638     /* convert frames to time */
 639     *dest_value = gst_util_uint64_scale (src_value, GST_SECOND * fps_d, fps_n);
 640     res = TRUE;
 641   } else if (src_format == GST_FORMAT_TIME &&
 642       *dest_format == GST_FORMAT_DEFAULT && fps_d) {
 643     /* convert time to frames */
 644     *dest_value = gst_util_uint64_scale (src_value, fps_n, GST_SECOND * fps_d);
 645     res = TRUE;
 646   } else if (src_format == GST_FORMAT_TIME &&
 647       *dest_format == GST_FORMAT_BYTES && fps_d && vidsize) {
 648     /* convert time to bytes */
 649     *dest_value = gst_util_uint64_scale (src_value,
 650         fps_n * (guint64) vidsize, GST_SECOND * fps_d);
 651     res = TRUE;
 652   } else if (src_format == GST_FORMAT_BYTES &&
 653       *dest_format == GST_FORMAT_TIME && fps_n && vidsize) {
 654     /* convert bytes to time */
 655     *dest_value = gst_util_uint64_scale (src_value,
 656         GST_SECOND * fps_d, fps_n * (guint64) vidsize);
 657     res = TRUE;
 658   }
 659
 660   return res;
 661 }
 662
 663 static gboolean
 664 gst_video_encoded_video_convert (gint64 bytes, gint64 time,
 665     GstFormat src_format, gint64 src_value, GstFormat * dest_format,
 666     gint64 * dest_value)
 667 {
 668   gboolean res = FALSE;
 669
 670   g_return_val_if_fail (dest_format != NULL, FALSE);
 671   g_return_val_if_fail (dest_value != NULL, FALSE);
 672
 673   if (G_UNLIKELY (src_format == *dest_format || src_value == 0 ||
 674           src_value == -1)) {
 675     if (dest_value)
 676       *dest_value = src_value;
 677     return TRUE;
 678   }
 679
 680   if (bytes <= 0 || time <= 0) {
 681     GST_DEBUG ("not enough metadata yet to convert");
 682     goto exit;
 683   }
 684
 685   switch (src_format) {
 686     case GST_FORMAT_BYTES:
 687       switch (*dest_format) {
 688         case GST_FORMAT_TIME:
 689           *dest_value = gst_util_uint64_scale (src_value, time, bytes);
 690           res = TRUE;
 691           break;
 692         default:
 693           res = FALSE;
 694       }
 695       break;
 696     case GST_FORMAT_TIME:
 697       switch (*dest_format) {
 698         case GST_FORMAT_BYTES:
 699           *dest_value = gst_util_uint64_scale (src_value, bytes, time);
 700           res = TRUE;
 701           break;
 702         default:
 703           res = FALSE;
 704       }
 705       break;
 706     default:
 707       GST_DEBUG ("unhandled conversion from %d to %d", src_format,
 708           *dest_format);
 709       res = FALSE;
 710   }
 711
 712 exit:
 713   return res;
 714 }
 715
 716 static GstVideoCodecState *
 717 _new_input_state (GstCaps * caps)
 718 {
 719   GstVideoCodecState *state;
 720   GstStructure *structure;
 721   const GValue *codec_data;
 722
 723   state = g_slice_new0 (GstVideoCodecState);
 724   state->ref_count = 1;
 725   gst_video_info_init (&state->info);
 726   if (G_UNLIKELY (!gst_video_info_from_caps (&state->info, caps)))
 727     goto parse_fail;
 728   state->caps = gst_caps_ref (caps);
 729
 730   structure = gst_caps_get_structure (caps, 0);
 731
 732   codec_data = gst_structure_get_value (structure, "codec_data");
 733   if (codec_data && G_VALUE_TYPE (codec_data) == GST_TYPE_BUFFER)
 734     state->codec_data = GST_BUFFER (g_value_dup_boxed (codec_data));
 735
 736   return state;
 737
 738 parse_fail:
 739   {
 740     g_slice_free (GstVideoCodecState, state);
 741     return NULL;
 742   }
 743 }
 744
 745 static GstVideoCodecState *
 746 _new_output_state (GstVideoFormat fmt, guint width, guint height,
 747     GstVideoCodecState * reference)
 748 {
 749   GstVideoCodecState *state;
 750
 751   state = g_slice_new0 (GstVideoCodecState);
 752   state->ref_count = 1;
 753   gst_video_info_init (&state->info);
 754   gst_video_info_set_format (&state->info, fmt, width, height);
 755
 756   if (reference) {
 757     GstVideoInfo *tgt, *ref;
 758
 759     tgt = &state->info;
 760     ref = &reference->info;
 761
 762     /* Copy over extra fields from reference state */
 763     tgt->interlace_mode = ref->interlace_mode;
 764     tgt->flags = ref->flags;
 765     /* only copy values that are not unknown so that we don't override the
 766      * defaults. subclasses should really fill these in when they know. */
 767     if (ref->chroma_site)
 768       tgt->chroma_site = ref->chroma_site;
 769     if (ref->colorimetry.range)
 770       tgt->colorimetry.range = ref->colorimetry.range;
 771     if (ref->colorimetry.matrix)
 772       tgt->colorimetry.matrix = ref->colorimetry.matrix;
 773     if (ref->colorimetry.transfer)
 774       tgt->colorimetry.transfer = ref->colorimetry.transfer;
 775     if (ref->colorimetry.primaries)
 776       tgt->colorimetry.primaries = ref->colorimetry.primaries;
 777     GST_DEBUG ("reference par %d/%d fps %d/%d",
 778         ref->par_n, ref->par_d, ref->fps_n, ref->fps_d);
 779     tgt->par_n = ref->par_n;
 780     tgt->par_d = ref->par_d;
 781     tgt->fps_n = ref->fps_n;
 782     tgt->fps_d = ref->fps_d;
 783     tgt->views = ref->views;
 784     if (GST_VIDEO_INFO_MULTIVIEW_MODE (ref) != GST_VIDEO_MULTIVIEW_MODE_NONE) {
 785       GST_VIDEO_INFO_MULTIVIEW_MODE (tgt) = GST_VIDEO_INFO_MULTIVIEW_MODE (ref);
 786       GST_VIDEO_INFO_MULTIVIEW_FLAGS (tgt) =
 787           GST_VIDEO_INFO_MULTIVIEW_FLAGS (ref);
 788     }
 789   }
 790
 791   GST_DEBUG ("reference par %d/%d fps %d/%d",
 792       state->info.par_n, state->info.par_d,
 793       state->info.fps_n, state->info.fps_d);
 794
 795   return state;
 796 }
 797
 798 static gboolean
 799 gst_video_decoder_setcaps (GstVideoDecoder * decoder, GstCaps * caps)
 800 {
 801   GstVideoDecoderClass *decoder_class;
 802   GstVideoCodecState *state;
 803   gboolean ret = TRUE;
 804
 805   decoder_class = GST_VIDEO_DECODER_GET_CLASS (decoder);
 806
 807   GST_DEBUG_OBJECT (decoder, "setcaps %" GST_PTR_FORMAT, caps);
 808
 809   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
 810
 811   if (decoder->priv->input_state) {
 812     GST_DEBUG_OBJECT (decoder,
 813         "Checking if caps changed old %" GST_PTR_FORMAT " new %" GST_PTR_FORMAT,
 814         decoder->priv->input_state->caps, caps);
 815     if (gst_caps_is_equal (decoder->priv->input_state->caps, caps))
 816       goto caps_not_changed;
 817   }
 818
 819   state = _new_input_state (caps);
 820
 821   if (G_UNLIKELY (state == NULL))
 822     goto parse_fail;
 823
 824   if (decoder_class->set_format)
 825     ret = decoder_class->set_format (decoder, state);
 826
 827   if (!ret)
 828     goto refused_format;
 829
 830   if (decoder->priv->input_state)
 831     gst_video_codec_state_unref (decoder->priv->input_state);
 832   decoder->priv->input_state = state;
 833
 834   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
 835
 836   return ret;
 837
 838 caps_not_changed:
 839   {
 840     GST_DEBUG_OBJECT (decoder, "Caps did not change - ignore");
 841     GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
 842     return TRUE;
 843   }
 844
 845   /* ERRORS */
 846 parse_fail:
 847   {
 848     GST_WARNING_OBJECT (decoder, "Failed to parse caps");
 849     GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
 850     return FALSE;
 851   }
 852
 853 refused_format:
 854   {
 855     GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
 856     GST_WARNING_OBJECT (decoder, "Subclass refused caps");
 857     gst_video_codec_state_unref (state);
 858     return FALSE;
 859   }
 860 }
 861
 862 static void
 863 gst_video_decoder_finalize (GObject * object)
 864 {
 865   GstVideoDecoder *decoder;
 866
 867   decoder = GST_VIDEO_DECODER (object);
 868
 869   GST_DEBUG_OBJECT (object, "finalize");
 870
 871   g_rec_mutex_clear (&decoder->stream_lock);
 872
 873   if (decoder->priv->input_adapter) {
 874     g_object_unref (decoder->priv->input_adapter);
 875     decoder->priv->input_adapter = NULL;
 876   }
 877   if (decoder->priv->output_adapter) {
 878     g_object_unref (decoder->priv->output_adapter);
 879     decoder->priv->output_adapter = NULL;
 880   }
 881
 882   if (decoder->priv->input_state)
 883     gst_video_codec_state_unref (decoder->priv->input_state);
 884   if (decoder->priv->output_state)
 885     gst_video_codec_state_unref (decoder->priv->output_state);
 886
 887   if (decoder->priv->pool) {
 888     gst_object_unref (decoder->priv->pool);
 889     decoder->priv->pool = NULL;
 890   }
 891
 892   if (decoder->priv->allocator) {
 893     gst_object_unref (decoder->priv->allocator);
 894     decoder->priv->allocator = NULL;
 895   }
 896
 897   G_OBJECT_CLASS (parent_class)->finalize (object);
 898 }
 899
 900 /* hard == FLUSH, otherwise discont */
 901 static GstFlowReturn
 902 gst_video_decoder_flush (GstVideoDecoder * dec, gboolean hard)
 903 {
 904   GstVideoDecoderClass *klass = GST_VIDEO_DECODER_GET_CLASS (dec);
 905   GstFlowReturn ret = GST_FLOW_OK;
 906
 907   GST_LOG_OBJECT (dec, "flush hard %d", hard);
 908
 909   /* Inform subclass */
 910   if (klass->reset) {
 911     GST_FIXME_OBJECT (dec, "GstVideoDecoder::reset() is deprecated");
 912     klass->reset (dec, hard);
 913   }
 914
 915   if (klass->flush)
 916     klass->flush (dec);
 917
 918   /* and get (re)set for the sequel */
 919   gst_video_decoder_reset (dec, FALSE, hard);
 920
 921   return ret;
 922 }
 923
 924 static GstEvent *
 925 gst_video_decoder_create_merged_tags_event (GstVideoDecoder * dec)
 926 {
 927   GstTagList *merged_tags;
 928
 929   GST_LOG_OBJECT (dec, "upstream : %" GST_PTR_FORMAT, dec->priv->upstream_tags);
 930   GST_LOG_OBJECT (dec, "decoder  : %" GST_PTR_FORMAT, dec->priv->tags);
 931   GST_LOG_OBJECT (dec, "mode     : %d", dec->priv->tags_merge_mode);
 932
 933   merged_tags =
 934       gst_tag_list_merge (dec->priv->upstream_tags, dec->priv->tags,
 935       dec->priv->tags_merge_mode);
 936
 937   GST_DEBUG_OBJECT (dec, "merged   : %" GST_PTR_FORMAT, merged_tags);
 938
 939   if (merged_tags == NULL)
 940     return NULL;
 941
 942   if (gst_tag_list_is_empty (merged_tags)) {
 943     gst_tag_list_unref (merged_tags);
 944     return NULL;
 945   }
 946
 947   return gst_event_new_tag (merged_tags);
 948 }
 949
 950 static gboolean
 951 gst_video_decoder_push_event (GstVideoDecoder * decoder, GstEvent * event)
 952 {
 953   switch (GST_EVENT_TYPE (event)) {
 954     case GST_EVENT_SEGMENT:
 955     {
 956       GstSegment segment;
 957
 958       gst_event_copy_segment (event, &segment);
 959
 960       GST_DEBUG_OBJECT (decoder, "segment %" GST_SEGMENT_FORMAT, &segment);
 961
 962       if (segment.format != GST_FORMAT_TIME) {
 963         GST_DEBUG_OBJECT (decoder, "received non TIME newsegment");
 964         break;
 965       }
 966
 967       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
 968       decoder->output_segment = segment;
 969       decoder->priv->in_out_segment_sync =
 970           gst_segment_is_equal (&decoder->input_segment, &segment);
 971       decoder->priv->last_timestamp_out = GST_CLOCK_TIME_NONE;
 972       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
 973       break;
 974     }
 975     default:
 976       break;
 977   }
 978
 979   GST_DEBUG_OBJECT (decoder, "pushing event %s",
 980       gst_event_type_get_name (GST_EVENT_TYPE (event)));
 981
 982   return gst_pad_push_event (decoder->srcpad, event);
 983 }
 984
 985 static GstFlowReturn
 986 gst_video_decoder_parse_available (GstVideoDecoder * dec, gboolean at_eos,
 987     gboolean new_buffer)
 988 {
 989   GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_GET_CLASS (dec);
 990   GstVideoDecoderPrivate *priv = dec->priv;
 991   GstFlowReturn ret = GST_FLOW_OK;
 992   gsize was_available, available;
 993   guint inactive = 0;
 994
 995   available = gst_adapter_available (priv->input_adapter);
 996
 997   while (available || new_buffer) {
 998     new_buffer = FALSE;
 999     /* current frame may have been parsed and handled,
1000      * so we need to set up a new one when asking subclass to parse */
1001     if (priv->current_frame == NULL)
1002       priv->current_frame = gst_video_decoder_new_frame (dec);
1003
1004     was_available = available;
1005     ret = decoder_class->parse (dec, priv->current_frame,
1006         priv->input_adapter, at_eos);
1007     if (ret != GST_FLOW_OK)
1008       break;
1009
1010     /* if the subclass returned success (GST_FLOW_OK), it is expected
1011      * to have collected and submitted a frame, i.e. it should have
1012      * called gst_video_decoder_have_frame(), or at least consumed a
1013      * few bytes through gst_video_decoder_add_to_frame().
1014      *
1015      * Otherwise, this is an implementation bug, and we error out
1016      * after 2 failed attempts */
1017     available = gst_adapter_available (priv->input_adapter);
1018     if (!priv->current_frame || available != was_available)
1019       inactive = 0;
1020     else if (++inactive == 2)
1021       goto error_inactive;
1022   }
1023
1024   return ret;
1025
1026   /* ERRORS */
1027 error_inactive:
1028   {
1029     GST_ERROR_OBJECT (dec, "Failed to consume data. Error in subclass?");
1030     return GST_FLOW_ERROR;
1031   }
1032 }
1033
1034 static GstFlowReturn
1035 gst_video_decoder_drain_out (GstVideoDecoder * dec, gboolean at_eos)
1036 {
1037   GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_GET_CLASS (dec);
1038   GstVideoDecoderPrivate *priv = dec->priv;
1039   GstFlowReturn ret = GST_FLOW_OK;
1040
1041   GST_VIDEO_DECODER_STREAM_LOCK (dec);
1042
1043   if (dec->input_segment.rate > 0.0) {
1044     /* Forward mode, if unpacketized, give the child class
1045      * a final chance to flush out packets */
1046     if (!priv->packetized) {
1047       ret = gst_video_decoder_parse_available (dec, TRUE, FALSE);
1048     }
1049
1050     if (at_eos) {
1051       if (decoder_class->finish)
1052         ret = decoder_class->finish (dec);
1053     } else {
1054       if (decoder_class->drain) {
1055         ret = decoder_class->drain (dec);
1056       } else {
1057         GST_FIXME_OBJECT (dec, "Sub-class should implement drain()");
1058       }
1059     }
1060   } else {
1061     /* Reverse playback mode */
1062     ret = gst_video_decoder_flush_parse (dec, TRUE);
1063   }
1064
1065   GST_VIDEO_DECODER_STREAM_UNLOCK (dec);
1066
1067   return ret;
1068 }
1069
1070 static GList *
1071 _flush_events (GstPad * pad, GList * events)
1072 {
1073   GList *tmp;
1074
1075   for (tmp = events; tmp; tmp = tmp->next) {
1076     if (GST_EVENT_TYPE (tmp->data) != GST_EVENT_EOS &&
1077         GST_EVENT_TYPE (tmp->data) != GST_EVENT_SEGMENT &&
1078         GST_EVENT_IS_STICKY (tmp->data)) {
1079       gst_pad_store_sticky_event (pad, GST_EVENT_CAST (tmp->data));
1080     }
1081     gst_event_unref (tmp->data);
1082   }
1083   g_list_free (events);
1084
1085   return NULL;
1086 }
1087
1088 /* Must be called holding the GST_VIDEO_DECODER_STREAM_LOCK */
1089 static gboolean
1090 gst_video_decoder_negotiate_default_caps (GstVideoDecoder * decoder)
1091 {
1092   GstCaps *caps, *templcaps;
1093   GstVideoCodecState *state;
1094   GstVideoInfo info;
1095   gint i;
1096   gint caps_size;
1097   GstStructure *structure;
1098
1099   templcaps = gst_pad_get_pad_template_caps (decoder->srcpad);
1100   caps = gst_pad_peer_query_caps (decoder->srcpad, templcaps);
1101   if (caps)
1102     gst_caps_unref (templcaps);
1103   else
1104     caps = templcaps;
1105   templcaps = NULL;
1106
1107   if (!caps || gst_caps_is_empty (caps) || gst_caps_is_any (caps))
1108     goto caps_error;
1109
1110   GST_LOG_OBJECT (decoder, "peer caps %" GST_PTR_FORMAT, caps);
1111
1112   /* before fixating, try to use whatever upstream provided */
1113   caps = gst_caps_make_writable (caps);
1114   caps_size = gst_caps_get_size (caps);
1115   if (decoder->priv->input_state && decoder->priv->input_state->caps) {
1116     GstCaps *sinkcaps = decoder->priv->input_state->caps;
1117     GstStructure *structure = gst_caps_get_structure (sinkcaps, 0);
1118     gint width, height;
1119     gint par_n, par_d;
1120     gint fps_n, fps_d;
1121
1122     if (gst_structure_get_int (structure, "width", &width)) {
1123       for (i = 0; i < caps_size; i++) {
1124         gst_structure_set (gst_caps_get_structure (caps, i), "width",
1125             G_TYPE_INT, width, NULL);
1126       }
1127     }
1128
1129     if (gst_structure_get_int (structure, "height", &height)) {
1130       for (i = 0; i < caps_size; i++) {
1131         gst_structure_set (gst_caps_get_structure (caps, i), "height",
1132             G_TYPE_INT, height, NULL);
1133       }
1134     }
1135
1136     if (gst_structure_get_fraction (structure, "framerate", &fps_n, &fps_d)) {
1137       for (i = 0; i < caps_size; i++) {
1138         gst_structure_set (gst_caps_get_structure (caps, i), "framerate",
1139             GST_TYPE_FRACTION, fps_n, fps_d, NULL);
1140       }
1141     }
1142
1143     if (gst_structure_get_fraction (structure, "pixel-aspect-ratio", &par_n,
1144             &par_d)) {
1145       for (i = 0; i < caps_size; i++) {
1146         gst_structure_set (gst_caps_get_structure (caps, i),
1147             "pixel-aspect-ratio", GST_TYPE_FRACTION, par_n, par_d, NULL);
1148       }
1149     }
1150   }
1151
1152   for (i = 0; i < caps_size; i++) {
1153     structure = gst_caps_get_structure (caps, i);
1154     /* Random 1280x720@30 for fixation */
1155     gst_structure_fixate_field_nearest_int (structure, "width", 1280);
1156     gst_structure_fixate_field_nearest_int (structure, "height", 720);
1157     gst_structure_fixate_field_nearest_fraction (structure, "framerate", 30, 1);
1158     if (gst_structure_has_field (structure, "pixel-aspect-ratio")) {
1159       gst_structure_fixate_field_nearest_fraction (structure,
1160           "pixel-aspect-ratio", 1, 1);
1161     } else {
1162       gst_structure_set (structure, "pixel-aspect-ratio", GST_TYPE_FRACTION,
1163           1, 1, NULL);
1164     }
1165   }
1166   caps = gst_caps_fixate (caps);
1167   structure = gst_caps_get_structure (caps, 0);
1168
1169   if (!caps || !gst_video_info_from_caps (&info, caps))
1170     goto caps_error;
1171
1172   GST_INFO_OBJECT (decoder,
1173       "Chose default caps %" GST_PTR_FORMAT " for initial gap", caps);
1174   state =
1175       gst_video_decoder_set_output_state (decoder, info.finfo->format,
1176       info.width, info.height, decoder->priv->input_state);
1177   gst_video_codec_state_unref (state);
1178   gst_caps_unref (caps);
1179
1180   return TRUE;
1181
1182 caps_error:
1183   {
1184     if (caps)
1185       gst_caps_unref (caps);
1186     return FALSE;
1187   }
1188 }
1189
1190 static gboolean
1191 gst_video_decoder_sink_event_default (GstVideoDecoder * decoder,
1192     GstEvent * event)
1193 {
1194   GstVideoDecoderPrivate *priv;
1195   gboolean ret = FALSE;
1196   gboolean forward_immediate = FALSE;
1197
1198   priv = decoder->priv;
1199
1200   switch (GST_EVENT_TYPE (event)) {
1201     case GST_EVENT_STREAM_START:
1202     {
1203       GstFlowReturn flow_ret = GST_FLOW_OK;
1204
1205       flow_ret = gst_video_decoder_drain_out (decoder, FALSE);
1206       ret = (flow_ret == GST_FLOW_OK);
1207
1208       GST_DEBUG_OBJECT (decoder, "received STREAM_START. Clearing taglist");
1209       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
1210       /* Flush upstream tags after a STREAM_START */
1211       if (priv->upstream_tags) {
1212         gst_tag_list_unref (priv->upstream_tags);
1213         priv->upstream_tags = NULL;
1214         priv->tags_changed = TRUE;
1215       }
1216       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
1217
1218       /* Forward STREAM_START immediately. Everything is drained after
1219        * the STREAM_START event and we can forward this event immediately
1220        * now without having buffers out of order.
1221        */
1222       forward_immediate = TRUE;
1223       break;
1224     }
1225     case GST_EVENT_CAPS:
1226     {
1227       GstCaps *caps;
1228
1229       gst_event_parse_caps (event, &caps);
1230       ret = gst_video_decoder_setcaps (decoder, caps);
1231       gst_event_unref (event);
1232       event = NULL;
1233       break;
1234     }
1235     case GST_EVENT_SEGMENT_DONE:
1236     {
1237       GstFlowReturn flow_ret = GST_FLOW_OK;
1238
1239       flow_ret = gst_video_decoder_drain_out (decoder, TRUE);
1240       ret = (flow_ret == GST_FLOW_OK);
1241
1242       /* Forward SEGMENT_DONE immediately. This is required
1243        * because no buffer or serialized event might come
1244        * after SEGMENT_DONE and nothing could trigger another
1245        * _finish_frame() call.
1246        *
1247        * The subclass can override this behaviour by overriding
1248        * the ::sink_event() vfunc and not chaining up to the
1249        * parent class' ::sink_event() until a later time.
1250        */
1251       forward_immediate = TRUE;
1252       break;
1253     }
1254     case GST_EVENT_EOS:
1255     {
1256       GstFlowReturn flow_ret = GST_FLOW_OK;
1257
1258       flow_ret = gst_video_decoder_drain_out (decoder, TRUE);
1259       ret = (flow_ret == GST_FLOW_OK);
1260
1261       /* Error out even if EOS was ok when we had input, but no output */
1262       if (ret && priv->had_input_data && !priv->had_output_data) {
1263         GST_ELEMENT_ERROR (decoder, STREAM, DECODE,
1264             ("No valid frames decoded before end of stream"),
1265             ("no valid frames found"));
1266       }
1267
1268       /* Forward EOS immediately. This is required because no
1269        * buffer or serialized event will come after EOS and
1270        * nothing could trigger another _finish_frame() call.
1271        *
1272        * The subclass can override this behaviour by overriding
1273        * the ::sink_event() vfunc and not chaining up to the
1274        * parent class' ::sink_event() until a later time.
1275        */
1276       forward_immediate = TRUE;
1277       break;
1278     }
1279     case GST_EVENT_GAP:
1280     {
1281       GstFlowReturn flow_ret = GST_FLOW_OK;
1282       gboolean needs_reconfigure = FALSE;
1283       GList *events;
1284       GList *frame_events;
1285
1286       flow_ret = gst_video_decoder_drain_out (decoder, FALSE);
1287       ret = (flow_ret == GST_FLOW_OK);
1288
1289       /* Ensure we have caps before forwarding the event */
1290       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
1291       if (!decoder->priv->output_state) {
1292         if (!gst_video_decoder_negotiate_default_caps (decoder)) {
1293           GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
1294           GST_ELEMENT_ERROR (decoder, STREAM, FORMAT, (NULL),
1295               ("Decoder output not negotiated before GAP event."));
1296           forward_immediate = TRUE;
1297           break;
1298         }
1299         needs_reconfigure = TRUE;
1300       }
1301
1302       needs_reconfigure = gst_pad_check_reconfigure (decoder->srcpad)
1303           || needs_reconfigure;
1304       if (decoder->priv->output_state_changed || needs_reconfigure) {
1305         if (!gst_video_decoder_negotiate_unlocked (decoder)) {
1306           GST_WARNING_OBJECT (decoder, "Failed to negotiate with downstream");
1307           gst_pad_mark_reconfigure (decoder->srcpad);
1308         }
1309       }
1310
1311       GST_DEBUG_OBJECT (decoder, "Pushing all pending serialized events"
1312           " before the gap");
1313       events = decoder->priv->pending_events;
1314       frame_events = decoder->priv->current_frame_events;
1315       decoder->priv->pending_events = NULL;
1316       decoder->priv->current_frame_events = NULL;
1317
1318       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
1319
1320       gst_video_decoder_push_event_list (decoder, events);
1321       gst_video_decoder_push_event_list (decoder, frame_events);
1322
1323       /* Forward GAP immediately. Everything is drained after
1324        * the GAP event and we can forward this event immediately
1325        * now without having buffers out of order.
1326        */
1327       forward_immediate = TRUE;
1328       break;
1329     }
1330     case GST_EVENT_CUSTOM_DOWNSTREAM:
1331     {
1332       gboolean in_still;
1333       GstFlowReturn flow_ret = GST_FLOW_OK;
1334
1335       if (gst_video_event_parse_still_frame (event, &in_still)) {
1336         if (in_still) {
1337           GST_DEBUG_OBJECT (decoder, "draining current data for still-frame");
1338           flow_ret = gst_video_decoder_drain_out (decoder, FALSE);
1339           ret = (flow_ret == GST_FLOW_OK);
1340         }
1341         /* Forward STILL_FRAME immediately. Everything is drained after
1342          * the STILL_FRAME event and we can forward this event immediately
1343          * now without having buffers out of order.
1344          */
1345         forward_immediate = TRUE;
1346       }
1347       break;
1348     }
1349     case GST_EVENT_SEGMENT:
1350     {
1351       GstSegment segment;
1352
1353       gst_event_copy_segment (event, &segment);
1354
1355       if (segment.format == GST_FORMAT_TIME) {
1356         GST_DEBUG_OBJECT (decoder,
1357             "received TIME SEGMENT %" GST_SEGMENT_FORMAT, &segment);
1358       } else {
1359         gint64 start;
1360
1361         GST_DEBUG_OBJECT (decoder,
1362             "received SEGMENT %" GST_SEGMENT_FORMAT, &segment);
1363
1364         /* handle newsegment as a result from our legacy simple seeking */
1365         /* note that initial 0 should convert to 0 in any case */
1366         if (priv->do_estimate_rate &&
1367             gst_pad_query_convert (decoder->sinkpad, GST_FORMAT_BYTES,
1368                 segment.start, GST_FORMAT_TIME, &start)) {
1369           /* best attempt convert */
1370           /* as these are only estimates, stop is kept open-ended to avoid
1371            * premature cutting */
1372           GST_DEBUG_OBJECT (decoder,
1373               "converted to TIME start %" GST_TIME_FORMAT,
1374               GST_TIME_ARGS (start));
1375           segment.start = start;
1376           segment.stop = GST_CLOCK_TIME_NONE;
1377           segment.time = start;
1378           /* replace event */
1379           gst_event_unref (event);
1380           event = gst_event_new_segment (&segment);
1381         } else {
1382           goto newseg_wrong_format;
1383         }
1384       }
1385
1386       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
1387
1388       priv->base_timestamp = GST_CLOCK_TIME_NONE;
1389       priv->base_picture_number = 0;
1390
1391       decoder->input_segment = segment;
1392       decoder->priv->in_out_segment_sync = FALSE;
1393
1394       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
1395       break;
1396     }
1397     case GST_EVENT_FLUSH_STOP:
1398     {
1399       GList *l;
1400
1401       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
1402       for (l = priv->frames; l; l = l->next) {
1403         GstVideoCodecFrame *frame = l->data;
1404
1405         frame->events = _flush_events (decoder->srcpad, frame->events);
1406       }
1407       priv->current_frame_events = _flush_events (decoder->srcpad,
1408           decoder->priv->current_frame_events);
1409
1410       /* well, this is kind of worse than a DISCONT */
1411       gst_video_decoder_flush (decoder, TRUE);
1412       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
1413       /* Forward FLUSH_STOP immediately. This is required because it is
1414        * expected to be forwarded immediately and no buffers are queued
1415        * anyway.
1416        */
1417       forward_immediate = TRUE;
1418       break;
1419     }
1420     case GST_EVENT_TAG:
1421     {
1422       GstTagList *tags;
1423
1424       gst_event_parse_tag (event, &tags);
1425
1426       if (gst_tag_list_get_scope (tags) == GST_TAG_SCOPE_STREAM) {
1427         GST_VIDEO_DECODER_STREAM_LOCK (decoder);
1428         if (priv->upstream_tags != tags) {
1429           if (priv->upstream_tags)
1430             gst_tag_list_unref (priv->upstream_tags);
1431           priv->upstream_tags = gst_tag_list_ref (tags);
1432           GST_INFO_OBJECT (decoder, "upstream tags: %" GST_PTR_FORMAT, tags);
1433         }
1434         gst_event_unref (event);
1435         event = gst_video_decoder_create_merged_tags_event (decoder);
1436         GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
1437         if (!event)
1438           ret = TRUE;
1439       }
1440       break;
1441     }
1442     default:
1443       break;
1444   }
1445
1446   /* Forward non-serialized events immediately, and all other
1447    * events which can be forwarded immediately without potentially
1448    * causing the event to go out of order with other events and
1449    * buffers as decided above.
1450    */
1451   if (event) {
1452     if (!GST_EVENT_IS_SERIALIZED (event) || forward_immediate) {
1453       ret = gst_video_decoder_push_event (decoder, event);
1454     } else {
1455       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
1456       decoder->priv->current_frame_events =
1457           g_list_prepend (decoder->priv->current_frame_events, event);
1458       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
1459       ret = TRUE;
1460     }
1461   }
1462
1463   return ret;
1464
1465 newseg_wrong_format:
1466   {
1467     GST_DEBUG_OBJECT (decoder, "received non TIME newsegment");
1468     gst_event_unref (event);
1469     /* SWALLOW EVENT */
1470     return TRUE;
1471   }
1472 }
1473
1474 static gboolean
1475 gst_video_decoder_sink_event (GstPad * pad, GstObject * parent,
1476     GstEvent * event)
1477 {
1478   GstVideoDecoder *decoder;
1479   GstVideoDecoderClass *decoder_class;
1480   gboolean ret = FALSE;
1481
1482   decoder = GST_VIDEO_DECODER (parent);
1483   decoder_class = GST_VIDEO_DECODER_GET_CLASS (decoder);
1484
1485   GST_DEBUG_OBJECT (decoder, "received event %d, %s", GST_EVENT_TYPE (event),
1486       GST_EVENT_TYPE_NAME (event));
1487
1488   if (decoder_class->sink_event)
1489     ret = decoder_class->sink_event (decoder, event);
1490
1491   return ret;
1492 }
1493
1494 /* perform upstream byte <-> time conversion (duration, seeking)
1495  * if subclass allows and if enough data for moderately decent conversion */
1496 static inline gboolean
1497 gst_video_decoder_do_byte (GstVideoDecoder * dec)
1498 {
1499   return dec->priv->do_estimate_rate && (dec->priv->bytes_out > 0)
1500       && (dec->priv->time > GST_SECOND);
1501 }
1502
1503 static gboolean
1504 gst_video_decoder_do_seek (GstVideoDecoder * dec, GstEvent * event)
1505 {
1506   GstFormat format;
1507   GstSeekFlags flags;
1508   GstSeekType start_type, end_type;
1509   gdouble rate;
1510   gint64 start, start_time, end_time;
1511   GstSegment seek_segment;
1512   guint32 seqnum;
1513
1514   gst_event_parse_seek (event, &rate, &format, &flags, &start_type,
1515       &start_time, &end_type, &end_time);
1516
1517   /* we'll handle plain open-ended flushing seeks with the simple approach */
1518   if (rate != 1.0) {
1519     GST_DEBUG_OBJECT (dec, "unsupported seek: rate");
1520     return FALSE;
1521   }
1522
1523   if (start_type != GST_SEEK_TYPE_SET) {
1524     GST_DEBUG_OBJECT (dec, "unsupported seek: start time");
1525     return FALSE;
1526   }
1527
1528   if ((end_type != GST_SEEK_TYPE_SET && end_type != GST_SEEK_TYPE_NONE) ||
1529       (end_type == GST_SEEK_TYPE_SET && end_time != GST_CLOCK_TIME_NONE)) {
1530     GST_DEBUG_OBJECT (dec, "unsupported seek: end time");
1531     return FALSE;
1532   }
1533
1534   if (!(flags & GST_SEEK_FLAG_FLUSH)) {
1535     GST_DEBUG_OBJECT (dec, "unsupported seek: not flushing");
1536     return FALSE;
1537   }
1538
1539   memcpy (&seek_segment, &dec->output_segment, sizeof (seek_segment));
1540   gst_segment_do_seek (&seek_segment, rate, format, flags, start_type,
1541       start_time, end_type, end_time, NULL);
1542   start_time = seek_segment.position;
1543
1544   if (!gst_pad_query_convert (dec->sinkpad, GST_FORMAT_TIME, start_time,
1545           GST_FORMAT_BYTES, &start)) {
1546     GST_DEBUG_OBJECT (dec, "conversion failed");
1547     return FALSE;
1548   }
1549
1550   seqnum = gst_event_get_seqnum (event);
1551   event = gst_event_new_seek (1.0, GST_FORMAT_BYTES, flags,
1552       GST_SEEK_TYPE_SET, start, GST_SEEK_TYPE_NONE, -1);
1553   gst_event_set_seqnum (event, seqnum);
1554
1555   GST_DEBUG_OBJECT (dec, "seeking to %" GST_TIME_FORMAT " at byte offset %"
1556       G_GINT64_FORMAT, GST_TIME_ARGS (start_time), start);
1557
1558   return gst_pad_push_event (dec->sinkpad, event);
1559 }
1560
1561 static gboolean
1562 gst_video_decoder_src_event_default (GstVideoDecoder * decoder,
1563     GstEvent * event)
1564 {
1565   GstVideoDecoderPrivate *priv;
1566   gboolean res = FALSE;
1567
1568   priv = decoder->priv;
1569
1570   GST_DEBUG_OBJECT (decoder,
1571       "received event %d, %s", GST_EVENT_TYPE (event),
1572       GST_EVENT_TYPE_NAME (event));
1573
1574   switch (GST_EVENT_TYPE (event)) {
1575     case GST_EVENT_SEEK:
1576     {
1577       GstFormat format;
1578       gdouble rate;
1579       GstSeekFlags flags;
1580       GstSeekType start_type, stop_type;
1581       gint64 start, stop;
1582       gint64 tstart, tstop;
1583       guint32 seqnum;
1584
1585       gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
1586           &stop_type, &stop);
1587       seqnum = gst_event_get_seqnum (event);
1588
1589       /* upstream gets a chance first */
1590       if ((res = gst_pad_push_event (decoder->sinkpad, event)))
1591         break;
1592
1593       /* if upstream fails for a time seek, maybe we can help if allowed */
1594       if (format == GST_FORMAT_TIME) {
1595         if (gst_video_decoder_do_byte (decoder))
1596           res = gst_video_decoder_do_seek (decoder, event);
1597         break;
1598       }
1599
1600       /* ... though a non-time seek can be aided as well */
1601       /* First bring the requested format to time */
1602       if (!(res =
1603               gst_pad_query_convert (decoder->srcpad, format, start,
1604                   GST_FORMAT_TIME, &tstart)))
1605         goto convert_error;
1606       if (!(res =
1607               gst_pad_query_convert (decoder->srcpad, format, stop,
1608                   GST_FORMAT_TIME, &tstop)))
1609         goto convert_error;
1610
1611       /* then seek with time on the peer */
1612       event = gst_event_new_seek (rate, GST_FORMAT_TIME,
1613           flags, start_type, tstart, stop_type, tstop);
1614       gst_event_set_seqnum (event, seqnum);
1615
1616       res = gst_pad_push_event (decoder->sinkpad, event);
1617       break;
1618     }
1619     case GST_EVENT_QOS:
1620     {
1621       GstQOSType type;
1622       gdouble proportion;
1623       GstClockTimeDiff diff;
1624       GstClockTime timestamp;
1625
1626       gst_event_parse_qos (event, &type, &proportion, &diff, &timestamp);
1627
1628       GST_OBJECT_LOCK (decoder);
1629       priv->proportion = proportion;
1630       if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (timestamp))) {
1631         if (G_UNLIKELY (diff > 0)) {
1632           priv->earliest_time = timestamp + 2 * diff + priv->qos_frame_duration;
1633         } else {
1634           priv->earliest_time = timestamp + diff;
1635         }
1636       } else {
1637         priv->earliest_time = GST_CLOCK_TIME_NONE;
1638       }
1639       GST_OBJECT_UNLOCK (decoder);
1640
1641       GST_DEBUG_OBJECT (decoder,
1642           "got QoS %" GST_TIME_FORMAT ", %" GST_STIME_FORMAT ", %g",
1643           GST_TIME_ARGS (timestamp), GST_STIME_ARGS (diff), proportion);
1644
1645       res = gst_pad_push_event (decoder->sinkpad, event);
1646       break;
1647     }
1648     default:
1649       res = gst_pad_push_event (decoder->sinkpad, event);
1650       break;
1651   }
1652 done:
1653   return res;
1654
1655 convert_error:
1656   GST_DEBUG_OBJECT (decoder, "could not convert format");
1657   goto done;
1658 }
1659
1660 static gboolean
1661 gst_video_decoder_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
1662 {
1663   GstVideoDecoder *decoder;
1664   GstVideoDecoderClass *decoder_class;
1665   gboolean ret = FALSE;
1666
1667   decoder = GST_VIDEO_DECODER (parent);
1668   decoder_class = GST_VIDEO_DECODER_GET_CLASS (decoder);
1669
1670   GST_DEBUG_OBJECT (decoder, "received event %d, %s", GST_EVENT_TYPE (event),
1671       GST_EVENT_TYPE_NAME (event));
1672
1673   if (decoder_class->src_event)
1674     ret = decoder_class->src_event (decoder, event);
1675
1676   return ret;
1677 }
1678
1679 static gboolean
1680 gst_video_decoder_src_query_default (GstVideoDecoder * dec, GstQuery * query)
1681 {
1682   GstPad *pad = GST_VIDEO_DECODER_SRC_PAD (dec);
1683   gboolean res = TRUE;
1684
1685   GST_LOG_OBJECT (dec, "handling query: %" GST_PTR_FORMAT, query);
1686
1687   switch (GST_QUERY_TYPE (query)) {
1688     case GST_QUERY_POSITION:
1689     {
1690       GstFormat format;
1691       gint64 time, value;
1692
1693       /* upstream gets a chance first */
1694       if ((res = gst_pad_peer_query (dec->sinkpad, query))) {
1695         GST_LOG_OBJECT (dec, "returning peer response");
1696         break;
1697       }
1698
1699       /* we start from the last seen time */
1700       time = dec->priv->last_timestamp_out;
1701       /* correct for the segment values */
1702       time = gst_segment_to_stream_time (&dec->output_segment,
1703           GST_FORMAT_TIME, time);
1704
1705       GST_LOG_OBJECT (dec,
1706           "query %p: our time: %" GST_TIME_FORMAT, query, GST_TIME_ARGS (time));
1707
1708       /* and convert to the final format */
1709       gst_query_parse_position (query, &format, NULL);
1710       if (!(res = gst_pad_query_convert (pad, GST_FORMAT_TIME, time,
1711                   format, &value)))
1712         break;
1713
1714       gst_query_set_position (query, format, value);
1715
1716       GST_LOG_OBJECT (dec,
1717           "query %p: we return %" G_GINT64_FORMAT " (format %u)", query, value,
1718           format);
1719       break;
1720     }
1721     case GST_QUERY_DURATION:
1722     {
1723       GstFormat format;
1724
1725       /* upstream in any case */
1726       if ((res = gst_pad_query_default (pad, GST_OBJECT (dec), query)))
1727         break;
1728
1729       gst_query_parse_duration (query, &format, NULL);
1730       /* try answering TIME by converting from BYTE if subclass allows  */
1731       if (format == GST_FORMAT_TIME && gst_video_decoder_do_byte (dec)) {
1732         gint64 value;
1733
1734         if (gst_pad_peer_query_duration (dec->sinkpad, GST_FORMAT_BYTES,
1735                 &value)) {
1736           GST_LOG_OBJECT (dec, "upstream size %" G_GINT64_FORMAT, value);
1737           if (gst_pad_query_convert (dec->sinkpad,
1738                   GST_FORMAT_BYTES, value, GST_FORMAT_TIME, &value)) {
1739             gst_query_set_duration (query, GST_FORMAT_TIME, value);
1740             res = TRUE;
1741           }
1742         }
1743       }
1744       break;
1745     }
1746     case GST_QUERY_CONVERT:
1747     {
1748       GstFormat src_fmt, dest_fmt;
1749       gint64 src_val, dest_val;
1750
1751       GST_DEBUG_OBJECT (dec, "convert query");
1752
1753       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
1754       GST_OBJECT_LOCK (dec);
1755       if (dec->priv->output_state != NULL)
1756         res = gst_video_rawvideo_convert (dec->priv->output_state,
1757             src_fmt, src_val, &dest_fmt, &dest_val);
1758       else
1759         res = FALSE;
1760       GST_OBJECT_UNLOCK (dec);
1761       if (!res)
1762         goto error;
1763       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
1764       break;
1765     }
1766     case GST_QUERY_LATENCY:
1767     {
1768       gboolean live;
1769       GstClockTime min_latency, max_latency;
1770
1771       res = gst_pad_peer_query (dec->sinkpad, query);
1772       if (res) {
1773         gst_query_parse_latency (query, &live, &min_latency, &max_latency);
1774         GST_DEBUG_OBJECT (dec, "Peer qlatency: live %d, min %"
1775             GST_TIME_FORMAT " max %" GST_TIME_FORMAT, live,
1776             GST_TIME_ARGS (min_latency), GST_TIME_ARGS (max_latency));
1777
1778         GST_OBJECT_LOCK (dec);
1779         min_latency += dec->priv->min_latency;
1780         if (max_latency == GST_CLOCK_TIME_NONE
1781             || dec->priv->max_latency == GST_CLOCK_TIME_NONE)
1782           max_latency = GST_CLOCK_TIME_NONE;
1783         else
1784           max_latency += dec->priv->max_latency;
1785         GST_OBJECT_UNLOCK (dec);
1786
1787         gst_query_set_latency (query, live, min_latency, max_latency);
1788       }
1789     }
1790       break;
1791     default:
1792       res = gst_pad_query_default (pad, GST_OBJECT (dec), query);
1793   }
1794   return res;
1795
1796 error:
1797   GST_ERROR_OBJECT (dec, "query failed");
1798   return res;
1799 }
1800
1801 static gboolean
1802 gst_video_decoder_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
1803 {
1804   GstVideoDecoder *decoder;
1805   GstVideoDecoderClass *decoder_class;
1806   gboolean ret = FALSE;
1807
1808   decoder = GST_VIDEO_DECODER (parent);
1809   decoder_class = GST_VIDEO_DECODER_GET_CLASS (decoder);
1810
1811   GST_DEBUG_OBJECT (decoder, "received query %d, %s", GST_QUERY_TYPE (query),
1812       GST_QUERY_TYPE_NAME (query));
1813
1814   if (decoder_class->src_query)
1815     ret = decoder_class->src_query (decoder, query);
1816
1817   return ret;
1818 }
1819
1820 /**
1821  * gst_video_decoder_proxy_getcaps:
1822  * @decoder: a #GstVideoDecoder
1823  * @caps: (allow-none): initial caps
1824  * @filter: (allow-none): filter caps
1825  *
1826  * Returns caps that express @caps (or sink template caps if @caps == NULL)
1827  * restricted to resolution/format/... combinations supported by downstream
1828  * elements.
1829  *
1830  * Returns: (transfer full): a #GstCaps owned by caller
1831  *
1832  * Since: 1.6
1833  */
1834 GstCaps *
1835 gst_video_decoder_proxy_getcaps (GstVideoDecoder * decoder, GstCaps * caps,
1836     GstCaps * filter)
1837 {
1838   return __gst_video_element_proxy_getcaps (GST_ELEMENT_CAST (decoder),
1839       GST_VIDEO_DECODER_SINK_PAD (decoder),
1840       GST_VIDEO_DECODER_SRC_PAD (decoder), caps, filter);
1841 }
1842
1843 static GstCaps *
1844 gst_video_decoder_sink_getcaps (GstVideoDecoder * decoder, GstCaps * filter)
1845 {
1846   GstVideoDecoderClass *klass;
1847   GstCaps *caps;
1848
1849   klass = GST_VIDEO_DECODER_GET_CLASS (decoder);
1850
1851   if (klass->getcaps)
1852     caps = klass->getcaps (decoder, filter);
1853   else
1854     caps = gst_video_decoder_proxy_getcaps (decoder, NULL, filter);
1855
1856   GST_LOG_OBJECT (decoder, "Returning caps %" GST_PTR_FORMAT, caps);
1857
1858   return caps;
1859 }
1860
1861 static gboolean
1862 gst_video_decoder_sink_query_default (GstVideoDecoder * decoder,
1863     GstQuery * query)
1864 {
1865   GstPad *pad = GST_VIDEO_DECODER_SINK_PAD (decoder);
1866   GstVideoDecoderPrivate *priv;
1867   gboolean res = FALSE;
1868
1869   priv = decoder->priv;
1870
1871   GST_LOG_OBJECT (decoder, "handling query: %" GST_PTR_FORMAT, query);
1872
1873   switch (GST_QUERY_TYPE (query)) {
1874     case GST_QUERY_CONVERT:
1875     {
1876       GstFormat src_fmt, dest_fmt;
1877       gint64 src_val, dest_val;
1878
1879       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
1880       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
1881       res =
1882           gst_video_encoded_video_convert (priv->bytes_out, priv->time, src_fmt,
1883           src_val, &dest_fmt, &dest_val);
1884       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
1885       if (!res)
1886         goto error;
1887       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
1888       break;
1889     }
1890     case GST_QUERY_ALLOCATION:{
1891       GstVideoDecoderClass *klass = GST_VIDEO_DECODER_GET_CLASS (decoder);
1892
1893       if (klass->propose_allocation)
1894         res = klass->propose_allocation (decoder, query);
1895       break;
1896     }
1897     case GST_QUERY_CAPS:{
1898       GstCaps *filter, *caps;
1899
1900       gst_query_parse_caps (query, &filter);
1901       caps = gst_video_decoder_sink_getcaps (decoder, filter);
1902       gst_query_set_caps_result (query, caps);
1903       gst_caps_unref (caps);
1904       res = TRUE;
1905       break;
1906     }
1907     case GST_QUERY_ACCEPT_CAPS:{
1908       if (decoder->priv->use_default_pad_acceptcaps) {
1909         res =
1910             gst_pad_query_default (GST_VIDEO_DECODER_SINK_PAD (decoder),
1911             GST_OBJECT_CAST (decoder), query);
1912       } else {
1913         GstCaps *caps;
1914         GstCaps *allowed_caps;
1915         GstCaps *template_caps;
1916         gboolean accept;
1917
1918         gst_query_parse_accept_caps (query, &caps);
1919
1920         template_caps = gst_pad_get_pad_template_caps (pad);
1921         accept = gst_caps_is_subset (caps, template_caps);
1922         gst_caps_unref (template_caps);
1923
1924         if (accept) {
1925           allowed_caps =
1926               gst_pad_query_caps (GST_VIDEO_DECODER_SINK_PAD (decoder), caps);
1927
1928           accept = gst_caps_can_intersect (caps, allowed_caps);
1929
1930           gst_caps_unref (allowed_caps);
1931         }
1932
1933         gst_query_set_accept_caps_result (query, accept);
1934         res = TRUE;
1935       }
1936       break;
1937     }
1938     default:
1939       res = gst_pad_query_default (pad, GST_OBJECT (decoder), query);
1940       break;
1941   }
1942 done:
1943
1944   return res;
1945 error:
1946   GST_DEBUG_OBJECT (decoder, "query failed");
1947   goto done;
1948
1949 }
1950
1951 static gboolean
1952 gst_video_decoder_sink_query (GstPad * pad, GstObject * parent,
1953     GstQuery * query)
1954 {
1955   GstVideoDecoder *decoder;
1956   GstVideoDecoderClass *decoder_class;
1957   gboolean ret = FALSE;
1958
1959   decoder = GST_VIDEO_DECODER (parent);
1960   decoder_class = GST_VIDEO_DECODER_GET_CLASS (decoder);
1961
1962   GST_DEBUG_OBJECT (decoder, "received query %d, %s", GST_QUERY_TYPE (query),
1963       GST_QUERY_TYPE_NAME (query));
1964
1965   if (decoder_class->sink_query)
1966     ret = decoder_class->sink_query (decoder, query);
1967
1968   return ret;
1969 }
1970
1971 typedef struct _Timestamp Timestamp;
1972 struct _Timestamp
1973 {
1974   guint64 offset;
1975   GstClockTime pts;
1976   GstClockTime dts;
1977   GstClockTime duration;
1978 };
1979
1980 static void
1981 timestamp_free (Timestamp * ts)
1982 {
1983   g_slice_free (Timestamp, ts);
1984 }
1985
1986 static void
1987 gst_video_decoder_add_timestamp (GstVideoDecoder * decoder, GstBuffer * buffer)
1988 {
1989   GstVideoDecoderPrivate *priv = decoder->priv;
1990   Timestamp *ts;
1991
1992   ts = g_slice_new (Timestamp);
1993
1994   GST_LOG_OBJECT (decoder,
1995       "adding PTS %" GST_TIME_FORMAT " DTS %" GST_TIME_FORMAT
1996       " (offset:%" G_GUINT64_FORMAT ")",
1997       GST_TIME_ARGS (GST_BUFFER_PTS (buffer)),
1998       GST_TIME_ARGS (GST_BUFFER_DTS (buffer)), priv->input_offset);
1999
2000   ts->offset = priv->input_offset;
2001   ts->pts = GST_BUFFER_PTS (buffer);
2002   ts->dts = GST_BUFFER_DTS (buffer);
2003   ts->duration = GST_BUFFER_DURATION (buffer);
2004
2005   priv->timestamps = g_list_append (priv->timestamps, ts);
2006 }
2007
2008 static void
2009 gst_video_decoder_get_timestamp_at_offset (GstVideoDecoder *
2010     decoder, guint64 offset, GstClockTime * pts, GstClockTime * dts,
2011     GstClockTime * duration)
2012 {
2013 #ifndef GST_DISABLE_GST_DEBUG
2014   guint64 got_offset = 0;
2015 #endif
2016   Timestamp *ts;
2017   GList *g;
2018
2019   *pts = GST_CLOCK_TIME_NONE;
2020   *dts = GST_CLOCK_TIME_NONE;
2021   *duration = GST_CLOCK_TIME_NONE;
2022
2023   g = decoder->priv->timestamps;
2024   while (g) {
2025     ts = g->data;
2026     if (ts->offset <= offset) {
2027 #ifndef GST_DISABLE_GST_DEBUG
2028       got_offset = ts->offset;
2029 #endif
2030       *pts = ts->pts;
2031       *dts = ts->dts;
2032       *duration = ts->duration;
2033       g = g->next;
2034       decoder->priv->timestamps = g_list_remove (decoder->priv->timestamps, ts);
2035       timestamp_free (ts);
2036     } else {
2037       break;
2038     }
2039   }
2040
2041   GST_LOG_OBJECT (decoder,
2042       "got PTS %" GST_TIME_FORMAT " DTS %" GST_TIME_FORMAT " @ offs %"
2043       G_GUINT64_FORMAT " (wanted offset:%" G_GUINT64_FORMAT ")",
2044       GST_TIME_ARGS (*pts), GST_TIME_ARGS (*dts), got_offset, offset);
2045 }
2046
2047 static void
2048 gst_video_decoder_clear_queues (GstVideoDecoder * dec)
2049 {
2050   GstVideoDecoderPrivate *priv = dec->priv;
2051
2052   g_list_free_full (priv->output_queued,
2053       (GDestroyNotify) gst_mini_object_unref);
2054   priv->output_queued = NULL;
2055
2056   g_list_free_full (priv->gather, (GDestroyNotify) gst_mini_object_unref);
2057   priv->gather = NULL;
2058   g_list_free_full (priv->decode, (GDestroyNotify) gst_video_codec_frame_unref);
2059   priv->decode = NULL;
2060   g_list_free_full (priv->parse, (GDestroyNotify) gst_mini_object_unref);
2061   priv->parse = NULL;
2062   g_list_free_full (priv->parse_gather,
2063       (GDestroyNotify) gst_video_codec_frame_unref);
2064   priv->parse_gather = NULL;
2065   g_list_free_full (priv->frames, (GDestroyNotify) gst_video_codec_frame_unref);
2066   priv->frames = NULL;
2067 }
2068
2069 static void
2070 gst_video_decoder_reset (GstVideoDecoder * decoder, gboolean full,
2071     gboolean flush_hard)
2072 {
2073   GstVideoDecoderPrivate *priv = decoder->priv;
2074
2075   GST_DEBUG_OBJECT (decoder, "reset full %d", full);
2076
2077   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
2078
2079   if (full || flush_hard) {
2080     gst_segment_init (&decoder->input_segment, GST_FORMAT_UNDEFINED);
2081     gst_segment_init (&decoder->output_segment, GST_FORMAT_UNDEFINED);
2082     gst_video_decoder_clear_queues (decoder);
2083     decoder->priv->in_out_segment_sync = TRUE;
2084
2085     if (priv->current_frame) {
2086       gst_video_codec_frame_unref (priv->current_frame);
2087       priv->current_frame = NULL;
2088     }
2089
2090     g_list_free_full (priv->current_frame_events,
2091         (GDestroyNotify) gst_event_unref);
2092     priv->current_frame_events = NULL;
2093     g_list_free_full (priv->pending_events, (GDestroyNotify) gst_event_unref);
2094     priv->pending_events = NULL;
2095
2096     priv->error_count = 0;
2097     priv->max_errors = GST_VIDEO_DECODER_MAX_ERRORS;
2098     priv->had_output_data = FALSE;
2099     priv->had_input_data = FALSE;
2100
2101     GST_OBJECT_LOCK (decoder);
2102     priv->earliest_time = GST_CLOCK_TIME_NONE;
2103     priv->proportion = 0.5;
2104     GST_OBJECT_UNLOCK (decoder);
2105   }
2106
2107   if (full) {
2108     if (priv->input_state)
2109       gst_video_codec_state_unref (priv->input_state);
2110     priv->input_state = NULL;
2111     GST_OBJECT_LOCK (decoder);
2112     if (priv->output_state)
2113       gst_video_codec_state_unref (priv->output_state);
2114     priv->output_state = NULL;
2115
2116     priv->qos_frame_duration = 0;
2117     GST_OBJECT_UNLOCK (decoder);
2118
2119     if (priv->tags)
2120       gst_tag_list_unref (priv->tags);
2121     priv->tags = NULL;
2122     priv->tags_merge_mode = GST_TAG_MERGE_APPEND;
2123     if (priv->upstream_tags) {
2124       gst_tag_list_unref (priv->upstream_tags);
2125       priv->upstream_tags = NULL;
2126     }
2127     priv->tags_changed = FALSE;
2128     priv->reordered_output = FALSE;
2129
2130     priv->dropped = 0;
2131     priv->processed = 0;
2132
2133     priv->decode_frame_number = 0;
2134     priv->base_picture_number = 0;
2135
2136     if (priv->pool) {
2137       GST_DEBUG_OBJECT (decoder, "deactivate pool %" GST_PTR_FORMAT,
2138           priv->pool);
2139       gst_buffer_pool_set_active (priv->pool, FALSE);
2140       gst_object_unref (priv->pool);
2141       priv->pool = NULL;
2142     }
2143
2144     if (priv->allocator) {
2145       gst_object_unref (priv->allocator);
2146       priv->allocator = NULL;
2147     }
2148   }
2149
2150   priv->discont = TRUE;
2151
2152   priv->base_timestamp = GST_CLOCK_TIME_NONE;
2153   priv->last_timestamp_out = GST_CLOCK_TIME_NONE;
2154   priv->pts_delta = GST_CLOCK_TIME_NONE;
2155
2156   priv->input_offset = 0;
2157   priv->frame_offset = 0;
2158   gst_adapter_clear (priv->input_adapter);
2159   gst_adapter_clear (priv->output_adapter);
2160   g_list_free_full (priv->timestamps, (GDestroyNotify) timestamp_free);
2161   priv->timestamps = NULL;
2162
2163   priv->bytes_out = 0;
2164   priv->time = 0;
2165
2166   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
2167 }
2168
2169 static GstFlowReturn
2170 gst_video_decoder_chain_forward (GstVideoDecoder * decoder,
2171     GstBuffer * buf, gboolean at_eos)
2172 {
2173   GstVideoDecoderPrivate *priv;
2174   GstVideoDecoderClass *klass;
2175   GstFlowReturn ret = GST_FLOW_OK;
2176
2177   klass = GST_VIDEO_DECODER_GET_CLASS (decoder);
2178   priv = decoder->priv;
2179
2180   g_return_val_if_fail (priv->packetized || klass->parse, GST_FLOW_ERROR);
2181
2182   if (priv->current_frame == NULL)
2183     priv->current_frame = gst_video_decoder_new_frame (decoder);
2184
2185   if (GST_BUFFER_PTS_IS_VALID (buf) && !priv->packetized) {
2186     gst_video_decoder_add_timestamp (decoder, buf);
2187   }
2188   priv->input_offset += gst_buffer_get_size (buf);
2189
2190   if (priv->packetized) {
2191     if (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT)) {
2192       GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (priv->current_frame);
2193     }
2194
2195     priv->current_frame->input_buffer = buf;
2196
2197     if (decoder->input_segment.rate < 0.0) {
2198       priv->parse_gather =
2199           g_list_prepend (priv->parse_gather, priv->current_frame);
2200     } else {
2201       ret = gst_video_decoder_decode_frame (decoder, priv->current_frame);
2202     }
2203     priv->current_frame = NULL;
2204   } else {
2205     gst_adapter_push (priv->input_adapter, buf);
2206
2207     ret = gst_video_decoder_parse_available (decoder, at_eos, TRUE);
2208   }
2209
2210   if (ret == GST_VIDEO_DECODER_FLOW_NEED_DATA)
2211     return GST_FLOW_OK;
2212
2213   return ret;
2214 }
2215
2216 static GstFlowReturn
2217 gst_video_decoder_flush_decode (GstVideoDecoder * dec)
2218 {
2219   GstVideoDecoderPrivate *priv = dec->priv;
2220   GstFlowReturn res = GST_FLOW_OK;
2221   GList *walk;
2222
2223   GST_DEBUG_OBJECT (dec, "flushing buffers to decode");
2224
2225   walk = priv->decode;
2226   while (walk) {
2227     GList *next;
2228     GstVideoCodecFrame *frame = (GstVideoCodecFrame *) (walk->data);
2229
2230     GST_DEBUG_OBJECT (dec, "decoding frame %p buffer %p, PTS %" GST_TIME_FORMAT
2231         ", DTS %" GST_TIME_FORMAT, frame, frame->input_buffer,
2232         GST_TIME_ARGS (GST_BUFFER_PTS (frame->input_buffer)),
2233         GST_TIME_ARGS (GST_BUFFER_DTS (frame->input_buffer)));
2234
2235     next = walk->next;
2236
2237     priv->decode = g_list_delete_link (priv->decode, walk);
2238
2239     /* decode buffer, resulting data prepended to queue */
2240     res = gst_video_decoder_decode_frame (dec, frame);
2241     if (res != GST_FLOW_OK)
2242       break;
2243
2244     walk = next;
2245   }
2246
2247   return res;
2248 }
2249
2250 /* gst_video_decoder_flush_parse is called from the
2251  * chain_reverse() function when a buffer containing
2252  * a DISCONT - indicating that reverse playback
2253  * looped back to the next data block, and therefore
2254  * all available data should be fed through the
2255  * decoder and frames gathered for reversed output
2256  */
2257 static GstFlowReturn
2258 gst_video_decoder_flush_parse (GstVideoDecoder * dec, gboolean at_eos)
2259 {
2260   GstVideoDecoderPrivate *priv = dec->priv;
2261   GstFlowReturn res = GST_FLOW_OK;
2262   GList *walk;
2263   GstVideoDecoderClass *decoder_class;
2264
2265   decoder_class = GST_VIDEO_DECODER_GET_CLASS (dec);
2266
2267   GST_DEBUG_OBJECT (dec, "flushing buffers to parsing");
2268
2269   /* Reverse the gather list, and prepend it to the parse list,
2270    * then flush to parse whatever we can */
2271   priv->gather = g_list_reverse (priv->gather);
2272   priv->parse = g_list_concat (priv->gather, priv->parse);
2273   priv->gather = NULL;
2274
2275   /* clear buffer and decoder state */
2276   gst_video_decoder_flush (dec, FALSE);
2277
2278   walk = priv->parse;
2279   while (walk) {
2280     GstBuffer *buf = GST_BUFFER_CAST (walk->data);
2281     GList *next = walk->next;
2282
2283     GST_DEBUG_OBJECT (dec, "parsing buffer %p, PTS %" GST_TIME_FORMAT
2284         ", DTS %" GST_TIME_FORMAT, buf, GST_TIME_ARGS (GST_BUFFER_PTS (buf)),
2285         GST_TIME_ARGS (GST_BUFFER_DTS (buf)));
2286
2287     /* parse buffer, resulting frames prepended to parse_gather queue */
2288     gst_buffer_ref (buf);
2289     res = gst_video_decoder_chain_forward (dec, buf, at_eos);
2290
2291     /* if we generated output, we can discard the buffer, else we
2292      * keep it in the queue */
2293     if (priv->parse_gather) {
2294       GST_DEBUG_OBJECT (dec, "parsed buffer to %p", priv->parse_gather->data);
2295       priv->parse = g_list_delete_link (priv->parse, walk);
2296       gst_buffer_unref (buf);
2297     } else {
2298       GST_DEBUG_OBJECT (dec, "buffer did not decode, keeping");
2299     }
2300     walk = next;
2301   }
2302
2303   walk = priv->parse_gather;
2304   while (walk) {
2305     GstVideoCodecFrame *frame = (GstVideoCodecFrame *) (walk->data);
2306     GList *walk2;
2307
2308     /* this is reverse playback, check if we need to apply some segment
2309      * to the output before decoding, as during decoding the segment.rate
2310      * must be used to determine if a buffer should be pushed or added to
2311      * the output list for reverse pushing.
2312      *
2313      * The new segment is not immediately pushed here because we must
2314      * wait for negotiation to happen before it can be pushed to avoid
2315      * pushing a segment before caps event. Negotiation only happens
2316      * when finish_frame is called.
2317      */
2318     for (walk2 = frame->events; walk2;) {
2319       GList *cur = walk2;
2320       GstEvent *event = walk2->data;
2321
2322       walk2 = g_list_next (walk2);
2323       if (GST_EVENT_TYPE (event) <= GST_EVENT_SEGMENT) {
2324
2325         if (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) {
2326           GstSegment segment;
2327
2328           GST_DEBUG_OBJECT (dec, "Segment at frame %p %" GST_TIME_FORMAT,
2329               frame, GST_TIME_ARGS (GST_BUFFER_PTS (frame->input_buffer)));
2330           gst_event_copy_segment (event, &segment);
2331           if (segment.format == GST_FORMAT_TIME) {
2332             dec->output_segment = segment;
2333             dec->priv->in_out_segment_sync =
2334                 gst_segment_is_equal (&dec->input_segment, &segment);
2335           }
2336         }
2337         dec->priv->pending_events =
2338             g_list_append (dec->priv->pending_events, event);
2339         frame->events = g_list_delete_link (frame->events, cur);
2340       }
2341     }
2342
2343     walk = walk->next;
2344   }
2345
2346   /* now we can process frames. Start by moving each frame from the parse_gather
2347    * to the decode list, reverse the order as we go, and stopping when/if we
2348    * copy a keyframe. */
2349   GST_DEBUG_OBJECT (dec, "checking parsed frames for a keyframe to decode");
2350   walk = priv->parse_gather;
2351   while (walk) {
2352     GstVideoCodecFrame *frame = (GstVideoCodecFrame *) (walk->data);
2353
2354     /* remove from the gather list */
2355     priv->parse_gather = g_list_remove_link (priv->parse_gather, walk);
2356
2357     /* move it to the front of the decode queue */
2358     priv->decode = g_list_concat (walk, priv->decode);
2359
2360     /* if we copied a keyframe, flush and decode the decode queue */
2361     if (GST_VIDEO_CODEC_FRAME_IS_SYNC_POINT (frame)) {
2362       GST_DEBUG_OBJECT (dec, "found keyframe %p with PTS %" GST_TIME_FORMAT
2363           ", DTS %" GST_TIME_FORMAT, frame,
2364           GST_TIME_ARGS (GST_BUFFER_PTS (frame->input_buffer)),
2365           GST_TIME_ARGS (GST_BUFFER_DTS (frame->input_buffer)));
2366       res = gst_video_decoder_flush_decode (dec);
2367       if (res != GST_FLOW_OK)
2368         goto done;
2369
2370       /* We need to tell the subclass to drain now.
2371        * We prefer the drain vfunc, but for backward-compat
2372        * we use a finish() vfunc if drain isn't implemented */
2373       if (decoder_class->drain) {
2374         GST_DEBUG_OBJECT (dec, "Draining");
2375         res = decoder_class->drain (dec);
2376       } else if (decoder_class->finish) {
2377         GST_FIXME_OBJECT (dec, "Sub-class should implement drain(). "
2378             "Calling finish() for backwards-compat");
2379         res = decoder_class->finish (dec);
2380       }
2381
2382       if (res != GST_FLOW_OK)
2383         goto done;
2384
2385       /* now send queued data downstream */
2386       walk = priv->output_queued;
2387       while (walk) {
2388         GstBuffer *buf = GST_BUFFER_CAST (walk->data);
2389
2390         if (G_LIKELY (res == GST_FLOW_OK)) {
2391           /* avoid stray DISCONT from forward processing,
2392            * which have no meaning in reverse pushing */
2393           GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
2394
2395           /* Last chance to calculate a timestamp as we loop backwards
2396            * through the list */
2397           if (GST_BUFFER_TIMESTAMP (buf) != GST_CLOCK_TIME_NONE)
2398             priv->last_timestamp_out = GST_BUFFER_TIMESTAMP (buf);
2399           else if (priv->last_timestamp_out != GST_CLOCK_TIME_NONE &&
2400               GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE) {
2401             GST_BUFFER_TIMESTAMP (buf) =
2402                 priv->last_timestamp_out - GST_BUFFER_DURATION (buf);
2403             priv->last_timestamp_out = GST_BUFFER_TIMESTAMP (buf);
2404             GST_LOG_OBJECT (dec,
2405                 "Calculated TS %" GST_TIME_FORMAT " working backwards",
2406                 GST_TIME_ARGS (priv->last_timestamp_out));
2407           }
2408
2409           res = gst_video_decoder_clip_and_push_buf (dec, buf);
2410         } else {
2411           gst_buffer_unref (buf);
2412         }
2413
2414         priv->output_queued =
2415             g_list_delete_link (priv->output_queued, priv->output_queued);
2416         walk = priv->output_queued;
2417       }
2418
2419       /* clear buffer and decoder state again
2420        * before moving to the previous keyframe */
2421       gst_video_decoder_flush (dec, FALSE);
2422     }
2423
2424     walk = priv->parse_gather;
2425   }
2426
2427 done:
2428   return res;
2429 }
2430
2431 static GstFlowReturn
2432 gst_video_decoder_chain_reverse (GstVideoDecoder * dec, GstBuffer * buf)
2433 {
2434   GstVideoDecoderPrivate *priv = dec->priv;
2435   GstFlowReturn result = GST_FLOW_OK;
2436
2437   /* if we have a discont, move buffers to the decode list */
2438   if (!buf || GST_BUFFER_IS_DISCONT (buf)) {
2439     GST_DEBUG_OBJECT (dec, "received discont");
2440
2441     /* parse and decode stuff in the gather and parse queues */
2442     result = gst_video_decoder_flush_parse (dec, FALSE);
2443   }
2444
2445   if (G_LIKELY (buf)) {
2446     GST_DEBUG_OBJECT (dec, "gathering buffer %p of size %" G_GSIZE_FORMAT ", "
2447         "PTS %" GST_TIME_FORMAT ", DTS %" GST_TIME_FORMAT ", dur %"
2448         GST_TIME_FORMAT, buf, gst_buffer_get_size (buf),
2449         GST_TIME_ARGS (GST_BUFFER_PTS (buf)),
2450         GST_TIME_ARGS (GST_BUFFER_DTS (buf)),
2451         GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
2452
2453     /* add buffer to gather queue */
2454     priv->gather = g_list_prepend (priv->gather, buf);
2455   }
2456
2457   return result;
2458 }
2459
2460 static GstFlowReturn
2461 gst_video_decoder_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
2462 {
2463   GstVideoDecoder *decoder;
2464   GstFlowReturn ret = GST_FLOW_OK;
2465
2466   decoder = GST_VIDEO_DECODER (parent);
2467
2468   if (G_UNLIKELY (!decoder->priv->input_state && decoder->priv->needs_format))
2469     goto not_negotiated;
2470
2471   GST_LOG_OBJECT (decoder,
2472       "chain PTS %" GST_TIME_FORMAT ", DTS %" GST_TIME_FORMAT " duration %"
2473       GST_TIME_FORMAT " size %" G_GSIZE_FORMAT,
2474       GST_TIME_ARGS (GST_BUFFER_PTS (buf)),
2475       GST_TIME_ARGS (GST_BUFFER_DTS (buf)),
2476       GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), gst_buffer_get_size (buf));
2477
2478   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
2479
2480   /* NOTE:
2481    * requiring the pad to be negotiated makes it impossible to use
2482    * oggdemux or filesrc ! decoder */
2483
2484   if (decoder->input_segment.format == GST_FORMAT_UNDEFINED) {
2485     GstEvent *event;
2486     GstSegment *segment = &decoder->input_segment;
2487
2488     GST_WARNING_OBJECT (decoder,
2489         "Received buffer without a new-segment. "
2490         "Assuming timestamps start from 0.");
2491
2492     gst_segment_init (segment, GST_FORMAT_TIME);
2493
2494     event = gst_event_new_segment (segment);
2495
2496     decoder->priv->current_frame_events =
2497         g_list_prepend (decoder->priv->current_frame_events, event);
2498   }
2499
2500   decoder->priv->had_input_data = TRUE;
2501
2502   if (decoder->input_segment.rate > 0.0)
2503     ret = gst_video_decoder_chain_forward (decoder, buf, FALSE);
2504   else
2505     ret = gst_video_decoder_chain_reverse (decoder, buf);
2506
2507   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
2508   return ret;
2509
2510   /* ERRORS */
2511 not_negotiated:
2512   {
2513     GST_ELEMENT_ERROR (decoder, CORE, NEGOTIATION, (NULL),
2514         ("decoder not initialized"));
2515     gst_buffer_unref (buf);
2516     return GST_FLOW_NOT_NEGOTIATED;
2517   }
2518 }
2519
2520 static GstStateChangeReturn
2521 gst_video_decoder_change_state (GstElement * element, GstStateChange transition)
2522 {
2523   GstVideoDecoder *decoder;
2524   GstVideoDecoderClass *decoder_class;
2525   GstStateChangeReturn ret;
2526
2527   decoder = GST_VIDEO_DECODER (element);
2528   decoder_class = GST_VIDEO_DECODER_GET_CLASS (element);
2529
2530   switch (transition) {
2531     case GST_STATE_CHANGE_NULL_TO_READY:
2532       /* open device/library if needed */
2533       if (decoder_class->open && !decoder_class->open (decoder))
2534         goto open_failed;
2535       break;
2536     case GST_STATE_CHANGE_READY_TO_PAUSED:
2537       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
2538       gst_video_decoder_reset (decoder, TRUE, TRUE);
2539       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
2540
2541       /* Initialize device/library if needed */
2542       if (decoder_class->start && !decoder_class->start (decoder))
2543         goto start_failed;
2544       break;
2545     default:
2546       break;
2547   }
2548
2549   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
2550
2551   switch (transition) {
2552     case GST_STATE_CHANGE_PAUSED_TO_READY:{
2553       gboolean stopped = TRUE;
2554
2555       if (decoder_class->stop)
2556         stopped = decoder_class->stop (decoder);
2557
2558       GST_VIDEO_DECODER_STREAM_LOCK (decoder);
2559       gst_video_decoder_reset (decoder, TRUE, TRUE);
2560       GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
2561
2562       if (!stopped)
2563         goto stop_failed;
2564
2565       break;
2566     }
2567     case GST_STATE_CHANGE_READY_TO_NULL:
2568       /* close device/library if needed */
2569       if (decoder_class->close && !decoder_class->close (decoder))
2570         goto close_failed;
2571       break;
2572     default:
2573       break;
2574   }
2575
2576   return ret;
2577
2578   /* Errors */
2579 open_failed:
2580   {
2581     GST_ELEMENT_ERROR (decoder, LIBRARY, INIT, (NULL),
2582         ("Failed to open decoder"));
2583     return GST_STATE_CHANGE_FAILURE;
2584   }
2585
2586 start_failed:
2587   {
2588     GST_ELEMENT_ERROR (decoder, LIBRARY, INIT, (NULL),
2589         ("Failed to start decoder"));
2590     return GST_STATE_CHANGE_FAILURE;
2591   }
2592
2593 stop_failed:
2594   {
2595     GST_ELEMENT_ERROR (decoder, LIBRARY, INIT, (NULL),
2596         ("Failed to stop decoder"));
2597     return GST_STATE_CHANGE_FAILURE;
2598   }
2599
2600 close_failed:
2601   {
2602     GST_ELEMENT_ERROR (decoder, LIBRARY, INIT, (NULL),
2603         ("Failed to close decoder"));
2604     return GST_STATE_CHANGE_FAILURE;
2605   }
2606 }
2607
2608 static GstVideoCodecFrame *
2609 gst_video_decoder_new_frame (GstVideoDecoder * decoder)
2610 {
2611   GstVideoDecoderPrivate *priv = decoder->priv;
2612   GstVideoCodecFrame *frame;
2613
2614   frame = g_slice_new0 (GstVideoCodecFrame);
2615
2616   frame->ref_count = 1;
2617
2618   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
2619   frame->system_frame_number = priv->system_frame_number;
2620   priv->system_frame_number++;
2621   frame->decode_frame_number = priv->decode_frame_number;
2622   priv->decode_frame_number++;
2623
2624   frame->dts = GST_CLOCK_TIME_NONE;
2625   frame->pts = GST_CLOCK_TIME_NONE;
2626   frame->duration = GST_CLOCK_TIME_NONE;
2627   frame->events = priv->current_frame_events;
2628   priv->current_frame_events = NULL;
2629
2630   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
2631
2632   GST_LOG_OBJECT (decoder, "Created new frame %p (sfn:%d)",
2633       frame, frame->system_frame_number);
2634
2635   return frame;
2636 }
2637
2638 static void
2639 gst_video_decoder_push_event_list (GstVideoDecoder * decoder, GList * events)
2640 {
2641   GList *l;
2642
2643   /* events are stored in reverse order */
2644   for (l = g_list_last (events); l; l = g_list_previous (l)) {
2645     GST_LOG_OBJECT (decoder, "pushing %s event", GST_EVENT_TYPE_NAME (l->data));
2646     gst_video_decoder_push_event (decoder, l->data);
2647   }
2648   g_list_free (events);
2649 }
2650
2651 static void
2652 gst_video_decoder_prepare_finish_frame (GstVideoDecoder *
2653     decoder, GstVideoCodecFrame * frame, gboolean dropping)
2654 {
2655   GstVideoDecoderPrivate *priv = decoder->priv;
2656   GList *l, *events = NULL;
2657   gboolean sync;
2658
2659 #ifndef GST_DISABLE_GST_DEBUG
2660   GST_LOG_OBJECT (decoder, "n %d in %" G_GSIZE_FORMAT " out %" G_GSIZE_FORMAT,
2661       g_list_length (priv->frames),
2662       gst_adapter_available (priv->input_adapter),
2663       gst_adapter_available (priv->output_adapter));
2664 #endif
2665
2666   sync = GST_VIDEO_CODEC_FRAME_IS_SYNC_POINT (frame);
2667
2668   GST_LOG_OBJECT (decoder,
2669       "finish frame %p (#%d) sync:%d PTS:%" GST_TIME_FORMAT " DTS:%"
2670       GST_TIME_FORMAT,
2671       frame, frame->system_frame_number,
2672       sync, GST_TIME_ARGS (frame->pts), GST_TIME_ARGS (frame->dts));
2673
2674   /* Push all pending events that arrived before this frame */
2675   for (l = priv->frames; l; l = l->next) {
2676     GstVideoCodecFrame *tmp = l->data;
2677
2678     if (tmp->events) {
2679       events = g_list_concat (events, tmp->events);
2680       tmp->events = NULL;
2681     }
2682
2683     if (tmp == frame)
2684       break;
2685   }
2686
2687   if (dropping || !decoder->priv->output_state) {
2688     /* Push before the next frame that is not dropped */
2689     decoder->priv->pending_events =
2690         g_list_concat (decoder->priv->pending_events, events);
2691   } else {
2692     gst_video_decoder_push_event_list (decoder, decoder->priv->pending_events);
2693     decoder->priv->pending_events = NULL;
2694
2695     gst_video_decoder_push_event_list (decoder, events);
2696   }
2697
2698   /* Check if the data should not be displayed. For example altref/invisible
2699    * frame in vp8. In this case we should not update the timestamps. */
2700   if (GST_VIDEO_CODEC_FRAME_IS_DECODE_ONLY (frame))
2701     return;
2702
2703   /* If the frame is meant to be output but we don't have an output_buffer
2704    * we have a problem :) */
2705   if (G_UNLIKELY ((frame->output_buffer == NULL) && !dropping))
2706     goto no_output_buffer;
2707
2708   if (GST_CLOCK_TIME_IS_VALID (frame->pts)) {
2709     if (frame->pts != priv->base_timestamp) {
2710       GST_DEBUG_OBJECT (decoder,
2711           "sync timestamp %" GST_TIME_FORMAT " diff %" GST_STIME_FORMAT,
2712           GST_TIME_ARGS (frame->pts),
2713           GST_STIME_ARGS (GST_CLOCK_DIFF (frame->pts,
2714                   decoder->output_segment.start)));
2715       priv->base_timestamp = frame->pts;
2716       priv->base_picture_number = frame->decode_frame_number;
2717     }
2718   }
2719
2720   if (frame->duration == GST_CLOCK_TIME_NONE) {
2721     frame->duration = gst_video_decoder_get_frame_duration (decoder, frame);
2722     GST_LOG_OBJECT (decoder,
2723         "Guessing duration %" GST_TIME_FORMAT " for frame...",
2724         GST_TIME_ARGS (frame->duration));
2725   }
2726
2727   /* PTS is expected montone ascending,
2728    * so a good guess is lowest unsent DTS */
2729   {
2730     GstClockTime min_ts = GST_CLOCK_TIME_NONE;
2731     GstVideoCodecFrame *oframe = NULL;
2732     gboolean seen_none = FALSE;
2733
2734     /* some maintenance regardless */
2735     for (l = priv->frames; l; l = l->next) {
2736       GstVideoCodecFrame *tmp = l->data;
2737
2738       if (!GST_CLOCK_TIME_IS_VALID (tmp->abidata.ABI.ts)) {
2739         seen_none = TRUE;
2740         continue;
2741       }
2742
2743       if (!GST_CLOCK_TIME_IS_VALID (min_ts) || tmp->abidata.ABI.ts < min_ts) {
2744         min_ts = tmp->abidata.ABI.ts;
2745         oframe = tmp;
2746       }
2747     }
2748     /* save a ts if needed */
2749     if (oframe && oframe != frame) {
2750       oframe->abidata.ABI.ts = frame->abidata.ABI.ts;
2751     }
2752
2753     /* and set if needed;
2754      * valid delta means we have reasonable DTS input */
2755     /* also, if we ended up reordered, means this approach is conflicting
2756      * with some sparse existing PTS, and so it does not work out */
2757     if (!priv->reordered_output &&
2758         !GST_CLOCK_TIME_IS_VALID (frame->pts) && !seen_none &&
2759         GST_CLOCK_TIME_IS_VALID (priv->pts_delta)) {
2760       frame->pts = min_ts + priv->pts_delta;
2761       GST_DEBUG_OBJECT (decoder,
2762           "no valid PTS, using oldest DTS %" GST_TIME_FORMAT,
2763           GST_TIME_ARGS (frame->pts));
2764     }
2765
2766     /* some more maintenance, ts2 holds PTS */
2767     min_ts = GST_CLOCK_TIME_NONE;
2768     seen_none = FALSE;
2769     for (l = priv->frames; l; l = l->next) {
2770       GstVideoCodecFrame *tmp = l->data;
2771
2772       if (!GST_CLOCK_TIME_IS_VALID (tmp->abidata.ABI.ts2)) {
2773         seen_none = TRUE;
2774         continue;
2775       }
2776
2777       if (!GST_CLOCK_TIME_IS_VALID (min_ts) || tmp->abidata.ABI.ts2 < min_ts) {
2778         min_ts = tmp->abidata.ABI.ts2;
2779         oframe = tmp;
2780       }
2781     }
2782     /* save a ts if needed */
2783     if (oframe && oframe != frame) {
2784       oframe->abidata.ABI.ts2 = frame->abidata.ABI.ts2;
2785     }
2786
2787     /* if we detected reordered output, then PTS are void,
2788      * however those were obtained; bogus input, subclass etc */
2789     if (priv->reordered_output && !seen_none) {
2790       GST_DEBUG_OBJECT (decoder, "invalidating PTS");
2791       frame->pts = GST_CLOCK_TIME_NONE;
2792     }
2793
2794     if (!GST_CLOCK_TIME_IS_VALID (frame->pts) && !seen_none) {
2795       frame->pts = min_ts;
2796       GST_DEBUG_OBJECT (decoder,
2797           "no valid PTS, using oldest PTS %" GST_TIME_FORMAT,
2798           GST_TIME_ARGS (frame->pts));
2799     }
2800   }
2801
2802
2803   if (frame->pts == GST_CLOCK_TIME_NONE) {
2804     /* Last ditch timestamp guess: Just add the duration to the previous
2805      * frame. If it's the first frame, just use the segment start. */
2806     if (frame->duration != GST_CLOCK_TIME_NONE) {
2807       if (GST_CLOCK_TIME_IS_VALID (priv->last_timestamp_out))
2808         frame->pts = priv->last_timestamp_out + frame->duration;
2809       else
2810         frame->pts = decoder->output_segment.start;
2811       GST_LOG_OBJECT (decoder,
2812           "Guessing timestamp %" GST_TIME_FORMAT " for frame...",
2813           GST_TIME_ARGS (frame->pts));
2814     } else if (sync && frame->dts != GST_CLOCK_TIME_NONE) {
2815       frame->pts = frame->dts;
2816       GST_LOG_OBJECT (decoder,
2817           "Setting DTS as PTS %" GST_TIME_FORMAT " for frame...",
2818           GST_TIME_ARGS (frame->pts));
2819     }
2820   }
2821
2822   if (GST_CLOCK_TIME_IS_VALID (priv->last_timestamp_out)) {
2823     if (frame->pts < priv->last_timestamp_out) {
2824       GST_WARNING_OBJECT (decoder,
2825           "decreasing timestamp (%" GST_TIME_FORMAT " < %"
2826           GST_TIME_FORMAT ")",
2827           GST_TIME_ARGS (frame->pts), GST_TIME_ARGS (priv->last_timestamp_out));
2828       priv->reordered_output = TRUE;
2829       /* make it a bit less weird downstream */
2830       frame->pts = priv->last_timestamp_out;
2831     }
2832   }
2833
2834   if (GST_CLOCK_TIME_IS_VALID (frame->pts))
2835     priv->last_timestamp_out = frame->pts;
2836
2837   return;
2838
2839   /* ERRORS */
2840 no_output_buffer:
2841   {
2842     GST_ERROR_OBJECT (decoder, "No buffer to output !");
2843   }
2844 }
2845
2846 /**
2847  * gst_video_decoder_release_frame:
2848  * @dec: a #GstVideoDecoder
2849  * @frame: (transfer full): the #GstVideoCodecFrame to release
2850  *
2851  * Similar to gst_video_decoder_drop_frame(), but simply releases @frame
2852  * without any processing other than removing it from list of pending frames,
2853  * after which it is considered finished and released.
2854  *
2855  * Since: 1.2.2
2856  */
2857 void
2858 gst_video_decoder_release_frame (GstVideoDecoder * dec,
2859     GstVideoCodecFrame * frame)
2860 {
2861   GList *link;
2862
2863   /* unref once from the list */
2864   GST_VIDEO_DECODER_STREAM_LOCK (dec);
2865   link = g_list_find (dec->priv->frames, frame);
2866   if (link) {
2867     gst_video_codec_frame_unref (frame);
2868     dec->priv->frames = g_list_delete_link (dec->priv->frames, link);
2869   }
2870   if (frame->events) {
2871     dec->priv->pending_events =
2872         g_list_concat (dec->priv->pending_events, frame->events);
2873     frame->events = NULL;
2874   }
2875   GST_VIDEO_DECODER_STREAM_UNLOCK (dec);
2876
2877   /* unref because this function takes ownership */
2878   gst_video_codec_frame_unref (frame);
2879 }
2880
2881 /**
2882  * gst_video_decoder_drop_frame:
2883  * @dec: a #GstVideoDecoder
2884  * @frame: (transfer full): the #GstVideoCodecFrame to drop
2885  *
2886  * Similar to gst_video_decoder_finish_frame(), but drops @frame in any
2887  * case and posts a QoS message with the frame's details on the bus.
2888  * In any case, the frame is considered finished and released.
2889  *
2890  * Returns: a #GstFlowReturn, usually GST_FLOW_OK.
2891  */
2892 GstFlowReturn
2893 gst_video_decoder_drop_frame (GstVideoDecoder * dec, GstVideoCodecFrame * frame)
2894 {
2895   GstClockTime stream_time, jitter, earliest_time, qostime, timestamp;
2896   GstSegment *segment;
2897   GstMessage *qos_msg;
2898   gdouble proportion;
2899
2900   GST_LOG_OBJECT (dec, "drop frame %p", frame);
2901
2902   GST_VIDEO_DECODER_STREAM_LOCK (dec);
2903
2904   gst_video_decoder_prepare_finish_frame (dec, frame, TRUE);
2905
2906   GST_DEBUG_OBJECT (dec, "dropping frame %" GST_TIME_FORMAT,
2907       GST_TIME_ARGS (frame->pts));
2908
2909   dec->priv->dropped++;
2910
2911   /* post QoS message */
2912   GST_OBJECT_LOCK (dec);
2913   proportion = dec->priv->proportion;
2914   earliest_time = dec->priv->earliest_time;
2915   GST_OBJECT_UNLOCK (dec);
2916
2917   timestamp = frame->pts;
2918   segment = &dec->output_segment;
2919   if (G_UNLIKELY (segment->format == GST_FORMAT_UNDEFINED))
2920     segment = &dec->input_segment;
2921   stream_time =
2922       gst_segment_to_stream_time (segment, GST_FORMAT_TIME, timestamp);
2923   qostime = gst_segment_to_running_time (segment, GST_FORMAT_TIME, timestamp);
2924   jitter = GST_CLOCK_DIFF (qostime, earliest_time);
2925   qos_msg =
2926       gst_message_new_qos (GST_OBJECT_CAST (dec), FALSE, qostime, stream_time,
2927       timestamp, GST_CLOCK_TIME_NONE);
2928   gst_message_set_qos_values (qos_msg, jitter, proportion, 1000000);
2929   gst_message_set_qos_stats (qos_msg, GST_FORMAT_BUFFERS,
2930       dec->priv->processed, dec->priv->dropped);
2931   gst_element_post_message (GST_ELEMENT_CAST (dec), qos_msg);
2932
2933   /* now free the frame */
2934   gst_video_decoder_release_frame (dec, frame);
2935
2936   GST_VIDEO_DECODER_STREAM_UNLOCK (dec);
2937
2938   return GST_FLOW_OK;
2939 }
2940
2941 static gboolean
2942 gst_video_decoder_transform_meta_default (GstVideoDecoder *
2943     decoder, GstVideoCodecFrame * frame, GstMeta * meta)
2944 {
2945   const GstMetaInfo *info = meta->info;
2946   const gchar *const *tags;
2947
2948   tags = gst_meta_api_type_get_tags (info->api);
2949
2950   if (!tags || (g_strv_length ((gchar **) tags) == 1
2951           && gst_meta_api_type_has_tag (info->api,
2952               g_quark_from_string (GST_META_TAG_VIDEO_STR))))
2953     return TRUE;
2954
2955   return FALSE;
2956 }
2957
2958 typedef struct
2959 {
2960   GstVideoDecoder *decoder;
2961   GstVideoCodecFrame *frame;
2962 } CopyMetaData;
2963
2964 static gboolean
2965 foreach_metadata (GstBuffer * inbuf, GstMeta ** meta, gpointer user_data)
2966 {
2967   CopyMetaData *data = user_data;
2968   GstVideoDecoder *decoder = data->decoder;
2969   GstVideoDecoderClass *klass = GST_VIDEO_DECODER_GET_CLASS (decoder);
2970   GstVideoCodecFrame *frame = data->frame;
2971   const GstMetaInfo *info = (*meta)->info;
2972   gboolean do_copy = FALSE;
2973
2974   if (gst_meta_api_type_has_tag (info->api, _gst_meta_tag_memory)) {
2975     /* never call the transform_meta with memory specific metadata */
2976     GST_DEBUG_OBJECT (decoder, "not copying memory specific metadata %s",
2977         g_type_name (info->api));
2978     do_copy = FALSE;
2979   } else if (klass->transform_meta) {
2980     do_copy = klass->transform_meta (decoder, frame, *meta);
2981     GST_DEBUG_OBJECT (decoder, "transformed metadata %s: copy: %d",
2982         g_type_name (info->api), do_copy);
2983   }
2984
2985   /* we only copy metadata when the subclass implemented a transform_meta
2986    * function and when it returns %TRUE */
2987   if (do_copy) {
2988     GstMetaTransformCopy copy_data = { FALSE, 0, -1 };
2989     GST_DEBUG_OBJECT (decoder, "copy metadata %s", g_type_name (info->api));
2990     /* simply copy then */
2991     info->transform_func (frame->output_buffer, *meta, inbuf,
2992         _gst_meta_transform_copy, &copy_data);
2993   }
2994   return TRUE;
2995 }
2996
2997 /**
2998  * gst_video_decoder_finish_frame:
2999  * @decoder: a #GstVideoDecoder
3000  * @frame: (transfer full): a decoded #GstVideoCodecFrame
3001  *
3002  * @frame should have a valid decoded data buffer, whose metadata fields
3003  * are then appropriately set according to frame data and pushed downstream.
3004  * If no output data is provided, @frame is considered skipped.
3005  * In any case, the frame is considered finished and released.
3006  *
3007  * After calling this function the output buffer of the frame is to be
3008  * considered read-only. This function will also change the metadata
3009  * of the buffer.
3010  *
3011  * Returns: a #GstFlowReturn resulting from sending data downstream
3012  */
3013 GstFlowReturn
3014 gst_video_decoder_finish_frame (GstVideoDecoder * decoder,
3015     GstVideoCodecFrame * frame)
3016 {
3017   GstFlowReturn ret = GST_FLOW_OK;
3018   GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_GET_CLASS (decoder);
3019   GstVideoDecoderPrivate *priv = decoder->priv;
3020   GstBuffer *output_buffer;
3021   gboolean needs_reconfigure = FALSE;
3022
3023   GST_LOG_OBJECT (decoder, "finish frame %p", frame);
3024
3025   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3026
3027   needs_reconfigure = gst_pad_check_reconfigure (decoder->srcpad);
3028   if (G_UNLIKELY (priv->output_state_changed || (priv->output_state
3029               && needs_reconfigure))) {
3030     if (!gst_video_decoder_negotiate_unlocked (decoder)) {
3031       gst_pad_mark_reconfigure (decoder->srcpad);
3032       if (GST_PAD_IS_FLUSHING (decoder->srcpad))
3033         ret = GST_FLOW_FLUSHING;
3034       else
3035         ret = GST_FLOW_NOT_NEGOTIATED;
3036       goto done;
3037     }
3038   }
3039
3040   gst_video_decoder_prepare_finish_frame (decoder, frame, FALSE);
3041   priv->processed++;
3042
3043   if (priv->tags_changed) {
3044     GstEvent *tags_event;
3045
3046     tags_event = gst_video_decoder_create_merged_tags_event (decoder);
3047
3048     if (tags_event != NULL)
3049       gst_video_decoder_push_event (decoder, tags_event);
3050
3051     priv->tags_changed = FALSE;
3052   }
3053
3054   /* no buffer data means this frame is skipped */
3055   if (!frame->output_buffer || GST_VIDEO_CODEC_FRAME_IS_DECODE_ONLY (frame)) {
3056     GST_DEBUG_OBJECT (decoder, "skipping frame %" GST_TIME_FORMAT,
3057         GST_TIME_ARGS (frame->pts));
3058     goto done;
3059   }
3060
3061   output_buffer = frame->output_buffer;
3062
3063   GST_BUFFER_FLAG_UNSET (output_buffer, GST_BUFFER_FLAG_DELTA_UNIT);
3064
3065   GST_BUFFER_PTS (output_buffer) = frame->pts;
3066   GST_BUFFER_DTS (output_buffer) = GST_CLOCK_TIME_NONE;
3067   GST_BUFFER_DURATION (output_buffer) = frame->duration;
3068
3069   GST_BUFFER_OFFSET (output_buffer) = GST_BUFFER_OFFSET_NONE;
3070   GST_BUFFER_OFFSET_END (output_buffer) = GST_BUFFER_OFFSET_NONE;
3071
3072   if (priv->discont) {
3073     GST_BUFFER_FLAG_SET (output_buffer, GST_BUFFER_FLAG_DISCONT);
3074     priv->discont = FALSE;
3075   }
3076
3077   if (decoder_class->transform_meta) {
3078     if (G_LIKELY (frame->input_buffer)) {
3079       CopyMetaData data;
3080
3081       data.decoder = decoder;
3082       data.frame = frame;
3083       gst_buffer_foreach_meta (frame->input_buffer, foreach_metadata, &data);
3084     } else {
3085       GST_WARNING_OBJECT (decoder,
3086           "Can't copy metadata because input frame disappeared");
3087     }
3088   }
3089
3090   /* Get an additional ref to the buffer, which is going to be pushed
3091    * downstream, the original ref is owned by the frame
3092    *
3093    * FIXME: clip_and_push_buf() changes buffer metadata but the buffer
3094    * might have a refcount > 1 */
3095   output_buffer = gst_buffer_ref (output_buffer);
3096
3097   /* Release frame so the buffer is writable when we push it downstream
3098    * if possible, i.e. if the subclass does not hold additional references
3099    * to the frame
3100    */
3101   gst_video_decoder_release_frame (decoder, frame);
3102   frame = NULL;
3103
3104   if (decoder->output_segment.rate < 0.0) {
3105     GST_LOG_OBJECT (decoder, "queued frame");
3106     priv->output_queued = g_list_prepend (priv->output_queued, output_buffer);
3107   } else {
3108     ret = gst_video_decoder_clip_and_push_buf (decoder, output_buffer);
3109   }
3110
3111 done:
3112   if (frame)
3113     gst_video_decoder_release_frame (decoder, frame);
3114   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3115   return ret;
3116 }
3117
3118 /* With stream lock, takes the frame reference */
3119 static GstFlowReturn
3120 gst_video_decoder_clip_and_push_buf (GstVideoDecoder * decoder, GstBuffer * buf)
3121 {
3122   GstFlowReturn ret = GST_FLOW_OK;
3123   GstVideoDecoderPrivate *priv = decoder->priv;
3124   guint64 start, stop;
3125   guint64 cstart, cstop;
3126   GstSegment *segment;
3127   GstClockTime duration;
3128
3129   /* Check for clipping */
3130   start = GST_BUFFER_PTS (buf);
3131   duration = GST_BUFFER_DURATION (buf);
3132
3133   /* store that we have valid decoded data */
3134   priv->had_output_data = TRUE;
3135
3136   stop = GST_CLOCK_TIME_NONE;
3137
3138   if (GST_CLOCK_TIME_IS_VALID (start) && GST_CLOCK_TIME_IS_VALID (duration)) {
3139     stop = start + duration;
3140   } else if (GST_CLOCK_TIME_IS_VALID (start)
3141       && !GST_CLOCK_TIME_IS_VALID (duration)) {
3142     /* If we don't clip away buffers that far before the segment we
3143      * can cause the pipeline to lockup. This can happen if audio is
3144      * properly clipped, and thus the audio sink does not preroll yet
3145      * but the video sink prerolls because we already outputted a
3146      * buffer here... and then queues run full.
3147      *
3148      * In the worst case we will clip one buffer too many here now if no
3149      * framerate is given, no buffer duration is given and the actual
3150      * framerate is lower than 25fps */
3151     stop = start + 40 * GST_MSECOND;
3152   }
3153
3154   segment = &decoder->output_segment;
3155   if (gst_segment_clip (segment, GST_FORMAT_TIME, start, stop, &cstart, &cstop)) {
3156     GST_BUFFER_PTS (buf) = cstart;
3157
3158     if (stop != GST_CLOCK_TIME_NONE && GST_CLOCK_TIME_IS_VALID (duration))
3159       GST_BUFFER_DURATION (buf) = cstop - cstart;
3160
3161     GST_LOG_OBJECT (decoder,
3162         "accepting buffer inside segment: %" GST_TIME_FORMAT " %"
3163         GST_TIME_FORMAT " seg %" GST_TIME_FORMAT " to %" GST_TIME_FORMAT
3164         " time %" GST_TIME_FORMAT,
3165         GST_TIME_ARGS (cstart),
3166         GST_TIME_ARGS (cstop),
3167         GST_TIME_ARGS (segment->start), GST_TIME_ARGS (segment->stop),
3168         GST_TIME_ARGS (segment->time));
3169   } else {
3170     GST_LOG_OBJECT (decoder,
3171         "dropping buffer outside segment: %" GST_TIME_FORMAT
3172         " %" GST_TIME_FORMAT
3173         " seg %" GST_TIME_FORMAT " to %" GST_TIME_FORMAT
3174         " time %" GST_TIME_FORMAT,
3175         GST_TIME_ARGS (start), GST_TIME_ARGS (stop),
3176         GST_TIME_ARGS (segment->start),
3177         GST_TIME_ARGS (segment->stop), GST_TIME_ARGS (segment->time));
3178     /* only check and return EOS if upstream still
3179      * in the same segment and interested as such */
3180     if (decoder->priv->in_out_segment_sync) {
3181       if (segment->rate >= 0) {
3182         if (GST_BUFFER_PTS (buf) >= segment->stop)
3183           ret = GST_FLOW_EOS;
3184       } else if (GST_BUFFER_PTS (buf) < segment->start) {
3185         ret = GST_FLOW_EOS;
3186       }
3187     }
3188     gst_buffer_unref (buf);
3189     goto done;
3190   }
3191
3192   /* update rate estimate */
3193   priv->bytes_out += gst_buffer_get_size (buf);
3194   if (GST_CLOCK_TIME_IS_VALID (duration)) {
3195     priv->time += duration;
3196   } else {
3197     /* FIXME : Use difference between current and previous outgoing
3198      * timestamp, and relate to difference between current and previous
3199      * bytes */
3200     /* better none than nothing valid */
3201     priv->time = GST_CLOCK_TIME_NONE;
3202   }
3203
3204   GST_DEBUG_OBJECT (decoder, "pushing buffer %p of size %" G_GSIZE_FORMAT ", "
3205       "PTS %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT, buf,
3206       gst_buffer_get_size (buf),
3207       GST_TIME_ARGS (GST_BUFFER_PTS (buf)),
3208       GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
3209
3210   /* we got data, so note things are looking up again, reduce
3211    * the error count, if there is one */
3212   if (G_UNLIKELY (priv->error_count))
3213     priv->error_count = 0;
3214
3215   ret = gst_pad_push (decoder->srcpad, buf);
3216
3217 done:
3218   return ret;
3219 }
3220
3221 /**
3222  * gst_video_decoder_add_to_frame:
3223  * @decoder: a #GstVideoDecoder
3224  * @n_bytes: the number of bytes to add
3225  *
3226  * Removes next @n_bytes of input data and adds it to currently parsed frame.
3227  */
3228 void
3229 gst_video_decoder_add_to_frame (GstVideoDecoder * decoder, int n_bytes)
3230 {
3231   GstVideoDecoderPrivate *priv = decoder->priv;
3232   GstBuffer *buf;
3233
3234   GST_LOG_OBJECT (decoder, "add %d bytes to frame", n_bytes);
3235
3236   if (n_bytes == 0)
3237     return;
3238
3239   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3240   if (gst_adapter_available (priv->output_adapter) == 0) {
3241     priv->frame_offset =
3242         priv->input_offset - gst_adapter_available (priv->input_adapter);
3243   }
3244   buf = gst_adapter_take_buffer (priv->input_adapter, n_bytes);
3245
3246   gst_adapter_push (priv->output_adapter, buf);
3247   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3248 }
3249
3250 /**
3251  * gst_video_decoder_get_pending_frame_size:
3252  * @decoder: a #GstVideoDecoder
3253  *
3254  * Returns the number of bytes previously added to the current frame
3255  * by calling gst_video_decoder_add_to_frame().
3256  *
3257  * Returns: The number of bytes pending for the current frame
3258  *
3259  * Since: 1.4
3260  */
3261 gsize
3262 gst_video_decoder_get_pending_frame_size (GstVideoDecoder * decoder)
3263 {
3264   GstVideoDecoderPrivate *priv = decoder->priv;
3265   gsize ret;
3266
3267   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3268   ret = gst_adapter_available (priv->output_adapter);
3269   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3270
3271   GST_LOG_OBJECT (decoder, "Current pending frame has %" G_GSIZE_FORMAT "bytes",
3272       ret);
3273
3274   return ret;
3275 }
3276
3277 static guint64
3278 gst_video_decoder_get_frame_duration (GstVideoDecoder * decoder,
3279     GstVideoCodecFrame * frame)
3280 {
3281   GstVideoCodecState *state = decoder->priv->output_state;
3282
3283   /* it's possible that we don't have a state yet when we are dropping the
3284    * initial buffers */
3285   if (state == NULL)
3286     return GST_CLOCK_TIME_NONE;
3287
3288   if (state->info.fps_d == 0 || state->info.fps_n == 0) {
3289     return GST_CLOCK_TIME_NONE;
3290   }
3291
3292   /* FIXME: For interlaced frames this needs to take into account
3293    * the number of valid fields in the frame
3294    */
3295
3296   return gst_util_uint64_scale (GST_SECOND, state->info.fps_d,
3297       state->info.fps_n);
3298 }
3299
3300 /**
3301  * gst_video_decoder_have_frame:
3302  * @decoder: a #GstVideoDecoder
3303  *
3304  * Gathers all data collected for currently parsed frame, gathers corresponding
3305  * metadata and passes it along for further processing, i.e. @handle_frame.
3306  *
3307  * Returns: a #GstFlowReturn
3308  */
3309 GstFlowReturn
3310 gst_video_decoder_have_frame (GstVideoDecoder * decoder)
3311 {
3312   GstVideoDecoderPrivate *priv = decoder->priv;
3313   GstBuffer *buffer;
3314   int n_available;
3315   GstClockTime pts, dts, duration;
3316   GstFlowReturn ret = GST_FLOW_OK;
3317
3318   GST_LOG_OBJECT (decoder, "have_frame");
3319
3320   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3321
3322   n_available = gst_adapter_available (priv->output_adapter);
3323   if (n_available) {
3324     buffer = gst_adapter_take_buffer (priv->output_adapter, n_available);
3325   } else {
3326     buffer = gst_buffer_new_and_alloc (0);
3327   }
3328
3329   priv->current_frame->input_buffer = buffer;
3330
3331   gst_video_decoder_get_timestamp_at_offset (decoder,
3332       priv->frame_offset, &pts, &dts, &duration);
3333
3334   GST_BUFFER_PTS (buffer) = pts;
3335   GST_BUFFER_DTS (buffer) = dts;
3336   GST_BUFFER_DURATION (buffer) = duration;
3337
3338   GST_LOG_OBJECT (decoder, "collected frame size %d, "
3339       "PTS %" GST_TIME_FORMAT ", DTS %" GST_TIME_FORMAT ", dur %"
3340       GST_TIME_FORMAT, n_available, GST_TIME_ARGS (pts), GST_TIME_ARGS (dts),
3341       GST_TIME_ARGS (duration));
3342
3343   /* In reverse playback, just capture and queue frames for later processing */
3344   if (decoder->output_segment.rate < 0.0) {
3345     priv->parse_gather =
3346         g_list_prepend (priv->parse_gather, priv->current_frame);
3347   } else {
3348     /* Otherwise, decode the frame, which gives away our ref */
3349     ret = gst_video_decoder_decode_frame (decoder, priv->current_frame);
3350   }
3351   /* Current frame is gone now, either way */
3352   priv->current_frame = NULL;
3353
3354   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3355
3356   return ret;
3357 }
3358
3359 /* Pass the frame in priv->current_frame through the
3360  * handle_frame() callback for decoding and passing to gvd_finish_frame(),
3361  * or dropping by passing to gvd_drop_frame() */
3362 static GstFlowReturn
3363 gst_video_decoder_decode_frame (GstVideoDecoder * decoder,
3364     GstVideoCodecFrame * frame)
3365 {
3366   GstVideoDecoderPrivate *priv = decoder->priv;
3367   GstVideoDecoderClass *decoder_class;
3368   GstFlowReturn ret = GST_FLOW_OK;
3369
3370   decoder_class = GST_VIDEO_DECODER_GET_CLASS (decoder);
3371
3372   /* FIXME : This should only have to be checked once (either the subclass has an
3373    * implementation, or it doesn't) */
3374   g_return_val_if_fail (decoder_class->handle_frame != NULL, GST_FLOW_ERROR);
3375
3376   frame->distance_from_sync = priv->distance_from_sync;
3377   priv->distance_from_sync++;
3378   frame->pts = GST_BUFFER_PTS (frame->input_buffer);
3379   frame->dts = GST_BUFFER_DTS (frame->input_buffer);
3380   frame->duration = GST_BUFFER_DURATION (frame->input_buffer);
3381
3382   /* For keyframes, PTS = DTS + constant_offset, usually 0 to 3 frame
3383    * durations. */
3384   /* FIXME upstream can be quite wrong about the keyframe aspect,
3385    * so we could be going off here as well,
3386    * maybe let subclass decide if it really is/was a keyframe */
3387   if (GST_VIDEO_CODEC_FRAME_IS_SYNC_POINT (frame) &&
3388       GST_CLOCK_TIME_IS_VALID (frame->pts)
3389       && GST_CLOCK_TIME_IS_VALID (frame->dts)) {
3390     /* just in case they are not equal as might ideally be,
3391      * e.g. quicktime has a (positive) delta approach */
3392     priv->pts_delta = frame->pts - frame->dts;
3393     GST_DEBUG_OBJECT (decoder, "PTS delta %d ms",
3394         (gint) (priv->pts_delta / GST_MSECOND));
3395   }
3396
3397   frame->abidata.ABI.ts = frame->dts;
3398   frame->abidata.ABI.ts2 = frame->pts;
3399
3400   GST_LOG_OBJECT (decoder, "PTS %" GST_TIME_FORMAT ", DTS %" GST_TIME_FORMAT,
3401       GST_TIME_ARGS (frame->pts), GST_TIME_ARGS (frame->dts));
3402   GST_LOG_OBJECT (decoder, "dist %d", frame->distance_from_sync);
3403
3404   gst_video_codec_frame_ref (frame);
3405   priv->frames = g_list_append (priv->frames, frame);
3406
3407   if (g_list_length (priv->frames) > 10) {
3408     GST_DEBUG_OBJECT (decoder, "decoder frame list getting long: %d frames,"
3409         "possible internal leaking?", g_list_length (priv->frames));
3410   }
3411
3412   frame->deadline =
3413       gst_segment_to_running_time (&decoder->input_segment, GST_FORMAT_TIME,
3414       frame->pts);
3415
3416   /* do something with frame */
3417   ret = decoder_class->handle_frame (decoder, frame);
3418   if (ret != GST_FLOW_OK)
3419     GST_DEBUG_OBJECT (decoder, "flow error %s", gst_flow_get_name (ret));
3420
3421   /* the frame has either been added to parse_gather or sent to
3422      handle frame so there is no need to unref it */
3423   return ret;
3424 }
3425
3426
3427 /**
3428  * gst_video_decoder_get_output_state:
3429  * @decoder: a #GstVideoDecoder
3430  *
3431  * Get the #GstVideoCodecState currently describing the output stream.
3432  *
3433  * Returns: (transfer full): #GstVideoCodecState describing format of video data.
3434  */
3435 GstVideoCodecState *
3436 gst_video_decoder_get_output_state (GstVideoDecoder * decoder)
3437 {
3438   GstVideoCodecState *state = NULL;
3439
3440   GST_OBJECT_LOCK (decoder);
3441   if (decoder->priv->output_state)
3442     state = gst_video_codec_state_ref (decoder->priv->output_state);
3443   GST_OBJECT_UNLOCK (decoder);
3444
3445   return state;
3446 }
3447
3448 /**
3449  * gst_video_decoder_set_output_state:
3450  * @decoder: a #GstVideoDecoder
3451  * @fmt: a #GstVideoFormat
3452  * @width: The width in pixels
3453  * @height: The height in pixels
3454  * @reference: (allow-none) (transfer none): An optional reference #GstVideoCodecState
3455  *
3456  * Creates a new #GstVideoCodecState with the specified @fmt, @width and @height
3457  * as the output state for the decoder.
3458  * Any previously set output state on @decoder will be replaced by the newly
3459  * created one.
3460  *
3461  * If the subclass wishes to copy over existing fields (like pixel aspec ratio,
3462  * or framerate) from an existing #GstVideoCodecState, it can be provided as a
3463  * @reference.
3464  *
3465  * If the subclass wishes to override some fields from the output state (like
3466  * pixel-aspect-ratio or framerate) it can do so on the returned #GstVideoCodecState.
3467  *
3468  * The new output state will only take effect (set on pads and buffers) starting
3469  * from the next call to #gst_video_decoder_finish_frame().
3470  *
3471  * Returns: (transfer full): the newly configured output state.
3472  */
3473 GstVideoCodecState *
3474 gst_video_decoder_set_output_state (GstVideoDecoder * decoder,
3475     GstVideoFormat fmt, guint width, guint height,
3476     GstVideoCodecState * reference)
3477 {
3478   GstVideoDecoderPrivate *priv = decoder->priv;
3479   GstVideoCodecState *state;
3480
3481   GST_DEBUG_OBJECT (decoder, "fmt:%d, width:%d, height:%d, reference:%p",
3482       fmt, width, height, reference);
3483
3484   /* Create the new output state */
3485   state = _new_output_state (fmt, width, height, reference);
3486
3487   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3488
3489   GST_OBJECT_LOCK (decoder);
3490   /* Replace existing output state by new one */
3491   if (priv->output_state)
3492     gst_video_codec_state_unref (priv->output_state);
3493   priv->output_state = gst_video_codec_state_ref (state);
3494
3495   if (priv->output_state != NULL && priv->output_state->info.fps_n > 0) {
3496     priv->qos_frame_duration =
3497         gst_util_uint64_scale (GST_SECOND, priv->output_state->info.fps_d,
3498         priv->output_state->info.fps_n);
3499   } else {
3500     priv->qos_frame_duration = 0;
3501   }
3502   priv->output_state_changed = TRUE;
3503   GST_OBJECT_UNLOCK (decoder);
3504
3505   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3506
3507   return state;
3508 }
3509
3510
3511 /**
3512  * gst_video_decoder_get_oldest_frame:
3513  * @decoder: a #GstVideoDecoder
3514  *
3515  * Get the oldest pending unfinished #GstVideoCodecFrame
3516  *
3517  * Returns: (transfer full): oldest pending unfinished #GstVideoCodecFrame.
3518  */
3519 GstVideoCodecFrame *
3520 gst_video_decoder_get_oldest_frame (GstVideoDecoder * decoder)
3521 {
3522   GstVideoCodecFrame *frame = NULL;
3523
3524   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3525   if (decoder->priv->frames)
3526     frame = gst_video_codec_frame_ref (decoder->priv->frames->data);
3527   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3528
3529   return (GstVideoCodecFrame *) frame;
3530 }
3531
3532 /**
3533  * gst_video_decoder_get_frame:
3534  * @decoder: a #GstVideoDecoder
3535  * @frame_number: system_frame_number of a frame
3536  *
3537  * Get a pending unfinished #GstVideoCodecFrame
3538  *
3539  * Returns: (transfer full): pending unfinished #GstVideoCodecFrame identified by @frame_number.
3540  */
3541 GstVideoCodecFrame *
3542 gst_video_decoder_get_frame (GstVideoDecoder * decoder, int frame_number)
3543 {
3544   GList *g;
3545   GstVideoCodecFrame *frame = NULL;
3546
3547   GST_DEBUG_OBJECT (decoder, "frame_number : %d", frame_number);
3548
3549   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3550   for (g = decoder->priv->frames; g; g = g->next) {
3551     GstVideoCodecFrame *tmp = g->data;
3552
3553     if (tmp->system_frame_number == frame_number) {
3554       frame = gst_video_codec_frame_ref (tmp);
3555       break;
3556     }
3557   }
3558   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3559
3560   return frame;
3561 }
3562
3563 /**
3564  * gst_video_decoder_get_frames:
3565  * @decoder: a #GstVideoDecoder
3566  *
3567  * Get all pending unfinished #GstVideoCodecFrame
3568  *
3569  * Returns: (transfer full) (element-type GstVideoCodecFrame): pending unfinished #GstVideoCodecFrame.
3570  */
3571 GList *
3572 gst_video_decoder_get_frames (GstVideoDecoder * decoder)
3573 {
3574   GList *frames;
3575
3576   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3577   frames = g_list_copy (decoder->priv->frames);
3578   g_list_foreach (frames, (GFunc) gst_video_codec_frame_ref, NULL);
3579   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3580
3581   return frames;
3582 }
3583
3584 static gboolean
3585 gst_video_decoder_decide_allocation_default (GstVideoDecoder * decoder,
3586     GstQuery * query)
3587 {
3588   GstCaps *outcaps = NULL;
3589   GstBufferPool *pool = NULL;
3590   guint size, min, max;
3591   GstAllocator *allocator = NULL;
3592   GstAllocationParams params;
3593   GstStructure *config;
3594   gboolean update_pool, update_allocator;
3595   GstVideoInfo vinfo;
3596
3597   gst_query_parse_allocation (query, &outcaps, NULL);
3598   gst_video_info_init (&vinfo);
3599   if (outcaps)
3600     gst_video_info_from_caps (&vinfo, outcaps);
3601
3602   /* we got configuration from our peer or the decide_allocation method,
3603    * parse them */
3604   if (gst_query_get_n_allocation_params (query) > 0) {
3605     /* try the allocator */
3606     gst_query_parse_nth_allocation_param (query, 0, &allocator, &params);
3607     update_allocator = TRUE;
3608   } else {
3609     allocator = NULL;
3610     gst_allocation_params_init (&params);
3611     update_allocator = FALSE;
3612   }
3613
3614   if (gst_query_get_n_allocation_pools (query) > 0) {
3615     gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
3616     size = MAX (size, vinfo.size);
3617     update_pool = TRUE;
3618   } else {
3619     pool = NULL;
3620     size = vinfo.size;
3621     min = max = 0;
3622
3623     update_pool = FALSE;
3624   }
3625
3626   if (pool == NULL) {
3627     /* no pool, we can make our own */
3628     GST_DEBUG_OBJECT (decoder, "no pool, making new pool");
3629     pool = gst_video_buffer_pool_new ();
3630   }
3631
3632   /* now configure */
3633   config = gst_buffer_pool_get_config (pool);
3634   gst_buffer_pool_config_set_params (config, outcaps, size, min, max);
3635   gst_buffer_pool_config_set_allocator (config, allocator, &params);
3636
3637   GST_DEBUG_OBJECT (decoder,
3638       "setting config %" GST_PTR_FORMAT " in pool %" GST_PTR_FORMAT, config,
3639       pool);
3640   if (!gst_buffer_pool_set_config (pool, config)) {
3641     config = gst_buffer_pool_get_config (pool);
3642
3643     /* If change are not acceptable, fallback to generic pool */
3644     if (!gst_buffer_pool_config_validate_params (config, outcaps, size, min,
3645             max)) {
3646       GST_DEBUG_OBJECT (decoder, "unsuported pool, making new pool");
3647
3648       gst_object_unref (pool);
3649       pool = gst_video_buffer_pool_new ();
3650       gst_buffer_pool_config_set_params (config, outcaps, size, min, max);
3651       gst_buffer_pool_config_set_allocator (config, allocator, &params);
3652     }
3653
3654     if (!gst_buffer_pool_set_config (pool, config))
3655       goto config_failed;
3656   }
3657
3658   if (update_allocator)
3659     gst_query_set_nth_allocation_param (query, 0, allocator, &params);
3660   else
3661     gst_query_add_allocation_param (query, allocator, &params);
3662   if (allocator)
3663     gst_object_unref (allocator);
3664
3665   if (update_pool)
3666     gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
3667   else
3668     gst_query_add_allocation_pool (query, pool, size, min, max);
3669
3670   if (pool)
3671     gst_object_unref (pool);
3672
3673   return TRUE;
3674
3675 config_failed:
3676   if (allocator)
3677     gst_object_unref (allocator);
3678   if (pool)
3679     gst_object_unref (pool);
3680   GST_ELEMENT_ERROR (decoder, RESOURCE, SETTINGS,
3681       ("Failed to configure the buffer pool"),
3682       ("Configuration is most likely invalid, please report this issue."));
3683   return FALSE;
3684 }
3685
3686 static gboolean
3687 gst_video_decoder_propose_allocation_default (GstVideoDecoder * decoder,
3688     GstQuery * query)
3689 {
3690   return TRUE;
3691 }
3692
3693 static gboolean
3694 gst_video_decoder_negotiate_pool (GstVideoDecoder * decoder, GstCaps * caps)
3695 {
3696   GstVideoDecoderClass *klass;
3697   GstQuery *query = NULL;
3698   GstBufferPool *pool = NULL;
3699   GstAllocator *allocator;
3700   GstAllocationParams params;
3701   gboolean ret = TRUE;
3702
3703   klass = GST_VIDEO_DECODER_GET_CLASS (decoder);
3704
3705   query = gst_query_new_allocation (caps, TRUE);
3706
3707   GST_DEBUG_OBJECT (decoder, "do query ALLOCATION");
3708
3709   if (!gst_pad_peer_query (decoder->srcpad, query)) {
3710     GST_DEBUG_OBJECT (decoder, "didn't get downstream ALLOCATION hints");
3711   }
3712
3713   g_assert (klass->decide_allocation != NULL);
3714   ret = klass->decide_allocation (decoder, query);
3715
3716   GST_DEBUG_OBJECT (decoder, "ALLOCATION (%d) params: %" GST_PTR_FORMAT, ret,
3717       query);
3718
3719   if (!ret)
3720     goto no_decide_allocation;
3721
3722   /* we got configuration from our peer or the decide_allocation method,
3723    * parse them */
3724   if (gst_query_get_n_allocation_params (query) > 0) {
3725     gst_query_parse_nth_allocation_param (query, 0, &allocator, &params);
3726   } else {
3727     allocator = NULL;
3728     gst_allocation_params_init (&params);
3729   }
3730
3731   if (gst_query_get_n_allocation_pools (query) > 0)
3732     gst_query_parse_nth_allocation_pool (query, 0, &pool, NULL, NULL, NULL);
3733   if (!pool) {
3734     if (allocator)
3735       gst_object_unref (allocator);
3736     ret = FALSE;
3737     goto no_decide_allocation;
3738   }
3739
3740   if (decoder->priv->allocator)
3741     gst_object_unref (decoder->priv->allocator);
3742   decoder->priv->allocator = allocator;
3743   decoder->priv->params = params;
3744
3745   if (decoder->priv->pool) {
3746     /* do not set the bufferpool to inactive here, it will be done
3747      * on its finalize function. As videodecoder do late renegotiation
3748      * it might happen that some element downstream is already using this
3749      * same bufferpool and deactivating it will make it fail.
3750      * Happens when a downstream element changes from passthrough to
3751      * non-passthrough and gets this same bufferpool to use */
3752     GST_DEBUG_OBJECT (decoder, "unref pool %" GST_PTR_FORMAT,
3753         decoder->priv->pool);
3754     gst_object_unref (decoder->priv->pool);
3755   }
3756   decoder->priv->pool = pool;
3757
3758   /* and activate */
3759   GST_DEBUG_OBJECT (decoder, "activate pool %" GST_PTR_FORMAT, pool);
3760   gst_buffer_pool_set_active (pool, TRUE);
3761
3762 done:
3763   if (query)
3764     gst_query_unref (query);
3765
3766   return ret;
3767
3768   /* Errors */
3769 no_decide_allocation:
3770   {
3771     GST_WARNING_OBJECT (decoder, "Subclass failed to decide allocation");
3772     goto done;
3773   }
3774 }
3775
3776 static gboolean
3777 gst_video_decoder_negotiate_default (GstVideoDecoder * decoder)
3778 {
3779   GstVideoCodecState *state = decoder->priv->output_state;
3780   gboolean ret = TRUE;
3781   GstVideoCodecFrame *frame;
3782   GstCaps *prevcaps;
3783
3784   if (!state) {
3785     GST_DEBUG_OBJECT (decoder,
3786         "Trying to negotiate the pool with out setting the o/p format");
3787     ret = gst_video_decoder_negotiate_pool (decoder, NULL);
3788     goto done;
3789   }
3790
3791   g_return_val_if_fail (GST_VIDEO_INFO_WIDTH (&state->info) != 0, FALSE);
3792   g_return_val_if_fail (GST_VIDEO_INFO_HEIGHT (&state->info) != 0, FALSE);
3793
3794   GST_DEBUG_OBJECT (decoder, "output_state par %d/%d fps %d/%d",
3795       state->info.par_n, state->info.par_d,
3796       state->info.fps_n, state->info.fps_d);
3797
3798   if (state->caps == NULL)
3799     state->caps = gst_video_info_to_caps (&state->info);
3800   if (state->allocation_caps == NULL)
3801     state->allocation_caps = gst_caps_ref (state->caps);
3802
3803   GST_DEBUG_OBJECT (decoder, "setting caps %" GST_PTR_FORMAT, state->caps);
3804
3805   /* Push all pending pre-caps events of the oldest frame before
3806    * setting caps */
3807   frame = decoder->priv->frames ? decoder->priv->frames->data : NULL;
3808   if (frame || decoder->priv->current_frame_events) {
3809     GList **events, *l;
3810
3811     if (frame) {
3812       events = &frame->events;
3813     } else {
3814       events = &decoder->priv->current_frame_events;
3815     }
3816
3817     for (l = g_list_last (*events); l;) {
3818       GstEvent *event = GST_EVENT (l->data);
3819       GList *tmp;
3820
3821       if (GST_EVENT_TYPE (event) < GST_EVENT_CAPS) {
3822         gst_video_decoder_push_event (decoder, event);
3823         tmp = l;
3824         l = l->prev;
3825         *events = g_list_delete_link (*events, tmp);
3826       } else {
3827         l = l->prev;
3828       }
3829     }
3830   }
3831
3832   prevcaps = gst_pad_get_current_caps (decoder->srcpad);
3833   if (!prevcaps || !gst_caps_is_equal (prevcaps, state->caps)) {
3834     if (!prevcaps) {
3835       GST_DEBUG_OBJECT (decoder, "decoder src pad has currently NULL caps");
3836     }
3837     ret = gst_pad_set_caps (decoder->srcpad, state->caps);
3838   } else {
3839     ret = TRUE;
3840     GST_DEBUG_OBJECT (decoder,
3841         "current src pad and output state caps are the same");
3842   }
3843   if (prevcaps)
3844     gst_caps_unref (prevcaps);
3845
3846   if (!ret)
3847     goto done;
3848   decoder->priv->output_state_changed = FALSE;
3849   /* Negotiate pool */
3850   ret = gst_video_decoder_negotiate_pool (decoder, state->allocation_caps);
3851
3852 done:
3853   return ret;
3854 }
3855
3856 static gboolean
3857 gst_video_decoder_negotiate_unlocked (GstVideoDecoder * decoder)
3858 {
3859   GstVideoDecoderClass *klass = GST_VIDEO_DECODER_GET_CLASS (decoder);
3860   gboolean ret = TRUE;
3861
3862   if (G_LIKELY (klass->negotiate))
3863     ret = klass->negotiate (decoder);
3864
3865   return ret;
3866 }
3867
3868 /**
3869  * gst_video_decoder_negotiate:
3870  * @decoder: a #GstVideoDecoder
3871  *
3872  * Negotiate with downstream elements to currently configured #GstVideoCodecState.
3873  * Unmark GST_PAD_FLAG_NEED_RECONFIGURE in any case. But mark it again if
3874  * negotiate fails.
3875  *
3876  * Returns: #TRUE if the negotiation succeeded, else #FALSE.
3877  */
3878 gboolean
3879 gst_video_decoder_negotiate (GstVideoDecoder * decoder)
3880 {
3881   GstVideoDecoderClass *klass;
3882   gboolean ret = TRUE;
3883
3884   g_return_val_if_fail (GST_IS_VIDEO_DECODER (decoder), FALSE);
3885
3886   klass = GST_VIDEO_DECODER_GET_CLASS (decoder);
3887
3888   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3889   gst_pad_check_reconfigure (decoder->srcpad);
3890   if (klass->negotiate) {
3891     ret = klass->negotiate (decoder);
3892     if (!ret)
3893       gst_pad_mark_reconfigure (decoder->srcpad);
3894   }
3895   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3896
3897   return ret;
3898 }
3899
3900 /**
3901  * gst_video_decoder_allocate_output_buffer:
3902  * @decoder: a #GstVideoDecoder
3903  *
3904  * Helper function that allocates a buffer to hold a video frame for @decoder's
3905  * current #GstVideoCodecState.
3906  *
3907  * You should use gst_video_decoder_allocate_output_frame() instead of this
3908  * function, if possible at all.
3909  *
3910  * Returns: (transfer full): allocated buffer, or NULL if no buffer could be
3911  *     allocated (e.g. when downstream is flushing or shutting down)
3912  */
3913 GstBuffer *
3914 gst_video_decoder_allocate_output_buffer (GstVideoDecoder * decoder)
3915 {
3916   GstFlowReturn flow;
3917   GstBuffer *buffer = NULL;
3918   gboolean needs_reconfigure = FALSE;
3919
3920   GST_DEBUG ("alloc src buffer");
3921
3922   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3923   needs_reconfigure = gst_pad_check_reconfigure (decoder->srcpad);
3924   if (G_UNLIKELY (!decoder->priv->output_state
3925           || decoder->priv->output_state_changed || needs_reconfigure)) {
3926     if (!gst_video_decoder_negotiate_unlocked (decoder)) {
3927       if (decoder->priv->output_state) {
3928         GST_DEBUG_OBJECT (decoder, "Failed to negotiate, fallback allocation");
3929         gst_pad_mark_reconfigure (decoder->srcpad);
3930         goto fallback;
3931       } else {
3932         GST_DEBUG_OBJECT (decoder, "Failed to negotiate, output_buffer=NULL");
3933         goto failed_allocation;
3934       }
3935     }
3936   }
3937
3938   flow = gst_buffer_pool_acquire_buffer (decoder->priv->pool, &buffer, NULL);
3939
3940   if (flow != GST_FLOW_OK) {
3941     GST_INFO_OBJECT (decoder, "couldn't allocate output buffer, flow %s",
3942         gst_flow_get_name (flow));
3943     if (decoder->priv->output_state && decoder->priv->output_state->info.size)
3944       goto fallback;
3945     else
3946       goto failed_allocation;
3947   }
3948   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3949
3950   return buffer;
3951
3952 fallback:
3953   GST_INFO_OBJECT (decoder,
3954       "Fallback allocation, creating new buffer which doesn't belongs to any buffer pool");
3955   buffer =
3956       gst_buffer_new_allocate (NULL, decoder->priv->output_state->info.size,
3957       NULL);
3958
3959 failed_allocation:
3960   GST_ERROR_OBJECT (decoder, "Failed to allocate the buffer..");
3961   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
3962
3963   return buffer;
3964 }
3965
3966 /**
3967  * gst_video_decoder_allocate_output_frame:
3968  * @decoder: a #GstVideoDecoder
3969  * @frame: a #GstVideoCodecFrame
3970  *
3971  * Helper function that allocates a buffer to hold a video frame for @decoder's
3972  * current #GstVideoCodecState.  Subclass should already have configured video
3973  * state and set src pad caps.
3974  *
3975  * The buffer allocated here is owned by the frame and you should only
3976  * keep references to the frame, not the buffer.
3977  *
3978  * Returns: %GST_FLOW_OK if an output buffer could be allocated
3979  */
3980 GstFlowReturn
3981 gst_video_decoder_allocate_output_frame (GstVideoDecoder *
3982     decoder, GstVideoCodecFrame * frame)
3983 {
3984   GstFlowReturn flow_ret;
3985   GstVideoCodecState *state;
3986   int num_bytes;
3987   gboolean needs_reconfigure = FALSE;
3988
3989   g_return_val_if_fail (decoder->priv->output_state, GST_FLOW_NOT_NEGOTIATED);
3990   g_return_val_if_fail (frame->output_buffer == NULL, GST_FLOW_ERROR);
3991
3992   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
3993
3994   state = decoder->priv->output_state;
3995   if (state == NULL) {
3996     g_warning ("Output state should be set before allocating frame");
3997     goto error;
3998   }
3999   num_bytes = GST_VIDEO_INFO_SIZE (&state->info);
4000   if (num_bytes == 0) {
4001     g_warning ("Frame size should not be 0");
4002     goto error;
4003   }
4004
4005   needs_reconfigure = gst_pad_check_reconfigure (decoder->srcpad);
4006   if (G_UNLIKELY (decoder->priv->output_state_changed || needs_reconfigure)) {
4007     if (!gst_video_decoder_negotiate_unlocked (decoder)) {
4008       GST_DEBUG_OBJECT (decoder, "Failed to negotiate, fallback allocation");
4009       gst_pad_mark_reconfigure (decoder->srcpad);
4010     }
4011   }
4012
4013   GST_LOG_OBJECT (decoder, "alloc buffer size %d", num_bytes);
4014
4015   flow_ret = gst_buffer_pool_acquire_buffer (decoder->priv->pool,
4016       &frame->output_buffer, NULL);
4017
4018   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
4019
4020   return flow_ret;
4021
4022 error:
4023   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
4024   return GST_FLOW_ERROR;
4025 }
4026
4027 /**
4028  * gst_video_decoder_get_max_decode_time:
4029  * @decoder: a #GstVideoDecoder
4030  * @frame: a #GstVideoCodecFrame
4031  *
4032  * Determines maximum possible decoding time for @frame that will
4033  * allow it to decode and arrive in time (as determined by QoS events).
4034  * In particular, a negative result means decoding in time is no longer possible
4035  * and should therefore occur as soon/skippy as possible.
4036  *
4037  * Returns: max decoding time.
4038  */
4039 GstClockTimeDiff
4040 gst_video_decoder_get_max_decode_time (GstVideoDecoder *
4041     decoder, GstVideoCodecFrame * frame)
4042 {
4043   GstClockTimeDiff deadline;
4044   GstClockTime earliest_time;
4045
4046   GST_OBJECT_LOCK (decoder);
4047   earliest_time = decoder->priv->earliest_time;
4048   if (GST_CLOCK_TIME_IS_VALID (earliest_time)
4049       && GST_CLOCK_TIME_IS_VALID (frame->deadline))
4050     deadline = GST_CLOCK_DIFF (earliest_time, frame->deadline);
4051   else
4052     deadline = G_MAXINT64;
4053
4054   GST_LOG_OBJECT (decoder, "earliest %" GST_TIME_FORMAT
4055       ", frame deadline %" GST_TIME_FORMAT ", deadline %" GST_STIME_FORMAT,
4056       GST_TIME_ARGS (earliest_time), GST_TIME_ARGS (frame->deadline),
4057       GST_STIME_ARGS (deadline));
4058
4059   GST_OBJECT_UNLOCK (decoder);
4060
4061   return deadline;
4062 }
4063
4064 /**
4065  * gst_video_decoder_get_qos_proportion:
4066  * @decoder: a #GstVideoDecoder
4067  *     current QoS proportion, or %NULL
4068  *
4069  * Returns: The current QoS proportion.
4070  *
4071  * Since: 1.0.3
4072  */
4073 gdouble
4074 gst_video_decoder_get_qos_proportion (GstVideoDecoder * decoder)
4075 {
4076   gdouble proportion;
4077
4078   g_return_val_if_fail (GST_IS_VIDEO_DECODER (decoder), 1.0);
4079
4080   GST_OBJECT_LOCK (decoder);
4081   proportion = decoder->priv->proportion;
4082   GST_OBJECT_UNLOCK (decoder);
4083
4084   return proportion;
4085 }
4086
4087 GstFlowReturn
4088 _gst_video_decoder_error (GstVideoDecoder * dec, gint weight,
4089     GQuark domain, gint code, gchar * txt, gchar * dbg, const gchar * file,
4090     const gchar * function, gint line)
4091 {
4092   if (txt)
4093     GST_WARNING_OBJECT (dec, "error: %s", txt);
4094   if (dbg)
4095     GST_WARNING_OBJECT (dec, "error: %s", dbg);
4096   dec->priv->error_count += weight;
4097   dec->priv->discont = TRUE;
4098   if (dec->priv->max_errors >= 0 &&
4099       dec->priv->error_count > dec->priv->max_errors) {
4100     gst_element_message_full (GST_ELEMENT (dec), GST_MESSAGE_ERROR,
4101         domain, code, txt, dbg, file, function, line);
4102     return GST_FLOW_ERROR;
4103   } else {
4104     g_free (txt);
4105     g_free (dbg);
4106     return GST_FLOW_OK;
4107   }
4108 }
4109
4110 /**
4111  * gst_video_decoder_set_max_errors:
4112  * @dec: a #GstVideoDecoder
4113  * @num: max tolerated errors
4114  *
4115  * Sets numbers of tolerated decoder errors, where a tolerated one is then only
4116  * warned about, but more than tolerated will lead to fatal error.  You can set
4117  * -1 for never returning fatal errors. Default is set to
4118  * GST_VIDEO_DECODER_MAX_ERRORS.
4119  *
4120  * The '-1' option was added in 1.4
4121  */
4122 void
4123 gst_video_decoder_set_max_errors (GstVideoDecoder * dec, gint num)
4124 {
4125   g_return_if_fail (GST_IS_VIDEO_DECODER (dec));
4126
4127   dec->priv->max_errors = num;
4128 }
4129
4130 /**
4131  * gst_video_decoder_get_max_errors:
4132  * @dec: a #GstVideoDecoder
4133  *
4134  * Returns: currently configured decoder tolerated error count.
4135  */
4136 gint
4137 gst_video_decoder_get_max_errors (GstVideoDecoder * dec)
4138 {
4139   g_return_val_if_fail (GST_IS_VIDEO_DECODER (dec), 0);
4140
4141   return dec->priv->max_errors;
4142 }
4143
4144 /**
4145  * gst_video_decoder_set_needs_format:
4146  * @dec: a #GstVideoDecoder
4147  * @enabled: new state
4148  *
4149  * Configures decoder format needs.  If enabled, subclass needs to be
4150  * negotiated with format caps before it can process any data.  It will then
4151  * never be handed any data before it has been configured.
4152  * Otherwise, it might be handed data without having been configured and
4153  * is then expected being able to do so either by default
4154  * or based on the input data.
4155  *
4156  * Since: 1.4
4157  */
4158 void
4159 gst_video_decoder_set_needs_format (GstVideoDecoder * dec, gboolean enabled)
4160 {
4161   g_return_if_fail (GST_IS_VIDEO_DECODER (dec));
4162
4163   dec->priv->needs_format = enabled;
4164 }
4165
4166 /**
4167  * gst_video_decoder_get_needs_format:
4168  * @dec: a #GstVideoDecoder
4169  *
4170  * Queries decoder required format handling.
4171  *
4172  * Returns: %TRUE if required format handling is enabled.
4173  *
4174  * Since: 1.4
4175  */
4176 gboolean
4177 gst_video_decoder_get_needs_format (GstVideoDecoder * dec)
4178 {
4179   gboolean result;
4180
4181   g_return_val_if_fail (GST_IS_VIDEO_DECODER (dec), FALSE);
4182
4183   result = dec->priv->needs_format;
4184
4185   return result;
4186 }
4187
4188 /**
4189  * gst_video_decoder_set_packetized:
4190  * @decoder: a #GstVideoDecoder
4191  * @packetized: whether the input data should be considered as packetized.
4192  *
4193  * Allows baseclass to consider input data as packetized or not. If the
4194  * input is packetized, then the @parse method will not be called.
4195  */
4196 void
4197 gst_video_decoder_set_packetized (GstVideoDecoder * decoder,
4198     gboolean packetized)
4199 {
4200   decoder->priv->packetized = packetized;
4201 }
4202
4203 /**
4204  * gst_video_decoder_get_packetized:
4205  * @decoder: a #GstVideoDecoder
4206  *
4207  * Queries whether input data is considered packetized or not by the
4208  * base class.
4209  *
4210  * Returns: TRUE if input data is considered packetized.
4211  */
4212 gboolean
4213 gst_video_decoder_get_packetized (GstVideoDecoder * decoder)
4214 {
4215   return decoder->priv->packetized;
4216 }
4217
4218 /**
4219  * gst_video_decoder_set_estimate_rate:
4220  * @dec: a #GstVideoDecoder
4221  * @enabled: whether to enable byte to time conversion
4222  *
4223  * Allows baseclass to perform byte to time estimated conversion.
4224  */
4225 void
4226 gst_video_decoder_set_estimate_rate (GstVideoDecoder * dec, gboolean enabled)
4227 {
4228   g_return_if_fail (GST_IS_VIDEO_DECODER (dec));
4229
4230   dec->priv->do_estimate_rate = enabled;
4231 }
4232
4233 /**
4234  * gst_video_decoder_get_estimate_rate:
4235  * @dec: a #GstVideoDecoder
4236  *
4237  * Returns: currently configured byte to time conversion setting
4238  */
4239 gboolean
4240 gst_video_decoder_get_estimate_rate (GstVideoDecoder * dec)
4241 {
4242   g_return_val_if_fail (GST_IS_VIDEO_DECODER (dec), 0);
4243
4244   return dec->priv->do_estimate_rate;
4245 }
4246
4247 /**
4248  * gst_video_decoder_set_latency:
4249  * @decoder: a #GstVideoDecoder
4250  * @min_latency: minimum latency
4251  * @max_latency: maximum latency
4252  *
4253  * Lets #GstVideoDecoder sub-classes tell the baseclass what the decoder
4254  * latency is. Will also post a LATENCY message on the bus so the pipeline
4255  * can reconfigure its global latency.
4256  */
4257 void
4258 gst_video_decoder_set_latency (GstVideoDecoder * decoder,
4259     GstClockTime min_latency, GstClockTime max_latency)
4260 {
4261   g_return_if_fail (GST_CLOCK_TIME_IS_VALID (min_latency));
4262   g_return_if_fail (max_latency >= min_latency);
4263
4264   GST_OBJECT_LOCK (decoder);
4265   decoder->priv->min_latency = min_latency;
4266   decoder->priv->max_latency = max_latency;
4267   GST_OBJECT_UNLOCK (decoder);
4268
4269   gst_element_post_message (GST_ELEMENT_CAST (decoder),
4270       gst_message_new_latency (GST_OBJECT_CAST (decoder)));
4271 }
4272
4273 /**
4274  * gst_video_decoder_get_latency:
4275  * @decoder: a #GstVideoDecoder
4276  * @min_latency: (out) (allow-none): address of variable in which to store the
4277  *     configured minimum latency, or %NULL
4278  * @max_latency: (out) (allow-none): address of variable in which to store the
4279  *     configured mximum latency, or %NULL
4280  *
4281  * Query the configured decoder latency. Results will be returned via
4282  * @min_latency and @max_latency.
4283  */
4284 void
4285 gst_video_decoder_get_latency (GstVideoDecoder * decoder,
4286     GstClockTime * min_latency, GstClockTime * max_latency)
4287 {
4288   GST_OBJECT_LOCK (decoder);
4289   if (min_latency)
4290     *min_latency = decoder->priv->min_latency;
4291   if (max_latency)
4292     *max_latency = decoder->priv->max_latency;
4293   GST_OBJECT_UNLOCK (decoder);
4294 }
4295
4296 /**
4297  * gst_video_decoder_merge_tags:
4298  * @decoder: a #GstVideoDecoder
4299  * @tags: (allow-none): a #GstTagList to merge, or NULL to unset
4300  *     previously-set tags
4301  * @mode: the #GstTagMergeMode to use, usually #GST_TAG_MERGE_REPLACE
4302  *
4303  * Sets the audio decoder tags and how they should be merged with any
4304  * upstream stream tags. This will override any tags previously-set
4305  * with gst_audio_decoder_merge_tags().
4306  *
4307  * Note that this is provided for convenience, and the subclass is
4308  * not required to use this and can still do tag handling on its own.
4309  *
4310  * MT safe.
4311  */
4312 void
4313 gst_video_decoder_merge_tags (GstVideoDecoder * decoder,
4314     const GstTagList * tags, GstTagMergeMode mode)
4315 {
4316   g_return_if_fail (GST_IS_VIDEO_DECODER (decoder));
4317   g_return_if_fail (tags == NULL || GST_IS_TAG_LIST (tags));
4318   g_return_if_fail (tags == NULL || mode != GST_TAG_MERGE_UNDEFINED);
4319
4320   GST_VIDEO_DECODER_STREAM_LOCK (decoder);
4321   if (decoder->priv->tags != tags) {
4322     if (decoder->priv->tags) {
4323       gst_tag_list_unref (decoder->priv->tags);
4324       decoder->priv->tags = NULL;
4325       decoder->priv->tags_merge_mode = GST_TAG_MERGE_APPEND;
4326     }
4327     if (tags) {
4328       decoder->priv->tags = gst_tag_list_ref ((GstTagList *) tags);
4329       decoder->priv->tags_merge_mode = mode;
4330     }
4331
4332     GST_DEBUG_OBJECT (decoder, "set decoder tags to %" GST_PTR_FORMAT, tags);
4333     decoder->priv->tags_changed = TRUE;
4334   }
4335   GST_VIDEO_DECODER_STREAM_UNLOCK (decoder);
4336 }
4337
4338 /**
4339  * gst_video_decoder_get_buffer_pool:
4340  * @decoder: a #GstVideoDecoder
4341  *
4342  * Returns: (transfer full): the instance of the #GstBufferPool used
4343  * by the decoder; free it after use it
4344  */
4345 GstBufferPool *
4346 gst_video_decoder_get_buffer_pool (GstVideoDecoder * decoder)
4347 {
4348   g_return_val_if_fail (GST_IS_VIDEO_DECODER (decoder), NULL);
4349
4350   if (decoder->priv->pool)
4351     return gst_object_ref (decoder->priv->pool);
4352
4353   return NULL;
4354 }
4355
4356 /**
4357  * gst_video_decoder_get_allocator:
4358  * @decoder: a #GstVideoDecoder
4359  * @allocator: (out) (allow-none) (transfer full): the #GstAllocator
4360  * used
4361  * @params: (out) (allow-none) (transfer full): the
4362  * #GstAllocatorParams of @allocator
4363  *
4364  * Lets #GstVideoDecoder sub-classes to know the memory @allocator
4365  * used by the base class and its @params.
4366  *
4367  * Unref the @allocator after use it.
4368  */
4369 void
4370 gst_video_decoder_get_allocator (GstVideoDecoder * decoder,
4371     GstAllocator ** allocator, GstAllocationParams * params)
4372 {
4373   g_return_if_fail (GST_IS_VIDEO_DECODER (decoder));
4374
4375   if (allocator)
4376     *allocator = decoder->priv->allocator ?
4377         gst_object_ref (decoder->priv->allocator) : NULL;
4378
4379   if (params)
4380     *params = decoder->priv->params;
4381 }
4382
4383 /**
4384  * gst_video_decoder_set_use_default_pad_acceptcaps:
4385  * @decoder: a #GstVideoDecoder
4386  * @use: if the default pad accept-caps query handling should be used
4387  *
4388  * Lets #GstVideoDecoder sub-classes decide if they want the sink pad
4389  * to use the default pad query handler to reply to accept-caps queries.
4390  *
4391  * By setting this to true it is possible to further customize the default
4392  * handler with %GST_PAD_SET_ACCEPT_INTERSECT and
4393  * %GST_PAD_SET_ACCEPT_TEMPLATE
4394  *
4395  * Since: 1.6
4396  */
4397 void
4398 gst_video_decoder_set_use_default_pad_acceptcaps (GstVideoDecoder * decoder,
4399     gboolean use)
4400 {
4401   decoder->priv->use_default_pad_acceptcaps = use;
4402 }