| 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 "base/test/simple_test_tick_clock.h" | |
| 6 #include "media/cast/framer/framer.h" | |
| 7 #include "media/cast/rtp_receiver/mock_rtp_payload_feedback.h" | |
| 8 #include "testing/gtest/include/gtest/gtest.h" | |
| 9 | |
| 10 namespace media { | |
| 11 namespace cast { | |
| 12 | |
| 13 class FramerTest : public ::testing::Test { | |
| 14 protected: | |
| 15 FramerTest() | |
| 16 : mock_rtp_payload_feedback_(), | |
| 17 framer_(&testing_clock_, &mock_rtp_payload_feedback_, 0, true, 0) { | |
| 18 payload_.assign(kMaxIpPacketSize, 0); | |
| 19 | |
| 20 EXPECT_CALL(mock_rtp_payload_feedback_, CastFeedback(testing::_)) | |
| 21 .WillRepeatedly(testing::Return()); | |
| 22 } | |
| 23 | |
| 24 virtual ~FramerTest() {} | |
| 25 | |
| 26 std::vector<uint8> payload_; | |
| 27 RtpCastHeader rtp_header_; | |
| 28 MockRtpPayloadFeedback mock_rtp_payload_feedback_; | |
| 29 Framer framer_; | |
| 30 base::SimpleTestTickClock testing_clock_; | |
| 31 | |
| 32 DISALLOW_COPY_AND_ASSIGN(FramerTest); | |
| 33 }; | |
| 34 | |
| 35 TEST_F(FramerTest, EmptyState) { | |
| 36 transport::EncodedFrame frame; | |
| 37 bool next_frame = false; | |
| 38 bool multiple = false; | |
| 39 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 40 } | |
| 41 | |
| 42 TEST_F(FramerTest, AlwaysStartWithKey) { | |
| 43 transport::EncodedFrame frame; | |
| 44 bool next_frame = false; | |
| 45 bool complete = false; | |
| 46 bool multiple = false; | |
| 47 bool duplicate = false; | |
| 48 | |
| 49 // Insert non key first frame. | |
| 50 complete = framer_.InsertPacket( | |
| 51 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 52 EXPECT_TRUE(complete); | |
| 53 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 54 rtp_header_.frame_id = 1; | |
| 55 rtp_header_.reference_frame_id = 1; | |
| 56 rtp_header_.is_key_frame = true; | |
| 57 complete = framer_.InsertPacket( | |
| 58 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 59 EXPECT_TRUE(complete); | |
| 60 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 61 EXPECT_TRUE(next_frame); | |
| 62 EXPECT_TRUE(multiple); | |
| 63 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 64 EXPECT_EQ(1u, frame.frame_id); | |
| 65 EXPECT_EQ(1u, frame.referenced_frame_id); | |
| 66 framer_.ReleaseFrame(frame.frame_id); | |
| 67 } | |
| 68 | |
| 69 TEST_F(FramerTest, CompleteFrame) { | |
| 70 transport::EncodedFrame frame; | |
| 71 bool next_frame = false; | |
| 72 bool complete = false; | |
| 73 bool multiple = false; | |
| 74 bool duplicate = false; | |
| 75 | |
| 76 // Start with a complete key frame. | |
| 77 rtp_header_.is_key_frame = true; | |
| 78 complete = framer_.InsertPacket( | |
| 79 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 80 EXPECT_TRUE(complete); | |
| 81 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 82 EXPECT_TRUE(next_frame); | |
| 83 EXPECT_FALSE(multiple); | |
| 84 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 85 EXPECT_EQ(0u, frame.frame_id); | |
| 86 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 87 framer_.ReleaseFrame(frame.frame_id); | |
| 88 | |
| 89 // Incomplete delta. | |
| 90 ++rtp_header_.frame_id; | |
| 91 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1; | |
| 92 rtp_header_.is_key_frame = false; | |
| 93 rtp_header_.max_packet_id = 2; | |
| 94 complete = framer_.InsertPacket( | |
| 95 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 96 EXPECT_FALSE(complete); | |
| 97 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 98 | |
| 99 // Complete delta - can't skip, as incomplete sequence. | |
| 100 ++rtp_header_.frame_id; | |
| 101 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1; | |
| 102 rtp_header_.max_packet_id = 0; | |
| 103 complete = framer_.InsertPacket( | |
| 104 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 105 EXPECT_TRUE(complete); | |
| 106 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 107 } | |
| 108 | |
| 109 TEST_F(FramerTest, DuplicatePackets) { | |
| 110 transport::EncodedFrame frame; | |
| 111 bool next_frame = false; | |
| 112 bool complete = false; | |
| 113 bool multiple = false; | |
| 114 bool duplicate = false; | |
| 115 | |
| 116 // Start with an incomplete key frame. | |
| 117 rtp_header_.is_key_frame = true; | |
| 118 rtp_header_.max_packet_id = 1; | |
| 119 duplicate = true; | |
| 120 complete = framer_.InsertPacket( | |
| 121 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 122 EXPECT_FALSE(complete); | |
| 123 EXPECT_FALSE(duplicate); | |
| 124 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 125 | |
| 126 // Add same packet again in incomplete key frame. | |
| 127 duplicate = false; | |
| 128 complete = framer_.InsertPacket( | |
| 129 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 130 EXPECT_FALSE(complete); | |
| 131 EXPECT_TRUE(duplicate); | |
| 132 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 133 | |
| 134 // Complete key frame. | |
| 135 rtp_header_.packet_id = 1; | |
| 136 duplicate = true; | |
| 137 complete = framer_.InsertPacket( | |
| 138 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 139 EXPECT_TRUE(complete); | |
| 140 EXPECT_FALSE(duplicate); | |
| 141 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 142 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 143 EXPECT_FALSE(multiple); | |
| 144 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 145 | |
| 146 // Add same packet again in complete key frame. | |
| 147 duplicate = false; | |
| 148 complete = framer_.InsertPacket( | |
| 149 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 150 EXPECT_FALSE(complete); | |
| 151 EXPECT_TRUE(duplicate); | |
| 152 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 153 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 154 EXPECT_EQ(0u, frame.frame_id); | |
| 155 EXPECT_FALSE(multiple); | |
| 156 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 157 framer_.ReleaseFrame(frame.frame_id); | |
| 158 | |
| 159 // Incomplete delta frame. | |
| 160 ++rtp_header_.frame_id; | |
| 161 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1; | |
| 162 rtp_header_.packet_id = 0; | |
| 163 rtp_header_.is_key_frame = false; | |
| 164 duplicate = true; | |
| 165 complete = framer_.InsertPacket( | |
| 166 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 167 EXPECT_FALSE(complete); | |
| 168 EXPECT_FALSE(duplicate); | |
| 169 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 170 | |
| 171 // Add same packet again in incomplete delta frame. | |
| 172 duplicate = false; | |
| 173 complete = framer_.InsertPacket( | |
| 174 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 175 EXPECT_FALSE(complete); | |
| 176 EXPECT_TRUE(duplicate); | |
| 177 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 178 | |
| 179 // Complete delta frame. | |
| 180 rtp_header_.packet_id = 1; | |
| 181 duplicate = true; | |
| 182 complete = framer_.InsertPacket( | |
| 183 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 184 EXPECT_TRUE(complete); | |
| 185 EXPECT_FALSE(duplicate); | |
| 186 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 187 EXPECT_EQ(transport::EncodedFrame::DEPENDENT, frame.dependency); | |
| 188 EXPECT_EQ(1u, frame.frame_id); | |
| 189 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 190 EXPECT_FALSE(multiple); | |
| 191 | |
| 192 // Add same packet again in complete delta frame. | |
| 193 duplicate = false; | |
| 194 complete = framer_.InsertPacket( | |
| 195 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 196 EXPECT_FALSE(complete); | |
| 197 EXPECT_TRUE(duplicate); | |
| 198 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 199 EXPECT_EQ(transport::EncodedFrame::DEPENDENT, frame.dependency); | |
| 200 EXPECT_EQ(1u, frame.frame_id); | |
| 201 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 202 EXPECT_FALSE(multiple); | |
| 203 } | |
| 204 | |
| 205 TEST_F(FramerTest, ContinuousSequence) { | |
| 206 transport::EncodedFrame frame; | |
| 207 bool next_frame = false; | |
| 208 bool complete = false; | |
| 209 bool multiple = false; | |
| 210 bool duplicate = false; | |
| 211 | |
| 212 // Start with a complete key frame. | |
| 213 rtp_header_.is_key_frame = true; | |
| 214 complete = framer_.InsertPacket( | |
| 215 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 216 EXPECT_TRUE(complete); | |
| 217 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 218 EXPECT_TRUE(next_frame); | |
| 219 EXPECT_FALSE(multiple); | |
| 220 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 221 EXPECT_EQ(0u, frame.frame_id); | |
| 222 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 223 framer_.ReleaseFrame(frame.frame_id); | |
| 224 | |
| 225 // Complete - not continuous. | |
| 226 rtp_header_.frame_id = 2; | |
| 227 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1; | |
| 228 rtp_header_.is_key_frame = false; | |
| 229 complete = framer_.InsertPacket( | |
| 230 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 231 EXPECT_TRUE(complete); | |
| 232 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 233 } | |
| 234 | |
| 235 TEST_F(FramerTest, Wrap) { | |
| 236 // Insert key frame, frame_id = 255 (will jump to that) | |
| 237 transport::EncodedFrame frame; | |
| 238 bool next_frame = false; | |
| 239 bool multiple = true; | |
| 240 bool duplicate = false; | |
| 241 | |
| 242 // Start with a complete key frame. | |
| 243 rtp_header_.is_key_frame = true; | |
| 244 rtp_header_.frame_id = 255; | |
| 245 rtp_header_.reference_frame_id = 255; | |
| 246 framer_.InsertPacket( | |
| 247 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 248 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 249 EXPECT_TRUE(next_frame); | |
| 250 EXPECT_FALSE(multiple); | |
| 251 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 252 EXPECT_EQ(255u, frame.frame_id); | |
| 253 EXPECT_EQ(255u, frame.referenced_frame_id); | |
| 254 framer_.ReleaseFrame(frame.frame_id); | |
| 255 | |
| 256 // Insert wrapped delta frame - should be continuous. | |
| 257 rtp_header_.is_key_frame = false; | |
| 258 rtp_header_.frame_id = 256; | |
| 259 framer_.InsertPacket( | |
| 260 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 261 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 262 EXPECT_TRUE(next_frame); | |
| 263 EXPECT_FALSE(multiple); | |
| 264 EXPECT_EQ(transport::EncodedFrame::DEPENDENT, frame.dependency); | |
| 265 EXPECT_EQ(256u, frame.frame_id); | |
| 266 EXPECT_EQ(255u, frame.referenced_frame_id); | |
| 267 framer_.ReleaseFrame(frame.frame_id); | |
| 268 } | |
| 269 | |
| 270 TEST_F(FramerTest, Reset) { | |
| 271 transport::EncodedFrame frame; | |
| 272 bool next_frame = false; | |
| 273 bool complete = false; | |
| 274 bool multiple = true; | |
| 275 bool duplicate = false; | |
| 276 | |
| 277 // Start with a complete key frame. | |
| 278 rtp_header_.is_key_frame = true; | |
| 279 complete = framer_.InsertPacket( | |
| 280 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 281 EXPECT_TRUE(complete); | |
| 282 framer_.Reset(); | |
| 283 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 284 } | |
| 285 | |
| 286 TEST_F(FramerTest, RequireKeyAfterReset) { | |
| 287 transport::EncodedFrame frame; | |
| 288 bool next_frame = false; | |
| 289 bool multiple = false; | |
| 290 bool duplicate = false; | |
| 291 | |
| 292 framer_.Reset(); | |
| 293 | |
| 294 // Start with a complete key frame. | |
| 295 rtp_header_.is_key_frame = false; | |
| 296 rtp_header_.frame_id = 0; | |
| 297 framer_.InsertPacket( | |
| 298 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 299 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 300 rtp_header_.frame_id = 1; | |
| 301 rtp_header_.reference_frame_id = 1; | |
| 302 rtp_header_.is_key_frame = true; | |
| 303 framer_.InsertPacket( | |
| 304 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 305 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 306 EXPECT_TRUE(next_frame); | |
| 307 EXPECT_TRUE(multiple); | |
| 308 } | |
| 309 | |
| 310 TEST_F(FramerTest, BasicNonLastReferenceId) { | |
| 311 transport::EncodedFrame frame; | |
| 312 bool next_frame = false; | |
| 313 bool multiple = false; | |
| 314 bool duplicate = false; | |
| 315 | |
| 316 rtp_header_.is_key_frame = true; | |
| 317 rtp_header_.frame_id = 0; | |
| 318 framer_.InsertPacket( | |
| 319 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 320 | |
| 321 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 322 EXPECT_FALSE(multiple); | |
| 323 framer_.ReleaseFrame(frame.frame_id); | |
| 324 | |
| 325 rtp_header_.is_key_frame = false; | |
| 326 rtp_header_.reference_frame_id = 0; | |
| 327 rtp_header_.frame_id = 5; | |
| 328 framer_.InsertPacket( | |
| 329 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 330 | |
| 331 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 332 EXPECT_FALSE(next_frame); | |
| 333 EXPECT_FALSE(multiple); | |
| 334 } | |
| 335 | |
| 336 TEST_F(FramerTest, InOrderReferenceFrameSelection) { | |
| 337 // Create pattern: 0, 1, 4, 5. | |
| 338 transport::EncodedFrame frame; | |
| 339 bool next_frame = false; | |
| 340 bool multiple = false; | |
| 341 bool duplicate = false; | |
| 342 | |
| 343 rtp_header_.is_key_frame = true; | |
| 344 rtp_header_.frame_id = 0; | |
| 345 framer_.InsertPacket( | |
| 346 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 347 rtp_header_.is_key_frame = false; | |
| 348 rtp_header_.frame_id = 1; | |
| 349 framer_.InsertPacket( | |
| 350 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 351 | |
| 352 // Insert frame #2 partially. | |
| 353 rtp_header_.frame_id = 2; | |
| 354 rtp_header_.max_packet_id = 1; | |
| 355 framer_.InsertPacket( | |
| 356 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 357 rtp_header_.frame_id = 4; | |
| 358 rtp_header_.max_packet_id = 0; | |
| 359 rtp_header_.reference_frame_id = 0; | |
| 360 framer_.InsertPacket( | |
| 361 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 362 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 363 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 364 EXPECT_EQ(0u, frame.frame_id); | |
| 365 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 366 EXPECT_FALSE(multiple); | |
| 367 framer_.ReleaseFrame(frame.frame_id); | |
| 368 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 369 EXPECT_TRUE(next_frame); | |
| 370 EXPECT_TRUE(multiple); | |
| 371 EXPECT_EQ(transport::EncodedFrame::DEPENDENT, frame.dependency); | |
| 372 EXPECT_EQ(1u, frame.frame_id); | |
| 373 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 374 framer_.ReleaseFrame(frame.frame_id); | |
| 375 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 376 EXPECT_FALSE(next_frame); | |
| 377 EXPECT_FALSE(multiple); | |
| 378 EXPECT_EQ(transport::EncodedFrame::DEPENDENT, frame.dependency); | |
| 379 EXPECT_EQ(4u, frame.frame_id); | |
| 380 EXPECT_EQ(0u, frame.referenced_frame_id); | |
| 381 framer_.ReleaseFrame(frame.frame_id); | |
| 382 // Insert remaining packet of frame #2 - should no be continuous. | |
| 383 rtp_header_.frame_id = 2; | |
| 384 rtp_header_.packet_id = 1; | |
| 385 framer_.InsertPacket( | |
| 386 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 387 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 388 rtp_header_.frame_id = 5; | |
| 389 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1; | |
| 390 rtp_header_.packet_id = 0; | |
| 391 rtp_header_.max_packet_id = 0; | |
| 392 framer_.InsertPacket( | |
| 393 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 394 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 395 EXPECT_TRUE(next_frame); | |
| 396 EXPECT_FALSE(multiple); | |
| 397 EXPECT_EQ(transport::EncodedFrame::DEPENDENT, frame.dependency); | |
| 398 EXPECT_EQ(5u, frame.frame_id); | |
| 399 EXPECT_EQ(4u, frame.referenced_frame_id); | |
| 400 } | |
| 401 | |
| 402 TEST_F(FramerTest, AudioWrap) { | |
| 403 // All audio frames are marked as key frames. | |
| 404 transport::EncodedFrame frame; | |
| 405 bool next_frame = false; | |
| 406 bool multiple = false; | |
| 407 bool duplicate = false; | |
| 408 | |
| 409 rtp_header_.is_key_frame = true; | |
| 410 rtp_header_.frame_id = 254; | |
| 411 rtp_header_.reference_frame_id = 254; | |
| 412 | |
| 413 framer_.InsertPacket( | |
| 414 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 415 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 416 EXPECT_TRUE(next_frame); | |
| 417 EXPECT_FALSE(multiple); | |
| 418 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 419 EXPECT_EQ(254u, frame.frame_id); | |
| 420 EXPECT_EQ(254u, frame.referenced_frame_id); | |
| 421 framer_.ReleaseFrame(frame.frame_id); | |
| 422 | |
| 423 rtp_header_.frame_id = 255; | |
| 424 rtp_header_.reference_frame_id = 255; | |
| 425 framer_.InsertPacket( | |
| 426 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 427 | |
| 428 // Insert wrapped frame - should be continuous. | |
| 429 rtp_header_.frame_id = 256; | |
| 430 rtp_header_.reference_frame_id = 256; | |
| 431 framer_.InsertPacket( | |
| 432 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 433 | |
| 434 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 435 EXPECT_TRUE(next_frame); | |
| 436 EXPECT_TRUE(multiple); | |
| 437 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 438 EXPECT_EQ(255u, frame.frame_id); | |
| 439 EXPECT_EQ(255u, frame.referenced_frame_id); | |
| 440 framer_.ReleaseFrame(frame.frame_id); | |
| 441 | |
| 442 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 443 EXPECT_TRUE(next_frame); | |
| 444 EXPECT_FALSE(multiple); | |
| 445 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 446 EXPECT_EQ(256u, frame.frame_id); | |
| 447 EXPECT_EQ(256u, frame.referenced_frame_id); | |
| 448 framer_.ReleaseFrame(frame.frame_id); | |
| 449 } | |
| 450 | |
| 451 TEST_F(FramerTest, AudioWrapWithMissingFrame) { | |
| 452 // All audio frames are marked as key frames. | |
| 453 transport::EncodedFrame frame; | |
| 454 bool next_frame = false; | |
| 455 bool multiple = true; | |
| 456 bool duplicate = false; | |
| 457 | |
| 458 // Insert and get first packet. | |
| 459 rtp_header_.is_key_frame = true; | |
| 460 rtp_header_.frame_id = 253; | |
| 461 rtp_header_.reference_frame_id = 253; | |
| 462 framer_.InsertPacket( | |
| 463 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 464 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 465 EXPECT_TRUE(next_frame); | |
| 466 EXPECT_FALSE(multiple); | |
| 467 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 468 EXPECT_EQ(253u, frame.frame_id); | |
| 469 EXPECT_EQ(253u, frame.referenced_frame_id); | |
| 470 framer_.ReleaseFrame(frame.frame_id); | |
| 471 | |
| 472 // Insert third and fourth packets. | |
| 473 rtp_header_.frame_id = 255; | |
| 474 rtp_header_.reference_frame_id = 255; | |
| 475 framer_.InsertPacket( | |
| 476 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 477 rtp_header_.frame_id = 256; | |
| 478 rtp_header_.reference_frame_id = 256; | |
| 479 framer_.InsertPacket( | |
| 480 payload_.data(), payload_.size(), rtp_header_, &duplicate); | |
| 481 | |
| 482 // Get third and fourth packets. | |
| 483 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 484 EXPECT_FALSE(next_frame); | |
| 485 EXPECT_TRUE(multiple); | |
| 486 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 487 EXPECT_EQ(255u, frame.frame_id); | |
| 488 EXPECT_EQ(255u, frame.referenced_frame_id); | |
| 489 framer_.ReleaseFrame(frame.frame_id); | |
| 490 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple)); | |
| 491 EXPECT_TRUE(next_frame); | |
| 492 EXPECT_FALSE(multiple); | |
| 493 EXPECT_EQ(transport::EncodedFrame::KEY, frame.dependency); | |
| 494 EXPECT_EQ(256u, frame.frame_id); | |
| 495 EXPECT_EQ(256u, frame.referenced_frame_id); | |
| 496 framer_.ReleaseFrame(frame.frame_id); | |
| 497 } | |
| 498 | |
| 499 } // namespace cast | |
| 500 } // 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