| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license | |
| 5 * that can be found in the LICENSE file in the root of the source | |
| 6 * tree. An additional intellectual property rights grant can be found | |
| 7 * in the file PATENTS. All contributing project authors may | |
| 8 * be found in the AUTHORS file in the root of the source tree. | |
| 9 */ | |
| 10 | |
| 11 #include <cstring> | |
| 12 #include <limits> | |
| 13 #include <map> | |
| 14 #include <set> | |
| 15 #include <utility> | |
| 16 | |
| 17 #include "webrtc/modules/video_coding/frame_object.h" | |
| 18 #include "webrtc/modules/video_coding/packet_buffer.h" | |
| 19 | |
| 20 #include "testing/gtest/include/gtest/gtest.h" | |
| 21 #include "webrtc/base/random.h" | |
| 22 | |
| 23 namespace webrtc { | |
| 24 namespace video_coding { | |
| 25 | |
| 26 class TestPacketBuffer : public ::testing::Test, | |
| 27 public OnCompleteFrameCallback { | |
| 28 protected: | |
| 29 TestPacketBuffer() | |
| 30 : rand_(0x8739211), | |
| 31 packet_buffer_(new PacketBuffer(kStartSize, kMaxSize, this)), | |
| 32 frames_from_callback_(FrameComp()) {} | |
| 33 | |
| 34 uint16_t Rand() { return rand_.Rand(std::numeric_limits<uint16_t>::max()); } | |
| 35 | |
| 36 void OnCompleteFrame(std::unique_ptr<FrameObject> frame) override { | |
| 37 uint16_t pid = frame->picture_id; | |
| 38 uint16_t sidx = frame->spatial_layer; | |
| 39 auto frame_it = frames_from_callback_.find(std::make_pair(pid, sidx)); | |
| 40 if (frame_it != frames_from_callback_.end()) { | |
| 41 ADD_FAILURE() << "Already received frame with (pid:sidx): (" | |
| 42 << pid << ":" << sidx << ")"; | |
| 43 return; | |
| 44 } | |
| 45 | |
| 46 frames_from_callback_.insert( | |
| 47 std::make_pair(std::make_pair(pid, sidx), std::move(frame))); | |
| 48 } | |
| 49 | |
| 50 void TearDown() override { | |
| 51 // All frame objects must be destroyed before the packet buffer since | |
| 52 // a frame object will try to remove itself from the packet buffer | |
| 53 // upon destruction. | |
| 54 frames_from_callback_.clear(); | |
| 55 } | |
| 56 | |
| 57 // Short version of true and false. | |
| 58 enum { | |
| 59 kT = true, | |
| 60 kF = false | |
| 61 }; | |
| 62 | |
| 63 // Insert a generic packet into the packet buffer. | |
| 64 void InsertGeneric(uint16_t seq_num, // packet sequence number | |
| 65 bool keyframe, // is keyframe | |
| 66 bool first, // is first packet of frame | |
| 67 bool last, // is last packet of frame | |
| 68 size_t data_size = 0, // size of data | |
| 69 uint8_t* data = nullptr) { // data pointer | |
| 70 VCMPacket packet; | |
| 71 packet.codec = kVideoCodecGeneric; | |
| 72 packet.seqNum = seq_num; | |
| 73 packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta; | |
| 74 packet.isFirstPacket = first; | |
| 75 packet.markerBit = last; | |
| 76 packet.sizeBytes = data_size; | |
| 77 packet.dataPtr = data; | |
| 78 | |
| 79 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 80 } | |
| 81 | |
| 82 // Insert a Vp8 packet into the packet buffer. | |
| 83 void InsertVp8(uint16_t seq_num, // packet sequence number | |
| 84 bool keyframe, // is keyframe | |
| 85 bool first, // is first packet of frame | |
| 86 bool last, // is last packet of frame | |
| 87 bool sync = false, // is sync frame | |
| 88 int32_t pid = kNoPictureId, // picture id | |
| 89 uint8_t tid = kNoTemporalIdx, // temporal id | |
| 90 int32_t tl0 = kNoTl0PicIdx, // tl0 pic index | |
| 91 size_t data_size = 0, // size of data | |
| 92 uint8_t* data = nullptr) { // data pointer | |
| 93 VCMPacket packet; | |
| 94 packet.codec = kVideoCodecVP8; | |
| 95 packet.seqNum = seq_num; | |
| 96 packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta; | |
| 97 packet.isFirstPacket = first; | |
| 98 packet.markerBit = last; | |
| 99 packet.sizeBytes = data_size; | |
| 100 packet.dataPtr = data; | |
| 101 packet.video_header.codecHeader.VP8.pictureId = pid % (1 << 15); | |
| 102 packet.video_header.codecHeader.VP8.temporalIdx = tid; | |
| 103 packet.video_header.codecHeader.VP8.tl0PicIdx = tl0; | |
| 104 packet.video_header.codecHeader.VP8.layerSync = sync; | |
| 105 | |
| 106 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 107 } | |
| 108 | |
| 109 // Insert a Vp9 packet into the packet buffer. | |
| 110 void InsertVp9Gof(uint16_t seq_num, // packet sequence number | |
| 111 bool keyframe, // is keyframe | |
| 112 bool first, // is first packet of frame | |
| 113 bool last, // is last packet of frame | |
| 114 bool up = false, // frame is up-switch point | |
| 115 int32_t pid = kNoPictureId, // picture id | |
| 116 uint8_t sid = kNoSpatialIdx, // spatial id | |
| 117 uint8_t tid = kNoTemporalIdx, // temporal id | |
| 118 int32_t tl0 = kNoTl0PicIdx, // tl0 pic index | |
| 119 GofInfoVP9* ss = nullptr, // scalability structure | |
| 120 size_t data_size = 0, // size of data | |
| 121 uint8_t* data = nullptr) { // data pointer | |
| 122 VCMPacket packet; | |
| 123 packet.codec = kVideoCodecVP9; | |
| 124 packet.seqNum = seq_num; | |
| 125 packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta; | |
| 126 packet.isFirstPacket = first; | |
| 127 packet.markerBit = last; | |
| 128 packet.sizeBytes = data_size; | |
| 129 packet.dataPtr = data; | |
| 130 packet.video_header.codecHeader.VP9.flexible_mode = false; | |
| 131 packet.video_header.codecHeader.VP9.picture_id = pid % (1 << 15); | |
| 132 packet.video_header.codecHeader.VP9.temporal_idx = tid; | |
| 133 packet.video_header.codecHeader.VP9.spatial_idx = sid; | |
| 134 packet.video_header.codecHeader.VP9.tl0_pic_idx = tl0; | |
| 135 packet.video_header.codecHeader.VP9.temporal_up_switch = up; | |
| 136 if (ss != nullptr) { | |
| 137 packet.video_header.codecHeader.VP9.ss_data_available = true; | |
| 138 packet.video_header.codecHeader.VP9.gof = *ss; | |
| 139 } | |
| 140 | |
| 141 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 142 } | |
| 143 | |
| 144 // Insert a Vp9 packet into the packet buffer. | |
| 145 void InsertVp9Flex(uint16_t seq_num, // packet sequence number | |
| 146 bool keyframe, // is keyframe | |
| 147 bool first, // is first packet of frame | |
| 148 bool last, // is last packet of frame | |
| 149 bool inter, // depends on S-1 layer | |
| 150 int32_t pid = kNoPictureId, // picture id | |
| 151 uint8_t sid = kNoSpatialIdx, // spatial id | |
| 152 uint8_t tid = kNoTemporalIdx, // temporal id | |
| 153 int32_t tl0 = kNoTl0PicIdx, // tl0 pic index | |
| 154 std::vector<uint8_t> refs = | |
| 155 std::vector<uint8_t>(), // frame references | |
| 156 size_t data_size = 0, // size of data | |
| 157 uint8_t* data = nullptr) { // data pointer | |
| 158 VCMPacket packet; | |
| 159 packet.codec = kVideoCodecVP9; | |
| 160 packet.seqNum = seq_num; | |
| 161 packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta; | |
| 162 packet.isFirstPacket = first; | |
| 163 packet.markerBit = last; | |
| 164 packet.sizeBytes = data_size; | |
| 165 packet.dataPtr = data; | |
| 166 packet.video_header.codecHeader.VP9.inter_layer_predicted = inter; | |
| 167 packet.video_header.codecHeader.VP9.flexible_mode = true; | |
| 168 packet.video_header.codecHeader.VP9.picture_id = pid % (1 << 15); | |
| 169 packet.video_header.codecHeader.VP9.temporal_idx = tid; | |
| 170 packet.video_header.codecHeader.VP9.spatial_idx = sid; | |
| 171 packet.video_header.codecHeader.VP9.tl0_pic_idx = tl0; | |
| 172 packet.video_header.codecHeader.VP9.num_ref_pics = refs.size(); | |
| 173 for (size_t i = 0; i < refs.size(); ++i) | |
| 174 packet.video_header.codecHeader.VP9.pid_diff[i] = refs[i]; | |
| 175 | |
| 176 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 177 } | |
| 178 | |
| 179 // Check if a frame with picture id |pid| and spatial index |sidx| has been | |
| 180 // delivered from the packet buffer, and if so, if it has the references | |
| 181 // specified by |refs|. | |
| 182 template <typename... T> | |
| 183 void CheckReferences(uint16_t pid, uint16_t sidx, T... refs) const { | |
| 184 auto frame_it = frames_from_callback_.find(std::make_pair(pid, sidx)); | |
| 185 if (frame_it == frames_from_callback_.end()) { | |
| 186 ADD_FAILURE() << "Could not find frame with (pid:sidx): (" | |
| 187 << pid << ":" << sidx << ")"; | |
| 188 return; | |
| 189 } | |
| 190 | |
| 191 std::set<uint16_t> actual_refs; | |
| 192 for (uint8_t r = 0; r < frame_it->second->num_references; ++r) { | |
| 193 actual_refs.insert(frame_it->second->references[r]); | |
| 194 } | |
| 195 | |
| 196 std::set<uint16_t> expected_refs; | |
| 197 RefsToSet(&expected_refs, refs...); | |
| 198 | |
| 199 ASSERT_EQ(expected_refs, actual_refs); | |
| 200 } | |
| 201 | |
| 202 template <typename... T> | |
| 203 void CheckReferencesGeneric(uint16_t pid, T... refs) const { | |
| 204 CheckReferences(pid, 0, refs...); | |
| 205 } | |
| 206 | |
| 207 template <typename... T> | |
| 208 void CheckReferencesVp8(uint16_t pid, T... refs) const { | |
| 209 CheckReferences(pid, 0, refs...); | |
| 210 } | |
| 211 | |
| 212 template <typename... T> | |
| 213 void CheckReferencesVp9(uint16_t pid, uint8_t sidx, T... refs) const { | |
| 214 CheckReferences(pid, sidx, refs...); | |
| 215 } | |
| 216 | |
| 217 template <typename... T> | |
| 218 void RefsToSet(std::set<uint16_t>* m, uint16_t ref, T... refs) const { | |
| 219 m->insert(ref); | |
| 220 RefsToSet(m, refs...); | |
| 221 } | |
| 222 | |
| 223 void RefsToSet(std::set<uint16_t>* m) const {} | |
| 224 | |
| 225 const int kStartSize = 16; | |
| 226 const int kMaxSize = 64; | |
| 227 | |
| 228 Random rand_; | |
| 229 std::unique_ptr<PacketBuffer> packet_buffer_; | |
| 230 struct FrameComp { | |
| 231 bool operator()(const std::pair<uint16_t, uint8_t> f1, | |
| 232 const std::pair<uint16_t, uint8_t> f2) const { | |
| 233 if (f1.first == f2.first) | |
| 234 return f1.second < f2.second; | |
| 235 return f1.first < f2.first; | |
| 236 } | |
| 237 }; | |
| 238 std::map<std::pair<uint16_t, uint8_t>, | |
| 239 std::unique_ptr<FrameObject>, | |
| 240 FrameComp> frames_from_callback_; | |
| 241 }; | |
| 242 | |
| 243 TEST_F(TestPacketBuffer, InsertOnePacket) { | |
| 244 VCMPacket packet; | |
| 245 packet.seqNum = Rand(); | |
| 246 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 247 } | |
| 248 | |
| 249 TEST_F(TestPacketBuffer, InsertMultiplePackets) { | |
| 250 VCMPacket packet; | |
| 251 packet.seqNum = Rand(); | |
| 252 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 253 ++packet.seqNum; | |
| 254 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 255 ++packet.seqNum; | |
| 256 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 257 } | |
| 258 | |
| 259 TEST_F(TestPacketBuffer, InsertDuplicatePacket) { | |
| 260 VCMPacket packet; | |
| 261 packet.seqNum = Rand(); | |
| 262 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 263 ++packet.seqNum; | |
| 264 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 265 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 266 } | |
| 267 | |
| 268 TEST_F(TestPacketBuffer, NackCount) { | |
| 269 uint16_t seq_num = Rand(); | |
| 270 | |
| 271 VCMPacket packet; | |
| 272 packet.codec = kVideoCodecGeneric; | |
| 273 packet.seqNum = seq_num; | |
| 274 packet.frameType = kVideoFrameKey; | |
| 275 packet.isFirstPacket = true; | |
| 276 packet.markerBit = false; | |
| 277 packet.sizeBytes = 0; | |
| 278 packet.dataPtr = nullptr; | |
| 279 packet.timesNacked = 0; | |
| 280 | |
| 281 packet_buffer_->InsertPacket(packet); | |
| 282 | |
| 283 packet.seqNum++; | |
| 284 packet.isFirstPacket = false; | |
| 285 packet.timesNacked = 1; | |
| 286 packet_buffer_->InsertPacket(packet); | |
| 287 | |
| 288 packet.seqNum++; | |
| 289 packet.timesNacked = 3; | |
| 290 packet_buffer_->InsertPacket(packet); | |
| 291 | |
| 292 packet.seqNum++; | |
| 293 packet.markerBit = true; | |
| 294 packet.timesNacked = 1; | |
| 295 packet_buffer_->InsertPacket(packet); | |
| 296 | |
| 297 | |
| 298 ASSERT_EQ(1UL, frames_from_callback_.size()); | |
| 299 FrameObject* frame = frames_from_callback_.begin()->second.get(); | |
| 300 RtpFrameObject* rtp_frame = static_cast<RtpFrameObject*>(frame); | |
| 301 EXPECT_EQ(3, rtp_frame->times_nacked()); | |
| 302 } | |
| 303 | |
| 304 TEST_F(TestPacketBuffer, FrameSize) { | |
| 305 uint16_t seq_num = Rand(); | |
| 306 uint8_t data[] = {1, 2, 3, 4, 5}; | |
| 307 | |
| 308 // seq_num , kf, frst, lst, size, data | |
| 309 InsertGeneric(seq_num , kT, kT , kF , 5 , data); | |
| 310 InsertGeneric(seq_num + 1, kT, kF , kF , 5 , data); | |
| 311 InsertGeneric(seq_num + 2, kT, kF , kF , 5 , data); | |
| 312 InsertGeneric(seq_num + 3, kT, kF , kT , 5 , data); | |
| 313 | |
| 314 ASSERT_EQ(1UL, frames_from_callback_.size()); | |
| 315 EXPECT_EQ(20UL, frames_from_callback_.begin()->second->size); | |
| 316 } | |
| 317 | |
| 318 TEST_F(TestPacketBuffer, ExpandBuffer) { | |
| 319 uint16_t seq_num = Rand(); | |
| 320 | |
| 321 for (int i = 0; i < kStartSize + 1; ++i) { | |
| 322 // seq_num , kf, frst, lst | |
| 323 InsertGeneric(seq_num + i, kT, kT , kT); | |
| 324 } | |
| 325 } | |
| 326 | |
| 327 TEST_F(TestPacketBuffer, ExpandBufferOverflow) { | |
| 328 uint16_t seq_num = Rand(); | |
| 329 | |
| 330 for (int i = 0; i < kMaxSize; ++i) { | |
| 331 // seq_num , kf, frst, lst | |
| 332 InsertGeneric(seq_num + i, kT, kT , kT); | |
| 333 } | |
| 334 | |
| 335 VCMPacket packet; | |
| 336 packet.seqNum = seq_num + kMaxSize + 1; | |
| 337 packet.sizeBytes = 1; | |
| 338 EXPECT_FALSE(packet_buffer_->InsertPacket(packet)); | |
| 339 } | |
| 340 | |
| 341 TEST_F(TestPacketBuffer, GenericOnePacketOneFrame) { | |
| 342 // seq_num, kf, frst, lst | |
| 343 InsertGeneric(Rand() , kT, kT , kT); | |
| 344 ASSERT_EQ(1UL, frames_from_callback_.size()); | |
| 345 } | |
| 346 | |
| 347 TEST_F(TestPacketBuffer, GenericTwoPacketsTwoFrames) { | |
| 348 uint16_t seq_num = Rand(); | |
| 349 | |
| 350 // seq_num , kf, frst, lst | |
| 351 InsertGeneric(seq_num , kT, kT , kT); | |
| 352 InsertGeneric(seq_num + 1, kT, kT , kT); | |
| 353 | |
| 354 EXPECT_EQ(2UL, frames_from_callback_.size()); | |
| 355 } | |
| 356 | |
| 357 TEST_F(TestPacketBuffer, GenericTwoPacketsOneFrames) { | |
| 358 uint16_t seq_num = Rand(); | |
| 359 | |
| 360 // seq_num , kf, frst, lst | |
| 361 InsertGeneric(seq_num , kT, kT , kF); | |
| 362 InsertGeneric(seq_num + 1, kT, kF , kT); | |
| 363 | |
| 364 EXPECT_EQ(1UL, frames_from_callback_.size()); | |
| 365 } | |
| 366 | |
| 367 TEST_F(TestPacketBuffer, GenericThreePacketReorderingOneFrame) { | |
| 368 uint16_t seq_num = Rand(); | |
| 369 | |
| 370 // seq_num , kf, frst, lst | |
| 371 InsertGeneric(seq_num , kT, kT , kF); | |
| 372 InsertGeneric(seq_num + 2, kT, kF , kT); | |
| 373 InsertGeneric(seq_num + 1, kT, kF , kF); | |
| 374 | |
| 375 EXPECT_EQ(1UL, frames_from_callback_.size()); | |
| 376 } | |
| 377 | |
| 378 TEST_F(TestPacketBuffer, DiscardOldPacket) { | |
| 379 uint16_t seq_num = Rand(); | |
| 380 VCMPacket packet; | |
| 381 packet.seqNum = Rand(); | |
| 382 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 383 packet.seqNum += 2; | |
| 384 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 385 | |
| 386 for (int i = 3; i < kMaxSize; ++i) { | |
| 387 ++packet.seqNum; | |
| 388 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 389 } | |
| 390 | |
| 391 ++packet.seqNum; | |
| 392 EXPECT_FALSE(packet_buffer_->InsertPacket(packet)); | |
| 393 packet_buffer_->ClearTo(seq_num + 1); | |
| 394 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 395 } | |
| 396 | |
| 397 TEST_F(TestPacketBuffer, DiscardMultipleOldPackets) { | |
| 398 uint16_t seq_num = Rand(); | |
| 399 VCMPacket packet; | |
| 400 packet.seqNum = seq_num; | |
| 401 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 402 packet.seqNum += 2; | |
| 403 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 404 | |
| 405 for (int i = 3; i < kMaxSize; ++i) { | |
| 406 ++packet.seqNum; | |
| 407 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 408 } | |
| 409 | |
| 410 packet_buffer_->ClearTo(seq_num + 15); | |
| 411 for (int i = 0; i < 15; ++i) { | |
| 412 ++packet.seqNum; | |
| 413 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 414 } | |
| 415 for (int i = 15; i < kMaxSize; ++i) { | |
| 416 ++packet.seqNum; | |
| 417 EXPECT_FALSE(packet_buffer_->InsertPacket(packet)); | |
| 418 } | |
| 419 } | |
| 420 | |
| 421 TEST_F(TestPacketBuffer, GenericFrames) { | |
| 422 uint16_t seq_num = Rand(); | |
| 423 | |
| 424 // seq_num , keyf , first, last | |
| 425 InsertGeneric(seq_num , true , true , true); | |
| 426 InsertGeneric(seq_num + 1, false, true , true); | |
| 427 InsertGeneric(seq_num + 2, false, true , true); | |
| 428 InsertGeneric(seq_num + 3, false, true , true); | |
| 429 | |
| 430 ASSERT_EQ(4UL, frames_from_callback_.size()); | |
| 431 CheckReferencesGeneric(seq_num); | |
| 432 CheckReferencesGeneric(seq_num + 1, seq_num); | |
| 433 CheckReferencesGeneric(seq_num + 2, seq_num + 1); | |
| 434 CheckReferencesGeneric(seq_num + 3, seq_num + 2); | |
| 435 } | |
| 436 | |
| 437 TEST_F(TestPacketBuffer, GenericFramesReordered) { | |
| 438 uint16_t seq_num = Rand(); | |
| 439 | |
| 440 // seq_num , keyf , first, last | |
| 441 InsertGeneric(seq_num + 1, false, true , true); | |
| 442 InsertGeneric(seq_num , true , true , true); | |
| 443 InsertGeneric(seq_num + 3, false, true , true); | |
| 444 InsertGeneric(seq_num + 2, false, true , true); | |
| 445 | |
| 446 ASSERT_EQ(4UL, frames_from_callback_.size()); | |
| 447 CheckReferencesGeneric(seq_num); | |
| 448 CheckReferencesGeneric(seq_num + 1, seq_num); | |
| 449 CheckReferencesGeneric(seq_num + 2, seq_num + 1); | |
| 450 CheckReferencesGeneric(seq_num + 3, seq_num + 2); | |
| 451 } | |
| 452 | |
| 453 TEST_F(TestPacketBuffer, GetBitstreamFromFrame) { | |
| 454 // "many bitstream, such data" with null termination. | |
| 455 uint8_t many[] = {0x6d, 0x61, 0x6e, 0x79, 0x20}; | |
| 456 uint8_t bitstream[] = {0x62, 0x69, 0x74, 0x73, 0x74, 0x72, | |
| 457 0x65, 0x61, 0x6d, 0x2c, 0x20}; | |
| 458 uint8_t such[] = {0x73, 0x75, 0x63, 0x68, 0x20}; | |
| 459 uint8_t data[] = {0x64, 0x61, 0x74, 0x61, 0x0}; | |
| 460 uint8_t | |
| 461 result[sizeof(many) + sizeof(bitstream) + sizeof(such) + sizeof(data)]; | |
| 462 | |
| 463 uint16_t seq_num = Rand(); | |
| 464 | |
| 465 // seq_num , kf, frst, lst, data_size , data | |
| 466 InsertGeneric(seq_num , kT, kT , kF , sizeof(many) , many); | |
| 467 InsertGeneric(seq_num + 1, kF, kF , kF , sizeof(bitstream), bitstream); | |
| 468 InsertGeneric(seq_num + 2, kF, kF , kF , sizeof(such) , such); | |
| 469 InsertGeneric(seq_num + 3, kF, kF , kT , sizeof(data) , data); | |
| 470 | |
| 471 ASSERT_EQ(1UL, frames_from_callback_.size()); | |
| 472 CheckReferencesVp8(seq_num + 3); | |
| 473 EXPECT_TRUE(frames_from_callback_[std::make_pair(seq_num + 3, 0)]-> | |
| 474 GetBitstream(result)); | |
| 475 EXPECT_EQ(std::strcmp("many bitstream, such data", | |
| 476 reinterpret_cast<char*>(result)), | |
| 477 0); | |
| 478 } | |
| 479 | |
| 480 TEST_F(TestPacketBuffer, FreeSlotsOnFrameDestruction) { | |
| 481 uint16_t seq_num = Rand(); | |
| 482 | |
| 483 // seq_num , kf, frst, lst | |
| 484 InsertGeneric(seq_num , kT, kT , kF); | |
| 485 InsertGeneric(seq_num + 1, kF, kF , kF); | |
| 486 InsertGeneric(seq_num + 2, kF, kF , kT); | |
| 487 EXPECT_EQ(1UL, frames_from_callback_.size()); | |
| 488 | |
| 489 frames_from_callback_.clear(); | |
| 490 | |
| 491 // seq_num , kf, frst, lst | |
| 492 InsertGeneric(seq_num , kT, kT , kF); | |
| 493 InsertGeneric(seq_num + 1, kF, kF , kF); | |
| 494 InsertGeneric(seq_num + 2, kF, kF , kT); | |
| 495 EXPECT_EQ(1UL, frames_from_callback_.size()); | |
| 496 } | |
| 497 | |
| 498 TEST_F(TestPacketBuffer, Clear) { | |
| 499 uint16_t seq_num = Rand(); | |
| 500 | |
| 501 // seq_num , kf, frst, lst | |
| 502 InsertGeneric(seq_num , kT, kT , kF); | |
| 503 InsertGeneric(seq_num + 1, kF, kF , kF); | |
| 504 InsertGeneric(seq_num + 2, kF, kF , kT); | |
| 505 EXPECT_EQ(1UL, frames_from_callback_.size()); | |
| 506 | |
| 507 packet_buffer_->Clear(); | |
| 508 | |
| 509 // seq_num , kf, frst, lst | |
| 510 InsertGeneric(seq_num + kStartSize , kT, kT , kF); | |
| 511 InsertGeneric(seq_num + kStartSize + 1, kF, kF , kF); | |
| 512 InsertGeneric(seq_num + kStartSize + 2, kF, kF , kT); | |
| 513 EXPECT_EQ(2UL, frames_from_callback_.size()); | |
| 514 } | |
| 515 | |
| 516 TEST_F(TestPacketBuffer, InvalidateFrameByClearing) { | |
| 517 VCMPacket packet; | |
| 518 packet.codec = kVideoCodecGeneric; | |
| 519 packet.frameType = kVideoFrameKey; | |
| 520 packet.isFirstPacket = kT; | |
| 521 packet.markerBit = kT; | |
| 522 packet.seqNum = Rand(); | |
| 523 EXPECT_TRUE(packet_buffer_->InsertPacket(packet)); | |
| 524 ASSERT_EQ(1UL, frames_from_callback_.size()); | |
| 525 | |
| 526 packet_buffer_->Clear(); | |
| 527 EXPECT_FALSE(frames_from_callback_.begin()->second->GetBitstream(nullptr)); | |
| 528 } | |
| 529 | |
| 530 TEST_F(TestPacketBuffer, Vp8NoPictureId) { | |
| 531 uint16_t seq_num = Rand(); | |
| 532 | |
| 533 // seq_num , kf, frst, lst | |
| 534 InsertVp8(seq_num , kT, kT , kF); | |
| 535 InsertVp8(seq_num + 1 , kF, kF , kF); | |
| 536 InsertVp8(seq_num + 2 , kF, kF , kT); | |
| 537 ASSERT_EQ(1UL, frames_from_callback_.size()); | |
| 538 | |
| 539 InsertVp8(seq_num + 3 , kF, kT , kF); | |
| 540 InsertVp8(seq_num + 4 , kF, kF , kT); | |
| 541 ASSERT_EQ(2UL, frames_from_callback_.size()); | |
| 542 | |
| 543 InsertVp8(seq_num + 5 , kF, kT , kF); | |
| 544 InsertVp8(seq_num + 6 , kF, kF , kF); | |
| 545 InsertVp8(seq_num + 7 , kF, kF , kF); | |
| 546 InsertVp8(seq_num + 8 , kF, kF , kT); | |
| 547 ASSERT_EQ(3UL, frames_from_callback_.size()); | |
| 548 | |
| 549 InsertVp8(seq_num + 9 , kF, kT , kT); | |
| 550 ASSERT_EQ(4UL, frames_from_callback_.size()); | |
| 551 | |
| 552 InsertVp8(seq_num + 10, kF, kT , kF); | |
| 553 InsertVp8(seq_num + 11, kF, kF , kT); | |
| 554 ASSERT_EQ(5UL, frames_from_callback_.size()); | |
| 555 | |
| 556 InsertVp8(seq_num + 12, kT, kT , kT); | |
| 557 ASSERT_EQ(6UL, frames_from_callback_.size()); | |
| 558 | |
| 559 InsertVp8(seq_num + 13, kF, kT , kF); | |
| 560 InsertVp8(seq_num + 14, kF, kF , kF); | |
| 561 InsertVp8(seq_num + 15, kF, kF , kF); | |
| 562 InsertVp8(seq_num + 16, kF, kF , kF); | |
| 563 InsertVp8(seq_num + 17, kF, kF , kT); | |
| 564 ASSERT_EQ(7UL, frames_from_callback_.size()); | |
| 565 | |
| 566 InsertVp8(seq_num + 18, kF, kT , kT); | |
| 567 ASSERT_EQ(8UL, frames_from_callback_.size()); | |
| 568 | |
| 569 InsertVp8(seq_num + 19, kF, kT , kF); | |
| 570 InsertVp8(seq_num + 20, kF, kF , kT); | |
| 571 ASSERT_EQ(9UL, frames_from_callback_.size()); | |
| 572 | |
| 573 InsertVp8(seq_num + 21, kF, kT , kT); | |
| 574 | |
| 575 ASSERT_EQ(10UL, frames_from_callback_.size()); | |
| 576 CheckReferencesVp8(seq_num + 2); | |
| 577 CheckReferencesVp8(seq_num + 4, seq_num + 2); | |
| 578 CheckReferencesVp8(seq_num + 8, seq_num + 4); | |
| 579 CheckReferencesVp8(seq_num + 9, seq_num + 8); | |
| 580 CheckReferencesVp8(seq_num + 11, seq_num + 9); | |
| 581 CheckReferencesVp8(seq_num + 12); | |
| 582 CheckReferencesVp8(seq_num + 17, seq_num + 12); | |
| 583 CheckReferencesVp8(seq_num + 18, seq_num + 17); | |
| 584 CheckReferencesVp8(seq_num + 20, seq_num + 18); | |
| 585 CheckReferencesVp8(seq_num + 21, seq_num + 20); | |
| 586 } | |
| 587 | |
| 588 TEST_F(TestPacketBuffer, Vp8NoPictureIdReordered) { | |
| 589 uint16_t seq_num = 0xfffa; | |
| 590 | |
| 591 // seq_num , kf, frst, lst | |
| 592 InsertVp8(seq_num + 1 , kF, kF , kF); | |
| 593 InsertVp8(seq_num , kT, kT , kF); | |
| 594 InsertVp8(seq_num + 2 , kF, kF , kT); | |
| 595 InsertVp8(seq_num + 4 , kF, kF , kT); | |
| 596 InsertVp8(seq_num + 6 , kF, kF , kF); | |
| 597 InsertVp8(seq_num + 3 , kF, kT , kF); | |
| 598 InsertVp8(seq_num + 7 , kF, kF , kF); | |
| 599 InsertVp8(seq_num + 5 , kF, kT , kF); | |
| 600 InsertVp8(seq_num + 9 , kF, kT , kT); | |
| 601 InsertVp8(seq_num + 10, kF, kT , kF); | |
| 602 InsertVp8(seq_num + 8 , kF, kF , kT); | |
| 603 InsertVp8(seq_num + 13, kF, kT , kF); | |
| 604 InsertVp8(seq_num + 14, kF, kF , kF); | |
| 605 InsertVp8(seq_num + 12, kT, kT , kT); | |
| 606 InsertVp8(seq_num + 11, kF, kF , kT); | |
| 607 InsertVp8(seq_num + 16, kF, kF , kF); | |
| 608 InsertVp8(seq_num + 19, kF, kT , kF); | |
| 609 InsertVp8(seq_num + 15, kF, kF , kF); | |
| 610 InsertVp8(seq_num + 17, kF, kF , kT); | |
| 611 InsertVp8(seq_num + 20, kF, kF , kT); | |
| 612 InsertVp8(seq_num + 21, kF, kT , kT); | |
| 613 InsertVp8(seq_num + 18, kF, kT , kT); | |
| 614 | |
| 615 ASSERT_EQ(10UL, frames_from_callback_.size()); | |
| 616 CheckReferencesVp8(seq_num + 2); | |
| 617 CheckReferencesVp8(seq_num + 4, seq_num + 2); | |
| 618 CheckReferencesVp8(seq_num + 8, seq_num + 4); | |
| 619 CheckReferencesVp8(seq_num + 9, seq_num + 8); | |
| 620 CheckReferencesVp8(seq_num + 11, seq_num + 9); | |
| 621 CheckReferencesVp8(seq_num + 12); | |
| 622 CheckReferencesVp8(seq_num + 17, seq_num + 12); | |
| 623 CheckReferencesVp8(seq_num + 18, seq_num + 17); | |
| 624 CheckReferencesVp8(seq_num + 20, seq_num + 18); | |
| 625 CheckReferencesVp8(seq_num + 21, seq_num + 20); | |
| 626 } | |
| 627 | |
| 628 | |
| 629 TEST_F(TestPacketBuffer, Vp8KeyFrameReferences) { | |
| 630 uint16_t pid = Rand(); | |
| 631 // seq_num, kf, frst, lst, sync, pid, tid, tl0 | |
| 632 InsertVp8(Rand() , kT, kT , kT , kF , pid, 0 , 0); | |
| 633 | |
| 634 ASSERT_EQ(1UL, frames_from_callback_.size()); | |
| 635 CheckReferencesVp8(pid); | |
| 636 } | |
| 637 | |
| 638 // Test with 1 temporal layer. | |
| 639 TEST_F(TestPacketBuffer, Vp8TemporalLayers_0) { | |
| 640 uint16_t pid = Rand(); | |
| 641 uint16_t seq_num = Rand(); | |
| 642 | |
| 643 // seq_num , kf, frst, lst, sync, pid , tid, tl0 | |
| 644 InsertVp8(seq_num , kT, kT , kT , kF , pid , 0 , 1); | |
| 645 InsertVp8(seq_num + 1, kF, kT , kT , kF , pid + 1, 0 , 2); | |
| 646 InsertVp8(seq_num + 2, kF, kT , kT , kF , pid + 2, 0 , 3); | |
| 647 InsertVp8(seq_num + 3, kF, kT , kT , kF , pid + 3, 0 , 4); | |
| 648 | |
| 649 ASSERT_EQ(4UL, frames_from_callback_.size()); | |
| 650 CheckReferencesVp8(pid); | |
| 651 CheckReferencesVp8(pid + 1, pid); | |
| 652 CheckReferencesVp8(pid + 2, pid + 1); | |
| 653 CheckReferencesVp8(pid + 3, pid + 2); | |
| 654 } | |
| 655 | |
| 656 // Test with 1 temporal layer. | |
| 657 TEST_F(TestPacketBuffer, Vp8TemporalLayersReordering_0) { | |
| 658 uint16_t pid = Rand(); | |
| 659 uint16_t seq_num = Rand(); | |
| 660 | |
| 661 // seq_num , kf, frst, lst, sync, pid , tid, tl0 | |
| 662 InsertVp8(seq_num , kT, kT , kT , kF , pid , 0 , 1); | |
| 663 InsertVp8(seq_num + 1, kF, kT , kT , kF , pid + 1, 0 , 2); | |
| 664 InsertVp8(seq_num + 3, kF, kT , kT , kF , pid + 3, 0 , 4); | |
| 665 InsertVp8(seq_num + 2, kF, kT , kT , kF , pid + 2, 0 , 3); | |
| 666 InsertVp8(seq_num + 5, kF, kT , kT , kF , pid + 5, 0 , 6); | |
| 667 InsertVp8(seq_num + 6, kF, kT , kT , kF , pid + 6, 0 , 7); | |
| 668 InsertVp8(seq_num + 4, kF, kT , kT , kF , pid + 4, 0 , 5); | |
| 669 | |
| 670 ASSERT_EQ(7UL, frames_from_callback_.size()); | |
| 671 CheckReferencesVp8(pid); | |
| 672 CheckReferencesVp8(pid + 1, pid); | |
| 673 CheckReferencesVp8(pid + 2, pid + 1); | |
| 674 CheckReferencesVp8(pid + 3, pid + 2); | |
| 675 CheckReferencesVp8(pid + 4, pid + 3); | |
| 676 CheckReferencesVp8(pid + 5, pid + 4); | |
| 677 CheckReferencesVp8(pid + 6, pid + 5); | |
| 678 } | |
| 679 | |
| 680 // Test with 2 temporal layers in a 01 pattern. | |
| 681 TEST_F(TestPacketBuffer, Vp8TemporalLayers_01) { | |
| 682 uint16_t pid = Rand(); | |
| 683 uint16_t seq_num = Rand(); | |
| 684 | |
| 685 // seq_num , kf, frst, lst, sync, pid , tid, tl0 | |
| 686 InsertVp8(seq_num , kT, kT , kT , kF , pid , 0, 255); | |
| 687 InsertVp8(seq_num + 1, kF, kT , kT , kT , pid + 1, 1, 255); | |
| 688 InsertVp8(seq_num + 2, kF, kT , kT , kF , pid + 2, 0, 0); | |
| 689 InsertVp8(seq_num + 3, kF, kT , kT , kF , pid + 3, 1, 0); | |
| 690 | |
| 691 ASSERT_EQ(4UL, frames_from_callback_.size()); | |
| 692 CheckReferencesVp8(pid); | |
| 693 CheckReferencesVp8(pid + 1, pid); | |
| 694 CheckReferencesVp8(pid + 2, pid); | |
| 695 CheckReferencesVp8(pid + 3, pid + 1, pid + 2); | |
| 696 } | |
| 697 | |
| 698 // Test with 2 temporal layers in a 01 pattern. | |
| 699 TEST_F(TestPacketBuffer, Vp8TemporalLayersReordering_01) { | |
| 700 uint16_t pid = Rand(); | |
| 701 uint16_t seq_num = Rand(); | |
| 702 | |
| 703 // seq_num , kf, frst, lst, sync, pid , tid, tl0 | |
| 704 InsertVp8(seq_num + 1, kF, kT , kT , kT , pid + 1, 1 , 255); | |
| 705 InsertVp8(seq_num , kT, kT , kT , kF , pid , 0 , 255); | |
| 706 InsertVp8(seq_num + 3, kF, kT , kT , kF , pid + 3, 1 , 0); | |
| 707 InsertVp8(seq_num + 5, kF, kT , kT , kF , pid + 5, 1 , 1); | |
| 708 InsertVp8(seq_num + 2, kF, kT , kT , kF , pid + 2, 0 , 0); | |
| 709 InsertVp8(seq_num + 4, kF, kT , kT , kF , pid + 4, 0 , 1); | |
| 710 InsertVp8(seq_num + 6, kF, kT , kT , kF , pid + 6, 0 , 2); | |
| 711 InsertVp8(seq_num + 7, kF, kT , kT , kF , pid + 7, 1 , 2); | |
| 712 | |
| 713 ASSERT_EQ(8UL, frames_from_callback_.size()); | |
| 714 CheckReferencesVp8(pid); | |
| 715 CheckReferencesVp8(pid + 1, pid); | |
| 716 CheckReferencesVp8(pid + 2, pid); | |
| 717 CheckReferencesVp8(pid + 3, pid + 1, pid + 2); | |
| 718 CheckReferencesVp8(pid + 4, pid + 2); | |
| 719 CheckReferencesVp8(pid + 5, pid + 3, pid + 4); | |
| 720 CheckReferencesVp8(pid + 6, pid + 4); | |
| 721 CheckReferencesVp8(pid + 7, pid + 5, pid + 6); | |
| 722 } | |
| 723 | |
| 724 // Test with 3 temporal layers in a 0212 pattern. | |
| 725 TEST_F(TestPacketBuffer, Vp8TemporalLayers_0212) { | |
| 726 uint16_t pid = Rand(); | |
| 727 uint16_t seq_num = Rand(); | |
| 728 | |
| 729 // seq_num , kf, frst, lst, sync, pid , tid, tl0 | |
| 730 InsertVp8(seq_num , kT, kT , kT , kF , pid , 0 , 55); | |
| 731 InsertVp8(seq_num + 1 , kF, kT , kT , kT , pid + 1 , 2 , 55); | |
| 732 InsertVp8(seq_num + 2 , kF, kT , kT , kT , pid + 2 , 1 , 55); | |
| 733 InsertVp8(seq_num + 3 , kF, kT , kT , kF , pid + 3 , 2 , 55); | |
| 734 InsertVp8(seq_num + 4 , kF, kT , kT , kF , pid + 4 , 0 , 56); | |
| 735 InsertVp8(seq_num + 5 , kF, kT , kT , kF , pid + 5 , 2 , 56); | |
| 736 InsertVp8(seq_num + 6 , kF, kT , kT , kF , pid + 6 , 1 , 56); | |
| 737 InsertVp8(seq_num + 7 , kF, kT , kT , kF , pid + 7 , 2 , 56); | |
| 738 InsertVp8(seq_num + 8 , kF, kT , kT , kF , pid + 8 , 0 , 57); | |
| 739 InsertVp8(seq_num + 9 , kF, kT , kT , kT , pid + 9 , 2 , 57); | |
| 740 InsertVp8(seq_num + 10, kF, kT , kT , kT , pid + 10, 1 , 57); | |
| 741 InsertVp8(seq_num + 11, kF, kT , kT , kF , pid + 11, 2 , 57); | |
| 742 | |
| 743 ASSERT_EQ(12UL, frames_from_callback_.size()); | |
| 744 CheckReferencesVp8(pid); | |
| 745 CheckReferencesVp8(pid + 1 , pid); | |
| 746 CheckReferencesVp8(pid + 2 , pid); | |
| 747 CheckReferencesVp8(pid + 3 , pid, pid + 1, pid + 2); | |
| 748 CheckReferencesVp8(pid + 4 , pid); | |
| 749 CheckReferencesVp8(pid + 5 , pid + 2, pid + 3, pid + 4); | |
| 750 CheckReferencesVp8(pid + 6 , pid + 2, pid + 4); | |
| 751 CheckReferencesVp8(pid + 7 , pid + 4, pid + 5, pid + 6); | |
| 752 CheckReferencesVp8(pid + 8 , pid + 4); | |
| 753 CheckReferencesVp8(pid + 9 , pid + 8); | |
| 754 CheckReferencesVp8(pid + 10, pid + 8); | |
| 755 CheckReferencesVp8(pid + 11, pid + 8, pid + 9, pid + 10); | |
| 756 } | |
| 757 | |
| 758 // Test with 3 temporal layers in a 0212 pattern. | |
| 759 TEST_F(TestPacketBuffer, Vp8TemporalLayersReordering_0212) { | |
| 760 uint16_t pid = 126; | |
| 761 uint16_t seq_num = Rand(); | |
| 762 | |
| 763 // seq_num , kf, frst, lst, sync, pid , tid, tl0 | |
| 764 InsertVp8(seq_num + 1 , kF, kT , kT , kT , pid + 1 , 2 , 55); | |
| 765 InsertVp8(seq_num , kT, kT , kT , kF , pid , 0 , 55); | |
| 766 InsertVp8(seq_num + 2 , kF, kT , kT , kT , pid + 2 , 1 , 55); | |
| 767 InsertVp8(seq_num + 4 , kF, kT , kT , kF , pid + 4 , 0 , 56); | |
| 768 InsertVp8(seq_num + 5 , kF, kT , kT , kF , pid + 5 , 2 , 56); | |
| 769 InsertVp8(seq_num + 3 , kF, kT , kT , kF , pid + 3 , 2 , 55); | |
| 770 InsertVp8(seq_num + 7 , kF, kT , kT , kF , pid + 7 , 2 , 56); | |
| 771 InsertVp8(seq_num + 9 , kF, kT , kT , kT , pid + 9 , 2 , 57); | |
| 772 InsertVp8(seq_num + 6 , kF, kT , kT , kF , pid + 6 , 1 , 56); | |
| 773 InsertVp8(seq_num + 8 , kF, kT , kT , kF , pid + 8 , 0 , 57); | |
| 774 InsertVp8(seq_num + 11, kF, kT , kT , kF , pid + 11, 2 , 57); | |
| 775 InsertVp8(seq_num + 10, kF, kT , kT , kT , pid + 10, 1 , 57); | |
| 776 | |
| 777 ASSERT_EQ(12UL, frames_from_callback_.size()); | |
| 778 CheckReferencesVp8(pid); | |
| 779 CheckReferencesVp8(pid + 1 , pid); | |
| 780 CheckReferencesVp8(pid + 2 , pid); | |
| 781 CheckReferencesVp8(pid + 3 , pid, pid + 1, pid + 2); | |
| 782 CheckReferencesVp8(pid + 4 , pid); | |
| 783 CheckReferencesVp8(pid + 5 , pid + 2, pid + 3, pid + 4); | |
| 784 CheckReferencesVp8(pid + 6 , pid + 2, pid + 4); | |
| 785 CheckReferencesVp8(pid + 7 , pid + 4, pid + 5, pid + 6); | |
| 786 CheckReferencesVp8(pid + 8 , pid + 4); | |
| 787 CheckReferencesVp8(pid + 9 , pid + 8); | |
| 788 CheckReferencesVp8(pid + 10, pid + 8); | |
| 789 CheckReferencesVp8(pid + 11, pid + 8, pid + 9, pid + 10); | |
| 790 } | |
| 791 | |
| 792 TEST_F(TestPacketBuffer, Vp8InsertManyFrames_0212) { | |
| 793 uint16_t pid = Rand(); | |
| 794 uint16_t seq_num = Rand(); | |
| 795 | |
| 796 const int keyframes_to_insert = 50; | |
| 797 const int frames_per_keyframe = 120; // Should be a multiple of 4. | |
| 798 uint8_t tl0 = 128; | |
| 799 | |
| 800 for (int k = 0; k < keyframes_to_insert; ++k) { | |
| 801 // seq_num , keyf, frst, lst, sync, pid , tid, tl0 | |
| 802 InsertVp8(seq_num , kT , kT , kT , kF , pid , 0 , tl0); | |
| 803 InsertVp8(seq_num + 1, kF , kT , kT , kT , pid + 1, 2 , tl0); | |
| 804 InsertVp8(seq_num + 2, kF , kT , kT , kT , pid + 2, 1 , tl0); | |
| 805 InsertVp8(seq_num + 3, kF , kT , kT , kF , pid + 3, 2 , tl0); | |
| 806 CheckReferencesVp8(pid); | |
| 807 CheckReferencesVp8(pid + 1, pid); | |
| 808 CheckReferencesVp8(pid + 2, pid); | |
| 809 CheckReferencesVp8(pid + 3, pid, pid + 1, pid + 2); | |
| 810 frames_from_callback_.clear(); | |
| 811 ++tl0; | |
| 812 | |
| 813 for (int f = 4; f < frames_per_keyframe; f += 4) { | |
| 814 uint16_t sf = seq_num + f; | |
| 815 uint16_t pidf = pid + f; | |
| 816 | |
| 817 // seq_num, keyf, frst, lst, sync, pid , tid, tl0 | |
| 818 InsertVp8(sf , kF , kT , kT , kF , pidf , 0 , tl0); | |
| 819 InsertVp8(sf + 1 , kF , kT , kT , kF , pidf + 1, 2 , tl0); | |
| 820 InsertVp8(sf + 2 , kF , kT , kT , kF , pidf + 2, 1 , tl0); | |
| 821 InsertVp8(sf + 3 , kF , kT , kT , kF , pidf + 3, 2 , tl0); | |
| 822 CheckReferencesVp8(pidf, pidf - 4); | |
| 823 CheckReferencesVp8(pidf + 1, pidf, pidf - 1, pidf - 2); | |
| 824 CheckReferencesVp8(pidf + 2, pidf, pidf - 2); | |
| 825 CheckReferencesVp8(pidf + 3, pidf, pidf + 1, pidf + 2); | |
| 826 frames_from_callback_.clear(); | |
| 827 ++tl0; | |
| 828 } | |
| 829 | |
| 830 pid += frames_per_keyframe; | |
| 831 seq_num += frames_per_keyframe; | |
| 832 } | |
| 833 } | |
| 834 | |
| 835 TEST_F(TestPacketBuffer, Vp8LayerSync) { | |
| 836 uint16_t pid = Rand(); | |
| 837 uint16_t seq_num = Rand(); | |
| 838 | |
| 839 // seq_num , keyf, frst, lst, sync, pid , tid, tl0 | |
| 840 InsertVp8(seq_num , kT , kT , kT , kF , pid , 0 , 0); | |
| 841 InsertVp8(seq_num + 1 , kF , kT , kT , kT , pid + 1 , 1 , 0); | |
| 842 InsertVp8(seq_num + 2 , kF , kT , kT , kF , pid + 2 , 0 , 1); | |
| 843 ASSERT_EQ(3UL, frames_from_callback_.size()); | |
| 844 | |
| 845 InsertVp8(seq_num + 4 , kF , kT , kT , kF , pid + 4 , 0 , 2); | |
| 846 InsertVp8(seq_num + 5 , kF , kT , kT , kT , pid + 5 , 1 , 2); | |
| 847 InsertVp8(seq_num + 6 , kF , kT , kT , kF , pid + 6 , 0 , 3); | |
| 848 InsertVp8(seq_num + 7 , kF , kT , kT , kF , pid + 7 , 1 , 3); | |
| 849 | |
| 850 ASSERT_EQ(7UL, frames_from_callback_.size()); | |
| 851 CheckReferencesVp8(pid); | |
| 852 CheckReferencesVp8(pid + 1, pid); | |
| 853 CheckReferencesVp8(pid + 2, pid); | |
| 854 CheckReferencesVp8(pid + 4, pid + 2); | |
| 855 CheckReferencesVp8(pid + 5, pid + 4); | |
| 856 CheckReferencesVp8(pid + 6, pid + 4); | |
| 857 CheckReferencesVp8(pid + 7, pid + 6, pid + 5); | |
| 858 } | |
| 859 | |
| 860 TEST_F(TestPacketBuffer, Vp8InsertLargeFrames) { | |
| 861 packet_buffer_.reset(new PacketBuffer(1 << 3, 1 << 12, this)); | |
| 862 uint16_t pid = Rand(); | |
| 863 uint16_t seq_num = Rand(); | |
| 864 | |
| 865 const uint16_t packets_per_frame = 1000; | |
| 866 uint16_t current = seq_num; | |
| 867 uint16_t end = current + packets_per_frame; | |
| 868 | |
| 869 // seq_num , keyf, frst, lst, sync, pid, tid, tl0 | |
| 870 InsertVp8(current++, kT , kT , kF , kF , pid, 0 , 0); | |
| 871 while (current != end) | |
| 872 InsertVp8(current++, kF , kF , kF , kF , pid, 0 , 0); | |
| 873 InsertVp8(current++, kF , kF , kT , kF , pid, 0 , 0); | |
| 874 end = current + packets_per_frame; | |
| 875 | |
| 876 for (int f = 1; f < 4; ++f) { | |
| 877 InsertVp8(current++, kF , kT , kF , kF , pid + f, 0, f); | |
| 878 while (current != end) | |
| 879 InsertVp8(current++, kF , kF , kF , kF , pid + f, 0, f); | |
| 880 InsertVp8(current++, kF , kF , kT , kF , pid + f, 0, f); | |
| 881 end = current + packets_per_frame; | |
| 882 } | |
| 883 | |
| 884 ASSERT_EQ(4UL, frames_from_callback_.size()); | |
| 885 CheckReferencesVp8(pid); | |
| 886 CheckReferencesVp8(pid + 1, pid); | |
| 887 CheckReferencesVp8(pid + 2, pid + 1); | |
| 888 CheckReferencesVp8(pid + 3, pid + 2); | |
| 889 } | |
| 890 | |
| 891 TEST_F(TestPacketBuffer, Vp9GofInsertOneFrame) { | |
| 892 uint16_t pid = Rand(); | |
| 893 uint16_t seq_num = Rand(); | |
| 894 GofInfoVP9 ss; | |
| 895 ss.SetGofInfoVP9(kTemporalStructureMode1); | |
| 896 | |
| 897 // seq_num, keyf, frst, lst, up, pid, sid, tid, tl0, ss | |
| 898 InsertVp9Gof(seq_num, kT , kT , kT , kF, pid, 0 , 0 , 0 , &ss); | |
| 899 | |
| 900 CheckReferencesVp9(pid, 0); | |
| 901 } | |
| 902 | |
| 903 TEST_F(TestPacketBuffer, Vp9NoPictureIdReordered) { | |
| 904 uint16_t sn = 0xfffa; | |
| 905 | |
| 906 // sn , kf, frst, lst | |
| 907 InsertVp9Gof(sn + 1 , kF, kF , kF); | |
| 908 InsertVp9Gof(sn , kT, kT , kF); | |
| 909 InsertVp9Gof(sn + 2 , kF, kF , kT); | |
| 910 InsertVp9Gof(sn + 4 , kF, kF , kT); | |
| 911 InsertVp9Gof(sn + 6 , kF, kF , kF); | |
| 912 InsertVp9Gof(sn + 3 , kF, kT , kF); | |
| 913 InsertVp9Gof(sn + 7 , kF, kF , kF); | |
| 914 InsertVp9Gof(sn + 5 , kF, kT , kF); | |
| 915 InsertVp9Gof(sn + 9 , kF, kT , kT); | |
| 916 InsertVp9Gof(sn + 10, kF, kT , kF); | |
| 917 InsertVp9Gof(sn + 8 , kF, kF , kT); | |
| 918 InsertVp9Gof(sn + 13, kF, kT , kF); | |
| 919 InsertVp9Gof(sn + 14, kF, kF , kF); | |
| 920 InsertVp9Gof(sn + 12, kT, kT , kT); | |
| 921 InsertVp9Gof(sn + 11, kF, kF , kT); | |
| 922 InsertVp9Gof(sn + 16, kF, kF , kF); | |
| 923 InsertVp9Gof(sn + 19, kF, kT , kF); | |
| 924 InsertVp9Gof(sn + 15, kF, kF , kF); | |
| 925 InsertVp9Gof(sn + 17, kF, kF , kT); | |
| 926 InsertVp9Gof(sn + 20, kF, kF , kT); | |
| 927 InsertVp9Gof(sn + 21, kF, kT , kT); | |
| 928 InsertVp9Gof(sn + 18, kF, kT , kT); | |
| 929 | |
| 930 ASSERT_EQ(10UL, frames_from_callback_.size()); | |
| 931 CheckReferencesVp9(sn + 2 , 0); | |
| 932 CheckReferencesVp9(sn + 4 , 0, sn + 2); | |
| 933 CheckReferencesVp9(sn + 8 , 0, sn + 4); | |
| 934 CheckReferencesVp9(sn + 9 , 0, sn + 8); | |
| 935 CheckReferencesVp9(sn + 11, 0, sn + 9); | |
| 936 CheckReferencesVp9(sn + 12, 0); | |
| 937 CheckReferencesVp9(sn + 17, 0, sn + 12); | |
| 938 CheckReferencesVp9(sn + 18, 0, sn + 17); | |
| 939 CheckReferencesVp9(sn + 20, 0, sn + 18); | |
| 940 CheckReferencesVp9(sn + 21, 0, sn + 20); | |
| 941 } | |
| 942 | |
| 943 TEST_F(TestPacketBuffer, Vp9GofTemporalLayers_0) { | |
| 944 uint16_t pid = Rand(); | |
| 945 uint16_t sn = Rand(); | |
| 946 GofInfoVP9 ss; | |
| 947 ss.SetGofInfoVP9(kTemporalStructureMode1); // Only 1 spatial layer. | |
| 948 | |
| 949 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 950 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 951 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 0 , 1); | |
| 952 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 0 , 2); | |
| 953 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 0 , 3); | |
| 954 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 4); | |
| 955 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 0 , 5); | |
| 956 InsertVp9Gof(sn + 6 , kF, kT , kT , kF, pid + 6 , 0 , 0 , 6); | |
| 957 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 0 , 7); | |
| 958 InsertVp9Gof(sn + 8 , kF, kT , kT , kF, pid + 8 , 0 , 0 , 8); | |
| 959 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 0 , 9); | |
| 960 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 0 , 10); | |
| 961 InsertVp9Gof(sn + 11, kF, kT , kT , kF, pid + 11, 0 , 0 , 11); | |
| 962 InsertVp9Gof(sn + 12, kF, kT , kT , kF, pid + 12, 0 , 0 , 12); | |
| 963 InsertVp9Gof(sn + 13, kF, kT , kT , kF, pid + 13, 0 , 0 , 13); | |
| 964 InsertVp9Gof(sn + 14, kF, kT , kT , kF, pid + 14, 0 , 0 , 14); | |
| 965 InsertVp9Gof(sn + 15, kF, kT , kT , kF, pid + 15, 0 , 0 , 15); | |
| 966 InsertVp9Gof(sn + 16, kF, kT , kT , kF, pid + 16, 0 , 0 , 16); | |
| 967 InsertVp9Gof(sn + 17, kF, kT , kT , kF, pid + 17, 0 , 0 , 17); | |
| 968 InsertVp9Gof(sn + 18, kF, kT , kT , kF, pid + 18, 0 , 0 , 18); | |
| 969 InsertVp9Gof(sn + 19, kF, kT , kT , kF, pid + 19, 0 , 0 , 19); | |
| 970 | |
| 971 ASSERT_EQ(20UL, frames_from_callback_.size()); | |
| 972 CheckReferencesVp9(pid, 0); | |
| 973 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 974 CheckReferencesVp9(pid + 2 , 0, pid + 1); | |
| 975 CheckReferencesVp9(pid + 3 , 0, pid + 2); | |
| 976 CheckReferencesVp9(pid + 4 , 0, pid + 3); | |
| 977 CheckReferencesVp9(pid + 5 , 0, pid + 4); | |
| 978 CheckReferencesVp9(pid + 6 , 0, pid + 5); | |
| 979 CheckReferencesVp9(pid + 7 , 0, pid + 6); | |
| 980 CheckReferencesVp9(pid + 8 , 0, pid + 7); | |
| 981 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 982 CheckReferencesVp9(pid + 10, 0, pid + 9); | |
| 983 CheckReferencesVp9(pid + 11, 0, pid + 10); | |
| 984 CheckReferencesVp9(pid + 12, 0, pid + 11); | |
| 985 CheckReferencesVp9(pid + 13, 0, pid + 12); | |
| 986 CheckReferencesVp9(pid + 14, 0, pid + 13); | |
| 987 CheckReferencesVp9(pid + 15, 0, pid + 14); | |
| 988 CheckReferencesVp9(pid + 16, 0, pid + 15); | |
| 989 CheckReferencesVp9(pid + 17, 0, pid + 16); | |
| 990 CheckReferencesVp9(pid + 18, 0, pid + 17); | |
| 991 CheckReferencesVp9(pid + 19, 0, pid + 18); | |
| 992 } | |
| 993 | |
| 994 TEST_F(TestPacketBuffer, Vp9GofTemporalLayersReordered_0) { | |
| 995 uint16_t pid = Rand(); | |
| 996 uint16_t sn = Rand(); | |
| 997 GofInfoVP9 ss; | |
| 998 ss.SetGofInfoVP9(kTemporalStructureMode1); // Only 1 spatial layer. | |
| 999 | |
| 1000 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 1001 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 0 , 2); | |
| 1002 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 0 , 1); | |
| 1003 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 1004 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 4); | |
| 1005 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 0 , 3); | |
| 1006 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 0 , 5); | |
| 1007 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 0 , 7); | |
| 1008 InsertVp9Gof(sn + 6 , kF, kT , kT , kF, pid + 6 , 0 , 0 , 6); | |
| 1009 InsertVp9Gof(sn + 8 , kF, kT , kT , kF, pid + 8 , 0 , 0 , 8); | |
| 1010 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 0 , 10); | |
| 1011 InsertVp9Gof(sn + 13, kF, kT , kT , kF, pid + 13, 0 , 0 , 13); | |
| 1012 InsertVp9Gof(sn + 11, kF, kT , kT , kF, pid + 11, 0 , 0 , 11); | |
| 1013 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 0 , 9); | |
| 1014 InsertVp9Gof(sn + 16, kF, kT , kT , kF, pid + 16, 0 , 0 , 16); | |
| 1015 InsertVp9Gof(sn + 14, kF, kT , kT , kF, pid + 14, 0 , 0 , 14); | |
| 1016 InsertVp9Gof(sn + 15, kF, kT , kT , kF, pid + 15, 0 , 0 , 15); | |
| 1017 InsertVp9Gof(sn + 12, kF, kT , kT , kF, pid + 12, 0 , 0 , 12); | |
| 1018 InsertVp9Gof(sn + 17, kF, kT , kT , kF, pid + 17, 0 , 0 , 17); | |
| 1019 InsertVp9Gof(sn + 19, kF, kT , kT , kF, pid + 19, 0 , 0 , 19); | |
| 1020 InsertVp9Gof(sn + 18, kF, kT , kT , kF, pid + 18, 0 , 0 , 18); | |
| 1021 | |
| 1022 ASSERT_EQ(20UL, frames_from_callback_.size()); | |
| 1023 CheckReferencesVp9(pid, 0); | |
| 1024 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 1025 CheckReferencesVp9(pid + 2 , 0, pid + 1); | |
| 1026 CheckReferencesVp9(pid + 3 , 0, pid + 2); | |
| 1027 CheckReferencesVp9(pid + 4 , 0, pid + 3); | |
| 1028 CheckReferencesVp9(pid + 5 , 0, pid + 4); | |
| 1029 CheckReferencesVp9(pid + 6 , 0, pid + 5); | |
| 1030 CheckReferencesVp9(pid + 7 , 0, pid + 6); | |
| 1031 CheckReferencesVp9(pid + 8 , 0, pid + 7); | |
| 1032 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 1033 CheckReferencesVp9(pid + 10, 0, pid + 9); | |
| 1034 CheckReferencesVp9(pid + 11, 0, pid + 10); | |
| 1035 CheckReferencesVp9(pid + 12, 0, pid + 11); | |
| 1036 CheckReferencesVp9(pid + 13, 0, pid + 12); | |
| 1037 CheckReferencesVp9(pid + 14, 0, pid + 13); | |
| 1038 CheckReferencesVp9(pid + 15, 0, pid + 14); | |
| 1039 CheckReferencesVp9(pid + 16, 0, pid + 15); | |
| 1040 CheckReferencesVp9(pid + 17, 0, pid + 16); | |
| 1041 CheckReferencesVp9(pid + 18, 0, pid + 17); | |
| 1042 CheckReferencesVp9(pid + 19, 0, pid + 18); | |
| 1043 } | |
| 1044 | |
| 1045 TEST_F(TestPacketBuffer, Vp9GofTemporalLayers_01) { | |
| 1046 uint16_t pid = Rand(); | |
| 1047 uint16_t sn = Rand(); | |
| 1048 GofInfoVP9 ss; | |
| 1049 ss.SetGofInfoVP9(kTemporalStructureMode2); // 0101 pattern | |
| 1050 | |
| 1051 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 1052 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 1053 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 1 , 0); | |
| 1054 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 0 , 1); | |
| 1055 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 1 , 1); | |
| 1056 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 2); | |
| 1057 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 1 , 2); | |
| 1058 InsertVp9Gof(sn + 6 , kF, kT , kT , kF, pid + 6 , 0 , 0 , 3); | |
| 1059 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 1 , 3); | |
| 1060 InsertVp9Gof(sn + 8 , kF, kT , kT , kF, pid + 8 , 0 , 0 , 4); | |
| 1061 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 1 , 4); | |
| 1062 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 0 , 5); | |
| 1063 InsertVp9Gof(sn + 11, kF, kT , kT , kF, pid + 11, 0 , 1 , 5); | |
| 1064 InsertVp9Gof(sn + 12, kF, kT , kT , kF, pid + 12, 0 , 0 , 6); | |
| 1065 InsertVp9Gof(sn + 13, kF, kT , kT , kF, pid + 13, 0 , 1 , 6); | |
| 1066 InsertVp9Gof(sn + 14, kF, kT , kT , kF, pid + 14, 0 , 0 , 7); | |
| 1067 InsertVp9Gof(sn + 15, kF, kT , kT , kF, pid + 15, 0 , 1 , 7); | |
| 1068 InsertVp9Gof(sn + 16, kF, kT , kT , kF, pid + 16, 0 , 0 , 8); | |
| 1069 InsertVp9Gof(sn + 17, kF, kT , kT , kF, pid + 17, 0 , 1 , 8); | |
| 1070 InsertVp9Gof(sn + 18, kF, kT , kT , kF, pid + 18, 0 , 0 , 9); | |
| 1071 InsertVp9Gof(sn + 19, kF, kT , kT , kF, pid + 19, 0 , 1 , 9); | |
| 1072 | |
| 1073 ASSERT_EQ(20UL, frames_from_callback_.size()); | |
| 1074 CheckReferencesVp9(pid, 0); | |
| 1075 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 1076 CheckReferencesVp9(pid + 2 , 0, pid); | |
| 1077 CheckReferencesVp9(pid + 3 , 0, pid + 2); | |
| 1078 CheckReferencesVp9(pid + 4 , 0, pid + 2); | |
| 1079 CheckReferencesVp9(pid + 5 , 0, pid + 4); | |
| 1080 CheckReferencesVp9(pid + 6 , 0, pid + 4); | |
| 1081 CheckReferencesVp9(pid + 7 , 0, pid + 6); | |
| 1082 CheckReferencesVp9(pid + 8 , 0, pid + 6); | |
| 1083 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 1084 CheckReferencesVp9(pid + 10, 0, pid + 8); | |
| 1085 CheckReferencesVp9(pid + 11, 0, pid + 10); | |
| 1086 CheckReferencesVp9(pid + 12, 0, pid + 10); | |
| 1087 CheckReferencesVp9(pid + 13, 0, pid + 12); | |
| 1088 CheckReferencesVp9(pid + 14, 0, pid + 12); | |
| 1089 CheckReferencesVp9(pid + 15, 0, pid + 14); | |
| 1090 CheckReferencesVp9(pid + 16, 0, pid + 14); | |
| 1091 CheckReferencesVp9(pid + 17, 0, pid + 16); | |
| 1092 CheckReferencesVp9(pid + 18, 0, pid + 16); | |
| 1093 CheckReferencesVp9(pid + 19, 0, pid + 18); | |
| 1094 } | |
| 1095 | |
| 1096 TEST_F(TestPacketBuffer, Vp9GofTemporalLayersReordered_01) { | |
| 1097 uint16_t pid = Rand(); | |
| 1098 uint16_t sn = Rand(); | |
| 1099 GofInfoVP9 ss; | |
| 1100 ss.SetGofInfoVP9(kTemporalStructureMode2); // 01 pattern | |
| 1101 | |
| 1102 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 1103 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 1 , 0); | |
| 1104 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 1105 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 0 , 1); | |
| 1106 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 2); | |
| 1107 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 1 , 1); | |
| 1108 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 1 , 2); | |
| 1109 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 1 , 3); | |
| 1110 InsertVp9Gof(sn + 6 , kF, kT , kT , kF, pid + 6 , 0 , 0 , 3); | |
| 1111 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 0 , 5); | |
| 1112 InsertVp9Gof(sn + 8 , kF, kT , kT , kF, pid + 8 , 0 , 0 , 4); | |
| 1113 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 1 , 4); | |
| 1114 InsertVp9Gof(sn + 11, kF, kT , kT , kF, pid + 11, 0 , 1 , 5); | |
| 1115 InsertVp9Gof(sn + 13, kF, kT , kT , kF, pid + 13, 0 , 1 , 6); | |
| 1116 InsertVp9Gof(sn + 16, kF, kT , kT , kF, pid + 16, 0 , 0 , 8); | |
| 1117 InsertVp9Gof(sn + 12, kF, kT , kT , kF, pid + 12, 0 , 0 , 6); | |
| 1118 InsertVp9Gof(sn + 14, kF, kT , kT , kF, pid + 14, 0 , 0 , 7); | |
| 1119 InsertVp9Gof(sn + 17, kF, kT , kT , kF, pid + 17, 0 , 1 , 8); | |
| 1120 InsertVp9Gof(sn + 19, kF, kT , kT , kF, pid + 19, 0 , 1 , 9); | |
| 1121 InsertVp9Gof(sn + 15, kF, kT , kT , kF, pid + 15, 0 , 1 , 7); | |
| 1122 InsertVp9Gof(sn + 18, kF, kT , kT , kF, pid + 18, 0 , 0 , 9); | |
| 1123 | |
| 1124 ASSERT_EQ(20UL, frames_from_callback_.size()); | |
| 1125 CheckReferencesVp9(pid, 0); | |
| 1126 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 1127 CheckReferencesVp9(pid + 2 , 0, pid); | |
| 1128 CheckReferencesVp9(pid + 3 , 0, pid + 2); | |
| 1129 CheckReferencesVp9(pid + 4 , 0, pid + 2); | |
| 1130 CheckReferencesVp9(pid + 5 , 0, pid + 4); | |
| 1131 CheckReferencesVp9(pid + 6 , 0, pid + 4); | |
| 1132 CheckReferencesVp9(pid + 7 , 0, pid + 6); | |
| 1133 CheckReferencesVp9(pid + 8 , 0, pid + 6); | |
| 1134 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 1135 CheckReferencesVp9(pid + 10, 0, pid + 8); | |
| 1136 CheckReferencesVp9(pid + 11, 0, pid + 10); | |
| 1137 CheckReferencesVp9(pid + 12, 0, pid + 10); | |
| 1138 CheckReferencesVp9(pid + 13, 0, pid + 12); | |
| 1139 CheckReferencesVp9(pid + 14, 0, pid + 12); | |
| 1140 CheckReferencesVp9(pid + 15, 0, pid + 14); | |
| 1141 CheckReferencesVp9(pid + 16, 0, pid + 14); | |
| 1142 CheckReferencesVp9(pid + 17, 0, pid + 16); | |
| 1143 CheckReferencesVp9(pid + 18, 0, pid + 16); | |
| 1144 CheckReferencesVp9(pid + 19, 0, pid + 18); | |
| 1145 } | |
| 1146 | |
| 1147 TEST_F(TestPacketBuffer, Vp9GofTemporalLayers_0212) { | |
| 1148 uint16_t pid = Rand(); | |
| 1149 uint16_t sn = Rand(); | |
| 1150 GofInfoVP9 ss; | |
| 1151 ss.SetGofInfoVP9(kTemporalStructureMode3); // 0212 pattern | |
| 1152 | |
| 1153 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 1154 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 1155 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 2 , 0); | |
| 1156 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 1 , 0); | |
| 1157 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 2 , 0); | |
| 1158 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 1); | |
| 1159 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 2 , 1); | |
| 1160 InsertVp9Gof(sn + 6 , kF, kT , kT , kF, pid + 6 , 0 , 1 , 1); | |
| 1161 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 2 , 1); | |
| 1162 InsertVp9Gof(sn + 8 , kF, kT , kT , kF, pid + 8 , 0 , 0 , 2); | |
| 1163 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 2 , 2); | |
| 1164 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 1 , 2); | |
| 1165 InsertVp9Gof(sn + 11, kF, kT , kT , kF, pid + 11, 0 , 2 , 2); | |
| 1166 InsertVp9Gof(sn + 12, kF, kT , kT , kF, pid + 12, 0 , 0 , 3); | |
| 1167 InsertVp9Gof(sn + 13, kF, kT , kT , kF, pid + 13, 0 , 2 , 3); | |
| 1168 InsertVp9Gof(sn + 14, kF, kT , kT , kF, pid + 14, 0 , 1 , 3); | |
| 1169 InsertVp9Gof(sn + 15, kF, kT , kT , kF, pid + 15, 0 , 2 , 3); | |
| 1170 InsertVp9Gof(sn + 16, kF, kT , kT , kF, pid + 16, 0 , 0 , 4); | |
| 1171 InsertVp9Gof(sn + 17, kF, kT , kT , kF, pid + 17, 0 , 2 , 4); | |
| 1172 InsertVp9Gof(sn + 18, kF, kT , kT , kF, pid + 18, 0 , 1 , 4); | |
| 1173 InsertVp9Gof(sn + 19, kF, kT , kT , kF, pid + 19, 0 , 2 , 4); | |
| 1174 | |
| 1175 ASSERT_EQ(20UL, frames_from_callback_.size()); | |
| 1176 CheckReferencesVp9(pid, 0); | |
| 1177 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 1178 CheckReferencesVp9(pid + 2 , 0, pid); | |
| 1179 CheckReferencesVp9(pid + 3 , 0, pid + 1, pid + 2); | |
| 1180 CheckReferencesVp9(pid + 4 , 0, pid); | |
| 1181 CheckReferencesVp9(pid + 5 , 0, pid + 4); | |
| 1182 CheckReferencesVp9(pid + 6 , 0, pid + 4); | |
| 1183 CheckReferencesVp9(pid + 7 , 0, pid + 5, pid + 6); | |
| 1184 CheckReferencesVp9(pid + 8 , 0, pid + 4); | |
| 1185 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 1186 CheckReferencesVp9(pid + 10, 0, pid + 8); | |
| 1187 CheckReferencesVp9(pid + 11, 0, pid + 9, pid + 10); | |
| 1188 CheckReferencesVp9(pid + 12, 0, pid + 8); | |
| 1189 CheckReferencesVp9(pid + 13, 0, pid + 12); | |
| 1190 CheckReferencesVp9(pid + 14, 0, pid + 12); | |
| 1191 CheckReferencesVp9(pid + 15, 0, pid + 13, pid + 14); | |
| 1192 CheckReferencesVp9(pid + 16, 0, pid + 12); | |
| 1193 CheckReferencesVp9(pid + 17, 0, pid + 16); | |
| 1194 CheckReferencesVp9(pid + 18, 0, pid + 16); | |
| 1195 CheckReferencesVp9(pid + 19, 0, pid + 17, pid + 18); | |
| 1196 } | |
| 1197 | |
| 1198 TEST_F(TestPacketBuffer, Vp9GofTemporalLayersReordered_0212) { | |
| 1199 uint16_t pid = Rand(); | |
| 1200 uint16_t sn = Rand(); | |
| 1201 GofInfoVP9 ss; | |
| 1202 ss.SetGofInfoVP9(kTemporalStructureMode3); // 0212 pattern | |
| 1203 | |
| 1204 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 1205 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 1 , 0); | |
| 1206 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 2 , 0); | |
| 1207 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 1208 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 2 , 0); | |
| 1209 InsertVp9Gof(sn + 6 , kF, kT , kT , kF, pid + 6 , 0 , 1 , 1); | |
| 1210 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 2 , 1); | |
| 1211 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 1); | |
| 1212 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 2 , 2); | |
| 1213 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 2 , 1); | |
| 1214 InsertVp9Gof(sn + 8 , kF, kT , kT , kF, pid + 8 , 0 , 0 , 2); | |
| 1215 InsertVp9Gof(sn + 11, kF, kT , kT , kF, pid + 11, 0 , 2 , 2); | |
| 1216 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 1 , 2); | |
| 1217 InsertVp9Gof(sn + 13, kF, kT , kT , kF, pid + 13, 0 , 2 , 3); | |
| 1218 InsertVp9Gof(sn + 12, kF, kT , kT , kF, pid + 12, 0 , 0 , 3); | |
| 1219 InsertVp9Gof(sn + 14, kF, kT , kT , kF, pid + 14, 0 , 1 , 3); | |
| 1220 InsertVp9Gof(sn + 16, kF, kT , kT , kF, pid + 16, 0 , 0 , 4); | |
| 1221 InsertVp9Gof(sn + 15, kF, kT , kT , kF, pid + 15, 0 , 2 , 3); | |
| 1222 InsertVp9Gof(sn + 17, kF, kT , kT , kF, pid + 17, 0 , 2 , 4); | |
| 1223 InsertVp9Gof(sn + 19, kF, kT , kT , kF, pid + 19, 0 , 2 , 4); | |
| 1224 InsertVp9Gof(sn + 18, kF, kT , kT , kF, pid + 18, 0 , 1 , 4); | |
| 1225 | |
| 1226 ASSERT_EQ(20UL, frames_from_callback_.size()); | |
| 1227 CheckReferencesVp9(pid, 0); | |
| 1228 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 1229 CheckReferencesVp9(pid + 2 , 0, pid); | |
| 1230 CheckReferencesVp9(pid + 3 , 0, pid + 1, pid + 2); | |
| 1231 CheckReferencesVp9(pid + 4 , 0, pid); | |
| 1232 CheckReferencesVp9(pid + 5 , 0, pid + 4); | |
| 1233 CheckReferencesVp9(pid + 6 , 0, pid + 4); | |
| 1234 CheckReferencesVp9(pid + 7 , 0, pid + 5, pid + 6); | |
| 1235 CheckReferencesVp9(pid + 8 , 0, pid + 4); | |
| 1236 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 1237 CheckReferencesVp9(pid + 10, 0, pid + 8); | |
| 1238 CheckReferencesVp9(pid + 11, 0, pid + 9, pid + 10); | |
| 1239 CheckReferencesVp9(pid + 12, 0, pid + 8); | |
| 1240 CheckReferencesVp9(pid + 13, 0, pid + 12); | |
| 1241 CheckReferencesVp9(pid + 14, 0, pid + 12); | |
| 1242 CheckReferencesVp9(pid + 15, 0, pid + 13, pid + 14); | |
| 1243 CheckReferencesVp9(pid + 16, 0, pid + 12); | |
| 1244 CheckReferencesVp9(pid + 17, 0, pid + 16); | |
| 1245 CheckReferencesVp9(pid + 18, 0, pid + 16); | |
| 1246 CheckReferencesVp9(pid + 19, 0, pid + 17, pid + 18); | |
| 1247 } | |
| 1248 | |
| 1249 TEST_F(TestPacketBuffer, Vp9GofTemporalLayersUpSwitch_02120212) { | |
| 1250 uint16_t pid = Rand(); | |
| 1251 uint16_t sn = Rand(); | |
| 1252 GofInfoVP9 ss; | |
| 1253 ss.SetGofInfoVP9(kTemporalStructureMode4); // 02120212 pattern | |
| 1254 | |
| 1255 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 1256 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 1257 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 2 , 0); | |
| 1258 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 1 , 0); | |
| 1259 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 2 , 0); | |
| 1260 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 1); | |
| 1261 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 2 , 1); | |
| 1262 InsertVp9Gof(sn + 6 , kF, kT , kT , kT, pid + 6 , 0 , 1 , 1); | |
| 1263 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 2 , 1); | |
| 1264 InsertVp9Gof(sn + 8 , kF, kT , kT , kT, pid + 8 , 0 , 0 , 2); | |
| 1265 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 2 , 2); | |
| 1266 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 1 , 2); | |
| 1267 InsertVp9Gof(sn + 11, kF, kT , kT , kT, pid + 11, 0 , 2 , 2); | |
| 1268 InsertVp9Gof(sn + 12, kF, kT , kT , kF, pid + 12, 0 , 0 , 3); | |
| 1269 InsertVp9Gof(sn + 13, kF, kT , kT , kF, pid + 13, 0 , 2 , 3); | |
| 1270 InsertVp9Gof(sn + 14, kF, kT , kT , kF, pid + 14, 0 , 1 , 3); | |
| 1271 InsertVp9Gof(sn + 15, kF, kT , kT , kF, pid + 15, 0 , 2 , 3); | |
| 1272 | |
| 1273 ASSERT_EQ(16UL, frames_from_callback_.size()); | |
| 1274 CheckReferencesVp9(pid, 0); | |
| 1275 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 1276 CheckReferencesVp9(pid + 2 , 0, pid); | |
| 1277 CheckReferencesVp9(pid + 3 , 0, pid + 1, pid + 2); | |
| 1278 CheckReferencesVp9(pid + 4 , 0, pid); | |
| 1279 CheckReferencesVp9(pid + 5 , 0, pid + 3, pid + 4); | |
| 1280 CheckReferencesVp9(pid + 6 , 0, pid + 2, pid + 4); | |
| 1281 CheckReferencesVp9(pid + 7 , 0, pid + 6); | |
| 1282 CheckReferencesVp9(pid + 8 , 0, pid + 4); | |
| 1283 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 1284 CheckReferencesVp9(pid + 10, 0, pid + 8); | |
| 1285 CheckReferencesVp9(pid + 11, 0, pid + 9, pid + 10); | |
| 1286 CheckReferencesVp9(pid + 12, 0, pid + 8); | |
| 1287 CheckReferencesVp9(pid + 13, 0, pid + 11, pid + 12); | |
| 1288 CheckReferencesVp9(pid + 14, 0, pid + 10, pid + 12); | |
| 1289 CheckReferencesVp9(pid + 15, 0, pid + 13, pid + 14); | |
| 1290 } | |
| 1291 | |
| 1292 TEST_F(TestPacketBuffer, Vp9GofTemporalLayersUpSwitchReordered_02120212) { | |
| 1293 uint16_t pid = Rand(); | |
| 1294 uint16_t sn = Rand(); | |
| 1295 GofInfoVP9 ss; | |
| 1296 ss.SetGofInfoVP9(kTemporalStructureMode4); // 02120212 pattern | |
| 1297 | |
| 1298 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 1299 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 2 , 0); | |
| 1300 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 1301 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 1); | |
| 1302 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 1 , 0); | |
| 1303 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 2 , 1); | |
| 1304 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 2 , 0); | |
| 1305 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 2 , 1); | |
| 1306 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 2 , 2); | |
| 1307 InsertVp9Gof(sn + 6 , kF, kT , kT , kT, pid + 6 , 0 , 1 , 1); | |
| 1308 InsertVp9Gof(sn + 12, kF, kT , kT , kF, pid + 12, 0 , 0 , 3); | |
| 1309 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 1 , 2); | |
| 1310 InsertVp9Gof(sn + 8 , kF, kT , kT , kT, pid + 8 , 0 , 0 , 2); | |
| 1311 InsertVp9Gof(sn + 11, kF, kT , kT , kT, pid + 11, 0 , 2 , 2); | |
| 1312 InsertVp9Gof(sn + 13, kF, kT , kT , kF, pid + 13, 0 , 2 , 3); | |
| 1313 InsertVp9Gof(sn + 15, kF, kT , kT , kF, pid + 15, 0 , 2 , 3); | |
| 1314 InsertVp9Gof(sn + 14, kF, kT , kT , kF, pid + 14, 0 , 1 , 3); | |
| 1315 | |
| 1316 ASSERT_EQ(16UL, frames_from_callback_.size()); | |
| 1317 CheckReferencesVp9(pid, 0); | |
| 1318 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 1319 CheckReferencesVp9(pid + 2 , 0, pid); | |
| 1320 CheckReferencesVp9(pid + 3 , 0, pid + 1, pid + 2); | |
| 1321 CheckReferencesVp9(pid + 4 , 0, pid); | |
| 1322 CheckReferencesVp9(pid + 5 , 0, pid + 3, pid + 4); | |
| 1323 CheckReferencesVp9(pid + 6 , 0, pid + 2, pid + 4); | |
| 1324 CheckReferencesVp9(pid + 7 , 0, pid + 6); | |
| 1325 CheckReferencesVp9(pid + 8 , 0, pid + 4); | |
| 1326 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 1327 CheckReferencesVp9(pid + 10, 0, pid + 8); | |
| 1328 CheckReferencesVp9(pid + 11, 0, pid + 9, pid + 10); | |
| 1329 CheckReferencesVp9(pid + 12, 0, pid + 8); | |
| 1330 CheckReferencesVp9(pid + 13, 0, pid + 11, pid + 12); | |
| 1331 CheckReferencesVp9(pid + 14, 0, pid + 10, pid + 12); | |
| 1332 CheckReferencesVp9(pid + 15, 0, pid + 13, pid + 14); | |
| 1333 } | |
| 1334 | |
| 1335 TEST_F(TestPacketBuffer, Vp9GofTemporalLayersReordered_01_0212) { | |
| 1336 uint16_t pid = Rand(); | |
| 1337 uint16_t sn = Rand(); | |
| 1338 GofInfoVP9 ss; | |
| 1339 ss.SetGofInfoVP9(kTemporalStructureMode2); // 01 pattern | |
| 1340 | |
| 1341 // sn , kf, frst, lst, up, pid , sid, tid, tl0, ss | |
| 1342 InsertVp9Gof(sn + 1 , kF, kT , kT , kF, pid + 1 , 0 , 1 , 0); | |
| 1343 InsertVp9Gof(sn , kT, kT , kT , kF, pid , 0 , 0 , 0 , &ss); | |
| 1344 InsertVp9Gof(sn + 3 , kF, kT , kT , kF, pid + 3 , 0 , 1 , 1); | |
| 1345 InsertVp9Gof(sn + 6 , kF, kT , kT , kF, pid + 6 , 0 , 1 , 2); | |
| 1346 ss.SetGofInfoVP9(kTemporalStructureMode3); // 0212 pattern | |
| 1347 InsertVp9Gof(sn + 4 , kF, kT , kT , kF, pid + 4 , 0 , 0 , 2 , &ss); | |
| 1348 InsertVp9Gof(sn + 2 , kF, kT , kT , kF, pid + 2 , 0 , 0 , 1); | |
| 1349 InsertVp9Gof(sn + 5 , kF, kT , kT , kF, pid + 5 , 0 , 2 , 2); | |
| 1350 InsertVp9Gof(sn + 8 , kF, kT , kT , kF, pid + 8 , 0 , 0 , 3); | |
| 1351 InsertVp9Gof(sn + 10, kF, kT , kT , kF, pid + 10, 0 , 1 , 3); | |
| 1352 InsertVp9Gof(sn + 7 , kF, kT , kT , kF, pid + 7 , 0 , 2 , 2); | |
| 1353 InsertVp9Gof(sn + 11, kF, kT , kT , kF, pid + 11, 0 , 2 , 3); | |
| 1354 InsertVp9Gof(sn + 9 , kF, kT , kT , kF, pid + 9 , 0 , 2 , 3); | |
| 1355 | |
| 1356 ASSERT_EQ(12UL, frames_from_callback_.size()); | |
| 1357 CheckReferencesVp9(pid, 0); | |
| 1358 CheckReferencesVp9(pid + 1 , 0, pid); | |
| 1359 CheckReferencesVp9(pid + 2 , 0, pid); | |
| 1360 CheckReferencesVp9(pid + 3 , 0, pid + 2); | |
| 1361 CheckReferencesVp9(pid + 4 , 0, pid); | |
| 1362 CheckReferencesVp9(pid + 5 , 0, pid + 4); | |
| 1363 CheckReferencesVp9(pid + 6 , 0, pid + 4); | |
| 1364 CheckReferencesVp9(pid + 7 , 0, pid + 5, pid + 6); | |
| 1365 CheckReferencesVp9(pid + 8 , 0, pid + 4); | |
| 1366 CheckReferencesVp9(pid + 9 , 0, pid + 8); | |
| 1367 CheckReferencesVp9(pid + 10, 0, pid + 8); | |
| 1368 CheckReferencesVp9(pid + 11, 0, pid + 9, pid + 10); | |
| 1369 } | |
| 1370 | |
| 1371 TEST_F(TestPacketBuffer, Vp9FlexibleModeOneFrame) { | |
| 1372 uint16_t pid = Rand(); | |
| 1373 uint16_t sn = Rand(); | |
| 1374 | |
| 1375 // sn, kf, frst, lst, intr, pid, sid, tid, tl0 | |
| 1376 InsertVp9Flex(sn, kT, kT , kT , kF , pid, 0 , 0 , 0); | |
| 1377 | |
| 1378 ASSERT_EQ(1UL, frames_from_callback_.size()); | |
| 1379 CheckReferencesVp9(pid, 0); | |
| 1380 } | |
| 1381 | |
| 1382 TEST_F(TestPacketBuffer, Vp9FlexibleModeTwoSpatialLayers) { | |
| 1383 uint16_t pid = Rand(); | |
| 1384 uint16_t sn = Rand(); | |
| 1385 | |
| 1386 // sn , kf, frst, lst, intr, pid , sid, tid, tl0, refs | |
| 1387 InsertVp9Flex(sn , kT, kT , kT , kF , pid , 0 , 0 , 0); | |
| 1388 InsertVp9Flex(sn + 1 , kT, kT , kT , kT , pid , 1 , 0 , 0); | |
| 1389 InsertVp9Flex(sn + 2 , kF, kT , kT , kF , pid + 1, 1 , 0 , 0 , {1}); | |
| 1390 InsertVp9Flex(sn + 3 , kF, kT , kT , kF , pid + 2, 0 , 0 , 1 , {2}); | |
| 1391 InsertVp9Flex(sn + 4 , kF, kT , kT , kF , pid + 2, 1 , 0 , 1 , {1}); | |
| 1392 InsertVp9Flex(sn + 5 , kF, kT , kT , kF , pid + 3, 1 , 0 , 1 , {1}); | |
| 1393 InsertVp9Flex(sn + 6 , kF, kT , kT , kF , pid + 4, 0 , 0 , 2 , {2}); | |
| 1394 InsertVp9Flex(sn + 7 , kF, kT , kT , kF , pid + 4, 1 , 0 , 2 , {1}); | |
| 1395 InsertVp9Flex(sn + 8 , kF, kT , kT , kF , pid + 5, 1 , 0 , 2 , {1}); | |
| 1396 InsertVp9Flex(sn + 9 , kF, kT , kT , kF , pid + 6, 0 , 0 , 3 , {2}); | |
| 1397 InsertVp9Flex(sn + 10, kF, kT , kT , kF , pid + 6, 1 , 0 , 3 , {1}); | |
| 1398 InsertVp9Flex(sn + 11, kF, kT , kT , kF , pid + 7, 1 , 0 , 3 , {1}); | |
| 1399 InsertVp9Flex(sn + 12, kF, kT , kT , kF , pid + 8, 0 , 0 , 4 , {2}); | |
| 1400 InsertVp9Flex(sn + 13, kF, kT , kT , kF , pid + 8, 1 , 0 , 4 , {1}); | |
| 1401 | |
| 1402 ASSERT_EQ(14UL, frames_from_callback_.size()); | |
| 1403 CheckReferencesVp9(pid , 0); | |
| 1404 CheckReferencesVp9(pid , 1); | |
| 1405 CheckReferencesVp9(pid + 1, 1, pid); | |
| 1406 CheckReferencesVp9(pid + 2, 0, pid); | |
| 1407 CheckReferencesVp9(pid + 2, 1, pid + 1); | |
| 1408 CheckReferencesVp9(pid + 3, 1, pid + 2); | |
| 1409 CheckReferencesVp9(pid + 4, 0, pid + 2); | |
| 1410 CheckReferencesVp9(pid + 4, 1, pid + 3); | |
| 1411 CheckReferencesVp9(pid + 5, 1, pid + 4); | |
| 1412 CheckReferencesVp9(pid + 6, 0, pid + 4); | |
| 1413 CheckReferencesVp9(pid + 6, 1, pid + 5); | |
| 1414 CheckReferencesVp9(pid + 7, 1, pid + 6); | |
| 1415 CheckReferencesVp9(pid + 8, 0, pid + 6); | |
| 1416 CheckReferencesVp9(pid + 8, 1, pid + 7); | |
| 1417 } | |
| 1418 | |
| 1419 TEST_F(TestPacketBuffer, Vp9FlexibleModeTwoSpatialLayersReordered) { | |
| 1420 uint16_t pid = Rand(); | |
| 1421 uint16_t sn = Rand(); | |
| 1422 | |
| 1423 // sn , kf, frst, lst, intr, pid , sid, tid, tl0, refs | |
| 1424 InsertVp9Flex(sn + 1 , kT, kT , kT , kT , pid , 1 , 0 , 0); | |
| 1425 InsertVp9Flex(sn + 2 , kF, kT , kT , kF , pid + 1, 1 , 0 , 0 , {1}); | |
| 1426 InsertVp9Flex(sn , kT, kT , kT , kF , pid , 0 , 0 , 0); | |
| 1427 InsertVp9Flex(sn + 4 , kF, kT , kT , kF , pid + 2, 1 , 0 , 1 , {1}); | |
| 1428 InsertVp9Flex(sn + 5 , kF, kT , kT , kF , pid + 3, 1 , 0 , 1 , {1}); | |
| 1429 InsertVp9Flex(sn + 3 , kF, kT , kT , kF , pid + 2, 0 , 0 , 1 , {2}); | |
| 1430 InsertVp9Flex(sn + 7 , kF, kT , kT , kF , pid + 4, 1 , 0 , 2 , {1}); | |
| 1431 InsertVp9Flex(sn + 6 , kF, kT , kT , kF , pid + 4, 0 , 0 , 2 , {2}); | |
| 1432 InsertVp9Flex(sn + 8 , kF, kT , kT , kF , pid + 5, 1 , 0 , 2 , {1}); | |
| 1433 InsertVp9Flex(sn + 9 , kF, kT , kT , kF , pid + 6, 0 , 0 , 3 , {2}); | |
| 1434 InsertVp9Flex(sn + 11, kF, kT , kT , kF , pid + 7, 1 , 0 , 3 , {1}); | |
| 1435 InsertVp9Flex(sn + 10, kF, kT , kT , kF , pid + 6, 1 , 0 , 3 , {1}); | |
| 1436 InsertVp9Flex(sn + 13, kF, kT , kT , kF , pid + 8, 1 , 0 , 4 , {1}); | |
| 1437 InsertVp9Flex(sn + 12, kF, kT , kT , kF , pid + 8, 0 , 0 , 4 , {2}); | |
| 1438 | |
| 1439 ASSERT_EQ(14UL, frames_from_callback_.size()); | |
| 1440 CheckReferencesVp9(pid , 0); | |
| 1441 CheckReferencesVp9(pid , 1); | |
| 1442 CheckReferencesVp9(pid + 1, 1, pid); | |
| 1443 CheckReferencesVp9(pid + 2, 0, pid); | |
| 1444 CheckReferencesVp9(pid + 2, 1, pid + 1); | |
| 1445 CheckReferencesVp9(pid + 3, 1, pid + 2); | |
| 1446 CheckReferencesVp9(pid + 4, 0, pid + 2); | |
| 1447 CheckReferencesVp9(pid + 4, 1, pid + 3); | |
| 1448 CheckReferencesVp9(pid + 5, 1, pid + 4); | |
| 1449 CheckReferencesVp9(pid + 6, 0, pid + 4); | |
| 1450 CheckReferencesVp9(pid + 6, 1, pid + 5); | |
| 1451 CheckReferencesVp9(pid + 7, 1, pid + 6); | |
| 1452 CheckReferencesVp9(pid + 8, 0, pid + 6); | |
| 1453 CheckReferencesVp9(pid + 8, 1, pid + 7); | |
| 1454 } | |
| 1455 | |
| 1456 } // namespace video_coding | |
| 1457 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews