237 lines
8.2 KiB
C++
237 lines
8.2 KiB
C++
|
/*
|
||
|
|
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
|
||
|
|
*
|
||
|
|
* Use of this source code is governed by a BSD-style license
|
||
|
|
* that can be found in the LICENSE file in the root of the source
|
||
|
|
* tree. An additional intellectual property rights grant can be found
|
||
|
|
* in the file PATENTS. All contributing project authors may
|
||
|
|
* be found in the AUTHORS file in the root of the source tree.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "webrtc/common_audio/blocker.h"
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
#include "webrtc/base/checks.h"
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
// Adds |a| and |b| frame by frame into |result| (basically matrix addition).
|
||
|
|
void AddFrames(const float* const* a,
|
||
|
|
size_t a_start_index,
|
||
|
|
const float* const* b,
|
||
|
|
int b_start_index,
|
||
|
|
size_t num_frames,
|
||
|
|
size_t num_channels,
|
||
|
|
float* const* result,
|
||
|
|
size_t result_start_index) {
|
||
|
|
for (size_t i = 0; i < num_channels; ++i) {
|
||
|
|
for (size_t j = 0; j < num_frames; ++j) {
|
||
|
|
result[i][j + result_start_index] =
|
||
|
|
a[i][j + a_start_index] + b[i][j + b_start_index];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Copies |src| into |dst| channel by channel.
|
||
|
|
void CopyFrames(const float* const* src,
|
||
|
|
size_t src_start_index,
|
||
|
|
size_t num_frames,
|
||
|
|
size_t num_channels,
|
||
|
|
float* const* dst,
|
||
|
|
size_t dst_start_index) {
|
||
|
|
for (size_t i = 0; i < num_channels; ++i) {
|
||
|
|
memcpy(&dst[i][dst_start_index],
|
||
|
|
&src[i][src_start_index],
|
||
|
|
num_frames * sizeof(dst[i][dst_start_index]));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Moves |src| into |dst| channel by channel.
|
||
|
|
void MoveFrames(const float* const* src,
|
||
|
|
size_t src_start_index,
|
||
|
|
size_t num_frames,
|
||
|
|
size_t num_channels,
|
||
|
|
float* const* dst,
|
||
|
|
size_t dst_start_index) {
|
||
|
|
for (size_t i = 0; i < num_channels; ++i) {
|
||
|
|
memmove(&dst[i][dst_start_index],
|
||
|
|
&src[i][src_start_index],
|
||
|
|
num_frames * sizeof(dst[i][dst_start_index]));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ZeroOut(float* const* buffer,
|
||
|
|
size_t starting_idx,
|
||
|
|
size_t num_frames,
|
||
|
|
size_t num_channels) {
|
||
|
|
for (size_t i = 0; i < num_channels; ++i) {
|
||
|
|
memset(&buffer[i][starting_idx], 0,
|
||
|
|
num_frames * sizeof(buffer[i][starting_idx]));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Pointwise multiplies each channel of |frames| with |window|. Results are
|
||
|
|
// stored in |frames|.
|
||
|
|
void ApplyWindow(const float* window,
|
||
|
|
size_t num_frames,
|
||
|
|
size_t num_channels,
|
||
|
|
float* const* frames) {
|
||
|
|
for (size_t i = 0; i < num_channels; ++i) {
|
||
|
|
for (size_t j = 0; j < num_frames; ++j) {
|
||
|
|
frames[i][j] = frames[i][j] * window[j];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
size_t gcd(size_t a, size_t b) {
|
||
|
|
size_t tmp;
|
||
|
|
while (b) {
|
||
|
|
tmp = a;
|
||
|
|
a = b;
|
||
|
|
b = tmp % b;
|
||
|
|
}
|
||
|
|
return a;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
namespace webrtc {
|
||
|
|
|
||
|
|
Blocker::Blocker(size_t chunk_size,
|
||
|
|
size_t block_size,
|
||
|
|
size_t num_input_channels,
|
||
|
|
size_t num_output_channels,
|
||
|
|
const float* window,
|
||
|
|
size_t shift_amount,
|
||
|
|
BlockerCallback* callback)
|
||
|
|
: chunk_size_(chunk_size),
|
||
|
|
block_size_(block_size),
|
||
|
|
num_input_channels_(num_input_channels),
|
||
|
|
num_output_channels_(num_output_channels),
|
||
|
|
initial_delay_(block_size_ - gcd(chunk_size, shift_amount)),
|
||
|
|
frame_offset_(0),
|
||
|
|
input_buffer_(num_input_channels_, chunk_size_ + initial_delay_),
|
||
|
|
output_buffer_(chunk_size_ + initial_delay_, num_output_channels_),
|
||
|
|
input_block_(block_size_, num_input_channels_),
|
||
|
|
output_block_(block_size_, num_output_channels_),
|
||
|
|
window_(new float[block_size_]),
|
||
|
|
shift_amount_(shift_amount),
|
||
|
|
callback_(callback) {
|
||
|
|
RTC_CHECK_LE(num_output_channels_, num_input_channels_);
|
||
|
|
RTC_CHECK_LE(shift_amount_, block_size_);
|
||
|
|
|
||
|
|
memcpy(window_.get(), window, block_size_ * sizeof(*window_.get()));
|
||
|
|
input_buffer_.MoveReadPositionBackward(initial_delay_);
|
||
|
|
}
|
||
|
|
|
||
|
|
// When block_size < chunk_size the input and output buffers look like this:
|
||
|
|
//
|
||
|
|
// delay* chunk_size chunk_size + delay*
|
||
|
|
// buffer: <-------------|---------------------|---------------|>
|
||
|
|
// _a_ _b_ _c_
|
||
|
|
//
|
||
|
|
// On each call to ProcessChunk():
|
||
|
|
// 1. New input gets read into sections _b_ and _c_ of the input buffer.
|
||
|
|
// 2. We block starting from frame_offset.
|
||
|
|
// 3. We block until we reach a block |bl| that doesn't contain any frames
|
||
|
|
// from sections _a_ or _b_ of the input buffer.
|
||
|
|
// 4. We window the current block, fire the callback for processing, window
|
||
|
|
// again, and overlap/add to the output buffer.
|
||
|
|
// 5. We copy sections _a_ and _b_ of the output buffer into output.
|
||
|
|
// 6. For both the input and the output buffers, we copy section _c_ into
|
||
|
|
// section _a_.
|
||
|
|
// 7. We set the new frame_offset to be the difference between the first frame
|
||
|
|
// of |bl| and the border between sections _b_ and _c_.
|
||
|
|
//
|
||
|
|
// When block_size > chunk_size the input and output buffers look like this:
|
||
|
|
//
|
||
|
|
// chunk_size delay* chunk_size + delay*
|
||
|
|
// buffer: <-------------|---------------------|---------------|>
|
||
|
|
// _a_ _b_ _c_
|
||
|
|
//
|
||
|
|
// On each call to ProcessChunk():
|
||
|
|
// The procedure is the same as above, except for:
|
||
|
|
// 1. New input gets read into section _c_ of the input buffer.
|
||
|
|
// 3. We block until we reach a block |bl| that doesn't contain any frames
|
||
|
|
// from section _a_ of the input buffer.
|
||
|
|
// 5. We copy section _a_ of the output buffer into output.
|
||
|
|
// 6. For both the input and the output buffers, we copy sections _b_ and _c_
|
||
|
|
// into section _a_ and _b_.
|
||
|
|
// 7. We set the new frame_offset to be the difference between the first frame
|
||
|
|
// of |bl| and the border between sections _a_ and _b_.
|
||
|
|
//
|
||
|
|
// * delay here refers to inintial_delay_
|
||
|
|
//
|
||
|
|
// TODO(claguna): Look at using ring buffers to eliminate some copies.
|
||
|
|
void Blocker::ProcessChunk(const float* const* input,
|
||
|
|
size_t chunk_size,
|
||
|
|
size_t num_input_channels,
|
||
|
|
size_t num_output_channels,
|
||
|
|
float* const* output) {
|
||
|
|
RTC_CHECK_EQ(chunk_size, chunk_size_);
|
||
|
|
RTC_CHECK_EQ(num_input_channels, num_input_channels_);
|
||
|
|
RTC_CHECK_EQ(num_output_channels, num_output_channels_);
|
||
|
|
|
||
|
|
input_buffer_.Write(input, num_input_channels, chunk_size_);
|
||
|
|
size_t first_frame_in_block = frame_offset_;
|
||
|
|
|
||
|
|
// Loop through blocks.
|
||
|
|
while (first_frame_in_block < chunk_size_) {
|
||
|
|
input_buffer_.Read(input_block_.channels(), num_input_channels,
|
||
|
|
block_size_);
|
||
|
|
input_buffer_.MoveReadPositionBackward(block_size_ - shift_amount_);
|
||
|
|
|
||
|
|
ApplyWindow(window_.get(),
|
||
|
|
block_size_,
|
||
|
|
num_input_channels_,
|
||
|
|
input_block_.channels());
|
||
|
|
callback_->ProcessBlock(input_block_.channels(),
|
||
|
|
block_size_,
|
||
|
|
num_input_channels_,
|
||
|
|
num_output_channels_,
|
||
|
|
output_block_.channels());
|
||
|
|
ApplyWindow(window_.get(),
|
||
|
|
block_size_,
|
||
|
|
num_output_channels_,
|
||
|
|
output_block_.channels());
|
||
|
|
|
||
|
|
AddFrames(output_buffer_.channels(),
|
||
|
|
first_frame_in_block,
|
||
|
|
output_block_.channels(),
|
||
|
|
0,
|
||
|
|
block_size_,
|
||
|
|
num_output_channels_,
|
||
|
|
output_buffer_.channels(),
|
||
|
|
first_frame_in_block);
|
||
|
|
|
||
|
|
first_frame_in_block += shift_amount_;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Copy output buffer to output
|
||
|
|
CopyFrames(output_buffer_.channels(),
|
||
|
|
0,
|
||
|
|
chunk_size_,
|
||
|
|
num_output_channels_,
|
||
|
|
output,
|
||
|
|
0);
|
||
|
|
|
||
|
|
// Copy output buffer [chunk_size_, chunk_size_ + initial_delay]
|
||
|
|
// to output buffer [0, initial_delay], zero the rest.
|
||
|
|
MoveFrames(output_buffer_.channels(),
|
||
|
|
chunk_size,
|
||
|
|
initial_delay_,
|
||
|
|
num_output_channels_,
|
||
|
|
output_buffer_.channels(),
|
||
|
|
0);
|
||
|
|
ZeroOut(output_buffer_.channels(),
|
||
|
|
initial_delay_,
|
||
|
|
chunk_size_,
|
||
|
|
num_output_channels_);
|
||
|
|
|
||
|
|
// Calculate new starting frames.
|
||
|
|
frame_offset_ = first_frame_in_block - chunk_size_;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace webrtc
|