1 /* -*- c-basic-offset: 2 -*-
2 *
3 * GStreamer
4 * Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
5 * 2006 Dreamlab Technologies Ltd. <mathis.hofer@dreamlab.net>
6 * 2007-2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
22 *
23 */
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include <string.h>
30 #include <math.h>
31 #include <gst/gst.h>
32 #include <gst/audio/gstaudiofilter.h>
33
34 #include "audiofxbasefirfilter.h"
35
36 #define GST_CAT_DEFAULT gst_audio_fx_base_fir_filter_debug
37 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
38
39 #define ALLOWED_CAPS \
40 "audio/x-raw, " \
41 " format=(string){"GST_AUDIO_NE(F32)","GST_AUDIO_NE(F64)"}, " \
42 " rate = (int) [ 1, MAX ], " \
43 " channels = (int) [ 1, MAX ], " \
44 " layout=(string) interleaved"
45
46 /* Switch from time-domain to FFT convolution for kernels >= this */
47 #define FFT_THRESHOLD 32
48
49 enum
50 {
51 PROP_0 = 0,
52 PROP_LOW_LATENCY,
53 PROP_DRAIN_ON_CHANGES
54 };
55
56 #define DEFAULT_LOW_LATENCY FALSE
57 #define DEFAULT_DRAIN_ON_CHANGES TRUE
58
59 #define gst_audio_fx_base_fir_filter_parent_class parent_class
60 G_DEFINE_TYPE (GstAudioFXBaseFIRFilter, gst_audio_fx_base_fir_filter,
61 GST_TYPE_AUDIO_FILTER);
62
63 static GstFlowReturn gst_audio_fx_base_fir_filter_transform (GstBaseTransform *
64 base, GstBuffer * inbuf, GstBuffer * outbuf);
65 static gboolean gst_audio_fx_base_fir_filter_start (GstBaseTransform * base);
66 static gboolean gst_audio_fx_base_fir_filter_stop (GstBaseTransform * base);
67 static gboolean gst_audio_fx_base_fir_filter_sink_event (GstBaseTransform *
68 base, GstEvent * event);
69 static gboolean gst_audio_fx_base_fir_filter_transform_size (GstBaseTransform *
70 base, GstPadDirection direction, GstCaps * caps, gsize size,
71 GstCaps * othercaps, gsize * othersize);
72 static gboolean gst_audio_fx_base_fir_filter_setup (GstAudioFilter * base,
73 const GstAudioInfo * info);
74
75 static gboolean gst_audio_fx_base_fir_filter_query (GstBaseTransform * trans,
76 GstPadDirection direction, GstQuery * quer);
77
78 /*
79 * The code below calculates the linear convolution:
80 *
81 * y[t] = \sum_{u=0}^{M-1} x[t - u] * h[u]
82 *
83 * where y is the output, x is the input, M is the length
84 * of the filter kernel and h is the filter kernel. For x
85 * holds: x[t] == 0 \forall t < 0.
86 *
87 * The runtime complexity of this is O (M) per sample.
88 *
89 */
90 #define DEFINE_PROCESS_FUNC(width,ctype) \
91 static guint \
92 process_##width (GstAudioFXBaseFIRFilter * self, const g##ctype * src, g##ctype * dst, guint input_samples) \
93 { \
94 gint channels = GST_AUDIO_FILTER_CHANNELS (self); \
95 TIME_DOMAIN_CONVOLUTION_BODY (channels); \
96 }
97
98 #define DEFINE_PROCESS_FUNC_FIXED_CHANNELS(width,channels,ctype) \
99 static guint \
100 process_##channels##_##width (GstAudioFXBaseFIRFilter * self, const g##ctype * src, g##ctype * dst, guint input_samples) \
101 { \
102 TIME_DOMAIN_CONVOLUTION_BODY (channels); \
103 }
104
105 #define TIME_DOMAIN_CONVOLUTION_BODY(channels) G_STMT_START { \
106 gint kernel_length = self->kernel_length; \
107 gint i, j, k, l; \
108 gint res_start; \
109 gint from_input; \
110 gint off; \
111 gdouble *buffer = self->buffer; \
112 gdouble *kernel = self->kernel; \
113 \
114 if (!buffer) { \
115 self->buffer_length = kernel_length * channels; \
116 self->buffer = buffer = g_new0 (gdouble, self->buffer_length); \
117 } \
118 \
119 input_samples *= channels; \
120 /* convolution */ \
121 for (i = 0; i < input_samples; i++) { \
122 dst[i] = 0.0; \
123 k = i % channels; \
124 l = i / channels; \
125 from_input = MIN (l, kernel_length-1); \
126 off = l * channels + k; \
127 for (j = 0; j <= from_input; j++) { \
128 dst[i] += src[off] * kernel[j]; \
129 off -= channels; \
130 } \
131 /* j == from_input && off == (l - j) * channels + k */ \
132 off += kernel_length * channels; \
133 for (; j < kernel_length; j++) { \
134 dst[i] += buffer[off] * kernel[j]; \
135 off -= channels; \
136 } \
137 } \
138 \
139 /* copy the tail of the current input buffer to the residue, while \
140 * keeping parts of the residue if the input buffer is smaller than \
141 * the kernel length */ \
142 /* from now on take kernel length as length over all channels */ \
143 kernel_length *= channels; \
144 if (input_samples < kernel_length) \
145 res_start = kernel_length - input_samples; \
146 else \
147 res_start = 0; \
148 \
149 for (i = 0; i < res_start; i++) \
150 buffer[i] = buffer[i + input_samples]; \
151 /* i == res_start */ \
152 for (; i < kernel_length; i++) \
153 buffer[i] = src[input_samples - kernel_length + i]; \
154 \
155 self->buffer_fill += kernel_length - res_start; \
156 if (self->buffer_fill > kernel_length) \
157 self->buffer_fill = kernel_length; \
158 \
159 return input_samples / channels; \
160 } G_STMT_END
161
162 DEFINE_PROCESS_FUNC (32, float);
163 DEFINE_PROCESS_FUNC (64, double);
164
165 DEFINE_PROCESS_FUNC_FIXED_CHANNELS (32, 1, float);
166 DEFINE_PROCESS_FUNC_FIXED_CHANNELS (64, 1, double);
167
168 DEFINE_PROCESS_FUNC_FIXED_CHANNELS (32, 2, float);
169 DEFINE_PROCESS_FUNC_FIXED_CHANNELS (64, 2, double);
170
171 #undef TIME_DOMAIN_CONVOLUTION_BODY
172 #undef DEFINE_PROCESS_FUNC
173 #undef DEFINE_PROCESS_FUNC_FIXED_CHANNELS
174
175 /* This implements FFT convolution and uses the overlap-save algorithm.
176 * See http://cnx.org/content/m12022/latest/ or your favorite
177 * digital signal processing book for details.
178 *
179 * In every pass the following is calculated:
180 *
181 * y = IFFT (FFT(x) * FFT(h))
182 *
183 * where y is the output in the time domain, x the
184 * input and h the filter kernel. * is the multiplication
185 * of complex numbers.
186 *
187 * Due to the circular convolution theorem this
188 * gives in the time domain:
189 *
190 * y[t] = \sum_{u=0}^{M-1} x[t - u] * h[u]
191 *
192 * where y is the output, M is the kernel length,
193 * x the periodically extended[0] input and h the
194 * filter kernel.
195 *
196 * ([0] Periodically extended means: )
197 * ( x[t] = x[t+kN] \forall k \in Z )
198 * ( where N is the length of x )
199 *
200 * This means:
201 * - Obviously x and h need to be of the same size for the FFT
202 * - The first M-1 output values are useless because they're
203 * built from 1 up to M-1 values from the end of the input
204 * (circular convolusion!).
205 * - The last M-1 input values are only used for 1 up to M-1
206 * output values, i.e. they need to be used again in the
207 * next pass for the first M-1 input values.
208 *
209 * => The first pass needs M-1 zeroes at the beginning of the
210 * input and the last M-1 input values of every pass need to
211 * be used as the first M-1 input values of the next pass.
212 *
213 * => x must be larger than h to give a useful number of output
214 * samples and h needs to be padded by zeroes at the end to give
215 * it virtually the same size as x (by M we denote the number of
216 * non-padding samples of h). If len(x)==len(h)==M only 1 output
217 * sample would be calculated per pass, len(x)==2*len(h) would
218 * give M+1 output samples, etc. Usually a factor between 4 and 8
219 * gives a low number of operations per output samples (see website
220 * given above).
221 *
222 * Overall this gives a runtime complexity per sample of
223 *
224 * ( N log N )
225 * O ( --------- ) compared to O (M) for the direct calculation.
226 * ( N - M + 1 )
227 */
228 #define DEFINE_FFT_PROCESS_FUNC(width,ctype) \
229 static guint \
230 process_fft_##width (GstAudioFXBaseFIRFilter * self, const g##ctype * src, \
231 g##ctype * dst, guint input_samples) \
232 { \
233 gint channels = GST_AUDIO_FILTER_CHANNELS (self); \
234 FFT_CONVOLUTION_BODY (channels); \
235 }
236
237 #define DEFINE_FFT_PROCESS_FUNC_FIXED_CHANNELS(width,channels,ctype) \
238 static guint \
239 process_fft_##channels##_##width (GstAudioFXBaseFIRFilter * self, const g##ctype * src, \
240 g##ctype * dst, guint input_samples) \
241 { \
242 FFT_CONVOLUTION_BODY (channels); \
243 }
244
245 #define FFT_CONVOLUTION_BODY(channels) G_STMT_START { \
246 gint i, j; \
247 guint pass; \
248 guint kernel_length = self->kernel_length; \
249 guint block_length = self->block_length; \
250 guint buffer_length = self->buffer_length; \
251 guint real_buffer_length = buffer_length + kernel_length - 1; \
252 guint buffer_fill = self->buffer_fill; \
253 GstFFTF64 *fft = self->fft; \
254 GstFFTF64 *ifft = self->ifft; \
255 GstFFTF64Complex *frequency_response = self->frequency_response; \
256 GstFFTF64Complex *fft_buffer = self->fft_buffer; \
257 guint frequency_response_length = self->frequency_response_length; \
258 gdouble *buffer = self->buffer; \
259 guint generated = 0; \
260 gdouble re, im; \
261 \
262 if (!fft_buffer) \
263 self->fft_buffer = fft_buffer = \
264 g_new (GstFFTF64Complex, frequency_response_length); \
265 \
266 /* Buffer contains the time domain samples of input data for one chunk \
267 * plus some more space for the inverse FFT below. \
268 * \
269 * The samples are put at offset kernel_length, the inverse FFT \
270 * overwrites everthing from offset 0 to length-kernel_length+1, keeping \
271 * the last kernel_length-1 samples for copying to the next processing \
272 * step. \
273 */ \
274 if (!buffer) { \
275 self->buffer_length = buffer_length = block_length; \
276 real_buffer_length = buffer_length + kernel_length - 1; \
277 \
278 self->buffer = buffer = g_new0 (gdouble, real_buffer_length * channels); \
279 \
280 /* Beginning has kernel_length-1 zeroes at the beginning */ \
281 self->buffer_fill = buffer_fill = kernel_length - 1; \
282 } \
283 \
284 g_assert (self->buffer_length == block_length); \
285 \
286 while (input_samples) { \
287 pass = MIN (buffer_length - buffer_fill, input_samples); \
288 \
289 /* Deinterleave channels */ \
290 for (i = 0; i < pass; i++) { \
291 for (j = 0; j < channels; j++) { \
292 buffer[real_buffer_length * j + buffer_fill + kernel_length - 1 + i] = \
293 src[i * channels + j]; \
294 } \
295 } \
296 buffer_fill += pass; \
297 src += channels * pass; \
298 input_samples -= pass; \
299 \
300 /* If we don't have a complete buffer go out */ \
301 if (buffer_fill < buffer_length) \
302 break; \
303 \
304 for (j = 0; j < channels; j++) { \
305 /* Calculate FFT of input block */ \
306 gst_fft_f64_fft (fft, \
307 buffer + real_buffer_length * j + kernel_length - 1, fft_buffer); \
308 \
309 /* Complex multiplication of input and filter spectrum */ \
310 for (i = 0; i < frequency_response_length; i++) { \
311 re = fft_buffer[i].r; \
312 im = fft_buffer[i].i; \
313 \
314 fft_buffer[i].r = \
315 re * frequency_response[i].r - \
316 im * frequency_response[i].i; \
317 fft_buffer[i].i = \
318 re * frequency_response[i].i + \
319 im * frequency_response[i].r; \
320 } \
321 \
322 /* Calculate inverse FFT of the result */ \
323 gst_fft_f64_inverse_fft (ifft, fft_buffer, \
324 buffer + real_buffer_length * j); \
325 \
326 /* Copy all except the first kernel_length-1 samples to the output */ \
327 for (i = 0; i < buffer_length - kernel_length + 1; i++) { \
328 dst[i * channels + j] = \
329 buffer[real_buffer_length * j + kernel_length - 1 + i]; \
330 } \
331 \
332 /* Copy the last kernel_length-1 samples to the beginning for the next block */ \
333 for (i = 0; i < kernel_length - 1; i++) { \
334 buffer[real_buffer_length * j + kernel_length - 1 + i] = \
335 buffer[real_buffer_length * j + buffer_length + i]; \
336 } \
337 } \
338 \
339 generated += buffer_length - kernel_length + 1; \
340 dst += channels * (buffer_length - kernel_length + 1); \
341 \
342 /* The the first kernel_length-1 samples are there already */ \
343 buffer_fill = kernel_length - 1; \
344 } \
345 \
346 /* Write back cached buffer_fill value */ \
347 self->buffer_fill = buffer_fill; \
348 \
349 return generated; \
350 } G_STMT_END
351
352 DEFINE_FFT_PROCESS_FUNC (32, float);
353 DEFINE_FFT_PROCESS_FUNC (64, double);
354
355 DEFINE_FFT_PROCESS_FUNC_FIXED_CHANNELS (32, 1, float);
356 DEFINE_FFT_PROCESS_FUNC_FIXED_CHANNELS (64, 1, double);
357
358 DEFINE_FFT_PROCESS_FUNC_FIXED_CHANNELS (32, 2, float);
359 DEFINE_FFT_PROCESS_FUNC_FIXED_CHANNELS (64, 2, double);
360
361 #undef FFT_CONVOLUTION_BODY
362 #undef DEFINE_FFT_PROCESS_FUNC
363 #undef DEFINE_FFT_PROCESS_FUNC_FIXED_CHANNELS
364
365 /* Element class */
366 static void
gst_audio_fx_base_fir_filter_calculate_frequency_response(GstAudioFXBaseFIRFilter * self)367 gst_audio_fx_base_fir_filter_calculate_frequency_response
368 (GstAudioFXBaseFIRFilter * self)
369 {
370 gst_fft_f64_free (self->fft);
371 self->fft = NULL;
372 gst_fft_f64_free (self->ifft);
373 self->ifft = NULL;
374 g_free (self->frequency_response);
375 self->frequency_response_length = 0;
376 g_free (self->fft_buffer);
377 self->fft_buffer = NULL;
378
379 if (self->kernel && self->kernel_length >= FFT_THRESHOLD
380 && !self->low_latency) {
381 guint block_length, i;
382 gdouble *kernel_tmp, *kernel = self->kernel;
383
384 /* We process 4 * kernel_length samples per pass in FFT mode */
385 block_length = 4 * self->kernel_length;
386 block_length = gst_fft_next_fast_length (block_length);
387 self->block_length = block_length;
388
389 kernel_tmp = g_new0 (gdouble, block_length);
390 memcpy (kernel_tmp, kernel, self->kernel_length * sizeof (gdouble));
391
392 self->fft = gst_fft_f64_new (block_length, FALSE);
393 self->ifft = gst_fft_f64_new (block_length, TRUE);
394 self->frequency_response_length = block_length / 2 + 1;
395 self->frequency_response =
396 g_new (GstFFTF64Complex, self->frequency_response_length);
397 gst_fft_f64_fft (self->fft, kernel_tmp, self->frequency_response);
398 g_free (kernel_tmp);
399
400 /* Normalize to make sure IFFT(FFT(x)) == x */
401 for (i = 0; i < self->frequency_response_length; i++) {
402 self->frequency_response[i].r /= block_length;
403 self->frequency_response[i].i /= block_length;
404 }
405 }
406 }
407
408 /* Must be called with base transform lock! */
409 static void
gst_audio_fx_base_fir_filter_select_process_function(GstAudioFXBaseFIRFilter * self,GstAudioFormat format,gint channels)410 gst_audio_fx_base_fir_filter_select_process_function (GstAudioFXBaseFIRFilter *
411 self, GstAudioFormat format, gint channels)
412 {
413 switch (format) {
414 case GST_AUDIO_FORMAT_F32:
415 if (self->fft && !self->low_latency) {
416 if (channels == 1)
417 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_fft_1_32;
418 else if (channels == 2)
419 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_fft_2_32;
420 else
421 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_fft_32;
422 } else {
423 if (channels == 1)
424 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_1_32;
425 else if (channels == 2)
426 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_2_32;
427 else
428 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_32;
429 }
430 break;
431 case GST_AUDIO_FORMAT_F64:
432 if (self->fft && !self->low_latency) {
433 if (channels == 1)
434 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_fft_1_64;
435 else if (channels == 2)
436 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_fft_2_64;
437 else
438 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_fft_64;
439 } else {
440 if (channels == 1)
441 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_1_64;
442 else if (channels == 2)
443 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_2_64;
444 else
445 self->process = (GstAudioFXBaseFIRFilterProcessFunc) process_64;
446 }
447 break;
448 default:
449 self->process = NULL;
450 break;
451 }
452 }
453
454 static void
gst_audio_fx_base_fir_filter_finalize(GObject * object)455 gst_audio_fx_base_fir_filter_finalize (GObject * object)
456 {
457 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (object);
458
459 g_free (self->buffer);
460 g_free (self->kernel);
461 gst_fft_f64_free (self->fft);
462 gst_fft_f64_free (self->ifft);
463 g_free (self->frequency_response);
464 g_free (self->fft_buffer);
465 g_mutex_clear (&self->lock);
466
467 G_OBJECT_CLASS (parent_class)->finalize (object);
468 }
469
470 static void
gst_audio_fx_base_fir_filter_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)471 gst_audio_fx_base_fir_filter_set_property (GObject * object, guint prop_id,
472 const GValue * value, GParamSpec * pspec)
473 {
474 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (object);
475
476 switch (prop_id) {
477 case PROP_LOW_LATENCY:{
478 gboolean low_latency;
479
480 if (GST_STATE (self) >= GST_STATE_PAUSED) {
481 g_warning ("Changing the \"low-latency\" property "
482 "is only allowed in states < PAUSED");
483 return;
484 }
485
486
487 g_mutex_lock (&self->lock);
488 low_latency = g_value_get_boolean (value);
489
490 if (self->low_latency != low_latency) {
491 self->low_latency = low_latency;
492 gst_audio_fx_base_fir_filter_calculate_frequency_response (self);
493 gst_audio_fx_base_fir_filter_select_process_function (self,
494 GST_AUDIO_FILTER_FORMAT (self), GST_AUDIO_FILTER_CHANNELS (self));
495 }
496 g_mutex_unlock (&self->lock);
497 break;
498 }
499 case PROP_DRAIN_ON_CHANGES:{
500 g_mutex_lock (&self->lock);
501 self->drain_on_changes = g_value_get_boolean (value);
502 g_mutex_unlock (&self->lock);
503 break;
504 }
505 default:
506 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
507 break;
508 }
509 }
510
511 static void
gst_audio_fx_base_fir_filter_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)512 gst_audio_fx_base_fir_filter_get_property (GObject * object, guint prop_id,
513 GValue * value, GParamSpec * pspec)
514 {
515 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (object);
516
517 switch (prop_id) {
518 case PROP_LOW_LATENCY:
519 g_value_set_boolean (value, self->low_latency);
520 break;
521 case PROP_DRAIN_ON_CHANGES:
522 g_value_set_boolean (value, self->drain_on_changes);
523 break;
524 default:
525 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
526 break;
527 }
528 }
529
530 static void
gst_audio_fx_base_fir_filter_class_init(GstAudioFXBaseFIRFilterClass * klass)531 gst_audio_fx_base_fir_filter_class_init (GstAudioFXBaseFIRFilterClass * klass)
532 {
533 GObjectClass *gobject_class = (GObjectClass *) klass;
534 GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass;
535 GstAudioFilterClass *filter_class = (GstAudioFilterClass *) klass;
536 GstCaps *caps;
537
538 GST_DEBUG_CATEGORY_INIT (gst_audio_fx_base_fir_filter_debug,
539 "audiofxbasefirfilter", 0, "FIR filter base class");
540
541 gobject_class->finalize = gst_audio_fx_base_fir_filter_finalize;
542 gobject_class->set_property = gst_audio_fx_base_fir_filter_set_property;
543 gobject_class->get_property = gst_audio_fx_base_fir_filter_get_property;
544
545 /**
546 * GstAudioFXBaseFIRFilter:low-latency:
547 *
548 * Work in low-latency mode. This mode is much slower for large filter sizes
549 * but the latency is always only the pre-latency of the filter.
550 */
551 g_object_class_install_property (gobject_class, PROP_LOW_LATENCY,
552 g_param_spec_boolean ("low-latency", "Low latency",
553 "Operate in low latency mode. This mode is slower but the "
554 "latency will only be the filter pre-latency. "
555 "Can only be changed in states < PAUSED!", DEFAULT_LOW_LATENCY,
556 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
557
558 /**
559 * GstAudioFXBaseFIRFilter:drain-on-changes:
560 *
561 * Whether the filter should be drained when its coeficients change
562 *
563 * Note: Currently this only works if the kernel size is not changed!
564 * Support for drainless kernel size changes will be added in the future.
565 */
566 g_object_class_install_property (gobject_class, PROP_DRAIN_ON_CHANGES,
567 g_param_spec_boolean ("drain-on-changes", "Drain on changes",
568 "Drains the filter when its coeficients change",
569 DEFAULT_DRAIN_ON_CHANGES,
570 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
571
572 caps = gst_caps_from_string (ALLOWED_CAPS);
573 gst_audio_filter_class_add_pad_templates (GST_AUDIO_FILTER_CLASS (klass),
574 caps);
575 gst_caps_unref (caps);
576
577 trans_class->transform =
578 GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_transform);
579 trans_class->start = GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_start);
580 trans_class->stop = GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_stop);
581 trans_class->sink_event =
582 GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_sink_event);
583 trans_class->query = GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_query);
584 trans_class->transform_size =
585 GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_transform_size);
586 filter_class->setup = GST_DEBUG_FUNCPTR (gst_audio_fx_base_fir_filter_setup);
587 }
588
589 static void
gst_audio_fx_base_fir_filter_init(GstAudioFXBaseFIRFilter * self)590 gst_audio_fx_base_fir_filter_init (GstAudioFXBaseFIRFilter * self)
591 {
592 self->kernel = NULL;
593 self->buffer = NULL;
594 self->buffer_length = 0;
595
596 self->start_ts = GST_CLOCK_TIME_NONE;
597 self->start_off = GST_BUFFER_OFFSET_NONE;
598 self->nsamples_out = 0;
599 self->nsamples_in = 0;
600
601 self->low_latency = DEFAULT_LOW_LATENCY;
602 self->drain_on_changes = DEFAULT_DRAIN_ON_CHANGES;
603
604 g_mutex_init (&self->lock);
605 }
606
607 void
gst_audio_fx_base_fir_filter_push_residue(GstAudioFXBaseFIRFilter * self)608 gst_audio_fx_base_fir_filter_push_residue (GstAudioFXBaseFIRFilter * self)
609 {
610 GstBuffer *outbuf;
611 GstFlowReturn res;
612 gint rate = GST_AUDIO_FILTER_RATE (self);
613 gint channels = GST_AUDIO_FILTER_CHANNELS (self);
614 gint bps = GST_AUDIO_FILTER_BPS (self);
615 gint outsize, outsamples;
616 GstMapInfo map;
617 guint8 *in, *out;
618
619 if (channels == 0 || rate == 0 || self->nsamples_in == 0) {
620 self->buffer_fill = 0;
621 g_free (self->buffer);
622 self->buffer = NULL;
623 return;
624 }
625
626 /* Calculate the number of samples and their memory size that
627 * should be pushed from the residue */
628 outsamples = self->nsamples_in - (self->nsamples_out - self->latency);
629 if (outsamples <= 0) {
630 self->buffer_fill = 0;
631 g_free (self->buffer);
632 self->buffer = NULL;
633 return;
634 }
635 outsize = outsamples * channels * bps;
636
637 if (!self->fft || self->low_latency) {
638 gint64 diffsize, diffsamples;
639
640 /* Process the difference between latency and residue length samples
641 * to start at the actual data instead of starting at the zeros before
642 * when we only got one buffer smaller than latency */
643 diffsamples =
644 ((gint64) self->latency) - ((gint64) self->buffer_fill) / channels;
645 if (diffsamples > 0) {
646 diffsize = diffsamples * channels * bps;
647 in = g_new0 (guint8, diffsize);
648 out = g_new0 (guint8, diffsize);
649 self->nsamples_out += self->process (self, in, out, diffsamples);
650 g_free (in);
651 g_free (out);
652 }
653
654 outbuf = gst_buffer_new_and_alloc (outsize);
655
656 /* Convolve the residue with zeros to get the actual remaining data */
657 in = g_new0 (guint8, outsize);
658 gst_buffer_map (outbuf, &map, GST_MAP_READWRITE);
659 self->nsamples_out += self->process (self, in, map.data, outsamples);
660 gst_buffer_unmap (outbuf, &map);
661
662 g_free (in);
663 } else {
664 guint gensamples = 0;
665
666 outbuf = gst_buffer_new_and_alloc (outsize);
667 gst_buffer_map (outbuf, &map, GST_MAP_READWRITE);
668
669 while (gensamples < outsamples) {
670 guint step_insamples = self->block_length - self->buffer_fill;
671 guint8 *zeroes = g_new0 (guint8, step_insamples * channels * bps);
672 guint8 *out = g_new (guint8, self->block_length * channels * bps);
673 guint step_gensamples;
674
675 step_gensamples = self->process (self, zeroes, out, step_insamples);
676 g_free (zeroes);
677
678 memcpy (map.data + gensamples * bps, out, MIN (step_gensamples,
679 outsamples - gensamples) * bps);
680 gensamples += MIN (step_gensamples, outsamples - gensamples);
681
682 g_free (out);
683 }
684 self->nsamples_out += gensamples;
685
686 gst_buffer_unmap (outbuf, &map);
687 }
688
689 /* Set timestamp, offset, etc from the values we
690 * saved when processing the regular buffers */
691 if (GST_CLOCK_TIME_IS_VALID (self->start_ts))
692 GST_BUFFER_TIMESTAMP (outbuf) = self->start_ts;
693 else
694 GST_BUFFER_TIMESTAMP (outbuf) = 0;
695 GST_BUFFER_TIMESTAMP (outbuf) +=
696 gst_util_uint64_scale_int (self->nsamples_out - outsamples -
697 self->latency, GST_SECOND, rate);
698
699 GST_BUFFER_DURATION (outbuf) =
700 gst_util_uint64_scale_int (outsamples, GST_SECOND, rate);
701
702 if (self->start_off != GST_BUFFER_OFFSET_NONE) {
703 GST_BUFFER_OFFSET (outbuf) =
704 self->start_off + self->nsamples_out - outsamples - self->latency;
705 GST_BUFFER_OFFSET_END (outbuf) = GST_BUFFER_OFFSET (outbuf) + outsamples;
706 }
707
708 GST_DEBUG_OBJECT (self,
709 "Pushing residue buffer of size %" G_GSIZE_FORMAT " with timestamp: %"
710 GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %"
711 G_GUINT64_FORMAT ", offset_end: %" G_GUINT64_FORMAT ", nsamples_out: %d",
712 gst_buffer_get_size (outbuf),
713 GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
714 GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
715 GST_BUFFER_OFFSET_END (outbuf), outsamples);
716
717 res = gst_pad_push (GST_BASE_TRANSFORM_CAST (self)->srcpad, outbuf);
718
719 if (G_UNLIKELY (res != GST_FLOW_OK)) {
720 GST_WARNING_OBJECT (self, "failed to push residue");
721 }
722
723 self->buffer_fill = 0;
724 }
725
726 /* GstAudioFilter vmethod implementations */
727
728 /* get notified of caps and plug in the correct process function */
729 static gboolean
gst_audio_fx_base_fir_filter_setup(GstAudioFilter * base,const GstAudioInfo * info)730 gst_audio_fx_base_fir_filter_setup (GstAudioFilter * base,
731 const GstAudioInfo * info)
732 {
733 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
734
735 g_mutex_lock (&self->lock);
736 if (self->buffer) {
737 gst_audio_fx_base_fir_filter_push_residue (self);
738 g_free (self->buffer);
739 self->buffer = NULL;
740 self->buffer_fill = 0;
741 self->buffer_length = 0;
742 self->start_ts = GST_CLOCK_TIME_NONE;
743 self->start_off = GST_BUFFER_OFFSET_NONE;
744 self->nsamples_out = 0;
745 self->nsamples_in = 0;
746 }
747
748 gst_audio_fx_base_fir_filter_select_process_function (self,
749 GST_AUDIO_INFO_FORMAT (info), GST_AUDIO_INFO_CHANNELS (info));
750 g_mutex_unlock (&self->lock);
751
752 return (self->process != NULL);
753 }
754
755 /* GstBaseTransform vmethod implementations */
756
757 static gboolean
gst_audio_fx_base_fir_filter_transform_size(GstBaseTransform * base,GstPadDirection direction,GstCaps * caps,gsize size,GstCaps * othercaps,gsize * othersize)758 gst_audio_fx_base_fir_filter_transform_size (GstBaseTransform * base,
759 GstPadDirection direction, GstCaps * caps, gsize size, GstCaps * othercaps,
760 gsize * othersize)
761 {
762 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
763 guint blocklen;
764 GstAudioInfo info;
765 gint bpf;
766
767 if (!self->fft || self->low_latency || direction == GST_PAD_SRC) {
768 *othersize = size;
769 return TRUE;
770 }
771
772 if (!gst_audio_info_from_caps (&info, caps))
773 return FALSE;
774
775 bpf = GST_AUDIO_INFO_BPF (&info);
776
777 size /= bpf;
778 blocklen = self->block_length - self->kernel_length + 1;
779 *othersize = ((size + blocklen - 1) / blocklen) * blocklen;
780 *othersize *= bpf;
781
782 return TRUE;
783 }
784
785 static GstFlowReturn
gst_audio_fx_base_fir_filter_transform(GstBaseTransform * base,GstBuffer * inbuf,GstBuffer * outbuf)786 gst_audio_fx_base_fir_filter_transform (GstBaseTransform * base,
787 GstBuffer * inbuf, GstBuffer * outbuf)
788 {
789 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
790 GstClockTime timestamp, expected_timestamp;
791 gint channels = GST_AUDIO_FILTER_CHANNELS (self);
792 gint rate = GST_AUDIO_FILTER_RATE (self);
793 gint bps = GST_AUDIO_FILTER_BPS (self);
794 GstMapInfo inmap, outmap;
795 guint input_samples;
796 guint output_samples;
797 guint generated_samples;
798 guint64 output_offset;
799 gint64 diff = 0;
800 GstClockTime stream_time;
801
802 timestamp = GST_BUFFER_TIMESTAMP (outbuf);
803
804 if (!GST_CLOCK_TIME_IS_VALID (timestamp)
805 && !GST_CLOCK_TIME_IS_VALID (self->start_ts)) {
806 GST_ERROR_OBJECT (self, "Invalid timestamp");
807 return GST_FLOW_ERROR;
808 }
809
810 g_mutex_lock (&self->lock);
811 stream_time =
812 gst_segment_to_stream_time (&base->segment, GST_FORMAT_TIME, timestamp);
813
814 GST_DEBUG_OBJECT (self, "sync to %" GST_TIME_FORMAT,
815 GST_TIME_ARGS (timestamp));
816
817 if (GST_CLOCK_TIME_IS_VALID (stream_time))
818 gst_object_sync_values (GST_OBJECT (self), stream_time);
819
820 g_return_val_if_fail (self->kernel != NULL, GST_FLOW_ERROR);
821 g_return_val_if_fail (channels != 0, GST_FLOW_ERROR);
822
823 if (GST_CLOCK_TIME_IS_VALID (self->start_ts))
824 expected_timestamp =
825 self->start_ts + gst_util_uint64_scale_int (self->nsamples_in,
826 GST_SECOND, rate);
827 else
828 expected_timestamp = GST_CLOCK_TIME_NONE;
829
830 /* Reset the residue if already existing on discont buffers */
831 if (GST_BUFFER_IS_DISCONT (inbuf)
832 || (GST_CLOCK_TIME_IS_VALID (expected_timestamp)
833 && (ABS (GST_CLOCK_DIFF (timestamp,
834 expected_timestamp)) > 5 * GST_MSECOND))) {
835 GST_DEBUG_OBJECT (self, "Discontinuity detected - flushing");
836 if (GST_CLOCK_TIME_IS_VALID (expected_timestamp))
837 gst_audio_fx_base_fir_filter_push_residue (self);
838 self->buffer_fill = 0;
839 g_free (self->buffer);
840 self->buffer = NULL;
841 self->start_ts = timestamp;
842 self->start_off = GST_BUFFER_OFFSET (inbuf);
843 self->nsamples_out = 0;
844 self->nsamples_in = 0;
845 } else if (!GST_CLOCK_TIME_IS_VALID (self->start_ts)) {
846 self->start_ts = timestamp;
847 self->start_off = GST_BUFFER_OFFSET (inbuf);
848 }
849
850 gst_buffer_map (inbuf, &inmap, GST_MAP_READ);
851 gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
852
853 input_samples = (inmap.size / bps) / channels;
854 output_samples = (outmap.size / bps) / channels;
855
856 self->nsamples_in += input_samples;
857
858 generated_samples =
859 self->process (self, inmap.data, outmap.data, input_samples);
860
861 gst_buffer_unmap (inbuf, &inmap);
862 gst_buffer_unmap (outbuf, &outmap);
863
864 g_assert (generated_samples <= output_samples);
865 self->nsamples_out += generated_samples;
866 if (generated_samples == 0)
867 goto no_samples;
868
869 /* Calculate the number of samples we can push out now without outputting
870 * latency zeros in the beginning */
871 diff = ((gint64) self->nsamples_out) - ((gint64) self->latency);
872 if (diff < 0)
873 goto no_samples;
874
875 if (diff < generated_samples) {
876 gint64 tmp = diff;
877 diff = generated_samples - diff;
878 generated_samples = tmp;
879 } else {
880 diff = 0;
881 }
882
883 gst_buffer_resize (outbuf, diff * bps * channels,
884 generated_samples * bps * channels);
885
886 output_offset = self->nsamples_out - self->latency - generated_samples;
887 GST_BUFFER_TIMESTAMP (outbuf) =
888 self->start_ts + gst_util_uint64_scale_int (output_offset, GST_SECOND,
889 rate);
890 GST_BUFFER_DURATION (outbuf) =
891 gst_util_uint64_scale_int (output_samples, GST_SECOND, rate);
892 if (self->start_off != GST_BUFFER_OFFSET_NONE) {
893 GST_BUFFER_OFFSET (outbuf) = self->start_off + output_offset;
894 GST_BUFFER_OFFSET_END (outbuf) =
895 GST_BUFFER_OFFSET (outbuf) + generated_samples;
896 } else {
897 GST_BUFFER_OFFSET (outbuf) = GST_BUFFER_OFFSET_NONE;
898 GST_BUFFER_OFFSET_END (outbuf) = GST_BUFFER_OFFSET_NONE;
899 }
900 g_mutex_unlock (&self->lock);
901
902 GST_DEBUG_OBJECT (self,
903 "Pushing buffer of size %" G_GSIZE_FORMAT " with timestamp: %"
904 GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %"
905 G_GUINT64_FORMAT ", offset_end: %" G_GUINT64_FORMAT ", nsamples_out: %d",
906 gst_buffer_get_size (outbuf),
907 GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
908 GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
909 GST_BUFFER_OFFSET_END (outbuf), generated_samples);
910
911 return GST_FLOW_OK;
912
913 no_samples:
914 {
915 g_mutex_unlock (&self->lock);
916 return GST_BASE_TRANSFORM_FLOW_DROPPED;
917 }
918 }
919
920 static gboolean
gst_audio_fx_base_fir_filter_start(GstBaseTransform * base)921 gst_audio_fx_base_fir_filter_start (GstBaseTransform * base)
922 {
923 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
924
925 self->buffer_fill = 0;
926 g_free (self->buffer);
927 self->buffer = NULL;
928 self->start_ts = GST_CLOCK_TIME_NONE;
929 self->start_off = GST_BUFFER_OFFSET_NONE;
930 self->nsamples_out = 0;
931 self->nsamples_in = 0;
932
933 return TRUE;
934 }
935
936 static gboolean
gst_audio_fx_base_fir_filter_stop(GstBaseTransform * base)937 gst_audio_fx_base_fir_filter_stop (GstBaseTransform * base)
938 {
939 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
940
941 g_free (self->buffer);
942 self->buffer = NULL;
943 self->buffer_length = 0;
944
945 return TRUE;
946 }
947
948 static gboolean
gst_audio_fx_base_fir_filter_query(GstBaseTransform * trans,GstPadDirection direction,GstQuery * query)949 gst_audio_fx_base_fir_filter_query (GstBaseTransform * trans,
950 GstPadDirection direction, GstQuery * query)
951 {
952 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (trans);
953 gboolean res = TRUE;
954
955 switch (GST_QUERY_TYPE (query)) {
956 case GST_QUERY_LATENCY:
957 {
958 GstClockTime min, max;
959 gboolean live;
960 guint64 latency;
961 gint rate = GST_AUDIO_FILTER_RATE (self);
962
963 if (rate == 0) {
964 res = FALSE;
965 } else if ((res =
966 gst_pad_peer_query (GST_BASE_TRANSFORM (self)->sinkpad, query))) {
967 gst_query_parse_latency (query, &live, &min, &max);
968
969 GST_DEBUG_OBJECT (self, "Peer latency: min %"
970 GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
971 GST_TIME_ARGS (min), GST_TIME_ARGS (max));
972
973 if (self->fft && !self->low_latency)
974 latency = self->block_length - self->kernel_length + 1;
975 else
976 latency = self->latency;
977
978 /* add our own latency */
979 latency = gst_util_uint64_scale_round (latency, GST_SECOND, rate);
980
981 GST_DEBUG_OBJECT (self, "Our latency: %"
982 GST_TIME_FORMAT, GST_TIME_ARGS (latency));
983
984 min += latency;
985 if (max != GST_CLOCK_TIME_NONE)
986 max += latency;
987
988 GST_DEBUG_OBJECT (self, "Calculated total latency : min %"
989 GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
990 GST_TIME_ARGS (min), GST_TIME_ARGS (max));
991
992 gst_query_set_latency (query, live, min, max);
993 }
994 break;
995 }
996 default:
997 res =
998 GST_BASE_TRANSFORM_CLASS (parent_class)->query (trans, direction,
999 query);
1000 break;
1001 }
1002 return res;
1003 }
1004
1005 static gboolean
gst_audio_fx_base_fir_filter_sink_event(GstBaseTransform * base,GstEvent * event)1006 gst_audio_fx_base_fir_filter_sink_event (GstBaseTransform * base,
1007 GstEvent * event)
1008 {
1009 GstAudioFXBaseFIRFilter *self = GST_AUDIO_FX_BASE_FIR_FILTER (base);
1010
1011 switch (GST_EVENT_TYPE (event)) {
1012 case GST_EVENT_EOS:
1013 gst_audio_fx_base_fir_filter_push_residue (self);
1014 self->start_ts = GST_CLOCK_TIME_NONE;
1015 self->start_off = GST_BUFFER_OFFSET_NONE;
1016 self->nsamples_out = 0;
1017 self->nsamples_in = 0;
1018 break;
1019 default:
1020 break;
1021 }
1022
1023 return GST_BASE_TRANSFORM_CLASS (parent_class)->sink_event (base, event);
1024 }
1025
1026 void
gst_audio_fx_base_fir_filter_set_kernel(GstAudioFXBaseFIRFilter * self,gdouble * kernel,guint kernel_length,guint64 latency,const GstAudioInfo * info)1027 gst_audio_fx_base_fir_filter_set_kernel (GstAudioFXBaseFIRFilter * self,
1028 gdouble * kernel, guint kernel_length, guint64 latency,
1029 const GstAudioInfo * info)
1030 {
1031 gboolean latency_changed;
1032 GstAudioFormat format;
1033 gint channels;
1034
1035 g_return_if_fail (kernel != NULL);
1036 g_return_if_fail (self != NULL);
1037
1038 g_mutex_lock (&self->lock);
1039
1040 latency_changed = (self->latency != latency
1041 || (!self->low_latency && self->kernel_length < FFT_THRESHOLD
1042 && kernel_length >= FFT_THRESHOLD)
1043 || (!self->low_latency && self->kernel_length >= FFT_THRESHOLD
1044 && kernel_length < FFT_THRESHOLD));
1045
1046 /* FIXME: If the latency changes, the buffer size changes too and we
1047 * have to drain in any case until this is fixed in the future */
1048 if (self->buffer && (!self->drain_on_changes || latency_changed)) {
1049 gst_audio_fx_base_fir_filter_push_residue (self);
1050 self->start_ts = GST_CLOCK_TIME_NONE;
1051 self->start_off = GST_BUFFER_OFFSET_NONE;
1052 self->nsamples_out = 0;
1053 self->nsamples_in = 0;
1054 self->buffer_fill = 0;
1055 }
1056
1057 g_free (self->kernel);
1058 if (!self->drain_on_changes || latency_changed) {
1059 g_free (self->buffer);
1060 self->buffer = NULL;
1061 self->buffer_fill = 0;
1062 self->buffer_length = 0;
1063 }
1064
1065 self->kernel = kernel;
1066 self->kernel_length = kernel_length;
1067
1068 if (info) {
1069 format = GST_AUDIO_INFO_FORMAT (info);
1070 channels = GST_AUDIO_INFO_CHANNELS (info);
1071 } else {
1072 format = GST_AUDIO_FILTER_FORMAT (self);
1073 channels = GST_AUDIO_FILTER_CHANNELS (self);
1074 }
1075
1076 gst_audio_fx_base_fir_filter_calculate_frequency_response (self);
1077 gst_audio_fx_base_fir_filter_select_process_function (self, format, channels);
1078
1079 if (latency_changed) {
1080 self->latency = latency;
1081 gst_element_post_message (GST_ELEMENT (self),
1082 gst_message_new_latency (GST_OBJECT (self)));
1083 }
1084
1085 g_mutex_unlock (&self->lock);
1086 }
1087