/* GStreamer
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
* <2006> Stefan Kost <ensonic@users.sf.net>
+ * <2007> Sebastian Dröge <slomo@circular-chaos.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* </listitem>
* <listitem>
* <para>
- * #GstValueList of #guchar
- * <classname>"spectrum"</classname>:
+ * #GstValueList of #gfloat
+ * <classname>"magnitude"</classname>:
* the level for each frequency band. A value of 0 maps to the
* db value given by the
* <link linkend="GstSpectrum--threshold">threshold property.</link>.
* </para>
* </listitem>
+ * <listitem>
+ * <para>
+ * #GstValueList of #gfloat
+ * <classname>"phase"</classname>:
+ * the phase for each frequency band. The value is between -pi and pi.
+ * </para>
+ * </listitem>
+
*
* This element cannot be used with the gst-launch command in a sensible way.
* The included demo shows how to use it in an application.
*
- * Last reviewed on 2006-05-21 (0.10.3)
+ * Last reviewed on 2007-08-18 (0.10.5)
* </refsect2>
*/
#include "config.h"
#endif
#include <string.h>
+#include <stdlib.h>
#include <gst/audio/audio.h>
+#include <gst/audio/gstaudiofilter.h>
+#include <math.h>
#include "gstspectrum.h"
+#include <gst/fft/gstfft.h>
+#include <gst/fft/gstffts16.h>
+#include <gst/fft/gstffts32.h>
+#include <gst/fft/gstfftf32.h>
+#include <gst/fft/gstfftf64.h>
+
GST_DEBUG_CATEGORY_STATIC (gst_spectrum_debug);
#define GST_CAT_DEFAULT gst_spectrum_debug
"Filter/Analyzer/Audio",
"Run an FFT on the audio signal, output spectrum data",
"Erik Walthinsen <omega@cse.ogi.edu>, "
- "Stefan Kost <ensonic@users.sf.net>");
-
-static GstStaticPadTemplate sink_template_factory =
-GST_STATIC_PAD_TEMPLATE ("sink",
- GST_PAD_SINK,
- GST_PAD_ALWAYS,
- GST_STATIC_CAPS ("audio/x-raw-int, "
- "rate = (int) [ 1, MAX ], "
- "channels = (int) [1, MAX], "
- "endianness = (int) BYTE_ORDER, "
- "width = (int) 16, " "depth = (int) 16, " "signed = (boolean) true")
- );
-
-static GstStaticPadTemplate src_template_factory =
-GST_STATIC_PAD_TEMPLATE ("src",
- GST_PAD_SRC,
- GST_PAD_ALWAYS,
- GST_STATIC_CAPS ("audio/x-raw-int, "
- "rate = (int) [ 1, MAX ], "
- "channels = (int) [1, MAX], "
- "endianness = (int) BYTE_ORDER, "
- "width = (int) 16, " "depth = (int) 16, " "signed = (boolean) true")
- );
+ "Stefan Kost <ensonic@users.sf.net>, "
+ "Sebastian Dröge <slomo@circular-chaos.org>");
+
+#define ALLOWED_CAPS \
+ "audio/x-raw-int, " \
+ " width = (int) 16, " \
+ " depth = (int) 16, " \
+ " signed = (boolean) true, " \
+ " endianness = (int) BYTE_ORDER, " \
+ " rate = (int) [ 1, MAX ], " \
+ " channels = (int) [ 1, MAX ]; " \
+ "audio/x-raw-int, " \
+ " width = (int) 32, " \
+ " depth = (int) 32, " \
+ " signed = (boolean) true, " \
+ " endianness = (int) BYTE_ORDER, " \
+ " rate = (int) [ 1, MAX ], " \
+ " channels = (int) [ 1, MAX ]; " \
+ "audio/x-raw-float, " \
+ " width = (int) { 32, 64 }, " \
+ " endianness = (int) BYTE_ORDER, " \
+ " rate = (int) [ 1, MAX ], " \
+ " channels = (int) [ 1, MAX ]"
/* Spectrum properties */
#define DEFAULT_SIGNAL_SPECTRUM TRUE
+#define DEFAULT_SIGNAL_MAGNITUDE TRUE
+#define DEFAULT_SIGNAL_PHASE FALSE
#define DEFAULT_SIGNAL_INTERVAL (GST_SECOND / 10)
#define DEFAULT_BANDS 128
#define DEFAULT_THRESHOLD -60
{
PROP_0,
PROP_SIGNAL_SPECTRUM,
+ PROP_SIGNAL_MAGNITUDE,
+ PROP_SIGNAL_PHASE,
PROP_SIGNAL_INTERVAL,
PROP_BANDS,
PROP_THRESHOLD
};
-GST_BOILERPLATE (GstSpectrum, gst_spectrum, GstBaseTransform,
- GST_TYPE_BASE_TRANSFORM);
+GST_BOILERPLATE (GstSpectrum, gst_spectrum, GstAudioFilter,
+ GST_TYPE_AUDIO_FILTER);
static void gst_spectrum_dispose (GObject * object);
static void gst_spectrum_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_spectrum_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
-static gboolean gst_spectrum_set_caps (GstBaseTransform * trans, GstCaps * in,
- GstCaps * out);
static gboolean gst_spectrum_start (GstBaseTransform * trans);
static gboolean gst_spectrum_stop (GstBaseTransform * trans);
static gboolean gst_spectrum_event (GstBaseTransform * trans, GstEvent * event);
static GstFlowReturn gst_spectrum_transform_ip (GstBaseTransform * trans,
GstBuffer * in);
+static gboolean gst_spectrum_setup (GstAudioFilter * base,
+ GstRingBufferSpec * format);
-
-#define fixed short
-extern int gst_spectrum_fix_fft (fixed fr[], fixed fi[], int m, int inverse);
-extern void gst_spectrum_fix_loud (fixed loud[], fixed fr[], fixed fi[], int n,
- int scale_shift);
-extern void gst_spectrum_window (fixed fr[], int n);
+static void process_s16 (GstSpectrum * spectrum, const gint16 * samples);
+static void process_s32 (GstSpectrum * spectrum, const gint32 * samples);
+static void process_f32 (GstSpectrum * spectrum, const gfloat * samples);
+static void process_f64 (GstSpectrum * spectrum, const gdouble * samples);
static void
gst_spectrum_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+ GstCaps *caps;
- gst_element_class_add_pad_template (element_class,
- gst_static_pad_template_get (&sink_template_factory));
- gst_element_class_add_pad_template (element_class,
- gst_static_pad_template_get (&src_template_factory));
gst_element_class_set_details (element_class, &gst_spectrum_details);
+
+ caps = gst_caps_from_string (ALLOWED_CAPS);
+ gst_audio_filter_class_add_pad_templates (GST_AUDIO_FILTER_CLASS (g_class),
+ caps);
+ gst_caps_unref (caps);
}
static void
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstBaseTransformClass *trans_class = GST_BASE_TRANSFORM_CLASS (klass);
+ GstAudioFilterClass *filter_class = GST_AUDIO_FILTER_CLASS (klass);
gobject_class->set_property = gst_spectrum_set_property;
gobject_class->get_property = gst_spectrum_get_property;
gobject_class->dispose = gst_spectrum_dispose;
- trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_spectrum_set_caps);
trans_class->start = GST_DEBUG_FUNCPTR (gst_spectrum_start);
trans_class->stop = GST_DEBUG_FUNCPTR (gst_spectrum_stop);
trans_class->event = GST_DEBUG_FUNCPTR (gst_spectrum_event);
trans_class->transform_ip = GST_DEBUG_FUNCPTR (gst_spectrum_transform_ip);
trans_class->passthrough_on_same_caps = TRUE;
+ filter_class->setup = GST_DEBUG_FUNCPTR (gst_spectrum_setup);
+
g_object_class_install_property (gobject_class, PROP_SIGNAL_SPECTRUM,
g_param_spec_boolean ("message", "Message",
"Post a level message for each passed interval",
DEFAULT_SIGNAL_SPECTRUM, G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class, PROP_SIGNAL_MAGNITUDE,
+ g_param_spec_boolean ("message-magnitude", "Magnitude",
+ "Post the magnitude of the spectrum",
+ DEFAULT_SIGNAL_MAGNITUDE, G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_SIGNAL_PHASE,
+ g_param_spec_boolean ("message-phase", "Phase",
+ "Post the phase of the spectrum",
+ DEFAULT_SIGNAL_PHASE, G_PARAM_READWRITE));
+
g_object_class_install_property (gobject_class, PROP_SIGNAL_INTERVAL,
g_param_spec_uint64 ("interval", "Interval",
"Interval of time between message posts (in nanoseconds)",
spectrum->adapter = gst_adapter_new ();
spectrum->message = DEFAULT_SIGNAL_SPECTRUM;
+ spectrum->message_magnitude = DEFAULT_SIGNAL_MAGNITUDE;
+ spectrum->message_phase = DEFAULT_SIGNAL_PHASE;
spectrum->interval = DEFAULT_SIGNAL_INTERVAL;
spectrum->bands = DEFAULT_BANDS;
spectrum->threshold = DEFAULT_THRESHOLD;
- spectrum->loud = g_malloc (SPECTRUM_WINDOW_LEN * sizeof (gint16));
- spectrum->im = g_malloc0 (SPECTRUM_WINDOW_LEN * sizeof (gint16));
- spectrum->re = g_malloc0 (SPECTRUM_WINDOW_LEN * sizeof (gint16));
- spectrum->spect = g_malloc (spectrum->bands * sizeof (guchar));
+ spectrum->spect_magnitude = g_new0 (gfloat, spectrum->bands);
+ spectrum->spect_phase = g_new0 (gfloat, spectrum->bands);
}
static void
spectrum->adapter = NULL;
}
- g_free (spectrum->re);
- g_free (spectrum->im);
- g_free (spectrum->loud);
- g_free (spectrum->spect);
+ g_free (spectrum->in);
+ if (spectrum->fft_free_func) {
+ spectrum->fft_free_func (spectrum->fft_ctx);
+ spectrum->fft_ctx = NULL;
+ spectrum->fft_free_func = NULL;
+ }
+ g_free (spectrum->freqdata);
+ g_free (spectrum->spect_magnitude);
+ g_free (spectrum->spect_phase);
- spectrum->re = NULL;
- spectrum->im = NULL;
- spectrum->loud = NULL;
- spectrum->spect = NULL;
+ spectrum->in = NULL;
+ spectrum->spect_magnitude = NULL;
+ spectrum->spect_phase = NULL;
+ spectrum->freqdata = NULL;
G_OBJECT_CLASS (parent_class)->dispose (object);
}
case PROP_SIGNAL_SPECTRUM:
filter->message = g_value_get_boolean (value);
break;
+ case PROP_SIGNAL_MAGNITUDE:
+ filter->message_magnitude = g_value_get_boolean (value);
+ break;
+ case PROP_SIGNAL_PHASE:
+ filter->message_phase = g_value_get_boolean (value);
+ break;
case PROP_SIGNAL_INTERVAL:
filter->interval = g_value_get_uint64 (value);
break;
case PROP_BANDS:
GST_BASE_TRANSFORM_LOCK (filter);
+
filter->bands = g_value_get_uint (value);
- g_free (filter->spect);
- filter->spect = g_malloc (filter->bands * sizeof (guchar));
+ g_free (filter->spect_magnitude);
+ g_free (filter->spect_phase);
+ g_free (filter->in);
+ g_free (filter->freqdata);
+
+ if (filter->fft_free_func) {
+ filter->fft_free_func (filter->fft_ctx);
+ filter->fft_ctx = NULL;
+ filter->fft_free_func = NULL;
+ }
+
+ filter->in = NULL;
+ filter->freqdata = NULL;
+ filter->spect_magnitude = g_new0 (gfloat, filter->bands);
+ filter->spect_phase = g_new0 (gfloat, filter->bands);
+ filter->num_frames = 0;
+ filter->num_fft = 0;
GST_BASE_TRANSFORM_UNLOCK (filter);
GST_DEBUG_OBJECT (filter, "reallocation, spect = %p, bands =%d ",
- filter->spect, filter->bands);
+ filter->spect_magnitude, filter->bands);
break;
case PROP_THRESHOLD:
filter->threshold = g_value_get_int (value);
case PROP_SIGNAL_SPECTRUM:
g_value_set_boolean (value, filter->message);
break;
+ case PROP_SIGNAL_MAGNITUDE:
+ g_value_set_boolean (value, filter->message_magnitude);
+ break;
+ case PROP_SIGNAL_PHASE:
+ g_value_set_boolean (value, filter->message_phase);
+ break;
case PROP_SIGNAL_INTERVAL:
g_value_set_uint64 (value, filter->interval);
break;
}
static gboolean
-gst_spectrum_set_caps (GstBaseTransform * trans, GstCaps * in, GstCaps * out)
-{
- GstSpectrum *filter = GST_SPECTRUM (trans);
- GstStructure *structure;
-
- structure = gst_caps_get_structure (in, 0);
- gst_structure_get_int (structure, "rate", &filter->rate);
- gst_structure_get_int (structure, "channels", &filter->channels);
-
- return TRUE;
-}
-
-static gboolean
gst_spectrum_start (GstBaseTransform * trans)
{
GstSpectrum *filter = GST_SPECTRUM (trans);
filter->num_frames = 0;
+ filter->num_fft = 0;
+ if (filter->spect_magnitude)
+ memset (filter->spect_magnitude, filter->bands * sizeof (gfloat), 0);
+ if (filter->spect_phase)
+ memset (filter->spect_phase, filter->bands * sizeof (gfloat), 0);
gst_segment_init (&filter->segment, GST_FORMAT_UNDEFINED);
return TRUE;
return TRUE;
}
+static gboolean
+gst_spectrum_setup (GstAudioFilter * base, GstRingBufferSpec * format)
+{
+ GstSpectrum *filter = GST_SPECTRUM (base);
+
+ if (filter->in) {
+ g_free (filter->in);
+ filter->in = NULL;
+ }
+
+ if (filter->fft_free_func) {
+ filter->fft_free_func (filter->fft_ctx);
+ filter->fft_ctx = NULL;
+ filter->fft_free_func = NULL;
+ }
+
+ if (filter->freqdata) {
+ g_free (filter->freqdata);
+ filter->freqdata = NULL;
+ }
+
+ if (format->type == GST_BUFTYPE_LINEAR && format->width == 32)
+ filter->process = (GstSpectrumProcessFunc) process_s32;
+ else if (format->type == GST_BUFTYPE_LINEAR && format->width == 16)
+ filter->process = (GstSpectrumProcessFunc) process_s16;
+ else if (format->type == GST_BUFTYPE_FLOAT && format->width == 64)
+ filter->process = (GstSpectrumProcessFunc) process_f64;
+ else if (format->type == GST_BUFTYPE_FLOAT && format->width == 32)
+ filter->process = (GstSpectrumProcessFunc) process_f32;
+ else
+ g_assert_not_reached ();
+
+ return TRUE;
+}
+
static GstMessage *
gst_spectrum_message_new (GstSpectrum * spectrum, GstClockTime endtime)
{
GValue v = { 0, };
GValue *l;
guint i;
- guchar *spect = spectrum->spect;
+ gfloat *spect_magnitude = spectrum->spect_magnitude;
+ gfloat *spect_phase = spectrum->spect_phase;
GST_DEBUG_OBJECT (spectrum, "preparing message, spect = %p, bands =%d ",
- spect, spectrum->bands);
+ spect_magnitude, spectrum->bands);
s = gst_structure_new ("spectrum", "endtime", GST_TYPE_CLOCK_TIME,
endtime, NULL);
- g_value_init (&v, GST_TYPE_LIST);
- /* will copy-by-value */
- gst_structure_set_value (s, "spectrum", &v);
- g_value_unset (&v);
+ if (spectrum->message_magnitude) {
+ g_value_init (&v, GST_TYPE_LIST);
+ /* will copy-by-value */
+ gst_structure_set_value (s, "magnitude", &v);
+ g_value_unset (&v);
+
+ g_value_init (&v, G_TYPE_FLOAT);
+ l = (GValue *) gst_structure_get_value (s, "magnitude");
+ for (i = 0; i < spectrum->bands; i++) {
+ g_value_set_float (&v, spect_magnitude[i]);
+ gst_value_list_append_value (l, &v); /* copies by value */
+ }
+ g_value_unset (&v);
+ }
- g_value_init (&v, G_TYPE_UCHAR);
- l = (GValue *) gst_structure_get_value (s, "spectrum");
- for (i = 0; i < spectrum->bands; i++) {
- g_value_set_uchar (&v, spect[i]);
- gst_value_list_append_value (l, &v); /* copies by value */
+ if (spectrum->message_phase) {
+ g_value_init (&v, GST_TYPE_LIST);
+ /* will copy-by-value */
+ gst_structure_set_value (s, "phase", &v);
+ g_value_unset (&v);
+
+ g_value_init (&v, G_TYPE_FLOAT);
+ l = (GValue *) gst_structure_get_value (s, "phase");
+ for (i = 0; i < spectrum->bands; i++) {
+ g_value_set_float (&v, spect_phase[i]);
+ gst_value_list_append_value (l, &v); /* copies by value */
+ }
+ g_value_unset (&v);
}
- g_value_unset (&v);
return gst_message_new_element (GST_OBJECT (spectrum), s);
}
+#define DEFINE_PROCESS_FUNC_INT(width,next_width,max) \
+static void \
+process_s##width (GstSpectrum *spectrum, const gint##width *samples) \
+{ \
+ gfloat *spect_magnitude = spectrum->spect_magnitude; \
+ gfloat *spect_phase = spectrum->spect_phase; \
+ gint channels = GST_AUDIO_FILTER (spectrum)->format.channels; \
+ gint i, j, k; \
+ gint##next_width acc; \
+ GstFFTS##width##Complex *freqdata; \
+ GstFFTS##width *ctx; \
+ gint##width *in; \
+ gint nfft = 2 * spectrum->bands - 2; \
+ \
+ if (!spectrum->in) \
+ spectrum->in = (guint8 *) g_new (gint##width, nfft); \
+ \
+ in = (gint##width *) spectrum->in; \
+ \
+ for (i = 0, j = 0; i < nfft; i++) { \
+ /* convert to mono */ \
+ for (k = 0, acc = 0; k < channels; k++) \
+ acc += samples[j++]; \
+ in[i] = (gint##width) (acc / channels); \
+ } \
+ \
+ if (!spectrum->fft_ctx) { \
+ spectrum->fft_ctx = gst_fft_s##width##_new (nfft, FALSE); \
+ spectrum->fft_free_func = (GstSpectrumFFTFreeFunc) gst_fft_s##width##_free; \
+ } \
+ ctx = spectrum->fft_ctx; \
+ \
+ gst_fft_s##width##_window (ctx, in, GST_FFT_WINDOW_HAMMING); \
+ \
+ if (!spectrum->freqdata) \
+ spectrum->freqdata = g_new (GstFFTS##width##Complex, spectrum->bands); \
+ \
+ freqdata = (GstFFTS##width##Complex *) spectrum->freqdata; \
+ \
+ gst_fft_s##width##_fft (ctx, in, freqdata); \
+ spectrum->num_fft++; \
+ \
+ /* Calculate magnitude in db */ \
+ for (i = 0; i < spectrum->bands; i++) { \
+ gdouble val = (gdouble) freqdata[i].r * (gdouble) freqdata[i].r \
+ + (gdouble) freqdata[i].i * (gdouble) freqdata[i].i; \
+ val = sqrt (val); \
+ val = 20.0 * log10 (val / max); \
+ if (val > spectrum->threshold) \
+ val -= spectrum->threshold; \
+ else \
+ val = 0.0; \
+ spect_magnitude[i] += val; \
+ } \
+ \
+ /* Calculate phase */ \
+ for (i = 0; i < spectrum->bands; i++) \
+ spect_phase[i] += atan2 (freqdata[i].i, freqdata[i].r); \
+ \
+}
+
+DEFINE_PROCESS_FUNC_INT (16, 32, 32767.0);
+DEFINE_PROCESS_FUNC_INT (32, 64, 2147483647.0);
+
+#define DEFINE_PROCESS_FUNC_FLOAT(width,type) \
+static void \
+process_f##width (GstSpectrum *spectrum, const g##type *samples) \
+{ \
+ gfloat *spect_magnitude = spectrum->spect_magnitude; \
+ gfloat *spect_phase = spectrum->spect_phase; \
+ gint channels = GST_AUDIO_FILTER (spectrum)->format.channels; \
+ gint i, j, k; \
+ g##type acc; \
+ GstFFTF##width##Complex *freqdata; \
+ GstFFTF##width *ctx; \
+ g##type *in; \
+ gint nfft = 2 * spectrum->bands - 2; \
+ \
+ if (!spectrum->in) \
+ spectrum->in = (guint8 *) g_new (g##type, nfft); \
+ \
+ in = (g##type *) spectrum->in; \
+ \
+ for (i = 0, j = 0; i < nfft; i++) { \
+ /* convert to mono */ \
+ for (k = 0, acc = 0; k < channels; k++) \
+ acc += samples[j++]; \
+ in[i] = (g##type) (acc / channels); \
+ if (abs (in[i]) > 1.0) \
+ g_assert_not_reached(); \
+ } \
+ \
+ if (!spectrum->fft_ctx) { \
+ spectrum->fft_ctx = gst_fft_f##width##_new (nfft, FALSE); \
+ spectrum->fft_free_func = (GstSpectrumFFTFreeFunc) gst_fft_f##width##_free; \
+ } \
+ ctx = spectrum->fft_ctx; \
+ \
+ gst_fft_f##width##_window (ctx, in, GST_FFT_WINDOW_HAMMING); \
+ \
+ if (!spectrum->freqdata) \
+ spectrum->freqdata = g_new (GstFFTF##width##Complex, spectrum->bands); \
+ \
+ freqdata = (GstFFTF##width##Complex *) spectrum->freqdata; \
+ \
+ gst_fft_f##width##_fft (ctx, in, freqdata); \
+ spectrum->num_fft++; \
+ \
+ /* Calculate magnitude in db */ \
+ for (i = 0; i < spectrum->bands; i++) { \
+ gdouble val = freqdata[i].r * freqdata[i].r + freqdata[i].i * freqdata[i].i; \
+ val = sqrt (val); \
+ val = 20.0 * log10 (val / nfft); \
+ if (val > spectrum->threshold) \
+ val -= spectrum->threshold; \
+ else \
+ val = 0.0; \
+ spect_magnitude[i] += val; \
+ } \
+ \
+ /* Calculate phase */ \
+ for (i = 0; i < spectrum->bands; i++) \
+ spect_phase[i] += atan2 (freqdata[i].i, freqdata[i].r); \
+ \
+}
+
+DEFINE_PROCESS_FUNC_FLOAT (32, float);
+DEFINE_PROCESS_FUNC_FLOAT (64, double);
+
static GstFlowReturn
gst_spectrum_transform_ip (GstBaseTransform * trans, GstBuffer * in)
{
GstSpectrum *spectrum = GST_SPECTRUM (trans);
gint wanted;
- gint i, j, k;
- gint32 acc;
- gfloat pos, step;
- guchar *spect = spectrum->spect;
+ gint i;
+ gfloat *spect_magnitude = spectrum->spect_magnitude;
+ gfloat *spect_phase = spectrum->spect_phase;
+ gint rate = GST_AUDIO_FILTER (spectrum)->format.rate;
+ gint channels = GST_AUDIO_FILTER (spectrum)->format.channels;
+ gint width = GST_AUDIO_FILTER (spectrum)->format.width / 8;
+ gint nfft = 2 * spectrum->bands - 2;
GstClockTime endtime =
gst_segment_to_running_time (&spectrum->segment, GST_FORMAT_TIME,
GST_BUFFER_TIMESTAMP (in));
- GstClockTime blktime =
- GST_FRAMES_TO_CLOCK_TIME (SPECTRUM_WINDOW_LEN, spectrum->rate);
+ GstClockTime blktime = GST_FRAMES_TO_CLOCK_TIME (nfft, rate);
GST_LOG_OBJECT (spectrum, "input size: %d bytes", GST_BUFFER_SIZE (in));
/* can we do this nicer? */
gst_adapter_push (spectrum->adapter, gst_buffer_copy (in));
/* required number of bytes */
- wanted = spectrum->channels * SPECTRUM_WINDOW_LEN * sizeof (gint16);
- /* FIXME: 4.0 was 2.0 before, but that include the mirrored spectrum */
- step = (gfloat) SPECTRUM_WINDOW_LEN / (spectrum->bands * 4.0);
+ wanted = channels * nfft * width;
while (gst_adapter_available (spectrum->adapter) >= wanted) {
- const gint16 *samples;
-
- samples = (const gint16 *) gst_adapter_peek (spectrum->adapter, wanted);
+ const guint8 *samples;
- /* the current fft code is gint16 based, so supporting other formats would
- * not really benefit now */
- for (i = 0, j = 0; i < SPECTRUM_WINDOW_LEN; i++) {
- /* convert to mono */
- for (k = 0, acc = 0; k < spectrum->channels; k++)
- acc += samples[j++];
- spectrum->re[i] = (gint16) (acc / spectrum->channels);
- }
+ samples = gst_adapter_peek (spectrum->adapter, wanted);
- gst_spectrum_window (spectrum->re, SPECTRUM_WINDOW_LEN);
- gst_spectrum_fix_fft (spectrum->re, spectrum->im, SPECTRUM_WINDOW_BASE,
- FALSE);
- gst_spectrum_fix_loud (spectrum->loud, spectrum->re, spectrum->im,
- SPECTRUM_WINDOW_LEN, 0);
-
- /* resample to requested number of bands and offset by threshold */
- for (i = 0, pos = 0.0; i < spectrum->bands; i++, pos += step) {
- if (spectrum->loud[(gint) pos] > spectrum->threshold) {
- spect[i] = spectrum->loud[(gint) pos] - spectrum->threshold;
- /*
- if (spect[i] > 15);
- spect[i] = 15;
- */
- } else
- /* treat as silence */
- spect[i] = 0;
- }
+ spectrum->process (spectrum, samples);
- spectrum->num_frames += SPECTRUM_WINDOW_LEN;
+ spectrum->num_frames += nfft;
endtime += blktime;
/* do we need to message ? */
if (spectrum->num_frames >=
- GST_CLOCK_TIME_TO_FRAMES (spectrum->interval, spectrum->rate)) {
+ GST_CLOCK_TIME_TO_FRAMES (spectrum->interval, rate)) {
if (spectrum->message) {
- GstMessage *m = gst_spectrum_message_new (spectrum, endtime);
+ GstMessage *m;
+
+ /* Calculate average */
+ for (i = 0; i < spectrum->bands; i++) {
+ spect_magnitude[i] /= spectrum->num_fft;
+ spect_phase[i] /= spectrum->num_fft;
+ }
+
+ m = gst_spectrum_message_new (spectrum, endtime);
gst_element_post_message (GST_ELEMENT (spectrum), m);
}
+ memset (spect_magnitude, spectrum->bands * sizeof (gfloat), 0);
+ memset (spect_phase, spectrum->bands * sizeof (gfloat), 0);
spectrum->num_frames = 0;
+ spectrum->num_fft = 0;
}
gst_adapter_flush (spectrum->adapter, wanted);
GstPad *mysrcpad, *mysinkpad;
#define SPECT_CAPS_TEMPLATE_STRING \
+ "audio/x-raw-int, " \
+ " width = (int) 16, " \
+ " depth = (int) 16, " \
+ " signed = (boolean) true, " \
+ " endianness = (int) BYTE_ORDER, " \
+ " rate = (int) [ 1, MAX ], " \
+ " channels = (int) [ 1, MAX ]; " \
+ "audio/x-raw-int, " \
+ " width = (int) 32, " \
+ " depth = (int) 32, " \
+ " signed = (boolean) true, " \
+ " endianness = (int) BYTE_ORDER, " \
+ " rate = (int) [ 1, MAX ], " \
+ " channels = (int) [ 1, MAX ]; " \
+ "audio/x-raw-float, " \
+ " width = (int) { 32, 64 }, " \
+ " endianness = (int) BYTE_ORDER, " \
+ " rate = (int) [ 1, MAX ], " \
+ " channels = (int) [ 1, MAX ]"
+
+#define SPECT_CAPS_STRING_S16 \
"audio/x-raw-int, " \
- "rate = (int) [ 1, MAX ], " \
- "channels = (int) [ 1, 8 ], " \
+ "rate = (int) 44100, " \
+ "channels = (int) 1, " \
"endianness = (int) BYTE_ORDER, " \
- "width = (int) {8, 16}, " \
- "depth = (int) {8, 16}, " \
+ "width = (int) 16, " \
+ "depth = (int) 16, " \
"signed = (boolean) true"
-#define SPECT_CAPS_STRING \
+#define SPECT_CAPS_STRING_S32 \
"audio/x-raw-int, " \
"rate = (int) 44100, " \
"channels = (int) 1, " \
"endianness = (int) BYTE_ORDER, " \
- "width = (int) 16, " \
- "depth = (int) 16, " \
+ "width = (int) 32, " \
+ "depth = (int) 32, " \
"signed = (boolean) true"
-#define SPECT_BANDS 64
+#define SPECT_CAPS_STRING_F32 \
+ "audio/x-raw-float, " \
+ " width = (int) 32, " \
+ " endianness = (int) BYTE_ORDER, " \
+ " rate = (int) 44100, " \
+ " channels = (int) 1"
+
+#define SPECT_CAPS_STRING_F64 \
+ "audio/x-raw-float, " \
+ " width = (int) 64, " \
+ " endianness = (int) BYTE_ORDER, " \
+ " rate = (int) 44100, " \
+ " channels = (int) 1"
+
+#define SPECT_BANDS 256
static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
gint16 *data;
const GValue *list, *value;
GstClockTime endtime;
- guchar level;
+ gfloat level;
spectrum = setup_spectrum ();
- g_object_set (spectrum, "message", TRUE, "interval", GST_SECOND / 10,
+ g_object_set (spectrum, "message", TRUE, "interval", GST_SECOND / 100,
"bands", SPECT_BANDS, "threshold", -80, NULL);
fail_unless (gst_element_set_state (spectrum,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
- /* create a fake 1 sec buffer with a half-amplitude block signal */
+ /* create a 1 sec buffer with an 11025 Hz sine wave */
inbuffer = gst_buffer_new_and_alloc (44100 * sizeof (gint16));
data = (gint16 *) GST_BUFFER_DATA (inbuffer);
- for (j = 0; j < 44100; ++j) {
- *data = 16536;
+
+ for (j = 0; j < 44100; j += 4) {
+ *data = 0;
+ ++data;
+ *data = 32767;
+ ++data;
+ *data = 0;
+ ++data;
+ *data = -32767;
+ ++data;
+ }
+
+ caps = gst_caps_from_string (SPECT_CAPS_STRING_S16);
+ gst_buffer_set_caps (inbuffer, caps);
+ gst_caps_unref (caps);
+ ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
+
+ /* create a bus to get the spectrum message on */
+ bus = gst_bus_new ();
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 1);
+ gst_element_set_bus (spectrum, bus);
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 2);
+
+ /* pushing gives away my reference ... */
+ fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
+ /* ... but it ends up being collected on the global buffer list */
+ ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
+ fail_unless_equals_int (g_list_length (buffers), 1);
+ fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
+ fail_unless (inbuffer == outbuffer);
+
+ message = gst_bus_poll (bus, GST_MESSAGE_ELEMENT, -1);
+ ASSERT_OBJECT_REFCOUNT (message, "message", 1);
+
+ fail_unless (message != NULL);
+ fail_unless (GST_MESSAGE_SRC (message) == GST_OBJECT (spectrum));
+ fail_unless (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT);
+ structure = gst_message_get_structure (message);
+ fail_if (structure == NULL);
+ fail_unless_equals_string ((char *) gst_structure_get_name (structure),
+ "spectrum");
+ fail_unless (gst_structure_get_clock_time (structure, "endtime", &endtime));
+
+ list = gst_structure_get_value (structure, "magnitude");
+ for (i = 0; i < SPECT_BANDS; ++i) {
+ value = gst_value_list_get_value (list, i);
+ level = g_value_get_float (value);
+ GST_DEBUG ("band[%3d] is %.2f", i, level);
+ /* Only the bands in the middle should have a level above 60 */
+ fail_if ((i == SPECT_BANDS / 2 || i == SPECT_BANDS / 2 - 1)
+ && level < 60.0);
+ fail_if ((i != SPECT_BANDS / 2 && i != SPECT_BANDS / 2 - 1)
+ && level > 60.0);
+ }
+ fail_unless_equals_int (g_list_length (buffers), 1);
+ fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
+ fail_unless (inbuffer == outbuffer);
+
+ /* clean up */
+ /* flush current messages,and future state change messages */
+ gst_bus_set_flushing (bus, TRUE);
+
+ /* message has a ref to the element */
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 2);
+ gst_message_unref (message);
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 1);
+
+ gst_element_set_bus (spectrum, NULL);
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 1);
+ gst_object_unref (bus);
+ gst_buffer_unref (outbuffer);
+ fail_unless (gst_element_set_state (spectrum,
+ GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 1);
+ cleanup_spectrum (spectrum);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_int32)
+{
+ GstElement *spectrum;
+ GstBuffer *inbuffer, *outbuffer;
+ GstBus *bus;
+ GstCaps *caps;
+ GstMessage *message;
+ const GstStructure *structure;
+ int i, j;
+ gint32 *data;
+ const GValue *list, *value;
+ GstClockTime endtime;
+ gfloat level;
+
+ spectrum = setup_spectrum ();
+ g_object_set (spectrum, "message", TRUE, "interval", GST_SECOND / 100,
+ "bands", SPECT_BANDS, "threshold", -80, NULL);
+
+ fail_unless (gst_element_set_state (spectrum,
+ GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
+ "could not set to playing");
+
+ /* create a 1 sec buffer with an 11025 Hz sine wave */
+ inbuffer = gst_buffer_new_and_alloc (44100 * sizeof (gint32));
+ data = (gint32 *) GST_BUFFER_DATA (inbuffer);
+ for (j = 0; j < 44100; j += 4) {
+ *data = 0;
+ ++data;
+ *data = 2147483647;
+ ++data;
+ *data = 0;
+ ++data;
+ *data = -2147483647;
+ ++data;
+ }
+ caps = gst_caps_from_string (SPECT_CAPS_STRING_S32);
+ gst_buffer_set_caps (inbuffer, caps);
+ gst_caps_unref (caps);
+ ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
+
+ /* create a bus to get the spectrum message on */
+ bus = gst_bus_new ();
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 1);
+ gst_element_set_bus (spectrum, bus);
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 2);
+
+ /* pushing gives away my reference ... */
+ fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
+ /* ... but it ends up being collected on the global buffer list */
+ ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
+ fail_unless_equals_int (g_list_length (buffers), 1);
+ fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
+ fail_unless (inbuffer == outbuffer);
+
+ message = gst_bus_poll (bus, GST_MESSAGE_ELEMENT, -1);
+ ASSERT_OBJECT_REFCOUNT (message, "message", 1);
+
+ fail_unless (message != NULL);
+ fail_unless (GST_MESSAGE_SRC (message) == GST_OBJECT (spectrum));
+ fail_unless (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT);
+ structure = gst_message_get_structure (message);
+ fail_if (structure == NULL);
+ fail_unless_equals_string ((char *) gst_structure_get_name (structure),
+ "spectrum");
+ fail_unless (gst_structure_get_clock_time (structure, "endtime", &endtime));
+
+ list = gst_structure_get_value (structure, "magnitude");
+ for (i = 0; i < SPECT_BANDS; ++i) {
+ value = gst_value_list_get_value (list, i);
+ level = g_value_get_float (value);
+ GST_DEBUG ("band[%3d] is %.2f", i, level);
+ /* Only the bands in the middle should have a level above 60 */
+ fail_if ((i == SPECT_BANDS / 2 || i == SPECT_BANDS / 2 - 1)
+ && level < 60.0);
+ fail_if ((i != SPECT_BANDS / 2 && i != SPECT_BANDS / 2 - 1)
+ && level > 60.0);
+ }
+ fail_unless_equals_int (g_list_length (buffers), 1);
+ fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
+ fail_unless (inbuffer == outbuffer);
+
+ /* clean up */
+ /* flush current messages,and future state change messages */
+ gst_bus_set_flushing (bus, TRUE);
+
+ /* message has a ref to the element */
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 2);
+ gst_message_unref (message);
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 1);
+
+ gst_element_set_bus (spectrum, NULL);
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 1);
+ gst_object_unref (bus);
+ gst_buffer_unref (outbuffer);
+ fail_unless (gst_element_set_state (spectrum,
+ GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 1);
+ cleanup_spectrum (spectrum);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_float32)
+{
+ GstElement *spectrum;
+ GstBuffer *inbuffer, *outbuffer;
+ GstBus *bus;
+ GstCaps *caps;
+ GstMessage *message;
+ const GstStructure *structure;
+ int i, j;
+ gfloat *data;
+ const GValue *list, *value;
+ GstClockTime endtime;
+ gfloat level;
+
+ spectrum = setup_spectrum ();
+ g_object_set (spectrum, "message", TRUE, "interval", GST_SECOND / 100,
+ "bands", SPECT_BANDS, "threshold", -80, NULL);
+
+ fail_unless (gst_element_set_state (spectrum,
+ GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
+ "could not set to playing");
+
+ /* create a 1 sec buffer with an 11025 Hz sine wave */
+ inbuffer = gst_buffer_new_and_alloc (44100 * sizeof (gfloat));
+ data = (gfloat *) GST_BUFFER_DATA (inbuffer);
+ for (j = 0; j < 44100; j += 4) {
+ *data = 0.0;
+ ++data;
+ *data = 1.0;
+ ++data;
+ *data = 0.0;
+ ++data;
+ *data = -1.0;
+ ++data;
+ }
+ caps = gst_caps_from_string (SPECT_CAPS_STRING_F32);
+ gst_buffer_set_caps (inbuffer, caps);
+ gst_caps_unref (caps);
+ ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
+
+ /* create a bus to get the spectrum message on */
+ bus = gst_bus_new ();
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 1);
+ gst_element_set_bus (spectrum, bus);
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 2);
+
+ /* pushing gives away my reference ... */
+ fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
+ /* ... but it ends up being collected on the global buffer list */
+ ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
+ fail_unless_equals_int (g_list_length (buffers), 1);
+ fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
+ fail_unless (inbuffer == outbuffer);
+
+ message = gst_bus_poll (bus, GST_MESSAGE_ELEMENT, -1);
+ ASSERT_OBJECT_REFCOUNT (message, "message", 1);
+
+ fail_unless (message != NULL);
+ fail_unless (GST_MESSAGE_SRC (message) == GST_OBJECT (spectrum));
+ fail_unless (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT);
+ structure = gst_message_get_structure (message);
+ fail_if (structure == NULL);
+ fail_unless_equals_string ((char *) gst_structure_get_name (structure),
+ "spectrum");
+ fail_unless (gst_structure_get_clock_time (structure, "endtime", &endtime));
+
+ list = gst_structure_get_value (structure, "magnitude");
+ for (i = 0; i < SPECT_BANDS; ++i) {
+ value = gst_value_list_get_value (list, i);
+ level = g_value_get_float (value);
+ GST_DEBUG ("band[%3d] is %.2f", i, level);
+ /* Only the bands in the middle should have a level above 60 */
+ fail_if ((i == SPECT_BANDS / 2 || i == SPECT_BANDS / 2 - 1)
+ && level < 60.0);
+ fail_if ((i != SPECT_BANDS / 2 && i != SPECT_BANDS / 2 - 1)
+ && level > 60.0);
+ }
+ fail_unless_equals_int (g_list_length (buffers), 1);
+ fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
+ fail_unless (inbuffer == outbuffer);
+
+ /* clean up */
+ /* flush current messages,and future state change messages */
+ gst_bus_set_flushing (bus, TRUE);
+
+ /* message has a ref to the element */
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 2);
+ gst_message_unref (message);
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 1);
+
+ gst_element_set_bus (spectrum, NULL);
+ ASSERT_OBJECT_REFCOUNT (bus, "bus", 1);
+ gst_object_unref (bus);
+ gst_buffer_unref (outbuffer);
+ fail_unless (gst_element_set_state (spectrum,
+ GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
+ ASSERT_OBJECT_REFCOUNT (spectrum, "spectrum", 1);
+ cleanup_spectrum (spectrum);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_float64)
+{
+ GstElement *spectrum;
+ GstBuffer *inbuffer, *outbuffer;
+ GstBus *bus;
+ GstCaps *caps;
+ GstMessage *message;
+ const GstStructure *structure;
+ int i, j;
+ gdouble *data;
+ const GValue *list, *value;
+ GstClockTime endtime;
+ gfloat level;
+
+ spectrum = setup_spectrum ();
+ g_object_set (spectrum, "message", TRUE, "interval", GST_SECOND / 100,
+ "bands", SPECT_BANDS, "threshold", -80, NULL);
+
+ fail_unless (gst_element_set_state (spectrum,
+ GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
+ "could not set to playing");
+
+ /* create a 1 sec buffer with an 11025 Hz sine wave */
+ inbuffer = gst_buffer_new_and_alloc (44100 * sizeof (gdouble));
+ data = (gdouble *) GST_BUFFER_DATA (inbuffer);
+ for (j = 0; j < 44100; j += 4) {
+ *data = 0.0;
+ ++data;
+ *data = 1.0;
+ ++data;
+ *data = 0.0;
+ ++data;
+ *data = -1.0;
++data;
}
- caps = gst_caps_from_string (SPECT_CAPS_STRING);
+ caps = gst_caps_from_string (SPECT_CAPS_STRING_F64);
gst_buffer_set_caps (inbuffer, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
"spectrum");
fail_unless (gst_structure_get_clock_time (structure, "endtime", &endtime));
- /* block wave of half amplitude has -5.94 dB for rms, peak and decay */
- list = gst_structure_get_value (structure, "spectrum");
+ list = gst_structure_get_value (structure, "magnitude");
for (i = 0; i < SPECT_BANDS; ++i) {
value = gst_value_list_get_value (list, i);
- level = g_value_get_uchar (value);
- GST_DEBUG ("band[%3d] is %3d", i, level);
- fail_if (level == 0);
+ level = g_value_get_float (value);
+ GST_DEBUG ("band[%3d] is %.2f", i, level);
+ /* Only the bands in the middle should have a level above 60 */
+ fail_if ((i == SPECT_BANDS / 2 || i == SPECT_BANDS / 2 - 1)
+ && level < 60.0);
+ fail_if ((i != SPECT_BANDS / 2 && i != SPECT_BANDS / 2 - 1)
+ && level > 60.0);
}
fail_unless_equals_int (g_list_length (buffers), 1);
fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
suite_add_tcase (s, tc_chain);
tcase_add_test (tc_chain, test_int16);
+ tcase_add_test (tc_chain, test_int32);
+ tcase_add_test (tc_chain, test_float32);
+ tcase_add_test (tc_chain, test_float64);
return s;
}
projects / platform / upstream / gst-plugins-good.git / commitdiff