mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-10-03 01:02:19 +00:00
Code Issues 1 Projects Releases Wiki Activity

gst/audiofx/: Implement a base class for generic audio FIR filters.

Browse source 
Original commit message from CVS:
* gst/audiofx/Makefile.am:
* gst/audiofx/audiofxbasefirfilter.c:
(gst_audio_fx_base_fir_filter_dispose),
(gst_audio_fx_base_fir_filter_base_init),
(gst_audio_fx_base_fir_filter_class_init),
(gst_audio_fx_base_fir_filter_init),
(gst_audio_fx_base_fir_filter_push_residue),
(gst_audio_fx_base_fir_filter_setup),
(gst_audio_fx_base_fir_filter_transform),
(gst_audio_fx_base_fir_filter_start),
(gst_audio_fx_base_fir_filter_stop),
(gst_audio_fx_base_fir_filter_query),
(gst_audio_fx_base_fir_filter_query_type),
(gst_audio_fx_base_fir_filter_event),
(gst_audio_fx_base_fir_filter_set_kernel):
* gst/audiofx/audiofxbasefirfilter.h:
* gst/audiofx/audiofxbaseiirfilter.c:
Implement a base class for generic audio FIR filters.
* gst/audiofx/audiowsincband.c:
(gst_gst_audio_wsincband_mode_get_type),
(gst_gst_audio_wsincband_window_get_type),
(gst_audio_wsincband_base_init), (gst_audio_wsincband_class_init),
(gst_audio_wsincband_init), (gst_audio_wsincband_build_kernel),
(gst_audio_wsincband_setup), (gst_audio_wsincband_set_property),
(gst_audio_wsincband_get_property):
* gst/audiofx/audiowsincband.h:
* gst/audiofx/audiowsinclimit.c:
(gst_audio_wsinclimit_mode_get_type),
(gst_audio_wsinclimit_window_get_type),
(gst_audio_wsinclimit_base_init),
(gst_audio_wsinclimit_class_init), (gst_audio_wsinclimit_init),
(gst_audio_wsinclimit_build_kernel), (gst_audio_wsinclimit_setup),
(gst_audio_wsinclimit_set_property),
(gst_audio_wsinclimit_get_property):
* gst/audiofx/audiowsinclimit.h:
* tests/check/elements/audiowsincband.c: (GST_START_TEST):
* tests/check/elements/audiowsinclimit.c: (GST_START_TEST):
Use this new base class for audiowsincband and audiowsinclimit.
Also cleanup both elements.
This commit is contained in:
Sebastian Dröge 2009-01-11 19:03:38 +00:00
parent 1d32ad886e
commit 0016658ace
11 changed files with 831 additions and 1034 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
ChangeLog
View file

@ -1,3 +1,46 @@
2009-01-11 Sebastian Dröge <sebastian.droege@collabora.co.uk>
* gst/audiofx/Makefile.am:
* gst/audiofx/audiofxbasefirfilter.c:
(gst_audio_fx_base_fir_filter_dispose),
(gst_audio_fx_base_fir_filter_base_init),
(gst_audio_fx_base_fir_filter_class_init),
(gst_audio_fx_base_fir_filter_init),
(gst_audio_fx_base_fir_filter_push_residue),
(gst_audio_fx_base_fir_filter_setup),
(gst_audio_fx_base_fir_filter_transform),
(gst_audio_fx_base_fir_filter_start),
(gst_audio_fx_base_fir_filter_stop),
(gst_audio_fx_base_fir_filter_query),
(gst_audio_fx_base_fir_filter_query_type),
(gst_audio_fx_base_fir_filter_event),
(gst_audio_fx_base_fir_filter_set_kernel):
* gst/audiofx/audiofxbasefirfilter.h:
* gst/audiofx/audiofxbaseiirfilter.c:
Implement a base class for generic audio FIR filters.
* gst/audiofx/audiowsincband.c:
(gst_gst_audio_wsincband_mode_get_type),
(gst_gst_audio_wsincband_window_get_type),
(gst_audio_wsincband_base_init), (gst_audio_wsincband_class_init),
(gst_audio_wsincband_init), (gst_audio_wsincband_build_kernel),
(gst_audio_wsincband_setup), (gst_audio_wsincband_set_property),
(gst_audio_wsincband_get_property):
* gst/audiofx/audiowsincband.h:
* gst/audiofx/audiowsinclimit.c:
(gst_audio_wsinclimit_mode_get_type),
(gst_audio_wsinclimit_window_get_type),
(gst_audio_wsinclimit_base_init),
(gst_audio_wsinclimit_class_init), (gst_audio_wsinclimit_init),
(gst_audio_wsinclimit_build_kernel), (gst_audio_wsinclimit_setup),
(gst_audio_wsinclimit_set_property),
(gst_audio_wsinclimit_get_property):
* gst/audiofx/audiowsinclimit.h:
* tests/check/elements/audiowsincband.c: (GST_START_TEST):
* tests/check/elements/audiowsinclimit.c: (GST_START_TEST):
Use this new base class for audiowsincband and audiowsinclimit.
Also cleanup both elements.
2009-01-08 Michael Smith <msmith@songbirdnest.com>
* gst/qtdemux/qtdemux.c:

2
gst/audiofx/Makefile.am
View file

@ -12,6 +12,7 @@ libgstaudiofx_la_SOURCES = audiofx.c\
audiofxbaseiirfilter.c \
audiocheblimit.c \
audiochebband.c \
audiofxbasefirfilter.c \
audiowsincband.c \
audiowsinclimit.c
@ -38,6 +39,7 @@ noinst_HEADERS = audiopanorama.h \
audiofxbaseiirfilter.h \
audiocheblimit.h \
audiochebband.h \
audiofxbasefirfilter.h \
audiowsincband.h \
audiowsinclimit.h \
math_compat.h

527
gst/audiofx/audiofxbasefirfilter.c Normal file
View file

@ -0,0 +1,527 @@
/* -*- c-basic-offset: 2 -*-
*
* GStreamer
* Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
* 2006 Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>
* 2007-2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
*
* 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.
*
*
* TODO: - Implement the convolution in place, probably only makes sense
* when using FFT convolution as currently the convolution itself
* is probably the bottleneck
* - Maybe allow cascading the filter to get a better stopband attenuation.
* Can be done by convolving a filter kernel with itself
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include <math.h>
#include <gst/gst.h>
#include <gst/audio/gstaudiofilter.h>
#include <gst/controller/gstcontroller.h>
#include "audiofxbasefirfilter.h"
#define GST_CAT_DEFAULT gst_audio_fx_base_fir_filter_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
#define ALLOWED_CAPS \
"audio/x-raw-float, " \
" width = (int) { 32, 64 }, " \
" endianness = (int) BYTE_ORDER, " \
" rate = (int) [ 1, MAX ], " \
" channels = (int) [ 1, MAX ]"
#define DEBUG_INIT(bla) \
GST_DEBUG_CATEGORY_INIT (gst_audio_fx_base_fir_filter_debug, "audiofxbasefirfilter", 0, \
"FIR filter base class");
GST_BOILERPLATE_FULL (GstAudioFXBaseFIRFilter, gst_audio_fx_base_fir_filter,
GstAudioFilter, GST_TYPE_AUDIO_FILTER, DEBUG_INIT);
static GstFlowReturn gst_audio_fx_base_fir_filter_transform (GstBaseTransform *
base, GstBuffer * inbuf, GstBuffer * outbuf);
static gboolean gst_audio_fx_base_fir_filter_start (GstBaseTransform * base);
static gboolean gst_audio_fx_base_fir_filter_stop (GstBaseTransform * base);
static gboolean gst_audio_fx_base_fir_filter_event (GstBaseTransform * base,
GstEvent * event);
static gboolean gst_audio_fx_base_fir_filter_setup (GstAudioFilter * base,
GstRingBufferSpec * format);
static gboolean gst_audio_fx_base_fir_filter_query (GstPad * pad,
GstQuery * query);
static const GstQueryType *gst_audio_fx_base_fir_filter_query_type (GstPad *
pad);
/* Element class */
static void
gst_audio_fx_base_fir_filter_dispose (GObject * object)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (object);
if (self->residue) {
g_free (self->residue);
self->residue = NULL;
}
if (self->kernel) {
g_free (self->kernel);
self->kernel = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_audio_fx_base_fir_filter_base_init (gpointer g_class)
{
GstCaps *caps;
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
gst_audio_fx_base_fir_filter_class_init (GstAudioFXBaseFIRFilterClass * klass)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass;
GstAudioFilterClass *filter_class = (GstAudioFilterClass *) klass;
gobject_class->dispose = gst_audio_fx_base_fir_filter_dispose;
trans_class->transform =
GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_transform);
trans_class->start = GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_start);
trans_class->stop = GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_stop);
trans_class->event = GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_event);
filter_class->setup = GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_setup);
}
static void
gst_audio_fx_base_fir_filter_init (GstAudioFXBaseFIRFilter * self,
GstAudioFXBaseFIRFilterClass * g_class)
{
self->kernel = NULL;
self->residue = NULL;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
gst_pad_set_query_function (GST_BASE_TRANSFORM (self)->srcpad,
gst_audio_fx_base_fir_filter_query);
gst_pad_set_query_type_function (GST_BASE_TRANSFORM (self)->srcpad,
gst_audio_fx_base_fir_filter_query_type);
}
#define DEFINE_PROCESS_FUNC(width,ctype) \
static void \
process_##width (GstAudioFXBaseFIRFilter * self, g##ctype * src, g##ctype * dst, guint input_samples) \
{ \
gint kernel_length = self->kernel_length; \
gint i, j, k, l; \
gint channels = GST_AUDIO_FILTER (self)->format.channels; \
gint res_start; \
\
/* convolution */ \
for (i = 0; i < input_samples; i++) { \
dst[i] = 0.0; \
k = i % channels; \
l = i / channels; \
for (j = 0; j < kernel_length; j++) \
if (l < j) \
dst[i] += \
self->residue[(kernel_length + l - j) * channels + \
k] * self->kernel[j]; \
else \
dst[i] += src[(l - j) * channels + k] * self->kernel[j]; \
} \
\
/* copy the tail of the current input buffer to the residue, while \
* keeping parts of the residue if the input buffer is smaller than \
* the kernel length */ \
if (input_samples < kernel_length * channels) \
res_start = kernel_length * channels - input_samples; \
else \
res_start = 0; \
\
for (i = 0; i < res_start; i++) \
self->residue[i] = self->residue[i + input_samples]; \
for (i = res_start; i < kernel_length * channels; i++) \
self->residue[i] = src[input_samples - kernel_length * channels + i]; \
\
self->residue_length += kernel_length * channels - res_start; \
if (self->residue_length > kernel_length * channels) \
self->residue_length = kernel_length * channels; \
}
DEFINE_PROCESS_FUNC (32, float);
DEFINE_PROCESS_FUNC (64, double);
#undef DEFINE_PROCESS_FUNC
void
gst_audio_fx_base_fir_filter_push_residue (GstAudioFXBaseFIRFilter * self)
{
GstBuffer *outbuf;
GstFlowReturn res;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
gint channels = GST_AUDIO_FILTER (self)->format.channels;
gint outsize, outsamples;
gint diffsize, diffsamples;
guint8 *in, *out;
if (channels == 0 || rate == 0) {
self->residue_length = 0;
return;
}
/* Calculate the number of samples and their memory size that
* should be pushed from the residue */
outsamples = MIN (self->latency, self->residue_length / channels);
outsize = outsamples * channels * (GST_AUDIO_FILTER (self)->format.width / 8);
if (outsize == 0) {
self->residue_length = 0;
return;
}
/* Process the difference between latency and residue_length samples
* to start at the actual data instead of starting at the zeros before
* when we only got one buffer smaller than latency */
diffsamples = self->latency - self->residue_length / channels;
diffsize =
diffsamples * channels * (GST_AUDIO_FILTER (self)->format.width / 8);
if (diffsize > 0) {
in = g_new0 (guint8, diffsize);
out = g_new0 (guint8, diffsize);
self->process (self, in, out, diffsamples * channels);
g_free (in);
g_free (out);
}
res = gst_pad_alloc_buffer (GST_BASE_TRANSFORM (self)->srcpad,
GST_BUFFER_OFFSET_NONE, outsize,
GST_PAD_CAPS (GST_BASE_TRANSFORM (self)->srcpad), &outbuf);
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING_OBJECT (self, "failed allocating buffer of %d bytes", outsize);
self->residue_length = 0;
return;
}
/* Convolve the residue with zeros to get the actual remaining data */
in = g_new0 (guint8, outsize);
self->process (self, in, GST_BUFFER_DATA (outbuf), outsamples * channels);
g_free (in);
/* Set timestamp, offset, etc from the values we
* saved when processing the regular buffers */
if (GST_CLOCK_TIME_IS_VALID (self->next_ts))
GST_BUFFER_TIMESTAMP (outbuf) = self->next_ts;
else
GST_BUFFER_TIMESTAMP (outbuf) = 0;
GST_BUFFER_DURATION (outbuf) =
gst_util_uint64_scale (outsamples, GST_SECOND, rate);
self->next_ts += gst_util_uint64_scale (outsamples, GST_SECOND, rate);
if (self->next_off != GST_BUFFER_OFFSET_NONE) {
GST_BUFFER_OFFSET (outbuf) = self->next_off;
GST_BUFFER_OFFSET_END (outbuf) = self->next_off + outsamples;
self->next_off = GST_BUFFER_OFFSET_END (outbuf);
}
GST_DEBUG_OBJECT (self, "Pushing residue buffer of size %d with timestamp: %"
GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %lld,"
" offset_end: %lld, nsamples: %d", GST_BUFFER_SIZE (outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
GST_BUFFER_OFFSET_END (outbuf), outsamples);
res = gst_pad_push (GST_BASE_TRANSFORM (self)->srcpad, outbuf);
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING_OBJECT (self, "failed to push residue");
}
self->residue_length = 0;
}
/* GstAudioFilter vmethod implementations */
/* get notified of caps and plug in the correct process function */
static gboolean
gst_audio_fx_base_fir_filter_setup (GstAudioFilter * base,
GstRingBufferSpec * format)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
gboolean ret = TRUE;
if (self->residue) {
gst_audio_fx_base_fir_filter_push_residue (self);
g_free (self->residue);
self->residue = NULL;
self->residue_length = 0;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
}
if (format->width == 32)
self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_32;
else if (format->width == 64)
self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_64;
else
ret = FALSE;
return TRUE;
}
/* GstBaseTransform vmethod implementations */
static GstFlowReturn
gst_audio_fx_base_fir_filter_transform (GstBaseTransform * base,
GstBuffer * inbuf, GstBuffer * outbuf)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
GstClockTime timestamp;
gint channels = GST_AUDIO_FILTER (self)->format.channels;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
gint input_samples =
GST_BUFFER_SIZE (outbuf) / (GST_AUDIO_FILTER (self)->format.width / 8);
gint output_samples = input_samples;
gint diff = 0;
timestamp = GST_BUFFER_TIMESTAMP (outbuf);
if (!GST_CLOCK_TIME_IS_VALID (timestamp)) {
GST_ERROR_OBJECT (self, "Invalid timestamp");
return GST_FLOW_ERROR;
}
gst_object_sync_values (G_OBJECT (self), timestamp);
g_return_val_if_fail (self->kernel != NULL, GST_FLOW_ERROR);
g_return_val_if_fail (channels != 0, GST_FLOW_ERROR);
if (!self->residue)
self->residue = g_new0 (gdouble, self->kernel_length * channels);
/* Reset the residue if already existing on discont buffers */
if (GST_BUFFER_IS_DISCONT (inbuf) || (GST_CLOCK_TIME_IS_VALID (self->next_ts)
&& timestamp - gst_util_uint64_scale (MIN (self->latency,
self->residue_length / channels), GST_SECOND,
rate) - self->next_ts > 5 * GST_MSECOND)) {
GST_DEBUG_OBJECT (self, "Discontinuity detected - flushing");
if (GST_CLOCK_TIME_IS_VALID (self->next_ts))
gst_audio_fx_base_fir_filter_push_residue (self);
self->residue_length = 0;
self->next_ts = timestamp;
self->next_off = GST_BUFFER_OFFSET (inbuf);
} else if (!GST_CLOCK_TIME_IS_VALID (self->next_ts)) {
self->next_ts = timestamp;
self->next_off = GST_BUFFER_OFFSET (inbuf);
}
/* Calculate the number of samples we can push out now without outputting
* latency zeros in the beginning */
diff = self->latency * channels - self->residue_length;
if (diff > 0)
output_samples -= diff;
self->process (self, GST_BUFFER_DATA (inbuf), GST_BUFFER_DATA (outbuf),
input_samples);
if (output_samples <= 0) {
return GST_BASE_TRANSFORM_FLOW_DROPPED;
}
GST_BUFFER_TIMESTAMP (outbuf) = self->next_ts;
GST_BUFFER_DURATION (outbuf) =
gst_util_uint64_scale (output_samples / channels, GST_SECOND, rate);
GST_BUFFER_OFFSET (outbuf) = self->next_off;
if (GST_BUFFER_OFFSET_IS_VALID (outbuf))
GST_BUFFER_OFFSET_END (outbuf) = self->next_off + output_samples / channels;
else
GST_BUFFER_OFFSET_END (outbuf) = GST_BUFFER_OFFSET_NONE;
if (output_samples < input_samples) {
GST_BUFFER_DATA (outbuf) +=
diff * (GST_AUDIO_FILTER (self)->format.width / 8);
GST_BUFFER_SIZE (outbuf) -=
diff * (GST_AUDIO_FILTER (self)->format.width / 8);
}
self->next_ts += GST_BUFFER_DURATION (outbuf);
self->next_off = GST_BUFFER_OFFSET_END (outbuf);
GST_DEBUG_OBJECT (self, "Pushing buffer of size %d with timestamp: %"
GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %lld,"
" offset_end: %lld, nsamples: %d", GST_BUFFER_SIZE (outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
GST_BUFFER_OFFSET_END (outbuf), output_samples / channels);
return GST_FLOW_OK;
}
static gboolean
gst_audio_fx_base_fir_filter_start (GstBaseTransform * base)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
self->residue_length = 0;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
return TRUE;
}
static gboolean
gst_audio_fx_base_fir_filter_stop (GstBaseTransform * base)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
g_free (self->residue);
self->residue = NULL;
return TRUE;
}
static gboolean
gst_audio_fx_base_fir_filter_query (GstPad * pad, GstQuery * query)
{
GstAudioFXBaseFIRFilter *self =
GST_AUDIO_FX_BASE_FIR_FILTER (gst_pad_get_parent (pad));
gboolean res = TRUE;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min, max;
gboolean live;
guint64 latency;
GstPad *peer;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
if (rate == 0) {
res = FALSE;
} else if ((peer = gst_pad_get_peer (GST_BASE_TRANSFORM (self)->sinkpad))) {
if ((res = gst_pad_query (peer, query))) {
gst_query_parse_latency (query, &live, &min, &max);
GST_DEBUG_OBJECT (self, "Peer latency: min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min), GST_TIME_ARGS (max));
/* add our own latency */
latency = gst_util_uint64_scale (self->latency, GST_SECOND, rate);
GST_DEBUG_OBJECT (self, "Our latency: %"
GST_TIME_FORMAT, GST_TIME_ARGS (latency));
min += latency;
if (max != GST_CLOCK_TIME_NONE)
max += latency;
GST_DEBUG_OBJECT (self, "Calculated total latency : min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min), GST_TIME_ARGS (max));
gst_query_set_latency (query, live, min, max);
}
gst_object_unref (peer);
}
break;
}
default:
res = gst_pad_query_default (pad, query);
break;
}
gst_object_unref (self);
return res;
}
static const GstQueryType *
gst_audio_fx_base_fir_filter_query_type (GstPad * pad)
{
static const GstQueryType types[] = {
GST_QUERY_LATENCY,
0
};
return types;
}
static gboolean
gst_audio_fx_base_fir_filter_event (GstBaseTransform * base, GstEvent * event)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
gst_audio_fx_base_fir_filter_push_residue (self);
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
break;
default:
break;
}
return GST_BASE_TRANSFORM_CLASS (parent_class)->event (base, event);
}
void
gst_audio_fx_base_fir_filter_set_kernel (GstAudioFXBaseFIRFilter * self,
gdouble * kernel, guint kernel_length, guint64 latency)
{
g_return_if_fail (kernel != NULL);
g_return_if_fail (self != NULL);
GST_BASE_TRANSFORM_LOCK (self);
if (self->residue) {
gst_audio_fx_base_fir_filter_push_residue (self);
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
self->residue_length = 0;
}
g_free (self->kernel);
g_free (self->residue);
self->kernel = kernel;
self->kernel_length = kernel_length;
if (GST_AUDIO_FILTER (self)->format.channels) {
self->residue =
g_new0 (gdouble,
kernel_length * GST_AUDIO_FILTER (self)->format.channels);
self->residue_length = 0;
}
if (self->latency != latency) {
self->latency = latency;
gst_element_post_message (GST_ELEMENT (self),
gst_message_new_latency (GST_OBJECT (self)));
}
GST_BASE_TRANSFORM_UNLOCK (self);
}

81
gst/audiofx/audiofxbasefirfilter.h Normal file
View file

@ -0,0 +1,81 @@
/* -*- c-basic-offset: 2 -*-
*
* GStreamer
* Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
* 2006 Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>
* 2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
*
* 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.
*
*/
#ifndef __GST_AUDIO_FX_BASE_FIR_FILTER_H__
#define __GST_AUDIO_FX_BASE_FIR_FILTER_H__
#include <gst/gst.h>
#include <gst/audio/gstaudiofilter.h>
G_BEGIN_DECLS
#define GST_TYPE_AUDIO_FX_BASE_FIR_FILTER \
(gst_audio_fx_base_fir_filter_get_type())
#define GST_AUDIO_FX_BASE_FIR_FILTER(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_FX_BASE_FIR_FILTER,GstAudioFXBaseFIRFilter))
#define GST_AUDIO_FX_BASE_FIR_FILTER_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIO_FX_BASE_FIR_FILTER,GstAudioFXBaseFIRFilterClass))
#define GST_IS_AUDIO_FX_BASE_FIR_FILTER(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_FX_BASE_FIR_FILTER))
#define GST_IS_AUDIO_FX_BASE_FIR_FILTER_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIO_FX_BASE_FIR_FILTER))
typedef struct _GstAudioFXBaseFIRFilter GstAudioFXBaseFIRFilter;
typedef struct _GstAudioFXBaseFIRFilterClass GstAudioFXBaseFIRFilterClass;
typedef void (*GstAudioFXBaseFIRFilterProcessFunc) (GstAudioFXBaseFIRFilter *, guint8 *, guint8 *, guint);
/**
* GstAudioFXBaseFIRFilter:
*
* Opaque data structure.
*/
struct _GstAudioFXBaseFIRFilter {
GstAudioFilter element;
/* < private > */
GstAudioFXBaseFIRFilterProcessFunc process;
gdouble *kernel; /* filter kernel */
guint kernel_length; /* length of the filter kernel */
gdouble *residue; /* buffer for left-over samples from previous buffer */
guint residue_length;
guint64 latency;
GstClockTime next_ts;
guint64 next_off;
};
struct _GstAudioFXBaseFIRFilterClass {
GstAudioFilterClass parent_class;
};
GType gst_audio_fx_base_fir_filter_get_type (void);
void gst_audio_fx_base_fir_filter_set_kernel (GstAudioFXBaseFIRFilter *filter, gdouble *kernel, guint kernel_length, guint64 latency);
void gst_audio_fx_base_fir_filter_push_residue (GstAudioFXBaseFIRFilter *filter);
G_END_DECLS
#endif /* __GST_AUDIO_FX_BASE_FIR_FILTER_H__ */

2
gst/audiofx/audiofxbaseiirfilter.c
View file

@ -43,7 +43,7 @@ GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
" channels = (int) [ 1, MAX ]"
#define DEBUG_INIT(bla) \
GST_DEBUG_CATEGORY_INIT (gst_audio_fx_base_iir_filter_debug, "audiobaseiirfilter", 0, "Audio IIR Filter Base Class");
GST_DEBUG_CATEGORY_INIT (gst_audio_fx_base_iir_filter_debug, "audiofxbaseiirfilter", 0, "Audio IIR Filter Base Class");
GST_BOILERPLATE_FULL (GstAudioFXBaseIIRFilter,
gst_audio_fx_base_iir_filter, GstAudioFilter, GST_TYPE_AUDIO_FILTER,

570
gst/audiofx/audiowsincband.c
View file

@ -3,7 +3,7 @@
* GStreamer
* Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
* 2006 Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>
* 2007 Sebastian Dröge <slomo@circular-chaos.org>
* 2007-2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
@ -74,25 +74,9 @@
#include "audiowsincband.h"
#define GST_CAT_DEFAULT gst_audio_wsincband_debug
#define GST_CAT_DEFAULT gst_gst_audio_wsincband_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
static const GstElementDetails audio_wsincband_details =
GST_ELEMENT_DETAILS ("Band pass & band reject filter",
"Filter/Effect/Audio",
"Band pass and band reject windowed sinc filter",
"Thomas Vander Stichele <thomas at apestaart dot org>, "
"Steven W. Smith, "
"Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>, "
"Sebastian Dröge <slomo@circular-chaos.org>");
/* Filter signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
enum
{
PROP_0,
@ -109,9 +93,9 @@ enum
MODE_BAND_REJECT
};
#define GST_TYPE_AUDIO_WSINC_BAND_MODE (gst_audio_wsincband_mode_get_type ())
#define GST_TYPE_AUDIO_WSINC_BAND_MODE (gst_gst_audio_wsincband_mode_get_type ())
static GType
gst_audio_wsincband_mode_get_type (void)
gst_gst_audio_wsincband_mode_get_type (void)
{
static GType gtype = 0;
@ -135,9 +119,9 @@ enum
WINDOW_BLACKMAN
};
#define GST_TYPE_AUDIO_WSINC_BAND_WINDOW (gst_audio_wsincband_window_get_type ())
#define GST_TYPE_AUDIO_WSINC_BAND_WINDOW (gst_gst_audio_wsincband_window_get_type ())
static GType
gst_audio_wsincband_window_get_type (void)
gst_gst_audio_wsincband_window_get_type (void)
{
static GType gtype = 0;
@ -155,193 +139,96 @@ gst_audio_wsincband_window_get_type (void)
return gtype;
}
#define ALLOWED_CAPS \
"audio/x-raw-float, " \
" width = (int) { 32, 64 }, " \
" endianness = (int) BYTE_ORDER, " \
" rate = (int) [ 1, MAX ], " \
" channels = (int) [ 1, MAX ] "
#define DEBUG_INIT(bla) \
GST_DEBUG_CATEGORY_INIT (gst_audio_wsincband_debug, "audiowsincband", 0, \
GST_DEBUG_CATEGORY_INIT (gst_gst_audio_wsincband_debug, "audiowsincband", 0, \
"Band-pass and Band-reject Windowed sinc filter plugin");
GST_BOILERPLATE_FULL (GstAudioWSincBand, audio_wsincband, GstAudioFilter,
GST_TYPE_AUDIO_FILTER, DEBUG_INIT);
GST_BOILERPLATE_FULL (GstAudioWSincBand, gst_audio_wsincband, GstAudioFilter,
GST_TYPE_AUDIO_FX_BASE_FIR_FILTER, DEBUG_INIT);
static void audio_wsincband_set_property (GObject * object, guint prop_id,
static void gst_audio_wsincband_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void audio_wsincband_get_property (GObject * object, guint prop_id,
static void gst_audio_wsincband_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstFlowReturn audio_wsincband_transform (GstBaseTransform * base,
GstBuffer * inbuf, GstBuffer * outbuf);
static gboolean audio_wsincband_start (GstBaseTransform * base);
static gboolean audio_wsincband_event (GstBaseTransform * base,
GstEvent * event);
static gboolean audio_wsincband_setup (GstAudioFilter * base,
static gboolean gst_audio_wsincband_setup (GstAudioFilter * base,
GstRingBufferSpec * format);
static gboolean audio_wsincband_query (GstPad * pad, GstQuery * query);
static const GstQueryType *audio_wsincband_query_type (GstPad * pad);
/* Element class */
static void
audio_wsincband_dispose (GObject * object)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (object);
if (self->residue) {
g_free (self->residue);
self->residue = NULL;
}
if (self->kernel) {
g_free (self->kernel);
self->kernel = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
audio_wsincband_base_init (gpointer g_class)
gst_audio_wsincband_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
GstCaps *caps;
gst_element_class_set_details (element_class, &audio_wsincband_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);
gst_element_class_set_details_simple (element_class,
"Band pass & band reject filter", "Filter/Effect/Audio",
"Band pass and band reject windowed sinc filter",
"Thomas Vander Stichele <thomas at apestaart dot org>, "
"Steven W. Smith, "
"Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>, "
"Sebastian Dröge <sebastian.droege@collabora.co.uk>");
}
static void
audio_wsincband_class_init (GstAudioWSincBandClass * klass)
gst_audio_wsincband_class_init (GstAudioWSincBandClass * klass)
{
GObjectClass *gobject_class;
GstBaseTransformClass *trans_class;
GstAudioFilterClass *filter_class;
GObjectClass *gobject_class = (GObjectClass *) klass;
GstAudioFilterClass *filter_class = (GstAudioFilterClass *) klass;
gobject_class = (GObjectClass *) klass;
trans_class = (GstBaseTransformClass *) klass;
filter_class = (GstAudioFilterClass *) klass;
gobject_class->set_property = audio_wsincband_set_property;
gobject_class->get_property = audio_wsincband_get_property;
gobject_class->dispose = audio_wsincband_dispose;
gobject_class->set_property = gst_audio_wsincband_set_property;
gobject_class->get_property = gst_audio_wsincband_get_property;
/* FIXME: Don't use the complete possible range but restrict the upper boundary
* so automatically generated UIs can use a slider */
g_object_class_install_property (gobject_class, PROP_LOWER_FREQUENCY,
g_param_spec_float ("lower-frequency", "Lower Frequency",
"Cut-off lower frequency (Hz)", 0.0, 100000.0, 0, G_PARAM_READWRITE));
"Cut-off lower frequency (Hz)", 0.0, 100000.0, 0,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_UPPER_FREQUENCY,
g_param_spec_float ("upper-frequency", "Upper Frequency",
"Cut-off upper frequency (Hz)", 0.0, 100000.0, 0, G_PARAM_READWRITE));
"Cut-off upper frequency (Hz)", 0.0, 100000.0, 0,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_LENGTH,
g_param_spec_int ("length", "Length",
"Filter kernel length, will be rounded to the next odd number",
3, 50000, 101, G_PARAM_READWRITE));
"Filter kernel length, will be rounded to the next odd number", 3,
50000, 101,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_MODE,
g_param_spec_enum ("mode", "Mode",
"Band pass or band reject mode", GST_TYPE_AUDIO_WSINC_BAND_MODE,
MODE_BAND_PASS, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
MODE_BAND_PASS,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_WINDOW,
g_param_spec_enum ("window", "Window",
"Window function to use", GST_TYPE_AUDIO_WSINC_BAND_WINDOW,
WINDOW_HAMMING, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
WINDOW_HAMMING,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
trans_class->transform = GST_DEBUG_FUNCPTR (audio_wsincband_transform);
trans_class->start = GST_DEBUG_FUNCPTR (audio_wsincband_start);
trans_class->event = GST_DEBUG_FUNCPTR (audio_wsincband_event);
filter_class->setup = GST_DEBUG_FUNCPTR (audio_wsincband_setup);
filter_class->setup = GST_DEBUG_FUNCPTR (gst_audio_wsincband_setup);
}
static void
audio_wsincband_init (GstAudioWSincBand * self,
gst_audio_wsincband_init (GstAudioWSincBand * self,
GstAudioWSincBandClass * g_class)
{
self->kernel_length = 101;
self->latency = 50;
self->lower_frequency = 0.0;
self->upper_frequency = 0.0;
self->mode = MODE_BAND_PASS;
self->window = WINDOW_HAMMING;
self->kernel = NULL;
self->have_kernel = FALSE;
self->residue = NULL;
self->residue_length = 0;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
gst_pad_set_query_function (GST_BASE_TRANSFORM (self)->srcpad,
audio_wsincband_query);
gst_pad_set_query_type_function (GST_BASE_TRANSFORM (self)->srcpad,
audio_wsincband_query_type);
}
#define DEFINE_PROCESS_FUNC(width,ctype) \
static void \
process_##width (GstAudioWSincBand * self, g##ctype * src, g##ctype * dst, guint input_samples) \
{ \
gint kernel_length = self->kernel_length; \
gint i, j, k, l; \
gint channels = GST_AUDIO_FILTER (self)->format.channels; \
gint res_start; \
\
/* convolution */ \
for (i = 0; i < input_samples; i++) { \
dst[i] = 0.0; \
k = i % channels; \
l = i / channels; \
for (j = 0; j < kernel_length; j++) \
if (l < j) \
dst[i] += \
self->residue[(kernel_length + l - j) * channels + \
k] * self->kernel[j]; \
else \
dst[i] += src[(l - j) * channels + k] * self->kernel[j]; \
} \
\
/* copy the tail of the current input buffer to the residue, while \
* keeping parts of the residue if the input buffer is smaller than \
* the kernel length */ \
if (input_samples < kernel_length * channels) \
res_start = kernel_length * channels - input_samples; \
else \
res_start = 0; \
\
for (i = 0; i < res_start; i++) \
self->residue[i] = self->residue[i + input_samples]; \
for (i = res_start; i < kernel_length * channels; i++) \
self->residue[i] = src[input_samples - kernel_length * channels + i]; \
\
self->residue_length += kernel_length * channels - res_start; \
if (self->residue_length > kernel_length * channels) \
self->residue_length = kernel_length * channels; \
}
DEFINE_PROCESS_FUNC (32, float);
DEFINE_PROCESS_FUNC (64, double);
#undef DEFINE_PROCESS_FUNC
static void
audio_wsincband_build_kernel (GstAudioWSincBand * self)
gst_audio_wsincband_build_kernel (GstAudioWSincBand * self)
{
gint i = 0;
gdouble sum = 0.0;
gint len = 0;
gdouble *kernel_lp, *kernel_hp;
gdouble w;
gdouble *kernel;
len = self->kernel_length;
@ -369,7 +256,7 @@ audio_wsincband_build_kernel (GstAudioWSincBand * self)
self->upper_frequency = tmp;
}
GST_DEBUG ("audio_wsincband: initializing filter kernel of length %d "
GST_DEBUG ("gst_audio_wsincband: initializing filter kernel of length %d "
"with lower frequency %.2lf Hz "
", upper frequency %.2lf Hz for mode %s",
len, self->lower_frequency, self->upper_frequency,
@ -431,12 +318,10 @@ audio_wsincband_build_kernel (GstAudioWSincBand * self)
kernel_hp[len / 2] += 1;
/* combine the two kernels */
if (self->kernel)
g_free (self->kernel);
self->kernel = g_new (gdouble, len);
kernel = g_new (gdouble, len);
for (i = 0; i < len; ++i)
self->kernel[i] = kernel_lp[i] + kernel_hp[i];
kernel[i] = kernel_lp[i] + kernel_hp[i];
/* free the helper kernels */
g_free (kernel_lp);
@ -446,338 +331,29 @@ audio_wsincband_build_kernel (GstAudioWSincBand * self)
* if specified */
if (self->mode == MODE_BAND_PASS) {
for (i = 0; i < len; ++i)
self->kernel[i] = -self->kernel[i];
self->kernel[len / 2] += 1;
}
/* set up the residue memory space */
if (!self->residue) {
self->residue =
g_new0 (gdouble, len * GST_AUDIO_FILTER (self)->format.channels);
self->residue_length = 0;
}
self->have_kernel = TRUE;
}
static void
audio_wsincband_push_residue (GstAudioWSincBand * self)
{
GstBuffer *outbuf;
GstFlowReturn res;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
gint channels = GST_AUDIO_FILTER (self)->format.channels;
gint outsize, outsamples;
gint diffsize, diffsamples;
guint8 *in, *out;
/* Calculate the number of samples and their memory size that
* should be pushed from the residue */
outsamples = MIN (self->latency, self->residue_length / channels);
outsize = outsamples * channels * (GST_AUDIO_FILTER (self)->format.width / 8);
if (outsize == 0)
return;
/* Process the difference between latency and residue_length samples
* to start at the actual data instead of starting at the zeros before
* when we only got one buffer smaller than latency */
diffsamples = self->latency - self->residue_length / channels;
diffsize =
diffsamples * channels * (GST_AUDIO_FILTER (self)->format.width / 8);
if (diffsize > 0) {
in = g_new0 (guint8, diffsize);
out = g_new0 (guint8, diffsize);
self->process (self, in, out, diffsamples * channels);
g_free (in);
g_free (out);
}
res = gst_pad_alloc_buffer (GST_BASE_TRANSFORM (self)->srcpad,
GST_BUFFER_OFFSET_NONE, outsize,
GST_PAD_CAPS (GST_BASE_TRANSFORM (self)->srcpad), &outbuf);
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING_OBJECT (self, "failed allocating buffer of %d bytes", outsize);
return;
}
/* Convolve the residue with zeros to get the actual remaining data */
in = g_new0 (guint8, outsize);
self->process (self, in, GST_BUFFER_DATA (outbuf), outsamples * channels);
g_free (in);
/* Set timestamp, offset, etc from the values we
* saved when processing the regular buffers */
if (GST_CLOCK_TIME_IS_VALID (self->next_ts))
GST_BUFFER_TIMESTAMP (outbuf) = self->next_ts;
else
GST_BUFFER_TIMESTAMP (outbuf) = 0;
GST_BUFFER_DURATION (outbuf) =
gst_util_uint64_scale (outsamples, GST_SECOND, rate);
self->next_ts += gst_util_uint64_scale (outsamples, GST_SECOND, rate);
if (self->next_off != GST_BUFFER_OFFSET_NONE) {
GST_BUFFER_OFFSET (outbuf) = self->next_off;
GST_BUFFER_OFFSET_END (outbuf) = self->next_off + outsamples;
}
GST_DEBUG_OBJECT (self, "Pushing residue buffer of size %d with timestamp: %"
GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %lld,"
" offset_end: %lld, nsamples: %d", GST_BUFFER_SIZE (outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
GST_BUFFER_OFFSET_END (outbuf), outsamples);
res = gst_pad_push (GST_BASE_TRANSFORM (self)->srcpad, outbuf);
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING_OBJECT (self, "failed to push residue");
kernel[i] = -kernel[i];
kernel[len / 2] += 1;
}
gst_audio_fx_base_fir_filter_set_kernel (GST_AUDIO_FX_BASE_FIR_FILTER (self),
kernel, self->kernel_length, (len - 1) / 2);
}
/* GstAudioFilter vmethod implementations */
/* get notified of caps and plug in the correct process function */
static gboolean
audio_wsincband_setup (GstAudioFilter * base, GstRingBufferSpec * format)
gst_audio_wsincband_setup (GstAudioFilter * base, GstRingBufferSpec * format)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (base);
gboolean ret = TRUE;
gst_audio_wsincband_build_kernel (self);
if (format->width == 32)
self->process = (GstAudioWSincBandProcessFunc) process_32;
else if (format->width == 64)
self->process = (GstAudioWSincBandProcessFunc) process_64;
else
ret = FALSE;
self->have_kernel = FALSE;
return TRUE;
}
/* GstBaseTransform vmethod implementations */
static GstFlowReturn
audio_wsincband_transform (GstBaseTransform * base, GstBuffer * inbuf,
GstBuffer * outbuf)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (base);
GstClockTime timestamp;
gint channels = GST_AUDIO_FILTER (self)->format.channels;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
gint input_samples =
GST_BUFFER_SIZE (outbuf) / (GST_AUDIO_FILTER (self)->format.width / 8);
gint output_samples = input_samples;
gint diff;
/* 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 (self), timestamp);
if (!self->have_kernel)
audio_wsincband_build_kernel (self);
/* Reset the residue if already existing on discont buffers */
if (GST_BUFFER_IS_DISCONT (inbuf)) {
if (channels && self->residue)
memset (self->residue, 0, channels *
self->kernel_length * sizeof (gdouble));
self->residue_length = 0;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
}
/* Calculate the number of samples we can push out now without outputting
* kernel_length/2 zeros in the beginning */
diff = (self->kernel_length / 2) * channels - self->residue_length;
if (diff > 0)
output_samples -= diff;
self->process (self, GST_BUFFER_DATA (inbuf), GST_BUFFER_DATA (outbuf),
input_samples);
if (output_samples <= 0) {
/* Drop buffer and save original timestamp/offset for later use */
if (!GST_CLOCK_TIME_IS_VALID (self->next_ts)
&& GST_BUFFER_TIMESTAMP_IS_VALID (outbuf))
self->next_ts = GST_BUFFER_TIMESTAMP (outbuf);
if (self->next_off == GST_BUFFER_OFFSET_NONE
&& GST_BUFFER_OFFSET_IS_VALID (outbuf))
self->next_off = GST_BUFFER_OFFSET (outbuf);
return GST_BASE_TRANSFORM_FLOW_DROPPED;
} else if (output_samples < input_samples) {
/* First (probably partial) buffer after starting from
* a clean residue. Use stored timestamp/offset here */
if (GST_CLOCK_TIME_IS_VALID (self->next_ts))
GST_BUFFER_TIMESTAMP (outbuf) = self->next_ts;
if (self->next_off != GST_BUFFER_OFFSET_NONE) {
GST_BUFFER_OFFSET (outbuf) = self->next_off;
if (GST_BUFFER_OFFSET_END_IS_VALID (outbuf))
GST_BUFFER_OFFSET_END (outbuf) =
self->next_off + output_samples / channels;
} else {
/* We dropped no buffer, offset is valid, offset_end must be adjusted by diff */
if (GST_BUFFER_OFFSET_END_IS_VALID (outbuf))
GST_BUFFER_OFFSET_END (outbuf) -= diff / channels;
}
if (GST_BUFFER_DURATION_IS_VALID (outbuf))
GST_BUFFER_DURATION (outbuf) -=
gst_util_uint64_scale (diff, GST_SECOND, channels * rate);
GST_BUFFER_DATA (outbuf) +=
diff * (GST_AUDIO_FILTER (self)->format.width / 8);
GST_BUFFER_SIZE (outbuf) -=
diff * (GST_AUDIO_FILTER (self)->format.width / 8);
} else {
GstClockTime ts_latency =
gst_util_uint64_scale (self->latency, GST_SECOND, rate);
/* Normal buffer, adjust timestamp/offset/etc by latency */
if (GST_BUFFER_TIMESTAMP (outbuf) < ts_latency) {
GST_WARNING_OBJECT (self, "GST_BUFFER_TIMESTAMP (outbuf) < latency");
GST_BUFFER_TIMESTAMP (outbuf) = 0;
} else {
GST_BUFFER_TIMESTAMP (outbuf) -= ts_latency;
}
if (GST_BUFFER_OFFSET_IS_VALID (outbuf)) {
if (GST_BUFFER_OFFSET (outbuf) > self->latency) {
GST_BUFFER_OFFSET (outbuf) -= self->latency;
} else {
GST_WARNING_OBJECT (self, "GST_BUFFER_OFFSET (outbuf) < latency");
GST_BUFFER_OFFSET (outbuf) = 0;
}
}
if (GST_BUFFER_OFFSET_END_IS_VALID (outbuf)) {
if (GST_BUFFER_OFFSET_END (outbuf) > self->latency) {
GST_BUFFER_OFFSET_END (outbuf) -= self->latency;
} else {
GST_WARNING_OBJECT (self, "GST_BUFFER_OFFSET_END (outbuf) < latency");
GST_BUFFER_OFFSET_END (outbuf) = 0;
}
}
}
GST_DEBUG_OBJECT (self, "Pushing buffer of size %d with timestamp: %"
GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %lld,"
" offset_end: %lld, nsamples: %d", GST_BUFFER_SIZE (outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
GST_BUFFER_OFFSET_END (outbuf), output_samples / channels);
self->next_ts = GST_BUFFER_TIMESTAMP (outbuf) + GST_BUFFER_DURATION (outbuf);
self->next_off = GST_BUFFER_OFFSET_END (outbuf);
return GST_FLOW_OK;
}
static gboolean
audio_wsincband_start (GstBaseTransform * base)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (base);
gint channels = GST_AUDIO_FILTER (self)->format.channels;
/* Reset the residue if already existing */
if (channels && self->residue)
memset (self->residue, 0, channels *
self->kernel_length * sizeof (gdouble));
self->residue_length = 0;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
return TRUE;
}
static gboolean
audio_wsincband_query (GstPad * pad, GstQuery * query)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (gst_pad_get_parent (pad));
gboolean res = TRUE;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min, max;
gboolean live;
guint64 latency;
GstPad *peer;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
if ((peer = gst_pad_get_peer (GST_BASE_TRANSFORM (self)->sinkpad))) {
if ((res = gst_pad_query (peer, query))) {
gst_query_parse_latency (query, &live, &min, &max);
GST_DEBUG_OBJECT (self, "Peer latency: min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min), GST_TIME_ARGS (max));
/* add our own latency */
latency =
(rate != 0) ? gst_util_uint64_scale (self->latency, GST_SECOND,
rate) : 0;
GST_DEBUG_OBJECT (self, "Our latency: %"
GST_TIME_FORMAT, GST_TIME_ARGS (latency));
min += latency;
if (max != GST_CLOCK_TIME_NONE)
max += latency;
GST_DEBUG_OBJECT (self, "Calculated total latency : min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min), GST_TIME_ARGS (max));
gst_query_set_latency (query, live, min, max);
}
gst_object_unref (peer);
}
break;
}
default:
res = gst_pad_query_default (pad, query);
break;
}
gst_object_unref (self);
return res;
}
static const GstQueryType *
audio_wsincband_query_type (GstPad * pad)
{
static const GstQueryType types[] = {
GST_QUERY_LATENCY,
0
};
return types;
}
static gboolean
audio_wsincband_event (GstBaseTransform * base, GstEvent * event)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (base);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
audio_wsincband_push_residue (self);
break;
default:
break;
}
return GST_BASE_TRANSFORM_CLASS (parent_class)->event (base, event);
return GST_AUDIO_FILTER_CLASS (parent_class)->setup (base, format);
}
static void
audio_wsincband_set_property (GObject * object, guint prop_id,
gst_audio_wsincband_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (object);
@ -788,49 +364,43 @@ audio_wsincband_set_property (GObject * object, guint prop_id,
case PROP_LENGTH:{
gint val;
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
val = g_value_get_int (value);
if (val % 2 == 0)
val++;
if (val != self->kernel_length) {
if (self->residue) {
audio_wsincband_push_residue (self);
g_free (self->residue);
self->residue = NULL;
}
gst_audio_fx_base_fir_filter_push_residue (GST_AUDIO_FX_BASE_FIR_FILTER
(self));
self->kernel_length = val;
self->latency = val / 2;
audio_wsincband_build_kernel (self);
gst_element_post_message (GST_ELEMENT (self),
gst_message_new_latency (GST_OBJECT (self)));
gst_audio_wsincband_build_kernel (self);
}
GST_BASE_TRANSFORM_UNLOCK (self);
GST_OBJECT_UNLOCK (self);
break;
}
case PROP_LOWER_FREQUENCY:
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
self->lower_frequency = g_value_get_float (value);
audio_wsincband_build_kernel (self);
GST_BASE_TRANSFORM_UNLOCK (self);
gst_audio_wsincband_build_kernel (self);
GST_OBJECT_UNLOCK (self);
break;
case PROP_UPPER_FREQUENCY:
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
self->upper_frequency = g_value_get_float (value);
audio_wsincband_build_kernel (self);
GST_BASE_TRANSFORM_UNLOCK (self);
gst_audio_wsincband_build_kernel (self);
GST_OBJECT_UNLOCK (self);
break;
case PROP_MODE:
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
self->mode = g_value_get_enum (value);
audio_wsincband_build_kernel (self);
GST_BASE_TRANSFORM_UNLOCK (self);
gst_audio_wsincband_build_kernel (self);
GST_OBJECT_UNLOCK (self);
break;
case PROP_WINDOW:
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
self->window = g_value_get_enum (value);
audio_wsincband_build_kernel (self);
GST_BASE_TRANSFORM_UNLOCK (self);
gst_audio_wsincband_build_kernel (self);
GST_OBJECT_UNLOCK (self);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -839,8 +409,8 @@ audio_wsincband_set_property (GObject * object, guint prop_id,
}
static void
audio_wsincband_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
gst_audio_wsincband_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (object);

23
gst/audiofx/audiowsincband.h
View file

@ -3,6 +3,7 @@
* GStreamer
* Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
* 2006 Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>
* 2007-2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
@ -33,10 +34,12 @@
#include <gst/gst.h>
#include <gst/audio/gstaudiofilter.h>
#include "audiofxbasefirfilter.h"
G_BEGIN_DECLS
#define GST_TYPE_AUDIO_WSINC_BAND \
(audio_wsincband_get_type())
(gst_audio_wsincband_get_type())
#define GST_AUDIO_WSINC_BAND(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_WSINC_BAND,GstAudioWSincBand))
#define GST_AUDIO_WSINC_BAND_CLASS(klass) \
@ -49,38 +52,26 @@ G_BEGIN_DECLS
typedef struct _GstAudioWSincBand GstAudioWSincBand;
typedef struct _GstAudioWSincBandClass GstAudioWSincBandClass;
typedef void (*GstAudioWSincBandProcessFunc) (GstAudioWSincBand *, guint8 *, guint8 *, guint);
/**
* GstAudioWSincBand:
*
* Opaque data structure.
*/
struct _GstAudioWSincBand {
GstAudioFilter element;
GstAudioFXBaseFIRFilter parent;
/* < private > */
GstAudioWSincBandProcessFunc process;
gint mode;
gint window;
gfloat lower_frequency, upper_frequency;
gint kernel_length; /* length of the filter kernel */
gdouble *residue; /* buffer for left-over samples from previous buffer */
gdouble *kernel;
gboolean have_kernel;
gint residue_length;
guint64 latency;
GstClockTime next_ts;
guint64 next_off;
};
struct _GstAudioWSincBandClass {
GstAudioFilterClass parent_class;
GstAudioFilterClass parent;
};
GType audio_wsincband_get_type (void);
GType gst_audio_wsincband_get_type (void);
G_END_DECLS

568
gst/audiofx/audiowsinclimit.c
View file

@ -3,7 +3,7 @@
* GStreamer
* Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
* 2006 Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>
* 2007 Sebastian Dröge <slomo@circular-chaos.org>
* 2007-2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
@ -72,25 +72,9 @@
#include "audiowsinclimit.h"
#define GST_CAT_DEFAULT audio_wsinclimit_debug
#define GST_CAT_DEFAULT gst_audio_wsinclimit_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
static const GstElementDetails audio_wsinclimit_details =
GST_ELEMENT_DETAILS ("Low pass & high pass filter",
"Filter/Effect/Audio",
"Low pass and high pass windowed sinc filter",
"Thomas Vander Stichele <thomas at apestaart dot org>, "
"Steven W. Smith, "
"Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>, "
"Sebastian Dröge <slomo@circular-chaos.org>");
/* Filter signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
enum
{
PROP_0,
@ -106,9 +90,9 @@ enum
MODE_HIGH_PASS
};
#define GST_TYPE_AUDIO_WSINC_LIMIT_MODE (audio_wsinclimit_mode_get_type ())
#define GST_TYPE_AUDIO_WSINC_LIMIT_MODE (gst_audio_wsinclimit_mode_get_type ())
static GType
audio_wsinclimit_mode_get_type (void)
gst_audio_wsinclimit_mode_get_type (void)
{
static GType gtype = 0;
@ -132,9 +116,9 @@ enum
WINDOW_BLACKMAN
};
#define GST_TYPE_AUDIO_WSINC_LIMIT_WINDOW (audio_wsinclimit_window_get_type ())
#define GST_TYPE_AUDIO_WSINC_LIMIT_WINDOW (gst_audio_wsinclimit_window_get_type ())
static GType
audio_wsinclimit_window_get_type (void)
gst_audio_wsinclimit_window_get_type (void)
{
static GType gtype = 0;
@ -152,189 +136,91 @@ audio_wsinclimit_window_get_type (void)
return gtype;
}
#define ALLOWED_CAPS \
"audio/x-raw-float, " \
" width = (int) { 32, 64 }, " \
" endianness = (int) BYTE_ORDER, " \
" rate = (int) [ 1, MAX ], " \
" channels = (int) [ 1, MAX ]"
#define DEBUG_INIT(bla) \
GST_DEBUG_CATEGORY_INIT (audio_wsinclimit_debug, "audiowsinclimit", 0, \
GST_DEBUG_CATEGORY_INIT (gst_audio_wsinclimit_debug, "audiowsinclimit", 0, \
"Low-pass and High-pass Windowed sinc filter plugin");
GST_BOILERPLATE_FULL (GstAudioWSincLimit, audio_wsinclimit, GstAudioFilter,
GST_TYPE_AUDIO_FILTER, DEBUG_INIT);
GST_BOILERPLATE_FULL (GstAudioWSincLimit, gst_audio_wsinclimit, GstAudioFilter,
GST_TYPE_AUDIO_FX_BASE_FIR_FILTER, DEBUG_INIT);
static void audio_wsinclimit_set_property (GObject * object, guint prop_id,
static void gst_audio_wsinclimit_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void audio_wsinclimit_get_property (GObject * object, guint prop_id,
static void gst_audio_wsinclimit_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstFlowReturn audio_wsinclimit_transform (GstBaseTransform * base,
GstBuffer * inbuf, GstBuffer * outbuf);
static gboolean audio_wsinclimit_start (GstBaseTransform * base);
static gboolean audio_wsinclimit_event (GstBaseTransform * base,
GstEvent * event);
static gboolean audio_wsinclimit_setup (GstAudioFilter * base,
static gboolean gst_audio_wsinclimit_setup (GstAudioFilter * base,
GstRingBufferSpec * format);
static gboolean audio_wsinclimit_query (GstPad * pad, GstQuery * query);
static const GstQueryType *audio_wsinclimit_query_type (GstPad * pad);
/* Element class */
static void
audio_wsinclimit_dispose (GObject * object)
{
GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (object);
if (self->residue) {
g_free (self->residue);
self->residue = NULL;
}
if (self->kernel) {
g_free (self->kernel);
self->kernel = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
audio_wsinclimit_base_init (gpointer g_class)
gst_audio_wsinclimit_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
GstCaps *caps;
gst_element_class_set_details (element_class, &audio_wsinclimit_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);
gst_element_class_set_details_simple (element_class,
"Low pass & high pass filter", "Filter/Effect/Audio",
"Low pass and high pass windowed sinc filter",
"Thomas Vander Stichele <thomas at apestaart dot org>, "
"Steven W. Smith, "
"Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>, "
"Sebastian Dröge <sebastian.droege@collabora.co.uk>");
}
static void
audio_wsinclimit_class_init (GstAudioWSincLimitClass * klass)
gst_audio_wsinclimit_class_init (GstAudioWSincLimitClass * klass)
{
GObjectClass *gobject_class;
GstBaseTransformClass *trans_class;
GstAudioFilterClass *filter_class;
gobject_class = (GObjectClass *) klass;
trans_class = (GstBaseTransformClass *) klass;
filter_class = (GstAudioFilterClass *) klass;
gobject_class->set_property = audio_wsinclimit_set_property;
gobject_class->get_property = audio_wsinclimit_get_property;
gobject_class->dispose = audio_wsinclimit_dispose;
GObjectClass *gobject_class = (GObjectClass *) klass;
GstAudioFilterClass *filter_class = (GstAudioFilterClass *) klass;
gobject_class->set_property = gst_audio_wsinclimit_set_property;
gobject_class->get_property = gst_audio_wsinclimit_get_property;
/* FIXME: Don't use the complete possible range but restrict the upper boundary
* so automatically generated UIs can use a slider */
g_object_class_install_property (gobject_class, PROP_FREQUENCY,
g_param_spec_float ("cutoff", "Cutoff",
"Cut-off Frequency (Hz)", 0.0, 100000.0, 0.0,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_LENGTH,
g_param_spec_int ("length", "Length",
"Filter kernel length, will be rounded to the next odd number",
3, 50000, 101, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
3, 50000, 101,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_MODE,
g_param_spec_enum ("mode", "Mode",
"Low pass or high pass mode", GST_TYPE_AUDIO_WSINC_LIMIT_MODE,
MODE_LOW_PASS, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
MODE_LOW_PASS,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_WINDOW,
g_param_spec_enum ("window", "Window",
"Window function to use", GST_TYPE_AUDIO_WSINC_LIMIT_WINDOW,
WINDOW_HAMMING, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
WINDOW_HAMMING,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
trans_class->transform = GST_DEBUG_FUNCPTR (audio_wsinclimit_transform);
trans_class->start = GST_DEBUG_FUNCPTR (audio_wsinclimit_start);
trans_class->event = GST_DEBUG_FUNCPTR (audio_wsinclimit_event);
filter_class->setup = GST_DEBUG_FUNCPTR (audio_wsinclimit_setup);
filter_class->setup = GST_DEBUG_FUNCPTR (gst_audio_wsinclimit_setup);
}
static void
audio_wsinclimit_init (GstAudioWSincLimit * self,
gst_audio_wsinclimit_init (GstAudioWSincLimit * self,
GstAudioWSincLimitClass * g_class)
{
self->mode = MODE_LOW_PASS;
self->window = WINDOW_HAMMING;
self->kernel_length = 101;
self->latency = 50;
self->cutoff = 0.0;
self->kernel = NULL;
self->residue = NULL;
self->have_kernel = FALSE;
self->residue_length = 0;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
gst_pad_set_query_function (GST_BASE_TRANSFORM (self)->srcpad,
audio_wsinclimit_query);
gst_pad_set_query_type_function (GST_BASE_TRANSFORM (self)->srcpad,
audio_wsinclimit_query_type);
}
#define DEFINE_PROCESS_FUNC(width,ctype) \
static void \
process_##width (GstAudioWSincLimit * self, g##ctype * src, g##ctype * dst, guint input_samples) \
{ \
gint kernel_length = self->kernel_length; \
gint i, j, k, l; \
gint channels = GST_AUDIO_FILTER (self)->format.channels; \
gint res_start; \
\
/* convolution */ \
for (i = 0; i < input_samples; i++) { \
dst[i] = 0.0; \
k = i % channels; \
l = i / channels; \
for (j = 0; j < kernel_length; j++) \
if (l < j) \
dst[i] += \
self->residue[(kernel_length + l - j) * channels + \
k] * self->kernel[j]; \
else \
dst[i] += src[(l - j) * channels + k] * self->kernel[j]; \
} \
\
/* copy the tail of the current input buffer to the residue, while \
* keeping parts of the residue if the input buffer is smaller than \
* the kernel length */ \
if (input_samples < kernel_length * channels) \
res_start = kernel_length * channels - input_samples; \
else \
res_start = 0; \
\
for (i = 0; i < res_start; i++) \
self->residue[i] = self->residue[i + input_samples]; \
for (i = res_start; i < kernel_length * channels; i++) \
self->residue[i] = src[input_samples - kernel_length * channels + i]; \
\
self->residue_length += kernel_length * channels - res_start; \
if (self->residue_length > kernel_length * channels) \
self->residue_length = kernel_length * channels; \
}
DEFINE_PROCESS_FUNC (32, float);
DEFINE_PROCESS_FUNC (64, double);
#undef DEFINE_PROCESS_FUNC
static void
audio_wsinclimit_build_kernel (GstAudioWSincLimit * self)
gst_audio_wsinclimit_build_kernel (GstAudioWSincLimit * self)
{
gint i = 0;
gdouble sum = 0.0;
gint len = 0;
gdouble w;
gdouble *kernel = NULL;
len = self->kernel_length;
@ -352,7 +238,7 @@ audio_wsinclimit_build_kernel (GstAudioWSincLimit * self)
self->cutoff =
CLAMP (self->cutoff, 0.0, GST_AUDIO_FILTER (self)->format.rate / 2);
GST_DEBUG ("audio_wsinclimit_: initializing filter kernel of length %d "
GST_DEBUG ("gst_audio_wsinclimit_: initializing filter kernel of length %d "
"with cutoff %.2lf Hz "
"for mode %s",
len, self->cutoff,
@ -361,365 +247,53 @@ audio_wsinclimit_build_kernel (GstAudioWSincLimit * self)
/* fill the kernel */
w = 2 * M_PI * (self->cutoff / GST_AUDIO_FILTER (self)->format.rate);
if (self->kernel)
g_free (self->kernel);
self->kernel = g_new (gdouble, len);
kernel = g_new (gdouble, len);
for (i = 0; i < len; ++i) {
if (i == len / 2)
self->kernel[i] = w;
kernel[i] = w;
else
self->kernel[i] = sin (w * (i - len / 2)) / (i - len / 2);
kernel[i] = sin (w * (i - len / 2)) / (i - len / 2);
/* windowing */
if (self->window == WINDOW_HAMMING)
self->kernel[i] *= (0.54 - 0.46 * cos (2 * M_PI * i / len));
kernel[i] *= (0.54 - 0.46 * cos (2 * M_PI * i / len));
else
self->kernel[i] *=
(0.42 - 0.5 * cos (2 * M_PI * i / len) +
kernel[i] *= (0.42 - 0.5 * cos (2 * M_PI * i / len) +
0.08 * cos (4 * M_PI * i / len));
}
/* normalize for unity gain at DC */
for (i = 0; i < len; ++i)
sum += self->kernel[i];
sum += kernel[i];
for (i = 0; i < len; ++i)
self->kernel[i] /= sum;
kernel[i] /= sum;
/* convert to highpass if specified */
if (self->mode == MODE_HIGH_PASS) {
for (i = 0; i < len; ++i)
self->kernel[i] = -self->kernel[i];
self->kernel[len / 2] += 1.0;
}
/* set up the residue memory space */
if (!self->residue) {
self->residue =
g_new0 (gdouble, len * GST_AUDIO_FILTER (self)->format.channels);
self->residue_length = 0;
}
self->have_kernel = TRUE;
}
static void
audio_wsinclimit_push_residue (GstAudioWSincLimit * self)
{
GstBuffer *outbuf;
GstFlowReturn res;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
gint channels = GST_AUDIO_FILTER (self)->format.channels;
gint outsize, outsamples;
gint diffsize, diffsamples;
guint8 *in, *out;
/* Calculate the number of samples and their memory size that
* should be pushed from the residue */
outsamples = MIN (self->latency, self->residue_length / channels);
outsize = outsamples * channels * (GST_AUDIO_FILTER (self)->format.width / 8);
if (outsize == 0)
return;
/* Process the difference between latency and residue_length samples
* to start at the actual data instead of starting at the zeros before
* when we only got one buffer smaller than latency */
diffsamples = self->latency - self->residue_length / channels;
diffsize =
diffsamples * channels * (GST_AUDIO_FILTER (self)->format.width / 8);
if (diffsize > 0) {
in = g_new0 (guint8, diffsize);
out = g_new0 (guint8, diffsize);
self->process (self, in, out, diffsamples * channels);
g_free (in);
g_free (out);
}
res = gst_pad_alloc_buffer (GST_BASE_TRANSFORM (self)->srcpad,
GST_BUFFER_OFFSET_NONE, outsize,
GST_PAD_CAPS (GST_BASE_TRANSFORM (self)->srcpad), &outbuf);
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING_OBJECT (self, "failed allocating buffer of %d bytes", outsize);
return;
}
/* Convolve the residue with zeros to get the actual remaining data */
in = g_new0 (guint8, outsize);
self->process (self, in, GST_BUFFER_DATA (outbuf), outsamples * channels);
g_free (in);
/* Set timestamp, offset, etc from the values we
* saved when processing the regular buffers */
if (GST_CLOCK_TIME_IS_VALID (self->next_ts))
GST_BUFFER_TIMESTAMP (outbuf) = self->next_ts;
else
GST_BUFFER_TIMESTAMP (outbuf) = 0;
GST_BUFFER_DURATION (outbuf) =
gst_util_uint64_scale (outsamples, GST_SECOND, rate);
self->next_ts += gst_util_uint64_scale (outsamples, GST_SECOND, rate);
if (self->next_off != GST_BUFFER_OFFSET_NONE) {
GST_BUFFER_OFFSET (outbuf) = self->next_off;
GST_BUFFER_OFFSET_END (outbuf) = self->next_off + outsamples;
}
GST_DEBUG_OBJECT (self, "Pushing residue buffer of size %d with timestamp: %"
GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %lld,"
" offset_end: %lld, nsamples: %d", GST_BUFFER_SIZE (outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
GST_BUFFER_OFFSET_END (outbuf), outsamples);
res = gst_pad_push (GST_BASE_TRANSFORM (self)->srcpad, outbuf);
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING_OBJECT (self, "failed to push residue");
kernel[i] = -kernel[i];
kernel[len / 2] += 1.0;
}
gst_audio_fx_base_fir_filter_set_kernel (GST_AUDIO_FX_BASE_FIR_FILTER (self),
kernel, self->kernel_length, (len - 1) / 2);
}
/* GstAudioFilter vmethod implementations */
/* get notified of caps and plug in the correct process function */
static gboolean
audio_wsinclimit_setup (GstAudioFilter * base, GstRingBufferSpec * format)
gst_audio_wsinclimit_setup (GstAudioFilter * base, GstRingBufferSpec * format)
{
GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (base);
gboolean ret = TRUE;
gst_audio_wsinclimit_build_kernel (self);
if (format->width == 32)
self->process = (GstAudioWSincLimitProcessFunc) process_32;
else if (format->width == 64)
self->process = (GstAudioWSincLimitProcessFunc) process_64;
else
ret = FALSE;
self->have_kernel = FALSE;
return TRUE;
}
/* GstBaseTransform vmethod implementations */
static GstFlowReturn
audio_wsinclimit_transform (GstBaseTransform * base, GstBuffer * inbuf,
GstBuffer * outbuf)
{
GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (base);
GstClockTime timestamp;
gint channels = GST_AUDIO_FILTER (self)->format.channels;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
gint input_samples =
GST_BUFFER_SIZE (outbuf) / (GST_AUDIO_FILTER (self)->format.width / 8);
gint output_samples = input_samples;
gint diff;
/* 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 (self), timestamp);
if (!self->have_kernel)
audio_wsinclimit_build_kernel (self);
/* Reset the residue if already existing on discont buffers */
if (GST_BUFFER_IS_DISCONT (inbuf)) {
if (channels && self->residue)
memset (self->residue, 0, channels *
self->kernel_length * sizeof (gdouble));
self->residue_length = 0;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
}
/* Calculate the number of samples we can push out now without outputting
* kernel_length/2 zeros in the beginning */
diff = (self->kernel_length / 2) * channels - self->residue_length;
if (diff > 0)
output_samples -= diff;
self->process (self, GST_BUFFER_DATA (inbuf), GST_BUFFER_DATA (outbuf),
input_samples);
if (output_samples <= 0) {
/* Drop buffer and save original timestamp/offset for later use */
if (!GST_CLOCK_TIME_IS_VALID (self->next_ts)
&& GST_BUFFER_TIMESTAMP_IS_VALID (outbuf))
self->next_ts = GST_BUFFER_TIMESTAMP (outbuf);
if (self->next_off == GST_BUFFER_OFFSET_NONE
&& GST_BUFFER_OFFSET_IS_VALID (outbuf))
self->next_off = GST_BUFFER_OFFSET (outbuf);
return GST_BASE_TRANSFORM_FLOW_DROPPED;
} else if (output_samples < input_samples) {
/* First (probably partial) buffer after starting from
* a clean residue. Use stored timestamp/offset here */
if (GST_CLOCK_TIME_IS_VALID (self->next_ts))
GST_BUFFER_TIMESTAMP (outbuf) = self->next_ts;
if (self->next_off != GST_BUFFER_OFFSET_NONE) {
GST_BUFFER_OFFSET (outbuf) = self->next_off;
if (GST_BUFFER_OFFSET_END_IS_VALID (outbuf))
GST_BUFFER_OFFSET_END (outbuf) =
self->next_off + output_samples / channels;
} else {
/* We dropped no buffer, offset is valid, offset_end must be adjusted by diff */
if (GST_BUFFER_OFFSET_END_IS_VALID (outbuf))
GST_BUFFER_OFFSET_END (outbuf) -= diff / channels;
}
if (GST_BUFFER_DURATION_IS_VALID (outbuf))
GST_BUFFER_DURATION (outbuf) -=
gst_util_uint64_scale (diff, GST_SECOND, channels * rate);
GST_BUFFER_DATA (outbuf) +=
diff * (GST_AUDIO_FILTER (self)->format.width / 8);
GST_BUFFER_SIZE (outbuf) -=
diff * (GST_AUDIO_FILTER (self)->format.width / 8);
} else {
GstClockTime ts_latency =
gst_util_uint64_scale (self->latency, GST_SECOND, rate);
/* Normal buffer, adjust timestamp/offset/etc by latency */
if (GST_BUFFER_TIMESTAMP (outbuf) < ts_latency) {
GST_WARNING_OBJECT (self, "GST_BUFFER_TIMESTAMP (outbuf) < latency");
GST_BUFFER_TIMESTAMP (outbuf) = 0;
} else {
GST_BUFFER_TIMESTAMP (outbuf) -= ts_latency;
}
if (GST_BUFFER_OFFSET_IS_VALID (outbuf)) {
if (GST_BUFFER_OFFSET (outbuf) > self->latency) {
GST_BUFFER_OFFSET (outbuf) -= self->latency;
} else {
GST_WARNING_OBJECT (self, "GST_BUFFER_OFFSET (outbuf) < latency");
GST_BUFFER_OFFSET (outbuf) = 0;
}
}
if (GST_BUFFER_OFFSET_END_IS_VALID (outbuf)) {
if (GST_BUFFER_OFFSET_END (outbuf) > self->latency) {
GST_BUFFER_OFFSET_END (outbuf) -= self->latency;
} else {
GST_WARNING_OBJECT (self, "GST_BUFFER_OFFSET_END (outbuf) < latency");
GST_BUFFER_OFFSET_END (outbuf) = 0;
}
}
}
GST_DEBUG_OBJECT (self, "Pushing buffer of size %d with timestamp: %"
GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %lld,"
" offset_end: %lld, nsamples: %d", GST_BUFFER_SIZE (outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
GST_BUFFER_OFFSET_END (outbuf), output_samples / channels);
self->next_ts = GST_BUFFER_TIMESTAMP (outbuf) + GST_BUFFER_DURATION (outbuf);
self->next_off = GST_BUFFER_OFFSET_END (outbuf);
return GST_FLOW_OK;
}
static gboolean
audio_wsinclimit_start (GstBaseTransform * base)
{
GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (base);
gint channels = GST_AUDIO_FILTER (self)->format.channels;
/* Reset the residue if already existing */
if (channels && self->residue)
memset (self->residue, 0, channels *
self->kernel_length * sizeof (gdouble));
self->residue_length = 0;
self->next_ts = GST_CLOCK_TIME_NONE;
self->next_off = GST_BUFFER_OFFSET_NONE;
return TRUE;
}
static gboolean
audio_wsinclimit_query (GstPad * pad, GstQuery * query)
{
GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (gst_pad_get_parent (pad));
gboolean res = TRUE;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min, max;
gboolean live;
guint64 latency;
GstPad *peer;
gint rate = GST_AUDIO_FILTER (self)->format.rate;
if ((peer = gst_pad_get_peer (GST_BASE_TRANSFORM (self)->sinkpad))) {
if ((res = gst_pad_query (peer, query))) {
gst_query_parse_latency (query, &live, &min, &max);
GST_DEBUG_OBJECT (self, "Peer latency: min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min), GST_TIME_ARGS (max));
/* add our own latency */
latency =
(rate != 0) ? gst_util_uint64_scale (self->latency, GST_SECOND,
rate) : 0;
GST_DEBUG_OBJECT (self, "Our latency: %"
GST_TIME_FORMAT, GST_TIME_ARGS (latency));
min += latency;
if (max != GST_CLOCK_TIME_NONE)
max += latency;
GST_DEBUG_OBJECT (self, "Calculated total latency : min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min), GST_TIME_ARGS (max));
gst_query_set_latency (query, live, min, max);
}
gst_object_unref (peer);
}
break;
}
default:
res = gst_pad_query_default (pad, query);
break;
}
gst_object_unref (self);
return res;
}
static const GstQueryType *
audio_wsinclimit_query_type (GstPad * pad)
{
static const GstQueryType types[] = {
GST_QUERY_LATENCY,
0
};
return types;
}
static gboolean
audio_wsinclimit_event (GstBaseTransform * base, GstEvent * event)
{
GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (base);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
audio_wsinclimit_push_residue (self);
break;
default:
break;
}
return GST_BASE_TRANSFORM_CLASS (parent_class)->event (base, event);
return GST_AUDIO_FILTER_CLASS (parent_class)->setup (base, format);
}
static void
audio_wsinclimit_set_property (GObject * object, guint prop_id,
gst_audio_wsinclimit_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (object);
@ -730,43 +304,37 @@ audio_wsinclimit_set_property (GObject * object, guint prop_id,
case PROP_LENGTH:{
gint val;
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
val = g_value_get_int (value);
if (val % 2 == 0)
val++;
if (val != self->kernel_length) {
if (self->residue) {
audio_wsinclimit_push_residue (self);
g_free (self->residue);
self->residue = NULL;
}
gst_audio_fx_base_fir_filter_push_residue (GST_AUDIO_FX_BASE_FIR_FILTER
(self));
self->kernel_length = val;
self->latency = val / 2;
audio_wsinclimit_build_kernel (self);
gst_element_post_message (GST_ELEMENT (self),
gst_message_new_latency (GST_OBJECT (self)));
gst_audio_wsinclimit_build_kernel (self);
}
GST_BASE_TRANSFORM_UNLOCK (self);
GST_OBJECT_UNLOCK (self);
break;
}
case PROP_FREQUENCY:
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
self->cutoff = g_value_get_float (value);
audio_wsinclimit_build_kernel (self);
GST_BASE_TRANSFORM_UNLOCK (self);
gst_audio_wsinclimit_build_kernel (self);
GST_OBJECT_UNLOCK (self);
break;
case PROP_MODE:
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
self->mode = g_value_get_enum (value);
audio_wsinclimit_build_kernel (self);
GST_BASE_TRANSFORM_UNLOCK (self);
gst_audio_wsinclimit_build_kernel (self);
GST_OBJECT_UNLOCK (self);
break;
case PROP_WINDOW:
GST_BASE_TRANSFORM_LOCK (self);
GST_OBJECT_LOCK (self);
self->window = g_value_get_enum (value);
audio_wsinclimit_build_kernel (self);
GST_BASE_TRANSFORM_UNLOCK (self);
gst_audio_wsinclimit_build_kernel (self);
GST_OBJECT_UNLOCK (self);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -775,8 +343,8 @@ audio_wsinclimit_set_property (GObject * object, guint prop_id,
}
static void
audio_wsinclimit_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
gst_audio_wsinclimit_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (object);

25
gst/audiofx/audiowsinclimit.h
View file

@ -3,6 +3,7 @@
* GStreamer
* Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
* 2006 Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>
* 2007-2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
@ -33,10 +34,12 @@
#include <gst/gst.h>
#include <gst/audio/gstaudiofilter.h>
#include "audiofxbasefirfilter.h"
G_BEGIN_DECLS
#define GST_TYPE_AUDIO_WSINC_LIMIT \
(audio_wsinclimit_get_type())
(gst_audio_wsinclimit_get_type())
#define GST_AUDIO_WSINC_LIMIT(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_WSINC_LIMIT,GstAudioWSincLimit))
#define GST_AUDIO_WSINC_LIMIT_CLASS(klass) \
@ -49,38 +52,26 @@ G_BEGIN_DECLS
typedef struct _GstAudioWSincLimit GstAudioWSincLimit;
typedef struct _GstAudioWSincLimitClass GstAudioWSincLimitClass;
typedef void (*GstAudioWSincLimitProcessFunc) (GstAudioWSincLimit *, guint8 *, guint8 *, guint);
/**
* GstAudioWSincLimit:
*
* Opaque data structure.
*/
struct _GstAudioWSincLimit {
GstAudioFilter element;
GstAudioFXBaseFIRFilter parent;
/* < private > */
GstAudioWSincLimitProcessFunc process;
gint mode;
gint window;
gfloat cutoff;
gint kernel_length; /* length of the filter kernel */
gdouble *residue; /* buffer for left-over samples from previous buffer */
gdouble *kernel; /* filter kernel */
gboolean have_kernel;
gint residue_length;
guint64 latency;
GstClockTime next_ts;
guint64 next_off;
gint kernel_length;
};
struct _GstAudioWSincLimitClass {
GstAudioFilterClass parent_class;
GstAudioFXBaseFIRFilterClass parent;
};
GType audio_wsinclimit_get_type (void);
GType gst_audio_wsinclimit_get_type (void);
G_END_DECLS

14
tests/check/elements/audiowsincband.c
View file

@ -119,6 +119,7 @@ GST_START_TEST (test_32_bp_0hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i++)
in[i] = 1.0;
@ -180,6 +181,7 @@ GST_START_TEST (test_32_bp_11025hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i += 4) {
in[i] = 0.0;
@ -246,6 +248,7 @@ GST_START_TEST (test_32_bp_22050hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i += 2) {
in[i] = 1.0;
@ -309,6 +312,7 @@ GST_START_TEST (test_32_br_0hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i++)
in[i] = 1.0;
@ -370,6 +374,7 @@ GST_START_TEST (test_32_br_11025hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i += 4) {
@ -437,6 +442,7 @@ GST_START_TEST (test_32_br_22050hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i += 2) {
in[i] = 1.0;
@ -498,6 +504,7 @@ GST_START_TEST (test_32_small_buffer)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 44100 / 16.0, NULL);
inbuffer = gst_buffer_new_and_alloc (20 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 20; i++)
in[i] = 1.0;
@ -553,6 +560,7 @@ GST_START_TEST (test_64_bp_0hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i++)
in[i] = 1.0;
@ -614,6 +622,7 @@ GST_START_TEST (test_64_bp_11025hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i += 4) {
in[i] = 0.0;
@ -680,6 +689,7 @@ GST_START_TEST (test_64_bp_22050hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i += 2) {
in[i] = 1.0;
@ -743,6 +753,7 @@ GST_START_TEST (test_64_br_0hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i++)
in[i] = 1.0;
@ -804,6 +815,7 @@ GST_START_TEST (test_64_br_11025hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i += 4) {
@ -871,6 +883,7 @@ GST_START_TEST (test_64_br_22050hz)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 1000, NULL);
inbuffer = gst_buffer_new_and_alloc (1024 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 1024; i += 2) {
in[i] = 1.0;
@ -932,6 +945,7 @@ GST_START_TEST (test_64_small_buffer)
g_object_set (G_OBJECT (audiowsincband), "upper-frequency",
44100 / 4.0 + 44100 / 16.0, NULL);
inbuffer = gst_buffer_new_and_alloc (20 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 20; i++)
in[i] = 1.0;

10
tests/check/elements/audiowsinclimit.c
View file

@ -117,6 +117,7 @@ GST_START_TEST (test_32_lp_0hz)
/* cutoff = sampling rate / 4, data = 0 */
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 128; i++)
in[i] = 1.0;
@ -175,6 +176,7 @@ GST_START_TEST (test_32_lp_22050hz)
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 128; i += 2) {
in[i] = 1.0;
@ -235,6 +237,7 @@ GST_START_TEST (test_32_hp_0hz)
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 128; i++)
in[i] = 1.0;
@ -293,6 +296,7 @@ GST_START_TEST (test_32_hp_22050hz)
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 128; i += 2) {
in[i] = 1.0;
@ -352,6 +356,7 @@ GST_START_TEST (test_32_small_buffer)
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (20 * sizeof (gfloat));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gfloat *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 20; i++)
in[i] = 1.0;
@ -398,6 +403,7 @@ GST_START_TEST (test_64_lp_0hz)
/* cutoff = sampling rate / 4, data = 0 */
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 128; i++)
in[i] = 1.0;
@ -456,6 +462,7 @@ GST_START_TEST (test_64_lp_22050hz)
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 128; i += 2) {
in[i] = 1.0;
@ -516,6 +523,7 @@ GST_START_TEST (test_64_hp_0hz)
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 128; i++)
in[i] = 1.0;
@ -574,6 +582,7 @@ GST_START_TEST (test_64_hp_22050hz)
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 128; i += 2) {
in[i] = 1.0;
@ -633,6 +642,7 @@ GST_START_TEST (test_64_small_buffer)
g_object_set (G_OBJECT (audiowsinclimit), "cutoff", 44100 / 4.0, NULL);
inbuffer = gst_buffer_new_and_alloc (20 * sizeof (gdouble));
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
in = (gdouble *) GST_BUFFER_DATA (inbuffer);
for (i = 0; i < 20; i++)
in[i] = 1.0;