mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-19 06:46:38 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/audiotestsrc/gstaudiotestsrc.c
Carlos Rafael Giani c656cfb170 audiotestsrc: Improvements to the "ticks" wave 
(Initially discussed in
https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/issues/305)

The ticks waveform can be useful for audio synchronization diagnostics
and other cases where the time offset between waveforms is important.
However, in its current form, it is too limited, and has problems with
discontinuities, which result in severe artifacts when this waveform
is output by a DAC.

This patch fixes some discontinuities and considerably expand the ticks
waveform's flexibility. They also introduce the notion of a "marker tick";
every Nth tick can have a different amplitude (usually one that is larger
than the others). This is useful for combining frequent oscilloscope
triggering with large time offset detection. For example, without marker
ticks, the tick intervals must not be too small, otherwise the maximum time
offset that can be unambiguously detected is quite small (for example, if
the interval is 50ms, then no time offset larger than 25ms can be
unambiguously recognized). If the tick intervals are too far apart, then
no sudden changes can be clearly observed, since the oscilloscope is not
updated quickly enough. But with marker ticks, this is not an issue: If
there's for example a tick every 100 ms, then the oscilloscope can be
triggered every 100 ms. And, if every 20th tick is a marker tick, then
time offsets of up to 1 second can be discovered, even though the time
between ticks is 100 ms.

The patch also applies some minor cleanup to the audiotestsrc documentation.
2019-01-10 16:15:47 +00:00

1699 lines
55 KiB
C
Raw Blame History

/* 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., 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:
*
* <orderedlist>
* <listitem>
* <itemizedlist><title>Gaussian white noise</title>
*
* 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.
*
* </itemizedlist>
* </listitem>
* <listitem>
* <itemizedlist><title>Ticks</title>
*
* 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.
* </itemizedlist>
* </listitem>
* </orderedlist>
*
* ## 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 <math.h>
#include <stdlib.h>
#include <string.h>
#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);
#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 4 times higher.",
0.0, (gdouble) G_MAXINT / 4, 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 <ensonic@users.sf.net>");
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);
}
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 * 4);
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))
gst_structure_set (structure, "channel-mask", GST_TYPE_BITMASK, 0ULL,
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); \
} 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 compex 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)
) {
/* 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 {
/* 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)
{
GST_DEBUG_CATEGORY_INIT (audio_test_src_debug, "audiotestsrc", 0,
"Audio Test Source");
return gst_element_register (plugin, "audiotestsrc",
GST_RANK_NONE, GST_TYPE_AUDIO_TEST_SRC);
}
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);
Reference in a new issue View git blame Copy permalink