/* GStreamer
 *  Copyright (C) <2024> V-Nova International Limited
 *
 * 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 <math.h>

#include <gst/codecparsers/gstlcevcmeta.h>

#include <lcevc_eil.h>

#include "gstlcevcencoder.h"
#include "gstlcevcencoderutils.h"

GST_DEBUG_CATEGORY_STATIC (lcevcencoder_debug);
#define GST_CAT_DEFAULT (lcevcencoder_debug)

#define DEFAULT_MIN_BITRATE 0
#define DEFAULT_MAX_BITRATE 2048000
#define DEFAULT_BITRATE 0
#define DEFAULT_SEI_LCEVC TRUE
#define DEFAULT_MIN_GOP_LENGTH -2
#define DEFAULT_GOP_LENGTH -2
#define DEFAULT_DEBUG FALSE

/* The max number of frames the encoder can receive without encoding a frame */
#define MAX_DELAYED_FRAMES 65

struct GstEILContext_
{
  grefcount ref;
  EILContext context;
};
typedef struct GstEILContext_ GstEILContext;

static void
log_callback (void *userdata, int32_t level, const char *msg)
{
  GstLcevcEncoder *eil = GST_LCEVC_ENCODER (userdata);
  gchar *new_msg = NULL;

  if (strlen (msg) <= 1)
    return;

  /* Remove \n from msg */
  new_msg = g_strdup (msg);
  new_msg[strlen (msg) - 1] = '\0';

  switch (level) {
    case EIL_LL_Error:
      GST_ERROR_OBJECT (eil, "EIL: %s", new_msg);
      break;
    case EIL_LL_Warning:
      GST_WARNING_OBJECT (eil, "EIL: %s", new_msg);
      break;
    case EIL_LL_Info:
      GST_INFO_OBJECT (eil, "EIL: %s", new_msg);
      break;
    case EIL_LL_Debug:
      GST_DEBUG_OBJECT (eil, "EIL: %s", new_msg);
      break;
    case EIL_LL_Verbose:
      GST_TRACE_OBJECT (eil, "EIL: %s", new_msg);
      break;
    default:
      break;
  }

  g_clear_pointer (&new_msg, g_free);
}

static GstEILContext *
gst_eil_context_new (GstLcevcEncoder * eil, const gchar * plugin_name,
    gboolean debug)
{
  GstEILContext *ctx = g_new0 (GstEILContext, 1);
  EILOpenSettings settings;
  EILReturnCode rc;

  g_return_val_if_fail (plugin_name, NULL);

  /* Initialize settings to default values */
  rc = EIL_OpenSettingsDefault (&settings);
  if (rc != EIL_RC_Success)
    return NULL;

  /* Set settings */
  settings.base_encoder = plugin_name;
  if (debug) {
    settings.log_callback = log_callback;
    settings.log_userdata = eil;
  }

  /* Open EIL context */
  if ((rc = EIL_Open (&settings, &ctx->context)) != EIL_RC_Success)
    return NULL;

  /* Init refcount */
  g_ref_count_init (&ctx->ref);
  return ctx;
}

static void
gst_eil_context_unref (GstEILContext * ctx)
{
  if (g_ref_count_dec (&ctx->ref)) {
    EIL_Close (ctx->context);
    g_free (ctx);
  }
}

static GstEILContext *
gst_eil_context_ref (GstEILContext * ctx)
{
  g_ref_count_inc (&ctx->ref);
  return ctx;
}

typedef struct
{
  GstEILContext *ctx;
  EILOutput *output;
} OutputData;

static OutputData *
output_data_new (GstEILContext * ctx, EILOutput * output)
{
  OutputData *data = g_new0 (OutputData, 1);
  data->ctx = gst_eil_context_ref (ctx);
  data->output = output;
  return data;
}

static void
output_data_free (gpointer p)
{
  OutputData *data = p;
  EIL_ReleaseOutput (data->ctx->context, data->output);
  g_clear_pointer (&data->ctx, gst_eil_context_unref);
  g_free (data);
}

enum
{
  PROP_0,
  PROP_PLUGIN_NAME,
  PROP_PLUGIN_PROPS,
  PROP_BITRATE,
  PROP_SEI_LCEVC,
  PROP_GOP_LENGTH,
  PROP_DEBUG,
};

typedef struct
{
  /* Props */
  gchar *plugin_name;
  gchar *plugin_props;
  guint bitrate;
  gboolean sei_lcevc;
  gint gop_length;
  gboolean debug;

  /* EIL */
  GstEILContext *ctx;
  GHashTable *plugin_props_spec;

  /* Input info */
  GstVideoInfo in_info;
  EILColourFormat in_format;
  EILFrameType in_frame_type;

  GstClockTime out_ts_offset;
} GstLcevcEncoderPrivate;

#define gst_lcevc_encoder_parent_class parent_class
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GstLcevcEncoder, gst_lcevc_encoder,
    GST_TYPE_VIDEO_ENCODER,
    G_ADD_PRIVATE (GstLcevcEncoder);
    GST_DEBUG_CATEGORY_INIT (lcevcencoder_debug, "lcevcencoder", 0,
        "lcevcencoder"));

static GstStaticPadTemplate gst_lcevc_encoder_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE
        (GST_LCEVC_ENCODER_UTILS_SUPPORTED_FORMATS))
    );

static void
gst_lcevc_encoder_finalize (GObject * obj)
{
  GstLcevcEncoder *eil = GST_LCEVC_ENCODER (obj);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);

  g_clear_pointer (&priv->plugin_name, g_free);
  g_clear_pointer (&priv->plugin_props, g_free);

  G_OBJECT_CLASS (parent_class)->finalize (obj);
}

static void
gst_lcevc_encoder_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstLcevcEncoder *self = GST_LCEVC_ENCODER (object);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (self);

  switch (prop_id) {
    case PROP_PLUGIN_NAME:
      g_clear_pointer (&priv->plugin_name, g_free);
      priv->plugin_name = g_value_dup_string (value);
      break;
    case PROP_PLUGIN_PROPS:
      g_clear_pointer (&priv->plugin_props, g_free);
      priv->plugin_props = g_value_dup_string (value);
      break;
    case PROP_BITRATE:
      priv->bitrate = g_value_get_uint (value);
      break;
    case PROP_SEI_LCEVC:
      priv->sei_lcevc = g_value_get_boolean (value);
      break;
    case PROP_GOP_LENGTH:
      priv->gop_length = g_value_get_int (value);
      break;
    case PROP_DEBUG:
      priv->debug = g_value_get_boolean (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_lcevc_encoder_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstLcevcEncoder *self = GST_LCEVC_ENCODER (object);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (self);

  switch (prop_id) {
    case PROP_PLUGIN_NAME:
      g_value_set_string (value, priv->plugin_name);
      break;
    case PROP_PLUGIN_PROPS:
      g_value_set_string (value, priv->plugin_props);
      break;
    case PROP_BITRATE:
      g_value_set_uint (value, priv->bitrate);
      break;
    case PROP_SEI_LCEVC:
      g_value_set_boolean (value, priv->sei_lcevc);
      break;
    case PROP_GOP_LENGTH:
      g_value_set_int (value, priv->gop_length);
      break;
    case PROP_DEBUG:
      g_value_set_boolean (value, priv->debug);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static GHashTable *
get_plugin_props_spec (GstEILContext * ctx, const gchar * plugin_name)
{
  EILReturnCode rc;
  GHashTable *res;
  EILPropertyGroups groups;

  rc = EIL_QueryPropertyGroups (ctx->context, &groups);
  if (rc != EIL_RC_Success)
    return NULL;

  res = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

  for (guint32 i = 0; i < groups.group_count; i++) {
    EILPropertyGroup *group = &groups.group[i];

    for (guint32 j = 0; j < group->property_count; j++) {
      EILProperty *property = &group->properties[j];
      g_hash_table_insert (res, g_strdup (property->name),
          GINT_TO_POINTER (property->type));
    }
  }

  return res;
}

static gboolean
open_eil_context (GstLcevcEncoder * eil)
{
  GstLcevcEncoderClass *klass = GST_LCEVC_ENCODER_GET_CLASS (eil);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);
  const gchar *plugin_name;

  g_return_val_if_fail (!priv->ctx, FALSE);

  /* Get the plugin name */
  if (priv->plugin_name)
    plugin_name = priv->plugin_name;
  else if (klass->get_eil_plugin_name)
    plugin_name = klass->get_eil_plugin_name (eil);
  else
    return FALSE;

  /* Create the EIL context */
  priv->ctx = gst_eil_context_new (eil, plugin_name, priv->debug);
  if (!priv->ctx)
    return FALSE;

  /* Get the plugin properties spec */
  priv->plugin_props_spec = get_plugin_props_spec (priv->ctx, plugin_name);
  if (!priv->plugin_props_spec) {
    g_clear_pointer (&priv->ctx, gst_eil_context_unref);
    return FALSE;
  }

  return TRUE;
}

static void
close_eil_context (GstLcevcEncoder * eil)
{
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);

  /* Flush */
  EIL_Encode (priv->ctx->context, NULL);

  /* Clear properties spec */
  g_clear_pointer (&priv->plugin_props_spec, g_hash_table_unref);

  /* Clear context */
  g_clear_pointer (&priv->ctx, gst_eil_context_unref);
}

static gboolean
gst_lcevc_encoder_start (GstVideoEncoder * encoder)
{
  GstLcevcEncoder *eil = GST_LCEVC_ENCODER (encoder);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);

  /* Open EIL context */
  if (!open_eil_context (eil)) {
    GST_ELEMENT_ERROR (encoder, LIBRARY, INIT, (NULL),
        ("Couldn't initialize EIL context"));
    return FALSE;
  }

  /* Reset out TS offset */
  priv->out_ts_offset = 0;

  return TRUE;
}

static gboolean
gst_lcevc_encoder_stop (GstVideoEncoder * encoder)
{
  GstLcevcEncoder *eil = GST_LCEVC_ENCODER (encoder);

  /* Close EIL context */
  close_eil_context (eil);

  return TRUE;
}

static gboolean
try_parse_number (const char *value, double *parsed)
{
  char *endptr;

  /* Skip leading spaces */
  while (g_ascii_isspace (*value))
    value++;

  /* Parse number */
  *parsed = g_strtod (value, &endptr);

  /* Allow trailing spaces */
  while (g_ascii_isspace (*endptr))
    value++;

  /* Ceck no extra characters after number and spaces */
  if (*endptr != '\0')
    return FALSE;

  return TRUE;
}

static GString *
build_json_props (GstLcevcEncoder * eil)
{
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);
  gchar *key_value;
  GString *res = g_string_new ("{");

  /* I/O props */
  if (priv->sei_lcevc) {
    /* separate_output=false */
    g_string_append_printf (res, "\"%s\"", "separate_output");
    g_string_append (res, ":");
    g_string_append (res, "false");
  } else {
    /* separate_output=true */
    g_string_append_printf (res, "\"%s\"", "separate_output");
    g_string_append (res, ": ");
    g_string_append (res, "true");
    g_string_append (res, ", ");
    /* output_format=raw */
    g_string_append_printf (res, "\"%s\"", "output_format");
    g_string_append (res, ": ");
    g_string_append_printf (res, "\"%s\"", "raw");
  }

  if (!priv->plugin_props)
    goto done;

  /* Plugin props */
  key_value = strtok (priv->plugin_props, ";");
  while (key_value != NULL) {
    const gchar *val_str = strchr (key_value, '=');
    if (val_str) {
      gsize key_size = val_str - key_value;
      if (key_size > 0) {
        gchar *key = g_strndup (key_value, key_size);
        gpointer p = g_hash_table_lookup (priv->plugin_props_spec, key);

        /* Add key */
        g_string_append (res, ", ");
        g_string_append_printf (res, "\"%s\"", key);
        g_string_append (res, ": ");

        /* Convert value to type defined by spec and add it, otherwise add the
         * value as it is */
        if (p) {
          EILPropertyType spec = GPOINTER_TO_INT (p);

          switch (spec) {
            case EIL_PT_Int8:
            case EIL_PT_Int16:
            case EIL_PT_Int32:
            case EIL_PT_Int64:{
              gint64 val = g_ascii_strtoll (val_str + 1, NULL, 10);
              g_string_append_printf (res, "%" G_GINT64_FORMAT, val);
              break;
            }
            case EIL_PT_Uint8:
            case EIL_PT_Uint16:
            case EIL_PT_Uint32:
            case EIL_PT_Uint64:{
              guint64 val = g_ascii_strtoull (val_str + 1, NULL, 10);
              g_string_append_printf (res, "%" G_GUINT64_FORMAT, val);
              break;
            }
            case EIL_PT_Float:
            case EIL_PT_Double:{
              double val = g_ascii_strtod (val_str + 1, NULL);
              g_string_append_printf (res, "%f", val);
              break;
            }
            case EIL_PT_Boolean:{
              if (g_str_equal (val_str + 1, "TRUE") ||
                  g_str_equal (val_str + 1, "True") ||
                  g_str_equal (val_str + 1, "true") ||
                  g_str_equal (val_str + 1, "1"))
                g_string_append (res, "true");
              else
                g_string_append (res, "false");
              break;
            }
            case EIL_PT_String:
            default:
              g_string_append_printf (res, "\"%s\"", val_str + 1);
              break;
          }
        } else {
          double val;
          if (try_parse_number (val_str + 1, &val)) {
            if (val == ceil (val))
              g_string_append_printf (res, "%d", (gint) val);
            else
              g_string_append_printf (res, "%f", val);
          } else {
            g_string_append_printf (res, "\"%s\"", val_str + 1);
          }
        }

        g_free (key);
      } else {
        GST_WARNING_OBJECT (eil, "Key value pair %s does not have key",
            key_value);
        goto error;
      }
    } else {
      GST_WARNING_OBJECT (eil, "Key value pair %s does not have '=' char",
          key_value);
      goto error;
    }

    key_value = strtok (NULL, ";");
  }

done:
  res = g_string_append (res, "}");
  return res;

error:
  g_string_free (res, TRUE);
  return NULL;
}

static void
on_encoded_output (void *data, EILOutput * output)
{
  GstLcevcEncoder *eil = GST_LCEVC_ENCODER (data);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);
  GstVideoCodecFrame *frame;
  GstClockTime pts;

  if (!output) {
    GST_INFO_OBJECT (eil, "All EIL Pictures processed");
    return;
  }

  frame = output->user_data;
  pts = frame->input_buffer->pts;

  GST_INFO_OBJECT (eil, "Received output frame %" GST_TIME_FORMAT
      " with lcevc size %u", GST_TIME_ARGS (pts), output->lcevc_length);

  /* The EIL DTS can be negative, we need to do the conversion so it can be
   * stored in a GstClockTime (guint64). The EIL PTS can never be negative
   * because it is set using the input buffer PTS, which is a GstClockTime. */
  if (output->dts < 0 && priv->out_ts_offset == 0) {
    priv->out_ts_offset = -1 * output->dts;
    GST_INFO_OBJECT (eil, "Output DTS offset set to %" GST_TIME_FORMAT,
        GST_TIME_ARGS (priv->out_ts_offset));
  }

  /* Created output buffer with output data */
  frame->output_buffer = gst_buffer_new_wrapped_full (0,
      (gpointer) output->data, output->data_length, 0, output->data_length,
      output_data_new (priv->ctx, output), output_data_free);
  frame->pts = priv->out_ts_offset + output->pts;
  frame->dts = priv->out_ts_offset + output->dts;

  /* Add LCEVC metadata to output buffer if present */
  if (output->lcevc_length > 0) {
    GstBuffer *lcevc_data = gst_buffer_new_memdup ((gpointer) output->lcevc,
        output->lcevc_length);
    gst_buffer_add_lcevc_meta (frame->output_buffer, lcevc_data);
    gst_buffer_unref (lcevc_data);
  }

  /* Set Delta unit flag if this is not a key frame */
  if (!output->keyframe)
    GST_BUFFER_FLAG_SET (frame->output_buffer, GST_BUFFER_FLAG_DELTA_UNIT);
  else
    GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);

  gst_video_encoder_finish_frame (GST_VIDEO_ENCODER (eil), frame);
}

static void
gst_lcevc_encoder_set_latency (GstLcevcEncoder * eil, GstVideoInfo * info)
{
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);
  gint delayed_frames;
  GstClockTime latency;

  /* The GOP affects the number of delayed frames */
  if (priv->gop_length == -2 || priv->gop_length == -1)
    delayed_frames = MAX_DELAYED_FRAMES;
  else
    delayed_frames = MIN (5 + priv->gop_length, MAX_DELAYED_FRAMES);

  latency =
      gst_util_uint64_scale_ceil (GST_SECOND * GST_VIDEO_INFO_FPS_D (info),
      delayed_frames, GST_VIDEO_INFO_FPS_N (info));
  gst_video_encoder_set_latency (GST_VIDEO_ENCODER (eil), latency, latency);

  GST_INFO_OBJECT (eil, "Updated latency to %" GST_TIME_FORMAT " (%d frames)",
      GST_TIME_ARGS (latency), delayed_frames);
}

static gboolean
gst_lcevc_encoder_set_format (GstVideoEncoder * encoder,
    GstVideoCodecState * state)
{
  GstLcevcEncoder *eil = GST_LCEVC_ENCODER (encoder);
  GstLcevcEncoderClass *klass = GST_LCEVC_ENCODER_GET_CLASS (eil);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);
  EILInitSettings settings;
  GString *properties_json;
  GstVideoInterlaceMode interlace_mode;
  EILReturnCode rc;
  GstCaps *outcaps;
  GstVideoCodecState *s;
  gint width = GST_VIDEO_INFO_WIDTH (&state->info);
  gint height = GST_VIDEO_INFO_HEIGHT (&state->info);

  /* Set input info, format and frame type */
  priv->in_info = state->info;
  priv->in_format =
      gst_lcevc_encoder_utils_get_color_format (GST_VIDEO_INFO_FORMAT
      (&state->info));
  interlace_mode = GST_VIDEO_INFO_INTERLACE_MODE (&state->info);
  switch (interlace_mode) {
    case GST_VIDEO_INTERLACE_MODE_PROGRESSIVE:
      priv->in_frame_type = EIL_FrameType_Progressive;
      break;
    case GST_VIDEO_INTERLACE_MODE_INTERLEAVED:
      priv->in_frame_type = EIL_FrameType_Interlaced;
      break;
    case GST_VIDEO_INTERLACE_MODE_FIELDS:
      priv->in_frame_type = EIL_FrameType_Field;
      break;
    default:
      GST_ELEMENT_ERROR (eil, STREAM, FORMAT, (NULL),
          ("Interlace mode %s not supported",
              gst_video_interlace_mode_to_string (interlace_mode)));
      return FALSE;
  }

  /* Init EIL Settings to default values */
  rc = EIL_InitSettingsDefault (&settings);
  if (rc != EIL_RC_Success) {
    GST_ELEMENT_ERROR (eil, LIBRARY, INIT, (NULL),
        ("Unabled to initialize EIL Settings"));
    return FALSE;
  }

  /* Set basic EIL settings */
  settings.color_format = priv->in_format;
  settings.memory_type = EIL_MT_Host;
  settings.width = width;
  settings.height = height;
  settings.fps_num = GST_VIDEO_INFO_FPS_N (&state->info);
  settings.fps_denom = GST_VIDEO_INFO_FPS_D (&state->info);
  settings.bitrate = priv->bitrate;
  settings.gop_length = priv->gop_length;
  settings.external_input = 1;

  /* Set properties JSON EIL setting */
  properties_json = build_json_props (eil);
  if (!properties_json) {
    GST_ELEMENT_ERROR (eil, RESOURCE, SETTINGS, (NULL),
        ("Could not parse plugin properties to JSON"));
    return FALSE;
  }
  settings.properties_json = properties_json->str;
  GST_INFO_OBJECT (eil, "Properties JSON: %s", properties_json->str);

  /* Initialize EIL */
  rc = EIL_Initialise (priv->ctx->context, &settings);
  g_string_free (properties_json, TRUE);
  if (rc != EIL_RC_Success)
    return FALSE;

  /* Get output caps */
  g_assert (klass->get_output_caps);
  outcaps = klass->get_output_caps (eil);
  if (!outcaps) {
    GST_ELEMENT_ERROR (eil, RESOURCE, NOT_FOUND, (NULL),
        ("Could not get output caps"));
    return FALSE;
  }

  /* Set width, height and pixel aspect ration.
   * The values from settings are updated to base width and height after
   * initialization.
   */
  if (width != settings.width || height != settings.height) {
    GST_VIDEO_INFO_WIDTH (&state->info) = settings.width;
    GST_VIDEO_INFO_HEIGHT (&state->info) = settings.height;
    /* If changed, the new width and height values are always half of what they
     * used to be, so update the pixel aspect ratio accordingly */
    GST_VIDEO_INFO_PAR_N (&state->info) = width > settings.width ? 2 : 1;
    GST_VIDEO_INFO_PAR_D (&state->info) = height > settings.height ? 2 : 1;
    GST_INFO_OBJECT (eil,
        "Base resolution changed: w=%d h=%d -> w=%d h=%d (par_n=%d, par_d=%d)",
        width, height, settings.width, settings.height,
        GST_VIDEO_INFO_PAR_N (&state->info),
        GST_VIDEO_INFO_PAR_D (&state->info));
  }

  /* Set output state */
  s = gst_video_encoder_set_output_state (encoder, outcaps, state);
  if (!s) {
    GST_ELEMENT_ERROR (eil, STREAM, FORMAT, (NULL),
        ("Could not set output state"));
    return FALSE;
  }

  /* Set output callback */
  EIL_SetOnEncodedCallback (priv->ctx->context, eil, on_encoded_output);

  /* Update latency */
  gst_lcevc_encoder_set_latency (eil, &s->info);

  gst_video_codec_state_unref (s);
  return TRUE;
}

static gboolean
gst_lcevc_encoder_sink_event (GstVideoEncoder * encoder, GstEvent * event)
{
  GstLcevcEncoder *eil = GST_LCEVC_ENCODER (encoder);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);

  switch (GST_EVENT_TYPE (event)) {
    case GST_EVENT_EOS:
      /* Flush on EOS */
      GST_INFO_OBJECT (eil, "EOS received, flushing encoder");
      EIL_Encode (priv->ctx->context, NULL);
      break;

    default:
      break;
  }

  return GST_VIDEO_ENCODER_CLASS (parent_class)->sink_event (encoder, event);
}

static GstFlowReturn
gst_lcevc_encoder_handle_frame (GstVideoEncoder * encoder,
    GstVideoCodecFrame * frame)
{
  GstLcevcEncoder *eil = GST_LCEVC_ENCODER (encoder);
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);
  GstClockTime pts = frame->input_buffer->pts;
  GstVideoFrame video_frame = { 0, };
  EILPicture picture;

  /* Map the input buffer */
  if (!gst_video_frame_map (&video_frame, &priv->in_info, frame->input_buffer,
          GST_MAP_READ)) {
    GST_ELEMENT_ERROR (eil, STREAM, ENCODE, (NULL),
        ("Could not map input buffer %" GST_TIME_FORMAT, GST_TIME_ARGS (pts)));
    goto error;
  }

  /* Initialize EIL picture */
  if (EIL_InitPictureDefault (&picture) != EIL_RC_Success) {
    GST_ELEMENT_ERROR (eil, STREAM, ENCODE, (NULL),
        ("Could not initialize EIL picture %" GST_TIME_FORMAT,
            GST_TIME_ARGS (pts)));
    goto error;
  }

  /* Set frame values on EIL picture */
  if (!gst_lcevc_encoder_utils_init_eil_picture (priv->in_frame_type,
          &video_frame, pts, &picture)) {
    GST_ELEMENT_ERROR (eil, STREAM, ENCODE, (NULL),
        ("Could not set frame values on EIL picture %" GST_TIME_FORMAT,
            GST_TIME_ARGS (pts)));
    goto error;
  }

  /* Set input frame as user data. This will be set in the encoded output as
   * user data, which will help us getting the associated frame */
  picture.user_data = frame;

  /* Encode frame */
  if (EIL_Encode (priv->ctx->context, &picture) != EIL_RC_Success) {
    GST_ELEMENT_ERROR (eil, STREAM, ENCODE, (NULL),
        ("Could not encode input frame %" GST_TIME_FORMAT,
            GST_TIME_ARGS (pts)));
    goto error;
  }

  GST_INFO_OBJECT (eil, "Sent input frame %" GST_TIME_FORMAT,
      GST_TIME_ARGS (pts));

  gst_video_frame_unmap (&video_frame);
  return GST_FLOW_OK;

error:
  gst_video_frame_unmap (&video_frame);
  return GST_FLOW_ERROR;
}

static void
gst_lcevc_encoder_class_init (GstLcevcEncoderClass * klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
  GstVideoEncoderClass *video_encoder_class = GST_VIDEO_ENCODER_CLASS (klass);

  gst_element_class_add_static_pad_template (element_class,
      &gst_lcevc_encoder_sink_template);

  gst_type_mark_as_plugin_api (GST_TYPE_LCEVC_ENCODER, 0);

  gobject_class->finalize = gst_lcevc_encoder_finalize;
  gobject_class->set_property = gst_lcevc_encoder_set_property;
  gobject_class->get_property = gst_lcevc_encoder_get_property;

  video_encoder_class->start = gst_lcevc_encoder_start;
  video_encoder_class->stop = gst_lcevc_encoder_stop;
  video_encoder_class->set_format = gst_lcevc_encoder_set_format;
  video_encoder_class->sink_event = gst_lcevc_encoder_sink_event;
  video_encoder_class->handle_frame = gst_lcevc_encoder_handle_frame;

  g_object_class_install_property (gobject_class, PROP_PLUGIN_NAME,
      g_param_spec_string ("plugin-name", "Plugin Name",
          "The name of the EIL plugin to use (NULL = auto)",
          NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_PLUGIN_PROPS,
      g_param_spec_string ("plugin-props", "Plugin Props",
          "A semi-colon list of key value pair properties for the EIL plugin",
          NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_BITRATE,
      g_param_spec_uint ("bitrate", "Bitrate",
          "Bitrate in kbit/sec (0 = auto)",
          DEFAULT_MIN_BITRATE, DEFAULT_MAX_BITRATE, DEFAULT_BITRATE,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_SEI_LCEVC,
      g_param_spec_boolean ("sei-lcevc", "SEI LCEVC",
          "Whether to have LCEVC data as SEI (in the video stream) or not (attached to buffers as GstMeta)",
          DEFAULT_SEI_LCEVC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_GOP_LENGTH,
      g_param_spec_int ("gop-length", "GOP Length",
          "The group of pictures length (-2 = auto, -1 = infinite, 0 = intra-only)",
          DEFAULT_MIN_GOP_LENGTH, INT_MAX, DEFAULT_GOP_LENGTH,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_DEBUG,
      g_param_spec_boolean ("debug", "Debug",
          "Whether to show EIL SDK logs or not",
          DEFAULT_DEBUG, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

static void
gst_lcevc_encoder_init (GstLcevcEncoder * eil)
{
  GstLcevcEncoderPrivate *priv = gst_lcevc_encoder_get_instance_private (eil);

  /* Props */
  priv->plugin_name = NULL;
  priv->plugin_props = NULL;
  priv->bitrate = DEFAULT_BITRATE;
  priv->sei_lcevc = DEFAULT_SEI_LCEVC;
  priv->gop_length = DEFAULT_GOP_LENGTH;
}
