blob: ae411734b0d759c3cf938c0704317a6e149ac3a8 [file] [log] [blame]
philipelc707ab72016-04-01 09:01:541/*
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>
philipel02447bc2016-05-13 13:01:0312#include <map>
13#include <set>
philipela1059872016-05-09 09:41:4814#include <utility>
philipelc707ab72016-04-01 09:01:5415
Mirko Bonadei92ea95e2017-09-15 04:47:3116#include "common_video/h264/h264_common.h"
17#include "modules/video_coding/frame_object.h"
18#include "modules/video_coding/packet_buffer.h"
19#include "rtc_base/random.h"
20#include "system_wrappers/include/clock.h"
Rasmus Brandtedf4ff72017-10-24 08:07:4821#include "test/field_trial.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3122#include "test/gtest.h"
philipelc707ab72016-04-01 09:01:5423
24namespace webrtc {
25namespace video_coding {
26
27class TestPacketBuffer : public ::testing::Test,
Elad Alonb4643ad2019-02-22 10:19:5028 public OnAssembledFrameCallback {
philipelc707ab72016-04-01 09:01:5429 protected:
Rasmus Brandt88f080a2017-11-02 13:28:0630 TestPacketBuffer() : TestPacketBuffer("") {}
31 explicit TestPacketBuffer(std::string field_trials)
32 : scoped_field_trials_(field_trials),
33 rand_(0x7732213),
philipelb4d31082016-07-11 15:46:2934 clock_(new SimulatedClock(0)),
philipel17deeb42016-08-11 13:09:2635 packet_buffer_(
36 PacketBuffer::Create(clock_.get(), kStartSize, kMaxSize, this)) {}
philipelc707ab72016-04-01 09:01:5437
philipel17deeb42016-08-11 13:09:2638 uint16_t Rand() { return rand_.Rand<uint16_t>(); }
philipelc707ab72016-04-01 09:01:5439
Elad Alonb4643ad2019-02-22 10:19:5040 void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame) override {
philipel17deeb42016-08-11 13:09:2641 uint16_t first_seq_num = frame->first_seq_num();
42 if (frames_from_callback_.find(first_seq_num) !=
43 frames_from_callback_.end()) {
44 ADD_FAILURE() << "Already received frame with first sequence number "
45 << first_seq_num << ".";
philipelf4139332016-04-20 08:26:3446 return;
47 }
philipel2c9f9f22017-06-13 09:47:2848
philipelf4139332016-04-20 08:26:3449 frames_from_callback_.insert(
philipel17deeb42016-08-11 13:09:2650 std::make_pair(frame->first_seq_num(), std::move(frame)));
philipelc707ab72016-04-01 09:01:5451 }
52
philipel17deeb42016-08-11 13:09:2653 enum IsKeyFrame { kKeyFrame, kDeltaFrame };
54 enum IsFirst { kFirst, kNotFirst };
55 enum IsLast { kLast, kNotLast };
philipelc707ab72016-04-01 09:01:5456
Ilya Nikolaevskiyd397a0d2018-02-21 14:57:0957 bool Insert(uint16_t seq_num, // packet sequence number
58 IsKeyFrame keyframe, // is keyframe
59 IsFirst first, // is first packet of frame
60 IsLast last, // is last packet of frame
61 int data_size = 0, // size of data
62 uint8_t* data = nullptr, // data pointer
63 uint32_t timestamp = 123u) { // rtp timestamp
philipelf4139332016-04-20 08:26:3464 VCMPacket packet;
Niels Möllerd5e02f02019-02-20 12:12:2165 packet.video_header.codec = kVideoCodecGeneric;
Ilya Nikolaevskiyd397a0d2018-02-21 14:57:0966 packet.timestamp = timestamp;
philipelf4139332016-04-20 08:26:3467 packet.seqNum = seq_num;
Niels Möllerabbc50e2019-04-24 07:41:1668 packet.video_header.frame_type = keyframe == kKeyFrame
69 ? VideoFrameType::kVideoFrameKey
70 : VideoFrameType::kVideoFrameDelta;
Niels Möllerd5e02f02019-02-20 12:12:2171 packet.video_header.is_first_packet_in_frame = first == kFirst;
72 packet.video_header.is_last_packet_in_frame = last == kLast;
philipelf4139332016-04-20 08:26:3473 packet.sizeBytes = data_size;
74 packet.dataPtr = data;
75
philipel759e0b72016-11-30 09:32:0576 return packet_buffer_->InsertPacket(&packet);
philipelf4139332016-04-20 08:26:3477 }
78
philipel17deeb42016-08-11 13:09:2679 void CheckFrame(uint16_t first_seq_num) {
80 auto frame_it = frames_from_callback_.find(first_seq_num);
81 ASSERT_FALSE(frame_it == frames_from_callback_.end())
82 << "Could not find frame with first sequence number " << first_seq_num
83 << ".";
philipelf4139332016-04-20 08:26:3484 }
85
Johannes Kron957c62e2018-10-01 12:53:0186 void DeleteFrame(uint16_t first_seq_num) {
87 auto frame_it = frames_from_callback_.find(first_seq_num);
88 ASSERT_FALSE(frame_it == frames_from_callback_.end())
89 << "Could not find frame with first sequence number " << first_seq_num
90 << ".";
91 frames_from_callback_.erase(frame_it);
92 }
93
philipel227f8b92017-08-04 13:39:3194 static constexpr int kStartSize = 16;
95 static constexpr int kMaxSize = 64;
philipelc707ab72016-04-01 09:01:5496
Rasmus Brandt88f080a2017-11-02 13:28:0697 const test::ScopedFieldTrials scoped_field_trials_;
98
philipelc707ab72016-04-01 09:01:5499 Random rand_;
philipel3184f8e2017-05-18 15:08:53100 std::unique_ptr<SimulatedClock> clock_;
philipel17deeb42016-08-11 13:09:26101 rtc::scoped_refptr<PacketBuffer> packet_buffer_;
102 std::map<uint16_t, std::unique_ptr<RtpFrameObject>> frames_from_callback_;
philipelc707ab72016-04-01 09:01:54103};
104
105TEST_F(TestPacketBuffer, InsertOnePacket) {
philipelaee3e0e2016-11-01 10:45:34106 const uint16_t seq_num = Rand();
107 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
philipelc707ab72016-04-01 09:01:54108}
109
110TEST_F(TestPacketBuffer, InsertMultiplePackets) {
philipelaee3e0e2016-11-01 10:45:34111 const uint16_t seq_num = Rand();
112 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
113 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kFirst, kLast));
114 EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kFirst, kLast));
115 EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kFirst, kLast));
philipelc707ab72016-04-01 09:01:54116}
117
118TEST_F(TestPacketBuffer, InsertDuplicatePacket) {
philipelaee3e0e2016-11-01 10:45:34119 const uint16_t seq_num = Rand();
Johannes Krona3705562019-08-26 14:37:11120 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
121 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
122 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast));
philipelaee3e0e2016-11-01 10:45:34123}
124
Artem Titarenko97e35ce2018-10-30 10:17:54125TEST_F(TestPacketBuffer, SeqNumWrapOneFrame) {
philipel2c2f34c2017-01-03 13:55:34126 EXPECT_TRUE(Insert(0xFFFF, kKeyFrame, kFirst, kNotLast));
127 EXPECT_TRUE(Insert(0x0, kKeyFrame, kNotFirst, kLast));
128
129 CheckFrame(0xFFFF);
130}
131
132TEST_F(TestPacketBuffer, SeqNumWrapTwoFrames) {
philipelaee3e0e2016-11-01 10:45:34133 EXPECT_TRUE(Insert(0xFFFF, kKeyFrame, kFirst, kLast));
134 EXPECT_TRUE(Insert(0x0, kKeyFrame, kFirst, kLast));
135
136 CheckFrame(0xFFFF);
philipel2c2f34c2017-01-03 13:55:34137 CheckFrame(0x0);
philipelaee3e0e2016-11-01 10:45:34138}
139
140TEST_F(TestPacketBuffer, InsertOldPackets) {
141 const uint16_t seq_num = Rand();
142
143 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
144 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
145 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast));
146 ASSERT_EQ(2UL, frames_from_callback_.size());
147
148 frames_from_callback_.erase(seq_num + 2);
149 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
150 ASSERT_EQ(1UL, frames_from_callback_.size());
151
152 frames_from_callback_.erase(frames_from_callback_.find(seq_num));
153 ASSERT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
154 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
155
156 packet_buffer_->ClearTo(seq_num + 2);
Johannes Kronbd3f3052019-08-01 13:45:54157 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
philipelaee3e0e2016-11-01 10:45:34158 EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast));
159 ASSERT_EQ(2UL, frames_from_callback_.size());
philipelc707ab72016-04-01 09:01:54160}
161
philipel5ceaaae2016-05-24 08:20:47162TEST_F(TestPacketBuffer, NackCount) {
philipelaee3e0e2016-11-01 10:45:34163 const uint16_t seq_num = Rand();
philipel5ceaaae2016-05-24 08:20:47164
165 VCMPacket packet;
Niels Möllerd5e02f02019-02-20 12:12:21166 packet.video_header.codec = kVideoCodecGeneric;
philipel5ceaaae2016-05-24 08:20:47167 packet.seqNum = seq_num;
Niels Möllerabbc50e2019-04-24 07:41:16168 packet.video_header.frame_type = VideoFrameType::kVideoFrameKey;
Niels Möllerd5e02f02019-02-20 12:12:21169 packet.video_header.is_first_packet_in_frame = true;
170 packet.video_header.is_last_packet_in_frame = false;
philipel5ceaaae2016-05-24 08:20:47171 packet.timesNacked = 0;
172
philipel759e0b72016-11-30 09:32:05173 packet_buffer_->InsertPacket(&packet);
philipel5ceaaae2016-05-24 08:20:47174
175 packet.seqNum++;
Niels Möllerd5e02f02019-02-20 12:12:21176 packet.video_header.is_first_packet_in_frame = false;
philipel5ceaaae2016-05-24 08:20:47177 packet.timesNacked = 1;
philipel759e0b72016-11-30 09:32:05178 packet_buffer_->InsertPacket(&packet);
philipel5ceaaae2016-05-24 08:20:47179
180 packet.seqNum++;
181 packet.timesNacked = 3;
philipel759e0b72016-11-30 09:32:05182 packet_buffer_->InsertPacket(&packet);
philipel5ceaaae2016-05-24 08:20:47183
184 packet.seqNum++;
Niels Möllerd5e02f02019-02-20 12:12:21185 packet.video_header.is_last_packet_in_frame = true;
philipel5ceaaae2016-05-24 08:20:47186 packet.timesNacked = 1;
philipel759e0b72016-11-30 09:32:05187 packet_buffer_->InsertPacket(&packet);
philipel5ceaaae2016-05-24 08:20:47188
philipel5ceaaae2016-05-24 08:20:47189 ASSERT_EQ(1UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26190 RtpFrameObject* frame = frames_from_callback_.begin()->second.get();
191 EXPECT_EQ(3, frame->times_nacked());
philipel5ceaaae2016-05-24 08:20:47192}
193
194TEST_F(TestPacketBuffer, FrameSize) {
philipelaee3e0e2016-11-01 10:45:34195 const uint16_t seq_num = Rand();
philipel41b8ca02016-11-07 14:42:24196 uint8_t* data1 = new uint8_t[5]();
197 uint8_t* data2 = new uint8_t[5]();
198 uint8_t* data3 = new uint8_t[5]();
199 uint8_t* data4 = new uint8_t[5]();
philipel5ceaaae2016-05-24 08:20:47200
philipel41b8ca02016-11-07 14:42:24201 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast, 5, data1));
202 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kNotLast, 5, data2));
203 EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kNotFirst, kNotLast, 5, data3));
204 EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kNotFirst, kLast, 5, data4));
philipel5ceaaae2016-05-24 08:20:47205
206 ASSERT_EQ(1UL, frames_from_callback_.size());
nisse37abf532016-10-28 07:37:29207 EXPECT_EQ(20UL, frames_from_callback_.begin()->second->size());
philipel5ceaaae2016-05-24 08:20:47208}
209
Ilya Nikolaevskiyd397a0d2018-02-21 14:57:09210TEST_F(TestPacketBuffer, CountsUniqueFrames) {
211 const uint16_t seq_num = Rand();
212
213 ASSERT_EQ(0, packet_buffer_->GetUniqueFramesSeen());
214
215 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast, 0, nullptr, 100));
216 ASSERT_EQ(1, packet_buffer_->GetUniqueFramesSeen());
217 // Still the same frame.
218 EXPECT_TRUE(
219 Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 100));
220 ASSERT_EQ(1, packet_buffer_->GetUniqueFramesSeen());
221
222 // Second frame.
223 EXPECT_TRUE(
224 Insert(seq_num + 2, kKeyFrame, kFirst, kNotLast, 0, nullptr, 200));
225 ASSERT_EQ(2, packet_buffer_->GetUniqueFramesSeen());
226 EXPECT_TRUE(
227 Insert(seq_num + 3, kKeyFrame, kNotFirst, kLast, 0, nullptr, 200));
228 ASSERT_EQ(2, packet_buffer_->GetUniqueFramesSeen());
229
230 // Old packet.
231 EXPECT_TRUE(
232 Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 100));
233 ASSERT_EQ(2, packet_buffer_->GetUniqueFramesSeen());
234
235 // Missing middle packet.
236 EXPECT_TRUE(
237 Insert(seq_num + 4, kKeyFrame, kFirst, kNotLast, 0, nullptr, 300));
238 EXPECT_TRUE(
239 Insert(seq_num + 6, kKeyFrame, kNotFirst, kLast, 0, nullptr, 300));
240 ASSERT_EQ(3, packet_buffer_->GetUniqueFramesSeen());
241}
242
243TEST_F(TestPacketBuffer, HasHistoryOfUniqueFrames) {
244 const int kNumFrames = 1500;
245 const int kRequiredHistoryLength = 1000;
246 const uint16_t seq_num = Rand();
247 const uint32_t timestamp = 0xFFFFFFF0; // Large enough to cause wrap-around.
248
249 for (int i = 0; i < kNumFrames; ++i) {
Johannes Kronbd3f3052019-08-01 13:45:54250 Insert(seq_num + i, kKeyFrame, kFirst, kNotLast, 0, nullptr,
251 timestamp + 10 * i);
Ilya Nikolaevskiyd397a0d2018-02-21 14:57:09252 }
253 ASSERT_EQ(kNumFrames, packet_buffer_->GetUniqueFramesSeen());
254
255 // Old packets within history should not affect number of seen unique frames.
256 for (int i = kNumFrames - kRequiredHistoryLength; i < kNumFrames; ++i) {
Johannes Kronbd3f3052019-08-01 13:45:54257 Insert(seq_num + i, kKeyFrame, kFirst, kNotLast, 0, nullptr,
258 timestamp + 10 * i);
Ilya Nikolaevskiyd397a0d2018-02-21 14:57:09259 }
260 ASSERT_EQ(kNumFrames, packet_buffer_->GetUniqueFramesSeen());
261
262 // Very old packets should be treated as unique.
Johannes Kronbd3f3052019-08-01 13:45:54263 Insert(seq_num, kKeyFrame, kFirst, kNotLast, 0, nullptr, timestamp);
Ilya Nikolaevskiyd397a0d2018-02-21 14:57:09264 ASSERT_EQ(kNumFrames + 1, packet_buffer_->GetUniqueFramesSeen());
265}
266
philipelc707ab72016-04-01 09:01:54267TEST_F(TestPacketBuffer, ExpandBuffer) {
philipelaee3e0e2016-11-01 10:45:34268 const uint16_t seq_num = Rand();
philipelc707ab72016-04-01 09:01:54269
Johannes Krona3705562019-08-26 14:37:11270 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
271 for (int i = 1; i < kStartSize; ++i)
272 EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast));
273
274 // Already inserted kStartSize number of packets, inserting the last packet
275 // should increase the buffer size and also result in an assembled frame.
276 EXPECT_TRUE(Insert(seq_num + kStartSize, kKeyFrame, kNotFirst, kLast));
philipelc707ab72016-04-01 09:01:54277}
278
philipelaee3e0e2016-11-01 10:45:34279TEST_F(TestPacketBuffer, SingleFrameExpandsBuffer) {
280 const uint16_t seq_num = Rand();
281
282 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
283 for (int i = 1; i < kStartSize; ++i)
284 EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast));
285 EXPECT_TRUE(Insert(seq_num + kStartSize, kKeyFrame, kNotFirst, kLast));
286
287 ASSERT_EQ(1UL, frames_from_callback_.size());
288 CheckFrame(seq_num);
289}
290
philipelc707ab72016-04-01 09:01:54291TEST_F(TestPacketBuffer, ExpandBufferOverflow) {
philipelaee3e0e2016-11-01 10:45:34292 const uint16_t seq_num = Rand();
philipelc707ab72016-04-01 09:01:54293
Johannes Krona3705562019-08-26 14:37:11294 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
295 for (int i = 1; i < kMaxSize; ++i)
296 EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast));
297
298 // Already inserted kMaxSize number of packets, inserting the last packet
299 // should overflow the buffer and result in false being returned.
300 EXPECT_FALSE(Insert(seq_num + kMaxSize, kKeyFrame, kNotFirst, kLast));
philipelc707ab72016-04-01 09:01:54301}
302
philipel17deeb42016-08-11 13:09:26303TEST_F(TestPacketBuffer, OnePacketOneFrame) {
philipelaee3e0e2016-11-01 10:45:34304 const uint16_t seq_num = Rand();
305 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
philipelf4139332016-04-20 08:26:34306 ASSERT_EQ(1UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26307 CheckFrame(seq_num);
philipelc707ab72016-04-01 09:01:54308}
309
philipel17deeb42016-08-11 13:09:26310TEST_F(TestPacketBuffer, TwoPacketsTwoFrames) {
philipelaee3e0e2016-11-01 10:45:34311 const uint16_t seq_num = Rand();
philipelf4139332016-04-20 08:26:34312
philipelaee3e0e2016-11-01 10:45:34313 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
314 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kFirst, kLast));
philipelf4139332016-04-20 08:26:34315
philipelc707ab72016-04-01 09:01:54316 EXPECT_EQ(2UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26317 CheckFrame(seq_num);
318 CheckFrame(seq_num + 1);
philipelc707ab72016-04-01 09:01:54319}
320
philipel17deeb42016-08-11 13:09:26321TEST_F(TestPacketBuffer, TwoPacketsOneFrames) {
philipelaee3e0e2016-11-01 10:45:34322 const uint16_t seq_num = Rand();
philipelf4139332016-04-20 08:26:34323
philipelaee3e0e2016-11-01 10:45:34324 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
325 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast));
philipelf4139332016-04-20 08:26:34326
philipelc707ab72016-04-01 09:01:54327 EXPECT_EQ(1UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26328 CheckFrame(seq_num);
philipelc707ab72016-04-01 09:01:54329}
330
philipel17deeb42016-08-11 13:09:26331TEST_F(TestPacketBuffer, ThreePacketReorderingOneFrame) {
philipelaee3e0e2016-11-01 10:45:34332 const uint16_t seq_num = Rand();
philipelc707ab72016-04-01 09:01:54333
philipelaee3e0e2016-11-01 10:45:34334 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
335 EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kNotFirst, kLast));
336 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kNotLast));
philipelf4139332016-04-20 08:26:34337
philipelc707ab72016-04-01 09:01:54338 EXPECT_EQ(1UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26339 CheckFrame(seq_num);
philipelc707ab72016-04-01 09:01:54340}
341
philipel17deeb42016-08-11 13:09:26342TEST_F(TestPacketBuffer, Frames) {
philipelaee3e0e2016-11-01 10:45:34343 const uint16_t seq_num = Rand();
philipelf4139332016-04-20 08:26:34344
philipelaee3e0e2016-11-01 10:45:34345 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
346 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kFirst, kLast));
347 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
348 EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast));
philipelf4139332016-04-20 08:26:34349
350 ASSERT_EQ(4UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26351 CheckFrame(seq_num);
352 CheckFrame(seq_num + 1);
353 CheckFrame(seq_num + 2);
354 CheckFrame(seq_num + 3);
philipelf4139332016-04-20 08:26:34355}
356
philipelaee3e0e2016-11-01 10:45:34357TEST_F(TestPacketBuffer, ClearSinglePacket) {
358 const uint16_t seq_num = Rand();
philipelf4139332016-04-20 08:26:34359
philipelaee3e0e2016-11-01 10:45:34360 for (int i = 0; i < kMaxSize; ++i)
361 EXPECT_TRUE(Insert(seq_num + i, kDeltaFrame, kFirst, kLast));
362
363 packet_buffer_->ClearTo(seq_num);
364 EXPECT_TRUE(Insert(seq_num + kMaxSize, kDeltaFrame, kFirst, kLast));
365}
366
philipelc5fb4682017-08-02 11:28:57367TEST_F(TestPacketBuffer, ClearFullBuffer) {
368 for (int i = 0; i < kMaxSize; ++i)
369 EXPECT_TRUE(Insert(i, kDeltaFrame, kFirst, kLast));
370
371 packet_buffer_->ClearTo(kMaxSize - 1);
372
373 for (int i = kMaxSize; i < 2 * kMaxSize; ++i)
374 EXPECT_TRUE(Insert(i, kDeltaFrame, kFirst, kLast));
375}
376
377TEST_F(TestPacketBuffer, DontClearNewerPacket) {
378 EXPECT_TRUE(Insert(0, kKeyFrame, kFirst, kLast));
379 packet_buffer_->ClearTo(0);
380 EXPECT_TRUE(Insert(2 * kStartSize, kKeyFrame, kFirst, kLast));
381 EXPECT_TRUE(Insert(3 * kStartSize + 1, kKeyFrame, kFirst, kNotLast));
382 packet_buffer_->ClearTo(2 * kStartSize);
383 EXPECT_TRUE(Insert(3 * kStartSize + 2, kKeyFrame, kNotFirst, kLast));
384
385 ASSERT_EQ(3UL, frames_from_callback_.size());
386 CheckFrame(0);
387 CheckFrame(2 * kStartSize);
388 CheckFrame(3 * kStartSize + 1);
389}
390
philipelaee3e0e2016-11-01 10:45:34391TEST_F(TestPacketBuffer, OneIncompleteFrame) {
392 const uint16_t seq_num = Rand();
393
394 EXPECT_TRUE(Insert(seq_num, kDeltaFrame, kFirst, kNotLast));
395 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kLast));
396 EXPECT_TRUE(Insert(seq_num - 1, kDeltaFrame, kNotFirst, kLast));
397
398 ASSERT_EQ(1UL, frames_from_callback_.size());
399 CheckFrame(seq_num);
400}
401
402TEST_F(TestPacketBuffer, TwoIncompleteFramesFullBuffer) {
403 const uint16_t seq_num = Rand();
404
405 for (int i = 1; i < kMaxSize - 1; ++i)
406 EXPECT_TRUE(Insert(seq_num + i, kDeltaFrame, kNotFirst, kNotLast));
407 EXPECT_TRUE(Insert(seq_num, kDeltaFrame, kFirst, kNotLast));
408 EXPECT_TRUE(Insert(seq_num - 1, kDeltaFrame, kNotFirst, kLast));
409
410 ASSERT_EQ(0UL, frames_from_callback_.size());
411}
412
413TEST_F(TestPacketBuffer, FramesReordered) {
414 const uint16_t seq_num = Rand();
415
416 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kFirst, kLast));
417 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
418 EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast));
419 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
philipelf4139332016-04-20 08:26:34420
421 ASSERT_EQ(4UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26422 CheckFrame(seq_num);
423 CheckFrame(seq_num + 1);
424 CheckFrame(seq_num + 2);
425 CheckFrame(seq_num + 3);
philipelf4139332016-04-20 08:26:34426}
427
philipel36928452016-11-07 09:42:36428TEST_F(TestPacketBuffer, GetBitstream) {
philipelc707ab72016-04-01 09:01:54429 // "many bitstream, such data" with null termination.
philipel41b8ca02016-11-07 14:42:24430 uint8_t many_data[] = {0x6d, 0x61, 0x6e, 0x79, 0x20};
431 uint8_t bitstream_data[] = {0x62, 0x69, 0x74, 0x73, 0x74, 0x72,
432 0x65, 0x61, 0x6d, 0x2c, 0x20};
433 uint8_t such_data[] = {0x73, 0x75, 0x63, 0x68, 0x20};
434 uint8_t data_data[] = {0x64, 0x61, 0x74, 0x61, 0x0};
435
436 uint8_t* many = new uint8_t[sizeof(many_data)];
437 uint8_t* bitstream = new uint8_t[sizeof(bitstream_data)];
438 uint8_t* such = new uint8_t[sizeof(such_data)];
439 uint8_t* data = new uint8_t[sizeof(data_data)];
440
441 memcpy(many, many_data, sizeof(many_data));
442 memcpy(bitstream, bitstream_data, sizeof(bitstream_data));
443 memcpy(such, such_data, sizeof(such_data));
444 memcpy(data, data_data, sizeof(data_data));
445
Niels Möller648a7ce2018-11-28 14:14:54446 const size_t result_length = sizeof(many_data) + sizeof(bitstream_data) +
447 sizeof(such_data) + sizeof(data_data);
philipelc707ab72016-04-01 09:01:54448
philipelaee3e0e2016-11-01 10:45:34449 const uint16_t seq_num = Rand();
philipelc707ab72016-04-01 09:01:54450
philipelaee3e0e2016-11-01 10:45:34451 EXPECT_TRUE(
philipel41b8ca02016-11-07 14:42:24452 Insert(seq_num, kKeyFrame, kFirst, kNotLast, sizeof(many_data), many));
453 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast,
454 sizeof(bitstream_data), bitstream));
455 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kNotLast,
456 sizeof(such_data), such));
457 EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kNotFirst, kLast,
458 sizeof(data_data), data));
philipelf4139332016-04-20 08:26:34459
460 ASSERT_EQ(1UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26461 CheckFrame(seq_num);
Niels Möller648a7ce2018-11-28 14:14:54462 EXPECT_EQ(frames_from_callback_[seq_num]->size(), result_length);
Niels Möller9c8439062019-01-11 09:21:35463 EXPECT_EQ(memcmp(frames_from_callback_[seq_num]->data(),
Niels Möller648a7ce2018-11-28 14:14:54464 "many bitstream, such data", result_length),
465 0);
philipelc707ab72016-04-01 09:01:54466}
467
philipel227f8b92017-08-04 13:39:31468TEST_F(TestPacketBuffer, GetBitstreamOneFrameOnePacket) {
469 uint8_t bitstream_data[] = "All the bitstream data for this frame!";
philipel227f8b92017-08-04 13:39:31470 uint8_t* data = new uint8_t[sizeof(bitstream_data)];
471 memcpy(data, bitstream_data, sizeof(bitstream_data));
472
473 EXPECT_TRUE(
474 Insert(0, kKeyFrame, kFirst, kLast, sizeof(bitstream_data), data));
475
476 ASSERT_EQ(1UL, frames_from_callback_.size());
477 CheckFrame(0);
478 EXPECT_EQ(frames_from_callback_[0]->size(), sizeof(bitstream_data));
Johannes Krona3705562019-08-26 14:37:11479 EXPECT_EQ(memcmp(frames_from_callback_[0]->data(), bitstream_data,
480 sizeof(bitstream_data)),
481 0);
philipel227f8b92017-08-04 13:39:31482}
483
484TEST_F(TestPacketBuffer, GetBitstreamOneFrameFullBuffer) {
485 uint8_t* data_arr[kStartSize];
486 uint8_t expected[kStartSize];
philipel227f8b92017-08-04 13:39:31487
488 for (uint8_t i = 0; i < kStartSize; ++i) {
489 data_arr[i] = new uint8_t[1];
490 data_arr[i][0] = i;
491 expected[i] = i;
492 }
493
494 EXPECT_TRUE(Insert(0, kKeyFrame, kFirst, kNotLast, 1, data_arr[0]));
495 for (uint8_t i = 1; i < kStartSize - 1; ++i)
496 EXPECT_TRUE(Insert(i, kKeyFrame, kNotFirst, kNotLast, 1, data_arr[i]));
497 EXPECT_TRUE(Insert(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1,
498 data_arr[kStartSize - 1]));
499
500 ASSERT_EQ(1UL, frames_from_callback_.size());
501 CheckFrame(0);
502 EXPECT_EQ(frames_from_callback_[0]->size(), static_cast<size_t>(kStartSize));
Niels Möller9c8439062019-01-11 09:21:35503 EXPECT_EQ(memcmp(frames_from_callback_[0]->data(), expected, kStartSize), 0);
philipel227f8b92017-08-04 13:39:31504}
505
Johannes Kron957c62e2018-10-01 12:53:01506TEST_F(TestPacketBuffer, InsertPacketAfterOldFrameObjectIsRemoved) {
507 uint16_t kFirstSeqNum = 0;
508 uint32_t kTimestampDelta = 100;
509 uint32_t timestamp = 10000;
510 uint16_t seq_num = kFirstSeqNum;
511
512 // Loop until seq_num wraps around.
Philip Eliasson1f850a62019-03-19 12:15:00513 SeqNumUnwrapper<uint16_t> unwrapper;
Johannes Kron957c62e2018-10-01 12:53:01514 while (unwrapper.Unwrap(seq_num) < std::numeric_limits<uint16_t>::max()) {
515 Insert(seq_num++, kKeyFrame, kFirst, kNotLast, 0, nullptr, timestamp);
516 for (int i = 0; i < 5; ++i) {
517 Insert(seq_num++, kKeyFrame, kNotFirst, kNotLast, 0, nullptr, timestamp);
518 }
519 Insert(seq_num++, kKeyFrame, kNotFirst, kLast, 0, nullptr, timestamp);
520 timestamp += kTimestampDelta;
521 }
522
523 size_t number_of_frames = frames_from_callback_.size();
524 // Delete old frame object while receiving frame with overlapping sequence
525 // numbers.
526 Insert(seq_num++, kKeyFrame, kFirst, kNotLast, 0, nullptr, timestamp);
527 for (int i = 0; i < 5; ++i) {
528 Insert(seq_num++, kKeyFrame, kNotFirst, kNotLast, 0, nullptr, timestamp);
529 }
530 // Delete FrameObject connected to packets that have already been cleared.
531 DeleteFrame(kFirstSeqNum);
532 Insert(seq_num++, kKeyFrame, kNotFirst, kLast, 0, nullptr, timestamp);
533
534 // Regardless of the initial size, the number of frames should be constant
535 // after removing and then adding a new frame object.
536 EXPECT_EQ(number_of_frames, frames_from_callback_.size());
537}
538
Rasmus Brandt88f080a2017-11-02 13:28:06539// If |sps_pps_idr_is_keyframe| is true, we require keyframes to contain
540// SPS/PPS/IDR and the keyframes we create as part of the test do contain
541// SPS/PPS/IDR. If |sps_pps_idr_is_keyframe| is false, we only require and
542// create keyframes containing only IDR.
543class TestPacketBufferH264 : public TestPacketBuffer {
Rasmus Brandtedf4ff72017-10-24 08:07:48544 protected:
Rasmus Brandtedf4ff72017-10-24 08:07:48545 explicit TestPacketBufferH264(bool sps_pps_idr_is_keyframe)
Rasmus Brandt88f080a2017-11-02 13:28:06546 : TestPacketBuffer(sps_pps_idr_is_keyframe
547 ? "WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/"
548 : ""),
549 sps_pps_idr_is_keyframe_(sps_pps_idr_is_keyframe) {}
Rasmus Brandtedf4ff72017-10-24 08:07:48550
551 bool InsertH264(uint16_t seq_num, // packet sequence number
552 IsKeyFrame keyframe, // is keyframe
553 IsFirst first, // is first packet of frame
554 IsLast last, // is last packet of frame
555 uint32_t timestamp, // rtp timestamp
556 int data_size = 0, // size of data
557 uint8_t* data = nullptr) { // data pointer
558 VCMPacket packet;
Niels Möllerd5e02f02019-02-20 12:12:21559 packet.video_header.codec = kVideoCodecH264;
philipel7d745e52018-08-02 12:03:53560 auto& h264_header =
561 packet.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
Rasmus Brandtedf4ff72017-10-24 08:07:48562 packet.seqNum = seq_num;
563 packet.timestamp = timestamp;
564 if (keyframe == kKeyFrame) {
565 if (sps_pps_idr_is_keyframe_) {
philipel7d745e52018-08-02 12:03:53566 h264_header.nalus[0].type = H264::NaluType::kSps;
567 h264_header.nalus[1].type = H264::NaluType::kPps;
568 h264_header.nalus[2].type = H264::NaluType::kIdr;
569 h264_header.nalus_length = 3;
Rasmus Brandtedf4ff72017-10-24 08:07:48570 } else {
philipel7d745e52018-08-02 12:03:53571 h264_header.nalus[0].type = H264::NaluType::kIdr;
572 h264_header.nalus_length = 1;
Rasmus Brandtedf4ff72017-10-24 08:07:48573 }
574 }
Niels Möllerd5e02f02019-02-20 12:12:21575 packet.video_header.is_first_packet_in_frame = first == kFirst;
576 packet.video_header.is_last_packet_in_frame = last == kLast;
Rasmus Brandtedf4ff72017-10-24 08:07:48577 packet.sizeBytes = data_size;
578 packet.dataPtr = data;
579
580 return packet_buffer_->InsertPacket(&packet);
581 }
582
583 const bool sps_pps_idr_is_keyframe_;
Rasmus Brandt88f080a2017-11-02 13:28:06584};
585
586// This fixture is used to test the general behaviour of the packet buffer
587// in both configurations.
588class TestPacketBufferH264Parameterized
589 : public ::testing::WithParamInterface<bool>,
590 public TestPacketBufferH264 {
591 protected:
592 TestPacketBufferH264Parameterized() : TestPacketBufferH264(GetParam()) {}
Rasmus Brandtedf4ff72017-10-24 08:07:48593};
594
Mirko Bonadeic84f6612019-01-31 11:20:57595INSTANTIATE_TEST_SUITE_P(SpsPpsIdrIsKeyframe,
596 TestPacketBufferH264Parameterized,
597 ::testing::Values(false, true));
Rasmus Brandtedf4ff72017-10-24 08:07:48598
philipelbc5a4082017-12-06 09:41:08599TEST_P(TestPacketBufferH264Parameterized, DontRemoveMissingPacketOnClearTo) {
600 EXPECT_TRUE(InsertH264(0, kKeyFrame, kFirst, kLast, 0));
601 EXPECT_TRUE(InsertH264(2, kDeltaFrame, kFirst, kNotLast, 2));
602 packet_buffer_->ClearTo(0);
603 EXPECT_TRUE(InsertH264(3, kDeltaFrame, kNotFirst, kLast, 2));
604
605 ASSERT_EQ(1UL, frames_from_callback_.size());
606 CheckFrame(0);
607}
608
Rasmus Brandt88f080a2017-11-02 13:28:06609TEST_P(TestPacketBufferH264Parameterized, GetBitstreamOneFrameFullBuffer) {
philipel227f8b92017-08-04 13:39:31610 uint8_t* data_arr[kStartSize];
611 uint8_t expected[kStartSize];
philipel227f8b92017-08-04 13:39:31612
613 for (uint8_t i = 0; i < kStartSize; ++i) {
614 data_arr[i] = new uint8_t[1];
615 data_arr[i][0] = i;
616 expected[i] = i;
617 }
618
619 EXPECT_TRUE(InsertH264(0, kKeyFrame, kFirst, kNotLast, 1, 1, data_arr[0]));
620 for (uint8_t i = 1; i < kStartSize - 1; ++i) {
621 EXPECT_TRUE(
622 InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1, 1, data_arr[i]));
623 }
624 EXPECT_TRUE(InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1, 1,
625 data_arr[kStartSize - 1]));
626
627 ASSERT_EQ(1UL, frames_from_callback_.size());
628 CheckFrame(0);
629 EXPECT_EQ(frames_from_callback_[0]->size(), static_cast<size_t>(kStartSize));
Niels Möller9c8439062019-01-11 09:21:35630 EXPECT_EQ(memcmp(frames_from_callback_[0]->data(), expected, kStartSize), 0);
philipel227f8b92017-08-04 13:39:31631}
632
Rasmus Brandt88f080a2017-11-02 13:28:06633TEST_P(TestPacketBufferH264Parameterized, GetBitstreamBufferPadding) {
philipel36928452016-11-07 09:42:36634 uint16_t seq_num = Rand();
philipel41b8ca02016-11-07 14:42:24635 uint8_t data_data[] = "some plain old data";
636 uint8_t* data = new uint8_t[sizeof(data_data)];
637 memcpy(data, data_data, sizeof(data_data));
philipel36928452016-11-07 09:42:36638
philipel36928452016-11-07 09:42:36639 VCMPacket packet;
philipel7d745e52018-08-02 12:03:53640 auto& h264_header =
641 packet.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
642 h264_header.nalus_length = 1;
643 h264_header.nalus[0].type = H264::NaluType::kIdr;
644 h264_header.packetization_type = kH264SingleNalu;
philipel36928452016-11-07 09:42:36645 packet.seqNum = seq_num;
Niels Möllerd5e02f02019-02-20 12:12:21646 packet.video_header.codec = kVideoCodecH264;
philipel36928452016-11-07 09:42:36647 packet.insertStartCode = true;
philipel36928452016-11-07 09:42:36648 packet.dataPtr = data;
philipel41b8ca02016-11-07 14:42:24649 packet.sizeBytes = sizeof(data_data);
Niels Möllerd5e02f02019-02-20 12:12:21650 packet.video_header.is_first_packet_in_frame = true;
651 packet.video_header.is_last_packet_in_frame = true;
philipel759e0b72016-11-30 09:32:05652 packet_buffer_->InsertPacket(&packet);
philipel36928452016-11-07 09:42:36653
654 ASSERT_EQ(1UL, frames_from_callback_.size());
Niels Möller77536a22019-01-15 07:50:01655 EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().size(),
philipel41b8ca02016-11-07 14:42:24656 sizeof(data_data));
Niels Möller48a79462018-12-07 15:21:18657 EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().capacity(),
Niels Möller009ab3c2019-03-08 10:26:58658 sizeof(data_data));
Johannes Krona3705562019-08-26 14:37:11659 EXPECT_EQ(memcmp(frames_from_callback_[seq_num]->data(), data_data,
660 sizeof(data_data)),
661 0);
philipel36928452016-11-07 09:42:36662}
663
Johannes Krona3705562019-08-26 14:37:11664TEST_F(TestPacketBuffer, FreeSlotsOnFrameCreation) {
philipelaee3e0e2016-11-01 10:45:34665 const uint16_t seq_num = Rand();
philipelf4139332016-04-20 08:26:34666
philipelaee3e0e2016-11-01 10:45:34667 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
668 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast));
669 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kLast));
philipelc707ab72016-04-01 09:01:54670 EXPECT_EQ(1UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26671 CheckFrame(seq_num);
philipelc707ab72016-04-01 09:01:54672
philipel17deeb42016-08-11 13:09:26673 // Insert frame that fills the whole buffer.
philipelaee3e0e2016-11-01 10:45:34674 EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kFirst, kNotLast));
philipel17deeb42016-08-11 13:09:26675 for (int i = 0; i < kMaxSize - 2; ++i)
philipelaee3e0e2016-11-01 10:45:34676 EXPECT_TRUE(Insert(seq_num + i + 4, kDeltaFrame, kNotFirst, kNotLast));
677 EXPECT_TRUE(Insert(seq_num + kMaxSize + 2, kKeyFrame, kNotFirst, kLast));
Johannes Krona3705562019-08-26 14:37:11678 EXPECT_EQ(2UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26679 CheckFrame(seq_num + 3);
Johannes Krona3705562019-08-26 14:37:11680
681 frames_from_callback_.clear();
philipelc707ab72016-04-01 09:01:54682}
683
philipel02447bc2016-05-13 13:01:03684TEST_F(TestPacketBuffer, Clear) {
philipelaee3e0e2016-11-01 10:45:34685 const uint16_t seq_num = Rand();
philipelf4139332016-04-20 08:26:34686
philipelaee3e0e2016-11-01 10:45:34687 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
688 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast));
689 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kLast));
philipelf4139332016-04-20 08:26:34690 EXPECT_EQ(1UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26691 CheckFrame(seq_num);
philipelf4139332016-04-20 08:26:34692
philipel02447bc2016-05-13 13:01:03693 packet_buffer_->Clear();
philipelf4139332016-04-20 08:26:34694
philipelaee3e0e2016-11-01 10:45:34695 EXPECT_TRUE(Insert(seq_num + kStartSize, kKeyFrame, kFirst, kNotLast));
696 EXPECT_TRUE(
697 Insert(seq_num + kStartSize + 1, kDeltaFrame, kNotFirst, kNotLast));
698 EXPECT_TRUE(Insert(seq_num + kStartSize + 2, kDeltaFrame, kNotFirst, kLast));
philipelc707ab72016-04-01 09:01:54699 EXPECT_EQ(2UL, frames_from_callback_.size());
philipel17deeb42016-08-11 13:09:26700 CheckFrame(seq_num + kStartSize);
philipelc707ab72016-04-01 09:01:54701}
702
philipel20dce342016-11-28 15:14:57703TEST_F(TestPacketBuffer, FramesAfterClear) {
704 Insert(9025, kDeltaFrame, kFirst, kLast);
705 Insert(9024, kKeyFrame, kFirst, kLast);
706 packet_buffer_->ClearTo(9025);
707 Insert(9057, kDeltaFrame, kFirst, kLast);
708 Insert(9026, kDeltaFrame, kFirst, kLast);
709
710 CheckFrame(9024);
711 CheckFrame(9025);
712 CheckFrame(9026);
713 CheckFrame(9057);
714}
715
philipel8b6995b2019-01-09 11:39:18716TEST_F(TestPacketBuffer, SameFrameDifferentTimestamps) {
717 Insert(0, kKeyFrame, kFirst, kNotLast, 0, nullptr, 1000);
718 Insert(1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 1001);
719
720 ASSERT_EQ(0UL, frames_from_callback_.size());
721}
722
philipel759e0b72016-11-30 09:32:05723TEST_F(TestPacketBuffer, DontLeakPayloadData) {
724 // NOTE! Any eventual leak is suppose to be detected by valgrind
725 // or any other similar tool.
726 uint8_t* data1 = new uint8_t[5];
727 uint8_t* data2 = new uint8_t[5];
728 uint8_t* data3 = new uint8_t[5];
729 uint8_t* data4 = new uint8_t[5];
730
731 // Expected to free data1 upon PacketBuffer destruction.
732 EXPECT_TRUE(Insert(2, kKeyFrame, kFirst, kNotLast, 5, data1));
733
734 // Expect to free data2 upon insertion.
735 EXPECT_TRUE(Insert(2, kKeyFrame, kFirst, kNotLast, 5, data2));
736
737 // Expect to free data3 upon insertion (old packet).
738 packet_buffer_->ClearTo(1);
Johannes Kronbd3f3052019-08-01 13:45:54739 EXPECT_TRUE(Insert(1, kKeyFrame, kFirst, kNotLast, 5, data3));
philipel759e0b72016-11-30 09:32:05740
741 // Expect to free data4 upon insertion (packet buffer is full).
Johannes Kronbd3f3052019-08-01 13:45:54742 EXPECT_FALSE(Insert(2 + kMaxSize, kKeyFrame, kFirst, kNotLast, 5, data4));
philipel759e0b72016-11-30 09:32:05743}
744
philipelea142f82017-01-11 10:01:56745TEST_F(TestPacketBuffer, ContinuousSeqNumDoubleMarkerBit) {
746 Insert(2, kKeyFrame, kNotFirst, kNotLast);
747 Insert(1, kKeyFrame, kFirst, kLast);
748 frames_from_callback_.clear();
749 Insert(3, kKeyFrame, kNotFirst, kLast);
750
751 EXPECT_EQ(0UL, frames_from_callback_.size());
752}
753
philipel3184f8e2017-05-18 15:08:53754TEST_F(TestPacketBuffer, PacketTimestamps) {
Danil Chapovalov0040b662018-06-18 08:48:16755 absl::optional<int64_t> packet_ms;
756 absl::optional<int64_t> packet_keyframe_ms;
philipel3184f8e2017-05-18 15:08:53757
758 packet_ms = packet_buffer_->LastReceivedPacketMs();
759 packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
760 EXPECT_FALSE(packet_ms);
761 EXPECT_FALSE(packet_keyframe_ms);
762
763 int64_t keyframe_ms = clock_->TimeInMilliseconds();
764 EXPECT_TRUE(Insert(100, kKeyFrame, kFirst, kLast));
765 packet_ms = packet_buffer_->LastReceivedPacketMs();
766 packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
767 EXPECT_TRUE(packet_ms);
768 EXPECT_TRUE(packet_keyframe_ms);
769 EXPECT_EQ(keyframe_ms, *packet_ms);
770 EXPECT_EQ(keyframe_ms, *packet_keyframe_ms);
771
772 clock_->AdvanceTimeMilliseconds(100);
773 int64_t delta_ms = clock_->TimeInMilliseconds();
774 EXPECT_TRUE(Insert(101, kDeltaFrame, kFirst, kLast));
775 packet_ms = packet_buffer_->LastReceivedPacketMs();
776 packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
777 EXPECT_TRUE(packet_ms);
778 EXPECT_TRUE(packet_keyframe_ms);
779 EXPECT_EQ(delta_ms, *packet_ms);
780 EXPECT_EQ(keyframe_ms, *packet_keyframe_ms);
781
782 packet_buffer_->Clear();
783 packet_ms = packet_buffer_->LastReceivedPacketMs();
784 packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
785 EXPECT_FALSE(packet_ms);
786 EXPECT_FALSE(packet_keyframe_ms);
787}
788
philipel09133af2018-05-17 12:11:09789TEST_F(TestPacketBuffer, IncomingCodecChange) {
790 VCMPacket packet;
Niels Möllerd5e02f02019-02-20 12:12:21791 packet.video_header.is_first_packet_in_frame = true;
792 packet.video_header.is_last_packet_in_frame = true;
philipel09133af2018-05-17 12:11:09793 packet.sizeBytes = 0;
794 packet.dataPtr = nullptr;
795
Niels Möllerd5e02f02019-02-20 12:12:21796 packet.video_header.codec = kVideoCodecVP8;
797 packet.video_header.video_type_header.emplace<RTPVideoHeaderVP8>();
philipel09133af2018-05-17 12:11:09798 packet.timestamp = 1;
799 packet.seqNum = 1;
Niels Möllerabbc50e2019-04-24 07:41:16800 packet.video_header.frame_type = VideoFrameType::kVideoFrameKey;
philipel09133af2018-05-17 12:11:09801 EXPECT_TRUE(packet_buffer_->InsertPacket(&packet));
802
Niels Möllerd5e02f02019-02-20 12:12:21803 packet.video_header.codec = kVideoCodecH264;
philipel7d745e52018-08-02 12:03:53804 auto& h264_header =
805 packet.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
806 h264_header.nalus_length = 1;
philipel09133af2018-05-17 12:11:09807 packet.timestamp = 3;
808 packet.seqNum = 3;
809 EXPECT_TRUE(packet_buffer_->InsertPacket(&packet));
810
Niels Möllerd5e02f02019-02-20 12:12:21811 packet.video_header.codec = kVideoCodecVP8;
812 packet.video_header.video_type_header.emplace<RTPVideoHeaderVP8>();
philipel09133af2018-05-17 12:11:09813 packet.timestamp = 2;
814 packet.seqNum = 2;
Niels Möllerabbc50e2019-04-24 07:41:16815 packet.video_header.frame_type = VideoFrameType::kVideoFrameDelta;
philipel09133af2018-05-17 12:11:09816
817 EXPECT_TRUE(packet_buffer_->InsertPacket(&packet));
818
819 EXPECT_EQ(3UL, frames_from_callback_.size());
820}
821
822TEST_F(TestPacketBuffer, TooManyNalusInPacket) {
823 VCMPacket packet;
Niels Möllerd5e02f02019-02-20 12:12:21824 packet.video_header.codec = kVideoCodecH264;
philipel09133af2018-05-17 12:11:09825 packet.timestamp = 1;
826 packet.seqNum = 1;
Niels Möllerabbc50e2019-04-24 07:41:16827 packet.video_header.frame_type = VideoFrameType::kVideoFrameKey;
Niels Möllerd5e02f02019-02-20 12:12:21828 packet.video_header.is_first_packet_in_frame = true;
829 packet.video_header.is_last_packet_in_frame = true;
philipel7d745e52018-08-02 12:03:53830 auto& h264_header =
831 packet.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
832 h264_header.nalus_length = kMaxNalusPerPacket;
philipel09133af2018-05-17 12:11:09833 packet.sizeBytes = 0;
834 packet.dataPtr = nullptr;
835 EXPECT_TRUE(packet_buffer_->InsertPacket(&packet));
836
837 EXPECT_EQ(0UL, frames_from_callback_.size());
838}
839
Rasmus Brandt88f080a2017-11-02 13:28:06840TEST_P(TestPacketBufferH264Parameterized, OneFrameFillBuffer) {
philipel2c9f9f22017-06-13 09:47:28841 InsertH264(0, kKeyFrame, kFirst, kNotLast, 1000);
842 for (int i = 1; i < kStartSize - 1; ++i)
843 InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1000);
844 InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1000);
845
846 EXPECT_EQ(1UL, frames_from_callback_.size());
847 CheckFrame(0);
848}
849
Rasmus Brandt88f080a2017-11-02 13:28:06850TEST_P(TestPacketBufferH264Parameterized, CreateFramesAfterFilledBuffer) {
philipel227f8b92017-08-04 13:39:31851 InsertH264(kStartSize - 2, kKeyFrame, kFirst, kLast, 0);
852 ASSERT_EQ(1UL, frames_from_callback_.size());
853 frames_from_callback_.clear();
854
855 InsertH264(kStartSize, kDeltaFrame, kFirst, kNotLast, 2000);
856 for (int i = 1; i < kStartSize; ++i)
857 InsertH264(kStartSize + i, kDeltaFrame, kNotFirst, kNotLast, 2000);
858 InsertH264(kStartSize + kStartSize, kDeltaFrame, kNotFirst, kLast, 2000);
859 ASSERT_EQ(0UL, frames_from_callback_.size());
860
861 InsertH264(kStartSize - 1, kKeyFrame, kFirst, kLast, 1000);
862 ASSERT_EQ(2UL, frames_from_callback_.size());
863 CheckFrame(kStartSize - 1);
864 CheckFrame(kStartSize);
865}
866
Rasmus Brandt88f080a2017-11-02 13:28:06867TEST_P(TestPacketBufferH264Parameterized, OneFrameMaxSeqNum) {
philipel2c9f9f22017-06-13 09:47:28868 InsertH264(65534, kKeyFrame, kFirst, kNotLast, 1000);
869 InsertH264(65535, kKeyFrame, kNotFirst, kLast, 1000);
870
871 EXPECT_EQ(1UL, frames_from_callback_.size());
872 CheckFrame(65534);
873}
874
Rasmus Brandt88f080a2017-11-02 13:28:06875TEST_P(TestPacketBufferH264Parameterized, ClearMissingPacketsOnKeyframe) {
philipel2c9f9f22017-06-13 09:47:28876 InsertH264(0, kKeyFrame, kFirst, kLast, 1000);
877 InsertH264(2, kKeyFrame, kFirst, kLast, 3000);
878 InsertH264(3, kDeltaFrame, kFirst, kNotLast, 4000);
879 InsertH264(4, kDeltaFrame, kNotFirst, kLast, 4000);
880
881 ASSERT_EQ(3UL, frames_from_callback_.size());
882
883 InsertH264(kStartSize + 1, kKeyFrame, kFirst, kLast, 18000);
884
885 ASSERT_EQ(4UL, frames_from_callback_.size());
886 CheckFrame(0);
887 CheckFrame(2);
888 CheckFrame(3);
889 CheckFrame(kStartSize + 1);
890}
891
Rasmus Brandt88f080a2017-11-02 13:28:06892TEST_P(TestPacketBufferH264Parameterized, FindFramesOnPadding) {
philipel2c9f9f22017-06-13 09:47:28893 InsertH264(0, kKeyFrame, kFirst, kLast, 1000);
894 InsertH264(2, kDeltaFrame, kFirst, kLast, 1000);
895
896 ASSERT_EQ(1UL, frames_from_callback_.size());
897 packet_buffer_->PaddingReceived(1);
898 ASSERT_EQ(2UL, frames_from_callback_.size());
899 CheckFrame(0);
900 CheckFrame(2);
901}
902
Rasmus Brandtedf4ff72017-10-24 08:07:48903class TestPacketBufferH264XIsKeyframe : public TestPacketBufferH264 {
904 protected:
905 const uint16_t kSeqNum = 5;
906
907 explicit TestPacketBufferH264XIsKeyframe(bool sps_pps_idr_is_keyframe)
908 : TestPacketBufferH264(sps_pps_idr_is_keyframe) {
Niels Möllerd5e02f02019-02-20 12:12:21909 packet_.video_header.codec = kVideoCodecH264;
Rasmus Brandtedf4ff72017-10-24 08:07:48910 packet_.seqNum = kSeqNum;
911
Niels Möllerd5e02f02019-02-20 12:12:21912 packet_.video_header.is_first_packet_in_frame = true;
913 packet_.video_header.is_last_packet_in_frame = true;
Rasmus Brandtedf4ff72017-10-24 08:07:48914 }
915
916 VCMPacket packet_;
917};
918
919class TestPacketBufferH264IdrIsKeyframe
920 : public TestPacketBufferH264XIsKeyframe {
921 protected:
922 TestPacketBufferH264IdrIsKeyframe()
923 : TestPacketBufferH264XIsKeyframe(false) {}
924};
925
926TEST_F(TestPacketBufferH264IdrIsKeyframe, IdrIsKeyframe) {
philipel7d745e52018-08-02 12:03:53927 auto& h264_header =
928 packet_.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
929 h264_header.nalus[0].type = H264::NaluType::kIdr;
930 h264_header.nalus_length = 1;
Rasmus Brandtedf4ff72017-10-24 08:07:48931 packet_buffer_->InsertPacket(&packet_);
932
933 ASSERT_EQ(1u, frames_from_callback_.size());
Niels Möller8f7ce222019-03-21 14:43:58934 EXPECT_EQ(VideoFrameType::kVideoFrameKey,
935 frames_from_callback_[kSeqNum]->frame_type());
Rasmus Brandtedf4ff72017-10-24 08:07:48936}
937
938TEST_F(TestPacketBufferH264IdrIsKeyframe, SpsPpsIdrIsKeyframe) {
philipel7d745e52018-08-02 12:03:53939 auto& h264_header =
940 packet_.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
941 h264_header.nalus[0].type = H264::NaluType::kSps;
942 h264_header.nalus[1].type = H264::NaluType::kPps;
943 h264_header.nalus[2].type = H264::NaluType::kIdr;
944 h264_header.nalus_length = 3;
Rasmus Brandtedf4ff72017-10-24 08:07:48945
946 packet_buffer_->InsertPacket(&packet_);
947
948 ASSERT_EQ(1u, frames_from_callback_.size());
Niels Möller8f7ce222019-03-21 14:43:58949 EXPECT_EQ(VideoFrameType::kVideoFrameKey,
950 frames_from_callback_[kSeqNum]->frame_type());
Rasmus Brandtedf4ff72017-10-24 08:07:48951}
952
953class TestPacketBufferH264SpsPpsIdrIsKeyframe
954 : public TestPacketBufferH264XIsKeyframe {
955 protected:
956 TestPacketBufferH264SpsPpsIdrIsKeyframe()
957 : TestPacketBufferH264XIsKeyframe(true) {}
958};
959
960TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, IdrIsNotKeyframe) {
philipel7d745e52018-08-02 12:03:53961 auto& h264_header =
962 packet_.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
963 h264_header.nalus[0].type = H264::NaluType::kIdr;
964 h264_header.nalus_length = 1;
Rasmus Brandtedf4ff72017-10-24 08:07:48965
966 packet_buffer_->InsertPacket(&packet_);
967
968 ASSERT_EQ(1u, frames_from_callback_.size());
Niels Möller8f7ce222019-03-21 14:43:58969 EXPECT_EQ(VideoFrameType::kVideoFrameDelta,
970 frames_from_callback_[5]->frame_type());
Rasmus Brandtedf4ff72017-10-24 08:07:48971}
972
973TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, SpsPpsIsNotKeyframe) {
philipel7d745e52018-08-02 12:03:53974 auto& h264_header =
975 packet_.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
976 h264_header.nalus[0].type = H264::NaluType::kSps;
977 h264_header.nalus[1].type = H264::NaluType::kPps;
978 h264_header.nalus_length = 2;
Rasmus Brandtedf4ff72017-10-24 08:07:48979
980 packet_buffer_->InsertPacket(&packet_);
981
982 ASSERT_EQ(1u, frames_from_callback_.size());
Niels Möller8f7ce222019-03-21 14:43:58983 EXPECT_EQ(VideoFrameType::kVideoFrameDelta,
984 frames_from_callback_[kSeqNum]->frame_type());
Rasmus Brandtedf4ff72017-10-24 08:07:48985}
986
987TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, SpsPpsIdrIsKeyframe) {
philipel7d745e52018-08-02 12:03:53988 auto& h264_header =
989 packet_.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
990 h264_header.nalus[0].type = H264::NaluType::kSps;
991 h264_header.nalus[1].type = H264::NaluType::kPps;
992 h264_header.nalus[2].type = H264::NaluType::kIdr;
993 h264_header.nalus_length = 3;
Rasmus Brandtedf4ff72017-10-24 08:07:48994
995 packet_buffer_->InsertPacket(&packet_);
996
997 ASSERT_EQ(1u, frames_from_callback_.size());
Niels Möller8f7ce222019-03-21 14:43:58998 EXPECT_EQ(VideoFrameType::kVideoFrameKey,
999 frames_from_callback_[kSeqNum]->frame_type());
Rasmus Brandtedf4ff72017-10-24 08:07:481000}
1001
philipelc707ab72016-04-01 09:01:541002} // namespace video_coding
1003} // namespace webrtc