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/common_audio/blocker.h" 12 13 #include <string.h> 14 15 #include "webrtc/base/checks.h" 16 17 namespace { 18 19 // Adds |a| and |b| frame by frame into |result| (basically matrix addition). 20 void AddFrames(const float* const* a, 21 size_t a_start_index, 22 const float* const* b, 23 int b_start_index, 24 size_t num_frames, 25 size_t num_channels, 26 float* const* result, 27 size_t result_start_index) { 28 for (size_t i = 0; i < num_channels; ++i) { 29 for (size_t j = 0; j < num_frames; ++j) { 30 result[i][j + result_start_index] = 31 a[i][j + a_start_index] + b[i][j + b_start_index]; 32 } 33 } 34 } 35 36 // Copies |src| into |dst| channel by channel. 37 void CopyFrames(const float* const* src, 38 size_t src_start_index, 39 size_t num_frames, 40 size_t num_channels, 41 float* const* dst, 42 size_t dst_start_index) { 43 for (size_t i = 0; i < num_channels; ++i) { 44 memcpy(&dst[i][dst_start_index], 45 &src[i][src_start_index], 46 num_frames * sizeof(dst[i][dst_start_index])); 47 } 48 } 49 50 // Moves |src| into |dst| channel by channel. 51 void MoveFrames(const float* const* src, 52 size_t src_start_index, 53 size_t num_frames, 54 size_t num_channels, 55 float* const* dst, 56 size_t dst_start_index) { 57 for (size_t i = 0; i < num_channels; ++i) { 58 memmove(&dst[i][dst_start_index], 59 &src[i][src_start_index], 60 num_frames * sizeof(dst[i][dst_start_index])); 61 } 62 } 63 64 void ZeroOut(float* const* buffer, 65 size_t starting_idx, 66 size_t num_frames, 67 size_t num_channels) { 68 for (size_t i = 0; i < num_channels; ++i) { 69 memset(&buffer[i][starting_idx], 0, 70 num_frames * sizeof(buffer[i][starting_idx])); 71 } 72 } 73 74 // Pointwise multiplies each channel of |frames| with |window|. Results are 75 // stored in |frames|. 76 void ApplyWindow(const float* window, 77 size_t num_frames, 78 size_t num_channels, 79 float* const* frames) { 80 for (size_t i = 0; i < num_channels; ++i) { 81 for (size_t j = 0; j < num_frames; ++j) { 82 frames[i][j] = frames[i][j] * window[j]; 83 } 84 } 85 } 86 87 size_t gcd(size_t a, size_t b) { 88 size_t tmp; 89 while (b) { 90 tmp = a; 91 a = b; 92 b = tmp % b; 93 } 94 return a; 95 } 96 97 } // namespace 98 99 namespace webrtc { 100 101 Blocker::Blocker(size_t chunk_size, 102 size_t block_size, 103 size_t num_input_channels, 104 size_t num_output_channels, 105 const float* window, 106 size_t shift_amount, 107 BlockerCallback* callback) 108 : chunk_size_(chunk_size), 109 block_size_(block_size), 110 num_input_channels_(num_input_channels), 111 num_output_channels_(num_output_channels), 112 initial_delay_(block_size_ - gcd(chunk_size, shift_amount)), 113 frame_offset_(0), 114 input_buffer_(num_input_channels_, chunk_size_ + initial_delay_), 115 output_buffer_(chunk_size_ + initial_delay_, num_output_channels_), 116 input_block_(block_size_, num_input_channels_), 117 output_block_(block_size_, num_output_channels_), 118 window_(new float[block_size_]), 119 shift_amount_(shift_amount), 120 callback_(callback) { 121 RTC_CHECK_LE(num_output_channels_, num_input_channels_); 122 RTC_CHECK_LE(shift_amount_, block_size_); 123 124 memcpy(window_.get(), window, block_size_ * sizeof(*window_.get())); 125 input_buffer_.MoveReadPositionBackward(initial_delay_); 126 } 127 128 // When block_size < chunk_size the input and output buffers look like this: 129 // 130 // delay* chunk_size chunk_size + delay* 131 // buffer: <-------------|---------------------|---------------|> 132 // _a_ _b_ _c_ 133 // 134 // On each call to ProcessChunk(): 135 // 1. New input gets read into sections _b_ and _c_ of the input buffer. 136 // 2. We block starting from frame_offset. 137 // 3. We block until we reach a block |bl| that doesn't contain any frames 138 // from sections _a_ or _b_ of the input buffer. 139 // 4. We window the current block, fire the callback for processing, window 140 // again, and overlap/add to the output buffer. 141 // 5. We copy sections _a_ and _b_ of the output buffer into output. 142 // 6. For both the input and the output buffers, we copy section _c_ into 143 // section _a_. 144 // 7. We set the new frame_offset to be the difference between the first frame 145 // of |bl| and the border between sections _b_ and _c_. 146 // 147 // When block_size > chunk_size the input and output buffers look like this: 148 // 149 // chunk_size delay* chunk_size + delay* 150 // buffer: <-------------|---------------------|---------------|> 151 // _a_ _b_ _c_ 152 // 153 // On each call to ProcessChunk(): 154 // The procedure is the same as above, except for: 155 // 1. New input gets read into section _c_ of the input buffer. 156 // 3. We block until we reach a block |bl| that doesn't contain any frames 157 // from section _a_ of the input buffer. 158 // 5. We copy section _a_ of the output buffer into output. 159 // 6. For both the input and the output buffers, we copy sections _b_ and _c_ 160 // into section _a_ and _b_. 161 // 7. We set the new frame_offset to be the difference between the first frame 162 // of |bl| and the border between sections _a_ and _b_. 163 // 164 // * delay here refers to inintial_delay_ 165 // 166 // TODO(claguna): Look at using ring buffers to eliminate some copies. 167 void Blocker::ProcessChunk(const float* const* input, 168 size_t chunk_size, 169 size_t num_input_channels, 170 size_t num_output_channels, 171 float* const* output) { 172 RTC_CHECK_EQ(chunk_size, chunk_size_); 173 RTC_CHECK_EQ(num_input_channels, num_input_channels_); 174 RTC_CHECK_EQ(num_output_channels, num_output_channels_); 175 176 input_buffer_.Write(input, num_input_channels, chunk_size_); 177 size_t first_frame_in_block = frame_offset_; 178 179 // Loop through blocks. 180 while (first_frame_in_block < chunk_size_) { 181 input_buffer_.Read(input_block_.channels(), num_input_channels, 182 block_size_); 183 input_buffer_.MoveReadPositionBackward(block_size_ - shift_amount_); 184 185 ApplyWindow(window_.get(), 186 block_size_, 187 num_input_channels_, 188 input_block_.channels()); 189 callback_->ProcessBlock(input_block_.channels(), 190 block_size_, 191 num_input_channels_, 192 num_output_channels_, 193 output_block_.channels()); 194 ApplyWindow(window_.get(), 195 block_size_, 196 num_output_channels_, 197 output_block_.channels()); 198 199 AddFrames(output_buffer_.channels(), 200 first_frame_in_block, 201 output_block_.channels(), 202 0, 203 block_size_, 204 num_output_channels_, 205 output_buffer_.channels(), 206 first_frame_in_block); 207 208 first_frame_in_block += shift_amount_; 209 } 210 211 // Copy output buffer to output 212 CopyFrames(output_buffer_.channels(), 213 0, 214 chunk_size_, 215 num_output_channels_, 216 output, 217 0); 218 219 // Copy output buffer [chunk_size_, chunk_size_ + initial_delay] 220 // to output buffer [0, initial_delay], zero the rest. 221 MoveFrames(output_buffer_.channels(), 222 chunk_size, 223 initial_delay_, 224 num_output_channels_, 225 output_buffer_.channels(), 226 0); 227 ZeroOut(output_buffer_.channels(), 228 initial_delay_, 229 chunk_size_, 230 num_output_channels_); 231 232 // Calculate new starting frames. 233 frame_offset_ = first_frame_in_block - chunk_size_; 234 } 235 236 } // namespace webrtc 237
