feat: add frame encryptor/decryptor interface.

BUILD.gn

@@ -56,6 +56,8 @@ rtc_shared_library("libwebrtc") {
     "include/rtc_data_channel.h",
     "include/rtc_dtls_transport.h",
     "include/rtc_dtmf_sender.h",
+    "include/rtc_frame_encryptor.h",
+    "include/rtc_frame_decryptor.h",
     "include/rtc_ice_candidate.h",
     "include/rtc_media_stream.h",
     "include/rtc_media_track.h",
@@ -91,6 +93,10 @@ rtc_shared_library("libwebrtc") {
     "src/rtc_dtls_transport_impl.h",
     "src/rtc_dtmf_sender_impl.cc",
     "src/rtc_dtmf_sender_impl.h",
+    "src/rtc_frame_decryptor_impl.h",
+    "src/rtc_frame_decryptor_impl.cc",
+    "src/rtc_frame_encryptor_impl.h",
+    "src/rtc_frame_encryptor_impl.cc",
     "src/rtc_ice_candidate_impl.cc",
     "src/rtc_ice_candidate_impl.h",
     "src/rtc_media_stream_impl.cc",
@@ -103,8 +109,8 @@ rtc_shared_library("libwebrtc") {
     "src/rtc_peerconnection_impl.h",
     "src/rtc_rtp_parameters_impl.cc",
     "src/rtc_rtp_parameters_impl.h",
-    "src/rtc_rtp_receive_imp.cc",
-    "src/rtc_rtp_receive_imp.h",
+    "src/rtc_rtp_receiver_imp.cc",
+    "src/rtc_rtp_receiver_imp.h",
     "src/rtc_rtp_sender_impl.cc",
     "src/rtc_rtp_sender_impl.h",
     "src/rtc_rtp_transceiver_impl.cc",

include/rtc_frame_decryptor.h

@@ -0,0 +1,43 @@
+
+#ifndef LIB_RTC_FRAME_DECRYPTOR_HXX
+#define LIB_RTC_FRAME_DECRYPTOR_HXX
+
+#include "base/refcount.h"
+#include "rtc_types.h"
+
+namespace libwebrtc {
+
+enum class DecryptResultStatus { kOk, kRecoverable, kFailedToDecrypt, kUnknown };
+
+struct DecryptResult {
+  DecryptResult(DecryptResultStatus status, size_t bytes_written)
+      : status(status), bytes_written(bytes_written) {}
+
+  bool IsOk() const { return status == DecryptResultStatus::kOk; }
+
+  const DecryptResultStatus status;
+  const size_t bytes_written;
+};
+
+typedef fixed_size_function<DecryptResult(
+    RTCMediaType media_type,
+    const portable::vector<uint32_t>& csrcs,
+    portable::vector<const uint8_t> additional_data,
+    portable::vector<const uint8_t> encrypted_frame,
+    portable::vector<uint8_t> frame)>
+    DecryptCallback;
+
+typedef fixed_size_function<size_t(RTCMediaType media_type,
+                                   size_t encrypted_frame_size)>
+    GetMaxPlaintextByteSizeCallback;
+
+class RTCFrameDecryptor : public RefCountInterface {
+ public:
+  static scoped_refptr<RTCFrameDecryptor> Create(
+      DecryptCallback decrypt,
+      GetMaxPlaintextByteSizeCallback get_max_plaintext_byte_size);
+};
+
+}  // namespace libwebrtc
+
+#endif  // LIB_RTC_FRAME_DECRYPTOR_HXX

include/rtc_frame_encryptor.h

@@ -0,0 +1,30 @@
+
+#ifndef LIB_RTC_FRAME_ENCRYPTOR_HXX
+#define LIB_RTC_FRAME_ENCRYPTOR_HXX
+
+#include "base/refcount.h"
+#include "rtc_types.h"
+
+namespace libwebrtc {
+
+typedef fixed_size_function<int(RTCMediaType media_type,
+                                uint32_t ssrc,
+                                portable::vector<const uint8_t> additional_data,
+                                portable::vector<const uint8_t> frame,
+                                portable::vector<uint8_t> encrypted_frame,
+                                size_t* bytes_written)>
+    EncryptCallback;
+
+typedef fixed_size_function<size_t(RTCMediaType media_type, size_t frame_size)>
+    GetMaxCiphertextByteSizeCallback;
+
+class RTCFrameEncryptor : public RefCountInterface {
+ public:
+ static scoped_refptr<RTCFrameEncryptor> Create(
+      EncryptCallback encrypt,
+      GetMaxCiphertextByteSizeCallback get_max_ciphertext_byte_size);
+};
+
+}  // namespace libwebrtc
+
+#endif  // LIB_RTC_FRAME_ENCRYPTOR_HXX

include/rtc_rtp_receiver.h

@@ -7,8 +7,7 @@
 #include "rtc_rtp_parameters.h"
 #include "rtc_types.h"
 
-//#include "rtc_frame_decryptor.h"
-//#include "rtc_frame_encryptor.h"
+#include "rtc_frame_decryptor.h"
 
 namespace libwebrtc {
 
@@ -46,13 +45,12 @@ class RTCRtpReceiver : public RefCountInterface {
 
   virtual void SetJitterBufferMinimumDelay(double delay_seconds) = 0;
 
-  // virtual Vector<RtpSource> GetSources() const = 0;
-
-  // virtual void SetFrameDecryptor(
-  //    scoped_refptr<FrameDecryptor> frame_decryptor);
+  virtual void SetFrameDecryptor(
+      scoped_refptr<RTCFrameDecryptor> frame_decryptor) = 0;
 
-  // virtual scoped_refptr<FrameDecryptor> GetFrameDecryptor() const = 0;
+  virtual scoped_refptr<RTCFrameDecryptor> GetFrameDecryptor() const = 0;
 
+  // virtual Vector<RtpSource> GetSources() const = 0;
   // virtual void SetDepacketizerToDecoderFrameTransformer(
   //    scoped_refptr<FrameTransformerInterface> frame_transformer) = 0;
 };

include/rtc_rtp_sender.h

@@ -7,6 +7,8 @@
 #include "rtc_rtp_parameters.h"
 #include "rtc_types.h"
 
+#include "rtc_frame_encryptor.h"
+
 namespace libwebrtc {
 
 class RTCMediaTrack;
@@ -40,6 +42,11 @@ class RTCRtpSender : public RefCountInterface {
       const scoped_refptr<RTCRtpParameters> parameters) = 0;
 
   virtual scoped_refptr<RTCDtmfSender> dtmf_sender() const = 0;
+
+  virtual void SetFrameEncryptor(
+      scoped_refptr<RTCFrameEncryptor> frame_encryptor) = 0;
+
+  virtual scoped_refptr<RTCFrameEncryptor> GetFrameEncryptor() const = 0;
 };
 
 }  // namespace libwebrtc

src/rtc_frame_decryptor_impl.cc

@@ -0,0 +1,22 @@
+#include "rtc_frame_decryptor_impl.h"
+
+#include "rtc_base/ref_counted_object.h"
+
+namespace libwebrtc {
+
+scoped_refptr<RTCFrameDecryptor> RTCFrameDecryptor::Create(
+    DecryptCallback decrypt,
+    GetMaxPlaintextByteSizeCallback get_max_plaintext_byte_size) {
+  return new RefCountedObject<RTCFrameDecryptorImpl>(
+      decrypt, get_max_plaintext_byte_size);
+}
+
+RTCFrameDecryptorImpl::RTCFrameDecryptorImpl(
+    DecryptCallback decrypt,
+    GetMaxPlaintextByteSizeCallback get_max_plaintext_byte_size) {
+  frame_decryptor_ = new rtc::RefCountedObject<RTCFrameDecryptorInternal>(
+      decrypt, get_max_plaintext_byte_size);
+}
+
+RTCFrameDecryptorImpl::~RTCFrameDecryptorImpl() {}
+}  // namespace libwebrtc

src/rtc_frame_decryptor_impl.h

@@ -0,0 +1,86 @@
+#ifndef RTC_FRAME_DECRYPTOR_IMPL_HXX
+#define RTC_FRAME_DECRYPTOR_IMPL_HXX
+
+#include "api/crypto/frame_decryptor_interface.h"
+#include "rtc_frame_decryptor.h"
+
+namespace libwebrtc {
+
+class RTCFrameDecryptorInternal : public webrtc::FrameDecryptorInterface {
+ public:
+  RTCFrameDecryptorInternal(
+      DecryptCallback decrypt,
+      GetMaxPlaintextByteSizeCallback get_max_plaintext_byte_size)
+      : decrypt_callback_(decrypt),
+        get_max_plaintext_byte_size_callback_(get_max_plaintext_byte_size) {}
+
+  virtual Result Decrypt(cricket::MediaType media_type,
+                         const std::vector<uint32_t>& csrcs,
+                         rtc::ArrayView<const uint8_t> additional_data,
+                         rtc::ArrayView<const uint8_t> encrypted_frame,
+                         rtc::ArrayView<uint8_t> frame) override {
+    //DecryptResult res =
+    //      decrypt_callback_(ConvertMediaType(media_type), csrcs, additional_data,
+    //                        encrypted_frame, frame);
+
+    return webrtc::FrameDecryptorInterface::Result(
+        webrtc::FrameDecryptorInterface::Status::kOk, 0);
+  }
+
+  virtual size_t GetMaxPlaintextByteSize(cricket::MediaType media_type,
+                                         size_t encrypted_frame_size) override {
+    return get_max_plaintext_byte_size_callback_(ConvertMediaType(media_type),
+                                                 encrypted_frame_size);
+  }
+
+  webrtc::FrameDecryptorInterface::Status ConvertResultStatus(
+      DecryptResultStatus status) {
+    switch (status) {
+      case DecryptResultStatus::kOk:
+        return webrtc::FrameDecryptorInterface::Status::kOk;
+      case DecryptResultStatus::kRecoverable:
+        return webrtc::FrameDecryptorInterface::Status::kRecoverable;
+      case DecryptResultStatus::kFailedToDecrypt:
+        return webrtc::FrameDecryptorInterface::Status::kFailedToDecrypt;
+      case DecryptResultStatus::kUnknown:
+        return webrtc::FrameDecryptorInterface::Status::kUnknown;
+    }
+    return webrtc::FrameDecryptorInterface::Status::kUnknown;
+  }
+
+  RTCMediaType ConvertMediaType(cricket::MediaType media_type) {
+    switch (media_type) {
+      case cricket::MEDIA_TYPE_AUDIO:
+        return RTCMediaType::AUDIO;
+      case cricket::MEDIA_TYPE_VIDEO:
+        return RTCMediaType::VIDEO;
+      case cricket::MEDIA_TYPE_DATA:
+        return RTCMediaType::DATA;
+      default:
+        return RTCMediaType::ANY;
+    }
+  }
+
+ private:
+  DecryptCallback decrypt_callback_;
+  GetMaxPlaintextByteSizeCallback get_max_plaintext_byte_size_callback_;
+};
+
+class RTCFrameDecryptorImpl : public RTCFrameDecryptor {
+ public:
+  RTCFrameDecryptorImpl(
+      DecryptCallback decrypt,
+      GetMaxPlaintextByteSizeCallback get_max_plaintext_byte_size);
+  ~RTCFrameDecryptorImpl() override;
+
+  rtc::scoped_refptr<webrtc::FrameDecryptorInterface> rtc_frame_decryptor() {
+    return frame_decryptor_;
+  }
+
+ private:
+  rtc::scoped_refptr<RTCFrameDecryptorInternal> frame_decryptor_;
+};
+
+}  // namespace libwebrtc
+
+#endif  // RTC_FRAME_DECRYPTOR_IMPL_HXX

src/rtc_frame_encryptor_impl.cc

@@ -0,0 +1,23 @@
+#include "rtc_frame_encryptor_impl.h"
+
+#include "rtc_base/ref_counted_object.h"
+
+namespace libwebrtc {
+
+scoped_refptr<RTCFrameEncryptor> RTCFrameEncryptor::Create(
+    EncryptCallback encrypt,
+    GetMaxCiphertextByteSizeCallback get_max_ciphertext_byte_size) {
+  return new RefCountedObject<RTCFrameEncryptorImpl>(
+      encrypt, get_max_ciphertext_byte_size);
+}
+
+RTCFrameEncryptorImpl::RTCFrameEncryptorImpl(
+    EncryptCallback encrypt,
+    GetMaxCiphertextByteSizeCallback get_max_ciphertext_byte_size) {
+  frame_encryptor_ = new rtc::RefCountedObject<RTCFrameEncryptorInternal>(
+      encrypt, get_max_ciphertext_byte_size);
+}
+
+RTCFrameEncryptorImpl::~RTCFrameEncryptorImpl() {}
+
+}  // namespace libwebrtc

src/rtc_frame_encryptor_impl.h

@@ -0,0 +1,67 @@
+#ifndef RTC_FRAME_ENCRYPTOR_IMPL_HXX
+#define RTC_FRAME_ENCRYPTOR_IMPL_HXX
+
+#include "rtc_frame_encryptor.h"
+
+#include "api/crypto/frame_encryptor_interface.h"
+
+namespace libwebrtc {
+
+class RTCFrameEncryptorInternal : public webrtc::FrameEncryptorInterface {
+ public:
+  RTCFrameEncryptorInternal(
+      EncryptCallback encrypt,
+      GetMaxCiphertextByteSizeCallback get_max_ciphertext_byte_size)
+      : encrypt_callback_(encrypt),
+        get_max_ciphertext_byte_size_callback_(get_max_ciphertext_byte_size) {}
+
+  virtual int Encrypt(cricket::MediaType media_type,
+                      uint32_t ssrc,
+                      rtc::ArrayView<const uint8_t> additional_data,
+                      rtc::ArrayView<const uint8_t> frame,
+                      rtc::ArrayView<uint8_t> encrypted_frame,
+                      size_t* bytes_written) override {
+    //return encrypt_callback_(ConvertMediaType(media_type), ssrc, additional_data, frame,
+    //                         encrypted_frame, bytes_written);
+    return 0;
+  }
+
+  virtual size_t GetMaxCiphertextByteSize(cricket::MediaType media_type,
+                                          size_t frame_size) override {
+    return get_max_ciphertext_byte_size_callback_(ConvertMediaType(media_type), frame_size);
+  }
+
+  RTCMediaType ConvertMediaType(cricket::MediaType media_type) {
+    switch (media_type) {
+      case cricket::MEDIA_TYPE_AUDIO:
+        return RTCMediaType::AUDIO;
+      case cricket::MEDIA_TYPE_VIDEO:
+        return RTCMediaType::VIDEO;
+      case cricket::MEDIA_TYPE_DATA:
+        return RTCMediaType::DATA;
+      default:
+        return RTCMediaType::ANY;
+    }
+  }
+
+ private:
+  EncryptCallback encrypt_callback_;
+  GetMaxCiphertextByteSizeCallback get_max_ciphertext_byte_size_callback_;
+};
+
+class RTCFrameEncryptorImpl : public RTCFrameEncryptor {
+ public:
+  RTCFrameEncryptorImpl(
+      EncryptCallback encrypt,
+      GetMaxCiphertextByteSizeCallback get_max_ciphertext_byte_size);
+  ~RTCFrameEncryptorImpl() override;
+
+  rtc::scoped_refptr<webrtc::FrameEncryptorInterface> rtc_frame_encryptor() {
+    return frame_encryptor_;
+  }
+
+ protected:
+  rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor_;
+};
+}  // namespace libwebrtc
+#endif  // RTC_FRAME_ENCRYPTOR_IMPL_HXX

src/rtc_peerconnection_impl.cc

@@ -12,7 +12,7 @@
 #include "rtc_ice_candidate_impl.h"
 #include "rtc_media_stream_impl.h"
 #include "rtc_mediaconstraints_impl.h"
-#include "rtc_rtp_receive_imp.h"
+#include "rtc_rtp_receiver_imp.h"
 #include "rtc_rtp_sender_impl.h"
 #include "rtc_rtp_transceiver_impl.h"