File: simple_fft_convolver.h

package info (click to toggle)
chromium 138.0.7204.183-1
  • links: PTS, VCS
  • area: main
  • in suites: trixie
  • size: 6,071,908 kB
  • sloc: cpp: 34,937,088; ansic: 7,176,967; javascript: 4,110,704; python: 1,419,953; asm: 946,768; xml: 739,971; pascal: 187,324; sh: 89,623; perl: 88,663; objc: 79,944; sql: 50,304; cs: 41,786; fortran: 24,137; makefile: 21,806; php: 13,980; tcl: 13,166; yacc: 8,925; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (59 lines) | stat: -rw-r--r-- 2,064 bytes parent folder | download | duplicates (6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_AUDIO_SIMPLE_FFT_CONVOLVER_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_AUDIO_SIMPLE_FFT_CONVOLVER_H_

#include <memory>
#include "third_party/blink/renderer/platform/audio/audio_array.h"
#include "third_party/blink/renderer/platform/audio/fft_frame.h"
#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"

namespace blink {

// The SimpleFFTConvolver does an FFT convolution. It differs from
// the FFTConvolver in that it restricts the maximum size of
// |convolution_kernel| to |input_block_size|. This restriction allows it to do
// an FFT on every Process call. Therefore, the processing delay of
// the SimpleFFTConvolver is the same as that of the DirectConvolver and thus
// smaller than that of the FFTConvolver.
class SimpleFFTConvolver final {
  USING_FAST_MALLOC(SimpleFFTConvolver);

 public:
  SimpleFFTConvolver(
      unsigned input_block_size,
      const std::unique_ptr<AudioFloatArray>& convolution_kernel);
  SimpleFFTConvolver(const SimpleFFTConvolver&) = delete;
  SimpleFFTConvolver& operator=(const SimpleFFTConvolver&) = delete;

  void Process(const float* source_p,
               float* dest_p,
               uint32_t frames_to_process);

  void Reset();

  uint32_t ConvolutionKernelSize() const { return convolution_kernel_size_; }

 private:
  unsigned FftSize() const { return frame_.FftSize(); }

  uint32_t convolution_kernel_size_;
  FFTFrame fft_kernel_;
  FFTFrame frame_;

  // Buffer input until we get fftSize / 2 samples then do an FFT
  AudioFloatArray input_buffer_;

  // Stores output which we read a little at a time
  AudioFloatArray output_buffer_;

  // Saves the 2nd half of the FFT buffer, so we can do an overlap-add with the
  // 1st half of the next one
  AudioFloatArray last_overlap_buffer_;
};

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_AUDIO_SIMPLE_FFT_CONVOLVER_H_