blob: cf953ae2059bb94c0b3f811fbc74f3d36866a116 [file] [log] [blame]
peahe0eae3c2016-12-14 01:16:23 -08001/*
2 * Copyright (c) 2016 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 */
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020010#include "modules/audio_processing/aec3/echo_canceller3.h"
peahe0eae3c2016-12-14 01:16:23 -080011
Yves Gerey988cc082018-10-23 12:03:01 +020012#include <algorithm>
13#include <utility>
14
15#include "modules/audio_processing/aec3/aec3_common.h"
Per Åhgren0aefbf02019-08-23 21:29:17 +020016#include "modules/audio_processing/high_pass_filter.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020017#include "modules/audio_processing/logging/apm_data_dumper.h"
Steve Anton10542f22019-01-11 09:11:00 -080018#include "rtc_base/atomic_ops.h"
Gustaf Ullberg9249fbf2019-03-14 11:24:54 +010019#include "system_wrappers/include/field_trial.h"
peahe0eae3c2016-12-14 01:16:23 -080020
21namespace webrtc {
22
peahd0263542017-01-03 04:20:34 -080023namespace {
24
peahcf02cf12017-04-05 14:18:07 -070025enum class EchoCanceller3ApiCall { kCapture, kRender };
26
peahd0263542017-01-03 04:20:34 -080027bool DetectSaturation(rtc::ArrayView<const float> y) {
28 for (auto y_k : y) {
peah522d71b2017-02-23 05:16:26 -080029 if (y_k >= 32700.0f || y_k <= -32700.0f) {
peahd0263542017-01-03 04:20:34 -080030 return true;
31 }
32 }
33 return false;
34}
35
Per Åhgren251c7352018-03-28 16:31:57 +020036// Method for adjusting config parameter dependencies..
37EchoCanceller3Config AdjustConfig(const EchoCanceller3Config& config) {
38 EchoCanceller3Config adjusted_cfg = config;
Gustaf Ullberg9249fbf2019-03-14 11:24:54 +010039
40 if (field_trial::IsEnabled("WebRTC-Aec3ShortHeadroomKillSwitch")) {
41 // Two blocks headroom.
42 adjusted_cfg.delay.delay_headroom_samples = kBlockSize * 2;
43 }
44
Per Åhgren251c7352018-03-28 16:31:57 +020045 return adjusted_cfg;
46}
47
Per Åhgrence202a02019-09-02 17:01:19 +020048void FillSubFrameView(
49 AudioBuffer* frame,
50 size_t sub_frame_index,
51 std::vector<std::vector<rtc::ArrayView<float>>>* sub_frame_view) {
peahd0263542017-01-03 04:20:34 -080052 RTC_DCHECK_GE(1, sub_frame_index);
53 RTC_DCHECK_LE(0, sub_frame_index);
54 RTC_DCHECK_EQ(frame->num_bands(), sub_frame_view->size());
Per Åhgrence202a02019-09-02 17:01:19 +020055 RTC_DCHECK_EQ(frame->num_channels(), (*sub_frame_view)[0].size());
56 for (size_t band = 0; band < sub_frame_view->size(); ++band) {
57 for (size_t channel = 0; channel < (*sub_frame_view)[0].size(); ++channel) {
58 (*sub_frame_view)[band][channel] = rtc::ArrayView<float>(
59 &frame->split_bands(channel)[band][sub_frame_index * kSubFrameLength],
60 kSubFrameLength);
61 }
peahd0263542017-01-03 04:20:34 -080062 }
63}
64
Per Åhgrence202a02019-09-02 17:01:19 +020065void FillSubFrameView(
66 std::vector<std::vector<std::vector<float>>>* frame,
67 size_t sub_frame_index,
68 std::vector<std::vector<rtc::ArrayView<float>>>* sub_frame_view) {
peahd0263542017-01-03 04:20:34 -080069 RTC_DCHECK_GE(1, sub_frame_index);
70 RTC_DCHECK_EQ(frame->size(), sub_frame_view->size());
Per Åhgrence202a02019-09-02 17:01:19 +020071 RTC_DCHECK_EQ((*frame)[0].size(), (*sub_frame_view)[0].size());
72 for (size_t band = 0; band < frame->size(); ++band) {
73 for (size_t channel = 0; channel < (*frame)[band].size(); ++channel) {
74 (*sub_frame_view)[band][channel] = rtc::ArrayView<float>(
75 &(*frame)[band][channel][sub_frame_index * kSubFrameLength],
76 kSubFrameLength);
77 }
peahd0263542017-01-03 04:20:34 -080078 }
79}
80
81void ProcessCaptureFrameContent(
82 AudioBuffer* capture,
peah69221db2017-01-27 03:28:19 -080083 bool level_change,
peahd0263542017-01-03 04:20:34 -080084 bool saturated_microphone_signal,
85 size_t sub_frame_index,
86 FrameBlocker* capture_blocker,
87 BlockFramer* output_framer,
88 BlockProcessor* block_processor,
Per Åhgrence202a02019-09-02 17:01:19 +020089 std::vector<std::vector<std::vector<float>>>* block,
90 std::vector<std::vector<rtc::ArrayView<float>>>* sub_frame_view) {
peahd0263542017-01-03 04:20:34 -080091 FillSubFrameView(capture, sub_frame_index, sub_frame_view);
92 capture_blocker->InsertSubFrameAndExtractBlock(*sub_frame_view, block);
peah69221db2017-01-27 03:28:19 -080093 block_processor->ProcessCapture(level_change, saturated_microphone_signal,
94 block);
peahd0263542017-01-03 04:20:34 -080095 output_framer->InsertBlockAndExtractSubFrame(*block, sub_frame_view);
96}
97
98void ProcessRemainingCaptureFrameContent(
peah69221db2017-01-27 03:28:19 -080099 bool level_change,
peahd0263542017-01-03 04:20:34 -0800100 bool saturated_microphone_signal,
101 FrameBlocker* capture_blocker,
102 BlockFramer* output_framer,
103 BlockProcessor* block_processor,
Per Åhgrence202a02019-09-02 17:01:19 +0200104 std::vector<std::vector<std::vector<float>>>* block) {
peahd0263542017-01-03 04:20:34 -0800105 if (!capture_blocker->IsBlockAvailable()) {
106 return;
107 }
108
109 capture_blocker->ExtractBlock(block);
peah69221db2017-01-27 03:28:19 -0800110 block_processor->ProcessCapture(level_change, saturated_microphone_signal,
111 block);
peahd0263542017-01-03 04:20:34 -0800112 output_framer->InsertBlock(*block);
113}
114
peahcf02cf12017-04-05 14:18:07 -0700115void BufferRenderFrameContent(
Per Åhgrence202a02019-09-02 17:01:19 +0200116 std::vector<std::vector<std::vector<float>>>* render_frame,
peahd0263542017-01-03 04:20:34 -0800117 size_t sub_frame_index,
118 FrameBlocker* render_blocker,
119 BlockProcessor* block_processor,
Per Åhgrence202a02019-09-02 17:01:19 +0200120 std::vector<std::vector<std::vector<float>>>* block,
121 std::vector<std::vector<rtc::ArrayView<float>>>* sub_frame_view) {
peahd0263542017-01-03 04:20:34 -0800122 FillSubFrameView(render_frame, sub_frame_index, sub_frame_view);
123 render_blocker->InsertSubFrameAndExtractBlock(*sub_frame_view, block);
peahcf02cf12017-04-05 14:18:07 -0700124 block_processor->BufferRender(*block);
peahd0263542017-01-03 04:20:34 -0800125}
126
Per Åhgrence202a02019-09-02 17:01:19 +0200127void BufferRemainingRenderFrameContent(
128 FrameBlocker* render_blocker,
129 BlockProcessor* block_processor,
130 std::vector<std::vector<std::vector<float>>>* block) {
peahd0263542017-01-03 04:20:34 -0800131 if (!render_blocker->IsBlockAvailable()) {
peahcf02cf12017-04-05 14:18:07 -0700132 return;
peahd0263542017-01-03 04:20:34 -0800133 }
134 render_blocker->ExtractBlock(block);
peahcf02cf12017-04-05 14:18:07 -0700135 block_processor->BufferRender(*block);
peahd0263542017-01-03 04:20:34 -0800136}
137
Per Åhgren0aefbf02019-08-23 21:29:17 +0200138void CopyBufferIntoFrame(const AudioBuffer& buffer,
peahcf02cf12017-04-05 14:18:07 -0700139 size_t num_bands,
Per Åhgrence202a02019-09-02 17:01:19 +0200140 size_t num_channels,
141 std::vector<std::vector<std::vector<float>>>* frame) {
peahd0263542017-01-03 04:20:34 -0800142 RTC_DCHECK_EQ(num_bands, frame->size());
Per Åhgrence202a02019-09-02 17:01:19 +0200143 RTC_DCHECK_EQ(num_channels, (*frame)[0].size());
144 RTC_DCHECK_EQ(AudioBuffer::kSplitBandSize, (*frame)[0][0].size());
145 for (size_t band = 0; band < num_bands; ++band) {
146 for (size_t channel = 0; channel < num_channels; ++channel) {
147 rtc::ArrayView<const float> buffer_view(
148 &buffer.split_bands_const(channel)[band][0],
149 AudioBuffer::kSplitBandSize);
150 std::copy(buffer_view.begin(), buffer_view.end(),
151 (*frame)[band][channel].begin());
152 }
peahcf02cf12017-04-05 14:18:07 -0700153 }
peahd0263542017-01-03 04:20:34 -0800154}
155
peahd0263542017-01-03 04:20:34 -0800156} // namespace
157
158class EchoCanceller3::RenderWriter {
159 public:
Mirko Bonadeif0d9cda2019-01-17 20:43:58 +0000160 RenderWriter(ApmDataDumper* data_dumper,
Per Åhgrence202a02019-09-02 17:01:19 +0200161 SwapQueue<std::vector<std::vector<std::vector<float>>>,
Mirko Bonadeif0d9cda2019-01-17 20:43:58 +0000162 Aec3RenderQueueItemVerifier>* render_transfer_queue,
Per Åhgrence202a02019-09-02 17:01:19 +0200163 size_t num_bands,
164 size_t num_channels);
peahd0263542017-01-03 04:20:34 -0800165 ~RenderWriter();
Per Åhgren0aefbf02019-08-23 21:29:17 +0200166 void Insert(const AudioBuffer& input);
peahd0263542017-01-03 04:20:34 -0800167
168 private:
169 ApmDataDumper* data_dumper_;
Per Åhgrence202a02019-09-02 17:01:19 +0200170 const size_t num_bands_;
171 const size_t num_channels_;
Per Åhgren0aefbf02019-08-23 21:29:17 +0200172 HighPassFilter high_pass_filter_;
Per Åhgrence202a02019-09-02 17:01:19 +0200173 std::vector<std::vector<std::vector<float>>> render_queue_input_frame_;
174 SwapQueue<std::vector<std::vector<std::vector<float>>>,
175 Aec3RenderQueueItemVerifier>* render_transfer_queue_;
peahd0263542017-01-03 04:20:34 -0800176 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RenderWriter);
177};
178
179EchoCanceller3::RenderWriter::RenderWriter(
180 ApmDataDumper* data_dumper,
Per Åhgrence202a02019-09-02 17:01:19 +0200181 SwapQueue<std::vector<std::vector<std::vector<float>>>,
182 Aec3RenderQueueItemVerifier>* render_transfer_queue,
183 size_t num_bands,
184 size_t num_channels)
peahd0263542017-01-03 04:20:34 -0800185 : data_dumper_(data_dumper),
peahd0263542017-01-03 04:20:34 -0800186 num_bands_(num_bands),
Per Åhgrence202a02019-09-02 17:01:19 +0200187 num_channels_(num_channels),
188 high_pass_filter_(num_channels),
189 render_queue_input_frame_(
190 num_bands_,
191 std::vector<std::vector<float>>(
192 num_channels_,
193 std::vector<float>(AudioBuffer::kSplitBandSize, 0.f))),
peahd0263542017-01-03 04:20:34 -0800194 render_transfer_queue_(render_transfer_queue) {
195 RTC_DCHECK(data_dumper);
196}
197
198EchoCanceller3::RenderWriter::~RenderWriter() = default;
199
Per Åhgren0aefbf02019-08-23 21:29:17 +0200200void EchoCanceller3::RenderWriter::Insert(const AudioBuffer& input) {
201 RTC_DCHECK_EQ(1, input.num_channels());
Per Åhgrence202a02019-09-02 17:01:19 +0200202 RTC_DCHECK_EQ(AudioBuffer::kSplitBandSize, input.num_frames_per_band());
Per Åhgren0aefbf02019-08-23 21:29:17 +0200203 RTC_DCHECK_EQ(num_bands_, input.num_bands());
Gustaf Ullberg7d042782018-01-16 13:39:27 +0100204
205 // TODO(bugs.webrtc.org/8759) Temporary work-around.
Per Åhgrence202a02019-09-02 17:01:19 +0200206 if (num_bands_ != input.num_bands())
Gustaf Ullberg7d042782018-01-16 13:39:27 +0100207 return;
208
Per Åhgrence202a02019-09-02 17:01:19 +0200209 data_dumper_->DumpWav("aec3_render_input", AudioBuffer::kSplitBandSize,
210 &input.split_bands_const(0)[0][0], 16000, 1);
peahd0263542017-01-03 04:20:34 -0800211
Per Åhgrence202a02019-09-02 17:01:19 +0200212 CopyBufferIntoFrame(input, num_bands_, num_channels_,
peahcf02cf12017-04-05 14:18:07 -0700213 &render_queue_input_frame_);
Per Åhgrence202a02019-09-02 17:01:19 +0200214 for (size_t channel = 0; channel < num_channels_; ++channel) {
215 high_pass_filter_.Process(render_queue_input_frame_[0][channel]);
216 }
peahd0263542017-01-03 04:20:34 -0800217
peah925e9d72017-04-10 04:18:38 -0700218 static_cast<void>(render_transfer_queue_->Insert(&render_queue_input_frame_));
peahd0263542017-01-03 04:20:34 -0800219}
220
peahe0eae3c2016-12-14 01:16:23 -0800221int EchoCanceller3::instance_count_ = 0;
222
Gustaf Ullbergbd83b912017-10-18 12:32:42 +0200223EchoCanceller3::EchoCanceller3(const EchoCanceller3Config& config,
Per Åhgrence202a02019-09-02 17:01:19 +0200224 int sample_rate_hz,
225 size_t num_render_channels,
226 size_t num_capture_channels)
227 : EchoCanceller3(AdjustConfig(config),
228 sample_rate_hz,
229 num_render_channels,
230 num_capture_channels,
231 std::unique_ptr<BlockProcessor>(
232 BlockProcessor::Create(AdjustConfig(config),
233 sample_rate_hz,
234 num_render_channels,
235 num_capture_channels))) {}
Per Åhgren8ba58612017-12-01 23:01:44 +0100236EchoCanceller3::EchoCanceller3(const EchoCanceller3Config& config,
237 int sample_rate_hz,
Per Åhgrence202a02019-09-02 17:01:19 +0200238 size_t num_render_channels,
239 size_t num_capture_channels,
peahd0263542017-01-03 04:20:34 -0800240 std::unique_ptr<BlockProcessor> block_processor)
241 : data_dumper_(
242 new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))),
Per Åhgren398689f2018-08-23 11:38:27 +0200243 config_(config),
peahd0263542017-01-03 04:20:34 -0800244 sample_rate_hz_(sample_rate_hz),
245 num_bands_(NumBandsForRate(sample_rate_hz_)),
Per Åhgrence202a02019-09-02 17:01:19 +0200246 num_render_channels_(num_render_channels),
247 num_capture_channels_(num_capture_channels),
248 output_framer_(num_bands_, num_capture_channels_),
249 capture_blocker_(num_bands_, num_capture_channels_),
250 render_blocker_(num_bands_, num_render_channels_),
Mirko Bonadeif0d9cda2019-01-17 20:43:58 +0000251 render_transfer_queue_(
252 kRenderTransferQueueSizeFrames,
Per Åhgrence202a02019-09-02 17:01:19 +0200253 std::vector<std::vector<std::vector<float>>>(
Per Åhgrend112c752019-09-02 13:56:56 +0000254 num_bands_,
Per Åhgrence202a02019-09-02 17:01:19 +0200255 std::vector<std::vector<float>>(
256 num_render_channels_,
257 std::vector<float>(AudioBuffer::kSplitBandSize, 0.f))),
258 Aec3RenderQueueItemVerifier(num_bands_,
259 num_render_channels_,
260 AudioBuffer::kSplitBandSize)),
Per Åhgrend112c752019-09-02 13:56:56 +0000261 block_processor_(std::move(block_processor)),
Per Åhgrence202a02019-09-02 17:01:19 +0200262 render_queue_output_frame_(
263 num_bands_,
264 std::vector<std::vector<float>>(
265 num_render_channels_,
266 std::vector<float>(AudioBuffer::kSplitBandSize, 0.f))),
267 render_block_(
268 num_bands_,
269 std::vector<std::vector<float>>(num_render_channels_,
270 std::vector<float>(kBlockSize, 0.f))),
271 capture_block_(
272 num_bands_,
273 std::vector<std::vector<float>>(num_capture_channels_,
274 std::vector<float>(kBlockSize, 0.f))),
275 render_sub_frame_view_(
276 num_bands_,
277 std::vector<rtc::ArrayView<float>>(num_render_channels_)),
278 capture_sub_frame_view_(
279 num_bands_,
280 std::vector<rtc::ArrayView<float>>(num_capture_channels_)),
Per Åhgren398689f2018-08-23 11:38:27 +0200281 block_delay_buffer_(num_bands_,
Per Åhgrence202a02019-09-02 17:01:19 +0200282 AudioBuffer::kSplitBandSize,
Per Åhgren398689f2018-08-23 11:38:27 +0200283 config_.delay.fixed_capture_delay_samples) {
peah21920892017-02-08 05:08:56 -0800284 RTC_DCHECK(ValidFullBandRate(sample_rate_hz_));
285
Per Åhgrence202a02019-09-02 17:01:19 +0200286 render_writer_.reset(new RenderWriter(data_dumper_.get(),
287 &render_transfer_queue_, num_bands_,
288 num_render_channels_));
peahd0263542017-01-03 04:20:34 -0800289
290 RTC_DCHECK_EQ(num_bands_, std::max(sample_rate_hz_, 16000) / 16000);
291 RTC_DCHECK_GE(kMaxNumBands, num_bands_);
peahe0eae3c2016-12-14 01:16:23 -0800292}
293
294EchoCanceller3::~EchoCanceller3() = default;
295
Per Åhgren0aefbf02019-08-23 21:29:17 +0200296void EchoCanceller3::AnalyzeRender(const AudioBuffer& render) {
peahd0263542017-01-03 04:20:34 -0800297 RTC_DCHECK_RUNS_SERIALIZED(&render_race_checker_);
Per Åhgrence202a02019-09-02 17:01:19 +0200298 RTC_DCHECK_EQ(render.num_channels(), num_render_channels_);
peahcf02cf12017-04-05 14:18:07 -0700299 data_dumper_->DumpRaw("aec3_call_order",
300 static_cast<int>(EchoCanceller3ApiCall::kRender));
301
peahd0263542017-01-03 04:20:34 -0800302 return render_writer_->Insert(render);
peahe0eae3c2016-12-14 01:16:23 -0800303}
304
Per Åhgren0aefbf02019-08-23 21:29:17 +0200305void EchoCanceller3::AnalyzeCapture(const AudioBuffer& capture) {
peahd0263542017-01-03 04:20:34 -0800306 RTC_DCHECK_RUNS_SERIALIZED(&capture_race_checker_);
Per Åhgren0aefbf02019-08-23 21:29:17 +0200307 data_dumper_->DumpWav("aec3_capture_analyze_input", capture.num_frames(),
308 capture.channels_const()[0], sample_rate_hz_, 1);
peahd0263542017-01-03 04:20:34 -0800309
310 saturated_microphone_signal_ = false;
Per Åhgrence202a02019-09-02 17:01:19 +0200311 for (size_t channel = 0; channel < capture.num_channels(); ++channel) {
peahd0263542017-01-03 04:20:34 -0800312 saturated_microphone_signal_ |=
Per Åhgren0aefbf02019-08-23 21:29:17 +0200313 DetectSaturation(rtc::ArrayView<const float>(
Per Åhgrence202a02019-09-02 17:01:19 +0200314 capture.channels_const()[channel], capture.num_frames()));
peahd0263542017-01-03 04:20:34 -0800315 if (saturated_microphone_signal_) {
316 break;
317 }
318 }
319}
peahe0eae3c2016-12-14 01:16:23 -0800320
peah69221db2017-01-27 03:28:19 -0800321void EchoCanceller3::ProcessCapture(AudioBuffer* capture, bool level_change) {
peahd0263542017-01-03 04:20:34 -0800322 RTC_DCHECK_RUNS_SERIALIZED(&capture_race_checker_);
323 RTC_DCHECK(capture);
peahe0eae3c2016-12-14 01:16:23 -0800324 RTC_DCHECK_EQ(1u, capture->num_channels());
peahd0263542017-01-03 04:20:34 -0800325 RTC_DCHECK_EQ(num_bands_, capture->num_bands());
Per Åhgrence202a02019-09-02 17:01:19 +0200326 RTC_DCHECK_EQ(AudioBuffer::kSplitBandSize, capture->num_frames_per_band());
327 RTC_DCHECK_EQ(capture->num_channels(), num_capture_channels_);
peahcf02cf12017-04-05 14:18:07 -0700328 data_dumper_->DumpRaw("aec3_call_order",
329 static_cast<int>(EchoCanceller3ApiCall::kCapture));
peahd0263542017-01-03 04:20:34 -0800330
Per Åhgren14f252a2018-11-27 18:02:56 +0100331 // Report capture call in the metrics and periodically update API call
332 // metrics.
333 api_call_metrics_.ReportCaptureCall();
334
Per Åhgren398689f2018-08-23 11:38:27 +0200335 // Optionally delay the capture signal.
336 if (config_.delay.fixed_capture_delay_samples > 0) {
337 block_delay_buffer_.DelaySignal(capture);
338 }
339
Per Åhgrence202a02019-09-02 17:01:19 +0200340 rtc::ArrayView<float> capture_lower_band = rtc::ArrayView<float>(
341 &capture->split_bands(0)[0][0], AudioBuffer::kSplitBandSize);
peahd0263542017-01-03 04:20:34 -0800342
Per Åhgrence202a02019-09-02 17:01:19 +0200343 data_dumper_->DumpWav("aec3_capture_input", capture_lower_band, 16000, 1);
peahd0263542017-01-03 04:20:34 -0800344
peahcf02cf12017-04-05 14:18:07 -0700345 EmptyRenderQueue();
peahd0263542017-01-03 04:20:34 -0800346
Per Åhgrence202a02019-09-02 17:01:19 +0200347 ProcessCaptureFrameContent(capture, level_change,
348 saturated_microphone_signal_, 0, &capture_blocker_,
349 &output_framer_, block_processor_.get(),
350 &capture_block_, &capture_sub_frame_view_);
peahd0263542017-01-03 04:20:34 -0800351
Per Åhgrence202a02019-09-02 17:01:19 +0200352 ProcessCaptureFrameContent(capture, level_change,
353 saturated_microphone_signal_, 1, &capture_blocker_,
354 &output_framer_, block_processor_.get(),
355 &capture_block_, &capture_sub_frame_view_);
peahd0263542017-01-03 04:20:34 -0800356
357 ProcessRemainingCaptureFrameContent(
peah69221db2017-01-27 03:28:19 -0800358 level_change, saturated_microphone_signal_, &capture_blocker_,
Per Åhgrence202a02019-09-02 17:01:19 +0200359 &output_framer_, block_processor_.get(), &capture_block_);
peahd0263542017-01-03 04:20:34 -0800360
Per Åhgrence202a02019-09-02 17:01:19 +0200361 data_dumper_->DumpWav("aec3_capture_output", AudioBuffer::kSplitBandSize,
362 &capture->split_bands(0)[0][0], 16000, 1);
peahe0eae3c2016-12-14 01:16:23 -0800363}
364
Gustaf Ullberg332150d2017-11-22 14:17:39 +0100365EchoControl::Metrics EchoCanceller3::GetMetrics() const {
366 RTC_DCHECK_RUNS_SERIALIZED(&capture_race_checker_);
367 Metrics metrics;
368 block_processor_->GetMetrics(&metrics);
369 return metrics;
370}
371
Per Åhgrend0fa8202018-04-18 09:35:13 +0200372void EchoCanceller3::SetAudioBufferDelay(size_t delay_ms) {
373 RTC_DCHECK_RUNS_SERIALIZED(&capture_race_checker_);
374 block_processor_->SetAudioBufferDelay(delay_ms);
375}
376
peahcf02cf12017-04-05 14:18:07 -0700377void EchoCanceller3::EmptyRenderQueue() {
peahd0263542017-01-03 04:20:34 -0800378 RTC_DCHECK_RUNS_SERIALIZED(&capture_race_checker_);
peahd0263542017-01-03 04:20:34 -0800379 bool frame_to_buffer =
380 render_transfer_queue_.Remove(&render_queue_output_frame_);
381 while (frame_to_buffer) {
Per Åhgren14f252a2018-11-27 18:02:56 +0100382 // Report render call in the metrics.
383 api_call_metrics_.ReportRenderCall();
384
peahcf02cf12017-04-05 14:18:07 -0700385 BufferRenderFrameContent(&render_queue_output_frame_, 0, &render_blocker_,
Per Åhgrence202a02019-09-02 17:01:19 +0200386 block_processor_.get(), &render_block_,
387 &render_sub_frame_view_);
peahd0263542017-01-03 04:20:34 -0800388
Per Åhgrence202a02019-09-02 17:01:19 +0200389 BufferRenderFrameContent(&render_queue_output_frame_, 1, &render_blocker_,
390 block_processor_.get(), &render_block_,
391 &render_sub_frame_view_);
peahd0263542017-01-03 04:20:34 -0800392
peahcf02cf12017-04-05 14:18:07 -0700393 BufferRemainingRenderFrameContent(&render_blocker_, block_processor_.get(),
Per Åhgrence202a02019-09-02 17:01:19 +0200394 &render_block_);
peahd0263542017-01-03 04:20:34 -0800395
396 frame_to_buffer =
397 render_transfer_queue_.Remove(&render_queue_output_frame_);
398 }
peahd0263542017-01-03 04:20:34 -0800399}
peahe0eae3c2016-12-14 01:16:23 -0800400} // namespace webrtc