/* 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:element-fakesrc

 * @title: 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:

 *

 * ## Example launch line

 * |[

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

 * ]| This pipeline will push 5 empty buffers to the fakesink element and then

 * sends an EOS.

 *

 */

/* FIXME: this ignores basesrc::blocksize property, which could be used as an

 * alias to ::sizemax (see gst_base_src_get_blocksize()).

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <stdlib.h>

#include <string.h>

#include "gstelements_private.h"

#include "gstfakesrc.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          TRUE

#define DEFAULT_DUMP            FALSE

#define DEFAULT_PARENTSIZE      4096*10

#define DEFAULT_CAN_ACTIVATE_PULL TRUE

#define DEFAULT_CAN_ACTIVATE_PUSH TRUE

#define DEFAULT_FORMAT          GST_FORMAT_BYTES

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,

  PROP_IS_LIVE,

  PROP_FORMAT,

  PROP_LAST,

};

/* 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 ("GstFakeSrcOutputType", 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 data", "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 \

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

#define gst_fake_src_parent_class parent_class

G_DEFINE_TYPE_WITH_CODE (GstFakeSrc, gst_fake_src, 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 GParamSpec *pspec_last_message = NULL;

static void

gst_fake_src_class_init (GstFakeSrcClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  GstBaseSrcClass *gstbase_src_class;

  gobject_class = G_OBJECT_CLASS (klass);

  gstelement_class = GST_ELEMENT_CLASS (klass);

  gstbase_src_class = GST_BASE_SRC_CLASS (klass);

  gobject_class->finalize = gst_fake_src_finalize;

  gobject_class->set_property = gst_fake_src_set_property;

  gobject_class->get_property = 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",

          GST_TYPE_FAKE_SRC_DATA, DEFAULT_DATA,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  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,

          DEFAULT_SIZETYPE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_SIZEMIN,

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

          G_MAXINT, DEFAULT_SIZEMIN,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_SIZEMAX,

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

          G_MAXINT, DEFAULT_SIZEMAX,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  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,

          DEFAULT_PARENTSIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  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,

          DEFAULT_FILLTYPE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  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_MAXINT, DEFAULT_DATARATE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_SYNC,

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

          DEFAULT_SYNC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /*  FIXME 2.0: Remove unused pattern property. Not implemented */

  g_object_class_install_property (gobject_class, PROP_PATTERN,

      g_param_spec_string ("pattern", "pattern", "Set the pattern (unused)",

          DEFAULT_PATTERN, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  pspec_last_message = g_param_spec_string ("last-message", "last-message",

      "The last status message", NULL,

      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

  g_object_class_install_property (gobject_class, PROP_LAST_MESSAGE,

      pspec_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_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  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_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_DUMP,

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

          DEFAULT_DUMP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_CAN_ACTIVATE_PUSH,

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

          "Can activate in push mode", DEFAULT_CAN_ACTIVATE_PUSH,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_CAN_ACTIVATE_PULL,

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

          "Can activate in pull mode", DEFAULT_CAN_ACTIVATE_PULL,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

  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,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

  /**

   * GstFakeSrc:format

   *

   * Set the format of the newsegment events to produce.

   */

  g_object_class_install_property (gobject_class, PROP_FORMAT,

      g_param_spec_enum ("format", "Format",

          "The format of the segment events", GST_TYPE_FORMAT,

          DEFAULT_FORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

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

      g_cclosure_marshal_generic, G_TYPE_NONE, 2,

      GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE, GST_TYPE_PAD);

  gst_element_class_set_static_metadata (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_static_pad_template (gstelement_class, &srctemplate);

  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)

{

  fakesrc->output = FAKE_SRC_FIRST_LAST_LOOP;

  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;

  fakesrc->format = DEFAULT_FORMAT;

}

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;

    const gchar *tstr;

    gchar *sstr;

    GST_OBJECT_LOCK (src);

    g_free (src->last_message);

    tstr = gst_event_type_get_name (GST_EVENT_TYPE (event));

    if ((s = gst_event_get_structure (event)))

      sstr = gst_structure_to_string (s);

    else

      sstr = g_strdup ("");

    src->last_message =

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

        GST_DEBUG_PAD_NAME (GST_BASE_SRC_CAST (src)->srcpad),

        tstr, GST_EVENT_TYPE (event), sstr, event);

    g_free (sstr);

    GST_OBJECT_UNLOCK (src);

    g_object_notify_by_pspec ((GObject *) src, pspec_last_message);

  }

  return GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event);

}

static void

gst_fake_src_alloc_parent (GstFakeSrc * src)

{

  GstBuffer *buf;

  buf = gst_buffer_new_allocate (NULL, src->parentsize, NULL);

  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 = (GstFakeSrcDataType) 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 = (GstFakeSrcSizeType) 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 = (GstFakeSrcFillType) 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_FLAG_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_FLAG_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;

    case PROP_FORMAT:

      src->format = (GstFormat) g_value_get_enum (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;

  g_return_if_fail (GST_IS_FAKE_SRC (object));

  src = GST_FAKE_SRC (object);

  basesrc = GST_BASE_SRC (object);

  switch (prop_id) {

    case PROP_OUTPUT:

      g_value_set_enum (value, src->output);

      break;

    case PROP_DATA:

      g_value_set_enum (value, src->data);

      break;

    case PROP_SIZETYPE:

      g_value_set_enum (value, src->sizetype);

      break;

    case PROP_SIZEMIN:

      g_value_set_int (value, src->sizemin);

      break;

    case PROP_SIZEMAX:

      g_value_set_int (value, src->sizemax);

      break;

    case PROP_PARENTSIZE:

      g_value_set_int (value, src->parentsize);

      break;

    case PROP_FILLTYPE:

      g_value_set_enum (value, src->filltype);

      break;

    case PROP_DATARATE:

      g_value_set_int (value, src->datarate);

      break;

    case PROP_SYNC:

      g_value_set_boolean (value, src->sync);

      break;

    case PROP_PATTERN:

      break;

    case PROP_SILENT:

      g_value_set_boolean (value, src->silent);

      break;

    case PROP_SIGNAL_HANDOFFS:

      g_value_set_boolean (value, src->signal_handoffs);

      break;

    case PROP_DUMP:

      g_value_set_boolean (value, src->dump);

      break;

    case PROP_LAST_MESSAGE:

      GST_OBJECT_LOCK (src);

      g_value_set_string (value, src->last_message);

      GST_OBJECT_UNLOCK (src);

      break;

    case PROP_CAN_ACTIVATE_PUSH:

      g_value_set_boolean (value, GST_BASE_SRC (src)->can_activate_push);

      break;

    case PROP_CAN_ACTIVATE_PULL:

      g_value_set_boolean (value, src->can_activate_pull);

      break;

    case PROP_IS_LIVE:

      g_value_set_boolean (value, gst_base_src_is_live (basesrc));

      break;

    case PROP_FORMAT:

      g_value_set_enum (value, src->format);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_fake_src_prepare_buffer (GstFakeSrc * src, guint8 * data, gsize size)

{

  if (size == 0)

    return;

  switch (src->filltype) {

    case FAKE_SRC_FILLTYPE_ZERO:

      memset (data, 0, size);

      break;

    case FAKE_SRC_FILLTYPE_RANDOM:

    {

      gint i;

      guint8 *ptr = data;

      for (i = size; i; i--) {

        *ptr++ = g_random_int_range (0, 256);

      }

      break;

    }

    case FAKE_SRC_FILLTYPE_PATTERN:

      src->pattern_byte = 0x00;

    case FAKE_SRC_FILLTYPE_PATTERN_CONT:

    {

      gint i;

      guint8 *ptr = data;

      for (i = size; i; i--) {

        *ptr++ = src->pattern_byte++;

      }

      break;

    }

    case FAKE_SRC_FILLTYPE_NOTHING:

    default:

      break;

  }

}

static GstBuffer *

gst_fake_src_alloc_buffer (GstFakeSrc * src, guint size)

{

  GstBuffer *buf;

  gpointer data;

  gboolean do_prepare = FALSE;

  buf = gst_buffer_new ();

  if (size != 0) {

    switch (src->filltype) {

      case FAKE_SRC_FILLTYPE_NOTHING:

        data = g_malloc (size);

        break;

      case FAKE_SRC_FILLTYPE_ZERO:

        data = g_malloc0 (size);

        break;

      case FAKE_SRC_FILLTYPE_RANDOM:

      case FAKE_SRC_FILLTYPE_PATTERN:

      case FAKE_SRC_FILLTYPE_PATTERN_CONT:

      default:

        data = g_malloc (size);

        do_prepare = TRUE;

        break;

    }

    if (do_prepare)

      gst_fake_src_prepare_buffer (src, data, size);

    gst_buffer_append_memory (buf,

        gst_memory_new_wrapped (0, data, size, 0, size, data, g_free));

  }

  return buf;

}

static guint

gst_fake_src_get_size (GstFakeSrc * src)

{

  guint size;

  switch (src->sizetype) {

    case FAKE_SRC_SIZETYPE_FIXED:

      size = src->sizemax;

      break;

    case FAKE_SRC_SIZETYPE_RANDOM:

      size = g_random_int_range (src->sizemin, src->sizemax);

      break;

    case FAKE_SRC_SIZETYPE_EMPTY:

    default:

      size = 0;

      break;

  }

  return size;

}

static GstBuffer *

gst_fake_src_create_buffer (GstFakeSrc * src, gsize * bufsize)

{

  GstBuffer *buf;

  gsize size = gst_fake_src_get_size (src);

  gboolean dump = src->dump;

  GstMapInfo info;

  *bufsize = size;

  switch (src->data) {

    case FAKE_SRC_DATA_ALLOCATE:

      buf = gst_fake_src_alloc_buffer (src, size);

      break;

    case FAKE_SRC_DATA_SUBBUFFER:

      /* see if we have a parent to subbuffer */

      if (!src->parent) {

        gst_fake_src_alloc_parent (src);

        g_assert (src->parent);

      }

      /* see if it's large enough */

      if ((src->parentsize - src->parentoffset) >= size) {

        buf =

            gst_buffer_copy_region (src->parent, GST_BUFFER_COPY_ALL,

            src->parentoffset, size);

        src->parentoffset += size;

      } else {

        /* the parent is useless now */

        gst_buffer_unref (src->parent);

        src->parent = NULL;

        /* try again (this will allocate a new parent) */

        return gst_fake_src_create_buffer (src, bufsize);

      }

      if (buf == NULL)

        goto buffer_create_fail;

      if (!gst_buffer_map (buf, &info, GST_MAP_WRITE))

        goto buffer_write_fail;

      gst_fake_src_prepare_buffer (src, info.data, info.size);

      gst_buffer_unmap (buf, &info;;

      break;

    default:

      g_warning ("fakesrc: dunno how to allocate buffers !");

      buf = gst_buffer_new ();

      break;

  }

  if (dump) {

    if (gst_buffer_map (buf, &info, GST_MAP_READ)) {

      gst_util_dump_mem (info.data, info.size);

      gst_buffer_unmap (buf, &info;;

    }

  }

  return buf;

buffer_create_fail:

  {

    GST_ELEMENT_ERROR (src, RESOURCE, BUSY, (NULL),

        ("Failed to create a buffer"));

    return NULL;

  }

buffer_write_fail:

  {

    GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL),

        ("Failed to write to buffer"));

    gst_buffer_unref (buf);

    return NULL;

  }

}

static void

gst_fake_src_get_times (GstBaseSrc * basesrc, GstBuffer * buffer,

    GstClockTime * start, GstClockTime * end)

{

  GstFakeSrc *src;

  src = GST_FAKE_SRC (basesrc);

  /* sync on the timestamp of the buffer if requested. */

  if (src->sync) {

    GstClockTime timestamp, duration;

    /* first sync on DTS, else use PTS */

    timestamp = GST_BUFFER_DTS (buffer);

    if (!GST_CLOCK_TIME_IS_VALID (timestamp))

      timestamp = GST_BUFFER_PTS (buffer);

    if (GST_CLOCK_TIME_IS_VALID (timestamp)) {

      /* get duration to calculate end time */

      duration = GST_BUFFER_DURATION (buffer);

      if (GST_CLOCK_TIME_IS_VALID (duration)) {

        *end = timestamp + duration;

      }

      *start = timestamp;

    }

  } else {

    *start = -1;

    *end = -1;

  }

}

static GstFlowReturn

gst_fake_src_create (GstBaseSrc * basesrc, guint64 offset, guint length,

    GstBuffer ** ret)

{

  GstFakeSrc *src;

  GstBuffer *buf;

  GstClockTime time;

  gsize size;

  src = GST_FAKE_SRC (basesrc);

  buf = gst_fake_src_create_buffer (src, &size);

  GST_BUFFER_OFFSET (buf) = offset;

  if (src->datarate > 0) {

    time = (src->bytes_sent * GST_SECOND) / src->datarate;

    GST_BUFFER_DURATION (buf) = size * GST_SECOND / src->datarate;

  } else if (gst_base_src_is_live (basesrc)) {

    GstClock *clock;

    clock = gst_element_get_clock (GST_ELEMENT (src));

    if (clock) {

      time = gst_clock_get_time (clock);

      time -= gst_element_get_base_time (GST_ELEMENT (src));

      gst_object_unref (clock);

    } else {

      /* not an error not to have a clock */

      time = GST_CLOCK_TIME_NONE;

    }

  } else {

    time = GST_CLOCK_TIME_NONE;

  }

  GST_BUFFER_DTS (buf) = time;

  GST_BUFFER_PTS (buf) = time;

  if (!src->silent) {

    gchar dts_str[64], pts_str[64], dur_str[64];

    gchar *flag_str;

    GST_OBJECT_LOCK (src);

    g_free (src->last_message);

    if (GST_BUFFER_DTS (buf) != GST_CLOCK_TIME_NONE) {

      g_snprintf (dts_str, sizeof (dts_str), "%" GST_TIME_FORMAT,

          GST_TIME_ARGS (GST_BUFFER_DTS (buf)));

    } else {

      g_strlcpy (dts_str, "none", sizeof (dts_str));

    }

    if (GST_BUFFER_PTS (buf) != GST_CLOCK_TIME_NONE) {

      g_snprintf (pts_str, sizeof (pts_str), "%" GST_TIME_FORMAT,

          GST_TIME_ARGS (GST_BUFFER_PTS (buf)));

    } else {

      g_strlcpy (pts_str, "none", sizeof (pts_str));

    }

    if (GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE) {

      g_snprintf (dur_str, sizeof (dur_str), "%" GST_TIME_FORMAT,

          GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));

    } else {

      g_strlcpy (dur_str, "none", sizeof (dur_str));

    }

    flag_str = gst_buffer_get_flags_string (buf);

    src->last_message =

        g_strdup_printf ("create   ******* (%s:%s) (%u bytes, dts: %s, pts:%s"

        ", duration: %s, offset: %" G_GINT64_FORMAT ", offset_end: %"

        G_GINT64_FORMAT ", flags: %08x %s) %p",

        GST_DEBUG_PAD_NAME (GST_BASE_SRC_CAST (src)->srcpad), (guint) size,

        dts_str, pts_str, dur_str, GST_BUFFER_OFFSET (buf),

        GST_BUFFER_OFFSET_END (buf), GST_MINI_OBJECT_CAST (buf)->flags,

        flag_str, buf);

    g_free (flag_str);

    GST_OBJECT_UNLOCK (src);

    g_object_notify_by_pspec ((GObject *) src, pspec_last_message);

  }

  if (src->signal_handoffs) {

    GST_LOG_OBJECT (src, "pre handoff emit");

    g_signal_emit (src, gst_fake_src_signals[SIGNAL_HANDOFF], 0, buf,

        basesrc->srcpad);

    GST_LOG_OBJECT (src, "post handoff emit");

  }

  src->bytes_sent += size;

  *ret = buf;

  return GST_FLOW_OK;

}

static gboolean

gst_fake_src_start (GstBaseSrc * basesrc)

{