OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
| 11 #include "base/memory/ptr_util.h" |
11 #include "base/test/simple_test_tick_clock.h" | 12 #include "base/test/simple_test_tick_clock.h" |
12 #include "media/cast/net/cast_transport_config.h" | 13 #include "media/cast/net/cast_transport_config.h" |
13 #include "media/cast/net/pacing/paced_sender.h" | 14 #include "media/cast/net/pacing/paced_sender.h" |
14 #include "media/cast/net/rtcp/receiver_rtcp_session.h" | 15 #include "media/cast/net/rtcp/receiver_rtcp_session.h" |
15 #include "media/cast/net/rtcp/rtcp_builder.h" | 16 #include "media/cast/net/rtcp/rtcp_builder.h" |
16 #include "media/cast/net/rtcp/rtcp_session.h" | 17 #include "media/cast/net/rtcp/rtcp_session.h" |
17 #include "media/cast/net/rtcp/rtcp_utility.h" | 18 #include "media/cast/net/rtcp/rtcp_utility.h" |
18 #include "media/cast/net/rtcp/sender_rtcp_session.h" | 19 #include "media/cast/net/rtcp/sender_rtcp_session.h" |
19 #include "media/cast/test/skewed_tick_clock.h" | 20 #include "media/cast/test/skewed_tick_clock.h" |
20 #include "testing/gmock/include/gmock/gmock.h" | 21 #include "testing/gmock/include/gmock/gmock.h" |
21 | 22 |
22 namespace media { | 23 namespace media { |
23 namespace cast { | 24 namespace cast { |
24 | 25 |
| 26 class RtcpTest; |
| 27 |
25 namespace { | 28 namespace { |
26 | 29 |
27 media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) { | 30 media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) { |
28 media::cast::RtcpTimeData ret; | 31 media::cast::RtcpTimeData ret; |
29 ret.timestamp = now; | 32 ret.timestamp = now; |
30 media::cast::ConvertTimeTicksToNtp(now, &ret.ntp_seconds, &ret.ntp_fraction); | 33 media::cast::ConvertTimeTicksToNtp(now, &ret.ntp_seconds, &ret.ntp_fraction); |
31 return ret; | 34 return ret; |
32 } | 35 } |
33 | 36 |
| 37 class RtcpClient : public SenderRtcpSession::Client { |
| 38 public: |
| 39 explicit RtcpClient(RtcpTest* rtcp_test) : rtcp_test_(rtcp_test) {} |
| 40 |
| 41 void OnCastMessageReceived(const RtcpCastMessage& cast_message) override; |
| 42 void OnRttReceived(base::TimeDelta round_trip_time) override; |
| 43 void OnReceiverLogReceived(const RtcpReceiverLogMessage& log) override; |
| 44 void OnPliReceived() override; |
| 45 |
| 46 private: |
| 47 RtcpTest* const rtcp_test_; |
| 48 |
| 49 DISALLOW_COPY_AND_ASSIGN(RtcpClient); |
| 50 }; |
| 51 |
34 } // namespace | 52 } // namespace |
35 | 53 |
36 using testing::_; | 54 using testing::_; |
37 | 55 |
38 static const uint32_t kSenderSsrc = 0x10203; | 56 static const uint32_t kSenderSsrc = 0x10203; |
39 static const uint32_t kReceiverSsrc = 0x40506; | 57 static const uint32_t kReceiverSsrc = 0x40506; |
40 static const int kInitialReceiverClockOffsetSeconds = -5; | 58 static const int kInitialReceiverClockOffsetSeconds = -5; |
41 static const uint16_t kTargetDelayMs = 100; | 59 static const uint16_t kTargetDelayMs = 100; |
42 | 60 |
43 class FakeRtcpTransport : public PacedPacketSender { | 61 class FakeRtcpTransport : public PacedPacketSender { |
(...skipping 25 matching lines...) Expand all Loading... |
69 | 87 |
70 private: | 88 private: |
71 base::SimpleTestTickClock* const clock_; | 89 base::SimpleTestTickClock* const clock_; |
72 base::TimeDelta packet_delay_; | 90 base::TimeDelta packet_delay_; |
73 RtcpSession* rtcp_session_; // RTCP destination. | 91 RtcpSession* rtcp_session_; // RTCP destination. |
74 | 92 |
75 DISALLOW_COPY_AND_ASSIGN(FakeRtcpTransport); | 93 DISALLOW_COPY_AND_ASSIGN(FakeRtcpTransport); |
76 }; | 94 }; |
77 | 95 |
78 class RtcpTest : public ::testing::Test { | 96 class RtcpTest : public ::testing::Test { |
79 protected: | 97 public: |
80 RtcpTest() | |
81 : sender_clock_(new base::SimpleTestTickClock()), | |
82 receiver_clock_(new test::SkewedTickClock(sender_clock_.get())), | |
83 rtp_sender_pacer_(sender_clock_.get()), | |
84 rtp_receiver_pacer_(sender_clock_.get()), | |
85 rtcp_at_rtp_sender_( | |
86 base::Bind(&RtcpTest::OnReceivedCastFeedback, | |
87 base::Unretained(this)), | |
88 base::Bind(&RtcpTest::OnMeasuredRoundTripTime, | |
89 base::Unretained(this)), | |
90 base::Bind(&RtcpTest::OnReceivedLogs, base::Unretained(this)), | |
91 base::Bind(&RtcpTest::OnReceivedPli, base::Unretained(this)), | |
92 sender_clock_.get(), | |
93 &rtp_sender_pacer_, | |
94 kSenderSsrc, | |
95 kReceiverSsrc), | |
96 rtcp_at_rtp_receiver_(receiver_clock_.get(), | |
97 kReceiverSsrc, | |
98 kSenderSsrc), | |
99 received_pli_(false) { | |
100 sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); | |
101 receiver_clock_->SetSkew( | |
102 1.0, // No skew. | |
103 base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds)); | |
104 | |
105 rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_); | |
106 rtp_receiver_pacer_.set_rtcp_destination(&rtcp_at_rtp_sender_); | |
107 } | |
108 | |
109 ~RtcpTest() override {} | |
110 | |
111 void OnReceivedCastFeedback(const RtcpCastMessage& cast_message) { | 98 void OnReceivedCastFeedback(const RtcpCastMessage& cast_message) { |
112 last_cast_message_ = cast_message; | 99 last_cast_message_ = cast_message; |
113 } | 100 } |
114 | 101 |
115 void OnMeasuredRoundTripTime(base::TimeDelta rtt) { | 102 void OnMeasuredRoundTripTime(base::TimeDelta rtt) { |
116 current_round_trip_time_ = rtt; | 103 current_round_trip_time_ = rtt; |
117 } | 104 } |
118 | 105 |
119 void OnReceivedLogs(const RtcpReceiverLogMessage& receiver_logs) { | 106 void OnReceivedLogs(const RtcpReceiverLogMessage& receiver_logs) { |
120 RtcpReceiverLogMessage().swap(last_logs_); | 107 RtcpReceiverLogMessage().swap(last_logs_); |
121 | 108 |
122 // Make a copy of the logs. | 109 // Make a copy of the logs. |
123 for (const RtcpReceiverFrameLogMessage& frame_log_msg : receiver_logs) { | 110 for (const RtcpReceiverFrameLogMessage& frame_log_msg : receiver_logs) { |
124 last_logs_.push_back( | 111 last_logs_.push_back( |
125 RtcpReceiverFrameLogMessage(frame_log_msg.rtp_timestamp_)); | 112 RtcpReceiverFrameLogMessage(frame_log_msg.rtp_timestamp_)); |
126 for (const RtcpReceiverEventLogMessage& event_log_msg : | 113 for (const RtcpReceiverEventLogMessage& event_log_msg : |
127 frame_log_msg.event_log_messages_) { | 114 frame_log_msg.event_log_messages_) { |
128 RtcpReceiverEventLogMessage event_log; | 115 RtcpReceiverEventLogMessage event_log; |
129 event_log.type = event_log_msg.type; | 116 event_log.type = event_log_msg.type; |
130 event_log.event_timestamp = event_log_msg.event_timestamp; | 117 event_log.event_timestamp = event_log_msg.event_timestamp; |
131 event_log.delay_delta = event_log_msg.delay_delta; | 118 event_log.delay_delta = event_log_msg.delay_delta; |
132 event_log.packet_id = event_log_msg.packet_id; | 119 event_log.packet_id = event_log_msg.packet_id; |
133 last_logs_.back().event_log_messages_.push_back(event_log); | 120 last_logs_.back().event_log_messages_.push_back(event_log); |
134 } | 121 } |
135 } | 122 } |
136 } | 123 } |
137 | 124 |
| 125 void OnReceivedPli() { received_pli_ = true; } |
| 126 |
| 127 protected: |
| 128 RtcpTest() |
| 129 : sender_clock_(new base::SimpleTestTickClock()), |
| 130 receiver_clock_(new test::SkewedTickClock(sender_clock_.get())), |
| 131 rtp_sender_pacer_(sender_clock_.get()), |
| 132 rtp_receiver_pacer_(sender_clock_.get()), |
| 133 rtcp_at_rtp_sender_(base::WrapUnique(new RtcpClient(this)), |
| 134 sender_clock_.get(), |
| 135 &rtp_sender_pacer_, |
| 136 kSenderSsrc, |
| 137 kReceiverSsrc), |
| 138 rtcp_at_rtp_receiver_(receiver_clock_.get(), |
| 139 kReceiverSsrc, |
| 140 kSenderSsrc), |
| 141 received_pli_(false) { |
| 142 sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); |
| 143 receiver_clock_->SetSkew( |
| 144 1.0, // No skew. |
| 145 base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds)); |
| 146 |
| 147 rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_); |
| 148 rtp_receiver_pacer_.set_rtcp_destination(&rtcp_at_rtp_sender_); |
| 149 } |
| 150 |
| 151 ~RtcpTest() override {} |
| 152 |
138 PacketRef BuildRtcpPacketFromRtpReceiver( | 153 PacketRef BuildRtcpPacketFromRtpReceiver( |
139 const RtcpTimeData& time_data, | 154 const RtcpTimeData& time_data, |
140 const RtcpCastMessage* cast_message, | 155 const RtcpCastMessage* cast_message, |
141 const RtcpPliMessage* pli_message, | 156 const RtcpPliMessage* pli_message, |
142 base::TimeDelta target_delay, | 157 base::TimeDelta target_delay, |
143 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events, | 158 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events, |
144 const RtpReceiverStatistics* rtp_receiver_statistics) { | 159 const RtpReceiverStatistics* rtp_receiver_statistics) { |
145 RtcpBuilder builder(rtcp_at_rtp_receiver_.local_ssrc()); | 160 RtcpBuilder builder(rtcp_at_rtp_receiver_.local_ssrc()); |
146 builder.Start(); | 161 builder.Start(); |
147 RtcpReceiverReferenceTimeReport rrtr; | 162 RtcpReceiverReferenceTimeReport rrtr; |
(...skipping 27 matching lines...) Expand all Loading... |
175 } | 190 } |
176 if (cast_message) | 191 if (cast_message) |
177 builder.AddCast(*cast_message, target_delay); | 192 builder.AddCast(*cast_message, target_delay); |
178 if (pli_message) | 193 if (pli_message) |
179 builder.AddPli(*pli_message); | 194 builder.AddPli(*pli_message); |
180 if (rtcp_events) | 195 if (rtcp_events) |
181 builder.AddReceiverLog(*rtcp_events); | 196 builder.AddReceiverLog(*rtcp_events); |
182 return builder.Finish(); | 197 return builder.Finish(); |
183 } | 198 } |
184 | 199 |
185 void OnReceivedPli() { received_pli_ = true; } | 200 std::unique_ptr<base::SimpleTestTickClock> sender_clock_; |
186 | 201 std::unique_ptr<test::SkewedTickClock> receiver_clock_; |
187 scoped_ptr<base::SimpleTestTickClock> sender_clock_; | |
188 scoped_ptr<test::SkewedTickClock> receiver_clock_; | |
189 FakeRtcpTransport rtp_sender_pacer_; | 202 FakeRtcpTransport rtp_sender_pacer_; |
190 FakeRtcpTransport rtp_receiver_pacer_; | 203 FakeRtcpTransport rtp_receiver_pacer_; |
191 SenderRtcpSession rtcp_at_rtp_sender_; | 204 SenderRtcpSession rtcp_at_rtp_sender_; |
192 ReceiverRtcpSession rtcp_at_rtp_receiver_; | 205 ReceiverRtcpSession rtcp_at_rtp_receiver_; |
193 | 206 |
194 base::TimeDelta current_round_trip_time_; | 207 base::TimeDelta current_round_trip_time_; |
195 RtcpCastMessage last_cast_message_; | 208 RtcpCastMessage last_cast_message_; |
196 RtcpReceiverLogMessage last_logs_; | 209 RtcpReceiverLogMessage last_logs_; |
197 bool received_pli_; | 210 bool received_pli_; |
198 | 211 |
199 private: | 212 private: |
200 DISALLOW_COPY_AND_ASSIGN(RtcpTest); | 213 DISALLOW_COPY_AND_ASSIGN(RtcpTest); |
201 }; | 214 }; |
202 | 215 |
| 216 namespace { |
| 217 |
| 218 void RtcpClient::OnCastMessageReceived(const RtcpCastMessage& cast_message) { |
| 219 rtcp_test_->OnReceivedCastFeedback(cast_message); |
| 220 } |
| 221 |
| 222 void RtcpClient::OnRttReceived(base::TimeDelta round_trip_time) { |
| 223 rtcp_test_->OnMeasuredRoundTripTime(round_trip_time); |
| 224 } |
| 225 |
| 226 void RtcpClient::OnReceiverLogReceived(const RtcpReceiverLogMessage& log) { |
| 227 rtcp_test_->OnReceivedLogs(log); |
| 228 } |
| 229 |
| 230 void RtcpClient::OnPliReceived() { |
| 231 rtcp_test_->OnReceivedPli(); |
| 232 } |
| 233 |
| 234 } // namespace |
| 235 |
203 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) { | 236 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) { |
204 // Initially, expect no lip-sync info receiver-side without having first | 237 // Initially, expect no lip-sync info receiver-side without having first |
205 // received a RTCP packet. | 238 // received a RTCP packet. |
206 base::TimeTicks reference_time; | 239 base::TimeTicks reference_time; |
207 RtpTimeTicks rtp_timestamp; | 240 RtpTimeTicks rtp_timestamp; |
208 ASSERT_FALSE(rtcp_at_rtp_receiver_.GetLatestLipSyncTimes(&rtp_timestamp, | 241 ASSERT_FALSE(rtcp_at_rtp_receiver_.GetLatestLipSyncTimes(&rtp_timestamp, |
209 &reference_time)); | 242 &reference_time)); |
210 | 243 |
211 // Send a Sender Report to the receiver. | 244 // Send a Sender Report to the receiver. |
212 const base::TimeTicks reference_time_sent = sender_clock_->NowTicks(); | 245 const base::TimeTicks reference_time_sent = sender_clock_->NowTicks(); |
(...skipping 156 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
369 // Only 24 bits of event timestamp sent on wire. | 402 // Only 24 bits of event timestamp sent on wire. |
370 uint32_t event_ts = | 403 uint32_t event_ts = |
371 (event.timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff; | 404 (event.timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff; |
372 uint32_t log_msg_ts = | 405 uint32_t log_msg_ts = |
373 (log_msg.event_timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff; | 406 (log_msg.event_timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff; |
374 EXPECT_EQ(log_msg_ts, event_ts); | 407 EXPECT_EQ(log_msg_ts, event_ts); |
375 } | 408 } |
376 | 409 |
377 } // namespace cast | 410 } // namespace cast |
378 } // namespace media | 411 } // namespace media |
OLD | NEW |