gstreamer/sys/nvcodec/gstnvh265enc.c

/* GStreamer NVENC plugin
 * Copyright (C) 2015 Centricular Ltd
 * Copyright (C) 2018 Seungha Yang <pudding8757@gmail.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 "gstnvh265enc.h"

#include <gst/pbutils/codec-utils.h>
#include <gst/base/gstbytewriter.h>

#include <string.h>

typedef struct
{
  GstCaps *sink_caps;
  GstCaps *src_caps;
  gboolean is_default;
} GstNvH265EncClassData;

GST_DEBUG_CATEGORY_STATIC (gst_nv_h265_enc_debug);
#define GST_CAT_DEFAULT gst_nv_h265_enc_debug

static GstElementClass *parent_class = NULL;

enum
{
  PROP_0,
  PROP_AUD,
  PROP_WEIGHTED_PRED,
  PROP_VBV_BUFFER_SIZE,
  PROP_RC_LOOKAHEAD,
  PROP_TEMPORAL_AQ,
  PROP_BFRAMES,
  PROP_B_ADAPT,
};

#define DEFAULT_AUD TRUE
#define DEFAULT_WEIGHTED_PRED FALSE
#define DEFAULT_VBV_BUFFER_SIZE 0
#define DEFAULT_RC_LOOKAHEAD 0
#define DEFAULT_TEMPORAL_AQ FALSE
#define DEFAULT_BFRAMES 0
#define DEFAULT_B_ADAPT FALSE

static gboolean gst_nv_h265_enc_open (GstVideoEncoder * enc);
static gboolean gst_nv_h265_enc_close (GstVideoEncoder * enc);
static gboolean gst_nv_h265_enc_stop (GstVideoEncoder * enc);
static gboolean gst_nv_h265_enc_set_src_caps (GstNvBaseEnc * nvenc,
    GstVideoCodecState * state);
static gboolean gst_nv_h265_enc_set_encoder_config (GstNvBaseEnc * nvenc,
    GstVideoCodecState * state, NV_ENC_CONFIG * config);
static gboolean gst_nv_h265_enc_set_pic_params (GstNvBaseEnc * nvenc,
    GstVideoCodecFrame * frame, NV_ENC_PIC_PARAMS * pic_params);
static void gst_nv_h265_enc_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec);
static void gst_nv_h265_enc_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec);
static void gst_nv_h265_enc_finalize (GObject * obj);

static void
gst_nv_h265_enc_class_init (GstNvH265EncClass * klass, gpointer data)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
  GstVideoEncoderClass *videoenc_class = GST_VIDEO_ENCODER_CLASS (klass);
  GstNvBaseEncClass *nvenc_class = GST_NV_BASE_ENC_CLASS (klass);
  GstNvEncDeviceCaps *device_caps = &nvenc_class->device_caps;
  GstNvH265EncClassData *cdata = (GstNvH265EncClassData *) data;
  gchar *long_name;

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->set_property = gst_nv_h265_enc_set_property;
  gobject_class->get_property = gst_nv_h265_enc_get_property;
  gobject_class->finalize = gst_nv_h265_enc_finalize;

  videoenc_class->open = GST_DEBUG_FUNCPTR (gst_nv_h265_enc_open);
  videoenc_class->close = GST_DEBUG_FUNCPTR (gst_nv_h265_enc_close);
  videoenc_class->stop = GST_DEBUG_FUNCPTR (gst_nv_h265_enc_stop);

  nvenc_class->codec_id = NV_ENC_CODEC_HEVC_GUID;
  nvenc_class->set_encoder_config = gst_nv_h265_enc_set_encoder_config;
  nvenc_class->set_src_caps = gst_nv_h265_enc_set_src_caps;
  nvenc_class->set_pic_params = gst_nv_h265_enc_set_pic_params;

  g_object_class_install_property (gobject_class, PROP_AUD,
      g_param_spec_boolean ("aud", "AUD",
          "Use AU (Access Unit) delimiter", DEFAULT_AUD,
          G_PARAM_READWRITE | GST_PARAM_MUTABLE_PLAYING |
          G_PARAM_STATIC_STRINGS));

  if (device_caps->weighted_prediction) {
    g_object_class_install_property (gobject_class, PROP_WEIGHTED_PRED,
        g_param_spec_boolean ("weighted-pred", "Weighted Pred",
            "Weighted Prediction "
            "(Exposed only if supported by device)", DEFAULT_WEIGHTED_PRED,
            G_PARAM_READWRITE | GST_PARAM_MUTABLE_PLAYING |
            G_PARAM_STATIC_STRINGS));
  }

  if (device_caps->custom_vbv_bufsize) {
    g_object_class_install_property (gobject_class,
        PROP_VBV_BUFFER_SIZE,
        g_param_spec_uint ("vbv-buffer-size", "VBV Buffer Size",
            "VBV(HRD) Buffer Size in kbits (0 = NVENC default) "
            "(Exposed only if supported by device)", 0, G_MAXUINT,
            DEFAULT_VBV_BUFFER_SIZE,
            G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
            G_PARAM_STATIC_STRINGS));
  }

  if (device_caps->lookahead) {
    g_object_class_install_property (gobject_class, PROP_RC_LOOKAHEAD,
        g_param_spec_uint ("rc-lookahead", "Rate Control Lookahead",
            "Number of frames for frame type lookahead "
            "(Exposed only if supported by device)", 0, 32,
            DEFAULT_RC_LOOKAHEAD,
            G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
            G_PARAM_STATIC_STRINGS));
  }

  if (device_caps->temporal_aq) {
    g_object_class_install_property (gobject_class, PROP_TEMPORAL_AQ,
        g_param_spec_boolean ("temporal-aq", "Temporal AQ",
            "Temporal Adaptive Quantization "
            "(Exposed only if supported by device)", DEFAULT_TEMPORAL_AQ,
            G_PARAM_READWRITE | GST_PARAM_MUTABLE_PLAYING |
            G_PARAM_STATIC_STRINGS));
  }

  if (device_caps->bframes > 0) {
    g_object_class_install_property (gobject_class, PROP_BFRAMES,
        g_param_spec_uint ("bframes", "B-Frames",
            "Number of B-frames between I and P "
            "(Exposed only if supported by device)", 0, device_caps->bframes,
            DEFAULT_BFRAMES,
            G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
            G_PARAM_STATIC_STRINGS));

    g_object_class_install_property (gobject_class, PROP_B_ADAPT,
        g_param_spec_boolean ("b-adapt", "B Adapt",
            "Enable adaptive B-frame insert when lookahead is enabled "
            "(Exposed only if supported by device)",
            DEFAULT_B_ADAPT,
            G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
            G_PARAM_STATIC_STRINGS));
  }

  if (cdata->is_default)
    long_name = g_strdup ("NVENC HEVC Video Encoder");
  else
    long_name = g_strdup_printf ("NVENC HEVC Video Encoder with device %d",
        nvenc_class->cuda_device_id);

  gst_element_class_set_metadata (element_class, long_name,
      "Codec/Encoder/Video/Hardware",
      "Encode HEVC video streams using NVIDIA's hardware-accelerated NVENC encoder API",
      "Tim-Philipp Müller <tim@centricular.com>, "
      "Matthew Waters <matthew@centricular.com>, "
      "Seungha Yang <pudding8757@gmail.com>");
  g_free (long_name);

  GST_DEBUG_CATEGORY_INIT (gst_nv_h265_enc_debug,
      "nvh265enc", 0, "Nvidia HEVC encoder");

  gst_element_class_add_pad_template (element_class,
      gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
          cdata->sink_caps));
  gst_element_class_add_pad_template (element_class,
      gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
          cdata->src_caps));

  gst_caps_unref (cdata->sink_caps);
  gst_caps_unref (cdata->src_caps);
  g_free (cdata);
}

static void
gst_nv_h265_enc_init (GstNvH265Enc * nvenc)
{
  GstNvBaseEnc *baseenc = GST_NV_BASE_ENC (nvenc);

  nvenc->aud = DEFAULT_AUD;

  /* device capability dependent properties */
  baseenc->weighted_pred = DEFAULT_WEIGHTED_PRED;
  baseenc->vbv_buffersize = DEFAULT_VBV_BUFFER_SIZE;
  baseenc->rc_lookahead = DEFAULT_RC_LOOKAHEAD;
  baseenc->temporal_aq = DEFAULT_TEMPORAL_AQ;
  baseenc->bframes = DEFAULT_BFRAMES;
  baseenc->b_adapt = DEFAULT_B_ADAPT;
}

static void
gst_nv_h265_enc_finalize (GObject * obj)
{
  G_OBJECT_CLASS (parent_class)->finalize (obj);
}

static gboolean
gst_nv_h265_enc_open (GstVideoEncoder * enc)
{
  GstNvBaseEnc *base = GST_NV_BASE_ENC (enc);

  if (!GST_VIDEO_ENCODER_CLASS (parent_class)->open (enc))
    return FALSE;

  /* Check if HEVC is supported */
  {
    uint32_t i, num = 0;
    GUID guids[16];

    NvEncGetEncodeGUIDs (base->encoder, guids, G_N_ELEMENTS (guids), &num);

    for (i = 0; i < num; ++i) {
      if (gst_nvenc_cmp_guid (guids[i], NV_ENC_CODEC_HEVC_GUID))
        break;
    }
    GST_INFO_OBJECT (enc, "HEVC encoding %ssupported", (i == num) ? "un" : "");
    if (i == num) {
      gst_nv_h265_enc_close (enc);
      return FALSE;
    }
  }

  return TRUE;
}

static gboolean
gst_nv_h265_enc_close (GstVideoEncoder * enc)
{
  return GST_VIDEO_ENCODER_CLASS (parent_class)->close (enc);
}

static void
gst_nv_h265_enc_clear_stream_data (GstNvH265Enc * h265enc)
{
  gint i;

  if (!h265enc->sei_payload)
    return;

  for (i = 0; i < h265enc->num_sei_payload; i++)
    g_free (h265enc->sei_payload[i].payload);

  g_free (h265enc->sei_payload);
  h265enc->sei_payload = NULL;
  h265enc->num_sei_payload = 0;
}

static gboolean
gst_nv_h265_enc_stop (GstVideoEncoder * enc)
{
  GstNvH265Enc *h265enc = (GstNvH265Enc *) enc;

  gst_nv_h265_enc_clear_stream_data (h265enc);

  return GST_VIDEO_ENCODER_CLASS (parent_class)->stop (enc);
}

static gboolean
gst_nv_h265_enc_set_level_tier_and_profile (GstNvH265Enc * nvenc,
    GstCaps * caps)
{
#define N_BYTES_VPS 128
  guint8 vps[N_BYTES_VPS];
  NV_ENC_SEQUENCE_PARAM_PAYLOAD spp = { 0, };
  NVENCSTATUS nv_ret;
  guint32 seq_size;

  spp.version = gst_nvenc_get_sequence_param_payload_version ();
  spp.inBufferSize = N_BYTES_VPS;
  spp.spsId = 0;
  spp.ppsId = 0;
  spp.spsppsBuffer = &vps;
  spp.outSPSPPSPayloadSize = &seq_size;
  nv_ret = NvEncGetSequenceParams (GST_NV_BASE_ENC (nvenc)->encoder, &spp);
  if (nv_ret != NV_ENC_SUCCESS) {
    GST_ELEMENT_ERROR (nvenc, STREAM, ENCODE, ("Encode header failed."),
        ("NvEncGetSequenceParams return code=%d", nv_ret));
    return FALSE;
  }

  if (seq_size < 8) {
    GST_ELEMENT_ERROR (nvenc, STREAM, ENCODE, ("Encode header failed."),
        ("NvEncGetSequenceParams returned incomplete data"));
    return FALSE;
  }

  GST_MEMDUMP ("Header", spp.spsppsBuffer, seq_size);

  /* skip nal header and identifier */
  gst_codec_utils_h265_caps_set_level_tier_and_profile (caps,
      &vps[6], seq_size - 6);

  return TRUE;

#undef N_BYTES_VPS
}

static gboolean
gst_nv_h265_enc_set_src_caps (GstNvBaseEnc * nvenc, GstVideoCodecState * state)
{
  GstNvH265Enc *h265enc = (GstNvH265Enc *) nvenc;
  GstVideoCodecState *out_state;
  GstStructure *s;
  GstCaps *out_caps;

  out_caps = gst_caps_new_empty_simple ("video/x-h265");
  s = gst_caps_get_structure (out_caps, 0);

  /* TODO: add support for hvc1,hev1 format as well */
  gst_structure_set (s, "stream-format", G_TYPE_STRING, "byte-stream",
      "alignment", G_TYPE_STRING, "au", NULL);

  if (!gst_nv_h265_enc_set_level_tier_and_profile (h265enc, out_caps)) {
    gst_caps_unref (out_caps);
    return FALSE;
  }

  out_state = gst_video_encoder_set_output_state (GST_VIDEO_ENCODER (nvenc),
      out_caps, state);

  GST_INFO_OBJECT (nvenc, "output caps: %" GST_PTR_FORMAT, out_state->caps);

  /* encoder will keep it around for us */
  gst_video_codec_state_unref (out_state);

  /* TODO: would be nice to also send some tags with the codec name */
  return TRUE;
}

static guint8 *
gst_nv_h265_enc_create_mastering_display_sei_nal (GstNvH265Enc * h265enc,
    GstVideoMasteringDisplayInfo * minfo, guint * size)
{
  guint sei_size;
  guint16 primary_x[3];
  guint16 primary_y[3];
  guint16 white_x, white_y;
  guint32 max_luma;
  guint32 min_luma;
  const guint chroma_scale = 50000;
  const guint luma_scale = 10000;
  gint i;
  GstByteWriter br;

  GST_DEBUG_OBJECT (h265enc, "Apply mastering display info");
  GST_LOG_OBJECT (h265enc, "\tRed  (%u/%u, %u/%u)", minfo->Rx_n,
      minfo->Rx_d, minfo->Ry_n, minfo->Ry_d);
  GST_LOG_OBJECT (h265enc, "\tGreen(%u/%u, %u/%u)", minfo->Gx_n,
      minfo->Gx_d, minfo->Gy_n, minfo->Gy_d);
  GST_LOG_OBJECT (h265enc, "\tBlue (%u/%u, %u/%u)", minfo->Bx_n,
      minfo->Bx_d, minfo->By_n, minfo->By_d);
  GST_LOG_OBJECT (h265enc, "\tWhite(%u/%u, %u/%u)", minfo->Wx_n,
      minfo->Wx_d, minfo->Wy_n, minfo->Wy_d);
  GST_LOG_OBJECT (h265enc,
      "\tmax_luminance:(%u/%u), min_luminance:(%u/%u)",
      minfo->max_luma_n, minfo->max_luma_d, minfo->min_luma_n,
      minfo->min_luma_d);

  primary_x[0] =
      (guint16) gst_util_uint64_scale_round (minfo->Gx_n, chroma_scale,
      minfo->Gx_d);
  primary_x[1] =
      (guint16) gst_util_uint64_scale_round (minfo->Bx_n, chroma_scale,
      minfo->Bx_d);
  primary_x[2] =
      (guint16) gst_util_uint64_scale_round (minfo->Rx_n, chroma_scale,
      minfo->Rx_d);

  primary_y[0] =
      (guint16) gst_util_uint64_scale_round (minfo->Gy_n, chroma_scale,
      minfo->Gy_d);
  primary_y[1] =
      (guint16) gst_util_uint64_scale_round (minfo->By_n, chroma_scale,
      minfo->By_d);
  primary_y[2] =
      (guint16) gst_util_uint64_scale_round (minfo->Ry_n, chroma_scale,
      minfo->Ry_d);

  white_x =
      (guint16) gst_util_uint64_scale_round (minfo->Wx_n, chroma_scale,
      minfo->Wx_d);
  white_y =
      (guint16) gst_util_uint64_scale_round (minfo->Wy_n, chroma_scale,
      minfo->Wy_d);
  max_luma =
      (guint32) gst_util_uint64_scale_round (minfo->max_luma_n, luma_scale,
      minfo->max_luma_d);
  min_luma =
      (guint32) gst_util_uint64_scale_round (minfo->min_luma_n, luma_scale,
      minfo->min_luma_d);

  /* x, y 16bits per RGB channel
   * x, y 16bits white point
   * max, min luminance 32bits
   */
  sei_size = (2 * 2 * 3) + (2 * 2) + (4 * 2);
  gst_byte_writer_init_with_size (&br, sei_size, TRUE);

  for (i = 0; i < 3; i++) {
    gst_byte_writer_put_uint16_be (&br, primary_x[i]);
    gst_byte_writer_put_uint16_be (&br, primary_y[i]);
  }

  gst_byte_writer_put_uint16_be (&br, white_x);
  gst_byte_writer_put_uint16_be (&br, white_y);

  gst_byte_writer_put_uint32_be (&br, max_luma);
  gst_byte_writer_put_uint32_be (&br, min_luma);

  *size = sei_size;

  return gst_byte_writer_reset_and_get_data (&br);
}

static guint8 *
gst_nv_h265_enc_create_content_light_level_sei_nal (GstNvH265Enc * h265enc,
    GstVideoContentLightLevel * linfo, guint * size)
{
  gdouble val;
  guint sei_size;
  GstByteWriter br;

  GST_DEBUG_OBJECT (h265enc, "Apply content light level");
  GST_LOG_OBJECT (h265enc, "content light level found");
  GST_LOG_OBJECT (h265enc,
      "\tmaxCLL:(%u/%u), maxFALL:(%u/%u)", linfo->maxCLL_n, linfo->maxCLL_d,
      linfo->maxFALL_n, linfo->maxFALL_d);

  /* maxCLL and maxFALL per 16bits */
  sei_size = 2 * 2;
  gst_byte_writer_init_with_size (&br, sei_size, TRUE);

  gst_util_fraction_to_double (linfo->maxCLL_n, linfo->maxCLL_d, &val);
  gst_byte_writer_put_uint16_be (&br, (guint16) val);

  gst_util_fraction_to_double (linfo->maxFALL_n, linfo->maxFALL_d, &val);
  gst_byte_writer_put_uint16_be (&br, (guint16) val);

  *size = sei_size;

  return gst_byte_writer_reset_and_get_data (&br);
}

static gboolean
gst_nv_h265_enc_set_encoder_config (GstNvBaseEnc * nvenc,
    GstVideoCodecState * state, NV_ENC_CONFIG * config)
{
  GstNvH265Enc *h265enc = (GstNvH265Enc *) nvenc;
  GstCaps *allowed_caps, *template_caps;
  GUID selected_profile = NV_ENC_CODEC_PROFILE_AUTOSELECT_GUID;
  int level_idc = NV_ENC_LEVEL_AUTOSELECT;
  GstVideoInfo *info = &state->info;
  NV_ENC_CONFIG_HEVC *hevc_config = &config->encodeCodecConfig.hevcConfig;
  NV_ENC_CONFIG_HEVC_VUI_PARAMETERS *vui = &hevc_config->hevcVUIParameters;

  template_caps =
      gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD (h265enc));
  allowed_caps = gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (h265enc));

  if (template_caps == allowed_caps) {
    GST_INFO_OBJECT (h265enc, "downstream has ANY caps");
  } else if (allowed_caps) {
    GstStructure *s;
    const gchar *profile;
    const gchar *level;

    if (gst_caps_is_empty (allowed_caps)) {
      gst_caps_unref (allowed_caps);
      gst_caps_unref (template_caps);
      return FALSE;
    }

    allowed_caps = gst_caps_make_writable (allowed_caps);
    allowed_caps = gst_caps_fixate (allowed_caps);
    s = gst_caps_get_structure (allowed_caps, 0);

    profile = gst_structure_get_string (s, "profile");
    /* FIXME: only support main profile only for now */
    if (profile) {
      if (!strcmp (profile, "main")) {
        selected_profile = NV_ENC_HEVC_PROFILE_MAIN_GUID;
      } else if (g_str_has_prefix (profile, "main-10")) {
        selected_profile = NV_ENC_HEVC_PROFILE_MAIN10_GUID;
      } else if (g_str_has_prefix (profile, "main-444")) {
        selected_profile = NV_ENC_HEVC_PROFILE_FREXT_GUID;
      } else {
        g_assert_not_reached ();
      }
    }

    level = gst_structure_get_string (s, "level");
    if (level)
      /* matches values stored in NV_ENC_LEVEL */
      level_idc = gst_codec_utils_h265_get_level_idc (level);

    gst_caps_unref (allowed_caps);
  }
  gst_caps_unref (template_caps);

  /* override some defaults */
  GST_LOG_OBJECT (h265enc, "setting parameters");
  config->profileGUID = selected_profile;
  hevc_config->level = level_idc;
  hevc_config->idrPeriod = config->gopLength;

  config->encodeCodecConfig.hevcConfig.chromaFormatIDC = 1;
  if (GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_Y444 ||
      GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_Y444_16LE ||
      GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_Y444_16BE ||
      GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_VUYA) {
    GST_DEBUG_OBJECT (h265enc, "have Y444 input, setting config accordingly");
    config->profileGUID = NV_ENC_HEVC_PROFILE_FREXT_GUID;
    config->encodeCodecConfig.hevcConfig.chromaFormatIDC = 3;
    if (GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_Y444_16LE ||
        GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_Y444_16BE)
      config->encodeCodecConfig.hevcConfig.pixelBitDepthMinus8 = 2;
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
  } else if (GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_P010_10LE) {
#else
  } else if (GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_P010_10BE) {
#endif
    config->profileGUID = NV_ENC_HEVC_PROFILE_MAIN10_GUID;
    config->encodeCodecConfig.hevcConfig.pixelBitDepthMinus8 = 2;
  }

  hevc_config->outputAUD = h265enc->aud;

  vui->videoSignalTypePresentFlag = 1;
  /* NOTE: vui::video_format represents the video format before
   * being encoded such as PAL, NTSC, SECAM, and MAC. That's not much informal
   * and can be inferred with resolution and framerate by any application.
   */
  /* Unspecified video format (5) */
  vui->videoFormat = 5;

  if (info->colorimetry.range == GST_VIDEO_COLOR_RANGE_0_255) {
    vui->videoFullRangeFlag = 1;
  } else {
    vui->videoFullRangeFlag = 0;
  }

  vui->colourDescriptionPresentFlag = 1;
  vui->colourMatrix = gst_video_color_matrix_to_iso (info->colorimetry.matrix);
  vui->colourPrimaries =
      gst_video_color_primaries_to_iso (info->colorimetry.primaries);
  vui->transferCharacteristics =
      gst_video_color_transfer_to_iso (info->colorimetry.transfer);

  gst_nv_h265_enc_clear_stream_data (h265enc);

  {
    GstVideoMasteringDisplayInfo minfo;
    GstVideoContentLightLevel linfo;
    gboolean have_mastering;
    gboolean have_cll;
    guint size;
    gint i = 0;

    have_mastering =
        gst_video_mastering_display_info_from_caps (&minfo, state->caps);
    have_cll = gst_video_content_light_level_from_caps (&linfo, state->caps);

    if (have_mastering)
      h265enc->num_sei_payload++;
    if (have_cll)
      h265enc->num_sei_payload++;

    h265enc->sei_payload =
        g_new0 (NV_ENC_SEI_PAYLOAD, h265enc->num_sei_payload);

    if (have_mastering) {
      h265enc->sei_payload[i].payload =
          gst_nv_h265_enc_create_mastering_display_sei_nal (h265enc,
          &minfo, &size);
      h265enc->sei_payload[i].payloadSize = size;
      h265enc->sei_payload[i].payloadType = 137;
      i++;
    }

    if (have_cll) {
      h265enc->sei_payload[i].payload =
          gst_nv_h265_enc_create_content_light_level_sei_nal (h265enc,
          &linfo, &size);
      h265enc->sei_payload[i].payloadSize = size;
      h265enc->sei_payload[i].payloadType = 144;
    }
  }

  return TRUE;
}

static gboolean
gst_nv_h265_enc_set_pic_params (GstNvBaseEnc * enc, GstVideoCodecFrame * frame,
    NV_ENC_PIC_PARAMS * pic_params)
{
  GstNvH265Enc *h265enc = (GstNvH265Enc *) enc;

  /* encode whole picture in one single slice */
  pic_params->codecPicParams.hevcPicParams.sliceMode = 0;
  pic_params->codecPicParams.hevcPicParams.sliceModeData = 0;

  if (h265enc->sei_payload) {
    pic_params->codecPicParams.hevcPicParams.seiPayloadArray =
        h265enc->sei_payload;
    pic_params->codecPicParams.hevcPicParams.seiPayloadArrayCnt =
        h265enc->num_sei_payload;
  }

  return TRUE;
}

static void
gst_nv_h265_enc_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstNvH265Enc *self = (GstNvH265Enc *) object;
  GstNvBaseEnc *nvenc = GST_NV_BASE_ENC (object);
  GstNvBaseEncClass *klass = GST_NV_BASE_ENC_GET_CLASS (object);
  GstNvEncDeviceCaps *device_caps = &klass->device_caps;
  gboolean reconfig = FALSE;

  switch (prop_id) {
    case PROP_AUD:
    {
      gboolean aud;

      aud = g_value_get_boolean (value);
      if (aud != self->aud) {
        self->aud = aud;
        reconfig = TRUE;
      }
      break;
    }
    case PROP_WEIGHTED_PRED:
      if (!device_caps->weighted_prediction) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        nvenc->weighted_pred = g_value_get_boolean (value);
        reconfig = TRUE;
      }
      break;
    case PROP_VBV_BUFFER_SIZE:
      if (!device_caps->custom_vbv_bufsize) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        nvenc->vbv_buffersize = g_value_get_uint (value);
        reconfig = TRUE;
      }
      break;
    case PROP_RC_LOOKAHEAD:
      if (!device_caps->lookahead) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        nvenc->rc_lookahead = g_value_get_uint (value);
        reconfig = TRUE;
      }
      break;
    case PROP_TEMPORAL_AQ:
      if (!device_caps->temporal_aq) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        nvenc->temporal_aq = g_value_get_boolean (value);
        reconfig = TRUE;
      }
      break;
    case PROP_BFRAMES:
      if (!device_caps->bframes) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        nvenc->bframes = g_value_get_uint (value);
        reconfig = TRUE;
      }
      break;
    case PROP_B_ADAPT:
      if (!device_caps->bframes) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        nvenc->b_adapt = g_value_get_boolean (value);
      }
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }

  if (reconfig)
    gst_nv_base_enc_schedule_reconfig (GST_NV_BASE_ENC (self));
}

static void
gst_nv_h265_enc_get_property (GObject * object, guint prop_id, GValue * value,
    GParamSpec * pspec)
{
  GstNvH265Enc *self = (GstNvH265Enc *) object;
  GstNvBaseEnc *nvenc = GST_NV_BASE_ENC (object);
  GstNvBaseEncClass *klass = GST_NV_BASE_ENC_GET_CLASS (object);
  GstNvEncDeviceCaps *device_caps = &klass->device_caps;

  switch (prop_id) {
    case PROP_AUD:
      g_value_set_boolean (value, self->aud);
      break;
    case PROP_WEIGHTED_PRED:
      if (!device_caps->weighted_prediction) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        g_value_set_boolean (value, nvenc->weighted_pred);
      }
      break;
    case PROP_VBV_BUFFER_SIZE:
      if (!device_caps->custom_vbv_bufsize) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        g_value_set_uint (value, nvenc->vbv_buffersize);
      }
      break;
    case PROP_RC_LOOKAHEAD:
      if (!device_caps->lookahead) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        g_value_set_uint (value, nvenc->rc_lookahead);
      }
      break;
    case PROP_TEMPORAL_AQ:
      if (!device_caps->temporal_aq) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        g_value_set_boolean (value, nvenc->temporal_aq);
      }
      break;
    case PROP_BFRAMES:
      if (!device_caps->bframes) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        g_value_set_uint (value, nvenc->bframes);
      }
      break;
    case PROP_B_ADAPT:
      if (!device_caps->bframes) {
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      } else {
        g_value_set_boolean (value, nvenc->b_adapt);
      }
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

void
gst_nv_h265_enc_register (GstPlugin * plugin, guint device_id, guint rank,
    GstCaps * sink_caps, GstCaps * src_caps, GstNvEncDeviceCaps * device_caps)
{
  GType parent_type;
  GType type;
  gchar *type_name;
  gchar *feature_name;
  GstNvH265EncClassData *cdata;
  gboolean is_default = TRUE;
  GTypeInfo type_info = {
    sizeof (GstNvH265EncClass),
    NULL,
    NULL,
    (GClassInitFunc) gst_nv_h265_enc_class_init,
    NULL,
    NULL,
    sizeof (GstNvH265Enc),
    0,
    (GInstanceInitFunc) gst_nv_h265_enc_init,
  };

  parent_type = gst_nv_base_enc_register ("H265", device_id, device_caps);

  cdata = g_new0 (GstNvH265EncClassData, 1);
  cdata->sink_caps = gst_caps_ref (sink_caps);
  cdata->src_caps = gst_caps_ref (src_caps);
  type_info.class_data = cdata;
  /* class data will be leaked if the element never gets instantiated */
  GST_MINI_OBJECT_FLAG_SET (sink_caps, GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
  GST_MINI_OBJECT_FLAG_SET (src_caps, GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);

  type_name = g_strdup ("GstNvH265Enc");
  feature_name = g_strdup ("nvh265enc");

  if (g_type_from_name (type_name) != 0) {
    g_free (type_name);
    g_free (feature_name);
    type_name = g_strdup_printf ("GstNvH265Device%dEnc", device_id);
    feature_name = g_strdup_printf ("nvh265device%denc", device_id);
    is_default = FALSE;
  }

  cdata->is_default = is_default;
  type = g_type_register_static (parent_type, type_name, &type_info, 0);

  /* make lower rank than default device */
  if (rank > 0 && !is_default)
    rank--;

  if (!gst_element_register (plugin, feature_name, rank, type))
    GST_WARNING ("Failed to register plugin '%s'", type_name);

  g_free (type_name);
  g_free (feature_name);
}