00765297a2
This change introduces a new class BufferedFrameDecryptor that is responsible for decrypting received encrypted frames and passing them on to the RtpReferenceFinder. This decoupling refactoring was triggered by a new optimization also introduced in this patch to stash a small number of undecryptable frames if no frames have ever been decrypted. The goal of this optimization is to prevent re-fectching of key frames on low bandwidth networks simply because the key to decrypt them had not arrived yet. The optimization will stash 24 frames (about 1 second of video) in a ring buffer and will attempt to re-decrypt previously received frames on the first valid decryption. This allows the decoder to receive the key frame without having to request due to short key delivery latencies. In testing this is actually hit quite often and saves an entire RTT which can be up to 200ms on a bad network. As the scope of frame encryption increases in WebRTC and has more specialized optimizations that do not apply to the general flow it makes sense to move it to a more explicit bump in the stack protocol that is decoupled from the WebRTC main flow, similar to how SRTP is utilized with srtp_protect and srtp_unprotect. One advantage of this approach is the BufferedFrameDecryptor isn't even constructed if FrameEncryption is not in use. I have decided against merging the RtpReferenceFinder and EncryptedFrame stash because it introduced a lot of complexity around the mixed scenario where some of the frames in the stash are encrypted and others are not. In this case we would need to mark certain frames as decrypted which appeared to introduce more complexity than this simple decoupling. Bug: webrtc:10022 Change-Id: Iab74f7b7d25ef1cdd15c4a76b5daae1cfa24932c Reviewed-on: https://webrtc-review.googlesource.com/c/112221 Commit-Queue: Benjamin Wright <benwright@webrtc.org> Reviewed-by: Philip Eliasson <philipel@webrtc.org> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Cr-Commit-Position: refs/heads/master@{#25865}
104 lines
3.9 KiB
C++
104 lines
3.9 KiB
C++
/*
|
|
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "video/buffered_frame_decryptor.h"
|
|
|
|
#include <utility>
|
|
|
|
#include "rtc_base/logging.h"
|
|
#include "rtc_base/system/fallthrough.h"
|
|
|
|
namespace webrtc {
|
|
|
|
BufferedFrameDecryptor::BufferedFrameDecryptor(
|
|
OnDecryptedFrameCallback* decrypted_frame_callback,
|
|
rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor)
|
|
: frame_decryptor_(std::move(frame_decryptor)),
|
|
decrypted_frame_callback_(decrypted_frame_callback) {}
|
|
|
|
BufferedFrameDecryptor::~BufferedFrameDecryptor() {}
|
|
|
|
void BufferedFrameDecryptor::ManageEncryptedFrame(
|
|
std::unique_ptr<video_coding::RtpFrameObject> encrypted_frame) {
|
|
switch (DecryptFrame(encrypted_frame.get())) {
|
|
case FrameDecision::kStash:
|
|
if (stashed_frames_.size() >= kMaxStashedFrames) {
|
|
stashed_frames_.pop_front();
|
|
}
|
|
stashed_frames_.push_back(std::move(encrypted_frame));
|
|
break;
|
|
case FrameDecision::kDecrypted:
|
|
RetryStashedFrames();
|
|
decrypted_frame_callback_->OnDecryptedFrame(std::move(encrypted_frame));
|
|
break;
|
|
case FrameDecision::kDrop:
|
|
break;
|
|
}
|
|
}
|
|
|
|
BufferedFrameDecryptor::FrameDecision BufferedFrameDecryptor::DecryptFrame(
|
|
video_coding::RtpFrameObject* frame) {
|
|
// Optionally attempt to decrypt the raw video frame if it was provided.
|
|
if (frame_decryptor_ == nullptr) {
|
|
RTC_LOG(LS_WARNING) << "Frame decryption required but not attached to this "
|
|
"stream. Dropping frame.";
|
|
return FrameDecision::kDrop;
|
|
}
|
|
// When using encryption we expect the frame to have the generic descriptor.
|
|
absl::optional<RtpGenericFrameDescriptor> descriptor =
|
|
frame->GetGenericFrameDescriptor();
|
|
if (!descriptor) {
|
|
RTC_LOG(LS_ERROR) << "No generic frame descriptor found dropping frame.";
|
|
return FrameDecision::kDrop;
|
|
}
|
|
// Retrieve the bitstream of the encrypted video frame.
|
|
rtc::ArrayView<const uint8_t> encrypted_frame_bitstream(frame->Buffer(),
|
|
frame->size());
|
|
// Retrieve the maximum possible size of the decrypted payload.
|
|
const size_t max_plaintext_byte_size =
|
|
frame_decryptor_->GetMaxPlaintextByteSize(cricket::MEDIA_TYPE_VIDEO,
|
|
frame->size());
|
|
RTC_CHECK_LE(max_plaintext_byte_size, frame->size());
|
|
// Place the decrypted frame inline into the existing frame.
|
|
rtc::ArrayView<uint8_t> inline_decrypted_bitstream(frame->MutableBuffer(),
|
|
max_plaintext_byte_size);
|
|
// Attempt to decrypt the video frame.
|
|
size_t bytes_written = 0;
|
|
if (frame_decryptor_->Decrypt(
|
|
cricket::MEDIA_TYPE_VIDEO, /*csrcs=*/{},
|
|
/*additional_data=*/nullptr, encrypted_frame_bitstream,
|
|
inline_decrypted_bitstream, &bytes_written) != 0) {
|
|
// Only stash frames if we have never decrypted a frame before.
|
|
return first_frame_decrypted_ ? FrameDecision::kDrop
|
|
: FrameDecision::kStash;
|
|
}
|
|
RTC_CHECK_LE(bytes_written, max_plaintext_byte_size);
|
|
// Update the frame to contain just the written bytes.
|
|
frame->SetSize(bytes_written);
|
|
|
|
// Indicate that all future fail to decrypt frames should be dropped.
|
|
if (!first_frame_decrypted_) {
|
|
first_frame_decrypted_ = true;
|
|
}
|
|
|
|
return FrameDecision::kDecrypted;
|
|
}
|
|
|
|
void BufferedFrameDecryptor::RetryStashedFrames() {
|
|
for (auto& frame : stashed_frames_) {
|
|
if (DecryptFrame(frame.get()) == FrameDecision::kDecrypted) {
|
|
decrypted_frame_callback_->OnDecryptedFrame(std::move(frame));
|
|
}
|
|
}
|
|
stashed_frames_.clear();
|
|
}
|
|
|
|
} // namespace webrtc
|