| /* |
| * Copyright (c) 2017 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 "modules/audio_processing/aec3/render_delay_controller.h" |
| |
| #include <algorithm> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "modules/audio_processing/aec3/aec3_common.h" |
| #include "modules/audio_processing/aec3/echo_path_delay_estimator.h" |
| #include "modules/audio_processing/aec3/render_delay_controller_metrics.h" |
| #include "modules/audio_processing/include/audio_processing.h" |
| #include "rtc_base/atomicops.h" |
| #include "rtc_base/constructormagic.h" |
| |
| namespace webrtc { |
| |
| namespace { |
| |
| class RenderDelayControllerImpl final : public RenderDelayController { |
| public: |
| RenderDelayControllerImpl(const EchoCanceller3Config& config, |
| int sample_rate_hz); |
| ~RenderDelayControllerImpl() override; |
| void Reset() override; |
| void SetDelay(size_t render_delay) override; |
| size_t GetDelay(const DownsampledRenderBuffer& render_buffer, |
| rtc::ArrayView<const float> capture) override; |
| rtc::Optional<size_t> AlignmentHeadroomSamples() const override { |
| return headroom_samples_; |
| } |
| |
| private: |
| static int instance_count_; |
| std::unique_ptr<ApmDataDumper> data_dumper_; |
| const size_t default_delay_; |
| size_t delay_; |
| EchoPathDelayEstimator delay_estimator_; |
| size_t blocks_since_last_delay_estimate_ = 300000; |
| int echo_path_delay_samples_; |
| size_t align_call_counter_ = 0; |
| rtc::Optional<size_t> headroom_samples_; |
| std::vector<float> capture_delay_buffer_; |
| int capture_delay_buffer_index_ = 0; |
| RenderDelayControllerMetrics metrics_; |
| RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RenderDelayControllerImpl); |
| }; |
| |
| size_t ComputeNewBufferDelay(size_t current_delay, |
| size_t echo_path_delay_samples) { |
| // The below division is not exact and the truncation is intended. |
| const int echo_path_delay_blocks = echo_path_delay_samples / kBlockSize; |
| constexpr int kDelayHeadroomBlocks = 1; |
| |
| // Compute the buffer delay increase required to achieve the desired latency. |
| size_t new_delay = std::max(echo_path_delay_blocks - kDelayHeadroomBlocks, 0); |
| |
| // Add hysteresis. |
| if (new_delay == current_delay + 1) { |
| new_delay = current_delay; |
| } |
| |
| return new_delay; |
| } |
| |
| int RenderDelayControllerImpl::instance_count_ = 0; |
| |
| RenderDelayControllerImpl::RenderDelayControllerImpl( |
| const EchoCanceller3Config& config, |
| int sample_rate_hz) |
| : data_dumper_( |
| new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))), |
| default_delay_( |
| std::max(config.delay.default_delay, kMinEchoPathDelayBlocks)), |
| delay_(default_delay_), |
| delay_estimator_(data_dumper_.get(), config), |
| echo_path_delay_samples_(default_delay_ * kBlockSize), |
| capture_delay_buffer_(kBlockSize * (kMaxApiCallsJitterBlocks + 2), 0.f) { |
| RTC_DCHECK(ValidFullBandRate(sample_rate_hz)); |
| } |
| |
| RenderDelayControllerImpl::~RenderDelayControllerImpl() = default; |
| |
| void RenderDelayControllerImpl::Reset() { |
| delay_ = default_delay_; |
| blocks_since_last_delay_estimate_ = 300000; |
| echo_path_delay_samples_ = delay_ * kBlockSize; |
| align_call_counter_ = 0; |
| headroom_samples_ = rtc::Optional<size_t>(); |
| std::fill(capture_delay_buffer_.begin(), capture_delay_buffer_.end(), 0.f); |
| delay_estimator_.Reset(); |
| } |
| |
| void RenderDelayControllerImpl::SetDelay(size_t render_delay) { |
| if (delay_ != render_delay) { |
| // If a the delay set does not match the actual delay, reset the delay |
| // controller. |
| Reset(); |
| delay_ = render_delay; |
| } |
| } |
| |
| size_t RenderDelayControllerImpl::GetDelay( |
| const DownsampledRenderBuffer& render_buffer, |
| rtc::ArrayView<const float> capture) { |
| RTC_DCHECK_EQ(kBlockSize, capture.size()); |
| |
| ++align_call_counter_; |
| |
| // Estimate the delay with a delayed capture signal in order to catch |
| // noncausal delays. |
| RTC_DCHECK_LT(capture_delay_buffer_index_ + kBlockSize - 1, |
| capture_delay_buffer_.size()); |
| const rtc::Optional<size_t> echo_path_delay_samples_shifted = |
| delay_estimator_.EstimateDelay( |
| render_buffer, |
| rtc::ArrayView<const float>( |
| &capture_delay_buffer_[capture_delay_buffer_index_], kBlockSize)); |
| std::copy(capture.begin(), capture.end(), |
| capture_delay_buffer_.begin() + capture_delay_buffer_index_); |
| capture_delay_buffer_index_ = |
| (capture_delay_buffer_index_ + kBlockSize) % capture_delay_buffer_.size(); |
| |
| if (echo_path_delay_samples_shifted) { |
| blocks_since_last_delay_estimate_ = 0; |
| |
| // Correct for the capture signal delay. |
| const int echo_path_delay_samples_corrected = |
| static_cast<int>(*echo_path_delay_samples_shifted) - |
| static_cast<int>(capture_delay_buffer_.size()); |
| echo_path_delay_samples_ = std::max(0, echo_path_delay_samples_corrected); |
| |
| // Compute and set new render delay buffer delay. |
| const size_t new_delay = |
| ComputeNewBufferDelay(delay_, echo_path_delay_samples_); |
| if (align_call_counter_ > kNumBlocksPerSecond) { |
| delay_ = new_delay; |
| |
| // Update render delay buffer headroom. |
| if (echo_path_delay_samples_corrected >= 0) { |
| const int headroom = echo_path_delay_samples_ - delay_ * kBlockSize; |
| RTC_DCHECK_LE(0, headroom); |
| headroom_samples_ = rtc::Optional<size_t>(headroom); |
| } else { |
| headroom_samples_ = rtc::Optional<size_t>(); |
| } |
| } |
| |
| metrics_.Update(rtc::Optional<size_t>(echo_path_delay_samples_), delay_); |
| } else { |
| metrics_.Update(rtc::Optional<size_t>(), delay_); |
| } |
| |
| data_dumper_->DumpRaw("aec3_render_delay_controller_delay", 1, |
| &echo_path_delay_samples_); |
| data_dumper_->DumpRaw("aec3_render_delay_controller_buffer_delay", delay_); |
| |
| return delay_; |
| } |
| |
| } // namespace |
| |
| RenderDelayController* RenderDelayController::Create( |
| const EchoCanceller3Config& config, |
| int sample_rate_hz) { |
| return new RenderDelayControllerImpl(config, sample_rate_hz); |
| } |
| |
| } // namespace webrtc |