/* GStreamer * Copyright (C) 2005 Stefan Kost * * 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-audiotestsrc * @title: audiotestsrc * * AudioTestSrc can be used to generate basic audio signals. It support several * different waveforms and allows to set the base frequency and volume. Some * waveforms might use additional properties. * * Waveform specific notes: * * ## Gaussian white noise * * This waveform produces white (zero mean) Gaussian noise. * Volume sets the standard deviation of the noise in units of the range * of values of the sample type, e.g. volume=0.1 produces noise with a * standard deviation of 0.1*32767=3277 with 16-bit integer samples, * or 0.1*1.0=0.1 with floating-point samples. * * ## Ticks * * This waveform is special in that it does not produce one continuous * signal. Instead, it produces finite-length sine wave pulses (the "ticks"). * It is useful for detecting time shifts between audio signal, for example * between RTSP audio clients that shall play synchronized. It is also useful * for generating a signal that feeds the trigger of an oscilloscope. * * To further help with oscilloscope triggering and time offset detection, * the waveform can apply a different volume to every Nth tick (this is then * called the "marker tick"). For instance, one could generate a tick every * 100ms, and make every 20th tick a marker tick (meaning that every 2 seconds * there is a marker tick). This is useful for detecting large time offsets * while still frequently triggering an oscilloscope. * * Also, a "ramp" can be applied to the begin & end of ticks. The sudden * start of the sine tick is a discontinuity, even if the sine wave starts * at 0. The* resulting artifacts can often make it more difficult to use the * ticks for an oscilloscope's trigger. To that end, an initial "ramp" can * be applied. The first few samples are modulated by a cubic function to * reduce the impact of the discontinuity, resulting in smaller artifacts. * The number of samples equals floor(samplerate / sine-wave-frequency). * Example: with a sample rate of 48 kHz and a sine wave frequency of 10 kHz, * the first 4 samples are modulated by the cubic function. * * ## Example launch line * |[ * gst-launch-1.0 audiotestsrc ! audioconvert ! autoaudiosink * ]| * This pipeline produces a sine with default frequency, 440 Hz, and the * default volume, 0.8 (relative to a maximum 1.0). * |[ * gst-launch-1.0 audiotestsrc wave=2 freq=200 ! tee name=t ! queue ! audioconvert ! \ * autoaudiosink t. ! queue ! audioconvert ! libvisual_lv_scope ! videoconvert ! autovideosink * ]| * In this example a saw wave is generated. The wave is shown using a * scope visualizer from libvisual, allowing you to visually verify that * the saw wave is correct. * * |[ * gst-launch-1.0 audiotestsrc wave=ticks apply-tick-ramp=true tick-interval=100000000 \ * freq=10000 volume=0.4 marker-tick-period=10 sine-periods-per-tick=20 ! autoaudiosink * ]| This pipeline produces a series of 10 kHz sine wave ticks. Each tick is * 20 sine wave periods long, ticks occur every 100 ms and have a volume of * 0.4. Every 10th tick is a marker tick and has the default marker tick volume * of 1.0. The beginning and end of the ticks are modulated with the ramp. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include "gstaudiotestsrc.h" #define M_PI_M2 ( G_PI + G_PI ) GST_DEBUG_CATEGORY_STATIC (audio_test_src_debug); #define GST_CAT_DEFAULT audio_test_src_debug #define DEFAULT_SAMPLES_PER_BUFFER 1024 #define DEFAULT_WAVE GST_AUDIO_TEST_SRC_WAVE_SINE #define DEFAULT_FREQ 440.0 #define DEFAULT_VOLUME 0.8 #define DEFAULT_IS_LIVE FALSE #define DEFAULT_TIMESTAMP_OFFSET G_GINT64_CONSTANT (0) #define DEFAULT_SINE_PERIODS_PER_TICK 10 #define DEFAULT_TIME_BETWEEN_TICKS GST_SECOND #define DEFAULT_MARKER_TICK_PERIOD 0 #define DEFAULT_MARKER_TICK_VOLUME 1.0 #define DEFAULT_APPLY_TICK_RAMP FALSE #define DEFAULT_CAN_ACTIVATE_PUSH TRUE #define DEFAULT_CAN_ACTIVATE_PULL FALSE enum { PROP_0, PROP_SAMPLES_PER_BUFFER, PROP_WAVE, PROP_FREQ, PROP_VOLUME, PROP_IS_LIVE, PROP_TIMESTAMP_OFFSET, PROP_SINE_PERIODS_PER_TICK, PROP_TICK_INTERVAL, PROP_MARKER_TICK_PERIOD, PROP_MARKER_TICK_VOLUME, PROP_APPLY_TICK_RAMP, PROP_CAN_ACTIVATE_PUSH, PROP_CAN_ACTIVATE_PULL }; #define FORMAT_STR " { S16LE, S16BE, U16LE, U16BE, " \ "S24_32LE, S24_32BE, U24_32LE, U24_32BE, " \ "S32LE, S32BE, U32LE, U32BE, " \ "S24LE, S24BE, U24LE, U24BE, " \ "S20LE, S20BE, U20LE, U20BE, " \ "S18LE, S18BE, U18LE, U18BE, " \ "F32LE, F32BE, F64LE, F64BE, " \ "S8, U8 }" #define DEFAULT_FORMAT_STR GST_AUDIO_NE ("S16") 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, " "format = (string) " FORMAT_STR ", " "layout = (string) { interleaved, non-interleaved }, " "rate = " GST_AUDIO_RATE_RANGE ", " "channels = " GST_AUDIO_CHANNELS_RANGE) ); #define gst_audio_test_src_parent_class parent_class G_DEFINE_TYPE (GstAudioTestSrc, gst_audio_test_src, GST_TYPE_BASE_SRC); GST_ELEMENT_REGISTER_DEFINE_WITH_CODE (audiotestsrc, "audiotestsrc", GST_RANK_NONE, GST_TYPE_AUDIO_TEST_SRC, GST_DEBUG_CATEGORY_INIT (audio_test_src_debug, "audiotestsrc", 0, "Audio Test Source")); #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_WHITE_NOISE, "White uniform noise", "white-noise"}, {GST_AUDIO_TEST_SRC_WAVE_PINK_NOISE, "Pink noise", "pink-noise"}, {GST_AUDIO_TEST_SRC_WAVE_SINE_TAB, "Sine table", "sine-table"}, {GST_AUDIO_TEST_SRC_WAVE_TICKS, "Periodic Ticks", "ticks"}, {GST_AUDIO_TEST_SRC_WAVE_GAUSSIAN_WHITE_NOISE, "White Gaussian noise", "gaussian-noise"}, {GST_AUDIO_TEST_SRC_WAVE_RED_NOISE, "Red (brownian) noise", "red-noise"}, {GST_AUDIO_TEST_SRC_WAVE_BLUE_NOISE, "Blue noise", "blue-noise"}, {GST_AUDIO_TEST_SRC_WAVE_VIOLET_NOISE, "Violet noise", "violet-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_finalize (GObject * object); 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 GstCaps *gst_audio_test_src_fixate (GstBaseSrc * bsrc, 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 gboolean gst_audio_test_src_start (GstBaseSrc * basesrc); static gboolean gst_audio_test_src_stop (GstBaseSrc * basesrc); static GstFlowReturn gst_audio_test_src_fill (GstBaseSrc * basesrc, guint64 offset, guint length, GstBuffer * buffer); static void gst_audio_test_src_class_init (GstAudioTestSrcClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstBaseSrcClass *gstbasesrc_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) 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; gobject_class->finalize = gst_audio_test_src_finalize; 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", 1, G_MAXINT, DEFAULT_SAMPLES_PER_BUFFER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_WAVE, g_param_spec_enum ("wave", "Waveform", "Oscillator waveform", GST_TYPE_AUDIO_TEST_SRC_WAVE, GST_AUDIO_TEST_SRC_WAVE_SINE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_FREQ, g_param_spec_double ("freq", "Frequency", "Frequency of test signal. " "The sample rate needs to be at least 2 times higher.", 0.0, (gdouble) G_MAXINT / 2, DEFAULT_FREQ, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_VOLUME, g_param_spec_double ("volume", "Volume", "Volume of test signal", 0.0, 1.0, DEFAULT_VOLUME, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); 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", DEFAULT_IS_LIVE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TIMESTAMP_OFFSET, g_param_spec_int64 ("timestamp-offset", "Timestamp offset", "An offset added to timestamps set on buffers (in ns)", G_MININT64, G_MAXINT64, DEFAULT_TIMESTAMP_OFFSET, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SINE_PERIODS_PER_TICK, g_param_spec_uint ("sine-periods-per-tick", "Sine periods per tick", "Number of sine wave periods in one tick. Only used if wave = ticks.", 1, G_MAXUINT, DEFAULT_SINE_PERIODS_PER_TICK, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_TICK_INTERVAL, g_param_spec_uint64 ("tick-interval", "Time between ticks", "Distance between start of current and start of next tick, in nanoseconds.", 1, G_MAXUINT64, DEFAULT_TIME_BETWEEN_TICKS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_MARKER_TICK_PERIOD, g_param_spec_uint ("marker-tick-period", "Marker tick period", "Make every Nth tick a marker tick (= a tick with different volume). " "Only used if wave = ticks. 0 = no marker ticks.", 0, G_MAXUINT, DEFAULT_MARKER_TICK_PERIOD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_MARKER_TICK_VOLUME, g_param_spec_double ("marker-tick-volume", "Marker tick volume", "Volume of marker ticks. Only used if wave = ticks and" "marker-tick-period is set to a nonzero value.", 0.0, 1.0, DEFAULT_MARKER_TICK_VOLUME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_APPLY_TICK_RAMP, g_param_spec_boolean ("apply-tick-ramp", "Apply tick ramp", "Apply ramp to tick samples", DEFAULT_APPLY_TICK_RAMP, 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_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_STATIC_STRINGS)); gst_element_class_add_static_pad_template (gstelement_class, &gst_audio_test_src_src_template); gst_element_class_set_static_metadata (gstelement_class, "Audio test source", "Source/Audio", "Creates audio test signals of given frequency and volume", "Stefan Kost "); gstbasesrc_class->set_caps = GST_DEBUG_FUNCPTR (gst_audio_test_src_setcaps); gstbasesrc_class->fixate = GST_DEBUG_FUNCPTR (gst_audio_test_src_fixate); 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->start = GST_DEBUG_FUNCPTR (gst_audio_test_src_start); gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_audio_test_src_stop); gstbasesrc_class->fill = GST_DEBUG_FUNCPTR (gst_audio_test_src_fill); gst_type_mark_as_plugin_api (GST_TYPE_AUDIO_TEST_SRC_WAVE, 0); } static void gst_audio_test_src_init (GstAudioTestSrc * src) { src->volume = DEFAULT_VOLUME; src->freq = DEFAULT_FREQ; /* we operate in time */ gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME); gst_base_src_set_live (GST_BASE_SRC (src), DEFAULT_IS_LIVE); src->samples_per_buffer = DEFAULT_SAMPLES_PER_BUFFER; src->generate_samples_per_buffer = src->samples_per_buffer; src->timestamp_offset = DEFAULT_TIMESTAMP_OFFSET; src->can_activate_pull = DEFAULT_CAN_ACTIVATE_PULL; src->sine_periods_per_tick = DEFAULT_SINE_PERIODS_PER_TICK; src->tick_interval = DEFAULT_TIME_BETWEEN_TICKS; src->marker_tick_period = DEFAULT_MARKER_TICK_PERIOD; src->marker_tick_volume = DEFAULT_MARKER_TICK_VOLUME; src->apply_tick_ramp = DEFAULT_APPLY_TICK_RAMP; src->gen = NULL; src->wave = DEFAULT_WAVE; gst_base_src_set_blocksize (GST_BASE_SRC (src), -1); } static void gst_audio_test_src_finalize (GObject * object) { GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (object); if (src->gen) g_rand_free (src->gen); src->gen = NULL; g_free (src->tmp); src->tmp = NULL; src->tmpsize = 0; G_OBJECT_CLASS (parent_class)->finalize (object); } static GstCaps * gst_audio_test_src_fixate (GstBaseSrc * bsrc, GstCaps * caps) { GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (bsrc); GstStructure *structure; gint channels, rate; caps = gst_caps_make_writable (caps); structure = gst_caps_get_structure (caps, 0); GST_DEBUG_OBJECT (src, "fixating samplerate to %d", GST_AUDIO_DEF_RATE); rate = MAX (GST_AUDIO_DEF_RATE, src->freq * 2); gst_structure_fixate_field_nearest_int (structure, "rate", rate); gst_structure_fixate_field_string (structure, "format", DEFAULT_FORMAT_STR); gst_structure_fixate_field_string (structure, "layout", "interleaved"); /* fixate to mono unless downstream requires stereo, for backwards compat */ gst_structure_fixate_field_nearest_int (structure, "channels", 1); if (gst_structure_get_int (structure, "channels", &channels) && channels > 2) { if (!gst_structure_has_field_typed (structure, "channel-mask", GST_TYPE_BITMASK)) { guint64 mask = gst_audio_channel_get_fallback_mask (channels); gst_structure_set (structure, "channel-mask", GST_TYPE_BITMASK, mask, NULL); } } caps = GST_BASE_SRC_CLASS (parent_class)->fixate (bsrc, caps); return caps; } static gboolean gst_audio_test_src_setcaps (GstBaseSrc * basesrc, GstCaps * caps) { GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (basesrc); GstAudioInfo info; if (!gst_audio_info_from_caps (&info, caps)) goto invalid_caps; GST_DEBUG_OBJECT (src, "negotiated to caps %" GST_PTR_FORMAT, caps); src->info = info; gst_base_src_set_blocksize (basesrc, GST_AUDIO_INFO_BPF (&info) * src->samples_per_buffer); gst_audio_test_src_change_wave (src); return TRUE; /* ERROR */ invalid_caps: { GST_ERROR_OBJECT (basesrc, "received invalid caps"); return FALSE; } } 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 (!gst_audio_info_convert (&src->info, src_fmt, src_val, dest_fmt, &dest_val)) goto error; gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); res = TRUE; break; } case GST_QUERY_SCHEDULING: { /* if we can operate in pull mode */ gst_query_set_scheduling (query, GST_SCHEDULING_FLAG_SEEKABLE, 1, -1, 0); gst_query_add_scheduling_mode (query, GST_PAD_MODE_PUSH); if (src->can_activate_pull) gst_query_add_scheduling_mode (query, GST_PAD_MODE_PULL); res = TRUE; break; } case GST_QUERY_LATENCY: { if (src->info.rate > 0) { GstClockTime latency; latency = gst_util_uint64_scale (src->generate_samples_per_buffer, GST_SECOND, src->info.rate); gst_query_set_latency (query, gst_base_src_is_live (GST_BASE_SRC_CAST (src)), latency, GST_CLOCK_TIME_NONE); GST_DEBUG_OBJECT (src, "Reporting latency of %" GST_TIME_FORMAT, GST_TIME_ARGS (latency)); 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) \ { \ gint i, c, channels, channel_step, sample_step; \ gdouble step, amp; \ g##type *ptr; \ \ channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ step = M_PI_M2 * src->freq / GST_AUDIO_INFO_RATE (&src->info); \ amp = src->volume * scale; \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ src->accumulator += step; \ if (src->accumulator >= M_PI_M2) \ src->accumulator -= M_PI_M2; \ \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) (sin (src->accumulator) * amp); \ ptr += channel_step; \ } \ samples += sample_step; \ } \ } DEFINE_SINE (int16, 32767.0); DEFINE_SINE (int32, 2147483647.0); DEFINE_SINE (float, 1.0); DEFINE_SINE (double, 1.0); static const ProcessFunc sine_funcs[] = { (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) \ { \ gint i, c, channels, channel_step, sample_step; \ gdouble step, amp; \ g##type *ptr; \ \ channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ step = M_PI_M2 * src->freq / GST_AUDIO_INFO_RATE (&src->info); \ amp = src->volume * scale; \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ src->accumulator += step; \ if (src->accumulator >= M_PI_M2) \ src->accumulator -= M_PI_M2; \ \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) ((src->accumulator < G_PI) ? amp : -amp); \ ptr += channel_step; \ } \ samples += sample_step; \ } \ } DEFINE_SQUARE (int16, 32767.0); DEFINE_SQUARE (int32, 2147483647.0); DEFINE_SQUARE (float, 1.0); DEFINE_SQUARE (double, 1.0); static const ProcessFunc square_funcs[] = { (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) \ { \ gint i, c, channels, channel_step, sample_step; \ gdouble step, amp; \ g##type *ptr; \ \ channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ step = M_PI_M2 * src->freq / GST_AUDIO_INFO_RATE (&src->info); \ amp = (src->volume * scale) / G_PI; \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ src->accumulator += step; \ if (src->accumulator >= M_PI_M2) \ src->accumulator -= M_PI_M2; \ \ ptr = samples; \ if (src->accumulator < G_PI) { \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) (src->accumulator * amp); \ ptr += channel_step; \ } \ } else { \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) ((M_PI_M2 - src->accumulator) * -amp); \ ptr += channel_step; \ } \ } \ samples += sample_step; \ } \ } DEFINE_SAW (int16, 32767.0); DEFINE_SAW (int32, 2147483647.0); DEFINE_SAW (float, 1.0); DEFINE_SAW (double, 1.0); static const ProcessFunc saw_funcs[] = { (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) \ { \ gint i, c, channels, channel_step, sample_step; \ gdouble step, amp; \ g##type *ptr; \ \ channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ step = M_PI_M2 * src->freq / GST_AUDIO_INFO_RATE (&src->info); \ amp = (src->volume * scale) / G_PI_2; \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ src->accumulator += step; \ if (src->accumulator >= M_PI_M2) \ src->accumulator -= M_PI_M2; \ \ ptr = samples; \ if (src->accumulator < (G_PI_2)) { \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) (src->accumulator * amp); \ ptr += channel_step; \ } \ } else if (src->accumulator < (G_PI * 1.5)) { \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) ((src->accumulator - G_PI) * -amp); \ ptr += channel_step; \ } \ } else { \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) ((M_PI_M2 - src->accumulator) * -amp); \ ptr += channel_step; \ } \ } \ samples += sample_step; \ } \ } DEFINE_TRIANGLE (int16, 32767.0); DEFINE_TRIANGLE (int32, 2147483647.0); DEFINE_TRIANGLE (float, 1.0); DEFINE_TRIANGLE (double, 1.0); static const ProcessFunc triangle_funcs[] = { (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) \ { \ memset (samples, 0, src->generate_samples_per_buffer * sizeof (g##type) * src->info.channels); \ } DEFINE_SILENCE (int16); DEFINE_SILENCE (int32); DEFINE_SILENCE (float); DEFINE_SILENCE (double); static const ProcessFunc silence_funcs[] = { (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) \ { \ gint i, c, channel_step, sample_step; \ g##type *ptr; \ gdouble amp = (src->volume * scale); \ gint channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) (amp * g_rand_double_range (src->gen, -1.0, 1.0)); \ ptr += channel_step; \ } \ samples += sample_step; \ } \ } DEFINE_WHITE_NOISE (int16, 32767.0); DEFINE_WHITE_NOISE (int32, 2147483647.0); DEFINE_WHITE_NOISE (float, 1.0); DEFINE_WHITE_NOISE (double, 1.0); static const ProcessFunc white_noise_funcs[] = { (ProcessFunc) gst_audio_test_src_create_white_noise_int16, (ProcessFunc) gst_audio_test_src_create_white_noise_int32, (ProcessFunc) gst_audio_test_src_create_white_noise_float, (ProcessFunc) gst_audio_test_src_create_white_noise_double }; /* pink noise calculation is based on * http://www.firstpr.com.au/dsp/pink-noise/phil_burk_19990905_patest_pink.c * which has been released under public domain * Many thanks Phil! */ static void gst_audio_test_src_init_pink_noise (GstAudioTestSrc * src) { gint i; gint num_rows = 12; /* arbitrary: 1 .. PINK_MAX_RANDOM_ROWS */ glong pmax; src->pink.index = 0; src->pink.index_mask = (1 << num_rows) - 1; /* calculate maximum possible signed random value. * Extra 1 for white noise always added. */ pmax = (num_rows + 1) * (1 << (PINK_RANDOM_BITS - 1)); src->pink.scalar = 1.0f / pmax; /* Initialize rows. */ for (i = 0; i < num_rows; i++) src->pink.rows[i] = 0; src->pink.running_sum = 0; } /* Generate Pink noise values between -1.0 and +1.0 */ static gdouble gst_audio_test_src_generate_pink_noise_value (GstAudioTestSrc * src) { GstPinkNoise *pink = &src->pink; glong new_random; glong sum; /* Increment and mask index. */ pink->index = (pink->index + 1) & pink->index_mask; /* If index is zero, don't update any random values. */ if (pink->index != 0) { /* Determine how many trailing zeros in PinkIndex. */ /* This algorithm will hang if n==0 so test first. */ gint num_zeros = 0; gint n = pink->index; while ((n & 1) == 0) { n = n >> 1; num_zeros++; } /* Replace the indexed ROWS random value. * Subtract and add back to RunningSum instead of adding all the random * values together. Only one changes each time. */ pink->running_sum -= pink->rows[num_zeros]; new_random = 32768.0 - (65536.0 * (gulong) g_rand_int (src->gen) / (G_MAXUINT32 + 1.0)); pink->running_sum += new_random; pink->rows[num_zeros] = new_random; } /* Add extra white noise value. */ new_random = 32768.0 - (65536.0 * (gulong) g_rand_int (src->gen) / (G_MAXUINT32 + 1.0)); sum = pink->running_sum + new_random; /* Scale to range of -1.0 to 0.9999. */ return (pink->scalar * sum); } #define DEFINE_PINK(type, scale) \ static void \ gst_audio_test_src_create_pink_noise_##type (GstAudioTestSrc * src, g##type * samples) \ { \ gint i, c, channels, channel_step, sample_step; \ gdouble amp; \ g##type *ptr; \ \ amp = src->volume * scale; \ channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) (gst_audio_test_src_generate_pink_noise_value (src) * amp); \ ptr += channel_step; \ } \ samples += sample_step; \ } \ } DEFINE_PINK (int16, 32767.0); DEFINE_PINK (int32, 2147483647.0); DEFINE_PINK (float, 1.0); DEFINE_PINK (double, 1.0); static const ProcessFunc pink_noise_funcs[] = { (ProcessFunc) gst_audio_test_src_create_pink_noise_int16, (ProcessFunc) gst_audio_test_src_create_pink_noise_int32, (ProcessFunc) gst_audio_test_src_create_pink_noise_float, (ProcessFunc) gst_audio_test_src_create_pink_noise_double }; static void gst_audio_test_src_init_sine_table (GstAudioTestSrc * src, gboolean use_volume) { gint i; gdouble ang = 0.0; gdouble step = M_PI_M2 / 1024.0; gdouble amp = use_volume ? src->volume : 1.0; for (i = 0; i < 1024; i++) { src->wave_table[i] = sin (ang) * amp; ang += step; } } #define DEFINE_SINE_TABLE(type,scale) \ static void \ gst_audio_test_src_create_sine_table_##type (GstAudioTestSrc * src, g##type * samples) \ { \ gint i, c, channels, channel_step, sample_step; \ gdouble step, scl; \ g##type *ptr; \ \ channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ step = M_PI_M2 * src->freq / GST_AUDIO_INFO_RATE (&src->info); \ scl = 1024.0 / M_PI_M2; \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ src->accumulator += step; \ if (src->accumulator >= M_PI_M2) \ src->accumulator -= M_PI_M2; \ \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ *ptr = (g##type) scale * src->wave_table[(gint) (src->accumulator * scl)]; \ ptr += channel_step; \ } \ samples += sample_step; \ } \ } DEFINE_SINE_TABLE (int16, 32767.0); DEFINE_SINE_TABLE (int32, 2147483647.0); DEFINE_SINE_TABLE (float, 1.0); DEFINE_SINE_TABLE (double, 1.0); static const ProcessFunc sine_table_funcs[] = { (ProcessFunc) gst_audio_test_src_create_sine_table_int16, (ProcessFunc) gst_audio_test_src_create_sine_table_int32, (ProcessFunc) gst_audio_test_src_create_sine_table_float, (ProcessFunc) gst_audio_test_src_create_sine_table_double }; static inline gdouble calc_scaled_tick_volume (GstAudioTestSrc * src, gdouble scale) { gdouble vol; vol = ((src->marker_tick_period > 0) && ((src->tick_counter % src->marker_tick_period) == 0)) ? src->marker_tick_volume : src->volume; return vol * scale; } #define DEFINE_TICKS(type,scale) \ static void \ gst_audio_test_src_create_tick_##type (GstAudioTestSrc * src, g##type * samples) \ { \ gint i, c, channels, samplerate, samplemod, channel_step, sample_step; \ gint num_nonzero_samples, num_ramp_samples, end_ramp_offset; \ gdouble step, scl; \ gdouble volscale; \ g##type *ptr; \ \ volscale = calc_scaled_tick_volume (src, scale); \ channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ samplerate = GST_AUDIO_INFO_RATE (&src->info); \ step = M_PI_M2 * src->freq / samplerate; \ num_nonzero_samples = samplerate * src->sine_periods_per_tick / src->freq; \ scl = 1024.0 / M_PI_M2; \ num_ramp_samples = src->apply_tick_ramp ? (samplerate / src->freq) : 0; \ end_ramp_offset = num_nonzero_samples - num_ramp_samples; \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ samplemod = (src->next_sample + i)%src->samples_between_ticks; \ \ ptr = samples; \ if (samplemod == 0) { \ src->accumulator = 0; \ src->tick_counter++; \ volscale = calc_scaled_tick_volume (src, scale); \ for (c = 0; c < channels; ++c) { \ *ptr = 0; \ ptr += channel_step; \ } \ } else if (samplemod < num_nonzero_samples) { \ gdouble ramp; \ if (num_ramp_samples > 0) { \ ramp = \ (samplemod < num_ramp_samples) ? (((gdouble)samplemod) / num_ramp_samples) : \ (samplemod >= end_ramp_offset) ? (((gdouble)(num_nonzero_samples - samplemod)) / num_ramp_samples) \ : 1.0; \ if (ramp > 1.0) \ ramp = 1.0; \ ramp *= ramp * ramp; \ } else \ ramp = 1.0; \ \ for (c = 0; c < channels; ++c) { \ *ptr = \ (g##type) volscale * ramp * src->wave_table[(gint) (src->accumulator * scl)]; \ ptr += channel_step; \ } \ } else { \ for (c = 0; c < channels; ++c) { \ *ptr = 0; \ ptr += channel_step; \ } \ } \ \ src->accumulator += step; \ if (src->accumulator >= M_PI_M2) \ src->accumulator -= M_PI_M2; \ \ samples += sample_step; \ } \ } DEFINE_TICKS (int16, 32767.0); DEFINE_TICKS (int32, 2147483647.0); DEFINE_TICKS (float, 1.0); DEFINE_TICKS (double, 1.0); static const ProcessFunc tick_funcs[] = { (ProcessFunc) gst_audio_test_src_create_tick_int16, (ProcessFunc) gst_audio_test_src_create_tick_int32, (ProcessFunc) gst_audio_test_src_create_tick_float, (ProcessFunc) gst_audio_test_src_create_tick_double }; /* Gaussian white noise using Box-Muller algorithm. unit variance * normally-distributed random numbers are generated in pairs as the real * and imaginary parts of a complex random variable with * uniformly-distributed argument and \chi^{2}-distributed modulus. */ #define DEFINE_GAUSSIAN_WHITE_NOISE(type,scale) \ static void \ gst_audio_test_src_create_gaussian_white_noise_##type (GstAudioTestSrc * src, g##type * samples) \ { \ gint i, c, channel_step, sample_step; \ g##type *ptr; \ gdouble amp = (src->volume * scale); \ gint channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ gdouble mag = sqrt (-2 * log (1.0 - g_rand_double (src->gen))); \ gdouble phs = g_rand_double_range (src->gen, 0.0, M_PI_M2); \ \ *ptr = (g##type) (amp * mag * cos (phs)); \ ptr += channel_step; \ if (++c >= channels) \ break; \ *ptr = (g##type) (amp * mag * sin (phs)); \ ptr += channel_step; \ } \ samples += sample_step; \ } \ } DEFINE_GAUSSIAN_WHITE_NOISE (int16, 32767.0); DEFINE_GAUSSIAN_WHITE_NOISE (int32, 2147483647.0); DEFINE_GAUSSIAN_WHITE_NOISE (float, 1.0); DEFINE_GAUSSIAN_WHITE_NOISE (double, 1.0); static const ProcessFunc gaussian_white_noise_funcs[] = { (ProcessFunc) gst_audio_test_src_create_gaussian_white_noise_int16, (ProcessFunc) gst_audio_test_src_create_gaussian_white_noise_int32, (ProcessFunc) gst_audio_test_src_create_gaussian_white_noise_float, (ProcessFunc) gst_audio_test_src_create_gaussian_white_noise_double }; /* Brownian (Red) Noise: noise where the power density decreases by 6 dB per * octave with increasing frequency * * taken from http://vellocet.com/dsp/noise/VRand.html * by Andrew Simper of Vellocet (andy@vellocet.com) */ #define DEFINE_RED_NOISE(type,scale) \ static void \ gst_audio_test_src_create_red_noise_##type (GstAudioTestSrc * src, g##type * samples) \ { \ gint i, c, channel_step, sample_step; \ g##type *ptr; \ gdouble amp = (src->volume * scale); \ gdouble state = src->red.state; \ gint channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ while (TRUE) { \ gdouble r = g_rand_double_range (src->gen, -1.0, 1.0); \ state += r; \ if (state < -8.0f || state > 8.0f) state -= r; \ else break; \ } \ *ptr = (g##type) (amp * state * 0.0625f); /* /16.0 */ \ ptr += channel_step; \ } \ samples += sample_step; \ } \ src->red.state = state; \ } DEFINE_RED_NOISE (int16, 32767.0); DEFINE_RED_NOISE (int32, 2147483647.0); DEFINE_RED_NOISE (float, 1.0); DEFINE_RED_NOISE (double, 1.0); static const ProcessFunc red_noise_funcs[] = { (ProcessFunc) gst_audio_test_src_create_red_noise_int16, (ProcessFunc) gst_audio_test_src_create_red_noise_int32, (ProcessFunc) gst_audio_test_src_create_red_noise_float, (ProcessFunc) gst_audio_test_src_create_red_noise_double }; /* Blue Noise: apply spectral inversion to pink noise */ #define DEFINE_BLUE_NOISE(type) \ static void \ gst_audio_test_src_create_blue_noise_##type (GstAudioTestSrc * src, g##type * samples) \ { \ gint i, c, channel_step, sample_step; \ static gdouble flip=1.0; \ gint channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ g##type *ptr; \ \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ \ gst_audio_test_src_create_pink_noise_##type (src, samples); \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ *ptr *= flip; \ ptr += channel_step; \ } \ flip *= -1.0; \ samples += sample_step; \ } \ } DEFINE_BLUE_NOISE (int16); DEFINE_BLUE_NOISE (int32); DEFINE_BLUE_NOISE (float); DEFINE_BLUE_NOISE (double); static const ProcessFunc blue_noise_funcs[] = { (ProcessFunc) gst_audio_test_src_create_blue_noise_int16, (ProcessFunc) gst_audio_test_src_create_blue_noise_int32, (ProcessFunc) gst_audio_test_src_create_blue_noise_float, (ProcessFunc) gst_audio_test_src_create_blue_noise_double }; /* Violet Noise: apply spectral inversion to red noise */ #define DEFINE_VIOLET_NOISE(type) \ static void \ gst_audio_test_src_create_violet_noise_##type (GstAudioTestSrc * src, g##type * samples) \ { \ gint i, c, channel_step, sample_step; \ static gdouble flip=1.0; \ gint channels = GST_AUDIO_INFO_CHANNELS (&src->info); \ g##type *ptr; \ \ if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_INTERLEAVED) { \ channel_step = 1; \ sample_step = channels; \ } else { \ channel_step = src->generate_samples_per_buffer; \ sample_step = 1; \ } \ \ gst_audio_test_src_create_red_noise_##type (src, samples); \ for (i = 0; i < src->generate_samples_per_buffer; i++) { \ ptr = samples; \ for (c = 0; c < channels; ++c) { \ *ptr *= flip; \ ptr += channel_step; \ } \ flip *= -1.0; \ samples += sample_step; \ } \ } DEFINE_VIOLET_NOISE (int16); DEFINE_VIOLET_NOISE (int32); DEFINE_VIOLET_NOISE (float); DEFINE_VIOLET_NOISE (double); static const ProcessFunc violet_noise_funcs[] = { (ProcessFunc) gst_audio_test_src_create_violet_noise_int16, (ProcessFunc) gst_audio_test_src_create_violet_noise_int32, (ProcessFunc) gst_audio_test_src_create_violet_noise_float, (ProcessFunc) gst_audio_test_src_create_violet_noise_double }; /* * gst_audio_test_src_change_wave: * Assign function pointer of wave generator. */ static void gst_audio_test_src_change_wave (GstAudioTestSrc * src) { gint idx; src->pack_func = NULL; src->process = NULL; /* not negotiated yet? */ if (src->info.finfo == NULL) return; switch (GST_AUDIO_FORMAT_INFO_FORMAT (src->info.finfo)) { case GST_AUDIO_FORMAT_S16: idx = 0; break; case GST_AUDIO_FORMAT_S32: idx = 1; break; case GST_AUDIO_FORMAT_F32: idx = 2; break; case GST_AUDIO_FORMAT_F64: idx = 3; break; default: /* special format */ switch (src->info.finfo->unpack_format) { case GST_AUDIO_FORMAT_S32: idx = 1; src->pack_func = src->info.finfo->pack_func; src->pack_size = sizeof (gint32); break; case GST_AUDIO_FORMAT_F64: idx = 3; src->pack_func = src->info.finfo->pack_func; src->pack_size = sizeof (gdouble); break; default: g_assert_not_reached (); return; } } switch (src->wave) { case GST_AUDIO_TEST_SRC_WAVE_SINE: src->process = sine_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_SQUARE: src->process = square_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_SAW: src->process = saw_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_TRIANGLE: src->process = triangle_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_SILENCE: src->process = silence_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_WHITE_NOISE: if (!(src->gen)) src->gen = g_rand_new (); src->process = white_noise_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_PINK_NOISE: if (!(src->gen)) src->gen = g_rand_new (); gst_audio_test_src_init_pink_noise (src); src->process = pink_noise_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_SINE_TAB: gst_audio_test_src_init_sine_table (src, TRUE); src->process = sine_table_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_TICKS: gst_audio_test_src_init_sine_table (src, FALSE); src->process = tick_funcs[idx]; src->samples_between_ticks = gst_util_uint64_scale_int (src->tick_interval, GST_AUDIO_INFO_RATE (&(src->info)), GST_SECOND); break; case GST_AUDIO_TEST_SRC_WAVE_GAUSSIAN_WHITE_NOISE: if (!(src->gen)) src->gen = g_rand_new (); src->process = gaussian_white_noise_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_RED_NOISE: if (!(src->gen)) src->gen = g_rand_new (); src->red.state = 0.0; src->process = red_noise_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_BLUE_NOISE: if (!(src->gen)) src->gen = g_rand_new (); gst_audio_test_src_init_pink_noise (src); src->process = blue_noise_funcs[idx]; break; case GST_AUDIO_TEST_SRC_WAVE_VIOLET_NOISE: if (!(src->gen)) src->gen = g_rand_new (); src->red.state = 0.0; src->process = violet_noise_funcs[idx]; break; default: GST_ERROR ("invalid wave-form"); break; } } /* * gst_audio_test_src_change_volume: * Recalc wave tables for precalculated waves. */ static void gst_audio_test_src_change_volume (GstAudioTestSrc * src) { switch (src->wave) { case GST_AUDIO_TEST_SRC_WAVE_SINE_TAB: gst_audio_test_src_init_sine_table (src, TRUE); break; default: break; } } static void gst_audio_test_src_get_times (GstBaseSrc * basesrc, GstBuffer * buffer, GstClockTime * start, GstClockTime * end) { /* for live sources, sync on the timestamp of the buffer */ if (gst_base_src_is_live (basesrc)) { GstClockTime timestamp = GST_BUFFER_TIMESTAMP (buffer); if (GST_CLOCK_TIME_IS_VALID (timestamp)) { /* get duration to calculate end time */ GstClockTime duration = GST_BUFFER_DURATION (buffer); if (GST_CLOCK_TIME_IS_VALID (duration)) { *end = timestamp + duration; } *start = timestamp; } } else { *start = -1; *end = -1; } } static gboolean gst_audio_test_src_start (GstBaseSrc * basesrc) { GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (basesrc); src->next_sample = 0; src->next_byte = 0; src->next_time = 0; src->check_seek_stop = FALSE; src->eos_reached = FALSE; src->tags_pushed = FALSE; src->accumulator = 0; src->tick_counter = 0; return TRUE; } static gboolean gst_audio_test_src_stop (GstBaseSrc * basesrc) { return TRUE; } /* seek to time, will be called when we operate in push mode. In pull mode we * get the requested byte offset. */ static gboolean gst_audio_test_src_do_seek (GstBaseSrc * basesrc, GstSegment * segment) { GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (basesrc); GstClockTime time; gint samplerate, bpf; gint64 next_sample; GST_DEBUG_OBJECT (src, "seeking %" GST_SEGMENT_FORMAT, segment); time = segment->position; src->reverse = (segment->rate < 0.0); samplerate = GST_AUDIO_INFO_RATE (&src->info); bpf = GST_AUDIO_INFO_BPF (&src->info); /* now move to the time indicated, don't seek to the sample *after* the time */ next_sample = gst_util_uint64_scale_int (time, samplerate, GST_SECOND); src->next_byte = next_sample * bpf; if (samplerate == 0) src->next_time = 0; else src->next_time = gst_util_uint64_scale_round (next_sample, GST_SECOND, samplerate); GST_DEBUG_OBJECT (src, "seeking next_sample=%" G_GINT64_FORMAT " next_time=%" GST_TIME_FORMAT, next_sample, GST_TIME_ARGS (src->next_time)); g_assert (src->next_time <= time); src->next_sample = next_sample; if (segment->rate > 0 && GST_CLOCK_TIME_IS_VALID (segment->stop)) { time = segment->stop; src->sample_stop = gst_util_uint64_scale_round (time, samplerate, GST_SECOND); src->check_seek_stop = TRUE; } else if (segment->rate < 0) { time = segment->start; src->sample_stop = gst_util_uint64_scale_round (time, samplerate, GST_SECOND); src->check_seek_stop = TRUE; } else { src->check_seek_stop = FALSE; } src->eos_reached = FALSE; return TRUE; } static gboolean gst_audio_test_src_is_seekable (GstBaseSrc * basesrc) { /* we're seekable... */ return TRUE; } static GstFlowReturn gst_audio_test_src_fill (GstBaseSrc * basesrc, guint64 offset, guint length, GstBuffer * buffer) { GstAudioTestSrc *src; GstClockTime next_time; gint64 next_sample, next_byte; gint bytes, samples; GstElementClass *eclass; GstMapInfo map; gint samplerate, bpf; src = GST_AUDIO_TEST_SRC (basesrc); /* example for tagging generated data */ if (!src->tags_pushed) { GstTagList *taglist; taglist = gst_tag_list_new (GST_TAG_DESCRIPTION, "audiotest wave", NULL); eclass = GST_ELEMENT_CLASS (parent_class); if (eclass->send_event) eclass->send_event (GST_ELEMENT_CAST (basesrc), gst_event_new_tag (taglist)); else gst_tag_list_unref (taglist); src->tags_pushed = TRUE; } if (src->eos_reached) { GST_INFO_OBJECT (src, "eos"); return GST_FLOW_EOS; } samplerate = GST_AUDIO_INFO_RATE (&src->info); bpf = GST_AUDIO_INFO_BPF (&src->info); /* if no length was given, use our default length in samples otherwise convert * the length in bytes to samples. */ if (length == -1) samples = src->samples_per_buffer; else samples = length / bpf; /* if no offset was given, use our next logical byte */ if (offset == -1) offset = src->next_byte; /* now see if we are at the byteoffset we think we are */ if (offset != src->next_byte) { GST_DEBUG_OBJECT (src, "seek to new offset %" G_GUINT64_FORMAT, offset); /* we have a discont in the expected sample offset, do a 'seek' */ src->next_sample = offset / bpf; src->next_time = gst_util_uint64_scale_int (src->next_sample, GST_SECOND, samplerate); src->next_byte = offset; } /* check for eos */ if (src->check_seek_stop && !src->reverse && (src->sample_stop > src->next_sample) && (src->sample_stop < src->next_sample + samples) ) { /* calculate only partial buffer */ src->generate_samples_per_buffer = src->sample_stop - src->next_sample; next_sample = src->sample_stop; src->eos_reached = TRUE; } else if (src->check_seek_stop && src->reverse && (src->sample_stop >= (src->next_sample - samples)) ) { /* calculate only partial buffer */ src->generate_samples_per_buffer = src->next_sample - src->sample_stop; next_sample = src->sample_stop; src->eos_reached = TRUE; } else { /* calculate full buffer */ src->generate_samples_per_buffer = samples; next_sample = src->next_sample + (src->reverse ? (-samples) : samples); } bytes = src->generate_samples_per_buffer * bpf; next_byte = src->next_byte + (src->reverse ? (-bytes) : bytes); next_time = gst_util_uint64_scale_int (next_sample, GST_SECOND, samplerate); GST_LOG_OBJECT (src, "samplerate %d", samplerate); GST_LOG_OBJECT (src, "next_sample %" G_GINT64_FORMAT ", ts %" GST_TIME_FORMAT, next_sample, GST_TIME_ARGS (next_time)); gst_buffer_set_size (buffer, bytes); GST_BUFFER_OFFSET (buffer) = src->next_sample; GST_BUFFER_OFFSET_END (buffer) = next_sample; if (!src->reverse) { GST_BUFFER_TIMESTAMP (buffer) = src->timestamp_offset + src->next_time; GST_BUFFER_DURATION (buffer) = next_time - src->next_time; } else { GST_BUFFER_TIMESTAMP (buffer) = src->timestamp_offset + next_time; GST_BUFFER_DURATION (buffer) = src->next_time - next_time; } gst_object_sync_values (GST_OBJECT (src), GST_BUFFER_TIMESTAMP (buffer)); src->next_time = next_time; src->next_sample = next_sample; src->next_byte = next_byte; GST_LOG_OBJECT (src, "generating %u samples at ts %" GST_TIME_FORMAT, src->generate_samples_per_buffer, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer))); gst_buffer_map (buffer, &map, GST_MAP_WRITE); if (src->pack_func) { gsize tmpsize; tmpsize = src->generate_samples_per_buffer * GST_AUDIO_INFO_CHANNELS (&src->info) * src->pack_size; if (tmpsize > src->tmpsize) { src->tmp = g_realloc (src->tmp, tmpsize); src->tmpsize = tmpsize; } src->process (src, src->tmp); src->pack_func (src->info.finfo, 0, src->tmp, map.data, src->generate_samples_per_buffer * GST_AUDIO_INFO_CHANNELS (&src->info)); } else { src->process (src, map.data); } gst_buffer_unmap (buffer, &map); if (G_UNLIKELY ((src->wave == GST_AUDIO_TEST_SRC_WAVE_SILENCE) || (src->volume == 0.0))) { GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_GAP); } if (GST_AUDIO_INFO_LAYOUT (&src->info) == GST_AUDIO_LAYOUT_NON_INTERLEAVED) { gst_buffer_add_audio_meta (buffer, &src->info, src->generate_samples_per_buffer, NULL); } return GST_FLOW_OK; } static void gst_audio_test_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (object); switch (prop_id) { case PROP_SAMPLES_PER_BUFFER: src->samples_per_buffer = g_value_get_int (value); gst_base_src_set_blocksize (GST_BASE_SRC_CAST (src), GST_AUDIO_INFO_BPF (&src->info) * src->samples_per_buffer); break; case PROP_WAVE: src->wave = g_value_get_enum (value); gst_audio_test_src_change_wave (src); break; case PROP_FREQ: src->freq = g_value_get_double (value); break; case PROP_VOLUME: src->volume = g_value_get_double (value); gst_audio_test_src_change_volume (src); break; case PROP_IS_LIVE: gst_base_src_set_live (GST_BASE_SRC (src), g_value_get_boolean (value)); break; case PROP_TIMESTAMP_OFFSET: src->timestamp_offset = g_value_get_int64 (value); break; case PROP_SINE_PERIODS_PER_TICK: src->sine_periods_per_tick = g_value_get_uint (value); break; case PROP_TICK_INTERVAL: src->tick_interval = g_value_get_uint64 (value); break; case PROP_MARKER_TICK_PERIOD: src->marker_tick_period = g_value_get_uint (value); break; case PROP_MARKER_TICK_VOLUME: src->marker_tick_volume = g_value_get_double (value); break; case PROP_APPLY_TICK_RAMP: src->apply_tick_ramp = g_value_get_boolean (value); break; case PROP_CAN_ACTIVATE_PUSH: GST_BASE_SRC (src)->can_activate_push = g_value_get_boolean (value); break; case PROP_CAN_ACTIVATE_PULL: src->can_activate_pull = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_audio_test_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (object); switch (prop_id) { case PROP_SAMPLES_PER_BUFFER: g_value_set_int (value, src->samples_per_buffer); break; case PROP_WAVE: g_value_set_enum (value, src->wave); break; case PROP_FREQ: g_value_set_double (value, src->freq); break; case PROP_VOLUME: g_value_set_double (value, src->volume); break; case PROP_IS_LIVE: g_value_set_boolean (value, gst_base_src_is_live (GST_BASE_SRC (src))); break; case PROP_TIMESTAMP_OFFSET: g_value_set_int64 (value, src->timestamp_offset); break; case PROP_SINE_PERIODS_PER_TICK: g_value_set_uint (value, src->sine_periods_per_tick); break; case PROP_TICK_INTERVAL: g_value_set_uint64 (value, src->tick_interval); break; case PROP_MARKER_TICK_PERIOD: g_value_set_uint (value, src->marker_tick_period); break; case PROP_MARKER_TICK_VOLUME: g_value_set_double (value, src->marker_tick_volume); break; case PROP_APPLY_TICK_RAMP: g_value_set_boolean (value, src->apply_tick_ramp); 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; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static gboolean plugin_init (GstPlugin * plugin) { return GST_ELEMENT_REGISTER (audiotestsrc, plugin); } GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, audiotestsrc, "Creates audio test signals of given frequency and volume", plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);