/* 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-appsrc

 *

 * The appsrc element can be used by applications to insert data into a

 * GStreamer pipeline. Unlike most GStreamer elements, Appsrc provides

 * external API functions.

 *

 * For the documentation of the API, please see the

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

 * GStreamer Plugins Base Libraries documentation.

 * 

 * Since: 0.10.22

 */

/**

 * SECTION:gstappsrc

 * @see_also: #GstBaseSrc, appsink

 *

 * The appsrc element can be used by applications to insert data into a

 * GStreamer pipeline. Unlike most GStreamer elements, Appsrc provides

 * external API functions.

 *

 * appsrc can be used by linking to the gstappsrc.h header file to access the

 * methods or by using the appsrc action signals. For the API

 * documentation, see the documentation for libgstapp in the

 * GStreamer Base Plugins Library reference...

 *

 * Before operating appsrc, the caps property must be set to a fixed caps

 * describing the format of the data that will be pushed with appsrc.

 *

 * The main way of handing data to the appsrc element is by calling the

 * gst_app_src_push_buffer() method or by emiting the push-buffer action signal.

 * This will put the buffer onto a queue from which appsrc will read from in its

 * streaming thread. It is important to note that data transport will not happen

 * from the thread that performed the push-buffer call.

 *

 * The "max-bytes" property controls how much data can be queued in appsrc

 * before appsrc considers the queue full. A filled internal queue will always

 * signal the "enough-data" signal, which signals the application that it should

 * stop pushing data into appsrc. The "block" property will cause appsrc to

 * block the push-buffer method until free data becomes available again.

 *

 * When the internal queue is running out of data, the "need-data" signal is

 * emited, which signals the application that it should start pushing more data

 * into appsrc.

 *

 * In addition to the "need-data" and "enough-data" signals, appsrc can emit the

 * "seek-data" signal when the "stream-mode" property is set to "seekable" or

 * "random-access". The signal argument will contain the new desired position in

 * the stream expressed in the unit set with the "format" property. After

 * receiving the seek-data signal, the application should push-buffers from the

 * new position.

 *

 * These signals allow the application to operate the appsrc in two different

 * ways:

 *

 * The push model, in which the application repeadedly calls the push-buffer method

 * with a new buffer. Optionally, the queue size in the appsrc can be controlled

 * with the enough-data and need-data signals by respectively stopping/starting

 * the push-buffer calls. This is a typical mode of operation for the

 * stream-type "stream" and "seekable". Use this model when implementing various

 * network protocols or hardware devices.

 *

 * The pull model where the need-data signal triggers the next push-buffer call.

 * This mode is typically used in the "random-access" stream-type. Use this

 * model for file access or other randomly accessable sources. In this mode, a

 * buffer of exactly the amount of bytes given by the need-data signal should be

 * pushed into appsrc.

 *

 * In all modes, the size property on appsrc should contain the total stream

 * size in bytes. Setting this property is mandatory in the random-access mode.

 * For the stream and seekable modes, setting this property is optional but

 * recommended.

 *

 * When the application is finished pushing data into appsrc, it should call 

 * gst_app_src_end_of_stream() or emit the end-of-stream action signal. After

 * this call, no more buffers can be pushed into appsrc until a flushing seek

 * happened or the state of the appsrc has gone through READY.

 *

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

 *

 * Since: 0.10.22

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/gst.h>

#include <gst/base/gstbasesrc.h>

#include <string.h>

#include "gstapp-marshal.h"

#include "gstappsrc.h"

struct _GstAppSrcPrivate

{

  GCond *cond;

  GMutex *mutex;

  GQueue *queue;

  GstCaps *caps;

  gint64 size;

  GstAppStreamType stream_type;

  guint64 max_bytes;

  GstFormat format;

  gboolean block;

  gboolean flushing;

  gboolean started;

  gboolean is_eos;

  guint64 queued_bytes;

  guint64 offset;

  GstAppStreamType current_type;

  guint64 min_latency;

  guint64 max_latency;

  gboolean emit_signals;

  GstAppSrcCallbacks callbacks;

  gpointer user_data;

  GDestroyNotify notify;

};

GST_DEBUG_CATEGORY_STATIC (app_src_debug);

#define GST_CAT_DEFAULT app_src_debug

enum

{

  /* signals */

  SIGNAL_NEED_DATA,

  SIGNAL_ENOUGH_DATA,

  SIGNAL_SEEK_DATA,

  /* actions */

  SIGNAL_PUSH_BUFFER,

  SIGNAL_END_OF_STREAM,

  LAST_SIGNAL

};

#define DEFAULT_PROP_SIZE          -1

#define DEFAULT_PROP_STREAM_TYPE   GST_APP_STREAM_TYPE_STREAM

#define DEFAULT_PROP_MAX_BYTES     200000

#define DEFAULT_PROP_FORMAT        GST_FORMAT_BYTES

#define DEFAULT_PROP_BLOCK         FALSE

#define DEFAULT_PROP_IS_LIVE       FALSE

#define DEFAULT_PROP_MIN_LATENCY   -1

#define DEFAULT_PROP_MAX_LATENCY   -1

#define DEFAULT_PROP_EMIT_SIGNALS  TRUE

enum

{

  PROP_0,

  PROP_CAPS,

  PROP_SIZE,

  PROP_STREAM_TYPE,

  PROP_MAX_BYTES,

  PROP_FORMAT,

  PROP_BLOCK,

  PROP_IS_LIVE,

  PROP_MIN_LATENCY,

  PROP_MAX_LATENCY,

  PROP_EMIT_SIGNALS,

  PROP_LAST

};

static GstStaticPadTemplate gst_app_src_template =

GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS_ANY);

#define GST_TYPE_APP_STREAM_TYPE (stream_type_get_type ())

static GType

stream_type_get_type (void)

{

  static GType stream_type_type = 0;

  static const GEnumValue stream_type[] = {

    {GST_APP_STREAM_TYPE_STREAM, "Stream", "stream"},

    {GST_APP_STREAM_TYPE_SEEKABLE, "Seekable", "seekable"},

    {GST_APP_STREAM_TYPE_RANDOM_ACCESS, "Random Access", "random-access"},

    {0, NULL, NULL},

  };

  if (!stream_type_type) {

    stream_type_type = g_enum_register_static ("GstAppStreamType", stream_type);

  }

  return stream_type_type;

}

static void gst_app_src_uri_handler_init (gpointer g_iface,

    gpointer iface_data);

static void gst_app_src_dispose (GObject * object);

static void gst_app_src_finalize (GObject * object);

#ifdef __SYMBIAN32__

static void gst_app_src_base_init (gpointer g_class);

static void gst_app_src_class_init (GstAppSrcClass * klass);

static void gst_app_src_init (GstAppSrc * appsrc, GstAppSrcClass * klass);

#endif

static void gst_app_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_app_src_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static void gst_app_src_set_latencies (GstAppSrc * appsrc,

    gboolean do_min, guint64 min, gboolean do_max, guint64 max);

static GstFlowReturn gst_app_src_create (GstBaseSrc * bsrc,

    guint64 offset, guint size, GstBuffer ** buf);

static gboolean gst_app_src_start (GstBaseSrc * bsrc);

static gboolean gst_app_src_stop (GstBaseSrc * bsrc);

static gboolean gst_app_src_unlock (GstBaseSrc * bsrc);

static gboolean gst_app_src_unlock_stop (GstBaseSrc * bsrc);

static gboolean gst_app_src_do_seek (GstBaseSrc * src, GstSegment * segment);

static gboolean gst_app_src_is_seekable (GstBaseSrc * src);

static gboolean gst_app_src_check_get_range (GstBaseSrc * src);

static gboolean gst_app_src_do_get_size (GstBaseSrc * src, guint64 * size);

static gboolean gst_app_src_query (GstBaseSrc * src, GstQuery * query);

static GstFlowReturn gst_app_src_push_buffer_action (GstAppSrc * appsrc,

    GstBuffer * buffer);

static guint gst_app_src_signals[LAST_SIGNAL] = { 0 };

static void

_do_init (GType filesrc_type)

{

  static const GInterfaceInfo urihandler_info = {

    gst_app_src_uri_handler_init,

    NULL,

    NULL

  };

  g_type_add_interface_static (filesrc_type, GST_TYPE_URI_HANDLER,

      &urihandler_info);

}

#ifndef __SYMBIAN32__

GST_BOILERPLATE_FULL (GstAppSrc, gst_app_src, GstBaseSrc, GST_TYPE_BASE_SRC,

    _do_init);

#else

static GstBaseSrcClass *parent_class = NULL;           

static void

gst_app_src_class_init_trampoline (gpointer g_class,

                        gpointer data)

{                                   

  parent_class = (GstBaseSrcClass *)               

      g_type_class_peek_parent (g_class);              

      gst_app_src_class_init ((GstAppSrcClass *)g_class);       

}

EXPORT_C GType

gst_app_src_get_type (void)

{

static GType object_type = 0;                      

 if (G_UNLIKELY (object_type == 0)) {                  

   object_type = gst_type_register_static_full(GST_TYPE_BASE_SRC,

       "GstAppSrc",

       sizeof (GstAppSrcClass),

       (GBaseInitFunc) gst_app_src_base_init,

       NULL,

       (GClassInitFunc) gst_app_src_class_init_trampoline,

       NULL,       

       NULL,

       sizeof (GstAppSrc),   

       0,

       (GInstanceInitFunc) gst_app_src_init,

       NULL,        

       (GTypeFlags) 0);

     _do_init (object_type);               

 }                                 

 return object_type;               

}

#endif

static void

gst_app_src_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  GST_DEBUG_CATEGORY_INIT (app_src_debug, "appsrc", 0, "appsrc element");

  gst_element_class_set_details_simple (element_class, "AppSrc",

      "Generic/Src", "Allow the application to feed buffers to a pipeline",

      "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_src_template));

}

static void

gst_app_src_class_init (GstAppSrcClass * klass)

{

  GObjectClass *gobject_class = (GObjectClass *) klass;

  GstBaseSrcClass *basesrc_class = (GstBaseSrcClass *) klass;

  gobject_class->dispose = gst_app_src_dispose;

  gobject_class->finalize = gst_app_src_finalize;

  gobject_class->set_property = gst_app_src_set_property;

  gobject_class->get_property = gst_app_src_get_property;

  /**

   * GstAppSrc::caps

   *

   * The GstCaps that will negotiated downstream and will be put

   * on outgoing buffers.

   */

  g_object_class_install_property (gobject_class, PROP_CAPS,

      g_param_spec_boxed ("caps", "Caps",

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

  /**

   * GstAppSrc::format

   *

   * The format to use for segment events. When the source is producing

   * timestamped buffers this property should be set to GST_FORMAT_TIME.

   */

  g_object_class_install_property (gobject_class, PROP_FORMAT,

      g_param_spec_enum ("format", "Format",

          "The format of the segment events and seek", GST_TYPE_FORMAT,

  /**

   * GstAppSrc::size

   *

   * The total size in bytes of the data stream. If the total size is known, it

   * is recommended to configure it with this property.

   */

  g_object_class_install_property (gobject_class, PROP_SIZE,

      g_param_spec_int64 ("size", "Size",

          "The size of the data stream in bytes (-1 if unknown)",

          -1, G_MAXINT64, DEFAULT_PROP_SIZE,

  /**

   * GstAppSrc::stream-type

   *

   * The type of stream that this source is producing.  For seekable streams the

   * application should connect to the seek-data signal.

   */

  g_object_class_install_property (gobject_class, PROP_STREAM_TYPE,

      g_param_spec_enum ("stream-type", "Stream Type",

          "the type of the stream", GST_TYPE_APP_STREAM_TYPE,

          DEFAULT_PROP_STREAM_TYPE,

  /**

   * GstAppSrc::max-bytes

   *

   * The maximum amount of bytes that can be queued internally.

   * After the maximum amount of bytes are queued, appsrc will emit the

   * "enough-data" signal.

   */

  g_object_class_install_property (gobject_class, PROP_MAX_BYTES,

      g_param_spec_uint64 ("max-bytes", "Max bytes",

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

          0, G_MAXUINT64, DEFAULT_PROP_MAX_BYTES,

  /**

   * GstAppSrc::block

   *

   * When max-bytes are queued and after the enough-data signal has been emited,

   * block any further push-buffer calls until the amount of queued bytes drops

   * below the max-bytes limit.

   */

  g_object_class_install_property (gobject_class, PROP_BLOCK,

      g_param_spec_boolean ("block", "Block",

          "Block push-buffer when max-bytes are queued",

  /**

   * GstAppSrc::is-live

   *

   * Instruct the source to behave like a live source. This includes that it

   * will only push out buffers in the PLAYING state.

   */

  g_object_class_install_property (gobject_class, PROP_IS_LIVE,

      g_param_spec_boolean ("is-live", "Is Live",

          "Whether to act as a live source",

  /**

   * GstAppSrc::min-latency

   *

   * The minimum latency of the source. A value of -1 will use the default

   * latency calculations of #GstBaseSrc.

   */

  g_object_class_install_property (gobject_class, PROP_MIN_LATENCY,

      g_param_spec_int64 ("min-latency", "Min Latency",

          "The minimum latency (-1 = default)",

          -1, G_MAXINT64, DEFAULT_PROP_MIN_LATENCY,

  /**

   * GstAppSrc::max-latency

   *

   * The maximum latency of the source. A value of -1 means an unlimited amout

   * of latency.

   */

  g_object_class_install_property (gobject_class, PROP_MAX_LATENCY,

      g_param_spec_int64 ("max-latency", "Max Latency",

          "The maximum latency (-1 = unlimited)",

          -1, G_MAXINT64, DEFAULT_PROP_MAX_LATENCY,

  /**

   * GstAppSrc::emit-signals

   *

   * Make appsrc emit the "need-data", "enough-data" and "seek-data" signals.

   * This option is by default enabled for backwards compatibility reasons but

   * can disabled when needed because signal emission is expensive.

   *

   * Since: 0.10.23

   */

  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,

  /**

   * GstAppSrc::need-data:

   * @appsrc: the appsrc element that emited the signal

   * @length: the amount of bytes needed.

   *

   * Signal that the source needs more data. In the callback or from another

   * thread you should call push-buffer or end-of-stream.

   *

   * @length is just a hint and when it is set to -1, any number of bytes can be

   * pushed into @appsrc.

   *

   * You can call push-buffer multiple times until the enough-data signal is

   * fired.

   */

  gst_app_src_signals[SIGNAL_NEED_DATA] =

      g_signal_new ("need-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstAppSrcClass, need_data),

      NULL, NULL, __gst_app_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);

  /**

   * GstAppSrc::enough-data:

   * @appsrc: the appsrc element that emited the signal

   *

   * Signal that the source has enough data. It is recommended that the

   * application stops calling push-buffer until the need-data signal is

   * emited again to avoid excessive buffer queueing.

   */

  gst_app_src_signals[SIGNAL_ENOUGH_DATA] =

      g_signal_new ("enough-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstAppSrcClass, enough_data),

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

  /**

   * GstAppSrc::seek-data:

   * @appsrc: the appsrc element that emited the signal

   * @offset: the offset to seek to

   *

   * Seek to the given offset. The next push-buffer should produce buffers from

   * the new @offset.

   * This callback is only called for seekable stream types.

   *

   * Returns: %TRUE if the seek succeeded.

   */

  gst_app_src_signals[SIGNAL_SEEK_DATA] =

      g_signal_new ("seek-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstAppSrcClass, seek_data),

      NULL, NULL, __gst_app_marshal_BOOLEAN__UINT64, G_TYPE_BOOLEAN, 1,

      G_TYPE_UINT64);

   /**

    * GstAppSrc::push-buffer:

    * @appsrc: the appsrc

    * @buffer: a buffer to push

    *

    * Adds a buffer to the queue of buffers that the appsrc element will

    * push to its source pad. This function does not take ownership of the

    * buffer so the buffer needs to be unreffed after calling this function.

    *

    * When the block property is TRUE, this function can block until free space

    * becomes available in the queue.

    */

  gst_app_src_signals[SIGNAL_PUSH_BUFFER] =

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

      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSrcClass,

          push_buffer), NULL, NULL, __gst_app_marshal_ENUM__OBJECT,

      GST_TYPE_FLOW_RETURN, 1, GST_TYPE_BUFFER);

   /**

    * GstAppSrc::end-of-stream:

    * @appsrc: the appsrc

    *

    * Notify @appsrc that no more buffer are available. 

    */

  gst_app_src_signals[SIGNAL_END_OF_STREAM] =

      g_signal_new ("end-of-stream", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSrcClass,

          end_of_stream), NULL, NULL, __gst_app_marshal_ENUM__VOID,

      GST_TYPE_FLOW_RETURN, 0, G_TYPE_NONE);