git.maemo.org Git - mafwsubrenderer/blob - gst-plugins-base-subtitles0.10/gst-libs/gst/fft/gstffts32.c

   1 /* GStreamer
   2  * Copyright (C) <2007> Sebastian Dröge <slomo@circular-chaos.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <glib.h>
  21 #include <math.h>
  22
  23 #include "_kiss_fft_guts_s32.h"
  24 #include "kiss_fftr_s32.h"
  25 #include "gstfft.h"
  26 #include "gstffts32.h"
  27
  28 /**
  29  * SECTION:gstffts32
  30  * @short_description: FFT functions for signed 32 bit integer samples
  31  *
  32  * #GstFFTS32 provides a FFT implementation and related functions for
  33  * signed 32 bit integer samples. To use this call gst_fft_s32_new() for
  34  * allocating a #GstFFTS32 instance with the appropiate parameters and
  35  * then call gst_fft_s32_fft() or gst_fft_s32_inverse_fft() to perform the
  36  * FFT or inverse FFT on a buffer of samples.
  37  *
  38  * After use free the #GstFFTS32 instance with gst_fft_s32_free().
  39  *
  40  * For the best performance use gst_fft_next_fast_length() to get a
  41  * number that is entirely a product of 2, 3 and 5 and use this as the
  42  * @len parameter for gst_fft_s32_new().
  43  *
  44  * The @len parameter specifies the number of samples in the time domain that
  45  * will be processed or generated. The number of samples in the frequency domain
  46  * is @len/2 + 1. To get n samples in the frequency domain use 2*n - 2 as @len.
  47  *
  48  * Before performing the FFT on time domain data it usually makes sense
  49  * to apply a window function to it. For this gst_fft_s32_window() can comfortably
  50  * be used.
  51  *
  52  * Be aware, that you can't simply run gst_fft_s32_inverse_fft() on the
  53  * resulting frequency data of gst_fft_s32_fft() to get the original data back.
  54  * The relation between them is iFFT (FFT (x)) = x / nfft where nfft is the
  55  * length of the FFT. This also has to be taken into account when calculation
  56  * the magnitude of the frequency data.
  57  */
  58
  59 /**
  60  * gst_fft_s32_new:
  61  * @len: Length of the FFT in the time domain
  62  * @inverse: %TRUE if the #GstFFTS32 instance should be used for the inverse FFT
  63  *
  64  * This returns a new #GstFFTS32 instance with the given parameters. It makes
  65  * sense to keep one instance for several calls for speed reasons.
  66  *
  67  * @len must be even and to get the best performance a product of
  68  * 2, 3 and 5. To get the next number with this characteristics use
  69  * gst_fft_next_fast_length().
  70  *
  71  * Returns: a new #GstFFTS32 instance.
  72  */
  73 GstFFTS32 *
  74 gst_fft_s32_new (gint len, gboolean inverse)
  75 {
  76   GstFFTS32 *self;
  77   gsize subsize = 0, memneeded;
  78
  79   g_return_val_if_fail (len > 0, NULL);
  80   g_return_val_if_fail (len % 2 == 0, NULL);
  81
  82   kiss_fftr_s32_alloc (len, (inverse) ? 1 : 0, NULL, &subsize);
  83   memneeded = ALIGN_STRUCT (sizeof (GstFFTS32)) + subsize;
  84
  85   self = (GstFFTS32 *) g_malloc0 (memneeded);
  86
  87   self->cfg = (((guint8 *) self) + ALIGN_STRUCT (sizeof (GstFFTS32)));
  88   self->cfg = kiss_fftr_s32_alloc (len, (inverse) ? 1 : 0, self->cfg, &subsize);
  89   g_assert (self->cfg);
  90
  91   self->inverse = inverse;
  92   self->len = len;
  93
  94   return self;
  95 }
  96
  97 /**
  98  * gst_fft_s32_fft:
  99  * @self: #GstFFTS32 instance for this call
 100  * @timedata: Buffer of the samples in the time domain
 101  * @freqdata: Target buffer for the samples in the frequency domain
 102  *
 103  * This performs the FFT on @timedata and puts the result in @freqdata.
 104  *
 105  * @timedata must have as many samples as specified with the @len parameter while
 106  * allocating the #GstFFTS32 instance with gst_fft_s32_new().
 107  *
 108  * @freqdata must be large enough to hold @len/2 + 1 #GstFFTS32Complex frequency
 109  * domain samples.
 110  *
 111  */
 112 void
 113 gst_fft_s32_fft (GstFFTS32 * self, const gint32 * timedata,
 114     GstFFTS32Complex * freqdata)
 115 {
 116   g_return_if_fail (self);
 117   g_return_if_fail (!self->inverse);
 118   g_return_if_fail (timedata);
 119   g_return_if_fail (freqdata);
 120
 121   kiss_fftr_s32 (self->cfg, timedata, (kiss_fft_s32_cpx *) freqdata);
 122 }
 123
 124 /**
 125  * gst_fft_s32_inverse_fft:
 126  * @self: #GstFFTS32 instance for this call
 127  * @freqdata: Buffer of the samples in the frequency domain
 128  * @timedata: Target buffer for the samples in the time domain
 129  *
 130  * This performs the inverse FFT on @freqdata and puts the result in @timedata.
 131  *
 132  * @freqdata must have @len/2 + 1 samples, where @len is the parameter specified
 133  * while allocating the #GstFFTS32 instance with gst_fft_s32_new().
 134  *
 135  * @timedata must be large enough to hold @len time domain samples.
 136  *
 137  */
 138 void
 139 gst_fft_s32_inverse_fft (GstFFTS32 * self, const GstFFTS32Complex * freqdata,
 140     gint32 * timedata)
 141 {
 142   g_return_if_fail (self);
 143   g_return_if_fail (self->inverse);
 144   g_return_if_fail (timedata);
 145   g_return_if_fail (freqdata);
 146
 147   kiss_fftri_s32 (self->cfg, (kiss_fft_s32_cpx *) freqdata, timedata);
 148 }
 149
 150 /**
 151  * gst_fft_s32_free:
 152  * @self: #GstFFTS32 instance for this call
 153  *
 154  * This frees the memory allocated for @self.
 155  *
 156  */
 157 void
 158 gst_fft_s32_free (GstFFTS32 * self)
 159 {
 160   g_free (self);
 161 }
 162
 163 /**
 164  * gst_fft_s32_window:
 165  * @self: #GstFFTS32 instance for this call
 166  * @timedata: Time domain samples
 167  * @window: Window function to apply
 168  *
 169  * This calls the window function @window on the @timedata sample buffer.
 170  *
 171  */
 172 void
 173 gst_fft_s32_window (GstFFTS32 * self, gint32 * timedata, GstFFTWindow window)
 174 {
 175   gint i, len;
 176
 177   g_return_if_fail (self);
 178   g_return_if_fail (timedata);
 179
 180   len = self->len;
 181
 182   switch (window) {
 183     case GST_FFT_WINDOW_RECTANGULAR:
 184       /* do nothing */
 185       break;
 186     case GST_FFT_WINDOW_HAMMING:
 187       for (i = 0; i < len; i++)
 188         timedata[i] *= (0.53836 - 0.46164 * cos (2.0 * M_PI * i / len));
 189       break;
 190     case GST_FFT_WINDOW_HANN:
 191       for (i = 0; i < len; i++)
 192         timedata[i] *= (0.5 - 0.5 * cos (2.0 * M_PI * i / len));
 193       break;
 194     case GST_FFT_WINDOW_BARTLETT:
 195       for (i = 0; i < len; i++)
 196         timedata[i] *= (1.0 - fabs ((2.0 * i - len) / len));
 197       break;
 198     case GST_FFT_WINDOW_BLACKMAN:
 199       for (i = 0; i < len; i++)
 200         timedata[i] *= (0.42 - 0.5 * cos ((2.0 * i) / len) +
 201             0.08 * cos ((4.0 * i) / len));
 202       break;
 203     default:
 204       g_assert_not_reached ();
 205       break;
 206   }
 207 }