/* GStreamer

 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>

 *

 * 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.

 */

/**

 * SECTION:element-videorate

 *

 * This element takes an incoming stream of timestamped video frames.

 * It will produce a perfect stream that matches the source pad's framerate.

 *

 * The correction is performed by dropping and duplicating frames, no fancy

 * algorithm is used to interpolate frames (yet).

 * By default the element will simply negotiate the same framerate on its

 * source and sink pad.

 * This operation is useful to link to elements that require a perfect stream.

 * Typical examples are formats that do not store timestamps for video frames,

 * but only store a framerate, like Ogg and AVI.

 * A conversion to a specific framerate can be forced by using filtered caps on

 * the source pad.

 *

 * An input stream that needs no adjustments will thus never have dropped or

 * duplicated frames.

 *

 * This can potentially cause performance degradation.

 * Note that property notification will happen from the streaming thread, so

 * applications should be prepared for this.

 * <title>Example pipelines</title>

 * gst-launch -v filesrc location=videotestsrc.ogg ! oggdemux ! theoradec ! videorate ! video/x-raw-yuv,framerate=15/1 ! xvimagesink

 * To create the test Ogg/Theora file refer to the documentation of theoraenc.

 * gst-launch -v v4lsrc ! videorate ! video/x-raw-yuv,framerate=25/2 ! theoraenc ! oggmux ! filesink location=v4l.ogg

 * encoding to Ogg/Theora.

 *

 * Last reviewed on 2006-09-02 (0.10.11)

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gstvideorate.h"

GST_DEBUG_CATEGORY_STATIC (video_rate_debug);

#define GST_CAT_DEFAULT video_rate_debug

/* elementfactory information */

static const GstElementDetails video_rate_details =

GST_ELEMENT_DETAILS ("Video rate adjuster",

    "Filter/Effect/Video",

    "Drops/duplicates/adjusts timestamps on video frames to make a perfect stream",

    "Wim Taymans <wim@fluendo.com>");

/* GstVideoRate signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

#define DEFAULT_SILENT          TRUE

#define DEFAULT_NEW_PREF        1.0

enum

{

  ARG_0,

  ARG_IN,

  ARG_OUT,

  ARG_DUP,

  ARG_DROP,

  ARG_SILENT,

  ARG_NEW_PREF,

  /* FILL ME */

};

static GstStaticPadTemplate gst_video_rate_src_template =

    GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    );

static GstStaticPadTemplate gst_video_rate_sink_template =

    GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    );

static void gst_video_rate_swap_prev (GstVideoRate * videorate,

    GstBuffer * buffer, gint64 time);

static gboolean gst_video_rate_event (GstPad * pad, GstEvent * event);

static gboolean gst_video_rate_query (GstPad * pad, GstQuery * query);

static GstFlowReturn gst_video_rate_chain (GstPad * pad, GstBuffer * buffer);

static void gst_video_rate_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static void gst_video_rate_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

static GstStateChangeReturn gst_video_rate_change_state (GstElement * element,

    GstStateChange transition);

/*static guint gst_video_rate_signals[LAST_SIGNAL] = { 0 }; */

GST_BOILERPLATE (GstVideoRate, gst_video_rate, GstElement, GST_TYPE_ELEMENT);

static void

gst_video_rate_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_set_details (element_class, &video_rate_details);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_video_rate_sink_template));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_video_rate_src_template));

}

static void

gst_video_rate_class_init (GstVideoRateClass * klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  object_class->set_property = gst_video_rate_set_property;

  object_class->get_property = gst_video_rate_get_property;

  g_object_class_install_property (object_class, ARG_IN,

      g_param_spec_uint64 ("in", "In",

  g_object_class_install_property (object_class, ARG_OUT,

  g_object_class_install_property (object_class, ARG_DUP,

      g_param_spec_uint64 ("duplicate", "Duplicate",

  g_object_class_install_property (object_class, ARG_DROP,

  g_object_class_install_property (object_class, ARG_SILENT,

      g_param_spec_boolean ("silent", "silent",

  g_object_class_install_property (object_class, ARG_NEW_PREF,

  element_class->change_state = gst_video_rate_change_state;

}

/* return the caps that can be used on out_pad given in_caps on in_pad */

static gboolean

gst_video_rate_transformcaps (GstPad * in_pad, GstCaps * in_caps,

    GstPad * out_pad, GstCaps ** out_caps)

{

  GstCaps *intersect;

  const GstCaps *in_templ;

  gint i;

  in_templ = gst_pad_get_pad_template_caps (in_pad);

  intersect = gst_caps_intersect (in_caps, in_templ);

  /* all possible framerates are allowed */

  for (i = 0; i < gst_caps_get_size (intersect); i++) {

    GstStructure *structure;

    structure = gst_caps_get_structure (intersect, i);

    gst_structure_set (structure,

        "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);

  }

  *out_caps = intersect;

  return TRUE;

}

static GstCaps *

gst_video_rate_getcaps (GstPad * pad)

{

  GstVideoRate *videorate;

  GstPad *otherpad;

  GstCaps *caps;

  videorate = GST_VIDEO_RATE (GST_PAD_PARENT (pad));

  otherpad = (pad == videorate->srcpad) ? videorate->sinkpad :

      videorate->srcpad;

  /* we can do what the peer can */

  caps = gst_pad_peer_get_caps (otherpad);

  if (caps) {

    GstCaps *transform;

    gst_video_rate_transformcaps (otherpad, caps, pad, &transform);

    gst_caps_unref (caps);

    caps = transform;

  } else {

    /* no peer, our padtemplate is enough then */

    caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));

  }

  return caps;

}

static gboolean

gst_video_rate_setcaps (GstPad * pad, GstCaps * caps)

{

  GstVideoRate *videorate;

  GstStructure *structure;

  gboolean ret = TRUE;

  GstPad *otherpad, *opeer;

  gint rate_numerator, rate_denominator;

  videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));

  GST_DEBUG ("setcaps called %" GST_PTR_FORMAT, caps);

  structure = gst_caps_get_structure (caps, 0);

  if (!gst_structure_get_fraction (structure, "framerate",

          &rate_numerator, &rate_denominator))

    goto no_framerate;

  if (pad == videorate->srcpad) {

    videorate->to_rate_numerator = rate_numerator;

    videorate->to_rate_denominator = rate_denominator;

    otherpad = videorate->sinkpad;

  } else {

    videorate->from_rate_numerator = rate_numerator;

    videorate->from_rate_denominator = rate_denominator;

    otherpad = videorate->srcpad;

  }

  /* now try to find something for the peer */

  opeer = gst_pad_get_peer (otherpad);

  if (opeer) {

    if (gst_pad_accept_caps (opeer, caps)) {

      /* the peer accepts the caps as they are */

      gst_pad_set_caps (otherpad, caps);

      ret = TRUE;

    } else {

      GstCaps *peercaps;

      GstCaps *intersect;

      GstCaps *transform = NULL;

      ret = FALSE;

      /* see how we can transform the input caps */

      if (!gst_video_rate_transformcaps (pad, caps, otherpad, &transform))

        goto no_transform;

      /* see what the peer can do */

      peercaps = gst_pad_get_caps (opeer);

      GST_DEBUG ("icaps %" GST_PTR_FORMAT, peercaps);

      GST_DEBUG ("transform %" GST_PTR_FORMAT, transform);

      /* filter against our possibilities */

      intersect = gst_caps_intersect (peercaps, transform);

      gst_caps_unref (peercaps);

      gst_caps_unref (transform);

      GST_DEBUG ("intersect %" GST_PTR_FORMAT, intersect);

      /* take first possibility */

      caps = gst_caps_copy_nth (intersect, 0);

      gst_caps_unref (intersect);

      structure = gst_caps_get_structure (caps, 0);

      /* and fixate */

      gst_structure_fixate_field_nearest_fraction (structure, "framerate",

          rate_numerator, rate_denominator);

      gst_structure_get_fraction (structure, "framerate",

          &rate_numerator, &rate_denominator);

      if (otherpad == videorate->srcpad) {

        videorate->to_rate_numerator = rate_numerator;

        videorate->to_rate_denominator = rate_denominator;

      } else {

        videorate->from_rate_numerator = rate_numerator;

        videorate->from_rate_denominator = rate_denominator;

      }

      gst_pad_set_caps (otherpad, caps);

      gst_caps_unref (caps);

      ret = TRUE;

    }

    gst_object_unref (opeer);

  }

done:

  /* After a setcaps, our caps may have changed. In that case, we can't use

   * the old buffer, if there was one (it might have different dimensions) */

  GST_DEBUG ("swapping old buffers");

  gst_video_rate_swap_prev (videorate, NULL, GST_CLOCK_TIME_NONE);

  gst_object_unref (videorate);

  return ret;

no_framerate:

  {

    GST_DEBUG_OBJECT (videorate, "no framerate specified");

    goto done;

  }

no_transform:

  {

    GST_DEBUG_OBJECT (videorate, "no framerate transform possible");

    ret = FALSE;

    goto done;

  }

}

static void

gst_video_rate_reset (GstVideoRate * videorate)

{

  GST_DEBUG ("resetting internal variables");

  videorate->in = 0;

  videorate->out = 0;

  videorate->drop = 0;

  videorate->dup = 0;

  videorate->next_ts = GST_CLOCK_TIME_NONE;

  gst_video_rate_swap_prev (videorate, NULL, 0);

  gst_segment_init (&videorate->segment, GST_FORMAT_TIME);

}

static void

gst_video_rate_init (GstVideoRate * videorate, GstVideoRateClass * klass)

{

  GST_DEBUG ("gst_video_rate_init");

  videorate->sinkpad =

      gst_pad_new_from_static_template (&gst_video_rate_sink_template, "sink");

  gst_pad_set_event_function (videorate->sinkpad, gst_video_rate_event);

  gst_pad_set_chain_function (videorate->sinkpad, gst_video_rate_chain);

  gst_pad_set_getcaps_function (videorate->sinkpad, gst_video_rate_getcaps);

  gst_pad_set_setcaps_function (videorate->sinkpad, gst_video_rate_setcaps);

  gst_element_add_pad (GST_ELEMENT (videorate), videorate->sinkpad);

  videorate->srcpad =

      gst_pad_new_from_static_template (&gst_video_rate_src_template, "src");

  gst_pad_set_query_function (videorate->srcpad, gst_video_rate_query);

  gst_pad_set_getcaps_function (videorate->srcpad, gst_video_rate_getcaps);

  gst_pad_set_setcaps_function (videorate->srcpad, gst_video_rate_setcaps);

  gst_element_add_pad (GST_ELEMENT (videorate), videorate->srcpad);

  gst_video_rate_reset (videorate);

  videorate->silent = DEFAULT_SILENT;

  videorate->new_pref = DEFAULT_NEW_PREF;

  videorate->from_rate_numerator = 0;

  videorate->from_rate_denominator = 0;

  videorate->to_rate_numerator = 0;

  videorate->to_rate_denominator = 0;

}

/* flush the oldest buffer */

static GstFlowReturn

gst_video_rate_flush_prev (GstVideoRate * videorate)

{

  GstFlowReturn res;

  GstBuffer *outbuf;

  GstClockTime push_ts;

  if (!videorate->prevbuf)

    goto eos_before_buffers;

  /* make sure we can write to the metadata */

  outbuf = gst_buffer_make_metadata_writable

      (gst_buffer_ref (videorate->prevbuf));

  GST_BUFFER_OFFSET (outbuf) = videorate->out;

  GST_BUFFER_OFFSET_END (outbuf) = videorate->out + 1;

  /* this is the timestamp we put on the buffer */

  push_ts = videorate->next_ts;

  videorate->out++;

  if (videorate->to_rate_numerator) {

    /* interpolate next expected timestamp in the segment */

    videorate->next_ts = videorate->segment.accum + videorate->segment.start +

        videorate->to_rate_denominator * GST_SECOND,

        videorate->to_rate_numerator);

    GST_BUFFER_DURATION (outbuf) = videorate->next_ts - push_ts;

  }

  /* adapt for looping, bring back to time in current segment. */

  GST_BUFFER_TIMESTAMP (outbuf) = push_ts - videorate->segment.accum;

  gst_buffer_set_caps (outbuf, GST_PAD_CAPS (videorate->srcpad));

  GST_LOG_OBJECT (videorate,

      "old is best, dup, pushing buffer outgoing ts %" GST_TIME_FORMAT,

      GST_TIME_ARGS (push_ts));

  res = gst_pad_push (videorate->srcpad, outbuf);

  return res;

  /* WARNINGS */

eos_before_buffers:

  {

    GST_INFO_OBJECT (videorate, "got EOS before any buffer was received");

    return GST_FLOW_OK;

  }

}

static void

gst_video_rate_swap_prev (GstVideoRate * videorate, GstBuffer * buffer,

    gint64 time)

{

  GST_LOG_OBJECT (videorate, "swap_prev: storing buffer %p in prev", buffer);

  if (videorate->prevbuf)

    gst_buffer_unref (videorate->prevbuf);

  videorate->prevbuf = buffer;

  videorate->prev_ts = time;

}

static gboolean

gst_video_rate_event (GstPad * pad, GstEvent * event)

{

  GstVideoRate *videorate;

  gboolean ret;

  videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_NEWSEGMENT:

    {

      gint64 start, stop, time;

      gdouble rate, arate;

      gboolean update;

      GstFormat format;

      gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,

          &start, &stop, &time);

      if (format != GST_FORMAT_TIME)

        goto format_error;

      GST_DEBUG_OBJECT (videorate, "handle NEWSEGMENT");

      /* We just want to update the accumulated stream_time  */

      gst_segment_set_newsegment_full (&videorate->segment, update, rate, arate,

          format, start, stop, time);

      GST_DEBUG_OBJECT (videorate, "updated segment: %" GST_SEGMENT_FORMAT,

          &videorate->segment);

      break;

    }

    case GST_EVENT_EOS:

      /* flush last queued frame */

      GST_DEBUG_OBJECT (videorate, "Got EOS");

      gst_video_rate_flush_prev (videorate);

      break;

    case GST_EVENT_FLUSH_STOP:

      /* also resets the segment */

      GST_DEBUG_OBJECT (videorate, "Got FLUSH_STOP");

      gst_video_rate_reset (videorate);

      break;

    default:

      break;

  }

  ret = gst_pad_push_event (videorate->srcpad, event);

done:

  gst_object_unref (videorate);

  return ret;

  /* ERRORS */

format_error:

  {

    GST_WARNING_OBJECT (videorate,

        "Got segment but doesn't have GST_FORMAT_TIME value");