gstreamer/ext/xvid/gstxvidenc.c

/* GStreamer xvid encoder plugin
 * Copyright (C) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
 *           (C) 2006 Mark Nauwelaerts <manauw@skynet.be>
 *
 * 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., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/* based on:
 * - the original xvidenc (by Ronald Bultje)
 * - transcode/mplayer's xvid encoder (by Edouard Gomez)
 *
 * TODO some documentation (e.g. on properties)
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string.h>

#include <xvid.h>

#include <gst/video/video.h>
#include "gstxvidenc.h"

static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("{ I420, YUY2, YV12, YVYU, UYVY }")
        "; " RGB_24_32_STATIC_CAPS (32, 0x00ff0000, 0x0000ff00,
            0x000000ff) "; " RGB_24_32_STATIC_CAPS (32, 0xff000000, 0x00ff0000,
            0x0000ff00) "; " RGB_24_32_STATIC_CAPS (32, 0x0000ff00, 0x00ff0000,
            0xff000000) "; " RGB_24_32_STATIC_CAPS (32, 0x000000ff, 0x0000ff00,
            0x00ff0000) "; " RGB_24_32_STATIC_CAPS (24, 0x0000ff, 0x00ff00,
            0xff0000) "; " GST_VIDEO_CAPS_RGB_15 "; " GST_VIDEO_CAPS_RGB_16)
    );

static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("video/x-xvid, "
        "width = (int) [ 0, MAX ], "
        "height = (int) [ 0, MAX ], " "framerate = (fraction) [ 0/1, MAX ]; "
        "video/mpeg, "
        "mpegversion = (int) 4, "
        "systemstream = (boolean) FALSE, "
        "width = (int) [ 0, MAX ], "
        "height = (int) [ 0, MAX ], " "framerate = (fraction) [ 0/1, MAX ]")
    );


/* XvidEnc properties */

/* maximum property-id */
static int xvidenc_prop_count;

/* quark used for named pointer on param specs */
static GQuark xvidenc_pspec_quark;

GST_DEBUG_CATEGORY_STATIC (xvidenc_debug);
#define GST_CAT_DEFAULT xvidenc_debug

static void gst_xvidenc_base_init (GstXvidEncClass * klass);
static void gst_xvidenc_class_init (GstXvidEncClass * klass);
static void gst_xvidenc_init (GstXvidEnc * xvidenc);
static void gst_xvidenc_finalize (GObject * object);
static GstFlowReturn gst_xvidenc_chain (GstPad * pad, GstBuffer * data);
static gboolean gst_xvidenc_setcaps (GstPad * pad, GstCaps * vscapslist);
static void gst_xvidenc_flush_buffers (GstXvidEnc * xvidenc, gboolean send);
static gboolean gst_xvidenc_handle_sink_event (GstPad * pad, GstEvent * event);

/* properties */
static void gst_xvidenc_set_property (GObject * object,
    guint prop_id, const GValue * value, GParamSpec * pspec);
static void gst_xvidenc_get_property (GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec);
static GstStateChangeReturn gst_xvidenc_change_state (GstElement * element,
    GstStateChange transition);

static GstElementClass *parent_class = NULL;

#define GST_TYPE_XVIDENC_PROFILE (gst_xvidenc_profile_get_type ())
static GType
gst_xvidenc_profile_get_type (void)
{
  static GType xvidenc_profile_type = 0;

  if (!xvidenc_profile_type) {
    static const GEnumValue xvidenc_profiles[] = {
      {0, "UNP", "Unrestricted profile"},
      {XVID_PROFILE_S_L0, "S_L0", "Simple profile, L0"},
      {XVID_PROFILE_S_L1, "S_L1", "Simple profile, L1"},
      {XVID_PROFILE_S_L2, "S_L2", "Simple profile, L2"},
      {XVID_PROFILE_S_L3, "S_L3", "Simple profile, L3"},
      {XVID_PROFILE_ARTS_L1, "ARTS_L1",
          "Advanced real-time simple profile, L1"},
      {XVID_PROFILE_ARTS_L2, "ARTS_L2",
          "Advanced real-time simple profile, L2"},
      {XVID_PROFILE_ARTS_L3, "ARTS_L3",
          "Advanced real-time simple profile, L3"},
      {XVID_PROFILE_ARTS_L4, "ARTS_L4",
          "Advanced real-time simple profile, L4"},
      {XVID_PROFILE_AS_L0, "AS_L0", "Advanced simple profile, L0"},
      {XVID_PROFILE_AS_L1, "AS_L1", "Advanced simple profile, L1"},
      {XVID_PROFILE_AS_L2, "AS_L2", "Advanced simple profile, L2"},
      {XVID_PROFILE_AS_L3, "AS_L3", "Advanced simple profile, L3"},
      {XVID_PROFILE_AS_L4, "AS_L4", "Advanced simple profile, L4"},
      {0, NULL, NULL},
    };

    xvidenc_profile_type =
        g_enum_register_static ("GstXvidEncProfiles", xvidenc_profiles);
  }

  return xvidenc_profile_type;
}

#define GST_TYPE_XVIDENC_QUANT_TYPE (gst_xvidenc_quant_type_get_type ())
static GType
gst_xvidenc_quant_type_get_type (void)
{
  static GType xvidenc_quant_type_type = 0;

  if (!xvidenc_quant_type_type) {
    static const GEnumValue xvidenc_quant_types[] = {
      {0, "H263 quantization", "h263"},
      {XVID_VOL_MPEGQUANT, "MPEG quantization", "mpeg"},
      {0, NULL, NULL},
    };

    xvidenc_quant_type_type =
        g_enum_register_static ("GstXvidEncQuantTypes", xvidenc_quant_types);
  }

  return xvidenc_quant_type_type;
}


enum
{
  XVIDENC_CBR,
  XVIDENC_VBR_PASS1,
  XVIDENC_VBR_PASS2,
  XVIDENC_QUANT
};

#define GST_TYPE_XVIDENC_PASS (gst_xvidenc_pass_get_type ())
static GType
gst_xvidenc_pass_get_type (void)
{
  static GType xvidenc_pass_type = 0;

  if (!xvidenc_pass_type) {
    static const GEnumValue xvidenc_passes[] = {
      {XVIDENC_CBR, "Constant Bitrate Encoding", "cbr"},
      {XVIDENC_QUANT, "Constant Quantizer", "quant"},
      {XVIDENC_VBR_PASS1, "VBR Encoding - Pass 1", "pass1"},
      {XVIDENC_VBR_PASS2, "VBR Encoding - Pass 2", "pass2"},
      {0, NULL, NULL},
    };

    xvidenc_pass_type =
        g_enum_register_static ("GstXvidEncPasses", xvidenc_passes);
  }

  return xvidenc_pass_type;
}


GType
gst_xvidenc_get_type (void)
{
  static GType xvidenc_type = 0;

  if (!xvidenc_type) {
    static const GTypeInfo xvidenc_info = {
      sizeof (GstXvidEncClass),
      (GBaseInitFunc) gst_xvidenc_base_init,
      NULL,
      (GClassInitFunc) gst_xvidenc_class_init,
      NULL,
      NULL,
      sizeof (GstXvidEnc),
      0,
      (GInstanceInitFunc) gst_xvidenc_init,
    };
    const GInterfaceInfo preset_interface_info = {
      NULL,                     /* interface_init */
      NULL,                     /* interface_finalize */
      NULL                      /* interface_data */
    };

    xvidenc_type = g_type_register_static (GST_TYPE_ELEMENT,
        "GstXvidEnc", &xvidenc_info, 0);

    g_type_add_interface_static (xvidenc_type, GST_TYPE_PRESET,
        &preset_interface_info);
  }
  return xvidenc_type;
}

static void
gst_xvidenc_base_init (GstXvidEncClass * klass)
{
  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&sink_template));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&src_template));
  gst_element_class_set_details_simple (element_class, "XviD video encoder",
      "Codec/Encoder/Video",
      "XviD encoder based on xvidcore",
      "Ronald Bultje <rbultje@ronald.bitfreak.net>");
}

/* add property pspec to klass using the counter count,
 * and place info based on struct_type and member as a named pointer
 * specified by quark */
#define gst_xvidenc_add_pspec_full(klass, pspec, count, quark,          \
    struct_type, member)                                                \
G_STMT_START {                                                          \
  guint _offset = G_STRUCT_OFFSET (struct_type, member);                \
  g_param_spec_set_qdata (pspec, quark,                                 \
      GUINT_TO_POINTER (_offset));                                      \
  g_object_class_install_property (klass, ++count, pspec);              \
} G_STMT_END

#define gst_xvidenc_add_pspec(klass, pspec, member)                     \
  gst_xvidenc_add_pspec_full (klass, pspec, xvidenc_prop_count,         \
      xvidenc_pspec_quark, GstXvidEnc, member)

/* using the above system, property maintenance is centralized here
 * (_get_property, _set_property and setting of default value in _init)
 * follow automatically, it only remains to actually use it in the code
 * (which may include free-ing in finalize) */

static void
gst_xvidenc_class_init (GstXvidEncClass * klass)
{
  GstElementClass *gstelement_class;
  GObjectClass *gobject_class;
  GParamSpec *pspec;

  gobject_class = G_OBJECT_CLASS (klass);
  gstelement_class = GST_ELEMENT_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  GST_DEBUG_CATEGORY_INIT (xvidenc_debug, "xvidenc", 0, "XviD encoder");

  gobject_class->finalize = gst_xvidenc_finalize;

  gobject_class->set_property = gst_xvidenc_set_property;
  gobject_class->get_property = gst_xvidenc_get_property;

  /* prop handling */
  xvidenc_prop_count = 0;
  xvidenc_pspec_quark = g_quark_from_static_string ("xvid-enc-param-spec-data");

  pspec = g_param_spec_enum ("profile", "Profile",
      "XviD/MPEG-4 encoding profile",
      GST_TYPE_XVIDENC_PROFILE, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, profile);

  pspec = g_param_spec_enum ("quant-type", "Quantizer Type",
      "Quantizer type", GST_TYPE_XVIDENC_QUANT_TYPE, 0,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, quant_type);

  pspec = g_param_spec_enum ("pass", "Encoding pass/type",
      "Encoding pass/type",
      GST_TYPE_XVIDENC_PASS, XVIDENC_CBR,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, pass);

  pspec = g_param_spec_int ("bitrate", "Bitrate",
      "[CBR|PASS2] Target video bitrate (bps)",
      0, G_MAXINT, 1800000, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, bitrate);

  pspec = g_param_spec_int ("quantizer", "Quantizer",
      "[QUANT] Quantizer to apply for constant quantizer mode",
      2, 31, 2, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, quant);

  pspec = g_param_spec_string ("statsfile", "Statistics Filename",
      "[PASS1|PASS2] Filename to store data for 2-pass encoding",
      "xvid-stats.log", G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, filename);

  pspec = g_param_spec_int ("max-key-interval", "Max. Key Interval",
      "Maximum number of frames between two keyframes (< 0 is in sec)",
      -100, G_MAXINT, -10, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, max_key_interval);

  pspec = g_param_spec_boolean ("closed-gop", "Closed GOP",
      "Closed GOP", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, closed_gop);

  pspec = g_param_spec_int ("motion", "ME Quality",
      "Quality of Motion Estimation", 0, 6, 6,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, motion);

  pspec = g_param_spec_boolean ("me-chroma", "ME Chroma",
      "Enable use of Chroma planes for Motion Estimation",
      TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, me_chroma);

  pspec = g_param_spec_int ("me-vhq", "ME DCT/Frequency",
      "Extent in which to use DCT to minimize encoding length",
      0, 4, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, me_vhq);

  pspec = g_param_spec_boolean ("me-quarterpel", "ME Quarterpel",
      "Use quarter pixel precision for motion vector search",
      FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, me_quarterpel);

  pspec = g_param_spec_boolean ("lumimasking", "Lumimasking",
      "Enable lumimasking - apply more compression to dark or bright areas",
      FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, lumimasking);

  pspec = g_param_spec_int ("max-bframes", "Max B-Frames",
      "Maximum B-frames in a row", 0, G_MAXINT, 1,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, max_bframes);

  pspec = g_param_spec_int ("bquant-ratio", "B-quantizer ratio",
      "Ratio in B-frame quantizer computation", 0, 200, 150,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, bquant_ratio);

  pspec = g_param_spec_int ("bquant-offset", "B-quantizer offset",
      "Offset in B-frame quantizer computation",
      0, 200, 100, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, bquant_offset);

  pspec = g_param_spec_int ("bframe-threshold", "B-Frame Threshold",
      "Higher threshold yields more chance that B-frame is used",
      -255, 255, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, bframe_threshold);

  pspec = g_param_spec_boolean ("gmc", "Global Motion Compensation",
      "Allow generation of Sprite Frames for Pan/Zoom/Rotating images",
      FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, gmc);

  pspec = g_param_spec_boolean ("trellis", "Trellis Quantization",
      "Enable Trellis Quantization", FALSE,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, trellis);

  pspec = g_param_spec_boolean ("interlaced", "Interlaced Material",
      "Enable for interlaced video material", FALSE,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, interlaced);

  pspec = g_param_spec_boolean ("cartoon", "Cartoon Material",
      "Adjust thresholds for flat looking cartoons", FALSE,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, cartoon);

  pspec = g_param_spec_boolean ("greyscale", "Disable Chroma",
      "Do not write chroma data in encoded video", FALSE,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, greyscale);

  pspec = g_param_spec_boolean ("hqacpred", "High quality AC prediction",
      "Enable high quality AC prediction", TRUE,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, hqacpred);

  pspec = g_param_spec_int ("max-iquant", "Max Quant I-Frames",
      "Upper bound for I-frame quantization", 0, 31, 31,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, max_iquant);

  pspec = g_param_spec_int ("min-iquant", "Min Quant I-Frames",
      "Lower bound for I-frame quantization", 0, 31, 2,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, min_iquant);

  pspec = g_param_spec_int ("max-pquant", "Max Quant P-Frames",
      "Upper bound for P-frame quantization", 0, 31, 31,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, max_pquant);

  pspec = g_param_spec_int ("min-pquant", "Min Quant P-Frames",
      "Lower bound for P-frame quantization", 0, 31, 2,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, min_pquant);

  pspec = g_param_spec_int ("max-bquant", "Max Quant B-Frames",
      "Upper bound for B-frame quantization", 0, 31, 31,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, max_bquant);

  pspec = g_param_spec_int ("min-bquant", "Min Quant B-Frames",
      "Lower bound for B-frame quantization", 0, 31, 2,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, min_bquant);

  pspec = g_param_spec_int ("reaction-delay-factor", "Reaction Delay Factor",
      "[CBR] Reaction delay factor", -1, 100, -1,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, reaction_delay_factor);

  pspec = g_param_spec_int ("averaging-period", "Averaging Period",
      "[CBR] Number of frames for which XviD averages bitrate",
      -1, 100, -1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, averaging_period);

  pspec = g_param_spec_int ("buffer", "Buffer Size",
      "[CBR] Size of the video buffers", -1, G_MAXINT, -1,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, buffer);

  pspec = g_param_spec_int ("keyframe-boost", "Keyframe boost",
      "[PASS2] Bitrate boost for keyframes", 0, 100, 0,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, keyframe_boost);

  pspec = g_param_spec_int ("curve-compression-high", "Curve Compression High",
      "[PASS2] Shrink factor for upper part of bitrate curve",
      0, 100, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, curve_compression_high);

  pspec = g_param_spec_int ("curve-compression-low", "Curve Compression Low",
      "[PASS2] Growing factor for lower part of bitrate curve",
      0, 100, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, curve_compression_low);

  pspec = g_param_spec_int ("flow-control-strength", "Flow Control Strength",
      "[PASS2] Overflow control strength per frame",
      -1, 100, 5, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, overflow_control_strength);

  pspec =
      g_param_spec_int ("max-overflow-improvement", "Max Overflow Improvement",
      "[PASS2] Amount in % that flow control can increase frame size compared to ideal curve",
      -1, 100, 5, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, max_overflow_improvement);

  pspec =
      g_param_spec_int ("max-overflow-degradation", "Max Overflow Degradation",
      "[PASS2] Amount in % that flow control can decrease frame size compared to ideal curve",
      -1, 100, 5, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, max_overflow_degradation);

  pspec = g_param_spec_int ("keyframe-reduction", "Keyframe Reduction",
      "[PASS2] Keyframe size reduction in % of those within threshold",
      -1, 100, 20, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, kfreduction);

  pspec = g_param_spec_int ("keyframe-threshold", "Keyframe Threshold",
      "[PASS2] Distance between keyframes not to be subject to reduction",
      -1, 100, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, kfthreshold);

  pspec =
      g_param_spec_int ("container-frame-overhead", "Container Frame Overhead",
      "[PASS2] Average container overhead per frame", -1, 100, -1,
      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  gst_xvidenc_add_pspec (gobject_class, pspec, container_frame_overhead);

  gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_xvidenc_change_state);
}


static void
gst_xvidenc_init (GstXvidEnc * xvidenc)
{
  GParamSpec **pspecs;
  guint i, num_props;

  /* create the sink pad */
  xvidenc->sinkpad = gst_pad_new_from_static_template (&sink_template, "sink");
  gst_element_add_pad (GST_ELEMENT (xvidenc), xvidenc->sinkpad);

  gst_pad_set_chain_function (xvidenc->sinkpad,
      GST_DEBUG_FUNCPTR (gst_xvidenc_chain));
  gst_pad_set_setcaps_function (xvidenc->sinkpad,
      GST_DEBUG_FUNCPTR (gst_xvidenc_setcaps));
  gst_pad_set_event_function (xvidenc->sinkpad,
      GST_DEBUG_FUNCPTR (gst_xvidenc_handle_sink_event));

  /* create the src pad */
  xvidenc->srcpad = gst_pad_new_from_static_template (&src_template, "src");
  gst_element_add_pad (GST_ELEMENT (xvidenc), xvidenc->srcpad);
  gst_pad_use_fixed_caps (xvidenc->srcpad);

  /* init properties. */
  xvidenc->width = xvidenc->height = xvidenc->csp = -1;
  xvidenc->par_width = xvidenc->par_height = 1;

  /* set defaults for user properties */
  pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (xvidenc),
      &num_props);

  for (i = 0; i < num_props; ++i) {
    GValue val = { 0, };
    GParamSpec *pspec = pspecs[i];

    /* only touch those that are really ours; i.e. should have some qdata */
    if (!g_param_spec_get_qdata (pspec, xvidenc_pspec_quark))
      continue;
    g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));
    g_param_value_set_default (pspec, &val);
    g_object_set_property (G_OBJECT (xvidenc), g_param_spec_get_name (pspec),
        &val);
    g_value_unset (&val);
  }

  g_free (pspecs);

  /* set xvid handle to NULL */
  xvidenc->handle = NULL;

  /* get a queue to keep time info if frames get delayed */
  xvidenc->delay = NULL;

  /* cache some xvid data so need not rebuild for each frame */
  xvidenc->xframe_cache = NULL;
}


static void
gst_xvidenc_finalize (GObject * object)
{

  GstXvidEnc *xvidenc = GST_XVIDENC (object);

  g_free (xvidenc->filename);

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

static gboolean
gst_xvidenc_handle_sink_event (GstPad * pad, GstEvent * event)
{
  GstXvidEnc *xvidenc = GST_XVIDENC (GST_PAD_PARENT (pad));

  switch (GST_EVENT_TYPE (event)) {
    case GST_EVENT_EOS:
      gst_xvidenc_flush_buffers (xvidenc, TRUE);
      break;
      /* no flushing if flush received,
         buffers in encoder are considered (in the) past */
    default:
      break;
  }

  return gst_pad_push_event (xvidenc->srcpad, event);
}

static gboolean
gst_xvidenc_setup (GstXvidEnc * xvidenc)
{
  xvid_enc_create_t xenc;
  xvid_enc_plugin_t xplugin[2];
  gint ret;

  /* see xvid.h for the meaning of all this. */
  gst_xvid_init_struct (xenc);

  xenc.profile = xvidenc->profile;
  xenc.width = xvidenc->width;
  xenc.height = xvidenc->height;
  xenc.max_bframes = xvidenc->max_bframes;
  xenc.global = XVID_GLOBAL_PACKED
      | (xvidenc->closed_gop ? XVID_GLOBAL_CLOSED_GOP : 0);

  xenc.bquant_ratio = xvidenc->bquant_ratio;
  xenc.bquant_offset = xvidenc->bquant_offset;

  xenc.fbase = xvidenc->fbase;
  xenc.fincr = xvidenc->fincr;
  xenc.max_key_interval = (xvidenc->max_key_interval < 0) ?
      (-xvidenc->max_key_interval * xenc.fbase /
      xenc.fincr) : xvidenc->max_key_interval;
  xenc.handle = NULL;

  /* quantizer ranges */
  xenc.min_quant[0] = xvidenc->min_iquant;
  xenc.min_quant[1] = xvidenc->min_pquant;
  xenc.min_quant[2] = xvidenc->min_bquant;
  xenc.max_quant[0] = xvidenc->max_iquant;
  xenc.max_quant[1] = xvidenc->max_pquant;
  xenc.max_quant[2] = xvidenc->max_bquant;

  /* cbr, vbr or constant quantizer */
  xenc.num_plugins = 1;
  xenc.plugins = xplugin;
  switch (xvidenc->pass) {
    case XVIDENC_CBR:
    case XVIDENC_QUANT:
    {
      xvid_plugin_single_t xsingle;
      xvid_enc_zone_t xzone;

      gst_xvid_init_struct (xsingle);

      xenc.plugins[0].func = xvid_plugin_single;
      xenc.plugins[0].param = &xsingle;

      xsingle.bitrate = xvidenc->bitrate;
      xsingle.reaction_delay_factor = MAX (0, xvidenc->reaction_delay_factor);
      xsingle.averaging_period = MAX (0, xvidenc->averaging_period);
      xsingle.buffer = MAX (0, xvidenc->buffer);

      if (xvidenc->pass == XVIDENC_CBR)
        break;

      /* set up a const quantizer zone */
      xzone.mode = XVID_ZONE_QUANT;
      xzone.frame = 0;
      xzone.increment = xvidenc->quant;
      xzone.base = 1;
      xenc.zones = &xzone;
      xenc.num_zones++;

      break;
    }
    case XVIDENC_VBR_PASS1:
    {
      xvid_plugin_2pass1_t xpass;

      gst_xvid_init_struct (xpass);

      xenc.plugins[0].func = xvid_plugin_2pass1;
      xenc.plugins[0].param = &xpass;

      xpass.filename = xvidenc->filename;
      break;
    }
    case XVIDENC_VBR_PASS2:
    {
      xvid_plugin_2pass2_t xpass;

      gst_xvid_init_struct (xpass);

      xenc.plugins[0].func = xvid_plugin_2pass2;
      xenc.plugins[0].param = &xpass;

      xpass.bitrate = xvidenc->bitrate;
      xpass.filename = xvidenc->filename;
      xpass.keyframe_boost = xvidenc->keyframe_boost;
      xpass.curve_compression_high = xvidenc->curve_compression_high;
      xpass.curve_compression_low = xvidenc->curve_compression_low;
      xpass.overflow_control_strength =
          MAX (0, xvidenc->overflow_control_strength);
      xpass.max_overflow_improvement =
          MAX (0, xvidenc->max_overflow_improvement);
      xpass.max_overflow_degradation =
          MAX (0, xvidenc->max_overflow_degradation);
      xpass.kfreduction = MAX (0, xvidenc->kfreduction);
      xpass.kfthreshold = MAX (0, xvidenc->kfthreshold);
      xpass.container_frame_overhead =
          MAX (0, xvidenc->container_frame_overhead);
      break;
    }
  }

  if (xvidenc->lumimasking) {
    xenc.plugins[1].func = xvid_plugin_lumimasking;
    xenc.plugins[1].param = NULL;
    xenc.num_plugins++;
  }

  if ((ret = xvid_encore (NULL, XVID_ENC_CREATE, &xenc, NULL)) < 0) {
    GST_DEBUG_OBJECT (xvidenc, "Error setting up xvid encoder: %s (%d)",
        gst_xvid_error (ret), ret);
    return FALSE;
  }

  xvidenc->handle = xenc.handle;

  return TRUE;
}

static gboolean
gst_xvidenc_setcaps (GstPad * pad, GstCaps * vscaps)
{
  GstXvidEnc *xvidenc;
  GstStructure *structure;
  gint w, h;
  const GValue *fps, *par;
  gint xvid_cs = -1;

  xvidenc = GST_XVIDENC (GST_PAD_PARENT (pad));

  /* if there's something old around, remove it */
  if (xvidenc->handle) {
    gst_xvidenc_flush_buffers (xvidenc, TRUE);
    xvid_encore (xvidenc->handle, XVID_ENC_DESTROY, NULL, NULL);
    xvidenc->handle = NULL;
  }

  structure = gst_caps_get_structure (vscaps, 0);

  if (!gst_structure_get_int (structure, "width", &w) ||
      !gst_structure_get_int (structure, "height", &h)) {
    return FALSE;
  }

  fps = gst_structure_get_value (structure, "framerate");
  if (fps == NULL || !GST_VALUE_HOLDS_FRACTION (fps)) {
    GST_WARNING_OBJECT (pad, "no framerate specified, or not a GstFraction");
    return FALSE;
  }

  /* optional par info */
  par = gst_structure_get_value (structure, "pixel-aspect-ratio");

  xvid_cs = gst_xvid_structure_to_csp (structure);
  if (xvid_cs == -1) {
    gchar *sstr;

    sstr = gst_structure_to_string (structure);
    GST_DEBUG_OBJECT (xvidenc, "Did not find xvid colourspace for caps %s",
        sstr);
    g_free (sstr);
    return FALSE;
  }

  xvidenc->csp = xvid_cs;
  xvidenc->width = w;
  xvidenc->height = h;
  xvidenc->fbase = gst_value_get_fraction_numerator (fps);
  xvidenc->fincr = gst_value_get_fraction_denominator (fps);
  if ((par != NULL) && GST_VALUE_HOLDS_FRACTION (par)) {
    xvidenc->par_width = gst_value_get_fraction_numerator (par);
    xvidenc->par_height = gst_value_get_fraction_denominator (par);
  } else {
    xvidenc->par_width = 1;
    xvidenc->par_height = 1;
  }

  /* wipe xframe cache given possible change caps properties */
  g_free (xvidenc->xframe_cache);
  xvidenc->xframe_cache = NULL;

  if (gst_xvidenc_setup (xvidenc)) {
    gboolean ret = FALSE;
    GstCaps *new_caps = NULL, *allowed_caps;

    /* please downstream with preferred caps */
    allowed_caps = gst_pad_get_allowed_caps (xvidenc->srcpad);
    GST_DEBUG_OBJECT (xvidenc, "allowed caps: %" GST_PTR_FORMAT, allowed_caps);

    if (allowed_caps && !gst_caps_is_empty (allowed_caps)) {
      new_caps = gst_caps_copy_nth (allowed_caps, 0);
    } else {
      new_caps = gst_caps_new_simple ("video/x-xvid", NULL);
    }
    if (allowed_caps)
      gst_caps_unref (allowed_caps);

    gst_caps_set_simple (new_caps,
        "width", G_TYPE_INT, w, "height", G_TYPE_INT, h,
        "framerate", GST_TYPE_FRACTION, xvidenc->fbase, xvidenc->fincr,
        "pixel-aspect-ratio", GST_TYPE_FRACTION,
        xvidenc->par_width, xvidenc->par_height, NULL);
    /* just to be sure */
    gst_pad_fixate_caps (xvidenc->srcpad, new_caps);

    /* src pad should accept anyway */
    ret = gst_pad_set_caps (xvidenc->srcpad, new_caps);
    gst_caps_unref (new_caps);

    if (!ret && xvidenc->handle) {
      xvid_encore (xvidenc->handle, XVID_ENC_DESTROY, NULL, NULL);
      xvidenc->handle = NULL;
    }
    return ret;

  } else                        /* setup did not work out */
    return FALSE;
}

/* encodes frame according to info in xframe;
   - buf is input buffer, can be NULL if dummy
   - buf is disposed of prior to exit
   - resulting buffer is returned, NULL if no encoder output or error
*/
static inline GstBuffer *
gst_xvidenc_encode (GstXvidEnc * xvidenc, GstBuffer * buf,
    xvid_enc_frame_t xframe)
{
  GstBuffer *outbuf;
  gint ret;

  /* compressed frame should fit in the rough size of an uncompressed one */
  outbuf = gst_buffer_new_and_alloc (gst_xvid_image_get_size (xvidenc->csp,
          xvidenc->width, xvidenc->height));

  xframe.bitstream = (void *) GST_BUFFER_DATA (outbuf);
  xframe.length = GST_BUFFER_SIZE (outbuf);

  /* now provide input image data where-abouts, if needed */
  if (buf)
    gst_xvid_image_fill (&xframe.input, GST_BUFFER_DATA (buf), xvidenc->csp,
        xvidenc->width, xvidenc->height);

  GST_DEBUG_OBJECT (xvidenc, "encoding frame into buffer of size %d",
      GST_BUFFER_SIZE (outbuf));
  ret = xvid_encore (xvidenc->handle, XVID_ENC_ENCODE, &xframe, NULL);

  if (ret < 0) {
    /* things can be nasty if we are trying to flush, so don't signal error then */
    if (buf) {
      GST_ELEMENT_WARNING (xvidenc, LIBRARY, ENCODE, (NULL),
          ("Error encoding xvid frame: %s (%d)", gst_xvid_error (ret), ret));
      gst_buffer_unref (buf);
    }
    gst_buffer_unref (outbuf);
    return NULL;
  } else if (ret > 0) {         /* make sub-buffer */
    GstBuffer *sub;

    GST_DEBUG_OBJECT (xvidenc, "xvid produced output of size %d", ret);
    sub = gst_buffer_create_sub (outbuf, 0, ret);

    /* parent no longer needed, will go away with child buffer */
    gst_buffer_unref (outbuf);
    outbuf = sub;
  } else {                      /* encoder did not yet produce something */
    GST_DEBUG_OBJECT (xvidenc, "xvid produced no output");
    gst_buffer_unref (outbuf);
    g_queue_push_tail (xvidenc->delay, buf);
    return NULL;
  }

  /* finish decoration and return */
  if (!(xframe.out_flags & XVID_KEYFRAME))
    GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
  gst_buffer_set_caps (outbuf, GST_PAD_CAPS (xvidenc->srcpad));

  /* now we need the right buf to take timestamps from;
     note that timestamps from a display order input buffer can end up with
     another encode order output buffer, but other than this permutation,
     the overall time progress is tracked,
     and keyframes should have the correct stamp */
  if (!g_queue_is_empty (xvidenc->delay)) {
    if (buf)
      g_queue_push_tail (xvidenc->delay, buf);
    buf = g_queue_pop_head (xvidenc->delay);
  }
  if (buf) {
    GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
    GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
    gst_buffer_unref (buf);
  }

  return outbuf;
}

static GstFlowReturn
gst_xvidenc_chain (GstPad * pad, GstBuffer * buf)
{
  GstXvidEnc *xvidenc = GST_XVIDENC (GST_PAD_PARENT (pad));
  GstBuffer *outbuf;
  xvid_enc_frame_t xframe;

  const gint motion_presets[] = {
    0, 0, 0, 0,
    XVID_ME_HALFPELREFINE16,
    XVID_ME_HALFPELREFINE16 | XVID_ME_ADVANCEDDIAMOND16,
    XVID_ME_HALFPELREFINE16 | XVID_ME_EXTSEARCH16
        | XVID_ME_HALFPELREFINE8 | XVID_ME_USESQUARES16
  };

  if (!xvidenc->handle) {
    GST_ELEMENT_ERROR (xvidenc, CORE, NEGOTIATION, (NULL),
        ("format wasn't negotiated before chain function"));
    gst_buffer_unref (buf);
    return GST_FLOW_NOT_NEGOTIATED;
  }

  GST_DEBUG_OBJECT (xvidenc,
      "Received buffer of time %" GST_TIME_FORMAT ", size %d",
      GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), GST_BUFFER_SIZE (buf));

  if (xvidenc->xframe_cache)
    memcpy (&xframe, xvidenc->xframe_cache, sizeof (xframe));
  else {                        /* need to build some inital xframe to be cached */
    /* encode and so ... */
    gst_xvid_init_struct (xframe);

    if (xvidenc->par_width == xvidenc->par_height)
      xframe.par = XVID_PAR_11_VGA;
    else {
      xframe.par = XVID_PAR_EXT;
      xframe.par_width = xvidenc->par_width;
      xframe.par_height = xvidenc->par_height;
    }

    /* handle options */
    xframe.vol_flags |= xvidenc->quant_type;
    xframe.vop_flags = XVID_VOP_HALFPEL;
    xframe.motion = motion_presets[xvidenc->motion];

    if (xvidenc->me_chroma) {
      xframe.motion |= XVID_ME_CHROMA_PVOP;
      xframe.motion |= XVID_ME_CHROMA_BVOP;
    }

    if (xvidenc->me_vhq >= 1) {
      xframe.vop_flags |= XVID_VOP_MODEDECISION_RD;
    }
    if (xvidenc->me_vhq >= 2) {
      xframe.motion |= XVID_ME_HALFPELREFINE16_RD;
      xframe.motion |= XVID_ME_QUARTERPELREFINE16_RD;
    }
    if (xvidenc->me_vhq >= 3) {
      xframe.motion |= XVID_ME_HALFPELREFINE8_RD;
      xframe.motion |= XVID_ME_QUARTERPELREFINE8_RD;
      xframe.motion |= XVID_ME_CHECKPREDICTION_RD;
    }
    if (xvidenc->me_vhq >= 4) {
      xframe.motion |= XVID_ME_EXTSEARCH_RD;
    }

    /* no motion estimation, then only intra */
    if (xvidenc->motion == 0) {
      xframe.type = XVID_TYPE_IVOP;
    } else {
      xframe.type = XVID_TYPE_AUTO;
    }

    if (xvidenc->motion > 4) {
      xframe.vop_flags |= XVID_VOP_INTER4V;
    }

    if (xvidenc->me_quarterpel) {
      xframe.vol_flags |= XVID_VOL_QUARTERPEL;
      xframe.motion |= XVID_ME_QUARTERPELREFINE16;
      xframe.motion |= XVID_ME_QUARTERPELREFINE8;
    }

    if (xvidenc->gmc) {
      xframe.vol_flags |= XVID_VOL_GMC;
      xframe.motion |= XVID_ME_GME_REFINE;
    }

    if (xvidenc->interlaced) {
      xframe.vol_flags |= XVID_VOL_INTERLACING;
    }

    if (xvidenc->trellis) {
      xframe.vop_flags |= XVID_VOP_TRELLISQUANT;
    }

    if (xvidenc->hqacpred) {
      xframe.vop_flags |= XVID_VOP_HQACPRED;
    }

    if (xvidenc->greyscale) {
      xframe.vop_flags |= XVID_VOP_GREYSCALE;
    }

    if (xvidenc->cartoon) {
      xframe.vop_flags |= XVID_VOP_CARTOON;
      xframe.motion |= XVID_ME_DETECT_STATIC_MOTION;
    }

    xframe.bframe_threshold = xvidenc->bframe_threshold;
    xframe.input.csp = xvidenc->csp;

    /* save in cache */
    xvidenc->xframe_cache = g_memdup (&xframe, sizeof (xframe));
  }

  outbuf = gst_xvidenc_encode (xvidenc, buf, xframe);

  if (!outbuf)                  /* error or no data yet */
    return GST_FLOW_OK;

  /* go out, multiply! */
  return gst_pad_push (xvidenc->srcpad, outbuf);
}

/* flush xvid encoder buffers caused by bframe usage */
static void
gst_xvidenc_flush_buffers (GstXvidEnc * xvidenc, gboolean send)
{
  GstBuffer *outbuf;
  xvid_enc_frame_t xframe;

  /* no need to flush if no handle */
  if (!xvidenc->handle)
    return;

  gst_xvid_init_struct (xframe);

  /* init a fake frame to force flushing */
  xframe.input.csp = XVID_CSP_NULL;
  xframe.input.plane[0] = NULL;
  xframe.input.plane[1] = NULL;
  xframe.input.plane[2] = NULL;
  xframe.input.stride[0] = 0;
  xframe.input.stride[1] = 0;
  xframe.input.stride[2] = 0;
  xframe.quant = 0;

  GST_DEBUG ("flushing buffers with sending %d", send);

  while (!g_queue_is_empty (xvidenc->delay)) {
    outbuf = gst_xvidenc_encode (xvidenc, NULL, xframe);

    if (outbuf) {
      if (send)
        gst_pad_push (xvidenc->srcpad, outbuf);
      else
        gst_buffer_unref (outbuf);
    } else                      /* hm, there should have been something in there */
      break;
  }

  /* our queue should be empty anyway if we did not have to break out ... */
  while (!g_queue_is_empty (xvidenc->delay))
    gst_buffer_unref (g_queue_pop_head (xvidenc->delay));
}

static void
gst_xvidenc_set_property (GObject * object,
    guint prop_id, const GValue * value, GParamSpec * pspec)
{
  GstXvidEnc *xvidenc;
  guint offset;

  xvidenc = GST_XVIDENC (object);

  if (prop_id > xvidenc_prop_count) {
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    return;
  }

  /* our param specs should have such qdata */
  offset =
      GPOINTER_TO_UINT (g_param_spec_get_qdata (pspec, xvidenc_pspec_quark));

  if (offset == 0)
    return;

  switch (G_PARAM_SPEC_VALUE_TYPE (pspec)) {
    case G_TYPE_BOOLEAN:
      G_STRUCT_MEMBER (gboolean, xvidenc, offset) = g_value_get_boolean (value);
      break;
    case G_TYPE_INT:
      G_STRUCT_MEMBER (gint, xvidenc, offset) = g_value_get_int (value);
      break;
    case G_TYPE_STRING:
      g_free (G_STRUCT_MEMBER (gchar *, xvidenc, offset));
      G_STRUCT_MEMBER (gchar *, xvidenc, offset) = g_value_dup_string (value);
      break;
    default:                   /* must be enum, given the check above */
      if (G_IS_PARAM_SPEC_ENUM (pspec)) {
        G_STRUCT_MEMBER (gint, xvidenc, offset) = g_value_get_enum (value);
      } else {
        G_STRUCT_MEMBER (guint, xvidenc, offset) = g_value_get_flags (value);
      }
      break;
  }
}

static void
gst_xvidenc_get_property (GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec)
{
  GstXvidEnc *xvidenc;
  guint offset;

  xvidenc = GST_XVIDENC (object);

  if (prop_id > xvidenc_prop_count) {
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    return;
  }

  /* our param specs should have such qdata */
  offset =
      GPOINTER_TO_UINT (g_param_spec_get_qdata (pspec, xvidenc_pspec_quark));

  if (offset == 0)
    return;

  switch (G_PARAM_SPEC_VALUE_TYPE (pspec)) {
    case G_TYPE_BOOLEAN:
      g_value_set_boolean (value, G_STRUCT_MEMBER (gboolean, xvidenc, offset));
      break;
    case G_TYPE_INT:
      g_value_set_int (value, G_STRUCT_MEMBER (gint, xvidenc, offset));
      break;
    case G_TYPE_STRING:
      g_value_take_string (value,
          g_strdup (G_STRUCT_MEMBER (gchar *, xvidenc, offset)));
      break;
    default:                   /* must be enum, given the check above */
      if (G_IS_PARAM_SPEC_ENUM (pspec)) {
        g_value_set_enum (value, G_STRUCT_MEMBER (gint, xvidenc, offset));
      } else if (G_IS_PARAM_SPEC_FLAGS (pspec)) {
        g_value_set_flags (value, G_STRUCT_MEMBER (guint, xvidenc, offset));
      } else {                  /* oops, bit lazy we don't cover this case yet */
        g_critical ("%s does not yet support type %s", GST_FUNCTION,
            g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
      }
      break;
  }
}

static GstStateChangeReturn
gst_xvidenc_change_state (GstElement * element, GstStateChange transition)
{
  GstXvidEnc *xvidenc = GST_XVIDENC (element);
  GstStateChangeReturn ret;

  switch (transition) {
    case GST_STATE_CHANGE_NULL_TO_READY:
      if (!gst_xvid_init ())
        return GST_STATE_CHANGE_FAILURE;
      break;
    case GST_STATE_CHANGE_READY_TO_PAUSED:
      xvidenc->delay = g_queue_new ();
      break;
    default:
      break;
  }


  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
  if (ret == GST_STATE_CHANGE_FAILURE)
    goto done;

  switch (transition) {
    case GST_STATE_CHANGE_PAUSED_TO_READY:
      if (xvidenc->handle) {
        gst_xvidenc_flush_buffers (xvidenc, FALSE);
        xvid_encore (xvidenc->handle, XVID_ENC_DESTROY, NULL, NULL);
        xvidenc->handle = NULL;
      }
      g_queue_free (xvidenc->delay);
      xvidenc->delay = NULL;
      g_free (xvidenc->xframe_cache);
      xvidenc->xframe_cache = NULL;
      break;
    default:
      break;
  }

done:
  return ret;
}