VideoToolBox decoder/encoder for MacOS & iOS (#19)

* VideoDecoderFactory wrapper

* wip

* fix compilation

* add notes

* upgrade webrtc version

webrtc-sys/src/objc_video_factory.mm

@@ -0,0 +1,21 @@
+#include "livekit/objc_video_factory.h"
+
+#import <sdk/objc/components/video_codec/RTCVideoDecoderFactoryH264.h>
+#import <sdk/objc/components/video_codec/RTCVideoEncoderFactoryH264.h>
+#include "sdk/objc/native/api/video_decoder_factory.h"
+#include "sdk/objc/native/api/video_encoder_factory.h"
+
+namespace livekit {
+
+std::unique_ptr<webrtc::VideoEncoderFactory> CreateObjCVideoEncoderFactory() {
+  // TODO(theomonnom): Simulcast?
+  return webrtc::ObjCToNativeVideoEncoderFactory(
+      [[RTCVideoEncoderFactoryH264 alloc] init]);
+}
+
+std::unique_ptr<webrtc::VideoDecoderFactory> CreateObjCVideoDecoderFactory() {
+  return webrtc::ObjCToNativeVideoDecoderFactory(
+      [[RTCVideoDecoderFactoryH264 alloc] init]);
+}
+
+}

webrtc-sys/src/peer_connection_factory.cpp

@@ -13,6 +13,8 @@
 #include "api/video_codecs/builtin_video_decoder_factory.h"
 #include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "livekit/rtc_error.h"
+#include "livekit/video_decoder_factory.h"
+#include "livekit/video_encoder_factory.h"
 #include "media/engine/webrtc_media_engine.h"
 #include "webrtc-sys/src/peer_connection_factory.rs.h"
 
@@ -36,8 +38,10 @@ PeerConnectionFactory::PeerConnectionFactory(
 
   cricket::MediaEngineDependencies media_deps;
   media_deps.task_queue_factory = dependencies.task_queue_factory.get();
-  media_deps.video_encoder_factory = webrtc::CreateBuiltinVideoEncoderFactory();
-  media_deps.video_decoder_factory = webrtc::CreateBuiltinVideoDecoderFactory();
+  media_deps.video_encoder_factory =
+      std::move(std::make_unique<livekit::VideoEncoderFactory>());
+  media_deps.video_decoder_factory =
+      std::move(std::make_unique<livekit::VideoDecoderFactory>());
   media_deps.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
   media_deps.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
   media_deps.audio_processing = webrtc::AudioProcessingBuilder().Create();

webrtc-sys/src/video_decoder_factory.cpp

@@ -0,0 +1,46 @@
+#include "livekit/video_decoder_factory.h"
+
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
+#include "api/video_codecs/sdp_video_format.h"
+#include "livekit/objc_video_factory.h"
+#include "media/base/media_constants.h"
+#include "rtc_base/logging.h"
+
+namespace livekit {
+
+VideoDecoderFactory::VideoDecoderFactory() {
+  factories_.push_back(webrtc::CreateBuiltinVideoDecoderFactory());
+
+#ifdef __APPLE__
+  factories_.push_back(livekit::CreateObjCVideoDecoderFactory());
+#endif
+
+  // TODO(theomonnom): Add other HW decoders here
+}
+
+std::vector<webrtc::SdpVideoFormat> VideoDecoderFactory::GetSupportedFormats()
+    const {
+  std::vector<webrtc::SdpVideoFormat> formats;
+  for (const auto& factory : factories_) {
+    auto supported_formats = factory->GetSupportedFormats();
+    formats.insert(formats.end(), supported_formats.begin(),
+                   supported_formats.end());
+  }
+  return formats;
+}
+
+std::unique_ptr<webrtc::VideoDecoder> VideoDecoderFactory::CreateVideoDecoder(
+    const webrtc::SdpVideoFormat& format) {
+  for (const auto& factory : factories_) {
+    for (const auto& supported_format : factory->GetSupportedFormats()) {
+      if (supported_format.IsSameCodec(format))
+        return factory->CreateVideoDecoder(format);
+    }
+  }
+
+  RTC_LOG(LS_ERROR) << "No VideoDecoder found for " << format.name;
+  return nullptr;
+}
+
+}  // namespace livekit

webrtc-sys/src/video_encoder_factory.cpp

@@ -0,0 +1,47 @@
+#include "livekit/video_encoder_factory.h"
+
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
+#include "api/video_codecs/sdp_video_format.h"
+#include "api/video_codecs/video_encoder.h"
+#include "livekit/objc_video_factory.h"
+#include "media/base/media_constants.h"
+#include "rtc_base/logging.h"
+
+namespace livekit {
+
+VideoEncoderFactory::VideoEncoderFactory() {
+  factories_.push_back(webrtc::CreateBuiltinVideoEncoderFactory());
+
+#ifdef __APPLE__
+  factories_.push_back(livekit::CreateObjCVideoEncoderFactory());
+#endif
+
+  // TODO(theomonnom): Add other HW encoders here
+}
+
+std::vector<webrtc::SdpVideoFormat> VideoEncoderFactory::GetSupportedFormats()
+    const {
+  std::vector<webrtc::SdpVideoFormat> formats;
+  for (const auto& factory : factories_) {
+    auto supported_formats = factory->GetSupportedFormats();
+    formats.insert(formats.end(), supported_formats.begin(),
+                   supported_formats.end());
+  }
+  return formats;
+}
+
+std::unique_ptr<webrtc::VideoEncoder> VideoEncoderFactory::CreateVideoEncoder(
+    const webrtc::SdpVideoFormat& format) {
+  for (const auto& factory : factories_) {
+    for (const auto& supported_format : factory->GetSupportedFormats()) {
+      if (supported_format.IsSameCodec(format))
+        return factory->CreateVideoEncoder(format);
+    }
+  }
+
+  RTC_LOG(LS_ERROR) << "No VideoEncoder found for " << format.name;
+  return nullptr;
+}
+
+}  // namespace livekit