From 8534b5e71e048c6fef788c6a561881f71972eee0 Mon Sep 17 00:00:00 2001 From: Mathis Hofer Date: Mon, 10 Jul 2006 14:42:15 +0000 Subject: Ported the gstfilter plugin to GStreamer 0.10. Original commit message from CVS: Patch by: Mathis Hofer * configure.ac: * gst/filter/Makefile.am: * gst/filter/gstbpwsinc.c: (gst_bpwsinc_dispose), (gst_bpwsinc_base_init), (gst_bpwsinc_class_init), (gst_bpwsinc_init), (bpwsinc_set_caps), (bpwsinc_transform_ip), (bpwsinc_set_property), (bpwsinc_get_property): * gst/filter/gstfilter.c: (plugin_init): * gst/filter/gstfilter.h: * gst/filter/gstiir.c: (gst_iir_dispose), (gst_iir_base_init), (gst_iir_class_init), (gst_iir_init), (iir_set_caps), (iir_transform_ip), (iir_set_property), (iir_get_property): * gst/filter/gstlpwsinc.c: (gst_lpwsinc_dispose), (gst_lpwsinc_base_init), (gst_lpwsinc_class_init), (gst_lpwsinc_init), (lpwsinc_set_caps), (lpwsinc_transform_ip), (lpwsinc_set_property), (lpwsinc_get_property): Ported the gstfilter plugin to GStreamer 0.10. --- gst/filter/Makefile.am | 12 +- gst/filter/gstbpwsinc.c | 438 ++++++++++++++++++++++-------------------------- gst/filter/gstfilter.c | 24 +-- gst/filter/gstfilter.h | 10 +- gst/filter/gstiir.c | 292 +++++++++++++++----------------- gst/filter/gstlpwsinc.c | 339 +++++++++++++++++-------------------- 6 files changed, 512 insertions(+), 603 deletions(-) (limited to 'gst/filter') diff --git a/gst/filter/Makefile.am b/gst/filter/Makefile.am index f19caa78..31e7a8d6 100644 --- a/gst/filter/Makefile.am +++ b/gst/filter/Makefile.am @@ -1,9 +1,13 @@ plugin_LTLIBRARIES = libgstfilter.la -libgstfilter_la_SOURCES = gstfilter.c gstiir.c iir.c gstlpwsinc.c gstbpwsinc.c -libgstfilter_la_CFLAGS = $(GST_CFLAGS) -libgstfilter_la_LIBADD = +libgstfilter_la_SOURCES = gstfilter.c gstlpwsinc.c gstbpwsinc.c gstiir.c iir.c +libgstfilter_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS) $(GST_CONTROLLER_CFLAGS) +libgstfilter_la_LIBADD = \ + $(GST_BASE_LIBS) \ + $(GST_LIBS) \ + $(GST_CONTROLLER_LIBS) + libgstfilter_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) -noinst_HEADERS = gstfilter.h iir.h +noinst_HEADERS = gstfilter.h gstlpwsinc.h gstbpwsinc.h gstiir.h iir.h diff --git a/gst/filter/gstbpwsinc.c b/gst/filter/gstbpwsinc.c index f94e201b..07175dee 100644 --- a/gst/filter/gstbpwsinc.c +++ b/gst/filter/gstbpwsinc.c @@ -1,6 +1,8 @@ /* -*- c-basic-offset: 2 -*- + * * GStreamer * Copyright (C) 1999-2001 Erik Walthinsen + * 2006 Dreamlab Technologies Ltd. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -16,15 +18,14 @@ * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. - */ - -/* this windowed sinc filter is taken from the freely downloadable DSP book, + * + * + * this windowed sinc filter is taken from the freely downloadable DSP book, * "The Scientist and Engineer's Guide to Digital Signal Processing", * chapter 16 * available at http://www.dspguide.com/ - */ - -/* FIXME: + * + * FIXME: * - this filter is totally unoptimized ! * - we do not destroy the allocated memory for filters and residue * - this might be improved upon with bytestream @@ -33,18 +34,27 @@ #ifdef HAVE_CONFIG_H #include "config.h" #endif + +#include +#include #include -#include "gstfilter.h" -#include /* M_PI */ -#include /* memmove */ +#include +#include -/* elementfactory information */ -static const GstElementDetails gst_bpwsinc_details = -GST_ELEMENT_DETAILS ("BPWSinc", +#include "gstbpwsinc.h" + +#define GST_CAT_DEFAULT gst_bpwsinc_debug +GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); + +static const GstElementDetails bpwsinc_details = +GST_ELEMENT_DETAILS ("Band-pass Windowed sinc filter", "Filter/Effect/Audio", - "Band-Pass Windowed sinc filter", - "Thomas , " "Steven W. Smith"); + "Band-pass Windowed sinc filter", + "Thomas , " + "Steven W. Smith, " + "Dreamlab Technologies Ltd. "); +/* Filter signals and args */ enum { /* FILL ME */ @@ -53,82 +63,54 @@ enum enum { - ARG_0, - ARG_LENGTH, - ARG_LOWER_FREQUENCY, - ARG_UPPER_FREQUENCY -}; - -#define GST_TYPE_BPWSINC \ - (gst_bpwsinc_get_type()) -#define GST_BPWSINC(obj) \ - (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BPWSINC,GstBPWSinc)) -#define GST_BPWSINC_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ULAW,GstBPWSinc)) -#define GST_IS_BPWSINC(obj) \ - (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BPWSINC)) -#define GST_IS_BPWSINC_CLASS(obj) \ - (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_BPWSINC)) - -typedef struct _GstBPWSinc GstBPWSinc; -typedef struct _GstBPWSincClass GstBPWSincClass; - -struct _GstBPWSinc -{ - GstElement element; - - GstPad *sinkpad, *srcpad; - - double frequency; - double lower_frequency, upper_frequency; - int wing_size; /* length of a "wing" of the filter; - actual length is 2 * wing_size + 1 */ - - gfloat *residue; /* buffer for left-over samples from previous buffer */ - double *kernel; -}; - -struct _GstBPWSincClass -{ - GstElementClass parent_class; + PROP_0, + PROP_LENGTH, + PROP_LOWER_FREQUENCY, + PROP_UPPER_FREQUENCY }; -static void gst_bpwsinc_base_init (gpointer g_class); -static void gst_bpwsinc_class_init (GstBPWSincClass * klass); -static void gst_bpwsinc_init (GstBPWSinc * filter); - -static void gst_bpwsinc_set_property (GObject * object, guint prop_id, +static GstStaticPadTemplate bpwsinc_sink_template = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-raw-float, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " "width = (int) 32") + ); + +static GstStaticPadTemplate bpwsinc_src_template = GST_STATIC_PAD_TEMPLATE + ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-raw-float, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " "width = (int) 32") + ); + +#define DEBUG_INIT(bla) \ + GST_DEBUG_CATEGORY_INIT (gst_bpwsinc_debug, "bpwsinc", 0, "Band-pass Windowed sinc filter plugin"); + +GST_BOILERPLATE_FULL (GstBPWSinc, gst_bpwsinc, GstBaseTransform, + GST_TYPE_BASE_TRANSFORM, DEBUG_INIT); + +static void bpwsinc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); -static void gst_bpwsinc_get_property (GObject * object, guint prop_id, +static void bpwsinc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); -static void gst_bpwsinc_chain (GstPad * pad, GstData * _data); -static GstPadLinkReturn -gst_bpwsinc_sink_connect (GstPad * pad, const GstCaps * caps); - -static GstElementClass *parent_class = NULL; +static GstFlowReturn bpwsinc_transform_ip (GstBaseTransform * base, + GstBuffer * outbuf); +static gboolean bpwsinc_set_caps (GstBaseTransform * base, GstCaps * incaps, + GstCaps * outcaps); -/*static guint gst_bpwsinc_signals[LAST_SIGNAL] = { 0 }; */ +/* Element class */ -GType -gst_bpwsinc_get_type (void) +static void +gst_bpwsinc_dispose (GObject * object) { - static GType bpwsinc_type = 0; - - if (!bpwsinc_type) { - static const GTypeInfo bpwsinc_info = { - sizeof (GstBPWSincClass), - gst_bpwsinc_base_init, - NULL, - (GClassInitFunc) gst_bpwsinc_class_init, NULL, NULL, - sizeof (GstBPWSinc), 0, - (GInstanceInitFunc) gst_bpwsinc_init, - }; - - bpwsinc_type = g_type_register_static (GST_TYPE_ELEMENT, "GstBPWSinc", - &bpwsinc_info, 0); - } - return bpwsinc_type; + G_OBJECT_CLASS (parent_class)->dispose (object); } static void @@ -136,195 +118,181 @@ gst_bpwsinc_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); - /* register src pads */ gst_element_class_add_pad_template (element_class, - gst_static_pad_template_get (&gst_filter_src_template)); + gst_static_pad_template_get (&bpwsinc_src_template)); gst_element_class_add_pad_template (element_class, - gst_static_pad_template_get (&gst_filter_sink_template)); - - gst_element_class_set_details (element_class, &gst_bpwsinc_details); + gst_static_pad_template_get (&bpwsinc_sink_template)); + gst_element_class_set_details (element_class, &bpwsinc_details); } static void gst_bpwsinc_class_init (GstBPWSincClass * klass) { GObjectClass *gobject_class; - GstElementClass *gstelement_class; + GstBaseTransformClass *trans_class; gobject_class = (GObjectClass *) klass; - gstelement_class = (GstElementClass *) klass; + trans_class = (GstBaseTransformClass *) klass; - parent_class = g_type_class_peek_parent (klass); + gobject_class->set_property = bpwsinc_set_property; + gobject_class->get_property = bpwsinc_get_property; + gobject_class->dispose = gst_bpwsinc_dispose; - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWER_FREQUENCY, + g_object_class_install_property (gobject_class, PROP_LOWER_FREQUENCY, g_param_spec_double ("lower-frequency", "Lower Frequency", "Cut-off lower frequency (relative to sample rate)", 0.0, 0.5, 0, G_PARAM_READWRITE)); - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_UPPER_FREQUENCY, + g_object_class_install_property (gobject_class, PROP_UPPER_FREQUENCY, g_param_spec_double ("upper-frequency", "Upper Frequency", "Cut-off upper frequency (relative to sample rate)", 0.0, 0.5, 0, G_PARAM_READWRITE)); - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LENGTH, + g_object_class_install_property (gobject_class, PROP_LENGTH, g_param_spec_int ("length", "Length", "N such that the filter length = 2N + 1", 1, G_MAXINT, 1, G_PARAM_READWRITE)); - gobject_class->set_property = gst_bpwsinc_set_property; - gobject_class->get_property = gst_bpwsinc_get_property; + trans_class->transform_ip = GST_DEBUG_FUNCPTR (bpwsinc_transform_ip); + trans_class->set_caps = GST_DEBUG_FUNCPTR (bpwsinc_set_caps); } static void -gst_bpwsinc_init (GstBPWSinc * filter) +gst_bpwsinc_init (GstBPWSinc * this, GstBPWSincClass * g_class) { - filter->sinkpad = - gst_pad_new_from_template (gst_static_pad_template_get - (&gst_filter_sink_template), "sink"); - gst_pad_set_chain_function (filter->sinkpad, gst_bpwsinc_chain); - gst_pad_set_link_function (filter->sinkpad, gst_bpwsinc_sink_connect); - gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); - - filter->srcpad = - gst_pad_new_from_template (gst_static_pad_template_get - (&gst_filter_src_template), "src"); - gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); - - filter->wing_size = 50; - filter->lower_frequency = 0.25; - filter->upper_frequency = 0.3; - filter->kernel = NULL; + this->wing_size = 50; + this->lower_frequency = 0.25; + this->upper_frequency = 0.3; + this->kernel = NULL; } -static GstPadLinkReturn -gst_bpwsinc_sink_connect (GstPad * pad, const GstCaps * caps) + +/* GstBaseTransform vmethod implementations */ + +/* get notified of caps and plug in the correct process function */ +static gboolean +bpwsinc_set_caps (GstBaseTransform * base, GstCaps * incaps, GstCaps * outcaps) { int i = 0; double sum = 0.0; int len = 0; double *kernel_lp, *kernel_hp; - GstPadLinkReturn set_retval; - - GstBPWSinc *filter = GST_BPWSINC (gst_pad_get_parent (pad)); - - g_assert (GST_IS_PAD (pad)); - g_assert (caps != NULL); - - set_retval = gst_pad_try_set_caps (filter->srcpad, caps); - - if (set_retval > 0) { - len = filter->wing_size; - /* fill the lp kernel */ - GST_DEBUG ("bpwsinc: initializing LP kernel of length %d with cut-off %f", - len * 2 + 1, filter->lower_frequency); - kernel_lp = (double *) g_malloc (sizeof (double) * (2 * len + 1)); - for (i = 0; i <= len * 2; ++i) { - if (i == len) - kernel_lp[i] = 2 * M_PI * filter->lower_frequency; - else - kernel_lp[i] = sin (2 * M_PI * filter->lower_frequency * (i - len)) - / (i - len); - /* Blackman windowing */ - kernel_lp[i] *= (0.42 - 0.5 * cos (M_PI * i / len) - + 0.08 * cos (2 * M_PI * i / len)); - } - - /* normalize for unity gain at DC - * FIXME: sure this is not supposed to be quadratic ? */ - sum = 0.0; - for (i = 0; i <= len * 2; ++i) - sum += kernel_lp[i]; - for (i = 0; i <= len * 2; ++i) - kernel_lp[i] /= sum; - - /* fill the hp kernel */ - GST_DEBUG ("bpwsinc: initializing HP kernel of length %d with cut-off %f", - len * 2 + 1, filter->upper_frequency); - kernel_hp = (double *) g_malloc (sizeof (double) * (2 * len + 1)); - for (i = 0; i <= len * 2; ++i) { - if (i == len) - kernel_hp[i] = 2 * M_PI * filter->upper_frequency; - else - kernel_hp[i] = sin (2 * M_PI * filter->upper_frequency * (i - len)) - / (i - len); - /* Blackman windowing */ - kernel_hp[i] *= (0.42 - 0.5 * cos (M_PI * i / len) - + 0.08 * cos (2 * M_PI * i / len)); - } - - /* normalize for unity gain at DC - * FIXME: sure this is not supposed to be quadratic ? */ - sum = 0.0; - for (i = 0; i <= len * 2; ++i) - sum += kernel_hp[i]; - for (i = 0; i <= len * 2; ++i) - kernel_hp[i] /= sum; - - /* do spectral inversion to get a HP filter */ - for (i = 0; i <= len * 2; ++i) - kernel_hp[i] = -kernel_hp[i]; - kernel_hp[len] += 1; - - /* combine the two filters */ - - filter->kernel = (double *) g_malloc (sizeof (double) * (2 * len + 1)); - - for (i = 0; i <= len * 2; ++i) - filter->kernel[i] = kernel_lp[i] + kernel_hp[i]; - - /* do spectral inversion to go from band reject to bandpass */ - for (i = 0; i <= len * 2; ++i) - filter->kernel[i] = -filter->kernel[i]; - filter->kernel[len] += 1; - - /* free the helper kernels */ - g_free (kernel_lp); - g_free (kernel_hp); - - /* set up the residue memory space */ - filter->residue = (gfloat *) g_malloc (sizeof (gfloat) * (len * 2 + 1)); - for (i = 0; i <= len * 2; ++i) - filter->residue[i] = 0.0; + GstBPWSinc *this = GST_BPWSINC (base); + + GST_DEBUG_OBJECT (this, + "set_caps: in %" GST_PTR_FORMAT " out %" GST_PTR_FORMAT, incaps, outcaps); + + len = this->wing_size; + /* fill the lp kernel */ + GST_DEBUG ("bpwsinc: initializing LP kernel of length %d with cut-off %f", + len * 2 + 1, this->lower_frequency); + kernel_lp = (double *) g_malloc (sizeof (double) * (2 * len + 1)); + for (i = 0; i <= len * 2; ++i) { + if (i == len) + kernel_lp[i] = 2 * M_PI * this->lower_frequency; + else + kernel_lp[i] = sin (2 * M_PI * this->lower_frequency * (i - len)) + / (i - len); + /* Blackman windowing */ + kernel_lp[i] *= (0.42 - 0.5 * cos (M_PI * i / len) + + 0.08 * cos (2 * M_PI * i / len)); + } + + /* normalize for unity gain at DC + * FIXME: sure this is not supposed to be quadratic ? */ + sum = 0.0; + for (i = 0; i <= len * 2; ++i) + sum += kernel_lp[i]; + for (i = 0; i <= len * 2; ++i) + kernel_lp[i] /= sum; + + /* fill the hp kernel */ + GST_DEBUG ("bpwsinc: initializing HP kernel of length %d with cut-off %f", + len * 2 + 1, this->upper_frequency); + kernel_hp = (double *) g_malloc (sizeof (double) * (2 * len + 1)); + for (i = 0; i <= len * 2; ++i) { + if (i == len) + kernel_hp[i] = 2 * M_PI * this->upper_frequency; + else + kernel_hp[i] = sin (2 * M_PI * this->upper_frequency * (i - len)) + / (i - len); + /* Blackman windowing */ + kernel_hp[i] *= (0.42 - 0.5 * cos (M_PI * i / len) + + 0.08 * cos (2 * M_PI * i / len)); } - return set_retval; + /* normalize for unity gain at DC + * FIXME: sure this is not supposed to be quadratic ? */ + sum = 0.0; + for (i = 0; i <= len * 2; ++i) + sum += kernel_hp[i]; + for (i = 0; i <= len * 2; ++i) + kernel_hp[i] /= sum; + + /* combine the two thiss */ + this->kernel = (double *) g_malloc (sizeof (double) * (2 * len + 1)); + + for (i = 0; i <= len * 2; ++i) + this->kernel[i] = kernel_lp[i] + kernel_hp[i]; + + /* do spectral inversion to go from band reject to bandpass */ + for (i = 0; i <= len * 2; ++i) + this->kernel[i] = -this->kernel[i]; + this->kernel[len] += 1; + + /* free the helper kernels */ + g_free (kernel_lp); + g_free (kernel_hp); + + /* set up the residue memory space */ + this->residue = (gfloat *) g_malloc (sizeof (gfloat) * (len * 2 + 1)); + for (i = 0; i <= len * 2; ++i) + this->residue[i] = 0.0; + + return TRUE; } -static void -gst_bpwsinc_chain (GstPad * pad, GstData * _data) +static GstFlowReturn +bpwsinc_transform_ip (GstBaseTransform * base, GstBuffer * outbuf) { - GstBuffer *buf = GST_BUFFER (_data); - GstBPWSinc *filter; + GstBPWSinc *this = GST_BPWSINC (base); + GstClockTime timestamp; + + /* don't process data in passthrough-mode */ + if (gst_base_transform_is_passthrough (base)) + return GST_FLOW_OK; + + /* FIXME: subdivide GST_BUFFER_SIZE into small chunks for smooth fades */ + timestamp = GST_BUFFER_TIMESTAMP (outbuf); + + if (GST_CLOCK_TIME_IS_VALID (timestamp)) + gst_object_sync_values (G_OBJECT (this), timestamp); + gfloat *src; gfloat *input; - gint residue_samples; + int residue_samples; gint input_samples; gint total_samples; int i, j; - filter = GST_BPWSINC (gst_pad_get_parent (pad)); - /* FIXME: out of laziness, we copy the left-over bit from last buffer * together with the incoming buffer to a new buffer to make the loop * easy; this could be a lot more optimized though * to make amends we keep the incoming buffer around and write our * output samples there */ - /* get a writable buffer */ - buf = gst_buffer_copy_on_write (buf); - - src = (gfloat *) GST_BUFFER_DATA (buf); - residue_samples = filter->wing_size * 2 + 1; - input_samples = GST_BUFFER_SIZE (buf) / sizeof (gfloat); + src = (gfloat *) GST_BUFFER_DATA (outbuf); + residue_samples = this->wing_size * 2 + 1; + input_samples = GST_BUFFER_SIZE (outbuf) / sizeof (gfloat); total_samples = residue_samples + input_samples; input = (gfloat *) g_malloc (sizeof (gfloat) * total_samples); /* copy the left-over bit */ - memcpy (input, filter->residue, sizeof (gfloat) * residue_samples); + memcpy (input, this->residue, sizeof (gfloat) * residue_samples); /* copy the new buffer */ memcpy (&input[residue_samples], src, sizeof (gfloat) * input_samples); /* copy the tail of the current input buffer to the residue */ - memcpy (filter->residue, &src[input_samples - residue_samples], + memcpy (this->residue, &src[input_samples - residue_samples], sizeof (gfloat) * residue_samples); /* convolution */ @@ -333,57 +301,53 @@ gst_bpwsinc_chain (GstPad * pad, GstData * _data) for (i = 0; i < input_samples; ++i) { src[i] = 0.0; for (j = 0; j < residue_samples; ++j) - src[i] += input[i - j + residue_samples] * filter->kernel[j]; + src[i] += input[i - j + residue_samples] * this->kernel[j]; } g_free (input); - gst_pad_push (filter->srcpad, GST_DATA (buf)); + + return GST_FLOW_OK; } static void -gst_bpwsinc_set_property (GObject * object, guint prop_id, const GValue * value, +bpwsinc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { - GstBPWSinc *filter; - - g_return_if_fail (GST_IS_BPWSINC (object)); + GstBPWSinc *this = GST_BPWSINC (object); - filter = GST_BPWSINC (object); + g_return_if_fail (GST_IS_BPWSINC (this)); switch (prop_id) { - case ARG_LENGTH: - filter->wing_size = g_value_get_int (value); + case PROP_LENGTH: + this->wing_size = g_value_get_int (value); break; - case ARG_LOWER_FREQUENCY: - filter->lower_frequency = g_value_get_double (value); + case PROP_LOWER_FREQUENCY: + this->lower_frequency = g_value_get_double (value); break; - case ARG_UPPER_FREQUENCY: - filter->upper_frequency = g_value_get_double (value); + case PROP_UPPER_FREQUENCY: + this->upper_frequency = g_value_get_double (value); break; default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void -gst_bpwsinc_get_property (GObject * object, guint prop_id, GValue * value, +bpwsinc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { - GstBPWSinc *filter; - - g_return_if_fail (GST_IS_BPWSINC (object)); - - filter = GST_BPWSINC (object); + GstBPWSinc *this = GST_BPWSINC (object); switch (prop_id) { - case ARG_LENGTH: - g_value_set_int (value, filter->wing_size); + case PROP_LENGTH: + g_value_set_int (value, this->wing_size); break; - case ARG_LOWER_FREQUENCY: - g_value_set_double (value, filter->lower_frequency); + case PROP_LOWER_FREQUENCY: + g_value_set_double (value, this->lower_frequency); break; - case ARG_UPPER_FREQUENCY: - g_value_set_double (value, filter->upper_frequency); + case PROP_UPPER_FREQUENCY: + g_value_set_double (value, this->upper_frequency); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); diff --git a/gst/filter/gstfilter.c b/gst/filter/gstfilter.c index e915de75..572d6475 100644 --- a/gst/filter/gstfilter.c +++ b/gst/filter/gstfilter.c @@ -1,6 +1,9 @@ -/* GStreamer +/* -*- c-basic-offset: 2 -*- + * + * GStreamer * Copyright (C) 1999,2000 Erik Walthinsen - * 2000 Wim Taymans + * 2000 Wim Taymans + * 2006 Dreamlab Technologies Ltd. * * gstfilter.c: element for filter plug-ins * @@ -25,7 +28,7 @@ #endif #include "gstfilter.h" #include - +#include struct _elements_entry { @@ -40,21 +43,12 @@ static struct _elements_entry _elements[] = { {NULL, 0}, }; -GstStaticPadTemplate gst_filter_src_template = GST_STATIC_PAD_TEMPLATE ("src", - GST_PAD_SRC, - GST_PAD_ALWAYS, - GST_STATIC_CAPS (GST_AUDIO_FLOAT_STANDARD_PAD_TEMPLATE_CAPS) - ); - -GstStaticPadTemplate gst_filter_sink_template = GST_STATIC_PAD_TEMPLATE ("sink", - GST_PAD_SINK, - GST_PAD_ALWAYS, - GST_STATIC_CAPS (GST_AUDIO_FLOAT_STANDARD_PAD_TEMPLATE_CAPS) - ); - static gboolean plugin_init (GstPlugin * plugin) { + /* initialize gst controller library */ + gst_controller_init (NULL, NULL); + gint i = 0; while (_elements[i].name) { diff --git a/gst/filter/gstfilter.h b/gst/filter/gstfilter.h index 1ad53a81..d8e43cb0 100644 --- a/gst/filter/gstfilter.h +++ b/gst/filter/gstfilter.h @@ -1,6 +1,9 @@ -/* GStreamer +/* -*- c-basic-offset: 2 -*- + * + * GStreamer * Copyright (C) 1999,2000 Erik Walthinsen - * 2000 Wim Taymans + * 2000 Wim Taymans + * 2006 Dreamlab Technologies Ltd. * * gstfilter.h: element for filter plug-ins * @@ -29,7 +32,4 @@ GType gst_iir_get_type (void); GType gst_lpwsinc_get_type (void); GType gst_bpwsinc_get_type (void); -extern GstStaticPadTemplate gst_filter_sink_template; -extern GstStaticPadTemplate gst_filter_src_template; - #endif /* __GST_FILTER_H__ */ diff --git a/gst/filter/gstiir.c b/gst/filter/gstiir.c index bdebf4ba..45d217db 100644 --- a/gst/filter/gstiir.c +++ b/gst/filter/gstiir.c @@ -1,6 +1,8 @@ /* -*- c-basic-offset: 2 -*- + * * GStreamer * Copyright (C) 1999-2001 Erik Walthinsen + * 2006 Dreamlab Technologies Ltd. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -21,16 +23,27 @@ #ifdef HAVE_CONFIG_H #include "config.h" #endif + +#include +#include #include -#include "gstfilter.h" -#include "iir.h" +#include +#include + +#include "gstiir.h" -static const GstElementDetails gst_iir_details = -GST_ELEMENT_DETAILS ("Infinite Impulse Response(IIR) filter", +#define GST_CAT_DEFAULT gst_iir_debug +GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); + +static const GstElementDetails iir_details = +GST_ELEMENT_DETAILS ("Infinite Impulse Response (IIR) filter", "Filter/Effect/Audio", "IIR filter based on vorbis code", - "Monty , " "Thomas "); + "Monty , " + "Thomas , " + "Dreamlab Technologies Ltd. "); +/* Filter signals and args */ enum { /* FILL ME */ @@ -39,80 +52,53 @@ enum enum { - ARG_0, - ARG_A, - ARG_B, - ARG_GAIN, - ARG_STAGES -}; - -#define GST_TYPE_IIR \ - (gst_iir_get_type()) -#define GST_IIR(obj) \ - (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_IIR,GstIIR)) -#define GST_IIR_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ULAW,GstIIR)) -#define GST_IS_IIR(obj) \ - (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_IIR)) -#define GST_IS_IIR_CLASS(obj) \ - (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_IIR)) - -typedef struct _GstIIR GstIIR; -typedef struct _GstIIRClass GstIIRClass; - -struct _GstIIR -{ - GstElement element; - - GstPad *sinkpad, *srcpad; - - double A, B; - double gain; - int stages; - IIR_state *state; -}; - -struct _GstIIRClass -{ - GstElementClass parent_class; + PROP_0, + PROP_A, + PROP_B, + PROP_GAIN, + PROP_STAGES }; -static void gst_iir_base_init (gpointer g_class); -static void gst_iir_class_init (GstIIRClass * klass); -static void gst_iir_init (GstIIR * filter); - -static void gst_iir_set_property (GObject * object, guint prop_id, +static GstStaticPadTemplate iir_sink_template = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-raw-float, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " "width = (int) 32") + ); + +static GstStaticPadTemplate iir_src_template = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-raw-float, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " "width = (int) 32") + ); + +#define DEBUG_INIT(bla) \ + GST_DEBUG_CATEGORY_INIT (gst_iir_debug, "iir", 0, "Infinite Impulse Response (IIR) filter plugin"); + +GST_BOILERPLATE_FULL (GstIIR, gst_iir, GstBaseTransform, + GST_TYPE_BASE_TRANSFORM, DEBUG_INIT); + +static void iir_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); -static void gst_iir_get_property (GObject * object, guint prop_id, +static void iir_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); -static void gst_iir_chain (GstPad * pad, GstData * _data); -static GstPadLinkReturn -gst_iir_sink_connect (GstPad * pad, const GstCaps * caps); +static GstFlowReturn iir_transform_ip (GstBaseTransform * base, + GstBuffer * outbuf); +static gboolean iir_set_caps (GstBaseTransform * base, GstCaps * incaps, + GstCaps * outcaps); -static GstElementClass *parent_class = NULL; +/* Element class */ -/*static guint gst_iir_signals[LAST_SIGNAL] = { 0 }; */ - -GType -gst_iir_get_type (void) +static void +gst_iir_dispose (GObject * object) { - static GType iir_type = 0; - - if (!iir_type) { - static const GTypeInfo iir_info = { - sizeof (GstIIRClass), - gst_iir_base_init, - NULL, - (GClassInitFunc) gst_iir_class_init, NULL, NULL, - sizeof (GstIIR), 0, - (GInstanceInitFunc) gst_iir_init, - }; - - iir_type = g_type_register_static (GST_TYPE_ELEMENT, "GstIIR", - &iir_info, 0); - } - return iir_type; + G_OBJECT_CLASS (parent_class)->dispose (object); } static void @@ -120,157 +106,145 @@ gst_iir_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); - /* register src pads */ gst_element_class_add_pad_template (element_class, - gst_static_pad_template_get (&gst_filter_src_template)); + gst_static_pad_template_get (&iir_src_template)); gst_element_class_add_pad_template (element_class, - gst_static_pad_template_get (&gst_filter_sink_template)); - - gst_element_class_set_details (element_class, &gst_iir_details); + gst_static_pad_template_get (&iir_sink_template)); + gst_element_class_set_details (element_class, &iir_details); } static void gst_iir_class_init (GstIIRClass * klass) { GObjectClass *gobject_class; - GstElementClass *gstelement_class; + GstBaseTransformClass *trans_class; gobject_class = (GObjectClass *) klass; - gstelement_class = (GstElementClass *) klass; + trans_class = (GstBaseTransformClass *) klass; - parent_class = g_type_class_peek_parent (klass); + gobject_class->set_property = iir_set_property; + gobject_class->get_property = iir_get_property; + gobject_class->dispose = gst_iir_dispose; - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_A, + g_object_class_install_property (gobject_class, PROP_A, g_param_spec_double ("A", "A", "A filter coefficient", -G_MAXDOUBLE, G_MAXDOUBLE, 0, G_PARAM_READWRITE)); - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_B, + g_object_class_install_property (gobject_class, PROP_B, g_param_spec_double ("B", "B", "B filter coefficient", -G_MAXDOUBLE, G_MAXDOUBLE, 0, G_PARAM_READWRITE)); - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_GAIN, + g_object_class_install_property (gobject_class, PROP_GAIN, g_param_spec_double ("gain", "Gain", "Filter gain", -G_MAXDOUBLE, G_MAXDOUBLE, 0, G_PARAM_READWRITE)); - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STAGES, + g_object_class_install_property (gobject_class, PROP_STAGES, g_param_spec_int ("stages", "Stages", "Number of filter stages", 1, G_MAXINT, 1, G_PARAM_READWRITE)); - gobject_class->set_property = gst_iir_set_property; - gobject_class->get_property = gst_iir_get_property; + trans_class->transform_ip = GST_DEBUG_FUNCPTR (iir_transform_ip); + trans_class->set_caps = GST_DEBUG_FUNCPTR (iir_set_caps); } static void -gst_iir_init (GstIIR * filter) +gst_iir_init (GstIIR * this, GstIIRClass * g_class) { - filter->sinkpad = - gst_pad_new_from_template (gst_static_pad_template_get - (&gst_filter_sink_template), "sink"); - gst_pad_set_chain_function (filter->sinkpad, gst_iir_chain); - gst_pad_set_link_function (filter->sinkpad, gst_iir_sink_connect); - gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); - - filter->srcpad = - gst_pad_new_from_template (gst_static_pad_template_get - (&gst_filter_src_template), "src"); - gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); - - filter->A = 0.0; - filter->B = 0.0; - filter->gain = 1.0; /* unity gain as default */ - filter->stages = 1; - filter->state = NULL; + this->A = 0.0; + this->B = 0.0; + this->gain = 1.0; /* unity gain as default */ + this->stages = 1; + this->state = NULL; } -static GstPadLinkReturn -gst_iir_sink_connect (GstPad * pad, const GstCaps * caps) + +/* GstBaseTransform vmethod implementations */ + +/* get notified of caps and plug in the correct process function */ +static gboolean +iir_set_caps (GstBaseTransform * base, GstCaps * incaps, GstCaps * outcaps) { - GstIIR *filter; - GstPadLinkReturn set_retval; - - filter = GST_IIR (gst_pad_get_parent (pad)); - - set_retval = gst_pad_try_set_caps (filter->srcpad, caps); - if (set_retval > 0) { - /* connection works, so init the filter */ - /* FIXME: remember to free it */ - filter->state = (IIR_state *) g_malloc (sizeof (IIR_state)); - IIR_init (filter->state, filter->stages, - filter->gain, &(filter->A), &(filter->B)); - } + GstIIR *this = GST_IIR (base); + + GST_DEBUG_OBJECT (this, + "set_caps: in %" GST_PTR_FORMAT " out %" GST_PTR_FORMAT, incaps, outcaps); - return set_retval; + /* FIXME: remember to free it */ + this->state = (IIR_state *) g_malloc (sizeof (IIR_state)); + IIR_init (this->state, this->stages, this->gain, &(this->A), &(this->B)); + + return TRUE; } -static void -gst_iir_chain (GstPad * pad, GstData * _data) +static GstFlowReturn +iir_transform_ip (GstBaseTransform * base, GstBuffer * outbuf) { - GstBuffer *buf = GST_BUFFER (_data); - GstIIR *filter; - gfloat *src; - int i; + GstIIR *this = GST_IIR (base); + GstClockTime timestamp; - filter = GST_IIR (gst_pad_get_parent (pad)); + /* don't process data in passthrough-mode */ + if (gst_base_transform_is_passthrough (base)) + return GST_FLOW_OK; - src = (gfloat *) GST_BUFFER_DATA (buf); + /* FIXME: subdivide GST_BUFFER_SIZE into small chunks for smooth fades */ + timestamp = GST_BUFFER_TIMESTAMP (outbuf); - /* get a writable buffer */ - buf = gst_buffer_copy_on_write (buf); + if (GST_CLOCK_TIME_IS_VALID (timestamp)) + gst_object_sync_values (G_OBJECT (this), timestamp); + + gfloat *src; + int i; + + src = (gfloat *) GST_BUFFER_DATA (outbuf); /* do an in-place edit */ - for (i = 0; i < GST_BUFFER_SIZE (buf) / sizeof (gfloat); ++i) - *(src + i) = (gfloat) IIR_filter (filter->state, (double) *(src + i)); + for (i = 0; i < GST_BUFFER_SIZE (outbuf) / sizeof (gfloat); ++i) + *(src + i) = (gfloat) IIR_filter (this->state, (double) *(src + i)); - gst_pad_push (filter->srcpad, GST_DATA (buf)); + return GST_FLOW_OK; } static void -gst_iir_set_property (GObject * object, guint prop_id, const GValue * value, +iir_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { - GstIIR *filter; + GstIIR *this = GST_IIR (object); - g_return_if_fail (GST_IS_IIR (object)); - - filter = GST_IIR (object); + g_return_if_fail (GST_IS_IIR (this)); switch (prop_id) { - case ARG_A: - filter->A = g_value_get_double (value); + case PROP_A: + this->A = g_value_get_double (value); break; - case ARG_B: - filter->B = g_value_get_double (value); + case PROP_B: + this->B = g_value_get_double (value); break; - case ARG_GAIN: - filter->gain = g_value_get_double (value); + case PROP_GAIN: + this->gain = g_value_get_double (value); break; - case ARG_STAGES: - filter->stages = g_value_get_int (value); + case PROP_STAGES: + this->stages = g_value_get_int (value); break; default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void -gst_iir_get_property (GObject * object, guint prop_id, GValue * value, +iir_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { - GstIIR *filter; - - g_return_if_fail (GST_IS_IIR (object)); - - filter = GST_IIR (object); + GstIIR *this = GST_IIR (object); switch (prop_id) { - case ARG_A: - g_value_set_double (value, filter->A); + case PROP_A: + g_value_set_double (value, this->A); break; - case ARG_B: - g_value_set_double (value, filter->B); + case PROP_B: + g_value_set_double (value, this->B); break; - case ARG_GAIN: - g_value_set_double (value, filter->gain); + case PROP_GAIN: + g_value_set_double (value, this->gain); break; - case ARG_STAGES: - g_value_set_int (value, filter->stages); + case PROP_STAGES: + g_value_set_int (value, this->stages); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); diff --git a/gst/filter/gstlpwsinc.c b/gst/filter/gstlpwsinc.c index d7b1a5ec..4a7b2679 100644 --- a/gst/filter/gstlpwsinc.c +++ b/gst/filter/gstlpwsinc.c @@ -1,6 +1,8 @@ /* -*- c-basic-offset: 2 -*- + * * GStreamer * Copyright (C) 1999-2001 Erik Walthinsen + * 2006 Dreamlab Technologies Ltd. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -16,15 +18,14 @@ * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. - */ - -/* this windowed sinc filter is taken from the freely downloadable DSP book, + * + * + * this windowed sinc filter is taken from the freely downloadable DSP book, * "The Scientist and Engineer's Guide to Digital Signal Processing", * chapter 16 * available at http://www.dspguide.com/ - */ - -/* FIXME: + * + * FIXME: * - this filter is totally unoptimized ! * - we do not destroy the allocated memory for filters and residue * - this might be improved upon with bytestream @@ -33,17 +34,27 @@ #ifdef HAVE_CONFIG_H #include "config.h" #endif + +#include +#include #include -#include "gstfilter.h" -#include /* M_PI */ -#include /* memmove */ +#include +#include + +#include "gstlpwsinc.h" + +#define GST_CAT_DEFAULT gst_lpwsinc_debug +GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); -static const GstElementDetails gst_lpwsinc_details = +static const GstElementDetails lpwsinc_details = GST_ELEMENT_DETAILS ("Low-pass Windowed sinc filter", "Filter/Effect/Audio", "Low-pass Windowed sinc filter", - "Thomas , " "Steven W. Smith"); + "Thomas , " + "Steven W. Smith, " + "Dreamlab Technologies Ltd. "); +/* Filter signals and args */ enum { /* FILL ME */ @@ -52,80 +63,53 @@ enum enum { - ARG_0, - ARG_LENGTH, - ARG_FREQUENCY -}; - -#define GST_TYPE_LPWSINC \ - (gst_lpwsinc_get_type()) -#define GST_LPWSINC(obj) \ - (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_LPWSINC,GstLPWSinc)) -#define GST_LPWSINC_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ULAW,GstLPWSinc)) -#define GST_IS_LPWSINC(obj) \ - (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_LPWSINC)) -#define GST_IS_LPWSINC_CLASS(obj) \ - (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_LPWSINC)) - -typedef struct _GstLPWSinc GstLPWSinc; -typedef struct _GstLPWSincClass GstLPWSincClass; - -struct _GstLPWSinc -{ - GstElement element; - - GstPad *sinkpad, *srcpad; - - double frequency; - int wing_size; /* length of a "wing" of the filter; - actual length is 2 * wing_size + 1 */ - - gfloat *residue; /* buffer for left-over samples from previous buffer */ - double *kernel; -}; - -struct _GstLPWSincClass -{ - GstElementClass parent_class; + PROP_0, + PROP_LENGTH, + PROP_FREQUENCY }; -static void gst_lpwsinc_base_init (gpointer g_class); -static void gst_lpwsinc_class_init (GstLPWSincClass * klass); -static void gst_lpwsinc_init (GstLPWSinc * filter); - -static void gst_lpwsinc_set_property (GObject * object, guint prop_id, +static GstStaticPadTemplate lpwsinc_sink_template = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-raw-float, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " "width = (int) 32") + ); + +static GstStaticPadTemplate lpwsinc_src_template = GST_STATIC_PAD_TEMPLATE + ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-raw-float, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " "width = (int) 32") + ); + +#define DEBUG_INIT(bla) \ + GST_DEBUG_CATEGORY_INIT (gst_lpwsinc_debug, "lpwsinc", 0, "Low-pass Windowed sinc filter plugin"); + +GST_BOILERPLATE_FULL (GstLPWSinc, gst_lpwsinc, GstBaseTransform, + GST_TYPE_BASE_TRANSFORM, DEBUG_INIT); + +static void lpwsinc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); -static void gst_lpwsinc_get_property (GObject * object, guint prop_id, +static void lpwsinc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); -static void gst_lpwsinc_chain (GstPad * pad, GstData * _data); -static GstPadLinkReturn -gst_lpwsinc_sink_connect (GstPad * pad, const GstCaps * caps); +static GstFlowReturn lpwsinc_transform_ip (GstBaseTransform * base, + GstBuffer * outbuf); +static gboolean lpwsinc_set_caps (GstBaseTransform * base, GstCaps * incaps, + GstCaps * outcaps); -static GstElementClass *parent_class = NULL; +/* Element class */ -/*static guint gst_lpwsinc_signals[LAST_SIGNAL] = { 0 }; */ - -GType -gst_lpwsinc_get_type (void) +static void +gst_lpwsinc_dispose (GObject * object) { - static GType lpwsinc_type = 0; - - if (!lpwsinc_type) { - static const GTypeInfo lpwsinc_info = { - sizeof (GstLPWSincClass), - gst_lpwsinc_base_init, - NULL, - (GClassInitFunc) gst_lpwsinc_class_init, NULL, NULL, - sizeof (GstLPWSinc), 0, - (GInstanceInitFunc) gst_lpwsinc_init, - }; - - lpwsinc_type = g_type_register_static (GST_TYPE_ELEMENT, "GstLPWSinc", - &lpwsinc_info, 0); - } - return lpwsinc_type; + G_OBJECT_CLASS (parent_class)->dispose (object); } static void @@ -133,145 +117,138 @@ gst_lpwsinc_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); - /* register src pads */ gst_element_class_add_pad_template (element_class, - gst_static_pad_template_get (&gst_filter_src_template)); + gst_static_pad_template_get (&lpwsinc_src_template)); gst_element_class_add_pad_template (element_class, - gst_static_pad_template_get (&gst_filter_sink_template)); - - gst_element_class_set_details (element_class, &gst_lpwsinc_details); + gst_static_pad_template_get (&lpwsinc_sink_template)); + gst_element_class_set_details (element_class, &lpwsinc_details); } static void gst_lpwsinc_class_init (GstLPWSincClass * klass) { GObjectClass *gobject_class; - GstElementClass *gstelement_class; + GstBaseTransformClass *trans_class; gobject_class = (GObjectClass *) klass; - gstelement_class = (GstElementClass *) klass; + trans_class = (GstBaseTransformClass *) klass; - parent_class = g_type_class_peek_parent (klass); + gobject_class->set_property = lpwsinc_set_property; + gobject_class->get_property = lpwsinc_get_property; + gobject_class->dispose = gst_lpwsinc_dispose; - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FREQUENCY, + g_object_class_install_property (gobject_class, PROP_FREQUENCY, g_param_spec_double ("frequency", "Frequency", - "Cut-off Frequency relative to sample rate)", + "Cut-off Frequency relative to sample rate", 0.0, 0.5, 0, G_PARAM_READWRITE)); - g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LENGTH, + + g_object_class_install_property (gobject_class, PROP_LENGTH, g_param_spec_int ("length", "Length", "N such that the filter length = 2N + 1", 1, G_MAXINT, 1, G_PARAM_READWRITE)); - gobject_class->set_property = gst_lpwsinc_set_property; - gobject_class->get_property = gst_lpwsinc_get_property; + trans_class->transform_ip = GST_DEBUG_FUNCPTR (lpwsinc_transform_ip); + trans_class->set_caps = GST_DEBUG_FUNCPTR (lpwsinc_set_caps); } static void -gst_lpwsinc_init (GstLPWSinc * filter) +gst_lpwsinc_init (GstLPWSinc * this, GstLPWSincClass * g_class) { - filter->sinkpad = - gst_pad_new_from_template (gst_static_pad_template_get - (&gst_filter_sink_template), "sink"); - gst_pad_set_chain_function (filter->sinkpad, gst_lpwsinc_chain); - gst_pad_set_link_function (filter->sinkpad, gst_lpwsinc_sink_connect); - gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); - - filter->srcpad = - gst_pad_new_from_template (gst_static_pad_template_get - (&gst_filter_src_template), "src"); - gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); - - filter->wing_size = 50; - filter->frequency = 0.25; - filter->kernel = NULL; + this->wing_size = 50; + this->frequency = 0.25; + this->kernel = NULL; } -static GstPadLinkReturn -gst_lpwsinc_sink_connect (GstPad * pad, const GstCaps * caps) + +/* GstBaseTransform vmethod implementations */ + +/* get notified of caps and plug in the correct process function */ +static gboolean +lpwsinc_set_caps (GstBaseTransform * base, GstCaps * incaps, GstCaps * outcaps) { int i = 0; double sum = 0.0; int len = 0; - GstLPWSinc *filter = GST_LPWSINC (gst_pad_get_parent (pad)); - GstPadLinkReturn set_retval; - - g_assert (GST_IS_PAD (pad)); - g_assert (caps != NULL); - - set_retval = gst_pad_try_set_caps (filter->srcpad, caps); - - if (set_retval > 0) { - /* connection works, so init the filter */ - /* FIXME: remember to free it */ - /* fill the kernel */ - g_print ("DEBUG: initing filter kernel\n"); - len = filter->wing_size; - GST_DEBUG ("lpwsinc: initializing filter kernel of length %d", len * 2 + 1); - filter->kernel = (double *) g_malloc (sizeof (double) * (2 * len + 1)); - - for (i = 0; i <= len * 2; ++i) { - if (i == len) - filter->kernel[i] = 2 * M_PI * filter->frequency; - else - filter->kernel[i] = sin (2 * M_PI * filter->frequency * (i - len)) - / (i - len); - /* windowing */ - filter->kernel[i] *= (0.54 - 0.46 * cos (M_PI * i / len)); - } - - /* normalize for unity gain at DC - * FIXME: sure this is not supposed to be quadratic ? */ - for (i = 0; i <= len * 2; ++i) - sum += filter->kernel[i]; - for (i = 0; i <= len * 2; ++i) - filter->kernel[i] /= sum; - - /* set up the residue memory space */ - filter->residue = (gfloat *) g_malloc (sizeof (gfloat) * (len * 2 + 1)); - for (i = 0; i <= len * 2; ++i) - filter->residue[i] = 0.0; + GstLPWSinc *this = GST_LPWSINC (base); + + GST_DEBUG_OBJECT (this, + "set_caps: in %" GST_PTR_FORMAT " out %" GST_PTR_FORMAT, incaps, outcaps); + + /* FIXME: remember to free it */ + /* fill the kernel */ + g_print ("DEBUG: initing filter kernel\n"); + len = this->wing_size; + GST_DEBUG ("lpwsinc: initializing filter kernel of length %d", len * 2 + 1); + this->kernel = (double *) g_malloc (sizeof (double) * (2 * len + 1)); + + for (i = 0; i <= len * 2; ++i) { + if (i == len) + this->kernel[i] = 2 * M_PI * this->frequency; + else + this->kernel[i] = + sin (2 * M_PI * this->frequency * (i - len)) / (i - len); + /* windowing */ + this->kernel[i] *= (0.54 - 0.46 * cos (M_PI * i / len)); } - return set_retval; + /* normalize for unity gain at DC + * FIXME: sure this is not supposed to be quadratic ? */ + for (i = 0; i <= len * 2; ++i) + sum += this->kernel[i]; + for (i = 0; i <= len * 2; ++i) + this->kernel[i] /= sum; + + /* set up the residue memory space */ + this->residue = (gfloat *) g_malloc (sizeof (gfloat) * (len * 2 + 1)); + for (i = 0; i <= len * 2; ++i) + this->residue[i] = 0.0; + + return TRUE; } -static void -gst_lpwsinc_chain (GstPad * pad, GstData * _data) +static GstFlowReturn +lpwsinc_transform_ip (GstBaseTransform * base, GstBuffer * outbuf) { - GstBuffer *buf = GST_BUFFER (_data); - GstLPWSinc *filter; + GstLPWSinc *this = GST_LPWSINC (base); + GstClockTime timestamp; + + /* don't process data in passthrough-mode */ + if (gst_base_transform_is_passthrough (base)) + return GST_FLOW_OK; + + /* FIXME: subdivide GST_BUFFER_SIZE into small chunks for smooth fades */ + timestamp = GST_BUFFER_TIMESTAMP (outbuf); + + if (GST_CLOCK_TIME_IS_VALID (timestamp)) + gst_object_sync_values (G_OBJECT (this), timestamp); + gfloat *src; gfloat *input; - gint residue_samples; + int residue_samples; gint input_samples; gint total_samples; int i, j; - filter = GST_LPWSINC (gst_pad_get_parent (pad)); - /* FIXME: out of laziness, we copy the left-over bit from last buffer * together with the incoming buffer to a new buffer to make the loop * easy; this could be a lot more optimized though * to make amends we keep the incoming buffer around and write our * output samples there */ - /* get a writable buffer */ - buf = gst_buffer_copy_on_write (buf); - - src = (gfloat *) GST_BUFFER_DATA (buf); - residue_samples = filter->wing_size * 2 + 1; - input_samples = GST_BUFFER_SIZE (buf) / sizeof (gfloat); + src = (gfloat *) GST_BUFFER_DATA (outbuf); + residue_samples = this->wing_size * 2 + 1; + input_samples = GST_BUFFER_SIZE (outbuf) / sizeof (gfloat); total_samples = residue_samples + input_samples; input = (gfloat *) g_malloc (sizeof (gfloat) * total_samples); /* copy the left-over bit */ - memcpy (input, filter->residue, sizeof (gfloat) * residue_samples); + memcpy (input, this->residue, sizeof (gfloat) * residue_samples); /* copy the new buffer */ memcpy (&input[residue_samples], src, sizeof (gfloat) * input_samples); /* copy the tail of the current input buffer to the residue */ - memcpy (filter->residue, &src[input_samples - residue_samples], + memcpy (this->residue, &src[input_samples - residue_samples], sizeof (gfloat) * residue_samples); /* convolution */ @@ -280,51 +257,47 @@ gst_lpwsinc_chain (GstPad * pad, GstData * _data) for (i = 0; i < input_samples; ++i) { src[i] = 0.0; for (j = 0; j < residue_samples; ++j) - src[i] += input[i - j + residue_samples] * filter->kernel[j]; + src[i] += input[i - j + residue_samples] * this->kernel[j]; } g_free (input); - gst_pad_push (filter->srcpad, GST_DATA (buf)); + + return GST_FLOW_OK; } static void -gst_lpwsinc_set_property (GObject * object, guint prop_id, const GValue * value, +lpwsinc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { - GstLPWSinc *filter; + GstLPWSinc *this = GST_LPWSINC (object); - g_return_if_fail (GST_IS_LPWSINC (object)); - - filter = GST_LPWSINC (object); + g_return_if_fail (GST_IS_LPWSINC (this)); switch (prop_id) { - case ARG_LENGTH: - filter->wing_size = g_value_get_int (value); + case PROP_LENGTH: + this->wing_size = g_value_get_int (value); break; - case ARG_FREQUENCY: - filter->frequency = g_value_get_double (value); + case PROP_FREQUENCY: + this->frequency = g_value_get_double (value); break; default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void -gst_lpwsinc_get_property (GObject * object, guint prop_id, GValue * value, +lpwsinc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { - GstLPWSinc *filter; - - g_return_if_fail (GST_IS_LPWSINC (object)); - - filter = GST_LPWSINC (object); + GstLPWSinc *this = GST_LPWSINC (object); switch (prop_id) { - case ARG_LENGTH: - g_value_set_int (value, filter->wing_size); + case PROP_LENGTH: + g_value_set_int (value, this->wing_size); break; - case ARG_FREQUENCY: - g_value_set_double (value, filter->frequency); + case PROP_FREQUENCY: + g_value_set_double (value, this->frequency); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); -- cgit v1.2.1