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 3 // found in the LICENSE file. 4 5 #include <deque> 6 #include <utility> 7 8 #include "base/bind.h" 9 #include "base/memory/ref_counted.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/test/simple_test_tick_clock.h" 12 #include "media/cast/cast_defines.h" 13 #include "media/cast/cast_environment.h" 14 #include "media/cast/logging/simple_event_subscriber.h" 15 #include "media/cast/net/pacing/mock_paced_packet_sender.h" 16 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h" 17 #include "media/cast/receiver/frame_receiver.h" 18 #include "media/cast/test/fake_single_thread_task_runner.h" 19 #include "media/cast/test/utility/default_config.h" 20 #include "testing/gmock/include/gmock/gmock.h" 21 22 using ::testing::_; 23 24 namespace media { 25 namespace cast { 26 27 namespace { 28 29 const int kPacketSize = 1500; 30 const uint32 kFirstFrameId = 1234; 31 const int kPlayoutDelayMillis = 100; 32 33 class FakeFrameClient { 34 public: 35 FakeFrameClient() : num_called_(0) {} 36 virtual ~FakeFrameClient() {} 37 38 void AddExpectedResult(uint32 expected_frame_id, 39 const base::TimeTicks& expected_playout_time) { 40 expected_results_.push_back( 41 std::make_pair(expected_frame_id, expected_playout_time)); 42 } 43 44 void DeliverEncodedFrame(scoped_ptr<EncodedFrame> frame) { 45 SCOPED_TRACE(::testing::Message() << "num_called_ is " << num_called_); 46 ASSERT_FALSE(!frame) 47 << "If at shutdown: There were unsatisfied requests enqueued."; 48 ASSERT_FALSE(expected_results_.empty()); 49 EXPECT_EQ(expected_results_.front().first, frame->frame_id); 50 EXPECT_EQ(expected_results_.front().second, frame->reference_time); 51 expected_results_.pop_front(); 52 ++num_called_; 53 } 54 55 int number_times_called() const { return num_called_; } 56 57 private: 58 std::deque<std::pair<uint32, base::TimeTicks> > expected_results_; 59 int num_called_; 60 61 DISALLOW_COPY_AND_ASSIGN(FakeFrameClient); 62 }; 63 } // namespace 64 65 class FrameReceiverTest : public ::testing::Test { 66 protected: 67 FrameReceiverTest() { 68 testing_clock_ = new base::SimpleTestTickClock(); 69 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); 70 start_time_ = testing_clock_->NowTicks(); 71 task_runner_ = new test::FakeSingleThreadTaskRunner(testing_clock_); 72 73 cast_environment_ = 74 new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_).Pass(), 75 task_runner_, 76 task_runner_, 77 task_runner_); 78 } 79 80 virtual ~FrameReceiverTest() {} 81 82 virtual void SetUp() { 83 payload_.assign(kPacketSize, 0); 84 85 // Always start with a key frame. 86 rtp_header_.is_key_frame = true; 87 rtp_header_.frame_id = kFirstFrameId; 88 rtp_header_.packet_id = 0; 89 rtp_header_.max_packet_id = 0; 90 rtp_header_.reference_frame_id = rtp_header_.frame_id; 91 rtp_header_.rtp_timestamp = 0; 92 } 93 94 void CreateFrameReceiverOfAudio() { 95 config_ = GetDefaultAudioReceiverConfig(); 96 config_.rtp_max_delay_ms = kPlayoutDelayMillis; 97 98 receiver_.reset(new FrameReceiver( 99 cast_environment_, config_, AUDIO_EVENT, &mock_transport_)); 100 } 101 102 void CreateFrameReceiverOfVideo() { 103 config_ = GetDefaultVideoReceiverConfig(); 104 config_.rtp_max_delay_ms = kPlayoutDelayMillis; 105 // Note: Frame rate must divide 1000 without remainder so the test code 106 // doesn't have to account for rounding errors. 107 config_.max_frame_rate = 25; 108 109 receiver_.reset(new FrameReceiver( 110 cast_environment_, config_, VIDEO_EVENT, &mock_transport_)); 111 } 112 113 void FeedOneFrameIntoReceiver() { 114 // Note: For testing purposes, a frame consists of only a single packet. 115 receiver_->ProcessParsedPacket( 116 rtp_header_, &payload_[0], payload_.size()); 117 } 118 119 void FeedLipSyncInfoIntoReceiver() { 120 const base::TimeTicks now = testing_clock_->NowTicks(); 121 const int64 rtp_timestamp = (now - start_time_) * 122 config_.frequency / base::TimeDelta::FromSeconds(1); 123 CHECK_LE(0, rtp_timestamp); 124 uint32 ntp_seconds; 125 uint32 ntp_fraction; 126 ConvertTimeTicksToNtp(now, &ntp_seconds, &ntp_fraction); 127 TestRtcpPacketBuilder rtcp_packet; 128 rtcp_packet.AddSrWithNtp(config_.incoming_ssrc, 129 ntp_seconds, ntp_fraction, 130 static_cast<uint32>(rtp_timestamp)); 131 ASSERT_TRUE(receiver_->ProcessPacket(rtcp_packet.GetPacket().Pass())); 132 } 133 134 FrameReceiverConfig config_; 135 std::vector<uint8> payload_; 136 RtpCastHeader rtp_header_; 137 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. 138 base::TimeTicks start_time_; 139 MockPacedPacketSender mock_transport_; 140 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; 141 scoped_refptr<CastEnvironment> cast_environment_; 142 FakeFrameClient frame_client_; 143 144 // Important for the FrameReceiver to be declared last, since its dependencies 145 // must remain alive until after its destruction. 146 scoped_ptr<FrameReceiver> receiver_; 147 148 DISALLOW_COPY_AND_ASSIGN(FrameReceiverTest); 149 }; 150 151 TEST_F(FrameReceiverTest, RejectsUnparsablePackets) { 152 CreateFrameReceiverOfVideo(); 153 154 SimpleEventSubscriber event_subscriber; 155 cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber); 156 157 const bool success = receiver_->ProcessPacket( 158 scoped_ptr<Packet>(new Packet(kPacketSize, 0xff)).Pass()); 159 EXPECT_FALSE(success); 160 161 // Confirm no log events. 162 std::vector<FrameEvent> frame_events; 163 event_subscriber.GetFrameEventsAndReset(&frame_events); 164 EXPECT_TRUE(frame_events.empty()); 165 cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber); 166 } 167 168 TEST_F(FrameReceiverTest, ReceivesOneFrame) { 169 CreateFrameReceiverOfAudio(); 170 171 SimpleEventSubscriber event_subscriber; 172 cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber); 173 174 EXPECT_CALL(mock_transport_, SendRtcpPacket(_, _)) 175 .WillRepeatedly(testing::Return(true)); 176 177 FeedLipSyncInfoIntoReceiver(); 178 task_runner_->RunTasks(); 179 180 // Enqueue a request for a frame. 181 receiver_->RequestEncodedFrame( 182 base::Bind(&FakeFrameClient::DeliverEncodedFrame, 183 base::Unretained(&frame_client_))); 184 185 // The request should not be satisfied since no packets have been received. 186 task_runner_->RunTasks(); 187 EXPECT_EQ(0, frame_client_.number_times_called()); 188 189 // Deliver one frame to the receiver and expect to get one frame back. 190 const base::TimeDelta target_playout_delay = 191 base::TimeDelta::FromMilliseconds(kPlayoutDelayMillis); 192 frame_client_.AddExpectedResult( 193 kFirstFrameId, testing_clock_->NowTicks() + target_playout_delay); 194 FeedOneFrameIntoReceiver(); 195 task_runner_->RunTasks(); 196 EXPECT_EQ(1, frame_client_.number_times_called()); 197 198 // Was the frame logged? 199 std::vector<FrameEvent> frame_events; 200 event_subscriber.GetFrameEventsAndReset(&frame_events); 201 ASSERT_TRUE(!frame_events.empty()); 202 EXPECT_EQ(FRAME_ACK_SENT, frame_events.begin()->type); 203 EXPECT_EQ(AUDIO_EVENT, frame_events.begin()->media_type); 204 EXPECT_EQ(rtp_header_.frame_id, frame_events.begin()->frame_id); 205 EXPECT_EQ(rtp_header_.rtp_timestamp, frame_events.begin()->rtp_timestamp); 206 cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber); 207 } 208 209 TEST_F(FrameReceiverTest, ReceivesFramesSkippingWhenAppropriate) { 210 CreateFrameReceiverOfAudio(); 211 212 SimpleEventSubscriber event_subscriber; 213 cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber); 214 215 EXPECT_CALL(mock_transport_, SendRtcpPacket(_, _)) 216 .WillRepeatedly(testing::Return(true)); 217 218 const uint32 rtp_advance_per_frame = 219 config_.frequency / config_.max_frame_rate; 220 const base::TimeDelta time_advance_per_frame = 221 base::TimeDelta::FromSeconds(1) / config_.max_frame_rate; 222 223 // Feed and process lip sync in receiver. 224 FeedLipSyncInfoIntoReceiver(); 225 task_runner_->RunTasks(); 226 const base::TimeTicks first_frame_capture_time = testing_clock_->NowTicks(); 227 228 // Enqueue a request for a frame. 229 const ReceiveEncodedFrameCallback frame_encoded_callback = 230 base::Bind(&FakeFrameClient::DeliverEncodedFrame, 231 base::Unretained(&frame_client_)); 232 receiver_->RequestEncodedFrame(frame_encoded_callback); 233 task_runner_->RunTasks(); 234 EXPECT_EQ(0, frame_client_.number_times_called()); 235 236 // Receive one frame and expect to see the first request satisfied. 237 const base::TimeDelta target_playout_delay = 238 base::TimeDelta::FromMilliseconds(kPlayoutDelayMillis); 239 frame_client_.AddExpectedResult( 240 kFirstFrameId, first_frame_capture_time + target_playout_delay); 241 rtp_header_.rtp_timestamp = 0; 242 FeedOneFrameIntoReceiver(); // Frame 1 243 task_runner_->RunTasks(); 244 EXPECT_EQ(1, frame_client_.number_times_called()); 245 246 // Enqueue a second request for a frame, but it should not be fulfilled yet. 247 receiver_->RequestEncodedFrame(frame_encoded_callback); 248 task_runner_->RunTasks(); 249 EXPECT_EQ(1, frame_client_.number_times_called()); 250 251 // Receive one frame out-of-order: Make sure that we are not continuous and 252 // that the RTP timestamp represents a time in the future. 253 rtp_header_.frame_id = kFirstFrameId + 2; // "Frame 3" 254 rtp_header_.reference_frame_id = rtp_header_.frame_id; 255 rtp_header_.rtp_timestamp += 2 * rtp_advance_per_frame; 256 frame_client_.AddExpectedResult( 257 kFirstFrameId + 2, 258 first_frame_capture_time + 2 * time_advance_per_frame + 259 target_playout_delay); 260 FeedOneFrameIntoReceiver(); // Frame 3 261 262 // Frame 2 should not come out at this point in time. 263 task_runner_->RunTasks(); 264 EXPECT_EQ(1, frame_client_.number_times_called()); 265 266 // Enqueue a third request for a frame. 267 receiver_->RequestEncodedFrame(frame_encoded_callback); 268 task_runner_->RunTasks(); 269 EXPECT_EQ(1, frame_client_.number_times_called()); 270 271 // Now, advance time forward such that the receiver is convinced it should 272 // skip Frame 2. Frame 3 is emitted (to satisfy the second request) because a 273 // decision was made to skip over the no-show Frame 2. 274 testing_clock_->Advance(2 * time_advance_per_frame + target_playout_delay); 275 task_runner_->RunTasks(); 276 EXPECT_EQ(2, frame_client_.number_times_called()); 277 278 // Receive Frame 4 and expect it to fulfill the third request immediately. 279 rtp_header_.frame_id = kFirstFrameId + 3; // "Frame 4" 280 rtp_header_.reference_frame_id = rtp_header_.frame_id; 281 rtp_header_.rtp_timestamp += rtp_advance_per_frame; 282 frame_client_.AddExpectedResult( 283 kFirstFrameId + 3, first_frame_capture_time + 3 * time_advance_per_frame + 284 target_playout_delay); 285 FeedOneFrameIntoReceiver(); // Frame 4 286 task_runner_->RunTasks(); 287 EXPECT_EQ(3, frame_client_.number_times_called()); 288 289 // Move forward to the playout time of an unreceived Frame 5. Expect no 290 // additional frames were emitted. 291 testing_clock_->Advance(3 * time_advance_per_frame); 292 task_runner_->RunTasks(); 293 EXPECT_EQ(3, frame_client_.number_times_called()); 294 295 // Were only non-skipped frames logged? 296 std::vector<FrameEvent> frame_events; 297 event_subscriber.GetFrameEventsAndReset(&frame_events); 298 ASSERT_TRUE(!frame_events.empty()); 299 for (size_t i = 0; i < frame_events.size(); ++i) { 300 EXPECT_EQ(FRAME_ACK_SENT, frame_events[i].type); 301 EXPECT_EQ(AUDIO_EVENT, frame_events[i].media_type); 302 EXPECT_LE(kFirstFrameId, frame_events[i].frame_id); 303 EXPECT_GE(kFirstFrameId + 4, frame_events[i].frame_id); 304 const int frame_offset = frame_events[i].frame_id - kFirstFrameId; 305 EXPECT_NE(frame_offset, 1); // Frame 2 never received. 306 EXPECT_EQ(frame_offset * rtp_advance_per_frame, 307 frame_events[i].rtp_timestamp); 308 } 309 cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber); 310 } 311 312 TEST_F(FrameReceiverTest, ReceivesFramesRefusingToSkipAny) { 313 CreateFrameReceiverOfVideo(); 314 315 SimpleEventSubscriber event_subscriber; 316 cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber); 317 318 EXPECT_CALL(mock_transport_, SendRtcpPacket(_, _)) 319 .WillRepeatedly(testing::Return(true)); 320 321 const uint32 rtp_advance_per_frame = 322 config_.frequency / config_.max_frame_rate; 323 const base::TimeDelta time_advance_per_frame = 324 base::TimeDelta::FromSeconds(1) / config_.max_frame_rate; 325 326 // Feed and process lip sync in receiver. 327 FeedLipSyncInfoIntoReceiver(); 328 task_runner_->RunTasks(); 329 const base::TimeTicks first_frame_capture_time = testing_clock_->NowTicks(); 330 331 // Enqueue a request for a frame. 332 const ReceiveEncodedFrameCallback frame_encoded_callback = 333 base::Bind(&FakeFrameClient::DeliverEncodedFrame, 334 base::Unretained(&frame_client_)); 335 receiver_->RequestEncodedFrame(frame_encoded_callback); 336 task_runner_->RunTasks(); 337 EXPECT_EQ(0, frame_client_.number_times_called()); 338 339 // Receive one frame and expect to see the first request satisfied. 340 const base::TimeDelta target_playout_delay = 341 base::TimeDelta::FromMilliseconds(kPlayoutDelayMillis); 342 frame_client_.AddExpectedResult( 343 kFirstFrameId, first_frame_capture_time + target_playout_delay); 344 rtp_header_.rtp_timestamp = 0; 345 FeedOneFrameIntoReceiver(); // Frame 1 346 task_runner_->RunTasks(); 347 EXPECT_EQ(1, frame_client_.number_times_called()); 348 349 // Enqueue a second request for a frame, but it should not be fulfilled yet. 350 receiver_->RequestEncodedFrame(frame_encoded_callback); 351 task_runner_->RunTasks(); 352 EXPECT_EQ(1, frame_client_.number_times_called()); 353 354 // Receive one frame out-of-order: Make sure that we are not continuous and 355 // that the RTP timestamp represents a time in the future. 356 rtp_header_.is_key_frame = false; 357 rtp_header_.frame_id = kFirstFrameId + 2; // "Frame 3" 358 rtp_header_.reference_frame_id = kFirstFrameId + 1; // "Frame 2" 359 rtp_header_.rtp_timestamp += 2 * rtp_advance_per_frame; 360 FeedOneFrameIntoReceiver(); // Frame 3 361 362 // Frame 2 should not come out at this point in time. 363 task_runner_->RunTasks(); 364 EXPECT_EQ(1, frame_client_.number_times_called()); 365 366 // Enqueue a third request for a frame. 367 receiver_->RequestEncodedFrame(frame_encoded_callback); 368 task_runner_->RunTasks(); 369 EXPECT_EQ(1, frame_client_.number_times_called()); 370 371 // Now, advance time forward such that Frame 2 is now too late for playback. 372 // Regardless, the receiver must NOT emit Frame 3 yet because it is not 373 // allowed to skip frames when dependencies are not satisfied. In other 374 // words, Frame 3 is not decodable without Frame 2. 375 testing_clock_->Advance(2 * time_advance_per_frame + target_playout_delay); 376 task_runner_->RunTasks(); 377 EXPECT_EQ(1, frame_client_.number_times_called()); 378 379 // Now receive Frame 2 and expect both the second and third requests to be 380 // fulfilled immediately. 381 frame_client_.AddExpectedResult( 382 kFirstFrameId + 1, // "Frame 2" 383 first_frame_capture_time + 1 * time_advance_per_frame + 384 target_playout_delay); 385 frame_client_.AddExpectedResult( 386 kFirstFrameId + 2, // "Frame 3" 387 first_frame_capture_time + 2 * time_advance_per_frame + 388 target_playout_delay); 389 --rtp_header_.frame_id; // "Frame 2" 390 --rtp_header_.reference_frame_id; // "Frame 1" 391 rtp_header_.rtp_timestamp -= rtp_advance_per_frame; 392 FeedOneFrameIntoReceiver(); // Frame 2 393 task_runner_->RunTasks(); 394 EXPECT_EQ(3, frame_client_.number_times_called()); 395 396 // Move forward to the playout time of an unreceived Frame 5. Expect no 397 // additional frames were emitted. 398 testing_clock_->Advance(3 * time_advance_per_frame); 399 task_runner_->RunTasks(); 400 EXPECT_EQ(3, frame_client_.number_times_called()); 401 402 // Sanity-check logging results. 403 std::vector<FrameEvent> frame_events; 404 event_subscriber.GetFrameEventsAndReset(&frame_events); 405 ASSERT_TRUE(!frame_events.empty()); 406 for (size_t i = 0; i < frame_events.size(); ++i) { 407 EXPECT_EQ(FRAME_ACK_SENT, frame_events[i].type); 408 EXPECT_EQ(VIDEO_EVENT, frame_events[i].media_type); 409 EXPECT_LE(kFirstFrameId, frame_events[i].frame_id); 410 EXPECT_GE(kFirstFrameId + 3, frame_events[i].frame_id); 411 const int frame_offset = frame_events[i].frame_id - kFirstFrameId; 412 EXPECT_EQ(frame_offset * rtp_advance_per_frame, 413 frame_events[i].rtp_timestamp); 414 } 415 cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber); 416 } 417 418 } // namespace cast 419 } // namespace media 420
