OLD | NEW |
---|---|
(Empty) | |
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 | |
11 #include "webrtc/test/call_test.h" | |
12 #include "webrtc/test/gtest.h" | |
13 #include "webrtc/test/rtcp_packet_parser.h" | |
14 | |
15 namespace webrtc { | |
16 namespace test { | |
17 namespace { | |
18 | |
19 class AudioSendTest : public SendTest { | |
20 public: | |
21 AudioSendTest() : SendTest(CallTest::kDefaultTimeoutMs) {} | |
22 | |
23 size_t GetNumVideoStreams() const override { | |
24 return 0; | |
25 } | |
26 size_t GetNumAudioStreams() const override { | |
27 return 1; | |
28 } | |
29 size_t GetNumFlexfecStreams() const override { | |
30 return 0; | |
31 } | |
32 }; | |
33 } // namespace | |
34 | |
35 using AudioSendStreamCallTest = CallTest; | |
36 | |
37 TEST_F(AudioSendStreamCallTest, SupportsCName) { | |
38 static std::string kCName = "PjqatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo="; | |
39 class CNameObserver : public AudioSendTest { | |
40 public: | |
41 CNameObserver() = default; | |
42 | |
43 private: | |
44 Action OnSendRtcp(const uint8_t* packet, size_t length) override { | |
45 RtcpPacketParser parser; | |
46 EXPECT_TRUE(parser.Parse(packet, length)); | |
47 if (parser.sdes()->num_packets() > 0) { | |
48 EXPECT_EQ(1u, parser.sdes()->chunks().size()); | |
49 EXPECT_EQ(kCName, parser.sdes()->chunks()[0].cname); | |
50 | |
51 observation_complete_.Set(); | |
52 } | |
53 | |
54 return SEND_PACKET; | |
55 } | |
56 | |
57 void ModifyAudioConfigs( | |
58 AudioSendStream::Config* send_config, | |
59 std::vector<AudioReceiveStream::Config>* receive_configs) override { | |
60 send_config->rtp.c_name = kCName; | |
61 } | |
62 | |
63 void PerformTest() override { | |
64 EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP with CNAME."; | |
65 } | |
66 } test; | |
67 | |
68 RunBaseTest(&test); | |
69 } | |
70 | |
71 TEST_F(AudioSendStreamCallTest, NoExtensionsByDefault) { | |
72 class NoExtensionsObserver : public AudioSendTest { | |
73 public: | |
74 NoExtensionsObserver() = default; | |
75 | |
76 private: | |
77 Action OnSendRtp(const uint8_t* packet, size_t length) override { | |
78 RTPHeader header; | |
79 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | |
80 | |
81 EXPECT_FALSE(header.extension.hasTransmissionTimeOffset); | |
82 EXPECT_FALSE(header.extension.hasAbsoluteSendTime); | |
83 EXPECT_FALSE(header.extension.hasTransportSequenceNumber); | |
84 EXPECT_FALSE(header.extension.hasAudioLevel); | |
85 EXPECT_FALSE(header.extension.hasVideoRotation); | |
86 EXPECT_FALSE(header.extension.hasVideoContentType); | |
87 observation_complete_.Set(); | |
88 | |
89 return SEND_PACKET; | |
90 } | |
91 | |
92 void ModifyAudioConfigs( | |
93 AudioSendStream::Config* send_config, | |
94 std::vector<AudioReceiveStream::Config>* receive_configs) override { | |
95 send_config->rtp.extensions.clear(); | |
96 } | |
97 | |
98 void PerformTest() override { | |
99 EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet."; | |
100 } | |
101 } test; | |
102 | |
103 RunBaseTest(&test); | |
104 } | |
105 | |
106 TEST_F(AudioSendStreamCallTest, SupportsAudioLevel) { | |
107 class AudioLevelObserver : public AudioSendTest { | |
108 public: | |
109 AudioLevelObserver() : AudioSendTest() { | |
110 EXPECT_TRUE(parser_->RegisterRtpHeaderExtension( | |
111 kRtpExtensionAudioLevel, test::kAudioLevelExtensionId)); | |
112 } | |
113 | |
114 Action OnSendRtp(const uint8_t* packet, size_t length) override { | |
115 RTPHeader header; | |
116 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | |
117 | |
118 EXPECT_TRUE(header.extension.hasAudioLevel); | |
119 if (header.extension.audioLevel != 0) { | |
120 // Wait for at least one packet with a non-zero level. | |
121 observation_complete_.Set(); | |
122 } else { | |
123 LOG(LS_WARNING) << "Got a packet with zero audioLevel - waiting" | |
124 " for another packet..."; | |
125 } | |
126 | |
127 return SEND_PACKET; | |
128 } | |
129 | |
130 void ModifyAudioConfigs( | |
131 AudioSendStream::Config* send_config, | |
132 std::vector<AudioReceiveStream::Config>* receive_configs) override { | |
133 send_config->rtp.extensions.clear(); | |
134 send_config->rtp.extensions.push_back(RtpExtension( | |
135 RtpExtension::kAudioLevelUri, test::kAudioLevelExtensionId)); | |
136 } | |
137 | |
138 void PerformTest() override { | |
139 EXPECT_TRUE(Wait()) << "Timed out while waiting for single RTP packet."; | |
140 } | |
141 } test; | |
142 | |
143 RunBaseTest(&test); | |
144 } | |
145 | |
146 TEST_F(AudioSendStreamCallTest, SupportsTransportWideSequenceNumbers) { | |
147 static const uint8_t kExtensionId = test::kTransportSequenceNumberExtensionId; | |
148 class TransportWideSequenceNumberObserver : public AudioSendTest { | |
149 public: | |
150 TransportWideSequenceNumberObserver() : AudioSendTest() { | |
151 EXPECT_TRUE(parser_->RegisterRtpHeaderExtension( | |
152 kRtpExtensionTransportSequenceNumber, kExtensionId)); | |
153 } | |
154 | |
155 private: | |
156 Action OnSendRtp(const uint8_t* packet, size_t length) override { | |
157 RTPHeader header; | |
158 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | |
159 | |
160 EXPECT_TRUE(header.extension.hasTransportSequenceNumber); | |
161 EXPECT_FALSE(header.extension.hasTransmissionTimeOffset); | |
162 EXPECT_FALSE(header.extension.hasAbsoluteSendTime); | |
163 | |
164 observation_complete_.Set(); | |
165 | |
166 return SEND_PACKET; | |
167 } | |
168 | |
169 void ModifyAudioConfigs( | |
170 AudioSendStream::Config* send_config, | |
171 std::vector<AudioReceiveStream::Config>* receive_configs) override { | |
172 send_config->rtp.extensions.clear(); | |
173 send_config->rtp.extensions.push_back(RtpExtension( | |
174 RtpExtension::kTransportSequenceNumberUri, kExtensionId)); | |
175 } | |
176 | |
177 void PerformTest() override { | |
178 EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet."; | |
179 } | |
180 } test; | |
181 | |
182 RunBaseTest(&test); | |
183 } | |
184 | |
185 TEST_F(AudioSendStreamCallTest, SendDtmf) { | |
186 static const uint8_t kDtmfPayloadType = 120; | |
187 static const int kDtmfPayloadFrequency = 8000; | |
188 static const int kDtmfEventFirst = 12; | |
189 static const int kDtmfEventLast = 31; | |
190 static const int kDtmfDuration = 50; | |
191 class DtmfObserver : public AudioSendTest { | |
192 public: | |
193 DtmfObserver() = default; | |
194 | |
195 private: | |
196 Action OnSendRtp(const uint8_t* packet, size_t length) override { | |
197 RTPHeader header; | |
198 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | |
199 | |
200 if (header.payloadType == kDtmfPayloadType) { | |
201 EXPECT_EQ(12u, header.headerLength); | |
202 EXPECT_EQ(16u, length); | |
203 const int event = packet[12]; | |
204 if (event == expected_dtmf_event_) { | |
205 if (expected_dtmf_event_ == kDtmfEventLast) { | |
206 observation_complete_.Set(); | |
207 } | |
208 } else { | |
ossu
2017/09/15 12:20:21
So, now we only advance the expected dtmf event if
the sun
2017/09/15 13:08:26
Yes. Good catch!
| |
209 ++expected_dtmf_event_; | |
210 EXPECT_EQ(event, expected_dtmf_event_); | |
211 } | |
212 } | |
213 | |
214 return SEND_PACKET; | |
215 } | |
216 | |
217 void OnAudioStreamsCreated( | |
218 AudioSendStream* send_stream, | |
219 const std::vector<AudioReceiveStream*>& receive_streams) override { | |
220 // Need to start stream here, else DTMF events are dropped. | |
221 send_stream->Start(); | |
222 for (int event = kDtmfEventFirst; event <= kDtmfEventLast; ++event) { | |
223 send_stream->SendTelephoneEvent(kDtmfPayloadType, kDtmfPayloadFrequency, | |
224 event, kDtmfDuration); | |
225 } | |
226 } | |
227 | |
228 void PerformTest() override { | |
229 EXPECT_TRUE(Wait()) << "Timed out while waiting for DTMF stream."; | |
230 } | |
231 | |
232 int expected_dtmf_event_ = kDtmfEventFirst; | |
233 } test; | |
234 | |
235 RunBaseTest(&test); | |
236 } | |
237 | |
238 } // namespace test | |
239 } // namespace webrtc | |
OLD | NEW |