1 /*
2 * Copyright (c) 2014 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 "absl/flags/flag.h"
12 #include "modules/audio_coding/codecs/opus/opus_inst.h"
13 #include "modules/audio_coding/codecs/opus/opus_interface.h"
14 #include "modules/audio_coding/neteq/tools/neteq_quality_test.h"
15
16 ABSL_FLAG(int, bit_rate_kbps, 32, "Target bit rate (kbps).");
17
18 ABSL_FLAG(int,
19 complexity,
20 10,
21 "Complexity: 0 ~ 10 -- defined as in Opus"
22 "specification.");
23
24 ABSL_FLAG(int, maxplaybackrate, 48000, "Maximum playback rate (Hz).");
25
26 ABSL_FLAG(int, application, 0, "Application mode: 0 -- VOIP, 1 -- Audio.");
27
28 ABSL_FLAG(int, reported_loss_rate, 10, "Reported percentile of packet loss.");
29
30 ABSL_FLAG(bool, fec, false, "Enable FEC for encoding (-nofec to disable).");
31
32 ABSL_FLAG(bool, dtx, false, "Enable DTX for encoding (-nodtx to disable).");
33
34 ABSL_FLAG(int, sub_packets, 1, "Number of sub packets to repacketize.");
35
36 using ::testing::InitGoogleTest;
37
38 namespace webrtc {
39 namespace test {
40 namespace {
41
42 static const int kOpusBlockDurationMs = 20;
43 static const int kOpusSamplingKhz = 48;
44 } // namespace
45
46 class NetEqOpusQualityTest : public NetEqQualityTest {
47 protected:
48 NetEqOpusQualityTest();
49 void SetUp() override;
50 void TearDown() override;
51 int EncodeBlock(int16_t* in_data,
52 size_t block_size_samples,
53 rtc::Buffer* payload,
54 size_t max_bytes) override;
55
56 private:
57 WebRtcOpusEncInst* opus_encoder_;
58 OpusRepacketizer* repacketizer_;
59 size_t sub_block_size_samples_;
60 int bit_rate_kbps_;
61 bool fec_;
62 bool dtx_;
63 int complexity_;
64 int maxplaybackrate_;
65 int target_loss_rate_;
66 int sub_packets_;
67 int application_;
68 };
69
NetEqOpusQualityTest()70 NetEqOpusQualityTest::NetEqOpusQualityTest()
71 : NetEqQualityTest(kOpusBlockDurationMs * absl::GetFlag(FLAGS_sub_packets),
72 kOpusSamplingKhz,
73 kOpusSamplingKhz,
74 SdpAudioFormat("opus", 48000, 2)),
75 opus_encoder_(NULL),
76 repacketizer_(NULL),
77 sub_block_size_samples_(
78 static_cast<size_t>(kOpusBlockDurationMs * kOpusSamplingKhz)),
79 bit_rate_kbps_(absl::GetFlag(FLAGS_bit_rate_kbps)),
80 fec_(absl::GetFlag(FLAGS_fec)),
81 dtx_(absl::GetFlag(FLAGS_dtx)),
82 complexity_(absl::GetFlag(FLAGS_complexity)),
83 maxplaybackrate_(absl::GetFlag(FLAGS_maxplaybackrate)),
84 target_loss_rate_(absl::GetFlag(FLAGS_reported_loss_rate)),
85 sub_packets_(absl::GetFlag(FLAGS_sub_packets)) {
86 // Flag validation
87 RTC_CHECK(absl::GetFlag(FLAGS_bit_rate_kbps) >= 6 &&
88 absl::GetFlag(FLAGS_bit_rate_kbps) <= 510)
89 << "Invalid bit rate, should be between 6 and 510 kbps.";
90
91 RTC_CHECK(absl::GetFlag(FLAGS_complexity) >= -1 &&
92 absl::GetFlag(FLAGS_complexity) <= 10)
93 << "Invalid complexity setting, should be between 0 and 10.";
94
95 RTC_CHECK(absl::GetFlag(FLAGS_application) == 0 ||
96 absl::GetFlag(FLAGS_application) == 1)
97 << "Invalid application mode, should be 0 or 1.";
98
99 RTC_CHECK(absl::GetFlag(FLAGS_reported_loss_rate) >= 0 &&
100 absl::GetFlag(FLAGS_reported_loss_rate) <= 100)
101 << "Invalid packet loss percentile, should be between 0 and 100.";
102
103 RTC_CHECK(absl::GetFlag(FLAGS_sub_packets) >= 1 &&
104 absl::GetFlag(FLAGS_sub_packets) <= 3)
105 << "Invalid number of sub packets, should be between 1 and 3.";
106
107 // Redefine decoder type if input is stereo.
108 if (channels_ > 1) {
109 audio_format_ = SdpAudioFormat("opus", 48000, 2,
110 SdpAudioFormat::Parameters{{"stereo", "1"}});
111 }
112 application_ = absl::GetFlag(FLAGS_application);
113 }
114
SetUp()115 void NetEqOpusQualityTest::SetUp() {
116 // Create encoder memory.
117 WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_, 48000);
118 ASSERT_TRUE(opus_encoder_);
119
120 // Create repacketizer.
121 repacketizer_ = opus_repacketizer_create();
122 ASSERT_TRUE(repacketizer_);
123
124 // Set bitrate.
125 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_, bit_rate_kbps_ * 1000));
126 if (fec_) {
127 EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_encoder_));
128 }
129 if (dtx_) {
130 EXPECT_EQ(0, WebRtcOpus_EnableDtx(opus_encoder_));
131 }
132 EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_encoder_, complexity_));
133 EXPECT_EQ(0, WebRtcOpus_SetMaxPlaybackRate(opus_encoder_, maxplaybackrate_));
134 EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_encoder_, target_loss_rate_));
135 NetEqQualityTest::SetUp();
136 }
137
TearDown()138 void NetEqOpusQualityTest::TearDown() {
139 // Free memory.
140 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
141 opus_repacketizer_destroy(repacketizer_);
142 NetEqQualityTest::TearDown();
143 }
144
EncodeBlock(int16_t * in_data,size_t block_size_samples,rtc::Buffer * payload,size_t max_bytes)145 int NetEqOpusQualityTest::EncodeBlock(int16_t* in_data,
146 size_t block_size_samples,
147 rtc::Buffer* payload,
148 size_t max_bytes) {
149 EXPECT_EQ(block_size_samples, sub_block_size_samples_ * sub_packets_);
150 int16_t* pointer = in_data;
151 int value;
152 opus_repacketizer_init(repacketizer_);
153 for (int idx = 0; idx < sub_packets_; idx++) {
154 payload->AppendData(max_bytes, [&](rtc::ArrayView<uint8_t> payload) {
155 value = WebRtcOpus_Encode(opus_encoder_, pointer, sub_block_size_samples_,
156 max_bytes, payload.data());
157
158 Log() << "Encoded a frame with Opus mode "
159 << (value == 0 ? 0 : payload[0] >> 3) << std::endl;
160
161 return (value >= 0) ? static_cast<size_t>(value) : 0;
162 });
163
164 if (OPUS_OK !=
165 opus_repacketizer_cat(repacketizer_, payload->data(), value)) {
166 opus_repacketizer_init(repacketizer_);
167 // If the repacketization fails, we discard this frame.
168 return 0;
169 }
170 pointer += sub_block_size_samples_ * channels_;
171 }
172 value = opus_repacketizer_out(repacketizer_, payload->data(),
173 static_cast<opus_int32>(max_bytes));
174 EXPECT_GE(value, 0);
175 return value;
176 }
177
TEST_F(NetEqOpusQualityTest,Test)178 TEST_F(NetEqOpusQualityTest, Test) {
179 Simulate();
180 }
181
182 } // namespace test
183 } // namespace webrtc
184