gstreamer/sys/va/gstvampeg2dec.c

/* 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;
};

/* *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_frame_size (base->decoder, base->width, base->height))
    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 (GST_VA_BASE_DEC_GET_PARENT_CLASS
      (decoder))->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:
        GST_ERROR_OBJECT (self, "profile %d is unsupported.", profile);
        hw_profile = VAProfileNone;
        break;
    }
  } while (hw_profile != VAProfileNone);

  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_config_is_equal (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 inline uint32_t
_is_frame_start (GstMpeg2Picture * picture)
{
  return (!picture->first_field
      || (picture->structure == GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME))
      ? 1 : 0;
}

static inline VASurfaceID
_get_surface_id (GstMpeg2Picture * picture)
{
  GstVaDecodePicture *va_pic;

  if (!picture)
    return VA_INVALID_ID;

  va_pic = gst_mpeg2_picture_get_user_data (picture);
  if (!va_pic)
    return VA_INVALID_ID;
  return gst_va_decode_picture_get_surface (va_pic);
}

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.bits = {
      .is_first_field = _is_frame_start (picture),
      .intra_dc_precision = slice->pic_ext->intra_dc_precision,
      .picture_structure = slice->pic_ext->picture_structure,
      .top_field_first = slice->pic_ext->top_field_first,
      .frame_pred_frame_dct = slice->pic_ext->frame_pred_frame_dct,
      .concealment_motion_vectors = slice->pic_ext->concealment_motion_vectors,
      .q_scale_type = slice->pic_ext->q_scale_type,
      .intra_vlc_format = slice->pic_ext->intra_vlc_format,
      .alternate_scan = slice->pic_ext->alternate_scan,
      .repeat_first_field = slice->pic_ext->repeat_first_field,
      .progressive_frame = slice->pic_ext->progressive_frame,
    },
  };
  /* *INDENT-ON* */

  switch (picture->type) {
    case GST_MPEG_VIDEO_PICTURE_TYPE_B:{
      VASurfaceID surface = _get_surface_id (next_picture);
      if (surface == VA_INVALID_ID) {
        GST_WARNING_OBJECT (self, "Missing the backward reference picture");
        if (GST_VA_DISPLAY_IS_IMPLEMENTATION (base->display, MESA_GALLIUM))
          return FALSE;
        else if (GST_VA_DISPLAY_IS_IMPLEMENTATION (base->display, INTEL_IHD))
          surface = gst_va_decode_picture_get_surface (va_pic);
      }
      pic_param.backward_reference_picture = surface;
    }
      /* fall-through */
    case GST_MPEG_VIDEO_PICTURE_TYPE_P:{
      VASurfaceID surface = _get_surface_id (prev_picture);
      if (surface == VA_INVALID_ID) {
        GST_WARNING_OBJECT (self, "Missing the forward reference picture");
        if (GST_VA_DISPLAY_IS_IMPLEMENTATION (base->display, MESA_GALLIUM))
          return FALSE;
        else if (GST_VA_DISPLAY_IS_IMPLEMENTATION (base->display, INTEL_IHD))
          surface = gst_va_decode_picture_get_surface (va_pic);
      }
      pic_param.forward_reference_picture = surface;
    }
    default:
      break;
  }

  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);

  if (picture->buffer_flags != 0) {
    gboolean interlaced =
        (picture->buffer_flags & GST_VIDEO_BUFFER_FLAG_INTERLACED) != 0;
    gboolean tff = (picture->buffer_flags & GST_VIDEO_BUFFER_FLAG_TFF) != 0;

    GST_TRACE_OBJECT (self,
        "apply buffer flags 0x%x (interlaced %d, top-field-first %d)",
        picture->buffer_flags, interlaced, tff);
    GST_BUFFER_FLAG_SET (frame->output_buffer, picture->buffer_flags);
  }

  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 (GST_VA_BASE_DEC_GET_PARENT_CLASS (object))->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;
}