blob: 2872c8d2a9c319ec05e43386630dcdd7d3deada8 [file] [log] [blame]
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +00001/*
2 * Copyright (c) 2013 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
Erik Språngc84cd952018-10-15 11:55:13 +020011#include "api/test/mock_video_decoder.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020012#include "modules/video_coding/include/video_coding.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020013#include "modules/video_coding/timing.h"
14#include "modules/video_coding/video_coding_impl.h"
15#include "system_wrappers/include/clock.h"
16#include "test/gtest.h"
17#include "test/video_codec_settings.h"
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000018
19using ::testing::_;
tommid0a71ba2017-03-14 04:16:20 -070020using ::testing::AnyNumber;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000021using ::testing::NiceMock;
22
23namespace webrtc {
24namespace vcm {
25namespace {
26
Niels Möller2fca9712020-02-04 10:46:37 +010027class MockPacketRequestCallback : public VCMPacketRequestCallback {
28 public:
Danil Chapovalovf2c0f152020-05-19 13:20:27 +020029 MOCK_METHOD(int32_t,
30 ResendPackets,
31 (const uint16_t* sequenceNumbers, uint16_t length),
32 (override));
Niels Möller2fca9712020-02-04 10:46:37 +010033};
34
35class MockVCMReceiveCallback : public VCMReceiveCallback {
36 public:
37 MockVCMReceiveCallback() {}
38 virtual ~MockVCMReceiveCallback() {}
39
Danil Chapovalovf2c0f152020-05-19 13:20:27 +020040 MOCK_METHOD(int32_t,
41 FrameToRender,
42 (VideoFrame&, absl::optional<uint8_t>, int32_t, VideoContentType),
43 (override));
44 MOCK_METHOD(void, OnIncomingPayloadType, (int), (override));
45 MOCK_METHOD(void, OnDecoderImplementationName, (const char*), (override));
Niels Möller2fca9712020-02-04 10:46:37 +010046};
47
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000048class TestVideoReceiver : public ::testing::Test {
49 protected:
50 static const int kUnusedPayloadType = 10;
Åsa Persson86202532019-01-09 14:03:59 +010051 static const uint16_t kMaxWaitTimeMs = 100;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000052
Åsa Persson86202532019-01-09 14:03:59 +010053 TestVideoReceiver()
54 : clock_(0), timing_(&clock_), receiver_(&clock_, &timing_) {}
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000055
56 virtual void SetUp() {
Åsa Persson86202532019-01-09 14:03:59 +010057 // Register decoder.
58 receiver_.RegisterExternalDecoder(&decoder_, kUnusedPayloadType);
59 webrtc::test::CodecSettings(kVideoCodecVP8, &settings_);
60 settings_.plType = kUnusedPayloadType;
61 EXPECT_EQ(0, receiver_.RegisterReceiveCodec(&settings_, 1, true));
62
63 // Set protection mode.
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000064 const size_t kMaxNackListSize = 250;
65 const int kMaxPacketAgeToNack = 450;
Åsa Persson86202532019-01-09 14:03:59 +010066 receiver_.SetNackSettings(kMaxNackListSize, kMaxPacketAgeToNack, 0);
Åsa Persson86202532019-01-09 14:03:59 +010067 EXPECT_EQ(
68 0, receiver_.RegisterPacketRequestCallback(&packet_request_callback_));
tommid0a71ba2017-03-14 04:16:20 -070069
70 // Since we call Decode, we need to provide a valid receive callback.
71 // However, for the purposes of these tests, we ignore the callbacks.
72 EXPECT_CALL(receive_callback_, OnIncomingPayloadType(_)).Times(AnyNumber());
73 EXPECT_CALL(receive_callback_, OnDecoderImplementationName(_))
74 .Times(AnyNumber());
Åsa Persson86202532019-01-09 14:03:59 +010075 receiver_.RegisterReceiveCallback(&receive_callback_);
76 }
77
Niels Möllerbe7a0ec2019-04-25 10:02:52 +020078 RTPHeader GetDefaultRTPHeader() const {
79 RTPHeader header;
80 header.markerBit = false;
81 header.payloadType = kUnusedPayloadType;
82 header.ssrc = 1;
83 header.headerLength = 12;
Åsa Persson86202532019-01-09 14:03:59 +010084 return header;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000085 }
86
Niels Möllerbe7a0ec2019-04-25 10:02:52 +020087 RTPVideoHeader GetDefaultVp8Header() const {
88 RTPVideoHeader video_header = {};
89 video_header.frame_type = VideoFrameType::kEmptyFrame;
90 video_header.codec = kVideoCodecVP8;
91 return video_header;
92 }
93
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000094 void InsertAndVerifyPaddingFrame(const uint8_t* payload,
Niels Möllerbe7a0ec2019-04-25 10:02:52 +020095 RTPHeader* header,
96 const RTPVideoHeader& video_header) {
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +000097 for (int j = 0; j < 5; ++j) {
98 // Padding only packets are passed to the VCM with payload size 0.
Niels Möllerbe7a0ec2019-04-25 10:02:52 +020099 EXPECT_EQ(0, receiver_.IncomingPacket(payload, 0, *header, video_header));
100 ++header->sequenceNumber;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000101 }
Åsa Persson86202532019-01-09 14:03:59 +0100102 receiver_.Process();
Niels Möller7aacdd92019-03-25 09:11:40 +0100103 EXPECT_CALL(decoder_, Decode(_, _, _)).Times(0);
Åsa Persson86202532019-01-09 14:03:59 +0100104 EXPECT_EQ(VCM_FRAME_NOT_READY, receiver_.Decode(kMaxWaitTimeMs));
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000105 }
106
107 void InsertAndVerifyDecodableFrame(const uint8_t* payload,
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000108 size_t length,
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200109 RTPHeader* header,
110 const RTPVideoHeader& video_header) {
111 EXPECT_EQ(0,
112 receiver_.IncomingPacket(payload, length, *header, video_header));
113 ++header->sequenceNumber;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000114 EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
Åsa Persson86202532019-01-09 14:03:59 +0100115
116 receiver_.Process();
Niels Möller7aacdd92019-03-25 09:11:40 +0100117 EXPECT_CALL(decoder_, Decode(_, _, _)).Times(1);
Åsa Persson86202532019-01-09 14:03:59 +0100118 EXPECT_EQ(0, receiver_.Decode(kMaxWaitTimeMs));
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000119 }
120
121 SimulatedClock clock_;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000122 VideoCodec settings_;
123 NiceMock<MockVideoDecoder> decoder_;
124 NiceMock<MockPacketRequestCallback> packet_request_callback_;
Åsa Persson86202532019-01-09 14:03:59 +0100125 VCMTiming timing_;
tommid0a71ba2017-03-14 04:16:20 -0700126 MockVCMReceiveCallback receive_callback_;
Åsa Persson86202532019-01-09 14:03:59 +0100127 VideoReceiver receiver_;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000128};
129
130TEST_F(TestVideoReceiver, PaddingOnlyFrames) {
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000131 const size_t kPaddingSize = 220;
Åsa Persson86202532019-01-09 14:03:59 +0100132 const uint8_t kPayload[kPaddingSize] = {0};
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200133 RTPHeader header = GetDefaultRTPHeader();
134 RTPVideoHeader video_header = GetDefaultVp8Header();
135 header.paddingLength = kPaddingSize;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000136 for (int i = 0; i < 10; ++i) {
137 EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200138 InsertAndVerifyPaddingFrame(kPayload, &header, video_header);
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000139 clock_.AdvanceTimeMilliseconds(33);
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200140 header.timestamp += 3000;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000141 }
142}
143
144TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000145 const size_t kFrameSize = 1200;
146 const size_t kPaddingSize = 220;
Åsa Persson86202532019-01-09 14:03:59 +0100147 const uint8_t kPayload[kFrameSize] = {0};
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200148 RTPHeader header = GetDefaultRTPHeader();
149 RTPVideoHeader video_header = GetDefaultVp8Header();
150 header.paddingLength = kPaddingSize;
151 video_header.video_type_header.emplace<RTPVideoHeaderVP8>();
Åsa Persson86202532019-01-09 14:03:59 +0100152
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000153 // Insert one video frame to get one frame decoded.
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200154 video_header.frame_type = VideoFrameType::kVideoFrameKey;
155 video_header.is_first_packet_in_frame = true;
156 header.markerBit = true;
157 InsertAndVerifyDecodableFrame(kPayload, kFrameSize, &header, video_header);
Åsa Persson86202532019-01-09 14:03:59 +0100158
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000159 clock_.AdvanceTimeMilliseconds(33);
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200160 header.timestamp += 3000;
161 video_header.frame_type = VideoFrameType::kEmptyFrame;
162 video_header.is_first_packet_in_frame = false;
163 header.markerBit = false;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000164 // Insert padding frames.
165 for (int i = 0; i < 10; ++i) {
166 // Lose one packet from the 6th frame.
167 if (i == 5) {
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200168 ++header.sequenceNumber;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000169 }
170 // Lose the 4th frame.
171 if (i == 3) {
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200172 header.sequenceNumber += 5;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000173 } else {
174 if (i > 3 && i < 5) {
175 EXPECT_CALL(packet_request_callback_, ResendPackets(_, 5)).Times(1);
176 } else if (i >= 5) {
177 EXPECT_CALL(packet_request_callback_, ResendPackets(_, 6)).Times(1);
178 } else {
179 EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
180 }
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200181 InsertAndVerifyPaddingFrame(kPayload, &header, video_header);
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000182 }
183 clock_.AdvanceTimeMilliseconds(33);
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200184 header.timestamp += 3000;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000185 }
186}
187
188TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000189 const size_t kFrameSize = 1200;
190 const size_t kPaddingSize = 220;
Åsa Persson86202532019-01-09 14:03:59 +0100191 const uint8_t kPayload[kFrameSize] = {0};
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200192 RTPHeader header = GetDefaultRTPHeader();
193 RTPVideoHeader video_header = GetDefaultVp8Header();
194 video_header.is_first_packet_in_frame = false;
195 header.paddingLength = kPaddingSize;
Philip Eliassond52a1a62018-09-07 13:03:55 +0000196 auto& vp8_header =
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200197 video_header.video_type_header.emplace<RTPVideoHeaderVP8>();
Philip Eliassond52a1a62018-09-07 13:03:55 +0000198 vp8_header.pictureId = -1;
199 vp8_header.tl0PicIdx = -1;
Åsa Persson86202532019-01-09 14:03:59 +0100200
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000201 for (int i = 0; i < 3; ++i) {
202 // Insert 2 video frames.
203 for (int j = 0; j < 2; ++j) {
204 if (i == 0 && j == 0) // First frame should be a key frame.
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200205 video_header.frame_type = VideoFrameType::kVideoFrameKey;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000206 else
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200207 video_header.frame_type = VideoFrameType::kVideoFrameDelta;
208 video_header.is_first_packet_in_frame = true;
209 header.markerBit = true;
210 InsertAndVerifyDecodableFrame(kPayload, kFrameSize, &header,
211 video_header);
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000212 clock_.AdvanceTimeMilliseconds(33);
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200213 header.timestamp += 3000;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000214 }
215
216 // Insert 2 padding only frames.
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200217 video_header.frame_type = VideoFrameType::kEmptyFrame;
218 video_header.is_first_packet_in_frame = false;
219 header.markerBit = false;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000220 for (int j = 0; j < 2; ++j) {
Åsa Persson86202532019-01-09 14:03:59 +0100221 // InsertAndVerifyPaddingFrame(kPayload, &header);
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000222 clock_.AdvanceTimeMilliseconds(33);
Niels Möllerbe7a0ec2019-04-25 10:02:52 +0200223 header.timestamp += 3000;
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000224 }
225 }
226}
227
andresp@webrtc.orge401c2e2013-09-16 20:29:13 +0000228} // namespace
229} // namespace vcm
230} // namespace webrtc