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
17namespace {
18
19// Adds |a| and |b| frame by frame into |result| (basically matrix addition).
20void 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.
37void 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.
51void 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
64void 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|.
76void 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
87size_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
99namespace webrtc {
100
101Blocker::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.
167void 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