1 /*
2 * Copyright (c) 2018 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 "video/buffered_frame_decryptor.h"
12
13 #include <map>
14 #include <memory>
15 #include <vector>
16
17 #include "api/test/mock_frame_decryptor.h"
18 #include "modules/video_coding/packet_buffer.h"
19 #include "rtc_base/ref_counted_object.h"
20 #include "system_wrappers/include/clock.h"
21 #include "test/gmock.h"
22 #include "test/gtest.h"
23
24 using ::testing::Return;
25
26 namespace webrtc {
27 namespace {
28
DecryptSuccess()29 FrameDecryptorInterface::Result DecryptSuccess() {
30 return FrameDecryptorInterface::Result(FrameDecryptorInterface::Status::kOk,
31 0);
32 }
33
DecryptFail()34 FrameDecryptorInterface::Result DecryptFail() {
35 return FrameDecryptorInterface::Result(
36 FrameDecryptorInterface::Status::kFailedToDecrypt, 0);
37 }
38
39 } // namespace
40
41 class BufferedFrameDecryptorTest : public ::testing::Test,
42 public OnDecryptedFrameCallback,
43 public OnDecryptionStatusChangeCallback {
44 public:
45 // Implements the OnDecryptedFrameCallbackInterface
OnDecryptedFrame(std::unique_ptr<video_coding::RtpFrameObject> frame)46 void OnDecryptedFrame(
47 std::unique_ptr<video_coding::RtpFrameObject> frame) override {
48 decrypted_frame_call_count_++;
49 }
50
OnDecryptionStatusChange(FrameDecryptorInterface::Status status)51 void OnDecryptionStatusChange(FrameDecryptorInterface::Status status) {
52 ++decryption_status_change_count_;
53 }
54
55 // Returns a new fake RtpFrameObject it abstracts the difficult construction
56 // of the RtpFrameObject to simplify testing.
CreateRtpFrameObject(bool key_frame)57 std::unique_ptr<video_coding::RtpFrameObject> CreateRtpFrameObject(
58 bool key_frame) {
59 seq_num_++;
60 RTPVideoHeader rtp_video_header;
61 rtp_video_header.generic.emplace();
62
63 // clang-format off
64 return std::make_unique<video_coding::RtpFrameObject>(
65 seq_num_,
66 seq_num_,
67 /*markerBit=*/true,
68 /*times_nacked=*/0,
69 /*first_packet_received_time=*/0,
70 /*last_packet_received_time=*/0,
71 /*rtp_timestamp=*/0,
72 /*ntp_time_ms=*/0,
73 VideoSendTiming(),
74 /*payload_type=*/0,
75 kVideoCodecGeneric,
76 kVideoRotation_0,
77 VideoContentType::UNSPECIFIED,
78 rtp_video_header,
79 /*color_space=*/absl::nullopt,
80 RtpPacketInfos(),
81 EncodedImageBuffer::Create(/*size=*/0));
82 // clang-format on
83 }
84
85 protected:
BufferedFrameDecryptorTest()86 BufferedFrameDecryptorTest() {
87 fake_packet_data_ = std::vector<uint8_t>(100);
88 decrypted_frame_call_count_ = 0;
89 decryption_status_change_count_ = 0;
90 seq_num_ = 0;
91 mock_frame_decryptor_ = new rtc::RefCountedObject<MockFrameDecryptor>();
92 buffered_frame_decryptor_ =
93 std::make_unique<BufferedFrameDecryptor>(this, this);
94 buffered_frame_decryptor_->SetFrameDecryptor(mock_frame_decryptor_.get());
95 }
96
97 static const size_t kMaxStashedFrames;
98
99 std::vector<uint8_t> fake_packet_data_;
100 rtc::scoped_refptr<MockFrameDecryptor> mock_frame_decryptor_;
101 std::unique_ptr<BufferedFrameDecryptor> buffered_frame_decryptor_;
102 size_t decrypted_frame_call_count_;
103 size_t decryption_status_change_count_ = 0;
104 uint16_t seq_num_;
105 };
106
107 const size_t BufferedFrameDecryptorTest::kMaxStashedFrames = 24;
108
109 // Callback should always be triggered on a successful decryption.
TEST_F(BufferedFrameDecryptorTest,CallbackCalledOnSuccessfulDecryption)110 TEST_F(BufferedFrameDecryptorTest, CallbackCalledOnSuccessfulDecryption) {
111 EXPECT_CALL(*mock_frame_decryptor_, Decrypt)
112 .Times(1)
113 .WillOnce(Return(DecryptSuccess()));
114 EXPECT_CALL(*mock_frame_decryptor_, GetMaxPlaintextByteSize)
115 .Times(1)
116 .WillOnce(Return(0));
117 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
118 EXPECT_EQ(decrypted_frame_call_count_, static_cast<size_t>(1));
119 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(1));
120 }
121
122 // An initial fail to decrypt should not trigger the callback.
TEST_F(BufferedFrameDecryptorTest,CallbackNotCalledOnFailedDecryption)123 TEST_F(BufferedFrameDecryptorTest, CallbackNotCalledOnFailedDecryption) {
124 EXPECT_CALL(*mock_frame_decryptor_, Decrypt)
125 .Times(1)
126 .WillOnce(Return(DecryptFail()));
127 EXPECT_CALL(*mock_frame_decryptor_, GetMaxPlaintextByteSize)
128 .Times(1)
129 .WillOnce(Return(0));
130 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
131 EXPECT_EQ(decrypted_frame_call_count_, static_cast<size_t>(0));
132 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(1));
133 }
134
135 // Initial failures should be stored and retried after the first successful
136 // decryption.
TEST_F(BufferedFrameDecryptorTest,DelayedCallbackOnBufferedFrames)137 TEST_F(BufferedFrameDecryptorTest, DelayedCallbackOnBufferedFrames) {
138 EXPECT_CALL(*mock_frame_decryptor_, Decrypt)
139 .Times(3)
140 .WillOnce(Return(DecryptFail()))
141 .WillOnce(Return(DecryptSuccess()))
142 .WillOnce(Return(DecryptSuccess()));
143 EXPECT_CALL(*mock_frame_decryptor_, GetMaxPlaintextByteSize)
144 .Times(3)
145 .WillRepeatedly(Return(0));
146
147 // The first decrypt will fail stashing the first frame.
148 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
149 EXPECT_EQ(decrypted_frame_call_count_, static_cast<size_t>(0));
150 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(1));
151 // The second call will succeed playing back both frames.
152 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(false));
153 EXPECT_EQ(decrypted_frame_call_count_, static_cast<size_t>(2));
154 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(2));
155 }
156
157 // Subsequent failure to decrypts after the first successful decryption should
158 // fail to decryptk
TEST_F(BufferedFrameDecryptorTest,FTDDiscardedAfterFirstSuccess)159 TEST_F(BufferedFrameDecryptorTest, FTDDiscardedAfterFirstSuccess) {
160 EXPECT_CALL(*mock_frame_decryptor_, Decrypt)
161 .Times(4)
162 .WillOnce(Return(DecryptFail()))
163 .WillOnce(Return(DecryptSuccess()))
164 .WillOnce(Return(DecryptSuccess()))
165 .WillOnce(Return(DecryptFail()));
166 EXPECT_CALL(*mock_frame_decryptor_, GetMaxPlaintextByteSize)
167 .Times(4)
168 .WillRepeatedly(Return(0));
169
170 // The first decrypt will fail stashing the first frame.
171 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
172 EXPECT_EQ(decrypted_frame_call_count_, static_cast<size_t>(0));
173 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(1));
174 // The second call will succeed playing back both frames.
175 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(false));
176 EXPECT_EQ(decrypted_frame_call_count_, static_cast<size_t>(2));
177 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(2));
178 // A new failure call will not result in an additional decrypted frame
179 // callback.
180 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
181 EXPECT_EQ(decrypted_frame_call_count_, static_cast<size_t>(2));
182 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(3));
183 }
184
185 // Validate that the maximum number of stashed frames cannot be exceeded even if
186 // more than its maximum arrives before the first successful decryption.
TEST_F(BufferedFrameDecryptorTest,MaximumNumberOfFramesStored)187 TEST_F(BufferedFrameDecryptorTest, MaximumNumberOfFramesStored) {
188 const size_t failed_to_decrypt_count = kMaxStashedFrames * 2;
189 EXPECT_CALL(*mock_frame_decryptor_, Decrypt)
190 .Times(failed_to_decrypt_count)
191 .WillRepeatedly(Return(DecryptFail()));
192 EXPECT_CALL(*mock_frame_decryptor_, GetMaxPlaintextByteSize)
193 .WillRepeatedly(Return(0));
194
195 for (size_t i = 0; i < failed_to_decrypt_count; ++i) {
196 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
197 }
198 EXPECT_EQ(decrypted_frame_call_count_, static_cast<size_t>(0));
199 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(1));
200
201 EXPECT_CALL(*mock_frame_decryptor_, Decrypt)
202 .Times(kMaxStashedFrames + 1)
203 .WillRepeatedly(Return(DecryptSuccess()));
204 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
205 EXPECT_EQ(decrypted_frame_call_count_, kMaxStashedFrames + 1);
206 EXPECT_EQ(decryption_status_change_count_, static_cast<size_t>(2));
207 }
208
209 // Verifies if a BufferedFrameDecryptor is attached but has no FrameDecryptor
210 // attached it will still store frames up to the frame max.
TEST_F(BufferedFrameDecryptorTest,FramesStoredIfDecryptorNull)211 TEST_F(BufferedFrameDecryptorTest, FramesStoredIfDecryptorNull) {
212 buffered_frame_decryptor_->SetFrameDecryptor(nullptr);
213 for (size_t i = 0; i < (2 * kMaxStashedFrames); ++i) {
214 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
215 }
216
217 EXPECT_CALL(*mock_frame_decryptor_, Decrypt)
218 .Times(kMaxStashedFrames + 1)
219 .WillRepeatedly(Return(DecryptSuccess()));
220 EXPECT_CALL(*mock_frame_decryptor_, GetMaxPlaintextByteSize)
221 .WillRepeatedly(Return(0));
222
223 // Attach the frame decryptor at a later point after frames have arrived.
224 buffered_frame_decryptor_->SetFrameDecryptor(mock_frame_decryptor_.get());
225
226 // Next frame should trigger kMaxStashedFrame decryptions.
227 buffered_frame_decryptor_->ManageEncryptedFrame(CreateRtpFrameObject(true));
228 EXPECT_EQ(decrypted_frame_call_count_, kMaxStashedFrames + 1);
229 }
230
231 } // namespace webrtc
232