## gstfftf32

gstfftf32 — FFT functions for 32 bit float samples

## Synopsis

    #include <gst/fft/gstfftf32.h>

    struct              GstFFTF32;
    struct              GstFFTF32Complex;
    GstFFTF32 *         gst_fft_f32_new                     (gint len,
                                                             gboolean inverse);
    void                gst_fft_f32_fft                     (GstFFTF32 *self,
                                                             const gfloat *timedata,
                                                             GstFFTF32Complex *freqdata);
    void                gst_fft_f32_inverse_fft             (GstFFTF32 *self,
                                                             const GstFFTF32Complex *freqdata,
                                                             gfloat *timedata);
    void                gst_fft_f32_window                  (GstFFTF32 *self,
                                                             gfloat *timedata,
                                                             GstFFTWindow window);
    void                gst_fft_f32_free                    (GstFFTF32 *self);

## Description

GstFFTF32 provides a FFT implementation and related functions for 32 bit float samples. To use this call `gst_fft_f32_new()` for allocating a GstFFTF32 instance with the appropriate parameters and then call `gst_fft_f32_fft()` or `gst_fft_f32_inverse_fft()` to perform the FFT or inverse FFT on a buffer of samples.

After use free the GstFFTF32 instance with `gst_fft_f32_free()`.

For the best performance use `gst_fft_next_fast_length()` to get a number that is entirely a product of 2, 3 and 5 and use this as the `len` parameter for `gst_fft_f32_new()`.

The `len` parameter specifies the number of samples in the time domain that will be processed or generated. The number of samples in the frequency domain is `len`/2 + 1. To get n samples in the frequency domain use 2*n - 2 as `len`.

Before performing the FFT on time domain data it usually makes sense to apply a window function to it. For this `gst_fft_f32_window()` can comfortably be used.

Be aware, that you can't simply run `gst_fft_f32_inverse_fft()` on the resulting frequency data of `gst_fft_f32_fft()` to get the original data back. The relation between them is iFFT (FFT (x)) = x * nfft where nfft is the length of the FFT. This also has to be taken into account when calculation the magnitude of the frequency data.

## Details

### struct GstFFTF32

    struct GstFFTF32 {
    };

Instance structure for GstFFTF32.

### struct GstFFTF32Complex

    struct GstFFTF32Complex {
      gfloat r;
      gfloat i;
    };

Data type for complex numbers composed of 32 bit float.

gfloat `r`; | Real part
gfloat `i`; | Imaginary part

### gst_fft_f32_new ()

    GstFFTF32 *         gst_fft_f32_new                     (gint len,
                                                             gboolean inverse);

This returns a new GstFFTF32 instance with the given parameters. It makes sense to keep one instance for several calls for speed reasons.

`len` must be even and to get the best performance a product of 2, 3 and 5. To get the next number with this characteristics use `gst_fft_next_fast_length()`.

`len` : | Length of the FFT in the time domain
`inverse` : | `TRUE` if the GstFFTF32 instance should be used for the inverse FFT
Returns : | a new GstFFTF32 instance.

### gst_fft_f32_fft ()

    void                gst_fft_f32_fft                     (GstFFTF32 *self,
                                                             const gfloat *timedata,
                                                             GstFFTF32Complex *freqdata);

This performs the FFT on `timedata` and puts the result in `freqdata`.

`timedata` must have as many samples as specified with the `len` parameter while allocating the GstFFTF32 instance with `gst_fft_f32_new()`.

`freqdata` must be large enough to hold `len`/2 + 1 GstFFTF32Complex frequency domain samples.

`self` : | GstFFTF32 instance for this call
`timedata` : | Buffer of the samples in the time domain
`freqdata` : | Target buffer for the samples in the frequency domain

### gst_fft_f32_inverse_fft ()

    void                gst_fft_f32_inverse_fft             (GstFFTF32 *self,
                                                             const GstFFTF32Complex *freqdata,
                                                             gfloat *timedata);

This performs the inverse FFT on `freqdata` and puts the result in `timedata`.

`freqdata` must have `len`/2 + 1 samples, where `len` is the parameter specified while allocating the GstFFTF32 instance with `gst_fft_f32_new()`.

`timedata` must be large enough to hold `len` time domain samples.

`self` : | GstFFTF32 instance for this call
`freqdata` : | Buffer of the samples in the frequency domain
`timedata` : | Target buffer for the samples in the time domain

### gst_fft_f32_window ()

    void                gst_fft_f32_window                  (GstFFTF32 *self,
                                                             gfloat *timedata,
                                                             GstFFTWindow window);

This calls the window function `window` on the `timedata` sample buffer.

`self` : | GstFFTF32 instance for this call
`timedata` : | Time domain samples
`window` : | Window function to apply

### gst_fft_f32_free ()

    void                gst_fft_f32_free                    (GstFFTF32 *self);

This frees the memory allocated for `self`.

`self` : | GstFFTF32 instance for this call