Line data    Source code

       1             : /*
       2             :  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
       3             :  *
       4             :  *  Use of this source code is governed by a BSD-style license
       5             :  *  that can be found in the LICENSE file in the root of the source
       6             :  *  tree. An additional intellectual property rights grant can be found
       7             :  *  in the file PATENTS.  All contributing project authors may
       8             :  *  be found in the AUTHORS file in the root of the source tree.
       9             :  */
      10             : 
      11             : #ifndef WEBRTC_COMMON_AUDIO_REAL_FOURIER_H_
      12             : #define WEBRTC_COMMON_AUDIO_REAL_FOURIER_H_
      13             : 
      14             : #include <complex>
      15             : #include <memory>
      16             : 
      17             : #include "webrtc/system_wrappers/include/aligned_malloc.h"
      18             : 
      19             : // Uniform interface class for the real DFT and its inverse, for power-of-2
      20             : // input lengths. Also contains helper functions for buffer allocation, taking
      21             : // care of any memory alignment requirements the underlying library might have.
      22             : 
      23             : namespace webrtc {
      24             : 
      25           0 : class RealFourier {
      26             :  public:
      27             :   // Shorthand typenames for the scopers used by the buffer allocation helpers.
      28             :   typedef std::unique_ptr<float[], AlignedFreeDeleter> fft_real_scoper;
      29             :   typedef std::unique_ptr<std::complex<float>[], AlignedFreeDeleter>
      30             :       fft_cplx_scoper;
      31             : 
      32             :   // The alignment required for all input and output buffers, in bytes.
      33             :   static const size_t kFftBufferAlignment;
      34             : 
      35             :   // Construct a wrapper instance for the given input order, which must be
      36             :   // between 1 and kMaxFftOrder, inclusively.
      37             :   static std::unique_ptr<RealFourier> Create(int fft_order);
      38           0 :   virtual ~RealFourier() {};
      39             : 
      40             :   // Helper to compute the smallest FFT order (a power of 2) which will contain
      41             :   // the given input length.
      42             :   static int FftOrder(size_t length);
      43             : 
      44             :   // Helper to compute the input length from the FFT order.
      45             :   static size_t FftLength(int order);
      46             : 
      47             :   // Helper to compute the exact length, in complex floats, of the transform
      48             :   // output (i.e. |2^order / 2 + 1|).
      49             :   static size_t ComplexLength(int order);
      50             : 
      51             :   // Buffer allocation helpers. The buffers are large enough to hold |count|
      52             :   // floats/complexes and suitably aligned for use by the implementation.
      53             :   // The returned scopers are set up with proper deleters; the caller owns
      54             :   // the allocated memory.
      55             :   static fft_real_scoper AllocRealBuffer(int count);
      56             :   static fft_cplx_scoper AllocCplxBuffer(int count);
      57             : 
      58             :   // Main forward transform interface. The output array need only be big
      59             :   // enough for |2^order / 2 + 1| elements - the conjugate pairs are not
      60             :   // returned. Input and output must be properly aligned (e.g. through
      61             :   // AllocRealBuffer and AllocCplxBuffer) and input length must be
      62             :   // |2^order| (same as given at construction time).
      63             :   virtual void Forward(const float* src, std::complex<float>* dest) const = 0;
      64             : 
      65             :   // Inverse transform. Same input format as output above, conjugate pairs
      66             :   // not needed.
      67             :   virtual void Inverse(const std::complex<float>* src, float* dest) const = 0;
      68             : 
      69             :   virtual int order() const = 0;
      70             : };
      71             : 
      72             : }  // namespace webrtc
      73             : 
      74             : #endif  // WEBRTC_COMMON_AUDIO_REAL_FOURIER_H_
      75             :