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 <andersc@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23897}diff --git a/examples/BUILD.gn b/examples/BUILD.gn
index 4083230..1c24f91 100644
--- a/examples/BUILD.gn
+++ b/examples/BUILD.gn
@@ -113,6 +113,7 @@
"../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 af37a39..075ef91 100644
--- a/media/engine/convert_legacy_video_factory.cc
+++ b/media/engine/convert_legacy_video_factory.cc
@@ -101,6 +101,11 @@
absl::make_unique<CricketToWebRtcEncoderFactory>(
std::move(external_encoder_factory))) {}
+ explicit EncoderAdapter(
+ std::unique_ptr<webrtc::VideoEncoderFactory> 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 @@
const std::unique_ptr<webrtc::VideoEncoderFactory> 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<WebRtcVideoDecoderFactory> external_decoder_factory)
: external_decoder_factory_(std::move(external_decoder_factory)) {}
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const webrtc::SdpVideoFormat& format) override {
- std::unique_ptr<webrtc::VideoDecoder> 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<webrtc::VideoDecoder> 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<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
@@ -217,6 +200,65 @@
const std::unique_ptr<WebRtcVideoDecoderFactory> 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<WebRtcVideoDecoderFactory> external_decoder_factory)
+ : internal_decoder_factory_(new webrtc::InternalDecoderFactory()),
+ external_decoder_factory_(
+ absl::make_unique<CricketToWebRtcDecoderFactory>(
+ std::move(external_decoder_factory))) {}
+
+ explicit DecoderAdapter(
+ std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory)
+ : internal_decoder_factory_(new webrtc::InternalDecoderFactory()),
+ external_decoder_factory_(std::move(external_decoder_factory)) {}
+
+ std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
+ const webrtc::SdpVideoFormat& format) override {
+ std::unique_ptr<webrtc::VideoDecoder> internal_decoder;
+ if (IsFormatSupported(internal_decoder_factory_->GetSupportedFormats(),
+ format)) {
+ internal_decoder = internal_decoder_factory_->CreateVideoDecoder(format);
+ }
+
+ std::unique_ptr<webrtc::VideoDecoder> 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<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
+ std::vector<webrtc::SdpVideoFormat> 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<webrtc::VideoDecoderFactory> internal_decoder_factory_;
+ const std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory_;
+};
+
} // namespace
std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
@@ -225,10 +267,22 @@
new EncoderAdapter(std::move(external_encoder_factory)));
}
+std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
+ std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory) {
+ return std::unique_ptr<webrtc::VideoEncoderFactory>(
+ new EncoderAdapter(std::move(external_encoder_factory)));
+}
+
std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory) {
return std::unique_ptr<webrtc::VideoDecoderFactory>(
new DecoderAdapter(std::move(external_decoder_factory)));
}
+std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
+ std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory) {
+ return std::unique_ptr<webrtc::VideoDecoderFactory>(
+ 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 5bd3580..9d0d154 100644
--- a/media/engine/convert_legacy_video_factory.h
+++ b/media/engine/convert_legacy_video_factory.h
@@ -30,9 +30,15 @@
std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory);
+std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
+ std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory);
+
std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory);
+std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
+ std::unique_ptr<webrtc::VideoDecoderFactory> 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 a7e9939..33ecace 100644
--- a/sdk/android/BUILD.gn
+++ b/sdk/android/BUILD.gn
@@ -297,6 +297,7 @@
"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 @@
"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 @@
"../../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("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 @@
deps = [
":base_jni",
+ "../../api/video_codecs:video_codecs_api",
]
}
@@ -627,6 +669,9 @@
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 @@
":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 @@
":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 @@
]
}
-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 @@
"//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("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 @@
deps = [
":base_java",
+ ":default_video_codec_factory_java",
":libjingle_peerconnection_java",
":libjingle_peerconnection_metrics_default_java",
":video_api_java",
@@ -1222,6 +1268,9 @@
# 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 @@
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 96fc748..74a6a52 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 @@
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 @@
}
}
-VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
- VideoCodecType type) {
- if (supported_codec_types_.empty()) {
- ALOGW << "No HW video decoder for type " << static_cast<int>(type);
- return nullptr;
- }
- for (VideoCodecType codec_type : supported_codec_types_) {
- if (codec_type == type) {
- ALOGD << "Create HW video decoder for type " << static_cast<int>(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<int>(type);
- return nullptr;
+std::vector<SdpVideoFormat> MediaCodecVideoDecoderFactory::GetSupportedFormats()
+ const {
+ return supported_formats_;
}
-void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(VideoDecoder* decoder) {
- ALOGD << "Destroy video decoder.";
- delete decoder;
+std::unique_ptr<VideoDecoder> 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<MediaCodecVideoDecoder>(
+ 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 b984dc5..28b8652 100644
--- a/sdk/android/src/jni/androidmediadecoder_jni.h
+++ b/sdk/android/src/jni/androidmediadecoder_jni.h
@@ -13,31 +13,30 @@
#include <vector>
-#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<SdpVideoFormat> GetSupportedFormats() const override;
+ std::unique_ptr<VideoDecoder> CreateVideoDecoder(
+ const SdpVideoFormat& format) override;
static bool IsH264HighProfileSupported(JNIEnv* env);
private:
jobject egl_context_;
- std::vector<VideoCodecType> supported_codec_types_;
+ std::vector<SdpVideoFormat> supported_formats_;
};
} // namespace jni
diff --git a/sdk/android/src/jni/androidmediaencoder.cc b/sdk/android/src/jni/androidmediaencoder.cc
index 9edbf2d..595484a 100644
--- a/sdk/android/src/jni/androidmediaencoder.cc
+++ b/sdk/android/src/jni/androidmediaencoder.cc
@@ -18,11 +18,14 @@
#include <string>
#include <utility>
+#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 @@
public:
~MediaCodecVideoEncoder() override;
MediaCodecVideoEncoder(JNIEnv* jni,
- const cricket::VideoCodec& codec,
+ const SdpVideoFormat& format,
jobject egl_context);
// VideoEncoder implementation.
@@ -197,7 +201,7 @@
#endif
// Type of video codec.
- const cricket::VideoCodec codec_;
+ const SdpVideoFormat format_;
EncodedImageCallback* callback_;
@@ -297,9 +301,9 @@
}
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 @@
profile_ = H264::Profile::kProfileBaseline;
if (codec_type == kVideoCodecH264) {
const absl::optional<H264::ProfileLevelId> 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 @@
return false;
}
-bool IsFormatSupported(
- const std::vector<webrtc::SdpVideoFormat>& 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<SdpVideoFormat>& 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 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 @@
}
VideoCodecType MediaCodecVideoEncoder::GetCodecType() const {
- return PayloadStringToCodecType(codec_.name);
+ return PayloadStringToCodecType(format_.name);
}
int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
@@ -1210,20 +1216,20 @@
: 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 @@
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 @@
// 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 @@
}
}
-VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
- const cricket::VideoCodec& codec) {
- if (supported_codecs().empty()) {
- ALOGW << "No HW video encoder for codec " << codec.name;
+std::unique_ptr<VideoEncoder> 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<MediaCodecVideoEncoder>(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<cricket::VideoCodec>&
-MediaCodecVideoEncoderFactory::supported_codecs() const {
- return supported_codecs_with_h264_hp_;
+std::vector<SdpVideoFormat> 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 4fd06bb..ff63c95 100644
--- a/sdk/android/src/jni/androidmediaencoder_jni.h
+++ b/sdk/android/src/jni/androidmediaencoder_jni.h
@@ -13,32 +13,32 @@
#include <vector>
-#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<cricket::VideoCodec>& supported_codecs() const override;
- void DestroyVideoEncoder(VideoEncoder* encoder) override;
+ // VideoEncoderFactory implementation.
+ std::vector<SdpVideoFormat> GetSupportedFormats() const override;
+ CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override;
+ std::unique_ptr<VideoEncoder> CreateVideoEncoder(
+ const SdpVideoFormat& format) override;
private:
jobject egl_context_;
// Empty if platform support is lacking, const after ctor returns.
- std::vector<cricket::VideoCodec> supported_codecs_;
- std::vector<cricket::VideoCodec> supported_codecs_with_h264_hp_;
+ std::vector<SdpVideoFormat> supported_formats_;
+ std::vector<SdpVideoFormat> 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 55ebae4..dba85fbf 100644
--- a/sdk/android/src/jni/pc/media.cc
+++ b/sdk/android/src/jni/pc/media.cc
@@ -30,21 +30,6 @@
return webrtc::CreateRtcEventLogFactory().release();
}
-#if defined(USE_BUILTIN_SW_CODECS)
-cricket::MediaEngineInterface* CreateMediaEngine(
- AudioDeviceModule* adm,
- const rtc::scoped_refptr<AudioEncoderFactory>& audio_encoder_factory,
- const rtc::scoped_refptr<AudioDecoderFactory>& audio_decoder_factory,
- cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
- cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
- rtc::scoped_refptr<AudioMixer> audio_mixer,
- rtc::scoped_refptr<AudioProcessing> 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<AudioDeviceModule> adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
diff --git a/sdk/android/src/jni/pc/media.h b/sdk/android/src/jni/pc/media.h
index 809f48c..8a0bb52 100644
--- a/sdk/android/src/jni/pc/media.h
+++ b/sdk/android/src/jni/pc/media.h
@@ -29,8 +29,6 @@
namespace cricket {
class MediaEngineInterface;
-class WebRtcVideoEncoderFactory;
-class WebRtcVideoDecoderFactory;
} // namespace cricket
namespace webrtc {
@@ -40,15 +38,6 @@
RtcEventLogFactoryInterface* CreateRtcEventLogFactory();
cricket::MediaEngineInterface* CreateMediaEngine(
- AudioDeviceModule* adm,
- const rtc::scoped_refptr<AudioEncoderFactory>& audio_encoder_factory,
- const rtc::scoped_refptr<AudioDecoderFactory>& audio_decoder_factory,
- cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
- cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
- rtc::scoped_refptr<AudioMixer> audio_mixer,
- rtc::scoped_refptr<AudioProcessing> audio_processor);
-
-cricket::MediaEngineInterface* CreateMediaEngine(
rtc::scoped_refptr<AudioDeviceModule> adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
diff --git a/sdk/android/src/jni/pc/null_media.cc b/sdk/android/src/jni/pc/null_media.cc
index d74eaa6..c59c476 100644
--- a/sdk/android/src/jni/pc/null_media.cc
+++ b/sdk/android/src/jni/pc/null_media.cc
@@ -22,17 +22,6 @@
}
cricket::MediaEngineInterface* CreateMediaEngine(
- AudioDeviceModule* adm,
- const rtc::scoped_refptr<AudioEncoderFactory>& audio_encoder_factory,
- const rtc::scoped_refptr<AudioDecoderFactory>& audio_decoder_factory,
- cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
- cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
- rtc::scoped_refptr<AudioMixer> audio_mixer,
- rtc::scoped_refptr<AudioProcessing> audio_processor) {
- return nullptr;
-}
-
-cricket::MediaEngineInterface* CreateMediaEngine(
rtc::scoped_refptr<AudioDeviceModule> adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
diff --git a/sdk/android/src/jni/pc/null_video.cc b/sdk/android/src/jni/pc/null_video.cc
index 72cc506..c14b84c 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 @@
}
void SetEglContext(JNIEnv* env,
- cricket::WebRtcVideoEncoderFactory* encoder_factory,
+ VideoEncoderFactory* encoder_factory,
const JavaRef<jobject>& egl_context) {}
void SetEglContext(JNIEnv* env,
- cricket::WebRtcVideoDecoderFactory* decoder_factory,
+ VideoDecoderFactory* decoder_factory,
const JavaRef<jobject>& egl_context) {}
void* CreateVideoSource(JNIEnv* env,
@@ -39,28 +42,21 @@
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<VideoEncoderFactory> CreateLegacyVideoEncoderFactory() {
return nullptr;
}
-cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory() {
+std::unique_ptr<VideoDecoderFactory> CreateLegacyVideoDecoderFactory() {
return nullptr;
}
-VideoEncoderFactory* WrapLegacyVideoEncoderFactory(
- cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory) {
+std::unique_ptr<VideoEncoderFactory> WrapLegacyVideoEncoderFactory(
+ std::unique_ptr<VideoEncoderFactory> legacy_encoder_factory) {
return nullptr;
}
-VideoDecoderFactory* WrapLegacyVideoDecoderFactory(
- cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory) {
+std::unique_ptr<VideoDecoderFactory> WrapLegacyVideoDecoderFactory(
+ std::unique_ptr<VideoDecoderFactory> legacy_decoder_factory) {
return nullptr;
}
diff --git a/sdk/android/src/jni/pc/ownedfactoryandthreads.h b/sdk/android/src/jni/pc/ownedfactoryandthreads.h
index 27e262a..0f46e57 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 @@
OwnedFactoryAndThreads(std::unique_ptr<Thread> network_thread,
std::unique_ptr<Thread> worker_thread,
std::unique_ptr<Thread> 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 @@
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 @@
const std::unique_ptr<Thread> network_thread_;
const std::unique_ptr<Thread> worker_thread_;
const std::unique_ptr<Thread> 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 04f9353..5dcc7e1 100644
--- a/sdk/android/src/jni/pc/peerconnectionfactory.cc
+++ b/sdk/android/src/jni/pc/peerconnectionfactory.cc
@@ -241,54 +241,43 @@
std::unique_ptr<RtcEventLogFactoryInterface> 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<cricket::MediaEngineInterface> 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<VideoEncoderFactory> 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<VideoEncoderFactory> 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<VideoEncoderFactory> 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<VideoEncoderFactory>(
- WrapLegacyVideoEncoderFactory(legacy_video_encoder_factory));
-#endif
- } else {
- video_encoder_factory = std::unique_ptr<VideoEncoderFactory>(
- CreateVideoEncoderFactory(jni, jencoder_factory));
- }
-
- std::unique_ptr<VideoDecoderFactory> 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<VideoDecoderFactory>(
- WrapLegacyVideoDecoderFactory(legacy_video_decoder_factory));
-#endif
- } else {
- video_decoder_factory = std::unique_ptr<VideoDecoderFactory>(
- 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<VideoEncoderFactory>(
+ CreateVideoEncoderFactory(jni, jencoder_factory));
}
+ std::unique_ptr<VideoDecoderFactory> 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<VideoDecoderFactory> 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<VideoDecoderFactory>(
+ 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<PeerConnectionFactoryInterface> factory(
CreateModularPeerConnectionFactory(
network_thread.get(), worker_thread.get(), signaling_thread.get(),
@@ -484,14 +473,12 @@
jlong native_factory,
const JavaParamRef<jobject>& local_egl_context,
const JavaParamRef<jobject>& remote_egl_context) {
-#if defined(USE_BUILTIN_SW_CODECS)
OwnedFactoryAndThreads* owned_factory =
reinterpret_cast<OwnedFactoryAndThreads*>(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 9bf528c..83ef8c7 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 @@
}
void SetEglContext(JNIEnv* env,
- cricket::WebRtcVideoEncoderFactory* encoder_factory,
+ VideoEncoderFactory* encoder_factory,
const JavaRef<jobject>& egl_context) {
-#if defined(USE_BUILTIN_SW_CODECS)
if (encoder_factory) {
MediaCodecVideoEncoderFactory* media_codec_factory =
static_cast<MediaCodecVideoEncoderFactory*>(encoder_factory);
@@ -56,16 +52,10 @@
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<jobject>& egl_context) {
if (decoder_factory) {
MediaCodecVideoDecoderFactory* media_codec_factory =
@@ -76,7 +66,6 @@
}
}
}
-#endif
void* CreateVideoSource(JNIEnv* env,
rtc::Thread* signaling_thread,
@@ -89,31 +78,25 @@
.release();
}
-#if defined(USE_BUILTIN_SW_CODECS)
-cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory() {
- return new MediaCodecVideoEncoderFactory();
+std::unique_ptr<VideoEncoderFactory> CreateLegacyVideoEncoderFactory() {
+ return rtc::MakeUnique<MediaCodecVideoEncoderFactory>();
}
-cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory() {
- return new MediaCodecVideoDecoderFactory();
+std::unique_ptr<VideoDecoderFactory> CreateLegacyVideoDecoderFactory() {
+ return rtc::MakeUnique<MediaCodecVideoDecoderFactory>();
}
-VideoEncoderFactory* WrapLegacyVideoEncoderFactory(
- cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory) {
- return ConvertVideoEncoderFactory(
- std::unique_ptr<cricket::WebRtcVideoEncoderFactory>(
- legacy_encoder_factory))
- .release();
+std::unique_ptr<VideoEncoderFactory> WrapLegacyVideoEncoderFactory(
+ std::unique_ptr<VideoEncoderFactory> legacy_encoder_factory) {
+ return std::unique_ptr<VideoEncoderFactory>(
+ cricket::ConvertVideoEncoderFactory(std::move(legacy_encoder_factory)));
}
-VideoDecoderFactory* WrapLegacyVideoDecoderFactory(
- cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory) {
- return ConvertVideoDecoderFactory(
- std::unique_ptr<cricket::WebRtcVideoDecoderFactory>(
- legacy_decoder_factory))
- .release();
+std::unique_ptr<VideoDecoderFactory> WrapLegacyVideoDecoderFactory(
+ std::unique_ptr<VideoDecoderFactory> legacy_decoder_factory) {
+ return std::unique_ptr<VideoDecoderFactory>(
+ 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 a341488..c198038 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 @@
const JavaRef<jobject>& j_decoder_factory);
void SetEglContext(JNIEnv* env,
- cricket::WebRtcVideoEncoderFactory* encoder_factory,
+ VideoEncoderFactory* encoder_factory,
const JavaRef<jobject>& egl_context);
void SetEglContext(JNIEnv* env,
- cricket::WebRtcVideoDecoderFactory* decoder_factory,
+ VideoDecoderFactory* decoder_factory,
const JavaRef<jobject>& egl_context);
void* CreateVideoSource(JNIEnv* env,
@@ -50,13 +45,13 @@
rtc::Thread* worker_thread,
jboolean is_screencast);
-cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory();
-cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory();
+std::unique_ptr<VideoEncoderFactory> CreateLegacyVideoEncoderFactory();
+std::unique_ptr<VideoDecoderFactory> CreateLegacyVideoDecoderFactory();
-VideoEncoderFactory* WrapLegacyVideoEncoderFactory(
- cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory);
-VideoDecoderFactory* WrapLegacyVideoDecoderFactory(
- cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory);
+std::unique_ptr<VideoEncoderFactory> WrapLegacyVideoEncoderFactory(
+ std::unique_ptr<VideoEncoderFactory> legacy_encoder_factory);
+std::unique_ptr<VideoDecoderFactory> WrapLegacyVideoDecoderFactory(
+ std::unique_ptr<VideoDecoderFactory> legacy_decoder_factory);
} // namespace jni
} // namespace webrtc
