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 // This test generate synthetic data. For audio it's a sinusoid waveform with 6 // frequency kSoundFrequency and different amplitudes. For video it's a pattern 7 // that is shifting by one pixel per frame, each pixels neighbors right and down 8 // is this pixels value +1, since the pixel value is 8 bit it will wrap 9 // frequently within the image. Visually this will create diagonally color bands 10 // that moves across the screen 11 12 #include <math.h> 13 #include <stdint.h> 14 15 #include <functional> 16 #include <list> 17 #include <map> 18 19 #include "base/bind.h" 20 #include "base/bind_helpers.h" 21 #include "base/strings/string_number_conversions.h" 22 #include "base/sys_byteorder.h" 23 #include "base/test/simple_test_tick_clock.h" 24 #include "base/time/tick_clock.h" 25 #include "media/base/audio_bus.h" 26 #include "media/base/video_frame.h" 27 #include "media/cast/cast_config.h" 28 #include "media/cast/cast_environment.h" 29 #include "media/cast/cast_receiver.h" 30 #include "media/cast/cast_sender.h" 31 #include "media/cast/logging/simple_event_subscriber.h" 32 #include "media/cast/net/cast_transport_config.h" 33 #include "media/cast/net/cast_transport_defines.h" 34 #include "media/cast/net/cast_transport_sender.h" 35 #include "media/cast/net/cast_transport_sender_impl.h" 36 #include "media/cast/test/fake_single_thread_task_runner.h" 37 #include "media/cast/test/skewed_single_thread_task_runner.h" 38 #include "media/cast/test/skewed_tick_clock.h" 39 #include "media/cast/test/utility/audio_utility.h" 40 #include "media/cast/test/utility/default_config.h" 41 #include "media/cast/test/utility/udp_proxy.h" 42 #include "media/cast/test/utility/video_utility.h" 43 #include "testing/gtest/include/gtest/gtest.h" 44 45 namespace media { 46 namespace cast { 47 48 namespace { 49 50 static const int64 kStartMillisecond = INT64_C(1245); 51 static const int kAudioChannels = 2; 52 static const double kSoundFrequency = 314.15926535897; // Freq of sine wave. 53 static const float kSoundVolume = 0.5f; 54 static const int kVideoHdWidth = 1280; 55 static const int kVideoHdHeight = 720; 56 static const int kVideoQcifWidth = 176; 57 static const int kVideoQcifHeight = 144; 58 59 // Since the video encoded and decoded an error will be introduced; when 60 // comparing individual pixels the error can be quite large; we allow a PSNR of 61 // at least |kVideoAcceptedPSNR|. 62 static const double kVideoAcceptedPSNR = 38.0; 63 64 // The tests are commonly implemented with |kFrameTimerMs| RunTask function; 65 // a normal video is 30 fps hence the 33 ms between frames. 66 // 67 // TODO(miu): The errors in timing will add up significantly. Find an 68 // alternative approach that eliminates use of this constant. 69 static const int kFrameTimerMs = 33; 70 71 // Start the video synthetic start value to medium range value, to avoid edge 72 // effects cause by encoding and quantization. 73 static const int kVideoStart = 100; 74 75 // The size of audio frames. The encoder joins/breaks all inserted audio into 76 // chunks of this size. 77 static const int kAudioFrameDurationMs = 10; 78 79 // The amount of time between frame capture on the sender and playout on the 80 // receiver. 81 static const int kTargetPlayoutDelayMs = 100; 82 83 // The maximum amount of deviation expected in the playout times emitted by the 84 // receiver. 85 static const int kMaxAllowedPlayoutErrorMs = 30; 86 87 std::string ConvertFromBase16String(const std::string base_16) { 88 std::string compressed; 89 DCHECK_EQ(base_16.size() % 2, 0u) << "Must be a multiple of 2"; 90 compressed.reserve(base_16.size() / 2); 91 92 std::vector<uint8> v; 93 if (!base::HexStringToBytes(base_16, &v)) { 94 NOTREACHED(); 95 } 96 compressed.assign(reinterpret_cast<const char*>(&v[0]), v.size()); 97 return compressed; 98 } 99 100 void UpdateCastTransportStatus(CastTransportStatus status) { 101 bool result = (status == TRANSPORT_AUDIO_INITIALIZED || 102 status == TRANSPORT_VIDEO_INITIALIZED); 103 EXPECT_TRUE(result); 104 } 105 106 void AudioInitializationStatus(CastInitializationStatus status) { 107 EXPECT_EQ(STATUS_AUDIO_INITIALIZED, status); 108 } 109 110 void VideoInitializationStatus(CastInitializationStatus status) { 111 EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status); 112 } 113 114 // This is wrapped in a struct because it needs to be put into a std::map. 115 typedef struct { 116 int counter[kNumOfLoggingEvents+1]; 117 } LoggingEventCounts; 118 119 // Constructs a map from each frame (RTP timestamp) to counts of each event 120 // type logged for that frame. 121 std::map<RtpTimestamp, LoggingEventCounts> GetEventCountForFrameEvents( 122 const std::vector<FrameEvent>& frame_events) { 123 std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame; 124 for (std::vector<FrameEvent>::const_iterator it = frame_events.begin(); 125 it != frame_events.end(); 126 ++it) { 127 std::map<RtpTimestamp, LoggingEventCounts>::iterator map_it = 128 event_counter_for_frame.find(it->rtp_timestamp); 129 if (map_it == event_counter_for_frame.end()) { 130 LoggingEventCounts new_counter; 131 memset(&new_counter, 0, sizeof(new_counter)); 132 ++(new_counter.counter[it->type]); 133 event_counter_for_frame.insert( 134 std::make_pair(it->rtp_timestamp, new_counter)); 135 } else { 136 ++(map_it->second.counter[it->type]); 137 } 138 } 139 return event_counter_for_frame; 140 } 141 142 // Constructs a map from each packet (Packet ID) to counts of each event 143 // type logged for that packet. 144 std::map<uint16, LoggingEventCounts> GetEventCountForPacketEvents( 145 const std::vector<PacketEvent>& packet_events) { 146 std::map<uint16, LoggingEventCounts> event_counter_for_packet; 147 for (std::vector<PacketEvent>::const_iterator it = packet_events.begin(); 148 it != packet_events.end(); 149 ++it) { 150 std::map<uint16, LoggingEventCounts>::iterator map_it = 151 event_counter_for_packet.find(it->packet_id); 152 if (map_it == event_counter_for_packet.end()) { 153 LoggingEventCounts new_counter; 154 memset(&new_counter, 0, sizeof(new_counter)); 155 ++(new_counter.counter[it->type]); 156 event_counter_for_packet.insert( 157 std::make_pair(it->packet_id, new_counter)); 158 } else { 159 ++(map_it->second.counter[it->type]); 160 } 161 } 162 return event_counter_for_packet; 163 } 164 165 } // namespace 166 167 // Shim that turns forwards packets from a test::PacketPipe to a 168 // PacketReceiverCallback. 169 class LoopBackPacketPipe : public test::PacketPipe { 170 public: 171 LoopBackPacketPipe(const PacketReceiverCallback& packet_receiver) 172 : packet_receiver_(packet_receiver) {} 173 174 virtual ~LoopBackPacketPipe() {} 175 176 // PacketPipe implementations. 177 virtual void Send(scoped_ptr<Packet> packet) OVERRIDE { 178 packet_receiver_.Run(packet.Pass()); 179 } 180 181 private: 182 PacketReceiverCallback packet_receiver_; 183 }; 184 185 // Class that sends the packet direct from sender into the receiver with the 186 // ability to drop packets between the two. 187 class LoopBackTransport : public PacketSender { 188 public: 189 explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment) 190 : send_packets_(true), 191 drop_packets_belonging_to_odd_frames_(false), 192 cast_environment_(cast_environment), 193 bytes_sent_(0) {} 194 195 void SetPacketReceiver( 196 const PacketReceiverCallback& packet_receiver, 197 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner, 198 base::TickClock* clock) { 199 scoped_ptr<test::PacketPipe> loopback_pipe( 200 new LoopBackPacketPipe(packet_receiver)); 201 if (packet_pipe_) { 202 packet_pipe_->AppendToPipe(loopback_pipe.Pass()); 203 } else { 204 packet_pipe_ = loopback_pipe.Pass(); 205 } 206 packet_pipe_->InitOnIOThread(task_runner, clock); 207 } 208 209 virtual bool SendPacket(PacketRef packet, 210 const base::Closure& cb) OVERRIDE { 211 DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN)); 212 if (!send_packets_) 213 return true; 214 215 bytes_sent_ += packet->data.size(); 216 if (drop_packets_belonging_to_odd_frames_) { 217 uint32 frame_id = packet->data[13]; 218 if (frame_id % 2 == 1) 219 return true; 220 } 221 222 scoped_ptr<Packet> packet_copy(new Packet(packet->data)); 223 packet_pipe_->Send(packet_copy.Pass()); 224 return true; 225 } 226 227 virtual int64 GetBytesSent() OVERRIDE { 228 return bytes_sent_; 229 } 230 231 void SetSendPackets(bool send_packets) { send_packets_ = send_packets; } 232 233 void DropAllPacketsBelongingToOddFrames() { 234 drop_packets_belonging_to_odd_frames_ = true; 235 } 236 237 void SetPacketPipe(scoped_ptr<test::PacketPipe> pipe) { 238 // Append the loopback pipe to the end. 239 pipe->AppendToPipe(packet_pipe_.Pass()); 240 packet_pipe_ = pipe.Pass(); 241 } 242 243 private: 244 bool send_packets_; 245 bool drop_packets_belonging_to_odd_frames_; 246 scoped_refptr<CastEnvironment> cast_environment_; 247 scoped_ptr<test::PacketPipe> packet_pipe_; 248 int64 bytes_sent_; 249 }; 250 251 // Class that verifies the audio frames coming out of the receiver. 252 class TestReceiverAudioCallback 253 : public base::RefCountedThreadSafe<TestReceiverAudioCallback> { 254 public: 255 struct ExpectedAudioFrame { 256 scoped_ptr<AudioBus> audio_bus; 257 base::TimeTicks playout_time; 258 }; 259 260 TestReceiverAudioCallback() : num_called_(0) {} 261 262 void SetExpectedSamplingFrequency(int expected_sampling_frequency) { 263 expected_sampling_frequency_ = expected_sampling_frequency; 264 } 265 266 void AddExpectedResult(const AudioBus& audio_bus, 267 const base::TimeTicks& playout_time) { 268 scoped_ptr<ExpectedAudioFrame> expected_audio_frame( 269 new ExpectedAudioFrame()); 270 expected_audio_frame->audio_bus = 271 AudioBus::Create(audio_bus.channels(), audio_bus.frames()).Pass(); 272 audio_bus.CopyTo(expected_audio_frame->audio_bus.get()); 273 expected_audio_frame->playout_time = playout_time; 274 expected_frames_.push_back(expected_audio_frame.release()); 275 } 276 277 void IgnoreAudioFrame(scoped_ptr<AudioBus> audio_bus, 278 const base::TimeTicks& playout_time, 279 bool is_continuous) { 280 ++num_called_; 281 } 282 283 void CheckAudioFrame(scoped_ptr<AudioBus> audio_bus, 284 const base::TimeTicks& playout_time, 285 bool is_continuous) { 286 ++num_called_; 287 288 ASSERT_TRUE(!!audio_bus); 289 ASSERT_FALSE(expected_frames_.empty()); 290 const scoped_ptr<ExpectedAudioFrame> expected_audio_frame( 291 expected_frames_.front()); 292 expected_frames_.pop_front(); 293 294 EXPECT_EQ(audio_bus->channels(), kAudioChannels); 295 EXPECT_EQ(audio_bus->frames(), expected_audio_frame->audio_bus->frames()); 296 for (int ch = 0; ch < audio_bus->channels(); ++ch) { 297 EXPECT_NEAR(CountZeroCrossings( 298 expected_audio_frame->audio_bus->channel(ch), 299 expected_audio_frame->audio_bus->frames()), 300 CountZeroCrossings(audio_bus->channel(ch), 301 audio_bus->frames()), 302 1); 303 } 304 305 EXPECT_NEAR( 306 (playout_time - expected_audio_frame->playout_time).InMillisecondsF(), 307 0.0, 308 kMaxAllowedPlayoutErrorMs); 309 VLOG_IF(1, !last_playout_time_.is_null()) 310 << "Audio frame playout time delta (compared to last frame) is " 311 << (playout_time - last_playout_time_).InMicroseconds() << " usec."; 312 last_playout_time_ = playout_time; 313 314 EXPECT_TRUE(is_continuous); 315 } 316 317 void CheckCodedAudioFrame(scoped_ptr<EncodedFrame> audio_frame) { 318 ASSERT_TRUE(!!audio_frame); 319 ASSERT_FALSE(expected_frames_.empty()); 320 const ExpectedAudioFrame& expected_audio_frame = 321 *(expected_frames_.front()); 322 // Note: Just peeking here. Will delegate to CheckAudioFrame() to pop. 323 324 // We need to "decode" the encoded audio frame. The codec is simply to 325 // swizzle the bytes of each int16 from host-->network-->host order to get 326 // interleaved int16 PCM. Then, make an AudioBus out of that. 327 const int num_elements = audio_frame->data.size() / sizeof(int16); 328 ASSERT_EQ(expected_audio_frame.audio_bus->channels() * 329 expected_audio_frame.audio_bus->frames(), 330 num_elements); 331 int16* const pcm_data = 332 reinterpret_cast<int16*>(audio_frame->mutable_bytes()); 333 for (int i = 0; i < num_elements; ++i) 334 pcm_data[i] = static_cast<int16>(base::NetToHost16(pcm_data[i])); 335 scoped_ptr<AudioBus> audio_bus( 336 AudioBus::Create(expected_audio_frame.audio_bus->channels(), 337 expected_audio_frame.audio_bus->frames())); 338 audio_bus->FromInterleaved(pcm_data, audio_bus->frames(), sizeof(int16)); 339 340 // Delegate the checking from here... 341 CheckAudioFrame(audio_bus.Pass(), audio_frame->reference_time, true); 342 } 343 344 int number_times_called() const { return num_called_; } 345 346 protected: 347 virtual ~TestReceiverAudioCallback() { 348 STLDeleteElements(&expected_frames_); 349 } 350 351 private: 352 friend class base::RefCountedThreadSafe<TestReceiverAudioCallback>; 353 354 int num_called_; 355 int expected_sampling_frequency_; 356 std::list<ExpectedAudioFrame*> expected_frames_; 357 base::TimeTicks last_playout_time_; 358 }; 359 360 // Class that verifies the video frames coming out of the receiver. 361 class TestReceiverVideoCallback 362 : public base::RefCountedThreadSafe<TestReceiverVideoCallback> { 363 public: 364 struct ExpectedVideoFrame { 365 int start_value; 366 int width; 367 int height; 368 base::TimeTicks playout_time; 369 bool should_be_continuous; 370 }; 371 372 TestReceiverVideoCallback() : num_called_(0) {} 373 374 void AddExpectedResult(int start_value, 375 int width, 376 int height, 377 const base::TimeTicks& playout_time, 378 bool should_be_continuous) { 379 ExpectedVideoFrame expected_video_frame; 380 expected_video_frame.start_value = start_value; 381 expected_video_frame.width = width; 382 expected_video_frame.height = height; 383 expected_video_frame.playout_time = playout_time; 384 expected_video_frame.should_be_continuous = should_be_continuous; 385 expected_frame_.push_back(expected_video_frame); 386 } 387 388 void CheckVideoFrame(const scoped_refptr<media::VideoFrame>& video_frame, 389 const base::TimeTicks& playout_time, 390 bool is_continuous) { 391 ++num_called_; 392 393 ASSERT_TRUE(!!video_frame.get()); 394 ASSERT_FALSE(expected_frame_.empty()); 395 ExpectedVideoFrame expected_video_frame = expected_frame_.front(); 396 expected_frame_.pop_front(); 397 398 EXPECT_EQ(expected_video_frame.width, video_frame->visible_rect().width()); 399 EXPECT_EQ(expected_video_frame.height, 400 video_frame->visible_rect().height()); 401 402 gfx::Size size(expected_video_frame.width, expected_video_frame.height); 403 scoped_refptr<media::VideoFrame> expected_I420_frame = 404 media::VideoFrame::CreateFrame( 405 VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta()); 406 PopulateVideoFrame(expected_I420_frame.get(), 407 expected_video_frame.start_value); 408 409 if (expected_video_frame.should_be_continuous) { 410 EXPECT_GE(I420PSNR(expected_I420_frame, video_frame), kVideoAcceptedPSNR); 411 } 412 413 EXPECT_NEAR( 414 (playout_time - expected_video_frame.playout_time).InMillisecondsF(), 415 0.0, 416 kMaxAllowedPlayoutErrorMs); 417 VLOG_IF(1, !last_playout_time_.is_null()) 418 << "Video frame playout time delta (compared to last frame) is " 419 << (playout_time - last_playout_time_).InMicroseconds() << " usec."; 420 last_playout_time_ = playout_time; 421 422 EXPECT_EQ(expected_video_frame.should_be_continuous, is_continuous); 423 } 424 425 int number_times_called() const { return num_called_; } 426 427 protected: 428 virtual ~TestReceiverVideoCallback() {} 429 430 private: 431 friend class base::RefCountedThreadSafe<TestReceiverVideoCallback>; 432 433 int num_called_; 434 std::list<ExpectedVideoFrame> expected_frame_; 435 base::TimeTicks last_playout_time_; 436 }; 437 438 // The actual test class, generate synthetic data for both audio and video and 439 // send those through the sender and receiver and analyzes the result. 440 class End2EndTest : public ::testing::Test { 441 protected: 442 End2EndTest() 443 : start_time_(), 444 task_runner_(new test::FakeSingleThreadTaskRunner(&testing_clock_)), 445 testing_clock_sender_(new test::SkewedTickClock(&testing_clock_)), 446 task_runner_sender_( 447 new test::SkewedSingleThreadTaskRunner(task_runner_)), 448 testing_clock_receiver_(new test::SkewedTickClock(&testing_clock_)), 449 task_runner_receiver_( 450 new test::SkewedSingleThreadTaskRunner(task_runner_)), 451 cast_environment_sender_(new CastEnvironment( 452 scoped_ptr<base::TickClock>(testing_clock_sender_).Pass(), 453 task_runner_sender_, 454 task_runner_sender_, 455 task_runner_sender_)), 456 cast_environment_receiver_(new CastEnvironment( 457 scoped_ptr<base::TickClock>(testing_clock_receiver_).Pass(), 458 task_runner_receiver_, 459 task_runner_receiver_, 460 task_runner_receiver_)), 461 receiver_to_sender_(cast_environment_receiver_), 462 sender_to_receiver_(cast_environment_sender_), 463 test_receiver_audio_callback_(new TestReceiverAudioCallback()), 464 test_receiver_video_callback_(new TestReceiverVideoCallback()) { 465 testing_clock_.Advance( 466 base::TimeDelta::FromMilliseconds(kStartMillisecond)); 467 cast_environment_sender_->Logging()->AddRawEventSubscriber( 468 &event_subscriber_sender_); 469 } 470 471 void Configure(Codec video_codec, 472 Codec audio_codec, 473 int audio_sampling_frequency, 474 int max_number_of_video_buffers_used) { 475 audio_sender_config_.ssrc = 1; 476 audio_sender_config_.incoming_feedback_ssrc = 2; 477 audio_sender_config_.max_playout_delay = 478 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs); 479 audio_sender_config_.rtp_payload_type = 96; 480 audio_sender_config_.use_external_encoder = false; 481 audio_sender_config_.frequency = audio_sampling_frequency; 482 audio_sender_config_.channels = kAudioChannels; 483 audio_sender_config_.bitrate = kDefaultAudioEncoderBitrate; 484 audio_sender_config_.codec = audio_codec; 485 486 audio_receiver_config_.feedback_ssrc = 487 audio_sender_config_.incoming_feedback_ssrc; 488 audio_receiver_config_.incoming_ssrc = audio_sender_config_.ssrc; 489 audio_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs; 490 audio_receiver_config_.rtp_payload_type = 491 audio_sender_config_.rtp_payload_type; 492 audio_receiver_config_.frequency = audio_sender_config_.frequency; 493 audio_receiver_config_.channels = kAudioChannels; 494 audio_receiver_config_.max_frame_rate = 100; 495 audio_receiver_config_.codec = audio_sender_config_.codec; 496 497 test_receiver_audio_callback_->SetExpectedSamplingFrequency( 498 audio_receiver_config_.frequency); 499 500 video_sender_config_.ssrc = 3; 501 video_sender_config_.incoming_feedback_ssrc = 4; 502 video_sender_config_.max_playout_delay = 503 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs); 504 video_sender_config_.rtp_payload_type = 97; 505 video_sender_config_.use_external_encoder = false; 506 video_sender_config_.width = kVideoHdWidth; 507 video_sender_config_.height = kVideoHdHeight; 508 video_sender_config_.max_bitrate = 50000; 509 video_sender_config_.min_bitrate = 10000; 510 video_sender_config_.start_bitrate = 10000; 511 video_sender_config_.max_qp = 30; 512 video_sender_config_.min_qp = 4; 513 video_sender_config_.max_frame_rate = 30; 514 video_sender_config_.max_number_of_video_buffers_used = 515 max_number_of_video_buffers_used; 516 video_sender_config_.codec = video_codec; 517 518 video_receiver_config_.feedback_ssrc = 519 video_sender_config_.incoming_feedback_ssrc; 520 video_receiver_config_.incoming_ssrc = video_sender_config_.ssrc; 521 video_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs; 522 video_receiver_config_.rtp_payload_type = 523 video_sender_config_.rtp_payload_type; 524 video_receiver_config_.frequency = kVideoFrequency; 525 video_receiver_config_.channels = 1; 526 video_receiver_config_.max_frame_rate = video_sender_config_.max_frame_rate; 527 video_receiver_config_.codec = video_sender_config_.codec; 528 } 529 530 void SetReceiverSkew(double skew, base::TimeDelta offset) { 531 testing_clock_receiver_->SetSkew(skew, offset); 532 task_runner_receiver_->SetSkew(1.0 / skew); 533 } 534 535 // Specify the minimum/maximum difference in playout times between two 536 // consecutive frames. Also, specify the maximum absolute rate of change over 537 // each three consecutive frames. 538 void SetExpectedVideoPlayoutSmoothness(base::TimeDelta min_delta, 539 base::TimeDelta max_delta, 540 base::TimeDelta max_curvature) { 541 min_video_playout_delta_ = min_delta; 542 max_video_playout_delta_ = max_delta; 543 max_video_playout_curvature_ = max_curvature; 544 } 545 546 void FeedAudioFrames(int count, bool will_be_checked) { 547 for (int i = 0; i < count; ++i) { 548 scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus( 549 base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs))); 550 const base::TimeTicks capture_time = 551 testing_clock_sender_->NowTicks() + 552 i * base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs); 553 if (will_be_checked) { 554 test_receiver_audio_callback_->AddExpectedResult( 555 *audio_bus, 556 capture_time + 557 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs)); 558 } 559 audio_frame_input_->InsertAudio(audio_bus.Pass(), capture_time); 560 } 561 } 562 563 void FeedAudioFramesWithExpectedDelay(int count, 564 const base::TimeDelta& delay) { 565 for (int i = 0; i < count; ++i) { 566 scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus( 567 base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs))); 568 const base::TimeTicks capture_time = 569 testing_clock_sender_->NowTicks() + 570 i * base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs); 571 test_receiver_audio_callback_->AddExpectedResult( 572 *audio_bus, 573 capture_time + delay + 574 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs)); 575 audio_frame_input_->InsertAudio(audio_bus.Pass(), capture_time); 576 } 577 } 578 579 void RequestAudioFrames(int count, bool with_check) { 580 for (int i = 0; i < count; ++i) { 581 cast_receiver_->RequestDecodedAudioFrame( 582 base::Bind(with_check ? &TestReceiverAudioCallback::CheckAudioFrame : 583 &TestReceiverAudioCallback::IgnoreAudioFrame, 584 test_receiver_audio_callback_)); 585 } 586 } 587 588 void Create() { 589 cast_receiver_ = CastReceiver::Create(cast_environment_receiver_, 590 audio_receiver_config_, 591 video_receiver_config_, 592 &receiver_to_sender_); 593 594 net::IPEndPoint dummy_endpoint; 595 transport_sender_.reset(new CastTransportSenderImpl( 596 NULL, 597 testing_clock_sender_, 598 dummy_endpoint, 599 make_scoped_ptr(new base::DictionaryValue), 600 base::Bind(&UpdateCastTransportStatus), 601 base::Bind(&End2EndTest::LogRawEvents, base::Unretained(this)), 602 base::TimeDelta::FromMilliseconds(1), 603 task_runner_sender_, 604 &sender_to_receiver_)); 605 606 cast_sender_ = 607 CastSender::Create(cast_environment_sender_, transport_sender_.get()); 608 609 // Initializing audio and video senders. 610 cast_sender_->InitializeAudio(audio_sender_config_, 611 base::Bind(&AudioInitializationStatus)); 612 cast_sender_->InitializeVideo(video_sender_config_, 613 base::Bind(&VideoInitializationStatus), 614 CreateDefaultVideoEncodeAcceleratorCallback(), 615 CreateDefaultVideoEncodeMemoryCallback()); 616 task_runner_->RunTasks(); 617 618 receiver_to_sender_.SetPacketReceiver( 619 transport_sender_->PacketReceiverForTesting(), 620 task_runner_, 621 &testing_clock_); 622 sender_to_receiver_.SetPacketReceiver(cast_receiver_->packet_receiver(), 623 task_runner_, 624 &testing_clock_); 625 626 audio_frame_input_ = cast_sender_->audio_frame_input(); 627 video_frame_input_ = cast_sender_->video_frame_input(); 628 629 audio_bus_factory_.reset( 630 new TestAudioBusFactory(audio_sender_config_.channels, 631 audio_sender_config_.frequency, 632 kSoundFrequency, 633 kSoundVolume)); 634 } 635 636 virtual ~End2EndTest() { 637 cast_environment_sender_->Logging()->RemoveRawEventSubscriber( 638 &event_subscriber_sender_); 639 } 640 641 virtual void TearDown() OVERRIDE { 642 cast_sender_.reset(); 643 cast_receiver_.reset(); 644 task_runner_->RunTasks(); 645 } 646 647 void SendVideoFrame(int start_value, const base::TimeTicks& capture_time) { 648 if (start_time_.is_null()) 649 start_time_ = capture_time; 650 base::TimeDelta time_diff = capture_time - start_time_; 651 gfx::Size size(video_sender_config_.width, video_sender_config_.height); 652 EXPECT_TRUE(VideoFrame::IsValidConfig( 653 VideoFrame::I420, size, gfx::Rect(size), size)); 654 scoped_refptr<media::VideoFrame> video_frame = 655 media::VideoFrame::CreateFrame( 656 VideoFrame::I420, size, gfx::Rect(size), size, time_diff); 657 PopulateVideoFrame(video_frame.get(), start_value); 658 video_frame_input_->InsertRawVideoFrame(video_frame, capture_time); 659 } 660 661 void SendFakeVideoFrame(const base::TimeTicks& capture_time) { 662 video_frame_input_->InsertRawVideoFrame( 663 media::VideoFrame::CreateBlackFrame(gfx::Size(2, 2)), capture_time); 664 } 665 666 void RunTasks(int ms) { 667 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(ms)); 668 } 669 670 void BasicPlayerGotVideoFrame( 671 const scoped_refptr<media::VideoFrame>& video_frame, 672 const base::TimeTicks& playout_time, bool continuous) { 673 // The following tests that the sender and receiver clocks can be 674 // out-of-sync, drift, and jitter with respect to one another; and depsite 675 // this, the receiver will produce smoothly-progressing playout times. 676 // Both first-order and second-order effects are tested. 677 if (!last_video_playout_time_.is_null() && 678 min_video_playout_delta_ > base::TimeDelta()) { 679 const base::TimeDelta delta = playout_time - last_video_playout_time_; 680 VLOG(1) << "Video frame playout time delta (compared to last frame) is " 681 << delta.InMicroseconds() << " usec."; 682 EXPECT_LE(min_video_playout_delta_.InMicroseconds(), 683 delta.InMicroseconds()); 684 EXPECT_GE(max_video_playout_delta_.InMicroseconds(), 685 delta.InMicroseconds()); 686 if (last_video_playout_delta_ > base::TimeDelta()) { 687 base::TimeDelta abs_curvature = delta - last_video_playout_delta_; 688 if (abs_curvature < base::TimeDelta()) 689 abs_curvature = -abs_curvature; 690 EXPECT_GE(max_video_playout_curvature_.InMicroseconds(), 691 abs_curvature.InMicroseconds()); 692 } 693 last_video_playout_delta_ = delta; 694 } 695 last_video_playout_time_ = playout_time; 696 697 video_ticks_.push_back(std::make_pair( 698 testing_clock_receiver_->NowTicks(), 699 playout_time)); 700 cast_receiver_->RequestDecodedVideoFrame( 701 base::Bind(&End2EndTest::BasicPlayerGotVideoFrame, 702 base::Unretained(this))); 703 } 704 705 void BasicPlayerGotAudioFrame(scoped_ptr<AudioBus> audio_bus, 706 const base::TimeTicks& playout_time, 707 bool is_continuous) { 708 VLOG_IF(1, !last_audio_playout_time_.is_null()) 709 << "Audio frame playout time delta (compared to last frame) is " 710 << (playout_time - last_audio_playout_time_).InMicroseconds() 711 << " usec."; 712 last_audio_playout_time_ = playout_time; 713 714 audio_ticks_.push_back(std::make_pair( 715 testing_clock_receiver_->NowTicks(), 716 playout_time)); 717 cast_receiver_->RequestDecodedAudioFrame( 718 base::Bind(&End2EndTest::BasicPlayerGotAudioFrame, 719 base::Unretained(this))); 720 } 721 722 void StartBasicPlayer() { 723 cast_receiver_->RequestDecodedVideoFrame( 724 base::Bind(&End2EndTest::BasicPlayerGotVideoFrame, 725 base::Unretained(this))); 726 cast_receiver_->RequestDecodedAudioFrame( 727 base::Bind(&End2EndTest::BasicPlayerGotAudioFrame, 728 base::Unretained(this))); 729 } 730 731 void LogRawEvents(const std::vector<PacketEvent>& packet_events, 732 const std::vector<FrameEvent>& frame_events) { 733 for (std::vector<media::cast::PacketEvent>::const_iterator it = 734 packet_events.begin(); 735 it != packet_events.end(); 736 ++it) { 737 cast_environment_sender_->Logging()->InsertPacketEvent(it->timestamp, 738 it->type, 739 it->media_type, 740 it->rtp_timestamp, 741 it->frame_id, 742 it->packet_id, 743 it->max_packet_id, 744 it->size); 745 } 746 for (std::vector<media::cast::FrameEvent>::const_iterator it = 747 frame_events.begin(); 748 it != frame_events.end(); 749 ++it) { 750 cast_environment_sender_->Logging()->InsertFrameEvent(it->timestamp, 751 it->type, 752 it->media_type, 753 it->rtp_timestamp, 754 it->frame_id); 755 } 756 } 757 758 FrameReceiverConfig audio_receiver_config_; 759 FrameReceiverConfig video_receiver_config_; 760 AudioSenderConfig audio_sender_config_; 761 VideoSenderConfig video_sender_config_; 762 763 base::TimeTicks start_time_; 764 765 // These run in "test time" 766 base::SimpleTestTickClock testing_clock_; 767 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; 768 769 // These run on the sender timeline. 770 test::SkewedTickClock* testing_clock_sender_; 771 scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_sender_; 772 773 // These run on the receiver timeline. 774 test::SkewedTickClock* testing_clock_receiver_; 775 scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_receiver_; 776 base::TimeDelta min_video_playout_delta_; 777 base::TimeDelta max_video_playout_delta_; 778 base::TimeDelta max_video_playout_curvature_; 779 base::TimeTicks last_video_playout_time_; 780 base::TimeDelta last_video_playout_delta_; 781 base::TimeTicks last_audio_playout_time_; 782 783 scoped_refptr<CastEnvironment> cast_environment_sender_; 784 scoped_refptr<CastEnvironment> cast_environment_receiver_; 785 786 LoopBackTransport receiver_to_sender_; 787 LoopBackTransport sender_to_receiver_; 788 scoped_ptr<CastTransportSenderImpl> transport_sender_; 789 790 scoped_ptr<CastReceiver> cast_receiver_; 791 scoped_ptr<CastSender> cast_sender_; 792 scoped_refptr<AudioFrameInput> audio_frame_input_; 793 scoped_refptr<VideoFrameInput> video_frame_input_; 794 795 scoped_refptr<TestReceiverAudioCallback> test_receiver_audio_callback_; 796 scoped_refptr<TestReceiverVideoCallback> test_receiver_video_callback_; 797 798 scoped_ptr<TestAudioBusFactory> audio_bus_factory_; 799 800 SimpleEventSubscriber event_subscriber_sender_; 801 std::vector<FrameEvent> frame_events_; 802 std::vector<PacketEvent> packet_events_; 803 std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_; 804 std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_; 805 // |transport_sender_| has a RepeatingTimer which needs a MessageLoop. 806 base::MessageLoop message_loop_; 807 }; 808 809 TEST_F(End2EndTest, LoopNoLossPcm16) { 810 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1); 811 // Reduce video resolution to allow processing multiple frames within a 812 // reasonable time frame. 813 video_sender_config_.width = kVideoQcifWidth; 814 video_sender_config_.height = kVideoQcifHeight; 815 Create(); 816 817 const int kNumIterations = 50; 818 int video_start = kVideoStart; 819 int audio_diff = kFrameTimerMs; 820 int num_audio_frames_requested = 0; 821 for (int i = 0; i < kNumIterations; ++i) { 822 const int num_audio_frames = audio_diff / kAudioFrameDurationMs; 823 audio_diff -= num_audio_frames * kAudioFrameDurationMs; 824 825 if (num_audio_frames > 0) 826 FeedAudioFrames(1, true); 827 828 test_receiver_video_callback_->AddExpectedResult( 829 video_start, 830 video_sender_config_.width, 831 video_sender_config_.height, 832 testing_clock_sender_->NowTicks() + 833 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs), 834 true); 835 SendVideoFrame(video_start, testing_clock_sender_->NowTicks()); 836 837 if (num_audio_frames > 0) 838 RunTasks(kAudioFrameDurationMs); // Advance clock forward. 839 if (num_audio_frames > 1) 840 FeedAudioFrames(num_audio_frames - 1, true); 841 842 RequestAudioFrames(num_audio_frames, true); 843 num_audio_frames_requested += num_audio_frames; 844 845 cast_receiver_->RequestDecodedVideoFrame( 846 base::Bind(&TestReceiverVideoCallback::CheckVideoFrame, 847 test_receiver_video_callback_)); 848 849 RunTasks(kFrameTimerMs - kAudioFrameDurationMs); 850 audio_diff += kFrameTimerMs; 851 video_start++; 852 } 853 854 RunTasks(2 * kFrameTimerMs + 1); // Empty the receiver pipeline. 855 EXPECT_EQ(num_audio_frames_requested, 856 test_receiver_audio_callback_->number_times_called()); 857 EXPECT_EQ(kNumIterations, 858 test_receiver_video_callback_->number_times_called()); 859 } 860 861 // This tests our external decoder interface for Audio. 862 // Audio test without packet loss using raw PCM 16 audio "codec"; 863 TEST_F(End2EndTest, LoopNoLossPcm16ExternalDecoder) { 864 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1); 865 Create(); 866 867 const int kNumIterations = 10; 868 for (int i = 0; i < kNumIterations; ++i) { 869 FeedAudioFrames(1, true); 870 RunTasks(kAudioFrameDurationMs); 871 cast_receiver_->RequestEncodedAudioFrame( 872 base::Bind(&TestReceiverAudioCallback::CheckCodedAudioFrame, 873 test_receiver_audio_callback_)); 874 } 875 RunTasks(2 * kFrameTimerMs + 1); // Empty the receiver pipeline. 876 EXPECT_EQ(kNumIterations, 877 test_receiver_audio_callback_->number_times_called()); 878 } 879 880 // This tests our Opus audio codec without video. 881 TEST_F(End2EndTest, LoopNoLossOpus) { 882 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS, 883 kDefaultAudioSamplingRate, 1); 884 Create(); 885 886 const int kNumIterations = 300; 887 for (int i = 0; i < kNumIterations; ++i) { 888 // Opus introduces a tiny delay before the sinewave starts; so don't examine 889 // the first frame. 890 const bool examine_audio_data = i > 0; 891 FeedAudioFrames(1, examine_audio_data); 892 RunTasks(kAudioFrameDurationMs); 893 RequestAudioFrames(1, examine_audio_data); 894 } 895 RunTasks(2 * kFrameTimerMs + 1); // Empty the receiver pipeline. 896 EXPECT_EQ(kNumIterations, 897 test_receiver_audio_callback_->number_times_called()); 898 } 899 900 // This tests start sending audio and video at start-up time before the receiver 901 // is ready; it sends 2 frames before the receiver comes online. 902 // 903 // Test disabled due to flakiness: It appears that the RTCP synchronization 904 // sometimes kicks in, and sometimes doesn't. When it does, there's a sharp 905 // discontinuity in the timeline, throwing off the test expectations. See TODOs 906 // in audio_receiver.cc for likely cause(s) of this bug. 907 // http://crbug.com/356942 908 TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) { 909 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 910 kDefaultAudioSamplingRate, 1); 911 Create(); 912 913 int video_start = kVideoStart; 914 int audio_diff = kFrameTimerMs; 915 916 sender_to_receiver_.SetSendPackets(false); 917 918 const int test_delay_ms = 100; 919 920 const int kNumVideoFramesBeforeReceiverStarted = 2; 921 const base::TimeTicks initial_send_time = testing_clock_sender_->NowTicks(); 922 const base::TimeDelta expected_delay = 923 base::TimeDelta::FromMilliseconds(test_delay_ms + kFrameTimerMs); 924 for (int i = 0; i < kNumVideoFramesBeforeReceiverStarted; ++i) { 925 const int num_audio_frames = audio_diff / kAudioFrameDurationMs; 926 audio_diff -= num_audio_frames * kAudioFrameDurationMs; 927 928 if (num_audio_frames > 0) 929 FeedAudioFramesWithExpectedDelay(1, expected_delay); 930 931 // Frame will be rendered with 100mS delay, as the transmission is delayed. 932 // The receiver at this point cannot be synced to the sender's clock, as no 933 // packets, and specifically no RTCP packets were sent. 934 test_receiver_video_callback_->AddExpectedResult( 935 video_start, 936 video_sender_config_.width, 937 video_sender_config_.height, 938 initial_send_time + expected_delay + 939 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs), 940 true); 941 SendVideoFrame(video_start, testing_clock_sender_->NowTicks()); 942 943 if (num_audio_frames > 0) 944 RunTasks(kAudioFrameDurationMs); // Advance clock forward. 945 if (num_audio_frames > 1) 946 FeedAudioFramesWithExpectedDelay(num_audio_frames - 1, expected_delay); 947 948 RunTasks(kFrameTimerMs - kAudioFrameDurationMs); 949 audio_diff += kFrameTimerMs; 950 video_start++; 951 } 952 953 RunTasks(test_delay_ms); 954 sender_to_receiver_.SetSendPackets(true); 955 956 int num_audio_frames_requested = 0; 957 for (int j = 0; j < 10; ++j) { 958 const int num_audio_frames = audio_diff / kAudioFrameDurationMs; 959 audio_diff -= num_audio_frames * kAudioFrameDurationMs; 960 961 if (num_audio_frames > 0) 962 FeedAudioFrames(1, true); 963 964 test_receiver_video_callback_->AddExpectedResult( 965 video_start, 966 video_sender_config_.width, 967 video_sender_config_.height, 968 testing_clock_sender_->NowTicks() + 969 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs), 970 true); 971 SendVideoFrame(video_start, testing_clock_sender_->NowTicks()); 972 973 if (num_audio_frames > 0) 974 RunTasks(kAudioFrameDurationMs); // Advance clock forward. 975 if (num_audio_frames > 1) 976 FeedAudioFrames(num_audio_frames - 1, true); 977 978 RequestAudioFrames(num_audio_frames, true); 979 num_audio_frames_requested += num_audio_frames; 980 981 cast_receiver_->RequestDecodedVideoFrame( 982 base::Bind(&TestReceiverVideoCallback::CheckVideoFrame, 983 test_receiver_video_callback_)); 984 985 RunTasks(kFrameTimerMs - kAudioFrameDurationMs); 986 audio_diff += kFrameTimerMs; 987 video_start++; 988 } 989 RunTasks(2 * kFrameTimerMs + 1); // Empty the receiver pipeline. 990 EXPECT_EQ(num_audio_frames_requested, 991 test_receiver_audio_callback_->number_times_called()); 992 EXPECT_EQ(10, test_receiver_video_callback_->number_times_called()); 993 } 994 995 TEST_F(End2EndTest, DropEveryOtherFrame3Buffers) { 996 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS, kDefaultAudioSamplingRate, 3); 997 int target_delay = 300; 998 video_sender_config_.max_playout_delay = 999 base::TimeDelta::FromMilliseconds(target_delay); 1000 audio_sender_config_.max_playout_delay = 1001 base::TimeDelta::FromMilliseconds(target_delay); 1002 video_receiver_config_.rtp_max_delay_ms = target_delay; 1003 Create(); 1004 sender_to_receiver_.DropAllPacketsBelongingToOddFrames(); 1005 1006 int video_start = kVideoStart; 1007 base::TimeTicks capture_time; 1008 1009 int i = 0; 1010 for (; i < 20; ++i) { 1011 capture_time = testing_clock_sender_->NowTicks(); 1012 SendVideoFrame(video_start, capture_time); 1013 1014 if (i % 2 == 0) { 1015 test_receiver_video_callback_->AddExpectedResult( 1016 video_start, 1017 video_sender_config_.width, 1018 video_sender_config_.height, 1019 capture_time + 1020 base::TimeDelta::FromMilliseconds(target_delay), 1021 i == 0); 1022 1023 // GetRawVideoFrame will not return the frame until we are close in 1024 // time before we should render the frame. 1025 cast_receiver_->RequestDecodedVideoFrame( 1026 base::Bind(&TestReceiverVideoCallback::CheckVideoFrame, 1027 test_receiver_video_callback_)); 1028 } 1029 RunTasks(kFrameTimerMs); 1030 video_start++; 1031 } 1032 1033 RunTasks(2 * kFrameTimerMs + target_delay); // Empty the pipeline. 1034 EXPECT_EQ(i / 2, test_receiver_video_callback_->number_times_called()); 1035 } 1036 1037 TEST_F(End2EndTest, CryptoVideo) { 1038 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1); 1039 1040 video_sender_config_.aes_iv_mask = 1041 ConvertFromBase16String("1234567890abcdeffedcba0987654321"); 1042 video_sender_config_.aes_key = 1043 ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef"); 1044 1045 video_receiver_config_.aes_iv_mask = 1046 video_sender_config_.aes_iv_mask; 1047 video_receiver_config_.aes_key = 1048 video_sender_config_.aes_key; 1049 1050 Create(); 1051 1052 int frames_counter = 0; 1053 for (; frames_counter < 3; ++frames_counter) { 1054 const base::TimeTicks capture_time = testing_clock_sender_->NowTicks(); 1055 SendVideoFrame(frames_counter, capture_time); 1056 1057 test_receiver_video_callback_->AddExpectedResult( 1058 frames_counter, 1059 video_sender_config_.width, 1060 video_sender_config_.height, 1061 capture_time + base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs), 1062 true); 1063 1064 RunTasks(kFrameTimerMs); 1065 1066 cast_receiver_->RequestDecodedVideoFrame( 1067 base::Bind(&TestReceiverVideoCallback::CheckVideoFrame, 1068 test_receiver_video_callback_)); 1069 } 1070 RunTasks(2 * kFrameTimerMs + 1); // Empty the pipeline. 1071 EXPECT_EQ(frames_counter, 1072 test_receiver_video_callback_->number_times_called()); 1073 } 1074 1075 TEST_F(End2EndTest, CryptoAudio) { 1076 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1); 1077 1078 audio_sender_config_.aes_iv_mask = 1079 ConvertFromBase16String("abcdeffedcba12345678900987654321"); 1080 audio_sender_config_.aes_key = 1081 ConvertFromBase16String("deadbeefcafecafedeadbeefb0b0b0b0"); 1082 1083 audio_receiver_config_.aes_iv_mask = 1084 audio_sender_config_.aes_iv_mask; 1085 audio_receiver_config_.aes_key = 1086 audio_sender_config_.aes_key; 1087 1088 Create(); 1089 1090 const int kNumIterations = 3; 1091 const int kNumAudioFramesPerIteration = 2; 1092 for (int i = 0; i < kNumIterations; ++i) { 1093 FeedAudioFrames(kNumAudioFramesPerIteration, true); 1094 RunTasks(kNumAudioFramesPerIteration * kAudioFrameDurationMs); 1095 RequestAudioFrames(kNumAudioFramesPerIteration, true); 1096 } 1097 RunTasks(2 * kFrameTimerMs + 1); // Empty the pipeline. 1098 EXPECT_EQ(kNumIterations * kNumAudioFramesPerIteration, 1099 test_receiver_audio_callback_->number_times_called()); 1100 } 1101 1102 // Video test without packet loss - tests the logging aspects of the end2end, 1103 // but is basically equivalent to LoopNoLossPcm16. 1104 TEST_F(End2EndTest, VideoLogging) { 1105 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1); 1106 Create(); 1107 1108 int video_start = kVideoStart; 1109 const int num_frames = 5; 1110 for (int i = 0; i < num_frames; ++i) { 1111 base::TimeTicks capture_time = testing_clock_sender_->NowTicks(); 1112 test_receiver_video_callback_->AddExpectedResult( 1113 video_start, 1114 video_sender_config_.width, 1115 video_sender_config_.height, 1116 capture_time + base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs), 1117 true); 1118 1119 SendVideoFrame(video_start, capture_time); 1120 RunTasks(kFrameTimerMs); 1121 1122 cast_receiver_->RequestDecodedVideoFrame( 1123 base::Bind(&TestReceiverVideoCallback::CheckVideoFrame, 1124 test_receiver_video_callback_)); 1125 1126 video_start++; 1127 } 1128 1129 // Basic tests. 1130 RunTasks(2 * kFrameTimerMs + 1); // Empty the receiver pipeline. 1131 int num_callbacks_called = 1132 test_receiver_video_callback_->number_times_called(); 1133 EXPECT_EQ(num_frames, num_callbacks_called); 1134 1135 RunTasks(750); // Make sure that we send a RTCP message with the log. 1136 1137 // Logging tests. 1138 // Frame logging. 1139 // Verify that all frames and all required events were logged. 1140 event_subscriber_sender_.GetFrameEventsAndReset(&frame_events_); 1141 1142 // For each frame, count the number of events that occurred for each event 1143 // for that frame. 1144 std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame = 1145 GetEventCountForFrameEvents(frame_events_); 1146 1147 // Verify that there are logs for expected number of frames. 1148 EXPECT_EQ(num_frames, static_cast<int>(event_counter_for_frame.size())); 1149 1150 // Verify that each frame have the expected types of events logged. 1151 for (std::map<RtpTimestamp, LoggingEventCounts>::iterator map_it = 1152 event_counter_for_frame.begin(); 1153 map_it != event_counter_for_frame.end(); 1154 ++map_it) { 1155 int total_event_count_for_frame = 0; 1156 for (int i = 0; i <= kNumOfLoggingEvents; ++i) { 1157 total_event_count_for_frame += map_it->second.counter[i]; 1158 } 1159 1160 int expected_event_count_for_frame = 0; 1161 1162 EXPECT_EQ(1, map_it->second.counter[FRAME_CAPTURE_BEGIN]); 1163 expected_event_count_for_frame += 1164 map_it->second.counter[FRAME_CAPTURE_BEGIN]; 1165 1166 EXPECT_EQ(1, map_it->second.counter[FRAME_CAPTURE_END]); 1167 expected_event_count_for_frame += 1168 map_it->second.counter[FRAME_CAPTURE_END]; 1169 1170 EXPECT_EQ(1, map_it->second.counter[FRAME_ENCODED]); 1171 expected_event_count_for_frame += 1172 map_it->second.counter[FRAME_ENCODED]; 1173 1174 EXPECT_EQ(1, map_it->second.counter[FRAME_DECODED]); 1175 expected_event_count_for_frame += 1176 map_it->second.counter[FRAME_DECODED]; 1177 1178 EXPECT_EQ(1, map_it->second.counter[FRAME_PLAYOUT]); 1179 expected_event_count_for_frame += map_it->second.counter[FRAME_PLAYOUT]; 1180 1181 1182 // There is no guarantee that FRAME_ACK_SENT is loggeed exactly once per 1183 // frame. 1184 EXPECT_GT(map_it->second.counter[FRAME_ACK_SENT], 0); 1185 expected_event_count_for_frame += map_it->second.counter[FRAME_ACK_SENT]; 1186 1187 // There is no guarantee that FRAME_ACK_RECEIVED is loggeed exactly once per 1188 // frame. 1189 EXPECT_GT(map_it->second.counter[FRAME_ACK_RECEIVED], 0); 1190 expected_event_count_for_frame += 1191 map_it->second.counter[FRAME_ACK_RECEIVED]; 1192 1193 // Verify that there were no other events logged with respect to this 1194 // frame. 1195 // (i.e. Total event count = expected event count) 1196 EXPECT_EQ(total_event_count_for_frame, expected_event_count_for_frame); 1197 } 1198 1199 // Packet logging. 1200 // Verify that all packet related events were logged. 1201 event_subscriber_sender_.GetPacketEventsAndReset(&packet_events_); 1202 std::map<uint16, LoggingEventCounts> event_count_for_packet = 1203 GetEventCountForPacketEvents(packet_events_); 1204 1205 // Verify that each packet have the expected types of events logged. 1206 for (std::map<uint16, LoggingEventCounts>::iterator map_it = 1207 event_count_for_packet.begin(); 1208 map_it != event_count_for_packet.end(); 1209 ++map_it) { 1210 int total_event_count_for_packet = 0; 1211 for (int i = 0; i <= kNumOfLoggingEvents; ++i) { 1212 total_event_count_for_packet += map_it->second.counter[i]; 1213 } 1214 1215 EXPECT_GT(map_it->second.counter[PACKET_RECEIVED], 0); 1216 int packets_received = map_it->second.counter[PACKET_RECEIVED]; 1217 int packets_sent = map_it->second.counter[PACKET_SENT_TO_NETWORK]; 1218 EXPECT_EQ(packets_sent, packets_received); 1219 1220 // Verify that there were no other events logged with respect to this 1221 // packet. (i.e. Total event count = packets sent + packets received) 1222 EXPECT_EQ(packets_received + packets_sent, total_event_count_for_packet); 1223 } 1224 } 1225 1226 // Audio test without packet loss - tests the logging aspects of the end2end, 1227 // but is basically equivalent to LoopNoLossPcm16. 1228 TEST_F(End2EndTest, AudioLogging) { 1229 Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1); 1230 Create(); 1231 1232 int audio_diff = kFrameTimerMs; 1233 const int kNumVideoFrames = 10; 1234 int num_audio_frames_requested = 0; 1235 for (int i = 0; i < kNumVideoFrames; ++i) { 1236 const int num_audio_frames = audio_diff / kAudioFrameDurationMs; 1237 audio_diff -= num_audio_frames * kAudioFrameDurationMs; 1238 1239 FeedAudioFrames(num_audio_frames, true); 1240 1241 RunTasks(kFrameTimerMs); 1242 audio_diff += kFrameTimerMs; 1243 1244 RequestAudioFrames(num_audio_frames, true); 1245 num_audio_frames_requested += num_audio_frames; 1246 } 1247 1248 // Basic tests. 1249 RunTasks(2 * kFrameTimerMs + 1); // Empty the receiver pipeline. 1250 1251 EXPECT_EQ(num_audio_frames_requested, 1252 test_receiver_audio_callback_->number_times_called()); 1253 1254 // Logging tests. 1255 // Verify that all frames and all required events were logged. 1256 event_subscriber_sender_.GetFrameEventsAndReset(&frame_events_); 1257 1258 // Construct a map from each frame (RTP timestamp) to a count of each event 1259 // type logged for that frame. 1260 std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame = 1261 GetEventCountForFrameEvents(frame_events_); 1262 1263 int encoded_count = 0; 1264 1265 // Verify the right number of events were logged for each event type. 1266 for (std::map<RtpTimestamp, LoggingEventCounts>::iterator it = 1267 event_counter_for_frame.begin(); 1268 it != event_counter_for_frame.end(); 1269 ++it) { 1270 encoded_count += it->second.counter[FRAME_ENCODED]; 1271 } 1272 1273 EXPECT_EQ(num_audio_frames_requested, encoded_count); 1274 1275 // Verify that each frame have the expected types of events logged. 1276 for (std::map<RtpTimestamp, LoggingEventCounts>::const_iterator map_it = 1277 event_counter_for_frame.begin(); 1278 map_it != event_counter_for_frame.end(); ++map_it) { 1279 int total_event_count_for_frame = 0; 1280 for (int j = 0; j <= kNumOfLoggingEvents; ++j) 1281 total_event_count_for_frame += map_it->second.counter[j]; 1282 1283 int expected_event_count_for_frame = 0; 1284 1285 EXPECT_EQ(1, map_it->second.counter[FRAME_ENCODED]); 1286 expected_event_count_for_frame += 1287 map_it->second.counter[FRAME_ENCODED]; 1288 1289 EXPECT_EQ(1, map_it->second.counter[FRAME_PLAYOUT]); 1290 expected_event_count_for_frame += 1291 map_it->second.counter[FRAME_PLAYOUT]; 1292 1293 EXPECT_EQ(1, map_it->second.counter[FRAME_DECODED]); 1294 expected_event_count_for_frame += 1295 map_it->second.counter[FRAME_DECODED]; 1296 1297 EXPECT_GT(map_it->second.counter[FRAME_ACK_SENT], 0); 1298 EXPECT_GT(map_it->second.counter[FRAME_ACK_RECEIVED], 0); 1299 expected_event_count_for_frame += map_it->second.counter[FRAME_ACK_SENT]; 1300 expected_event_count_for_frame += 1301 map_it->second.counter[FRAME_ACK_RECEIVED]; 1302 1303 // Verify that there were no other events logged with respect to this frame. 1304 // (i.e. Total event count = expected event count) 1305 EXPECT_EQ(total_event_count_for_frame, expected_event_count_for_frame); 1306 } 1307 } 1308 1309 TEST_F(End2EndTest, BasicFakeSoftwareVideo) { 1310 Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1311 1); 1312 Create(); 1313 StartBasicPlayer(); 1314 SetReceiverSkew(1.0, base::TimeDelta::FromMilliseconds(1)); 1315 1316 // Expect very smooth playout when there is no clock skew. 1317 SetExpectedVideoPlayoutSmoothness( 1318 base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 99 / 100, 1319 base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 101 / 100, 1320 base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 100); 1321 1322 int frames_counter = 0; 1323 for (; frames_counter < 1000; ++frames_counter) { 1324 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1325 RunTasks(kFrameTimerMs); 1326 } 1327 RunTasks(2 * kFrameTimerMs + 1); // Empty the pipeline. 1328 EXPECT_EQ(1000ul, video_ticks_.size()); 1329 } 1330 1331 TEST_F(End2EndTest, ReceiverClockFast) { 1332 Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1333 1); 1334 Create(); 1335 StartBasicPlayer(); 1336 SetReceiverSkew(2.0, base::TimeDelta::FromMicroseconds(1234567)); 1337 1338 int frames_counter = 0; 1339 for (; frames_counter < 10000; ++frames_counter) { 1340 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1341 RunTasks(kFrameTimerMs); 1342 } 1343 RunTasks(2 * kFrameTimerMs + 1); // Empty the pipeline. 1344 EXPECT_EQ(10000ul, video_ticks_.size()); 1345 } 1346 1347 TEST_F(End2EndTest, ReceiverClockSlow) { 1348 Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1349 1); 1350 Create(); 1351 StartBasicPlayer(); 1352 SetReceiverSkew(0.5, base::TimeDelta::FromMicroseconds(-765432)); 1353 1354 int frames_counter = 0; 1355 for (; frames_counter < 10000; ++frames_counter) { 1356 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1357 RunTasks(kFrameTimerMs); 1358 } 1359 RunTasks(2 * kFrameTimerMs + 1); // Empty the pipeline. 1360 EXPECT_EQ(10000ul, video_ticks_.size()); 1361 } 1362 1363 TEST_F(End2EndTest, SmoothPlayoutWithFivePercentClockRateSkew) { 1364 Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1365 1); 1366 Create(); 1367 StartBasicPlayer(); 1368 SetReceiverSkew(1.05, base::TimeDelta::FromMilliseconds(-42)); 1369 1370 // Expect smooth playout when there is 5% skew. 1371 SetExpectedVideoPlayoutSmoothness( 1372 base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 90 / 100, 1373 base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 110 / 100, 1374 base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 10); 1375 1376 int frames_counter = 0; 1377 for (; frames_counter < 10000; ++frames_counter) { 1378 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1379 RunTasks(kFrameTimerMs); 1380 } 1381 RunTasks(2 * kFrameTimerMs + 1); // Empty the pipeline. 1382 EXPECT_EQ(10000ul, video_ticks_.size()); 1383 } 1384 1385 TEST_F(End2EndTest, EvilNetwork) { 1386 Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1387 1); 1388 receiver_to_sender_.SetPacketPipe(test::EvilNetwork().Pass()); 1389 sender_to_receiver_.SetPacketPipe(test::EvilNetwork().Pass()); 1390 Create(); 1391 StartBasicPlayer(); 1392 1393 int frames_counter = 0; 1394 for (; frames_counter < 10000; ++frames_counter) { 1395 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1396 RunTasks(kFrameTimerMs); 1397 } 1398 base::TimeTicks test_end = testing_clock_receiver_->NowTicks(); 1399 RunTasks(100 * kFrameTimerMs + 1); // Empty the pipeline. 1400 EXPECT_GT(video_ticks_.size(), 100ul); 1401 VLOG(1) << "Fully transmitted " << video_ticks_.size() 1402 << " out of 10000 frames."; 1403 EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000); 1404 } 1405 1406 // Tests that a system configured for 30 FPS drops frames when input is provided 1407 // at a much higher frame rate. 1408 TEST_F(End2EndTest, ShoveHighFrameRateDownYerThroat) { 1409 Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1410 1); 1411 receiver_to_sender_.SetPacketPipe(test::EvilNetwork().Pass()); 1412 sender_to_receiver_.SetPacketPipe(test::EvilNetwork().Pass()); 1413 Create(); 1414 StartBasicPlayer(); 1415 1416 int frames_counter = 0; 1417 for (; frames_counter < 10000; ++frames_counter) { 1418 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1419 RunTasks(10 /* 10 ms, but 33.3 expected by system */); 1420 } 1421 base::TimeTicks test_end = testing_clock_receiver_->NowTicks(); 1422 RunTasks(100 * kFrameTimerMs + 1); // Empty the pipeline. 1423 EXPECT_LT(100ul, video_ticks_.size()); 1424 EXPECT_GE(3334ul, video_ticks_.size()); 1425 VLOG(1) << "Fully transmitted " << video_ticks_.size() 1426 << " out of 10000 frames."; 1427 EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000); 1428 } 1429 1430 TEST_F(End2EndTest, OldPacketNetwork) { 1431 Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1); 1432 sender_to_receiver_.SetPacketPipe(test::NewRandomDrop(0.01)); 1433 scoped_ptr<test::PacketPipe> echo_chamber( 1434 test::NewDuplicateAndDelay(1, 10 * kFrameTimerMs)); 1435 echo_chamber->AppendToPipe( 1436 test::NewDuplicateAndDelay(1, 20 * kFrameTimerMs)); 1437 echo_chamber->AppendToPipe( 1438 test::NewDuplicateAndDelay(1, 40 * kFrameTimerMs)); 1439 echo_chamber->AppendToPipe( 1440 test::NewDuplicateAndDelay(1, 80 * kFrameTimerMs)); 1441 echo_chamber->AppendToPipe( 1442 test::NewDuplicateAndDelay(1, 160 * kFrameTimerMs)); 1443 1444 receiver_to_sender_.SetPacketPipe(echo_chamber.Pass()); 1445 Create(); 1446 StartBasicPlayer(); 1447 1448 SetExpectedVideoPlayoutSmoothness( 1449 base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 90 / 100, 1450 base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 110 / 100, 1451 base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 10); 1452 1453 int frames_counter = 0; 1454 for (; frames_counter < 10000; ++frames_counter) { 1455 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1456 RunTasks(kFrameTimerMs); 1457 } 1458 RunTasks(100 * kFrameTimerMs + 1); // Empty the pipeline. 1459 1460 EXPECT_EQ(10000ul, video_ticks_.size()); 1461 } 1462 1463 TEST_F(End2EndTest, TestSetPlayoutDelay) { 1464 Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1); 1465 video_sender_config_.min_playout_delay = 1466 video_sender_config_.max_playout_delay; 1467 audio_sender_config_.min_playout_delay = 1468 audio_sender_config_.max_playout_delay; 1469 video_sender_config_.max_playout_delay = base::TimeDelta::FromSeconds(1); 1470 audio_sender_config_.max_playout_delay = base::TimeDelta::FromSeconds(1); 1471 Create(); 1472 StartBasicPlayer(); 1473 const int kNewDelay = 600; 1474 1475 int frames_counter = 0; 1476 for (; frames_counter < 200; ++frames_counter) { 1477 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1478 RunTasks(kFrameTimerMs); 1479 } 1480 cast_sender_->SetTargetPlayoutDelay( 1481 base::TimeDelta::FromMilliseconds(kNewDelay)); 1482 for (; frames_counter < 400; ++frames_counter) { 1483 SendFakeVideoFrame(testing_clock_sender_->NowTicks()); 1484 RunTasks(kFrameTimerMs); 1485 } 1486 RunTasks(100 * kFrameTimerMs + 1); // Empty the pipeline. 1487 size_t jump = 0; 1488 for (size_t i = 1; i < video_ticks_.size(); i++) { 1489 int64 delta = (video_ticks_[i].second - 1490 video_ticks_[i-1].second).InMilliseconds(); 1491 if (delta > 100) { 1492 EXPECT_EQ(delta, kNewDelay - kTargetPlayoutDelayMs + kFrameTimerMs); 1493 EXPECT_EQ(0u, jump); 1494 jump = i; 1495 } 1496 } 1497 EXPECT_GT(jump, 199u); 1498 EXPECT_LT(jump, 220u); 1499 } 1500 1501 // TODO(pwestin): Add repeatable packet loss test. 1502 // TODO(pwestin): Add test for misaligned send get calls. 1503 // TODO(pwestin): Add more tests that does not resample. 1504 // TODO(pwestin): Add test when we have starvation for our RunTask. 1505 1506 } // namespace cast 1507 } // namespace media 1508
