| 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/memory/scoped_ptr.h" | |
| 8 #include "base/test/simple_test_tick_clock.h" | |
| 9 #include "media/cast/framer/cast_message_builder.h" | |
| 10 #include "media/cast/rtcp/rtcp.h" | |
| 11 #include "media/cast/rtp_receiver/rtp_receiver_defines.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 namespace media { | |
| 15 namespace cast { | |
| 16 | |
| 17 namespace { | |
| 18 static const uint32 kSsrc = 0x1234; | |
| 19 static const uint32 kShortTimeIncrementMs = 10; | |
| 20 static const uint32 kLongTimeIncrementMs = 40; | |
| 21 static const int64 kStartMillisecond = INT64_C(12345678900000); | |
| 22 | |
| 23 typedef std::map<uint32, size_t> MissingPacketsMap; | |
| 24 | |
| 25 class NackFeedbackVerification : public RtpPayloadFeedback { | |
| 26 public: | |
| 27 NackFeedbackVerification() | |
| 28 : triggered_(false), missing_packets_(), last_frame_acked_(0) {} | |
| 29 | |
| 30 virtual void CastFeedback(const RtcpCastMessage& cast_feedback) OVERRIDE { | |
| 31 EXPECT_EQ(kSsrc, cast_feedback.media_ssrc_); | |
| 32 | |
| 33 last_frame_acked_ = cast_feedback.ack_frame_id_; | |
| 34 | |
| 35 MissingFramesAndPacketsMap::const_iterator frame_it = | |
| 36 cast_feedback.missing_frames_and_packets_.begin(); | |
| 37 | |
| 38 // Keep track of the number of missing packets per frame. | |
| 39 missing_packets_.clear(); | |
| 40 while (frame_it != cast_feedback.missing_frames_and_packets_.end()) { | |
| 41 // Check for complete frame lost. | |
| 42 if ((frame_it->second.size() == 1) && | |
| 43 (*frame_it->second.begin() == kRtcpCastAllPacketsLost)) { | |
| 44 missing_packets_.insert( | |
| 45 std::make_pair(frame_it->first, kRtcpCastAllPacketsLost)); | |
| 46 } else { | |
| 47 missing_packets_.insert( | |
| 48 std::make_pair(frame_it->first, frame_it->second.size())); | |
| 49 } | |
| 50 ++frame_it; | |
| 51 } | |
| 52 triggered_ = true; | |
| 53 } | |
| 54 | |
| 55 size_t num_missing_packets(uint32 frame_id) { | |
| 56 MissingPacketsMap::iterator it; | |
| 57 it = missing_packets_.find(frame_id); | |
| 58 if (it == missing_packets_.end()) | |
| 59 return 0; | |
| 60 | |
| 61 return it->second; | |
| 62 } | |
| 63 | |
| 64 // Holds value for one call. | |
| 65 bool triggered() { | |
| 66 bool ret_val = triggered_; | |
| 67 triggered_ = false; | |
| 68 return ret_val; | |
| 69 } | |
| 70 | |
| 71 uint32 last_frame_acked() { return last_frame_acked_; } | |
| 72 | |
| 73 private: | |
| 74 bool triggered_; | |
| 75 MissingPacketsMap missing_packets_; // Missing packets per frame. | |
| 76 uint32 last_frame_acked_; | |
| 77 | |
| 78 DISALLOW_COPY_AND_ASSIGN(NackFeedbackVerification); | |
| 79 }; | |
| 80 } // namespace | |
| 81 | |
| 82 class CastMessageBuilderTest : public ::testing::Test { | |
| 83 protected: | |
| 84 CastMessageBuilderTest() | |
| 85 : cast_msg_builder_(new CastMessageBuilder(&testing_clock_, | |
| 86 &feedback_, | |
| 87 &frame_id_map_, | |
| 88 kSsrc, | |
| 89 true, | |
| 90 0)) { | |
| 91 rtp_header_.sender_ssrc = kSsrc; | |
| 92 rtp_header_.is_key_frame = false; | |
| 93 testing_clock_.Advance( | |
| 94 base::TimeDelta::FromMilliseconds(kStartMillisecond)); | |
| 95 } | |
| 96 | |
| 97 virtual ~CastMessageBuilderTest() {} | |
| 98 | |
| 99 void SetFrameIds(uint32 frame_id, uint32 reference_frame_id) { | |
| 100 rtp_header_.frame_id = frame_id; | |
| 101 rtp_header_.reference_frame_id = reference_frame_id; | |
| 102 } | |
| 103 | |
| 104 void SetPacketId(uint16 packet_id) { rtp_header_.packet_id = packet_id; } | |
| 105 | |
| 106 void SetMaxPacketId(uint16 max_packet_id) { | |
| 107 rtp_header_.max_packet_id = max_packet_id; | |
| 108 } | |
| 109 | |
| 110 void SetKeyFrame(bool is_key) { rtp_header_.is_key_frame = is_key; } | |
| 111 | |
| 112 void InsertPacket() { | |
| 113 PacketType packet_type = frame_id_map_.InsertPacket(rtp_header_); | |
| 114 if (packet_type == kNewPacketCompletingFrame) { | |
| 115 cast_msg_builder_->CompleteFrameReceived(rtp_header_.frame_id); | |
| 116 } | |
| 117 cast_msg_builder_->UpdateCastMessage(); | |
| 118 } | |
| 119 | |
| 120 void SetDecoderSlowerThanMaxFrameRate(int max_unacked_frames) { | |
| 121 cast_msg_builder_.reset(new CastMessageBuilder(&testing_clock_, | |
| 122 &feedback_, | |
| 123 &frame_id_map_, | |
| 124 kSsrc, | |
| 125 false, | |
| 126 max_unacked_frames)); | |
| 127 } | |
| 128 | |
| 129 NackFeedbackVerification feedback_; | |
| 130 scoped_ptr<CastMessageBuilder> cast_msg_builder_; | |
| 131 RtpCastHeader rtp_header_; | |
| 132 FrameIdMap frame_id_map_; | |
| 133 base::SimpleTestTickClock testing_clock_; | |
| 134 | |
| 135 DISALLOW_COPY_AND_ASSIGN(CastMessageBuilderTest); | |
| 136 }; | |
| 137 | |
| 138 TEST_F(CastMessageBuilderTest, OneFrameNackList) { | |
| 139 SetFrameIds(0, 0); | |
| 140 SetPacketId(4); | |
| 141 SetMaxPacketId(10); | |
| 142 InsertPacket(); | |
| 143 testing_clock_.Advance( | |
| 144 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 145 EXPECT_FALSE(feedback_.triggered()); | |
| 146 testing_clock_.Advance( | |
| 147 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 148 SetPacketId(5); | |
| 149 InsertPacket(); | |
| 150 EXPECT_TRUE(feedback_.triggered()); | |
| 151 EXPECT_EQ(4u, feedback_.num_missing_packets(0)); | |
| 152 } | |
| 153 | |
| 154 TEST_F(CastMessageBuilderTest, CompleteFrameMissing) { | |
| 155 SetFrameIds(0, 0); | |
| 156 SetPacketId(2); | |
| 157 SetMaxPacketId(5); | |
| 158 InsertPacket(); | |
| 159 testing_clock_.Advance( | |
| 160 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 161 SetFrameIds(2, 1); | |
| 162 SetPacketId(2); | |
| 163 SetMaxPacketId(5); | |
| 164 InsertPacket(); | |
| 165 EXPECT_TRUE(feedback_.triggered()); | |
| 166 EXPECT_EQ(kRtcpCastAllPacketsLost, feedback_.num_missing_packets(1)); | |
| 167 } | |
| 168 | |
| 169 TEST_F(CastMessageBuilderTest, RemoveOldFrames) { | |
| 170 SetFrameIds(1, 0); | |
| 171 SetPacketId(0); | |
| 172 SetMaxPacketId(1); | |
| 173 InsertPacket(); | |
| 174 EXPECT_FALSE(feedback_.triggered()); | |
| 175 testing_clock_.Advance( | |
| 176 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 177 SetFrameIds(2, 1); | |
| 178 SetPacketId(0); | |
| 179 SetMaxPacketId(0); | |
| 180 InsertPacket(); | |
| 181 EXPECT_TRUE(feedback_.triggered()); | |
| 182 testing_clock_.Advance( | |
| 183 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 184 SetFrameIds(3, 2); | |
| 185 SetPacketId(0); | |
| 186 SetMaxPacketId(5); | |
| 187 InsertPacket(); | |
| 188 EXPECT_TRUE(feedback_.triggered()); | |
| 189 EXPECT_EQ(2u, feedback_.last_frame_acked()); | |
| 190 testing_clock_.Advance( | |
| 191 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 192 SetFrameIds(5, 5); | |
| 193 SetPacketId(0); | |
| 194 SetMaxPacketId(0); | |
| 195 SetKeyFrame(true); | |
| 196 InsertPacket(); | |
| 197 testing_clock_.Advance( | |
| 198 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 199 frame_id_map_.RemoveOldFrames(5); // Simulate 5 being pulled for rendering. | |
| 200 cast_msg_builder_->UpdateCastMessage(); | |
| 201 EXPECT_TRUE(feedback_.triggered()); | |
| 202 EXPECT_EQ(5u, feedback_.last_frame_acked()); | |
| 203 testing_clock_.Advance( | |
| 204 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 205 SetFrameIds(1, 0); | |
| 206 SetPacketId(1); | |
| 207 SetMaxPacketId(1); | |
| 208 InsertPacket(); | |
| 209 EXPECT_FALSE(feedback_.triggered()); | |
| 210 testing_clock_.Advance( | |
| 211 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 212 InsertPacket(); | |
| 213 EXPECT_TRUE(feedback_.triggered()); | |
| 214 EXPECT_EQ(5u, feedback_.last_frame_acked()); | |
| 215 } | |
| 216 | |
| 217 TEST_F(CastMessageBuilderTest, NackUntilMaxReceivedPacket) { | |
| 218 SetFrameIds(0, 0); | |
| 219 SetPacketId(0); | |
| 220 SetMaxPacketId(20); | |
| 221 SetKeyFrame(true); | |
| 222 InsertPacket(); | |
| 223 testing_clock_.Advance( | |
| 224 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 225 SetPacketId(5); | |
| 226 InsertPacket(); | |
| 227 EXPECT_TRUE(feedback_.triggered()); | |
| 228 EXPECT_EQ(4u, feedback_.num_missing_packets(0)); | |
| 229 } | |
| 230 | |
| 231 TEST_F(CastMessageBuilderTest, NackUntilMaxReceivedPacketNextFrame) { | |
| 232 SetFrameIds(0, 0); | |
| 233 SetPacketId(0); | |
| 234 SetMaxPacketId(20); | |
| 235 SetKeyFrame(true); | |
| 236 InsertPacket(); | |
| 237 testing_clock_.Advance( | |
| 238 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 239 SetPacketId(5); | |
| 240 InsertPacket(); | |
| 241 testing_clock_.Advance( | |
| 242 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 243 EXPECT_TRUE(feedback_.triggered()); | |
| 244 EXPECT_EQ(4u, feedback_.num_missing_packets(0)); | |
| 245 SetFrameIds(1, 0); | |
| 246 SetMaxPacketId(2); | |
| 247 SetPacketId(0); | |
| 248 SetKeyFrame(false); | |
| 249 InsertPacket(); | |
| 250 testing_clock_.Advance( | |
| 251 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 252 EXPECT_TRUE(feedback_.triggered()); | |
| 253 EXPECT_EQ(19u, feedback_.num_missing_packets(0)); | |
| 254 } | |
| 255 | |
| 256 TEST_F(CastMessageBuilderTest, NackUntilMaxReceivedPacketNextKey) { | |
| 257 SetFrameIds(0, 0); | |
| 258 SetPacketId(0); | |
| 259 SetMaxPacketId(20); | |
| 260 SetKeyFrame(true); | |
| 261 InsertPacket(); | |
| 262 testing_clock_.Advance( | |
| 263 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 264 SetPacketId(5); | |
| 265 InsertPacket(); | |
| 266 testing_clock_.Advance( | |
| 267 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 268 EXPECT_TRUE(feedback_.triggered()); | |
| 269 EXPECT_EQ(4u, feedback_.num_missing_packets(0)); | |
| 270 SetFrameIds(1, 1); | |
| 271 SetMaxPacketId(0); | |
| 272 SetPacketId(0); | |
| 273 SetKeyFrame(true); | |
| 274 InsertPacket(); | |
| 275 testing_clock_.Advance( | |
| 276 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 277 EXPECT_TRUE(feedback_.triggered()); | |
| 278 EXPECT_EQ(0u, feedback_.num_missing_packets(0)); | |
| 279 } | |
| 280 | |
| 281 TEST_F(CastMessageBuilderTest, Reset) { | |
| 282 InsertPacket(); | |
| 283 testing_clock_.Advance( | |
| 284 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 285 cast_msg_builder_->Reset(); | |
| 286 frame_id_map_.Clear(); | |
| 287 // Should reset nack list state and request a key frame. | |
| 288 cast_msg_builder_->UpdateCastMessage(); | |
| 289 EXPECT_TRUE(feedback_.triggered()); | |
| 290 EXPECT_EQ(0u, feedback_.num_missing_packets(0)); | |
| 291 } | |
| 292 | |
| 293 TEST_F(CastMessageBuilderTest, DeltaAfterReset) { | |
| 294 SetFrameIds(0, 0); | |
| 295 SetPacketId(0); | |
| 296 SetMaxPacketId(0); | |
| 297 SetKeyFrame(true); | |
| 298 InsertPacket(); | |
| 299 EXPECT_TRUE(feedback_.triggered()); | |
| 300 EXPECT_EQ(0u, feedback_.num_missing_packets(0)); | |
| 301 testing_clock_.Advance( | |
| 302 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 303 cast_msg_builder_->Reset(); | |
| 304 SetFrameIds(1, 0); | |
| 305 SetPacketId(0); | |
| 306 SetMaxPacketId(0); | |
| 307 SetKeyFrame(true); | |
| 308 EXPECT_FALSE(feedback_.triggered()); | |
| 309 } | |
| 310 | |
| 311 TEST_F(CastMessageBuilderTest, BasicRps) { | |
| 312 SetFrameIds(0, 0); | |
| 313 SetPacketId(0); | |
| 314 SetMaxPacketId(0); | |
| 315 SetKeyFrame(true); | |
| 316 InsertPacket(); | |
| 317 testing_clock_.Advance( | |
| 318 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 319 EXPECT_TRUE(feedback_.triggered()); | |
| 320 EXPECT_EQ(0u, feedback_.last_frame_acked()); | |
| 321 SetFrameIds(3, 0); | |
| 322 SetKeyFrame(false); | |
| 323 InsertPacket(); | |
| 324 EXPECT_TRUE(feedback_.triggered()); | |
| 325 EXPECT_EQ(3u, feedback_.last_frame_acked()); | |
| 326 testing_clock_.Advance( | |
| 327 base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs)); | |
| 328 frame_id_map_.RemoveOldFrames(3); // Simulate 3 being pulled for rendering. | |
| 329 cast_msg_builder_->UpdateCastMessage(); | |
| 330 EXPECT_TRUE(feedback_.triggered()); | |
| 331 EXPECT_EQ(3u, feedback_.last_frame_acked()); | |
| 332 } | |
| 333 | |
| 334 TEST_F(CastMessageBuilderTest, InOrderRps) { | |
| 335 // Create a pattern - skip to rps, and don't look back. | |
| 336 SetFrameIds(0, 0); | |
| 337 SetPacketId(0); | |
| 338 SetMaxPacketId(0); | |
| 339 SetKeyFrame(true); | |
| 340 InsertPacket(); | |
| 341 testing_clock_.Advance( | |
| 342 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 343 EXPECT_TRUE(feedback_.triggered()); | |
| 344 EXPECT_EQ(0u, feedback_.last_frame_acked()); | |
| 345 SetFrameIds(1, 0); | |
| 346 SetPacketId(0); | |
| 347 SetMaxPacketId(1); | |
| 348 SetKeyFrame(false); | |
| 349 InsertPacket(); | |
| 350 testing_clock_.Advance( | |
| 351 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 352 EXPECT_FALSE(feedback_.triggered()); | |
| 353 SetFrameIds(3, 0); | |
| 354 SetPacketId(0); | |
| 355 SetMaxPacketId(0); | |
| 356 SetKeyFrame(false); | |
| 357 InsertPacket(); | |
| 358 testing_clock_.Advance( | |
| 359 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 360 frame_id_map_.RemoveOldFrames(3); // Simulate 3 being pulled for rendering. | |
| 361 testing_clock_.Advance( | |
| 362 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 363 cast_msg_builder_->UpdateCastMessage(); | |
| 364 EXPECT_TRUE(feedback_.triggered()); | |
| 365 EXPECT_EQ(3u, feedback_.last_frame_acked()); | |
| 366 // Make an old frame complete - should not trigger an ack. | |
| 367 SetFrameIds(1, 0); | |
| 368 SetPacketId(1); | |
| 369 SetMaxPacketId(1); | |
| 370 SetKeyFrame(false); | |
| 371 InsertPacket(); | |
| 372 testing_clock_.Advance( | |
| 373 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 374 EXPECT_FALSE(feedback_.triggered()); | |
| 375 EXPECT_EQ(3u, feedback_.last_frame_acked()); | |
| 376 } | |
| 377 | |
| 378 TEST_F(CastMessageBuilderTest, SlowDownAck) { | |
| 379 SetDecoderSlowerThanMaxFrameRate(3); | |
| 380 SetFrameIds(0, 0); | |
| 381 SetPacketId(0); | |
| 382 SetMaxPacketId(0); | |
| 383 SetKeyFrame(true); | |
| 384 InsertPacket(); | |
| 385 | |
| 386 uint32 frame_id; | |
| 387 testing_clock_.Advance( | |
| 388 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 389 SetKeyFrame(false); | |
| 390 for (frame_id = 1; frame_id < 3; ++frame_id) { | |
| 391 EXPECT_TRUE(feedback_.triggered()); | |
| 392 EXPECT_EQ(frame_id - 1, feedback_.last_frame_acked()); | |
| 393 SetFrameIds(frame_id, frame_id - 1); | |
| 394 InsertPacket(); | |
| 395 testing_clock_.Advance( | |
| 396 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 397 } | |
| 398 // We should now have entered the slowdown ACK state. | |
| 399 uint32 expected_frame_id = 1; | |
| 400 for (; frame_id < 10; ++frame_id) { | |
| 401 if (frame_id % 2) { | |
| 402 ++expected_frame_id; | |
| 403 EXPECT_TRUE(feedback_.triggered()); | |
| 404 } else { | |
| 405 EXPECT_FALSE(feedback_.triggered()); | |
| 406 } | |
| 407 EXPECT_EQ(expected_frame_id, feedback_.last_frame_acked()); | |
| 408 SetFrameIds(frame_id, frame_id - 1); | |
| 409 InsertPacket(); | |
| 410 testing_clock_.Advance( | |
| 411 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 412 } | |
| 413 EXPECT_FALSE(feedback_.triggered()); | |
| 414 EXPECT_EQ(expected_frame_id, feedback_.last_frame_acked()); | |
| 415 | |
| 416 // Simulate frame_id being pulled for rendering. | |
| 417 frame_id_map_.RemoveOldFrames(frame_id); | |
| 418 // We should now leave the slowdown ACK state. | |
| 419 ++frame_id; | |
| 420 SetFrameIds(frame_id, frame_id - 1); | |
| 421 InsertPacket(); | |
| 422 testing_clock_.Advance( | |
| 423 base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs)); | |
| 424 EXPECT_TRUE(feedback_.triggered()); | |
| 425 EXPECT_EQ(frame_id, feedback_.last_frame_acked()); | |
| 426 } | |
| 427 | |
| 428 } // namespace cast | |
| 429 } // 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