/* GStreamer

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

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

 *

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

 *

 * The videotestsrc element is used to produce test video data in a wide variaty

 * of formats. The video test data produced can be controlled with the "pattern"

 * property.

 * <title>Example launch line</title>

 * gst-launch -v videotestsrc pattern=snow ! ximagesink

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gstvideotestsrc.h"

#include "videotestsrc.h"

#include <string.h>

#include <stdlib.h>

GST_DEBUG_CATEGORY_STATIC (video_test_src_debug);

#define GST_CAT_DEFAULT video_test_src_debug

static const GstElementDetails video_test_src_details =

GST_ELEMENT_DETAILS ("Video test source",

    "Source/Video",

    "Creates a test video stream",

    "David A. Schleef <ds@schleef.org>");

enum

{

  PROP_0,

  PROP_PATTERN,

  PROP_TIMESTAMP_OFFSET,

};

GST_BOILERPLATE (GstVideoTestSrc, gst_video_test_src, GstPushSrc,

    GST_TYPE_PUSH_SRC);

static void gst_video_test_src_set_pattern (GstVideoTestSrc * videotestsrc,

    int pattern_type);

static void gst_video_test_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_video_test_src_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static GstCaps *gst_video_test_src_getcaps (GstBaseSrc * bsrc);

static gboolean gst_video_test_src_setcaps (GstBaseSrc * bsrc, GstCaps * caps);

static void gst_video_test_src_src_fixate (GstPad * pad, GstCaps * caps);

static gboolean gst_video_test_src_is_seekable (GstBaseSrc * psrc);

static gboolean gst_video_test_src_do_seek (GstBaseSrc * bsrc,

    GstSegment * segment);

static gboolean gst_video_test_src_query (GstBaseSrc * bsrc, GstQuery * query);

static void gst_video_test_src_get_times (GstBaseSrc * basesrc,

    GstBuffer * buffer, GstClockTime * start, GstClockTime * end);

static GstFlowReturn gst_video_test_src_create (GstPushSrc * psrc,

    GstBuffer ** buffer);

static gboolean gst_video_test_src_start (GstBaseSrc * basesrc);

#define GST_TYPE_VIDEO_TEST_SRC_PATTERN (gst_video_test_src_pattern_get_type ())

static GType

gst_video_test_src_pattern_get_type (void)

{

  static GType video_test_src_pattern_type = 0;

  static const GEnumValue pattern_types[] = {

    {GST_VIDEO_TEST_SRC_SMPTE, "SMPTE 100% color bars", "smpte"},

    {GST_VIDEO_TEST_SRC_SNOW, "Random (television snow)", "snow"},

    {GST_VIDEO_TEST_SRC_BLACK, "100% Black", "black"},

    {GST_VIDEO_TEST_SRC_WHITE, "100% White", "white"},

    {GST_VIDEO_TEST_SRC_RED, "Red", "red"},

    {GST_VIDEO_TEST_SRC_GREEN, "Green", "green"},

    {GST_VIDEO_TEST_SRC_BLUE, "Blue", "blue"},

    {GST_VIDEO_TEST_SRC_CHECKERS1, "Checkers 1px", "checkers-1"},

    {GST_VIDEO_TEST_SRC_CHECKERS2, "Checkers 2px", "checkers-2"},

    {GST_VIDEO_TEST_SRC_CHECKERS4, "Checkers 4px", "checkers-4"},

    {GST_VIDEO_TEST_SRC_CHECKERS8, "Checkers 8px", "checkers-8"},

    {GST_VIDEO_TEST_SRC_CIRCULAR, "Circular", "circular"},

    {GST_VIDEO_TEST_SRC_BLINK, "Blink", "blink"},

    {0, NULL, NULL}

  };

  if (!video_test_src_pattern_type) {

    video_test_src_pattern_type =

        g_enum_register_static ("GstVideoTestSrcPattern", pattern_types);

  }

  return video_test_src_pattern_type;

}

static void

gst_video_test_src_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_set_details (element_class, &video_test_src_details);

  gst_element_class_add_pad_template (element_class,

      gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,

          gst_video_test_src_getcaps (NULL)));

}

static void

gst_video_test_src_class_init (GstVideoTestSrcClass * klass)

{

  GObjectClass *gobject_class;

  GstBaseSrcClass *gstbasesrc_class;

  GstPushSrcClass *gstpushsrc_class;

  gobject_class = (GObjectClass *) klass;

  gstbasesrc_class = (GstBaseSrcClass *) klass;

  gstpushsrc_class = (GstPushSrcClass *) klass;

  gobject_class->set_property = gst_video_test_src_set_property;

  gobject_class->get_property = gst_video_test_src_get_property;

  g_object_class_install_property (gobject_class, PROP_PATTERN,

      g_param_spec_enum ("pattern", "Pattern",

          "Type of test pattern to generate", GST_TYPE_VIDEO_TEST_SRC_PATTERN,

          "An offset added to timestamps set on buffers (in ns)", G_MININT64,

  g_object_class_install_property (gobject_class, PROP_IS_LIVE,

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

  gstbasesrc_class->get_caps = gst_video_test_src_getcaps;

  gstbasesrc_class->set_caps = gst_video_test_src_setcaps;

  gstbasesrc_class->is_seekable = gst_video_test_src_is_seekable;

  gstbasesrc_class->do_seek = gst_video_test_src_do_seek;

  gstbasesrc_class->query = gst_video_test_src_query;

  gstbasesrc_class->get_times = gst_video_test_src_get_times;

  gstbasesrc_class->start = gst_video_test_src_start;

  gstpushsrc_class->create = gst_video_test_src_create;

}

static void

gst_video_test_src_init (GstVideoTestSrc * src, GstVideoTestSrcClass * g_class)

{

  GstPad *pad = GST_BASE_SRC_PAD (src);

  gst_pad_set_fixatecaps_function (pad, gst_video_test_src_src_fixate);

  /* we operate in time */

  gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);

}

static void

gst_video_test_src_src_fixate (GstPad * pad, GstCaps * caps)

{

  GstStructure *structure;

  structure = gst_caps_get_structure (caps, 0);

  gst_structure_fixate_field_nearest_int (structure, "width", 320);

  gst_structure_fixate_field_nearest_int (structure, "height", 240);

  gst_structure_fixate_field_nearest_fraction (structure, "framerate", 30, 1);

}

static void

gst_video_test_src_set_pattern (GstVideoTestSrc * videotestsrc,

    int pattern_type)

{

  videotestsrc->pattern_type = pattern_type;

  GST_DEBUG_OBJECT (videotestsrc, "setting pattern to %d", pattern_type);

  switch (pattern_type) {

    case GST_VIDEO_TEST_SRC_SMPTE:

      videotestsrc->make_image = gst_video_test_src_smpte;

      break;

    case GST_VIDEO_TEST_SRC_SNOW:

      videotestsrc->make_image = gst_video_test_src_snow;

      break;

    case GST_VIDEO_TEST_SRC_BLACK:

      videotestsrc->make_image = gst_video_test_src_black;

      break;

    case GST_VIDEO_TEST_SRC_WHITE:

      videotestsrc->make_image = gst_video_test_src_white;

      break;

    case GST_VIDEO_TEST_SRC_RED:

      videotestsrc->make_image = gst_video_test_src_red;

      break;

    case GST_VIDEO_TEST_SRC_GREEN:

      videotestsrc->make_image = gst_video_test_src_green;

      break;

    case GST_VIDEO_TEST_SRC_BLUE:

      videotestsrc->make_image = gst_video_test_src_blue;

      break;

    case GST_VIDEO_TEST_SRC_CHECKERS1:

      videotestsrc->make_image = gst_video_test_src_checkers1;

      break;

    case GST_VIDEO_TEST_SRC_CHECKERS2:

      videotestsrc->make_image = gst_video_test_src_checkers2;

      break;

    case GST_VIDEO_TEST_SRC_CHECKERS4:

      videotestsrc->make_image = gst_video_test_src_checkers4;

      break;

    case GST_VIDEO_TEST_SRC_CHECKERS8:

      videotestsrc->make_image = gst_video_test_src_checkers8;

      break;

    case GST_VIDEO_TEST_SRC_CIRCULAR:

      videotestsrc->make_image = gst_video_test_src_circular;

      break;

    case GST_VIDEO_TEST_SRC_BLINK:

      videotestsrc->make_image = gst_video_test_src_black;

      break;

    default:

      g_assert_not_reached ();

  }

}

static void

gst_video_test_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstVideoTestSrc *src = GST_VIDEO_TEST_SRC (object);

  switch (prop_id) {

    case PROP_PATTERN:

      gst_video_test_src_set_pattern (src, g_value_get_enum (value));

      break;

    case PROP_TIMESTAMP_OFFSET:

      src->timestamp_offset = g_value_get_int64 (value);

      break;

    case PROP_IS_LIVE:

      gst_base_src_set_live (GST_BASE_SRC (src), g_value_get_boolean (value));

      break;

    default:

      break;

  }

}

static void

gst_video_test_src_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstVideoTestSrc *src = GST_VIDEO_TEST_SRC (object);

  switch (prop_id) {

    case PROP_PATTERN:

      g_value_set_enum (value, src->pattern_type);

      break;

    case PROP_TIMESTAMP_OFFSET:

      g_value_set_int64 (value, src->timestamp_offset);

      break;

    case PROP_IS_LIVE:

      g_value_set_boolean (value, gst_base_src_is_live (GST_BASE_SRC (src)));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

/* threadsafe because this gets called as the plugin is loaded */

static GstCaps *

{

  static GstCaps *capslist = NULL;

  if (!capslist) {

    GstCaps *caps;

    GstStructure *structure;

    int i;

    caps = gst_caps_new_empty ();

    for (i = 0; i < n_fourccs; i++) {

      structure = paint_get_structure (fourcc_list + i);

      gst_structure_set (structure,

          "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,