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 = ffmpegdec->context->time_base.den;
 678     gint fps_d =
 679         ffmpegdec->context->time_base.num * ffmpegdec->context->ticks_per_frame;
 680     if (fps_n) {
 681       latency = gst_util_uint64_scale_ceil (
 682           (ffmpegdec->context->has_b_frames) * GST_SECOND, fps_d, fps_n);
 683
 684       if (ffmpegdec->context->thread_type & FF_THREAD_FRAME) {
 685         latency +=
 686             gst_util_uint64_scale_ceil (ffmpegdec->context->thread_count *
 687             GST_SECOND, fps_d, fps_n);
 688       }
 689     }
 690   }
 691
 692   ret = TRUE;
 693
 694 done:
 695   GST_OBJECT_UNLOCK (ffmpegdec);
 696
 697   if (GST_CLOCK_TIME_IS_VALID (latency))
 698     gst_video_decoder_set_latency (decoder, latency, latency);
 699
 700   return ret;
 701
 702   /* ERRORS */
 703 open_failed:
 704   {
 705     GST_DEBUG_OBJECT (ffmpegdec, "Failed to open");
 706     goto done;
 707   }
 708 nal_only_slice:
 709   {
 710     GST_ERROR_OBJECT (ffmpegdec,
 711         "Can't do NAL aligned H.264 with frame threading.");
 712     goto done;
 713   }
 714 }
 715
 716 typedef struct
 717 {
 718   GstFFMpegVidDec *ffmpegdec;
 719   GstVideoCodecFrame *frame;
 720   gboolean mapped;
 721   GstVideoFrame vframe;
 722   GstBuffer *buffer;
 723   AVBufferRef *avbuffer;
 724 } GstFFMpegVidDecVideoFrame;
 725
 726 static GstFFMpegVidDecVideoFrame *
 727 gst_ffmpegviddec_video_frame_new (GstFFMpegVidDec * ffmpegdec,
 728     GstVideoCodecFrame * frame)
 729 {
 730   GstFFMpegVidDecVideoFrame *dframe;
 731
 732   dframe = g_slice_new0 (GstFFMpegVidDecVideoFrame);
 733   dframe->ffmpegdec = ffmpegdec;
 734   dframe->frame = frame;
 735
 736   GST_DEBUG_OBJECT (ffmpegdec, "new video frame %p", dframe);
 737
 738   return dframe;
 739 }
 740
 741 static void
 742 gst_ffmpegviddec_video_frame_free (GstFFMpegVidDec * ffmpegdec,
 743     GstFFMpegVidDecVideoFrame * frame)
 744 {
 745   GST_DEBUG_OBJECT (ffmpegdec, "free video frame %p", frame);
 746
 747   if (frame->mapped)
 748     gst_video_frame_unmap (&frame->vframe);
 749   GST_VIDEO_CODEC_FRAME_FLAG_UNSET (frame->frame,
 750       GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
 751   gst_video_decoder_release_frame (GST_VIDEO_DECODER (ffmpegdec), frame->frame);
 752   gst_buffer_replace (&frame->buffer, NULL);
 753   if (frame->avbuffer) {
 754     av_buffer_unref (&frame->avbuffer);
 755   }
 756   g_slice_free (GstFFMpegVidDecVideoFrame, frame);
 757 }
 758
 759 static void
 760 dummy_free_buffer (void *opaque, uint8_t * data)
 761 {
 762   GstFFMpegVidDecVideoFrame *frame = opaque;
 763
 764   gst_ffmpegviddec_video_frame_free (frame->ffmpegdec, frame);
 765 }
 766
 767 /* This function prepares the pool configuration for direct rendering. To use
 768  * this method, the codec should support direct rendering and the pool should
 769  * support video meta and video alignment */
 770 static void
 771 gst_ffmpegvideodec_prepare_dr_pool (GstFFMpegVidDec * ffmpegdec,
 772     GstBufferPool * pool, GstVideoInfo * info, GstStructure * config)
 773 {
 774   GstAllocationParams params;
 775   GstVideoAlignment align;
 776   GstAllocator *allocator = NULL;
 777   gint width, height;
 778   gint linesize_align[AV_NUM_DATA_POINTERS];
 779   gint i;
 780   gsize max_align;
 781
 782   width = GST_VIDEO_INFO_WIDTH (info);
 783   height = MAX (GST_VIDEO_INFO_HEIGHT (info), ffmpegdec->context->coded_height);
 784
 785   /* let ffmpeg find the alignment and padding */
 786   avcodec_align_dimensions2 (ffmpegdec->context, &width, &height,
 787       linesize_align);
 788
 789   align.padding_top = 0;
 790   align.padding_left = 0;
 791   align.padding_right = width - GST_VIDEO_INFO_WIDTH (info);
 792   align.padding_bottom = height - GST_VIDEO_INFO_HEIGHT (info);
 793
 794   /* add extra padding to match libav buffer allocation sizes */
 795   align.padding_bottom++;
 796
 797   gst_buffer_pool_config_get_allocator (config, &allocator, &params);
 798
 799   max_align = DEFAULT_STRIDE_ALIGN;
 800   max_align |= params.align;
 801
 802   for (i = 0; i < GST_VIDEO_MAX_PLANES; i++) {
 803     if (linesize_align[i] > 0)
 804       max_align |= linesize_align[i] - 1;
 805   }
 806
 807   for (i = 0; i < GST_VIDEO_MAX_PLANES; i++)
 808     align.stride_align[i] = max_align;
 809
 810   params.align = max_align;
 811
 812   gst_buffer_pool_config_set_allocator (config, allocator, &params);
 813
 814   GST_DEBUG_OBJECT (ffmpegdec, "aligned dimension %dx%d -> %dx%d "
 815       "padding t:%u l:%u r:%u b:%u, stride_align %d:%d:%d:%d",
 816       GST_VIDEO_INFO_WIDTH (info),
 817       GST_VIDEO_INFO_HEIGHT (info), width, height, align.padding_top,
 818       align.padding_left, align.padding_right, align.padding_bottom,
 819       align.stride_align[0], align.stride_align[1], align.stride_align[2],
 820       align.stride_align[3]);
 821
 822   gst_buffer_pool_config_add_option (config,
 823       GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
 824   gst_buffer_pool_config_set_video_alignment (config, &align);
 825 }
 826
 827 static void
 828 gst_ffmpegviddec_ensure_internal_pool (GstFFMpegVidDec * ffmpegdec,
 829     AVFrame * picture, GstVideoInterlaceMode interlace_mode)
 830 {
 831   GstAllocationParams params = DEFAULT_ALLOC_PARAM;
 832   GstVideoInfo info;
 833   GstVideoFormat format;
 834   GstCaps *caps;
 835   GstStructure *config;
 836   guint i;
 837
 838   format = gst_ffmpeg_pixfmt_to_videoformat (picture->format);
 839
 840   if (ffmpegdec->internal_pool != NULL &&
 841       GST_VIDEO_INFO_FORMAT (&ffmpegdec->pool_info) == format &&
 842       ffmpegdec->pool_width == picture->width &&
 843       ffmpegdec->pool_height == picture->height &&
 844       ffmpegdec->pool_format == picture->format)
 845     return;
 846
 847   GST_DEBUG_OBJECT (ffmpegdec, "Updating internal pool (%i, %i)",
 848       picture->width, picture->height);
 849
 850   /* if we are negotiating from get_buffer, then renegotiate later in order
 851    * to potentially use a downstream pool */
 852   if (gst_ffmpegviddec_can_direct_render (ffmpegdec))
 853     gst_pad_mark_reconfigure (GST_VIDEO_DECODER_SRC_PAD (ffmpegdec));
 854
 855   format = gst_ffmpeg_pixfmt_to_videoformat (picture->format);
 856
 857   if (interlace_mode == GST_VIDEO_INTERLACE_MODE_ALTERNATE) {
 858     gst_video_info_set_interlaced_format (&info, format, interlace_mode,
 859         picture->width, 2 * picture->height);
 860   } else {
 861     gst_video_info_set_format (&info, format, picture->width, picture->height);
 862   }
 863
 864   /* If we have not yet been negotiated, a NONE format here would
 865    * result in invalid initial dimension alignments, and potential
 866    * out of bounds writes.
 867    */
 868   ffmpegdec->context->pix_fmt = picture->format;
 869
 870   for (i = 0; i < G_N_ELEMENTS (ffmpegdec->stride); i++)
 871     ffmpegdec->stride[i] = -1;
 872
 873   if (ffmpegdec->internal_pool)
 874     gst_object_unref (ffmpegdec->internal_pool);
 875
 876   ffmpegdec->internal_pool = gst_video_buffer_pool_new ();
 877   config = gst_buffer_pool_get_config (ffmpegdec->internal_pool);
 878
 879   caps = gst_video_info_to_caps (&info);
 880   gst_buffer_pool_config_set_params (config, caps, info.size, 2, 0);
 881   gst_buffer_pool_config_set_allocator (config, NULL, &params);
 882   gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
 883
 884   gst_ffmpegvideodec_prepare_dr_pool (ffmpegdec,
 885       ffmpegdec->internal_pool, &info, config);
 886   /* generic video pool never fails */
 887   gst_buffer_pool_set_config (ffmpegdec->internal_pool, config);
 888   gst_caps_unref (caps);
 889
 890   gst_buffer_pool_set_active (ffmpegdec->internal_pool, TRUE);
 891
 892   /* Remember pool size so we can detect changes */
 893   ffmpegdec->pool_width = picture->width;
 894   ffmpegdec->pool_height =
 895       MAX (picture->height, ffmpegdec->context->coded_height);
 896   ffmpegdec->pool_format = picture->format;
 897   ffmpegdec->pool_info = info;
 898 }
 899
 900 static gboolean
 901 gst_ffmpegviddec_can_direct_render (GstFFMpegVidDec * ffmpegdec)
 902 {
 903   GstFFMpegVidDecClass *oclass;
 904
 905   if (!ffmpegdec->direct_rendering)
 906     return FALSE;
 907
 908   oclass = GST_FFMPEGVIDDEC_GET_CLASS (ffmpegdec);
 909   return ((oclass->in_plugin->capabilities & AV_CODEC_CAP_DR1) ==
 910       AV_CODEC_CAP_DR1);
 911 }
 912
 913 /* called when ffmpeg wants us to allocate a buffer to write the decoded frame
 914  * into. We try to give it memory from our pool */
 915 static int
 916 gst_ffmpegviddec_get_buffer2 (AVCodecContext * context, AVFrame * picture,
 917     int flags)
 918 {
 919   GstVideoCodecFrame *frame;
 920   GstFFMpegVidDecVideoFrame *dframe;
 921   GstFFMpegVidDec *ffmpegdec;
 922   guint c;
 923   GstFlowReturn ret;
 924   int create_buffer_flags = 0;
 925
 926   ffmpegdec = GST_FFMPEGVIDDEC (context->opaque);
 927
 928   GST_DEBUG_OBJECT (ffmpegdec, "getting buffer picture %p", picture);
 929
 930   /* apply the last info we have seen to this picture, when we get the
 931    * picture back from ffmpeg we can use this to correctly timestamp the output
 932    * buffer */
 933   GST_DEBUG_OBJECT (ffmpegdec, "opaque value SN %d",
 934       (gint32) picture->reordered_opaque);
 935
 936   frame =
 937       gst_video_decoder_get_frame (GST_VIDEO_DECODER (ffmpegdec),
 938       picture->reordered_opaque);
 939   if (G_UNLIKELY (frame == NULL))
 940     goto no_frame;
 941
 942   /* now it has a buffer allocated, so it is real and will also
 943    * be _released */
 944   GST_VIDEO_CODEC_FRAME_FLAG_SET (frame,
 945       GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
 946   GST_VIDEO_CODEC_FRAME_FLAG_UNSET (frame,
 947       GST_VIDEO_CODEC_FRAME_FLAG_DECODE_ONLY);
 948
 949   if (G_UNLIKELY (frame->output_buffer != NULL))
 950     goto duplicate_frame;
 951
 952   /* GstFFMpegVidDecVideoFrame receives the frame ref */
 953   if (picture->opaque) {
 954     dframe = picture->opaque;
 955     dframe->frame = frame;
 956   } else {
 957     picture->opaque = dframe =
 958         gst_ffmpegviddec_video_frame_new (ffmpegdec, frame);
 959   }
 960
 961   GST_DEBUG_OBJECT (ffmpegdec, "storing opaque %p", dframe);
 962
 963   if (!gst_ffmpegviddec_can_direct_render (ffmpegdec))
 964     goto no_dr;
 965
 966   gst_ffmpegviddec_ensure_internal_pool (ffmpegdec, picture,
 967       GST_BUFFER_FLAG_IS_SET (frame->input_buffer,
 968           GST_VIDEO_BUFFER_FLAG_ONEFIELD) ? GST_VIDEO_INTERLACE_MODE_ALTERNATE :
 969       GST_VIDEO_INTERLACE_MODE_PROGRESSIVE);
 970
 971   ret = gst_buffer_pool_acquire_buffer (ffmpegdec->internal_pool,
 972       &frame->output_buffer, NULL);
 973   if (ret != GST_FLOW_OK)
 974     goto alloc_failed;
 975
 976   /* piggy-backed alloc'ed on the frame,
 977    * and there was much rejoicing and we are grateful.
 978    * Now take away buffer from frame, we will give it back later when decoded.
 979    * This allows multiple request for a buffer per frame; unusual but possible. */
 980   gst_buffer_replace (&dframe->buffer, frame->output_buffer);
 981   gst_buffer_replace (&frame->output_buffer, NULL);
 982
 983   /* Fill avpicture */
 984   if (!gst_video_frame_map (&dframe->vframe, &ffmpegdec->pool_info,
 985           dframe->buffer, GST_MAP_READWRITE))
 986     goto map_failed;
 987   dframe->mapped = TRUE;
 988
 989   for (c = 0; c < AV_NUM_DATA_POINTERS; c++) {
 990     if (c < GST_VIDEO_INFO_N_PLANES (&ffmpegdec->pool_info)) {
 991       picture->data[c] = GST_VIDEO_FRAME_PLANE_DATA (&dframe->vframe, c);
 992       picture->linesize[c] = GST_VIDEO_FRAME_PLANE_STRIDE (&dframe->vframe, c);
 993
 994       if (ffmpegdec->stride[c] == -1)
 995         ffmpegdec->stride[c] = picture->linesize[c];
 996
 997       /* libav does not allow stride changes, decide allocation should check
 998        * before replacing the internal pool with a downstream pool.
 999        * https://bugzilla.gnome.org/show_bug.cgi?id=704769
1000        * https://bugzilla.libav.org/show_bug.cgi?id=556
1001        */
1002       g_assert (picture->linesize[c] == ffmpegdec->stride[c]);
1003     } else {
1004       picture->data[c] = NULL;
1005       picture->linesize[c] = 0;
1006     }
1007     GST_LOG_OBJECT (ffmpegdec, "linesize %d, data %p", picture->linesize[c],
1008         picture->data[c]);
1009   }
1010
1011   if ((flags & AV_GET_BUFFER_FLAG_REF) == AV_GET_BUFFER_FLAG_REF) {
1012     /* decoder might reuse this AVFrame and it would result to no more
1013      * get_buffer() call if the AVFrame's AVBuffer is writable
1014      * (meaning that the refcount of AVBuffer == 1).
1015      * To enforce get_buffer() for the every output frame, set read-only flag here
1016      */
1017     create_buffer_flags = AV_BUFFER_FLAG_READONLY;
1018   }
1019   picture->buf[0] = av_buffer_create (NULL,
1020       0, dummy_free_buffer, dframe, create_buffer_flags);
1021
1022   GST_LOG_OBJECT (ffmpegdec, "returned frame %p", dframe->buffer);
1023
1024   return 0;
1025
1026 no_dr:
1027   {
1028     int c;
1029     int ret = avcodec_default_get_buffer2 (context, picture, flags);
1030
1031     GST_LOG_OBJECT (ffmpegdec, "direct rendering disabled, fallback alloc");
1032
1033     for (c = 0; c < AV_NUM_DATA_POINTERS; c++) {
1034       ffmpegdec->stride[c] = picture->linesize[c];
1035     }
1036     /* Wrap our buffer around the default one to be able to have a callback
1037      * when our data can be freed. Just putting our data into the first free
1038      * buffer might not work if there are too many allocated already
1039      */
1040     if (picture->buf[0]) {
1041       dframe->avbuffer = picture->buf[0];
1042       picture->buf[0] =
1043           av_buffer_create (picture->buf[0]->data, picture->buf[0]->size,
1044           dummy_free_buffer, dframe, 0);
1045     } else {
1046       picture->buf[0] =
1047           av_buffer_create (NULL, 0, dummy_free_buffer, dframe, 0);
1048     }
1049
1050     return ret;
1051   }
1052 alloc_failed:
1053   {
1054     GST_ELEMENT_ERROR (ffmpegdec, RESOURCE, FAILED,
1055         ("Unable to allocate memory"),
1056         ("The downstream pool failed to allocated buffer."));
1057     return -1;
1058   }
1059 map_failed:
1060   {
1061     GST_ELEMENT_ERROR (ffmpegdec, RESOURCE, OPEN_READ_WRITE,
1062         ("Cannot access memory for read and write operation."),
1063         ("The video memory allocated from downstream pool could not mapped for"
1064             "read and write."));
1065     return -1;
1066   }
1067 duplicate_frame:
1068   {
1069     GST_WARNING_OBJECT (ffmpegdec, "already alloc'ed output buffer for frame");
1070     gst_video_codec_frame_unref (frame);
1071     return -1;
1072   }
1073 no_frame:
1074   {
1075     GST_WARNING_OBJECT (ffmpegdec, "Couldn't get codec frame !");
1076     return -1;
1077   }
1078 }
1079
1080 static gboolean
1081 picture_changed (GstFFMpegVidDec * ffmpegdec, AVFrame * picture,
1082     gboolean one_field)
1083 {
1084   gint pic_field_order = 0;
1085
1086   if (one_field) {
1087     pic_field_order = ffmpegdec->pic_field_order;
1088   } else if (picture->interlaced_frame) {
1089     if (picture->repeat_pict)
1090       pic_field_order |= GST_VIDEO_BUFFER_FLAG_RFF;
1091     if (picture->top_field_first)
1092       pic_field_order |= GST_VIDEO_BUFFER_FLAG_TFF;
1093   }
1094
1095   return !(ffmpegdec->pic_width == picture->width
1096       && ffmpegdec->pic_height == picture->height
1097       && ffmpegdec->pic_pix_fmt == picture->format
1098       && ffmpegdec->pic_par_n == picture->sample_aspect_ratio.num
1099       && ffmpegdec->pic_par_d == picture->sample_aspect_ratio.den
1100       && ffmpegdec->pic_interlaced == picture->interlaced_frame
1101       && ffmpegdec->pic_field_order == pic_field_order
1102       && ffmpegdec->cur_multiview_mode == ffmpegdec->picture_multiview_mode
1103       && ffmpegdec->cur_multiview_flags == ffmpegdec->picture_multiview_flags);
1104 }
1105
1106 static gboolean
1107 context_changed (GstFFMpegVidDec * ffmpegdec, AVCodecContext * context)
1108 {
1109   return !(ffmpegdec->ctx_ticks == context->ticks_per_frame
1110       && ffmpegdec->ctx_time_n == context->time_base.num
1111       && ffmpegdec->ctx_time_d == context->time_base.den);
1112 }
1113
1114 static gboolean
1115 update_video_context (GstFFMpegVidDec * ffmpegdec, AVCodecContext * context,
1116     AVFrame * picture, gboolean one_field)
1117 {
1118   gint pic_field_order = 0;
1119
1120   if (picture->interlaced_frame) {
1121     if (picture->repeat_pict)
1122       pic_field_order |= GST_VIDEO_BUFFER_FLAG_RFF;
1123     if (picture->top_field_first)
1124       pic_field_order |= GST_VIDEO_BUFFER_FLAG_TFF;
1125   }
1126
1127   if (!picture_changed (ffmpegdec, picture, one_field)
1128       && !context_changed (ffmpegdec, context))
1129     return FALSE;
1130
1131   GST_DEBUG_OBJECT (ffmpegdec,
1132       "Renegotiating video from %dx%d@ %d:%d PAR %d/%d fps pixfmt %d to %dx%d@ %d:%d PAR %d/%d fps pixfmt %d",
1133       ffmpegdec->pic_width, ffmpegdec->pic_height,
1134       ffmpegdec->pic_par_n, ffmpegdec->pic_par_d,
1135       ffmpegdec->ctx_time_n, ffmpegdec->ctx_time_d,
1136       ffmpegdec->pic_pix_fmt,
1137       picture->width, picture->height,
1138       picture->sample_aspect_ratio.num,
1139       picture->sample_aspect_ratio.den,
1140       context->time_base.num, context->time_base.den, picture->format);
1141
1142   ffmpegdec->pic_pix_fmt = picture->format;
1143   ffmpegdec->pic_width = picture->width;
1144   ffmpegdec->pic_height = picture->height;
1145   ffmpegdec->pic_par_n = picture->sample_aspect_ratio.num;
1146   ffmpegdec->pic_par_d = picture->sample_aspect_ratio.den;
1147   ffmpegdec->cur_multiview_mode = ffmpegdec->picture_multiview_mode;
1148   ffmpegdec->cur_multiview_flags = ffmpegdec->picture_multiview_flags;
1149
1150   /* Remember if we have interlaced content and the field order changed
1151    * at least once. If that happens, we must be interlace-mode=mixed
1152    */
1153   if (ffmpegdec->pic_field_order_changed ||
1154       (ffmpegdec->pic_field_order != pic_field_order &&
1155           ffmpegdec->pic_interlaced))
1156     ffmpegdec->pic_field_order_changed = TRUE;
1157
1158   ffmpegdec->pic_field_order = pic_field_order;
1159   ffmpegdec->pic_interlaced = picture->interlaced_frame;
1160
1161   if (!ffmpegdec->pic_interlaced)
1162     ffmpegdec->pic_field_order_changed = FALSE;
1163
1164   ffmpegdec->ctx_ticks = context->ticks_per_frame;
1165   ffmpegdec->ctx_time_n = context->time_base.num;
1166   ffmpegdec->ctx_time_d = context->time_base.den;
1167
1168   return TRUE;
1169 }
1170
1171 static void
1172 gst_ffmpegviddec_update_par (GstFFMpegVidDec * ffmpegdec,
1173     GstVideoInfo * in_info, GstVideoInfo * out_info)
1174 {
1175   gboolean demuxer_par_set = FALSE;
1176   gboolean decoder_par_set = FALSE;
1177   gint demuxer_num = 1, demuxer_denom = 1;
1178   gint decoder_num = 1, decoder_denom = 1;
1179   GstVideoCodecFrame *out_frame;
1180   GstFFMpegVidDecVideoFrame *out_dframe;
1181
1182   if (in_info->par_n && in_info->par_d) {
1183     demuxer_num = in_info->par_n;
1184     demuxer_denom = in_info->par_d;
1185     demuxer_par_set = TRUE;
1186     GST_DEBUG_OBJECT (ffmpegdec, "Demuxer PAR: %d:%d", demuxer_num,
1187         demuxer_denom);
1188   }
1189
1190   if (ffmpegdec->pic_par_n && ffmpegdec->pic_par_d) {
1191     decoder_num = ffmpegdec->pic_par_n;
1192     decoder_denom = ffmpegdec->pic_par_d;
1193     decoder_par_set = TRUE;
1194     GST_DEBUG_OBJECT (ffmpegdec, "Decoder PAR: %d:%d", decoder_num,
1195         decoder_denom);
1196   }
1197
1198   if (!demuxer_par_set && !decoder_par_set)
1199     goto no_par;
1200
1201   if (demuxer_par_set && !decoder_par_set)
1202     goto use_demuxer_par;
1203
1204   if (decoder_par_set && !demuxer_par_set)
1205     goto use_decoder_par;
1206
1207   /* Special case for some encoders which provide an 1:2 pixel aspect ratio
1208    * for HEVC interlaced content, possibly to work around decoders that don't
1209    * support field-based interlacing. Add some defensive checks to check for
1210    * a "common" aspect ratio. */
1211   out_dframe = ffmpegdec->picture->opaque;
1212   out_frame = out_dframe->frame;
1213
1214   if (demuxer_num == 1 && demuxer_denom == 1 &&
1215       decoder_num == 1 && decoder_denom == 2 &&
1216       GST_BUFFER_FLAG_IS_SET (out_frame->input_buffer,
1217           GST_VIDEO_BUFFER_FLAG_ONEFIELD) &&
1218       gst_video_is_common_aspect_ratio (ffmpegdec->pic_width,
1219           ffmpegdec->pic_height, 1, 2) &&
1220       !gst_video_is_common_aspect_ratio (ffmpegdec->pic_width,
1221           ffmpegdec->pic_height, 1, 1)) {
1222     GST_WARNING_OBJECT (ffmpegdec,
1223         "PAR 1/2 makes the aspect ratio of "
1224         "a %d x %d frame uncommon. Switching to 1/1",
1225         ffmpegdec->pic_width, ffmpegdec->pic_height);
1226     goto use_demuxer_par;
1227   }
1228
1229   /* Both the demuxer and the decoder provide a PAR. If one of
1230    * the two PARs is 1:1 and the other one is not, use the one
1231    * that is not 1:1. */
1232   if (demuxer_num == demuxer_denom && decoder_num != decoder_denom) {
1233     goto use_decoder_par;
1234   }
1235
1236   if (decoder_num == decoder_denom && demuxer_num != demuxer_denom) {
1237     goto use_demuxer_par;
1238   }
1239
1240   /* Both PARs are non-1:1, so use the PAR provided by the demuxer */
1241   goto use_demuxer_par;
1242
1243 use_decoder_par:
1244   {
1245     GST_DEBUG_OBJECT (ffmpegdec,
1246         "Setting decoder provided pixel-aspect-ratio of %u:%u", decoder_num,
1247         decoder_denom);
1248     out_info->par_n = decoder_num;
1249     out_info->par_d = decoder_denom;
1250     return;
1251   }
1252 use_demuxer_par:
1253   {
1254     GST_DEBUG_OBJECT (ffmpegdec,
1255         "Setting demuxer provided pixel-aspect-ratio of %u:%u", demuxer_num,
1256         demuxer_denom);
1257     out_info->par_n = demuxer_num;
1258     out_info->par_d = demuxer_denom;
1259     return;
1260   }
1261 no_par:
1262   {
1263     GST_DEBUG_OBJECT (ffmpegdec,
1264         "Neither demuxer nor codec provide a pixel-aspect-ratio");
1265     out_info->par_n = 1;
1266     out_info->par_d = 1;
1267     return;
1268   }
1269 }
1270
1271 static GstVideoMultiviewMode
1272 stereo_av_to_gst (enum AVStereo3DType type)
1273 {
1274   switch (type) {
1275     case AV_STEREO3D_SIDEBYSIDE:
1276       return GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE;
1277     case AV_STEREO3D_TOPBOTTOM:
1278       return GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM;
1279     case AV_STEREO3D_FRAMESEQUENCE:
1280       return GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME;
1281     case AV_STEREO3D_CHECKERBOARD:
1282       return GST_VIDEO_MULTIVIEW_MODE_CHECKERBOARD;
1283     case AV_STEREO3D_SIDEBYSIDE_QUINCUNX:
1284       return GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX;
1285     case AV_STEREO3D_LINES:
1286       return GST_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED;
1287     case AV_STEREO3D_COLUMNS:
1288       return GST_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED;
1289     default:
1290       break;
1291   }
1292
1293   return GST_VIDEO_MULTIVIEW_MODE_NONE;
1294 }
1295
1296 static gboolean
1297 mastering_display_metadata_av_to_gst (AVMasteringDisplayMetadata * av,
1298     GstVideoMasteringDisplayInfo * gst)
1299 {
1300   const guint64 chroma_scale = 50000;
1301   const guint64 luma_scale = 10000;
1302   gint i;
1303
1304   /* Use only complete mastering meta */
1305   if (!av->has_primaries || !av->has_luminance)
1306     return FALSE;
1307
1308   for (i = 0; i < G_N_ELEMENTS (gst->display_primaries); i++) {
1309     gst->display_primaries[i].x = (guint16) gst_util_uint64_scale (chroma_scale,
1310         av->display_primaries[i][0].num, av->display_primaries[i][0].den);
1311     gst->display_primaries[i].y = (guint16) gst_util_uint64_scale (chroma_scale,
1312         av->display_primaries[i][1].num, av->display_primaries[i][1].den);
1313   }
1314
1315   gst->white_point.x = (guint16) gst_util_uint64_scale (chroma_scale,
1316       av->white_point[0].num, av->white_point[0].den);
1317   gst->white_point.y = (guint16) gst_util_uint64_scale (chroma_scale,
1318       av->white_point[1].num, av->white_point[1].den);
1319
1320
1321   gst->max_display_mastering_luminance =
1322       (guint32) gst_util_uint64_scale (luma_scale,
1323       av->max_luminance.num, av->max_luminance.den);
1324   gst->min_display_mastering_luminance =
1325       (guint32) gst_util_uint64_scale (luma_scale,
1326       av->min_luminance.num, av->min_luminance.den);
1327
1328   return TRUE;
1329 }
1330
1331 static gboolean
1332 content_light_metadata_av_to_gst (AVContentLightMetadata * av,
1333     GstVideoContentLightLevel * gst)
1334 {
1335   gst->max_content_light_level = av->MaxCLL;
1336   gst->max_frame_average_light_level = av->MaxFALL;
1337
1338   return TRUE;
1339 }
1340
1341 static gboolean
1342 gst_ffmpegviddec_negotiate (GstFFMpegVidDec * ffmpegdec,
1343     AVCodecContext * context, AVFrame * picture, GstBufferFlags flags)
1344 {
1345   GstVideoFormat fmt;
1346   GstVideoInfo *in_info, *out_info;
1347   GstVideoCodecState *output_state;
1348   gint fps_n, fps_d;
1349   GstClockTime latency;
1350   GstStructure *in_s;
1351   GstVideoInterlaceMode interlace_mode;
1352   gint caps_height;
1353   gboolean one_field = ! !(flags & GST_VIDEO_BUFFER_FLAG_ONEFIELD);
1354
1355   if (!update_video_context (ffmpegdec, context, picture, one_field))
1356     return TRUE;
1357
1358   caps_height = ffmpegdec->pic_height;
1359
1360   fmt = gst_ffmpeg_pixfmt_to_videoformat (ffmpegdec->pic_pix_fmt);
1361   if (G_UNLIKELY (fmt == GST_VIDEO_FORMAT_UNKNOWN))
1362     goto unknown_format;
1363
1364   /* set the interlaced flag */
1365   in_s = gst_caps_get_structure (ffmpegdec->input_state->caps, 0);
1366   if (flags & GST_VIDEO_BUFFER_FLAG_ONEFIELD) {
1367     /* TODO: we don't get that information from ffmpeg, so copy it from
1368      * the parser */
1369     interlace_mode = GST_VIDEO_INTERLACE_MODE_ALTERNATE;
1370     caps_height = 2 * caps_height;
1371   } else if (!gst_structure_has_field (in_s, "interlace-mode")) {
1372     if (ffmpegdec->pic_interlaced) {
1373       if (ffmpegdec->pic_field_order_changed ||
1374           (ffmpegdec->pic_field_order & GST_VIDEO_BUFFER_FLAG_RFF)) {
1375         interlace_mode = GST_VIDEO_INTERLACE_MODE_MIXED;
1376       } else {
1377         interlace_mode = GST_VIDEO_INTERLACE_MODE_INTERLEAVED;
1378       }
1379     } else {
1380       interlace_mode = GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
1381     }
1382   } else {
1383     GstVideoInfo info;
1384
1385     gst_video_info_from_caps (&info, ffmpegdec->input_state->caps);
1386     interlace_mode = info.interlace_mode;
1387   }
1388
1389   if (interlace_mode == GST_VIDEO_INTERLACE_MODE_ALTERNATE)
1390     output_state =
1391         gst_video_decoder_set_interlaced_output_state (GST_VIDEO_DECODER
1392         (ffmpegdec), fmt, interlace_mode, ffmpegdec->pic_width, caps_height,
1393         ffmpegdec->input_state);
1394   else
1395     output_state =
1396         gst_video_decoder_set_output_state (GST_VIDEO_DECODER
1397         (ffmpegdec), fmt, ffmpegdec->pic_width, caps_height,
1398         ffmpegdec->input_state);
1399   if (ffmpegdec->output_state)
1400     gst_video_codec_state_unref (ffmpegdec->output_state);
1401   ffmpegdec->output_state = output_state;
1402
1403   in_info = &ffmpegdec->input_state->info;
1404   out_info = &ffmpegdec->output_state->info;
1405
1406   out_info->interlace_mode = interlace_mode;
1407   if (!gst_structure_has_field (in_s, "interlace-mode")
1408       && interlace_mode == GST_VIDEO_INTERLACE_MODE_INTERLEAVED) {
1409     if ((ffmpegdec->pic_field_order & GST_VIDEO_BUFFER_FLAG_TFF))
1410       GST_VIDEO_INFO_FIELD_ORDER (out_info) =
1411           GST_VIDEO_FIELD_ORDER_TOP_FIELD_FIRST;
1412     else
1413       GST_VIDEO_INFO_FIELD_ORDER (out_info) =
1414           GST_VIDEO_FIELD_ORDER_BOTTOM_FIELD_FIRST;
1415   }
1416
1417   if (!gst_structure_has_field (in_s, "chroma-site")) {
1418     switch (context->chroma_sample_location) {
1419       case AVCHROMA_LOC_LEFT:
1420         out_info->chroma_site = GST_VIDEO_CHROMA_SITE_MPEG2;
1421         break;
1422       case AVCHROMA_LOC_CENTER:
1423         out_info->chroma_site = GST_VIDEO_CHROMA_SITE_JPEG;
1424         break;
1425       case AVCHROMA_LOC_TOPLEFT:
1426         out_info->chroma_site = GST_VIDEO_CHROMA_SITE_DV;
1427         break;
1428       case AVCHROMA_LOC_TOP:
1429         out_info->chroma_site = GST_VIDEO_CHROMA_SITE_V_COSITED;
1430         break;
1431       default:
1432         break;
1433     }
1434   }
1435
1436   if (!gst_structure_has_field (in_s, "colorimetry")
1437       || in_info->colorimetry.primaries == GST_VIDEO_COLOR_PRIMARIES_UNKNOWN) {
1438     out_info->colorimetry.primaries =
1439         gst_video_color_primaries_from_iso (context->color_primaries);
1440   }
1441
1442   if (!gst_structure_has_field (in_s, "colorimetry")
1443       || in_info->colorimetry.transfer == GST_VIDEO_TRANSFER_UNKNOWN) {
1444     out_info->colorimetry.transfer =
1445         gst_video_transfer_function_from_iso (context->color_trc);
1446   }
1447
1448   if (!gst_structure_has_field (in_s, "colorimetry")
1449       || in_info->colorimetry.matrix == GST_VIDEO_COLOR_MATRIX_UNKNOWN) {
1450     out_info->colorimetry.matrix =
1451         gst_video_color_matrix_from_iso (context->colorspace);
1452   }
1453
1454   if (!gst_structure_has_field (in_s, "colorimetry")
1455       || in_info->colorimetry.range == GST_VIDEO_COLOR_RANGE_UNKNOWN) {
1456     if (context->color_range == AVCOL_RANGE_JPEG) {
1457       out_info->colorimetry.range = GST_VIDEO_COLOR_RANGE_0_255;
1458     } else if (context->color_range == AVCOL_RANGE_MPEG) {
1459       out_info->colorimetry.range = GST_VIDEO_COLOR_RANGE_16_235;
1460     } else {
1461       out_info->colorimetry.range = GST_VIDEO_COLOR_RANGE_UNKNOWN;
1462     }
1463   }
1464
1465   /* try to find a good framerate */
1466   if ((in_info->fps_d && in_info->fps_n)) {
1467     /* take framerate from input when it was specified (#313970) */
1468     fps_n = in_info->fps_n;
1469     fps_d = in_info->fps_d;
1470   } else {
1471     fps_n = ffmpegdec->ctx_time_d;
1472     fps_d = ffmpegdec->ctx_time_n * ffmpegdec->ctx_ticks;
1473
1474     if (!fps_d) {
1475       GST_LOG_OBJECT (ffmpegdec, "invalid framerate: %d/0, -> %d/1", fps_n,
1476           fps_n);
1477       fps_d = 1;
1478     }
1479     if (gst_util_fraction_compare (fps_n, fps_d, 1000, 1) > 0) {
1480       GST_LOG_OBJECT (ffmpegdec, "excessive framerate: %d/%d, -> 0/1", fps_n,
1481           fps_d);
1482       fps_n = 0;
1483       fps_d = 1;
1484     }
1485   }
1486
1487   if (GST_VIDEO_INFO_FLAG_IS_SET (in_info, GST_VIDEO_FLAG_VARIABLE_FPS)) {
1488     GST_LOG_OBJECT (ffmpegdec, "setting framerate: %d/%d", in_info->fps_n,
1489         in_info->fps_d);
1490     out_info->fps_n = in_info->fps_n;
1491     out_info->fps_d = in_info->fps_d;
1492   } else {
1493     GST_LOG_OBJECT (ffmpegdec, "setting framerate: %d/%d", fps_n, fps_d);
1494     out_info->fps_n = fps_n;
1495     out_info->fps_d = fps_d;
1496   }
1497
1498   /* calculate and update par now */
1499   gst_ffmpegviddec_update_par (ffmpegdec, in_info, out_info);
1500
1501   GST_VIDEO_INFO_MULTIVIEW_MODE (out_info) = ffmpegdec->cur_multiview_mode;
1502   GST_VIDEO_INFO_MULTIVIEW_FLAGS (out_info) = ffmpegdec->cur_multiview_flags;
1503
1504   /* To passing HDR information to caps directly */
1505   if (output_state->caps == NULL) {
1506     output_state->caps = gst_video_info_to_caps (out_info);
1507   } else {
1508     output_state->caps = gst_caps_make_writable (output_state->caps);
1509   }
1510
1511   if (flags & GST_VIDEO_BUFFER_FLAG_ONEFIELD) {
1512     /* TODO: we don't get that information from ffmpeg, so copy it from
1513      * the parser */
1514     gst_caps_features_add (gst_caps_get_features (ffmpegdec->output_state->caps,
1515             0), GST_CAPS_FEATURE_FORMAT_INTERLACED);
1516   }
1517
1518   if (!gst_structure_has_field (in_s, "mastering-display-info")) {
1519     AVFrameSideData *sd = av_frame_get_side_data (picture,
1520         AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
1521     GstVideoMasteringDisplayInfo minfo;
1522
1523     if (sd
1524         && mastering_display_metadata_av_to_gst ((AVMasteringDisplayMetadata *)
1525             sd->data, &minfo)) {
1526       GST_LOG_OBJECT (ffmpegdec, "update mastering display info: "
1527           "Red(%u, %u) "
1528           "Green(%u, %u) "
1529           "Blue(%u, %u) "
1530           "White(%u, %u) "
1531           "max_luminance(%u) "
1532           "min_luminance(%u) ",
1533           minfo.display_primaries[0].x, minfo.display_primaries[0].y,
1534           minfo.display_primaries[1].x, minfo.display_primaries[1].y,
1535           minfo.display_primaries[2].x, minfo.display_primaries[2].y,
1536           minfo.white_point.x, minfo.white_point.y,
1537           minfo.max_display_mastering_luminance,
1538           minfo.min_display_mastering_luminance);
1539
1540       if (!gst_video_mastering_display_info_add_to_caps (&minfo,
1541               output_state->caps)) {
1542         GST_WARNING_OBJECT (ffmpegdec,
1543             "Couldn't set mastering display info to caps");
1544       }
1545     }
1546   }
1547
1548   if (!gst_structure_has_field (in_s, "content-light-level")) {
1549     AVFrameSideData *sd = av_frame_get_side_data (picture,
1550         AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);
1551     GstVideoContentLightLevel cll;
1552
1553     if (sd && content_light_metadata_av_to_gst ((AVContentLightMetadata *)
1554             sd->data, &cll)) {
1555       GST_LOG_OBJECT (ffmpegdec, "update content light level: "
1556           "maxCLL:(%u), maxFALL:(%u)", cll.max_content_light_level,
1557           cll.max_frame_average_light_level);
1558
1559       if (!gst_video_content_light_level_add_to_caps (&cll, output_state->caps)) {
1560         GST_WARNING_OBJECT (ffmpegdec,
1561             "Couldn't set content light level to caps");
1562       }
1563     }
1564   }
1565
1566   if (!gst_video_decoder_negotiate (GST_VIDEO_DECODER (ffmpegdec)))
1567     goto negotiate_failed;
1568
1569   /* The decoder is configured, we now know the true latency */
1570   if (fps_n) {
1571     latency =
1572         gst_util_uint64_scale_ceil (ffmpegdec->context->has_b_frames *
1573         GST_SECOND, fps_d, fps_n);
1574     if (ffmpegdec->context->thread_type & FF_THREAD_FRAME) {
1575       latency +=
1576           gst_util_uint64_scale_ceil (ffmpegdec->context->thread_count *
1577           GST_SECOND, fps_d, fps_n);
1578     }
1579     gst_video_decoder_set_latency (GST_VIDEO_DECODER (ffmpegdec), latency,
1580         latency);
1581   }
1582
1583   return TRUE;
1584
1585   /* ERRORS */
1586 unknown_format:
1587   {
1588     GST_ERROR_OBJECT (ffmpegdec,
1589         "decoder requires a video format unsupported by GStreamer");
1590     return FALSE;
1591   }
1592 negotiate_failed:
1593   {
1594     /* Reset so we try again next time even if force==FALSE */
1595     ffmpegdec->pic_pix_fmt = 0;
1596     ffmpegdec->pic_width = 0;
1597     ffmpegdec->pic_height = 0;
1598     ffmpegdec->pic_par_n = 0;
1599     ffmpegdec->pic_par_d = 0;
1600     ffmpegdec->pic_interlaced = 0;
1601     ffmpegdec->pic_field_order = 0;
1602     ffmpegdec->pic_field_order_changed = FALSE;
1603     ffmpegdec->ctx_ticks = 0;
1604     ffmpegdec->ctx_time_n = 0;
1605     ffmpegdec->ctx_time_d = 0;
1606
1607     GST_ERROR_OBJECT (ffmpegdec, "negotiation failed");
1608     return FALSE;
1609   }
1610 }
1611
1612 /* perform qos calculations before decoding the next frame.
1613  *
1614  * Sets the skip_frame flag and if things are really bad, skips to the next
1615  * keyframe.
1616  *
1617  */
1618 static void
1619 gst_ffmpegviddec_do_qos (GstFFMpegVidDec * ffmpegdec,
1620     GstVideoCodecFrame * frame, gboolean * mode_switch)
1621 {
1622   GstClockTimeDiff diff;
1623   GstSegmentFlags skip_flags =
1624       GST_VIDEO_DECODER_INPUT_SEGMENT (ffmpegdec).flags;
1625
1626   *mode_switch = FALSE;
1627
1628   if (frame == NULL)
1629     return;
1630
1631   if (skip_flags & GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS) {
1632     ffmpegdec->context->skip_frame = AVDISCARD_NONKEY;
1633     *mode_switch = TRUE;
1634   } else if (skip_flags & GST_SEGMENT_FLAG_TRICKMODE) {
1635     ffmpegdec->context->skip_frame = AVDISCARD_NONREF;
1636     *mode_switch = TRUE;
1637   }
1638
1639   if (*mode_switch == TRUE) {
1640     /* We've already switched mode, we can return straight away
1641      * without any further calculation */
1642     return;
1643   }
1644
1645   diff =
1646       gst_video_decoder_get_max_decode_time (GST_VIDEO_DECODER (ffmpegdec),
1647       frame);
1648
1649   /* if we don't have timing info, then we don't do QoS */
1650   if (G_UNLIKELY (diff == G_MAXINT64)) {
1651     /* Ensure the skipping strategy is the default one */
1652     ffmpegdec->context->skip_frame = ffmpegdec->skip_frame;
1653     return;
1654   }
1655
1656   GST_DEBUG_OBJECT (ffmpegdec, "decoding time %" G_GINT64_FORMAT, diff);
1657
1658   if (diff > 0 && ffmpegdec->context->skip_frame != AVDISCARD_DEFAULT) {
1659     ffmpegdec->context->skip_frame = AVDISCARD_DEFAULT;
1660     *mode_switch = TRUE;
1661     GST_DEBUG_OBJECT (ffmpegdec, "QOS: normal mode");
1662   }
1663
1664   else if (diff <= 0 && ffmpegdec->context->skip_frame != AVDISCARD_NONREF) {
1665     ffmpegdec->context->skip_frame = AVDISCARD_NONREF;
1666     *mode_switch = TRUE;
1667     GST_DEBUG_OBJECT (ffmpegdec,
1668         "QOS: hurry up, diff %" G_GINT64_FORMAT " >= 0", diff);
1669   }
1670 }
1671
1672 /* get an outbuf buffer with the current picture */
1673 static GstFlowReturn
1674 get_output_buffer (GstFFMpegVidDec * ffmpegdec, GstVideoCodecFrame * frame)
1675 {
1676   GstFlowReturn ret = GST_FLOW_OK;
1677   AVFrame pic, *outpic;
1678   GstVideoFrame vframe;
1679   GstVideoInfo *info;
1680   guint c;
1681
1682   GST_LOG_OBJECT (ffmpegdec, "get output buffer");
1683
1684   if (!ffmpegdec->output_state)
1685     goto not_negotiated;
1686
1687   ret =
1688       gst_video_decoder_allocate_output_frame (GST_VIDEO_DECODER (ffmpegdec),
1689       frame);
1690   if (G_UNLIKELY (ret != GST_FLOW_OK))
1691     goto alloc_failed;
1692
1693   /* original ffmpeg code does not handle odd sizes correctly.
1694    * This patched up version does */
1695   /* Fill avpicture */
1696   info = &ffmpegdec->output_state->info;
1697   if (!gst_video_frame_map (&vframe, info, frame->output_buffer,
1698           GST_MAP_READ | GST_MAP_WRITE))
1699     goto map_failed;
1700
1701   memset (&pic, 0, sizeof (pic));
1702   pic.format = ffmpegdec->pic_pix_fmt;
1703   pic.width = GST_VIDEO_FRAME_WIDTH (&vframe);
1704   pic.height = GST_VIDEO_FRAME_HEIGHT (&vframe);
1705   for (c = 0; c < AV_NUM_DATA_POINTERS; c++) {
1706     if (c < GST_VIDEO_INFO_N_PLANES (info)) {
1707       pic.data[c] = GST_VIDEO_FRAME_PLANE_DATA (&vframe, c);
1708       pic.linesize[c] = GST_VIDEO_FRAME_PLANE_STRIDE (&vframe, c);
1709       GST_LOG_OBJECT (ffmpegdec, "[%i] linesize %d, data %p", c,
1710           pic.linesize[c], pic.data[c]);
1711     } else {
1712       pic.data[c] = NULL;
1713       pic.linesize[c] = 0;
1714     }
1715   }
1716
1717   outpic = ffmpegdec->picture;
1718
1719   if (av_frame_copy (&pic, outpic) != 0) {
1720     GST_ERROR_OBJECT (ffmpegdec, "Failed to copy output frame");
1721     ret = GST_FLOW_ERROR;
1722   }
1723
1724   gst_video_frame_unmap (&vframe);
1725
1726   ffmpegdec->picture->reordered_opaque = -1;
1727
1728   return ret;
1729
1730   /* special cases */
1731 alloc_failed:
1732   {
1733     GST_ELEMENT_ERROR (ffmpegdec, RESOURCE, FAILED,
1734         ("Unable to allocate memory"),
1735         ("The downstream pool failed to allocated buffer."));
1736     return ret;
1737   }
1738 map_failed:
1739   {
1740     GST_ELEMENT_ERROR (ffmpegdec, RESOURCE, OPEN_READ_WRITE,
1741         ("Cannot access memory for read and write operation."),
1742         ("The video memory allocated from downstream pool could not mapped for"
1743             "read and write."));
1744     return ret;
1745   }
1746 not_negotiated:
1747   {
1748     GST_DEBUG_OBJECT (ffmpegdec, "not negotiated");
1749     return GST_FLOW_NOT_NEGOTIATED;
1750   }
1751 }
1752
1753 static void
1754 gst_avpacket_init (AVPacket * packet, guint8 * data, guint size)
1755 {
1756   memset (packet, 0, sizeof (AVPacket));
1757   packet->data = data;
1758   packet->size = size;
1759 }
1760
1761 /*
1762  * Returns: whether a frame was decoded
1763  */
1764 static gboolean
1765 gst_ffmpegviddec_video_frame (GstFFMpegVidDec * ffmpegdec,
1766     GstVideoCodecFrame * frame, GstFlowReturn * ret)
1767 {
1768   gint res;
1769   gboolean got_frame = FALSE;
1770   gboolean mode_switch;
1771   GstVideoCodecFrame *out_frame;
1772   GstFFMpegVidDecVideoFrame *out_dframe;
1773   GstBufferPool *pool;
1774
1775   *ret = GST_FLOW_OK;
1776
1777   /* in case we skip frames */
1778   ffmpegdec->picture->pict_type = -1;
1779
1780   /* run QoS code, we don't stop decoding the frame when we are late because
1781    * else we might skip a reference frame */
1782   gst_ffmpegviddec_do_qos (ffmpegdec, frame, &mode_switch);
1783
1784   /* FFmpeg might request new buffer from other threads.
1785    * Release lock here */
1786   GST_VIDEO_DECODER_STREAM_UNLOCK (ffmpegdec);
1787   res = avcodec_receive_frame (ffmpegdec->context, ffmpegdec->picture);
1788   GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
1789
1790   /* No frames available at this time */
1791   if (res == AVERROR (EAGAIN)) {
1792     GST_DEBUG_OBJECT (ffmpegdec, "Need more data");
1793     goto beach;
1794   } else if (res == AVERROR_EOF) {
1795     *ret = GST_FLOW_EOS;
1796     GST_DEBUG_OBJECT (ffmpegdec, "Context was entirely flushed");
1797     goto beach;
1798   } else if (res < 0) {
1799     GST_VIDEO_DECODER_ERROR (ffmpegdec, 1, STREAM, DECODE, (NULL),
1800         ("Video decoding error"), *ret);
1801     goto beach;
1802   }
1803
1804   got_frame = TRUE;
1805
1806   /* get the output picture timing info again */
1807   out_dframe = ffmpegdec->picture->opaque;
1808   out_frame = gst_video_codec_frame_ref (out_dframe->frame);
1809
1810   /* also give back a buffer allocated by the frame, if any */
1811   gst_buffer_replace (&out_frame->output_buffer, out_dframe->buffer);
1812   gst_buffer_replace (&out_dframe->buffer, NULL);
1813
1814   /* Extract auxilliary info not stored in the main AVframe */
1815   {
1816     GstVideoInfo *in_info = &ffmpegdec->input_state->info;
1817     /* Take multiview mode from upstream if present */
1818     ffmpegdec->picture_multiview_mode = GST_VIDEO_INFO_MULTIVIEW_MODE (in_info);
1819     ffmpegdec->picture_multiview_flags =
1820         GST_VIDEO_INFO_MULTIVIEW_FLAGS (in_info);
1821
1822     /* Otherwise, see if there's info in the frame */
1823     if (ffmpegdec->picture_multiview_mode == GST_VIDEO_MULTIVIEW_MODE_NONE) {
1824       AVFrameSideData *side_data =
1825           av_frame_get_side_data (ffmpegdec->picture, AV_FRAME_DATA_STEREO3D);
1826       if (side_data) {
1827         AVStereo3D *stereo = (AVStereo3D *) side_data->data;
1828         ffmpegdec->picture_multiview_mode = stereo_av_to_gst (stereo->type);
1829         if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
1830           ffmpegdec->picture_multiview_flags =
1831               GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
1832         } else {
1833           ffmpegdec->picture_multiview_flags = GST_VIDEO_MULTIVIEW_FLAGS_NONE;
1834         }
1835       }
1836     }
1837   }
1838
1839   GST_DEBUG_OBJECT (ffmpegdec,
1840       "pts %" G_GUINT64_FORMAT " duration %" G_GUINT64_FORMAT,
1841       out_frame->pts, out_frame->duration);
1842   GST_DEBUG_OBJECT (ffmpegdec, "picture: pts %" G_GUINT64_FORMAT,
1843       (guint64) ffmpegdec->picture->pts);
1844   GST_DEBUG_OBJECT (ffmpegdec, "picture: num %d",
1845       ffmpegdec->picture->coded_picture_number);
1846   GST_DEBUG_OBJECT (ffmpegdec, "picture: display %d",
1847       ffmpegdec->picture->display_picture_number);
1848   GST_DEBUG_OBJECT (ffmpegdec, "picture: opaque %p",
1849       ffmpegdec->picture->opaque);
1850   GST_DEBUG_OBJECT (ffmpegdec, "picture: reordered opaque %" G_GUINT64_FORMAT,
1851       (guint64) ffmpegdec->picture->reordered_opaque);
1852   GST_DEBUG_OBJECT (ffmpegdec, "repeat_pict:%d",
1853       ffmpegdec->picture->repeat_pict);
1854   GST_DEBUG_OBJECT (ffmpegdec, "corrupted frame: %d",
1855       ! !(ffmpegdec->picture->flags & AV_FRAME_FLAG_CORRUPT));
1856
1857   if (!gst_ffmpegviddec_negotiate (ffmpegdec, ffmpegdec->context,
1858           ffmpegdec->picture, GST_BUFFER_FLAGS (out_frame->input_buffer)))
1859     goto negotiation_error;
1860
1861   pool = gst_video_decoder_get_buffer_pool (GST_VIDEO_DECODER (ffmpegdec));
1862   if (G_UNLIKELY (out_frame->output_buffer == NULL)) {
1863     *ret = get_output_buffer (ffmpegdec, out_frame);
1864   } else if (G_UNLIKELY (out_frame->output_buffer->pool != pool)) {
1865     GstBuffer *tmp = out_frame->output_buffer;
1866     out_frame->output_buffer = NULL;
1867     *ret = get_output_buffer (ffmpegdec, out_frame);
1868     gst_buffer_unref (tmp);
1869   }
1870 #ifndef G_DISABLE_ASSERT
1871   else {
1872     GstVideoMeta *vmeta = gst_buffer_get_video_meta (out_frame->output_buffer);
1873     if (vmeta) {
1874       GstVideoInfo *info = &ffmpegdec->output_state->info;
1875       g_assert ((gint) vmeta->width == GST_VIDEO_INFO_WIDTH (info));
1876       g_assert ((gint) vmeta->height == GST_VIDEO_INFO_HEIGHT (info));
1877     }
1878   }
1879 #endif
1880   gst_object_unref (pool);
1881
1882   if (G_UNLIKELY (*ret != GST_FLOW_OK))
1883     goto no_output;
1884
1885   /* Mark corrupted frames as corrupted */
1886   if (ffmpegdec->picture->flags & AV_FRAME_FLAG_CORRUPT)
1887     GST_BUFFER_FLAG_SET (out_frame->output_buffer, GST_BUFFER_FLAG_CORRUPTED);
1888
1889   if (ffmpegdec->pic_interlaced) {
1890     /* set interlaced flags */
1891     if (ffmpegdec->picture->repeat_pict)
1892       GST_BUFFER_FLAG_SET (out_frame->output_buffer, GST_VIDEO_BUFFER_FLAG_RFF);
1893     if (ffmpegdec->picture->top_field_first)
1894       GST_BUFFER_FLAG_SET (out_frame->output_buffer, GST_VIDEO_BUFFER_FLAG_TFF);
1895     if (ffmpegdec->picture->interlaced_frame)
1896       GST_BUFFER_FLAG_SET (out_frame->output_buffer,
1897           GST_VIDEO_BUFFER_FLAG_INTERLACED);
1898   }
1899
1900   {
1901     AVFrameSideData *side_data =
1902         av_frame_get_side_data (ffmpegdec->picture, AV_FRAME_DATA_A53_CC);
1903     if (side_data) {
1904       GST_LOG_OBJECT (ffmpegdec,
1905           "Found CC side data of type AV_FRAME_DATA_A53_CC, size %d",
1906           (int) side_data->size);
1907       GST_MEMDUMP ("A53 CC", side_data->data, side_data->size);
1908
1909       /* do not add closed caption meta if it already exists */
1910       if (!gst_buffer_get_meta (out_frame->input_buffer,
1911               GST_VIDEO_CAPTION_META_API_TYPE)) {
1912         out_frame->output_buffer =
1913             gst_buffer_make_writable (out_frame->output_buffer);
1914         gst_buffer_add_video_caption_meta (out_frame->output_buffer,
1915             GST_VIDEO_CAPTION_TYPE_CEA708_RAW, side_data->data,
1916             side_data->size);
1917       } else {
1918         GST_LOG_OBJECT (ffmpegdec,
1919             "Closed caption meta already exists: will not add new caption meta");
1920       }
1921     }
1922   }
1923
1924   /* cleaning time */
1925   /* so we decoded this frame, frames preceding it in decoding order
1926    * that still do not have a buffer allocated seem rather useless,
1927    * and can be discarded, due to e.g. misparsed bogus frame
1928    * or non-keyframe in skipped decoding, ...
1929    * In any case, not likely to be seen again, so discard those,
1930    * before they pile up and/or mess with timestamping */
1931   {
1932     GList *l, *ol;
1933     GstVideoDecoder *dec = GST_VIDEO_DECODER (ffmpegdec);
1934     gboolean old = TRUE;
1935
1936     ol = l = gst_video_decoder_get_frames (dec);
1937     while (l) {
1938       GstVideoCodecFrame *tmp = l->data;
1939
1940       if (tmp == frame)
1941         old = FALSE;
1942
1943       if (old && GST_VIDEO_CODEC_FRAME_IS_DECODE_ONLY (tmp)) {
1944         GST_LOG_OBJECT (dec,
1945             "discarding ghost frame %p (#%d) PTS:%" GST_TIME_FORMAT " DTS:%"
1946             GST_TIME_FORMAT, tmp, tmp->system_frame_number,
1947             GST_TIME_ARGS (tmp->pts), GST_TIME_ARGS (tmp->dts));
1948         /* drop extra ref and remove from frame list */
1949         GST_VIDEO_CODEC_FRAME_FLAG_UNSET (tmp,
1950             GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
1951         gst_video_decoder_release_frame (dec, tmp);
1952       } else {
1953         /* drop extra ref we got */
1954         gst_video_codec_frame_unref (tmp);
1955       }
1956       l = l->next;
1957     }
1958     g_list_free (ol);
1959   }
1960
1961   av_frame_unref (ffmpegdec->picture);
1962
1963   if (frame)
1964     GST_VIDEO_CODEC_FRAME_FLAG_UNSET (frame,
1965         GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
1966
1967   if (gst_video_decoder_get_subframe_mode (GST_VIDEO_DECODER (ffmpegdec)))
1968     gst_video_decoder_have_last_subframe (GST_VIDEO_DECODER (ffmpegdec),
1969         out_frame);
1970
1971   /* FIXME: Ideally we would remap the buffer read-only now before pushing but
1972    * libav might still have a reference to it!
1973    */
1974   if (GST_BUFFER_FLAG_IS_SET (out_frame->input_buffer,
1975           GST_VIDEO_BUFFER_FLAG_ONEFIELD)) {
1976     GST_BUFFER_FLAG_SET (out_frame->output_buffer,
1977         GST_VIDEO_BUFFER_FLAG_ONEFIELD);
1978     if (GST_BUFFER_FLAG_IS_SET (out_frame->input_buffer,
1979             GST_VIDEO_BUFFER_FLAG_TFF)) {
1980       GST_BUFFER_FLAG_SET (out_frame->output_buffer, GST_VIDEO_BUFFER_FLAG_TFF);
1981     }
1982   }
1983   *ret =
1984       gst_video_decoder_finish_frame (GST_VIDEO_DECODER (ffmpegdec), out_frame);
1985
1986 beach:
1987   GST_DEBUG_OBJECT (ffmpegdec, "return flow %s, got frame: %d",
1988       gst_flow_get_name (*ret), got_frame);
1989   return got_frame;
1990
1991   /* special cases */
1992 no_output:
1993   {
1994     GST_DEBUG_OBJECT (ffmpegdec, "no output buffer");
1995     GST_VIDEO_CODEC_FRAME_FLAG_UNSET (frame,
1996         GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED);
1997     gst_video_decoder_drop_frame (GST_VIDEO_DECODER (ffmpegdec), out_frame);
1998     goto beach;
1999   }
2000
2001 negotiation_error:
2002   {
2003     gst_video_decoder_drop_frame (GST_VIDEO_DECODER (ffmpegdec), out_frame);
2004     if (GST_PAD_IS_FLUSHING (GST_VIDEO_DECODER_SRC_PAD (ffmpegdec))) {
2005       *ret = GST_FLOW_FLUSHING;
2006       goto beach;
2007     }
2008     GST_WARNING_OBJECT (ffmpegdec, "Error negotiating format");
2009     *ret = GST_FLOW_NOT_NEGOTIATED;
2010     goto beach;
2011   }
2012 }
2013
2014
2015  /* Returns: Whether a frame was decoded */
2016 static gboolean
2017 gst_ffmpegviddec_frame (GstFFMpegVidDec * ffmpegdec, GstVideoCodecFrame * frame,
2018     GstFlowReturn * ret)
2019 {
2020   gboolean got_frame = FALSE;
2021
2022   if (G_UNLIKELY (ffmpegdec->context->codec == NULL))
2023     goto no_codec;
2024
2025   *ret = GST_FLOW_OK;
2026   ffmpegdec->context->frame_number++;
2027
2028   got_frame = gst_ffmpegviddec_video_frame (ffmpegdec, frame, ret);
2029
2030   return got_frame;
2031
2032   /* ERRORS */
2033 no_codec:
2034   {
2035     GST_ERROR_OBJECT (ffmpegdec, "no codec context");
2036     *ret = GST_FLOW_NOT_NEGOTIATED;
2037     return -1;
2038   }
2039 }
2040
2041 static GstFlowReturn
2042 gst_ffmpegviddec_drain (GstVideoDecoder * decoder)
2043 {
2044   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2045   GstFlowReturn ret = GST_FLOW_OK;
2046   gboolean got_frame = FALSE;
2047
2048   if (!ffmpegdec->opened)
2049     return GST_FLOW_OK;
2050
2051   GST_VIDEO_DECODER_STREAM_UNLOCK (ffmpegdec);
2052   if (avcodec_send_packet (ffmpegdec->context, NULL)) {
2053     GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2054     goto send_packet_failed;
2055   }
2056   GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2057
2058   do {
2059     got_frame = gst_ffmpegviddec_frame (ffmpegdec, NULL, &ret);
2060   } while (got_frame && ret == GST_FLOW_OK);
2061
2062   GST_VIDEO_DECODER_STREAM_UNLOCK (ffmpegdec);
2063   avcodec_flush_buffers (ffmpegdec->context);
2064   GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2065
2066   /* FFMpeg will return AVERROR_EOF if it's internal was fully drained
2067    * then we are translating it to GST_FLOW_EOS. However, because this behavior
2068    * is fully internal stuff of this implementation and gstvideodecoder
2069    * baseclass doesn't convert this GST_FLOW_EOS to GST_FLOW_OK,
2070    * convert this flow returned here */
2071   if (ret == GST_FLOW_EOS)
2072     ret = GST_FLOW_OK;
2073
2074 done:
2075   return ret;
2076
2077 send_packet_failed:
2078   GST_WARNING_OBJECT (ffmpegdec, "send packet failed, could not drain decoder");
2079   goto done;
2080 }
2081
2082 static GstFlowReturn
2083 gst_ffmpegviddec_handle_frame (GstVideoDecoder * decoder,
2084     GstVideoCodecFrame * frame)
2085 {
2086   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2087   guint8 *data;
2088   gint size;
2089   gboolean got_frame;
2090   GstMapInfo minfo;
2091   GstFlowReturn ret = GST_FLOW_OK;
2092   AVPacket packet;
2093
2094   GST_LOG_OBJECT (ffmpegdec,
2095       "Received new data of size %" G_GSIZE_FORMAT ", dts %" GST_TIME_FORMAT
2096       ", pts:%" GST_TIME_FORMAT ", dur:%" GST_TIME_FORMAT,
2097       gst_buffer_get_size (frame->input_buffer), GST_TIME_ARGS (frame->dts),
2098       GST_TIME_ARGS (frame->pts), GST_TIME_ARGS (frame->duration));
2099
2100   if (!gst_buffer_map (frame->input_buffer, &minfo, GST_MAP_READ)) {
2101     GST_ELEMENT_ERROR (ffmpegdec, STREAM, DECODE, ("Decoding problem"),
2102         ("Failed to map buffer for reading"));
2103     return GST_FLOW_ERROR;
2104   }
2105
2106   /* treat frame as void until a buffer is requested for it */
2107   if (!GST_VIDEO_CODEC_FRAME_FLAG_IS_SET (frame,
2108           GST_FFMPEG_VIDEO_CODEC_FRAME_FLAG_ALLOCATED))
2109     GST_VIDEO_CODEC_FRAME_FLAG_SET (frame,
2110         GST_VIDEO_CODEC_FRAME_FLAG_DECODE_ONLY);
2111
2112   data = minfo.data;
2113   size = minfo.size;
2114
2115   if (size > 0 && (!GST_MEMORY_IS_ZERO_PADDED (minfo.memory)
2116           || (minfo.maxsize - minfo.size) < AV_INPUT_BUFFER_PADDING_SIZE)) {
2117     /* add padding */
2118     if (ffmpegdec->padded_size < size + AV_INPUT_BUFFER_PADDING_SIZE) {
2119       ffmpegdec->padded_size = size + AV_INPUT_BUFFER_PADDING_SIZE;
2120       ffmpegdec->padded = g_realloc (ffmpegdec->padded, ffmpegdec->padded_size);
2121       GST_LOG_OBJECT (ffmpegdec, "resized padding buffer to %d",
2122           ffmpegdec->padded_size);
2123     }
2124     GST_CAT_TRACE_OBJECT (GST_CAT_PERFORMANCE, ffmpegdec,
2125         "Copy input to add padding");
2126     memcpy (ffmpegdec->padded, data, size);
2127     memset (ffmpegdec->padded + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2128
2129     data = ffmpegdec->padded;
2130   }
2131
2132   /* now decode the frame */
2133   gst_avpacket_init (&packet, data, size);
2134
2135   if (!packet.size)
2136     goto done;
2137
2138   if (ffmpegdec->palette) {
2139     guint8 *pal;
2140
2141     pal = av_packet_new_side_data (&packet, AV_PKT_DATA_PALETTE,
2142         AVPALETTE_SIZE);
2143     gst_buffer_extract (ffmpegdec->palette, 0, pal, AVPALETTE_SIZE);
2144     GST_DEBUG_OBJECT (ffmpegdec, "copy pal %p %p", &packet, pal);
2145   }
2146
2147   /* save reference to the timing info */
2148   ffmpegdec->context->reordered_opaque = (gint64) frame->system_frame_number;
2149   ffmpegdec->picture->reordered_opaque = (gint64) frame->system_frame_number;
2150
2151   GST_DEBUG_OBJECT (ffmpegdec, "stored opaque values idx %d",
2152       frame->system_frame_number);
2153
2154   /* This might call into get_buffer() from another thread,
2155    * which would cause a deadlock. Release the lock here
2156    * and taking it again later seems safe
2157    * See https://bugzilla.gnome.org/show_bug.cgi?id=726020
2158    */
2159   GST_VIDEO_DECODER_STREAM_UNLOCK (ffmpegdec);
2160   if (avcodec_send_packet (ffmpegdec->context, &packet) < 0) {
2161     GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2162     av_packet_free_side_data (&packet);
2163     goto send_packet_failed;
2164   }
2165   av_packet_free_side_data (&packet);
2166   GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2167
2168   do {
2169     /* decode a frame of audio/video now */
2170     got_frame = gst_ffmpegviddec_frame (ffmpegdec, frame, &ret);
2171
2172     if (ret != GST_FLOW_OK) {
2173       GST_LOG_OBJECT (ffmpegdec, "breaking because of flow ret %s",
2174           gst_flow_get_name (ret));
2175       break;
2176     }
2177   } while (got_frame);
2178
2179 done:
2180   gst_buffer_unmap (frame->input_buffer, &minfo);
2181   gst_video_codec_frame_unref (frame);
2182
2183   return ret;
2184
2185 send_packet_failed:
2186   {
2187     GST_VIDEO_DECODER_ERROR (decoder, 1, STREAM, DECODE,
2188         ("Failed to send data for decoding"), ("Invalid input packet"), ret);
2189     goto done;
2190   }
2191 }
2192
2193 static gboolean
2194 gst_ffmpegviddec_start (GstVideoDecoder * decoder)
2195 {
2196   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2197   GstFFMpegVidDecClass *oclass;
2198
2199   oclass = GST_FFMPEGVIDDEC_GET_CLASS (ffmpegdec);
2200
2201   GST_OBJECT_LOCK (ffmpegdec);
2202   avcodec_free_context (&ffmpegdec->context);
2203   ffmpegdec->context = avcodec_alloc_context3 (oclass->in_plugin);
2204   if (ffmpegdec->context == NULL) {
2205     GST_DEBUG_OBJECT (ffmpegdec, "Failed to set context defaults");
2206     GST_OBJECT_UNLOCK (ffmpegdec);
2207     return FALSE;
2208   }
2209   ffmpegdec->context->opaque = ffmpegdec;
2210   GST_OBJECT_UNLOCK (ffmpegdec);
2211
2212   return TRUE;
2213 }
2214
2215 static gboolean
2216 gst_ffmpegviddec_stop (GstVideoDecoder * decoder)
2217 {
2218   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2219
2220   GST_OBJECT_LOCK (ffmpegdec);
2221   gst_ffmpegviddec_close (ffmpegdec, FALSE);
2222   GST_OBJECT_UNLOCK (ffmpegdec);
2223   g_free (ffmpegdec->padded);
2224   ffmpegdec->padded = NULL;
2225   ffmpegdec->padded_size = 0;
2226   if (ffmpegdec->input_state)
2227     gst_video_codec_state_unref (ffmpegdec->input_state);
2228   ffmpegdec->input_state = NULL;
2229   if (ffmpegdec->output_state)
2230     gst_video_codec_state_unref (ffmpegdec->output_state);
2231   ffmpegdec->output_state = NULL;
2232
2233   if (ffmpegdec->internal_pool)
2234     gst_object_unref (ffmpegdec->internal_pool);
2235   ffmpegdec->internal_pool = NULL;
2236
2237   ffmpegdec->pic_pix_fmt = 0;
2238   ffmpegdec->pic_width = 0;
2239   ffmpegdec->pic_height = 0;
2240   ffmpegdec->pic_par_n = 0;
2241   ffmpegdec->pic_par_d = 0;
2242   ffmpegdec->pic_interlaced = 0;
2243   ffmpegdec->pic_field_order = 0;
2244   ffmpegdec->pic_field_order_changed = FALSE;
2245   ffmpegdec->ctx_ticks = 0;
2246   ffmpegdec->ctx_time_n = 0;
2247   ffmpegdec->ctx_time_d = 0;
2248
2249   ffmpegdec->pool_width = 0;
2250   ffmpegdec->pool_height = 0;
2251   ffmpegdec->pool_format = 0;
2252
2253   return TRUE;
2254 }
2255
2256 static GstFlowReturn
2257 gst_ffmpegviddec_finish (GstVideoDecoder * decoder)
2258 {
2259   GstFlowReturn flow_ret;
2260
2261   flow_ret = gst_ffmpegviddec_drain (decoder);
2262
2263   /* note that finish can and should clean up more drastically,
2264    * but drain is also invoked on e.g. packet loss in GAP handling */
2265   gst_ffmpegviddec_flush (decoder);
2266
2267   return flow_ret;
2268 }
2269
2270 static gboolean
2271 gst_ffmpegviddec_flush (GstVideoDecoder * decoder)
2272 {
2273   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2274
2275   if (ffmpegdec->opened) {
2276     GST_LOG_OBJECT (decoder, "flushing buffers");
2277     GST_VIDEO_DECODER_STREAM_UNLOCK (ffmpegdec);
2278     avcodec_flush_buffers (ffmpegdec->context);
2279     GST_VIDEO_DECODER_STREAM_LOCK (ffmpegdec);
2280   }
2281
2282   return TRUE;
2283 }
2284
2285 static gboolean
2286 gst_ffmpegviddec_decide_allocation (GstVideoDecoder * decoder, GstQuery * query)
2287 {
2288   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (decoder);
2289   GstVideoCodecState *state;
2290   GstBufferPool *pool;
2291   guint size, min, max;
2292   GstStructure *config;
2293   gboolean have_pool, have_videometa, have_alignment, update_pool = FALSE;
2294   GstAllocator *allocator = NULL;
2295   GstAllocationParams params = DEFAULT_ALLOC_PARAM;
2296
2297   have_pool = (gst_query_get_n_allocation_pools (query) != 0);
2298
2299   if (!GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation (decoder,
2300           query))
2301     return FALSE;
2302
2303   state = gst_video_decoder_get_output_state (decoder);
2304
2305   if (gst_query_get_n_allocation_params (query) > 0) {
2306     gst_query_parse_nth_allocation_param (query, 0, &allocator, &params);
2307     params.align = MAX (params.align, DEFAULT_STRIDE_ALIGN);
2308   } else {
2309     gst_query_add_allocation_param (query, allocator, &params);
2310   }
2311
2312   gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
2313
2314   /* Don't use pool that can't grow, as we don't know how many buffer we'll
2315    * need, otherwise we may stall */
2316   if (max != 0 && max < REQUIRED_POOL_MAX_BUFFERS) {
2317     gst_object_unref (pool);
2318     pool = gst_video_buffer_pool_new ();
2319     max = 0;
2320     update_pool = TRUE;
2321     have_pool = FALSE;
2322
2323     /* if there is an allocator, also drop it, as it might be the reason we
2324      * have this limit. Default will be used */
2325     if (allocator) {
2326       gst_object_unref (allocator);
2327       allocator = NULL;
2328     }
2329   }
2330
2331   config = gst_buffer_pool_get_config (pool);
2332   gst_buffer_pool_config_set_params (config, state->caps, size, min, max);
2333   gst_buffer_pool_config_set_allocator (config, allocator, &params);
2334
2335   have_videometa =
2336       gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
2337
2338   if (have_videometa)
2339     gst_buffer_pool_config_add_option (config,
2340         GST_BUFFER_POOL_OPTION_VIDEO_META);
2341
2342   have_alignment =
2343       gst_buffer_pool_has_option (pool, GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
2344
2345   /* If we have videometa, we never have to copy */
2346   if (have_videometa && have_pool && have_alignment &&
2347       gst_ffmpegviddec_can_direct_render (ffmpegdec)) {
2348     GstStructure *config_copy = gst_structure_copy (config);
2349
2350     gst_ffmpegvideodec_prepare_dr_pool (ffmpegdec, pool, &state->info,
2351         config_copy);
2352
2353     /* FIXME validate and retry */
2354     if (gst_buffer_pool_set_config (pool, config_copy)) {
2355       GstFlowReturn ret;
2356       GstBuffer *tmp;
2357
2358       gst_buffer_pool_set_active (pool, TRUE);
2359       ret = gst_buffer_pool_acquire_buffer (pool, &tmp, NULL);
2360       if (ret == GST_FLOW_OK) {
2361         GstVideoMeta *vmeta = gst_buffer_get_video_meta (tmp);
2362         gboolean same_stride = TRUE;
2363         guint i;
2364
2365         for (i = 0; i < vmeta->n_planes; i++) {
2366           if (vmeta->stride[i] != ffmpegdec->stride[i]) {
2367             same_stride = FALSE;
2368             break;
2369           }
2370         }
2371
2372         gst_buffer_unref (tmp);
2373
2374         if (same_stride) {
2375           if (ffmpegdec->internal_pool)
2376             gst_object_unref (ffmpegdec->internal_pool);
2377           ffmpegdec->internal_pool = gst_object_ref (pool);
2378           ffmpegdec->pool_width = GST_VIDEO_INFO_WIDTH (&state->info);
2379           ffmpegdec->pool_height =
2380               MAX (GST_VIDEO_INFO_HEIGHT (&state->info),
2381               ffmpegdec->context->coded_height);
2382           ffmpegdec->pool_info = state->info;
2383           gst_structure_free (config);
2384           goto done;
2385         }
2386       }
2387     }
2388   }
2389
2390   if (have_videometa && ffmpegdec->internal_pool
2391       && gst_ffmpeg_pixfmt_to_videoformat (ffmpegdec->pool_format) ==
2392       GST_VIDEO_INFO_FORMAT (&state->info)
2393       && ffmpegdec->pool_width == state->info.width
2394       && ffmpegdec->pool_height == state->info.height) {
2395     update_pool = TRUE;
2396     gst_object_unref (pool);
2397     pool = gst_object_ref (ffmpegdec->internal_pool);
2398     gst_structure_free (config);
2399     goto done;
2400   }
2401
2402   /* configure */
2403   if (!gst_buffer_pool_set_config (pool, config)) {
2404     gboolean working_pool = FALSE;
2405     config = gst_buffer_pool_get_config (pool);
2406
2407     if (gst_buffer_pool_config_validate_params (config, state->caps, size, min,
2408             max)) {
2409       working_pool = gst_buffer_pool_set_config (pool, config);
2410     } else {
2411       gst_structure_free (config);
2412     }
2413
2414     if (!working_pool) {
2415       gst_object_unref (pool);
2416       pool = gst_video_buffer_pool_new ();
2417       config = gst_buffer_pool_get_config (pool);
2418       gst_buffer_pool_config_set_params (config, state->caps, size, min, max);
2419       gst_buffer_pool_config_set_allocator (config, NULL, &params);
2420       gst_buffer_pool_set_config (pool, config);
2421       update_pool = TRUE;
2422     }
2423   }
2424
2425 done:
2426   /* and store */
2427   if (update_pool)
2428     gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
2429
2430   gst_object_unref (pool);
2431   if (allocator)
2432     gst_object_unref (allocator);
2433   gst_video_codec_state_unref (state);
2434
2435   return TRUE;
2436 }
2437
2438 static gboolean
2439 gst_ffmpegviddec_propose_allocation (GstVideoDecoder * decoder,
2440     GstQuery * query)
2441 {
2442   GstAllocationParams params;
2443
2444   gst_allocation_params_init (&params);
2445   params.flags = GST_MEMORY_FLAG_ZERO_PADDED;
2446   params.align = DEFAULT_STRIDE_ALIGN;
2447   params.padding = AV_INPUT_BUFFER_PADDING_SIZE;
2448   /* we would like to have some padding so that we don't have to
2449    * memcpy. We don't suggest an allocator. */
2450   gst_query_add_allocation_param (query, NULL, &params);
2451
2452   return GST_VIDEO_DECODER_CLASS (parent_class)->propose_allocation (decoder,
2453       query);
2454 }
2455
2456 static void
2457 gst_ffmpegviddec_set_property (GObject * object,
2458     guint prop_id, const GValue * value, GParamSpec * pspec)
2459 {
2460   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (object);
2461
2462   switch (prop_id) {
2463     case PROP_LOWRES:
2464       ffmpegdec->lowres = ffmpegdec->context->lowres = g_value_get_enum (value);
2465       break;
2466     case PROP_SKIPFRAME:
2467       ffmpegdec->skip_frame = ffmpegdec->context->skip_frame =
2468           g_value_get_enum (value);
2469       break;
2470     case PROP_DIRECT_RENDERING:
2471       ffmpegdec->direct_rendering = g_value_get_boolean (value);
2472       break;
2473 #ifndef GST_REMOVE_DEPRECATED
2474     case PROP_DEBUG_MV:
2475       /* non-functional */
2476       break;
2477 #endif
2478     case PROP_MAX_THREADS:
2479       ffmpegdec->max_threads = g_value_get_int (value);
2480       break;
2481     case PROP_OUTPUT_CORRUPT:
2482       ffmpegdec->output_corrupt = g_value_get_boolean (value);
2483       break;
2484     case PROP_THREAD_TYPE:
2485       ffmpegdec->thread_type = g_value_get_flags (value);
2486       break;
2487     case PROP_STD_COMPLIANCE:
2488       ffmpegdec->std_compliance = g_value_get_enum (value);
2489       break;
2490     default:
2491       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2492       break;
2493   }
2494 }
2495
2496 static void
2497 gst_ffmpegviddec_get_property (GObject * object,
2498     guint prop_id, GValue * value, GParamSpec * pspec)
2499 {
2500   GstFFMpegVidDec *ffmpegdec = GST_FFMPEGVIDDEC (object);
2501
2502   switch (prop_id) {
2503     case PROP_LOWRES:
2504       g_value_set_enum (value, ffmpegdec->lowres);
2505       break;
2506     case PROP_SKIPFRAME:
2507       g_value_set_enum (value, ffmpegdec->skip_frame);
2508       break;
2509     case PROP_DIRECT_RENDERING:
2510       g_value_set_boolean (value, ffmpegdec->direct_rendering);
2511       break;
2512 #ifndef GST_REMOVE_DEPRECATED
2513     case PROP_DEBUG_MV:
2514       g_value_set_boolean (value, FALSE);
2515       break;
2516 #endif
2517     case PROP_MAX_THREADS:
2518       g_value_set_int (value, ffmpegdec->max_threads);
2519       break;
2520     case PROP_OUTPUT_CORRUPT:
2521       g_value_set_boolean (value, ffmpegdec->output_corrupt);
2522       break;
2523     case PROP_THREAD_TYPE:
2524       g_value_set_flags (value, ffmpegdec->thread_type);
2525       break;
2526     case PROP_STD_COMPLIANCE:
2527       g_value_set_enum (value, ffmpegdec->std_compliance);
2528       break;
2529     default:
2530       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2531       break;
2532   }
2533 }
2534
2535 gboolean
2536 gst_ffmpegviddec_register (GstPlugin * plugin)
2537 {
2538   GTypeInfo typeinfo = {
2539     sizeof (GstFFMpegVidDecClass),
2540     NULL,
2541     NULL,
2542     (GClassInitFunc) gst_ffmpegviddec_subclass_init,
2543     NULL,
2544     NULL,
2545     sizeof (GstFFMpegVidDec),
2546     0,
2547     (GInstanceInitFunc) gst_ffmpegviddec_subinit,
2548   };
2549   GType type;
2550   AVCodec *in_plugin;
2551   gint rank;
2552   void *i = 0;
2553
2554   GST_LOG ("Registering decoders");
2555
2556   while ((in_plugin = (AVCodec *) av_codec_iterate (&i))) {
2557     gchar *type_name;
2558     gchar *plugin_name;
2559
2560     /* only video decoders */
2561     if (!av_codec_is_decoder (in_plugin)
2562         || in_plugin->type != AVMEDIA_TYPE_VIDEO)
2563       continue;
2564
2565     /* no quasi codecs, please */
2566     if (in_plugin->id == AV_CODEC_ID_RAWVIDEO ||
2567         in_plugin->id == AV_CODEC_ID_V210 ||
2568         in_plugin->id == AV_CODEC_ID_V210X ||
2569         in_plugin->id == AV_CODEC_ID_V308 ||
2570         in_plugin->id == AV_CODEC_ID_V408 ||
2571         in_plugin->id == AV_CODEC_ID_V410 ||
2572         in_plugin->id == AV_CODEC_ID_R210
2573         || in_plugin->id == AV_CODEC_ID_AYUV
2574         || in_plugin->id == AV_CODEC_ID_Y41P
2575         || in_plugin->id == AV_CODEC_ID_012V
2576         || in_plugin->id == AV_CODEC_ID_YUV4
2577 #if AV_VERSION_INT (LIBAVCODEC_VERSION_MAJOR, LIBAVCODEC_VERSION_MINOR, LIBAVCODEC_VERSION_MICRO) >= \
2578         AV_VERSION_INT (57,4,0)
2579         || in_plugin->id == AV_CODEC_ID_WRAPPED_AVFRAME
2580 #endif
2581         || in_plugin->id == AV_CODEC_ID_ZLIB) {
2582       continue;
2583     }
2584
2585     /* No decoders depending on external libraries (we don't build them, but
2586      * people who build against an external ffmpeg might have them.
2587      * We have native gstreamer plugins for all of those libraries anyway. */
2588     if (!strncmp (in_plugin->name, "lib", 3)) {
2589       GST_DEBUG
2590           ("Not using external library decoder %s. Use the gstreamer-native ones instead.",
2591           in_plugin->name);
2592       continue;
2593     }
2594
2595     /* Skip hardware or hybrid (hardware with software fallback) */
2596     if ((in_plugin->capabilities & AV_CODEC_CAP_HARDWARE) ==
2597         AV_CODEC_CAP_HARDWARE) {
2598       GST_DEBUG
2599           ("Ignoring hardware decoder %s. We can't handle this outside of ffmpeg",
2600           in_plugin->name);
2601       continue;
2602     }
2603
2604     if ((in_plugin->capabilities & AV_CODEC_CAP_HYBRID) == AV_CODEC_CAP_HYBRID) {
2605       GST_DEBUG
2606           ("Ignoring hybrid decoder %s. We can't handle this outside of ffmpeg",
2607           in_plugin->name);
2608       continue;
2609     }
2610
2611     /* No vdpau plugins until we can figure out how to properly use them
2612      * outside of ffmpeg. */
2613     if (g_str_has_suffix (in_plugin->name, "_vdpau")) {
2614       GST_DEBUG
2615           ("Ignoring VDPAU decoder %s. We can't handle this outside of ffmpeg",
2616           in_plugin->name);
2617       continue;
2618     }
2619
2620     if (g_str_has_suffix (in_plugin->name, "_xvmc")) {
2621       GST_DEBUG
2622           ("Ignoring XVMC decoder %s. We can't handle this outside of ffmpeg",
2623           in_plugin->name);
2624       continue;
2625     }
2626
2627     if (strstr (in_plugin->name, "vaapi")) {
2628       GST_DEBUG
2629           ("Ignoring VAAPI decoder %s. We can't handle this outside of ffmpeg",
2630           in_plugin->name);
2631       continue;
2632     }
2633
2634     if (g_str_has_suffix (in_plugin->name, "_qsv")) {
2635       GST_DEBUG
2636           ("Ignoring qsv decoder %s. We can't handle this outside of ffmpeg",
2637           in_plugin->name);
2638       continue;
2639     }
2640
2641     GST_DEBUG ("Trying plugin %s [%s]", in_plugin->name, in_plugin->long_name);
2642
2643     /* no codecs for which we're GUARANTEED to have better alternatives */
2644     /* MPEG1VIDEO : the mpeg2video decoder is preferred */
2645     /* MP1 : Use MP3 for decoding */
2646     /* MP2 : Use MP3 for decoding */
2647     /* Theora: Use libtheora based theoradec */
2648     /* CDG: use cdgdec */
2649     /* AV1: Use av1dec, dav1ddec or any of the hardware decoders.
2650      *      Also ffmpeg's decoder only works with hardware support!
2651      */
2652     if (!strcmp (in_plugin->name, "theora") ||
2653         !strcmp (in_plugin->name, "mpeg1video") ||
2654         strstr (in_plugin->name, "crystalhd") != NULL ||
2655         !strcmp (in_plugin->name, "ass") ||
2656         !strcmp (in_plugin->name, "srt") ||
2657         !strcmp (in_plugin->name, "pgssub") ||
2658         !strcmp (in_plugin->name, "dvdsub") ||
2659         !strcmp (in_plugin->name, "dvbsub") ||
2660         !strcmp (in_plugin->name, "cdgraphics") ||
2661         !strcmp (in_plugin->name, "av1")) {
2662       GST_LOG ("Ignoring decoder %s", in_plugin->name);
2663       continue;
2664     }
2665
2666     /* construct the type */
2667     if (!strcmp (in_plugin->name, "hevc")) {
2668       plugin_name = g_strdup ("h265");
2669     } else {
2670       plugin_name = g_strdup ((gchar *) in_plugin->name);
2671     }
2672     g_strdelimit (plugin_name, NULL, '_');
2673     type_name = g_strdup_printf ("avdec_%s", plugin_name);
2674     g_free (plugin_name);
2675
2676     type = g_type_from_name (type_name);
2677
2678     if (!type) {
2679       /* create the gtype now */
2680       typeinfo.class_data = in_plugin;
2681       type =
2682           g_type_register_static (GST_TYPE_FFMPEGVIDDEC, type_name, &typeinfo,
2683           0);
2684     }
2685
2686     /* (Ronald) MPEG-4 gets a higher priority because it has been well-
2687      * tested and by far outperforms divxdec/xviddec - so we prefer it.
2688      * msmpeg4v3 same, as it outperforms divxdec for divx3 playback. */
2689     switch (in_plugin->id) {
2690       case AV_CODEC_ID_MPEG1VIDEO:
2691       case AV_CODEC_ID_MPEG2VIDEO:
2692       case AV_CODEC_ID_MPEG4:
2693       case AV_CODEC_ID_MSMPEG4V3:
2694       case AV_CODEC_ID_H264:
2695       case AV_CODEC_ID_HEVC:
2696       case AV_CODEC_ID_RV10:
2697       case AV_CODEC_ID_RV20:
2698       case AV_CODEC_ID_RV30:
2699       case AV_CODEC_ID_RV40:
2700         rank = GST_RANK_PRIMARY;
2701         break;
2702         /* DVVIDEO: we have a good dv decoder, fast on both ppc as well as x86.
2703          * They say libdv's quality is better though. leave as secondary.
2704          * note: if you change this, see the code in gstdv.c in good/ext/dv.
2705          */
2706       case AV_CODEC_ID_DVVIDEO:
2707         rank = GST_RANK_SECONDARY;
2708         break;
2709       default:
2710         rank = GST_RANK_MARGINAL;
2711         break;
2712     }
2713     if (!gst_element_register (plugin, type_name, rank, type)) {
2714       g_warning ("Failed to register %s", type_name);
2715       g_free (type_name);
2716       return FALSE;
2717     }
2718
2719     g_free (type_name);
2720   }
2721
2722   GST_LOG ("Finished Registering decoders");
2723
2724   return TRUE;
2725 }