xref: /aosp_15_r20/external/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc (revision d9f758449e529ab9291ac668be2861e7a55c2422) 
1 /*
2  *  Copyright (c) 2015 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 "api/audio_codecs/opus/audio_encoder_opus.h"
12 
13 #include <array>
14 #include <memory>
15 #include <utility>
16 
17 #include "absl/strings/string_view.h"
18 #include "common_audio/mocks/mock_smoothing_filter.h"
19 #include "modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h"
20 #include "modules/audio_coding/codecs/opus/audio_encoder_opus.h"
21 #include "modules/audio_coding/codecs/opus/opus_interface.h"
22 #include "modules/audio_coding/neteq/tools/audio_loop.h"
23 #include "rtc_base/checks.h"
24 #include "rtc_base/fake_clock.h"
25 #include "test/field_trial.h"
26 #include "test/gmock.h"
27 #include "test/gtest.h"
28 #include "test/testsupport/file_utils.h"
29 
30 namespace webrtc {
31 using ::testing::NiceMock;
32 using ::testing::Return;
33 
34 namespace {
35 
36 constexpr int kDefaultOpusPayloadType = 105;
37 constexpr int kDefaultOpusRate = 32000;
38 constexpr int kDefaultOpusPacSize = 960;
39 constexpr int64_t kInitialTimeUs = 12345678;
40 
CreateConfigWithParameters(const SdpAudioFormat::Parameters & params)41 AudioEncoderOpusConfig CreateConfigWithParameters(
42     const SdpAudioFormat::Parameters& params) {
43   const SdpAudioFormat format("opus", 48000, 2, params);
44   return *AudioEncoderOpus::SdpToConfig(format);
45 }
46 
47 struct AudioEncoderOpusStates {
48   MockAudioNetworkAdaptor* mock_audio_network_adaptor;
49   MockSmoothingFilter* mock_bitrate_smoother;
50   std::unique_ptr<AudioEncoderOpusImpl> encoder;
51   std::unique_ptr<rtc::ScopedFakeClock> fake_clock;
52   AudioEncoderOpusConfig config;
53 };
54 
CreateCodec(int sample_rate_hz,size_t num_channels)55 std::unique_ptr<AudioEncoderOpusStates> CreateCodec(int sample_rate_hz,
56                                                     size_t num_channels) {
57   std::unique_ptr<AudioEncoderOpusStates> states =
58       std::make_unique<AudioEncoderOpusStates>();
59   states->mock_audio_network_adaptor = nullptr;
60   states->fake_clock.reset(new rtc::ScopedFakeClock());
61   states->fake_clock->SetTime(Timestamp::Micros(kInitialTimeUs));
62 
63   MockAudioNetworkAdaptor** mock_ptr = &states->mock_audio_network_adaptor;
64   AudioEncoderOpusImpl::AudioNetworkAdaptorCreator creator =
65       [mock_ptr](absl::string_view, RtcEventLog* event_log) {
66         std::unique_ptr<MockAudioNetworkAdaptor> adaptor(
67             new NiceMock<MockAudioNetworkAdaptor>());
68         EXPECT_CALL(*adaptor, Die());
69         *mock_ptr = adaptor.get();
70         return adaptor;
71       };
72 
73   AudioEncoderOpusConfig config;
74   config.frame_size_ms = rtc::CheckedDivExact(kDefaultOpusPacSize, 48);
75   config.sample_rate_hz = sample_rate_hz;
76   config.num_channels = num_channels;
77   config.bitrate_bps = kDefaultOpusRate;
78   config.application = num_channels == 1
79                            ? AudioEncoderOpusConfig::ApplicationMode::kVoip
80                            : AudioEncoderOpusConfig::ApplicationMode::kAudio;
81   config.supported_frame_lengths_ms.push_back(config.frame_size_ms);
82   states->config = config;
83 
84   std::unique_ptr<MockSmoothingFilter> bitrate_smoother(
85       new MockSmoothingFilter());
86   states->mock_bitrate_smoother = bitrate_smoother.get();
87 
88   states->encoder.reset(
89       new AudioEncoderOpusImpl(states->config, kDefaultOpusPayloadType, creator,
90                                std::move(bitrate_smoother)));
91   return states;
92 }
93 
CreateEncoderRuntimeConfig()94 AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() {
95   constexpr int kBitrate = 40000;
96   constexpr int kFrameLength = 60;
97   constexpr bool kEnableDtx = false;
98   constexpr size_t kNumChannels = 1;
99   AudioEncoderRuntimeConfig config;
100   config.bitrate_bps = kBitrate;
101   config.frame_length_ms = kFrameLength;
102   config.enable_dtx = kEnableDtx;
103   config.num_channels = kNumChannels;
104   return config;
105 }
106 
CheckEncoderRuntimeConfig(const AudioEncoderOpusImpl * encoder,const AudioEncoderRuntimeConfig & config)107 void CheckEncoderRuntimeConfig(const AudioEncoderOpusImpl* encoder,
108                                const AudioEncoderRuntimeConfig& config) {
109   EXPECT_EQ(*config.bitrate_bps, encoder->GetTargetBitrate());
110   EXPECT_EQ(*config.frame_length_ms, encoder->next_frame_length_ms());
111   EXPECT_EQ(*config.enable_dtx, encoder->GetDtx());
112   EXPECT_EQ(*config.num_channels, encoder->num_channels_to_encode());
113 }
114 
115 // Create 10ms audio data blocks for a total packet size of "packet_size_ms".
Create10msAudioBlocks(const std::unique_ptr<AudioEncoderOpusImpl> & encoder,int packet_size_ms)116 std::unique_ptr<test::AudioLoop> Create10msAudioBlocks(
117     const std::unique_ptr<AudioEncoderOpusImpl>& encoder,
118     int packet_size_ms) {
119   const std::string file_name =
120       test::ResourcePath("audio_coding/testfile32kHz", "pcm");
121 
122   std::unique_ptr<test::AudioLoop> speech_data(new test::AudioLoop());
123   int audio_samples_per_ms =
124       rtc::CheckedDivExact(encoder->SampleRateHz(), 1000);
125   if (!speech_data->Init(
126           file_name,
127           packet_size_ms * audio_samples_per_ms *
128               encoder->num_channels_to_encode(),
129           10 * audio_samples_per_ms * encoder->num_channels_to_encode()))
130     return nullptr;
131   return speech_data;
132 }
133 
134 }  // namespace
135 
136 class AudioEncoderOpusTest : public ::testing::TestWithParam<int> {
137  protected:
138   int sample_rate_hz_{GetParam()};
139 };
140 INSTANTIATE_TEST_SUITE_P(Param,
141                          AudioEncoderOpusTest,
142                          ::testing::Values(16000, 48000));
143 
TEST_P(AudioEncoderOpusTest,DefaultApplicationModeMono)144 TEST_P(AudioEncoderOpusTest, DefaultApplicationModeMono) {
145   auto states = CreateCodec(sample_rate_hz_, 1);
146   EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kVoip,
147             states->encoder->application());
148 }
149 
TEST_P(AudioEncoderOpusTest,DefaultApplicationModeStereo)150 TEST_P(AudioEncoderOpusTest, DefaultApplicationModeStereo) {
151   auto states = CreateCodec(sample_rate_hz_, 2);
152   EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kAudio,
153             states->encoder->application());
154 }
155 
TEST_P(AudioEncoderOpusTest,ChangeApplicationMode)156 TEST_P(AudioEncoderOpusTest, ChangeApplicationMode) {
157   auto states = CreateCodec(sample_rate_hz_, 2);
158   EXPECT_TRUE(
159       states->encoder->SetApplication(AudioEncoder::Application::kSpeech));
160   EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kVoip,
161             states->encoder->application());
162 }
163 
TEST_P(AudioEncoderOpusTest,ResetWontChangeApplicationMode)164 TEST_P(AudioEncoderOpusTest, ResetWontChangeApplicationMode) {
165   auto states = CreateCodec(sample_rate_hz_, 2);
166 
167   // Trigger a reset.
168   states->encoder->Reset();
169   // Verify that the mode is still kAudio.
170   EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kAudio,
171             states->encoder->application());
172 
173   // Now change to kVoip.
174   EXPECT_TRUE(
175       states->encoder->SetApplication(AudioEncoder::Application::kSpeech));
176   EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kVoip,
177             states->encoder->application());
178 
179   // Trigger a reset again.
180   states->encoder->Reset();
181   // Verify that the mode is still kVoip.
182   EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kVoip,
183             states->encoder->application());
184 }
185 
TEST_P(AudioEncoderOpusTest,ToggleDtx)186 TEST_P(AudioEncoderOpusTest, ToggleDtx) {
187   auto states = CreateCodec(sample_rate_hz_, 2);
188   // Enable DTX
189   EXPECT_TRUE(states->encoder->SetDtx(true));
190   EXPECT_TRUE(states->encoder->GetDtx());
191   // Turn off DTX.
192   EXPECT_TRUE(states->encoder->SetDtx(false));
193   EXPECT_FALSE(states->encoder->GetDtx());
194 }
195 
TEST_P(AudioEncoderOpusTest,OnReceivedUplinkBandwidthWithoutAudioNetworkAdaptor)196 TEST_P(AudioEncoderOpusTest,
197        OnReceivedUplinkBandwidthWithoutAudioNetworkAdaptor) {
198   auto states = CreateCodec(sample_rate_hz_, 1);
199   // Constants are replicated from audio_states->encoderopus.cc.
200   const int kMinBitrateBps = 6000;
201   const int kMaxBitrateBps = 510000;
202   const int kOverheadBytesPerPacket = 64;
203   states->encoder->OnReceivedOverhead(kOverheadBytesPerPacket);
204   const int kOverheadBps = 8 * kOverheadBytesPerPacket *
205                            rtc::CheckedDivExact(48000, kDefaultOpusPacSize);
206   // Set a too low bitrate.
207   states->encoder->OnReceivedUplinkBandwidth(kMinBitrateBps + kOverheadBps - 1,
208                                              absl::nullopt);
209   EXPECT_EQ(kMinBitrateBps, states->encoder->GetTargetBitrate());
210   // Set a too high bitrate.
211   states->encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps + kOverheadBps + 1,
212                                              absl::nullopt);
213   EXPECT_EQ(kMaxBitrateBps, states->encoder->GetTargetBitrate());
214   // Set the minimum rate.
215   states->encoder->OnReceivedUplinkBandwidth(kMinBitrateBps + kOverheadBps,
216                                              absl::nullopt);
217   EXPECT_EQ(kMinBitrateBps, states->encoder->GetTargetBitrate());
218   // Set the maximum rate.
219   states->encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps + kOverheadBps,
220                                              absl::nullopt);
221   EXPECT_EQ(kMaxBitrateBps, states->encoder->GetTargetBitrate());
222   // Set rates from kMaxBitrateBps up to 32000 bps.
223   for (int rate = kMinBitrateBps + kOverheadBps; rate <= 32000 + kOverheadBps;
224        rate += 1000) {
225     states->encoder->OnReceivedUplinkBandwidth(rate, absl::nullopt);
226     EXPECT_EQ(rate - kOverheadBps, states->encoder->GetTargetBitrate());
227   }
228 }
229 
TEST_P(AudioEncoderOpusTest,SetReceiverFrameLengthRange)230 TEST_P(AudioEncoderOpusTest, SetReceiverFrameLengthRange) {
231   auto states = CreateCodec(sample_rate_hz_, 2);
232   // Before calling to `SetReceiverFrameLengthRange`,
233   // `supported_frame_lengths_ms` should contain only the frame length being
234   // used.
235   using ::testing::ElementsAre;
236   EXPECT_THAT(states->encoder->supported_frame_lengths_ms(),
237               ElementsAre(states->encoder->next_frame_length_ms()));
238   states->encoder->SetReceiverFrameLengthRange(0, 12345);
239   states->encoder->SetReceiverFrameLengthRange(21, 60);
240   EXPECT_THAT(states->encoder->supported_frame_lengths_ms(),
241               ElementsAre(40, 60));
242   states->encoder->SetReceiverFrameLengthRange(20, 59);
243   EXPECT_THAT(states->encoder->supported_frame_lengths_ms(),
244               ElementsAre(20, 40));
245 }
246 
TEST_P(AudioEncoderOpusTest,InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction)247 TEST_P(AudioEncoderOpusTest,
248        InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction) {
249   auto states = CreateCodec(sample_rate_hz_, 2);
250   states->encoder->EnableAudioNetworkAdaptor("", nullptr);
251 
252   auto config = CreateEncoderRuntimeConfig();
253   EXPECT_CALL(*states->mock_audio_network_adaptor, GetEncoderRuntimeConfig())
254       .WillOnce(Return(config));
255 
256   // Since using mock audio network adaptor, any packet loss fraction is fine.
257   constexpr float kUplinkPacketLoss = 0.1f;
258   EXPECT_CALL(*states->mock_audio_network_adaptor,
259               SetUplinkPacketLossFraction(kUplinkPacketLoss));
260   states->encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss);
261 
262   CheckEncoderRuntimeConfig(states->encoder.get(), config);
263 }
264 
TEST_P(AudioEncoderOpusTest,InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth)265 TEST_P(AudioEncoderOpusTest,
266        InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) {
267   test::ScopedFieldTrials override_field_trials(
268       "WebRTC-Audio-StableTargetAdaptation/Disabled/");
269   auto states = CreateCodec(sample_rate_hz_, 2);
270   states->encoder->EnableAudioNetworkAdaptor("", nullptr);
271 
272   auto config = CreateEncoderRuntimeConfig();
273   EXPECT_CALL(*states->mock_audio_network_adaptor, GetEncoderRuntimeConfig())
274       .WillOnce(Return(config));
275 
276   // Since using mock audio network adaptor, any target audio bitrate is fine.
277   constexpr int kTargetAudioBitrate = 30000;
278   constexpr int64_t kProbingIntervalMs = 3000;
279   EXPECT_CALL(*states->mock_audio_network_adaptor,
280               SetTargetAudioBitrate(kTargetAudioBitrate));
281   EXPECT_CALL(*states->mock_bitrate_smoother,
282               SetTimeConstantMs(kProbingIntervalMs * 4));
283   EXPECT_CALL(*states->mock_bitrate_smoother, AddSample(kTargetAudioBitrate));
284   states->encoder->OnReceivedUplinkBandwidth(kTargetAudioBitrate,
285                                              kProbingIntervalMs);
286 
287   CheckEncoderRuntimeConfig(states->encoder.get(), config);
288 }
289 
TEST_P(AudioEncoderOpusTest,InvokeAudioNetworkAdaptorOnReceivedUplinkAllocation)290 TEST_P(AudioEncoderOpusTest,
291        InvokeAudioNetworkAdaptorOnReceivedUplinkAllocation) {
292   auto states = CreateCodec(sample_rate_hz_, 2);
293   states->encoder->EnableAudioNetworkAdaptor("", nullptr);
294 
295   auto config = CreateEncoderRuntimeConfig();
296   EXPECT_CALL(*states->mock_audio_network_adaptor, GetEncoderRuntimeConfig())
297       .WillOnce(Return(config));
298 
299   BitrateAllocationUpdate update;
300   update.target_bitrate = DataRate::BitsPerSec(30000);
301   update.stable_target_bitrate = DataRate::BitsPerSec(20000);
302   update.bwe_period = TimeDelta::Millis(200);
303   EXPECT_CALL(*states->mock_audio_network_adaptor,
304               SetTargetAudioBitrate(update.target_bitrate.bps()));
305   EXPECT_CALL(*states->mock_audio_network_adaptor,
306               SetUplinkBandwidth(update.stable_target_bitrate.bps()));
307   states->encoder->OnReceivedUplinkAllocation(update);
308 
309   CheckEncoderRuntimeConfig(states->encoder.get(), config);
310 }
311 
TEST_P(AudioEncoderOpusTest,InvokeAudioNetworkAdaptorOnReceivedRtt)312 TEST_P(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) {
313   auto states = CreateCodec(sample_rate_hz_, 2);
314   states->encoder->EnableAudioNetworkAdaptor("", nullptr);
315 
316   auto config = CreateEncoderRuntimeConfig();
317   EXPECT_CALL(*states->mock_audio_network_adaptor, GetEncoderRuntimeConfig())
318       .WillOnce(Return(config));
319 
320   // Since using mock audio network adaptor, any rtt is fine.
321   constexpr int kRtt = 30;
322   EXPECT_CALL(*states->mock_audio_network_adaptor, SetRtt(kRtt));
323   states->encoder->OnReceivedRtt(kRtt);
324 
325   CheckEncoderRuntimeConfig(states->encoder.get(), config);
326 }
327 
TEST_P(AudioEncoderOpusTest,InvokeAudioNetworkAdaptorOnReceivedOverhead)328 TEST_P(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedOverhead) {
329   auto states = CreateCodec(sample_rate_hz_, 2);
330   states->encoder->EnableAudioNetworkAdaptor("", nullptr);
331 
332   auto config = CreateEncoderRuntimeConfig();
333   EXPECT_CALL(*states->mock_audio_network_adaptor, GetEncoderRuntimeConfig())
334       .WillOnce(Return(config));
335 
336   // Since using mock audio network adaptor, any overhead is fine.
337   constexpr size_t kOverhead = 64;
338   EXPECT_CALL(*states->mock_audio_network_adaptor, SetOverhead(kOverhead));
339   states->encoder->OnReceivedOverhead(kOverhead);
340 
341   CheckEncoderRuntimeConfig(states->encoder.get(), config);
342 }
343 
TEST_P(AudioEncoderOpusTest,PacketLossFractionSmoothedOnSetUplinkPacketLossFraction)344 TEST_P(AudioEncoderOpusTest,
345        PacketLossFractionSmoothedOnSetUplinkPacketLossFraction) {
346   auto states = CreateCodec(sample_rate_hz_, 2);
347 
348   // The values are carefully chosen so that if no smoothing is made, the test
349   // will fail.
350   constexpr float kPacketLossFraction_1 = 0.02f;
351   constexpr float kPacketLossFraction_2 = 0.198f;
352   // `kSecondSampleTimeMs` is chosen to ease the calculation since
353   // 0.9999 ^ 6931 = 0.5.
354   constexpr int64_t kSecondSampleTimeMs = 6931;
355 
356   // First time, no filtering.
357   states->encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1);
358   EXPECT_FLOAT_EQ(0.02f, states->encoder->packet_loss_rate());
359 
360   states->fake_clock->AdvanceTime(TimeDelta::Millis(kSecondSampleTimeMs));
361   states->encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2);
362 
363   // Now the output of packet loss fraction smoother should be
364   // (0.02 + 0.198) / 2 = 0.109.
365   EXPECT_NEAR(0.109f, states->encoder->packet_loss_rate(), 0.001);
366 }
367 
TEST_P(AudioEncoderOpusTest,PacketLossRateUpperBounded)368 TEST_P(AudioEncoderOpusTest, PacketLossRateUpperBounded) {
369   auto states = CreateCodec(sample_rate_hz_, 2);
370 
371   states->encoder->OnReceivedUplinkPacketLossFraction(0.5);
372   EXPECT_FLOAT_EQ(0.2f, states->encoder->packet_loss_rate());
373 }
374 
TEST_P(AudioEncoderOpusTest,DoNotInvokeSetTargetBitrateIfOverheadUnknown)375 TEST_P(AudioEncoderOpusTest, DoNotInvokeSetTargetBitrateIfOverheadUnknown) {
376   auto states = CreateCodec(sample_rate_hz_, 2);
377 
378   states->encoder->OnReceivedUplinkBandwidth(kDefaultOpusRate * 2,
379                                              absl::nullopt);
380 
381   // Since `OnReceivedOverhead` has not been called, the codec bitrate should
382   // not change.
383   EXPECT_EQ(kDefaultOpusRate, states->encoder->GetTargetBitrate());
384 }
385 
386 // Verifies that the complexity adaptation in the config works as intended.
TEST(AudioEncoderOpusTest,ConfigComplexityAdaptation)387 TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) {
388   AudioEncoderOpusConfig config;
389   config.low_rate_complexity = 8;
390   config.complexity = 6;
391 
392   // Bitrate within hysteresis window. Expect empty output.
393   config.bitrate_bps = 12500;
394   EXPECT_EQ(absl::nullopt, AudioEncoderOpusImpl::GetNewComplexity(config));
395 
396   // Bitrate below hysteresis window. Expect higher complexity.
397   config.bitrate_bps = 10999;
398   EXPECT_EQ(8, AudioEncoderOpusImpl::GetNewComplexity(config));
399 
400   // Bitrate within hysteresis window. Expect empty output.
401   config.bitrate_bps = 12500;
402   EXPECT_EQ(absl::nullopt, AudioEncoderOpusImpl::GetNewComplexity(config));
403 
404   // Bitrate above hysteresis window. Expect lower complexity.
405   config.bitrate_bps = 14001;
406   EXPECT_EQ(6, AudioEncoderOpusImpl::GetNewComplexity(config));
407 }
408 
409 // Verifies that the bandwidth adaptation in the config works as intended.
TEST_P(AudioEncoderOpusTest,ConfigBandwidthAdaptation)410 TEST_P(AudioEncoderOpusTest, ConfigBandwidthAdaptation) {
411   AudioEncoderOpusConfig config;
412   const size_t opus_rate_khz = rtc::CheckedDivExact(sample_rate_hz_, 1000);
413   const std::vector<int16_t> silence(
414       opus_rate_khz * config.frame_size_ms * config.num_channels, 0);
415   constexpr size_t kMaxBytes = 1000;
416   uint8_t bitstream[kMaxBytes];
417 
418   OpusEncInst* inst;
419   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(
420                    &inst, config.num_channels,
421                    config.application ==
422                            AudioEncoderOpusConfig::ApplicationMode::kVoip
423                        ? 0
424                        : 1,
425                    sample_rate_hz_));
426 
427   // Bitrate below minmum wideband. Expect narrowband.
428   config.bitrate_bps = absl::optional<int>(7999);
429   auto bandwidth = AudioEncoderOpusImpl::GetNewBandwidth(config, inst);
430   EXPECT_EQ(absl::optional<int>(OPUS_BANDWIDTH_NARROWBAND), bandwidth);
431   WebRtcOpus_SetBandwidth(inst, *bandwidth);
432   // It is necessary to encode here because Opus has some logic in the encoder
433   // that goes from the user-set bandwidth to the used and returned one.
434   WebRtcOpus_Encode(inst, silence.data(),
435                     rtc::CheckedDivExact(silence.size(), config.num_channels),
436                     kMaxBytes, bitstream);
437 
438   // Bitrate not yet above maximum narrowband. Expect empty.
439   config.bitrate_bps = absl::optional<int>(9000);
440   bandwidth = AudioEncoderOpusImpl::GetNewBandwidth(config, inst);
441   EXPECT_EQ(absl::optional<int>(), bandwidth);
442 
443   // Bitrate above maximum narrowband. Expect wideband.
444   config.bitrate_bps = absl::optional<int>(9001);
445   bandwidth = AudioEncoderOpusImpl::GetNewBandwidth(config, inst);
446   EXPECT_EQ(absl::optional<int>(OPUS_BANDWIDTH_WIDEBAND), bandwidth);
447   WebRtcOpus_SetBandwidth(inst, *bandwidth);
448   // It is necessary to encode here because Opus has some logic in the encoder
449   // that goes from the user-set bandwidth to the used and returned one.
450   WebRtcOpus_Encode(inst, silence.data(),
451                     rtc::CheckedDivExact(silence.size(), config.num_channels),
452                     kMaxBytes, bitstream);
453 
454   // Bitrate not yet below minimum wideband. Expect empty.
455   config.bitrate_bps = absl::optional<int>(8000);
456   bandwidth = AudioEncoderOpusImpl::GetNewBandwidth(config, inst);
457   EXPECT_EQ(absl::optional<int>(), bandwidth);
458 
459   // Bitrate above automatic threshold. Expect automatic.
460   config.bitrate_bps = absl::optional<int>(12001);
461   bandwidth = AudioEncoderOpusImpl::GetNewBandwidth(config, inst);
462   EXPECT_EQ(absl::optional<int>(OPUS_AUTO), bandwidth);
463 
464   EXPECT_EQ(0, WebRtcOpus_EncoderFree(inst));
465 }
466 
TEST_P(AudioEncoderOpusTest,EmptyConfigDoesNotAffectEncoderSettings)467 TEST_P(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
468   auto states = CreateCodec(sample_rate_hz_, 2);
469   states->encoder->EnableAudioNetworkAdaptor("", nullptr);
470 
471   auto config = CreateEncoderRuntimeConfig();
472   AudioEncoderRuntimeConfig empty_config;
473 
474   EXPECT_CALL(*states->mock_audio_network_adaptor, GetEncoderRuntimeConfig())
475       .WillOnce(Return(config))
476       .WillOnce(Return(empty_config));
477 
478   constexpr size_t kOverhead = 64;
479   EXPECT_CALL(*states->mock_audio_network_adaptor, SetOverhead(kOverhead))
480       .Times(2);
481   states->encoder->OnReceivedOverhead(kOverhead);
482   states->encoder->OnReceivedOverhead(kOverhead);
483 
484   CheckEncoderRuntimeConfig(states->encoder.get(), config);
485 }
486 
TEST_P(AudioEncoderOpusTest,UpdateUplinkBandwidthInAudioNetworkAdaptor)487 TEST_P(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
488   test::ScopedFieldTrials override_field_trials(
489       "WebRTC-Audio-StableTargetAdaptation/Disabled/");
490   auto states = CreateCodec(sample_rate_hz_, 2);
491   states->encoder->EnableAudioNetworkAdaptor("", nullptr);
492   const size_t opus_rate_khz = rtc::CheckedDivExact(sample_rate_hz_, 1000);
493   const std::vector<int16_t> audio(opus_rate_khz * 10 * 2, 0);
494   rtc::Buffer encoded;
495   EXPECT_CALL(*states->mock_bitrate_smoother, GetAverage())
496       .WillOnce(Return(50000));
497   EXPECT_CALL(*states->mock_audio_network_adaptor, SetUplinkBandwidth(50000));
498   states->encoder->Encode(
499       0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
500 
501   // Repeat update uplink bandwidth tests.
502   for (int i = 0; i < 5; i++) {
503     // Don't update till it is time to update again.
504     states->fake_clock->AdvanceTime(TimeDelta::Millis(
505         states->config.uplink_bandwidth_update_interval_ms - 1));
506     states->encoder->Encode(
507         0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
508 
509     // Update when it is time to update.
510     EXPECT_CALL(*states->mock_bitrate_smoother, GetAverage())
511         .WillOnce(Return(40000));
512     EXPECT_CALL(*states->mock_audio_network_adaptor, SetUplinkBandwidth(40000));
513     states->fake_clock->AdvanceTime(TimeDelta::Millis(1));
514     states->encoder->Encode(
515         0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
516   }
517 }
518 
TEST_P(AudioEncoderOpusTest,EncodeAtMinBitrate)519 TEST_P(AudioEncoderOpusTest, EncodeAtMinBitrate) {
520   auto states = CreateCodec(sample_rate_hz_, 1);
521   constexpr int kNumPacketsToEncode = 2;
522   auto audio_frames =
523       Create10msAudioBlocks(states->encoder, kNumPacketsToEncode * 20);
524   ASSERT_TRUE(audio_frames) << "Create10msAudioBlocks failed";
525   rtc::Buffer encoded;
526   uint32_t rtp_timestamp = 12345;  // Just a number not important to this test.
527 
528   states->encoder->OnReceivedUplinkBandwidth(0, absl::nullopt);
529   for (int packet_index = 0; packet_index < kNumPacketsToEncode;
530        packet_index++) {
531     // Make sure we are not encoding before we have enough data for
532     // a 20ms packet.
533     for (int index = 0; index < 1; index++) {
534       states->encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(),
535                               &encoded);
536       EXPECT_EQ(0u, encoded.size());
537     }
538 
539     // Should encode now.
540     states->encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(),
541                             &encoded);
542     EXPECT_GT(encoded.size(), 0u);
543     encoded.Clear();
544   }
545 }
546 
TEST(AudioEncoderOpusTest,TestConfigDefaults)547 TEST(AudioEncoderOpusTest, TestConfigDefaults) {
548   const auto config_opt = AudioEncoderOpus::SdpToConfig({"opus", 48000, 2});
549   ASSERT_TRUE(config_opt);
550   EXPECT_EQ(48000, config_opt->max_playback_rate_hz);
551   EXPECT_EQ(1u, config_opt->num_channels);
552   EXPECT_FALSE(config_opt->fec_enabled);
553   EXPECT_FALSE(config_opt->dtx_enabled);
554   EXPECT_EQ(20, config_opt->frame_size_ms);
555 }
556 
TEST(AudioEncoderOpusTest,TestConfigFromParams)557 TEST(AudioEncoderOpusTest, TestConfigFromParams) {
558   const auto config1 = CreateConfigWithParameters({{"stereo", "0"}});
559   EXPECT_EQ(1U, config1.num_channels);
560 
561   const auto config2 = CreateConfigWithParameters({{"stereo", "1"}});
562   EXPECT_EQ(2U, config2.num_channels);
563 
564   const auto config3 = CreateConfigWithParameters({{"useinbandfec", "0"}});
565   EXPECT_FALSE(config3.fec_enabled);
566 
567   const auto config4 = CreateConfigWithParameters({{"useinbandfec", "1"}});
568   EXPECT_TRUE(config4.fec_enabled);
569 
570   const auto config5 = CreateConfigWithParameters({{"usedtx", "0"}});
571   EXPECT_FALSE(config5.dtx_enabled);
572 
573   const auto config6 = CreateConfigWithParameters({{"usedtx", "1"}});
574   EXPECT_TRUE(config6.dtx_enabled);
575 
576   const auto config7 = CreateConfigWithParameters({{"cbr", "0"}});
577   EXPECT_FALSE(config7.cbr_enabled);
578 
579   const auto config8 = CreateConfigWithParameters({{"cbr", "1"}});
580   EXPECT_TRUE(config8.cbr_enabled);
581 
582   const auto config9 =
583       CreateConfigWithParameters({{"maxplaybackrate", "12345"}});
584   EXPECT_EQ(12345, config9.max_playback_rate_hz);
585 
586   const auto config10 =
587       CreateConfigWithParameters({{"maxaveragebitrate", "96000"}});
588   EXPECT_EQ(96000, config10.bitrate_bps);
589 
590   const auto config11 = CreateConfigWithParameters({{"maxptime", "40"}});
591   for (int frame_length : config11.supported_frame_lengths_ms) {
592     EXPECT_LE(frame_length, 40);
593   }
594 
595   const auto config12 = CreateConfigWithParameters({{"minptime", "40"}});
596   for (int frame_length : config12.supported_frame_lengths_ms) {
597     EXPECT_GE(frame_length, 40);
598   }
599 
600   const auto config13 = CreateConfigWithParameters({{"ptime", "40"}});
601   EXPECT_EQ(40, config13.frame_size_ms);
602 
603   constexpr int kMinSupportedFrameLength = 10;
604   constexpr int kMaxSupportedFrameLength =
605       WEBRTC_OPUS_SUPPORT_120MS_PTIME ? 120 : 60;
606 
607   const auto config14 = CreateConfigWithParameters({{"ptime", "1"}});
608   EXPECT_EQ(kMinSupportedFrameLength, config14.frame_size_ms);
609 
610   const auto config15 = CreateConfigWithParameters({{"ptime", "2000"}});
611   EXPECT_EQ(kMaxSupportedFrameLength, config15.frame_size_ms);
612 }
613 
TEST(AudioEncoderOpusTest,TestConfigFromInvalidParams)614 TEST(AudioEncoderOpusTest, TestConfigFromInvalidParams) {
615   const webrtc::SdpAudioFormat format("opus", 48000, 2);
616   const auto default_config = *AudioEncoderOpus::SdpToConfig(format);
617 #if WEBRTC_OPUS_SUPPORT_120MS_PTIME
618   const std::vector<int> default_supported_frame_lengths_ms({20, 40, 60, 120});
619 #else
620   const std::vector<int> default_supported_frame_lengths_ms({20, 40, 60});
621 #endif
622 
623   AudioEncoderOpusConfig config;
624   config = CreateConfigWithParameters({{"stereo", "invalid"}});
625   EXPECT_EQ(default_config.num_channels, config.num_channels);
626 
627   config = CreateConfigWithParameters({{"useinbandfec", "invalid"}});
628   EXPECT_EQ(default_config.fec_enabled, config.fec_enabled);
629 
630   config = CreateConfigWithParameters({{"usedtx", "invalid"}});
631   EXPECT_EQ(default_config.dtx_enabled, config.dtx_enabled);
632 
633   config = CreateConfigWithParameters({{"cbr", "invalid"}});
634   EXPECT_EQ(default_config.dtx_enabled, config.dtx_enabled);
635 
636   config = CreateConfigWithParameters({{"maxplaybackrate", "0"}});
637   EXPECT_EQ(default_config.max_playback_rate_hz, config.max_playback_rate_hz);
638 
639   config = CreateConfigWithParameters({{"maxplaybackrate", "-23"}});
640   EXPECT_EQ(default_config.max_playback_rate_hz, config.max_playback_rate_hz);
641 
642   config = CreateConfigWithParameters({{"maxplaybackrate", "not a number!"}});
643   EXPECT_EQ(default_config.max_playback_rate_hz, config.max_playback_rate_hz);
644 
645   config = CreateConfigWithParameters({{"maxaveragebitrate", "0"}});
646   EXPECT_EQ(6000, config.bitrate_bps);
647 
648   config = CreateConfigWithParameters({{"maxaveragebitrate", "-1000"}});
649   EXPECT_EQ(6000, config.bitrate_bps);
650 
651   config = CreateConfigWithParameters({{"maxaveragebitrate", "1024000"}});
652   EXPECT_EQ(510000, config.bitrate_bps);
653 
654   config = CreateConfigWithParameters({{"maxaveragebitrate", "not a number!"}});
655   EXPECT_EQ(default_config.bitrate_bps, config.bitrate_bps);
656 
657   config = CreateConfigWithParameters({{"maxptime", "invalid"}});
658   EXPECT_EQ(default_supported_frame_lengths_ms,
659             config.supported_frame_lengths_ms);
660 
661   config = CreateConfigWithParameters({{"minptime", "invalid"}});
662   EXPECT_EQ(default_supported_frame_lengths_ms,
663             config.supported_frame_lengths_ms);
664 
665   config = CreateConfigWithParameters({{"ptime", "invalid"}});
666   EXPECT_EQ(default_supported_frame_lengths_ms,
667             config.supported_frame_lengths_ms);
668 }
669 
TEST(AudioEncoderOpusTest,GetFrameLenghtRange)670 TEST(AudioEncoderOpusTest, GetFrameLenghtRange) {
671   AudioEncoderOpusConfig config =
672       CreateConfigWithParameters({{"maxptime", "10"}, {"ptime", "10"}});
673   std::unique_ptr<AudioEncoder> encoder =
674       AudioEncoderOpus::MakeAudioEncoder(config, kDefaultOpusPayloadType);
675   auto ptime = webrtc::TimeDelta::Millis(10);
676   absl::optional<std::pair<webrtc::TimeDelta, webrtc::TimeDelta>> range = {
677       {ptime, ptime}};
678   EXPECT_EQ(encoder->GetFrameLengthRange(), range);
679 }
680 
681 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter.
682 // Also test that the "maxaveragebitrate" can't be set to values outside the
683 // range of 6000 and 510000
TEST(AudioEncoderOpusTest,SetSendCodecOpusMaxAverageBitrate)684 TEST(AudioEncoderOpusTest, SetSendCodecOpusMaxAverageBitrate) {
685   // Ignore if less than 6000.
686   const auto config1 = AudioEncoderOpus::SdpToConfig(
687       {"opus", 48000, 2, {{"maxaveragebitrate", "5999"}}});
688   EXPECT_EQ(6000, config1->bitrate_bps);
689 
690   // Ignore if larger than 510000.
691   const auto config2 = AudioEncoderOpus::SdpToConfig(
692       {"opus", 48000, 2, {{"maxaveragebitrate", "510001"}}});
693   EXPECT_EQ(510000, config2->bitrate_bps);
694 
695   const auto config3 = AudioEncoderOpus::SdpToConfig(
696       {"opus", 48000, 2, {{"maxaveragebitrate", "200000"}}});
697   EXPECT_EQ(200000, config3->bitrate_bps);
698 }
699 
700 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
TEST(AudioEncoderOpusTest,SetMaxPlaybackRateNb)701 TEST(AudioEncoderOpusTest, SetMaxPlaybackRateNb) {
702   auto config = CreateConfigWithParameters({{"maxplaybackrate", "8000"}});
703   EXPECT_EQ(8000, config.max_playback_rate_hz);
704   EXPECT_EQ(12000, config.bitrate_bps);
705 
706   config = CreateConfigWithParameters(
707       {{"maxplaybackrate", "8000"}, {"stereo", "1"}});
708   EXPECT_EQ(8000, config.max_playback_rate_hz);
709   EXPECT_EQ(24000, config.bitrate_bps);
710 }
711 
712 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode.
TEST(AudioEncoderOpusTest,SetMaxPlaybackRateMb)713 TEST(AudioEncoderOpusTest, SetMaxPlaybackRateMb) {
714   auto config = CreateConfigWithParameters({{"maxplaybackrate", "8001"}});
715   EXPECT_EQ(8001, config.max_playback_rate_hz);
716   EXPECT_EQ(20000, config.bitrate_bps);
717 
718   config = CreateConfigWithParameters(
719       {{"maxplaybackrate", "8001"}, {"stereo", "1"}});
720   EXPECT_EQ(8001, config.max_playback_rate_hz);
721   EXPECT_EQ(40000, config.bitrate_bps);
722 }
723 
724 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode.
TEST(AudioEncoderOpusTest,SetMaxPlaybackRateWb)725 TEST(AudioEncoderOpusTest, SetMaxPlaybackRateWb) {
726   auto config = CreateConfigWithParameters({{"maxplaybackrate", "12001"}});
727   EXPECT_EQ(12001, config.max_playback_rate_hz);
728   EXPECT_EQ(20000, config.bitrate_bps);
729 
730   config = CreateConfigWithParameters(
731       {{"maxplaybackrate", "12001"}, {"stereo", "1"}});
732   EXPECT_EQ(12001, config.max_playback_rate_hz);
733   EXPECT_EQ(40000, config.bitrate_bps);
734 }
735 
736 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode.
TEST(AudioEncoderOpusTest,SetMaxPlaybackRateSwb)737 TEST(AudioEncoderOpusTest, SetMaxPlaybackRateSwb) {
738   auto config = CreateConfigWithParameters({{"maxplaybackrate", "16001"}});
739   EXPECT_EQ(16001, config.max_playback_rate_hz);
740   EXPECT_EQ(32000, config.bitrate_bps);
741 
742   config = CreateConfigWithParameters(
743       {{"maxplaybackrate", "16001"}, {"stereo", "1"}});
744   EXPECT_EQ(16001, config.max_playback_rate_hz);
745   EXPECT_EQ(64000, config.bitrate_bps);
746 }
747 
748 // Test 24000 < maxplaybackrate triggers Opus full band mode.
TEST(AudioEncoderOpusTest,SetMaxPlaybackRateFb)749 TEST(AudioEncoderOpusTest, SetMaxPlaybackRateFb) {
750   auto config = CreateConfigWithParameters({{"maxplaybackrate", "24001"}});
751   EXPECT_EQ(24001, config.max_playback_rate_hz);
752   EXPECT_EQ(32000, config.bitrate_bps);
753 
754   config = CreateConfigWithParameters(
755       {{"maxplaybackrate", "24001"}, {"stereo", "1"}});
756   EXPECT_EQ(24001, config.max_playback_rate_hz);
757   EXPECT_EQ(64000, config.bitrate_bps);
758 }
759 
TEST_P(AudioEncoderOpusTest,OpusFlagDtxAsNonSpeech)760 TEST_P(AudioEncoderOpusTest, OpusFlagDtxAsNonSpeech) {
761   // Create encoder with DTX enabled.
762   AudioEncoderOpusConfig config;
763   config.dtx_enabled = true;
764   config.sample_rate_hz = sample_rate_hz_;
765   constexpr int payload_type = 17;
766   const auto encoder = AudioEncoderOpus::MakeAudioEncoder(config, payload_type);
767 
768   // Open file containing speech and silence.
769   const std::string kInputFileName =
770       webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm");
771   test::AudioLoop audio_loop;
772   // Use the file as if it were sampled at our desired input rate.
773   const size_t max_loop_length_samples =
774       sample_rate_hz_ * 10;  // Max 10 second loop.
775   const size_t input_block_size_samples =
776       10 * sample_rate_hz_ / 1000;  // 10 ms.
777   EXPECT_TRUE(audio_loop.Init(kInputFileName, max_loop_length_samples,
778                               input_block_size_samples));
779 
780   // Encode.
781   AudioEncoder::EncodedInfo info;
782   rtc::Buffer encoded(500);
783   int nonspeech_frames = 0;
784   int max_nonspeech_frames = 0;
785   int dtx_frames = 0;
786   int max_dtx_frames = 0;
787   uint32_t rtp_timestamp = 0u;
788   for (size_t i = 0; i < 500; ++i) {
789     encoded.Clear();
790 
791     // Every second call to the encoder will generate an Opus packet.
792     for (int j = 0; j < 2; j++) {
793       info =
794           encoder->Encode(rtp_timestamp, audio_loop.GetNextBlock(), &encoded);
795       rtp_timestamp += input_block_size_samples;
796     }
797 
798     // Bookkeeping of number of DTX frames.
799     if (info.encoded_bytes <= 2) {
800       ++dtx_frames;
801     } else {
802       if (dtx_frames > max_dtx_frames)
803         max_dtx_frames = dtx_frames;
804       dtx_frames = 0;
805     }
806 
807     // Bookkeeping of number of non-speech frames.
808     if (info.speech == 0) {
809       ++nonspeech_frames;
810     } else {
811       if (nonspeech_frames > max_nonspeech_frames)
812         max_nonspeech_frames = nonspeech_frames;
813       nonspeech_frames = 0;
814     }
815   }
816 
817   // Maximum number of consecutive non-speech packets should exceed 15.
818   EXPECT_GT(max_nonspeech_frames, 15);
819 }
820 
TEST(AudioEncoderOpusTest,OpusDtxFilteringHighEnergyRefreshPackets)821 TEST(AudioEncoderOpusTest, OpusDtxFilteringHighEnergyRefreshPackets) {
822   test::ScopedFieldTrials override_field_trials(
823       "WebRTC-Audio-OpusAvoidNoisePumpingDuringDtx/Enabled/");
824   const std::string kInputFileName =
825       webrtc::test::ResourcePath("audio_coding/testfile16kHz", "pcm");
826   constexpr int kSampleRateHz = 16000;
827   AudioEncoderOpusConfig config;
828   config.dtx_enabled = true;
829   config.sample_rate_hz = kSampleRateHz;
830   constexpr int payload_type = 17;
831   const auto encoder = AudioEncoderOpus::MakeAudioEncoder(config, payload_type);
832   test::AudioLoop audio_loop;
833   constexpr size_t kMaxLoopLengthSaples = kSampleRateHz * 11.6f;
834   constexpr size_t kInputBlockSizeSamples = kSampleRateHz / 100;
835   EXPECT_TRUE(audio_loop.Init(kInputFileName, kMaxLoopLengthSaples,
836                               kInputBlockSizeSamples));
837   AudioEncoder::EncodedInfo info;
838   rtc::Buffer encoded(500);
839   // Encode the audio file and store the last part that corresponds to silence.
840   constexpr size_t kSilenceDurationSamples = kSampleRateHz * 0.2f;
841   std::array<int16_t, kSilenceDurationSamples> silence;
842   uint32_t rtp_timestamp = 0;
843   bool last_packet_dtx_frame = false;
844   bool opus_entered_dtx = false;
845   bool silence_filled = false;
846   size_t timestamp_start_silence = 0;
847   while (!silence_filled && rtp_timestamp < kMaxLoopLengthSaples) {
848     encoded.Clear();
849     // Every second call to the encoder will generate an Opus packet.
850     for (int j = 0; j < 2; j++) {
851       auto next_frame = audio_loop.GetNextBlock();
852       info = encoder->Encode(rtp_timestamp, next_frame, &encoded);
853       if (opus_entered_dtx) {
854         size_t silence_frame_start = rtp_timestamp - timestamp_start_silence;
855         silence_filled = silence_frame_start >= kSilenceDurationSamples;
856         if (!silence_filled) {
857           std::copy(next_frame.begin(), next_frame.end(),
858                     silence.begin() + silence_frame_start);
859         }
860       }
861       rtp_timestamp += kInputBlockSizeSamples;
862     }
863     EXPECT_TRUE(info.encoded_bytes > 0 || last_packet_dtx_frame);
864     last_packet_dtx_frame = info.encoded_bytes > 0 ? info.encoded_bytes <= 2
865                                                    : last_packet_dtx_frame;
866     if (info.encoded_bytes <= 2 && !opus_entered_dtx) {
867       timestamp_start_silence = rtp_timestamp;
868     }
869     opus_entered_dtx = info.encoded_bytes <= 2;
870   }
871 
872   EXPECT_TRUE(silence_filled);
873   // The copied 200 ms of silence is used for creating 6 bursts that are fed to
874   // the encoder, the first three ones with a larger energy and the last three
875   // with a lower energy. This test verifies that the encoder just sends refresh
876   // DTX packets during the last bursts.
877   int number_non_empty_packets_during_increase = 0;
878   int number_non_empty_packets_during_decrease = 0;
879   for (size_t burst = 0; burst < 6; ++burst) {
880     uint32_t rtp_timestamp_start = rtp_timestamp;
881     const bool increase_noise = burst < 3;
882     const float gain = increase_noise ? 1.4f : 0.0f;
883     while (rtp_timestamp < rtp_timestamp_start + kSilenceDurationSamples) {
884       encoded.Clear();
885       // Every second call to the encoder will generate an Opus packet.
886       for (int j = 0; j < 2; j++) {
887         std::array<int16_t, kInputBlockSizeSamples> silence_frame;
888         size_t silence_frame_start = rtp_timestamp - rtp_timestamp_start;
889         std::transform(
890             silence.begin() + silence_frame_start,
891             silence.begin() + silence_frame_start + kInputBlockSizeSamples,
892             silence_frame.begin(), [gain](float s) { return gain * s; });
893         info = encoder->Encode(rtp_timestamp, silence_frame, &encoded);
894         rtp_timestamp += kInputBlockSizeSamples;
895       }
896       EXPECT_TRUE(info.encoded_bytes > 0 || last_packet_dtx_frame);
897       last_packet_dtx_frame = info.encoded_bytes > 0 ? info.encoded_bytes <= 2
898                                                      : last_packet_dtx_frame;
899       // Tracking the number of non empty packets.
900       if (increase_noise && info.encoded_bytes > 2) {
901         number_non_empty_packets_during_increase++;
902       }
903       if (!increase_noise && info.encoded_bytes > 2) {
904         number_non_empty_packets_during_decrease++;
905       }
906     }
907   }
908   // Check that the refresh DTX packets are just sent during the decrease energy
909   // region.
910   EXPECT_EQ(number_non_empty_packets_during_increase, 0);
911   EXPECT_GT(number_non_empty_packets_during_decrease, 0);
912 }
913 
914 }  // namespace webrtc
915