/* GStreamer

 * Copyright (C) 2005 Stefan Kost <ensonic@users.sf.net>

 *

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

 *

 * AudioTestSrc can be used to generate basic audio signals. It support several

 * <title>Example launch line</title>

 * gst-launch audiotestsrc ! audioconvert ! alsasink

 * gst-launch audiotestsrc wave=2 freq=200 ! audioconvert ! tee name=t ! queue ! alsasink t. ! queue ! libvisual_lv_scope ! ffmpegcolorspace ! xvimagesink

 * scope visualizer from libvisual, allowing you to visually verify that

 * the saw wave is correct.

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <math.h>

#include <stdlib.h>

#include <string.h>

#include <gst/controller/gstcontroller.h>

#include "gstaudiotestsrc.h"

#ifndef M_PI

#define M_PI  3.14159265358979323846

#endif

#ifndef M_PI_2

#define M_PI_2  1.57079632679489661923

#endif

#define M_PI_M2 ( M_PI + M_PI )

GST_DEBUG_CATEGORY_STATIC (audio_test_src_debug);

#define GST_CAT_DEFAULT audio_test_src_debug

static const GstElementDetails gst_audio_test_src_details =

GST_ELEMENT_DETAILS ("Audio test source",

    "Source/Audio",

    "Creates audio test signals of given frequency and volume",

    "Stefan Kost <ensonic@users.sf.net>");

enum

{

  PROP_0,

  PROP_SAMPLES_PER_BUFFER,

  PROP_WAVE,

  PROP_FREQ,

  PROP_VOLUME,

  PROP_IS_LIVE,

  PROP_TIMESTAMP_OFFSET,

};

static GstStaticPadTemplate gst_audio_test_src_src_template =

    GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("audio/x-raw-int, "

        "endianness = (int) BYTE_ORDER, "

        "signed = (boolean) true, "

        "width = (int) 16, "

        "depth = (int) 16, "

        "rate = (int) [ 1, MAX ], "

        "audio/x-raw-int, "

        "endianness = (int) BYTE_ORDER, "

        "signed = (boolean) true, "

        "width = (int) 32, "

        "depth = (int) 32,"

        "rate = (int) [ 1, MAX ], "

        "audio/x-raw-float, "

        "endianness = (int) BYTE_ORDER, "

        "width = (int) { 32, 64 }, "

    );

GST_BOILERPLATE (GstAudioTestSrc, gst_audio_test_src, GstBaseSrc,

    GST_TYPE_BASE_SRC);

#define GST_TYPE_AUDIO_TEST_SRC_WAVE (gst_audiostestsrc_wave_get_type())

static GType

gst_audiostestsrc_wave_get_type (void)

{

  static GType audiostestsrc_wave_type = 0;

  static const GEnumValue audiostestsrc_waves[] = {

    {GST_AUDIO_TEST_SRC_WAVE_SINE, "Sine", "sine"},

    {GST_AUDIO_TEST_SRC_WAVE_SQUARE, "Square", "square"},

    {GST_AUDIO_TEST_SRC_WAVE_SAW, "Saw", "saw"},

    {GST_AUDIO_TEST_SRC_WAVE_TRIANGLE, "Triangle", "triangle"},

    {GST_AUDIO_TEST_SRC_WAVE_SILENCE, "Silence", "silence"},

    {GST_AUDIO_TEST_SRC_WAVE_PINK_NOISE, "Pink noise", "pink-noise"},

    {0, NULL, NULL},

  };

  if (G_UNLIKELY (audiostestsrc_wave_type == 0)) {

    audiostestsrc_wave_type = g_enum_register_static ("GstAudioTestSrcWave",

        audiostestsrc_waves);

  }

  return audiostestsrc_wave_type;

}

static void gst_audio_test_src_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static void gst_audio_test_src_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

static gboolean gst_audio_test_src_setcaps (GstBaseSrc * basesrc,

    GstCaps * caps);

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

static gboolean gst_audio_test_src_is_seekable (GstBaseSrc * basesrc);

static gboolean gst_audio_test_src_do_seek (GstBaseSrc * basesrc,

    GstSegment * segment);

static gboolean gst_audio_test_src_query (GstBaseSrc * basesrc,

    GstQuery * query);

static void gst_audio_test_src_change_wave (GstAudioTestSrc * src);

static void gst_audio_test_src_get_times (GstBaseSrc * basesrc,

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

static GstFlowReturn gst_audio_test_src_create (GstBaseSrc * basesrc,

    guint64 offset, guint length, GstBuffer ** buffer);

static void

gst_audio_test_src_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_audio_test_src_src_template));

  gst_element_class_set_details (element_class, &gst_audio_test_src_details);

}

static void

gst_audio_test_src_class_init (GstAudioTestSrcClass * klass)

{

  GObjectClass *gobject_class;

  GstBaseSrcClass *gstbasesrc_class;

  gobject_class = (GObjectClass *) klass;

  gstbasesrc_class = (GstBaseSrcClass *) klass;

  gobject_class->set_property = gst_audio_test_src_set_property;

  gobject_class->get_property = gst_audio_test_src_get_property;

  g_object_class_install_property (gobject_class, PROP_SAMPLES_PER_BUFFER,

      g_param_spec_int ("samplesperbuffer", "Samples per buffer",

          "Number of samples in each outgoing buffer",

  g_object_class_install_property (gobject_class, PROP_FREQ,

      g_param_spec_double ("freq", "Frequency", "Frequency of test signal",

  g_object_class_install_property (gobject_class, PROP_VOLUME,

  g_object_class_install_property (gobject_class, PROP_IS_LIVE,

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

  g_object_class_install_property (G_OBJECT_CLASS (klass),

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

  gstbasesrc_class->set_caps = GST_DEBUG_FUNCPTR (gst_audio_test_src_setcaps);

  gstbasesrc_class->is_seekable =

      GST_DEBUG_FUNCPTR (gst_audio_test_src_is_seekable);

  gstbasesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_audio_test_src_do_seek);

  gstbasesrc_class->query = GST_DEBUG_FUNCPTR (gst_audio_test_src_query);

  gstbasesrc_class->get_times =

      GST_DEBUG_FUNCPTR (gst_audio_test_src_get_times);

  gstbasesrc_class->create = GST_DEBUG_FUNCPTR (gst_audio_test_src_create);

}

static void

gst_audio_test_src_init (GstAudioTestSrc * src, GstAudioTestSrcClass * g_class)

{

  GstPad *pad = GST_BASE_SRC_PAD (src);

  gst_pad_set_fixatecaps_function (pad, gst_audio_test_src_src_fixate);

  src->samplerate = 44100;

  src->format = GST_AUDIO_TEST_SRC_FORMAT_NONE;

  /* we operate in time */

  gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);

  src->generate_samples_per_buffer = src->samples_per_buffer;

}

static void

gst_audio_test_src_src_fixate (GstPad * pad, GstCaps * caps)

{

  GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (GST_PAD_PARENT (pad));

  const gchar *name;

  GstStructure *structure;

  structure = gst_caps_get_structure (caps, 0);

  gst_structure_fixate_field_nearest_int (structure, "rate", src->samplerate);

  name = gst_structure_get_name (structure);

  if (strcmp (name, "audio/x-raw-int") == 0)

    gst_structure_fixate_field_nearest_int (structure, "width", 32);

  else if (strcmp (name, "audio/x-raw-float") == 0)

    gst_structure_fixate_field_nearest_int (structure, "width", 64);

}

static gboolean

gst_audio_test_src_setcaps (GstBaseSrc * basesrc, GstCaps * caps)

{

  GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (basesrc);

  const GstStructure *structure;

  const gchar *name;

  gint width;

  gboolean ret;

  structure = gst_caps_get_structure (caps, 0);

  ret = gst_structure_get_int (structure, "rate", &src->samplerate);

  name = gst_structure_get_name (structure);

  if (strcmp (name, "audio/x-raw-int") == 0) {

    ret &= gst_structure_get_int (structure, "width", &width);

    src->format = (width == 32) ? GST_AUDIO_TEST_SRC_FORMAT_S32 :

        GST_AUDIO_TEST_SRC_FORMAT_S16;

  } else {

    ret &= gst_structure_get_int (structure, "width", &width);

    src->format = (width == 32) ? GST_AUDIO_TEST_SRC_FORMAT_F32 :

        GST_AUDIO_TEST_SRC_FORMAT_F64;

  }

  gst_audio_test_src_change_wave (src);

  return ret;

}

static gboolean

gst_audio_test_src_query (GstBaseSrc * basesrc, GstQuery * query)

{

  GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (basesrc);

  gboolean res = FALSE;

  switch (GST_QUERY_TYPE (query)) {

    case GST_QUERY_CONVERT:

    {

      GstFormat src_fmt, dest_fmt;

      gint64 src_val, dest_val;

      gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);

      if (src_fmt == dest_fmt) {

        dest_val = src_val;

        goto done;

      }

      switch (src_fmt) {

        case GST_FORMAT_DEFAULT:

          switch (dest_fmt) {

            case GST_FORMAT_TIME:

              /* samples to time */

              dest_val =

                  gst_util_uint64_scale_int (src_val, GST_SECOND,

                  src->samplerate);

              break;

            default:

              goto error;

          }

          break;

        case GST_FORMAT_TIME:

          switch (dest_fmt) {

            case GST_FORMAT_DEFAULT:

              /* time to samples */

              dest_val =

                  gst_util_uint64_scale_int (src_val, src->samplerate,

                  GST_SECOND);

              break;

            default:

              goto error;

          }

          break;

        default:

          goto error;

      }

    done:

      gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);

      res = TRUE;

      break;

    }

    default:

      res = GST_BASE_SRC_CLASS (parent_class)->query (basesrc, query);

      break;

  }

  return res;

  /* ERROR */

error:

  {

    GST_DEBUG_OBJECT (src, "query failed");

    return FALSE;

  }

}

#define DEFINE_SINE(type,scale) \

static void \

gst_audio_test_src_create_sine_##type (GstAudioTestSrc * src, g##type * samples) \

{ \

  gdouble step, amp; \

  \

  step = M_PI_M2 * src->freq / src->samplerate; \

  amp = src->volume * scale; \

  \

    src->accumulator += step; \

    if (src->accumulator >= M_PI_M2) \

      src->accumulator -= M_PI_M2; \

    \

  } \

}

DEFINE_SINE (int16, 32767.0);

DEFINE_SINE (int32, 2147483647.0);

DEFINE_SINE (float, 1.0);

DEFINE_SINE (double, 1.0);

  (ProcessFunc) gst_audio_test_src_create_sine_int16,

  (ProcessFunc) gst_audio_test_src_create_sine_int32,

  (ProcessFunc) gst_audio_test_src_create_sine_float,

  (ProcessFunc) gst_audio_test_src_create_sine_double

};

#define DEFINE_SQUARE(type,scale) \

static void \

gst_audio_test_src_create_square_##type (GstAudioTestSrc * src, g##type * samples) \

{ \

  gdouble step, amp; \

  \

  step = M_PI_M2 * src->freq / src->samplerate; \

  amp = src->volume * scale; \

  \

    src->accumulator += step; \

    if (src->accumulator >= M_PI_M2) \

      src->accumulator -= M_PI_M2; \

    \

  } \

}

DEFINE_SQUARE (int16, 32767.0);

DEFINE_SQUARE (int32, 2147483647.0);

DEFINE_SQUARE (float, 1.0);

DEFINE_SQUARE (double, 1.0);

  (ProcessFunc) gst_audio_test_src_create_square_int16,

  (ProcessFunc) gst_audio_test_src_create_square_int32,

  (ProcessFunc) gst_audio_test_src_create_square_float,

  (ProcessFunc) gst_audio_test_src_create_square_double

};

#define DEFINE_SAW(type,scale) \

static void \

gst_audio_test_src_create_saw_##type (GstAudioTestSrc * src, g##type * samples) \

{ \

  gdouble step, amp; \

  \

  step = M_PI_M2 * src->freq / src->samplerate; \

  amp = (src->volume * scale) / M_PI; \

  \

    src->accumulator += step; \

    if (src->accumulator >= M_PI_M2) \

      src->accumulator -= M_PI_M2; \

    \

    if (src->accumulator < M_PI) { \

    } else { \

    } \

  } \

}

DEFINE_SAW (int16, 32767.0);

DEFINE_SAW (int32, 2147483647.0);

DEFINE_SAW (float, 1.0);

DEFINE_SAW (double, 1.0);

  (ProcessFunc) gst_audio_test_src_create_saw_int16,

  (ProcessFunc) gst_audio_test_src_create_saw_int32,

  (ProcessFunc) gst_audio_test_src_create_saw_float,

  (ProcessFunc) gst_audio_test_src_create_saw_double

};

#define DEFINE_TRIANGLE(type,scale) \

static void \

gst_audio_test_src_create_triangle_##type (GstAudioTestSrc * src, g##type * samples) \

{ \

  gdouble step, amp; \

  \

  step = M_PI_M2 * src->freq / src->samplerate; \

  amp = (src->volume * scale) / M_PI_2; \

  \

    src->accumulator += step; \

    if (src->accumulator >= M_PI_M2) \

      src->accumulator -= M_PI_M2; \

    \

    if (src->accumulator < (M_PI * 0.5)) { \

    } else if (src->accumulator < (M_PI * 1.5)) { \

    } else { \

    } \

  } \

}

DEFINE_TRIANGLE (int16, 32767.0);

DEFINE_TRIANGLE (int32, 2147483647.0);

DEFINE_TRIANGLE (float, 1.0);

DEFINE_TRIANGLE (double, 1.0);

  (ProcessFunc) gst_audio_test_src_create_triangle_int16,

  (ProcessFunc) gst_audio_test_src_create_triangle_int32,

  (ProcessFunc) gst_audio_test_src_create_triangle_float,

  (ProcessFunc) gst_audio_test_src_create_triangle_double

};

#define DEFINE_SILENCE(type) \

static void \

gst_audio_test_src_create_silence_##type (GstAudioTestSrc * src, g##type * samples) \

{ \

}

DEFINE_SILENCE (int16);

DEFINE_SILENCE (int32);

DEFINE_SILENCE (float);

DEFINE_SILENCE (double);

  (ProcessFunc) gst_audio_test_src_create_silence_int16,

  (ProcessFunc) gst_audio_test_src_create_silence_int32,

  (ProcessFunc) gst_audio_test_src_create_silence_float,

  (ProcessFunc) gst_audio_test_src_create_silence_double

};

#define DEFINE_WHITE_NOISE(type,scale) \

static void \

gst_audio_test_src_create_white_noise_##type (GstAudioTestSrc * src, g##type * samples) \

{ \

  gdouble amp = (src->volume * scale); \

  \

  } \

}

DEFINE_WHITE_NOISE (int16, 32767.0);

DEFINE_WHITE_NOISE (int32, 2147483647.0);