OLD | NEW |
| (Empty) |
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 #include "webrtc/modules/audio_processing/utility/lapped_transform.h" | |
12 | |
13 #include <algorithm> | |
14 #include <cstdlib> | |
15 #include <cstring> | |
16 | |
17 #include "webrtc/base/checks.h" | |
18 #include "webrtc/common_audio/real_fourier.h" | |
19 | |
20 namespace webrtc { | |
21 | |
22 void LappedTransform::BlockThunk::ProcessBlock(const float* const* input, | |
23 size_t num_frames, | |
24 size_t num_input_channels, | |
25 size_t num_output_channels, | |
26 float* const* output) { | |
27 RTC_CHECK_EQ(num_input_channels, parent_->num_in_channels_); | |
28 RTC_CHECK_EQ(num_output_channels, parent_->num_out_channels_); | |
29 RTC_CHECK_EQ(parent_->block_length_, num_frames); | |
30 | |
31 for (size_t i = 0; i < num_input_channels; ++i) { | |
32 memcpy(parent_->real_buf_.Row(i), input[i], | |
33 num_frames * sizeof(*input[0])); | |
34 parent_->fft_->Forward(parent_->real_buf_.Row(i), | |
35 parent_->cplx_pre_.Row(i)); | |
36 } | |
37 | |
38 size_t block_length = RealFourier::ComplexLength( | |
39 RealFourier::FftOrder(num_frames)); | |
40 RTC_CHECK_EQ(parent_->cplx_length_, block_length); | |
41 parent_->block_processor_->ProcessAudioBlock(parent_->cplx_pre_.Array(), | |
42 num_input_channels, | |
43 parent_->cplx_length_, | |
44 num_output_channels, | |
45 parent_->cplx_post_.Array()); | |
46 | |
47 for (size_t i = 0; i < num_output_channels; ++i) { | |
48 parent_->fft_->Inverse(parent_->cplx_post_.Row(i), | |
49 parent_->real_buf_.Row(i)); | |
50 memcpy(output[i], parent_->real_buf_.Row(i), | |
51 num_frames * sizeof(*input[0])); | |
52 } | |
53 } | |
54 | |
55 LappedTransform::LappedTransform(size_t num_in_channels, | |
56 size_t num_out_channels, | |
57 size_t chunk_length, | |
58 const float* window, | |
59 size_t block_length, | |
60 size_t shift_amount, | |
61 Callback* callback) | |
62 : blocker_callback_(this), | |
63 num_in_channels_(num_in_channels), | |
64 num_out_channels_(num_out_channels), | |
65 block_length_(block_length), | |
66 chunk_length_(chunk_length), | |
67 block_processor_(callback), | |
68 blocker_(chunk_length_, | |
69 block_length_, | |
70 num_in_channels_, | |
71 num_out_channels_, | |
72 window, | |
73 shift_amount, | |
74 &blocker_callback_), | |
75 fft_(rtc::ScopedToUnique( | |
76 RealFourier::Create(RealFourier::FftOrder(block_length_)))), | |
77 cplx_length_(RealFourier::ComplexLength(fft_->order())), | |
78 real_buf_(num_in_channels, | |
79 block_length_, | |
80 RealFourier::kFftBufferAlignment), | |
81 cplx_pre_(num_in_channels, | |
82 cplx_length_, | |
83 RealFourier::kFftBufferAlignment), | |
84 cplx_post_(num_out_channels, | |
85 cplx_length_, | |
86 RealFourier::kFftBufferAlignment) { | |
87 RTC_CHECK(num_in_channels_ > 0 && num_out_channels_ > 0); | |
88 RTC_CHECK_GT(block_length_, 0u); | |
89 RTC_CHECK_GT(chunk_length_, 0u); | |
90 RTC_CHECK(block_processor_); | |
91 | |
92 // block_length_ power of 2? | |
93 RTC_CHECK_EQ(0u, block_length_ & (block_length_ - 1)); | |
94 } | |
95 | |
96 void LappedTransform::ProcessChunk(const float* const* in_chunk, | |
97 float* const* out_chunk) { | |
98 blocker_.ProcessChunk(in_chunk, chunk_length_, num_in_channels_, | |
99 num_out_channels_, out_chunk); | |
100 } | |
101 | |
102 } // namespace webrtc | |
OLD | NEW |