1 /*
2 * Copyright (c) 2017 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 #include "modules/audio_processing/aec3/render_delay_controller.h"
11
12 #include <algorithm>
13 #include <memory>
14 #include <string>
15 #include <vector>
16
17 #include "modules/audio_processing/aec3/aec3_common.h"
18 #include "modules/audio_processing/aec3/echo_path_delay_estimator.h"
19 #include "modules/audio_processing/aec3/render_delay_controller_metrics.h"
20 #include "modules/audio_processing/include/audio_processing.h"
21 #include "rtc_base/atomicops.h"
22 #include "rtc_base/constructormagic.h"
23
24 namespace webrtc {
25
26 namespace {
27
28 class RenderDelayControllerImpl final : public RenderDelayController {
29 public:
30 RenderDelayControllerImpl(const EchoCanceller3Config& config,
31 int sample_rate_hz);
32 ~RenderDelayControllerImpl() override;
33 void Reset() override;
34 void SetDelay(size_t render_delay) override;
35 size_t GetDelay(const DownsampledRenderBuffer& render_buffer,
36 rtc::ArrayView<const float> capture) override;
AlignmentHeadroomSamples() const37 rtc::Optional<size_t> AlignmentHeadroomSamples() const override {
38 return headroom_samples_;
39 }
40
41 private:
42 static int instance_count_;
43 std::unique_ptr<ApmDataDumper> data_dumper_;
44 const size_t default_delay_;
45 size_t delay_;
46 size_t blocks_since_last_delay_estimate_ = 300000;
47 int echo_path_delay_samples_;
48 size_t align_call_counter_ = 0;
49 rtc::Optional<size_t> headroom_samples_;
50 std::vector<float> capture_delay_buffer_;
51 int capture_delay_buffer_index_ = 0;
52 RenderDelayControllerMetrics metrics_;
53 EchoPathDelayEstimator delay_estimator_;
54 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RenderDelayControllerImpl);
55 };
56
ComputeNewBufferDelay(size_t current_delay,size_t echo_path_delay_samples)57 size_t ComputeNewBufferDelay(size_t current_delay,
58 size_t echo_path_delay_samples) {
59 // The below division is not exact and the truncation is intended.
60 const int echo_path_delay_blocks = echo_path_delay_samples / kBlockSize;
61 constexpr int kDelayHeadroomBlocks = 1;
62
63 // Compute the buffer delay increase required to achieve the desired latency.
64 size_t new_delay = std::max(echo_path_delay_blocks - kDelayHeadroomBlocks, 0);
65
66 // Add hysteresis.
67 if (new_delay == current_delay + 1) {
68 new_delay = current_delay;
69 }
70
71 return new_delay;
72 }
73
74 int RenderDelayControllerImpl::instance_count_ = 0;
75
RenderDelayControllerImpl(const EchoCanceller3Config & config,int sample_rate_hz)76 RenderDelayControllerImpl::RenderDelayControllerImpl(
77 const EchoCanceller3Config& config,
78 int sample_rate_hz)
79 : data_dumper_(
80 new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))),
81 default_delay_(
82 std::max(config.delay.default_delay, kMinEchoPathDelayBlocks)),
83 delay_(default_delay_),
84 echo_path_delay_samples_(default_delay_ * kBlockSize),
85 capture_delay_buffer_(kBlockSize * (kMaxApiCallsJitterBlocks + 2), 0.f),
86 delay_estimator_(data_dumper_.get(), config) {
87 RTC_DCHECK(ValidFullBandRate(sample_rate_hz));
88 delay_estimator_.LogDelayEstimationProperties(sample_rate_hz,
89 capture_delay_buffer_.size());
90 }
91
92 RenderDelayControllerImpl::~RenderDelayControllerImpl() = default;
93
Reset()94 void RenderDelayControllerImpl::Reset() {
95 delay_ = default_delay_;
96 blocks_since_last_delay_estimate_ = 300000;
97 echo_path_delay_samples_ = delay_ * kBlockSize;
98 align_call_counter_ = 0;
99 headroom_samples_ = rtc::nullopt;
100 std::fill(capture_delay_buffer_.begin(), capture_delay_buffer_.end(), 0.f);
101 delay_estimator_.Reset();
102 }
103
SetDelay(size_t render_delay)104 void RenderDelayControllerImpl::SetDelay(size_t render_delay) {
105 if (delay_ != render_delay) {
106 // If a the delay set does not match the actual delay, reset the delay
107 // controller.
108 Reset();
109 delay_ = render_delay;
110 }
111 }
112
GetDelay(const DownsampledRenderBuffer & render_buffer,rtc::ArrayView<const float> capture)113 size_t RenderDelayControllerImpl::GetDelay(
114 const DownsampledRenderBuffer& render_buffer,
115 rtc::ArrayView<const float> capture) {
116 RTC_DCHECK_EQ(kBlockSize, capture.size());
117
118 ++align_call_counter_;
119
120 // Estimate the delay with a delayed capture signal in order to catch
121 // noncausal delays.
122 RTC_DCHECK_LT(capture_delay_buffer_index_ + kBlockSize - 1,
123 capture_delay_buffer_.size());
124 const rtc::Optional<size_t> echo_path_delay_samples_shifted =
125 delay_estimator_.EstimateDelay(
126 render_buffer,
127 rtc::ArrayView<const float>(
128 &capture_delay_buffer_[capture_delay_buffer_index_], kBlockSize));
129 std::copy(capture.begin(), capture.end(),
130 capture_delay_buffer_.begin() + capture_delay_buffer_index_);
131 capture_delay_buffer_index_ =
132 (capture_delay_buffer_index_ + kBlockSize) % capture_delay_buffer_.size();
133
134 if (echo_path_delay_samples_shifted) {
135 blocks_since_last_delay_estimate_ = 0;
136
137 // Correct for the capture signal delay.
138 const int echo_path_delay_samples_corrected =
139 static_cast<int>(*echo_path_delay_samples_shifted) -
140 static_cast<int>(capture_delay_buffer_.size());
141 echo_path_delay_samples_ = std::max(0, echo_path_delay_samples_corrected);
142
143 // Compute and set new render delay buffer delay.
144 const size_t new_delay =
145 ComputeNewBufferDelay(delay_, echo_path_delay_samples_);
146 if (align_call_counter_ > kNumBlocksPerSecond) {
147 delay_ = new_delay;
148
149 // Update render delay buffer headroom.
150 if (echo_path_delay_samples_corrected >= 0) {
151 const int headroom = echo_path_delay_samples_ - delay_ * kBlockSize;
152 RTC_DCHECK_LE(0, headroom);
153 headroom_samples_ = headroom;
154 } else {
155 headroom_samples_ = rtc::nullopt;
156 }
157 }
158
159 metrics_.Update(echo_path_delay_samples_, delay_);
160 } else {
161 metrics_.Update(rtc::nullopt, delay_);
162 }
163
164 data_dumper_->DumpRaw("aec3_render_delay_controller_delay", 1,
165 &echo_path_delay_samples_);
166 data_dumper_->DumpRaw("aec3_render_delay_controller_buffer_delay", delay_);
167
168 return delay_;
169 }
170
171 } // namespace
172
Create(const EchoCanceller3Config & config,int sample_rate_hz)173 RenderDelayController* RenderDelayController::Create(
174 const EchoCanceller3Config& config,
175 int sample_rate_hz) {
176 return new RenderDelayControllerImpl(config, sample_rate_hz);
177 }
178
179 } // namespace webrtc
180