admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use the factory instead of using the builtin code path in VideoCodecInitializer.

Browse Source 
Bug: webrtc:9513
Change-Id: Ia299ae1044a3ff4c91e208200938cba540bdcea6
Reviewed-on: https://webrtc-review.googlesource.com/c/94782
Commit-Queue: Jiawei Ou <ouj@fb.com>
Reviewed-by: Kári Helgason <kthelgason@webrtc.org>
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Anders Carlsson <andersc@webrtc.org>
Reviewed-by: Seth Hampson <shampson@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25456}
This commit is contained in:
Jiawei Ou 2018-10-10 01:16:20 -07:00 committed by Commit Bot
parent 838643550f
commit be142178aa
57 changed files with 389 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
api/BUILD.gn
View File

@ -544,6 +544,18 @@ if (rtc_include_tests) {
]
}
rtc_source_set("mock_video_bitrate_allocator_factory") {
testonly = true
sources = [
"test/mock_video_bitrate_allocator_factory.h",
]
deps = [
"../api/video:video_bitrate_allocator_factory",
"../test:test_support",
]
}
rtc_source_set("mock_video_codec_factory") {
testonly = true
sources = [

37
api/test/mock_video_bitrate_allocator_factory.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2018 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_TEST_MOCK_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
#define API_TEST_MOCK_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
#include <memory>
#include "api/video/video_bitrate_allocator_factory.h"
#include "test/gmock.h"
namespace webrtc {
class MockVideoBitrateAllocatorFactory
: public webrtc::VideoBitrateAllocatorFactory {
public:
virtual std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
const VideoCodec& codec) {
return std::unique_ptr<VideoBitrateAllocator>(
CreateVideoBitrateAllocatorProxy(codec));
}
~MockVideoBitrateAllocatorFactory() { Die(); }
MOCK_METHOD1(CreateVideoBitrateAllocatorProxy,
VideoBitrateAllocator*(const VideoCodec&));
MOCK_METHOD0(Die, void());
};
} // namespace webrtc
#endif // API_TEST_MOCK_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_

20
api/video/BUILD.gn
View File

@ -174,6 +174,7 @@ rtc_source_set("video_stream_encoder") {
]
deps = [
":video_bitrate_allocator_factory",
":video_frame",
# For rtpparameters.h
@ -204,3 +205,22 @@ rtc_source_set("video_stream_encoder_create") {
"//third_party/abseil-cpp/absl/memory",
]
}
rtc_static_library("builtin_video_bitrate_allocator_factory") {
visibility = [ "*" ]
sources = [
"builtin_video_bitrate_allocator_factory.cc",
"builtin_video_bitrate_allocator_factory.h",
]
deps = [
":video_bitrate_allocation",
":video_bitrate_allocator_factory",
"../../media:rtc_media_base",
"../../modules/video_coding:video_coding_utility",
"../../modules/video_coding:webrtc_vp9_helpers",
"../../rtc_base:ptr_util",
"../../rtc_base/system:fallthrough",
"//third_party/abseil-cpp/absl/memory",
]
}

2
pc/builtin_video_bitrate_allocator_factory.cc → api/video/builtin_video_bitrate_allocator_factory.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "pc/builtin_video_bitrate_allocator_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "absl/memory/memory.h"
#include "media/base/codec.h"

6
pc/builtin_video_bitrate_allocator_factory.h → api/video/builtin_video_bitrate_allocator_factory.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef PC_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
#define PC_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
#ifndef API_VIDEO_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
#define API_VIDEO_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
#include <memory>
@ -22,4 +22,4 @@ CreateBuiltinVideoBitrateAllocatorFactory();
} // namespace webrtc
#endif // PC_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
#endif // API_VIDEO_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_

4
api/video/video_stream_encoder_settings.h
View File

@ -11,6 +11,7 @@
#ifndef API_VIDEO_VIDEO_STREAM_ENCODER_SETTINGS_H_
#define API_VIDEO_VIDEO_STREAM_ENCODER_SETTINGS_H_
#include "api/video/video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
namespace webrtc {
@ -24,6 +25,9 @@ struct VideoStreamEncoderSettings {
// Ownership stays with WebrtcVideoEngine (delegated from PeerConnection).
VideoEncoderFactory* encoder_factory = nullptr;
// Ownership stays with WebrtcVideoEngine (delegated from PeerConnection).
VideoBitrateAllocatorFactory* bitrate_allocator_factory = nullptr;
};
} // namespace webrtc

1
call/BUILD.gn
View File

@ -386,6 +386,7 @@ if (rtc_include_tests) {
"..:webrtc_common",
"../api:simulated_network_api",
"../api/audio_codecs:builtin_audio_encoder_factory",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:video_bitrate_allocation",
"../api/video_codecs:video_codecs_api",
"../logging:rtc_event_log_api",

2
call/bitrate_estimator_tests.cc
View File

@ -126,6 +126,8 @@ class BitrateEstimatorTest : public test::CallTest {
video_send_config.rtp.ssrcs.push_back(kVideoSendSsrcs[0]);
video_send_config.encoder_settings.encoder_factory =
&fake_encoder_factory_;
video_send_config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
video_send_config.rtp.payload_name = "FAKE";
video_send_config.rtp.payload_type = kFakeVideoSendPayloadType;
SetVideoSendConfig(video_send_config);

8
call/call_perf_tests.cc
View File

@ -16,6 +16,7 @@
#include "absl/memory/memory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/test/simulated_network.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/video_bitrate_allocation.h"
#include "api/video_codecs/video_encoder_config.h"
#include "call/call.h"
@ -730,7 +731,9 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
last_set_bitrate_kbps_(0),
send_stream_(nullptr),
frame_generator_(nullptr),
encoder_factory_(this) {}
encoder_factory_(this),
bitrate_allocator_factory_(
CreateBuiltinVideoBitrateAllocatorFactory()) {}
int32_t InitEncode(const VideoCodec* config,
int32_t number_of_cores,
@ -777,6 +780,8 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
encoder_config->max_bitrate_bps = 2 * kReconfigureThresholdKbps * 1000;
encoder_config->video_stream_factory =
new rtc::RefCountedObject<VideoStreamFactory>();
@ -812,6 +817,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
VideoSendStream* send_stream_;
test::FrameGeneratorCapturer* frame_generator_;
test::VideoEncoderProxyFactory encoder_factory_;
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
VideoEncoderConfig encoder_config_;
} test;

1
examples/BUILD.gn
View File

@ -503,6 +503,7 @@ if (is_ios || (is_mac && target_cpu != "x86")) {
"../api:libjingle_peerconnection_api",
"../api/audio_codecs:builtin_audio_decoder_factory",
"../api/audio_codecs:builtin_audio_encoder_factory",
"../api/video:builtin_video_bitrate_allocator_factory",
"../logging:rtc_event_log_impl_base",
"../media:rtc_audio_video",
"../modules/audio_processing:audio_processing",

1
examples/androidnativeapi/BUILD.gn
View File

@ -49,6 +49,7 @@ if (is_android) {
"//api:libjingle_peerconnection_api",
"//api/audio_codecs:builtin_audio_decoder_factory",
"//api/audio_codecs:builtin_audio_encoder_factory",
"//api/video:builtin_video_bitrate_allocator_factory",
"//logging:rtc_event_log_impl_base",
"//media:rtc_audio_video",
"//media:rtc_internal_video_codecs",

2
examples/androidnativeapi/jni/androidcallclient.cc
View File

@ -16,6 +16,7 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/peerconnectioninterface.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "examples/androidnativeapi/generated_jni/jni/CallClient_jni.h"
#include "media/engine/internaldecoderfactory.h"
#include "media/engine/internalencoderfactory.h"
@ -159,6 +160,7 @@ void AndroidCallClient::CreatePeerConnectionFactory() {
webrtc::CreateBuiltinAudioDecoderFactory(),
absl::make_unique<webrtc::InternalEncoderFactory>(),
absl::make_unique<webrtc::InternalDecoderFactory>(),
webrtc::CreateBuiltinVideoBitrateAllocatorFactory(),
nullptr /* audio_mixer */, webrtc::AudioProcessingBuilder().Create());
RTC_LOG(LS_INFO) << "Media engine created: " << media_engine.get();

5
examples/objcnativeapi/objc/objccallclient.mm
View File

@ -21,6 +21,7 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/peerconnectioninterface.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "media/engine/webrtcmediaengine.h"
#include "modules/audio_processing/include/audio_processing.h"
#include "sdk/objc/native/api/video_capturer.h"
@ -116,12 +117,16 @@ void ObjCCallClient::CreatePeerConnectionFactory() {
std::unique_ptr<webrtc::VideoEncoderFactory> videoEncoderFactory =
webrtc::ObjCToNativeVideoEncoderFactory([[RTCDefaultVideoEncoderFactory alloc] init]);
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory> videoBitrateAllocatorFactory =
webrtc::CreateBuiltinVideoBitrateAllocatorFactory();
std::unique_ptr<cricket::MediaEngineInterface> media_engine =
cricket::WebRtcMediaEngineFactory::Create(nullptr /* adm */,
webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(),
std::move(videoEncoderFactory),
std::move(videoDecoderFactory),
std::move(videoBitrateAllocatorFactory),
nullptr /* audio_mixer */,
webrtc::AudioProcessingBuilder().Create());
RTC_LOG(LS_INFO) << "Media engine created: " << media_engine.get();

4
media/BUILD.gn
View File

@ -278,6 +278,7 @@ rtc_static_library("rtc_audio_video") {
defines = []
libs = []
deps = [
"../api/video:video_bitrate_allocator_factory",
"../modules/audio_processing/aec_dump:aec_dump",
"../modules/video_coding:video_codec_interface",
"../modules/video_coding:video_coding",
@ -626,10 +627,13 @@ if (rtc_include_tests) {
":rtc_vp9_profile",
"../api:create_simulcast_test_fixture_api",
"../api:libjingle_peerconnection_api",
"../api:mock_video_bitrate_allocator",
"../api:mock_video_bitrate_allocator_factory",
"../api:mock_video_codec_factory",
"../api:simulcast_test_fixture_api",
"../api/audio_codecs:builtin_audio_decoder_factory",
"../api/audio_codecs:builtin_audio_encoder_factory",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:video_bitrate_allocation",
"../api/video:video_frame",
"../api/video_codecs:builtin_video_decoder_factory",

1
media/engine/fakewebrtccall.cc
View File

@ -123,6 +123,7 @@ FakeVideoSendStream::FakeVideoSendStream(
source_(nullptr),
num_swapped_frames_(0) {
RTC_DCHECK(config.encoder_settings.encoder_factory != nullptr);
RTC_DCHECK(config.encoder_settings.bitrate_allocator_factory != nullptr);
ReconfigureVideoEncoder(std::move(encoder_config));
}

34
media/engine/webrtcmediaengine.cc
View File

@ -15,6 +15,7 @@
#include <tuple>
#include <utility>
#include "api/video/video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "media/engine/webrtcvoiceengine.h"
@ -38,15 +39,19 @@ MediaEngineInterface* CreateWebRtcMediaEngine(
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing) {
#ifdef HAVE_WEBRTC_VIDEO
typedef WebRtcVideoEngine VideoEngine;
std::tuple<std::unique_ptr<WebRtcVideoEncoderFactory>,
std::unique_ptr<WebRtcVideoDecoderFactory>>
std::unique_ptr<WebRtcVideoDecoderFactory>,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>>
video_args(
(std::unique_ptr<WebRtcVideoEncoderFactory>(video_encoder_factory)),
(std::unique_ptr<WebRtcVideoDecoderFactory>(video_decoder_factory)));
(std::unique_ptr<WebRtcVideoDecoderFactory>(video_decoder_factory)),
(std::move(video_bitrate_allocator_factory)));
#else
typedef NullWebRtcVideoEngine VideoEngine;
std::tuple<> video_args;
@ -66,11 +71,13 @@ MediaEngineInterface* WebRtcMediaEngineFactory::Create(
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory) {
return CreateWebRtcMediaEngine(adm, audio_encoder_factory,
audio_decoder_factory, video_encoder_factory,
video_decoder_factory, nullptr,
webrtc::AudioProcessingBuilder().Create());
WebRtcVideoDecoderFactory* video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory) {
return CreateWebRtcMediaEngine(
adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
video_decoder_factory, std::move(video_bitrate_allocator_factory),
nullptr, webrtc::AudioProcessingBuilder().Create());
}
MediaEngineInterface* WebRtcMediaEngineFactory::Create(
@ -81,11 +88,14 @@ MediaEngineInterface* WebRtcMediaEngineFactory::Create(
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing) {
return CreateWebRtcMediaEngine(
adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
video_decoder_factory, audio_mixer, audio_processing);
video_decoder_factory, std::move(video_bitrate_allocator_factory),
audio_mixer, audio_processing);
}
#endif
@ -95,14 +105,18 @@ std::unique_ptr<MediaEngineInterface> WebRtcMediaEngineFactory::Create(
rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing) {
#ifdef HAVE_WEBRTC_VIDEO
typedef WebRtcVideoEngine VideoEngine;
std::tuple<std::unique_ptr<webrtc::VideoEncoderFactory>,
std::unique_ptr<webrtc::VideoDecoderFactory>>
std::unique_ptr<webrtc::VideoDecoderFactory>,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>>
video_args(std::move(video_encoder_factory),
std::move(video_decoder_factory));
std::move(video_decoder_factory),
std::move(video_bitrate_allocator_factory));
#else
typedef NullWebRtcVideoEngine VideoEngine;
std::tuple<> video_args;

9
media/engine/webrtcmediaengine.h
View File

@ -25,6 +25,7 @@ class AudioMixer;
class AudioProcessing;
class VideoDecoderFactory;
class VideoEncoderFactory;
class VideoBitrateAllocatorFactory;
} // namespace webrtc
namespace cricket {
class WebRtcVideoDecoderFactory;
@ -49,7 +50,9 @@ class WebRtcMediaEngineFactory {
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory);
WebRtcVideoDecoderFactory* video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory);
static MediaEngineInterface* Create(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
@ -58,6 +61,8 @@ class WebRtcMediaEngineFactory {
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
rtc::scoped_refptr<webrtc::AudioProcessing> apm);
#endif
@ -71,6 +76,8 @@ class WebRtcMediaEngineFactory {
rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing);
};

6
media/engine/webrtcmediaengine_unittest.cc
View File

@ -12,6 +12,7 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
#include "media/engine/webrtcmediaengine.h"
@ -244,8 +245,9 @@ TEST(WebRtcMediaEngineFactoryTest, CreateWithBuiltinDecoders) {
nullptr /* adm */, webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(),
webrtc::CreateBuiltinVideoEncoderFactory(),
webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
webrtc::AudioProcessingBuilder().Create()));
webrtc::CreateBuiltinVideoDecoderFactory(),
webrtc::CreateBuiltinVideoBitrateAllocatorFactory(),
nullptr /* audio_mixer */, webrtc::AudioProcessingBuilder().Create()));
EXPECT_TRUE(engine);
}

23
media/engine/webrtcvideoengine.cc
View File

@ -437,20 +437,26 @@ void DefaultUnsignalledSsrcHandler::SetDefaultSink(
#if defined(USE_BUILTIN_SW_CODECS)
WebRtcVideoEngine::WebRtcVideoEngine(
std::unique_ptr<WebRtcVideoEncoderFactory> external_video_encoder_factory,
std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory)
std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory)
: decoder_factory_(ConvertVideoDecoderFactory(
std::move(external_video_decoder_factory))),
encoder_factory_(ConvertVideoEncoderFactory(
std::move(external_video_encoder_factory))) {
std::move(external_video_encoder_factory))),
bitrate_allocator_factory_(std::move(video_bitrate_allocator_factory)) {
RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
}
#endif
WebRtcVideoEngine::WebRtcVideoEngine(
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory)
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory)
: decoder_factory_(std::move(video_decoder_factory)),
encoder_factory_(std::move(video_encoder_factory)) {
encoder_factory_(std::move(video_encoder_factory)),
bitrate_allocator_factory_(std::move(video_bitrate_allocator_factory)) {
RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
}
@ -465,7 +471,8 @@ WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel(
const webrtc::CryptoOptions& crypto_options) {
RTC_LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
return new WebRtcVideoChannel(call, config, options, crypto_options,
encoder_factory_.get(), decoder_factory_.get());
encoder_factory_.get(), decoder_factory_.get(),
bitrate_allocator_factory_.get());
}
std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
@ -516,13 +523,15 @@ WebRtcVideoChannel::WebRtcVideoChannel(
const VideoOptions& options,
const webrtc::CryptoOptions& crypto_options,
webrtc::VideoEncoderFactory* encoder_factory,
webrtc::VideoDecoderFactory* decoder_factory)
webrtc::VideoDecoderFactory* decoder_factory,
webrtc::VideoBitrateAllocatorFactory* bitrate_allocator_factory)
: VideoMediaChannel(config),
call_(call),
unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
video_config_(config.video),
encoder_factory_(encoder_factory),
decoder_factory_(decoder_factory),
bitrate_allocator_factory_(bitrate_allocator_factory),
preferred_dscp_(rtc::DSCP_DEFAULT),
default_send_options_(options),
last_stats_log_ms_(-1),
@ -1069,6 +1078,8 @@ bool WebRtcVideoChannel::AddSendStream(const StreamParams& sp) {
config.encoder_settings.experiment_cpu_load_estimator =
video_config_.experiment_cpu_load_estimator;
config.encoder_settings.encoder_factory = encoder_factory_;
config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_;
config.crypto_options = crypto_options_;
config.rtp.extmap_allow_mixed = ExtmapAllowMixed();

27
media/engine/webrtcvideoengine.h
View File

@ -19,6 +19,7 @@
#include "absl/types/optional.h"
#include "api/call/transport.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "api/video/video_frame.h"
#include "api/video/video_sink_interface.h"
#include "api/video/video_source_interface.h"
@ -84,15 +85,18 @@ class WebRtcVideoEngine {
// Internal SW video codecs will be added on top of the external codecs.
WebRtcVideoEngine(
std::unique_ptr<WebRtcVideoEncoderFactory> external_video_encoder_factory,
std::unique_ptr<WebRtcVideoDecoderFactory>
external_video_decoder_factory);
std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory);
#endif
// These video codec factories represents all video codecs, i.e. both software
// and external hardware codecs.
WebRtcVideoEngine(
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory);
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory);
virtual ~WebRtcVideoEngine();
@ -108,16 +112,20 @@ class WebRtcVideoEngine {
private:
const std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_;
const std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory_;
const std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
bitrate_allocator_factory_;
};
class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
public:
WebRtcVideoChannel(webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options,
const webrtc::CryptoOptions& crypto_options,
webrtc::VideoEncoderFactory* encoder_factory,
webrtc::VideoDecoderFactory* decoder_factory);
WebRtcVideoChannel(
webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options,
const webrtc::CryptoOptions& crypto_options,
webrtc::VideoEncoderFactory* encoder_factory,
webrtc::VideoDecoderFactory* decoder_factory,
webrtc::VideoBitrateAllocatorFactory* bitrate_allocator_factory);
~WebRtcVideoChannel() override;
// VideoMediaChannel implementation
@ -491,6 +499,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
webrtc::VideoEncoderFactory* const encoder_factory_;
webrtc::VideoDecoderFactory* const decoder_factory_;
webrtc::VideoBitrateAllocatorFactory* const bitrate_allocator_factory_;
std::vector<VideoCodecSettings> recv_codecs_;
std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
// See reason for keeping track of the FlexFEC payload type separately in

48
media/engine/webrtcvideoengine_unittest.cc
View File

@ -16,9 +16,12 @@
#include "absl/strings/match.h"
#include "api/rtpparameters.h"
#include "api/test/mock_video_bitrate_allocator.h"
#include "api/test/mock_video_bitrate_allocator_factory.h"
#include "api/test/mock_video_decoder_factory.h"
#include "api/test/mock_video_encoder_factory.h"
#include "api/units/time_delta.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/video_bitrate_allocation.h"
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
@ -214,7 +217,8 @@ class WebRtcVideoEngineTest : public ::testing::Test {
engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
encoder_factory_),
std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
decoder_factory_)) {
decoder_factory_),
webrtc::CreateBuiltinVideoBitrateAllocatorFactory()) {
// Ensure fake clock doesn't return 0, which will cause some initializations
// fail inside RTP senders.
fake_clock_.AdvanceTimeMicros(1);
@ -1009,8 +1013,10 @@ TEST_F(WebRtcVideoEngineTest, GetSourcesWithNonExistingSsrc) {
TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, NullFactories) {
std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory;
std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory;
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory> rate_allocator_factory;
WebRtcVideoEngine engine(std::move(encoder_factory),
std::move(decoder_factory));
std::move(decoder_factory),
std::move(rate_allocator_factory));
EXPECT_EQ(0u, engine.codecs().size());
}
@ -1020,13 +1026,18 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, EmptyFactories) {
new webrtc::MockVideoEncoderFactory();
webrtc::MockVideoDecoderFactory* decoder_factory =
new webrtc::MockVideoDecoderFactory();
webrtc::MockVideoBitrateAllocatorFactory* rate_allocator_factory =
new webrtc::MockVideoBitrateAllocatorFactory();
WebRtcVideoEngine engine(
(std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)),
(std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)));
(std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)),
(std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>(
rate_allocator_factory)));
EXPECT_CALL(*encoder_factory, GetSupportedFormats());
EXPECT_EQ(0u, engine.codecs().size());
EXPECT_CALL(*encoder_factory, Die());
EXPECT_CALL(*decoder_factory, Die());
EXPECT_CALL(*rate_allocator_factory, Die());
}
// Test full behavior in the video engine when video codec factories of the new
@ -1039,9 +1050,17 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
new webrtc::MockVideoEncoderFactory();
webrtc::MockVideoDecoderFactory* decoder_factory =
new webrtc::MockVideoDecoderFactory();
webrtc::MockVideoBitrateAllocatorFactory* rate_allocator_factory =
new webrtc::MockVideoBitrateAllocatorFactory();
EXPECT_CALL(*rate_allocator_factory,
CreateVideoBitrateAllocatorProxy(Field(
&webrtc::VideoCodec::codecType, webrtc::kVideoCodecVP8)))
.WillOnce(testing::Return(new webrtc::MockVideoBitrateAllocator()));
WebRtcVideoEngine engine(
(std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)),
(std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)));
(std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)),
(std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>(
rate_allocator_factory)));
const webrtc::SdpVideoFormat vp8_format("VP8");
const std::vector<webrtc::SdpVideoFormat> supported_formats = {vp8_format};
EXPECT_CALL(*encoder_factory, GetSupportedFormats())
@ -1137,6 +1156,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
// Remove streams previously added to free the encoder and decoder instance.
EXPECT_CALL(*encoder_factory, Die());
EXPECT_CALL(*decoder_factory, Die());
EXPECT_CALL(*rate_allocator_factory, Die());
EXPECT_TRUE(send_channel->RemoveSendStream(send_ssrc));
EXPECT_TRUE(recv_channel->RemoveRecvStream(recv_ssrc));
}
@ -1145,12 +1165,16 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, NullDecoder) {
// |engine| take ownership of the factories.
webrtc::MockVideoEncoderFactory* encoder_factory =
new testing::StrictMock<webrtc::MockVideoEncoderFactory>();
new webrtc::MockVideoEncoderFactory();
webrtc::MockVideoDecoderFactory* decoder_factory =
new testing::StrictMock<webrtc::MockVideoDecoderFactory>();
new webrtc::MockVideoDecoderFactory();
webrtc::MockVideoBitrateAllocatorFactory* rate_allocator_factory =
new webrtc::MockVideoBitrateAllocatorFactory();
WebRtcVideoEngine engine(
(std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)),
(std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)));
(std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)),
(std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>(
rate_allocator_factory)));
const webrtc::SdpVideoFormat vp8_format("VP8");
const std::vector<webrtc::SdpVideoFormat> supported_formats = {vp8_format};
EXPECT_CALL(*encoder_factory, GetSupportedFormats())
@ -1243,7 +1267,8 @@ class WebRtcVideoChannelBaseTest : public testing::Test {
protected:
WebRtcVideoChannelBaseTest()
: engine_(webrtc::CreateBuiltinVideoEncoderFactory(),
webrtc::CreateBuiltinVideoDecoderFactory()) {}
webrtc::CreateBuiltinVideoDecoderFactory(),
webrtc::CreateBuiltinVideoBitrateAllocatorFactory()) {}
virtual void SetUp() {
// One testcase calls SetUp in a loop, only create call_ once.
@ -6760,10 +6785,14 @@ class WebRtcVideoChannelSimulcastTest : public testing::Test {
: fake_call_(),
encoder_factory_(new cricket::FakeWebRtcVideoEncoderFactory),
decoder_factory_(new cricket::FakeWebRtcVideoDecoderFactory),
mock_rate_allocator_factory_(
new webrtc::MockVideoBitrateAllocatorFactory),
engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
encoder_factory_),
std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
decoder_factory_)),
decoder_factory_),
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>(
mock_rate_allocator_factory_)),
last_ssrc_(0) {}
void SetUp() override {
@ -6920,6 +6949,7 @@ class WebRtcVideoChannelSimulcastTest : public testing::Test {
FakeCall fake_call_;
cricket::FakeWebRtcVideoEncoderFactory* encoder_factory_;
cricket::FakeWebRtcVideoDecoderFactory* decoder_factory_;
webrtc::MockVideoBitrateAllocatorFactory* mock_rate_allocator_factory_;
WebRtcVideoEngine engine_;
std::unique_ptr<VideoMediaChannel> channel_;
uint32_t last_ssrc_;

4
modules/video_coding/BUILD.gn
View File

@ -158,6 +158,7 @@ rtc_static_library("video_coding") {
"..:module_api_public",
"../..:webrtc_common",
"../../api:fec_controller_api",
"../../api/video:builtin_video_bitrate_allocator_factory",
"../../api/video:encoded_frame",
"../../api/video:video_bitrate_allocator",
"../../api/video:video_frame",
@ -642,6 +643,7 @@ if (rtc_include_tests) {
":webrtc_vp9_helpers",
"../..:webrtc_common",
"../../api:videocodec_test_fixture_api",
"../../api/video:builtin_video_bitrate_allocator_factory",
"../../api/video:video_bitrate_allocator",
"../../api/video:video_frame",
"../../api/video:video_frame_i420",
@ -895,7 +897,9 @@ if (rtc_include_tests) {
"../../api:simulcast_test_fixture_api",
"../../api:videocodec_test_fixture_api",
"../../api/test/video:function_video_factory",
"../../api/video:builtin_video_bitrate_allocator_factory",
"../../api/video:video_bitrate_allocator",
"../../api/video:video_bitrate_allocator_factory",
"../../api/video:video_frame",
"../../api/video:video_frame_i420",
"../../api/video_codecs:create_vp8_temporal_layers",

6
modules/video_coding/codecs/test/videoprocessor.cc
View File

@ -14,6 +14,7 @@
#include <limits>
#include <utility>
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/i420_buffer.h"
#include "common_types.h" // NOLINT(build/include)
#include "common_video/h264/h264_common.h"
@ -173,8 +174,9 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
stats_(stats),
encoder_(encoder),
decoders_(decoders),
bitrate_allocator_(VideoCodecInitializer::CreateBitrateAllocator(
config_.codec_settings)),
bitrate_allocator_(
CreateBuiltinVideoBitrateAllocatorFactory()
->CreateVideoBitrateAllocator(config_.codec_settings)),
framerate_fps_(0),
encode_callback_(this),
input_frame_reader_(input_frame_reader),

12
modules/video_coding/include/video_codec_initializer.h
View File

@ -30,15 +30,9 @@ class VideoCodecInitializer {
// type used. For instance, VP8 will create an allocator than can handle
// simulcast and temporal layering.
// GetBitrateAllocator is called implicitly from here, no need to call again.
static bool SetupCodec(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams,
VideoCodec* codec,
std::unique_ptr<VideoBitrateAllocator>* bitrate_allocator);
// Create a bitrate allocator for the specified codec.
static std::unique_ptr<VideoBitrateAllocator> CreateBitrateAllocator(
const VideoCodec& codec);
static bool SetupCodec(const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams,
VideoCodec* codec);
private:
static VideoCodec VideoEncoderConfigToVideoCodec(

32
modules/video_coding/video_codec_initializer.cc
View File

@ -24,15 +24,13 @@
namespace webrtc {
bool VideoCodecInitializer::SetupCodec(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams,
VideoCodec* codec,
std::unique_ptr<VideoBitrateAllocator>* bitrate_allocator) {
bool VideoCodecInitializer::SetupCodec(const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams,
VideoCodec* codec) {
if (config.codec_type == kVideoCodecMultiplex) {
VideoEncoderConfig associated_config = config.Copy();
associated_config.codec_type = kVideoCodecVP9;
if (!SetupCodec(associated_config, streams, codec, bitrate_allocator)) {
if (!SetupCodec(associated_config, streams, codec)) {
RTC_LOG(LS_ERROR) << "Failed to create stereo encoder configuration.";
return false;
}
@ -41,31 +39,9 @@ bool VideoCodecInitializer::SetupCodec(
}
*codec = VideoEncoderConfigToVideoCodec(config, streams);
*bitrate_allocator = CreateBitrateAllocator(*codec);
return true;
}
std::unique_ptr<VideoBitrateAllocator>
VideoCodecInitializer::CreateBitrateAllocator(const VideoCodec& codec) {
std::unique_ptr<VideoBitrateAllocator> rate_allocator;
switch (codec.codecType) {
case kVideoCodecVP8:
RTC_FALLTHROUGH();
case kVideoCodecH264:
rate_allocator.reset(new SimulcastRateAllocator(codec));
break;
case kVideoCodecVP9:
rate_allocator.reset(new SvcRateAllocator(codec));
break;
default:
rate_allocator.reset(new DefaultVideoBitrateAllocator(codec));
}
return rate_allocator;
}
// TODO(sprang): Split this up and separate the codec specific parts.
VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
const VideoEncoderConfig& config,

39
modules/video_coding/video_codec_initializer_unittest.cc
View File

@ -9,12 +9,13 @@
*/
#include "modules/video_coding/include/video_codec_initializer.h"
#include "api/video/video_bitrate_allocator.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/create_vp8_temporal_layers.h"
#include "api/video_codecs/video_encoder.h"
#include "api/video_codecs/vp8_temporal_layers.h"
#include "common_types.h" // NOLINT(build/include)
#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
#include "rtc_base/checks.h"
#include "rtc_base/refcountedobject.h"
#include "test/gtest.h"
@ -75,12 +76,13 @@ class VideoCodecInitializerTest : public ::testing::Test {
bool InitializeCodec() {
codec_out_ = VideoCodec();
bitrate_allocator_out_.reset();
temporal_layers_.clear();
if (!VideoCodecInitializer::SetupCodec(config_, streams_, &codec_out_,
&bitrate_allocator_out_)) {
if (!VideoCodecInitializer::SetupCodec(config_, streams_, &codec_out_)) {
return false;
}
bitrate_allocator_ = CreateBuiltinVideoBitrateAllocatorFactory()
->CreateVideoBitrateAllocator(codec_out_);
RTC_CHECK(bitrate_allocator_);
if (codec_out_.codecType == VideoCodecType::kVideoCodecMultiplex)
return true;
@ -126,7 +128,7 @@ class VideoCodecInitializerTest : public ::testing::Test {
// Output.
VideoCodec codec_out_;
std::unique_ptr<VideoBitrateAllocator> bitrate_allocator_out_;
std::unique_ptr<VideoBitrateAllocator> bitrate_allocator_;
std::vector<std::unique_ptr<Vp8TemporalLayers>> temporal_layers_;
};
@ -135,9 +137,8 @@ TEST_F(VideoCodecInitializerTest, SingleStreamVp8Screenshare) {
streams_.push_back(DefaultStream());
EXPECT_TRUE(InitializeCodec());
VideoBitrateAllocation bitrate_allocation =
bitrate_allocator_out_->GetAllocation(kDefaultTargetBitrateBps,
kDefaultFrameRate);
VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
kDefaultTargetBitrateBps, kDefaultFrameRate);
EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams);
EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
EXPECT_EQ(kDefaultTargetBitrateBps, bitrate_allocation.get_sum_bps());
@ -150,9 +151,8 @@ TEST_F(VideoCodecInitializerTest, SingleStreamVp8ScreenshareInactive) {
streams_.push_back(inactive_stream);
EXPECT_TRUE(InitializeCodec());
VideoBitrateAllocation bitrate_allocation =
bitrate_allocator_out_->GetAllocation(kDefaultTargetBitrateBps,
kDefaultFrameRate);
VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
kDefaultTargetBitrateBps, kDefaultFrameRate);
EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams);
EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
EXPECT_EQ(0U, bitrate_allocation.get_sum_bps());
@ -165,9 +165,8 @@ TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8Screenshare) {
EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams);
EXPECT_EQ(2u, codec_out_.VP8()->numberOfTemporalLayers);
VideoBitrateAllocation bitrate_allocation =
bitrate_allocator_out_->GetAllocation(kScreenshareCodecTargetBitrateBps,
kScreenshareDefaultFramerate);
VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
kScreenshareCodecTargetBitrateBps, kScreenshareDefaultFramerate);
EXPECT_EQ(kScreenshareCodecTargetBitrateBps,
bitrate_allocation.get_sum_bps());
EXPECT_EQ(kScreenshareTl0BitrateBps, bitrate_allocation.GetBitrate(0, 0));
@ -185,9 +184,8 @@ TEST_F(VideoCodecInitializerTest, SimulcastVp8Screenshare) {
EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
const uint32_t max_bitrate_bps =
streams_[0].target_bitrate_bps + streams_[1].max_bitrate_bps;
VideoBitrateAllocation bitrate_allocation =
bitrate_allocator_out_->GetAllocation(max_bitrate_bps,
kScreenshareDefaultFramerate);
VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
max_bitrate_bps, kScreenshareDefaultFramerate);
EXPECT_EQ(max_bitrate_bps, bitrate_allocation.get_sum_bps());
EXPECT_EQ(static_cast<uint32_t>(streams_[0].target_bitrate_bps),
bitrate_allocation.GetSpatialLayerSum(0));
@ -210,9 +208,8 @@ TEST_F(VideoCodecInitializerTest, SimulcastVp8ScreenshareInactive) {
EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
const uint32_t target_bitrate =
streams_[0].target_bitrate_bps + streams_[1].target_bitrate_bps;
VideoBitrateAllocation bitrate_allocation =
bitrate_allocator_out_->GetAllocation(target_bitrate,
kScreenshareDefaultFramerate);
VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
target_bitrate, kScreenshareDefaultFramerate);
EXPECT_EQ(static_cast<uint32_t>(streams_[0].max_bitrate_bps),
bitrate_allocation.get_sum_bps());
EXPECT_EQ(static_cast<uint32_t>(streams_[0].max_bitrate_bps),
@ -235,7 +232,7 @@ TEST_F(VideoCodecInitializerTest, HighFpsSimulcastVp8Screenshare) {
const uint32_t max_bitrate_bps =
streams_[0].target_bitrate_bps + streams_[1].max_bitrate_bps;
VideoBitrateAllocation bitrate_allocation =
bitrate_allocator_out_->GetAllocation(max_bitrate_bps, kDefaultFrameRate);
bitrate_allocator_->GetAllocation(max_bitrate_bps, kDefaultFrameRate);
EXPECT_EQ(max_bitrate_bps, bitrate_allocation.get_sum_bps());
EXPECT_EQ(static_cast<uint32_t>(streams_[0].target_bitrate_bps),
bitrate_allocation.GetSpatialLayerSum(0));

8
modules/video_coding/video_coding_impl.cc
View File

@ -13,6 +13,7 @@
#include <algorithm>
#include <utility>
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/video_bitrate_allocator.h"
#include "common_types.h" // NOLINT(build/include)
#include "common_video/libyuv/include/webrtc_libyuv.h"
@ -86,6 +87,7 @@ class VideoCodingModuleImpl : public VideoCodingModule {
KeyFrameRequestSender* keyframe_request_sender)
: VideoCodingModule(),
sender_(clock, &post_encode_callback_),
rate_allocator_factory_(CreateBuiltinVideoBitrateAllocatorFactory()),
timing_(new VCMTiming(clock)),
receiver_(clock,
event_factory,
@ -114,7 +116,8 @@ class VideoCodingModuleImpl : public VideoCodingModule {
// asynchronously keep the instance alive until destruction or until a
// new send codec is registered.
VideoCodec codec = *sendCodec;
rate_allocator_ = VideoCodecInitializer::CreateBitrateAllocator(codec);
rate_allocator_ =
rate_allocator_factory_->CreateVideoBitrateAllocator(codec);
return sender_.RegisterSendCodec(&codec, numberOfCores, maxPayloadSize);
}
return sender_.RegisterSendCodec(sendCodec, numberOfCores, maxPayloadSize);
@ -213,8 +216,9 @@ class VideoCodingModuleImpl : public VideoCodingModule {
rtc::ThreadChecker construction_thread_;
EncodedImageCallbackWrapper post_encode_callback_;
vcm::VideoSender sender_;
const std::unique_ptr<VideoBitrateAllocatorFactory> rate_allocator_factory_;
std::unique_ptr<VideoBitrateAllocator> rate_allocator_;
std::unique_ptr<VCMTiming> timing_;
const std::unique_ptr<VCMTiming> timing_;
vcm::VideoReceiver receiver_;
};
} // namespace

19
pc/BUILD.gn
View File

@ -217,23 +217,6 @@ rtc_static_library("peerconnection") {
]
}
rtc_static_library("builtin_video_bitrate_allocator_factory") {
sources = [
"builtin_video_bitrate_allocator_factory.cc",
"builtin_video_bitrate_allocator_factory.h",
]
deps = [
"../api/video:video_bitrate_allocator_factory",
"../media:rtc_media_base",
"../modules/video_coding:video_coding_utility",
"../modules/video_coding:webrtc_vp9_helpers",
"../rtc_base:ptr_util",
"../rtc_base/system:fallthrough",
"//third_party/abseil-cpp/absl/memory",
]
}
# This target implements CreatePeerConnectionFactory methods that will create a
# PeerConnection will full functionality (audio, video and data). Applications
# that wish to reduce their binary size by ommitting functionality they don't
@ -250,6 +233,7 @@ rtc_static_library("create_pc_factory") {
"../api:libjingle_peerconnection_api",
"../api/audio:audio_mixer_api",
"../api/audio_codecs:audio_codecs_api",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video_codecs:video_codecs_api",
"../call",
"../call:call_interfaces",
@ -502,6 +486,7 @@ if (rtc_include_tests) {
"../api:libjingle_peerconnection_api",
"../api:mock_rtp",
"../api/units:time_delta",
"../api/video:builtin_video_bitrate_allocator_factory",
"../logging:fake_rtc_event_log",
"../rtc_base:checks",
"../rtc_base:stringutils",

22
pc/createpeerconnectionfactory.cc
View File

@ -10,6 +10,7 @@
#include "api/call/callfactoryinterface.h"
#include "api/peerconnectioninterface.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "logging/rtc_event_log/rtc_event_log_factory_interface.h"
@ -52,10 +53,15 @@ rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
audio_processing_use = AudioProcessingBuilder().Create();
}
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory =
CreateBuiltinVideoBitrateAllocatorFactory();
std::unique_ptr<cricket::MediaEngineInterface> media_engine(
cricket::WebRtcMediaEngineFactory::Create(
default_adm, audio_encoder_factory, audio_decoder_factory,
video_encoder_factory, video_decoder_factory, audio_mixer,
video_encoder_factory, video_decoder_factory,
std::move(video_bitrate_allocator_factory), audio_mixer,
audio_processing_use));
std::unique_ptr<CallFactoryInterface> call_factory = CreateCallFactory();
@ -87,10 +93,15 @@ rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
audio_processing_use = AudioProcessingBuilder().Create();
}
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory =
CreateBuiltinVideoBitrateAllocatorFactory();
std::unique_ptr<cricket::MediaEngineInterface> media_engine(
cricket::WebRtcMediaEngineFactory::Create(
default_adm, audio_encoder_factory, audio_decoder_factory,
video_encoder_factory, video_decoder_factory, audio_mixer,
video_encoder_factory, video_decoder_factory,
std::move(video_bitrate_allocator_factory), audio_mixer,
audio_processing_use));
std::unique_ptr<CallFactoryInterface> call_factory = CreateCallFactory();
@ -119,11 +130,16 @@ rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
if (!audio_processing)
audio_processing = AudioProcessingBuilder().Create();
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory =
CreateBuiltinVideoBitrateAllocatorFactory();
std::unique_ptr<cricket::MediaEngineInterface> media_engine =
cricket::WebRtcMediaEngineFactory::Create(
default_adm, audio_encoder_factory, audio_decoder_factory,
std::move(video_encoder_factory), std::move(video_decoder_factory),
audio_mixer, audio_processing);
std::move(video_bitrate_allocator_factory), audio_mixer,
audio_processing);
std::unique_ptr<CallFactoryInterface> call_factory = CreateCallFactory();

5
pc/peerconnection_integrationtest.cc
View File

@ -29,6 +29,7 @@
#include "api/peerconnectionproxy.h"
#include "api/rtpreceiverinterface.h"
#include "api/umametrics.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
#include "api/video_codecs/sdp_video_format.h"
@ -621,7 +622,9 @@ class PeerConnectionWrapper : public webrtc::PeerConnectionObserver,
webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory(),
webrtc::CreateBuiltinVideoEncoderFactory(),
webrtc::CreateBuiltinVideoDecoderFactory(), nullptr,
webrtc::CreateBuiltinVideoDecoderFactory(),
webrtc::CreateBuiltinVideoBitrateAllocatorFactory(),
nullptr /* audio_mixer */,
webrtc::AudioProcessingBuilder().Create());
pc_factory_dependencies.call_factory = webrtc::CreateCallFactory();
if (event_log_factory) {

2
pc/peerconnection_jsep_unittest.cc
View File

@ -10,6 +10,7 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
#include "media/engine/webrtcmediaengine.h"
@ -56,6 +57,7 @@ class PeerConnectionFactoryForJsepTest : public PeerConnectionFactory {
CreateBuiltinAudioDecoderFactory(),
CreateBuiltinVideoEncoderFactory(),
CreateBuiltinVideoDecoderFactory(),
CreateBuiltinVideoBitrateAllocatorFactory(),
nullptr,
AudioProcessingBuilder().Create()),
CreateCallFactory(),

6
pc/peerconnectioninterface_unittest.cc
View File

@ -22,6 +22,7 @@
#include "api/peerconnectioninterface.h"
#include "api/rtpreceiverinterface.h"
#include "api/rtpsenderinterface.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
#include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
@ -633,6 +634,8 @@ class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
auto audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
auto video_encoder_factory = webrtc::CreateBuiltinVideoEncoderFactory();
auto video_decoder_factory = webrtc::CreateBuiltinVideoDecoderFactory();
auto video_bitrate_allocator_factory =
webrtc::CreateBuiltinVideoBitrateAllocatorFactory();
// Use fake audio device module since we're only testing the interface
// level, and using a real one could make tests flaky when run in parallel.
@ -640,7 +643,8 @@ class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
cricket::WebRtcMediaEngineFactory::Create(
FakeAudioCaptureModule::Create(), audio_encoder_factory,
audio_decoder_factory, std::move(video_encoder_factory),
std::move(video_decoder_factory), nullptr,
std::move(video_decoder_factory),
std::move(video_bitrate_allocator_factory), nullptr,
webrtc::AudioProcessingBuilder().Create()));
std::unique_ptr<webrtc::CallFactoryInterface> call_factory =

1
sdk/BUILD.gn
View File

@ -913,6 +913,7 @@ if (is_ios || is_mac) {
"../api/audio_codecs:audio_codecs_api",
"../api/audio_codecs:builtin_audio_decoder_factory",
"../api/audio_codecs:builtin_audio_encoder_factory",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:video_frame",
"../api/video_codecs:video_codecs_api",
"../common_video",

5
sdk/android/BUILD.gn
View File

@ -573,6 +573,7 @@ if (is_android) {
":vp9_jni", # TODO(bugs.webrtc.org/7925): Remove.
"../..:webrtc_common",
"../../api:libjingle_peerconnection_api",
"../../api/video:builtin_video_bitrate_allocator_factory",
"../../api/video:encoded_image",
"../../api/video:video_frame",
"../../api/video_codecs:builtin_video_decoder_factory",
@ -662,6 +663,7 @@ if (is_android) {
":native_api_jni",
"../..:webrtc_common",
"../../api:libjingle_peerconnection_api",
"../../api/video:video_bitrate_allocator_factory",
"../../api/video_codecs:video_codecs_api",
"../../logging:rtc_event_log_api",
"../../logging:rtc_event_log_impl_base",
@ -874,6 +876,7 @@ if (is_android) {
deps = [
":base_jni",
"../../api/video:video_bitrate_allocator_factory",
"../../api/video_codecs:video_codecs_api",
]
}
@ -896,6 +899,7 @@ if (is_android) {
deps = [
":base_jni",
"../../api:callfactory_api",
"../../api/video:video_bitrate_allocator_factory",
"../../api/video_codecs:video_codecs_api",
"../../call:call_interfaces",
"../../logging:rtc_event_log_api",
@ -1388,6 +1392,7 @@ if (is_android) {
":video_jni",
"../../api/audio_codecs:builtin_audio_decoder_factory",
"../../api/audio_codecs:builtin_audio_encoder_factory",
"../../api/video:builtin_video_bitrate_allocator_factory",
"../../api/video:video_frame",
"../../media:rtc_audio_video",
"../../media:rtc_internal_video_codecs",

2
sdk/android/native_unittests/peerconnection/peerconnectionfactory_unittest.cc
View File

@ -12,6 +12,7 @@
#include "absl/memory/memory.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "media/base/mediaengine.h"
#include "media/engine/internaldecoderfactory.h"
#include "media/engine/internalencoderfactory.h"
@ -44,6 +45,7 @@ rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> CreateTestPCF(
webrtc::CreateBuiltinAudioDecoderFactory(),
absl::make_unique<webrtc::InternalEncoderFactory>(),
absl::make_unique<webrtc::InternalDecoderFactory>(),
webrtc::CreateBuiltinVideoBitrateAllocatorFactory(),
nullptr /* audio_mixer */, webrtc::AudioProcessingBuilder().Create());
RTC_LOG(LS_INFO) << "Media engine created: " << media_engine.get();

6
sdk/android/src/jni/pc/media.cc
View File

@ -12,6 +12,7 @@
#include <utility>
#include "api/call/callfactoryinterface.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "logging/rtc_event_log/rtc_event_log_factory_interface.h"
@ -36,12 +37,15 @@ cricket::MediaEngineInterface* CreateMediaEngine(
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processor) {
return cricket::WebRtcMediaEngineFactory::Create(
adm, audio_encoder_factory, audio_decoder_factory,
std::move(video_encoder_factory), std::move(video_decoder_factory),
audio_mixer, audio_processor)
std::move(video_bitrate_allocator_factory), audio_mixer,
audio_processor)
.release();
}

3
sdk/android/src/jni/pc/media.h
View File

@ -25,6 +25,7 @@ class AudioMixer;
class AudioProcessing;
class VideoEncoderFactory;
class VideoDecoderFactory;
class VideoBitrateAllocatorFactory;
} // namespace webrtc
namespace cricket {
@ -43,6 +44,8 @@ cricket::MediaEngineInterface* CreateMediaEngine(
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processor);

2
sdk/android/src/jni/pc/null_media.cc
View File

@ -27,6 +27,8 @@ cricket::MediaEngineInterface* CreateMediaEngine(
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<VideoDecoderFactory> video_decoder_factory,
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processor) {
return nullptr;

6
sdk/android/src/jni/pc/null_video.cc
View File

@ -10,6 +10,7 @@
#include "sdk/android/src/jni/pc/video.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
@ -35,5 +36,10 @@ void* CreateVideoSource(JNIEnv* env,
return nullptr;
}
std::unique_ptr<VideoBitrateAllocatorFactory>
CreateVideoBitrateAllocatorFactory() {
return nullptr;
}
} // namespace jni
} // namespace webrtc

7
sdk/android/src/jni/pc/peerconnectionfactory.cc
View File

@ -13,6 +13,7 @@
#include <memory>
#include <utility>
#include "api/video/video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "media/base/mediaengine.h"
@ -259,13 +260,17 @@ jlong CreatePeerConnectionFactoryForJava(
std::unique_ptr<RtcEventLogFactoryInterface> rtc_event_log_factory(
CreateRtcEventLogFactory());
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory = CreateVideoBitrateAllocatorFactory();
std::unique_ptr<cricket::MediaEngineInterface> media_engine(CreateMediaEngine(
audio_device_module, audio_encoder_factory, audio_decoder_factory,
std::unique_ptr<VideoEncoderFactory>(
CreateVideoEncoderFactory(jni, jencoder_factory)),
std::unique_ptr<VideoDecoderFactory>(
CreateVideoDecoderFactory(jni, jdecoder_factory)),
audio_mixer, audio_processor));
std::move(video_bitrate_allocator_factory), audio_mixer,
audio_processor));
PeerConnectionFactoryDependencies dependencies;
dependencies.network_thread = network_thread.get();
dependencies.worker_thread = worker_thread.get();

6
sdk/android/src/jni/pc/video.cc
View File

@ -13,6 +13,7 @@
#include <jni.h>
#include <memory>
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "api/videosourceproxy.h"
@ -52,5 +53,10 @@ void* CreateVideoSource(JNIEnv* env,
.release();
}
std::unique_ptr<VideoBitrateAllocatorFactory>
CreateVideoBitrateAllocatorFactory() {
return CreateBuiltinVideoBitrateAllocatorFactory();
}
} // namespace jni
} // namespace webrtc

5
sdk/android/src/jni/pc/video.h
View File

@ -13,6 +13,7 @@
#include <jni.h>
#include <memory>
#include "rtc_base/scoped_ref_ptr.h"
#include "rtc_base/thread.h"
#include "sdk/android/native_api/jni/scoped_java_ref.h"
@ -20,6 +21,7 @@
namespace webrtc {
class VideoEncoderFactory;
class VideoDecoderFactory;
class VideoBitrateAllocatorFactory;
} // namespace webrtc
namespace webrtc {
@ -38,6 +40,9 @@ void* CreateVideoSource(JNIEnv* env,
rtc::Thread* worker_thread,
jboolean is_screencast);
std::unique_ptr<VideoBitrateAllocatorFactory>
CreateVideoBitrateAllocatorFactory();
} // namespace jni
} // namespace webrtc

17
sdk/objc/api/peerconnection/RTCPeerConnectionFactory.mm
View File

@ -30,6 +30,7 @@
// is not smart enough to take the #ifdef into account.
#include "api/audio_codecs/builtin_audio_decoder_factory.h" // nogncheck
#include "api/audio_codecs/builtin_audio_encoder_factory.h" // nogncheck
#include "api/video/builtin_video_bitrate_allocator_factory.h" // nogncheck
#include "media/engine/convert_legacy_video_factory.h" // nogncheck
#include "modules/audio_device/include/audio_device.h" // nogncheck
#include "modules/audio_processing/include/audio_processing.h" // nogncheck
@ -193,13 +194,15 @@
if (!audioProcessingModule) audioProcessingModule = webrtc::AudioProcessingBuilder().Create();
std::unique_ptr<cricket::MediaEngineInterface> media_engine =
cricket::WebRtcMediaEngineFactory::Create(audioDeviceModule,
audioEncoderFactory,
audioDecoderFactory,
std::move(videoEncoderFactory),
std::move(videoDecoderFactory),
nullptr, // audio mixer
audioProcessingModule);
cricket::WebRtcMediaEngineFactory::Create(
audioDeviceModule,
audioEncoderFactory,
audioDecoderFactory,
std::move(videoEncoderFactory),
std::move(videoDecoderFactory),
webrtc::CreateBuiltinVideoBitrateAllocatorFactory(),
nullptr, // audio mixer
audioProcessingModule);
std::unique_ptr<webrtc::CallFactoryInterface> call_factory = webrtc::CreateCallFactory();

3
test/BUILD.gn
View File

@ -327,6 +327,7 @@ if (rtc_include_tests) {
"../api:create_simulcast_test_fixture_api",
"../api:simulcast_test_fixture_api",
"../api/test/video:function_video_factory",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:video_frame_i420",
"../modules/rtp_rtcp:rtp_rtcp",
"../modules/video_capture",
@ -662,6 +663,8 @@ rtc_source_set("test_common") {
"../api/audio_codecs:builtin_audio_decoder_factory",
"../api/audio_codecs:builtin_audio_encoder_factory",
"../api/test/video:function_video_factory",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:video_bitrate_allocator_factory",
"../api/video:video_frame",
"../api/video_codecs:video_codecs_api",
"../audio",

4
test/call_test.cc
View File

@ -15,6 +15,7 @@
#include "absl/memory/memory.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_encoder_config.h"
#include "call/fake_network_pipe.h"
#include "call/rtp_transport_controller_send.h"
@ -54,6 +55,7 @@ CallTest::CallTest()
return fake_encoder;
}),
fake_decoder_factory_([]() { return absl::make_unique<FakeDecoder>(); }),
bitrate_allocator_factory_(CreateBuiltinVideoBitrateAllocatorFactory()),
num_video_streams_(1),
num_audio_streams_(0),
num_flexfec_streams_(0),
@ -233,6 +235,8 @@ void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config,
RTC_DCHECK_LE(num_video_streams + num_used_ssrcs, kNumSsrcs);
*video_config = VideoSendStream::Config(send_transport);
video_config->encoder_settings.encoder_factory = &fake_encoder_factory_;
video_config->encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
video_config->rtp.payload_name = "FAKE";
video_config->rtp.payload_type = kFakeVideoSendPayloadType;
video_config->rtp.extensions.push_back(

2
test/call_test.h
View File

@ -15,6 +15,7 @@
#include "api/test/video/function_video_decoder_factory.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "call/call.h"
#include "call/rtp_transport_controller_send.h"
#include "logging/rtc_event_log/rtc_event_log.h"
@ -205,6 +206,7 @@ class CallTest : public ::testing::Test {
test::FunctionVideoEncoderFactory fake_encoder_factory_;
int fake_encoder_max_bitrate_ = -1;
test::FunctionVideoDecoderFactory fake_decoder_factory_;
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
// Number of simulcast substreams.
size_t num_video_streams_;
size_t num_audio_streams_;

1
test/scenario/BUILD.gn
View File

@ -46,6 +46,7 @@ if (rtc_include_tests) {
"../../api/units:data_rate",
"../../api/units:time_delta",
"../../api/units:timestamp",
"../../api/video:builtin_video_bitrate_allocator_factory",
"../../api/video:video_frame",
"../../api/video:video_frame_i420",
"../../api/video_codecs:video_codecs_api",

7
test/scenario/video_stream.cc
View File

@ -13,6 +13,7 @@
#include <utility>
#include "api/test/video/function_video_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "media/base/mediaconstants.h"
#include "media/engine/internaldecoderfactory.h"
#include "media/engine/internalencoderfactory.h"
@ -213,9 +214,15 @@ SendVideoStream::SendVideoStream(CallClient* sender,
}
RTC_CHECK(encoder_factory_);
bitrate_allocator_factory_ = CreateBuiltinVideoBitrateAllocatorFactory();
RTC_CHECK(bitrate_allocator_factory_);
VideoSendStream::Config send_config =
CreateVideoSendStreamConfig(config, ssrcs_, send_transport);
send_config.encoder_settings.encoder_factory = encoder_factory_.get();
send_config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config);
send_stream_ = sender_->call_->CreateVideoSendStream(

1
test/scenario/video_stream.h
View File

@ -50,6 +50,7 @@ class SendVideoStream {
CallClient* const sender_;
const VideoStreamConfig config_;
std::unique_ptr<VideoEncoderFactory> encoder_factory_;
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
std::unique_ptr<TestVideoCapturer> video_capturer_;
FrameGeneratorCapturer* frame_generator_ = nullptr;
int next_local_network_id_ = 0;

4
video/BUILD.gn
View File

@ -154,6 +154,7 @@ rtc_source_set("video_stream_encoder_impl") {
deps = [
"../api/video:encoded_image",
"../api/video:video_bitrate_allocator",
"../api/video:video_bitrate_allocator_factory",
"../api/video:video_frame",
"../api/video:video_frame_i420",
"../api/video:video_stream_encoder",
@ -207,6 +208,8 @@ if (rtc_include_tests) {
"../api:fec_controller_api",
"../api:test_dependency_factory",
"../api:video_quality_test_fixture_api",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:video_bitrate_allocator_factory",
"../call:fake_network",
"../call:simulated_network",
"../logging:rtc_event_log_api",
@ -431,6 +434,7 @@ if (rtc_include_tests) {
"../api:fake_frame_encryptor",
"../api:simulated_network_api",
"../api/test/video:function_video_factory",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:encoded_image",
"../api/video:video_frame",
"../api/video:video_frame_i420",

6
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -9,6 +9,7 @@
*/
#include "api/test/simulated_network.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
#include "modules/rtp_rtcp/include/rtp_rtcp.h"
@ -273,6 +274,8 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
task_queue_(task_queue),
send_stream_(nullptr),
encoder_factory_(this),
bitrate_allocator_factory_(
CreateBuiltinVideoBitrateAllocatorFactory()),
bitrate_kbps_(0) {}
void OnVideoStreamsCreated(
@ -286,6 +289,8 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
RTC_DCHECK_EQ(1, encoder_config->number_of_streams);
}
@ -344,6 +349,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
rtc::CriticalSection crit_;
VideoSendStream* send_stream_;
test::VideoEncoderProxyFactory encoder_factory_;
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
uint32_t bitrate_kbps_ RTC_GUARDED_BY(crit_);
} test(&task_queue_);

5
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -16,6 +16,7 @@
#include "api/test/simulated_network.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
#include "logging/rtc_event_log/rtc_event_log.h"
@ -54,6 +55,8 @@ void MultiStreamTester::RunTest() {
test::FrameGeneratorCapturer* frame_generators[kNumStreams];
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory =
CreateBuiltinVideoBitrateAllocatorFactory();
InternalDecoderFactory decoder_factory;
task_queue_->SendTask([&]() {
@ -75,6 +78,8 @@ void MultiStreamTester::RunTest() {
VideoSendStream::Config send_config(sender_transport.get());
send_config.rtp.ssrcs.push_back(ssrc);
send_config.encoder_settings.encoder_factory = &encoder_factory;
send_config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory.get();
send_config.rtp.payload_name = "VP8";
send_config.rtp.payload_type = kVideoPayloadType;
VideoEncoderConfig encoder_config;

7
video/video_quality_test.cc
View File

@ -16,6 +16,7 @@
#include <string>
#include <vector>
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
#include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
@ -283,6 +284,8 @@ VideoQualityTest::VideoQualityTest(
[this](const SdpVideoFormat& format) {
return this->CreateVideoEncoder(format, analyzer_.get());
}),
video_bitrate_allocator_factory_(
CreateBuiltinVideoBitrateAllocatorFactory()),
receive_logs_(0),
send_logs_(0),
injection_components_(std::move(injection_components)) {
@ -613,6 +616,8 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
video_send_configs_[video_idx].encoder_settings.encoder_factory =
(video_idx == 0) ? &video_encoder_factory_with_analyzer_
: &video_encoder_factory_;
video_send_configs_[video_idx].encoder_settings.bitrate_allocator_factory =
video_bitrate_allocator_factory_.get();
video_send_configs_[video_idx].rtp.payload_name =
params_.video[video_idx].codec;
@ -801,6 +806,8 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
// TODO(nisse): Could use a simpler VP8-only encoder factory.
thumbnail_send_config.encoder_settings.encoder_factory =
&video_encoder_factory_;
thumbnail_send_config.encoder_settings.bitrate_allocator_factory =
video_bitrate_allocator_factory_.get();
thumbnail_send_config.rtp.payload_name = params_.video[0].codec;
thumbnail_send_config.rtp.payload_type = kPayloadTypeVP8;
thumbnail_send_config.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

3
video/video_quality_test.h
View File

@ -17,6 +17,7 @@
#include "api/fec_controller.h"
#include "api/test/video_quality_test_fixture.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "call/fake_network_pipe.h"
#include "media/engine/internaldecoderfactory.h"
#include "media/engine/internalencoderfactory.h"
@ -105,6 +106,8 @@ class VideoQualityTest :
InternalDecoderFactory internal_decoder_factory_;
test::FunctionVideoEncoderFactory video_encoder_factory_;
test::FunctionVideoEncoderFactory video_encoder_factory_with_analyzer_;
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory_;
InternalEncoderFactory internal_encoder_factory_;
std::vector<VideoSendStream::Config> thumbnail_send_configs_;
std::vector<VideoEncoderConfig> thumbnail_encoder_configs_;

1
video/video_send_stream.cc
View File

@ -78,6 +78,7 @@ VideoSendStream::VideoSendStream(
config_(std::move(config)),
content_type_(encoder_config.content_type) {
RTC_DCHECK(config_.encoder_settings.encoder_factory);
RTC_DCHECK(config_.encoder_settings.bitrate_allocator_factory);
video_stream_encoder_ = CreateVideoStreamEncoder(num_cpu_cores, &stats_proxy_,
config_.encoder_settings,

9
video/video_stream_encoder.cc
View File

@ -17,6 +17,8 @@
#include "api/video/encoded_image.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "common_video/include/video_frame.h"
#include "modules/video_coding/include/video_codec_initializer.h"
#include "modules/video_coding/include/video_coding.h"
#include "rtc_base/arraysize.h"
@ -534,11 +536,14 @@ void VideoStreamEncoder::ReconfigureEncoder() {
crop_height_ = last_frame_info_->height - highest_stream_height;
VideoCodec codec;
if (!VideoCodecInitializer::SetupCodec(encoder_config_, streams, &codec,
&rate_allocator_)) {
if (!VideoCodecInitializer::SetupCodec(encoder_config_, streams, &codec)) {
RTC_LOG(LS_ERROR) << "Failed to create encoder configuration.";
}
rate_allocator_ =
settings_.bitrate_allocator_factory->CreateVideoBitrateAllocator(codec);
RTC_CHECK(rate_allocator_) << "Failed to create bitrate allocator.";
// Set min_bitrate_bps, max_bitrate_bps, and max padding bit rate for VP9.
if (encoder_config_.codec_type == kVideoCodecVP9) {
RTC_DCHECK_EQ(1U, streams.size());

5
video/video_stream_encoder_unittest.cc
View File

@ -14,6 +14,7 @@
#include <limits>
#include <utility>
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/i420_buffer.h"
#include "api/video_codecs/create_vp8_temporal_layers.h"
#include "api/video_codecs/vp8_temporal_layers.h"
@ -279,6 +280,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
max_framerate_(kDefaultFramerate),
fake_encoder_(),
encoder_factory_(&fake_encoder_),
bitrate_allocator_factory_(CreateBuiltinVideoBitrateAllocatorFactory()),
stats_proxy_(new MockableSendStatisticsProxy(
Clock::GetRealTimeClock(),
video_send_config_,
@ -289,6 +291,8 @@ class VideoStreamEncoderTest : public ::testing::Test {
metrics::Reset();
video_send_config_ = VideoSendStream::Config(nullptr);
video_send_config_.encoder_settings.encoder_factory = &encoder_factory_;
video_send_config_.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
video_send_config_.rtp.payload_name = "FAKE";
video_send_config_.rtp.payload_type = 125;
@ -695,6 +699,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
int max_framerate_;
TestEncoder fake_encoder_;
test::VideoEncoderProxyFactory encoder_factory_;
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
std::unique_ptr<MockableSendStatisticsProxy> stats_proxy_;
TestSink sink_;
AdaptingFrameForwarder video_source_;