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