/* 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;
}
/* get notified of caps and plug in the correct process function */
static gboolean
gst_audio_fx_base_fir_filter_setup (GstAudioFilter * base,
const GstAudioInfo * info)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
g_mutex_lock (&self->lock);
if (self->buffer) {
gst_audio_fx_base_fir_filter_push_residue (self);
g_free (self->buffer);
self->buffer = NULL;
self->buffer_fill = 0;
self->buffer_length = 0;
self->start_ts = GST_CLOCK_TIME_NONE;
self->start_off = GST_BUFFER_OFFSET_NONE;
self->nsamples_out = 0;
self->nsamples_in = 0;
}
gst_audio_fx_base_fir_filter_select_process_function (self,
GST_AUDIO_INFO_FORMAT (info), GST_AUDIO_INFO_CHANNELS (info));
g_mutex_unlock (&self->lock);
return (self->process != NULL);
}
static gboolean
gst_audio_fx_base_fir_filter_transform_size (GstBaseTransform * base,
GstPadDirection direction, GstCaps * caps, gsize size, GstCaps * othercaps,
gsize * othersize)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
guint blocklen;
GstAudioInfo info;
gint bpf;
if (!self->fft || self->low_latency || direction == GST_PAD_SRC) {
*othersize = size;
return TRUE;
}
if (!gst_audio_info_from_caps (&info, caps))
return FALSE;
bpf = GST_AUDIO_INFO_BPF (&info);
size /= bpf;
blocklen = self->block_length - self->kernel_length + 1;
*othersize = ((size + blocklen - 1) / blocklen) * blocklen;
*othersize *= bpf;
return TRUE;
}
static gboolean
gst_audio_fx_base_fir_filter_transform_size (GstBaseTransform * base,
GstPadDirection direction, GstCaps * caps, guint size, GstCaps * othercaps,
guint * othersize)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
guint blocklen;
GstStructure *s;
gint width, channels;
if (!self->fft || self->low_latency || direction == GST_PAD_SRC) {
*othersize = size;
return TRUE;
}
s = gst_caps_get_structure (caps, 0);
if (!gst_structure_get_int (s, "width", &width) ||
!gst_structure_get_int (s, "channels", &channels))
return FALSE;
width /= 8;
size /= width * channels;
blocklen = self->block_length - self->kernel_length + 1;
*othersize = ((size + blocklen - 1) / blocklen) * blocklen;
*othersize *= width * channels;
return TRUE;
}
static void
gst_audio_fx_base_fir_filter_dispose (GObject * object)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (object);
g_free (self->buffer);
self->buffer = NULL;
self->buffer_length = 0;
g_free (self->kernel);
self->kernel = NULL;
gst_fft_f64_free (self->fft);
self->fft = NULL;
gst_fft_f64_free (self->ifft);
self->ifft = NULL;
g_free (self->frequency_response);
self->frequency_response = NULL;
g_free (self->fft_buffer);
self->fft_buffer = NULL;
G_OBJECT_CLASS (parent_class)->dispose (object);
}
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));
if (self->fft && !self->low_latency)
latency = self->block_length - self->kernel_length + 1;
else
latency = self->latency;
/* add our own latency */
latency = gst_util_uint64_scale_round (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 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 void
gst_audio_wsincband_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstAudioWSincBand *self = GST_AUDIO_WSINC_BAND (object);
g_return_if_fail (GST_IS_AUDIO_WSINC_BAND (self));
switch (prop_id) {
case PROP_LENGTH:{
gint val;
g_mutex_lock (self->lock);
val = g_value_get_int (value);
if (val % 2 == 0)
val++;
if (val != self->kernel_length) {
gst_audio_fx_base_fir_filter_push_residue (GST_AUDIO_FX_BASE_FIR_FILTER
(self));
self->kernel_length = val;
gst_audio_wsincband_build_kernel (self);
}
g_mutex_unlock (self->lock);
break;
}
case PROP_LOWER_FREQUENCY:
g_mutex_lock (self->lock);
self->lower_frequency = g_value_get_float (value);
gst_audio_wsincband_build_kernel (self);
g_mutex_unlock (self->lock);
break;
case PROP_UPPER_FREQUENCY:
g_mutex_lock (self->lock);
self->upper_frequency = g_value_get_float (value);
gst_audio_wsincband_build_kernel (self);
g_mutex_unlock (self->lock);
break;
case PROP_MODE:
g_mutex_lock (self->lock);
self->mode = g_value_get_enum (value);
gst_audio_wsincband_build_kernel (self);
g_mutex_unlock (self->lock);
break;
case PROP_WINDOW:
g_mutex_lock (self->lock);
self->window = g_value_get_enum (value);
gst_audio_wsincband_build_kernel (self);
g_mutex_unlock (self->lock);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
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_start (GstBaseTransform * base)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
self->buffer_fill = 0;
g_free (self->buffer);
self->buffer = NULL;
self->start_ts = GST_CLOCK_TIME_NONE;
self->start_off = GST_BUFFER_OFFSET_NONE;
self->nsamples_out = 0;
self->nsamples_in = 0;
return TRUE;
}
static void
gst_audio_fx_base_fir_filter_finalize (GObject * object)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (object);
g_free (self->buffer);
g_free (self->kernel);
gst_fft_f64_free (self->fft);
gst_fft_f64_free (self->ifft);
g_free (self->frequency_response);
g_free (self->fft_buffer);
g_mutex_clear (&self->lock);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
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);
}
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_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (object);
switch (prop_id) {
case PROP_LOW_LATENCY:
g_value_set_boolean (value, self->low_latency);
break;
case PROP_DRAIN_ON_CHANGES:
g_value_set_boolean (value, self->drain_on_changes);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_audio_fx_base_fir_filter_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (object);
switch (prop_id) {
case PROP_LOW_LATENCY:{
gboolean low_latency;
if (GST_STATE (self) >= GST_STATE_PAUSED) {
g_warning ("Changing the \"low-latency\" property "
"is only allowed in states < PAUSED");
return;
}
g_mutex_lock (&self->lock);
low_latency = g_value_get_boolean (value);
if (self->low_latency != low_latency) {
self->low_latency = low_latency;
gst_audio_fx_base_fir_filter_calculate_frequency_response (self);
gst_audio_fx_base_fir_filter_select_process_function (self,
GST_AUDIO_FILTER_FORMAT (self), GST_AUDIO_FILTER_CHANNELS (self));
}
g_mutex_unlock (&self->lock);
break;
}
case PROP_DRAIN_ON_CHANGES:{
g_mutex_lock (&self->lock);
self->drain_on_changes = g_value_get_boolean (value);
g_mutex_unlock (&self->lock);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_audio_fir_filter_update_kernel (GstAudioFIRFilter * self, GValueArray * va)
{
gdouble *kernel;
guint i;
if (va) {
if (self->kernel)
g_value_array_free (self->kernel);
self->kernel = va;
}
kernel = g_new (gdouble, self->kernel->n_values);
for (i = 0; i < self->kernel->n_values; i++) {
GValue *v = g_value_array_get_nth (self->kernel, i);
kernel[i] = g_value_get_double (v);
}
gst_audio_fx_base_fir_filter_set_kernel (GST_AUDIO_FX_BASE_FIR_FILTER (self),
kernel, self->kernel->n_values, self->latency);
}
/* 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);
if (self->buffer) {
gst_audio_fx_base_fir_filter_push_residue (self);
g_free (self->buffer);
self->buffer = NULL;
self->buffer_fill = 0;
self->buffer_length = 0;
self->start_ts = GST_CLOCK_TIME_NONE;
self->start_off = GST_BUFFER_OFFSET_NONE;
self->nsamples_out = 0;
self->nsamples_in = 0;
}
gst_audio_fx_base_fir_filter_select_process_function (self, format->width,
format->channels);
return (self->process != NULL);
}
static void
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;
if (GST_AUDIO_FILTER (self)->format.rate == 0) {
GST_DEBUG ("rate not set yet");
return;
}
if (GST_AUDIO_FILTER (self)->format.channels == 0) {
GST_DEBUG ("channels not set yet");
return;
}
/* Clamp frequencies */
self->lower_frequency =
CLAMP (self->lower_frequency, 0.0,
GST_AUDIO_FILTER (self)->format.rate / 2);
self->upper_frequency =
CLAMP (self->upper_frequency, 0.0,
GST_AUDIO_FILTER (self)->format.rate / 2);
if (self->lower_frequency > self->upper_frequency) {
gint tmp = self->lower_frequency;
self->lower_frequency = self->upper_frequency;
self->upper_frequency = tmp;
}
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,
(self->mode == MODE_BAND_PASS) ? "band-pass" : "band-reject");
/* fill the lp kernel */
w = 2 * M_PI * (self->lower_frequency / GST_AUDIO_FILTER (self)->format.rate);
kernel_lp = g_new (gdouble, len);
for (i = 0; i < len; ++i) {
if (i == len / 2)
kernel_lp[i] = w;
else
kernel_lp[i] = sin (w * (i - len / 2))
/ (i - len / 2);
/* Windowing */
if (self->window == WINDOW_HAMMING)
kernel_lp[i] *= (0.54 - 0.46 * cos (2 * M_PI * i / len));
else
kernel_lp[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 */
sum = 0.0;
for (i = 0; i < len; ++i)
sum += kernel_lp[i];
for (i = 0; i < len; ++i)
kernel_lp[i] /= sum;
/* fill the hp kernel */
w = 2 * M_PI * (self->upper_frequency / GST_AUDIO_FILTER (self)->format.rate);
kernel_hp = g_new (gdouble, len);
for (i = 0; i < len; ++i) {
if (i == len / 2)
kernel_hp[i] = w;
else
kernel_hp[i] = sin (w * (i - len / 2))
/ (i - len / 2);
/* Windowing */
if (self->window == WINDOW_HAMMING)
kernel_hp[i] *= (0.54 - 0.46 * cos (2 * M_PI * i / len));
else
kernel_hp[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 */
sum = 0.0;
for (i = 0; i < len; ++i)
sum += kernel_hp[i];
for (i = 0; i < len; ++i)
kernel_hp[i] /= sum;
/* do spectral inversion to go from lowpass to highpass */
for (i = 0; i < len; ++i)
kernel_hp[i] = -kernel_hp[i];
kernel_hp[len / 2] += 1;
/* combine the two kernels */
kernel = g_new (gdouble, len);
for (i = 0; i < len; ++i)
kernel[i] = kernel_lp[i] + kernel_hp[i];
/* free the helper kernels */
g_free (kernel_lp);
g_free (kernel_hp);
/* do spectral inversion to go from bandreject to bandpass
* if specified */
if (self->mode == MODE_BAND_PASS) {
for (i = 0; i < len; ++i)
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);
}
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, expected_timestamp;
gint channels = GST_AUDIO_FILTER_CHANNELS (self);
gint rate = GST_AUDIO_FILTER_RATE (self);
gint bps = GST_AUDIO_FILTER_BPS (self);
GstMapInfo inmap, outmap;
guint input_samples;
guint output_samples;
guint generated_samples;
guint64 output_offset;
gint64 diff = 0;
GstClockTime stream_time;
timestamp = GST_BUFFER_TIMESTAMP (outbuf);
if (!GST_CLOCK_TIME_IS_VALID (timestamp)
&& !GST_CLOCK_TIME_IS_VALID (self->start_ts)) {
GST_ERROR_OBJECT (self, "Invalid timestamp");
return GST_FLOW_ERROR;
}
g_mutex_lock (&self->lock);
stream_time =
gst_segment_to_stream_time (&base->segment, GST_FORMAT_TIME, timestamp);
GST_DEBUG_OBJECT (self, "sync to %" GST_TIME_FORMAT,
GST_TIME_ARGS (timestamp));
if (GST_CLOCK_TIME_IS_VALID (stream_time))
gst_object_sync_values (GST_OBJECT (self), stream_time);
g_return_val_if_fail (self->kernel != NULL, GST_FLOW_ERROR);
g_return_val_if_fail (channels != 0, GST_FLOW_ERROR);
if (GST_CLOCK_TIME_IS_VALID (self->start_ts))
expected_timestamp =
self->start_ts + gst_util_uint64_scale_int (self->nsamples_in,
GST_SECOND, rate);
else
expected_timestamp = GST_CLOCK_TIME_NONE;
/* Reset the residue if already existing on discont buffers */
if (GST_BUFFER_IS_DISCONT (inbuf)
|| (GST_CLOCK_TIME_IS_VALID (expected_timestamp)
&& (ABS (GST_CLOCK_DIFF (timestamp,
expected_timestamp) > 5 * GST_MSECOND)))) {
GST_DEBUG_OBJECT (self, "Discontinuity detected - flushing");
if (GST_CLOCK_TIME_IS_VALID (expected_timestamp))
gst_audio_fx_base_fir_filter_push_residue (self);
self->buffer_fill = 0;
g_free (self->buffer);
self->buffer = NULL;
self->start_ts = timestamp;
self->start_off = GST_BUFFER_OFFSET (inbuf);
self->nsamples_out = 0;
self->nsamples_in = 0;
} else if (!GST_CLOCK_TIME_IS_VALID (self->start_ts)) {
self->start_ts = timestamp;
self->start_off = GST_BUFFER_OFFSET (inbuf);
}
gst_buffer_map (inbuf, &inmap, GST_MAP_READ);
gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
input_samples = (inmap.size / bps) / channels;
output_samples = (outmap.size / bps) / channels;
self->nsamples_in += input_samples;
generated_samples =
self->process (self, inmap.data, outmap.data, input_samples);
gst_buffer_unmap (inbuf, &inmap);
gst_buffer_unmap (outbuf, &outmap);
g_assert (generated_samples <= output_samples);
self->nsamples_out += generated_samples;
if (generated_samples == 0)
goto no_samples;
/* Calculate the number of samples we can push out now without outputting
* latency zeros in the beginning */
diff = ((gint64) self->nsamples_out) - ((gint64) self->latency);
if (diff < 0)
goto no_samples;
if (diff < generated_samples) {
gint64 tmp = diff;
diff = generated_samples - diff;
generated_samples = tmp;
} else {
diff = 0;
}
gst_buffer_resize (outbuf, diff * bps * channels,
generated_samples * bps * channels);
output_offset = self->nsamples_out - self->latency - generated_samples;
GST_BUFFER_TIMESTAMP (outbuf) =
self->start_ts + gst_util_uint64_scale_int (output_offset, GST_SECOND,
rate);
GST_BUFFER_DURATION (outbuf) =
gst_util_uint64_scale_int (output_samples, GST_SECOND, rate);
if (self->start_off != GST_BUFFER_OFFSET_NONE) {
GST_BUFFER_OFFSET (outbuf) = self->start_off + output_offset;
GST_BUFFER_OFFSET_END (outbuf) =
GST_BUFFER_OFFSET (outbuf) + generated_samples;
} else {
GST_BUFFER_OFFSET (outbuf) = GST_BUFFER_OFFSET_NONE;
GST_BUFFER_OFFSET_END (outbuf) = GST_BUFFER_OFFSET_NONE;
}
g_mutex_unlock (&self->lock);
GST_DEBUG_OBJECT (self,
"Pushing buffer of size %" G_GSIZE_FORMAT " with timestamp: %"
GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %"
G_GUINT64_FORMAT ", offset_end: %" G_GUINT64_FORMAT ", nsamples_out: %d",
gst_buffer_get_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), generated_samples);
return GST_FLOW_OK;
no_samples:
{
g_mutex_unlock (&self->lock);
return GST_BASE_TRANSFORM_FLOW_DROPPED;
}
}
static void
gst_audio_wsincband_build_kernel (GstAudioWSincBand * self,
const GstAudioInfo * info)
{
gint i = 0;
gdouble sum = 0.0;
gint len = 0;
gdouble *kernel_lp, *kernel_hp;
gdouble w;
gdouble *kernel;
gint rate, channels;
len = self->kernel_length;
if (info) {
rate = GST_AUDIO_INFO_RATE (info);
channels = GST_AUDIO_INFO_CHANNELS (info);
} else {
rate = GST_AUDIO_FILTER_RATE (self);
channels = GST_AUDIO_FILTER_CHANNELS (self);
}
if (rate == 0) {
GST_DEBUG ("rate not set yet");
return;
}
if (channels == 0) {
GST_DEBUG ("channels not set yet");
return;
}
/* Clamp frequencies */
self->lower_frequency = CLAMP (self->lower_frequency, 0.0, rate / 2);
self->upper_frequency = CLAMP (self->upper_frequency, 0.0, rate / 2);
if (self->lower_frequency > self->upper_frequency) {
gint tmp = self->lower_frequency;
self->lower_frequency = self->upper_frequency;
self->upper_frequency = tmp;
}
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,
(self->mode == MODE_BAND_PASS) ? "band-pass" : "band-reject");
/* fill the lp kernel */
w = 2 * G_PI * (self->lower_frequency / rate);
kernel_lp = g_new (gdouble, len);
for (i = 0; i < len; ++i) {
if (i == (len - 1) / 2.0)
kernel_lp[i] = w;
else
kernel_lp[i] = sin (w * (i - (len - 1) / 2.0)) / (i - (len - 1) / 2.0);
/* windowing */
switch (self->window) {
case WINDOW_HAMMING:
kernel_lp[i] *= (0.54 - 0.46 * cos (2 * G_PI * i / (len - 1)));
break;
case WINDOW_BLACKMAN:
kernel_lp[i] *= (0.42 - 0.5 * cos (2 * G_PI * i / (len - 1)) +
0.08 * cos (4 * G_PI * i / (len - 1)));
break;
case WINDOW_GAUSSIAN:
kernel_lp[i] *= exp (-0.5 * POW2 (3.0 / len * (2 * i - (len - 1))));
break;
case WINDOW_COSINE:
kernel_lp[i] *= cos (G_PI * i / (len - 1) - G_PI / 2);
break;
case WINDOW_HANN:
kernel_lp[i] *= 0.5 * (1 - cos (2 * G_PI * i / (len - 1)));
break;
}
}
/* normalize for unity gain at DC */
sum = 0.0;
for (i = 0; i < len; ++i)
sum += kernel_lp[i];
for (i = 0; i < len; ++i)
kernel_lp[i] /= sum;
/* fill the hp kernel */
w = 2 * G_PI * (self->upper_frequency / rate);
kernel_hp = g_new (gdouble, len);
for (i = 0; i < len; ++i) {
if (i == (len - 1) / 2.0)
kernel_hp[i] = w;
else
kernel_hp[i] = sin (w * (i - (len - 1) / 2.0)) / (i - (len - 1) / 2.0);
/* Windowing */
switch (self->window) {
case WINDOW_HAMMING:
kernel_hp[i] *= (0.54 - 0.46 * cos (2 * G_PI * i / (len - 1)));
break;
case WINDOW_BLACKMAN:
kernel_hp[i] *= (0.42 - 0.5 * cos (2 * G_PI * i / (len - 1)) +
0.08 * cos (4 * G_PI * i / (len - 1)));
break;
case WINDOW_GAUSSIAN:
kernel_hp[i] *= exp (-0.5 * POW2 (3.0 / len * (2 * i - (len - 1))));
break;
case WINDOW_COSINE:
kernel_hp[i] *= cos (G_PI * i / (len - 1) - G_PI / 2);
break;
case WINDOW_HANN:
kernel_hp[i] *= 0.5 * (1 - cos (2 * G_PI * i / (len - 1)));
break;
}
}
/* normalize for unity gain at DC */
sum = 0.0;
for (i = 0; i < len; ++i)
sum += kernel_hp[i];
for (i = 0; i < len; ++i)
kernel_hp[i] /= sum;
/* do spectral inversion to go from lowpass to highpass */
for (i = 0; i < len; ++i)
kernel_hp[i] = -kernel_hp[i];
if (len % 2 == 1) {
kernel_hp[(len - 1) / 2] += 1.0;
} else {
kernel_hp[len / 2 - 1] += 0.5;
kernel_hp[len / 2] += 0.5;
}
/* combine the two kernels */
kernel = g_new (gdouble, len);
for (i = 0; i < len; ++i)
kernel[i] = kernel_lp[i] + kernel_hp[i];
/* free the helper kernels */
g_free (kernel_lp);
g_free (kernel_hp);
/* do spectral inversion to go from bandreject to bandpass
* if specified */
if (self->mode == MODE_BAND_PASS) {
for (i = 0; i < len; ++i)
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, info);
}
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 void
gst_audio_wsinclimit_build_kernel (GstAudioWSincLimit * self,
const GstAudioInfo * info)
{
gint i = 0;
gdouble sum = 0.0;
gint len = 0;
gdouble w;
gdouble *kernel = NULL;
gint rate, channels;
len = self->kernel_length;
if (info) {
rate = GST_AUDIO_INFO_RATE (info);
channels = GST_AUDIO_INFO_CHANNELS (info);
} else {
rate = GST_AUDIO_FILTER_RATE (self);
channels = GST_AUDIO_FILTER_CHANNELS (self);
}
if (rate == 0) {
GST_DEBUG ("rate not set yet");
return;
}
if (channels == 0) {
GST_DEBUG ("channels not set yet");
return;
}
/* Clamp cutoff frequency between 0 and the nyquist frequency */
self->cutoff = CLAMP (self->cutoff, 0.0, rate / 2);
GST_DEBUG ("gst_audio_wsinclimit_: initializing filter kernel of length %d "
"with cutoff %.2lf Hz "
"for mode %s",
len, self->cutoff,
(self->mode == MODE_LOW_PASS) ? "low-pass" : "high-pass");
/* fill the kernel */
w = 2 * G_PI * (self->cutoff / rate);
kernel = g_new (gdouble, len);
for (i = 0; i < len; ++i) {
if (i == (len - 1) / 2.0)
kernel[i] = w;
else
kernel[i] = sin (w * (i - (len - 1) / 2)) / (i - (len - 1) / 2.0);
/* windowing */
switch (self->window) {
case WINDOW_HAMMING:
kernel[i] *= (0.54 - 0.46 * cos (2 * G_PI * i / (len - 1)));
break;
case WINDOW_BLACKMAN:
kernel[i] *= (0.42 - 0.5 * cos (2 * G_PI * i / (len - 1)) +
0.08 * cos (4 * G_PI * i / (len - 1)));
break;
case WINDOW_GAUSSIAN:
kernel[i] *= exp (-0.5 * POW2 (3.0 / len * (2 * i - (len - 1))));
break;
case WINDOW_COSINE:
kernel[i] *= cos (G_PI * i / (len - 1) - G_PI / 2);
break;
case WINDOW_HANN:
kernel[i] *= 0.5 * (1 - cos (2 * G_PI * i / (len - 1)));
break;
}
}
/* normalize for unity gain at DC */
for (i = 0; i < len; ++i)
sum += kernel[i];
for (i = 0; i < len; ++i)
kernel[i] /= sum;
/* convert to highpass if specified */
if (self->mode == MODE_HIGH_PASS) {
for (i = 0; i < len; ++i)
kernel[i] = -kernel[i];
if (len % 2 == 1) {
kernel[(len - 1) / 2] += 1.0;
} else {
kernel[len / 2 - 1] += 0.5;
kernel[len / 2] += 0.5;
}
}
gst_audio_fx_base_fir_filter_set_kernel (GST_AUDIO_FX_BASE_FIR_FILTER (self),
kernel, self->kernel_length, (len - 1) / 2, info);
}
