/* GStreamer

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

 *                    2000 Wim Taymans <wim@fluendo.com>

 *

 * gstfakesrc.c:

 *

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

 * @see_also: #GstFakeSink

 *

 * The fakesrc element is a multipurpose element that can generate

 * a wide range of buffers and can operate in various scheduling modes.

 * It is mostly used as a testing element, one trivial example for testing

 * basic <application>GStreamer</application> core functionality is:

 * <title>Example launch line</title>

 * gst-launch -v fakesrc num-buffers=5 ! fakesink

 * sends an EOS.

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <stdlib.h>

#include <string.h>

#include "gstfakesrc.h"

#include <gst/gstmarshal.h>

static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS_ANY);

GST_DEBUG_CATEGORY_STATIC (gst_fake_src_debug);

#define GST_CAT_DEFAULT gst_fake_src_debug

/* FakeSrc signals and args */

enum

{

  /* FILL ME */

  SIGNAL_HANDOFF,

  LAST_SIGNAL

};

#define DEFAULT_OUTPUT          FAKE_SRC_FIRST_LAST_LOOP

#define DEFAULT_DATA            FAKE_SRC_DATA_ALLOCATE

#define DEFAULT_SIZETYPE        FAKE_SRC_SIZETYPE_EMPTY

#define DEFAULT_SIZEMIN         0

#define DEFAULT_SIZEMAX         4096

#define DEFAULT_FILLTYPE        FAKE_SRC_FILLTYPE_ZERO

#define DEFAULT_DATARATE        0

#define DEFAULT_SYNC            FALSE

#define DEFAULT_PATTERN         NULL

#define DEFAULT_EOS             FALSE

#define DEFAULT_SIGNAL_HANDOFFS FALSE

#define DEFAULT_SILENT          FALSE

#define DEFAULT_DUMP            FALSE

#define DEFAULT_PARENTSIZE      4096*10

#define DEFAULT_CAN_ACTIVATE_PULL TRUE

#define DEFAULT_CAN_ACTIVATE_PUSH TRUE

enum

{

  PROP_0,

  PROP_OUTPUT,

  PROP_DATA,

  PROP_SIZETYPE,

  PROP_SIZEMIN,

  PROP_SIZEMAX,

  PROP_FILLTYPE,

  PROP_DATARATE,

  PROP_SYNC,

  PROP_PATTERN,

  PROP_EOS,

  PROP_SIGNAL_HANDOFFS,

  PROP_SILENT,

  PROP_DUMP,

  PROP_PARENTSIZE,

  PROP_LAST_MESSAGE,

  PROP_CAN_ACTIVATE_PULL,

  PROP_CAN_ACTIVATE_PUSH,

};

/* not implemented

#define GST_TYPE_FAKE_SRC_OUTPUT (gst_fake_src_output_get_type())

static GType

gst_fake_src_output_get_type (void)

{

  static GType fakesrc_output_type = 0;

  static const GEnumValue fakesrc_output[] = {

    {FAKE_SRC_FIRST_LAST_LOOP, "1", "First-Last loop"},

    {FAKE_SRC_LAST_FIRST_LOOP, "2", "Last-First loop"},

    {FAKE_SRC_PING_PONG, "3", "Ping-Pong"},

    {FAKE_SRC_ORDERED_RANDOM, "4", "Ordered Random"},

    {FAKE_SRC_RANDOM, "5", "Random"},

    {FAKE_SRC_PATTERN_LOOP, "6", "Patttern loop"},

    {FAKE_SRC_PING_PONG_PATTERN, "7", "Ping-Pong Pattern"},

    {FAKE_SRC_GET_ALWAYS_SUCEEDS, "8", "'_get' Always succeeds"},

    {0, NULL, NULL},

  };

  if (!fakesrc_output_type) {

    fakesrc_output_type =

        g_enum_register_static ("GstFakeSrcOutput", fakesrc_output);

  }

  return fakesrc_output_type;

}

*/

#define GST_TYPE_FAKE_SRC_DATA (gst_fake_src_data_get_type())

static GType

gst_fake_src_data_get_type (void)

{

  static GType fakesrc_data_type = 0;

  static const GEnumValue fakesrc_data[] = {

    {FAKE_SRC_DATA_ALLOCATE, "Allocate data", "allocate"},

    {FAKE_SRC_DATA_SUBBUFFER, "Subbuffer data", "subbuffer"},

    {0, NULL, NULL},

  };

  if (!fakesrc_data_type) {

    fakesrc_data_type =

        g_enum_register_static ("GstFakeSrcDataType", fakesrc_data);

  }

  return fakesrc_data_type;

}

#define GST_TYPE_FAKE_SRC_SIZETYPE (gst_fake_src_sizetype_get_type())

static GType

gst_fake_src_sizetype_get_type (void)

{

  static GType fakesrc_sizetype_type = 0;

  static const GEnumValue fakesrc_sizetype[] = {

    {FAKE_SRC_SIZETYPE_EMPTY, "Send empty buffers", "empty"},

    {FAKE_SRC_SIZETYPE_FIXED, "Fixed size buffers (sizemax sized)", "fixed"},

    {FAKE_SRC_SIZETYPE_RANDOM,

        "Random sized buffers (sizemin <= size <= sizemax)", "random"},

    {0, NULL, NULL},

  };

  if (!fakesrc_sizetype_type) {

    fakesrc_sizetype_type =

        g_enum_register_static ("GstFakeSrcSizeType", fakesrc_sizetype);

  }

  return fakesrc_sizetype_type;

}

#define GST_TYPE_FAKE_SRC_FILLTYPE (gst_fake_src_filltype_get_type())

static GType

gst_fake_src_filltype_get_type (void)

{

  static GType fakesrc_filltype_type = 0;

  static const GEnumValue fakesrc_filltype[] = {

    {FAKE_SRC_FILLTYPE_NOTHING, "Leave data as malloced", "nothing"},

    {FAKE_SRC_FILLTYPE_ZERO, "Fill buffers with zeros", "zero"},

    {FAKE_SRC_FILLTYPE_RANDOM, "Fill buffers with random crap", "random"},

    {FAKE_SRC_FILLTYPE_PATTERN, "Fill buffers with pattern 0x00 -> 0xff",

        "pattern"},

    {FAKE_SRC_FILLTYPE_PATTERN_CONT,

          "Fill buffers with pattern 0x00 -> 0xff that spans buffers",

        "pattern-span"},

    {0, NULL, NULL},

  };

  if (!fakesrc_filltype_type) {

    fakesrc_filltype_type =

        g_enum_register_static ("GstFakeSrcFillType", fakesrc_filltype);

  }

  return fakesrc_filltype_type;

}

#define _do_init(bla) \

    GST_DEBUG_CATEGORY_INIT (gst_fake_src_debug, "fakesrc", 0, "fakesrc element");

GST_BOILERPLATE_FULL (GstFakeSrc, gst_fake_src, GstBaseSrc, GST_TYPE_BASE_SRC,

    _do_init);

static void gst_fake_src_finalize (GObject * object);

static void gst_fake_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_fake_src_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static gboolean gst_fake_src_start (GstBaseSrc * basesrc);

static gboolean gst_fake_src_stop (GstBaseSrc * basesrc);

static gboolean gst_fake_src_is_seekable (GstBaseSrc * basesrc);

static gboolean gst_fake_src_event_handler (GstBaseSrc * src, GstEvent * event);

static void gst_fake_src_get_times (GstBaseSrc * basesrc, GstBuffer * buffer,

    GstClockTime * start, GstClockTime * end);

static GstFlowReturn gst_fake_src_create (GstBaseSrc * src, guint64 offset,

    guint length, GstBuffer ** buf);

static guint gst_fake_src_signals[LAST_SIGNAL] = { 0 };

static void

gst_fake_src_base_init (gpointer g_class)

{

  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_set_details_simple (gstelement_class,

      "Fake Source",

      "Source",

      "Push empty (no data) buffers around",

      "Erik Walthinsen <omega@cse.ogi.edu>, " "Wim Taymans <wim@fluendo.com>");

  gst_element_class_add_pad_template (gstelement_class,

      gst_static_pad_template_get (&srctemplate));

}

static void

gst_fake_src_class_init (GstFakeSrcClass * klass)

{

  GObjectClass *gobject_class;

  GstBaseSrcClass *gstbase_src_class;

  gobject_class = G_OBJECT_CLASS (klass);

  gstbase_src_class = GST_BASE_SRC_CLASS (klass);

  gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_fake_src_finalize);

  gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_fake_src_set_property);

  gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_fake_src_get_property);

/*

  FIXME: this is not implemented; would make sense once basesrc and fakesrc

  support multiple pads

  g_object_class_install_property (gobject_class, PROP_OUTPUT,

      g_param_spec_enum ("output", "output", "Output method (currently unused)",

          GST_TYPE_FAKE_SRC_OUTPUT, DEFAULT_OUTPUT, G_PARAM_READWRITE));

*/

  g_object_class_install_property (gobject_class, PROP_DATA,

      g_param_spec_enum ("data", "data", "Data allocation method",

  g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SIZETYPE,

      g_param_spec_enum ("sizetype", "sizetype",

          "How to determine buffer sizes", GST_TYPE_FAKE_SRC_SIZETYPE,

  g_object_class_install_property (gobject_class, PROP_SIZEMIN,

      g_param_spec_int ("sizemin", "sizemin", "Minimum buffer size", 0,

  g_object_class_install_property (gobject_class, PROP_SIZEMAX,

      g_param_spec_int ("sizemax", "sizemax", "Maximum buffer size", 0,

  g_object_class_install_property (gobject_class, PROP_PARENTSIZE,

      g_param_spec_int ("parentsize", "parentsize",

          "Size of parent buffer for sub-buffered allocation", 0, G_MAXINT,

  g_object_class_install_property (gobject_class, PROP_FILLTYPE,

      g_param_spec_enum ("filltype", "filltype",

          "How to fill the buffer, if at all", GST_TYPE_FAKE_SRC_FILLTYPE,

  g_object_class_install_property (gobject_class, PROP_DATARATE,

      g_param_spec_int ("datarate", "Datarate",

          "Timestamps buffers with number of bytes per second (0 = none)", 0,

  g_object_class_install_property (gobject_class, PROP_SYNC,

      g_param_spec_boolean ("sync", "Sync", "Sync to the clock to the datarate",

  g_object_class_install_property (gobject_class, PROP_PATTERN,

      g_param_spec_string ("pattern", "pattern", "pattern", DEFAULT_PATTERN,

  g_object_class_install_property (gobject_class, PROP_LAST_MESSAGE,

      g_param_spec_string ("last-message", "last-message",

  g_object_class_install_property (gobject_class, PROP_SILENT,

      g_param_spec_boolean ("silent", "Silent",

          "Don't produce last_message events", DEFAULT_SILENT,

  g_object_class_install_property (gobject_class, PROP_SIGNAL_HANDOFFS,

      g_param_spec_boolean ("signal-handoffs", "Signal handoffs",

          "Send a signal before pushing the buffer", DEFAULT_SIGNAL_HANDOFFS,

  g_object_class_install_property (gobject_class, PROP_DUMP,

      g_param_spec_boolean ("dump", "Dump", "Dump buffer contents to stdout",

      g_param_spec_boolean ("can-activate-push", "Can activate push",

          "Can activate in push mode", DEFAULT_CAN_ACTIVATE_PUSH,

      g_param_spec_boolean ("can-activate-pull", "Can activate pull",

          "Can activate in pull mode", DEFAULT_CAN_ACTIVATE_PULL,

  g_object_class_install_property (gobject_class, PROP_IS_LIVE,

      g_param_spec_boolean ("is-live", "Is this a live source",

          "True if the element cannot produce data in PAUSED", FALSE,

  /**

   * GstFakeSrc::handoff:

   * @fakesrc: the fakesrc instance

   * @buffer: the buffer that will be pushed

   * @pad: the pad that will sent it

   *

   * This signal gets emitted before sending the buffer.

   */

  gst_fake_src_signals[SIGNAL_HANDOFF] =

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

      G_STRUCT_OFFSET (GstFakeSrcClass, handoff), NULL, NULL,

      GST_TYPE_PAD);

  gstbase_src_class->is_seekable = GST_DEBUG_FUNCPTR (gst_fake_src_is_seekable);

  gstbase_src_class->start = GST_DEBUG_FUNCPTR (gst_fake_src_start);

  gstbase_src_class->stop = GST_DEBUG_FUNCPTR (gst_fake_src_stop);

  gstbase_src_class->event = GST_DEBUG_FUNCPTR (gst_fake_src_event_handler);

  gstbase_src_class->get_times = GST_DEBUG_FUNCPTR (gst_fake_src_get_times);

  gstbase_src_class->create = GST_DEBUG_FUNCPTR (gst_fake_src_create);

}

static void

gst_fake_src_init (GstFakeSrc * fakesrc, GstFakeSrcClass * g_class)

{

  fakesrc->output = FAKE_SRC_FIRST_LAST_LOOP;

  fakesrc->buffer_count = 0;

  fakesrc->silent = DEFAULT_SILENT;

  fakesrc->signal_handoffs = DEFAULT_SIGNAL_HANDOFFS;

  fakesrc->dump = DEFAULT_DUMP;

  fakesrc->pattern_byte = 0x00;

  fakesrc->data = FAKE_SRC_DATA_ALLOCATE;

  fakesrc->sizetype = FAKE_SRC_SIZETYPE_EMPTY;

  fakesrc->filltype = FAKE_SRC_FILLTYPE_NOTHING;

  fakesrc->sizemin = DEFAULT_SIZEMIN;

  fakesrc->sizemax = DEFAULT_SIZEMAX;

  fakesrc->parent = NULL;

  fakesrc->parentsize = DEFAULT_PARENTSIZE;

  fakesrc->last_message = NULL;

  fakesrc->datarate = DEFAULT_DATARATE;

  fakesrc->sync = DEFAULT_SYNC;

}

static void

gst_fake_src_finalize (GObject * object)

{

  GstFakeSrc *src;

  src = GST_FAKE_SRC (object);

  g_free (src->last_message);

  if (src->parent) {

    gst_buffer_unref (src->parent);

    src->parent = NULL;

  }

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static gboolean

gst_fake_src_event_handler (GstBaseSrc * basesrc, GstEvent * event)

{

  GstFakeSrc *src;

  src = GST_FAKE_SRC (basesrc);

  if (!src->silent) {

    const GstStructure *s;

    gchar *sstr;

    GST_OBJECT_LOCK (src);

    g_free (src->last_message);

    if ((s = gst_event_get_structure (event)))

      sstr = gst_structure_to_string (s);

    else

      sstr = g_strdup ("");

    src->last_message =

        g_strdup_printf ("event   ******* E (type: %d, %s) %p",

        GST_EVENT_TYPE (event), sstr, event);

    g_free (sstr);

    GST_OBJECT_UNLOCK (src);

    g_object_notify (G_OBJECT (src), "last_message");

  }

}

static void

gst_fake_src_alloc_parent (GstFakeSrc * src)

{

  GstBuffer *buf;

  buf = gst_buffer_new ();

  GST_BUFFER_DATA (buf) = g_malloc (src->parentsize);

  GST_BUFFER_MALLOCDATA (buf) = GST_BUFFER_DATA (buf);

  GST_BUFFER_SIZE (buf) = src->parentsize;

  src->parent = buf;

  src->parentoffset = 0;

}

static void

gst_fake_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstFakeSrc *src;

  GstBaseSrc *basesrc;

  src = GST_FAKE_SRC (object);

  basesrc = GST_BASE_SRC (object);

  switch (prop_id) {

    case PROP_OUTPUT:

      g_warning ("not yet implemented");

      break;

    case PROP_DATA:

      src->data = g_value_get_enum (value);

      if (src->data == FAKE_SRC_DATA_SUBBUFFER) {

        if (!src->parent)

          gst_fake_src_alloc_parent (src);

      } else {

        if (src->parent) {

          gst_buffer_unref (src->parent);

          src->parent = NULL;

        }

      }

      break;

    case PROP_SIZETYPE:

      src->sizetype = g_value_get_enum (value);

      break;

    case PROP_SIZEMIN:

      src->sizemin = g_value_get_int (value);

      break;

    case PROP_SIZEMAX:

      src->sizemax = g_value_get_int (value);

      break;

    case PROP_PARENTSIZE:

      src->parentsize = g_value_get_int (value);

      break;

    case PROP_FILLTYPE:

      src->filltype = g_value_get_enum (value);

      break;

    case PROP_DATARATE:

      src->datarate = g_value_get_int (value);

      break;

    case PROP_SYNC:

      src->sync = g_value_get_boolean (value);

      break;

    case PROP_PATTERN:

      break;

    case PROP_SILENT:

      src->silent = g_value_get_boolean (value);

      break;

    case PROP_SIGNAL_HANDOFFS:

      src->signal_handoffs = g_value_get_boolean (value);

      break;

    case PROP_DUMP:

      src->dump = g_value_get_boolean (value);

      break;

    case PROP_CAN_ACTIVATE_PUSH:

      g_return_if_fail (!GST_OBJECT_FLAG_IS_SET (object, GST_BASE_SRC_STARTED));

      GST_BASE_SRC (src)->can_activate_push = g_value_get_boolean (value);

      break;

    case PROP_CAN_ACTIVATE_PULL:

      g_return_if_fail (!GST_OBJECT_FLAG_IS_SET (object, GST_BASE_SRC_STARTED));

      src->can_activate_pull = g_value_get_boolean (value);

      break;

    case PROP_IS_LIVE:

      gst_base_src_set_live (basesrc, g_value_get_boolean (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

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

    GParamSpec * pspec)

{

  GstFakeSrc *src;

  GstBaseSrc *basesrc;