OLD | NEW |
---|---|
(Empty) | |
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 <vector> | |
12 | |
13 #include "testing/gmock/include/gmock/gmock.h" | |
14 #include "testing/gtest/include/gtest/gtest.h" | |
15 | |
16 #include "webrtc/base/checks.h" | |
17 #include "webrtc/base/scoped_ptr.h" | |
18 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitra te_estimator.h" | |
19 #include "webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h" | |
20 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h" | |
21 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" | |
22 #include "webrtc/modules/utility/interface/mock/mock_process_thread.h" | |
23 #include "webrtc/system_wrappers/interface/clock.h" | |
24 | |
25 using ::testing::_; | |
26 using ::testing::Invoke; | |
27 | |
28 namespace webrtc { | |
29 namespace test { | |
30 | |
31 class TransportFeedbackAdapterTest : public ::testing::Test { | |
32 public: | |
33 TransportFeedbackAdapterTest() | |
34 : clock_(0), | |
35 bitrate_estimator_(nullptr), | |
36 receiver_estimated_bitrate_(0) {} | |
37 | |
38 virtual ~TransportFeedbackAdapterTest() {} | |
39 | |
40 virtual void SetUp() { | |
41 adapter_.reset(new TransportFeedbackAdapter( | |
42 new RtcpBandwidthObserverAdapter(this), &clock_, &process_thread_)); | |
43 | |
44 bitrate_estimator_ = new MockRemoteBitrateEstimator(); | |
45 EXPECT_CALL(process_thread_, RegisterModule(bitrate_estimator_)).Times(1); | |
46 adapter_->SetBitrateEstimator(bitrate_estimator_); | |
47 } | |
48 | |
49 virtual void TearDown() { | |
50 EXPECT_CALL(process_thread_, DeRegisterModule(bitrate_estimator_)).Times(1); | |
51 adapter_.reset(); | |
52 } | |
53 | |
54 protected: | |
55 // Proxy class used since TransportFeedbackAdapter will own the instance | |
56 // passed at construction. | |
57 class RtcpBandwidthObserverAdapter : public RtcpBandwidthObserver { | |
58 public: | |
59 explicit RtcpBandwidthObserverAdapter(TransportFeedbackAdapterTest* owner) | |
60 : owner_(owner) {} | |
61 | |
62 void OnReceivedEstimatedBitrate(uint32_t bitrate) override { | |
63 owner_->receiver_estimated_bitrate_ = bitrate; | |
64 } | |
65 | |
66 void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks, | |
67 int64_t rtt, | |
68 int64_t now_ms) override { | |
69 RTC_NOTREACHED(); | |
70 } | |
71 | |
72 TransportFeedbackAdapterTest* const owner_; | |
73 }; | |
74 | |
75 void OnReceivedEstimatedBitrate(uint32_t bitrate) {} | |
76 | |
77 void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks, | |
78 int64_t rtt, | |
79 int64_t now_ms) {} | |
80 | |
81 void ComparePacketVectors(const std::vector<PacketInfo>& truth, | |
82 const std::vector<PacketInfo>& input) { | |
83 ASSERT_EQ(truth.size(), input.size()); | |
84 size_t len = truth.size(); | |
85 int64_t arrival_time_delta = | |
86 truth[0].arrival_time_ms - input[0].arrival_time_ms; | |
stefan-webrtc
2015/09/11 08:15:12
Just from reading this code I don't fully understa
sprang_webrtc
2015/09/11 12:33:47
Done.
| |
87 for (size_t i = 0; i < len; ++i) { | |
88 EXPECT_EQ(truth[i].arrival_time_ms, | |
89 input[i].arrival_time_ms + arrival_time_delta); | |
90 EXPECT_EQ(truth[i].send_time_ms, input[i].send_time_ms); | |
91 EXPECT_EQ(truth[i].sequence_number, input[i].sequence_number); | |
92 EXPECT_EQ(truth[i].payload_size, input[i].payload_size); | |
93 EXPECT_EQ(truth[i].was_paced, input[i].was_paced); | |
94 } | |
95 } | |
96 | |
97 SimulatedClock clock_; | |
98 MockProcessThread process_thread_; | |
99 MockRemoteBitrateEstimator* bitrate_estimator_; | |
stefan-webrtc
2015/09/11 08:15:12
Do you have to allocate it on the heap? Would save
sprang_webrtc
2015/09/11 12:33:48
Yes, the instance will be owned by TransportFeedba
| |
100 rtc::scoped_ptr<TransportFeedbackAdapter> adapter_; | |
101 | |
102 uint32_t receiver_estimated_bitrate_; | |
103 }; | |
104 | |
105 TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) { | |
106 std::vector<PacketInfo> packets; | |
107 packets.push_back(PacketInfo(100, 200, 0, 1500, true)); | |
108 packets.push_back(PacketInfo(110, 210, 1, 1500, true)); | |
109 packets.push_back(PacketInfo(120, 220, 2, 1500, true)); | |
110 packets.push_back(PacketInfo(130, 230, 3, 1500, true)); | |
111 packets.push_back(PacketInfo(140, 240, 4, 1500, true)); | |
112 | |
113 for (const PacketInfo& packet : packets) { | |
114 adapter_->OnPacketSent(packet.sequence_number, packet.send_time_ms, | |
115 packet.payload_size, packet.was_paced); | |
stefan-webrtc
2015/09/11 08:15:12
Makes me wonder why we don't pass in a PacketInfo
sprang_webrtc
2015/09/11 12:33:47
Done.
| |
116 } | |
117 | |
118 rtcp::TransportFeedback feedback; | |
119 feedback.WithBase(packets[0].sequence_number, | |
120 packets[0].arrival_time_ms * 1000); | |
121 | |
122 for (const PacketInfo& packet : packets) { | |
123 EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number, | |
124 packet.arrival_time_ms * 1000)); | |
125 } | |
126 | |
127 feedback.Build(); | |
128 | |
129 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | |
130 .Times(1) | |
131 .WillOnce(Invoke( | |
132 [packets, this](const std::vector<PacketInfo>& feedback_vector) { | |
133 ComparePacketVectors(packets, feedback_vector); | |
134 })); | |
135 adapter_->OnTransportFeedback(feedback); | |
136 } | |
137 | |
138 TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) { | |
139 std::vector<PacketInfo> packets; | |
140 packets.push_back(PacketInfo(100, 200, 0, 1500, true)); | |
141 packets.push_back(PacketInfo(110, 210, 1, 1500, true)); | |
142 packets.push_back(PacketInfo(120, 220, 2, 1500, true)); | |
143 packets.push_back(PacketInfo(130, 230, 3, 1500, true)); | |
144 packets.push_back(PacketInfo(140, 240, 4, 1500, true)); | |
145 | |
146 const uint16_t kSendSideDropBefore = 1; | |
147 const uint16_t kReceiveSideDropAfter = 3; | |
148 | |
149 for (const PacketInfo& packet : packets) { | |
150 if (packet.sequence_number >= kSendSideDropBefore) { | |
151 adapter_->OnPacketSent(packet.sequence_number, packet.send_time_ms, | |
152 packet.payload_size, packet.was_paced); | |
153 } | |
154 } | |
155 | |
156 rtcp::TransportFeedback feedback; | |
157 feedback.WithBase(packets[0].sequence_number, | |
158 packets[0].arrival_time_ms * 1000); | |
159 | |
160 for (const PacketInfo& packet : packets) { | |
161 if (packet.sequence_number <= kReceiveSideDropAfter) { | |
162 EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number, | |
163 packet.arrival_time_ms * 1000)); | |
164 } | |
165 } | |
166 | |
167 feedback.Build(); | |
168 | |
169 std::vector<PacketInfo> expected_packets( | |
170 packets.begin() + kSendSideDropBefore, | |
171 packets.begin() + kReceiveSideDropAfter + 1); | |
172 | |
173 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | |
174 .Times(1) | |
175 .WillOnce(Invoke([expected_packets, | |
176 this](const std::vector<PacketInfo>& feedback_vector) { | |
177 ComparePacketVectors(expected_packets, feedback_vector); | |
178 })); | |
179 adapter_->OnTransportFeedback(feedback); | |
180 } | |
181 | |
182 TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) { | |
183 int64_t kHighArrivalTimeMs = rtcp::TransportFeedback::kDeltaScaleFactor * | |
184 (1L << 8) * ((1L << 23) - 1) / 1000; | |
185 std::vector<PacketInfo> packets; | |
186 packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500, true)); | |
187 packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500, true)); | |
188 packets.push_back(PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, true)); | |
189 | |
190 for (const PacketInfo& packet : packets) { | |
191 adapter_->OnPacketSent(packet.sequence_number, packet.send_time_ms, | |
192 packet.payload_size, packet.was_paced); | |
193 } | |
194 | |
195 for (size_t i = 0; i < packets.size(); ++i) { | |
196 rtc::scoped_ptr<rtcp::TransportFeedback> feedback( | |
197 new rtcp::TransportFeedback()); | |
198 feedback->WithBase(packets[i].sequence_number, | |
199 packets[i].arrival_time_ms * 1000); | |
200 | |
201 EXPECT_TRUE(feedback->WithReceivedPacket( | |
202 packets[i].sequence_number, packets[i].arrival_time_ms * 1000)); | |
203 | |
204 rtc::scoped_ptr<rtcp::RawPacket> raw_packet = feedback->Build(); | |
205 feedback = rtcp::TransportFeedback::ParseFrom(raw_packet->Buffer(), | |
206 raw_packet->Length()); | |
207 | |
208 std::vector<PacketInfo> expected_packets; | |
209 expected_packets.push_back(packets[i]); | |
210 | |
211 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | |
212 .Times(1) | |
213 .WillOnce(Invoke([expected_packets, this]( | |
214 const std::vector<PacketInfo>& feedback_vector) { | |
215 ComparePacketVectors(expected_packets, feedback_vector); | |
216 })); | |
217 adapter_->OnTransportFeedback(*feedback.get()); | |
218 } | |
219 } | |
220 | |
stefan-webrtc
2015/09/11 08:15:12
Should we have a test for the limit on time deltas
sprang_webrtc
2015/09/11 12:33:48
Done.
| |
221 } // namespace test | |
222 } // namespace webrtc | |
OLD | NEW |