subprojects/gst-libav/ext/libav/gstavviddec.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <assert.h>
  25 #include <string.h>
  26
  27 #include <libavcodec/avcodec.h>
  28 #include <libavutil/stereo3d.h>
  29 #include <libavutil/mastering_display_metadata.h>
  30
  31 #include "gstav.h"
  32 #include "gstavcodecmap.h"
  33 #include "gstavutils.h"
  34 #include "gstavviddec.h"
  35
  36 GST_DEBUG_CATEGORY_STATIC (GST_CAT_PERFORMANCE);
  37
  38 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58,132,100)
  39 #define AV_CODEC_CAP_OTHER_THREADS AV_CODEC_CAP_AUTO_THREADS
  40 #endif
  41
  42 #define GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED (1<<15)
  43
  44 #define MAX_TS_MASK 0xff
  45
  46 #define DEFAULT_LOWRES                  0
  47 #define DEFAULT_SKIPFRAME               0
  48 #define DEFAULT_DIRECT_RENDERING        TRUE
  49 #define DEFAULT_MAX_THREADS             0
  50 #define DEFAULT_OUTPUT_CORRUPT          TRUE
  51 #define REQUIRED_POOL_MAX_BUFFERS       32
  52 #define DEFAULT_STRIDE_ALIGN            31
  53 #define DEFAULT_ALLOC_PARAM             { 0, DEFAULT_STRIDE_ALIGN, 0, 0, }
  54 #define DEFAULT_THREAD_TYPE             0
  55 #define DEFAULT_STD_COMPLIANCE   GST_AV_CODEC_COMPLIANCE_AUTO
  56
  57 enum
  58 {
  59   PROP_0,
  60   PROP_LOWRES,
  61   PROP_SKIPFRAME,
  62   PROP_DIRECT_RENDERING,
  63   PROP_DEBUG_MV,
  64   PROP_MAX_THREADS,
  65   PROP_OUTPUT_CORRUPT,
  66   PROP_THREAD_TYPE,
  67   PROP_STD_COMPLIANCE,
  68   PROP_LAST
  69 };
  70
  71 /* A number of function prototypes are given so we can refer to them later. */
  72 static void gst_ffmpegviddec_finalize (GObject * object);
  73
  74 static gboolean gst_ffmpegviddec_set_format (GstVideoDecoder * decoder,
  75     GstVideoCodecState * state);
  76 static GstFlowReturn gst_ffmpegviddec_handle_frame (GstVideoDecoder * decoder,
  77     GstVideoCodecFrame * frame);
  78 static gboolean gst_ffmpegviddec_start (GstVideoDecoder * decoder);
  79 static gboolean gst_ffmpegviddec_stop (GstVideoDecoder * decoder);
  80 static gboolean gst_ffmpegviddec_flush (GstVideoDecoder * decoder);
  81 static gboolean gst_ffmpegviddec_decide_allocation (GstVideoDecoder * decoder,
  82     GstQuery * query);
  83 static gboolean gst_ffmpegviddec_propose_allocation (GstVideoDecoder * decoder,
  84     GstQuery * query);
  85
  86 static void gst_ffmpegviddec_set_property (GObject * object,
  87     guint prop_id, const GValue * value, GParamSpec * pspec);
  88 static void gst_ffmpegviddec_get_property (GObject * object,
  89     guint prop_id, GValue * value, GParamSpec * pspec);
  90
  91 static gboolean gst_ffmpegviddec_negotiate (GstFFMpegVidDec * ffmpegdec,
  92     AVCodecContext * context, AVFrame * picture, GstBufferFlags flags);
  93
  94 /* some sort of bufferpool handling, but different */
  95 static int gst_ffmpegviddec_get_buffer2 (AVCodecContext * context,
  96     AVFrame * picture, int flags);
  97 static gboolean gst_ffmpegviddec_can_direct_render (GstFFMpegVidDec *
  98     ffmpegdec);
  99
 100 static GstFlowReturn gst_ffmpegviddec_finish (GstVideoDecoder * decoder);
 101 static GstFlowReturn gst_ffmpegviddec_drain (GstVideoDecoder * decoder);
 102
 103 static gboolean picture_changed (GstFFMpegVidDec * ffmpegdec,
 104     AVFrame * picture, gboolean one_field);
 105 static gboolean context_changed (GstFFMpegVidDec * ffmpegdec,
 106     AVCodecContext * context);
 107
 108 G_DEFINE_ABSTRACT_TYPE (GstFFMpegVidDec, gst_ffmpegviddec,
 109     GST_TYPE_VIDEO_DECODER);
 110
 111 #define parent_class gst_ffmpegviddec_parent_class
 112
 113 #define GST_FFMPEGVIDDEC_TYPE_LOWRES (gst_ffmpegviddec_lowres_get_type())
 114 static GType
 115 gst_ffmpegviddec_lowres_get_type (void)
 116 {
 117   static GType ffmpegdec_lowres_type = 0;
 118
 119   if (!ffmpegdec_lowres_type) {
 120     static const GEnumValue ffmpegdec_lowres[] = {
 121       {0, "0", "full"},
 122       {1, "1", "1/2-size"},
 123       {2, "2", "1/4-size"},
 124       {0, NULL, NULL},
 125     };
 126
 127     ffmpegdec_lowres_type =
 128         g_enum_register_static ("GstLibAVVidDecLowres", ffmpegdec_lowres);
 129   }
 130
 131   return ffmpegdec_lowres_type;
 132 }
 133
 134 #define GST_FFMPEGVIDDEC_TYPE_SKIPFRAME (gst_ffmpegviddec_skipframe_get_type())
 135 static GType
 136 gst_ffmpegviddec_skipframe_get_type (void)
 137 {
 138   static GType ffmpegdec_skipframe_type = 0;
 139
 140   if (!ffmpegdec_skipframe_type) {
 141     static const GEnumValue ffmpegdec_skipframe[] = {
 142       {0, "0", "Skip nothing"},
 143       {1, "1", "Skip B-frames"},
 144       {2, "2", "Skip IDCT/Dequantization"},
 145       {5, "5", "Skip everything"},
 146       {0, NULL, NULL},
 147     };
 148
 149     ffmpegdec_skipframe_type =
 150         g_enum_register_static ("GstLibAVVidDecSkipFrame", ffmpegdec_skipframe);
 151   }
 152
 153   return ffmpegdec_skipframe_type;
 154 }
 155
 156 static const GFlagsValue ffmpegdec_thread_types[] = {
 157   {0x0, "Auto", "auto"},
 158   {0x1, "Frame", "frame"},
 159   {0x2, "Slice", "slice"},
 160   {0, NULL, NULL},
 161 };
 162
 163 #define GST_FFMPEGVIDDEC_TYPE_THREAD_TYPE (gst_ffmpegviddec_thread_type_get_type())
 164 static GType
 165 gst_ffmpegviddec_thread_type_get_type (void)
 166 {
 167   static GType ffmpegdec_thread_type_type = 0;
 168
 169   if (!ffmpegdec_thread_type_type) {
 170     ffmpegdec_thread_type_type =
 171         g_flags_register_static ("GstLibAVVidDecThreadType",
 172         ffmpegdec_thread_types);
 173   }
 174   return ffmpegdec_thread_type_type;
 175 }
 176
 177 static GstCaps *
 178 dup_caps_with_alternate (GstCaps * caps)
 179 {
 180   GstCaps *with_alternate;
 181   GstCapsFeatures *features;
 182
 183   with_alternate = gst_caps_copy (caps);
 184   features = gst_caps_features_new (GST_CAPS_FEATURE_FORMAT_INTERLACED, NULL);
 185   gst_caps_set_features_simple (with_alternate, features);
 186
 187   gst_caps_set_simple (with_alternate, "interlace-mode", G_TYPE_STRING,
 188       "alternate", NULL);
 189
 190   return with_alternate;
 191 }
 192
 193 static void
 194 gst_ffmpegviddec_class_init (GstFFMpegVidDecClass * klass)
 195 {
 196   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 197
 198   gobject_class->set_property = gst_ffmpegviddec_set_property;
 199   gobject_class->get_property = gst_ffmpegviddec_get_property;
 200
 201   /**
 202    * GstFFMpegVidDec:std-compliance:
 203    *
 204    * Specifies standard compliance mode to use
 205    *
 206    * Since: 1.22
 207    */
 208   g_object_class_install_property (gobject_class, PROP_STD_COMPLIANCE,
 209       g_param_spec_enum ("std-compliance", "Standard Compliance",
 210           "Standard compliance mode to use", GST_TYPE_AV_CODEC_COMPLIANCE,
 211           DEFAULT_STD_COMPLIANCE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 212 }
 213
 214 static void
 215 gst_ffmpegviddec_subclass_init (GstFFMpegVidDecClass * klass,
 216     gconstpointer class_data)
 217 {
 218   GstVideoDecoderClass *viddec_class = GST_VIDEO_DECODER_CLASS (klass);
 219   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 220   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 221   GstPadTemplate *sinktempl, *srctempl;
 222   GstCaps *sinkcaps, *srccaps;
 223   const AVCodec *in_plugin;
 224   gchar *longname, *description;
 225   int caps;
 226
 227   in_plugin = class_data;
 228   g_assert (in_plugin != NULL);
 229
 230   /* construct the element details struct */
 231   longname = g_strdup_printf ("libav %s decoder", in_plugin->long_name);
 232   description = g_strdup_printf ("libav %s decoder", in_plugin->name);
 233   gst_element_class_set_metadata (element_class, longname,
 234       "Codec/Decoder/Video", description,
 235       "Wim Taymans <wim.taymans@gmail.com>, "
 236       "Ronald Bultje <rbultje@ronald.bitfreak.net>, "
 237       "Edward Hervey <bilboed@bilboed.com>");
 238   g_free (longname);
 239   g_free (description);
 240
 241   /* get the caps */
 242   sinkcaps = gst_ffmpeg_codecid_to_caps (in_plugin->id, NULL, FALSE);
 243   if (!sinkcaps) {
 244     GST_DEBUG ("Couldn't get sink caps for decoder '%s'", in_plugin->name);
 245     sinkcaps = gst_caps_new_empty_simple ("unknown/unknown");
 246   }
 247   srccaps = gst_ffmpeg_codectype_to_video_caps (NULL,
 248       in_plugin->id, FALSE, in_plugin);
 249   if (!srccaps) {
 250     GST_DEBUG ("Couldn't get source caps for decoder '%s'", in_plugin->name);
 251     srccaps = gst_caps_from_string ("video/x-raw");
 252   }
 253   gst_caps_append (srccaps, dup_caps_with_alternate (srccaps));
 254
 255   /* pad templates */
 256   sinktempl = gst_pad_template_new ("sink", GST_PAD_SINK,
 257       GST_PAD_ALWAYS, sinkcaps);
 258   srctempl = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, srccaps);
 259
 260   gst_element_class_add_pad_template (element_class, srctempl);
 261   gst_element_class_add_pad_template (element_class, sinktempl);
 262
 263   gst_caps_unref (sinkcaps);
 264   gst_caps_unref (srccaps);
 265
 266   klass->in_plugin = in_plugin;
 267
 268   gobject_class->finalize = gst_ffmpegviddec_finalize;
 269
 270   gobject_class->set_property = gst_ffmpegviddec_set_property;
 271   gobject_class->get_property = gst_ffmpegviddec_get_property;
 272
 273   g_object_class_install_property (gobject_class, PROP_SKIPFRAME,
 274       g_param_spec_enum ("skip-frame", "Skip frames",
 275           "Which types of frames to skip during decoding",
 276           GST_FFMPEGVIDDEC_TYPE_SKIPFRAME, 0,
 277           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 278   g_object_class_install_property (gobject_class, PROP_LOWRES,
 279       g_param_spec_enum ("lowres", "Low resolution",
 280           "At which resolution to decode images",
 281           GST_FFMPEGVIDDEC_TYPE_LOWRES, 0,
 282           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 283   g_object_class_install_property (gobject_class, PROP_DIRECT_RENDERING,
 284       g_param_spec_boolean ("direct-rendering", "Direct Rendering",
 285           "Enable direct rendering", DEFAULT_DIRECT_RENDERING,
 286           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 287 #ifndef GST_REMOVE_DEPRECATED
 288   g_object_class_install_property (gobject_class, PROP_DEBUG_MV,
 289       g_param_spec_boolean ("debug-mv", "Debug motion vectors",
 290           "Whether to print motion vectors on top of the image "
 291           "(deprecated, non-functional)", FALSE,
 292           G_PARAM_DEPRECATED | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 293 #endif
 294   g_object_class_install_property (gobject_class, PROP_OUTPUT_CORRUPT,
 295       g_param_spec_boolean ("output-corrupt", "Output corrupt buffers",
 296           "Whether libav should output frames even if corrupted",
 297           DEFAULT_OUTPUT_CORRUPT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 298
 299   caps = klass->in_plugin->capabilities;
 300   if (caps & (AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS)) {
 301     g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MAX_THREADS,
 302         g_param_spec_int ("max-threads", "Maximum decode threads",
 303             "Maximum number of worker threads to spawn. (0 = auto)",
 304             0, G_MAXINT, DEFAULT_MAX_THREADS,
 305             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 306     g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_THREAD_TYPE,
 307         g_param_spec_flags ("thread-type", "Thread type",
 308             "Multithreading methods to use",
 309             GST_FFMPEGVIDDEC_TYPE_THREAD_TYPE,
 310             DEFAULT_THREAD_TYPE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 311   }
 312
 313   viddec_class->set_format = gst_ffmpegviddec_set_format;
 314   viddec_class->handle_frame = gst_ffmpegviddec_handle_frame;
 315   viddec_class->start = gst_ffmpegviddec_start;
 316   viddec_class->stop = gst_ffmpegviddec_stop;
 317   viddec_class->flush = gst_ffmpegviddec_flush;
 318   viddec_class->finish = gst_ffmpegviddec_finish;
 319   viddec_class->drain = gst_ffmpegviddec_drain;
 320   viddec_class->decide_allocation = gst_ffmpegviddec_decide_allocation;
 321   viddec_class->propose_allocation = gst_ffmpegviddec_propose_allocation;
 322
 323   GST_DEBUG_CATEGORY_GET (GST_CAT_PERFORMANCE, "GST_PERFORMANCE");
 324
 325   gst_type_mark_as_plugin_api (GST_FFMPEGVIDDEC_TYPE_LOWRES, 0);
 326   gst_type_mark_as_plugin_api (GST_FFMPEGVIDDEC_TYPE_SKIPFRAME, 0);
 327   gst_type_mark_as_plugin_api (GST_FFMPEGVIDDEC_TYPE_THREAD_TYPE, 0);
 328   gst_type_mark_as_plugin_api (GST_TYPE_AV_CODEC_COMPLIANCE, 0);
 329   gst_type_mark_as_plugin_api (GST_TYPE_FFMPEGVIDDEC, 0);
 330 }
 331
 332 static void
 333 gst_ffmpegviddec_init (GstFFMpegVidDec * ffmpegdec)
 334 {
 335 }
 336
 337 static void
 338 gst_ffmpegviddec_subinit (GstFFMpegVidDec * ffmpegdec)
 339 {
 340   GstFFMpegVidDecClass *klass =
 341       (GstFFMpegVidDecClass *) G_OBJECT_GET_CLASS (ffmpegdec);
 342
 343   /* some ffmpeg data */
 344   ffmpegdec->context = avcodec_alloc_context3 (klass->in_plugin);
 345   ffmpegdec->context->opaque = ffmpegdec;
 346   ffmpegdec->picture = av_frame_alloc ();
 347   ffmpegdec->opened = FALSE;
 348   ffmpegdec->skip_frame = ffmpegdec->lowres = 0;
 349   ffmpegdec->direct_rendering = DEFAULT_DIRECT_RENDERING;
 350   ffmpegdec->max_threads = DEFAULT_MAX_THREADS;
 351   ffmpegdec->output_corrupt = DEFAULT_OUTPUT_CORRUPT;
 352   ffmpegdec->thread_type = DEFAULT_THREAD_TYPE;
 353   ffmpegdec->std_compliance = DEFAULT_STD_COMPLIANCE;
 354
 355   GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_DECODER_SINK_PAD (ffmpegdec));
 356   gst_video_decoder_set_use_default_pad_acceptcaps (GST_VIDEO_DECODER_CAST
 357       (ffmpegdec), TRUE);
 358
 359   gst_video_decoder_set_needs_format (GST_VIDEO_DECODER (ffmpegdec), TRUE);
 360 }
 361
 362 static void
 363 gst_ffmpegviddec_finalize (GObject * object)
 364 {
 365   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (object);
 366
 367   av_frame_free (&ffmpegdec->picture);
 368   avcodec_free_context (&ffmpegdec->context);
 369
 370   G_OBJECT_CLASS (parent_class)->finalize (object);
 371 }
 372
 373 static void
 374 gst_ffmpegviddec_context_set_flags (AVCodecContext * context, guint flags,
 375     gboolean enable)
 376 {
 377   g_return_if_fail (context != NULL);
 378
 379   if (enable)
 380     context->flags |= flags;
 381   else
 382     context->flags &= ~flags;
 383 }
 384
 385 static void
 386 gst_ffmpegviddec_context_set_flags2 (AVCodecContext * context, guint flags,
 387     gboolean enable)
 388 {
 389   g_return_if_fail (context != NULL);
 390
 391   if (enable)
 392     context->flags2 |= flags;
 393   else
 394     context->flags2 &= ~flags;
 395 }
 396
 397 /* with LOCK */
 398 static gboolean
 399 gst_ffmpegviddec_close (GstFFMpegVidDec * ffmpegdec, gboolean reset)
 400 {
 401   GstFFMpegVidDecClass *oclass;
 402   guint i;
 403
 404   oclass = GST_FFMPEGVIDDEC_GET_CLASS (ffmpegdec);
 405
 406   GST_LOG_OBJECT (ffmpegdec, "closing ffmpeg codec");
 407
 408   gst_caps_replace (&ffmpegdec->last_caps, NULL);
 409
 410   gst_ffmpeg_avcodec_close (ffmpegdec->context);
 411   ffmpegdec->opened = FALSE;
 412
 413   for (i = 0; i < G_N_ELEMENTS (ffmpegdec->stride); i++)
 414     ffmpegdec->stride[i] = -1;
 415
 416   gst_buffer_replace (&ffmpegdec->palette, NULL);
 417
 418   av_freep (&ffmpegdec->context->extradata);
 419   if (reset) {
 420     avcodec_free_context (&ffmpegdec->context);
 421     ffmpegdec->context = avcodec_alloc_context3 (oclass->in_plugin);
 422     if (ffmpegdec->context == NULL) {
 423       GST_DEBUG_OBJECT (ffmpegdec, "Failed to set context defaults");
 424       return FALSE;
 425     }
 426     ffmpegdec->context->opaque = ffmpegdec;
 427   }
 428   return TRUE;
 429 }
 430
 431 /* with LOCK */
 432 static gboolean
 433 gst_ffmpegviddec_open (GstFFMpegVidDec * ffmpegdec)
 434 {
 435   GstFFMpegVidDecClass *oclass;
 436   guint i;
 437
 438   oclass = GST_FFMPEGVIDDEC_GET_CLASS (ffmpegdec);
 439
 440   if (gst_ffmpeg_avcodec_open (ffmpegdec->context, oclass->in_plugin) < 0)
 441     goto could_not_open;
 442
 443   for (i = 0; i < G_N_ELEMENTS (ffmpegdec->stride); i++)
 444     ffmpegdec->stride[i] = -1;
 445
 446   ffmpegdec->opened = TRUE;
 447
 448   GST_LOG_OBJECT (ffmpegdec, "Opened libav codec %s, id %d",
 449       oclass->in_plugin->name, oclass->in_plugin->id);
 450
 451   gst_ffmpegviddec_context_set_flags (ffmpegdec->context,
 452       AV_CODEC_FLAG_OUTPUT_CORRUPT, ffmpegdec->output_corrupt);
 453
 454   return TRUE;
 455
 456   /* ERRORS */
 457 could_not_open:
 458   {
 459     gst_ffmpegviddec_close (ffmpegdec, TRUE);
 460     GST_DEBUG_OBJECT (ffmpegdec, "avdec_%s: Failed to open libav codec",
 461         oclass->in_plugin->name);
 462     return FALSE;
 463   }
 464 }
 465
 466 static void
 467 gst_ffmpegviddec_get_palette (GstFFMpegVidDec * ffmpegdec,
 468     GstVideoCodecState * state)
 469 {
 470   GstStructure *str = gst_caps_get_structure (state->caps, 0);
 471   const GValue *palette_v;
 472   GstBuffer *palette;
 473
 474   /* do we have a palette? */
 475   if ((palette_v = gst_structure_get_value (str, "palette_data"))) {
 476     palette = gst_value_get_buffer (palette_v);
 477     GST_DEBUG ("got palette data %p", palette);
 478     if (gst_buffer_get_size (palette) >= AVPALETTE_SIZE) {
 479       gst_buffer_replace (&ffmpegdec->palette, palette);
 480     }
 481   }
 482 }
 483
 484 static gboolean
 485 gst_ffmpegviddec_needs_reset (GstFFMpegVidDec * ffmpegdec,
 486     GstVideoCodecState * state)
 487 {
 488   GstCaps *last_caps, *new_caps;
 489   gboolean needs_reset;
 490
 491   if (ffmpegdec->last_caps == NULL)
 492     return TRUE;
 493
 494   last_caps = gst_caps_copy (ffmpegdec->last_caps);
 495   new_caps = gst_caps_copy (state->caps);
 496
 497   /* Simply ignore framerate for now, this could easily be evolved per CODEC if
 498    * future issue are found.*/
 499   gst_structure_remove_field (gst_caps_get_structure (last_caps, 0),
 500       "framerate");
 501   gst_structure_remove_field (gst_caps_get_structure (new_caps, 0),
 502       "framerate");
 503
 504   needs_reset = !gst_caps_is_equal (last_caps, new_caps);
 505
 506   gst_caps_unref (last_caps);
 507   gst_caps_unref (new_caps);
 508
 509   return needs_reset;
 510 }
 511
 512 static gboolean
 513 gst_ffmpegviddec_set_format (GstVideoDecoder * decoder,
 514     GstVideoCodecState * state)
 515 {
 516   GstFFMpegVidDec *ffmpegdec;
 517   GstFFMpegVidDecClass *oclass;
 518   GstClockTime latency = GST_CLOCK_TIME_NONE;
 519   gboolean ret = FALSE;
 520   gboolean is_live;
 521   GstQuery *query;
 522
 523   ffmpegdec = GST_FFMPEGVIDDEC (decoder);
 524   oclass = GST_FFMPEGVIDDEC_GET_CLASS (ffmpegdec);
 525
 526   GST_DEBUG_OBJECT (ffmpegdec, "setcaps called");
 527
 528   GST_OBJECT_LOCK (ffmpegdec);
 529
 530   if (!gst_ffmpegviddec_needs_reset (ffmpegdec, state)) {
 531     gst_caps_replace (&ffmpegdec->last_caps, state->caps);
 532     goto update_state;
 533   }
 534
 535   /* close old session */
 536   if (ffmpegdec->opened) {
 537     GST_OBJECT_UNLOCK (ffmpegdec);
 538     gst_ffmpegviddec_finish (decoder);
 539     GST_OBJECT_LOCK (ffmpegdec);
 540     if (!gst_ffmpegviddec_close (ffmpegdec, TRUE)) {
 541       GST_OBJECT_UNLOCK (ffmpegdec);
 542       return FALSE;
 543     }
 544     ffmpegdec->pic_pix_fmt = 0;
 545     ffmpegdec->pic_width = 0;
 546     ffmpegdec->pic_height = 0;
 547     ffmpegdec->pic_par_n = 0;
 548     ffmpegdec->pic_par_d = 0;
 549     ffmpegdec->pic_interlaced = 0;
 550     ffmpegdec->pic_field_order = 0;
 551     ffmpegdec->pic_field_order_changed = FALSE;
 552     ffmpegdec->ctx_ticks = 0;
 553     ffmpegdec->ctx_time_n = 0;
 554     ffmpegdec->ctx_time_d = 0;
 555     ffmpegdec->cur_multiview_mode = GST_VIDEO_MULTIVIEW_MODE_NONE;
 556     ffmpegdec->cur_multiview_flags = GST_VIDEO_MULTIVIEW_FLAGS_NONE;
 557   }
 558
 559   gst_caps_replace (&ffmpegdec->last_caps, state->caps);
 560
 561   /* set buffer functions */
 562   ffmpegdec->context->get_buffer2 = gst_ffmpegviddec_get_buffer2;
 563   ffmpegdec->context->draw_horiz_band = NULL;
 564
 565   /* reset coded_width/_height to prevent it being reused from last time when
 566    * the codec is opened again, causing a mismatch and possible
 567    * segfault/corruption. (Common scenario when renegotiating caps) */
 568   ffmpegdec->context->coded_width = 0;
 569   ffmpegdec->context->coded_height = 0;
 570
 571   GST_LOG_OBJECT (ffmpegdec, "size %dx%d", ffmpegdec->context->width,
 572       ffmpegdec->context->height);
 573
 574   /* FIXME : Create a method that takes GstVideoCodecState instead */
 575   /* get size and so */
 576   gst_ffmpeg_caps_with_codecid (oclass->in_plugin->id,
 577       oclass->in_plugin->type, state->caps, ffmpegdec->context);
 578
 579   GST_LOG_OBJECT (ffmpegdec, "size after %dx%d", ffmpegdec->context->width,
 580       ffmpegdec->context->height);
 581
 582   gst_ffmpegviddec_get_palette (ffmpegdec, state);
 583
 584   if (!ffmpegdec->context->time_base.den || !ffmpegdec->context->time_base.num) {
 585     GST_DEBUG_OBJECT (ffmpegdec, "forcing 25/1 framerate");
 586     ffmpegdec->context->time_base.num = 1;
 587     ffmpegdec->context->time_base.den = 25;
 588   }
 589
 590   /* workaround encoder bugs */
 591   ffmpegdec->context->workaround_bugs |= FF_BUG_AUTODETECT;
 592   ffmpegdec->context->err_recognition = 1;
 593
 594   /* for slow cpus */
 595   ffmpegdec->context->lowres = ffmpegdec->lowres;
 596   ffmpegdec->context->skip_frame = ffmpegdec->skip_frame;
 597
 598
 599   query = gst_query_new_latency ();
 600   is_live = FALSE;
 601   /* Check if upstream is live. If it isn't we can enable frame based
 602    * threading, which is adding latency */
 603   if (gst_pad_peer_query (GST_VIDEO_DECODER_SINK_PAD (ffmpegdec), query)) {
 604     gst_query_parse_latency (query, &is_live, NULL, NULL);
 605   }
 606   gst_query_unref (query);
 607
 608   if (ffmpegdec->thread_type) {
 609     GST_DEBUG_OBJECT (ffmpegdec, "Use requested thread type 0x%x",
 610         ffmpegdec->thread_type);
 611     ffmpegdec->context->thread_type = ffmpegdec->thread_type;
 612   } else {
 613     if (is_live)
 614       ffmpegdec->context->thread_type = FF_THREAD_SLICE;
 615     else
 616       ffmpegdec->context->thread_type = FF_THREAD_SLICE | FF_THREAD_FRAME;
 617   }
 618
 619   if (ffmpegdec->max_threads == 0) {
 620     /* When thread type is FF_THREAD_FRAME, extra latency is introduced equal
 621      * to one frame per thread. We thus need to calculate the thread count ourselves */
 622     if ((!(oclass->in_plugin->capabilities & AV_CODEC_CAP_OTHER_THREADS)) ||
 623         (ffmpegdec->context->thread_type & FF_THREAD_FRAME))
 624       ffmpegdec->context->thread_count =
 625           MIN (gst_ffmpeg_auto_max_threads (), 16);
 626     else
 627       ffmpegdec->context->thread_count = 0;
 628   } else
 629     ffmpegdec->context->thread_count = ffmpegdec->max_threads;
 630
 631   if (ffmpegdec->std_compliance == GST_AV_CODEC_COMPLIANCE_AUTO) {
 632     /* Normal yields lower latency, but fails some compliance check */
 633     if (is_live || ffmpegdec->context->thread_type == FF_THREAD_SLICE) {
 634       ffmpegdec->context->strict_std_compliance =
 635           GST_AV_CODEC_COMPLIANCE_NORMAL;
 636     } else {
 637       ffmpegdec->context->strict_std_compliance =
 638           GST_AV_CODEC_COMPLIANCE_STRICT;
 639     }
 640   } else {
 641     ffmpegdec->context->strict_std_compliance = ffmpegdec->std_compliance;
 642   }
 643
 644   if (oclass->in_plugin->id == AV_CODEC_ID_H264) {
 645     GstStructure *s = gst_caps_get_structure (state->caps, 0);
 646     const char *alignment;
 647     gboolean nal_aligned;
 648
 649     alignment = gst_structure_get_string (s, "alignment");
 650     nal_aligned = !g_strcmp0 (alignment, "nal");
 651     if (nal_aligned) {
 652       if (ffmpegdec->context->thread_type == FF_THREAD_FRAME)
 653         goto nal_only_slice;
 654       ffmpegdec->context->thread_type = FF_THREAD_SLICE;
 655     }
 656
 657     gst_ffmpegviddec_context_set_flags2 (ffmpegdec->context,
 658         AV_CODEC_FLAG2_CHUNKS, nal_aligned);
 659     gst_video_decoder_set_subframe_mode (decoder, nal_aligned);
 660   }
 661
 662   /* open codec - we don't select an output pix_fmt yet,
 663    * simply because we don't know! We only get it
 664    * during playback... */
 665   if (!gst_ffmpegviddec_open (ffmpegdec))
 666     goto open_failed;
 667
 668 update_state:
 669   if (ffmpegdec->input_state)
 670     gst_video_codec_state_unref (ffmpegdec->input_state);
 671   ffmpegdec->input_state = gst_video_codec_state_ref (state);
 672
 673   /* Use the framerate values stored in the decoder for calculating latency. The
 674    * upstream framerate might not be set but we still want to report a latency
 675    * if needed. */
 676   if (ffmpegdec->context->time_base.den && ffmpegdec->context->ticks_per_frame) {
 677     gint fps_n =
 678         ffmpegdec->context->time_base.den / ffmpegdec->context->ticks_per_frame;
 679     gint fps_d = ffmpegdec->context->time_base.num;
 680     latency = gst_util_uint64_scale_ceil (
 681         (ffmpegdec->context->has_b_frames) * GST_SECOND, fps_d, fps_n);
 682
 683     if (ffmpegdec->context->thread_type & FF_THREAD_FRAME) {
 684       latency +=
 685           gst_util_uint64_scale_ceil (ffmpegdec->context->thread_count *
 686           GST_SECOND, fps_d, fps_n);
 687     }
 688   }
 689
 690   ret = TRUE;
 691
 692 done:
 693   GST_OBJECT_UNLOCK (ffmpegdec);
 694
 695   if (GST_CLOCK_TIME_IS_VALID (latency))
 696     gst_video_decoder_set_latency (decoder, latency, latency);
 697
 698   return ret;
 699
 700   /* ERRORS */
 701 open_failed:
 702   {
 703     GST_DEBUG_OBJECT (ffmpegdec, "Failed to open");
 704     goto done;
 705   }
 706 nal_only_slice:
 707   {
 708     GST_ERROR_OBJECT (ffmpegdec,
 709         "Can't do NAL aligned H.264 with frame threading.");
 710     goto done;
 711   }
 712 }
 713
 714 typedef struct
 715 {
 716   GstFFMpegVidDec *ffmpegdec;
 717   GstVideoCodecFrame *frame;
 718   gboolean mapped;
 719   GstVideoFrame vframe;
 720   GstBuffer *buffer;
 721   AVBufferRef *avbuffer;
 722 } GstFFMpegVidDecVideoFrame;
 723
 724 static GstFFMpegVidDecVideoFrame *
 725 gst_ffmpegviddec_video_frame_new (GstFFMpegVidDec * ffmpegdec,
 726     GstVideoCodecFrame * frame)
 727 {
 728   GstFFMpegVidDecVideoFrame *dframe;
 729
 730   dframe = g_slice_new0 (GstFFMpegVidDecVideoFrame);
 731   dframe->ffmpegdec = ffmpegdec;
 732   dframe->frame = frame;
 733
 734   GST_DEBUG_OBJECT (ffmpegdec, "new video frame %p", dframe);
 735
 736   return dframe;
 737 }
 738
 739 static void
 740 gst_ffmpegviddec_video_frame_free (GstFFMpegVidDec * ffmpegdec,
 741     GstFFMpegVidDecVideoFrame * frame)
 742 {
 743   GST_DEBUG_OBJECT (ffmpegdec, "free video frame %p", frame);
 744
 745   if (frame->mapped)
 746     gst_video_frame_unmap (&frame->vframe);
 747   GST_VIDEO_CODEC_FRAME_FLAG_UNSET (frame->frame,
 748       GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
 749   gst_video_decoder_release_frame (GST_VIDEO_DECODER (ffmpegdec), frame->frame);
 750   gst_buffer_replace (&frame->buffer, NULL);
 751   if (frame->avbuffer) {
 752     av_buffer_unref (&frame->avbuffer);
 753   }
 754   g_slice_free (GstFFMpegVidDecVideoFrame, frame);
 755 }
 756
 757 static void
 758 dummy_free_buffer (void *opaque, uint8_t * data)
 759 {
 760   GstFFMpegVidDecVideoFrame *frame = opaque;
 761
 762   gst_ffmpegviddec_video_frame_free (frame->ffmpegdec, frame);
 763 }
 764
 765 /* This function prepares the pool configuration for direct rendering. To use
 766  * this method, the codec should support direct rendering and the pool should
 767  * support video meta and video alignment */
 768 static void
 769 gst_ffmpegvideodec_prepare_dr_pool (GstFFMpegVidDec * ffmpegdec,
 770     GstBufferPool * pool, GstVideoInfo * info, GstStructure * config)
 771 {
 772   GstAllocationParams params;
 773   GstVideoAlignment align;
 774   GstAllocator *allocator = NULL;
 775   gint width, height;
 776   gint linesize_align[AV_NUM_DATA_POINTERS];
 777   gint i;
 778   gsize max_align;
 779
 780   width = GST_VIDEO_INFO_WIDTH (info);
 781   height = MAX (GST_VIDEO_INFO_HEIGHT (info), ffmpegdec->context->coded_height);
 782
 783   /* let ffmpeg find the alignment and padding */
 784   avcodec_align_dimensions2 (ffmpegdec->context, &width, &height,
 785       linesize_align);
 786
 787   align.padding_top = 0;
 788   align.padding_left = 0;
 789   align.padding_right = width - GST_VIDEO_INFO_WIDTH (info);
 790   align.padding_bottom = height - GST_VIDEO_INFO_HEIGHT (info);
 791
 792   /* add extra padding to match libav buffer allocation sizes */
 793   align.padding_bottom++;
 794
 795   gst_buffer_pool_config_get_allocator (config, &allocator, &params);
 796
 797   max_align = DEFAULT_STRIDE_ALIGN;
 798   max_align |= params.align;
 799
 800   for (i = 0; i < GST_VIDEO_MAX_PLANES; i++) {
 801     if (linesize_align[i] > 0)
 802       max_align |= linesize_align[i] - 1;
 803   }
 804
 805   for (i = 0; i < GST_VIDEO_MAX_PLANES; i++)
 806     align.stride_align[i] = max_align;
 807
 808   params.align = max_align;
 809
 810   gst_buffer_pool_config_set_allocator (config, allocator, &params);
 811
 812   GST_DEBUG_OBJECT (ffmpegdec, "aligned dimension %dx%d -> %dx%d "
 813       "padding t:%u l:%u r:%u b:%u, stride_align %d:%d:%d:%d",
 814       GST_VIDEO_INFO_WIDTH (info),
 815       GST_VIDEO_INFO_HEIGHT (info), width, height, align.padding_top,
 816       align.padding_left, align.padding_right, align.padding_bottom,
 817       align.stride_align[0], align.stride_align[1], align.stride_align[2],
 818       align.stride_align[3]);
 819
 820   gst_buffer_pool_config_add_option (config,
 821       GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
 822   gst_buffer_pool_config_set_video_alignment (config, &align);
 823 }
 824
 825 static void
 826 gst_ffmpegviddec_ensure_internal_pool (GstFFMpegVidDec * ffmpegdec,
 827     AVFrame * picture, GstVideoInterlaceMode interlace_mode)
 828 {
 829   GstAllocationParams params = DEFAULT_ALLOC_PARAM;
 830   GstVideoInfo info;
 831   GstVideoFormat format;
 832   GstCaps *caps;
 833   GstStructure *config;
 834   guint i;
 835
 836   format = gst_ffmpeg_pixfmt_to_videoformat (picture->format);
 837
 838   if (ffmpegdec->internal_pool != NULL &&
 839       GST_VIDEO_INFO_FORMAT (&ffmpegdec->pool_info) == format &&
 840       ffmpegdec->pool_width == picture->width &&
 841       ffmpegdec->pool_height == picture->height &&
 842       ffmpegdec->pool_format == picture->format)
 843     return;
 844
 845   GST_DEBUG_OBJECT (ffmpegdec, "Updating internal pool (%i, %i)",
 846       picture->width, picture->height);
 847
 848   /* if we are negotiating from get_buffer, then renegotiate later in order
 849    * to potentially use a downstream pool */
 850   if (gst_ffmpegviddec_can_direct_render (ffmpegdec))
 851     gst_pad_mark_reconfigure (GST_VIDEO_DECODER_SRC_PAD (ffmpegdec));
 852
 853   format = gst_ffmpeg_pixfmt_to_videoformat (picture->format);
 854
 855   if (interlace_mode == GST_VIDEO_INTERLACE_MODE_ALTERNATE) {
 856     gst_video_info_set_interlaced_format (&info, format, interlace_mode,
 857         picture->width, 2 * picture->height);
 858   } else {
 859     gst_video_info_set_format (&info, format, picture->width, picture->height);
 860   }
 861
 862   /* If we have not yet been negotiated, a NONE format here would
 863    * result in invalid initial dimension alignments, and potential
 864    * out of bounds writes.
 865    */
 866   ffmpegdec->context->pix_fmt = picture->format;
 867
 868   for (i = 0; i < G_N_ELEMENTS (ffmpegdec->stride); i++)
 869     ffmpegdec->stride[i] = -1;
 870
 871   if (ffmpegdec->internal_pool)
 872     gst_object_unref (ffmpegdec->internal_pool);
 873
 874   ffmpegdec->internal_pool = gst_video_buffer_pool_new ();
 875   config = gst_buffer_pool_get_config (ffmpegdec->internal_pool);
 876
 877   caps = gst_video_info_to_caps (&info);
 878   gst_buffer_pool_config_set_params (config, caps, info.size, 2, 0);
 879   gst_buffer_pool_config_set_allocator (config, NULL, &params);
 880   gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
 881
 882   gst_ffmpegvideodec_prepare_dr_pool (ffmpegdec,
 883       ffmpegdec->internal_pool, &info, config);
 884   /* generic video pool never fails */
 885   gst_buffer_pool_set_config (ffmpegdec->internal_pool, config);
 886   gst_caps_unref (caps);
 887
 888   gst_buffer_pool_set_active (ffmpegdec->internal_pool, TRUE);
 889
 890   /* Remember pool size so we can detect changes */
 891   ffmpegdec->pool_width = picture->width;
 892   ffmpegdec->pool_height =
 893       MAX (picture->height, ffmpegdec->context->coded_height);
 894   ffmpegdec->pool_format = picture->format;
 895   ffmpegdec->pool_info = info;
 896 }
 897
 898 static gboolean
 899 gst_ffmpegviddec_can_direct_render (GstFFMpegVidDec * ffmpegdec)
 900 {
 901   GstFFMpegVidDecClass *oclass;
 902
 903   if (!ffmpegdec->direct_rendering)
 904     return FALSE;
 905
 906   oclass = GST_FFMPEGVIDDEC_GET_CLASS (ffmpegdec);
 907   return ((oclass->in_plugin->capabilities & AV_CODEC_CAP_DR1) ==
 908       AV_CODEC_CAP_DR1);
 909 }
 910
 911 /* called when ffmpeg wants us to allocate a buffer to write the decoded frame
 912  * into. We try to give it memory from our pool */
 913 static int
 914 gst_ffmpegviddec_get_buffer2 (AVCodecContext * context, AVFrame * picture,
 915     int flags)
 916 {
 917   GstVideoCodecFrame *frame;
 918   GstFFMpegVidDecVideoFrame *dframe;
 919   GstFFMpegVidDec *ffmpegdec;
 920   guint c;
 921   GstFlowReturn ret;
 922   int create_buffer_flags = 0;
 923
 924   ffmpegdec = GST_FFMPEGVIDDEC (context->opaque);
 925
 926   GST_DEBUG_OBJECT (ffmpegdec, "getting buffer picture %p", picture);
 927
 928   /* apply the last info we have seen to this picture, when we get the
 929    * picture back from ffmpeg we can use this to correctly timestamp the output
 930    * buffer */
 931   GST_DEBUG_OBJECT (ffmpegdec, "opaque value SN %d",
 932       (gint32) picture->reordered_opaque);
 933
 934   frame =
 935       gst_video_decoder_get_frame (GST_VIDEO_DECODER (ffmpegdec),
 936       picture->reordered_opaque);
 937   if (G_UNLIKELY (frame == NULL))
 938     goto no_frame;
 939
 940   /* now it has a buffer allocated, so it is real and will also
 941    * be _released */
 942   GST_VIDEO_CODEC_FRAME_FLAG_SET (frame,
 943       GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
 944   GST_VIDEO_CODEC_FRAME_FLAG_UNSET (frame,
 945       GST_VIDEO_CODEC_FRAME_FLAG_DECODE_ONLY);
 946
 947   if (G_UNLIKELY (frame->output_buffer != NULL))
 948     goto duplicate_frame;
 949
 950   /* GstFFMpegVidDecVideoFrame receives the frame ref */
 951   if (picture->opaque) {
 952     dframe = picture->opaque;
 953     dframe->frame = frame;
 954   } else {
 955     picture->opaque = dframe =
 956         gst_ffmpegviddec_video_frame_new (ffmpegdec, frame);
 957   }
 958
 959   GST_DEBUG_OBJECT (ffmpegdec, "storing opaque %p", dframe);
 960
 961   if (!gst_ffmpegviddec_can_direct_render (ffmpegdec))
 962     goto no_dr;
 963
 964   gst_ffmpegviddec_ensure_internal_pool (ffmpegdec, picture,
 965       GST_BUFFER_FLAG_IS_SET (frame->input_buffer,
 966           GST_VIDEO_BUFFER_FLAG_ONEFIELD) ? GST_VIDEO_INTERLACE_MODE_ALTERNATE :
 967       GST_VIDEO_INTERLACE_MODE_PROGRESSIVE);
 968
 969   ret = gst_buffer_pool_acquire_buffer (ffmpegdec->internal_pool,
 970       &frame->output_buffer, NULL);
 971   if (ret != GST_FLOW_OK)
 972     goto alloc_failed;
 973
 974   /* piggy-backed alloc'ed on the frame,
 975    * and there was much rejoicing and we are grateful.
 976    * Now take away buffer from frame, we will give it back later when decoded.
 977    * This allows multiple request for a buffer per frame; unusual but possible. */
 978   gst_buffer_replace (&dframe->buffer, frame->output_buffer);
 979   gst_buffer_replace (&frame->output_buffer, NULL);
 980
 981   /* Fill avpicture */
 982   if (!gst_video_frame_map (&dframe->vframe, &ffmpegdec->pool_info,
 983           dframe->buffer, GST_MAP_READWRITE))
 984     goto map_failed;
 985   dframe->mapped = TRUE;
 986
 987   for (c = 0; c < AV_NUM_DATA_POINTERS; c++) {
 988     if (c < GST_VIDEO_INFO_N_PLANES (&ffmpegdec->pool_info)) {
 989       picture->data[c] = GST_VIDEO_FRAME_PLANE_DATA (&dframe->vframe, c);
 990       picture->linesize[c] = GST_VIDEO_FRAME_PLANE_STRIDE (&dframe->vframe, c);
 991
 992       if (ffmpegdec->stride[c] == -1)
 993         ffmpegdec->stride[c] = picture->linesize[c];
 994
 995       /* libav does not allow stride changes, decide allocation should check
 996        * before replacing the internal pool with a downstream pool.
 997        * https://bugzilla.gnome.org/show_bug.cgi?id=704769
 998        * https://bugzilla.libav.org/show_bug.cgi?id=556
 999        */
1000       g_assert (picture->linesize[c] == ffmpegdec->stride[c]);
1001     } else {
1002       picture->data[c] = NULL;
1003       picture->linesize[c] = 0;
1004     }
1005     GST_LOG_OBJECT (ffmpegdec, "linesize %d, data %p", picture->linesize[c],
1006         picture->data[c]);
1007   }
1008
1009   if ((flags & AV_GET_BUFFER_FLAG_REF) == AV_GET_BUFFER_FLAG_REF) {
1010     /* decoder might reuse this AVFrame and it would result to no more
1011      * get_buffer() call if the AVFrame's AVBuffer is writable
1012      * (meaning that the refcount of AVBuffer == 1).
1013      * To enforce get_buffer() for the every output frame, set read-only flag here
1014      */
1015     create_buffer_flags = AV_BUFFER_FLAG_READONLY;
1016   }
1017   picture->buf[0] = av_buffer_create (NULL,
1018       0, dummy_free_buffer, dframe, create_buffer_flags);
1019
1020   GST_LOG_OBJECT (ffmpegdec, "returned frame %p", dframe->buffer);
1021
1022   return 0;
1023
1024 no_dr:
1025   {
1026     int c;
1027     int ret = avcodec_default_get_buffer2 (context, picture, flags);
1028
1029     GST_LOG_OBJECT (ffmpegdec, "direct rendering disabled, fallback alloc");
1030
1031     for (c = 0; c < AV_NUM_DATA_POINTERS; c++) {
1032       ffmpegdec->stride[c] = picture->linesize[c];
1033     }
1034     /* Wrap our buffer around the default one to be able to have a callback
1035      * when our data can be freed. Just putting our data into the first free
1036      * buffer might not work if there are too many allocated already
1037      */
1038     if (picture->buf[0]) {
1039       dframe->avbuffer = picture->buf[0];
1040       picture->buf[0] =
1041           av_buffer_create (picture->buf[0]->data, picture->buf[0]->size,
1042           dummy_free_buffer, dframe, 0);
1043     } else {
1044       picture->buf[0] =
1045           av_buffer_create (NULL, 0, dummy_free_buffer, dframe, 0);
1046     }
1047
1048     return ret;
1049   }
1050 alloc_failed:
1051   {
1052     GST_ELEMENT_ERROR (ffmpegdec, RESOURCE, FAILED,
1053         ("Unable to allocate memory"),
1054         ("The downstream pool failed to allocated buffer."));
1055     return -1;
1056   }
1057 map_failed:
1058   {
1059     GST_ELEMENT_ERROR (ffmpegdec, RESOURCE, OPEN_READ_WRITE,
1060         ("Cannot access memory for read and write operation."),
1061         ("The video memory allocated from downstream pool could not mapped for"
1062             "read and write."));
1063     return -1;
1064   }
1065 duplicate_frame:
1066   {
1067     GST_WARNING_OBJECT (ffmpegdec, "already alloc'ed output buffer for frame");
1068     gst_video_codec_frame_unref (frame);
1069     return -1;
1070   }
1071 no_frame:
1072   {
1073     GST_WARNING_OBJECT (ffmpegdec, "Couldn't get codec frame !");
1074     return -1;
1075   }
1076 }
1077
1078 static gboolean
1079 picture_changed (GstFFMpegVidDec * ffmpegdec, AVFrame * picture,
1080     gboolean one_field)
1081 {
1082   gint pic_field_order = 0;
1083
1084   if (one_field) {
1085     pic_field_order = ffmpegdec->pic_field_order;
1086   } else if (picture->interlaced_frame) {
1087     if (picture->repeat_pict)
1088       pic_field_order |= GST_VIDEO_BUFFER_FLAG_RFF;
1089     if (picture->top_field_first)
1090       pic_field_order |= GST_VIDEO_BUFFER_FLAG_TFF;
1091   }
1092
1093   return !(ffmpegdec->pic_width == picture->width
1094       && ffmpegdec->pic_height == picture->height
1095       && ffmpegdec->pic_pix_fmt == picture->format
1096       && ffmpegdec->pic_par_n == picture->sample_aspect_ratio.num
1097       && ffmpegdec->pic_par_d == picture->sample_aspect_ratio.den
1098       && ffmpegdec->pic_interlaced == picture->interlaced_frame
1099       && ffmpegdec->pic_field_order == pic_field_order
1100       && ffmpegdec->cur_multiview_mode == ffmpegdec->picture_multiview_mode
1101       && ffmpegdec->cur_multiview_flags == ffmpegdec->picture_multiview_flags);
1102 }
1103
1104 static gboolean
1105 context_changed (GstFFMpegVidDec * ffmpegdec, AVCodecContext * context)
1106 {
1107   return !(ffmpegdec->ctx_ticks == context->ticks_per_frame
1108       && ffmpegdec->ctx_time_n == context->time_base.num
1109       && ffmpegdec->ctx_time_d == context->time_base.den);
1110 }
1111
1112 static gboolean
1113 update_video_context (GstFFMpegVidDec * ffmpegdec, AVCodecContext * context,
1114     AVFrame * picture, gboolean one_field)
1115 {
1116   gint pic_field_order = 0;
1117
1118   if (picture->interlaced_frame) {
1119     if (picture->repeat_pict)
1120       pic_field_order |= GST_VIDEO_BUFFER_FLAG_RFF;
1121     if (picture->top_field_first)
1122       pic_field_order |= GST_VIDEO_BUFFER_FLAG_TFF;
1123   }
1124
1125   if (!picture_changed (ffmpegdec, picture, one_field)
1126       && !context_changed (ffmpegdec, context))
1127     return FALSE;
1128
1129   GST_DEBUG_OBJECT (ffmpegdec,
1130       "Renegotiating video from %dx%d@ %d:%d PAR %d/%d fps pixfmt %d to %dx%d@ %d:%d PAR %d/%d fps pixfmt %d",
1131       ffmpegdec->pic_width, ffmpegdec->pic_height,
1132       ffmpegdec->pic_par_n, ffmpegdec->pic_par_d,
1133       ffmpegdec->ctx_time_n, ffmpegdec->ctx_time_d,
1134       ffmpegdec->pic_pix_fmt,
1135       picture->width, picture->height,
1136       picture->sample_aspect_ratio.num,
1137       picture->sample_aspect_ratio.den,
1138       context->time_base.num, context->time_base.den, picture->format);
1139
1140   ffmpegdec->pic_pix_fmt = picture->format;
1141   ffmpegdec->pic_width = picture->width;
1142   ffmpegdec->pic_height = picture->height;
1143   ffmpegdec->pic_par_n = picture->sample_aspect_ratio.num;
1144   ffmpegdec->pic_par_d = picture->sample_aspect_ratio.den;
1145   ffmpegdec->cur_multiview_mode = ffmpegdec->picture_multiview_mode;
1146   ffmpegdec->cur_multiview_flags = ffmpegdec->picture_multiview_flags;
1147
1148   /* Remember if we have interlaced content and the field order changed
1149    * at least once. If that happens, we must be interlace-mode=mixed
1150    */
1151   if (ffmpegdec->pic_field_order_changed ||
1152       (ffmpegdec->pic_field_order != pic_field_order &&
1153           ffmpegdec->pic_interlaced))
1154     ffmpegdec->pic_field_order_changed = TRUE;
1155
1156   ffmpegdec->pic_field_order = pic_field_order;
1157   ffmpegdec->pic_interlaced = picture->interlaced_frame;
1158
1159   if (!ffmpegdec->pic_interlaced)
1160     ffmpegdec->pic_field_order_changed = FALSE;
1161
1162   ffmpegdec->ctx_ticks = context->ticks_per_frame;
1163   ffmpegdec->ctx_time_n = context->time_base.num;
1164   ffmpegdec->ctx_time_d = context->time_base.den;
1165
1166   return TRUE;
1167 }
1168
1169 static void
1170 gst_ffmpegviddec_update_par (GstFFMpegVidDec * ffmpegdec,
1171     GstVideoInfo * in_info, GstVideoInfo * out_info)
1172 {
1173   gboolean demuxer_par_set = FALSE;
1174   gboolean decoder_par_set = FALSE;
1175   gint demuxer_num = 1, demuxer_denom = 1;
1176   gint decoder_num = 1, decoder_denom = 1;
1177   GstVideoCodecFrame *out_frame;
1178   GstFFMpegVidDecVideoFrame *out_dframe;
1179
1180   if (in_info->par_n && in_info->par_d) {
1181     demuxer_num = in_info->par_n;
1182     demuxer_denom = in_info->par_d;
1183     demuxer_par_set = TRUE;
1184     GST_DEBUG_OBJECT (ffmpegdec, "Demuxer PAR: %d:%d", demuxer_num,
1185         demuxer_denom);
1186   }
1187
1188   if (ffmpegdec->pic_par_n && ffmpegdec->pic_par_d) {
1189     decoder_num = ffmpegdec->pic_par_n;
1190     decoder_denom = ffmpegdec->pic_par_d;
1191     decoder_par_set = TRUE;
1192     GST_DEBUG_OBJECT (ffmpegdec, "Decoder PAR: %d:%d", decoder_num,
1193         decoder_denom);
1194   }
1195
1196   if (!demuxer_par_set && !decoder_par_set)
1197     goto no_par;
1198
1199   if (demuxer_par_set && !decoder_par_set)
1200     goto use_demuxer_par;
1201
1202   if (decoder_par_set && !demuxer_par_set)
1203     goto use_decoder_par;
1204
1205   /* Special case for some encoders which provide an 1:2 pixel aspect ratio
1206    * for HEVC interlaced content, possibly to work around decoders that don't
1207    * support field-based interlacing. Add some defensive checks to check for
1208    * a "common" aspect ratio. */
1209   out_dframe = ffmpegdec->picture->opaque;
1210   out_frame = out_dframe->frame;
1211
1212   if (demuxer_num == 1 && demuxer_denom == 1 &&
1213       decoder_num == 1 && decoder_denom == 2 &&
1214       GST_BUFFER_FLAG_IS_SET (out_frame->input_buffer,
1215           GST_VIDEO_BUFFER_FLAG_ONEFIELD) &&
1216       gst_video_is_common_aspect_ratio (ffmpegdec->pic_width,
1217           ffmpegdec->pic_height, 1, 2) &&
1218       !gst_video_is_common_aspect_ratio (ffmpegdec->pic_width,
1219           ffmpegdec->pic_height, 1, 1)) {
1220     GST_WARNING_OBJECT (ffmpegdec,
1221         "PAR 1/2 makes the aspect ratio of "
1222         "a %d x %d frame uncommon. Switching to 1/1",
1223         ffmpegdec->pic_width, ffmpegdec->pic_height);
1224     goto use_demuxer_par;
1225   }
1226
1227   /* Both the demuxer and the decoder provide a PAR. If one of
1228    * the two PARs is 1:1 and the other one is not, use the one
1229    * that is not 1:1. */
1230   if (demuxer_num == demuxer_denom && decoder_num != decoder_denom) {
1231     goto use_decoder_par;
1232   }
1233
1234   if (decoder_num == decoder_denom && demuxer_num != demuxer_denom) {
1235     goto use_demuxer_par;
1236   }
1237
1238   /* Both PARs are non-1:1, so use the PAR provided by the demuxer */
1239   goto use_demuxer_par;
1240
1241 use_decoder_par:
1242   {
1243     GST_DEBUG_OBJECT (ffmpegdec,
1244         "Setting decoder provided pixel-aspect-ratio of %u:%u", decoder_num,
1245         decoder_denom);
1246     out_info->par_n = decoder_num;
1247     out_info->par_d = decoder_denom;
1248     return;
1249   }
1250 use_demuxer_par:
1251   {
1252     GST_DEBUG_OBJECT (ffmpegdec,
1253         "Setting demuxer provided pixel-aspect-ratio of %u:%u", demuxer_num,
1254         demuxer_denom);
1255     out_info->par_n = demuxer_num;
1256     out_info->par_d = demuxer_denom;
1257     return;
1258   }
1259 no_par:
1260   {
1261     GST_DEBUG_OBJECT (ffmpegdec,
1262         "Neither demuxer nor codec provide a pixel-aspect-ratio");
1263     out_info->par_n = 1;
1264     out_info->par_d = 1;
1265     return;
1266   }
1267 }
1268
1269 static GstVideoMultiviewMode
1270 stereo_av_to_gst (enum AVStereo3DType type)
1271 {
1272   switch (type) {
1273     case AV_STEREO3D_SIDEBYSIDE:
1274       return GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE;
1275     case AV_STEREO3D_TOPBOTTOM:
1276       return GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM;
1277     case AV_STEREO3D_FRAMESEQUENCE:
1278       return GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME;
1279     case AV_STEREO3D_CHECKERBOARD:
1280       return GST_VIDEO_MULTIVIEW_MODE_CHECKERBOARD;
1281     case AV_STEREO3D_SIDEBYSIDE_QUINCUNX:
1282       return GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX;
1283     case AV_STEREO3D_LINES:
1284       return GST_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED;
1285     case AV_STEREO3D_COLUMNS:
1286       return GST_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED;
1287     default:
1288       break;
1289   }
1290
1291   return GST_VIDEO_MULTIVIEW_MODE_NONE;
1292 }
1293
1294 static gboolean
1295 mastering_display_metadata_av_to_gst (AVMasteringDisplayMetadata * av,
1296     GstVideoMasteringDisplayInfo * gst)
1297 {
1298   const guint64 chroma_scale = 50000;
1299   const guint64 luma_scale = 10000;
1300   gint i;
1301
1302   /* Use only complete mastering meta */
1303   if (!av->has_primaries || !av->has_luminance)
1304     return FALSE;
1305
1306   for (i = 0; i < G_N_ELEMENTS (gst->display_primaries); i++) {
1307     gst->display_primaries[i].x = (guint16) gst_util_uint64_scale (chroma_scale,
1308         av->display_primaries[i][0].num, av->display_primaries[i][0].den);
1309     gst->display_primaries[i].y = (guint16) gst_util_uint64_scale (chroma_scale,
1310         av->display_primaries[i][1].num, av->display_primaries[i][1].den);
1311   }
1312
1313   gst->white_point.x = (guint16) gst_util_uint64_scale (chroma_scale,
1314       av->white_point[0].num, av->white_point[0].den);
1315   gst->white_point.y = (guint16) gst_util_uint64_scale (chroma_scale,
1316       av->white_point[1].num, av->white_point[1].den);
1317
1318
1319   gst->max_display_mastering_luminance =
1320       (guint32) gst_util_uint64_scale (luma_scale,
1321       av->max_luminance.num, av->max_luminance.den);
1322   gst->min_display_mastering_luminance =
1323       (guint32) gst_util_uint64_scale (luma_scale,
1324       av->min_luminance.num, av->min_luminance.den);
1325
1326   return TRUE;
1327 }
1328
1329 static gboolean
1330 content_light_metadata_av_to_gst (AVContentLightMetadata * av,
1331     GstVideoContentLightLevel * gst)
1332 {
1333   gst->max_content_light_level = av->MaxCLL;
1334   gst->max_frame_average_light_level = av->MaxFALL;
1335
1336   return TRUE;
1337 }
1338
1339 static gboolean
1340 gst_ffmpegviddec_negotiate (GstFFMpegVidDec * ffmpegdec,
1341     AVCodecContext * context, AVFrame * picture, GstBufferFlags flags)
1342 {
1343   GstVideoFormat fmt;
1344   GstVideoInfo *in_info, *out_info;
1345   GstVideoCodecState *output_state;
1346   gint fps_n, fps_d;
1347   GstClockTime latency;
1348   GstStructure *in_s;
1349   GstVideoInterlaceMode interlace_mode;
1350   gint caps_height;
1351   gboolean one_field = ! !(flags & GST_VIDEO_BUFFER_FLAG_ONEFIELD);
1352
1353   if (!update_video_context (ffmpegdec, context, picture, one_field))
1354     return TRUE;
1355
1356   caps_height = ffmpegdec->pic_height;
1357
1358   fmt = gst_ffmpeg_pixfmt_to_videoformat (ffmpegdec->pic_pix_fmt);
1359   if (G_UNLIKELY (fmt == GST_VIDEO_FORMAT_UNKNOWN))
1360     goto unknown_format;
1361
1362   /* set the interlaced flag */
1363   in_s = gst_caps_get_structure (ffmpegdec->input_state->caps, 0);
1364   if (flags & GST_VIDEO_BUFFER_FLAG_ONEFIELD) {
1365     /* TODO: we don't get that information from ffmpeg, so copy it from
1366      * the parser */
1367     interlace_mode = GST_VIDEO_INTERLACE_MODE_ALTERNATE;
1368     caps_height = 2 * caps_height;
1369   } else if (!gst_structure_has_field (in_s, "interlace-mode")) {
1370     if (ffmpegdec->pic_interlaced) {
1371       if (ffmpegdec->pic_field_order_changed ||
1372           (ffmpegdec->pic_field_order & GST_VIDEO_BUFFER_FLAG_RFF)) {
1373         interlace_mode = GST_VIDEO_INTERLACE_MODE_MIXED;
1374       } else {
1375         interlace_mode = GST_VIDEO_INTERLACE_MODE_INTERLEAVED;
1376       }
1377     } else {
1378       interlace_mode = GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
1379     }
1380   } else {
1381     GstVideoInfo info;
1382
1383     gst_video_info_from_caps (&info, ffmpegdec->input_state->caps);
1384     interlace_mode = info.interlace_mode;
1385   }
1386
1387   if (interlace_mode == GST_VIDEO_INTERLACE_MODE_ALTERNATE)
1388     output_state =
1389         gst_video_decoder_set_interlaced_output_state (GST_VIDEO_DECODER
1390         (ffmpegdec), fmt, interlace_mode, ffmpegdec->pic_width, caps_height,
1391         ffmpegdec->input_state);
1392   else
1393     output_state =
1394         gst_video_decoder_set_output_state (GST_VIDEO_DECODER
1395         (ffmpegdec), fmt, ffmpegdec->pic_width, caps_height,
1396         ffmpegdec->input_state);
1397   if (ffmpegdec->output_state)
1398     gst_video_codec_state_unref (ffmpegdec->output_state);
1399   ffmpegdec->output_state = output_state;
1400
1401   in_info = &ffmpegdec->input_state->info;
1402   out_info = &ffmpegdec->output_state->info;
1403
1404   out_info->interlace_mode = interlace_mode;
1405   if (!gst_structure_has_field (in_s, "interlace-mode")
1406       && interlace_mode == GST_VIDEO_INTERLACE_MODE_INTERLEAVED) {
1407     if ((ffmpegdec->pic_field_order & GST_VIDEO_BUFFER_FLAG_TFF))
1408       GST_VIDEO_INFO_FIELD_ORDER (out_info) =
1409           GST_VIDEO_FIELD_ORDER_TOP_FIELD_FIRST;
1410     else
1411       GST_VIDEO_INFO_FIELD_ORDER (out_info) =
1412           GST_VIDEO_FIELD_ORDER_BOTTOM_FIELD_FIRST;
1413   }
1414
1415   if (!gst_structure_has_field (in_s, "chroma-site")) {
1416     switch (context->chroma_sample_location) {
1417       case AVCHROMA_LOC_LEFT:
1418         out_info->chroma_site = GST_VIDEO_CHROMA_SITE_MPEG2;
1419         break;
1420       case AVCHROMA_LOC_CENTER:
1421         out_info->chroma_site = GST_VIDEO_CHROMA_SITE_JPEG;
1422         break;
1423       case AVCHROMA_LOC_TOPLEFT:
1424         out_info->chroma_site = GST_VIDEO_CHROMA_SITE_DV;
1425         break;
1426       case AVCHROMA_LOC_TOP:
1427         out_info->chroma_site = GST_VIDEO_CHROMA_SITE_V_COSITED;
1428         break;
1429       default:
1430         break;
1431     }
1432   }
1433
1434   if (!gst_structure_has_field (in_s, "colorimetry")
1435       || in_info->colorimetry.primaries == GST_VIDEO_COLOR_PRIMARIES_UNKNOWN) {
1436     out_info->colorimetry.primaries =
1437         gst_video_color_primaries_from_iso (context->color_primaries);
1438   }
1439
1440   if (!gst_structure_has_field (in_s, "colorimetry")
1441       || in_info->colorimetry.transfer == GST_VIDEO_TRANSFER_UNKNOWN) {
1442     out_info->colorimetry.transfer =
1443         gst_video_transfer_function_from_iso (context->color_trc);
1444   }
1445
1446   if (!gst_structure_has_field (in_s, "colorimetry")
1447       || in_info->colorimetry.matrix == GST_VIDEO_COLOR_MATRIX_UNKNOWN) {
1448     out_info->colorimetry.matrix =
1449         gst_video_color_matrix_from_iso (context->colorspace);
1450   }
1451
1452   if (!gst_structure_has_field (in_s, "colorimetry")
1453       || in_info->colorimetry.range == GST_VIDEO_COLOR_RANGE_UNKNOWN) {
1454     if (context->color_range == AVCOL_RANGE_JPEG) {
1455       out_info->colorimetry.range = GST_VIDEO_COLOR_RANGE_0_255;
1456     } else if (context->color_range == AVCOL_RANGE_MPEG) {
1457       out_info->colorimetry.range = GST_VIDEO_COLOR_RANGE_16_235;
1458     } else {
1459       out_info->colorimetry.range = GST_VIDEO_COLOR_RANGE_UNKNOWN;
1460     }
1461   }
1462
1463   /* try to find a good framerate */
1464   if ((in_info->fps_d && in_info->fps_n)) {
1465     /* take framerate from input when it was specified (#313970) */
1466     fps_n = in_info->fps_n;
1467     fps_d = in_info->fps_d;
1468   } else {
1469     fps_n = ffmpegdec->ctx_time_d / ffmpegdec->ctx_ticks;
1470     fps_d = ffmpegdec->ctx_time_n;
1471
1472     if (!fps_d) {
1473       GST_LOG_OBJECT (ffmpegdec, "invalid framerate: %d/0, -> %d/1", fps_n,
1474           fps_n);
1475       fps_d = 1;
1476     }
1477     if (gst_util_fraction_compare (fps_n, fps_d, 1000, 1) > 0) {
1478       GST_LOG_OBJECT (ffmpegdec, "excessive framerate: %d/%d, -> 0/1", fps_n,
1479           fps_d);
1480       fps_n = 0;
1481       fps_d = 1;
1482     }
1483   }
1484
1485   if (GST_VIDEO_INFO_FLAG_IS_SET (in_info, GST_VIDEO_FLAG_VARIABLE_FPS)) {
1486     GST_LOG_OBJECT (ffmpegdec, "setting framerate: %d/%d", in_info->fps_n,
1487         in_info->fps_d);
1488     out_info->fps_n = in_info->fps_n;
1489     out_info->fps_d = in_info->fps_d;
1490   } else {
1491     GST_LOG_OBJECT (ffmpegdec, "setting framerate: %d/%d", fps_n, fps_d);
1492     out_info->fps_n = fps_n;
1493     out_info->fps_d = fps_d;
1494   }
1495
1496   /* calculate and update par now */
1497   gst_ffmpegviddec_update_par (ffmpegdec, in_info, out_info);
1498
1499   GST_VIDEO_INFO_MULTIVIEW_MODE (out_info) = ffmpegdec->cur_multiview_mode;
1500   GST_VIDEO_INFO_MULTIVIEW_FLAGS (out_info) = ffmpegdec->cur_multiview_flags;
1501
1502   /* To passing HDR information to caps directly */
1503   if (output_state->caps == NULL) {
1504     output_state->caps = gst_video_info_to_caps (out_info);
1505   } else {
1506     output_state->caps = gst_caps_make_writable (output_state->caps);
1507   }
1508
1509   if (flags & GST_VIDEO_BUFFER_FLAG_ONEFIELD) {
1510     /* TODO: we don't get that information from ffmpeg, so copy it from
1511      * the parser */
1512     gst_caps_features_add (gst_caps_get_features (ffmpegdec->output_state->caps,
1513             0), GST_CAPS_FEATURE_FORMAT_INTERLACED);
1514   }
1515
1516   if (!gst_structure_has_field (in_s, "mastering-display-info")) {
1517     AVFrameSideData *sd = av_frame_get_side_data (picture,
1518         AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
1519     GstVideoMasteringDisplayInfo minfo;
1520
1521     if (sd
1522         && mastering_display_metadata_av_to_gst ((AVMasteringDisplayMetadata *)
1523             sd->data, &minfo)) {
1524       GST_LOG_OBJECT (ffmpegdec, "update mastering display info: "
1525           "Red(%u, %u) "
1526           "Green(%u, %u) "
1527           "Blue(%u, %u) "
1528           "White(%u, %u) "
1529           "max_luminance(%u) "
1530           "min_luminance(%u) ",
1531           minfo.display_primaries[0].x, minfo.display_primaries[0].y,
1532           minfo.display_primaries[1].x, minfo.display_primaries[1].y,
1533           minfo.display_primaries[2].x, minfo.display_primaries[2].y,
1534           minfo.white_point.x, minfo.white_point.y,
1535           minfo.max_display_mastering_luminance,
1536           minfo.min_display_mastering_luminance);
1537
1538       if (!gst_video_mastering_display_info_add_to_caps (&minfo,
1539               output_state->caps)) {
1540         GST_WARNING_OBJECT (ffmpegdec,
1541             "Couldn't set mastering display info to caps");
1542       }
1543     }
1544   }
1545
1546   if (!gst_structure_has_field (in_s, "content-light-level")) {
1547     AVFrameSideData *sd = av_frame_get_side_data (picture,
1548         AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);
1549     GstVideoContentLightLevel cll;
1550
1551     if (sd && content_light_metadata_av_to_gst ((AVContentLightMetadata *)
1552             sd->data, &cll)) {
1553       GST_LOG_OBJECT (ffmpegdec, "update content light level: "
1554           "maxCLL:(%u), maxFALL:(%u)", cll.max_content_light_level,
1555           cll.max_frame_average_light_level);
1556
1557       if (!gst_video_content_light_level_add_to_caps (&cll, output_state->caps)) {
1558         GST_WARNING_OBJECT (ffmpegdec,
1559             "Couldn't set content light level to caps");
1560       }
1561     }
1562   }
1563
1564   if (!gst_video_decoder_negotiate (GST_VIDEO_DECODER (ffmpegdec)))
1565     goto negotiate_failed;
1566
1567   /* The decoder is configured, we now know the true latency */
1568   if (fps_n) {
1569     latency =
1570         gst_util_uint64_scale_ceil (ffmpegdec->context->has_b_frames *
1571         GST_SECOND, fps_d, fps_n);
1572     if (ffmpegdec->context->thread_type & FF_THREAD_FRAME) {
1573       latency +=
1574           gst_util_uint64_scale_ceil (ffmpegdec->context->thread_count *
1575           GST_SECOND, fps_d, fps_n);
1576     }
1577     gst_video_decoder_set_latency (GST_VIDEO_DECODER (ffmpegdec), latency,
1578         latency);
1579   }
1580
1581   return TRUE;
1582
1583   /* ERRORS */
1584 unknown_format:
1585   {
1586     GST_ERROR_OBJECT (ffmpegdec,
1587         "decoder requires a video format unsupported by GStreamer");
1588     return FALSE;
1589   }
1590 negotiate_failed:
1591   {
1592     /* Reset so we try again next time even if force==FALSE */
1593     ffmpegdec->pic_pix_fmt = 0;
1594     ffmpegdec->pic_width = 0;
1595     ffmpegdec->pic_height = 0;
1596     ffmpegdec->pic_par_n = 0;
1597     ffmpegdec->pic_par_d = 0;
1598     ffmpegdec->pic_interlaced = 0;
1599     ffmpegdec->pic_field_order = 0;
1600     ffmpegdec->pic_field_order_changed = FALSE;
1601     ffmpegdec->ctx_ticks = 0;
1602     ffmpegdec->ctx_time_n = 0;
1603     ffmpegdec->ctx_time_d = 0;
1604
1605     GST_ERROR_OBJECT (ffmpegdec, "negotiation failed");
1606     return FALSE;
1607   }
1608 }
1609
1610 /* perform qos calculations before decoding the next frame.
1611  *
1612  * Sets the skip_frame flag and if things are really bad, skips to the next
1613  * keyframe.
1614  *
1615  */
1616 static void
1617 gst_ffmpegviddec_do_qos (GstFFMpegVidDec * ffmpegdec,
1618     GstVideoCodecFrame * frame, gboolean * mode_switch)
1619 {
1620   GstClockTimeDiff diff;
1621   GstSegmentFlags skip_flags =
1622       GST_VIDEO_DECODER_INPUT_SEGMENT (ffmpegdec).flags;
1623
1624   *mode_switch = FALSE;
1625
1626   if (frame == NULL)
1627     return;
1628
1629   if (skip_flags & GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS) {
1630     ffmpegdec->context->skip_frame = AVDISCARD_NONKEY;
1631     *mode_switch = TRUE;
1632   } else if (skip_flags & GST_SEGMENT_FLAG_TRICKMODE) {
1633     ffmpegdec->context->skip_frame = AVDISCARD_NONREF;
1634     *mode_switch = TRUE;
1635   }
1636
1637   if (*mode_switch == TRUE) {
1638     /* We've already switched mode, we can return straight away
1639      * without any further calculation */
1640     return;
1641   }
1642
1643   diff =
1644       gst_video_decoder_get_max_decode_time (GST_VIDEO_DECODER (ffmpegdec),
1645       frame);
1646
1647   /* if we don't have timing info, then we don't do QoS */
1648   if (G_UNLIKELY (diff == G_MAXINT64)) {
1649     /* Ensure the skipping strategy is the default one */
1650     ffmpegdec->context->skip_frame = ffmpegdec->skip_frame;
1651     return;
1652   }
1653
1654   GST_DEBUG_OBJECT (ffmpegdec, "decoding time %" G_GINT64_FORMAT, diff);
1655
1656   if (diff > 0 && ffmpegdec->context->skip_frame != AVDISCARD_DEFAULT) {
1657     ffmpegdec->context->skip_frame = AVDISCARD_DEFAULT;
1658     *mode_switch = TRUE;
1659     GST_DEBUG_OBJECT (ffmpegdec, "QOS: normal mode");
1660   }
1661
1662   else if (diff <= 0 && ffmpegdec->context->skip_frame != AVDISCARD_NONREF) {
1663     ffmpegdec->context->skip_frame = AVDISCARD_NONREF;
1664     *mode_switch = TRUE;
1665     GST_DEBUG_OBJECT (ffmpegdec,
1666         "QOS: hurry up, diff %" G_GINT64_FORMAT " >= 0", diff);
1667   }
1668 }
1669
1670 /* get an outbuf buffer with the current picture */
1671 static GstFlowReturn
1672 get_output_buffer (GstFFMpegVidDec * ffmpegdec, GstVideoCodecFrame * frame)
1673 {
1674   GstFlowReturn ret = GST_FLOW_OK;
1675   AVFrame pic, *outpic;
1676   GstVideoFrame vframe;
1677   GstVideoInfo *info;
1678   guint c;
1679
1680   GST_LOG_OBJECT (ffmpegdec, "get output buffer");
1681
1682   if (!ffmpegdec->output_state)
1683     goto not_negotiated;
1684
1685   ret =
1686       gst_video_decoder_allocate_output_frame (GST_VIDEO_DECODER (ffmpegdec),
1687       frame);
1688   if (G_UNLIKELY (ret != GST_FLOW_OK))
1689     goto alloc_failed;
1690
1691   /* original ffmpeg code does not handle odd sizes correctly.
1692    * This patched up version does */
1693   /* Fill avpicture */
1694   info = &ffmpegdec->output_state->info;
1695   if (!gst_video_frame_map (&vframe, info, frame->output_buffer,
1696           GST_MAP_READ | GST_MAP_WRITE))
1697     goto map_failed;
1698
1699   memset (&pic, 0, sizeof (pic));
1700   pic.format = ffmpegdec->pic_pix_fmt;
1701   pic.width = GST_VIDEO_FRAME_WIDTH (&vframe);
1702   pic.height = GST_VIDEO_FRAME_HEIGHT (&vframe);
1703   for (c = 0; c < AV_NUM_DATA_POINTERS; c++) {
1704     if (c < GST_VIDEO_INFO_N_PLANES (info)) {
1705       pic.data[c] = GST_VIDEO_FRAME_PLANE_DATA (&vframe, c);
1706       pic.linesize[c] = GST_VIDEO_FRAME_PLANE_STRIDE (&vframe, c);
1707       GST_LOG_OBJECT (ffmpegdec, "[%i] linesize %d, data %p", c,
1708           pic.linesize[c], pic.data[c]);
1709     } else {
1710       pic.data[c] = NULL;
1711       pic.linesize[c] = 0;
1712     }
1713   }
1714
1715   outpic = ffmpegdec->picture;
1716
1717   if (av_frame_copy (&pic, outpic) != 0) {
1718     GST_ERROR_OBJECT (ffmpegdec, "Failed to copy output frame");
1719     ret = GST_FLOW_ERROR;
1720   }
1721
1722   gst_video_frame_unmap (&vframe);
1723
1724   ffmpegdec->picture->reordered_opaque = -1;
1725
1726   return ret;
1727
1728   /* special cases */
1729 alloc_failed:
1730   {
1731     GST_ELEMENT_ERROR (ffmpegdec, RESOURCE, FAILED,
1732         ("Unable to allocate memory"),
1733         ("The downstream pool failed to allocated buffer."));
1734     return ret;
1735   }
1736 map_failed:
1737   {
1738     GST_ELEMENT_ERROR (ffmpegdec, RESOURCE, OPEN_READ_WRITE,
1739         ("Cannot access memory for read and write operation."),
1740         ("The video memory allocated from downstream pool could not mapped for"
1741             "read and write."));
1742     return ret;
1743   }
1744 not_negotiated:
1745   {
1746     GST_DEBUG_OBJECT (ffmpegdec, "not negotiated");
1747     return GST_FLOW_NOT_NEGOTIATED;
1748   }
1749 }
1750
1751 static void
1752 gst_avpacket_init (AVPacket * packet, guint8 * data, guint size)
1753 {
1754   memset (packet, 0, sizeof (AVPacket));
1755   packet->data = data;
1756   packet->size = size;
1757 }
1758
1759 /*
1760  * Returns: whether a frame was decoded
1761  */
1762 static gboolean
1763 gst_ffmpegviddec_video_frame (GstFFMpegVidDec * ffmpegdec,
1764     GstVideoCodecFrame * frame, GstFlowReturn * ret)
1765 {
1766   gint res;
1767   gboolean got_frame = FALSE;
1768   gboolean mode_switch;
1769   GstVideoCodecFrame *out_frame;
1770   GstFFMpegVidDecVideoFrame *out_dframe;
1771   GstBufferPool *pool;
1772
1773   *ret = GST_FLOW_OK;
1774
1775   /* in case we skip frames */
1776   ffmpegdec->picture->pict_type = -1;
1777
1778   /* run QoS code, we don't stop decoding the frame when we are late because
1779    * else we might skip a reference frame */
1780   gst_ffmpegviddec_do_qos (ffmpegdec, frame, &mode_switch);
1781
1782   res = avcodec_receive_frame (ffmpegdec->context, ffmpegdec->picture);
1783
1784   /* No frames available at this time */
1785   if (res == AVERROR (EAGAIN)) {
1786     GST_DEBUG_OBJECT (ffmpegdec, "Need more data");
1787     goto beach;
1788   } else if (res == AVERROR_EOF) {
1789     *ret = GST_FLOW_EOS;
1790     GST_DEBUG_OBJECT (ffmpegdec, "Context was entirely flushed");
1791     goto beach;
1792   } else if (res < 0) {
1793     GST_VIDEO_DECODER_ERROR (ffmpegdec, 1, STREAM, DECODE, (NULL),
1794         ("Video decoding error"), *ret);
1795     goto beach;
1796   }
1797
1798   got_frame = TRUE;
1799
1800   /* get the output picture timing info again */
1801   out_dframe = ffmpegdec->picture->opaque;
1802   out_frame = gst_video_codec_frame_ref (out_dframe->frame);
1803
1804   /* also give back a buffer allocated by the frame, if any */
1805   gst_buffer_replace (&out_frame->output_buffer, out_dframe->buffer);
1806   gst_buffer_replace (&out_dframe->buffer, NULL);
1807
1808   /* Extract auxilliary info not stored in the main AVframe */
1809   {
1810     GstVideoInfo *in_info = &ffmpegdec->input_state->info;
1811     /* Take multiview mode from upstream if present */
1812     ffmpegdec->picture_multiview_mode = GST_VIDEO_INFO_MULTIVIEW_MODE (in_info);
1813     ffmpegdec->picture_multiview_flags =
1814         GST_VIDEO_INFO_MULTIVIEW_FLAGS (in_info);
1815
1816     /* Otherwise, see if there's info in the frame */
1817     if (ffmpegdec->picture_multiview_mode == GST_VIDEO_MULTIVIEW_MODE_NONE) {
1818       AVFrameSideData *side_data =
1819           av_frame_get_side_data (ffmpegdec->picture, AV_FRAME_DATA_STEREO3D);
1820       if (side_data) {
1821         AVStereo3D *stereo = (AVStereo3D *) side_data->data;
1822         ffmpegdec->picture_multiview_mode = stereo_av_to_gst (stereo->type);
1823         if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
1824           ffmpegdec->picture_multiview_flags =
1825               GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
1826         } else {
1827           ffmpegdec->picture_multiview_flags = GST_VIDEO_MULTIVIEW_FLAGS_NONE;
1828         }
1829       }
1830     }
1831   }
1832
1833   GST_DEBUG_OBJECT (ffmpegdec,
1834       "pts %" G_GUINT64_FORMAT " duration %" G_GUINT64_FORMAT,
1835       out_frame->pts, out_frame->duration);
1836   GST_DEBUG_OBJECT (ffmpegdec, "picture: pts %" G_GUINT64_FORMAT,
1837       (guint64) ffmpegdec->picture->pts);
1838   GST_DEBUG_OBJECT (ffmpegdec, "picture: num %d",
1839       ffmpegdec->picture->coded_picture_number);
1840   GST_DEBUG_OBJECT (ffmpegdec, "picture: display %d",
1841       ffmpegdec->picture->display_picture_number);
1842   GST_DEBUG_OBJECT (ffmpegdec, "picture: opaque %p",
1843       ffmpegdec->picture->opaque);
1844   GST_DEBUG_OBJECT (ffmpegdec, "picture: reordered opaque %" G_GUINT64_FORMAT,
1845       (guint64) ffmpegdec->picture->reordered_opaque);
1846   GST_DEBUG_OBJECT (ffmpegdec, "repeat_pict:%d",
1847       ffmpegdec->picture->repeat_pict);
1848   GST_DEBUG_OBJECT (ffmpegdec, "corrupted frame: %d",
1849       ! !(ffmpegdec->picture->flags & AV_FRAME_FLAG_CORRUPT));
1850
1851   if (!gst_ffmpegviddec_negotiate (ffmpegdec, ffmpegdec->context,
1852           ffmpegdec->picture, GST_BUFFER_FLAGS (out_frame->input_buffer)))
1853     goto negotiation_error;
1854
1855   pool = gst_video_decoder_get_buffer_pool (GST_VIDEO_DECODER (ffmpegdec));
1856   if (G_UNLIKELY (out_frame->output_buffer == NULL)) {
1857     *ret = get_output_buffer (ffmpegdec, out_frame);
1858   } else if (G_UNLIKELY (out_frame->output_buffer->pool != pool)) {
1859     GstBuffer *tmp = out_frame->output_buffer;
1860     out_frame->output_buffer = NULL;
1861     *ret = get_output_buffer (ffmpegdec, out_frame);
1862     gst_buffer_unref (tmp);
1863   }
1864 #ifndef G_DISABLE_ASSERT
1865   else {
1866     GstVideoMeta *vmeta = gst_buffer_get_video_meta (out_frame->output_buffer);
1867     if (vmeta) {
1868       GstVideoInfo *info = &ffmpegdec->output_state->info;
1869       g_assert ((gint) vmeta->width == GST_VIDEO_INFO_WIDTH (info));
1870       g_assert ((gint) vmeta->height == GST_VIDEO_INFO_HEIGHT (info));
1871     }
1872   }
1873 #endif
1874   gst_object_unref (pool);
1875
1876   if (G_UNLIKELY (*ret != GST_FLOW_OK))
1877     goto no_output;
1878
1879   /* Mark corrupted frames as corrupted */
1880   if (ffmpegdec->picture->flags & AV_FRAME_FLAG_CORRUPT)
1881     GST_BUFFER_FLAG_SET (out_frame->output_buffer, GST_BUFFER_FLAG_CORRUPTED);
1882
1883   if (ffmpegdec->pic_interlaced) {
1884     /* set interlaced flags */
1885     if (ffmpegdec->picture->repeat_pict)
1886       GST_BUFFER_FLAG_SET (out_frame->output_buffer, GST_VIDEO_BUFFER_FLAG_RFF);
1887     if (ffmpegdec->picture->top_field_first)
1888       GST_BUFFER_FLAG_SET (out_frame->output_buffer, GST_VIDEO_BUFFER_FLAG_TFF);
1889     if (ffmpegdec->picture->interlaced_frame)
1890       GST_BUFFER_FLAG_SET (out_frame->output_buffer,
1891           GST_VIDEO_BUFFER_FLAG_INTERLACED);
1892   }
1893
1894   {
1895     AVFrameSideData *side_data =
1896         av_frame_get_side_data (ffmpegdec->picture, AV_FRAME_DATA_A53_CC);
1897     if (side_data) {
1898       GST_LOG_OBJECT (ffmpegdec,
1899           "Found CC side data of type AV_FRAME_DATA_A53_CC, size %d",
1900           (int) side_data->size);
1901       GST_MEMDUMP ("A53 CC", side_data->data, side_data->size);
1902
1903       /* do not add closed caption meta if it already exists */
1904       if (!gst_buffer_get_meta (out_frame->input_buffer,
1905               GST_VIDEO_CAPTION_META_API_TYPE)) {
1906         out_frame->output_buffer =
1907             gst_buffer_make_writable (out_frame->output_buffer);
1908         gst_buffer_add_video_caption_meta (out_frame->output_buffer,
1909             GST_VIDEO_CAPTION_TYPE_CEA708_RAW, side_data->data,
1910             side_data->size);
1911       } else {
1912         GST_LOG_OBJECT (ffmpegdec,
1913             "Closed caption meta already exists: will not add new caption meta");
1914       }
1915     }
1916   }
1917
1918   /* cleaning time */
1919   /* so we decoded this frame, frames preceding it in decoding order
1920    * that still do not have a buffer allocated seem rather useless,
1921    * and can be discarded, due to e.g. misparsed bogus frame
1922    * or non-keyframe in skipped decoding, ...
1923    * In any case, not likely to be seen again, so discard those,
1924    * before they pile up and/or mess with timestamping */
1925   {
1926     GList *l, *ol;
1927     GstVideoDecoder *dec = GST_VIDEO_DECODER (ffmpegdec);
1928     gboolean old = TRUE;
1929
1930     ol = l = gst_video_decoder_get_frames (dec);
1931     while (l) {
1932       GstVideoCodecFrame *tmp = l->data;
1933
1934       if (tmp == frame)
1935         old = FALSE;
1936
1937       if (old && GST_VIDEO_CODEC_FRAME_IS_DECODE_ONLY (tmp)) {
1938         GST_LOG_OBJECT (dec,
1939             "discarding ghost frame %p (#%d) PTS:%" GST_TIME_FORMAT " DTS:%"
1940             GST_TIME_FORMAT, tmp, tmp->system_frame_number,
1941             GST_TIME_ARGS (tmp->pts), GST_TIME_ARGS (tmp->dts));
1942         /* drop extra ref and remove from frame list */
1943         GST_VIDEO_CODEC_FRAME_FLAG_UNSET (tmp,
1944             GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
1945         gst_video_decoder_release_frame (dec, tmp);
1946       } else {
1947         /* drop extra ref we got */
1948         gst_video_codec_frame_unref (tmp);
1949       }
1950       l = l->next;
1951     }
1952     g_list_free (ol);
1953   }
1954
1955   av_frame_unref (ffmpegdec->picture);
1956
1957   if (frame)
1958     GST_VIDEO_CODEC_FRAME_FLAG_UNSET (frame,
1959         GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
1960
1961   if (gst_video_decoder_get_subframe_mode (GST_VIDEO_DECODER (ffmpegdec)))
1962     gst_video_decoder_have_last_subframe (GST_VIDEO_DECODER (ffmpegdec),
1963         out_frame);
1964
1965   /* FIXME: Ideally we would remap the buffer read-only now before pushing but
1966    * libav might still have a reference to it!
1967    */
1968   if (GST_BUFFER_FLAG_IS_SET (out_frame->input_buffer,
1969           GST_VIDEO_BUFFER_FLAG_ONEFIELD)) {
1970     GST_BUFFER_FLAG_SET (out_frame->output_buffer,
1971         GST_VIDEO_BUFFER_FLAG_ONEFIELD);
1972     if (GST_BUFFER_FLAG_IS_SET (out_frame->input_buffer,
1973             GST_VIDEO_BUFFER_FLAG_TFF)) {
1974       GST_BUFFER_FLAG_SET (out_frame->output_buffer, GST_VIDEO_BUFFER_FLAG_TFF);
1975     }
1976   }
1977   *ret =
1978       gst_video_decoder_finish_frame (GST_VIDEO_DECODER (ffmpegdec), out_frame);
1979
1980 beach:
1981   GST_DEBUG_OBJECT (ffmpegdec, "return flow %s, got frame: %d",
1982       gst_flow_get_name (*ret), got_frame);
1983   return got_frame;
1984
1985   /* special cases */
1986 no_output:
1987   {
1988     GST_DEBUG_OBJECT (ffmpegdec, "no output buffer");
1989     GST_VIDEO_CODEC_FRAME_FLAG_UNSET (frame,
1990         GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
1991     gst_video_decoder_drop_frame (GST_VIDEO_DECODER (ffmpegdec), out_frame);
1992     goto beach;
1993   }
1994
1995 negotiation_error:
1996   {
1997     gst_video_decoder_drop_frame (GST_VIDEO_DECODER (ffmpegdec), out_frame);
1998     if (GST_PAD_IS_FLUSHING (GST_VIDEO_DECODER_SRC_PAD (ffmpegdec))) {
1999       *ret = GST_FLOW_FLUSHING;
2000       goto beach;
2001     }
2002     GST_WARNING_OBJECT (ffmpegdec, "Error negotiating format");
2003     *ret = GST_FLOW_NOT_NEGOTIATED;
2004     goto beach;
2005   }
2006 }
2007
2008
2009  /* Returns: Whether a frame was decoded */
2010 static gboolean
2011 gst_ffmpegviddec_frame (GstFFMpegVidDec * ffmpegdec, GstVideoCodecFrame * frame,
2012     GstFlowReturn * ret)
2013 {
2014   gboolean got_frame = FALSE;
2015
2016   if (G_UNLIKELY (ffmpegdec->context->codec == NULL))
2017     goto no_codec;
2018
2019   *ret = GST_FLOW_OK;
2020   ffmpegdec->context->frame_number++;
2021
2022   got_frame = gst_ffmpegviddec_video_frame (ffmpegdec, frame, ret);
2023
2024   return got_frame;
2025
2026   /* ERRORS */
2027 no_codec:
2028   {
2029     GST_ERROR_OBJECT (ffmpegdec, "no codec context");
2030     *ret = GST_FLOW_NOT_NEGOTIATED;
2031     return -1;
2032   }
2033 }
2034
2035 static GstFlowReturn
2036 gst_ffmpegviddec_drain (GstVideoDecoder * decoder)
2037 {
2038   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2039   GstFlowReturn ret = GST_FLOW_OK;
2040   gboolean got_frame = FALSE;
2041
2042   if (!ffmpegdec->opened)
2043     return GST_FLOW_OK;
2044
2045   GST_VIDEO_DECODER_STREAM_UNLOCK (ffmpegdec);
2046   if (avcodec_send_packet (ffmpegdec->context, NULL)) {
2047     GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2048     goto send_packet_failed;
2049   }
2050   GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2051
2052   do {
2053     got_frame = gst_ffmpegviddec_frame (ffmpegdec, NULL, &ret);
2054   } while (got_frame && ret == GST_FLOW_OK);
2055   avcodec_flush_buffers (ffmpegdec->context);
2056
2057   /* FFMpeg will return AVERROR_EOF if it's internal was fully drained
2058    * then we are translating it to GST_FLOW_EOS. However, because this behavior
2059    * is fully internal stuff of this implementation and gstvideodecoder
2060    * baseclass doesn't convert this GST_FLOW_EOS to GST_FLOW_OK,
2061    * convert this flow returned here */
2062   if (ret == GST_FLOW_EOS)
2063     ret = GST_FLOW_OK;
2064
2065 done:
2066   return ret;
2067
2068 send_packet_failed:
2069   GST_WARNING_OBJECT (ffmpegdec, "send packet failed, could not drain decoder");
2070   goto done;
2071 }
2072
2073 static GstFlowReturn
2074 gst_ffmpegviddec_handle_frame (GstVideoDecoder * decoder,
2075     GstVideoCodecFrame * frame)
2076 {
2077   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2078   guint8 *data;
2079   gint size;
2080   gboolean got_frame;
2081   GstMapInfo minfo;
2082   GstFlowReturn ret = GST_FLOW_OK;
2083   AVPacket packet;
2084
2085   GST_LOG_OBJECT (ffmpegdec,
2086       "Received new data of size %" G_GSIZE_FORMAT ", dts %" GST_TIME_FORMAT
2087       ", pts:%" GST_TIME_FORMAT ", dur:%" GST_TIME_FORMAT,
2088       gst_buffer_get_size (frame->input_buffer), GST_TIME_ARGS (frame->dts),
2089       GST_TIME_ARGS (frame->pts), GST_TIME_ARGS (frame->duration));
2090
2091   if (!gst_buffer_map (frame->input_buffer, &minfo, GST_MAP_READ)) {
2092     GST_ELEMENT_ERROR (ffmpegdec, STREAM, DECODE, ("Decoding problem"),
2093         ("Failed to map buffer for reading"));
2094     return GST_FLOW_ERROR;
2095   }
2096
2097   /* treat frame as void until a buffer is requested for it */
2098   if (!GST_VIDEO_CODEC_FRAME_FLAG_IS_SET (frame,
2099           GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED))
2100     GST_VIDEO_CODEC_FRAME_FLAG_SET (frame,
2101         GST_VIDEO_CODEC_FRAME_FLAG_DECODE_ONLY);
2102
2103   data = minfo.data;
2104   size = minfo.size;
2105
2106   if (size > 0 && (!GST_MEMORY_IS_ZERO_PADDED (minfo.memory)
2107           || (minfo.maxsize - minfo.size) < AV_INPUT_BUFFER_PADDING_SIZE)) {
2108     /* add padding */
2109     if (ffmpegdec->padded_size < size + AV_INPUT_BUFFER_PADDING_SIZE) {
2110       ffmpegdec->padded_size = size + AV_INPUT_BUFFER_PADDING_SIZE;
2111       ffmpegdec->padded = g_realloc (ffmpegdec->padded, ffmpegdec->padded_size);
2112       GST_LOG_OBJECT (ffmpegdec, "resized padding buffer to %d",
2113           ffmpegdec->padded_size);
2114     }
2115     GST_CAT_TRACE_OBJECT (GST_CAT_PERFORMANCE, ffmpegdec,
2116         "Copy input to add padding");
2117     memcpy (ffmpegdec->padded, data, size);
2118     memset (ffmpegdec->padded + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2119
2120     data = ffmpegdec->padded;
2121   }
2122
2123   /* now decode the frame */
2124   gst_avpacket_init (&packet, data, size);
2125
2126   if (!packet.size)
2127     goto done;
2128
2129   if (ffmpegdec->palette) {
2130     guint8 *pal;
2131
2132     pal = av_packet_new_side_data (&packet, AV_PKT_DATA_PALETTE,
2133         AVPALETTE_SIZE);
2134     gst_buffer_extract (ffmpegdec->palette, 0, pal, AVPALETTE_SIZE);
2135     GST_DEBUG_OBJECT (ffmpegdec, "copy pal %p %p", &packet, pal);
2136   }
2137
2138   /* save reference to the timing info */
2139   ffmpegdec->context->reordered_opaque = (gint64) frame->system_frame_number;
2140   ffmpegdec->picture->reordered_opaque = (gint64) frame->system_frame_number;
2141
2142   GST_DEBUG_OBJECT (ffmpegdec, "stored opaque values idx %d",
2143       frame->system_frame_number);
2144
2145   /* This might call into get_buffer() from another thread,
2146    * which would cause a deadlock. Release the lock here
2147    * and taking it again later seems safe
2148    * See https://bugzilla.gnome.org/show_bug.cgi?id=726020
2149    */
2150   GST_VIDEO_DECODER_STREAM_UNLOCK (ffmpegdec);
2151   if (avcodec_send_packet (ffmpegdec->context, &packet) < 0) {
2152     GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2153     av_packet_free_side_data (&packet);
2154     goto send_packet_failed;
2155   }
2156   av_packet_free_side_data (&packet);
2157   GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2158
2159   do {
2160     /* decode a frame of audio/video now */
2161     got_frame = gst_ffmpegviddec_frame (ffmpegdec, frame, &ret);
2162
2163     if (ret != GST_FLOW_OK) {
2164       GST_LOG_OBJECT (ffmpegdec, "breaking because of flow ret %s",
2165           gst_flow_get_name (ret));
2166       break;
2167     }
2168   } while (got_frame);
2169
2170 done:
2171   gst_buffer_unmap (frame->input_buffer, &minfo);
2172   gst_video_codec_frame_unref (frame);
2173
2174   return ret;
2175
2176 send_packet_failed:
2177   {
2178     GST_VIDEO_DECODER_ERROR (decoder, 1, STREAM, DECODE,
2179         ("Failed to send data for decoding"), ("Invalid input packet"), ret);
2180     goto done;
2181   }
2182 }
2183
2184 static gboolean
2185 gst_ffmpegviddec_start (GstVideoDecoder * decoder)
2186 {
2187   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2188   GstFFMpegVidDecClass *oclass;
2189
2190   oclass = GST_FFMPEGVIDDEC_GET_CLASS (ffmpegdec);
2191
2192   GST_OBJECT_LOCK (ffmpegdec);
2193   avcodec_free_context (&ffmpegdec->context);
2194   ffmpegdec->context = avcodec_alloc_context3 (oclass->in_plugin);
2195   if (ffmpegdec->context == NULL) {
2196     GST_DEBUG_OBJECT (ffmpegdec, "Failed to set context defaults");
2197     GST_OBJECT_UNLOCK (ffmpegdec);
2198     return FALSE;
2199   }
2200   ffmpegdec->context->opaque = ffmpegdec;
2201   GST_OBJECT_UNLOCK (ffmpegdec);
2202
2203   return TRUE;
2204 }
2205
2206 static gboolean
2207 gst_ffmpegviddec_stop (GstVideoDecoder * decoder)
2208 {
2209   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2210
2211   GST_OBJECT_LOCK (ffmpegdec);
2212   gst_ffmpegviddec_close (ffmpegdec, FALSE);
2213   GST_OBJECT_UNLOCK (ffmpegdec);
2214   g_free (ffmpegdec->padded);
2215   ffmpegdec->padded = NULL;
2216   ffmpegdec->padded_size = 0;
2217   if (ffmpegdec->input_state)
2218     gst_video_codec_state_unref (ffmpegdec->input_state);
2219   ffmpegdec->input_state = NULL;
2220   if (ffmpegdec->output_state)
2221     gst_video_codec_state_unref (ffmpegdec->output_state);
2222   ffmpegdec->output_state = NULL;
2223
2224   if (ffmpegdec->internal_pool)
2225     gst_object_unref (ffmpegdec->internal_pool);
2226   ffmpegdec->internal_pool = NULL;
2227
2228   ffmpegdec->pic_pix_fmt = 0;
2229   ffmpegdec->pic_width = 0;
2230   ffmpegdec->pic_height = 0;
2231   ffmpegdec->pic_par_n = 0;
2232   ffmpegdec->pic_par_d = 0;
2233   ffmpegdec->pic_interlaced = 0;
2234   ffmpegdec->pic_field_order = 0;
2235   ffmpegdec->pic_field_order_changed = FALSE;
2236   ffmpegdec->ctx_ticks = 0;
2237   ffmpegdec->ctx_time_n = 0;
2238   ffmpegdec->ctx_time_d = 0;
2239
2240   ffmpegdec->pool_width = 0;
2241   ffmpegdec->pool_height = 0;
2242   ffmpegdec->pool_format = 0;
2243
2244   return TRUE;
2245 }
2246
2247 static GstFlowReturn
2248 gst_ffmpegviddec_finish (GstVideoDecoder * decoder)
2249 {
2250   GstFlowReturn flow_ret;
2251
2252   flow_ret = gst_ffmpegviddec_drain (decoder);
2253
2254   /* note that finish can and should clean up more drastically,
2255    * but drain is also invoked on e.g. packet loss in GAP handling */
2256   gst_ffmpegviddec_flush (decoder);
2257
2258   return flow_ret;
2259 }
2260
2261 static gboolean
2262 gst_ffmpegviddec_flush (GstVideoDecoder * decoder)
2263 {
2264   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2265
2266   if (ffmpegdec->opened) {
2267     GST_LOG_OBJECT (decoder, "flushing buffers");
2268     avcodec_flush_buffers (ffmpegdec->context);
2269   }
2270
2271   return TRUE;
2272 }
2273
2274 static gboolean
2275 gst_ffmpegviddec_decide_allocation (GstVideoDecoder * decoder, GstQuery * query)
2276 {
2277   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2278   GstVideoCodecState *state;
2279   GstBufferPool *pool;
2280   guint size, min, max;
2281   GstStructure *config;
2282   gboolean have_pool, have_videometa, have_alignment, update_pool = FALSE;
2283   GstAllocator *allocator = NULL;
2284   GstAllocationParams params = DEFAULT_ALLOC_PARAM;
2285
2286   have_pool = (gst_query_get_n_allocation_pools (query) != 0);
2287
2288   if (!GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation (decoder,
2289           query))
2290     return FALSE;
2291
2292   state = gst_video_decoder_get_output_state (decoder);
2293
2294   if (gst_query_get_n_allocation_params (query) > 0) {
2295     gst_query_parse_nth_allocation_param (query, 0, &allocator, &params);
2296     params.align = MAX (params.align, DEFAULT_STRIDE_ALIGN);
2297   } else {
2298     gst_query_add_allocation_param (query, allocator, &params);
2299   }
2300
2301   gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
2302
2303   /* Don't use pool that can't grow, as we don't know how many buffer we'll
2304    * need, otherwise we may stall */
2305   if (max != 0 && max < REQUIRED_POOL_MAX_BUFFERS) {
2306     gst_object_unref (pool);
2307     pool = gst_video_buffer_pool_new ();
2308     max = 0;
2309     update_pool = TRUE;
2310     have_pool = FALSE;
2311
2312     /* if there is an allocator, also drop it, as it might be the reason we
2313      * have this limit. Default will be used */
2314     if (allocator) {
2315       gst_object_unref (allocator);
2316       allocator = NULL;
2317     }
2318   }
2319
2320   config = gst_buffer_pool_get_config (pool);
2321   gst_buffer_pool_config_set_params (config, state->caps, size, min, max);
2322   gst_buffer_pool_config_set_allocator (config, allocator, &params);
2323
2324   have_videometa =
2325       gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
2326
2327   if (have_videometa)
2328     gst_buffer_pool_config_add_option (config,
2329         GST_BUFFER_POOL_OPTION_VIDEO_META);
2330
2331   have_alignment =
2332       gst_buffer_pool_has_option (pool, GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
2333
2334   /* If we have videometa, we never have to copy */
2335   if (have_videometa && have_pool && have_alignment &&
2336       gst_ffmpegviddec_can_direct_render (ffmpegdec)) {
2337     GstStructure *config_copy = gst_structure_copy (config);
2338
2339     gst_ffmpegvideodec_prepare_dr_pool (ffmpegdec, pool, &state->info,
2340         config_copy);
2341
2342     /* FIXME validate and retry */
2343     if (gst_buffer_pool_set_config (pool, config_copy)) {
2344       GstFlowReturn ret;
2345       GstBuffer *tmp;
2346
2347       gst_buffer_pool_set_active (pool, TRUE);
2348       ret = gst_buffer_pool_acquire_buffer (pool, &tmp, NULL);
2349       if (ret == GST_FLOW_OK) {
2350         GstVideoMeta *vmeta = gst_buffer_get_video_meta (tmp);
2351         gboolean same_stride = TRUE;
2352         guint i;
2353
2354         for (i = 0; i < vmeta->n_planes; i++) {
2355           if (vmeta->stride[i] != ffmpegdec->stride[i]) {
2356             same_stride = FALSE;
2357             break;
2358           }
2359         }
2360
2361         gst_buffer_unref (tmp);
2362
2363         if (same_stride) {
2364           if (ffmpegdec->internal_pool)
2365             gst_object_unref (ffmpegdec->internal_pool);
2366           ffmpegdec->internal_pool = gst_object_ref (pool);
2367           ffmpegdec->pool_width = GST_VIDEO_INFO_WIDTH (&state->info);
2368           ffmpegdec->pool_height =
2369               MAX (GST_VIDEO_INFO_HEIGHT (&state->info),
2370               ffmpegdec->context->coded_height);
2371           ffmpegdec->pool_info = state->info;
2372           gst_structure_free (config);
2373           goto done;
2374         }
2375       }
2376     }
2377   }
2378
2379   if (have_videometa && ffmpegdec->internal_pool
2380       && gst_ffmpeg_pixfmt_to_videoformat (ffmpegdec->pool_format) ==
2381       GST_VIDEO_INFO_FORMAT (&state->info)
2382       && ffmpegdec->pool_width == state->info.width
2383       && ffmpegdec->pool_height == state->info.height) {
2384     update_pool = TRUE;
2385     gst_object_unref (pool);
2386     pool = gst_object_ref (ffmpegdec->internal_pool);
2387     gst_structure_free (config);
2388     goto done;
2389   }
2390
2391   /* configure */
2392   if (!gst_buffer_pool_set_config (pool, config)) {
2393     gboolean working_pool = FALSE;
2394     config = gst_buffer_pool_get_config (pool);
2395
2396     if (gst_buffer_pool_config_validate_params (config, state->caps, size, min,
2397             max)) {
2398       working_pool = gst_buffer_pool_set_config (pool, config);
2399     } else {
2400       gst_structure_free (config);
2401     }
2402
2403     if (!working_pool) {
2404       gst_object_unref (pool);
2405       pool = gst_video_buffer_pool_new ();
2406       config = gst_buffer_pool_get_config (pool);
2407       gst_buffer_pool_config_set_params (config, state->caps, size, min, max);
2408       gst_buffer_pool_config_set_allocator (config, NULL, &params);
2409       gst_buffer_pool_set_config (pool, config);
2410       update_pool = TRUE;
2411     }
2412   }
2413
2414 done:
2415   /* and store */
2416   if (update_pool)
2417     gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
2418
2419   gst_object_unref (pool);
2420   if (allocator)
2421     gst_object_unref (allocator);
2422   gst_video_codec_state_unref (state);
2423
2424   return TRUE;
2425 }
2426
2427 static gboolean
2428 gst_ffmpegviddec_propose_allocation (GstVideoDecoder * decoder,
2429     GstQuery * query)
2430 {
2431   GstAllocationParams params;
2432
2433   gst_allocation_params_init (&params);
2434   params.flags = GST_MEMORY_FLAG_ZERO_PADDED;
2435   params.align = DEFAULT_STRIDE_ALIGN;
2436   params.padding = AV_INPUT_BUFFER_PADDING_SIZE;
2437   /* we would like to have some padding so that we don't have to
2438    * memcpy. We don't suggest an allocator. */
2439   gst_query_add_allocation_param (query, NULL, &params);
2440
2441   return GST_VIDEO_DECODER_CLASS (parent_class)->propose_allocation (decoder,
2442       query);
2443 }
2444
2445 static void
2446 gst_ffmpegviddec_set_property (GObject * object,
2447     guint prop_id, const GValue * value, GParamSpec * pspec)
2448 {
2449   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (object);
2450
2451   switch (prop_id) {
2452     case PROP_LOWRES:
2453       ffmpegdec->lowres = ffmpegdec->context->lowres = g_value_get_enum (value);
2454       break;
2455     case PROP_SKIPFRAME:
2456       ffmpegdec->skip_frame = ffmpegdec->context->skip_frame =
2457           g_value_get_enum (value);
2458       break;
2459     case PROP_DIRECT_RENDERING:
2460       ffmpegdec->direct_rendering = g_value_get_boolean (value);
2461       break;
2462 #ifndef GST_REMOVE_DEPRECATED
2463     case PROP_DEBUG_MV:
2464       /* non-functional */
2465       break;
2466 #endif
2467     case PROP_MAX_THREADS:
2468       ffmpegdec->max_threads = g_value_get_int (value);
2469       break;
2470     case PROP_OUTPUT_CORRUPT:
2471       ffmpegdec->output_corrupt = g_value_get_boolean (value);
2472       break;
2473     case PROP_THREAD_TYPE:
2474       ffmpegdec->thread_type = g_value_get_flags (value);
2475       break;
2476     case PROP_STD_COMPLIANCE:
2477       ffmpegdec->std_compliance = g_value_get_enum (value);
2478       break;
2479     default:
2480       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2481       break;
2482   }
2483 }
2484
2485 static void
2486 gst_ffmpegviddec_get_property (GObject * object,
2487     guint prop_id, GValue * value, GParamSpec * pspec)
2488 {
2489   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (object);
2490
2491   switch (prop_id) {
2492     case PROP_LOWRES:
2493       g_value_set_enum (value, ffmpegdec->lowres);
2494       break;
2495     case PROP_SKIPFRAME:
2496       g_value_set_enum (value, ffmpegdec->skip_frame);
2497       break;
2498     case PROP_DIRECT_RENDERING:
2499       g_value_set_boolean (value, ffmpegdec->direct_rendering);
2500       break;
2501 #ifndef GST_REMOVE_DEPRECATED
2502     case PROP_DEBUG_MV:
2503       g_value_set_boolean (value, FALSE);
2504       break;
2505 #endif
2506     case PROP_MAX_THREADS:
2507       g_value_set_int (value, ffmpegdec->max_threads);
2508       break;
2509     case PROP_OUTPUT_CORRUPT:
2510       g_value_set_boolean (value, ffmpegdec->output_corrupt);
2511       break;
2512     case PROP_THREAD_TYPE:
2513       g_value_set_flags (value, ffmpegdec->thread_type);
2514       break;
2515     case PROP_STD_COMPLIANCE:
2516       g_value_set_enum (value, ffmpegdec->std_compliance);
2517       break;
2518     default:
2519       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2520       break;
2521   }
2522 }
2523
2524 gboolean
2525 gst_ffmpegviddec_register (GstPlugin * plugin)
2526 {
2527   GTypeInfo typeinfo = {
2528     sizeof (GstFFMpegVidDecClass),
2529     NULL,
2530     NULL,
2531     (GClassInitFunc) gst_ffmpegviddec_subclass_init,
2532     NULL,
2533     NULL,
2534     sizeof (GstFFMpegVidDec),
2535     0,
2536     (GInstanceInitFunc) gst_ffmpegviddec_subinit,
2537   };
2538   GType type;
2539   AVCodec *in_plugin;
2540   gint rank;
2541   void *i = 0;
2542
2543   GST_LOG ("Registering decoders");
2544
2545   while ((in_plugin = (AVCodec *) av_codec_iterate (&i))) {
2546     gchar *type_name;
2547     gchar *plugin_name;
2548
2549     /* only video decoders */
2550     if (!av_codec_is_decoder (in_plugin)
2551         || in_plugin->type != AVMEDIA_TYPE_VIDEO)
2552       continue;
2553
2554     /* no quasi codecs, please */
2555     if (in_plugin->id == AV_CODEC_ID_RAWVIDEO ||
2556         in_plugin->id == AV_CODEC_ID_V210 ||
2557         in_plugin->id == AV_CODEC_ID_V210X ||
2558         in_plugin->id == AV_CODEC_ID_V308 ||
2559         in_plugin->id == AV_CODEC_ID_V408 ||
2560         in_plugin->id == AV_CODEC_ID_V410 ||
2561         in_plugin->id == AV_CODEC_ID_R210
2562         || in_plugin->id == AV_CODEC_ID_AYUV
2563         || in_plugin->id == AV_CODEC_ID_Y41P
2564         || in_plugin->id == AV_CODEC_ID_012V
2565         || in_plugin->id == AV_CODEC_ID_YUV4
2566 #if AV_VERSION_INT (LIBAVCODEC_VERSION_MAJOR, LIBAVCODEC_VERSION_MINOR, LIBAVCODEC_VERSION_MICRO) >= \
2567         AV_VERSION_INT (57,4,0)
2568         || in_plugin->id == AV_CODEC_ID_WRAPPED_AVFRAME
2569 #endif
2570         || in_plugin->id == AV_CODEC_ID_ZLIB) {
2571       continue;
2572     }
2573
2574     /* No decoders depending on external libraries (we don't build them, but
2575      * people who build against an external ffmpeg might have them.
2576      * We have native gstreamer plugins for all of those libraries anyway. */
2577     if (!strncmp (in_plugin->name, "lib", 3)) {
2578       GST_DEBUG
2579           ("Not using external library decoder %s. Use the gstreamer-native ones instead.",
2580           in_plugin->name);
2581       continue;
2582     }
2583
2584     /* Skip hardware or hybrid (hardware with software fallback) */
2585     if ((in_plugin->capabilities & AV_CODEC_CAP_HARDWARE) ==
2586         AV_CODEC_CAP_HARDWARE) {
2587       GST_DEBUG
2588           ("Ignoring hardware decoder %s. We can't handle this outside of ffmpeg",
2589           in_plugin->name);
2590       continue;
2591     }
2592
2593     if ((in_plugin->capabilities & AV_CODEC_CAP_HYBRID) == AV_CODEC_CAP_HYBRID) {
2594       GST_DEBUG
2595           ("Ignoring hybrid decoder %s. We can't handle this outside of ffmpeg",
2596           in_plugin->name);
2597       continue;
2598     }
2599
2600     /* No vdpau plugins until we can figure out how to properly use them
2601      * outside of ffmpeg. */
2602     if (g_str_has_suffix (in_plugin->name, "_vdpau")) {
2603       GST_DEBUG
2604           ("Ignoring VDPAU decoder %s. We can't handle this outside of ffmpeg",
2605           in_plugin->name);
2606       continue;
2607     }
2608
2609     if (g_str_has_suffix (in_plugin->name, "_xvmc")) {
2610       GST_DEBUG
2611           ("Ignoring XVMC decoder %s. We can't handle this outside of ffmpeg",
2612           in_plugin->name);
2613       continue;
2614     }
2615
2616     if (strstr (in_plugin->name, "vaapi")) {
2617       GST_DEBUG
2618           ("Ignoring VAAPI decoder %s. We can't handle this outside of ffmpeg",
2619           in_plugin->name);
2620       continue;
2621     }
2622
2623     if (g_str_has_suffix (in_plugin->name, "_qsv")) {
2624       GST_DEBUG
2625           ("Ignoring qsv decoder %s. We can't handle this outside of ffmpeg",
2626           in_plugin->name);
2627       continue;
2628     }
2629
2630     GST_DEBUG ("Trying plugin %s [%s]", in_plugin->name, in_plugin->long_name);
2631
2632     /* no codecs for which we're GUARANTEED to have better alternatives */
2633     /* MPEG1VIDEO : the mpeg2video decoder is preferred */
2634     /* MP1 : Use MP3 for decoding */
2635     /* MP2 : Use MP3 for decoding */
2636     /* Theora: Use libtheora based theoradec */
2637     /* CDG: use cdgdec */
2638     /* AV1: Use av1dec, dav1ddec or any of the hardware decoders.
2639      *      Also ffmpeg's decoder only works with hardware support!
2640      */
2641     if (!strcmp (in_plugin->name, "theora") ||
2642         !strcmp (in_plugin->name, "mpeg1video") ||
2643         strstr (in_plugin->name, "crystalhd") != NULL ||
2644         !strcmp (in_plugin->name, "ass") ||
2645         !strcmp (in_plugin->name, "srt") ||
2646         !strcmp (in_plugin->name, "pgssub") ||
2647         !strcmp (in_plugin->name, "dvdsub") ||
2648         !strcmp (in_plugin->name, "dvbsub") ||
2649         !strcmp (in_plugin->name, "cdgraphics") ||
2650         !strcmp (in_plugin->name, "av1")) {
2651       GST_LOG ("Ignoring decoder %s", in_plugin->name);
2652       continue;
2653     }
2654
2655     /* construct the type */
2656     if (!strcmp (in_plugin->name, "hevc")) {
2657       plugin_name = g_strdup ("h265");
2658     } else {
2659       plugin_name = g_strdup ((gchar *) in_plugin->name);
2660     }
2661     g_strdelimit (plugin_name, NULL, '_');
2662     type_name = g_strdup_printf ("avdec_%s", plugin_name);
2663     g_free (plugin_name);
2664
2665     type = g_type_from_name (type_name);
2666
2667     if (!type) {
2668       /* create the gtype now */
2669       typeinfo.class_data = in_plugin;
2670       type =
2671           g_type_register_static (GST_TYPE_FFMPEGVIDDEC, type_name, &typeinfo,
2672           0);
2673     }
2674
2675     /* (Ronald) MPEG-4 gets a higher priority because it has been well-
2676      * tested and by far outperforms divxdec/xviddec - so we prefer it.
2677      * msmpeg4v3 same, as it outperforms divxdec for divx3 playback. */
2678     switch (in_plugin->id) {
2679       case AV_CODEC_ID_MPEG1VIDEO:
2680       case AV_CODEC_ID_MPEG2VIDEO:
2681       case AV_CODEC_ID_MPEG4:
2682       case AV_CODEC_ID_MSMPEG4V3:
2683       case AV_CODEC_ID_H264:
2684       case AV_CODEC_ID_HEVC:
2685       case AV_CODEC_ID_RV10:
2686       case AV_CODEC_ID_RV20:
2687       case AV_CODEC_ID_RV30:
2688       case AV_CODEC_ID_RV40:
2689         rank = GST_RANK_PRIMARY;
2690         break;
2691         /* DVVIDEO: we have a good dv decoder, fast on both ppc as well as x86.
2692          * They say libdv's quality is better though. leave as secondary.
2693          * note: if you change this, see the code in gstdv.c in good/ext/dv.
2694          */
2695       case AV_CODEC_ID_DVVIDEO:
2696         rank = GST_RANK_SECONDARY;
2697         break;
2698       default:
2699         rank = GST_RANK_MARGINAL;
2700         break;
2701     }
2702     if (!gst_element_register (plugin, type_name, rank, type)) {
2703       g_warning ("Failed to register %s", type_name);
2704       g_free (type_name);
2705       return FALSE;
2706     }
2707
2708     g_free (type_name);
2709   }
2710
2711   GST_LOG ("Finished Registering decoders");
2712
2713   return TRUE;
2714 }