OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <memory> | 11 #include <memory> |
12 | 12 |
13 #include "webrtc/base/checks.h" | 13 #include "webrtc/base/checks.h" |
14 #include "webrtc/common_types.h" | 14 #include "webrtc/common_types.h" |
| 15 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_netw
ork_adaptor.h" |
15 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h" | 16 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h" |
16 #include "webrtc/test/gtest.h" | 17 #include "webrtc/test/gtest.h" |
17 | 18 |
18 namespace webrtc { | 19 namespace webrtc { |
| 20 using ::testing::NiceMock; |
| 21 using ::testing::Return; |
19 | 22 |
20 namespace { | 23 namespace { |
21 const CodecInst kOpusSettings = {105, "opus", 48000, 960, 1, 32000}; | 24 |
| 25 const CodecInst kDefaultOpusSettings = {105, "opus", 48000, 960, 1, 32000}; |
| 26 |
| 27 AudioEncoderOpus::Config CreateConfig(const CodecInst& codec_inst) { |
| 28 AudioEncoderOpus::Config config; |
| 29 config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48); |
| 30 config.num_channels = codec_inst.channels; |
| 31 config.bitrate_bps = rtc::Optional<int>(codec_inst.rate); |
| 32 config.payload_type = codec_inst.pltype; |
| 33 config.application = config.num_channels == 1 ? AudioEncoderOpus::kVoip |
| 34 : AudioEncoderOpus::kAudio; |
| 35 return config; |
| 36 } |
| 37 |
| 38 struct AudioEncoderOpusStates { |
| 39 std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor; |
| 40 std::unique_ptr<AudioEncoderOpus> encoder; |
| 41 }; |
| 42 |
| 43 AudioEncoderOpusStates CreateCodec(size_t num_channels) { |
| 44 AudioEncoderOpusStates states; |
| 45 states.mock_audio_network_adaptor = |
| 46 std::make_shared<MockAudioNetworkAdaptor*>(nullptr); |
| 47 |
| 48 std::weak_ptr<MockAudioNetworkAdaptor*> mock_ptr( |
| 49 states.mock_audio_network_adaptor); |
| 50 AudioEncoderOpus::AudioNetworkAdaptorCreator creator = [mock_ptr]( |
| 51 const std::string&, const Clock*) { |
| 52 std::unique_ptr<MockAudioNetworkAdaptor> adaptor( |
| 53 new NiceMock<MockAudioNetworkAdaptor>()); |
| 54 EXPECT_CALL(*adaptor, Die()); |
| 55 if (auto sp = mock_ptr.lock()) { |
| 56 *sp = adaptor.get(); |
| 57 } else { |
| 58 RTC_NOTREACHED(); |
| 59 } |
| 60 return adaptor; |
| 61 }; |
| 62 |
| 63 CodecInst codec_inst = kDefaultOpusSettings; |
| 64 codec_inst.channels = num_channels; |
| 65 auto config = CreateConfig(codec_inst); |
| 66 states.encoder.reset(new AudioEncoderOpus(config, std::move(creator))); |
| 67 return states; |
| 68 } |
| 69 |
| 70 AudioNetworkAdaptor::EncoderRuntimeConfig CreateEncoderRuntimeConfig() { |
| 71 constexpr int kBitrate = 40000; |
| 72 constexpr int kFrameLength = 60; |
| 73 constexpr bool kEnableFec = true; |
| 74 constexpr bool kEnableDtx = false; |
| 75 constexpr size_t kNumChannels = 1; |
| 76 constexpr float kPacketLossFraction = 0.1f; |
| 77 AudioNetworkAdaptor::EncoderRuntimeConfig config; |
| 78 config.bitrate_bps = rtc::Optional<int>(kBitrate); |
| 79 config.frame_length_ms = rtc::Optional<int>(kFrameLength); |
| 80 config.enable_fec = rtc::Optional<bool>(kEnableFec); |
| 81 config.enable_dtx = rtc::Optional<bool>(kEnableDtx); |
| 82 config.num_channels = rtc::Optional<size_t>(kNumChannels); |
| 83 config.uplink_packet_loss_fraction = |
| 84 rtc::Optional<float>(kPacketLossFraction); |
| 85 return config; |
| 86 } |
| 87 |
| 88 void CheckEncoderRuntimeConfig( |
| 89 const AudioEncoderOpus* encoder, |
| 90 const AudioNetworkAdaptor::EncoderRuntimeConfig& config) { |
| 91 EXPECT_EQ(*config.bitrate_bps, encoder->GetTargetBitrate()); |
| 92 EXPECT_EQ(*config.frame_length_ms, encoder->next_frame_length_ms()); |
| 93 EXPECT_EQ(*config.enable_fec, encoder->fec_enabled()); |
| 94 EXPECT_EQ(*config.enable_dtx, encoder->GetDtx()); |
| 95 EXPECT_EQ(*config.num_channels, encoder->num_channels_to_encode()); |
| 96 } |
| 97 |
22 } // namespace | 98 } // namespace |
23 | 99 |
24 class AudioEncoderOpusTest : public ::testing::Test { | 100 TEST(AudioEncoderOpusTest, DefaultApplicationModeMono) { |
25 protected: | 101 auto states = CreateCodec(1); |
26 void CreateCodec(int num_channels) { | 102 EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application()); |
27 codec_inst_.channels = num_channels; | |
28 encoder_.reset(new AudioEncoderOpus(codec_inst_)); | |
29 auto expected_app = | |
30 num_channels == 1 ? AudioEncoderOpus::kVoip : AudioEncoderOpus::kAudio; | |
31 EXPECT_EQ(expected_app, encoder_->application()); | |
32 } | |
33 | |
34 CodecInst codec_inst_ = kOpusSettings; | |
35 std::unique_ptr<AudioEncoderOpus> encoder_; | |
36 }; | |
37 | |
38 TEST_F(AudioEncoderOpusTest, DefaultApplicationModeMono) { | |
39 CreateCodec(1); | |
40 } | 103 } |
41 | 104 |
42 TEST_F(AudioEncoderOpusTest, DefaultApplicationModeStereo) { | 105 TEST(AudioEncoderOpusTest, DefaultApplicationModeStereo) { |
43 CreateCodec(2); | 106 auto states = CreateCodec(2); |
| 107 EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application()); |
44 } | 108 } |
45 | 109 |
46 TEST_F(AudioEncoderOpusTest, ChangeApplicationMode) { | 110 TEST(AudioEncoderOpusTest, ChangeApplicationMode) { |
47 CreateCodec(2); | 111 auto states = CreateCodec(2); |
48 EXPECT_TRUE(encoder_->SetApplication(AudioEncoder::Application::kSpeech)); | 112 EXPECT_TRUE( |
49 EXPECT_EQ(AudioEncoderOpus::kVoip, encoder_->application()); | 113 states.encoder->SetApplication(AudioEncoder::Application::kSpeech)); |
| 114 EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application()); |
50 } | 115 } |
51 | 116 |
52 TEST_F(AudioEncoderOpusTest, ResetWontChangeApplicationMode) { | 117 TEST(AudioEncoderOpusTest, ResetWontChangeApplicationMode) { |
53 CreateCodec(2); | 118 auto states = CreateCodec(2); |
54 | 119 |
55 // Trigger a reset. | 120 // Trigger a reset. |
56 encoder_->Reset(); | 121 states.encoder->Reset(); |
57 // Verify that the mode is still kAudio. | 122 // Verify that the mode is still kAudio. |
58 EXPECT_EQ(AudioEncoderOpus::kAudio, encoder_->application()); | 123 EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application()); |
59 | 124 |
60 // Now change to kVoip. | 125 // Now change to kVoip. |
61 EXPECT_TRUE(encoder_->SetApplication(AudioEncoder::Application::kSpeech)); | 126 EXPECT_TRUE( |
62 EXPECT_EQ(AudioEncoderOpus::kVoip, encoder_->application()); | 127 states.encoder->SetApplication(AudioEncoder::Application::kSpeech)); |
| 128 EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application()); |
63 | 129 |
64 // Trigger a reset again. | 130 // Trigger a reset again. |
65 encoder_->Reset(); | 131 states.encoder->Reset(); |
66 // Verify that the mode is still kVoip. | 132 // Verify that the mode is still kVoip. |
67 EXPECT_EQ(AudioEncoderOpus::kVoip, encoder_->application()); | 133 EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application()); |
68 } | 134 } |
69 | 135 |
70 TEST_F(AudioEncoderOpusTest, ToggleDtx) { | 136 TEST(AudioEncoderOpusTest, ToggleDtx) { |
71 CreateCodec(2); | 137 auto states = CreateCodec(2); |
72 // Enable DTX | 138 // Enable DTX |
73 EXPECT_TRUE(encoder_->SetDtx(true)); | 139 EXPECT_TRUE(states.encoder->SetDtx(true)); |
74 // Verify that the mode is still kAudio. | 140 // Verify that the mode is still kAudio. |
75 EXPECT_EQ(AudioEncoderOpus::kAudio, encoder_->application()); | 141 EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application()); |
76 // Turn off DTX. | 142 // Turn off DTX. |
77 EXPECT_TRUE(encoder_->SetDtx(false)); | 143 EXPECT_TRUE(states.encoder->SetDtx(false)); |
78 } | 144 } |
79 | 145 |
80 TEST_F(AudioEncoderOpusTest, SetBitrate) { | 146 TEST(AudioEncoderOpusTest, SetBitrate) { |
81 CreateCodec(1); | 147 auto states = CreateCodec(1); |
82 // Constants are replicated from audio_encoder_opus.cc. | 148 // Constants are replicated from audio_states.encoderopus.cc. |
83 const int kMinBitrateBps = 500; | 149 const int kMinBitrateBps = 500; |
84 const int kMaxBitrateBps = 512000; | 150 const int kMaxBitrateBps = 512000; |
85 // Set a too low bitrate. | 151 // Set a too low bitrate. |
86 encoder_->SetTargetBitrate(kMinBitrateBps - 1); | 152 states.encoder->SetTargetBitrate(kMinBitrateBps - 1); |
87 EXPECT_EQ(kMinBitrateBps, encoder_->GetTargetBitrate()); | 153 EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); |
88 // Set a too high bitrate. | 154 // Set a too high bitrate. |
89 encoder_->SetTargetBitrate(kMaxBitrateBps + 1); | 155 states.encoder->SetTargetBitrate(kMaxBitrateBps + 1); |
90 EXPECT_EQ(kMaxBitrateBps, encoder_->GetTargetBitrate()); | 156 EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); |
91 // Set the minimum rate. | 157 // Set the minimum rate. |
92 encoder_->SetTargetBitrate(kMinBitrateBps); | 158 states.encoder->SetTargetBitrate(kMinBitrateBps); |
93 EXPECT_EQ(kMinBitrateBps, encoder_->GetTargetBitrate()); | 159 EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); |
94 // Set the maximum rate. | 160 // Set the maximum rate. |
95 encoder_->SetTargetBitrate(kMaxBitrateBps); | 161 states.encoder->SetTargetBitrate(kMaxBitrateBps); |
96 EXPECT_EQ(kMaxBitrateBps, encoder_->GetTargetBitrate()); | 162 EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); |
97 // Set rates from 1000 up to 32000 bps. | 163 // Set rates from 1000 up to 32000 bps. |
98 for (int rate = 1000; rate <= 32000; rate += 1000) { | 164 for (int rate = 1000; rate <= 32000; rate += 1000) { |
99 encoder_->SetTargetBitrate(rate); | 165 states.encoder->SetTargetBitrate(rate); |
100 EXPECT_EQ(rate, encoder_->GetTargetBitrate()); | 166 EXPECT_EQ(rate, states.encoder->GetTargetBitrate()); |
101 } | 167 } |
102 } | 168 } |
103 | 169 |
104 namespace { | 170 namespace { |
105 | 171 |
106 // Returns a vector with the n evenly-spaced numbers a, a + (b - a)/(n - 1), | 172 // Returns a vector with the n evenly-spaced numbers a, a + (b - a)/(n - 1), |
107 // ..., b. | 173 // ..., b. |
108 std::vector<double> IntervalSteps(double a, double b, size_t n) { | 174 std::vector<double> IntervalSteps(double a, double b, size_t n) { |
109 RTC_DCHECK_GT(n, 1u); | 175 RTC_DCHECK_GT(n, 1u); |
110 const double step = (b - a) / (n - 1); | 176 const double step = (b - a) / (n - 1); |
(...skipping 10 matching lines...) Expand all Loading... |
121 const std::vector<double>& losses, | 187 const std::vector<double>& losses, |
122 double expected_return) { | 188 double expected_return) { |
123 for (double loss : losses) { | 189 for (double loss : losses) { |
124 encoder->SetProjectedPacketLossRate(loss); | 190 encoder->SetProjectedPacketLossRate(loss); |
125 EXPECT_DOUBLE_EQ(expected_return, encoder->packet_loss_rate()); | 191 EXPECT_DOUBLE_EQ(expected_return, encoder->packet_loss_rate()); |
126 } | 192 } |
127 } | 193 } |
128 | 194 |
129 } // namespace | 195 } // namespace |
130 | 196 |
131 TEST_F(AudioEncoderOpusTest, PacketLossRateOptimized) { | 197 TEST(AudioEncoderOpusTest, PacketLossRateOptimized) { |
132 CreateCodec(1); | 198 auto states = CreateCodec(1); |
133 auto I = [](double a, double b) { return IntervalSteps(a, b, 10); }; | 199 auto I = [](double a, double b) { return IntervalSteps(a, b, 10); }; |
134 const double eps = 1e-15; | 200 const double eps = 1e-15; |
135 | 201 |
136 // Note that the order of the following calls is critical. | 202 // Note that the order of the following calls is critical. |
137 | 203 |
138 // clang-format off | 204 // clang-format off |
139 TestSetPacketLossRate(encoder_.get(), I(0.00 , 0.01 - eps), 0.00); | 205 TestSetPacketLossRate(states.encoder.get(), I(0.00 , 0.01 - eps), 0.00); |
140 TestSetPacketLossRate(encoder_.get(), I(0.01 + eps, 0.06 - eps), 0.01); | 206 TestSetPacketLossRate(states.encoder.get(), I(0.01 + eps, 0.06 - eps), 0.01); |
141 TestSetPacketLossRate(encoder_.get(), I(0.06 + eps, 0.11 - eps), 0.05); | 207 TestSetPacketLossRate(states.encoder.get(), I(0.06 + eps, 0.11 - eps), 0.05); |
142 TestSetPacketLossRate(encoder_.get(), I(0.11 + eps, 0.22 - eps), 0.10); | 208 TestSetPacketLossRate(states.encoder.get(), I(0.11 + eps, 0.22 - eps), 0.10); |
143 TestSetPacketLossRate(encoder_.get(), I(0.22 + eps, 1.00 ), 0.20); | 209 TestSetPacketLossRate(states.encoder.get(), I(0.22 + eps, 1.00 ), 0.20); |
144 | 210 |
145 TestSetPacketLossRate(encoder_.get(), I(1.00 , 0.18 + eps), 0.20); | 211 TestSetPacketLossRate(states.encoder.get(), I(1.00 , 0.18 + eps), 0.20); |
146 TestSetPacketLossRate(encoder_.get(), I(0.18 - eps, 0.09 + eps), 0.10); | 212 TestSetPacketLossRate(states.encoder.get(), I(0.18 - eps, 0.09 + eps), 0.10); |
147 TestSetPacketLossRate(encoder_.get(), I(0.09 - eps, 0.04 + eps), 0.05); | 213 TestSetPacketLossRate(states.encoder.get(), I(0.09 - eps, 0.04 + eps), 0.05); |
148 TestSetPacketLossRate(encoder_.get(), I(0.04 - eps, 0.01 + eps), 0.01); | 214 TestSetPacketLossRate(states.encoder.get(), I(0.04 - eps, 0.01 + eps), 0.01); |
149 TestSetPacketLossRate(encoder_.get(), I(0.01 - eps, 0.00 ), 0.00); | 215 TestSetPacketLossRate(states.encoder.get(), I(0.01 - eps, 0.00 ), 0.00); |
150 // clang-format on | 216 // clang-format on |
151 } | 217 } |
152 | 218 |
| 219 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnSetUplinkBandwidth) { |
| 220 auto states = CreateCodec(2); |
| 221 printf("passed!\n"); |
| 222 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
| 223 |
| 224 auto config = CreateEncoderRuntimeConfig(); |
| 225 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
| 226 .WillOnce(Return(config)); |
| 227 |
| 228 // Since using mock audio network adaptor, any bandwidth value is fine. |
| 229 constexpr int kUplinkBandwidth = 50000; |
| 230 EXPECT_CALL(**states.mock_audio_network_adaptor, |
| 231 SetUplinkBandwidth(kUplinkBandwidth)); |
| 232 states.encoder->OnReceivedUplinkBandwidth(kUplinkBandwidth); |
| 233 |
| 234 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
| 235 } |
| 236 |
| 237 TEST(AudioEncoderOpusTest, |
| 238 InvokeAudioNetworkAdaptorOnSetUplinkPacketLossFraction) { |
| 239 auto states = CreateCodec(2); |
| 240 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
| 241 |
| 242 auto config = CreateEncoderRuntimeConfig(); |
| 243 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
| 244 .WillOnce(Return(config)); |
| 245 |
| 246 // Since using mock audio network adaptor, any packet loss fraction is fine. |
| 247 constexpr float kUplinkPacketLoss = 0.1f; |
| 248 EXPECT_CALL(**states.mock_audio_network_adaptor, |
| 249 SetUplinkPacketLossFraction(kUplinkPacketLoss)); |
| 250 states.encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss); |
| 251 |
| 252 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
| 253 } |
| 254 |
| 255 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnSetTargetAudioBitrate) { |
| 256 auto states = CreateCodec(2); |
| 257 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
| 258 |
| 259 auto config = CreateEncoderRuntimeConfig(); |
| 260 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
| 261 .WillOnce(Return(config)); |
| 262 |
| 263 // Since using mock audio network adaptor, any target audio bitrate is fine. |
| 264 constexpr int kTargetAudioBitrate = 30000; |
| 265 EXPECT_CALL(**states.mock_audio_network_adaptor, |
| 266 SetTargetAudioBitrate(kTargetAudioBitrate)); |
| 267 states.encoder->OnReceivedTargetAudioBitrate(kTargetAudioBitrate); |
| 268 |
| 269 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
| 270 } |
| 271 |
| 272 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnSetRtt) { |
| 273 auto states = CreateCodec(2); |
| 274 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
| 275 |
| 276 auto config = CreateEncoderRuntimeConfig(); |
| 277 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
| 278 .WillOnce(Return(config)); |
| 279 |
| 280 // Since using mock audio network adaptor, any rtt is fine. |
| 281 constexpr int kRtt = 30; |
| 282 EXPECT_CALL(**states.mock_audio_network_adaptor, SetRtt(kRtt)); |
| 283 states.encoder->OnReceivedRtt(kRtt); |
| 284 |
| 285 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
| 286 } |
| 287 |
| 288 TEST(AudioEncoderOpusTest, |
| 289 InvokeAudioNetworkAdaptorOnSetReceiverFrameLengthRange) { |
| 290 auto states = CreateCodec(2); |
| 291 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
| 292 |
| 293 auto config = CreateEncoderRuntimeConfig(); |
| 294 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
| 295 .WillOnce(Return(config)); |
| 296 |
| 297 constexpr int kMinFrameLength = 10; |
| 298 constexpr int kMaxFrameLength = 60; |
| 299 EXPECT_CALL(**states.mock_audio_network_adaptor, |
| 300 SetReceiverFrameLengthRange(kMinFrameLength, kMaxFrameLength)); |
| 301 states.encoder->SetReceiverFrameLengthRange(kMinFrameLength, kMaxFrameLength); |
| 302 |
| 303 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
| 304 } |
| 305 |
153 } // namespace webrtc | 306 } // namespace webrtc |
OLD | NEW |