/* -*- 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 * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * * * 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: * - this filter is totally unoptimized ! * - we do not destroy the allocated memory for filters and residue * - this might be improved upon with bytestream */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #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, " "Dreamlab Technologies Ltd. "); /* Filter signals and args */ enum { /* FILL ME */ LAST_SIGNAL }; enum { PROP_0, PROP_LENGTH, PROP_LOWER_FREQUENCY, PROP_UPPER_FREQUENCY }; 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 bpwsinc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static GstFlowReturn bpwsinc_transform_ip (GstBaseTransform * base, GstBuffer * outbuf); static gboolean bpwsinc_set_caps (GstBaseTransform * base, GstCaps * incaps, GstCaps * outcaps); /* Element class */ static void gst_bpwsinc_dispose (GObject * object) { G_OBJECT_CLASS (parent_class)->dispose (object); } static void gst_bpwsinc_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&bpwsinc_src_template)); gst_element_class_add_pad_template (element_class, 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; GstBaseTransformClass *trans_class; gobject_class = (GObjectClass *) klass; trans_class = (GstBaseTransformClass *) 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 (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 (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 (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)); 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 * this, GstBPWSincClass * g_class) { this->wing_size = 50; this->lower_frequency = 0.25; this->upper_frequency = 0.3; this->kernel = NULL; } /* 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; 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)); } /* 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 GstFlowReturn bpwsinc_transform_ip (GstBaseTransform * base, GstBuffer * outbuf) { 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; int residue_samples; gint input_samples; gint total_samples; int i, j; /* 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 */ 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, 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 (this->residue, &src[input_samples - residue_samples], sizeof (gfloat) * residue_samples); /* convolution */ /* since we copied the previous set of samples we needed before the actual * input data, we need to add the filter length to our indices for input */ 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] * this->kernel[j]; } g_free (input); return GST_FLOW_OK; } static void bpwsinc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstBPWSinc *this = GST_BPWSINC (object); g_return_if_fail (GST_IS_BPWSINC (this)); switch (prop_id) { case PROP_LENGTH: this->wing_size = g_value_get_int (value); break; case PROP_LOWER_FREQUENCY: this->lower_frequency = g_value_get_double (value); break; 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 bpwsinc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstBPWSinc *this = GST_BPWSINC (object); switch (prop_id) { case PROP_LENGTH: g_value_set_int (value, this->wing_size); break; case PROP_LOWER_FREQUENCY: g_value_set_double (value, this->lower_frequency); break; case PROP_UPPER_FREQUENCY: g_value_set_double (value, this->upper_frequency); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }