zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update videoprocessor tool to use new video factory interface

Browse Source 
This will also cause us to use the new Android HardwareVideoEncoder,
instead of the deprecated MediaCodecVideoEncoderFactory. Unfortunately,
the new HW encoder does not seem to work as good as the old (or the new
encoder is more strict with return values or something). I don't think
it adds much value to continue testing the deprecated encoder, so I
filed a bug for fixing the new encoder, and in this CL I disabled the
tests on Android. I want to remove as many places as possible where we
use the old WebRtcVideoEncoderFactory interface, because it makes it
more difficult to migrate to the new interface.

Bug: webrtc:7925
Change-Id: If8e34752148a5e5139944d2dfbe7e231fe58aeb9
Reviewed-on: https://webrtc-review.googlesource.com/27540
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21037}
This commit is contained in:
Magnus Jedvert
2017-12-04 14:09:40 +01:00
committed by Commit Bot
parent 86de7e898a
commit e4a9e923e4
5 changed files with 73 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
modules/video_coding/codecs/test/objc_codec_h264_test.h
View File

@ -13,13 +13,13 @@
#include <memory>
#include "media/engine/webrtcvideodecoderfactory.h"
#include "media/engine/webrtcvideoencoderfactory.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
namespace webrtc {
std::unique_ptr<cricket::WebRtcVideoEncoderFactory> CreateObjCEncoderFactory();
std::unique_ptr<cricket::WebRtcVideoDecoderFactory> CreateObjCDecoderFactory();
std::unique_ptr<VideoEncoderFactory> CreateObjCEncoderFactory();
std::unique_ptr<VideoDecoderFactory> CreateObjCDecoderFactory();
} // namespace webrtc

11
modules/video_coding/codecs/test/objc_codec_h264_test.mm
View File

@ -11,19 +11,18 @@
#include "modules/video_coding/codecs/test/objc_codec_h264_test.h"
#import "WebRTC/RTCVideoCodecH264.h"
#include "rtc_base/ptr_util.h"
#include "sdk/objc/Framework/Classes/VideoToolbox/objc_video_decoder_factory.h"
#include "sdk/objc/Framework/Classes/VideoToolbox/objc_video_encoder_factory.h"
namespace webrtc {
std::unique_ptr<cricket::WebRtcVideoEncoderFactory> CreateObjCEncoderFactory() {
return std::unique_ptr<cricket::WebRtcVideoEncoderFactory>(
new ObjCVideoEncoderFactory([[RTCVideoEncoderFactoryH264 alloc] init]));
std::unique_ptr<VideoEncoderFactory> CreateObjCEncoderFactory() {
return rtc::MakeUnique<ObjCVideoEncoderFactory>([[RTCVideoEncoderFactoryH264 alloc] init]);
}
std::unique_ptr<cricket::WebRtcVideoDecoderFactory> CreateObjCDecoderFactory() {
return std::unique_ptr<cricket::WebRtcVideoDecoderFactory>(
new ObjCVideoDecoderFactory([[RTCVideoDecoderFactoryH264 alloc] init]));
std::unique_ptr<VideoDecoderFactory> CreateObjCDecoderFactory() {
return rtc::MakeUnique<ObjCVideoDecoderFactory>([[RTCVideoDecoderFactoryH264 alloc] init]);
}
} // namespace webrtc

166
modules/video_coding/codecs/test/videoprocessor_integrationtest.cc
View File

@ -15,8 +15,9 @@
#if defined(WEBRTC_ANDROID)
#include "modules/video_coding/codecs/test/android_test_initializer.h"
#include "sdk/android/src/jni/androidmediadecoder_jni.h"
#include "sdk/android/src/jni/androidmediaencoder_jni.h"
#include "sdk/android/src/jni/class_loader.h"
#include "sdk/android/src/jni/videodecoderfactorywrapper.h"
#include "sdk/android/src/jni/videoencoderfactorywrapper.h"
#elif defined(WEBRTC_IOS)
#include "modules/video_coding/codecs/test/objc_codec_h264_test.h"
#endif
@ -63,56 +64,32 @@ bool RunEncodeInRealTime(const TestConfig& config) {
#endif
}
// An internal encoder factory in the old WebRtcVideoEncoderFactory format.
// TODO(magjed): Update these tests to use new webrtc::VideoEncoderFactory
// instead.
class LegacyInternalEncoderFactory : public cricket::WebRtcVideoEncoderFactory {
public:
LegacyInternalEncoderFactory() {
for (const SdpVideoFormat& format :
InternalEncoderFactory().GetSupportedFormats()) {
supported_codecs_.push_back(cricket::VideoCodec(format));
SdpVideoFormat CreateSdpVideoFormat(const TestConfig& config) {
switch (config.codec_settings.codecType) {
case kVideoCodecVP8:
return SdpVideoFormat(cricket::kVp8CodecName);
case kVideoCodecVP9:
return SdpVideoFormat(cricket::kVp9CodecName);
case kVideoCodecH264: {
const char* packetization_mode =
config.h264_codec_settings.packetization_mode ==
H264PacketizationMode::NonInterleaved
? "1"
: "0";
return SdpVideoFormat(
cricket::kH264CodecName,
{{cricket::kH264FmtpProfileLevelId,
*H264::ProfileLevelIdToString(H264::ProfileLevelId(
config.h264_codec_settings.profile, H264::kLevel3_1))},
{cricket::kH264FmtpPacketizationMode, packetization_mode}});
}
default:
RTC_NOTREACHED();
return SdpVideoFormat("");
}
// WebRtcVideoEncoderFactory implementation.
VideoEncoder* CreateVideoEncoder(const cricket::VideoCodec& codec) override {
return InternalEncoderFactory()
.CreateVideoEncoder(SdpVideoFormat(codec.name, codec.params))
.release();
}
const std::vector<cricket::VideoCodec>& supported_codecs() const override {
return supported_codecs_;
}
bool EncoderTypeHasInternalSource(
webrtc::VideoCodecType type) const override {
return false;
}
void DestroyVideoEncoder(VideoEncoder* encoder) override { delete encoder; }
private:
std::vector<cricket::VideoCodec> supported_codecs_;
};
// An internal decoder factory in the old WebRtcVideoDecoderFactory format.
// TODO(magjed): Update these tests to use new webrtc::VideoDecoderFactory
// instead.
class LegacyInternalDecoderFactory : public cricket::WebRtcVideoDecoderFactory {
public:
// WebRtcVideoDecoderFactory implementation.
VideoDecoder* CreateVideoDecoderWithParams(
const cricket::VideoCodec& codec,
cricket::VideoDecoderParams params) override {
return InternalDecoderFactory()
.CreateVideoDecoder(SdpVideoFormat(codec.name, codec.params))
.release();
}
void DestroyVideoDecoder(VideoDecoder* decoder) override { delete decoder; }
};
}
} // namespace
@ -309,10 +286,21 @@ void VideoProcessorIntegrationTest::ProcessFramesAndMaybeVerify(
}
void VideoProcessorIntegrationTest::CreateEncoderAndDecoder() {
std::unique_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
std::unique_ptr<VideoEncoderFactory> encoder_factory;
if (config_.hw_encoder) {
#if defined(WEBRTC_ANDROID)
encoder_factory.reset(new jni::MediaCodecVideoEncoderFactory());
JNIEnv* env = jni::AttachCurrentThreadIfNeeded();
jni::ScopedLocalRefFrame local_ref_frame(env);
jclass factory_class =
webrtc::jni::GetClass(env, "org/webrtc/HardwareVideoEncoderFactory");
jmethodID factory_constructor = env->GetMethodID(
factory_class, "<init>", "(Lorg/webrtc/EglBase$Context;ZZ)V");
jobject factory_object = env->NewObject(
factory_class, factory_constructor, nullptr /* shared_context */,
false /* enable_intel_vp8_encoder */,
true /* enable_h264_high_profile */);
encoder_factory = rtc::MakeUnique<webrtc::jni::VideoEncoderFactoryWrapper>(
env, factory_object);
#elif defined(WEBRTC_IOS)
EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
<< "iOS HW codecs only support H264.";
@ -321,13 +309,22 @@ void VideoProcessorIntegrationTest::CreateEncoderAndDecoder() {
RTC_NOTREACHED() << "Only support HW encoder on Android and iOS.";
#endif
} else {
encoder_factory.reset(new LegacyInternalEncoderFactory());
encoder_factory = rtc::MakeUnique<InternalEncoderFactory>();
}
std::unique_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory;
std::unique_ptr<VideoDecoderFactory> decoder_factory;
if (config_.hw_decoder) {
#if defined(WEBRTC_ANDROID)
decoder_factory.reset(new jni::MediaCodecVideoDecoderFactory());
JNIEnv* env = jni::AttachCurrentThreadIfNeeded();
jni::ScopedLocalRefFrame local_ref_frame(env);
jclass factory_class =
webrtc::jni::GetClass(env, "org/webrtc/HardwareVideoDecoderFactory");
jmethodID factory_constructor = env->GetMethodID(
factory_class, "<init>", "(Lorg/webrtc/EglBase$Context;)V");
jobject factory_object = env->NewObject(factory_class, factory_constructor,
nullptr /* shared_context */);
decoder_factory = rtc::MakeUnique<webrtc::jni::VideoDecoderFactoryWrapper>(
env, factory_object);
#elif defined(WEBRTC_IOS)
EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
<< "iOS HW codecs only support H264.";
@ -336,68 +333,21 @@ void VideoProcessorIntegrationTest::CreateEncoderAndDecoder() {
RTC_NOTREACHED() << "Only support HW decoder on Android and iOS.";
#endif
} else {
decoder_factory.reset(new LegacyInternalDecoderFactory());
decoder_factory = rtc::MakeUnique<InternalDecoderFactory>();
}
cricket::VideoCodec codec;
cricket::VideoDecoderParams decoder_params; // Empty.
switch (config_.codec_settings.codecType) {
case kVideoCodecVP8:
codec = cricket::VideoCodec(cricket::kVp8CodecName);
encoder_.reset(encoder_factory->CreateVideoEncoder(codec));
decoder_.reset(
decoder_factory->CreateVideoDecoderWithParams(codec, decoder_params));
break;
case kVideoCodecVP9:
codec = cricket::VideoCodec(cricket::kVp9CodecName);
encoder_.reset(encoder_factory->CreateVideoEncoder(codec));
decoder_.reset(
decoder_factory->CreateVideoDecoderWithParams(codec, decoder_params));
break;
case kVideoCodecH264:
codec = cricket::VideoCodec(cricket::kH264CodecName);
if (config_.h264_codec_settings.profile ==
H264::kProfileConstrainedHigh) {
const H264::ProfileLevelId constrained_high_profile(
H264::kProfileConstrainedHigh, H264::kLevel3_1);
codec.SetParam(cricket::kH264FmtpProfileLevelId,
*H264::ProfileLevelIdToString(constrained_high_profile));
} else {
RTC_CHECK_EQ(config_.h264_codec_settings.profile,
H264::kProfileConstrainedBaseline);
const H264::ProfileLevelId constrained_baseline_profile(
H264::kProfileConstrainedBaseline, H264::kLevel3_1);
codec.SetParam(
cricket::kH264FmtpProfileLevelId,
*H264::ProfileLevelIdToString(constrained_baseline_profile));
}
if (config_.h264_codec_settings.packetization_mode ==
H264PacketizationMode::NonInterleaved) {
codec.SetParam(cricket::kH264FmtpPacketizationMode, "1");
} else {
RTC_CHECK_EQ(config_.h264_codec_settings.packetization_mode,
H264PacketizationMode::SingleNalUnit);
codec.SetParam(cricket::kH264FmtpPacketizationMode, "0");
}
encoder_.reset(encoder_factory->CreateVideoEncoder(codec));
decoder_.reset(
decoder_factory->CreateVideoDecoderWithParams(codec, decoder_params));
break;
default:
RTC_NOTREACHED();
break;
}
const SdpVideoFormat format = CreateSdpVideoFormat(config_);
encoder_ = encoder_factory->CreateVideoEncoder(format);
decoder_ = decoder_factory->CreateVideoDecoder(format);
if (config_.sw_fallback_encoder) {
encoder_ = rtc::MakeUnique<VideoEncoderSoftwareFallbackWrapper>(
InternalEncoderFactory().CreateVideoEncoder(
SdpVideoFormat(codec.name, codec.params)),
InternalEncoderFactory().CreateVideoEncoder(format),
std::move(encoder_));
}
if (config_.sw_fallback_decoder) {
decoder_ = rtc::MakeUnique<VideoDecoderSoftwareFallbackWrapper>(
InternalDecoderFactory().CreateVideoDecoder(
SdpVideoFormat(codec.name, codec.params)),
InternalDecoderFactory().CreateVideoDecoder(format),
std::move(decoder_));
}

7
modules/video_coding/codecs/test/videoprocessor_integrationtest_mediacodec.cc
View File

@ -40,7 +40,8 @@ class VideoProcessorIntegrationTestMediaCodec
}
};
TEST_F(VideoProcessorIntegrationTestMediaCodec, ForemanCif500kbpsVp8) {
// TODO(bugs.webrtc.org/8601): Fix HW encoder and re-enable.
TEST_F(VideoProcessorIntegrationTestMediaCodec, DISABLED_ForemanCif500kbpsVp8) {
config_.SetCodecSettings(kVideoCodecVP8, 1, false, false, false, false, false,
352, 288);
@ -59,7 +60,9 @@ TEST_F(VideoProcessorIntegrationTestMediaCodec, ForemanCif500kbpsVp8) {
kNoVisualizationParams);
}
TEST_F(VideoProcessorIntegrationTestMediaCodec, ForemanCif500kbpsH264CBP) {
// TODO(bugs.webrtc.org/8601): Fix HW encoder and re-enable.
TEST_F(VideoProcessorIntegrationTestMediaCodec,
DISABLED_ForemanCif500kbpsH264CBP) {
config_.encoded_frame_checker = &h264_keyframe_checker_;
config_.SetCodecSettings(kVideoCodecH264, 1, false, false, false, false,
false, 352, 288);