From 1e06d885dcad0690f2ef41396c5158059cad9afc Mon Sep 17 00:00:00 2001 From: Anders Carlsson Date: Tue, 10 Jul 2018 09:33:30 +0200 Subject: [PATCH] Migrate legacy Android video codec factories. Prepare for building without built-in software codecs. When passing null, inject the new type of factories but wrap them in the built-in software codecs outside the videoengine. Bug: webrtc:7925 Change-Id: I7408e6e46e6b9efdf346852954bf51a97e023b5c Reviewed-on: https://webrtc-review.googlesource.com/83729 Commit-Queue: Anders Carlsson Reviewed-by: Magnus Jedvert Cr-Commit-Position: refs/heads/master@{#23897} --- examples/BUILD.gn | 1 + media/engine/convert_legacy_video_factory.cc | 110 +++++++++---- media/engine/convert_legacy_video_factory.h | 6 + sdk/android/BUILD.gn | 150 ++++++++++++------ sdk/android/src/jni/androidmediadecoder.cc | 50 +++--- sdk/android/src/jni/androidmediadecoder_jni.h | 15 +- sdk/android/src/jni/androidmediaencoder.cc | 99 ++++++------ sdk/android/src/jni/androidmediaencoder_jni.h | 18 +-- sdk/android/src/jni/pc/media.cc | 15 -- sdk/android/src/jni/pc/media.h | 11 -- sdk/android/src/jni/pc/null_media.cc | 11 -- sdk/android/src/jni/pc/null_video.cc | 26 ++- .../src/jni/pc/ownedfactoryandthreads.h | 14 +- .../src/jni/pc/peerconnectionfactory.cc | 79 ++++----- sdk/android/src/jni/pc/video.cc | 49 ++---- sdk/android/src/jni/pc/video.h | 21 +-- 16 files changed, 360 insertions(+), 315 deletions(-) diff --git a/examples/BUILD.gn b/examples/BUILD.gn index 4083230f8c..1c24f912ff 100644 --- a/examples/BUILD.gn +++ b/examples/BUILD.gn @@ -113,6 +113,7 @@ if (is_android) { "../sdk/android:audio_api_java", "../sdk/android:base_java", "../sdk/android:camera_java", + "../sdk/android:default_video_codec_factory_java", "../sdk/android:filevideo_java", "../sdk/android:hwcodecs_java", "../sdk/android:java_audio_device_module_java", diff --git a/media/engine/convert_legacy_video_factory.cc b/media/engine/convert_legacy_video_factory.cc index af37a393cb..075ef91c58 100644 --- a/media/engine/convert_legacy_video_factory.cc +++ b/media/engine/convert_legacy_video_factory.cc @@ -101,6 +101,11 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory { absl::make_unique( std::move(external_encoder_factory))) {} + explicit EncoderAdapter( + std::unique_ptr external_encoder_factory) + : internal_encoder_factory_(new webrtc::InternalEncoderFactory()), + external_encoder_factory_(std::move(external_encoder_factory)) {} + webrtc::VideoEncoderFactory::CodecInfo QueryVideoEncoder( const webrtc::SdpVideoFormat& format) const override { if (IsFormatSupported(external_encoder_factory_->GetSupportedFormats(), @@ -171,40 +176,18 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory { const std::unique_ptr external_encoder_factory_; }; -// This class combines an external factory with the internal factory and adds -// internal SW codecs, simulcast, and SW fallback wrappers. -class DecoderAdapter : public webrtc::VideoDecoderFactory { +// Converts the cricket::WebRtcVideoDecoderFactory to a +// webrtc::VideoDecoderFactory (without adding any SW fallback). +class CricketToWebRtcDecoderFactory : public webrtc::VideoDecoderFactory { public: - explicit DecoderAdapter( + explicit CricketToWebRtcDecoderFactory( std::unique_ptr external_decoder_factory) : external_decoder_factory_(std::move(external_decoder_factory)) {} std::unique_ptr CreateVideoDecoder( const webrtc::SdpVideoFormat& format) override { - std::unique_ptr internal_decoder; - webrtc::InternalDecoderFactory internal_decoder_factory; - if (IsFormatSupported(internal_decoder_factory.GetSupportedFormats(), - format)) { - internal_decoder = internal_decoder_factory.CreateVideoDecoder(format); - } - - const VideoCodec codec(format); - const VideoDecoderParams params = {}; - if (external_decoder_factory_ != nullptr) { - std::unique_ptr external_decoder = - CreateScopedVideoDecoder(external_decoder_factory_.get(), codec, - params); - if (external_decoder) { - if (!internal_decoder) - return external_decoder; - // Both external and internal decoder available - create fallback - // wrapper. - return webrtc::CreateVideoDecoderSoftwareFallbackWrapper( - std::move(internal_decoder), std::move(external_decoder)); - } - } - - return internal_decoder; + return CreateScopedVideoDecoder(external_decoder_factory_.get(), + VideoCodec(format), {}); } std::vector GetSupportedFormats() const override { @@ -217,6 +200,65 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory { const std::unique_ptr external_decoder_factory_; }; +// This class combines an external factory with the internal factory and adds +// internal SW codecs and SW fallback wrappers. +class DecoderAdapter : public webrtc::VideoDecoderFactory { + public: + explicit DecoderAdapter( + std::unique_ptr external_decoder_factory) + : internal_decoder_factory_(new webrtc::InternalDecoderFactory()), + external_decoder_factory_( + absl::make_unique( + std::move(external_decoder_factory))) {} + + explicit DecoderAdapter( + std::unique_ptr external_decoder_factory) + : internal_decoder_factory_(new webrtc::InternalDecoderFactory()), + external_decoder_factory_(std::move(external_decoder_factory)) {} + + std::unique_ptr CreateVideoDecoder( + const webrtc::SdpVideoFormat& format) override { + std::unique_ptr internal_decoder; + if (IsFormatSupported(internal_decoder_factory_->GetSupportedFormats(), + format)) { + internal_decoder = internal_decoder_factory_->CreateVideoDecoder(format); + } + + std::unique_ptr external_decoder = nullptr; + if (external_decoder_factory_ != nullptr) { + external_decoder = external_decoder_factory_->CreateVideoDecoder(format); + } + + if (internal_decoder && external_decoder) { + // Both internal SW decoder and external HW decoder available - create + // fallback decoder. + return webrtc::CreateVideoDecoderSoftwareFallbackWrapper( + std::move(internal_decoder), std::move(external_decoder)); + } + return external_decoder ? std::move(external_decoder) + : std::move(internal_decoder); + } + + std::vector GetSupportedFormats() const override { + std::vector formats = + internal_decoder_factory_->GetSupportedFormats(); + + // Add external codecs. + for (const webrtc::SdpVideoFormat& format : + external_decoder_factory_->GetSupportedFormats()) { + // Don't add same codec twice. + if (!IsFormatSupported(formats, format)) + formats.push_back(format); + } + + return formats; + } + + private: + const std::unique_ptr internal_decoder_factory_; + const std::unique_ptr external_decoder_factory_; +}; + } // namespace std::unique_ptr ConvertVideoEncoderFactory( @@ -225,10 +267,22 @@ std::unique_ptr ConvertVideoEncoderFactory( new EncoderAdapter(std::move(external_encoder_factory))); } +std::unique_ptr ConvertVideoEncoderFactory( + std::unique_ptr external_encoder_factory) { + return std::unique_ptr( + new EncoderAdapter(std::move(external_encoder_factory))); +} + std::unique_ptr ConvertVideoDecoderFactory( std::unique_ptr external_decoder_factory) { return std::unique_ptr( new DecoderAdapter(std::move(external_decoder_factory))); } +std::unique_ptr ConvertVideoDecoderFactory( + std::unique_ptr external_decoder_factory) { + return std::unique_ptr( + new DecoderAdapter(std::move(external_decoder_factory))); +} + } // namespace cricket diff --git a/media/engine/convert_legacy_video_factory.h b/media/engine/convert_legacy_video_factory.h index 5bd3580a6f..9d0d154910 100644 --- a/media/engine/convert_legacy_video_factory.h +++ b/media/engine/convert_legacy_video_factory.h @@ -30,9 +30,15 @@ class WebRtcVideoDecoderFactory; std::unique_ptr ConvertVideoEncoderFactory( std::unique_ptr external_encoder_factory); +std::unique_ptr ConvertVideoEncoderFactory( + std::unique_ptr external_encoder_factory); + std::unique_ptr ConvertVideoDecoderFactory( std::unique_ptr external_decoder_factory); +std::unique_ptr ConvertVideoDecoderFactory( + std::unique_ptr external_decoder_factory); + } // namespace cricket #endif // MEDIA_ENGINE_CONVERT_LEGACY_VIDEO_FACTORY_H_ diff --git a/sdk/android/BUILD.gn b/sdk/android/BUILD.gn index a7e99396e0..33ecacec30 100644 --- a/sdk/android/BUILD.gn +++ b/sdk/android/BUILD.gn @@ -297,6 +297,7 @@ rtc_static_library("video_jni") { "src/jni/androidvideotracksource.h", "src/jni/encodedimage.cc", "src/jni/encodedimage.h", + "src/jni/hardwarevideoencoderfactory.cc", "src/jni/jni_generator_helper.h", "src/jni/nativecapturerobserver.cc", "src/jni/nativecapturerobserver.h", @@ -317,37 +318,21 @@ rtc_static_library("video_jni") { "src/jni/videoencoderfallback.cc", "src/jni/videoencoderwrapper.cc", "src/jni/videoencoderwrapper.h", - "src/jni/videoframe.cc", - "src/jni/videoframe.h", "src/jni/videosink.cc", "src/jni/videosink.h", "src/jni/videosource.cc", "src/jni/videotrack.cc", - "src/jni/wrapped_native_i420_buffer.cc", - "src/jni/wrapped_native_i420_buffer.h", "src/jni/yuvhelper.cc", ] - if (rtc_use_builtin_sw_codecs) { - sources += [ - "src/jni/androidmediacodeccommon.h", - "src/jni/androidmediadecoder.cc", - "src/jni/androidmediadecoder_jni.h", - "src/jni/androidmediaencoder.cc", - "src/jni/androidmediaencoder_jni.h", - "src/jni/hardwarevideoencoderfactory.cc", - ] - - deps += [ - ":vp8_jni", - ":vp9_jni", - "../../media:rtc_internal_video_codecs", - ] - } deps += [ ":base_jni", ":generated_video_jni", + ":legacy_video_jni", # TODO(bugs.webrtc.org/7925): Remove. ":native_api_jni", + ":videoframe_jni", + ":vp8_jni", # TODO(bugs.webrtc.org/7925): Remove. + ":vp9_jni", # TODO(bugs.webrtc.org/7925): Remove. "../..:webrtc_common", "../../api:libjingle_peerconnection_api", "../../api/video:video_frame", @@ -356,6 +341,7 @@ rtc_static_library("video_jni") { "../../common_video:common_video", "../../media:rtc_audio_video", "../../media:rtc_h264_profile_id", + "../../media:rtc_internal_video_codecs", "../../media:rtc_media_base", "../../modules:module_api", "../../modules/utility:utility", @@ -374,6 +360,61 @@ rtc_static_library("video_jni") { ] } +rtc_static_library("videoframe_jni") { + sources = [ + "src/jni/videoframe.cc", + "src/jni/videoframe.h", + "src/jni/wrapped_native_i420_buffer.cc", + "src/jni/wrapped_native_i420_buffer.h", + ] + + deps = [ + ":base_jni", + ":generated_video_jni", + ":native_api_jni", + "../../api/video:video_frame", + "../../common_video:common_video", + "../../rtc_base:checks", + "../../rtc_base:rtc_base", + "../../rtc_base:rtc_base_approved", + "../../rtc_base/memory:aligned_malloc", + "//third_party/libyuv", + ] +} + +# TODO(bugs.webrtc.org/7925): Remove. +rtc_static_library("legacy_video_jni") { + sources = [ + "src/jni/androidmediacodeccommon.h", + "src/jni/androidmediadecoder.cc", + "src/jni/androidmediadecoder_jni.h", + "src/jni/androidmediaencoder.cc", + "src/jni/androidmediaencoder_jni.h", + ] + + deps = [ + ":base_jni", + ":generated_video_jni", + ":native_api_jni", + ":videoframe_jni", + "../..:webrtc_common", + "../../api/video_codecs:video_codecs_api", + "../../common_video:common_video", + "../../media:rtc_internal_video_codecs", + "../../media:rtc_media_base", + "../../modules/video_coding:video_codec_interface", + "../../modules/video_coding:video_coding_utility", + "../../rtc_base:checks", + "../../rtc_base:rtc_base", + "../../rtc_base:rtc_base_approved", + "../../rtc_base:rtc_task_queue", + "../../rtc_base:sequenced_task_checker", + "../../rtc_base:weak_ptr", + "../../system_wrappers:field_trial_api", + "//third_party/libyuv", + ] +} + rtc_static_library("null_video_jni") { sources = [ "src/jni/pc/null_video.cc", @@ -381,6 +422,7 @@ rtc_static_library("null_video_jni") { deps = [ ":base_jni", + "../../api/video_codecs:video_codecs_api", ] } @@ -627,6 +669,9 @@ generate_jni("generated_metrics_jni") { rtc_static_library("libjingle_peerconnection_metrics_default_jni") { visibility = [ "*" ] + + allow_poison = [ "software_video_codecs" ] # TODO(bugs.webrtc.org/7925): Remove. + sources = [ "src/jni/androidmetrics.cc", ] @@ -698,6 +743,7 @@ dist_jar("libwebrtc") { ":audio_api_java", ":base_java", ":camera_java", + ":default_video_codec_factory_java", ":filevideo_java", ":hwcodecs_java", ":java_audio_device_module_java", @@ -707,15 +753,12 @@ dist_jar("libwebrtc") { ":peerconnection_java", ":screencapturer_java", ":surfaceviewrenderer_java", + ":swcodecs_java", ":video_api_java", ":video_java", "../../modules/audio_device:audio_device_java", "../../rtc_base:base_java", ] - - if (rtc_use_builtin_sw_codecs) { - deps += [ ":swcodecs_java" ] - } } # TODO(sakal): Extract files from this target to releveant subtargets, video, audio etc. @@ -905,24 +948,22 @@ rtc_android_library("filevideo_java") { ] } -if (rtc_use_builtin_sw_codecs) { - rtc_android_library("swcodecs_java") { - java_files = [ - "api/org/webrtc/SoftwareVideoDecoderFactory.java", - "api/org/webrtc/SoftwareVideoEncoderFactory.java", - "src/java/org/webrtc/VP8Encoder.java", - "src/java/org/webrtc/VP8Decoder.java", - "src/java/org/webrtc/VP9Encoder.java", - "src/java/org/webrtc/VP9Decoder.java", - ] +rtc_android_library("swcodecs_java") { + java_files = [ + "api/org/webrtc/SoftwareVideoDecoderFactory.java", + "api/org/webrtc/SoftwareVideoEncoderFactory.java", + "src/java/org/webrtc/VP8Encoder.java", + "src/java/org/webrtc/VP8Decoder.java", + "src/java/org/webrtc/VP9Encoder.java", + "src/java/org/webrtc/VP9Decoder.java", + ] - deps = [ - ":base_java", - ":video_api_java", - ":video_java", - "//rtc_base:base_java", - ] - } + deps = [ + ":base_java", + ":video_api_java", + ":video_java", + "//rtc_base:base_java", + ] } rtc_android_library("hwcodecs_java") { @@ -1021,15 +1062,6 @@ rtc_android_library("libjingle_peerconnection_java") { "//modules/audio_device:audio_device_java", "//rtc_base:base_java", ] - - if (rtc_use_builtin_sw_codecs) { - deps += [ ":swcodecs_java" ] - - java_files += [ - "api/org/webrtc/DefaultVideoDecoderFactory.java", - "api/org/webrtc/DefaultVideoEncoderFactory.java", - ] - } } rtc_android_library("libjingle_peerconnection_metrics_default_java") { @@ -1042,6 +1074,19 @@ rtc_android_library("libjingle_peerconnection_metrics_default_java") { ] } +rtc_android_library("default_video_codec_factory_java") { + java_files = [ + "api/org/webrtc/DefaultVideoDecoderFactory.java", + "api/org/webrtc/DefaultVideoEncoderFactory.java", + ] + + deps = [ + ":hwcodecs_java", + ":swcodecs_java", + ":video_api_java", + ] +} + if (rtc_include_tests) { rtc_instrumentation_test_apk("libjingle_peerconnection_android_unittest") { apk_name = "libjingle_peerconnection_android_unittest" @@ -1079,6 +1124,7 @@ if (rtc_include_tests) { deps = [ ":base_java", + ":default_video_codec_factory_java", ":libjingle_peerconnection_java", ":libjingle_peerconnection_metrics_default_java", ":video_api_java", @@ -1222,6 +1268,9 @@ rtc_static_library("native_api_codecs") { # API for creating Java PeerConnectionFactory from C++ equivalents. rtc_static_library("native_api_peerconnection") { visibility = [ "*" ] + + allow_poison = [ "software_video_codecs" ] # TODO(bugs.webrtc.org/7925): Remove. + sources = [ "native_api/peerconnection/peerconnectionfactory.cc", "native_api/peerconnection/peerconnectionfactory.h", @@ -1258,6 +1307,7 @@ rtc_static_library("native_api_video") { deps = [ ":native_api_jni", ":video_jni", + ":videoframe_jni", "//api:libjingle_peerconnection_api", "//api/video:video_frame", "//rtc_base:rtc_base_approved", diff --git a/sdk/android/src/jni/androidmediadecoder.cc b/sdk/android/src/jni/androidmediadecoder.cc index 96fc748bb9..74a6a5272c 100644 --- a/sdk/android/src/jni/androidmediadecoder.cc +++ b/sdk/android/src/jni/androidmediadecoder.cc @@ -17,14 +17,17 @@ // androidmediacodeccommon.h to avoid build errors. #include "sdk/android/src/jni/androidmediadecoder_jni.h" +#include "api/video_codecs/sdp_video_format.h" #include "common_video/h264/h264_bitstream_parser.h" #include "common_video/include/i420_buffer_pool.h" +#include "media/base/mediaconstants.h" #include "modules/video_coding/include/video_codec_interface.h" #include "modules/video_coding/utility/vp8_header_parser.h" #include "rtc_base/bind.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" #include "rtc_base/numerics/safe_conversions.h" +#include "rtc_base/ptr_util.h" #include "rtc_base/scoped_ref_ptr.h" #include "rtc_base/thread.h" #include "rtc_base/timeutils.h" @@ -781,24 +784,24 @@ MediaCodecVideoDecoderFactory::MediaCodecVideoDecoderFactory() ALOGD << "MediaCodecVideoDecoderFactory ctor"; JNIEnv* jni = AttachCurrentThreadIfNeeded(); ScopedLocalRefFrame local_ref_frame(jni); - supported_codec_types_.clear(); + supported_formats_.clear(); if (Java_MediaCodecVideoDecoder_isVp8HwSupported(jni) && !CheckException(jni)) { ALOGD << "VP8 HW Decoder supported."; - supported_codec_types_.push_back(kVideoCodecVP8); + supported_formats_.push_back(SdpVideoFormat(cricket::kVp8CodecName)); } if (Java_MediaCodecVideoDecoder_isVp9HwSupported(jni) && !CheckException(jni)) { ALOGD << "VP9 HW Decoder supported."; - supported_codec_types_.push_back(kVideoCodecVP9); + supported_formats_.push_back(SdpVideoFormat(cricket::kVp9CodecName)); } if (Java_MediaCodecVideoDecoder_isH264HwSupported(jni) && !CheckException(jni)) { ALOGD << "H264 HW Decoder supported."; - supported_codec_types_.push_back(kVideoCodecH264); + supported_formats_.push_back(SdpVideoFormat(cricket::kH264CodecName)); } } @@ -823,27 +826,28 @@ void MediaCodecVideoDecoderFactory::SetEGLContext(JNIEnv* jni, } } -VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder( - VideoCodecType type) { - if (supported_codec_types_.empty()) { - ALOGW << "No HW video decoder for type " << static_cast(type); - return nullptr; - } - for (VideoCodecType codec_type : supported_codec_types_) { - if (codec_type == type) { - ALOGD << "Create HW video decoder for type " << static_cast(type); - JNIEnv* jni = AttachCurrentThreadIfNeeded(); - ScopedLocalRefFrame local_ref_frame(jni); - return new MediaCodecVideoDecoder(jni, type, egl_context_); - } - } - ALOGW << "Can not find HW video decoder for type " << static_cast(type); - return nullptr; +std::vector MediaCodecVideoDecoderFactory::GetSupportedFormats() + const { + return supported_formats_; } -void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(VideoDecoder* decoder) { - ALOGD << "Destroy video decoder."; - delete decoder; +std::unique_ptr MediaCodecVideoDecoderFactory::CreateVideoDecoder( + const SdpVideoFormat& format) { + if (supported_formats_.empty()) { + ALOGW << "No HW video decoder for type " << format.name; + return nullptr; + } + for (SdpVideoFormat supported_format : supported_formats_) { + if (supported_format == format) { + ALOGD << "Create HW video decoder for type " << format.name; + JNIEnv* jni = AttachCurrentThreadIfNeeded(); + ScopedLocalRefFrame local_ref_frame(jni); + return rtc::MakeUnique( + jni, PayloadStringToCodecType(format.name), egl_context_); + } + } + ALOGW << "Can not find HW video decoder for type " << format.name; + return nullptr; } bool MediaCodecVideoDecoderFactory::IsH264HighProfileSupported(JNIEnv* env) { diff --git a/sdk/android/src/jni/androidmediadecoder_jni.h b/sdk/android/src/jni/androidmediadecoder_jni.h index b984dc5553..28b8652fd6 100644 --- a/sdk/android/src/jni/androidmediadecoder_jni.h +++ b/sdk/android/src/jni/androidmediadecoder_jni.h @@ -13,31 +13,30 @@ #include -#include "media/engine/webrtcvideodecoderfactory.h" +#include "api/video_codecs/video_decoder_factory.h" #include "sdk/android/src/jni/jni_helpers.h" namespace webrtc { namespace jni { // Implementation of Android MediaCodec based decoder factory. -class MediaCodecVideoDecoderFactory - : public cricket::WebRtcVideoDecoderFactory { +class MediaCodecVideoDecoderFactory : public VideoDecoderFactory { public: MediaCodecVideoDecoderFactory(); ~MediaCodecVideoDecoderFactory() override; void SetEGLContext(JNIEnv* jni, jobject render_egl_context); - // WebRtcVideoDecoderFactory implementation. - VideoDecoder* CreateVideoDecoder(VideoCodecType type) override; - - void DestroyVideoDecoder(VideoDecoder* decoder) override; + // VideoDecoderFactory implementation. + std::vector GetSupportedFormats() const override; + std::unique_ptr CreateVideoDecoder( + const SdpVideoFormat& format) override; static bool IsH264HighProfileSupported(JNIEnv* env); private: jobject egl_context_; - std::vector supported_codec_types_; + std::vector supported_formats_; }; } // namespace jni diff --git a/sdk/android/src/jni/androidmediaencoder.cc b/sdk/android/src/jni/androidmediaencoder.cc index 9edbf2d8b1..595484aff1 100644 --- a/sdk/android/src/jni/androidmediaencoder.cc +++ b/sdk/android/src/jni/androidmediaencoder.cc @@ -18,11 +18,14 @@ #include #include +#include "api/video_codecs/sdp_video_format.h" #include "api/video_codecs/video_encoder.h" #include "common_types.h" // NOLINT(build/include) #include "common_video/h264/h264_bitstream_parser.h" #include "common_video/h264/h264_common.h" #include "common_video/h264/profile_level_id.h" +#include "media/base/codec.h" +#include "media/base/mediaconstants.h" #include "media/engine/internalencoderfactory.h" #include "modules/video_coding/include/video_codec_interface.h" #include "modules/video_coding/utility/quality_scaler.h" @@ -31,6 +34,7 @@ #include "rtc_base/bind.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" +#include "rtc_base/ptr_util.h" #include "rtc_base/sequenced_task_checker.h" #include "rtc_base/task_queue.h" #include "rtc_base/thread.h" @@ -93,7 +97,7 @@ class MediaCodecVideoEncoder : public VideoEncoder { public: ~MediaCodecVideoEncoder() override; MediaCodecVideoEncoder(JNIEnv* jni, - const cricket::VideoCodec& codec, + const SdpVideoFormat& format, jobject egl_context); // VideoEncoder implementation. @@ -197,7 +201,7 @@ class MediaCodecVideoEncoder : public VideoEncoder { #endif // Type of video codec. - const cricket::VideoCodec codec_; + const SdpVideoFormat format_; EncodedImageCallback* callback_; @@ -297,9 +301,9 @@ MediaCodecVideoEncoder::~MediaCodecVideoEncoder() { } MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni, - const cricket::VideoCodec& codec, + const SdpVideoFormat& format, jobject egl_context) - : codec_(codec), + : format_(format), callback_(NULL), j_media_codec_video_encoder_( jni, @@ -348,7 +352,7 @@ int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings, profile_ = H264::Profile::kProfileBaseline; if (codec_type == kVideoCodecH264) { const absl::optional profile_level_id = - H264::ParseSdpProfileLevelId(codec_.params); + H264::ParseSdpProfileLevelId(format_.parameters); RTC_DCHECK(profile_level_id); profile_ = profile_level_id->profile; ALOGD << "H.264 profile: " << profile_; @@ -425,12 +429,14 @@ bool MediaCodecVideoEncoder::EncodeTask::Run() { return false; } -bool IsFormatSupported( - const std::vector& supported_formats, - const std::string& name) { - for (const webrtc::SdpVideoFormat& supported_format : supported_formats) { - if (cricket::CodecNamesEq(name, supported_format.name)) +bool IsFormatSupported(const std::vector& supported_formats, + const SdpVideoFormat& format) { + for (const SdpVideoFormat& supported_format : supported_formats) { + if (cricket::IsSameCodec(format.name, format.parameters, + supported_format.name, + supported_format.parameters)) { return true; + } } return false; } @@ -439,7 +445,7 @@ bool MediaCodecVideoEncoder::ProcessHWError( bool reset_if_fallback_unavailable) { ALOGE << "ProcessHWError"; if (IsFormatSupported(InternalEncoderFactory().GetSupportedFormats(), - codec_.name)) { + format_)) { ALOGE << "Fallback to SW encoder."; sw_fallback_required_ = true; return false; @@ -457,7 +463,7 @@ int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncode() { } VideoCodecType MediaCodecVideoEncoder::GetCodecType() const { - return PayloadStringToCodecType(codec_.name); + return PayloadStringToCodecType(format_.name); } int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width, @@ -1210,20 +1216,20 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory() : egl_context_(nullptr) { JNIEnv* jni = AttachCurrentThreadIfNeeded(); ScopedLocalRefFrame local_ref_frame(jni); - supported_codecs_.clear(); + supported_formats_.clear(); bool is_vp8_hw_supported = Java_MediaCodecVideoEncoder_isVp8HwSupported(jni); if (is_vp8_hw_supported) { ALOGD << "VP8 HW Encoder supported."; - supported_codecs_.push_back(cricket::VideoCodec(cricket::kVp8CodecName)); + supported_formats_.push_back(SdpVideoFormat(cricket::kVp8CodecName)); } bool is_vp9_hw_supported = Java_MediaCodecVideoEncoder_isVp9HwSupported(jni); if (is_vp9_hw_supported) { ALOGD << "VP9 HW Encoder supported."; - supported_codecs_.push_back(cricket::VideoCodec(cricket::kVp9CodecName)); + supported_formats_.push_back(SdpVideoFormat(cricket::kVp9CodecName)); } - supported_codecs_with_h264_hp_ = supported_codecs_; + supported_formats_with_h264_hp_ = supported_formats_; // Check if high profile is supported by decoder. If yes, encoder can always // fall back to baseline profile as a subset as high profile. @@ -1233,15 +1239,14 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory() ALOGD << "H.264 High Profile HW Encoder supported."; // TODO(magjed): Enumerate actual level instead of using hardcoded level // 3.1. Level 3.1 is 1280x720@30fps which is enough for now. - cricket::VideoCodec constrained_high(cricket::kH264CodecName); + SdpVideoFormat constrained_high(cricket::kH264CodecName); const H264::ProfileLevelId constrained_high_profile( H264::kProfileConstrainedHigh, H264::kLevel3_1); - constrained_high.SetParam( - cricket::kH264FmtpProfileLevelId, - *H264::ProfileLevelIdToString(constrained_high_profile)); - constrained_high.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1"); - constrained_high.SetParam(cricket::kH264FmtpPacketizationMode, "1"); - supported_codecs_with_h264_hp_.push_back(constrained_high); + constrained_high.parameters[cricket::kH264FmtpProfileLevelId] = + *H264::ProfileLevelIdToString(constrained_high_profile); + constrained_high.parameters[cricket::kH264FmtpLevelAsymmetryAllowed] = "1"; + constrained_high.parameters[cricket::kH264FmtpPacketizationMode] = "1"; + supported_formats_with_h264_hp_.push_back(constrained_high); } bool is_h264_hw_supported = @@ -1252,16 +1257,16 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory() // ready, http://crbug/webrtc/6337. We can negotiate Constrained High // profile as long as we have decode support for it and still send Baseline // since Baseline is a subset of the High profile. - cricket::VideoCodec constrained_baseline(cricket::kH264CodecName); + SdpVideoFormat constrained_baseline(cricket::kH264CodecName); const H264::ProfileLevelId constrained_baseline_profile( H264::kProfileConstrainedBaseline, H264::kLevel3_1); - constrained_baseline.SetParam( - cricket::kH264FmtpProfileLevelId, - *H264::ProfileLevelIdToString(constrained_baseline_profile)); - constrained_baseline.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1"); - constrained_baseline.SetParam(cricket::kH264FmtpPacketizationMode, "1"); - supported_codecs_.push_back(constrained_baseline); - supported_codecs_with_h264_hp_.push_back(constrained_baseline); + constrained_baseline.parameters[cricket::kH264FmtpProfileLevelId] = + *H264::ProfileLevelIdToString(constrained_baseline_profile); + constrained_baseline.parameters[cricket::kH264FmtpLevelAsymmetryAllowed] = + "1"; + constrained_baseline.parameters[cricket::kH264FmtpPacketizationMode] = "1"; + supported_formats_.push_back(constrained_baseline); + supported_formats_with_h264_hp_.push_back(constrained_baseline); } } @@ -1286,30 +1291,34 @@ void MediaCodecVideoEncoderFactory::SetEGLContext(JNIEnv* jni, } } -VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder( - const cricket::VideoCodec& codec) { - if (supported_codecs().empty()) { - ALOGW << "No HW video encoder for codec " << codec.name; +std::unique_ptr MediaCodecVideoEncoderFactory::CreateVideoEncoder( + const SdpVideoFormat& format) { + if (GetSupportedFormats().empty()) { + ALOGW << "No HW video encoder for codec " << format.name; return nullptr; } - if (FindMatchingCodec(supported_codecs(), codec)) { - ALOGD << "Create HW video encoder for " << codec.name; + if (IsFormatSupported(GetSupportedFormats(), format)) { + ALOGD << "Create HW video encoder for " << format.name; JNIEnv* jni = AttachCurrentThreadIfNeeded(); ScopedLocalRefFrame local_ref_frame(jni); - return new MediaCodecVideoEncoder(jni, codec, egl_context_); + return rtc::MakeUnique(jni, format, egl_context_); } - ALOGW << "Can not find HW video encoder for type " << codec.name; + ALOGW << "Can not find HW video encoder for type " << format.name; return nullptr; } -const std::vector& -MediaCodecVideoEncoderFactory::supported_codecs() const { - return supported_codecs_with_h264_hp_; +std::vector MediaCodecVideoEncoderFactory::GetSupportedFormats() + const { + return supported_formats_with_h264_hp_; } -void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(VideoEncoder* encoder) { - ALOGD << "Destroy video encoder."; - delete encoder; +VideoEncoderFactory::CodecInfo MediaCodecVideoEncoderFactory::QueryVideoEncoder( + const SdpVideoFormat& format) const { + VideoEncoderFactory::CodecInfo codec_info; + codec_info.is_hardware_accelerated = + IsFormatSupported(supported_formats_, format); + codec_info.has_internal_source = false; + return codec_info; } static void JNI_MediaCodecVideoEncoder_FillInputBuffer( diff --git a/sdk/android/src/jni/androidmediaencoder_jni.h b/sdk/android/src/jni/androidmediaencoder_jni.h index 4fd06bb8e2..ff63c959b4 100644 --- a/sdk/android/src/jni/androidmediaencoder_jni.h +++ b/sdk/android/src/jni/androidmediaencoder_jni.h @@ -13,32 +13,32 @@ #include -#include "media/engine/webrtcvideoencoderfactory.h" +#include "api/video_codecs/video_encoder_factory.h" #include "sdk/android/src/jni/jni_helpers.h" namespace webrtc { namespace jni { // Implementation of Android MediaCodec based encoder factory. -class MediaCodecVideoEncoderFactory - : public cricket::WebRtcVideoEncoderFactory { +class MediaCodecVideoEncoderFactory : public VideoEncoderFactory { public: MediaCodecVideoEncoderFactory(); ~MediaCodecVideoEncoderFactory() override; void SetEGLContext(JNIEnv* jni, jobject egl_context); - // WebRtcVideoEncoderFactory implementation. - VideoEncoder* CreateVideoEncoder(const cricket::VideoCodec& codec) override; - const std::vector& supported_codecs() const override; - void DestroyVideoEncoder(VideoEncoder* encoder) override; + // VideoEncoderFactory implementation. + std::vector GetSupportedFormats() const override; + CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override; + std::unique_ptr CreateVideoEncoder( + const SdpVideoFormat& format) override; private: jobject egl_context_; // Empty if platform support is lacking, const after ctor returns. - std::vector supported_codecs_; - std::vector supported_codecs_with_h264_hp_; + std::vector supported_formats_; + std::vector supported_formats_with_h264_hp_; }; } // namespace jni diff --git a/sdk/android/src/jni/pc/media.cc b/sdk/android/src/jni/pc/media.cc index 55ebae489e..dba85fbffa 100644 --- a/sdk/android/src/jni/pc/media.cc +++ b/sdk/android/src/jni/pc/media.cc @@ -30,21 +30,6 @@ RtcEventLogFactoryInterface* CreateRtcEventLogFactory() { return webrtc::CreateRtcEventLogFactory().release(); } -#if defined(USE_BUILTIN_SW_CODECS) -cricket::MediaEngineInterface* CreateMediaEngine( - AudioDeviceModule* adm, - const rtc::scoped_refptr& audio_encoder_factory, - const rtc::scoped_refptr& audio_decoder_factory, - cricket::WebRtcVideoEncoderFactory* video_encoder_factory, - cricket::WebRtcVideoDecoderFactory* video_decoder_factory, - rtc::scoped_refptr audio_mixer, - rtc::scoped_refptr audio_processor) { - return cricket::WebRtcMediaEngineFactory::Create( - adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory, - video_decoder_factory, audio_mixer, audio_processor); -} -#endif - cricket::MediaEngineInterface* CreateMediaEngine( rtc::scoped_refptr adm, rtc::scoped_refptr audio_encoder_factory, diff --git a/sdk/android/src/jni/pc/media.h b/sdk/android/src/jni/pc/media.h index 809f48ccd6..8a0bb52174 100644 --- a/sdk/android/src/jni/pc/media.h +++ b/sdk/android/src/jni/pc/media.h @@ -29,8 +29,6 @@ class VideoDecoderFactory; namespace cricket { class MediaEngineInterface; -class WebRtcVideoEncoderFactory; -class WebRtcVideoDecoderFactory; } // namespace cricket namespace webrtc { @@ -39,15 +37,6 @@ namespace jni { CallFactoryInterface* CreateCallFactory(); RtcEventLogFactoryInterface* CreateRtcEventLogFactory(); -cricket::MediaEngineInterface* CreateMediaEngine( - AudioDeviceModule* adm, - const rtc::scoped_refptr& audio_encoder_factory, - const rtc::scoped_refptr& audio_decoder_factory, - cricket::WebRtcVideoEncoderFactory* video_encoder_factory, - cricket::WebRtcVideoDecoderFactory* video_decoder_factory, - rtc::scoped_refptr audio_mixer, - rtc::scoped_refptr audio_processor); - cricket::MediaEngineInterface* CreateMediaEngine( rtc::scoped_refptr adm, rtc::scoped_refptr audio_encoder_factory, diff --git a/sdk/android/src/jni/pc/null_media.cc b/sdk/android/src/jni/pc/null_media.cc index d74eaa605f..c59c476d51 100644 --- a/sdk/android/src/jni/pc/null_media.cc +++ b/sdk/android/src/jni/pc/null_media.cc @@ -21,17 +21,6 @@ RtcEventLogFactoryInterface* CreateRtcEventLogFactory() { return nullptr; } -cricket::MediaEngineInterface* CreateMediaEngine( - AudioDeviceModule* adm, - const rtc::scoped_refptr& audio_encoder_factory, - const rtc::scoped_refptr& audio_decoder_factory, - cricket::WebRtcVideoEncoderFactory* video_encoder_factory, - cricket::WebRtcVideoDecoderFactory* video_decoder_factory, - rtc::scoped_refptr audio_mixer, - rtc::scoped_refptr audio_processor) { - return nullptr; -} - cricket::MediaEngineInterface* CreateMediaEngine( rtc::scoped_refptr adm, rtc::scoped_refptr audio_encoder_factory, diff --git a/sdk/android/src/jni/pc/null_video.cc b/sdk/android/src/jni/pc/null_video.cc index 72cc5066f7..c14b84cd87 100644 --- a/sdk/android/src/jni/pc/null_video.cc +++ b/sdk/android/src/jni/pc/null_video.cc @@ -10,6 +10,9 @@ #include "sdk/android/src/jni/pc/video.h" +#include "api/video_codecs/video_decoder_factory.h" +#include "api/video_codecs/video_encoder_factory.h" + namespace webrtc { namespace jni { @@ -26,10 +29,10 @@ VideoDecoderFactory* CreateVideoDecoderFactory( } void SetEglContext(JNIEnv* env, - cricket::WebRtcVideoEncoderFactory* encoder_factory, + VideoEncoderFactory* encoder_factory, const JavaRef& egl_context) {} void SetEglContext(JNIEnv* env, - cricket::WebRtcVideoDecoderFactory* decoder_factory, + VideoDecoderFactory* decoder_factory, const JavaRef& egl_context) {} void* CreateVideoSource(JNIEnv* env, @@ -39,28 +42,21 @@ void* CreateVideoSource(JNIEnv* env, return nullptr; } -void SetEglContext(JNIEnv* env, - cricket::WebRtcVideoEncoderFactory* encoder_factory, - jobject egl_context) {} -void SetEglContext(JNIEnv* env, - cricket::WebRtcVideoDecoderFactory* decoder_factory, - jobject egl_context) {} - -cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory() { +std::unique_ptr CreateLegacyVideoEncoderFactory() { return nullptr; } -cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory() { +std::unique_ptr CreateLegacyVideoDecoderFactory() { return nullptr; } -VideoEncoderFactory* WrapLegacyVideoEncoderFactory( - cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory) { +std::unique_ptr WrapLegacyVideoEncoderFactory( + std::unique_ptr legacy_encoder_factory) { return nullptr; } -VideoDecoderFactory* WrapLegacyVideoDecoderFactory( - cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory) { +std::unique_ptr WrapLegacyVideoDecoderFactory( + std::unique_ptr legacy_decoder_factory) { return nullptr; } diff --git a/sdk/android/src/jni/pc/ownedfactoryandthreads.h b/sdk/android/src/jni/pc/ownedfactoryandthreads.h index 27e262ab26..0f46e57f39 100644 --- a/sdk/android/src/jni/pc/ownedfactoryandthreads.h +++ b/sdk/android/src/jni/pc/ownedfactoryandthreads.h @@ -18,8 +18,6 @@ #include "api/peerconnectioninterface.h" #include "rtc_base/thread.h" -using cricket::WebRtcVideoDecoderFactory; -using cricket::WebRtcVideoEncoderFactory; using rtc::Thread; namespace webrtc { @@ -38,8 +36,8 @@ class OwnedFactoryAndThreads { OwnedFactoryAndThreads(std::unique_ptr network_thread, std::unique_ptr worker_thread, std::unique_ptr signaling_thread, - WebRtcVideoEncoderFactory* legacy_encoder_factory, - WebRtcVideoDecoderFactory* legacy_decoder_factory, + VideoEncoderFactory* legacy_encoder_factory, + VideoDecoderFactory* legacy_decoder_factory, rtc::NetworkMonitorFactory* network_monitor_factory, PeerConnectionFactoryInterface* factory) : network_thread_(std::move(network_thread)), @@ -56,10 +54,10 @@ class OwnedFactoryAndThreads { Thread* network_thread() { return network_thread_.get(); } Thread* signaling_thread() { return signaling_thread_.get(); } Thread* worker_thread() { return worker_thread_.get(); } - WebRtcVideoEncoderFactory* legacy_encoder_factory() { + VideoEncoderFactory* legacy_encoder_factory() { return legacy_encoder_factory_; } - WebRtcVideoDecoderFactory* legacy_decoder_factory() { + VideoDecoderFactory* legacy_decoder_factory() { return legacy_decoder_factory_; } rtc::NetworkMonitorFactory* network_monitor_factory() { @@ -72,8 +70,8 @@ class OwnedFactoryAndThreads { const std::unique_ptr network_thread_; const std::unique_ptr worker_thread_; const std::unique_ptr signaling_thread_; - WebRtcVideoEncoderFactory* legacy_encoder_factory_; - WebRtcVideoDecoderFactory* legacy_decoder_factory_; + VideoEncoderFactory* legacy_encoder_factory_; + VideoDecoderFactory* legacy_decoder_factory_; rtc::NetworkMonitorFactory* network_monitor_factory_; PeerConnectionFactoryInterface* factory_; // Const after ctor except dtor. }; diff --git a/sdk/android/src/jni/pc/peerconnectionfactory.cc b/sdk/android/src/jni/pc/peerconnectionfactory.cc index 04f9353d44..5dcc7e1da4 100644 --- a/sdk/android/src/jni/pc/peerconnectionfactory.cc +++ b/sdk/android/src/jni/pc/peerconnectionfactory.cc @@ -241,54 +241,43 @@ jlong CreatePeerConnectionFactoryForJava( std::unique_ptr rtc_event_log_factory( CreateRtcEventLogFactory()); - cricket::WebRtcVideoEncoderFactory* legacy_video_encoder_factory = nullptr; - cricket::WebRtcVideoDecoderFactory* legacy_video_decoder_factory = nullptr; + VideoEncoderFactory* legacy_video_encoder_factory = nullptr; + VideoDecoderFactory* legacy_video_decoder_factory = nullptr; std::unique_ptr media_engine; - if (jencoder_factory.is_null() && jdecoder_factory.is_null()) { -#if defined(USE_BUILTIN_SW_CODECS) - // This uses the legacy API, which automatically uses the internal SW - // codecs in WebRTC. - if (video_hw_acceleration_enabled) { - legacy_video_encoder_factory = CreateLegacyVideoEncoderFactory(); - legacy_video_decoder_factory = CreateLegacyVideoDecoderFactory(); - } - media_engine.reset(CreateMediaEngine( - audio_device_module, audio_encoder_factory, audio_decoder_factory, - legacy_video_encoder_factory, legacy_video_decoder_factory, audio_mixer, - audio_processor)); -#endif + + std::unique_ptr video_encoder_factory = nullptr; + if (jencoder_factory.is_null()) { + // TODO(bugs.webrtc.org/7925): When all clients switched to injectable + // factories, remove the legacy codec factories + std::unique_ptr legacy_factory = + CreateLegacyVideoEncoderFactory(); + legacy_video_encoder_factory = legacy_factory.get(); + video_encoder_factory = + WrapLegacyVideoEncoderFactory(std::move(legacy_factory)); } else { - // This uses the new API, does not automatically include software codecs. - std::unique_ptr video_encoder_factory = nullptr; - if (jencoder_factory.is_null()) { -#if defined(USE_BUILTIN_SW_CODECS) - legacy_video_encoder_factory = CreateLegacyVideoEncoderFactory(); - video_encoder_factory = std::unique_ptr( - WrapLegacyVideoEncoderFactory(legacy_video_encoder_factory)); -#endif - } else { - video_encoder_factory = std::unique_ptr( - CreateVideoEncoderFactory(jni, jencoder_factory)); - } - - std::unique_ptr video_decoder_factory = nullptr; - if (jdecoder_factory.is_null()) { -#if defined(USE_BUILTIN_SW_CODECS) - legacy_video_decoder_factory = CreateLegacyVideoDecoderFactory(); - video_decoder_factory = std::unique_ptr( - WrapLegacyVideoDecoderFactory(legacy_video_decoder_factory)); -#endif - } else { - video_decoder_factory = std::unique_ptr( - CreateVideoDecoderFactory(jni, jdecoder_factory)); - } - - media_engine.reset(CreateMediaEngine( - audio_device_module, audio_encoder_factory, audio_decoder_factory, - std::move(video_encoder_factory), std::move(video_decoder_factory), - audio_mixer, audio_processor)); + video_encoder_factory = std::unique_ptr( + CreateVideoEncoderFactory(jni, jencoder_factory)); } + std::unique_ptr video_decoder_factory = nullptr; + if (jdecoder_factory.is_null()) { + // TODO(bugs.webrtc.org/7925): When all clients switched to injectable + // factories, remove the legacy codec factories + std::unique_ptr legacy_factory = + CreateLegacyVideoDecoderFactory(); + legacy_video_decoder_factory = legacy_factory.get(); + video_decoder_factory = + WrapLegacyVideoDecoderFactory(std::move(legacy_factory)); + } else { + video_decoder_factory = std::unique_ptr( + CreateVideoDecoderFactory(jni, jdecoder_factory)); + } + + media_engine.reset(CreateMediaEngine( + audio_device_module, audio_encoder_factory, audio_decoder_factory, + std::move(video_encoder_factory), std::move(video_decoder_factory), + audio_mixer, audio_processor)); + rtc::scoped_refptr factory( CreateModularPeerConnectionFactory( network_thread.get(), worker_thread.get(), signaling_thread.get(), @@ -484,14 +473,12 @@ static void JNI_PeerConnectionFactory_SetVideoHwAccelerationOptions( jlong native_factory, const JavaParamRef& local_egl_context, const JavaParamRef& remote_egl_context) { -#if defined(USE_BUILTIN_SW_CODECS) OwnedFactoryAndThreads* owned_factory = reinterpret_cast(native_factory); SetEglContext(jni, owned_factory->legacy_encoder_factory(), local_egl_context); SetEglContext(jni, owned_factory->legacy_decoder_factory(), remote_egl_context); -#endif } static jlong JNI_PeerConnectionFactory_GetNativePeerConnectionFactory( diff --git a/sdk/android/src/jni/pc/video.cc b/sdk/android/src/jni/pc/video.cc index 9bf528ce4b..83ef8c763b 100644 --- a/sdk/android/src/jni/pc/video.cc +++ b/sdk/android/src/jni/pc/video.cc @@ -16,12 +16,9 @@ #include "api/video_codecs/video_decoder_factory.h" #include "api/video_codecs/video_encoder_factory.h" #include "api/videosourceproxy.h" -#if defined(USE_BUILTIN_SW_CODECS) -#include "media/engine/convert_legacy_video_factory.h" // nogncheck -#endif -#include "media/engine/webrtcvideodecoderfactory.h" -#include "media/engine/webrtcvideoencoderfactory.h" +#include "media/engine/convert_legacy_video_factory.h" #include "rtc_base/logging.h" +#include "rtc_base/ptr_util.h" #include "sdk/android/generated_video_jni/jni/EglBase14_jni.h" #include "sdk/android/src/jni/androidmediadecoder_jni.h" #include "sdk/android/src/jni/androidmediaencoder_jni.h" @@ -45,9 +42,8 @@ VideoDecoderFactory* CreateVideoDecoderFactory( } void SetEglContext(JNIEnv* env, - cricket::WebRtcVideoEncoderFactory* encoder_factory, + VideoEncoderFactory* encoder_factory, const JavaRef& egl_context) { -#if defined(USE_BUILTIN_SW_CODECS) if (encoder_factory) { MediaCodecVideoEncoderFactory* media_codec_factory = static_cast(encoder_factory); @@ -56,16 +52,10 @@ void SetEglContext(JNIEnv* env, media_codec_factory->SetEGLContext(env, egl_context.obj()); } } -#else - if (Java_Context_isEgl14Context(env, egl_context)) { - RTC_LOG(LS_INFO) << "Set EGL context for HW encoding."; - } -#endif } -#if defined(USE_BUILTIN_SW_CODECS) void SetEglContext(JNIEnv* env, - cricket::WebRtcVideoDecoderFactory* decoder_factory, + VideoDecoderFactory* decoder_factory, const JavaRef& egl_context) { if (decoder_factory) { MediaCodecVideoDecoderFactory* media_codec_factory = @@ -76,7 +66,6 @@ void SetEglContext(JNIEnv* env, } } } -#endif void* CreateVideoSource(JNIEnv* env, rtc::Thread* signaling_thread, @@ -89,31 +78,25 @@ void* CreateVideoSource(JNIEnv* env, .release(); } -#if defined(USE_BUILTIN_SW_CODECS) -cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory() { - return new MediaCodecVideoEncoderFactory(); +std::unique_ptr CreateLegacyVideoEncoderFactory() { + return rtc::MakeUnique(); } -cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory() { - return new MediaCodecVideoDecoderFactory(); +std::unique_ptr CreateLegacyVideoDecoderFactory() { + return rtc::MakeUnique(); } -VideoEncoderFactory* WrapLegacyVideoEncoderFactory( - cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory) { - return ConvertVideoEncoderFactory( - std::unique_ptr( - legacy_encoder_factory)) - .release(); +std::unique_ptr WrapLegacyVideoEncoderFactory( + std::unique_ptr legacy_encoder_factory) { + return std::unique_ptr( + cricket::ConvertVideoEncoderFactory(std::move(legacy_encoder_factory))); } -VideoDecoderFactory* WrapLegacyVideoDecoderFactory( - cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory) { - return ConvertVideoDecoderFactory( - std::unique_ptr( - legacy_decoder_factory)) - .release(); +std::unique_ptr WrapLegacyVideoDecoderFactory( + std::unique_ptr legacy_decoder_factory) { + return std::unique_ptr( + cricket::ConvertVideoDecoderFactory(std::move(legacy_decoder_factory))); } -#endif } // namespace jni } // namespace webrtc diff --git a/sdk/android/src/jni/pc/video.h b/sdk/android/src/jni/pc/video.h index a341488877..c198038f44 100644 --- a/sdk/android/src/jni/pc/video.h +++ b/sdk/android/src/jni/pc/video.h @@ -17,11 +17,6 @@ #include "rtc_base/thread.h" #include "sdk/android/native_api/jni/scoped_java_ref.h" -namespace cricket { -class WebRtcVideoEncoderFactory; -class WebRtcVideoDecoderFactory; -} // namespace cricket - namespace webrtc { class VideoEncoderFactory; class VideoDecoderFactory; @@ -39,10 +34,10 @@ VideoDecoderFactory* CreateVideoDecoderFactory( const JavaRef& j_decoder_factory); void SetEglContext(JNIEnv* env, - cricket::WebRtcVideoEncoderFactory* encoder_factory, + VideoEncoderFactory* encoder_factory, const JavaRef& egl_context); void SetEglContext(JNIEnv* env, - cricket::WebRtcVideoDecoderFactory* decoder_factory, + VideoDecoderFactory* decoder_factory, const JavaRef& egl_context); void* CreateVideoSource(JNIEnv* env, @@ -50,13 +45,13 @@ void* CreateVideoSource(JNIEnv* env, rtc::Thread* worker_thread, jboolean is_screencast); -cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory(); -cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory(); +std::unique_ptr CreateLegacyVideoEncoderFactory(); +std::unique_ptr CreateLegacyVideoDecoderFactory(); -VideoEncoderFactory* WrapLegacyVideoEncoderFactory( - cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory); -VideoDecoderFactory* WrapLegacyVideoDecoderFactory( - cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory); +std::unique_ptr WrapLegacyVideoEncoderFactory( + std::unique_ptr legacy_encoder_factory); +std::unique_ptr WrapLegacyVideoDecoderFactory( + std::unique_ptr legacy_decoder_factory); } // namespace jni } // namespace webrtc