From dd3e0ab2bf507ee3088e795d8b6b20c1757feb8f Mon Sep 17 00:00:00 2001 From: Anders Carlsson Date: Tue, 12 Jun 2018 11:15:56 +0200 Subject: [PATCH] Make rtc_software_fallback_wrappers target visible. Need to depend on them from Chromium. Bug: webrtc:7925 Change-Id: Iea1bb3b937c602920bfd87f885c87c790ac7bc17 Reviewed-on: https://webrtc-review.googlesource.com/82061 Reviewed-by: Magnus Jedvert Reviewed-by: Karl Wiberg Commit-Queue: Anders Carlsson Cr-Commit-Position: refs/heads/master@{#23580} --- BUILD.gn | 2 +- api/DEPS | 1 + api/video_codecs/BUILD.gn | 28 +++++ api/video_codecs/test/BUILD.gn | 12 +- ...oder_software_fallback_wrapper_unittest.cc | 75 ++++++------- ...oder_software_fallback_wrapper_unittest.cc | 75 +++++++------ ...video_decoder_software_fallback_wrapper.cc | 61 ++++++++++- .../video_decoder_software_fallback_wrapper.h | 29 +++++ ...video_encoder_software_fallback_wrapper.cc | 93 +++++++++++++++- .../video_encoder_software_fallback_wrapper.h | 29 +++++ media/BUILD.gn | 33 +----- media/engine/convert_legacy_video_factory.cc | 11 +- .../videodecodersoftwarefallbackwrapper.h | 70 ------------ .../videoencodersoftwarefallbackwrapper.h | 103 ------------------ modules/video_coding/BUILD.gn | 2 +- sdk/android/BUILD.gn | 2 +- sdk/android/src/jni/videodecoderfallback.cc | 9 +- sdk/android/src/jni/videoencoderfallback.cc | 9 +- 18 files changed, 340 insertions(+), 304 deletions(-) rename media/engine/videodecodersoftwarefallbackwrapper_unittest.cc => api/video_codecs/test/video_decoder_software_fallback_wrapper_unittest.cc (75%) rename media/engine/videoencodersoftwarefallbackwrapper_unittest.cc => api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc (87%) rename media/engine/videodecodersoftwarefallbackwrapper.cc => api/video_codecs/video_decoder_software_fallback_wrapper.cc (74%) create mode 100644 api/video_codecs/video_decoder_software_fallback_wrapper.h rename media/engine/videoencodersoftwarefallbackwrapper.cc => api/video_codecs/video_encoder_software_fallback_wrapper.cc (77%) create mode 100644 api/video_codecs/video_encoder_software_fallback_wrapper.h delete mode 100644 media/engine/videodecodersoftwarefallbackwrapper.h delete mode 100644 media/engine/videoencodersoftwarefallbackwrapper.h diff --git a/BUILD.gn b/BUILD.gn index 04e97a2550..e99793791d 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -435,7 +435,7 @@ if (rtc_include_tests) { "api:rtc_api_unittests", "api/audio/test:audio_api_unittests", "api/audio_codecs/test:audio_codecs_api_unittests", - "api/video_codecs/test:builtin_video_codec_factory_unittests", + "api/video_codecs/test:video_codecs_api_unittests", "p2p:libstunprober_unittests", "p2p:rtc_p2p_unittests", "rtc_base:rtc_base_approved_unittests", diff --git a/api/DEPS b/api/DEPS index adbe10bda9..847cce259f 100644 --- a/api/DEPS +++ b/api/DEPS @@ -6,6 +6,7 @@ include_rules = [ "+pc", "+logging/rtc_event_log/rtc_event_log_factory_interface.h", "+modules/audio_processing/include", + "+system_wrappers/include", ] specific_include_rules = { diff --git a/api/video_codecs/BUILD.gn b/api/video_codecs/BUILD.gn index e589b6ed9d..079df989d4 100644 --- a/api/video_codecs/BUILD.gn +++ b/api/video_codecs/BUILD.gn @@ -76,3 +76,31 @@ rtc_static_library("builtin_video_encoder_factory") { "../../rtc_base:ptr_util", ] } + +rtc_static_library("rtc_software_fallback_wrappers") { + visibility = [ "*" ] + + sources = [ + "video_decoder_software_fallback_wrapper.cc", + "video_decoder_software_fallback_wrapper.h", + "video_encoder_software_fallback_wrapper.cc", + "video_encoder_software_fallback_wrapper.h", + ] + + if (!build_with_chromium && is_clang) { + # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163). + suppressed_configs += [ "//build/config/clang:find_bad_constructs" ] + } + + deps = [ + ":video_codecs_api", + "../../media:rtc_h264_profile_id", + "../../media:rtc_media_base", + "../../modules/video_coding:video_codec_interface", + "../../rtc_base:checks", + "../../rtc_base:rtc_base_approved", + "../../rtc_base/system:fallthrough", + "../../system_wrappers:field_trial_api", + "../video:video_bitrate_allocation", + ] +} diff --git a/api/video_codecs/test/BUILD.gn b/api/video_codecs/test/BUILD.gn index aa68f939ac..8dc2fcc6d3 100644 --- a/api/video_codecs/test/BUILD.gn +++ b/api/video_codecs/test/BUILD.gn @@ -9,18 +9,28 @@ import("../../../webrtc.gni") if (rtc_include_tests) { - rtc_source_set("builtin_video_codec_factory_unittests") { + rtc_source_set("video_codecs_api_unittests") { testonly = true sources = [ "builtin_video_encoder_factory_unittest.cc", + "video_decoder_software_fallback_wrapper_unittest.cc", + "video_encoder_software_fallback_wrapper_unittest.cc", ] deps = [ "..:builtin_video_encoder_factory", + "..:rtc_software_fallback_wrappers", "..:video_codecs_api", + "../../../modules/video_coding:video_codec_interface", + "../../../modules/video_coding:webrtc_vp8", + "../../../modules/video_coding:webrtc_vp8_helpers", + "../../../rtc_base:checks", + "../../../rtc_base:rtc_base_tests_utils", "../../../system_wrappers:metrics_default", "../../../test:field_trial", "../../../test:test_support", + "../../video:video_bitrate_allocation", + "../../video:video_frame_i420", "//testing/gtest", ] } diff --git a/media/engine/videodecodersoftwarefallbackwrapper_unittest.cc b/api/video_codecs/test/video_decoder_software_fallback_wrapper_unittest.cc similarity index 75% rename from media/engine/videodecodersoftwarefallbackwrapper_unittest.cc rename to api/video_codecs/test/video_decoder_software_fallback_wrapper_unittest.cc index 28d883a2d1..29f005abab 100644 --- a/media/engine/videodecodersoftwarefallbackwrapper_unittest.cc +++ b/api/video_codecs/test/video_decoder_software_fallback_wrapper_unittest.cc @@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "media/engine/videodecodersoftwarefallbackwrapper.h" +#include "api/video_codecs/video_decoder_software_fallback_wrapper.h" #include "api/video_codecs/video_decoder.h" #include "modules/video_coding/codecs/vp8/include/vp8.h" #include "modules/video_coding/include/video_error_codes.h" @@ -21,8 +21,9 @@ class VideoDecoderSoftwareFallbackWrapperTest : public ::testing::Test { protected: VideoDecoderSoftwareFallbackWrapperTest() : fake_decoder_(new CountingFakeDecoder()), - fallback_wrapper_(std::unique_ptr(VP8Decoder::Create()), - std::unique_ptr(fake_decoder_)) {} + fallback_wrapper_(CreateVideoDecoderSoftwareFallbackWrapper( + std::unique_ptr(VP8Decoder::Create()), + std::unique_ptr(fake_decoder_))) {} class CountingFakeDecoder : public VideoDecoder { public: @@ -51,9 +52,7 @@ class VideoDecoderSoftwareFallbackWrapperTest : public ::testing::Test { return WEBRTC_VIDEO_CODEC_OK; } - const char* ImplementationName() const override { - return "fake-decoder"; - } + const char* ImplementationName() const override { return "fake-decoder"; } int init_decode_count_ = 0; int decode_count_ = 0; @@ -65,17 +64,17 @@ class VideoDecoderSoftwareFallbackWrapperTest : public ::testing::Test { }; // |fake_decoder_| is owned and released by |fallback_wrapper_|. CountingFakeDecoder* fake_decoder_; - VideoDecoderSoftwareFallbackWrapper fallback_wrapper_; + std::unique_ptr fallback_wrapper_; }; TEST_F(VideoDecoderSoftwareFallbackWrapperTest, InitializesDecoder) { VideoCodec codec = {}; - fallback_wrapper_.InitDecode(&codec, 2); + fallback_wrapper_->InitDecode(&codec, 2); EXPECT_EQ(1, fake_decoder_->init_decode_count_); EncodedImage encoded_image; encoded_image._frameType = kVideoFrameKey; - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); EXPECT_EQ(1, fake_decoder_->init_decode_count_) << "Initialized decoder should not be reinitialized."; EXPECT_EQ(1, fake_decoder_->decode_count_); @@ -84,14 +83,13 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, InitializesDecoder) { TEST_F(VideoDecoderSoftwareFallbackWrapperTest, UsesFallbackDecoderAfterAnyInitDecodeFailure) { VideoCodec codec = {}; - fake_decoder_->init_decode_return_code_ = - WEBRTC_VIDEO_CODEC_UNINITIALIZED; - fallback_wrapper_.InitDecode(&codec, 2); + fake_decoder_->init_decode_return_code_ = WEBRTC_VIDEO_CODEC_UNINITIALIZED; + fallback_wrapper_->InitDecode(&codec, 2); EXPECT_EQ(1, fake_decoder_->init_decode_count_); EncodedImage encoded_image; encoded_image._frameType = kVideoFrameKey; - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); EXPECT_EQ(1, fake_decoder_->init_decode_count_) << "Should not have attempted reinitializing the fallback decoder on " "keyframe."; @@ -103,16 +101,16 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, TEST_F(VideoDecoderSoftwareFallbackWrapperTest, IsSoftwareFallbackSticky) { VideoCodec codec = {}; - fallback_wrapper_.InitDecode(&codec, 2); + fallback_wrapper_->InitDecode(&codec, 2); fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; EncodedImage encoded_image; - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); EXPECT_EQ(1, fake_decoder_->decode_count_); // Software fallback should be sticky, fake_decoder_ shouldn't be used. encoded_image._frameType = kVideoFrameKey; - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); EXPECT_EQ(1, fake_decoder_->decode_count_) << "Decoder shouldn't be used after failure."; @@ -122,50 +120,49 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, IsSoftwareFallbackSticky) { TEST_F(VideoDecoderSoftwareFallbackWrapperTest, DoesNotFallbackOnEveryError) { VideoCodec codec = {}; - fallback_wrapper_.InitDecode(&codec, 2); + fallback_wrapper_->InitDecode(&codec, 2); fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR; EncodedImage encoded_image; - EXPECT_EQ( - fake_decoder_->decode_return_code_, - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1)); + EXPECT_EQ(fake_decoder_->decode_return_code_, + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1)); EXPECT_EQ(1, fake_decoder_->decode_count_); - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); EXPECT_EQ(2, fake_decoder_->decode_count_) << "Decoder should be active even though previous decode failed."; } TEST_F(VideoDecoderSoftwareFallbackWrapperTest, UsesHwDecoderAfterReinit) { VideoCodec codec = {}; - fallback_wrapper_.InitDecode(&codec, 2); + fallback_wrapper_->InitDecode(&codec, 2); fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; EncodedImage encoded_image; - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); EXPECT_EQ(1, fake_decoder_->decode_count_); - fallback_wrapper_.Release(); - fallback_wrapper_.InitDecode(&codec, 2); + fallback_wrapper_->Release(); + fallback_wrapper_->InitDecode(&codec, 2); fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_OK; - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); EXPECT_EQ(2, fake_decoder_->decode_count_) << "Should not be using fallback after reinit."; } TEST_F(VideoDecoderSoftwareFallbackWrapperTest, ForwardsReleaseCall) { VideoCodec codec = {}; - fallback_wrapper_.InitDecode(&codec, 2); - fallback_wrapper_.Release(); + fallback_wrapper_->InitDecode(&codec, 2); + fallback_wrapper_->Release(); EXPECT_EQ(1, fake_decoder_->release_count_); - fallback_wrapper_.InitDecode(&codec, 2); + fallback_wrapper_->InitDecode(&codec, 2); fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; EncodedImage encoded_image; - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); EXPECT_EQ(2, fake_decoder_->release_count_) << "Decoder should be released during fallback."; - fallback_wrapper_.Release(); + fallback_wrapper_->Release(); EXPECT_EQ(2, fake_decoder_->release_count_); } @@ -175,8 +172,8 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, ForwardsRegisterDecodeCompleteCallback) { class FakeDecodedImageCallback : public DecodedImageCallback { int32_t Decoded(VideoFrame& decodedImage) override { return 0; } - int32_t Decoded( - webrtc::VideoFrame& decodedImage, int64_t decode_time_ms) override { + int32_t Decoded(webrtc::VideoFrame& decodedImage, + int64_t decode_time_ms) override { RTC_NOTREACHED(); return -1; } @@ -188,24 +185,24 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, } callback; VideoCodec codec = {}; - fallback_wrapper_.InitDecode(&codec, 2); - fallback_wrapper_.RegisterDecodeCompleteCallback(&callback); + fallback_wrapper_->InitDecode(&codec, 2); + fallback_wrapper_->RegisterDecodeCompleteCallback(&callback); EXPECT_EQ(&callback, fake_decoder_->decode_complete_callback_); } TEST_F(VideoDecoderSoftwareFallbackWrapperTest, ReportsFallbackImplementationName) { VideoCodec codec = {}; - fallback_wrapper_.InitDecode(&codec, 2); + fallback_wrapper_->InitDecode(&codec, 2); fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; EncodedImage encoded_image; - fallback_wrapper_.Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); // Hard coded expected value since libvpx is the software implementation name // for VP8. Change accordingly if the underlying implementation does. EXPECT_STREQ("libvpx (fallback from: fake-decoder)", - fallback_wrapper_.ImplementationName()); - fallback_wrapper_.Release(); + fallback_wrapper_->ImplementationName()); + fallback_wrapper_->Release(); } } // namespace webrtc diff --git a/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc b/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc similarity index 87% rename from media/engine/videoencodersoftwarefallbackwrapper_unittest.cc rename to api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc index 931892ee38..ad40f90f01 100644 --- a/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc +++ b/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc @@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "media/engine/videoencodersoftwarefallbackwrapper.h" +#include "api/video_codecs/video_encoder_software_fallback_wrapper.h" #include @@ -44,8 +44,9 @@ class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test { const std::string& field_trials) : override_field_trials_(field_trials), fake_encoder_(new CountingFakeEncoder()), - fallback_wrapper_(std::unique_ptr(VP8Encoder::Create()), - std::unique_ptr(fake_encoder_)) {} + fallback_wrapper_(CreateVideoEncoderSoftwareFallbackWrapper( + std::unique_ptr(VP8Encoder::Create()), + std::unique_ptr(fake_encoder_))) {} class CountingFakeEncoder : public VideoEncoder { public: @@ -96,9 +97,7 @@ class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test { return supports_native_handle_; } - const char* ImplementationName() const override { - return "fake-encoder"; - } + const char* ImplementationName() const override { return "fake-encoder"; } VideoEncoder::ScalingSettings GetScalingSettings() const override { return VideoEncoder::ScalingSettings(kLowThreshold, kHighThreshold); @@ -142,7 +141,7 @@ class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test { FakeEncodedImageCallback callback_; // |fake_encoder_| is owned and released by |fallback_wrapper_|. CountingFakeEncoder* fake_encoder_; - VideoEncoderSoftwareFallbackWrapper fallback_wrapper_; + std::unique_ptr fallback_wrapper_; VideoCodec codec_ = {}; std::unique_ptr frame_; std::unique_ptr rate_allocator_; @@ -160,11 +159,11 @@ void VideoEncoderSoftwareFallbackWrapperTest::EncodeFrame(int expected_ret) { frame_.reset( new VideoFrame(buffer, webrtc::kVideoRotation_0, 0 /* timestamp_us */)); - EXPECT_EQ(expected_ret, fallback_wrapper_.Encode(*frame_, nullptr, &types)); + EXPECT_EQ(expected_ret, fallback_wrapper_->Encode(*frame_, nullptr, &types)); } void VideoEncoderSoftwareFallbackWrapperTest::UtilizeFallbackEncoder() { - fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_); + fallback_wrapper_->RegisterEncodeCompleteCallback(&callback_); EXPECT_EQ(&callback_, fake_encoder_->encode_complete_callback_); // Register with failing fake encoder. Should succeed with VP8 fallback. @@ -177,10 +176,10 @@ void VideoEncoderSoftwareFallbackWrapperTest::UtilizeFallbackEncoder() { fake_encoder_->init_encode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR; EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize)); + fallback_wrapper_->InitEncode(&codec_, kNumCores, kMaxPayloadSize)); EXPECT_EQ( WEBRTC_VIDEO_CODEC_OK, - fallback_wrapper_.SetRateAllocation( + fallback_wrapper_->SetRateAllocation( rate_allocator_->GetAllocation(300000, kFramerate), kFramerate)); int callback_count = callback_.callback_count_; @@ -191,17 +190,17 @@ void VideoEncoderSoftwareFallbackWrapperTest::UtilizeFallbackEncoder() { } void VideoEncoderSoftwareFallbackWrapperTest::FallbackFromEncodeRequest() { - fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_); + fallback_wrapper_->RegisterEncodeCompleteCallback(&callback_); codec_.codecType = kVideoCodecVP8; codec_.maxFramerate = kFramerate; codec_.width = kWidth; codec_.height = kHeight; codec_.VP8()->numberOfTemporalLayers = 1; rate_allocator_.reset(new SimulcastRateAllocator(codec_)); - fallback_wrapper_.InitEncode(&codec_, 2, kMaxPayloadSize); + fallback_wrapper_->InitEncode(&codec_, 2, kMaxPayloadSize); EXPECT_EQ( WEBRTC_VIDEO_CODEC_OK, - fallback_wrapper_.SetRateAllocation( + fallback_wrapper_->SetRateAllocation( rate_allocator_->GetAllocation(300000, kFramerate), kFramerate)); EXPECT_EQ(1, fake_encoder_->init_encode_count_); @@ -217,7 +216,7 @@ void VideoEncoderSoftwareFallbackWrapperTest::FallbackFromEncodeRequest() { TEST_F(VideoEncoderSoftwareFallbackWrapperTest, InitializesEncoder) { VideoCodec codec = {}; - fallback_wrapper_.InitEncode(&codec, 2, kMaxPayloadSize); + fallback_wrapper_->InitEncode(&codec, 2, kMaxPayloadSize); EXPECT_EQ(1, fake_encoder_->init_encode_count_); } @@ -231,7 +230,7 @@ TEST_F(VideoEncoderSoftwareFallbackWrapperTest, EncodeRequestsFallback) { TEST_F(VideoEncoderSoftwareFallbackWrapperTest, CanUtilizeFallbackEncoder) { UtilizeFallbackEncoder(); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release()); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release()); } TEST_F(VideoEncoderSoftwareFallbackWrapperTest, @@ -239,7 +238,7 @@ TEST_F(VideoEncoderSoftwareFallbackWrapperTest, EXPECT_EQ(0, fake_encoder_->release_count_); UtilizeFallbackEncoder(); EXPECT_EQ(1, fake_encoder_->release_count_); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release()); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release()); // No extra release when the fallback is released. EXPECT_EQ(1, fake_encoder_->release_count_); } @@ -251,7 +250,7 @@ TEST_F(VideoEncoderSoftwareFallbackWrapperTest, EncodeFrame(); EXPECT_EQ(encode_count, fake_encoder_->encode_count_); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release()); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release()); } TEST_F(VideoEncoderSoftwareFallbackWrapperTest, @@ -260,55 +259,55 @@ TEST_F(VideoEncoderSoftwareFallbackWrapperTest, // Registering an encode-complete callback should still work when fallback // encoder is being used. FakeEncodedImageCallback callback2; - fallback_wrapper_.RegisterEncodeCompleteCallback(&callback2); + fallback_wrapper_->RegisterEncodeCompleteCallback(&callback2); EXPECT_EQ(&callback2, fake_encoder_->encode_complete_callback_); // Encoding a frame using the fallback should arrive at the new callback. std::vector types(1, kVideoFrameKey); frame_->set_timestamp(frame_->timestamp() + 1000); EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - fallback_wrapper_.Encode(*frame_, nullptr, &types)); + fallback_wrapper_->Encode(*frame_, nullptr, &types)); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release()); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release()); } TEST_F(VideoEncoderSoftwareFallbackWrapperTest, SetChannelParametersForwardedDuringFallback) { UtilizeFallbackEncoder(); EXPECT_EQ(0, fake_encoder_->set_channel_parameters_count_); - fallback_wrapper_.SetChannelParameters(1, 1); + fallback_wrapper_->SetChannelParameters(1, 1); EXPECT_EQ(1, fake_encoder_->set_channel_parameters_count_); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release()); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release()); } TEST_F(VideoEncoderSoftwareFallbackWrapperTest, SetRatesForwardedDuringFallback) { UtilizeFallbackEncoder(); EXPECT_EQ(1, fake_encoder_->set_rates_count_); - fallback_wrapper_.SetRateAllocation(VideoBitrateAllocation(), 1); + fallback_wrapper_->SetRateAllocation(VideoBitrateAllocation(), 1); EXPECT_EQ(2, fake_encoder_->set_rates_count_); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release()); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release()); } TEST_F(VideoEncoderSoftwareFallbackWrapperTest, SupportsNativeHandleForwardedWithoutFallback) { - fallback_wrapper_.SupportsNativeHandle(); + fallback_wrapper_->SupportsNativeHandle(); EXPECT_EQ(1, fake_encoder_->supports_native_handle_count_); } TEST_F(VideoEncoderSoftwareFallbackWrapperTest, SupportsNativeHandleNotForwardedDuringFallback) { UtilizeFallbackEncoder(); - fallback_wrapper_.SupportsNativeHandle(); + fallback_wrapper_->SupportsNativeHandle(); EXPECT_EQ(0, fake_encoder_->supports_native_handle_count_); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release()); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release()); } TEST_F(VideoEncoderSoftwareFallbackWrapperTest, ReportsImplementationName) { codec_.width = kWidth; codec_.height = kHeight; - fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_); - fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize); + fallback_wrapper_->RegisterEncodeCompleteCallback(&callback_); + fallback_wrapper_->InitEncode(&codec_, kNumCores, kMaxPayloadSize); EncodeFrame(); CheckLastEncoderName("fake-encoder"); } @@ -341,11 +340,11 @@ class ForcedFallbackTest : public VideoEncoderSoftwareFallbackWrapperTest { } void TearDown() override { - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release()); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release()); } void ConfigureVp8Codec() { - fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_); + fallback_wrapper_->RegisterEncodeCompleteCallback(&callback_); codec_.codecType = kVideoCodecVP8; codec_.maxFramerate = kFramerate; codec_.width = kWidth; @@ -359,13 +358,13 @@ class ForcedFallbackTest : public VideoEncoderSoftwareFallbackWrapperTest { void InitEncode(int width, int height) { codec_.width = width; codec_.height = height; - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.InitEncode( + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->InitEncode( &codec_, kNumCores, kMaxPayloadSize)); SetRateAllocation(kBitrateKbps); } void SetRateAllocation(uint32_t bitrate_kbps) { - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.SetRateAllocation( + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->SetRateAllocation( rate_allocator_->GetAllocation( bitrate_kbps * 1000, kFramerate), kFramerate)); @@ -490,7 +489,7 @@ TEST_F(ForcedFallbackTestDisabled, GetScaleSettings) { EncodeFrameAndVerifyLastName("fake-encoder"); // Default min pixels per frame should be used. - const auto settings = fallback_wrapper_.GetScalingSettings(); + const auto settings = fallback_wrapper_->GetScalingSettings(); EXPECT_TRUE(settings.thresholds.has_value()); EXPECT_EQ(kDefaultMinPixelsPerFrame, settings.min_pixels_per_frame); } @@ -501,7 +500,7 @@ TEST_F(ForcedFallbackTestEnabled, GetScaleSettingsWithNoFallback) { EncodeFrameAndVerifyLastName("fake-encoder"); // Configured min pixels per frame should be used. - const auto settings = fallback_wrapper_.GetScalingSettings(); + const auto settings = fallback_wrapper_->GetScalingSettings(); EXPECT_EQ(kMinPixelsPerFrame, settings.min_pixels_per_frame); ASSERT_TRUE(settings.thresholds); EXPECT_EQ(kLowThreshold, settings.thresholds->low); @@ -514,7 +513,7 @@ TEST_F(ForcedFallbackTestEnabled, GetScaleSettingsWithFallback) { EncodeFrameAndVerifyLastName("libvpx"); // Configured min pixels per frame should be used. - const auto settings = fallback_wrapper_.GetScalingSettings(); + const auto settings = fallback_wrapper_->GetScalingSettings(); EXPECT_TRUE(settings.thresholds.has_value()); EXPECT_EQ(kMinPixelsPerFrame, settings.min_pixels_per_frame); } @@ -526,7 +525,7 @@ TEST_F(ForcedFallbackTestEnabled, ScalingDisabledIfResizeOff) { EncodeFrameAndVerifyLastName("libvpx"); // Should be disabled for automatic resize off. - const auto settings = fallback_wrapper_.GetScalingSettings(); + const auto settings = fallback_wrapper_->GetScalingSettings(); EXPECT_FALSE(settings.thresholds.has_value()); } diff --git a/media/engine/videodecodersoftwarefallbackwrapper.cc b/api/video_codecs/video_decoder_software_fallback_wrapper.cc similarity index 74% rename from media/engine/videodecodersoftwarefallbackwrapper.cc rename to api/video_codecs/video_decoder_software_fallback_wrapper.cc index 564498c617..01c7de86f4 100644 --- a/media/engine/videodecodersoftwarefallbackwrapper.cc +++ b/api/video_codecs/video_decoder_software_fallback_wrapper.cc @@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "media/engine/videodecodersoftwarefallbackwrapper.h" +#include "api/video_codecs/video_decoder_software_fallback_wrapper.h" #include #include @@ -16,11 +16,58 @@ #include "modules/video_coding/include/video_error_codes.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" +#include "rtc_base/ptr_util.h" #include "rtc_base/system/fallthrough.h" #include "rtc_base/trace_event.h" namespace webrtc { +namespace { + +class VideoDecoderSoftwareFallbackWrapper final : public VideoDecoder { + public: + VideoDecoderSoftwareFallbackWrapper( + std::unique_ptr sw_fallback_decoder, + std::unique_ptr hw_decoder); + ~VideoDecoderSoftwareFallbackWrapper() override; + + int32_t InitDecode(const VideoCodec* codec_settings, + int32_t number_of_cores) override; + + int32_t Decode(const EncodedImage& input_image, + bool missing_frames, + const CodecSpecificInfo* codec_specific_info, + int64_t render_time_ms) override; + + int32_t RegisterDecodeCompleteCallback( + DecodedImageCallback* callback) override; + + int32_t Release() override; + bool PrefersLateDecoding() const override; + + const char* ImplementationName() const override; + + private: + bool InitFallbackDecoder(); + int32_t InitHwDecoder(); + + VideoDecoder& active_decoder() const; + + // Determines if we are trying to use the HW or SW decoder. + enum class DecoderType { + kNone, + kHardware, + kFallback, + } decoder_type_; + std::unique_ptr hw_decoder_; + + VideoCodec codec_settings_; + int32_t number_of_cores_; + const std::unique_ptr fallback_decoder_; + const std::string fallback_implementation_name_; + DecodedImageCallback* callback_; +}; + VideoDecoderSoftwareFallbackWrapper::VideoDecoderSoftwareFallbackWrapper( std::unique_ptr sw_fallback_decoder, std::unique_ptr hw_decoder) @@ -115,8 +162,7 @@ int32_t VideoDecoderSoftwareFallbackWrapper::Decode( } case DecoderType::kFallback: return fallback_decoder_->Decode(input_image, missing_frames, - codec_specific_info, - render_time_ms); + codec_specific_info, render_time_ms); default: RTC_NOTREACHED(); return WEBRTC_VIDEO_CODEC_ERROR; @@ -166,4 +212,13 @@ VideoDecoder& VideoDecoderSoftwareFallbackWrapper::active_decoder() const { : *hw_decoder_; } +} // namespace + +std::unique_ptr CreateVideoDecoderSoftwareFallbackWrapper( + std::unique_ptr sw_fallback_decoder, + std::unique_ptr hw_decoder) { + return rtc::MakeUnique( + std::move(sw_fallback_decoder), std::move(hw_decoder)); +} + } // namespace webrtc diff --git a/api/video_codecs/video_decoder_software_fallback_wrapper.h b/api/video_codecs/video_decoder_software_fallback_wrapper.h new file mode 100644 index 0000000000..0608715182 --- /dev/null +++ b/api/video_codecs/video_decoder_software_fallback_wrapper.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef API_VIDEO_CODECS_VIDEO_DECODER_SOFTWARE_FALLBACK_WRAPPER_H_ +#define API_VIDEO_CODECS_VIDEO_DECODER_SOFTWARE_FALLBACK_WRAPPER_H_ + +#include + +#include "api/video_codecs/video_decoder.h" + +namespace webrtc { + +// Used to wrap external VideoDecoders to provide a fallback option on +// software decoding when a hardware decoder fails to decode a stream due to +// hardware restrictions, such as max resolution. +std::unique_ptr CreateVideoDecoderSoftwareFallbackWrapper( + std::unique_ptr sw_fallback_decoder, + std::unique_ptr hw_decoder); + +} // namespace webrtc + +#endif // API_VIDEO_CODECS_VIDEO_DECODER_SOFTWARE_FALLBACK_WRAPPER_H_ diff --git a/media/engine/videoencodersoftwarefallbackwrapper.cc b/api/video_codecs/video_encoder_software_fallback_wrapper.cc similarity index 77% rename from media/engine/videoencodersoftwarefallbackwrapper.cc rename to api/video_codecs/video_encoder_software_fallback_wrapper.cc index bc60fde030..e345ea6dae 100644 --- a/media/engine/videoencodersoftwarefallbackwrapper.cc +++ b/api/video_codecs/video_encoder_software_fallback_wrapper.cc @@ -8,20 +8,26 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "media/engine/videoencodersoftwarefallbackwrapper.h" +#include "api/video_codecs/video_encoder_software_fallback_wrapper.h" #include +#include #include +#include +#include "media/base/codec.h" #include "media/base/h264_profile_level_id.h" #include "modules/video_coding/include/video_error_codes.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" +#include "rtc_base/ptr_util.h" #include "rtc_base/timeutils.h" #include "system_wrappers/include/field_trial.h" namespace webrtc { + namespace { + const char kVp8ForceFallbackEncoderFieldTrial[] = "WebRTC-VP8-Forced-Fallback-Encoder-v2"; @@ -62,7 +68,81 @@ void GetForcedFallbackParamsFromFieldTrialGroup(int* param_min_pixels, *param_min_pixels = min_pixels; *param_max_pixels = max_pixels; } -} // namespace + +class VideoEncoderSoftwareFallbackWrapper final : public VideoEncoder { + public: + VideoEncoderSoftwareFallbackWrapper( + std::unique_ptr sw_encoder, + std::unique_ptr hw_encoder); + ~VideoEncoderSoftwareFallbackWrapper() override; + + int32_t InitEncode(const VideoCodec* codec_settings, + int32_t number_of_cores, + size_t max_payload_size) override; + + int32_t RegisterEncodeCompleteCallback( + EncodedImageCallback* callback) override; + + int32_t Release() override; + int32_t Encode(const VideoFrame& frame, + const CodecSpecificInfo* codec_specific_info, + const std::vector* frame_types) override; + int32_t SetChannelParameters(uint32_t packet_loss, int64_t rtt) override; + int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation, + uint32_t framerate) override; + bool SupportsNativeHandle() const override; + ScalingSettings GetScalingSettings() const override; + const char* ImplementationName() const override; + + private: + bool InitFallbackEncoder(); + + // If |forced_fallback_possible_| is true: + // The forced fallback is requested if the resolution is less than or equal to + // |max_pixels_|. The resolution is allowed to be scaled down to + // |min_pixels_|. + class ForcedFallbackParams { + public: + bool IsValid(const VideoCodec& codec) const { + return codec.width * codec.height <= max_pixels_; + } + + bool active_ = false; + int min_pixels_ = 320 * 180; + int max_pixels_ = 320 * 240; + }; + + bool TryInitForcedFallbackEncoder(); + bool TryReInitForcedFallbackEncoder(); + void ValidateSettingsForForcedFallback(); + bool IsForcedFallbackActive() const; + void MaybeModifyCodecForFallback(); + + // Settings used in the last InitEncode call and used if a dynamic fallback to + // software is required. + VideoCodec codec_settings_; + int32_t number_of_cores_; + size_t max_payload_size_; + + // The last bitrate/framerate set, and a flag for noting they are set. + bool rates_set_; + VideoBitrateAllocation bitrate_allocation_; + uint32_t framerate_; + + // The last channel parameters set, and a flag for noting they are set. + bool channel_parameters_set_; + uint32_t packet_loss_; + int64_t rtt_; + + bool use_fallback_encoder_; + const std::unique_ptr encoder_; + + const std::unique_ptr fallback_encoder_; + EncodedImageCallback* callback_; + + bool forced_fallback_possible_; + ForcedFallbackParams forced_fallback_; +}; VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper( std::unique_ptr sw_encoder, @@ -295,4 +375,13 @@ void VideoEncoderSoftwareFallbackWrapper::ValidateSettingsForForcedFallback() { } } +} // namespace + +std::unique_ptr CreateVideoEncoderSoftwareFallbackWrapper( + std::unique_ptr sw_fallback_encoder, + std::unique_ptr hw_encoder) { + return rtc::MakeUnique( + std::move(sw_fallback_encoder), std::move(hw_encoder)); +} + } // namespace webrtc diff --git a/api/video_codecs/video_encoder_software_fallback_wrapper.h b/api/video_codecs/video_encoder_software_fallback_wrapper.h new file mode 100644 index 0000000000..0f46ad41ba --- /dev/null +++ b/api/video_codecs/video_encoder_software_fallback_wrapper.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef API_VIDEO_CODECS_VIDEO_ENCODER_SOFTWARE_FALLBACK_WRAPPER_H_ +#define API_VIDEO_CODECS_VIDEO_ENCODER_SOFTWARE_FALLBACK_WRAPPER_H_ + +#include + +#include "api/video_codecs/video_encoder.h" + +namespace webrtc { + +// Used to wrap external VideoEncoders to provide a fallback option on +// software encoding when a hardware encoder fails to encode a stream due to +// hardware restrictions, such as max resolution. +std::unique_ptr CreateVideoEncoderSoftwareFallbackWrapper( + std::unique_ptr sw_fallback_encoder, + std::unique_ptr hw_encoder); + +} // namespace webrtc + +#endif // API_VIDEO_CODECS_VIDEO_ENCODER_SOFTWARE_FALLBACK_WRAPPER_H_ diff --git a/media/BUILD.gn b/media/BUILD.gn index 694b8feb88..cfa81cbdc0 100644 --- a/media/BUILD.gn +++ b/media/BUILD.gn @@ -192,10 +192,10 @@ rtc_static_library("rtc_internal_video_codecs") { deps += [ ":rtc_constants", ":rtc_media_base", - ":rtc_software_fallback_wrappers", "..:webrtc_common", "../api/video:video_bitrate_allocation", "../api/video:video_frame_i420", + "../api/video_codecs:rtc_software_fallback_wrappers", "../api/video_codecs:video_codecs_api", "../call:call_interfaces", "../call:video_stream_api", @@ -214,32 +214,6 @@ rtc_static_library("rtc_internal_video_codecs") { ] } -rtc_static_library("rtc_software_fallback_wrappers") { - sources = [ - "engine/videodecodersoftwarefallbackwrapper.cc", - "engine/videodecodersoftwarefallbackwrapper.h", - "engine/videoencodersoftwarefallbackwrapper.cc", - "engine/videoencodersoftwarefallbackwrapper.h", - ] - - if (!build_with_chromium && is_clang) { - # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163). - suppressed_configs += [ "//build/config/clang:find_bad_constructs" ] - } - - deps = [ - ":rtc_h264_profile_id", - ":rtc_media_base", - "../api/video:video_bitrate_allocation", - "../api/video_codecs:video_codecs_api", - "../modules/video_coding:video_codec_interface", - "../rtc_base:checks", - "../rtc_base:rtc_base_approved", - "../rtc_base/system:fallthrough", - "../system_wrappers:field_trial_api", - ] -} - rtc_static_library("rtc_audio_video") { visibility = [ "*" ] allow_poison = [ @@ -327,7 +301,6 @@ rtc_static_library("rtc_audio_video") { deps += [ ":rtc_constants", ":rtc_media_base", - ":rtc_software_fallback_wrappers", "..:webrtc_common", "../api:call_api", "../api:libjingle_peerconnection_api", @@ -336,6 +309,7 @@ rtc_static_library("rtc_audio_video") { "../api/audio_codecs:audio_codecs_api", "../api/video:video_frame", "../api/video:video_frame_i420", + "../api/video_codecs:rtc_software_fallback_wrappers", "../api/video_codecs:video_codecs_api", "../call", "../call:call_interfaces", @@ -547,8 +521,6 @@ if (rtc_include_tests) { "engine/nullwebrtcvideoengine_unittest.cc", "engine/payload_type_mapper_unittest.cc", "engine/simulcast_encoder_adapter_unittest.cc", - "engine/videodecodersoftwarefallbackwrapper_unittest.cc", - "engine/videoencodersoftwarefallbackwrapper_unittest.cc", "engine/vp8_encoder_simulcast_proxy_unittest.cc", "engine/webrtcmediaengine_unittest.cc", "engine/webrtcvideocapturer_unittest.cc", @@ -608,7 +580,6 @@ if (rtc_include_tests) { ":rtc_media", ":rtc_media_base", ":rtc_media_tests_utils", - ":rtc_software_fallback_wrappers", "../api:create_simulcast_test_fixture_api", "../api:libjingle_peerconnection_api", "../api:mock_video_codec_factory", diff --git a/media/engine/convert_legacy_video_factory.cc b/media/engine/convert_legacy_video_factory.cc index 8f85828a5d..4f197ab209 100644 --- a/media/engine/convert_legacy_video_factory.cc +++ b/media/engine/convert_legacy_video_factory.cc @@ -14,15 +14,15 @@ #include #include "api/video_codecs/video_decoder_factory.h" +#include "api/video_codecs/video_decoder_software_fallback_wrapper.h" #include "api/video_codecs/video_encoder_factory.h" +#include "api/video_codecs/video_encoder_software_fallback_wrapper.h" #include "media/base/h264_profile_level_id.h" #include "media/engine/internaldecoderfactory.h" #include "media/engine/internalencoderfactory.h" #include "media/engine/scopedvideodecoder.h" #include "media/engine/scopedvideoencoder.h" #include "media/engine/simulcast_encoder_adapter.h" -#include "media/engine/videodecodersoftwarefallbackwrapper.h" -#include "media/engine/videoencodersoftwarefallbackwrapper.h" #include "media/engine/vp8_encoder_simulcast_proxy.h" #include "media/engine/webrtcvideodecoderfactory.h" #include "media/engine/webrtcvideoencoderfactory.h" @@ -144,7 +144,7 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory { if (internal_encoder && external_encoder) { // Both internal SW encoder and external HW encoder available - create // fallback encoder. - return rtc::MakeUnique( + return webrtc::CreateVideoEncoderSoftwareFallbackWrapper( std::move(internal_encoder), std::move(external_encoder)); } return external_encoder ? std::move(external_encoder) @@ -199,9 +199,8 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory { return external_decoder; // Both external and internal decoder available - create fallback // wrapper. - return std::unique_ptr( - new webrtc::VideoDecoderSoftwareFallbackWrapper( - std::move(internal_decoder), std::move(external_decoder))); + return webrtc::CreateVideoDecoderSoftwareFallbackWrapper( + std::move(internal_decoder), std::move(external_decoder)); } } diff --git a/media/engine/videodecodersoftwarefallbackwrapper.h b/media/engine/videodecodersoftwarefallbackwrapper.h deleted file mode 100644 index 7aa76904fe..0000000000 --- a/media/engine/videodecodersoftwarefallbackwrapper.h +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#ifndef MEDIA_ENGINE_VIDEODECODERSOFTWAREFALLBACKWRAPPER_H_ -#define MEDIA_ENGINE_VIDEODECODERSOFTWAREFALLBACKWRAPPER_H_ - -#include -#include - -#include "api/video_codecs/video_decoder.h" - -namespace webrtc { - -// Class used to wrap external VideoDecoders to provide a fallback option on -// software decoding when a hardware decoder fails to decode a stream due to -// hardware restrictions, such as max resolution. -class VideoDecoderSoftwareFallbackWrapper : public VideoDecoder { - public: - VideoDecoderSoftwareFallbackWrapper( - std::unique_ptr sw_fallback_decoder, - std::unique_ptr hw_decoder); - ~VideoDecoderSoftwareFallbackWrapper() override; - - int32_t InitDecode(const VideoCodec* codec_settings, - int32_t number_of_cores) override; - - int32_t Decode(const EncodedImage& input_image, - bool missing_frames, - const CodecSpecificInfo* codec_specific_info, - int64_t render_time_ms) override; - - int32_t RegisterDecodeCompleteCallback( - DecodedImageCallback* callback) override; - - int32_t Release() override; - bool PrefersLateDecoding() const override; - - const char* ImplementationName() const override; - - private: - bool InitFallbackDecoder(); - int32_t InitHwDecoder(); - - VideoDecoder& active_decoder() const; - - // Determines if we are trying to use the HW or SW decoder. - enum class DecoderType { - kNone, - kHardware, - kFallback, - } decoder_type_; - std::unique_ptr hw_decoder_; - - VideoCodec codec_settings_; - int32_t number_of_cores_; - const std::unique_ptr fallback_decoder_; - const std::string fallback_implementation_name_; - DecodedImageCallback* callback_; -}; - -} // namespace webrtc - -#endif // MEDIA_ENGINE_VIDEODECODERSOFTWAREFALLBACKWRAPPER_H_ diff --git a/media/engine/videoencodersoftwarefallbackwrapper.h b/media/engine/videoencodersoftwarefallbackwrapper.h deleted file mode 100644 index 1c472d1e55..0000000000 --- a/media/engine/videoencodersoftwarefallbackwrapper.h +++ /dev/null @@ -1,103 +0,0 @@ -/* - * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#ifndef MEDIA_ENGINE_VIDEOENCODERSOFTWAREFALLBACKWRAPPER_H_ -#define MEDIA_ENGINE_VIDEOENCODERSOFTWAREFALLBACKWRAPPER_H_ - -#include -#include -#include - -#include "api/video_codecs/video_encoder.h" -#include "media/base/codec.h" - -namespace webrtc { - -// Class used to wrap external VideoEncoders to provide a fallback option on -// software encoding when a hardware encoder fails to encode a stream due to -// hardware restrictions, such as max resolution. -class VideoEncoderSoftwareFallbackWrapper : public VideoEncoder { - public: - VideoEncoderSoftwareFallbackWrapper( - std::unique_ptr sw_encoder, - std::unique_ptr hw_encoder); - ~VideoEncoderSoftwareFallbackWrapper() override; - - int32_t InitEncode(const VideoCodec* codec_settings, - int32_t number_of_cores, - size_t max_payload_size) override; - - int32_t RegisterEncodeCompleteCallback( - EncodedImageCallback* callback) override; - - int32_t Release() override; - int32_t Encode(const VideoFrame& frame, - const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) override; - int32_t SetChannelParameters(uint32_t packet_loss, int64_t rtt) override; - int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation, - uint32_t framerate) override; - bool SupportsNativeHandle() const override; - ScalingSettings GetScalingSettings() const override; - const char *ImplementationName() const override; - - private: - bool InitFallbackEncoder(); - - // If |forced_fallback_possible_| is true: - // The forced fallback is requested if the resolution is less than or equal to - // |max_pixels_|. The resolution is allowed to be scaled down to - // |min_pixels_|. - class ForcedFallbackParams { - public: - bool IsValid(const VideoCodec& codec) const { - return codec.width * codec.height <= max_pixels_; - } - - bool active_ = false; - int min_pixels_ = 320 * 180; - int max_pixels_ = 320 * 240; - }; - - bool TryInitForcedFallbackEncoder(); - bool TryReInitForcedFallbackEncoder(); - void ValidateSettingsForForcedFallback(); - bool IsForcedFallbackActive() const; - void MaybeModifyCodecForFallback(); - - // Settings used in the last InitEncode call and used if a dynamic fallback to - // software is required. - VideoCodec codec_settings_; - int32_t number_of_cores_; - size_t max_payload_size_; - - // The last bitrate/framerate set, and a flag for noting they are set. - bool rates_set_; - VideoBitrateAllocation bitrate_allocation_; - uint32_t framerate_; - - // The last channel parameters set, and a flag for noting they are set. - bool channel_parameters_set_; - uint32_t packet_loss_; - int64_t rtt_; - - bool use_fallback_encoder_; - const std::unique_ptr encoder_; - - const std::unique_ptr fallback_encoder_; - EncodedImageCallback* callback_; - - bool forced_fallback_possible_; - ForcedFallbackParams forced_fallback_; -}; - -} // namespace webrtc - -#endif // MEDIA_ENGINE_VIDEOENCODERSOFTWAREFALLBACKWRAPPER_H_ diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn index e211ae6b1f..dd939ce401 100644 --- a/modules/video_coding/BUILD.gn +++ b/modules/video_coding/BUILD.gn @@ -726,12 +726,12 @@ if (rtc_include_tests) { "../../api:optional", "../../api:videocodec_test_fixture_api", "../../api/video:video_frame_i420", + "../../api/video_codecs:rtc_software_fallback_wrappers", "../../api/video_codecs:video_codecs_api", "../../common_video", "../../media:rtc_h264_profile_id", "../../media:rtc_internal_video_codecs", "../../media:rtc_media_base", - "../../media:rtc_software_fallback_wrappers", "../../rtc_base:rtc_base", "../../test:fileutils", "../../test:test_common", diff --git a/sdk/android/BUILD.gn b/sdk/android/BUILD.gn index 2de53d900e..34a4f279ad 100644 --- a/sdk/android/BUILD.gn +++ b/sdk/android/BUILD.gn @@ -366,12 +366,12 @@ rtc_static_library("video_jni") { "../..:webrtc_common", "../../api:libjingle_peerconnection_api", "../../api/video:video_frame", + "../../api/video_codecs:rtc_software_fallback_wrappers", "../../api/video_codecs:video_codecs_api", "../../common_video:common_video", "../../media:rtc_audio_video", "../../media:rtc_h264_profile_id", "../../media:rtc_media_base", - "../../media:rtc_software_fallback_wrappers", "../../modules:module_api", "../../modules/utility:utility", "../../modules/video_coding:codec_globals_headers", diff --git a/sdk/android/src/jni/videodecoderfallback.cc b/sdk/android/src/jni/videodecoderfallback.cc index 6d09c776a5..66d7fdf224 100644 --- a/sdk/android/src/jni/videodecoderfallback.cc +++ b/sdk/android/src/jni/videodecoderfallback.cc @@ -10,7 +10,7 @@ #include -#include "media/engine/videodecodersoftwarefallbackwrapper.h" +#include "api/video_codecs/video_decoder_software_fallback_wrapper.h" #include "sdk/android/generated_video_jni/jni/VideoDecoderFallback_jni.h" #include "sdk/android/src/jni/jni_helpers.h" #include "sdk/android/src/jni/wrappednativecodec.h" @@ -28,9 +28,10 @@ static jlong JNI_VideoDecoderFallback_CreateDecoder( std::unique_ptr primary_decoder = JavaToNativeVideoDecoder(jni, j_primary_decoder); - VideoDecoderSoftwareFallbackWrapper* nativeWrapper = - new VideoDecoderSoftwareFallbackWrapper(std::move(fallback_decoder), - std::move(primary_decoder)); + VideoDecoder* nativeWrapper = + CreateVideoDecoderSoftwareFallbackWrapper(std::move(fallback_decoder), + std::move(primary_decoder)) + .release(); return jlongFromPointer(nativeWrapper); } diff --git a/sdk/android/src/jni/videoencoderfallback.cc b/sdk/android/src/jni/videoencoderfallback.cc index 086a3a9688..55c5dd2afc 100644 --- a/sdk/android/src/jni/videoencoderfallback.cc +++ b/sdk/android/src/jni/videoencoderfallback.cc @@ -10,7 +10,7 @@ #include -#include "media/engine/videoencodersoftwarefallbackwrapper.h" +#include "api/video_codecs/video_encoder_software_fallback_wrapper.h" #include "sdk/android/generated_video_jni/jni/VideoEncoderFallback_jni.h" #include "sdk/android/src/jni/jni_helpers.h" #include "sdk/android/src/jni/wrappednativecodec.h" @@ -28,9 +28,10 @@ static jlong JNI_VideoEncoderFallback_CreateEncoder( std::unique_ptr primary_encoder = JavaToNativeVideoEncoder(jni, j_primary_encoder); - VideoEncoderSoftwareFallbackWrapper* nativeWrapper = - new VideoEncoderSoftwareFallbackWrapper(std::move(fallback_encoder), - std::move(primary_encoder)); + VideoEncoder* nativeWrapper = + CreateVideoEncoderSoftwareFallbackWrapper(std::move(fallback_encoder), + std::move(primary_encoder)) + .release(); return jlongFromPointer(nativeWrapper); }