mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 13:50:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Migrate legacy Android video codec factories.

Browse source 
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}
This commit is contained in:
Anders Carlsson 2018-07-10 09:33:30 +02:00 committed by Commit Bot
parent ef43aafcf5
commit 1e06d885dc
16 changed files with 360 additions and 315 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
examples/BUILD.gn
View file

@ -113,6 +113,7 @@ if (is_android) {
"../sdk/android:audio_api_java", "../sdk/android:audio_api_java",
"../sdk/android:base_java", "../sdk/android:base_java",
"../sdk/android:camera_java", "../sdk/android:camera_java",
"../sdk/android:default_video_codec_factory_java",
"../sdk/android:filevideo_java", "../sdk/android:filevideo_java",
"../sdk/android:hwcodecs_java", "../sdk/android:hwcodecs_java",
"../sdk/android:java_audio_device_module_java", "../sdk/android:java_audio_device_module_java",

110
media/engine/convert_legacy_video_factory.cc
View file

@ -101,6 +101,11 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory {
absl::make_unique<CricketToWebRtcEncoderFactory>( absl::make_unique<CricketToWebRtcEncoderFactory>(
std::move(external_encoder_factory))) {} 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( webrtc::VideoEncoderFactory::CodecInfo QueryVideoEncoder(
const webrtc::SdpVideoFormat& format) const override { const webrtc::SdpVideoFormat& format) const override {
if (IsFormatSupported(external_encoder_factory_->GetSupportedFormats(), if (IsFormatSupported(external_encoder_factory_->GetSupportedFormats(),
@ -171,40 +176,18 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory {
const std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory_; const std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory_;
}; };
// This class combines an external factory with the internal factory and adds // Converts the cricket::WebRtcVideoDecoderFactory to a
// internal SW codecs, simulcast, and SW fallback wrappers. // webrtc::VideoDecoderFactory (without adding any SW fallback).
class DecoderAdapter : public webrtc::VideoDecoderFactory { class CricketToWebRtcDecoderFactory : public webrtc::VideoDecoderFactory {
public: public:
explicit DecoderAdapter( explicit CricketToWebRtcDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory) std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory)
: external_decoder_factory_(std::move(external_decoder_factory)) {} : external_decoder_factory_(std::move(external_decoder_factory)) {}
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const webrtc::SdpVideoFormat& format) override { const webrtc::SdpVideoFormat& format) override {
std::unique_ptr<webrtc::VideoDecoder> internal_decoder; return CreateScopedVideoDecoder(external_decoder_factory_.get(),
webrtc::InternalDecoderFactory internal_decoder_factory; VideoCodec(format), {});
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;
} }
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override { std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
@ -217,6 +200,65 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory {
const std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory_; 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 } // namespace
std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory( std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
@ -225,10 +267,22 @@ std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
new EncoderAdapter(std::move(external_encoder_factory))); 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<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory) { std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory) {
return std::unique_ptr<webrtc::VideoDecoderFactory>( return std::unique_ptr<webrtc::VideoDecoderFactory>(
new DecoderAdapter(std::move(external_decoder_factory))); 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 } // namespace cricket

6
media/engine/convert_legacy_video_factory.h
View file

@ -30,9 +30,15 @@ class WebRtcVideoDecoderFactory;
std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory( std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory); 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<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory); std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory);
std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory);
} // namespace cricket } // namespace cricket
#endif // MEDIA_ENGINE_CONVERT_LEGACY_VIDEO_FACTORY_H_ #endif // MEDIA_ENGINE_CONVERT_LEGACY_VIDEO_FACTORY_H_

150
sdk/android/BUILD.gn
View file

@ -297,6 +297,7 @@ rtc_static_library("video_jni") {
"src/jni/androidvideotracksource.h", "src/jni/androidvideotracksource.h",
"src/jni/encodedimage.cc", "src/jni/encodedimage.cc",
"src/jni/encodedimage.h", "src/jni/encodedimage.h",
"src/jni/hardwarevideoencoderfactory.cc",
"src/jni/jni_generator_helper.h", "src/jni/jni_generator_helper.h",
"src/jni/nativecapturerobserver.cc", "src/jni/nativecapturerobserver.cc",
"src/jni/nativecapturerobserver.h", "src/jni/nativecapturerobserver.h",
@ -317,37 +318,21 @@ rtc_static_library("video_jni") {
"src/jni/videoencoderfallback.cc", "src/jni/videoencoderfallback.cc",
"src/jni/videoencoderwrapper.cc", "src/jni/videoencoderwrapper.cc",
"src/jni/videoencoderwrapper.h", "src/jni/videoencoderwrapper.h",
"src/jni/videoframe.cc",
"src/jni/videoframe.h",
"src/jni/videosink.cc", "src/jni/videosink.cc",
"src/jni/videosink.h", "src/jni/videosink.h",
"src/jni/videosource.cc", "src/jni/videosource.cc",
"src/jni/videotrack.cc", "src/jni/videotrack.cc",
"src/jni/wrapped_native_i420_buffer.cc",
"src/jni/wrapped_native_i420_buffer.h",
"src/jni/yuvhelper.cc", "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 += [ deps += [
":base_jni", ":base_jni",
":generated_video_jni", ":generated_video_jni",
":legacy_video_jni", # TODO(bugs.webrtc.org/7925): Remove.
":native_api_jni", ":native_api_jni",
":videoframe_jni",
":vp8_jni", # TODO(bugs.webrtc.org/7925): Remove.
":vp9_jni", # TODO(bugs.webrtc.org/7925): Remove.
"../..:webrtc_common", "../..:webrtc_common",
"../../api:libjingle_peerconnection_api", "../../api:libjingle_peerconnection_api",
"../../api/video:video_frame", "../../api/video:video_frame",
@ -356,6 +341,7 @@ rtc_static_library("video_jni") {
"../../common_video:common_video", "../../common_video:common_video",
"../../media:rtc_audio_video", "../../media:rtc_audio_video",
"../../media:rtc_h264_profile_id", "../../media:rtc_h264_profile_id",
"../../media:rtc_internal_video_codecs",
"../../media:rtc_media_base", "../../media:rtc_media_base",
"../../modules:module_api", "../../modules:module_api",
"../../modules/utility:utility", "../../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") { rtc_static_library("null_video_jni") {
sources = [ sources = [
"src/jni/pc/null_video.cc", "src/jni/pc/null_video.cc",
@ -381,6 +422,7 @@ rtc_static_library("null_video_jni") {
deps = [ deps = [
":base_jni", ":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") { rtc_static_library("libjingle_peerconnection_metrics_default_jni") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ "software_video_codecs" ] # TODO(bugs.webrtc.org/7925): Remove.
sources = [ sources = [
"src/jni/androidmetrics.cc", "src/jni/androidmetrics.cc",
] ]
@ -698,6 +743,7 @@ dist_jar("libwebrtc") {
":audio_api_java", ":audio_api_java",
":base_java", ":base_java",
":camera_java", ":camera_java",
":default_video_codec_factory_java",
":filevideo_java", ":filevideo_java",
":hwcodecs_java", ":hwcodecs_java",
":java_audio_device_module_java", ":java_audio_device_module_java",
@ -707,15 +753,12 @@ dist_jar("libwebrtc") {
":peerconnection_java", ":peerconnection_java",
":screencapturer_java", ":screencapturer_java",
":surfaceviewrenderer_java", ":surfaceviewrenderer_java",
":swcodecs_java",
":video_api_java", ":video_api_java",
":video_java", ":video_java",
"../../modules/audio_device:audio_device_java", "../../modules/audio_device:audio_device_java",
"../../rtc_base:base_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. # 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") {
rtc_android_library("swcodecs_java") { java_files = [
java_files = [ "api/org/webrtc/SoftwareVideoDecoderFactory.java",
"api/org/webrtc/SoftwareVideoDecoderFactory.java", "api/org/webrtc/SoftwareVideoEncoderFactory.java",
"api/org/webrtc/SoftwareVideoEncoderFactory.java", "src/java/org/webrtc/VP8Encoder.java",
"src/java/org/webrtc/VP8Encoder.java", "src/java/org/webrtc/VP8Decoder.java",
"src/java/org/webrtc/VP8Decoder.java", "src/java/org/webrtc/VP9Encoder.java",
"src/java/org/webrtc/VP9Encoder.java", "src/java/org/webrtc/VP9Decoder.java",
"src/java/org/webrtc/VP9Decoder.java", ]
]
deps = [ deps = [
":base_java", ":base_java",
":video_api_java", ":video_api_java",
":video_java", ":video_java",
"//rtc_base:base_java", "//rtc_base:base_java",
] ]
}
} }
rtc_android_library("hwcodecs_java") { rtc_android_library("hwcodecs_java") {
@ -1021,15 +1062,6 @@ rtc_android_library("libjingle_peerconnection_java") {
"//modules/audio_device:audio_device_java", "//modules/audio_device:audio_device_java",
"//rtc_base:base_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") { 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) { if (rtc_include_tests) {
rtc_instrumentation_test_apk("libjingle_peerconnection_android_unittest") { rtc_instrumentation_test_apk("libjingle_peerconnection_android_unittest") {
apk_name = "libjingle_peerconnection_android_unittest" apk_name = "libjingle_peerconnection_android_unittest"
@ -1079,6 +1124,7 @@ if (rtc_include_tests) {
deps = [ deps = [
":base_java", ":base_java",
":default_video_codec_factory_java",
":libjingle_peerconnection_java", ":libjingle_peerconnection_java",
":libjingle_peerconnection_metrics_default_java", ":libjingle_peerconnection_metrics_default_java",
":video_api_java", ":video_api_java",
@ -1222,6 +1268,9 @@ rtc_static_library("native_api_codecs") {
# API for creating Java PeerConnectionFactory from C++ equivalents. # API for creating Java PeerConnectionFactory from C++ equivalents.
rtc_static_library("native_api_peerconnection") { rtc_static_library("native_api_peerconnection") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ "software_video_codecs" ] # TODO(bugs.webrtc.org/7925): Remove.
sources = [ sources = [
"native_api/peerconnection/peerconnectionfactory.cc", "native_api/peerconnection/peerconnectionfactory.cc",
"native_api/peerconnection/peerconnectionfactory.h", "native_api/peerconnection/peerconnectionfactory.h",
@ -1258,6 +1307,7 @@ rtc_static_library("native_api_video") {
deps = [ deps = [
":native_api_jni", ":native_api_jni",
":video_jni", ":video_jni",
":videoframe_jni",
"//api:libjingle_peerconnection_api", "//api:libjingle_peerconnection_api",
"//api/video:video_frame", "//api/video:video_frame",
"//rtc_base:rtc_base_approved", "//rtc_base:rtc_base_approved",

50
sdk/android/src/jni/androidmediadecoder.cc
View file

@ -17,14 +17,17 @@
// androidmediacodeccommon.h to avoid build errors. // androidmediacodeccommon.h to avoid build errors.
#include "sdk/android/src/jni/androidmediadecoder_jni.h" #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/h264/h264_bitstream_parser.h"
#include "common_video/include/i420_buffer_pool.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/include/video_codec_interface.h"
#include "modules/video_coding/utility/vp8_header_parser.h" #include "modules/video_coding/utility/vp8_header_parser.h"
#include "rtc_base/bind.h" #include "rtc_base/bind.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_conversions.h" #include "rtc_base/numerics/safe_conversions.h"
#include "rtc_base/ptr_util.h"
#include "rtc_base/scoped_ref_ptr.h" #include "rtc_base/scoped_ref_ptr.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "rtc_base/timeutils.h" #include "rtc_base/timeutils.h"
@ -781,24 +784,24 @@ MediaCodecVideoDecoderFactory::MediaCodecVideoDecoderFactory()
ALOGD << "MediaCodecVideoDecoderFactory ctor"; ALOGD << "MediaCodecVideoDecoderFactory ctor";
JNIEnv* jni = AttachCurrentThreadIfNeeded(); JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni); ScopedLocalRefFrame local_ref_frame(jni);
supported_codec_types_.clear(); supported_formats_.clear();
if (Java_MediaCodecVideoDecoder_isVp8HwSupported(jni) && if (Java_MediaCodecVideoDecoder_isVp8HwSupported(jni) &&
!CheckException(jni)) { !CheckException(jni)) {
ALOGD << "VP8 HW Decoder supported."; ALOGD << "VP8 HW Decoder supported.";
supported_codec_types_.push_back(kVideoCodecVP8); supported_formats_.push_back(SdpVideoFormat(cricket::kVp8CodecName));
} }
if (Java_MediaCodecVideoDecoder_isVp9HwSupported(jni) && if (Java_MediaCodecVideoDecoder_isVp9HwSupported(jni) &&
!CheckException(jni)) { !CheckException(jni)) {
ALOGD << "VP9 HW Decoder supported."; ALOGD << "VP9 HW Decoder supported.";
supported_codec_types_.push_back(kVideoCodecVP9); supported_formats_.push_back(SdpVideoFormat(cricket::kVp9CodecName));
} }
if (Java_MediaCodecVideoDecoder_isH264HwSupported(jni) && if (Java_MediaCodecVideoDecoder_isH264HwSupported(jni) &&
!CheckException(jni)) { !CheckException(jni)) {
ALOGD << "H264 HW Decoder supported."; 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( std::vector<SdpVideoFormat> MediaCodecVideoDecoderFactory::GetSupportedFormats()
VideoCodecType type) { const {
if (supported_codec_types_.empty()) { return supported_formats_;
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;
} }
void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(VideoDecoder* decoder) { std::unique_ptr<VideoDecoder> MediaCodecVideoDecoderFactory::CreateVideoDecoder(
ALOGD << "Destroy video decoder."; const SdpVideoFormat& format) {
delete decoder; 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) { bool MediaCodecVideoDecoderFactory::IsH264HighProfileSupported(JNIEnv* env) {

15
sdk/android/src/jni/androidmediadecoder_jni.h
View file

@ -13,31 +13,30 @@
#include <vector> #include <vector>
#include "media/engine/webrtcvideodecoderfactory.h" #include "api/video_codecs/video_decoder_factory.h"
#include "sdk/android/src/jni/jni_helpers.h" #include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc { namespace webrtc {
namespace jni { namespace jni {
// Implementation of Android MediaCodec based decoder factory. // Implementation of Android MediaCodec based decoder factory.
class MediaCodecVideoDecoderFactory class MediaCodecVideoDecoderFactory : public VideoDecoderFactory {
: public cricket::WebRtcVideoDecoderFactory {
public: public:
MediaCodecVideoDecoderFactory(); MediaCodecVideoDecoderFactory();
~MediaCodecVideoDecoderFactory() override; ~MediaCodecVideoDecoderFactory() override;
void SetEGLContext(JNIEnv* jni, jobject render_egl_context); void SetEGLContext(JNIEnv* jni, jobject render_egl_context);
// WebRtcVideoDecoderFactory implementation. // VideoDecoderFactory implementation.
VideoDecoder* CreateVideoDecoder(VideoCodecType type) override; std::vector<SdpVideoFormat> GetSupportedFormats() const override;
std::unique_ptr<VideoDecoder> CreateVideoDecoder(
void DestroyVideoDecoder(VideoDecoder* decoder) override; const SdpVideoFormat& format) override;
static bool IsH264HighProfileSupported(JNIEnv* env); static bool IsH264HighProfileSupported(JNIEnv* env);
private: private:
jobject egl_context_; jobject egl_context_;
std::vector<VideoCodecType> supported_codec_types_; std::vector<SdpVideoFormat> supported_formats_;
}; };
} // namespace jni } // namespace jni

99
sdk/android/src/jni/androidmediaencoder.cc
View file

@ -18,11 +18,14 @@
#include <string> #include <string>
#include <utility> #include <utility>
#include "api/video_codecs/sdp_video_format.h"
#include "api/video_codecs/video_encoder.h" #include "api/video_codecs/video_encoder.h"
#include "common_types.h" // NOLINT(build/include) #include "common_types.h" // NOLINT(build/include)
#include "common_video/h264/h264_bitstream_parser.h" #include "common_video/h264/h264_bitstream_parser.h"
#include "common_video/h264/h264_common.h" #include "common_video/h264/h264_common.h"
#include "common_video/h264/profile_level_id.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 "media/engine/internalencoderfactory.h"
#include "modules/video_coding/include/video_codec_interface.h" #include "modules/video_coding/include/video_codec_interface.h"
#include "modules/video_coding/utility/quality_scaler.h" #include "modules/video_coding/utility/quality_scaler.h"
@ -31,6 +34,7 @@
#include "rtc_base/bind.h" #include "rtc_base/bind.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/ptr_util.h"
#include "rtc_base/sequenced_task_checker.h" #include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/task_queue.h" #include "rtc_base/task_queue.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
@ -93,7 +97,7 @@ class MediaCodecVideoEncoder : public VideoEncoder {
public: public:
~MediaCodecVideoEncoder() override; ~MediaCodecVideoEncoder() override;
MediaCodecVideoEncoder(JNIEnv* jni, MediaCodecVideoEncoder(JNIEnv* jni,
const cricket::VideoCodec& codec, const SdpVideoFormat& format,
jobject egl_context); jobject egl_context);
// VideoEncoder implementation. // VideoEncoder implementation.
@ -197,7 +201,7 @@ class MediaCodecVideoEncoder : public VideoEncoder {
#endif #endif
// Type of video codec. // Type of video codec.
const cricket::VideoCodec codec_; const SdpVideoFormat format_;
EncodedImageCallback* callback_; EncodedImageCallback* callback_;
@ -297,9 +301,9 @@ MediaCodecVideoEncoder::~MediaCodecVideoEncoder() {
} }
MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni, MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni,
const cricket::VideoCodec& codec, const SdpVideoFormat& format,
jobject egl_context) jobject egl_context)
: codec_(codec), : format_(format),
callback_(NULL), callback_(NULL),
j_media_codec_video_encoder_( j_media_codec_video_encoder_(
jni, jni,
@ -348,7 +352,7 @@ int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings,
profile_ = H264::Profile::kProfileBaseline; profile_ = H264::Profile::kProfileBaseline;
if (codec_type == kVideoCodecH264) { if (codec_type == kVideoCodecH264) {
const absl::optional<H264::ProfileLevelId> profile_level_id = const absl::optional<H264::ProfileLevelId> profile_level_id =
H264::ParseSdpProfileLevelId(codec_.params); H264::ParseSdpProfileLevelId(format_.parameters);
RTC_DCHECK(profile_level_id); RTC_DCHECK(profile_level_id);
profile_ = profile_level_id->profile; profile_ = profile_level_id->profile;
ALOGD << "H.264 profile: " << profile_; ALOGD << "H.264 profile: " << profile_;
@ -425,12 +429,14 @@ bool MediaCodecVideoEncoder::EncodeTask::Run() {
return false; return false;
} }
bool IsFormatSupported( bool IsFormatSupported(const std::vector<SdpVideoFormat>& supported_formats,
const std::vector<webrtc::SdpVideoFormat>& supported_formats, const SdpVideoFormat& format) {
const std::string& name) { for (const SdpVideoFormat& supported_format : supported_formats) {
for (const webrtc::SdpVideoFormat& supported_format : supported_formats) { if (cricket::IsSameCodec(format.name, format.parameters,
if (cricket::CodecNamesEq(name, supported_format.name)) supported_format.name,
supported_format.parameters)) {
return true; return true;
}
} }
return false; return false;
} }
@ -439,7 +445,7 @@ bool MediaCodecVideoEncoder::ProcessHWError(
bool reset_if_fallback_unavailable) { bool reset_if_fallback_unavailable) {
ALOGE << "ProcessHWError"; ALOGE << "ProcessHWError";
if (IsFormatSupported(InternalEncoderFactory().GetSupportedFormats(), if (IsFormatSupported(InternalEncoderFactory().GetSupportedFormats(),
codec_.name)) { format_)) {
ALOGE << "Fallback to SW encoder."; ALOGE << "Fallback to SW encoder.";
sw_fallback_required_ = true; sw_fallback_required_ = true;
return false; return false;
@ -457,7 +463,7 @@ int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncode() {
} }
VideoCodecType MediaCodecVideoEncoder::GetCodecType() const { VideoCodecType MediaCodecVideoEncoder::GetCodecType() const {
return PayloadStringToCodecType(codec_.name); return PayloadStringToCodecType(format_.name);
} }
int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width, int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
@ -1210,20 +1216,20 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
: egl_context_(nullptr) { : egl_context_(nullptr) {
JNIEnv* jni = AttachCurrentThreadIfNeeded(); JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni); ScopedLocalRefFrame local_ref_frame(jni);
supported_codecs_.clear(); supported_formats_.clear();
bool is_vp8_hw_supported = Java_MediaCodecVideoEncoder_isVp8HwSupported(jni); bool is_vp8_hw_supported = Java_MediaCodecVideoEncoder_isVp8HwSupported(jni);
if (is_vp8_hw_supported) { if (is_vp8_hw_supported) {
ALOGD << "VP8 HW Encoder 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); bool is_vp9_hw_supported = Java_MediaCodecVideoEncoder_isVp9HwSupported(jni);
if (is_vp9_hw_supported) { if (is_vp9_hw_supported) {
ALOGD << "VP9 HW Encoder 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 // Check if high profile is supported by decoder. If yes, encoder can always
// fall back to baseline profile as a subset as high profile. // 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."; ALOGD << "H.264 High Profile HW Encoder supported.";
// TODO(magjed): Enumerate actual level instead of using hardcoded level // TODO(magjed): Enumerate actual level instead of using hardcoded level
// 3.1. Level 3.1 is 1280x720@30fps which is enough for now. // 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( const H264::ProfileLevelId constrained_high_profile(
H264::kProfileConstrainedHigh, H264::kLevel3_1); H264::kProfileConstrainedHigh, H264::kLevel3_1);
constrained_high.SetParam( constrained_high.parameters[cricket::kH264FmtpProfileLevelId] =
cricket::kH264FmtpProfileLevelId, *H264::ProfileLevelIdToString(constrained_high_profile);
*H264::ProfileLevelIdToString(constrained_high_profile)); constrained_high.parameters[cricket::kH264FmtpLevelAsymmetryAllowed] = "1";
constrained_high.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1"); constrained_high.parameters[cricket::kH264FmtpPacketizationMode] = "1";
constrained_high.SetParam(cricket::kH264FmtpPacketizationMode, "1"); supported_formats_with_h264_hp_.push_back(constrained_high);
supported_codecs_with_h264_hp_.push_back(constrained_high);
} }
bool is_h264_hw_supported = bool is_h264_hw_supported =
@ -1252,16 +1257,16 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
// ready, http://crbug/webrtc/6337. We can negotiate Constrained High // ready, http://crbug/webrtc/6337. We can negotiate Constrained High
// profile as long as we have decode support for it and still send Baseline // profile as long as we have decode support for it and still send Baseline
// since Baseline is a subset of the High profile. // 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( const H264::ProfileLevelId constrained_baseline_profile(
H264::kProfileConstrainedBaseline, H264::kLevel3_1); H264::kProfileConstrainedBaseline, H264::kLevel3_1);
constrained_baseline.SetParam( constrained_baseline.parameters[cricket::kH264FmtpProfileLevelId] =
cricket::kH264FmtpProfileLevelId, *H264::ProfileLevelIdToString(constrained_baseline_profile);
*H264::ProfileLevelIdToString(constrained_baseline_profile)); constrained_baseline.parameters[cricket::kH264FmtpLevelAsymmetryAllowed] =
constrained_baseline.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1"); "1";
constrained_baseline.SetParam(cricket::kH264FmtpPacketizationMode, "1"); constrained_baseline.parameters[cricket::kH264FmtpPacketizationMode] = "1";
supported_codecs_.push_back(constrained_baseline); supported_formats_.push_back(constrained_baseline);
supported_codecs_with_h264_hp_.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( std::unique_ptr<VideoEncoder> MediaCodecVideoEncoderFactory::CreateVideoEncoder(
const cricket::VideoCodec& codec) { const SdpVideoFormat& format) {
if (supported_codecs().empty()) { if (GetSupportedFormats().empty()) {
ALOGW << "No HW video encoder for codec " << codec.name; ALOGW << "No HW video encoder for codec " << format.name;
return nullptr; return nullptr;
} }
if (FindMatchingCodec(supported_codecs(), codec)) { if (IsFormatSupported(GetSupportedFormats(), format)) {
ALOGD << "Create HW video encoder for " << codec.name; ALOGD << "Create HW video encoder for " << format.name;
JNIEnv* jni = AttachCurrentThreadIfNeeded(); JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni); 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; return nullptr;
} }
const std::vector<cricket::VideoCodec>& std::vector<SdpVideoFormat> MediaCodecVideoEncoderFactory::GetSupportedFormats()
MediaCodecVideoEncoderFactory::supported_codecs() const { const {
return supported_codecs_with_h264_hp_; return supported_formats_with_h264_hp_;
} }
void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(VideoEncoder* encoder) { VideoEncoderFactory::CodecInfo MediaCodecVideoEncoderFactory::QueryVideoEncoder(
ALOGD << "Destroy video encoder."; const SdpVideoFormat& format) const {
delete encoder; 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( static void JNI_MediaCodecVideoEncoder_FillInputBuffer(

18
sdk/android/src/jni/androidmediaencoder_jni.h
View file

@ -13,32 +13,32 @@
#include <vector> #include <vector>
#include "media/engine/webrtcvideoencoderfactory.h" #include "api/video_codecs/video_encoder_factory.h"
#include "sdk/android/src/jni/jni_helpers.h" #include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc { namespace webrtc {
namespace jni { namespace jni {
// Implementation of Android MediaCodec based encoder factory. // Implementation of Android MediaCodec based encoder factory.
class MediaCodecVideoEncoderFactory class MediaCodecVideoEncoderFactory : public VideoEncoderFactory {
: public cricket::WebRtcVideoEncoderFactory {
public: public:
MediaCodecVideoEncoderFactory(); MediaCodecVideoEncoderFactory();
~MediaCodecVideoEncoderFactory() override; ~MediaCodecVideoEncoderFactory() override;
void SetEGLContext(JNIEnv* jni, jobject egl_context); void SetEGLContext(JNIEnv* jni, jobject egl_context);
// WebRtcVideoEncoderFactory implementation. // VideoEncoderFactory implementation.
VideoEncoder* CreateVideoEncoder(const cricket::VideoCodec& codec) override; std::vector<SdpVideoFormat> GetSupportedFormats() const override;
const std::vector<cricket::VideoCodec>& supported_codecs() const override; CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override;
void DestroyVideoEncoder(VideoEncoder* encoder) override; std::unique_ptr<VideoEncoder> CreateVideoEncoder(
const SdpVideoFormat& format) override;
private: private:
jobject egl_context_; jobject egl_context_;
// Empty if platform support is lacking, const after ctor returns. // Empty if platform support is lacking, const after ctor returns.
std::vector<cricket::VideoCodec> supported_codecs_; std::vector<SdpVideoFormat> supported_formats_;
std::vector<cricket::VideoCodec> supported_codecs_with_h264_hp_; std::vector<SdpVideoFormat> supported_formats_with_h264_hp_;
}; };
} // namespace jni } // namespace jni

15
sdk/android/src/jni/pc/media.cc
View file

@ -30,21 +30,6 @@ RtcEventLogFactoryInterface* CreateRtcEventLogFactory() {
return webrtc::CreateRtcEventLogFactory().release(); 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( cricket::MediaEngineInterface* CreateMediaEngine(
rtc::scoped_refptr<AudioDeviceModule> adm, rtc::scoped_refptr<AudioDeviceModule> adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,

11
sdk/android/src/jni/pc/media.h
View file

@ -29,8 +29,6 @@ class VideoDecoderFactory;
namespace cricket { namespace cricket {
class MediaEngineInterface; class MediaEngineInterface;
class WebRtcVideoEncoderFactory;
class WebRtcVideoDecoderFactory;
} // namespace cricket } // namespace cricket
namespace webrtc { namespace webrtc {
@ -39,15 +37,6 @@ namespace jni {
CallFactoryInterface* CreateCallFactory(); CallFactoryInterface* CreateCallFactory();
RtcEventLogFactoryInterface* CreateRtcEventLogFactory(); 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( cricket::MediaEngineInterface* CreateMediaEngine(
rtc::scoped_refptr<AudioDeviceModule> adm, rtc::scoped_refptr<AudioDeviceModule> adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,

11
sdk/android/src/jni/pc/null_media.cc
View file

@ -21,17 +21,6 @@ RtcEventLogFactoryInterface* CreateRtcEventLogFactory() {
return nullptr; return nullptr;
} }
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( cricket::MediaEngineInterface* CreateMediaEngine(
rtc::scoped_refptr<AudioDeviceModule> adm, rtc::scoped_refptr<AudioDeviceModule> adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,

26
sdk/android/src/jni/pc/null_video.cc
View file

@ -10,6 +10,9 @@
#include "sdk/android/src/jni/pc/video.h" #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 webrtc {
namespace jni { namespace jni {
@ -26,10 +29,10 @@ VideoDecoderFactory* CreateVideoDecoderFactory(
} }
void SetEglContext(JNIEnv* env, void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoEncoderFactory* encoder_factory, VideoEncoderFactory* encoder_factory,
const JavaRef<jobject>& egl_context) {} const JavaRef<jobject>& egl_context) {}
void SetEglContext(JNIEnv* env, void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoDecoderFactory* decoder_factory, VideoDecoderFactory* decoder_factory,
const JavaRef<jobject>& egl_context) {} const JavaRef<jobject>& egl_context) {}
void* CreateVideoSource(JNIEnv* env, void* CreateVideoSource(JNIEnv* env,
@ -39,28 +42,21 @@ void* CreateVideoSource(JNIEnv* env,
return nullptr; return nullptr;
} }
void SetEglContext(JNIEnv* env, std::unique_ptr<VideoEncoderFactory> CreateLegacyVideoEncoderFactory() {
cricket::WebRtcVideoEncoderFactory* encoder_factory,
jobject egl_context) {}
void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoDecoderFactory* decoder_factory,
jobject egl_context) {}
cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory() {
return nullptr; return nullptr;
} }
cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory() { std::unique_ptr<VideoDecoderFactory> CreateLegacyVideoDecoderFactory() {
return nullptr; return nullptr;
} }
VideoEncoderFactory* WrapLegacyVideoEncoderFactory( std::unique_ptr<VideoEncoderFactory> WrapLegacyVideoEncoderFactory(
cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory) { std::unique_ptr<VideoEncoderFactory> legacy_encoder_factory) {
return nullptr; return nullptr;
} }
VideoDecoderFactory* WrapLegacyVideoDecoderFactory( std::unique_ptr<VideoDecoderFactory> WrapLegacyVideoDecoderFactory(
cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory) { std::unique_ptr<VideoDecoderFactory> legacy_decoder_factory) {
return nullptr; return nullptr;
} }

14
sdk/android/src/jni/pc/ownedfactoryandthreads.h
View file

@ -18,8 +18,6 @@
#include "api/peerconnectioninterface.h" #include "api/peerconnectioninterface.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
using cricket::WebRtcVideoDecoderFactory;
using cricket::WebRtcVideoEncoderFactory;
using rtc::Thread; using rtc::Thread;
namespace webrtc { namespace webrtc {
@ -38,8 +36,8 @@ class OwnedFactoryAndThreads {
OwnedFactoryAndThreads(std::unique_ptr<Thread> network_thread, OwnedFactoryAndThreads(std::unique_ptr<Thread> network_thread,
std::unique_ptr<Thread> worker_thread, std::unique_ptr<Thread> worker_thread,
std::unique_ptr<Thread> signaling_thread, std::unique_ptr<Thread> signaling_thread,
WebRtcVideoEncoderFactory* legacy_encoder_factory, VideoEncoderFactory* legacy_encoder_factory,
WebRtcVideoDecoderFactory* legacy_decoder_factory, VideoDecoderFactory* legacy_decoder_factory,
rtc::NetworkMonitorFactory* network_monitor_factory, rtc::NetworkMonitorFactory* network_monitor_factory,
PeerConnectionFactoryInterface* factory) PeerConnectionFactoryInterface* factory)
: network_thread_(std::move(network_thread)), : network_thread_(std::move(network_thread)),
@ -56,10 +54,10 @@ class OwnedFactoryAndThreads {
Thread* network_thread() { return network_thread_.get(); } Thread* network_thread() { return network_thread_.get(); }
Thread* signaling_thread() { return signaling_thread_.get(); } Thread* signaling_thread() { return signaling_thread_.get(); }
Thread* worker_thread() { return worker_thread_.get(); } Thread* worker_thread() { return worker_thread_.get(); }
WebRtcVideoEncoderFactory* legacy_encoder_factory() { VideoEncoderFactory* legacy_encoder_factory() {
return legacy_encoder_factory_; return legacy_encoder_factory_;
} }
WebRtcVideoDecoderFactory* legacy_decoder_factory() { VideoDecoderFactory* legacy_decoder_factory() {
return legacy_decoder_factory_; return legacy_decoder_factory_;
} }
rtc::NetworkMonitorFactory* network_monitor_factory() { rtc::NetworkMonitorFactory* network_monitor_factory() {
@ -72,8 +70,8 @@ class OwnedFactoryAndThreads {
const std::unique_ptr<Thread> network_thread_; const std::unique_ptr<Thread> network_thread_;
const std::unique_ptr<Thread> worker_thread_; const std::unique_ptr<Thread> worker_thread_;
const std::unique_ptr<Thread> signaling_thread_; const std::unique_ptr<Thread> signaling_thread_;
WebRtcVideoEncoderFactory* legacy_encoder_factory_; VideoEncoderFactory* legacy_encoder_factory_;
WebRtcVideoDecoderFactory* legacy_decoder_factory_; VideoDecoderFactory* legacy_decoder_factory_;
rtc::NetworkMonitorFactory* network_monitor_factory_; rtc::NetworkMonitorFactory* network_monitor_factory_;
PeerConnectionFactoryInterface* factory_; // Const after ctor except dtor. PeerConnectionFactoryInterface* factory_; // Const after ctor except dtor.
}; };

79
sdk/android/src/jni/pc/peerconnectionfactory.cc
View file

@ -241,54 +241,43 @@ jlong CreatePeerConnectionFactoryForJava(
std::unique_ptr<RtcEventLogFactoryInterface> rtc_event_log_factory( std::unique_ptr<RtcEventLogFactoryInterface> rtc_event_log_factory(
CreateRtcEventLogFactory()); CreateRtcEventLogFactory());
cricket::WebRtcVideoEncoderFactory* legacy_video_encoder_factory = nullptr; VideoEncoderFactory* legacy_video_encoder_factory = nullptr;
cricket::WebRtcVideoDecoderFactory* legacy_video_decoder_factory = nullptr; VideoDecoderFactory* legacy_video_decoder_factory = nullptr;
std::unique_ptr<cricket::MediaEngineInterface> media_engine; std::unique_ptr<cricket::MediaEngineInterface> media_engine;
if (jencoder_factory.is_null() && jdecoder_factory.is_null()) {
#if defined(USE_BUILTIN_SW_CODECS) std::unique_ptr<VideoEncoderFactory> video_encoder_factory = nullptr;
// This uses the legacy API, which automatically uses the internal SW if (jencoder_factory.is_null()) {
// codecs in WebRTC. // TODO(bugs.webrtc.org/7925): When all clients switched to injectable
if (video_hw_acceleration_enabled) { // factories, remove the legacy codec factories
legacy_video_encoder_factory = CreateLegacyVideoEncoderFactory(); std::unique_ptr<VideoEncoderFactory> legacy_factory =
legacy_video_decoder_factory = CreateLegacyVideoDecoderFactory(); CreateLegacyVideoEncoderFactory();
} legacy_video_encoder_factory = legacy_factory.get();
media_engine.reset(CreateMediaEngine( video_encoder_factory =
audio_device_module, audio_encoder_factory, audio_decoder_factory, WrapLegacyVideoEncoderFactory(std::move(legacy_factory));
legacy_video_encoder_factory, legacy_video_decoder_factory, audio_mixer,
audio_processor));
#endif
} else { } else {
// This uses the new API, does not automatically include software codecs. video_encoder_factory = std::unique_ptr<VideoEncoderFactory>(
std::unique_ptr<VideoEncoderFactory> video_encoder_factory = nullptr; CreateVideoEncoderFactory(jni, jencoder_factory));
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));
} }
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( rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
CreateModularPeerConnectionFactory( CreateModularPeerConnectionFactory(
network_thread.get(), worker_thread.get(), signaling_thread.get(), network_thread.get(), worker_thread.get(), signaling_thread.get(),
@ -484,14 +473,12 @@ static void JNI_PeerConnectionFactory_SetVideoHwAccelerationOptions(
jlong native_factory, jlong native_factory,
const JavaParamRef<jobject>& local_egl_context, const JavaParamRef<jobject>& local_egl_context,
const JavaParamRef<jobject>& remote_egl_context) { const JavaParamRef<jobject>& remote_egl_context) {
#if defined(USE_BUILTIN_SW_CODECS)
OwnedFactoryAndThreads* owned_factory = OwnedFactoryAndThreads* owned_factory =
reinterpret_cast<OwnedFactoryAndThreads*>(native_factory); reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
SetEglContext(jni, owned_factory->legacy_encoder_factory(), SetEglContext(jni, owned_factory->legacy_encoder_factory(),
local_egl_context); local_egl_context);
SetEglContext(jni, owned_factory->legacy_decoder_factory(), SetEglContext(jni, owned_factory->legacy_decoder_factory(),
remote_egl_context); remote_egl_context);
#endif
} }
static jlong JNI_PeerConnectionFactory_GetNativePeerConnectionFactory( static jlong JNI_PeerConnectionFactory_GetNativePeerConnectionFactory(

49
sdk/android/src/jni/pc/video.cc
View file

@ -16,12 +16,9 @@
#include "api/video_codecs/video_decoder_factory.h" #include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h" #include "api/video_codecs/video_encoder_factory.h"
#include "api/videosourceproxy.h" #include "api/videosourceproxy.h"
#if defined(USE_BUILTIN_SW_CODECS) #include "media/engine/convert_legacy_video_factory.h"
#include "media/engine/convert_legacy_video_factory.h" // nogncheck
#endif
#include "media/engine/webrtcvideodecoderfactory.h"
#include "media/engine/webrtcvideoencoderfactory.h"
#include "rtc_base/logging.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/generated_video_jni/jni/EglBase14_jni.h"
#include "sdk/android/src/jni/androidmediadecoder_jni.h" #include "sdk/android/src/jni/androidmediadecoder_jni.h"
#include "sdk/android/src/jni/androidmediaencoder_jni.h" #include "sdk/android/src/jni/androidmediaencoder_jni.h"
@ -45,9 +42,8 @@ VideoDecoderFactory* CreateVideoDecoderFactory(
} }
void SetEglContext(JNIEnv* env, void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoEncoderFactory* encoder_factory, VideoEncoderFactory* encoder_factory,
const JavaRef<jobject>& egl_context) { const JavaRef<jobject>& egl_context) {
#if defined(USE_BUILTIN_SW_CODECS)
if (encoder_factory) { if (encoder_factory) {
MediaCodecVideoEncoderFactory* media_codec_factory = MediaCodecVideoEncoderFactory* media_codec_factory =
static_cast<MediaCodecVideoEncoderFactory*>(encoder_factory); static_cast<MediaCodecVideoEncoderFactory*>(encoder_factory);
@ -56,16 +52,10 @@ void SetEglContext(JNIEnv* env,
media_codec_factory->SetEGLContext(env, egl_context.obj()); 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, void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoDecoderFactory* decoder_factory, VideoDecoderFactory* decoder_factory,
const JavaRef<jobject>& egl_context) { const JavaRef<jobject>& egl_context) {
if (decoder_factory) { if (decoder_factory) {
MediaCodecVideoDecoderFactory* media_codec_factory = MediaCodecVideoDecoderFactory* media_codec_factory =
@ -76,7 +66,6 @@ void SetEglContext(JNIEnv* env,
} }
} }
} }
#endif
void* CreateVideoSource(JNIEnv* env, void* CreateVideoSource(JNIEnv* env,
rtc::Thread* signaling_thread, rtc::Thread* signaling_thread,
@ -89,31 +78,25 @@ void* CreateVideoSource(JNIEnv* env,
.release(); .release();
} }
#if defined(USE_BUILTIN_SW_CODECS) std::unique_ptr<VideoEncoderFactory> CreateLegacyVideoEncoderFactory() {
cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory() { return rtc::MakeUnique<MediaCodecVideoEncoderFactory>();
return new MediaCodecVideoEncoderFactory();
} }
cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory() { std::unique_ptr<VideoDecoderFactory> CreateLegacyVideoDecoderFactory() {
return new MediaCodecVideoDecoderFactory(); return rtc::MakeUnique<MediaCodecVideoDecoderFactory>();
} }
VideoEncoderFactory* WrapLegacyVideoEncoderFactory( std::unique_ptr<VideoEncoderFactory> WrapLegacyVideoEncoderFactory(
cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory) { std::unique_ptr<VideoEncoderFactory> legacy_encoder_factory) {
return ConvertVideoEncoderFactory( return std::unique_ptr<VideoEncoderFactory>(
std::unique_ptr<cricket::WebRtcVideoEncoderFactory>( cricket::ConvertVideoEncoderFactory(std::move(legacy_encoder_factory)));
legacy_encoder_factory))
.release();
} }
VideoDecoderFactory* WrapLegacyVideoDecoderFactory( std::unique_ptr<VideoDecoderFactory> WrapLegacyVideoDecoderFactory(
cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory) { std::unique_ptr<VideoDecoderFactory> legacy_decoder_factory) {
return ConvertVideoDecoderFactory( return std::unique_ptr<VideoDecoderFactory>(
std::unique_ptr<cricket::WebRtcVideoDecoderFactory>( cricket::ConvertVideoDecoderFactory(std::move(legacy_decoder_factory)));
legacy_decoder_factory))
.release();
} }
#endif
} // namespace jni } // namespace jni
} // namespace webrtc } // namespace webrtc

21
sdk/android/src/jni/pc/video.h
View file

@ -17,11 +17,6 @@
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "sdk/android/native_api/jni/scoped_java_ref.h" #include "sdk/android/native_api/jni/scoped_java_ref.h"
namespace cricket {
class WebRtcVideoEncoderFactory;
class WebRtcVideoDecoderFactory;
} // namespace cricket
namespace webrtc { namespace webrtc {
class VideoEncoderFactory; class VideoEncoderFactory;
class VideoDecoderFactory; class VideoDecoderFactory;
@ -39,10 +34,10 @@ VideoDecoderFactory* CreateVideoDecoderFactory(
const JavaRef<jobject>& j_decoder_factory); const JavaRef<jobject>& j_decoder_factory);
void SetEglContext(JNIEnv* env, void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoEncoderFactory* encoder_factory, VideoEncoderFactory* encoder_factory,
const JavaRef<jobject>& egl_context); const JavaRef<jobject>& egl_context);
void SetEglContext(JNIEnv* env, void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoDecoderFactory* decoder_factory, VideoDecoderFactory* decoder_factory,
const JavaRef<jobject>& egl_context); const JavaRef<jobject>& egl_context);
void* CreateVideoSource(JNIEnv* env, void* CreateVideoSource(JNIEnv* env,
@ -50,13 +45,13 @@ void* CreateVideoSource(JNIEnv* env,
rtc::Thread* worker_thread, rtc::Thread* worker_thread,
jboolean is_screencast); jboolean is_screencast);
cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory(); std::unique_ptr<VideoEncoderFactory> CreateLegacyVideoEncoderFactory();
cricket::WebRtcVideoDecoderFactory* CreateLegacyVideoDecoderFactory(); std::unique_ptr<VideoDecoderFactory> CreateLegacyVideoDecoderFactory();
VideoEncoderFactory* WrapLegacyVideoEncoderFactory( std::unique_ptr<VideoEncoderFactory> WrapLegacyVideoEncoderFactory(
cricket::WebRtcVideoEncoderFactory* legacy_encoder_factory); std::unique_ptr<VideoEncoderFactory> legacy_encoder_factory);
VideoDecoderFactory* WrapLegacyVideoDecoderFactory( std::unique_ptr<VideoDecoderFactory> WrapLegacyVideoDecoderFactory(
cricket::WebRtcVideoDecoderFactory* legacy_decoder_factory); std::unique_ptr<VideoDecoderFactory> legacy_decoder_factory);
} // namespace jni } // namespace jni
} // namespace webrtc } // namespace webrtc