| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <stdint.h> | |
| 6 | |
| 7 #include "base/test/simple_test_tick_clock.h" | |
| 8 #include "media/cast/cast_defines.h" | |
| 9 #include "media/cast/cast_environment.h" | |
| 10 #include "media/cast/rtcp/mock_rtcp_receiver_feedback.h" | |
| 11 #include "media/cast/rtcp/mock_rtcp_sender_feedback.h" | |
| 12 #include "media/cast/rtcp/rtcp.h" | |
| 13 #include "media/cast/rtcp/test_rtcp_packet_builder.h" | |
| 14 #include "media/cast/test/fake_single_thread_task_runner.h" | |
| 15 #include "media/cast/transport/cast_transport_config.h" | |
| 16 #include "media/cast/transport/cast_transport_sender_impl.h" | |
| 17 #include "media/cast/transport/pacing/paced_sender.h" | |
| 18 #include "testing/gmock/include/gmock/gmock.h" | |
| 19 | |
| 20 namespace media { | |
| 21 namespace cast { | |
| 22 | |
| 23 using testing::_; | |
| 24 | |
| 25 static const uint32 kSenderSsrc = 0x10203; | |
| 26 static const uint32 kReceiverSsrc = 0x40506; | |
| 27 static const std::string kCName("test@10.1.1.1"); | |
| 28 static const uint32 kRtcpIntervalMs = 500; | |
| 29 static const int64 kAddedDelay = 123; | |
| 30 static const int64 kAddedShortDelay = 100; | |
| 31 | |
| 32 class RtcpTestPacketSender : public transport::PacketSender { | |
| 33 public: | |
| 34 explicit RtcpTestPacketSender(base::SimpleTestTickClock* testing_clock) | |
| 35 : drop_packets_(false), | |
| 36 short_delay_(false), | |
| 37 rtcp_receiver_(NULL), | |
| 38 testing_clock_(testing_clock) {} | |
| 39 virtual ~RtcpTestPacketSender() {} | |
| 40 // Packet lists imply a RTP packet. | |
| 41 void set_rtcp_receiver(Rtcp* rtcp) { rtcp_receiver_ = rtcp; } | |
| 42 | |
| 43 void set_short_delay() { short_delay_ = true; } | |
| 44 | |
| 45 void set_drop_packets(bool drop_packets) { drop_packets_ = drop_packets; } | |
| 46 | |
| 47 // A singular packet implies a RTCP packet. | |
| 48 virtual bool SendPacket(transport::PacketRef packet, | |
| 49 const base::Closure& cb) OVERRIDE { | |
| 50 if (short_delay_) { | |
| 51 testing_clock_->Advance( | |
| 52 base::TimeDelta::FromMilliseconds(kAddedShortDelay)); | |
| 53 } else { | |
| 54 testing_clock_->Advance(base::TimeDelta::FromMilliseconds(kAddedDelay)); | |
| 55 } | |
| 56 if (drop_packets_) | |
| 57 return true; | |
| 58 | |
| 59 rtcp_receiver_->IncomingRtcpPacket(&packet->data[0], packet->data.size()); | |
| 60 return true; | |
| 61 } | |
| 62 | |
| 63 private: | |
| 64 bool drop_packets_; | |
| 65 bool short_delay_; | |
| 66 Rtcp* rtcp_receiver_; | |
| 67 base::SimpleTestTickClock* testing_clock_; | |
| 68 | |
| 69 DISALLOW_COPY_AND_ASSIGN(RtcpTestPacketSender); | |
| 70 }; | |
| 71 | |
| 72 class LocalRtcpTransport : public transport::PacedPacketSender { | |
| 73 public: | |
| 74 LocalRtcpTransport(scoped_refptr<CastEnvironment> cast_environment, | |
| 75 base::SimpleTestTickClock* testing_clock) | |
| 76 : drop_packets_(false), | |
| 77 short_delay_(false), | |
| 78 testing_clock_(testing_clock) {} | |
| 79 | |
| 80 void set_rtcp_receiver(Rtcp* rtcp) { rtcp_ = rtcp; } | |
| 81 | |
| 82 void set_short_delay() { short_delay_ = true; } | |
| 83 | |
| 84 void set_drop_packets(bool drop_packets) { drop_packets_ = drop_packets; } | |
| 85 | |
| 86 virtual bool SendRtcpPacket(uint32 ssrc, | |
| 87 transport::PacketRef packet) OVERRIDE { | |
| 88 if (short_delay_) { | |
| 89 testing_clock_->Advance( | |
| 90 base::TimeDelta::FromMilliseconds(kAddedShortDelay)); | |
| 91 } else { | |
| 92 testing_clock_->Advance(base::TimeDelta::FromMilliseconds(kAddedDelay)); | |
| 93 } | |
| 94 if (drop_packets_) | |
| 95 return true; | |
| 96 | |
| 97 rtcp_->IncomingRtcpPacket(&packet->data[0], packet->data.size()); | |
| 98 return true; | |
| 99 } | |
| 100 | |
| 101 virtual bool SendPackets( | |
| 102 const transport::SendPacketVector& packets) OVERRIDE { | |
| 103 return false; | |
| 104 } | |
| 105 | |
| 106 virtual bool ResendPackets( | |
| 107 const transport::SendPacketVector& packets, | |
| 108 base::TimeDelta dedupe_window) OVERRIDE { | |
| 109 return false; | |
| 110 } | |
| 111 | |
| 112 virtual void CancelSendingPacket( | |
| 113 const transport::PacketKey& packet_key) OVERRIDE { | |
| 114 } | |
| 115 | |
| 116 private: | |
| 117 bool drop_packets_; | |
| 118 bool short_delay_; | |
| 119 Rtcp* rtcp_; | |
| 120 base::SimpleTestTickClock* testing_clock_; | |
| 121 scoped_refptr<CastEnvironment> cast_environment_; | |
| 122 | |
| 123 DISALLOW_COPY_AND_ASSIGN(LocalRtcpTransport); | |
| 124 }; | |
| 125 | |
| 126 class RtcpPeer : public Rtcp { | |
| 127 public: | |
| 128 RtcpPeer(scoped_refptr<CastEnvironment> cast_environment, | |
| 129 RtcpSenderFeedback* sender_feedback, | |
| 130 transport::CastTransportSender* const transport_sender, | |
| 131 transport::PacedPacketSender* paced_packet_sender, | |
| 132 RtpReceiverStatistics* rtp_receiver_statistics, | |
| 133 RtcpMode rtcp_mode, | |
| 134 const base::TimeDelta& rtcp_interval, | |
| 135 uint32 local_ssrc, | |
| 136 uint32 remote_ssrc, | |
| 137 const std::string& c_name) | |
| 138 : Rtcp(cast_environment, | |
| 139 sender_feedback, | |
| 140 transport_sender, | |
| 141 paced_packet_sender, | |
| 142 rtp_receiver_statistics, | |
| 143 rtcp_mode, | |
| 144 rtcp_interval, | |
| 145 local_ssrc, | |
| 146 remote_ssrc, | |
| 147 c_name, | |
| 148 AUDIO_EVENT) {} | |
| 149 | |
| 150 using Rtcp::OnReceivedNtp; | |
| 151 using Rtcp::OnReceivedLipSyncInfo; | |
| 152 }; | |
| 153 | |
| 154 class RtcpTest : public ::testing::Test { | |
| 155 protected: | |
| 156 RtcpTest() | |
| 157 : testing_clock_(new base::SimpleTestTickClock()), | |
| 158 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), | |
| 159 cast_environment_(new CastEnvironment( | |
| 160 scoped_ptr<base::TickClock>(testing_clock_).Pass(), | |
| 161 task_runner_, | |
| 162 task_runner_, | |
| 163 task_runner_)), | |
| 164 sender_to_receiver_(testing_clock_), | |
| 165 receiver_to_sender_(cast_environment_, testing_clock_) { | |
| 166 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); | |
| 167 net::IPEndPoint dummy_endpoint; | |
| 168 transport_sender_.reset(new transport::CastTransportSenderImpl( | |
| 169 NULL, | |
| 170 testing_clock_, | |
| 171 dummy_endpoint, | |
| 172 base::Bind(&UpdateCastTransportStatus), | |
| 173 transport::BulkRawEventsCallback(), | |
| 174 base::TimeDelta(), | |
| 175 task_runner_, | |
| 176 &sender_to_receiver_)); | |
| 177 transport::CastTransportRtpConfig config; | |
| 178 config.ssrc = kSenderSsrc; | |
| 179 config.rtp_payload_type = 127; | |
| 180 config.stored_frames = 1; | |
| 181 transport_sender_->InitializeAudio(config); | |
| 182 EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(0); | |
| 183 } | |
| 184 | |
| 185 virtual ~RtcpTest() {} | |
| 186 | |
| 187 static void UpdateCastTransportStatus(transport::CastTransportStatus status) { | |
| 188 bool result = (status == transport::TRANSPORT_AUDIO_INITIALIZED || | |
| 189 status == transport::TRANSPORT_VIDEO_INITIALIZED); | |
| 190 EXPECT_TRUE(result); | |
| 191 } | |
| 192 | |
| 193 void RunTasks(int during_ms) { | |
| 194 for (int i = 0; i < during_ms; ++i) { | |
| 195 // Call process the timers every 1 ms. | |
| 196 testing_clock_->Advance(base::TimeDelta::FromMilliseconds(1)); | |
| 197 task_runner_->RunTasks(); | |
| 198 } | |
| 199 } | |
| 200 | |
| 201 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. | |
| 202 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | |
| 203 scoped_refptr<CastEnvironment> cast_environment_; | |
| 204 RtcpTestPacketSender sender_to_receiver_; | |
| 205 scoped_ptr<transport::CastTransportSenderImpl> transport_sender_; | |
| 206 LocalRtcpTransport receiver_to_sender_; | |
| 207 MockRtcpSenderFeedback mock_sender_feedback_; | |
| 208 | |
| 209 DISALLOW_COPY_AND_ASSIGN(RtcpTest); | |
| 210 }; | |
| 211 | |
| 212 TEST_F(RtcpTest, TimeToSend) { | |
| 213 const base::TimeTicks start_time = testing_clock_->NowTicks(); | |
| 214 Rtcp rtcp(cast_environment_, | |
| 215 &mock_sender_feedback_, | |
| 216 transport_sender_.get(), | |
| 217 &receiver_to_sender_, | |
| 218 NULL, | |
| 219 kRtcpCompound, | |
| 220 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 221 kSenderSsrc, | |
| 222 kReceiverSsrc, | |
| 223 kCName, | |
| 224 AUDIO_EVENT); | |
| 225 receiver_to_sender_.set_rtcp_receiver(&rtcp); | |
| 226 EXPECT_LE(start_time, rtcp.TimeToSendNextRtcpReport()); | |
| 227 EXPECT_GE( | |
| 228 start_time + base::TimeDelta::FromMilliseconds(kRtcpIntervalMs * 3 / 2), | |
| 229 rtcp.TimeToSendNextRtcpReport()); | |
| 230 base::TimeDelta delta = rtcp.TimeToSendNextRtcpReport() - start_time; | |
| 231 testing_clock_->Advance(delta); | |
| 232 EXPECT_EQ(testing_clock_->NowTicks(), rtcp.TimeToSendNextRtcpReport()); | |
| 233 } | |
| 234 | |
| 235 TEST_F(RtcpTest, BasicSenderReport) { | |
| 236 Rtcp rtcp(cast_environment_, | |
| 237 &mock_sender_feedback_, | |
| 238 transport_sender_.get(), | |
| 239 NULL, | |
| 240 NULL, | |
| 241 kRtcpCompound, | |
| 242 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 243 kSenderSsrc, | |
| 244 kReceiverSsrc, | |
| 245 kCName, | |
| 246 AUDIO_EVENT); | |
| 247 sender_to_receiver_.set_rtcp_receiver(&rtcp); | |
| 248 rtcp.SendRtcpFromRtpSender(base::TimeTicks(), 0); | |
| 249 } | |
| 250 | |
| 251 TEST_F(RtcpTest, BasicReceiverReport) { | |
| 252 Rtcp rtcp(cast_environment_, | |
| 253 &mock_sender_feedback_, | |
| 254 NULL, | |
| 255 &receiver_to_sender_, | |
| 256 NULL, | |
| 257 kRtcpCompound, | |
| 258 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 259 kSenderSsrc, | |
| 260 kReceiverSsrc, | |
| 261 kCName, | |
| 262 AUDIO_EVENT); | |
| 263 receiver_to_sender_.set_rtcp_receiver(&rtcp); | |
| 264 rtcp.SendRtcpFromRtpReceiver(NULL, NULL); | |
| 265 } | |
| 266 | |
| 267 TEST_F(RtcpTest, BasicCast) { | |
| 268 EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(1); | |
| 269 | |
| 270 // Media receiver. | |
| 271 Rtcp rtcp(cast_environment_, | |
| 272 &mock_sender_feedback_, | |
| 273 NULL, | |
| 274 &receiver_to_sender_, | |
| 275 NULL, | |
| 276 kRtcpReducedSize, | |
| 277 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 278 kSenderSsrc, | |
| 279 kSenderSsrc, | |
| 280 kCName, | |
| 281 AUDIO_EVENT); | |
| 282 receiver_to_sender_.set_rtcp_receiver(&rtcp); | |
| 283 RtcpCastMessage cast_message(kSenderSsrc); | |
| 284 cast_message.ack_frame_id_ = kAckFrameId; | |
| 285 PacketIdSet missing_packets; | |
| 286 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; | |
| 287 | |
| 288 missing_packets.insert(kLostPacketId1); | |
| 289 missing_packets.insert(kLostPacketId2); | |
| 290 missing_packets.insert(kLostPacketId3); | |
| 291 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = | |
| 292 missing_packets; | |
| 293 rtcp.SendRtcpFromRtpReceiver(&cast_message, NULL); | |
| 294 } | |
| 295 | |
| 296 TEST_F(RtcpTest, RttReducedSizeRtcp) { | |
| 297 // Media receiver. | |
| 298 Rtcp rtcp_receiver(cast_environment_, | |
| 299 &mock_sender_feedback_, | |
| 300 NULL, | |
| 301 &receiver_to_sender_, | |
| 302 NULL, | |
| 303 kRtcpReducedSize, | |
| 304 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 305 kReceiverSsrc, | |
| 306 kSenderSsrc, | |
| 307 kCName, | |
| 308 AUDIO_EVENT); | |
| 309 | |
| 310 // Media sender. | |
| 311 Rtcp rtcp_sender(cast_environment_, | |
| 312 &mock_sender_feedback_, | |
| 313 transport_sender_.get(), | |
| 314 NULL, | |
| 315 NULL, | |
| 316 kRtcpReducedSize, | |
| 317 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 318 kSenderSsrc, | |
| 319 kReceiverSsrc, | |
| 320 kCName, | |
| 321 AUDIO_EVENT); | |
| 322 | |
| 323 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); | |
| 324 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); | |
| 325 | |
| 326 base::TimeDelta rtt; | |
| 327 base::TimeDelta avg_rtt; | |
| 328 base::TimeDelta min_rtt; | |
| 329 base::TimeDelta max_rtt; | |
| 330 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 331 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 332 | |
| 333 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1); | |
| 334 RunTasks(33); | |
| 335 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | |
| 336 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 337 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 338 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); | |
| 339 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); | |
| 340 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); | |
| 341 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | |
| 342 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2); | |
| 343 RunTasks(33); | |
| 344 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 345 | |
| 346 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); | |
| 347 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); | |
| 348 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); | |
| 349 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | |
| 350 } | |
| 351 | |
| 352 TEST_F(RtcpTest, Rtt) { | |
| 353 // Media receiver. | |
| 354 Rtcp rtcp_receiver(cast_environment_, | |
| 355 &mock_sender_feedback_, | |
| 356 NULL, | |
| 357 &receiver_to_sender_, | |
| 358 NULL, | |
| 359 kRtcpCompound, | |
| 360 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 361 kReceiverSsrc, | |
| 362 kSenderSsrc, | |
| 363 kCName, | |
| 364 AUDIO_EVENT); | |
| 365 | |
| 366 // Media sender. | |
| 367 Rtcp rtcp_sender(cast_environment_, | |
| 368 &mock_sender_feedback_, | |
| 369 transport_sender_.get(), | |
| 370 NULL, | |
| 371 NULL, | |
| 372 kRtcpCompound, | |
| 373 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 374 kSenderSsrc, | |
| 375 kReceiverSsrc, | |
| 376 kCName, | |
| 377 AUDIO_EVENT); | |
| 378 | |
| 379 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); | |
| 380 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); | |
| 381 | |
| 382 base::TimeDelta rtt; | |
| 383 base::TimeDelta avg_rtt; | |
| 384 base::TimeDelta min_rtt; | |
| 385 base::TimeDelta max_rtt; | |
| 386 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 387 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 388 | |
| 389 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1); | |
| 390 RunTasks(33); | |
| 391 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | |
| 392 | |
| 393 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 394 RunTasks(33); | |
| 395 | |
| 396 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 397 RunTasks(33); | |
| 398 | |
| 399 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); | |
| 400 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); | |
| 401 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); | |
| 402 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | |
| 403 | |
| 404 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2); | |
| 405 RunTasks(33); | |
| 406 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 407 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); | |
| 408 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); | |
| 409 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); | |
| 410 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | |
| 411 | |
| 412 receiver_to_sender_.set_short_delay(); | |
| 413 sender_to_receiver_.set_short_delay(); | |
| 414 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | |
| 415 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 416 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2); | |
| 417 EXPECT_NEAR( | |
| 418 (kAddedShortDelay + 3 * kAddedDelay) / 2, avg_rtt.InMilliseconds(), 2); | |
| 419 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, min_rtt.InMilliseconds(), 2); | |
| 420 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | |
| 421 | |
| 422 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 3); | |
| 423 RunTasks(33); | |
| 424 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 425 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 1); | |
| 426 EXPECT_NEAR((2 * kAddedShortDelay + 2 * kAddedDelay) / 2, | |
| 427 avg_rtt.InMilliseconds(), | |
| 428 1); | |
| 429 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); | |
| 430 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | |
| 431 | |
| 432 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | |
| 433 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 434 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2); | |
| 435 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); | |
| 436 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | |
| 437 | |
| 438 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | |
| 439 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 440 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2); | |
| 441 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); | |
| 442 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | |
| 443 } | |
| 444 | |
| 445 TEST_F(RtcpTest, RttWithPacketLoss) { | |
| 446 // Media receiver. | |
| 447 Rtcp rtcp_receiver(cast_environment_, | |
| 448 &mock_sender_feedback_, | |
| 449 NULL, | |
| 450 &receiver_to_sender_, | |
| 451 NULL, | |
| 452 kRtcpReducedSize, | |
| 453 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 454 kReceiverSsrc, | |
| 455 kSenderSsrc, | |
| 456 kCName, | |
| 457 AUDIO_EVENT); | |
| 458 | |
| 459 // Media sender. | |
| 460 Rtcp rtcp_sender(cast_environment_, | |
| 461 &mock_sender_feedback_, | |
| 462 transport_sender_.get(), | |
| 463 NULL, | |
| 464 NULL, | |
| 465 kRtcpReducedSize, | |
| 466 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
| 467 kSenderSsrc, | |
| 468 kReceiverSsrc, | |
| 469 kCName, | |
| 470 AUDIO_EVENT); | |
| 471 | |
| 472 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); | |
| 473 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); | |
| 474 | |
| 475 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | |
| 476 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 0); | |
| 477 RunTasks(33); | |
| 478 | |
| 479 base::TimeDelta rtt; | |
| 480 base::TimeDelta avg_rtt; | |
| 481 base::TimeDelta min_rtt; | |
| 482 base::TimeDelta max_rtt; | |
| 483 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 484 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 485 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1); | |
| 486 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1); | |
| 487 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1); | |
| 488 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1); | |
| 489 | |
| 490 receiver_to_sender_.set_short_delay(); | |
| 491 sender_to_receiver_.set_short_delay(); | |
| 492 receiver_to_sender_.set_drop_packets(true); | |
| 493 | |
| 494 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | |
| 495 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1); | |
| 496 RunTasks(33); | |
| 497 | |
| 498 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | |
| 499 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2); | |
| 500 } | |
| 501 | |
| 502 TEST_F(RtcpTest, NtpAndTime) { | |
| 503 const int64 kSecondsbetweenYear1900and2010 = INT64_C(40176 * 24 * 60 * 60); | |
| 504 const int64 kSecondsbetweenYear1900and2030 = INT64_C(47481 * 24 * 60 * 60); | |
| 505 | |
| 506 uint32 ntp_seconds_1 = 0; | |
| 507 uint32 ntp_fraction_1 = 0; | |
| 508 base::TimeTicks input_time = base::TimeTicks::Now(); | |
| 509 ConvertTimeTicksToNtp(input_time, &ntp_seconds_1, &ntp_fraction_1); | |
| 510 | |
| 511 // Verify absolute value. | |
| 512 EXPECT_GT(ntp_seconds_1, kSecondsbetweenYear1900and2010); | |
| 513 EXPECT_LT(ntp_seconds_1, kSecondsbetweenYear1900and2030); | |
| 514 | |
| 515 base::TimeTicks out_1 = ConvertNtpToTimeTicks(ntp_seconds_1, ntp_fraction_1); | |
| 516 EXPECT_EQ(input_time, out_1); // Verify inverse. | |
| 517 | |
| 518 base::TimeDelta time_delta = base::TimeDelta::FromMilliseconds(1000); | |
| 519 input_time += time_delta; | |
| 520 | |
| 521 uint32 ntp_seconds_2 = 0; | |
| 522 uint32 ntp_fraction_2 = 0; | |
| 523 | |
| 524 ConvertTimeTicksToNtp(input_time, &ntp_seconds_2, &ntp_fraction_2); | |
| 525 base::TimeTicks out_2 = ConvertNtpToTimeTicks(ntp_seconds_2, ntp_fraction_2); | |
| 526 EXPECT_EQ(input_time, out_2); // Verify inverse. | |
| 527 | |
| 528 // Verify delta. | |
| 529 EXPECT_EQ((out_2 - out_1), time_delta); | |
| 530 EXPECT_EQ((ntp_seconds_2 - ntp_seconds_1), UINT32_C(1)); | |
| 531 EXPECT_NEAR(ntp_fraction_2, ntp_fraction_1, 1); | |
| 532 | |
| 533 time_delta = base::TimeDelta::FromMilliseconds(500); | |
| 534 input_time += time_delta; | |
| 535 | |
| 536 uint32 ntp_seconds_3 = 0; | |
| 537 uint32 ntp_fraction_3 = 0; | |
| 538 | |
| 539 ConvertTimeTicksToNtp(input_time, &ntp_seconds_3, &ntp_fraction_3); | |
| 540 base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3); | |
| 541 EXPECT_EQ(input_time, out_3); // Verify inverse. | |
| 542 | |
| 543 // Verify delta. | |
| 544 EXPECT_EQ((out_3 - out_2), time_delta); | |
| 545 EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1); | |
| 546 } | |
| 547 | |
| 548 } // namespace cast | |
| 549 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 388663003:
Cast: Reshuffle files under media/cast (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src