/* GStreamer

 * Copyright (C) 2007 David Schleef <ds@schleef.org>

 *           (C) 2008 Wim Taymans <wim.taymans@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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:element-appsink

 * 

 * Appsink is a sink plugin that supports many different methods for making

 * the application get a handle on the GStreamer data in a pipeline. Unlike

 * most GStreamer elements, Appsink provides external API functions.

 *

 * For the documentation of the API, please see the

 * <link linkend="gst-plugins-base-libs-appsink">libgstapp</link> section in

 * the GStreamer Plugins Base Libraries documentation.

 *

 * Since: 0.10.22

 */

/**

 * SECTION:gstappsink

 * @see_also: #GstBaseSink, appsrc

 *

 * Appsink is a sink plugin that supports many different methods for making

 * the application get a handle on the GStreamer data in a pipeline. Unlike

 * most GStreamer elements, Appsink provides external API functions.

 *

 * appsink can be used by linking to the gstappsink.h header file to access the

 * methods or by using the appsink action signals and properties.

 *

 * The normal way of retrieving buffers from appsink is by using the

 * gst_app_sink_pull_buffer() and gst_app_sink_pull_preroll() methods.

 * These methods block until a buffer becomes available in the sink or when the

 * sink is shut down or reaches EOS.

 *

 * Appsink will internally use a queue to collect buffers from the streaming

 * thread. If the application is not pulling buffers fast enough, this queue

 * will consume a lot of memory over time. The "max-buffers" property can be

 * used to limit the queue size. The "drop" property controls whether the

 * streaming thread blocks or if older buffers are dropped when the maximum

 * queue size is reached. Note that blocking the streaming thread can negatively

 * affect real-time performance and should be avoided.

 *

 * If a blocking behaviour is not desirable, setting the "emit-signals" property

 * to %TRUE will make appsink emit the "new-buffer" and "new-preroll" signals

 * when a buffer can be pulled without blocking.

 *

 * The "caps" property on appsink can be used to control the formats that

 * appsink can receive. This property can contain non-fixed caps, the format of

 * the pulled buffers can be obtained by getting the buffer caps.

 *

 * If one of the pull-preroll or pull-buffer methods return %NULL, the appsink

 * is stopped or in the EOS state. You can check for the EOS state with the

 * "eos" property or with the gst_app_sink_is_eos() method.

 *

 * The eos signal can also be used to be informed when the EOS state is reached

 * to avoid polling.

 *

 * Last reviewed on 2008-12-17 (0.10.22)

 *

 * Since: 0.10.22

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/gst.h>

#include <gst/base/gstbasesink.h>

#include <gst/gstbuffer.h>

#include <string.h>

#include "gstappsink.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

struct _GstAppSinkPrivate

{

  GstCaps *caps;

  gboolean emit_signals;

  guint max_buffers;

  gboolean drop;

  GCond *cond;

  GMutex *mutex;

  GQueue *queue;

  GstBuffer *preroll;

  gboolean flushing;

  gboolean started;

  gboolean is_eos;

  GstAppSinkCallbacks callbacks;

  gpointer user_data;

  GDestroyNotify notify;

};

GST_DEBUG_CATEGORY_STATIC (app_sink_debug);

#define GST_CAT_DEFAULT app_sink_debug

enum

{

  /* signals */

  SIGNAL_EOS,

  SIGNAL_NEW_PREROLL,

  SIGNAL_NEW_BUFFER,

  /* actions */

  SIGNAL_PULL_PREROLL,

  SIGNAL_PULL_BUFFER,

  LAST_SIGNAL

};

#define DEFAULT_PROP_EOS		TRUE

#define DEFAULT_PROP_EMIT_SIGNALS	FALSE

#define DEFAULT_PROP_MAX_BUFFERS	0

#define DEFAULT_PROP_DROP		FALSE

enum

{

  PROP_0,

  PROP_CAPS,

  PROP_EOS,

  PROP_EMIT_SIGNALS,

  PROP_MAX_BUFFERS,

  PROP_DROP,

  PROP_LAST

};

static GstStaticPadTemplate gst_app_sink_template =

GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS_ANY);

static void gst_app_sink_uri_handler_init (gpointer g_iface,

    gpointer iface_data);

static void gst_app_sink_dispose (GObject * object);

static void gst_app_sink_finalize (GObject * object);

#ifdef __SYMBIAN32__

static void gst_app_sink_class_init (GstAppSinkClass * klass);

static void gst_app_sink_init (GstAppSink * appsink, GstAppSinkClass * klass);

static void gst_app_sink_base_init (gpointer g_class);

#endif

static void gst_app_sink_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_app_sink_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static gboolean gst_app_sink_unlock_start (GstBaseSink * bsink);

static gboolean gst_app_sink_unlock_stop (GstBaseSink * bsink);

static gboolean gst_app_sink_start (GstBaseSink * psink);

static gboolean gst_app_sink_stop (GstBaseSink * psink);

static gboolean gst_app_sink_event (GstBaseSink * sink, GstEvent * event);

static GstFlowReturn gst_app_sink_preroll (GstBaseSink * psink,

    GstBuffer * buffer);

static GstFlowReturn gst_app_sink_render (GstBaseSink * psink,

    GstBuffer * buffer);

static GstCaps *gst_app_sink_getcaps (GstBaseSink * psink);

static guint gst_app_sink_signals[LAST_SIGNAL] = { 0 };

static void

_do_init (GType filesrc_type)

{

  static const GInterfaceInfo urihandler_info = {

    gst_app_sink_uri_handler_init,

    NULL,

    NULL

  };

  g_type_add_interface_static (filesrc_type, GST_TYPE_URI_HANDLER,

      &urihandler_info);

}

#ifndef __SYMBIAN32__

GST_BOILERPLATE_FULL (GstAppSink, gst_app_sink, GstBaseSink, GST_TYPE_BASE_SINK,

    _do_init);

#else

static GstBaseSinkClass *parent_class = NULL;           

static void

gst_app_sink_class_init_trampoline (gpointer g_class,

                        gpointer data)

{                                   

  parent_class = (GstBaseSinkClass *)               

      g_type_class_peek_parent (g_class);              

      gst_app_sink_class_init ((GstAppSinkClass *)g_class);       

}

EXPORT_C GType

gst_app_sink_get_type (void)

{

static GType object_type = 0;                      

 if (G_UNLIKELY (object_type == 0)) {                  

   object_type = gst_type_register_static_full(GST_TYPE_BASE_SINK,

       "GstAppSink",

       sizeof (GstAppSinkClass),

       (GBaseInitFunc) gst_app_sink_base_init,

       NULL,

       (GClassInitFunc) gst_app_sink_class_init_trampoline,

       NULL,       

       NULL,

       sizeof (GstAppSink),   

       0,

       (GInstanceInitFunc) gst_app_sink_init,

       NULL,        

       (GTypeFlags) 0);

     _do_init (object_type);               

 }                                 

 return object_type;               

}

#endif

/* Can't use glib-genmarshal for this, as it doesn't know how to handle

 * GstMiniObject-based types, which are a new fundamental type */

static void

gst_app_marshal_BUFFER__VOID (GClosure * closure,

    GValue * return_value,

    guint n_param_values,

    const GValue * param_values,

    gpointer invocation_hint, gpointer marshal_data)

{

  typedef GstBuffer *(*GMarshalFunc_BUFFER__VOID) (gpointer data1,

      gpointer data2);

  register GMarshalFunc_BUFFER__VOID callback;

  register GCClosure *cc = (GCClosure *) closure;

  register gpointer data1, data2;

  GstBuffer *v_return;

  g_return_if_fail (return_value != NULL);

  g_return_if_fail (n_param_values == 1);

  if (G_CCLOSURE_SWAP_DATA (closure)) {

    data1 = closure->data;

    data2 = g_value_peek_pointer (param_values + 0);

  } else {

    data1 = g_value_peek_pointer (param_values + 0);

    data2 = closure->data;

  }

  callback =

      (GMarshalFunc_BUFFER__VOID) (marshal_data ? marshal_data : cc->callback);

  v_return = callback (data1, data2);

  gst_value_take_buffer (return_value, v_return);

}

static void

gst_app_sink_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  GST_DEBUG_CATEGORY_INIT (app_sink_debug, "appsink", 0, "appsink element");

  gst_element_class_set_details_simple (element_class, "AppSink",

      "Generic/Sink", "Allow the application to get access to raw buffer",

      "David Schleef <ds@schleef.org>, Wim Taymans <wim.taymans@gmail.com>");

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_app_sink_template));

}

static void

gst_app_sink_class_init (GstAppSinkClass * klass)

{

  GObjectClass *gobject_class = (GObjectClass *) klass;

  GstBaseSinkClass *basesink_class = (GstBaseSinkClass *) klass;

  gobject_class->dispose = gst_app_sink_dispose;

  gobject_class->finalize = gst_app_sink_finalize;

  gobject_class->set_property = gst_app_sink_set_property;

  gobject_class->get_property = gst_app_sink_get_property;

  g_object_class_install_property (gobject_class, PROP_CAPS,

      g_param_spec_boxed ("caps", "Caps",

          "The allowed caps for the sink pad", GST_TYPE_CAPS,

          G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, PROP_EOS,

      g_param_spec_boolean ("eos", "EOS",

          "Check if the sink is EOS or not started", DEFAULT_PROP_EOS,

          G_PARAM_READABLE));

  g_object_class_install_property (gobject_class, PROP_EMIT_SIGNALS,

      g_param_spec_boolean ("emit-signals", "Emit signals",

          "Emit new-preroll and new-buffer signals", DEFAULT_PROP_EMIT_SIGNALS,

          G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, PROP_MAX_BUFFERS,

      g_param_spec_uint ("max-buffers", "Max Buffers",

          "The maximum number of buffers to queue internally (0 = unlimited)",

          0, G_MAXUINT, DEFAULT_PROP_MAX_BUFFERS,

          G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, PROP_DROP,

      g_param_spec_boolean ("drop", "Drop",

          "Drop old buffers when the buffer queue is filled", DEFAULT_PROP_DROP,

          G_PARAM_READWRITE));

  /**

   * GstAppSink::eos:

   * @appsink: the appsink element that emited the signal

   *

   * Signal that the end-of-stream has been reached. This signal is emited from

   * the steaming thread.

   */

  gst_app_sink_signals[SIGNAL_EOS] =

      g_signal_new ("eos", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstAppSinkClass, eos),

      NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);

  /**

   * GstAppSink::new-preroll:

   * @appsink: the appsink element that emited the signal

   *

   * Signal that a new preroll buffer is available. 

   *

   * This signal is emited from the steaming thread and only when the

   * "emit-signals" property is %TRUE. 

   *

   * The new preroll buffer can be retrieved with the "pull-preroll" action

   * signal or gst_app_sink_pull_preroll() either from this signal callback

   * or from any other thread.

   *

   * Note that this signal is only emited when the "emit-signals" property is

   * set to %TRUE, which it is not by default for performance reasons.

   */

  gst_app_sink_signals[SIGNAL_NEW_PREROLL] =

      g_signal_new ("new-preroll", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstAppSinkClass, new_preroll),

      NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);

  /**

   * GstAppSink::new-buffer:

   * @appsink: the appsink element that emited the signal

   *

   * Signal that a new buffer is available.

   *

   * This signal is emited from the steaming thread and only when the

   * "emit-signals" property is %TRUE. 

   *

   * The new buffer can be retrieved with the "pull-buffer" action

   * signal or gst_app_sink_pull_buffer() either from this signal callback

   * or from any other thread.

   *

   * Note that this signal is only emited when the "emit-signals" property is

   * set to %TRUE, which it is not by default for performance reasons.

   */

  gst_app_sink_signals[SIGNAL_NEW_BUFFER] =

      g_signal_new ("new-buffer", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstAppSinkClass, new_buffer),

      NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);

  /**

   * GstAppSink::pull-preroll:

   * @appsink: the appsink element to emit this signal on

   *

   * Get the last preroll buffer in @appsink. This was the buffer that caused the

   * appsink to preroll in the PAUSED state. This buffer can be pulled many times

   * and remains available to the application even after EOS.

   *

   * This function is typically used when dealing with a pipeline in the PAUSED

   * state. Calling this function after doing a seek will give the buffer right

   * after the seek position.

   *

   * Note that the preroll buffer will also be returned as the first buffer

   * when calling gst_app_sink_pull_buffer() or the "pull-buffer" action signal.

   *

   * If an EOS event was received before any buffers, this function returns

   * %NULL. Use gst_app_sink_is_eos () to check for the EOS condition. 

   *

   * This function blocks until a preroll buffer or EOS is received or the appsink

   * element is set to the READY/NULL state. 

   *

   * Returns: a #GstBuffer or NULL when the appsink is stopped or EOS.

   */

  gst_app_sink_signals[SIGNAL_PULL_PREROLL] =

      g_signal_new ("pull-preroll", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSinkClass,

          pull_preroll), NULL, NULL, gst_app_marshal_BUFFER__VOID,

      GST_TYPE_BUFFER, 0, G_TYPE_NONE);

  /**

   * GstAppSink::pull-buffer:

   * @appsink: the appsink element to emit this signal on

   *

   * This function blocks until a buffer or EOS becomes available or the appsink

   * element is set to the READY/NULL state. 

   *

   * This function will only return buffers when the appsink is in the PLAYING

   * state. All rendered buffers will be put in a queue so that the application

   * can pull buffers at its own rate. 

   *

   * Note that when the application does not pull buffers fast enough, the

   * queued buffers could consume a lot of memory, especially when dealing with

   * raw video frames. It's possible to control the behaviour of the queue with

   * the "drop" and "max-buffers" properties.

   *

   * If an EOS event was received before any buffers, this function returns

   * %NULL. Use gst_app_sink_is_eos () to check for the EOS condition. 

   *

   * Returns: a #GstBuffer or NULL when the appsink is stopped or EOS.

   */

  gst_app_sink_signals[SIGNAL_PULL_BUFFER] =

      g_signal_new ("pull-buffer", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSinkClass,

          pull_buffer), NULL, NULL, gst_app_marshal_BUFFER__VOID,

      GST_TYPE_BUFFER, 0, G_TYPE_NONE);

  basesink_class->unlock = gst_app_sink_unlock_start;

  basesink_class->unlock_stop = gst_app_sink_unlock_stop;

  basesink_class->start = gst_app_sink_start;

  basesink_class->stop = gst_app_sink_stop;

  basesink_class->event = gst_app_sink_event;

  basesink_class->preroll = gst_app_sink_preroll;

  basesink_class->render = gst_app_sink_render;

  basesink_class->get_caps = gst_app_sink_getcaps;

  klass->pull_preroll = gst_app_sink_pull_preroll;

  klass->pull_buffer = gst_app_sink_pull_buffer;

  g_type_class_add_private (klass, sizeof (GstAppSinkPrivate));

}

static void

gst_app_sink_init (GstAppSink * appsink, GstAppSinkClass * klass)

{

  appsink->priv = G_TYPE_INSTANCE_GET_PRIVATE (appsink, GST_TYPE_APP_SINK,

      GstAppSinkPrivate);

  appsink->priv->mutex = g_mutex_new ();

  appsink->priv->cond = g_cond_new ();

  appsink->priv->queue = g_queue_new ();

  appsink->priv->emit_signals = DEFAULT_PROP_EMIT_SIGNALS;

  appsink->priv->max_buffers = DEFAULT_PROP_MAX_BUFFERS;

  appsink->priv->drop = DEFAULT_PROP_DROP;

}

static void

gst_app_sink_dispose (GObject * obj)

{

  GstAppSink *appsink = GST_APP_SINK (obj);

  GstBuffer *buffer;

  GST_OBJECT_LOCK (appsink);

  if (appsink->priv->caps) {

    gst_caps_unref (appsink->priv->caps);

    appsink->priv->caps = NULL;

  }

  if (appsink->priv->notify) {

    appsink->priv->notify (appsink->priv->user_data);

  }

  appsink->priv->user_data = NULL;

  appsink->priv->notify = NULL;

  GST_OBJECT_UNLOCK (appsink);

  g_mutex_lock (appsink->priv->mutex);

  if (appsink->priv->preroll) {

    gst_buffer_unref (appsink->priv->preroll);

    appsink->priv->preroll = NULL;

  }

  while ((buffer = g_queue_pop_head (appsink->priv->queue)))

    gst_buffer_unref (buffer);

  g_mutex_unlock (appsink->priv->mutex);

  G_OBJECT_CLASS (parent_class)->dispose (obj);

}

static void

gst_app_sink_finalize (GObject * obj)

{

  GstAppSink *appsink = GST_APP_SINK (obj);

  g_mutex_free (appsink->priv->mutex);

  g_cond_free (appsink->priv->cond);

  g_queue_free (appsink->priv->queue);

  G_OBJECT_CLASS (parent_class)->finalize (obj);

}

static void

gst_app_sink_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstAppSink *appsink = GST_APP_SINK (object);

  switch (prop_id) {

    case PROP_CAPS:

      gst_app_sink_set_caps (appsink, gst_value_get_caps (value));

      break;

    case PROP_EMIT_SIGNALS:

      gst_app_sink_set_emit_signals (appsink, g_value_get_boolean (value));

      break;

    case PROP_MAX_BUFFERS:

      gst_app_sink_set_max_buffers (appsink, g_value_get_uint (value));

      break;

    case PROP_DROP:

      gst_app_sink_set_drop (appsink, g_value_get_boolean (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_app_sink_get_property (GObject * object, guint prop_id, GValue * value,

    GParamSpec * pspec)

{

  GstAppSink *appsink = GST_APP_SINK (object);