va: Add mpeg2 VA decoder.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/merge_requests/1798>

sys/va/gstvabasedec.h

@@ -23,6 +23,7 @@
 
 #include <gst/codecs/gsth264decoder.h>
 #include <gst/codecs/gsth265decoder.h>
+#include <gst/codecs/gstmpeg2decoder.h>
 #include <gst/codecs/gstvp8decoder.h>
 #include <gst/codecs/gstvp9decoder.h>
 
@@ -46,6 +47,7 @@ struct _GstVaBaseDec
   {
     GstH264Decoder h264;
     GstH265Decoder h265;
+    GstMpeg2Decoder mpeg2;
     GstVp8Decoder vp8;
     GstVp9Decoder vp9;
   } parent;
@@ -78,6 +80,7 @@ struct _GstVaBaseDecClass
   {
     GstH264DecoderClass h264;
     GstH265DecoderClass h265;
+    GstMpeg2DecoderClass mpeg2;
     GstVp8DecoderClass vp8;
     GstVp9DecoderClass vp9;
   } parent_class;

sys/va/gstvadecoder.c

@@ -512,7 +512,6 @@ gst_va_decoder_add_param_buffer (GstVaDecoder * self, GstVaDecodePicture * pic,
   g_return_val_if_fail (GST_IS_VA_DECODER (self), FALSE);
   g_return_val_if_fail (self->context != VA_INVALID_ID, FALSE);
   g_return_val_if_fail (pic && data && size > 0, FALSE);
-  g_return_val_if_fail (pic->buffers->len + 1 <= 16, FALSE);
 
   dpy = gst_va_display_get_va_dpy (self->display);
   gst_va_display_lock (self->display);

sys/va/gstvampeg2dec.c

@@ -0,0 +1,719 @@
+/* GStreamer
+ *  Copyright (C) 2020 Intel Corporation
+ *     Author: He Junyan <junyan.he@intel.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the0
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+/**
+ * SECTION:element-vampeg2dec
+ * @title: vampeg2dec
+ * @short_description: A VA-API based Mpeg2 video decoder
+ *
+ * vampeg2dec decodes Mpeg2 bitstreams to VA surfaces using the
+ * installed and chosen [VA-API](https://01.org/linuxmedia/vaapi)
+ * driver.
+ *
+ * The decoding surfaces can be mapped onto main memory as video
+ * frames.
+ *
+ * ## Example launch line
+ * ```
+ * gst-launch-1.0 filesrc location=sample.mpg ! parsebin ! vampeg2dec ! autovideosink
+ * ```
+ *
+ * Since: 1.20
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstvampeg2dec.h"
+
+#include "gstvabasedec.h"
+
+GST_DEBUG_CATEGORY_STATIC (gst_va_mpeg2dec_debug);
+#ifndef GST_DISABLE_GST_DEBUG
+#define GST_CAT_DEFAULT gst_va_mpeg2dec_debug
+#else
+#define GST_CAT_DEFAULT NULL
+#endif
+
+#define GST_VA_MPEG2_DEC(obj)           ((GstVaMpeg2Dec *) obj)
+#define GST_VA_MPEG2_DEC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_FROM_INSTANCE (obj), GstVaMpeg2DecClass))
+#define GST_VA_MPEG2_DEC_CLASS(klass)   ((GstVaMpeg2DecClass *) klass)
+
+typedef struct _GstVaMpeg2Dec GstVaMpeg2Dec;
+typedef struct _GstVaMpeg2DecClass GstVaMpeg2DecClass;
+
+struct _GstVaMpeg2DecClass
+{
+  GstVaBaseDecClass parent_class;
+};
+
+struct _GstVaMpeg2Dec
+{
+  GstVaBaseDec parent;
+
+  gboolean progressive;
+  gboolean need_negotiation;
+
+  GstMpegVideoSequenceHdr seq;
+};
+
+#define parent_class gst_va_base_dec_parent_class
+extern gpointer gst_va_base_dec_parent_class;
+
+/* *INDENT-OFF* */
+static const gchar *src_caps_str = GST_VIDEO_CAPS_MAKE_WITH_FEATURES ("memory:VAMemory",
+            "{ NV12 }") " ;" GST_VIDEO_CAPS_MAKE ("{ NV12 }");
+/* *INDENT-ON* */
+
+static const gchar *sink_caps_str = "video/x-mpeg2";
+
+static gboolean
+gst_va_mpeg2_dec_negotiate (GstVideoDecoder * decoder)
+{
+  GstCapsFeatures *capsfeatures = NULL;
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+  GstVaMpeg2Dec *self = GST_VA_MPEG2_DEC (decoder);
+  GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN;
+  GstMpeg2Decoder *mpeg2dec = GST_MPEG2_DECODER (decoder);
+
+  /* Ignore downstream renegotiation request. */
+  if (!self->need_negotiation)
+    return TRUE;
+
+  self->need_negotiation = FALSE;
+
+  if (gst_va_decoder_is_open (base->decoder)
+      && !gst_va_decoder_close (base->decoder))
+    return FALSE;
+
+  if (!gst_va_decoder_open (base->decoder, base->profile, base->rt_format))
+    return FALSE;
+
+  if (!gst_va_decoder_set_format (base->decoder, base->width,
+          base->height, NULL))
+    return FALSE;
+
+  if (base->output_state)
+    gst_video_codec_state_unref (base->output_state);
+
+  gst_va_base_dec_get_preferred_format_and_caps_features (base, &format,
+      &capsfeatures);
+
+  base->output_state =
+      gst_video_decoder_set_output_state (decoder, format,
+      base->width, base->height, mpeg2dec->input_state);
+
+  if (!self->progressive)
+    base->output_state->info.interlace_mode = GST_VIDEO_INTERLACE_MODE_MIXED;
+
+  base->output_state->caps = gst_video_info_to_caps (&base->output_state->info);
+  if (capsfeatures)
+    gst_caps_set_features_simple (base->output_state->caps, capsfeatures);
+
+  GST_INFO_OBJECT (self, "Negotiated caps %" GST_PTR_FORMAT,
+      base->output_state->caps);
+
+  return GST_VIDEO_DECODER_CLASS (parent_class)->negotiate (decoder);
+}
+
+static VAProfile
+_map_profile (GstMpegVideoProfile profile)
+{
+  VAProfile p = VAProfileNone;
+
+  switch (profile) {
+    case GST_MPEG_VIDEO_PROFILE_SIMPLE:
+      p = VAProfileMPEG2Simple;
+      break;
+    case GST_MPEG_VIDEO_PROFILE_MAIN:
+      p = VAProfileMPEG2Main;
+      break;
+    default:
+      p = VAProfileNone;
+      break;
+  }
+
+  return p;
+}
+
+static VAProfile
+_get_profile (GstVaMpeg2Dec * self, GstMpegVideoProfile profile,
+    const GstMpegVideoSequenceExt * seq_ext,
+    const GstMpegVideoSequenceScalableExt * seq_scalable_ext)
+{
+  GstVaBaseDec *base = GST_VA_BASE_DEC (self);
+  VAProfile hw_profile;
+
+  hw_profile = _map_profile (profile);
+  if (hw_profile == VAProfileNone)
+    return hw_profile;
+
+  /* promote the profile if hw does not support, until we get one */
+  do {
+    if (gst_va_decoder_has_profile (base->decoder, hw_profile))
+      return hw_profile;
+
+    /* Otherwise, try to map to a higher profile */
+    switch (profile) {
+      case GST_MPEG_VIDEO_PROFILE_SIMPLE:
+        hw_profile = VAProfileMPEG2Main;
+        break;
+      case GST_MPEG_VIDEO_PROFILE_HIGH:
+        // Try to map to main profile if no high profile specific bits used
+        if (!seq_scalable_ext && (seq_ext && seq_ext->chroma_format == 1)) {
+          hw_profile = VAProfileMPEG2Main;
+          break;
+        }
+        // fall-through
+      default:
+        hw_profile = VAProfileNone;
+        break;
+    }
+  } while (hw_profile != VAProfileNone);
+
+  if (hw_profile == VAProfileNone)
+    GST_ERROR_OBJECT (self, "profile %d is unsupported.", profile);
+
+  return hw_profile;
+}
+
+static guint
+_get_rtformat (GstVaMpeg2Dec * self, GstMpegVideoChromaFormat chroma_format)
+{
+  guint ret = 0;
+
+  switch (chroma_format) {
+    case GST_MPEG_VIDEO_CHROMA_420:
+      ret = VA_RT_FORMAT_YUV420;
+      break;
+    case GST_MPEG_VIDEO_CHROMA_422:
+      ret = VA_RT_FORMAT_YUV422;
+      break;
+    case GST_MPEG_VIDEO_CHROMA_444:
+      ret = VA_RT_FORMAT_YUV444;
+      break;
+    default:
+      GST_ERROR_OBJECT (self, "Unsupported chroma format: %d ", chroma_format);
+      break;
+  }
+
+  return ret;
+}
+
+static gboolean
+gst_va_mpeg2_dec_new_sequence (GstMpeg2Decoder * decoder,
+    const GstMpegVideoSequenceHdr * seq,
+    const GstMpegVideoSequenceExt * seq_ext,
+    const GstMpegVideoSequenceDisplayExt * seq_display_ext,
+    const GstMpegVideoSequenceScalableExt * seq_scalable_ext)
+{
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+  GstVaMpeg2Dec *self = GST_VA_MPEG2_DEC (decoder);
+  VAProfile profile;
+  GstMpegVideoProfile mpeg_profile;
+  gboolean negotiation_needed = FALSE;
+  guint rt_format;
+  gint width, height;
+  gboolean progressive;
+
+  self->seq = *seq;
+
+  width = seq->width;
+  height = seq->height;
+  if (seq_ext) {
+    width = (width & 0x0fff) | ((guint32) seq_ext->horiz_size_ext << 12);
+    height = (height & 0x0fff) | ((guint32) seq_ext->vert_size_ext << 12);
+  }
+
+  mpeg_profile = GST_MPEG_VIDEO_PROFILE_MAIN;
+  if (seq_ext)
+    mpeg_profile = seq_ext->profile;
+
+  profile = _get_profile (self, mpeg_profile, seq_ext, seq_scalable_ext);
+  if (profile == VAProfileNone)
+    return FALSE;
+
+  rt_format = _get_rtformat (self,
+      seq_ext ? seq_ext->chroma_format : GST_MPEG_VIDEO_CHROMA_420);
+  if (rt_format == 0)
+    return FALSE;
+
+  if (gst_va_decoder_format_changed (base->decoder, profile,
+          rt_format, width, height)) {
+    base->profile = profile;
+    base->rt_format = rt_format;
+    base->width = width;
+    base->height = height;
+
+    negotiation_needed = TRUE;
+
+    GST_INFO_OBJECT (self, "Format changed to %s [%x] (%dx%d)",
+        gst_va_profile_name (profile), rt_format, base->width, base->height);
+  }
+
+  progressive = seq_ext ? seq_ext->progressive : 1;
+  if (self->progressive != progressive) {
+    self->progressive = progressive;
+
+    negotiation_needed = TRUE;
+    GST_INFO_OBJECT (self, "Interlaced mode changed to %d", !progressive);
+  }
+
+  base->need_valign = FALSE;
+
+  base->min_buffers = 2 + 4;    /* max num pic references + scratch surfaces */
+
+  if (negotiation_needed) {
+    self->need_negotiation = TRUE;
+    if (!gst_video_decoder_negotiate (GST_VIDEO_DECODER (self))) {
+      GST_ERROR_OBJECT (self, "Failed to negotiate with downstream");
+      return FALSE;
+    }
+  }
+
+  return TRUE;
+}
+
+static gboolean
+gst_va_mpeg2_dec_new_picture (GstMpeg2Decoder * decoder,
+    GstVideoCodecFrame * frame, GstMpeg2Picture * picture)
+{
+  GstFlowReturn ret;
+  GstVaMpeg2Dec *self = GST_VA_MPEG2_DEC (decoder);
+  GstVaDecodePicture *pic;
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+  GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
+
+  ret = gst_video_decoder_allocate_output_frame (vdec, frame);
+  if (ret != GST_FLOW_OK)
+    goto error;
+
+  pic = gst_va_decode_picture_new (base->decoder, frame->output_buffer);
+
+  gst_mpeg2_picture_set_user_data (picture, pic,
+      (GDestroyNotify) gst_va_decode_picture_free);
+
+  GST_LOG_OBJECT (self, "New va decode picture %p - %#x", pic,
+      gst_va_decode_picture_get_surface (pic));
+
+  return TRUE;
+
+error:
+  {
+    GST_WARNING_OBJECT (self, "Failed to allocated output buffer, return %s",
+        gst_flow_get_name (ret));
+    return FALSE;
+  }
+}
+
+static gboolean
+gst_va_mpeg2_dec_new_field_picture (GstMpeg2Decoder * decoder,
+    const GstMpeg2Picture * first_field, GstMpeg2Picture * second_field)
+{
+  GstVaDecodePicture *first_pic, *second_pic;
+  GstVaMpeg2Dec *self = GST_VA_MPEG2_DEC (decoder);
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+
+  first_pic = gst_mpeg2_picture_get_user_data ((GstMpeg2Picture *) first_field);
+  if (!first_pic)
+    return FALSE;
+
+  second_pic = gst_va_decode_picture_new (base->decoder, first_pic->gstbuffer);
+  gst_mpeg2_picture_set_user_data (second_field, second_pic,
+      (GDestroyNotify) gst_va_decode_picture_free);
+
+  GST_LOG_OBJECT (self, "New va decode picture %p - %#x", second_pic,
+      gst_va_decode_picture_get_surface (second_pic));
+
+  return TRUE;
+}
+
+static inline guint32
+_pack_f_code (guint8 f_code[2][2])
+{
+  return (((guint32) f_code[0][0] << 12) |
+      ((guint32) f_code[0][1] << 8) |
+      ((guint32) f_code[1][0] << 4) | (f_code[1][1]));
+}
+
+static inline void
+_copy_quant_matrix (guint8 dst[64], const guint8 src[64])
+{
+  memcpy (dst, src, 64);
+}
+
+static gboolean
+gst_va_mpeg2_dec_add_quant_matrix (GstMpeg2Decoder * decoder,
+    GstMpeg2Picture * picture, GstMpeg2Slice * slice)
+{
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+  GstVaMpeg2Dec *self = GST_VA_MPEG2_DEC (decoder);
+  GstMpegVideoQuantMatrixExt *const quant_matrix = slice->quant_matrix;
+  guint8 *intra_quant_matrix = NULL;
+  guint8 *non_intra_quant_matrix = NULL;
+  guint8 *chroma_intra_quant_matrix = NULL;
+  guint8 *chroma_non_intra_quant_matrix = NULL;
+  VAIQMatrixBufferMPEG2 iq_matrix = { 0 };
+  GstVaDecodePicture *va_pic;
+
+  intra_quant_matrix = self->seq.intra_quantizer_matrix;
+  non_intra_quant_matrix = self->seq.non_intra_quantizer_matrix;
+
+  if (quant_matrix) {
+    if (quant_matrix->load_intra_quantiser_matrix)
+      intra_quant_matrix = quant_matrix->intra_quantiser_matrix;
+    if (quant_matrix->load_non_intra_quantiser_matrix)
+      non_intra_quant_matrix = quant_matrix->non_intra_quantiser_matrix;
+    if (quant_matrix->load_chroma_intra_quantiser_matrix)
+      chroma_intra_quant_matrix = quant_matrix->chroma_intra_quantiser_matrix;
+    if (quant_matrix->load_chroma_non_intra_quantiser_matrix)
+      chroma_non_intra_quant_matrix =
+          quant_matrix->chroma_non_intra_quantiser_matrix;
+  }
+
+  iq_matrix.load_intra_quantiser_matrix = intra_quant_matrix != NULL;
+  if (intra_quant_matrix)
+    _copy_quant_matrix (iq_matrix.intra_quantiser_matrix, intra_quant_matrix);
+
+  iq_matrix.load_non_intra_quantiser_matrix = non_intra_quant_matrix != NULL;
+  if (non_intra_quant_matrix)
+    _copy_quant_matrix (iq_matrix.non_intra_quantiser_matrix,
+        non_intra_quant_matrix);
+
+  iq_matrix.load_chroma_intra_quantiser_matrix =
+      chroma_intra_quant_matrix != NULL;
+  if (chroma_intra_quant_matrix)
+    _copy_quant_matrix (iq_matrix.chroma_intra_quantiser_matrix,
+        chroma_intra_quant_matrix);
+
+  iq_matrix.load_chroma_non_intra_quantiser_matrix =
+      chroma_non_intra_quant_matrix != NULL;
+  if (chroma_non_intra_quant_matrix)
+    _copy_quant_matrix (iq_matrix.chroma_non_intra_quantiser_matrix,
+        chroma_non_intra_quant_matrix);
+
+  va_pic = gst_mpeg2_picture_get_user_data (picture);
+  return gst_va_decoder_add_param_buffer (base->decoder, va_pic,
+      VAIQMatrixBufferType, &iq_matrix, sizeof (iq_matrix));
+}
+
+static gboolean
+gst_va_mpeg2_dec_start_picture (GstMpeg2Decoder * decoder,
+    GstMpeg2Picture * picture, GstMpeg2Slice * slice,
+    GstMpeg2Picture * prev_picture, GstMpeg2Picture * next_picture)
+{
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+  GstVaMpeg2Dec *self = GST_VA_MPEG2_DEC (decoder);
+  GstVaDecodePicture *va_pic;
+  VAPictureParameterBufferMPEG2 pic_param;
+
+  va_pic = gst_mpeg2_picture_get_user_data (picture);
+
+  /* *INDENT-OFF* */ 
+  pic_param = (VAPictureParameterBufferMPEG2)
+  {
+    .horizontal_size = base->width,
+    .vertical_size = base->height,
+    .forward_reference_picture = VA_INVALID_ID,
+    .backward_reference_picture = VA_INVALID_ID,
+    .picture_coding_type = slice->pic_hdr->pic_type,
+    .f_code = _pack_f_code (slice->pic_ext->f_code),
+    .picture_coding_extension.value = 0,
+    .picture_coding_extension.bits.is_first_field =
+        (picture->first_field == NULL),
+    .picture_coding_extension.bits.intra_dc_precision =
+        slice->pic_ext->intra_dc_precision,
+    .picture_coding_extension.bits.picture_structure =
+        slice->pic_ext->picture_structure,
+    .picture_coding_extension.bits.top_field_first =
+        slice->pic_ext->top_field_first,
+    .picture_coding_extension.bits.frame_pred_frame_dct =
+        slice->pic_ext->frame_pred_frame_dct,
+    .picture_coding_extension.bits.concealment_motion_vectors =
+        slice->pic_ext->concealment_motion_vectors,
+    .picture_coding_extension.bits.q_scale_type =
+        slice->pic_ext->q_scale_type,
+    .picture_coding_extension.bits.intra_vlc_format =
+        slice->pic_ext->intra_vlc_format,
+    .picture_coding_extension.bits.alternate_scan =
+        slice->pic_ext->alternate_scan,
+    .picture_coding_extension.bits.repeat_first_field =
+        slice->pic_ext->repeat_first_field,
+    .picture_coding_extension.bits.progressive_frame =
+        slice->pic_ext->progressive_frame,
+  };
+  /* *INDENT-ON* */
+
+  if (picture->type == GST_MPEG_VIDEO_PICTURE_TYPE_B ||
+      picture->type == GST_MPEG_VIDEO_PICTURE_TYPE_P) {
+    GstVaDecodePicture *prev_pic;
+
+    prev_pic =
+        prev_picture ? gst_mpeg2_picture_get_user_data (prev_picture) : NULL;
+    if (!prev_pic) {
+      GST_WARNING_OBJECT (self, "Missing the forward reference picture");
+      return FALSE;
+    } else {
+      pic_param.forward_reference_picture =
+          gst_va_decode_picture_get_surface (prev_pic);
+    }
+  }
+
+  if (picture->type == GST_MPEG_VIDEO_PICTURE_TYPE_B) {
+    GstVaDecodePicture *next_pic;
+
+    next_pic =
+        next_picture ? gst_mpeg2_picture_get_user_data (next_picture) : NULL;
+    if (!next_pic) {
+      GST_WARNING_OBJECT (self, "Missing the backward reference picture");
+      return FALSE;
+    } else {
+      pic_param.backward_reference_picture =
+          gst_va_decode_picture_get_surface (next_pic);
+    }
+  }
+
+  if (!gst_va_decoder_add_param_buffer (base->decoder, va_pic,
+          VAPictureParameterBufferType, &pic_param, sizeof (pic_param)))
+    return FALSE;
+
+  if (!gst_va_mpeg2_dec_add_quant_matrix (decoder, picture, slice))
+    return FALSE;
+
+  return TRUE;
+}
+
+static gboolean
+gst_va_mpeg2_dec_decode_slice (GstMpeg2Decoder * decoder,
+    GstMpeg2Picture * picture, GstMpeg2Slice * slice)
+{
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+  GstMpegVideoSliceHdr *header = &slice->header;
+  GstMpegVideoPacket *packet = &slice->packet;
+  GstVaDecodePicture *va_pic;
+  VASliceParameterBufferMPEG2 slice_param;
+
+  /* The slice data pass to driver should be a full packet
+     include the start code. The packet->offset return by
+     gst_mpeg_video_parse does not include the start code
+     and so we need to wrap back 4 bytes. */
+  g_assert (packet->offset >= 4);
+
+  /* *INDENT-OFF* */
+  slice_param = (VASliceParameterBufferMPEG2) {
+    .slice_data_size = packet->size + 4 /* start code */,
+    .slice_data_offset = 0,
+    .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
+    .macroblock_offset = header->header_size + 32,
+    .slice_horizontal_position = header->mb_column,
+    .slice_vertical_position = header->mb_row,
+    .quantiser_scale_code = header->quantiser_scale_code,
+    .intra_slice_flag = header->intra_slice,
+  };
+  /* *INDENT-ON* */
+
+  va_pic = gst_mpeg2_picture_get_user_data (picture);
+  if (!gst_va_decoder_add_slice_buffer (base->decoder, va_pic,
+          &slice_param, sizeof (slice_param),
+          (guint8 *) (packet->data + packet->offset - 4 /* start code */ ),
+          packet->size + 4 /* start code */ ))
+    return FALSE;
+
+  return TRUE;
+}
+
+static gboolean
+gst_va_mpeg2_dec_end_picture (GstMpeg2Decoder * decoder,
+    GstMpeg2Picture * picture)
+{
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+  GstVaDecodePicture *va_pic;
+
+  GST_LOG_OBJECT (base, "end picture %p, (poc %d)",
+      picture, picture->pic_order_cnt);
+
+  va_pic = gst_mpeg2_picture_get_user_data (picture);
+
+  return gst_va_decoder_decode (base->decoder, va_pic);
+}
+
+static GstFlowReturn
+gst_va_mpeg2_dec_output_picture (GstMpeg2Decoder * decoder,
+    GstVideoCodecFrame * frame, GstMpeg2Picture * picture)
+{
+  GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+  GstVaMpeg2Dec *self = GST_VA_MPEG2_DEC (decoder);
+
+  GST_LOG_OBJECT (self,
+      "Outputting picture %p (poc %d)", picture, picture->pic_order_cnt);
+
+  if (base->copy_frames)
+    gst_va_base_dec_copy_output_buffer (base, frame);
+
+  gst_mpeg2_picture_unref (picture);
+
+  return gst_video_decoder_finish_frame (GST_VIDEO_DECODER (self), frame);
+}
+
+static void
+gst_va_mpeg2_dec_init (GTypeInstance * instance, gpointer g_class)
+{
+  gst_va_base_dec_init (GST_VA_BASE_DEC (instance), GST_CAT_DEFAULT);
+}
+
+static void
+gst_va_mpeg2_dec_dispose (GObject * object)
+{
+  gst_va_base_dec_close (GST_VIDEO_DECODER (object));
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gst_va_mpeg2_dec_class_init (gpointer g_class, gpointer class_data)
+{
+  GstCaps *src_doc_caps, *sink_doc_caps;
+  GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+  GstMpeg2DecoderClass *mpeg2decoder_class = GST_MPEG2_DECODER_CLASS (g_class);
+  GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_CLASS (g_class);
+  struct CData *cdata = class_data;
+  gchar *long_name;
+
+  if (cdata->description) {
+    long_name = g_strdup_printf ("VA-API Mpeg2 Decoder in %s",
+        cdata->description);
+  } else {
+    long_name = g_strdup ("VA-API Mpeg2 Decoder");
+  }
+
+  gst_element_class_set_metadata (element_class, long_name,
+      "Codec/Decoder/Video/Hardware",
+      "VA-API based Mpeg2 video decoder", "He Junyan <junyan.he@intel.com>");
+
+  sink_doc_caps = gst_caps_from_string (sink_caps_str);
+  src_doc_caps = gst_caps_from_string (src_caps_str);
+
+  gst_va_base_dec_class_init (GST_VA_BASE_DEC_CLASS (g_class), MPEG2,
+      cdata->render_device_path, cdata->sink_caps, cdata->src_caps,
+      src_doc_caps, sink_doc_caps);
+
+  gobject_class->dispose = gst_va_mpeg2_dec_dispose;
+
+  decoder_class->negotiate = GST_DEBUG_FUNCPTR (gst_va_mpeg2_dec_negotiate);
+
+  mpeg2decoder_class->new_sequence =
+      GST_DEBUG_FUNCPTR (gst_va_mpeg2_dec_new_sequence);
+  mpeg2decoder_class->new_picture =
+      GST_DEBUG_FUNCPTR (gst_va_mpeg2_dec_new_picture);
+  mpeg2decoder_class->new_field_picture =
+      GST_DEBUG_FUNCPTR (gst_va_mpeg2_dec_new_field_picture);
+  mpeg2decoder_class->start_picture =
+      GST_DEBUG_FUNCPTR (gst_va_mpeg2_dec_start_picture);
+  mpeg2decoder_class->decode_slice =
+      GST_DEBUG_FUNCPTR (gst_va_mpeg2_dec_decode_slice);
+  mpeg2decoder_class->end_picture =
+      GST_DEBUG_FUNCPTR (gst_va_mpeg2_dec_end_picture);
+  mpeg2decoder_class->output_picture =
+      GST_DEBUG_FUNCPTR (gst_va_mpeg2_dec_output_picture);
+
+  g_free (long_name);
+  g_free (cdata->description);
+  g_free (cdata->render_device_path);
+  gst_caps_unref (cdata->src_caps);
+  gst_caps_unref (cdata->sink_caps);
+  g_free (cdata);
+}
+
+static gpointer
+_register_debug_category (gpointer data)
+{
+  GST_DEBUG_CATEGORY_INIT (gst_va_mpeg2dec_debug, "vampeg2dec", 0,
+      "VA Mpeg2 decoder");
+
+  return NULL;
+}
+
+gboolean
+gst_va_mpeg2_dec_register (GstPlugin * plugin, GstVaDevice * device,
+    GstCaps * sink_caps, GstCaps * src_caps, guint rank)
+{
+  static GOnce debug_once = G_ONCE_INIT;
+  GType type;
+  GTypeInfo type_info = {
+    .class_size = sizeof (GstVaMpeg2DecClass),
+    .class_init = gst_va_mpeg2_dec_class_init,
+    .instance_size = sizeof (GstVaMpeg2Dec),
+    .instance_init = gst_va_mpeg2_dec_init,
+  };
+  struct CData *cdata;
+  gboolean ret;
+  gchar *type_name, *feature_name;
+
+  g_return_val_if_fail (GST_IS_PLUGIN (plugin), FALSE);
+  g_return_val_if_fail (GST_IS_VA_DEVICE (device), FALSE);
+  g_return_val_if_fail (GST_IS_CAPS (sink_caps), FALSE);
+  g_return_val_if_fail (GST_IS_CAPS (src_caps), FALSE);
+
+  cdata = g_new (struct CData, 1);
+  cdata->description = NULL;
+  cdata->render_device_path = g_strdup (device->render_device_path);
+  cdata->sink_caps = gst_caps_ref (sink_caps);
+  cdata->src_caps = gst_caps_ref (src_caps);
+
+  /* class data will be leaked if the element never gets instantiated */
+  GST_MINI_OBJECT_FLAG_SET (cdata->sink_caps,
+      GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
+  GST_MINI_OBJECT_FLAG_SET (src_caps, GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
+
+  type_info.class_data = cdata;
+
+  type_name = g_strdup ("GstVaMpeg2dec");
+  feature_name = g_strdup ("vampeg2dec");
+
+  /* The first decoder to be registered should use a constant name,
+   * like vampeg2dec, for any additional decoders, we create unique
+   * names, using inserting the render device name. */
+  if (g_type_from_name (type_name)) {
+    gchar *basename = g_path_get_basename (device->render_device_path);
+    g_free (type_name);
+    g_free (feature_name);
+    type_name = g_strdup_printf ("GstVa%sMpeg2Dec", basename);
+    feature_name = g_strdup_printf ("va%smpeg2dec", basename);
+    cdata->description = basename;
+
+    /* lower rank for non-first device */
+    if (rank > 0)
+      rank--;
+  }
+
+  g_once (&debug_once, _register_debug_category, NULL);
+
+  type = g_type_register_static (GST_TYPE_MPEG2_DECODER,
+      type_name, &type_info, 0);
+
+  ret = gst_element_register (plugin, feature_name, rank, type);
+
+  g_free (type_name);
+  g_free (feature_name);
+
+  return ret;
+}

sys/va/gstvampeg2dec.h

@@ -0,0 +1,33 @@
+/* GStreamer
+ *  Copyright (C) 2020 Intel Corporation
+ *     Author: He Junyan <junyan.he@intel.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the0
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "gstvadevice.h"
+
+G_BEGIN_DECLS
+
+gboolean              gst_va_mpeg2_dec_register          (GstPlugin * plugin,
+                                                          GstVaDevice * device,
+                                                          GstCaps * sink_caps,
+                                                          GstCaps * src_caps,
+                                                          guint rank);
+
+G_END_DECLS

sys/va/meson.build

@@ -17,6 +17,7 @@ va_sources = [
   'gstvavideoformat.c',
   'gstvavp8dec.c',
   'gstvavp9dec.c',
+  'gstvampeg2dec.c',
   'gstvavpp.c'
 ]
 

sys/va/plugin.c

@@ -31,6 +31,7 @@
 #include "gstvadevice.h"
 #include "gstvah264dec.h"
 #include "gstvah265dec.h"
+#include "gstvampeg2dec.h"
 #include "gstvaprofile.h"
 #include "gstvavp8dec.h"
 #include "gstvavp9dec.h"
@@ -120,6 +121,13 @@ plugin_register_decoders (GstPlugin * plugin, GstVaDevice * device,
               device->render_device_path);
         }
         break;
+      case MPEG2:
+        if (!gst_va_mpeg2_dec_register (plugin, device, sinkcaps, srccaps,
+                GST_RANK_NONE)) {
+          GST_WARNING ("Failed to register Mpeg2 decoder: %s",
+              device->render_device_path);
+        }
+        break;
       default:
         GST_DEBUG ("No decoder implementation for %" GST_FOURCC_FORMAT,
             GST_FOURCC_ARGS (codec));