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: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",

110
media/engine/convert_legacy_video_factory.cc
View file

@ -101,6 +101,11 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory {
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 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory {
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 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory {
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 @@ std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
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

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<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_

122
sdk/android/BUILD.gn
View file

@ -297,6 +297,7 @@ rtc_static_library("video_jni") {
"src/jni/androidvideotracksource.h",
"src/jni/encodedimage.cc",
"src/jni/encodedimage.h",
"src/jni/hardwarevideoencoderfactory.cc",
"src/jni/jni_generator_helper.h",
"src/jni/nativecapturerobserver.cc",
"src/jni/nativecapturerobserver.h",
@ -317,37 +318,21 @@ rtc_static_library("video_jni") {
"src/jni/videoencoderfallback.cc",
"src/jni/videoencoderwrapper.cc",
"src/jni/videoencoderwrapper.h",
"src/jni/videoframe.cc",
"src/jni/videoframe.h",
"src/jni/videosink.cc",
"src/jni/videosink.h",
"src/jni/videosource.cc",
"src/jni/videotrack.cc",
"src/jni/wrapped_native_i420_buffer.cc",
"src/jni/wrapped_native_i420_buffer.h",
"src/jni/yuvhelper.cc",
]
if (rtc_use_builtin_sw_codecs) {
sources += [
"src/jni/androidmediacodeccommon.h",
"src/jni/androidmediadecoder.cc",
"src/jni/androidmediadecoder_jni.h",
"src/jni/androidmediaencoder.cc",
"src/jni/androidmediaencoder_jni.h",
"src/jni/hardwarevideoencoderfactory.cc",
]
deps += [
":vp8_jni",
":vp9_jni",
"../../media:rtc_internal_video_codecs",
]
}
deps += [
":base_jni",
":generated_video_jni",
":legacy_video_jni", # TODO(bugs.webrtc.org/7925): Remove.
":native_api_jni",
":videoframe_jni",
":vp8_jni", # TODO(bugs.webrtc.org/7925): Remove.
":vp9_jni", # TODO(bugs.webrtc.org/7925): Remove.
"../..:webrtc_common",
"../../api:libjingle_peerconnection_api",
"../../api/video:video_frame",
@ -356,6 +341,7 @@ rtc_static_library("video_jni") {
"../../common_video:common_video",
"../../media:rtc_audio_video",
"../../media:rtc_h264_profile_id",
"../../media:rtc_internal_video_codecs",
"../../media:rtc_media_base",
"../../modules:module_api",
"../../modules/utility:utility",
@ -374,6 +360,61 @@ rtc_static_library("video_jni") {
]
}
rtc_static_library("videoframe_jni") {
sources = [
"src/jni/videoframe.cc",
"src/jni/videoframe.h",
"src/jni/wrapped_native_i420_buffer.cc",
"src/jni/wrapped_native_i420_buffer.h",
]
deps = [
":base_jni",
":generated_video_jni",
":native_api_jni",
"../../api/video:video_frame",
"../../common_video:common_video",
"../../rtc_base:checks",
"../../rtc_base:rtc_base",
"../../rtc_base:rtc_base_approved",
"../../rtc_base/memory:aligned_malloc",
"//third_party/libyuv",
]
}
# TODO(bugs.webrtc.org/7925): Remove.
rtc_static_library("legacy_video_jni") {
sources = [
"src/jni/androidmediacodeccommon.h",
"src/jni/androidmediadecoder.cc",
"src/jni/androidmediadecoder_jni.h",
"src/jni/androidmediaencoder.cc",
"src/jni/androidmediaencoder_jni.h",
]
deps = [
":base_jni",
":generated_video_jni",
":native_api_jni",
":videoframe_jni",
"../..:webrtc_common",
"../../api/video_codecs:video_codecs_api",
"../../common_video:common_video",
"../../media:rtc_internal_video_codecs",
"../../media:rtc_media_base",
"../../modules/video_coding:video_codec_interface",
"../../modules/video_coding:video_coding_utility",
"../../rtc_base:checks",
"../../rtc_base:rtc_base",
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base:weak_ptr",
"../../system_wrappers:field_trial_api",
"//third_party/libyuv",
]
}
rtc_static_library("null_video_jni") {
sources = [
"src/jni/pc/null_video.cc",
@ -381,6 +422,7 @@ rtc_static_library("null_video_jni") {
deps = [
":base_jni",
"../../api/video_codecs:video_codecs_api",
]
}
@ -627,6 +669,9 @@ generate_jni("generated_metrics_jni") {
rtc_static_library("libjingle_peerconnection_metrics_default_jni") {
visibility = [ "*" ]
allow_poison = [ "software_video_codecs" ] # TODO(bugs.webrtc.org/7925): Remove.
sources = [
"src/jni/androidmetrics.cc",
]
@ -698,6 +743,7 @@ dist_jar("libwebrtc") {
":audio_api_java",
":base_java",
":camera_java",
":default_video_codec_factory_java",
":filevideo_java",
":hwcodecs_java",
":java_audio_device_module_java",
@ -707,15 +753,12 @@ dist_jar("libwebrtc") {
":peerconnection_java",
":screencapturer_java",
":surfaceviewrenderer_java",
":swcodecs_java",
":video_api_java",
":video_java",
"../../modules/audio_device:audio_device_java",
"../../rtc_base:base_java",
]
if (rtc_use_builtin_sw_codecs) {
deps += [ ":swcodecs_java" ]
}
}
# TODO(sakal): Extract files from this target to releveant subtargets, video, audio etc.
@ -905,8 +948,7 @@ rtc_android_library("filevideo_java") {
]
}
if (rtc_use_builtin_sw_codecs) {
rtc_android_library("swcodecs_java") {
rtc_android_library("swcodecs_java") {
java_files = [
"api/org/webrtc/SoftwareVideoDecoderFactory.java",
"api/org/webrtc/SoftwareVideoEncoderFactory.java",
@ -922,7 +964,6 @@ if (rtc_use_builtin_sw_codecs) {
":video_java",
"//rtc_base:base_java",
]
}
}
rtc_android_library("hwcodecs_java") {
@ -1021,15 +1062,6 @@ rtc_android_library("libjingle_peerconnection_java") {
"//modules/audio_device:audio_device_java",
"//rtc_base:base_java",
]
if (rtc_use_builtin_sw_codecs) {
deps += [ ":swcodecs_java" ]
java_files += [
"api/org/webrtc/DefaultVideoDecoderFactory.java",
"api/org/webrtc/DefaultVideoEncoderFactory.java",
]
}
}
rtc_android_library("libjingle_peerconnection_metrics_default_java") {
@ -1042,6 +1074,19 @@ rtc_android_library("libjingle_peerconnection_metrics_default_java") {
]
}
rtc_android_library("default_video_codec_factory_java") {
java_files = [
"api/org/webrtc/DefaultVideoDecoderFactory.java",
"api/org/webrtc/DefaultVideoEncoderFactory.java",
]
deps = [
":hwcodecs_java",
":swcodecs_java",
":video_api_java",
]
}
if (rtc_include_tests) {
rtc_instrumentation_test_apk("libjingle_peerconnection_android_unittest") {
apk_name = "libjingle_peerconnection_android_unittest"
@ -1079,6 +1124,7 @@ if (rtc_include_tests) {
deps = [
":base_java",
":default_video_codec_factory_java",
":libjingle_peerconnection_java",
":libjingle_peerconnection_metrics_default_java",
":video_api_java",
@ -1222,6 +1268,9 @@ rtc_static_library("native_api_codecs") {
# API for creating Java PeerConnectionFactory from C++ equivalents.
rtc_static_library("native_api_peerconnection") {
visibility = [ "*" ]
allow_poison = [ "software_video_codecs" ] # TODO(bugs.webrtc.org/7925): Remove.
sources = [
"native_api/peerconnection/peerconnectionfactory.cc",
"native_api/peerconnection/peerconnectionfactory.h",
@ -1258,6 +1307,7 @@ rtc_static_library("native_api_video") {
deps = [
":native_api_jni",
":video_jni",
":videoframe_jni",
"//api:libjingle_peerconnection_api",
"//api/video:video_frame",
"//rtc_base:rtc_base_approved",

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

@ -17,14 +17,17 @@
// androidmediacodeccommon.h to avoid build errors.
#include "sdk/android/src/jni/androidmediadecoder_jni.h"
#include "api/video_codecs/sdp_video_format.h"
#include "common_video/h264/h264_bitstream_parser.h"
#include "common_video/include/i420_buffer_pool.h"
#include "media/base/mediaconstants.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "modules/video_coding/utility/vp8_header_parser.h"
#include "rtc_base/bind.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_conversions.h"
#include "rtc_base/ptr_util.h"
#include "rtc_base/scoped_ref_ptr.h"
#include "rtc_base/thread.h"
#include "rtc_base/timeutils.h"
@ -781,24 +784,24 @@ MediaCodecVideoDecoderFactory::MediaCodecVideoDecoderFactory()
ALOGD << "MediaCodecVideoDecoderFactory ctor";
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
supported_codec_types_.clear();
supported_formats_.clear();
if (Java_MediaCodecVideoDecoder_isVp8HwSupported(jni) &&
!CheckException(jni)) {
ALOGD << "VP8 HW Decoder supported.";
supported_codec_types_.push_back(kVideoCodecVP8);
supported_formats_.push_back(SdpVideoFormat(cricket::kVp8CodecName));
}
if (Java_MediaCodecVideoDecoder_isVp9HwSupported(jni) &&
!CheckException(jni)) {
ALOGD << "VP9 HW Decoder supported.";
supported_codec_types_.push_back(kVideoCodecVP9);
supported_formats_.push_back(SdpVideoFormat(cricket::kVp9CodecName));
}
if (Java_MediaCodecVideoDecoder_isH264HwSupported(jni) &&
!CheckException(jni)) {
ALOGD << "H264 HW Decoder supported.";
supported_codec_types_.push_back(kVideoCodecH264);
supported_formats_.push_back(SdpVideoFormat(cricket::kH264CodecName));
}
}
@ -823,27 +826,28 @@ void MediaCodecVideoDecoderFactory::SetEGLContext(JNIEnv* jni,
}
}
VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
VideoCodecType type) {
if (supported_codec_types_.empty()) {
ALOGW << "No HW video decoder for type " << static_cast<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) {

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

@ -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

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

@ -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 @@ class MediaCodecVideoEncoder : public VideoEncoder {
public:
~MediaCodecVideoEncoder() override;
MediaCodecVideoEncoder(JNIEnv* jni,
const cricket::VideoCodec& codec,
const SdpVideoFormat& format,
jobject egl_context);
// VideoEncoder implementation.
@ -197,7 +201,7 @@ class MediaCodecVideoEncoder : public VideoEncoder {
#endif
// Type of video codec.
const cricket::VideoCodec codec_;
const SdpVideoFormat format_;
EncodedImageCallback* callback_;
@ -297,9 +301,9 @@ MediaCodecVideoEncoder::~MediaCodecVideoEncoder() {
}
MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni,
const cricket::VideoCodec& codec,
const SdpVideoFormat& format,
jobject egl_context)
: codec_(codec),
: format_(format),
callback_(NULL),
j_media_codec_video_encoder_(
jni,
@ -348,7 +352,7 @@ int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings,
profile_ = H264::Profile::kProfileBaseline;
if (codec_type == kVideoCodecH264) {
const absl::optional<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,13 +429,15 @@ bool MediaCodecVideoEncoder::EncodeTask::Run() {
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 MediaCodecVideoEncoder::ProcessHWError(
bool reset_if_fallback_unavailable) {
ALOGE << "ProcessHWError";
if (IsFormatSupported(InternalEncoderFactory().GetSupportedFormats(),
codec_.name)) {
format_)) {
ALOGE << "Fallback to SW encoder.";
sw_fallback_required_ = true;
return false;
@ -457,7 +463,7 @@ int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncode() {
}
VideoCodecType MediaCodecVideoEncoder::GetCodecType() const {
return PayloadStringToCodecType(codec_.name);
return PayloadStringToCodecType(format_.name);
}
int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
@ -1210,20 +1216,20 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
: egl_context_(nullptr) {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
supported_codecs_.clear();
supported_formats_.clear();
bool is_vp8_hw_supported = Java_MediaCodecVideoEncoder_isVp8HwSupported(jni);
if (is_vp8_hw_supported) {
ALOGD << "VP8 HW Encoder supported.";
supported_codecs_.push_back(cricket::VideoCodec(cricket::kVp8CodecName));
supported_formats_.push_back(SdpVideoFormat(cricket::kVp8CodecName));
}
bool is_vp9_hw_supported = Java_MediaCodecVideoEncoder_isVp9HwSupported(jni);
if (is_vp9_hw_supported) {
ALOGD << "VP9 HW Encoder supported.";
supported_codecs_.push_back(cricket::VideoCodec(cricket::kVp9CodecName));
supported_formats_.push_back(SdpVideoFormat(cricket::kVp9CodecName));
}
supported_codecs_with_h264_hp_ = supported_codecs_;
supported_formats_with_h264_hp_ = supported_formats_;
// Check if high profile is supported by decoder. If yes, encoder can always
// fall back to baseline profile as a subset as high profile.
@ -1233,15 +1239,14 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
ALOGD << "H.264 High Profile HW Encoder supported.";
// TODO(magjed): Enumerate actual level instead of using hardcoded level
// 3.1. Level 3.1 is 1280x720@30fps which is enough for now.
cricket::VideoCodec constrained_high(cricket::kH264CodecName);
SdpVideoFormat constrained_high(cricket::kH264CodecName);
const H264::ProfileLevelId constrained_high_profile(
H264::kProfileConstrainedHigh, H264::kLevel3_1);
constrained_high.SetParam(
cricket::kH264FmtpProfileLevelId,
*H264::ProfileLevelIdToString(constrained_high_profile));
constrained_high.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
constrained_high.SetParam(cricket::kH264FmtpPacketizationMode, "1");
supported_codecs_with_h264_hp_.push_back(constrained_high);
constrained_high.parameters[cricket::kH264FmtpProfileLevelId] =
*H264::ProfileLevelIdToString(constrained_high_profile);
constrained_high.parameters[cricket::kH264FmtpLevelAsymmetryAllowed] = "1";
constrained_high.parameters[cricket::kH264FmtpPacketizationMode] = "1";
supported_formats_with_h264_hp_.push_back(constrained_high);
}
bool is_h264_hw_supported =
@ -1252,16 +1257,16 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
// ready, http://crbug/webrtc/6337. We can negotiate Constrained High
// profile as long as we have decode support for it and still send Baseline
// since Baseline is a subset of the High profile.
cricket::VideoCodec constrained_baseline(cricket::kH264CodecName);
SdpVideoFormat constrained_baseline(cricket::kH264CodecName);
const H264::ProfileLevelId constrained_baseline_profile(
H264::kProfileConstrainedBaseline, H264::kLevel3_1);
constrained_baseline.SetParam(
cricket::kH264FmtpProfileLevelId,
*H264::ProfileLevelIdToString(constrained_baseline_profile));
constrained_baseline.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
constrained_baseline.SetParam(cricket::kH264FmtpPacketizationMode, "1");
supported_codecs_.push_back(constrained_baseline);
supported_codecs_with_h264_hp_.push_back(constrained_baseline);
constrained_baseline.parameters[cricket::kH264FmtpProfileLevelId] =
*H264::ProfileLevelIdToString(constrained_baseline_profile);
constrained_baseline.parameters[cricket::kH264FmtpLevelAsymmetryAllowed] =
"1";
constrained_baseline.parameters[cricket::kH264FmtpPacketizationMode] = "1";
supported_formats_.push_back(constrained_baseline);
supported_formats_with_h264_hp_.push_back(constrained_baseline);
}
}
@ -1286,30 +1291,34 @@ void MediaCodecVideoEncoderFactory::SetEGLContext(JNIEnv* jni,
}
}
VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
const cricket::VideoCodec& codec) {
if (supported_codecs().empty()) {
ALOGW << "No HW video encoder for codec " << codec.name;
std::unique_ptr<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(

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

@ -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

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

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

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

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

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

@ -21,17 +21,6 @@ RtcEventLogFactoryInterface* CreateRtcEventLogFactory() {
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(
rtc::scoped_refptr<AudioDeviceModule> adm,
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 "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
namespace webrtc {
namespace jni {
@ -26,10 +29,10 @@ VideoDecoderFactory* CreateVideoDecoderFactory(
}
void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoEncoderFactory* encoder_factory,
VideoEncoderFactory* encoder_factory,
const JavaRef<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 @@ void* CreateVideoSource(JNIEnv* env,
return nullptr;
}
void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoEncoderFactory* encoder_factory,
jobject egl_context) {}
void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoDecoderFactory* decoder_factory,
jobject egl_context) {}
cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory() {
std::unique_ptr<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;
}

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

@ -18,8 +18,6 @@
#include "api/peerconnectioninterface.h"
#include "rtc_base/thread.h"
using cricket::WebRtcVideoDecoderFactory;
using cricket::WebRtcVideoEncoderFactory;
using rtc::Thread;
namespace webrtc {
@ -38,8 +36,8 @@ class OwnedFactoryAndThreads {
OwnedFactoryAndThreads(std::unique_ptr<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 @@ class OwnedFactoryAndThreads {
Thread* network_thread() { return network_thread_.get(); }
Thread* signaling_thread() { return signaling_thread_.get(); }
Thread* worker_thread() { return worker_thread_.get(); }
WebRtcVideoEncoderFactory* legacy_encoder_factory() {
VideoEncoderFactory* legacy_encoder_factory() {
return legacy_encoder_factory_;
}
WebRtcVideoDecoderFactory* legacy_decoder_factory() {
VideoDecoderFactory* legacy_decoder_factory() {
return legacy_decoder_factory_;
}
rtc::NetworkMonitorFactory* network_monitor_factory() {
@ -72,8 +70,8 @@ class OwnedFactoryAndThreads {
const std::unique_ptr<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.
};

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

@ -241,31 +241,19 @@ jlong CreatePeerConnectionFactoryForJava(
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
} 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
// 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 {
video_encoder_factory = std::unique_ptr<VideoEncoderFactory>(
CreateVideoEncoderFactory(jni, jencoder_factory));
@ -273,11 +261,13 @@ jlong CreatePeerConnectionFactoryForJava(
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
// 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));
@ -287,7 +277,6 @@ jlong CreatePeerConnectionFactoryForJava(
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(
@ -484,14 +473,12 @@ static void JNI_PeerConnectionFactory_SetVideoHwAccelerationOptions(
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(

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_encoder_factory.h"
#include "api/videosourceproxy.h"
#if defined(USE_BUILTIN_SW_CODECS)
#include "media/engine/convert_legacy_video_factory.h" // nogncheck
#endif
#include "media/engine/webrtcvideodecoderfactory.h"
#include "media/engine/webrtcvideoencoderfactory.h"
#include "media/engine/convert_legacy_video_factory.h"
#include "rtc_base/logging.h"
#include "rtc_base/ptr_util.h"
#include "sdk/android/generated_video_jni/jni/EglBase14_jni.h"
#include "sdk/android/src/jni/androidmediadecoder_jni.h"
#include "sdk/android/src/jni/androidmediaencoder_jni.h"
@ -45,9 +42,8 @@ VideoDecoderFactory* CreateVideoDecoderFactory(
}
void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoEncoderFactory* encoder_factory,
VideoEncoderFactory* encoder_factory,
const JavaRef<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 @@ void SetEglContext(JNIEnv* env,
media_codec_factory->SetEGLContext(env, egl_context.obj());
}
}
#else
if (Java_Context_isEgl14Context(env, egl_context)) {
RTC_LOG(LS_INFO) << "Set EGL context for HW encoding.";
}
#endif
}
#if defined(USE_BUILTIN_SW_CODECS)
void SetEglContext(JNIEnv* env,
cricket::WebRtcVideoDecoderFactory* decoder_factory,
VideoDecoderFactory* decoder_factory,
const JavaRef<jobject>& egl_context) {
if (decoder_factory) {
MediaCodecVideoDecoderFactory* media_codec_factory =
@ -76,7 +66,6 @@ void SetEglContext(JNIEnv* env,
}
}
}
#endif
void* CreateVideoSource(JNIEnv* env,
rtc::Thread* signaling_thread,
@ -89,31 +78,25 @@ void* CreateVideoSource(JNIEnv* env,
.release();
}
#if defined(USE_BUILTIN_SW_CODECS)
cricket::WebRtcVideoEncoderFactory* CreateLegacyVideoEncoderFactory() {
return new MediaCodecVideoEncoderFactory();
std::unique_ptr<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

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

@ -17,11 +17,6 @@
#include "rtc_base/thread.h"
#include "sdk/android/native_api/jni/scoped_java_ref.h"
namespace cricket {
class WebRtcVideoEncoderFactory;
class WebRtcVideoDecoderFactory;
} // namespace cricket
namespace webrtc {
class VideoEncoderFactory;
class VideoDecoderFactory;
@ -39,10 +34,10 @@ VideoDecoderFactory* CreateVideoDecoderFactory(
const JavaRef<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 @@ void* CreateVideoSource(JNIEnv* env,
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