| 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_common/mock_rtp_payload_feedback.h" |
| 8 #include "testing/gtest/include/gtest/gtest.h" |
| 9 |
| 10 namespace media { |
| 11 namespace cast { |
| 12 |
| 13 static const int64 kFrameTimeMillisecond = 33; |
| 14 |
| 15 class FramerTest : public ::testing::Test { |
| 16 protected: |
| 17 FramerTest() |
| 18 : mock_rtp_payload_feedback_(), |
| 19 framer_(&mock_rtp_payload_feedback_, 0, true, 0) { |
| 20 framer_.set_clock(&testing_clock_); |
| 21 } |
| 22 |
| 23 ~FramerTest() {} |
| 24 |
| 25 void SetUp() { |
| 26 // Build a default one packet frame - populate webrtc header. |
| 27 rtp_header_.is_key_frame = false; |
| 28 rtp_header_.frame_id = 0; |
| 29 rtp_header_.packet_id = 0; |
| 30 rtp_header_.max_packet_id = 0; |
| 31 rtp_header_.is_reference = false; |
| 32 rtp_header_.reference_frame_id = 0; |
| 33 payload_.assign(kIpPacketSize, 0); |
| 34 |
| 35 EXPECT_CALL(mock_rtp_payload_feedback_, |
| 36 CastFeedback(testing::_)).WillRepeatedly(testing::Return()); |
| 37 } |
| 38 |
| 39 std::vector<uint8> payload_; |
| 40 RtpCastHeader rtp_header_; |
| 41 MockRtpPayloadFeedback mock_rtp_payload_feedback_; |
| 42 Framer framer_; |
| 43 base::SimpleTestTickClock testing_clock_; |
| 44 }; |
| 45 |
| 46 |
| 47 TEST_F(FramerTest, EmptyState) { |
| 48 EncodedVideoFrame frame; |
| 49 uint32_t rtp_timestamp; |
| 50 bool next_frame = false; |
| 51 base::TimeTicks timeout; |
| 52 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 53 &next_frame)); |
| 54 } |
| 55 |
| 56 TEST_F(FramerTest, AlwaysStartWithKey) { |
| 57 EncodedVideoFrame frame; |
| 58 uint32_t rtp_timestamp; |
| 59 bool next_frame = false; |
| 60 base::TimeTicks timeout; |
| 61 |
| 62 // Insert non key first frame. |
| 63 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 64 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 65 &next_frame)); |
| 66 rtp_header_.frame_id = 1; |
| 67 rtp_header_.is_key_frame = true; |
| 68 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 69 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 70 &next_frame)); |
| 71 EXPECT_TRUE(next_frame); |
| 72 EXPECT_EQ(1, frame.frame_id); |
| 73 EXPECT_TRUE(frame.key_frame); |
| 74 framer_.ReleaseFrame(frame.frame_id); |
| 75 } |
| 76 |
| 77 TEST_F(FramerTest, CompleteFrame) { |
| 78 EncodedVideoFrame frame; |
| 79 uint32_t rtp_timestamp; |
| 80 bool next_frame = false; |
| 81 base::TimeTicks timeout; |
| 82 |
| 83 // start with a complete key frame. |
| 84 rtp_header_.is_key_frame = true; |
| 85 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 86 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 87 &next_frame)); |
| 88 EXPECT_TRUE(next_frame); |
| 89 EXPECT_EQ(0, frame.frame_id); |
| 90 EXPECT_TRUE(frame.key_frame); |
| 91 framer_.ReleaseFrame(frame.frame_id); |
| 92 |
| 93 // Incomplete delta. |
| 94 ++rtp_header_.frame_id; |
| 95 rtp_header_.is_key_frame = false; |
| 96 rtp_header_.max_packet_id = 2; |
| 97 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 98 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 99 &next_frame)); |
| 100 |
| 101 // Complete delta - can't skip, as incomplete sequence. |
| 102 ++rtp_header_.frame_id; |
| 103 rtp_header_.max_packet_id = 0; |
| 104 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 105 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 106 &next_frame)); |
| 107 } |
| 108 |
| 109 TEST_F(FramerTest, ContinuousSequence) { |
| 110 EncodedVideoFrame frame; |
| 111 uint32_t rtp_timestamp; |
| 112 bool next_frame = false; |
| 113 base::TimeTicks timeout; |
| 114 |
| 115 // start with a complete key frame. |
| 116 rtp_header_.is_key_frame = true; |
| 117 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 118 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 119 &next_frame)); |
| 120 EXPECT_TRUE(next_frame); |
| 121 EXPECT_EQ(0, frame.frame_id); |
| 122 EXPECT_TRUE(frame.key_frame); |
| 123 framer_.ReleaseFrame(frame.frame_id); |
| 124 |
| 125 // Complete - not continuous. |
| 126 rtp_header_.frame_id = 2; |
| 127 rtp_header_.is_key_frame = false; |
| 128 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 129 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 130 &next_frame)); |
| 131 } |
| 132 |
| 133 TEST_F(FramerTest, Wrap) { |
| 134 // Insert key frame, frame_id = 255 (will jump to that) |
| 135 EncodedVideoFrame frame; |
| 136 uint32_t rtp_timestamp; |
| 137 bool next_frame = false; |
| 138 base::TimeTicks timeout; |
| 139 |
| 140 // Start with a complete key frame. |
| 141 rtp_header_.is_key_frame = true; |
| 142 rtp_header_.frame_id = 255; |
| 143 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 144 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 145 &next_frame)); |
| 146 EXPECT_TRUE(next_frame); |
| 147 EXPECT_EQ(255, frame.frame_id); |
| 148 framer_.ReleaseFrame(frame.frame_id); |
| 149 |
| 150 // Insert wrapped delta frame - should be continuous. |
| 151 rtp_header_.is_key_frame = false; |
| 152 rtp_header_.frame_id = 0; |
| 153 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 154 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 155 &next_frame)); |
| 156 EXPECT_TRUE(next_frame); |
| 157 EXPECT_EQ(0, frame.frame_id); |
| 158 framer_.ReleaseFrame(frame.frame_id); |
| 159 } |
| 160 |
| 161 TEST_F(FramerTest, Reset) { |
| 162 EncodedVideoFrame frame; |
| 163 uint32_t rtp_timestamp; |
| 164 bool next_frame = false; |
| 165 base::TimeTicks timeout; |
| 166 |
| 167 // Start with a complete key frame. |
| 168 rtp_header_.is_key_frame = true; |
| 169 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 170 framer_.Reset(); |
| 171 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 172 &next_frame)); |
| 173 } |
| 174 |
| 175 TEST_F(FramerTest, RequireKeyAfterReset) { |
| 176 EncodedVideoFrame frame; |
| 177 uint32_t rtp_timestamp; |
| 178 bool next_frame = false; |
| 179 base::TimeTicks timeout; |
| 180 framer_.Reset(); |
| 181 |
| 182 // Start with a complete key frame. |
| 183 rtp_header_.is_key_frame = false; |
| 184 rtp_header_.frame_id = 0; |
| 185 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 186 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 187 &next_frame)); |
| 188 rtp_header_.frame_id = 1; |
| 189 rtp_header_.is_key_frame = true; |
| 190 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 191 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 192 &next_frame)); |
| 193 EXPECT_TRUE(next_frame); |
| 194 } |
| 195 |
| 196 TEST_F(FramerTest, BasicNonLastReferenceId) { |
| 197 EncodedVideoFrame frame; |
| 198 uint32_t rtp_timestamp; |
| 199 bool next_frame = false; |
| 200 rtp_header_.is_key_frame = true; |
| 201 rtp_header_.frame_id = 0; |
| 202 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 203 |
| 204 base::TimeTicks timeout; |
| 205 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 206 &next_frame)); |
| 207 framer_.ReleaseFrame(frame.frame_id); |
| 208 |
| 209 rtp_header_.is_key_frame = false; |
| 210 rtp_header_.is_reference = true; |
| 211 rtp_header_.reference_frame_id = 0; |
| 212 rtp_header_.frame_id = 5; |
| 213 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 214 |
| 215 timeout += base::TimeDelta::FromMilliseconds(kFrameTimeMillisecond); |
| 216 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 217 &next_frame)); |
| 218 testing_clock_.Advance( |
| 219 base::TimeDelta::FromMilliseconds(kFrameTimeMillisecond)); |
| 220 |
| 221 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 222 &next_frame)); |
| 223 EXPECT_FALSE(next_frame); |
| 224 } |
| 225 |
| 226 TEST_F(FramerTest, InOrderReferenceFrameSelection) { |
| 227 // Create pattern: 0, 1, 4, 5. |
| 228 EncodedVideoFrame frame; |
| 229 uint32_t rtp_timestamp; |
| 230 bool next_frame = false; |
| 231 base::TimeTicks timeout; |
| 232 rtp_header_.is_key_frame = true; |
| 233 rtp_header_.frame_id = 0; |
| 234 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 235 rtp_header_.is_key_frame = false; |
| 236 rtp_header_.frame_id = 1; |
| 237 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 238 |
| 239 // Insert frame #2 partially. |
| 240 rtp_header_.frame_id = 2; |
| 241 rtp_header_.max_packet_id = 1; |
| 242 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 243 rtp_header_.frame_id = 4; |
| 244 rtp_header_.max_packet_id = 0; |
| 245 rtp_header_.is_reference = true; |
| 246 rtp_header_.reference_frame_id = 0; |
| 247 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 248 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 249 &next_frame)); |
| 250 EXPECT_EQ(0, frame.frame_id); |
| 251 framer_.ReleaseFrame(frame.frame_id); |
| 252 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 253 &next_frame)); |
| 254 EXPECT_TRUE(next_frame); |
| 255 EXPECT_EQ(1, frame.frame_id); |
| 256 framer_.ReleaseFrame(frame.frame_id); |
| 257 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 258 &next_frame)); |
| 259 EXPECT_FALSE(next_frame); |
| 260 EXPECT_EQ(4, frame.frame_id); |
| 261 framer_.ReleaseFrame(frame.frame_id); |
| 262 // Insert remaining packet of frame #2 - should no be continuous. |
| 263 rtp_header_.frame_id = 2; |
| 264 rtp_header_.packet_id = 1; |
| 265 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 266 EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 267 &next_frame)); |
| 268 rtp_header_.is_reference = false; |
| 269 rtp_header_.frame_id = 5; |
| 270 rtp_header_.packet_id = 0; |
| 271 rtp_header_.max_packet_id = 0; |
| 272 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 273 EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp, |
| 274 &next_frame)); |
| 275 EXPECT_TRUE(next_frame); |
| 276 EXPECT_EQ(5, frame.frame_id); |
| 277 } |
| 278 |
| 279 TEST_F(FramerTest, AudioWrap) { |
| 280 // All audio frames are marked as key frames. |
| 281 EncodedAudioFrame frame; |
| 282 uint32_t rtp_timestamp; |
| 283 base::TimeTicks timeout; |
| 284 bool next_frame = false; |
| 285 rtp_header_.is_key_frame = true; |
| 286 rtp_header_.frame_id = 254; |
| 287 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 288 EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp, |
| 289 &next_frame)); |
| 290 EXPECT_TRUE(next_frame); |
| 291 EXPECT_EQ(254, frame.frame_id); |
| 292 framer_.ReleaseFrame(frame.frame_id); |
| 293 |
| 294 rtp_header_.frame_id = 255; |
| 295 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 296 |
| 297 // Insert wrapped frame - should be continuous. |
| 298 rtp_header_.frame_id = 0; |
| 299 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 300 |
| 301 EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp, |
| 302 &next_frame)); |
| 303 EXPECT_TRUE(next_frame); |
| 304 EXPECT_EQ(255, frame.frame_id); |
| 305 framer_.ReleaseFrame(frame.frame_id); |
| 306 |
| 307 EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp, |
| 308 &next_frame)); |
| 309 EXPECT_TRUE(next_frame); |
| 310 EXPECT_EQ(0, frame.frame_id); |
| 311 framer_.ReleaseFrame(frame.frame_id); |
| 312 } |
| 313 |
| 314 TEST_F(FramerTest, AudioWrapWithMissingFrame) { |
| 315 // All audio frames are marked as key frames. |
| 316 EncodedAudioFrame frame; |
| 317 uint32_t rtp_timestamp; |
| 318 bool next_frame = false; |
| 319 base::TimeTicks timeout; |
| 320 |
| 321 // Insert and get first packet. |
| 322 rtp_header_.is_key_frame = true; |
| 323 rtp_header_.frame_id = 253; |
| 324 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 325 EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp, |
| 326 &next_frame)); |
| 327 EXPECT_TRUE(next_frame); |
| 328 EXPECT_EQ(253, frame.frame_id); |
| 329 framer_.ReleaseFrame(frame.frame_id); |
| 330 |
| 331 // Insert third and fourth packets. |
| 332 rtp_header_.frame_id = 255; |
| 333 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 334 rtp_header_.frame_id = 0; |
| 335 framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_); |
| 336 |
| 337 // Get third and fourth packets. |
| 338 EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp, |
| 339 &next_frame)); |
| 340 EXPECT_FALSE(next_frame); |
| 341 EXPECT_EQ(255, frame.frame_id); |
| 342 framer_.ReleaseFrame(frame.frame_id); |
| 343 EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp, |
| 344 &next_frame)); |
| 345 EXPECT_TRUE(next_frame); |
| 346 EXPECT_EQ(0, frame.frame_id); |
| 347 framer_.ReleaseFrame(frame.frame_id); |
| 348 } |
| 349 |
| 350 } // namespace cast |
| 351 } // namespace media |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 23467003:
Added framer to cast. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@rtcp