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
60
61
62
63
64
65
|
// 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.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif
#include "third_party/blink/renderer/platform/audio/simple_fft_convolver.h"
#include "third_party/blink/renderer/platform/audio/vector_math.h"
namespace blink {
SimpleFFTConvolver::SimpleFFTConvolver(
unsigned input_block_size,
const std::unique_ptr<AudioFloatArray>& convolution_kernel)
: convolution_kernel_size_(convolution_kernel->size()),
fft_kernel_(2 * input_block_size),
frame_(2 * input_block_size),
input_buffer_(2 *
input_block_size), // 2nd half of buffer is always zeroed
output_buffer_(2 * input_block_size),
last_overlap_buffer_(input_block_size) {
DCHECK_LE(convolution_kernel_size_, FftSize() / 2);
// Do padded FFT to get frequency-domain version of the convolution kernel.
// This FFT and caching is done once in here so that it does not have to be
// done repeatedly in |Process|.
fft_kernel_.DoPaddedFFT(convolution_kernel->Data(), convolution_kernel_size_);
}
void SimpleFFTConvolver::Process(const float* source_p,
float* dest_p,
uint32_t frames_to_process) {
unsigned half_size = FftSize() / 2;
// frames_to_process must be exactly half_size.
DCHECK(source_p);
DCHECK(dest_p);
DCHECK_EQ(frames_to_process, half_size);
// Do padded FFT (get frequency-domain version) by copying samples to the 1st
// half of the input buffer (the second half is always zero), multiply in
// frequency-domain and do inverse FFT to get output samples.
input_buffer_.CopyToRange(source_p, 0, half_size);
frame_.DoFFT(input_buffer_.Data());
frame_.Multiply(fft_kernel_);
frame_.DoInverseFFT(output_buffer_.Data());
// Overlap-add 1st half with 2nd half from previous time and write
// to destination.
vector_math::Vadd(output_buffer_.Data(), 1, last_overlap_buffer_.Data(), 1,
dest_p, 1, half_size);
// Finally, save 2nd half for the next time.
last_overlap_buffer_.CopyToRange(output_buffer_.Data() + half_size, 0,
half_size);
}
void SimpleFFTConvolver::Reset() {
last_overlap_buffer_.Zero();
}
} // namespace blink
|
