#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. 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. #GstFFTF32 instance for this call Buffer of the samples in the time domain Target buffer for the samples in the frequency domain This frees the memory allocated for @self. #GstFFTF32 instance for this call 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. #GstFFTF32 instance for this call Buffer of the samples in the frequency domain Target buffer for the samples in the time domain This calls the window function @window on the @timedata sample buffer. #GstFFTF32 instance for this call Time domain samples Window function to apply 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(). a new #GstFFTF32 instance. Length of the FFT in the time domain %TRUE if the #GstFFTF32 instance should be used for the inverse FFT Data type for complex numbers composed of 32 bit float. Real part Imaginary part #GstFFTF64 provides a FFT implementation and related functions for 64 bit float samples. To use this call gst_fft_f64_new() for allocating a #GstFFTF64 instance with the appropriate parameters and then call gst_fft_f64_fft() or gst_fft_f64_inverse_fft() to perform the FFT or inverse FFT on a buffer of samples. After use free the #GstFFTF64 instance with gst_fft_f64_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_f64_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_f64_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. 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 #GstFFTF64 instance with gst_fft_f64_new(). @freqdata must be large enough to hold @len/2 + 1 #GstFFTF64Complex frequency domain samples. #GstFFTF64 instance for this call Buffer of the samples in the time domain Target buffer for the samples in the frequency domain This frees the memory allocated for @self. #GstFFTF64 instance for this call 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 #GstFFTF64 instance with gst_fft_f64_new(). @timedata must be large enough to hold @len time domain samples. #GstFFTF64 instance for this call Buffer of the samples in the frequency domain Target buffer for the samples in the time domain This calls the window function @window on the @timedata sample buffer. #GstFFTF64 instance for this call Time domain samples Window function to apply This returns a new #GstFFTF64 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(). a new #GstFFTF64 instance. Length of the FFT in the time domain %TRUE if the #GstFFTF64 instance should be used for the inverse FFT Data type for complex numbers composed of 64 bit float. Real part Imaginary part #GstFFTS16 provides a FFT implementation and related functions for signed 16 bit integer samples. To use this call gst_fft_s16_new() for allocating a #GstFFTS16 instance with the appropriate parameters and then call gst_fft_s16_fft() or gst_fft_s16_inverse_fft() to perform the FFT or inverse FFT on a buffer of samples. After use free the #GstFFTS16 instance with gst_fft_s16_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_s16_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_s16_window() can comfortably be used. Be aware, that you can't simply run gst_fft_s16_inverse_fft() on the resulting frequency data of gst_fft_s16_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. 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 #GstFFTS16 instance with gst_fft_s16_new(). @freqdata must be large enough to hold @len/2 + 1 #GstFFTS16Complex frequency domain samples. #GstFFTS16 instance for this call Buffer of the samples in the time domain Target buffer for the samples in the frequency domain This frees the memory allocated for @self. #GstFFTS16 instance for this call 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 #GstFFTS16 instance with gst_fft_s16_new(). @timedata must be large enough to hold @len time domain samples. #GstFFTS16 instance for this call Buffer of the samples in the frequency domain Target buffer for the samples in the time domain This calls the window function @window on the @timedata sample buffer. #GstFFTS16 instance for this call Time domain samples Window function to apply This returns a new #GstFFTS16 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(). a new #GstFFTS16 instance. Length of the FFT in the time domain %TRUE if the #GstFFTS16 instance should be used for the inverse FFT Data type for complex numbers composed of signed 16 bit integers. Real part Imaginary part #GstFFTS32 provides a FFT implementation and related functions for signed 32 bit integer samples. To use this call gst_fft_s32_new() for allocating a #GstFFTS32 instance with the appropriate parameters and then call gst_fft_s32_fft() or gst_fft_s32_inverse_fft() to perform the FFT or inverse FFT on a buffer of samples. After use free the #GstFFTS32 instance with gst_fft_s32_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_s32_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_s32_window() can comfortably be used. Be aware, that you can't simply run gst_fft_s32_inverse_fft() on the resulting frequency data of gst_fft_s32_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. 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 #GstFFTS32 instance with gst_fft_s32_new(). @freqdata must be large enough to hold @len/2 + 1 #GstFFTS32Complex frequency domain samples. #GstFFTS32 instance for this call Buffer of the samples in the time domain Target buffer for the samples in the frequency domain This frees the memory allocated for @self. #GstFFTS32 instance for this call 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 #GstFFTS32 instance with gst_fft_s32_new(). @timedata must be large enough to hold @len time domain samples. #GstFFTS32 instance for this call Buffer of the samples in the frequency domain Target buffer for the samples in the time domain This calls the window function @window on the @timedata sample buffer. #GstFFTS32 instance for this call Time domain samples Window function to apply This returns a new #GstFFTS32 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(). a new #GstFFTS32 instance. Length of the FFT in the time domain %TRUE if the #GstFFTS32 instance should be used for the inverse FFT Data type for complex numbers composed of signed 32 bit integers. Real part Imaginary part The various window functions available. Rectangular window Hamming window Hann (sometimes also called Hanning) window Bartlett window Blackman window 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(). a new #GstFFTF32 instance. Length of the FFT in the time domain %TRUE if the #GstFFTF32 instance should be used for the inverse FFT This returns a new #GstFFTF64 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(). a new #GstFFTF64 instance. Length of the FFT in the time domain %TRUE if the #GstFFTF64 instance should be used for the inverse FFT Returns the next number to @n that is entirely a product of 2, 3 and 5. Using this as the @len parameter for the different GstFFT types will provide the best performance. the next fast FFT length. Number for which the next fast length should be returned This returns a new #GstFFTS16 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(). a new #GstFFTS16 instance. Length of the FFT in the time domain %TRUE if the #GstFFTS16 instance should be used for the inverse FFT This returns a new #GstFFTS32 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(). a new #GstFFTS32 instance. Length of the FFT in the time domain %TRUE if the #GstFFTS32 instance should be used for the inverse FFT