d3d11: Add h265 decoder element

Some DPB management implementation is taken from gstreamer-vaapi

sys/d3d11/gstd3d11_fwd.h

@@ -82,6 +82,9 @@ typedef struct _GstD3D11H264DecClass GstD3D11H264DecClass;
 typedef struct _GstD3D11Vp9Dec GstD3D11Vp9Dec;
 typedef struct _GstD3D11Vp9DecClass GstD3D11Vp9DecClass;
 
+typedef struct _GstD3D11H265Dec GstD3D11H265Dec;
+typedef struct _GstD3D11H265DecClass GstD3D11H265DecClass;
+
 G_END_DECLS
 
 #endif /* __GST_D3D11_FWD_H__ */

sys/d3d11/gstd3d11decoder.c

@@ -599,7 +599,8 @@ gst_d3d11_decoder_open (GstD3D11Decoder * decoder, GstD3D11Codec codec,
       break;
     }
 
-    if (codec == GST_D3D11_CODEC_VP9 && config_list[i].ConfigBitstreamRaw == 1) {
+    if ((codec == GST_D3D11_CODEC_VP9 || codec == GST_D3D11_CODEC_H265)
+        && config_list[i].ConfigBitstreamRaw == 1) {
       best_config = &config_list[i];
       break;
     }

sys/d3d11/gstd3d11decoder.h

@@ -58,6 +58,7 @@ typedef enum
   GST_D3D11_CODEC_NONE,
   GST_D3D11_CODEC_H264,
   GST_D3D11_CODEC_VP9,
+  GST_D3D11_CODEC_H265,
 
   /* the last of supported codec */
   GST_D3D11_CODEC_LAST

sys/d3d11/gstd3d11h265dec.h

@@ -0,0 +1,88 @@
+/* GStreamer
+ * Copyright (C) 2019 Seungha Yang <seungha.yang@navercorp.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 the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __GST_D3D11_H265_DEC_H__
+#define __GST_D3D11_H265_DEC_H__
+
+#include "gsth265decoder.h"
+#include "gsth265picture.h"
+#include "gstd3d11decoder.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_D3D11_H265_DEC \
+  (gst_d3d11_h265_dec_get_type())
+#define GST_D3D11_H265_DEC(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_D3D11_H265_DEC,GstD3D11H265Dec))
+#define GST_D3D11_H265_DEC_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_D3D11_H265_DEC,GstD3D11H265DecClass))
+#define GST_D3D11_H265_DEC_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_D3D11_H265_DEC,GstD3D11H265DecClass))
+#define GST_IS_D3D11_H265_DEC(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_D3D11_H265_DEC))
+#define GST_IS_D3D11_H265_DEC_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_D3D11_H265_DEC))
+
+struct _GstD3D11H265Dec
+{
+  GstH265Decoder parent;
+
+  GstVideoCodecState *output_state;
+
+  GstD3D11Device *device;
+  gint adapter;
+
+  guint width, height;
+  guint coded_width, coded_height;
+  guint bitdepth;
+  guint chroma_format_idc;
+  GstVideoFormat out_format;
+
+  DXVA_PicEntry_HEVC ref_pic_list[15];
+  INT pic_order_cnt_val_list[15];
+  UCHAR ref_pic_set_st_curr_before[8];
+  UCHAR ref_pic_set_st_curr_after[8];
+  UCHAR ref_pic_set_lt_curr[8];
+
+  /* Array of DXVA_Slice_HEVC_Short */
+  GArray *slice_list;
+  gboolean submit_iq_data;
+
+  GstD3D11Decoder *d3d11_decoder;
+
+  GstH265Picture *current_picture;
+
+  /* Pointing current bitstream buffer */
+  guint current_offset;
+  guint bitstream_buffer_size;
+  guint8 * bitstream_buffer_bytes;
+
+  gboolean use_d3d11_output;
+};
+
+struct _GstD3D11H265DecClass
+{
+  GstH265DecoderClass parent_class;
+};
+
+GType gst_d3d11_h265_dec_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GST_D3D11_H265_DEC_H__ */

sys/d3d11/gsth265decoder.h

@@ -0,0 +1,143 @@
+/* GStreamer
+ * Copyright (C) 2019 Seungha Yang <seungha.yang@navercorp.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 the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __GST_H265_DECODER_H__
+#define __GST_H265_DECODER_H__
+
+#include <gst/gst.h>
+#include <gst/video/video.h>
+#include <gst/codecparsers/gsth265parser.h>
+#include "gsth265picture.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_H265_DECODER            (gst_h265_decoder_get_type())
+#define GST_H265_DECODER(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_H265_DECODER,GstH265Decoder))
+#define GST_H265_DECODER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_H265_DECODER,GstH265DecoderClass))
+#define GST_H265_DECODER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_H265_DECODER,GstH265DecoderClass))
+#define GST_IS_H265_DECODER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_H265_DECODER))
+#define GST_IS_H265_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_H265_DECODER))
+#define GST_H265_DECODER_CAST(obj)       ((GstH265Decoder*)obj)
+
+typedef struct _GstH265Decoder GstH265Decoder;
+typedef struct _GstH265DecoderClass GstH265DecoderClass;
+typedef struct _GstH265DecoderPrivate GstH265DecoderPrivate;
+
+#define IS_IDR(nal_type) \
+  ((nal_type) == GST_H265_NAL_SLICE_IDR_W_RADL || (nal_type) == GST_H265_NAL_SLICE_IDR_N_LP)
+
+#define IS_IRAP(nal_type) \
+  ((nal_type) >= GST_H265_NAL_SLICE_BLA_W_LP && (nal_type) <= RESERVED_IRAP_NAL_TYPE_MAX)
+
+#define IS_BLA(nal_type) \
+  ((nal_type) >= GST_H265_NAL_SLICE_BLA_W_LP && (nal_type) <= GST_H265_NAL_SLICE_BLA_N_LP)
+
+#define IS_CRA(nal_type) \
+  ((nal_type) == GST_H265_NAL_SLICE_CRA_NUT)
+
+#define IS_RADL(nal_type) \
+  ((nal_type) >= GST_H265_NAL_SLICE_RADL_N && (nal_type) <= GST_H265_NAL_SLICE_RADL_R)
+
+#define IS_RASL(nal_type) \
+  ((nal_type) >= GST_H265_NAL_SLICE_RASL_N && (nal_type) <= GST_H265_NAL_SLICE_RASL_R)
+
+/**
+ * GstH265Decoder:
+ *
+ * The opaque #GstH265Decoder data structure.
+ */
+struct _GstH265Decoder
+{
+  /*< private >*/
+  GstVideoDecoder parent;
+
+  /*< protected >*/
+  GstVideoCodecState * input_state;
+
+  GstH265Picture *RefPicSetStCurrBefore[16];
+  GstH265Picture *RefPicSetStCurrAfter[16];
+  GstH265Picture *RefPicSetStFoll[16];
+  GstH265Picture *RefPicSetLtCurr[16];
+  GstH265Picture *RefPicSetLtFoll[16];
+
+  guint NumPocStCurrBefore;
+  guint NumPocStCurrAfter;
+  guint NumPocStFoll;
+  guint NumPocLtCurr;
+  guint NumPocLtFoll;
+  guint NumPocTotalCurr;
+
+  /*< private >*/
+  GstH265DecoderPrivate *priv;
+  gpointer padding[GST_PADDING_LARGE];
+};
+
+/**
+ * GstH265DecoderClass:
+ * @new_sequence:   Notifies subclass of SPS update
+ * @new_picture:    Optional.
+ *                  Called whenever new #GstH265Picture is created.
+ *                  Subclass can set implementation specific user data
+ *                  on the #GstH265Picture via gst_h265_picture_set_user_data()
+ * @output_picture: Optional.
+ *                  Called just before gst_video_decoder_have_frame().
+ *                  Subclass should be prepared for handle_frame()
+ * @start_picture:  Optional.
+ *                  Called per one #GstH265Picture to notify subclass to prepare
+ *                  decoding process for the #GstH265Picture
+ * @decode_slice:   Provides per slice data with parsed slice header and
+ *                  required raw bitstream for subclass to decode it
+ * @end_picture:    Optional.
+ *                  Called per one #GstH265Picture to notify subclass to finish
+ *                  decoding process for the #GstH265Picture
+ */
+struct _GstH265DecoderClass
+{
+  GstVideoDecoderClass parent_class;
+
+  gboolean      (*new_sequence)     (GstH265Decoder * decoder,
+                                     const GstH265SPS * sps);
+
+  gboolean      (*new_picture)      (GstH265Decoder * decoder,
+                                     GstH265Picture * picture);
+
+  GstFlowReturn (*output_picture)   (GstH265Decoder * decoder,
+                                     GstH265Picture * picture);
+
+  gboolean      (*start_picture)    (GstH265Decoder * decoder,
+                                     GstH265Picture * picture,
+                                     GstH265Slice * slice,
+                                     GstH265Dpb * dpb);
+
+  gboolean      (*decode_slice)     (GstH265Decoder * decoder,
+                                     GstH265Picture * picture,
+                                     GstH265Slice * slice);
+
+  gboolean      (*end_picture)      (GstH265Decoder * decoder,
+                                     GstH265Picture * picture);
+
+  /*< private >*/
+  gpointer padding[GST_PADDING_LARGE];
+};
+
+GType gst_h265_decoder_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GST_H265_DECODER_H__ */

sys/d3d11/gsth265picture.c

@@ -0,0 +1,486 @@
+/* GStreamer
+ * Copyright (C) 2019 Seungha Yang <seungha.yang@navercorp.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 the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "gsth265picture.h"
+
+GST_DEBUG_CATEGORY_EXTERN (gst_d3d11_h265_dec_debug);
+#define GST_CAT_DEFAULT gst_d3d11_h265_dec_debug
+
+GST_DEFINE_MINI_OBJECT_TYPE (GstH265Picture, gst_h265_picture);
+
+static void
+_gst_h265_picture_free (GstH265Picture * picture)
+{
+  if (picture->notify)
+    picture->notify (picture->user_data);
+
+  g_free (picture);
+}
+
+/**
+ * gst_h265_picture_new:
+ *
+ * Create new #GstH265Picture
+ *
+ * Returns: a new #GstH265Picture
+ */
+GstH265Picture *
+gst_h265_picture_new (void)
+{
+  GstH265Picture *pic;
+
+  pic = g_new0 (GstH265Picture, 1);
+
+  pic->pts = GST_CLOCK_TIME_NONE;
+  pic->field = GST_H265_PICTURE_FIELD_FRAME;
+
+  gst_mini_object_init (GST_MINI_OBJECT_CAST (pic), 0,
+      GST_TYPE_H265_PICTURE, NULL, NULL,
+      (GstMiniObjectFreeFunction) _gst_h265_picture_free);
+
+  return pic;
+}
+
+/**
+ * gst_h265_picture_set_user_data:
+ * @picture: a #GstH265Picture
+ * @user_data: private data
+ * @notify: (closure user_data): a #GDestroyNotify
+ *
+ * Sets @user_data on the picture and the #GDestroyNotify that will be called when
+ * the picture is freed.
+ *
+ * If a @user_data was previously set, then the previous set @notify will be called
+ * before the @user_data is replaced.
+ */
+void
+gst_h265_picture_set_user_data (GstH265Picture * picture, gpointer user_data,
+    GDestroyNotify notify)
+{
+  g_return_if_fail (GST_IS_H265_PICTURE (picture));
+
+  if (picture->notify)
+    picture->notify (picture->user_data);
+
+  picture->user_data = user_data;
+  picture->notify = notify;
+}
+
+/**
+ * gst_h265_picture_get_user_data:
+ * @picture: a #GstH265Picture
+ *
+ * Gets private data set on the picture via
+ * gst_h265_picture_set_user_data() previously.
+ *
+ * Returns: (transfer none): The previously set user_data
+ */
+gpointer
+gst_h265_picture_get_user_data (GstH265Picture * picture)
+{
+  return picture->user_data;
+}
+
+struct _GstH265Dpb
+{
+  GArray *pic_list;
+  gint max_num_pics;
+};
+
+/**
+ * gst_h265_dpb_new:
+ *
+ * Create new #GstH265Dpb
+ *
+ * Returns: a new #GstH265Dpb
+ */
+GstH265Dpb *
+gst_h265_dpb_new (void)
+{
+  GstH265Dpb *dpb;
+
+  dpb = g_new0 (GstH265Dpb, 1);
+
+  dpb->pic_list =
+      g_array_sized_new (FALSE, TRUE, sizeof (GstH265Picture *),
+      GST_H265_DPB_MAX_SIZE);
+  g_array_set_clear_func (dpb->pic_list,
+      (GDestroyNotify) gst_h265_picture_clear);
+
+  return dpb;
+}
+
+/**
+ * gst_h265_dpb_set_max_num_pics:
+ * @dpb: a #GstH265Dpb
+ * @max_num_pics: the maximum number of picture
+ *
+ * Set the number of maximum allowed pictures to store
+ */
+void
+gst_h265_dpb_set_max_num_pics (GstH265Dpb * dpb, gint max_num_pics)
+{
+  g_return_if_fail (dpb != NULL);
+
+  dpb->max_num_pics = max_num_pics;
+}
+
+/**
+ * gst_h265_dpb_get_max_num_pics:
+ * @dpb: a #GstH265Dpb
+ *
+ * Returns: the number of maximum pictures
+ */
+gint
+gst_h265_dpb_get_max_num_pics (GstH265Dpb * dpb)
+{
+  g_return_val_if_fail (dpb != NULL, 0);
+
+  return dpb->max_num_pics;
+}
+
+/**
+ * gst_h265_dpb_free:
+ * @dpb: a #GstH265Dpb to free
+ *
+ * Free the @dpb
+ */
+void
+gst_h265_dpb_free (GstH265Dpb * dpb)
+{
+  g_return_if_fail (dpb != NULL);
+
+  gst_h265_dpb_clear (dpb);
+  g_free (dpb);
+}
+
+/**
+ * gst_h265_dpb_clear:
+ * @dpb: a #GstH265Dpb
+ *
+ * Clear all stored #GstH265Picture
+ */
+void
+gst_h265_dpb_clear (GstH265Dpb * dpb)
+{
+  g_return_if_fail (dpb != NULL);
+
+  g_array_set_size (dpb->pic_list, 0);
+}
+
+/**
+ * gst_h265_dpb_add:
+ * @dpb: a #GstH265Dpb
+ * @picture: (transfer full): a #GstH265Picture
+ *
+ * Store the @picture
+ */
+void
+gst_h265_dpb_add (GstH265Dpb * dpb, GstH265Picture * picture)
+{
+  g_return_if_fail (dpb != NULL);
+  g_return_if_fail (GST_IS_H265_PICTURE (picture));
+
+  g_array_append_val (dpb->pic_list, picture);
+}
+
+/**
+ * gst_h265_dpb_delete_unused:
+ * @dpb: a #GstH265Dpb
+ *
+ * Delete already outputted and not referenced all pictures from dpb
+ */
+void
+gst_h265_dpb_delete_unused (GstH265Dpb * dpb)
+{
+  gint i;
+
+  g_return_if_fail (dpb != NULL);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    if (picture->outputted && !picture->ref) {
+      GST_TRACE ("remove picture %p (poc %d) from dpb",
+          picture, picture->pic_order_cnt);
+      g_array_remove_index (dpb->pic_list, i);
+      i--;
+    }
+  }
+}
+
+/**
+ * gst_h265_dpb_delete_by_poc:
+ * @dpb: a #GstH265Dpb
+ * @poc: a poc of #GstH265Picture to remove
+ *
+ * Delete a #GstH265Dpb by @poc
+ */
+void
+gst_h265_dpb_delete_by_poc (GstH265Dpb * dpb, gint poc)
+{
+  gint i;
+
+  g_return_if_fail (dpb != NULL);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    if (picture->pic_order_cnt == poc) {
+      g_array_remove_index (dpb->pic_list, i);
+      return;
+    }
+  }
+
+  GST_WARNING ("Couldn't find picture with poc %d", poc);
+}
+
+/**
+ * gst_h265_dpb_num_ref_pictures:
+ * @dpb: a #GstH265Dpb
+ *
+ * Returns: The number of referenced pictures
+ */
+gint
+gst_h265_dpb_num_ref_pictures (GstH265Dpb * dpb)
+{
+  gint i;
+  gint ret = 0;
+
+  g_return_val_if_fail (dpb != NULL, -1);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    if (picture->ref)
+      ret++;
+  }
+
+  return ret;
+}
+
+/**
+ * gst_h265_dpb_mark_all_non_ref:
+ * @dpb: a #GstH265Dpb
+ *
+ * Mark all pictures are not referenced
+ */
+void
+gst_h265_dpb_mark_all_non_ref (GstH265Dpb * dpb)
+{
+  gint i;
+
+  g_return_if_fail (dpb != NULL);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    picture->ref = FALSE;
+  }
+}
+
+/**
+ * gst_h265_dpb_get_ref_by_poc:
+ * @dpb: a #GstH265Dpb
+ * @poc: a picture order count
+ *
+ * Find a short or long term reference picture which has matching poc
+ *
+ * Returns: (nullable) (transfer full): a #GstH265Picture
+ */
+GstH265Picture *
+gst_h265_dpb_get_ref_by_poc (GstH265Dpb * dpb, gint poc)
+{
+  gint i;
+
+  g_return_val_if_fail (dpb != NULL, NULL);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    if (picture->ref && picture->pic_order_cnt == poc)
+      return gst_h265_picture_ref (picture);
+  }
+
+  GST_DEBUG ("No short term reference picture for %d", poc);
+
+  return NULL;
+}
+
+/**
+ * gst_h265_dpb_get_ref_by_poc:
+ * @dpb: a #GstH265Dpb
+ * @poc_lsb: a picture order count lsb
+ *
+ * Find a short or long term reference picture which has matching poc_lsb
+ *
+ * Returns: (nullable) (transfer full): a #GstH265Picture
+ */
+GstH265Picture *
+gst_h265_dpb_get_ref_by_poc_lsb (GstH265Dpb * dpb, gint poc_lsb)
+{
+  gint i;
+
+  g_return_val_if_fail (dpb != NULL, NULL);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    if (picture->ref && picture->pic_order_cnt_lsb == poc_lsb)
+      return gst_h265_picture_ref (picture);
+  }
+
+  GST_DEBUG ("No short term reference picture for %d", poc_lsb);
+
+  return NULL;
+}
+
+/**
+ * gst_h265_dpb_get_short_ref_by_poc:
+ * @dpb: a #GstH265Dpb
+ * @poc: a picture order count
+ *
+ * Find a short term reference picture which has matching poc
+ *
+ * Returns: (nullable) (transfer full): a #GstH265Picture
+ */
+GstH265Picture *
+gst_h265_dpb_get_short_ref_by_poc (GstH265Dpb * dpb, gint poc)
+{
+  gint i;
+
+  g_return_val_if_fail (dpb != NULL, NULL);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    if (picture->ref && !picture->long_term && picture->pic_order_cnt == poc)
+      return gst_h265_picture_ref (picture);
+  }
+
+  GST_DEBUG ("No short term reference picture for %d", poc);
+
+  return NULL;
+}
+
+/**
+ * gst_h265_dpb_get_long_ref_by_poc:
+ * @dpb: a #GstH265Dpb
+ * @poc: a picture order count
+ *
+ * Find a long term reference picture which has matching poc
+ *
+ * Returns: (nullable) (transfer full): a #GstH265Picture
+ */
+GstH265Picture *
+gst_h265_dpb_get_long_ref_by_poc (GstH265Dpb * dpb, gint poc)
+{
+  gint i;
+
+  g_return_val_if_fail (dpb != NULL, NULL);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    if (picture->ref && picture->long_term && picture->pic_order_cnt == poc)
+      return gst_h265_picture_ref (picture);
+  }
+
+  GST_DEBUG ("No long term reference picture for %d", poc);
+
+  return NULL;
+}
+
+/**
+ * gst_h265_dpb_get_pictures_not_outputted:
+ * @dpb: a #GstH265Dpb
+ * @out: (out): a list of #GstH265Dpb
+ *
+ * Retrieve all not-outputted pictures from @dpb
+ */
+void
+gst_h265_dpb_get_pictures_not_outputted (GstH265Dpb * dpb, GList ** out)
+{
+  gint i;
+
+  g_return_if_fail (dpb != NULL);
+  g_return_if_fail (out != NULL);
+
+  for (i = 0; i < dpb->pic_list->len; i++) {
+    GstH265Picture *picture =
+        g_array_index (dpb->pic_list, GstH265Picture *, i);
+
+    if (!picture->outputted)
+      *out = g_list_append (*out, gst_h265_picture_ref (picture));
+  }
+}
+
+/**
+ * gst_h265_dpb_get_pictures_all:
+ * @dpb: a #GstH265Dpb
+ *
+ * Return: (transfer full): a #GArray of #GstH265Picture stored in @dpb
+ */
+GArray *
+gst_h265_dpb_get_pictures_all (GstH265Dpb * dpb)
+{
+  g_return_val_if_fail (dpb != NULL, NULL);
+
+  return g_array_ref (dpb->pic_list);
+}
+
+/**
+ * gst_h265_dpb_get_size:
+ * @dpb: a #GstH265Dpb
+ *
+ * Return: the length of stored dpb array
+ */
+gint
+gst_h265_dpb_get_size (GstH265Dpb * dpb)
+{
+  g_return_val_if_fail (dpb != NULL, -1);
+
+  return dpb->pic_list->len;
+}
+
+/**
+ * gst_h265_dpb_is_full:
+ * @dpb: a #GstH265Dpb
+ *
+ * Return: %TRUE if @dpb is full
+ */
+gboolean
+gst_h265_dpb_is_full (GstH265Dpb * dpb)
+{
+  g_return_val_if_fail (dpb != NULL, -1);
+
+  return dpb->pic_list->len >= dpb->max_num_pics;
+}

sys/d3d11/gsth265picture.h

@@ -0,0 +1,199 @@
+/* GStreamer
+ * Copyright (C) 2019 Seungha Yang <seungha.yang@navercorp.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 the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __GST_H265_PICTURE_H__
+#define __GST_H265_PICTURE_H__
+
+#include <gst/gst.h>
+#include <gst/codecparsers/gsth265parser.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_H265_PICTURE     (gst_h265_picture_get_type())
+#define GST_IS_H265_PICTURE(obj)  (GST_IS_MINI_OBJECT_TYPE(obj, GST_TYPE_H265_PICTURE))
+#define GST_H265_PICTURE(obj)     ((GstH265Picture *)obj)
+#define GST_H265_PICTURE_CAST(obj) (GST_H265_PICTURE(obj))
+
+typedef struct _GstH265Slice GstH265Slice;
+typedef struct _GstH265Picture GstH265Picture;
+
+#define GST_H265_DPB_MAX_SIZE 16
+
+struct _GstH265Slice
+{
+  GstH265SliceHdr header;
+
+  /* parsed nal unit (doesn't take ownership of raw data) */
+  GstH265NalUnit nalu;
+};
+
+typedef enum
+{
+  GST_H265_PICTURE_FIELD_FRAME,
+  GST_H265_PICTURE_FILED_TOP_FIELD,
+  GST_H265_PICTURE_FIELD_BOTTOM_FIELD,
+} GstH265PictureField;
+
+struct _GstH265Picture
+{
+  GstMiniObject parent;
+
+  GstH265SliceType type;
+
+  GstClockTime pts;
+
+  gint pic_order_cnt;
+  gint pic_order_cnt_msb;
+  gint pic_order_cnt_lsb;
+
+  guint32 pic_latency_cnt;      /* PicLatencyCount */
+
+  gboolean output_flag;
+  gboolean NoRaslOutputFlag;
+  gboolean NoOutputOfPriorPicsFlag;
+  gboolean RapPicFlag;           /* nalu type between 16 and 21 */
+  gboolean IntraPicFlag;         /* Intra pic (only Intra slices) */
+
+  gboolean ref;
+  gboolean long_term;
+  gboolean outputted;
+
+  GstH265PictureField field;
+
+  gpointer user_data;
+  GDestroyNotify notify;
+};
+
+G_GNUC_INTERNAL
+GType gst_h265_picture_get_type (void);
+
+G_GNUC_INTERNAL
+GstH265Picture * gst_h265_picture_new (void);
+
+G_GNUC_INTERNAL
+static inline GstH265Picture *
+gst_h265_picture_ref (GstH265Picture * picture)
+{
+  return (GstH265Picture *) gst_mini_object_ref (GST_MINI_OBJECT_CAST (picture));
+}
+
+G_GNUC_INTERNAL
+static inline void
+gst_h265_picture_unref (GstH265Picture * picture)
+{
+  gst_mini_object_unref (GST_MINI_OBJECT_CAST (picture));
+}
+
+G_GNUC_INTERNAL
+static inline gboolean
+gst_h265_picture_replace (GstH265Picture ** old_picture,
+    GstH265Picture * new_picture)
+{
+  return gst_mini_object_replace ((GstMiniObject **) old_picture,
+      (GstMiniObject *) new_picture);
+}
+
+G_GNUC_INTERNAL
+static inline void
+gst_h265_picture_clear (GstH265Picture ** picture)
+{
+  if (picture && *picture) {
+    gst_h265_picture_unref (*picture);
+    *picture = NULL;
+  }
+}
+
+G_GNUC_INTERNAL
+void gst_h265_picture_set_user_data (GstH265Picture * picture,
+                                     gpointer user_data,
+                                     GDestroyNotify notify);
+
+G_GNUC_INTERNAL
+gpointer gst_h265_picture_get_user_data (GstH265Picture * picture);
+
+/*******************
+ * GstH265Dpb *
+ *******************/
+typedef struct _GstH265Dpb GstH265Dpb;
+
+G_GNUC_INTERNAL
+GstH265Dpb * gst_h265_dpb_new (void);
+
+G_GNUC_INTERNAL
+void  gst_h265_dpb_set_max_num_pics (GstH265Dpb * dpb,
+                                     gint max_num_pics);
+
+G_GNUC_INTERNAL
+gint gst_h265_dpb_get_max_num_pics  (GstH265Dpb * dpb);
+
+G_GNUC_INTERNAL
+void  gst_h265_dpb_free             (GstH265Dpb * dpb);
+
+G_GNUC_INTERNAL
+void  gst_h265_dpb_clear            (GstH265Dpb * dpb);
+
+G_GNUC_INTERNAL
+void  gst_h265_dpb_add              (GstH265Dpb * dpb,
+                                     GstH265Picture * picture);
+
+G_GNUC_INTERNAL
+void  gst_h265_dpb_delete_unused    (GstH265Dpb * dpb);
+
+G_GNUC_INTERNAL
+void  gst_h265_dpb_delete_by_poc    (GstH265Dpb * dpb,
+                                     gint poc);
+
+G_GNUC_INTERNAL
+gint  gst_h265_dpb_num_ref_pictures (GstH265Dpb * dpb);
+
+G_GNUC_INTERNAL
+void  gst_h265_dpb_mark_all_non_ref (GstH265Dpb * dpb);
+
+G_GNUC_INTERNAL
+GstH265Picture * gst_h265_dpb_get_ref_by_poc       (GstH265Dpb * dpb,
+                                                    gint poc);
+
+G_GNUC_INTERNAL
+GstH265Picture * gst_h265_dpb_get_ref_by_poc_lsb   (GstH265Dpb * dpb,
+                                                    gint poc_lsb);
+
+G_GNUC_INTERNAL
+GstH265Picture * gst_h265_dpb_get_short_ref_by_poc (GstH265Dpb * dpb,
+                                                    gint poc);
+
+G_GNUC_INTERNAL
+GstH265Picture * gst_h265_dpb_get_long_ref_by_poc  (GstH265Dpb * dpb,
+                                                    gint poc);
+
+G_GNUC_INTERNAL
+void  gst_h265_dpb_get_pictures_not_outputted  (GstH265Dpb * dpb,
+                                                GList ** out);
+
+G_GNUC_INTERNAL
+GArray * gst_h265_dpb_get_pictures_all         (GstH265Dpb * dpb);
+
+G_GNUC_INTERNAL
+gint  gst_h265_dpb_get_size   (GstH265Dpb * dpb);
+
+G_GNUC_INTERNAL
+gboolean gst_h265_dpb_is_full (GstH265Dpb * dpb);
+
+G_END_DECLS
+
+#endif /* __GST_H265_PICTURE_H__ */

sys/d3d11/meson.build

@@ -25,6 +25,9 @@ d3d11_dec_sources = [
   'gstvp9picture.c',
   'gstvp9decoder.c',
   'gstd3d11vp9dec.c',
+  'gsth265picture.c',
+  'gsth265decoder.c',
+  'gstd3d11h265dec.c',
 ]
 
 dxgi_headers = [

sys/d3d11/plugin.c

@@ -32,6 +32,7 @@
 #ifdef HAVE_DXVA_H
 #include "gstd3d11utils.h"
 #include "gstd3d11h264dec.h"
+#include "gstd3d11h265dec.h"
 #include "gstd3d11vp9dec.h"
 #endif
 
@@ -48,6 +49,7 @@ GST_DEBUG_CATEGORY (gst_d3d11_debug_layer_debug);
 
 #ifdef HAVE_DXVA_H
 GST_DEBUG_CATEGORY (gst_d3d11_h264_dec_debug);
+GST_DEBUG_CATEGORY (gst_d3d11_h265_dec_debug);
 GST_DEBUG_CATEGORY (gst_d3d11_vp9_dec_debug);
 #endif
 
@@ -91,11 +93,15 @@ plugin_init (GstPlugin * plugin)
         "d3d11h264dec", 0, "Direct3D11 H.264 Video Decoder");
     GST_DEBUG_CATEGORY_INIT (gst_d3d11_vp9_dec_debug,
         "d3d11vp9dec", 0, "Direct3D11 VP9 Video Decoder");
+    GST_DEBUG_CATEGORY_INIT (gst_d3d11_h265_dec_debug,
+        "d3d11h265dec", 0, "Direct3D11 H.265 Video Decoder");
 
     gst_element_register (plugin,
         "d3d11h264dec", GST_RANK_SECONDARY, GST_TYPE_D3D11_H264_DEC);
     gst_element_register (plugin,
         "d3d11vp9dec", GST_RANK_SECONDARY, GST_TYPE_D3D11_VP9_DEC);
+    gst_element_register (plugin,
+        "d3d11h265dec", GST_RANK_SECONDARY, GST_TYPE_D3D11_H265_DEC);
   }
 #endif