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

Remove legacy video codec factories.

Browse Source 
Removes the deprecated video codec factories and the related flag and
helper classes.

Bug: webrtc:7925
Change-Id: I0a6d1666ece9ad074fefc79b626ba241765e1b98
Reviewed-on: https://webrtc-review.googlesource.com/c/113940
Commit-Queue: Anders Carlsson <andersc@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Kári Helgason <kthelgason@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26245}
This commit is contained in:
Anders Carlsson
2019-01-14 14:23:23 +01:00
committed by Commit Bot
parent 959e9b6b57
commit 45340ca824
35 changed files with 12 additions and 1460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
BUILD.gn
View File

@ -242,10 +242,6 @@ config("common_config") {
defines += [ "ENABLE_EXTERNAL_AUTH" ] defines += [ "ENABLE_EXTERNAL_AUTH" ]
} }
if (rtc_use_builtin_sw_codecs) {
defines += [ "USE_BUILTIN_SW_CODECS" ]
}
if (build_with_chromium) { if (build_with_chromium) {
defines += [ defines += [
# NOTICE: Since common_inherited_config is used in public_configs for our # NOTICE: Since common_inherited_config is used in public_configs for our

1
api/BUILD.gn
View File

@ -47,7 +47,6 @@ rtc_source_set("callfactory_api") {
rtc_static_library("create_peerconnection_factory") { rtc_static_library("create_peerconnection_factory") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ "software_video_codecs" ]
sources = [ sources = [
"create_peerconnection_factory.cc", "create_peerconnection_factory.cc",
"create_peerconnection_factory.h", "create_peerconnection_factory.h",

117
api/create_peerconnection_factory.cc
View File

@ -33,89 +33,6 @@
namespace webrtc { namespace webrtc {
#if defined(USE_BUILTIN_SW_CODECS)
rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory) {
return CreatePeerConnectionFactoryWithAudioMixer(
nullptr /*network_thread*/, nullptr /*worker_thread*/,
nullptr /*signaling_thread*/, nullptr /*default_adm*/,
audio_encoder_factory, audio_decoder_factory,
nullptr /*video_encoder_factory*/, nullptr /*video_decoder_factory*/,
nullptr /*audio_mixer*/);
}
// Note: all the other CreatePeerConnectionFactory variants just end up calling
// this, ultimately.
rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processing) {
rtc::scoped_refptr<AudioProcessing> audio_processing_use = audio_processing;
if (!audio_processing_use) {
audio_processing_use = AudioProcessingBuilder().Create();
}
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,
audio_processing_use));
std::unique_ptr<CallFactoryInterface> call_factory = CreateCallFactory();
std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory =
CreateRtcEventLogFactory();
return CreateModularPeerConnectionFactory(
network_thread, worker_thread, signaling_thread, std::move(media_engine),
std::move(call_factory), std::move(event_log_factory));
}
rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processing,
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory,
std::unique_ptr<NetworkControllerFactoryInterface>
network_controller_factory) {
rtc::scoped_refptr<AudioProcessing> audio_processing_use = audio_processing;
if (!audio_processing_use) {
audio_processing_use = AudioProcessingBuilder().Create();
}
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,
audio_processing_use));
std::unique_ptr<CallFactoryInterface> call_factory = CreateCallFactory();
std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory =
CreateRtcEventLogFactory();
return CreateModularPeerConnectionFactory(
network_thread, worker_thread, signaling_thread, std::move(media_engine),
std::move(call_factory), std::move(event_log_factory),
std::move(fec_controller_factory), std::move(network_controller_factory));
}
#endif
rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory( rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
rtc::Thread* network_thread, rtc::Thread* network_thread,
rtc::Thread* worker_thread, rtc::Thread* worker_thread,
@ -150,38 +67,4 @@ rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
return CreateModularPeerConnectionFactory(std::move(dependencies)); return CreateModularPeerConnectionFactory(std::move(dependencies));
} }
#if defined(USE_BUILTIN_SW_CODECS)
rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactoryWithAudioMixer(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer) {
return CreatePeerConnectionFactory(
network_thread, worker_thread, signaling_thread, default_adm,
audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
video_decoder_factory, audio_mixer, nullptr);
}
rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory) {
return CreatePeerConnectionFactoryWithAudioMixer(
network_thread, worker_thread, signaling_thread, default_adm,
audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
video_decoder_factory, nullptr);
}
#endif
} // namespace webrtc } // namespace webrtc

126
api/create_peerconnection_factory.h
View File

@ -29,104 +29,14 @@ namespace rtc {
class Thread; class Thread;
} // namespace rtc } // namespace rtc
namespace cricket {
class WebRtcVideoDecoderFactory;
class WebRtcVideoEncoderFactory;
} // namespace cricket
namespace webrtc { namespace webrtc {
class AudioDeviceModule; class AudioDeviceModule;
class AudioProcessing; class AudioProcessing;
#if defined(USE_BUILTIN_SW_CODECS)
// Create a new instance of PeerConnectionFactoryInterface.
//
// This method relies on the thread it's called on as the "signaling thread"
// for the PeerConnectionFactory it creates.
//
// As such, if the current thread is not already running an rtc::Thread message
// loop, an application using this method must eventually either call
// rtc::Thread::Current()->Run(), or call
// rtc::Thread::Current()->ProcessMessages() within the application's own
// message loop.
RTC_DEPRECATED RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactory(
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory);
// Create a new instance of PeerConnectionFactoryInterface.
//
// |network_thread|, |worker_thread| and |signaling_thread| are
// the only mandatory parameters.
//
// If non-null, a reference is added to |default_adm|, and ownership of
// |video_encoder_factory| and |video_decoder_factory| is transferred to the
// returned factory.
// TODO(deadbeef): Use rtc::scoped_refptr<> and std::unique_ptr<> to make this
// ownership transfer and ref counting more obvious.
RTC_DEPRECATED RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactory(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory);
// Create a new instance of PeerConnectionFactoryInterface with optional
// external audio mixed and audio processing modules.
//
// If |audio_mixer| is null, an internal audio mixer will be created and used.
// If |audio_processing| is null, an internal audio processing module will be
// created and used.
RTC_DEPRECATED RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactory(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processing);
// Create a new instance of PeerConnectionFactoryInterface with optional
// external audio mixer, audio processing, and fec controller modules.
//
// If |audio_mixer| is null, an internal audio mixer will be created and used.
// If |audio_processing| is null, an internal audio processing module will be
// created and used.
// If |fec_controller_factory| is null, an internal fec controller module will
// be created and used.
// If |network_controller_factory| is provided, it will be used if enabled via
// field trial.
RTC_DEPRECATED RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactory(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processing,
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory,
std::unique_ptr<NetworkControllerFactoryInterface>
network_controller_factory = nullptr);
#endif // defined(USE_BUILTIN_SW_CODECS)
// Create a new instance of PeerConnectionFactoryInterface with optional video // Create a new instance of PeerConnectionFactoryInterface with optional video
// codec factories. These video factories represents all video codecs, i.e. no // codec factories. These video factories represents all video codecs, i.e. no
// extra internal video codecs will be added. // extra internal video codecs will be added.
// When building WebRTC with rtc_use_builtin_sw_codecs = false, this is the
// only available CreatePeerConnectionFactory overload.
RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface> RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactory( CreatePeerConnectionFactory(
rtc::Thread* network_thread, rtc::Thread* network_thread,
@ -140,42 +50,6 @@ CreatePeerConnectionFactory(
rtc::scoped_refptr<AudioMixer> audio_mixer, rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processing); rtc::scoped_refptr<AudioProcessing> audio_processing);
#if defined(USE_BUILTIN_SW_CODECS)
// Create a new instance of PeerConnectionFactoryInterface with external audio
// mixer.
//
// If |audio_mixer| is null, an internal audio mixer will be created and used.
RTC_DEPRECATED RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactoryWithAudioMixer(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer);
// Create a new instance of PeerConnectionFactoryInterface.
// Same thread is used as worker and network thread.
RTC_DEPRECATED
RTC_EXPORT inline rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactory(
rtc::Thread* worker_and_network_thread,
rtc::Thread* signaling_thread,
AudioDeviceModule* default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory) {
return CreatePeerConnectionFactory(
worker_and_network_thread, worker_and_network_thread, signaling_thread,
default_adm, audio_encoder_factory, audio_decoder_factory,
video_encoder_factory, video_decoder_factory);
}
#endif // defined(USE_BUILTIN_SW_CODECS)
} // namespace webrtc } // namespace webrtc
#endif // API_CREATE_PEERCONNECTION_FACTORY_H_ #endif // API_CREATE_PEERCONNECTION_FACTORY_H_

5
api/peer_connection_interface.h
View File

@ -120,11 +120,6 @@ class SSLIdentity;
class Thread; class Thread;
} // namespace rtc } // namespace rtc
namespace cricket {
class WebRtcVideoDecoderFactory;
class WebRtcVideoEncoderFactory;
} // namespace cricket
namespace webrtc { namespace webrtc {
class AudioDeviceModule; class AudioDeviceModule;
class AudioMixer; class AudioMixer;

1
api/video/BUILD.gn
View File

@ -188,7 +188,6 @@ rtc_source_set("video_stream_encoder") {
rtc_source_set("video_stream_encoder_create") { rtc_source_set("video_stream_encoder_create") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ "software_video_codecs" ] # TODO(bugs.webrtc.org/7925): Remove.
sources = [ sources = [
"video_stream_encoder_create.cc", "video_stream_encoder_create.cc",
"video_stream_encoder_create.h", "video_stream_encoder_create.h",

2
examples/unityplugin/simple_peer_connection.cc
View File

@ -20,8 +20,6 @@
#include "media/engine/internal_decoder_factory.h" #include "media/engine/internal_decoder_factory.h"
#include "media/engine/internal_encoder_factory.h" #include "media/engine/internal_encoder_factory.h"
#include "media/engine/multiplex_codec_factory.h" #include "media/engine/multiplex_codec_factory.h"
#include "media/engine/webrtc_video_decoder_factory.h"
#include "media/engine/webrtc_video_encoder_factory.h"
#include "modules/audio_device/include/audio_device.h" #include "modules/audio_device/include/audio_device.h"
#include "modules/audio_processing/include/audio_processing.h" #include "modules/audio_processing/include/audio_processing.h"
#include "modules/video_capture/video_capture_factory.h" #include "modules/video_capture/video_capture_factory.h"

32
media/BUILD.gn
View File

@ -248,8 +248,6 @@ rtc_static_library("rtc_internal_video_codecs") {
"//third_party/abseil-cpp/absl/memory", "//third_party/abseil-cpp/absl/memory",
] ]
sources = [ sources = [
"engine/convert_legacy_video_factory.cc",
"engine/convert_legacy_video_factory.h",
"engine/internal_decoder_factory.cc", "engine/internal_decoder_factory.cc",
"engine/internal_decoder_factory.h", "engine/internal_decoder_factory.h",
"engine/internal_encoder_factory.cc", "engine/internal_encoder_factory.cc",
@ -259,20 +257,10 @@ rtc_static_library("rtc_internal_video_codecs") {
"engine/multiplex_codec_factory.cc", "engine/multiplex_codec_factory.cc",
"engine/multiplex_codec_factory.h", "engine/multiplex_codec_factory.h",
"engine/multiplexcodecfactory.h", "engine/multiplexcodecfactory.h",
"engine/scoped_video_decoder.cc",
"engine/scoped_video_decoder.h",
"engine/scoped_video_encoder.cc",
"engine/scoped_video_encoder.h",
"engine/scopedvideodecoder.h",
"engine/scopedvideoencoder.h",
# TODO(bugs.webrtc.org/7925): stop exporting this header once downstream # TODO(bugs.webrtc.org/7925): stop exporting this header once downstream
# targets depend on :rtc_encoder_simulcast_proxy directly. # targets depend on :rtc_encoder_simulcast_proxy directly.
"engine/encoder_simulcast_proxy.h", "engine/encoder_simulcast_proxy.h",
"engine/webrtc_video_decoder_factory.h",
"engine/webrtc_video_encoder_factory.h",
"engine/webrtcvideodecoderfactory.h",
"engine/webrtcvideoencoderfactory.h",
] ]
if (!build_with_chromium && is_clang) { if (!build_with_chromium && is_clang) {
@ -306,10 +294,7 @@ rtc_static_library("rtc_internal_video_codecs") {
rtc_static_library("rtc_audio_video") { rtc_static_library("rtc_audio_video") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
defines = [] defines = []
libs = [] libs = []
deps = [ deps = [
@ -342,17 +327,11 @@ rtc_static_library("rtc_audio_video") {
"engine/simulcast.h", "engine/simulcast.h",
"engine/webrtc_media_engine.cc", "engine/webrtc_media_engine.cc",
"engine/webrtc_media_engine.h", "engine/webrtc_media_engine.h",
"engine/webrtc_video_decoder_factory.cc",
"engine/webrtc_video_decoder_factory.h",
"engine/webrtc_video_encoder_factory.cc",
"engine/webrtc_video_encoder_factory.h",
"engine/webrtc_video_engine.cc", "engine/webrtc_video_engine.cc",
"engine/webrtc_video_engine.h", "engine/webrtc_video_engine.h",
"engine/webrtc_voice_engine.cc", "engine/webrtc_voice_engine.cc",
"engine/webrtc_voice_engine.h", "engine/webrtc_voice_engine.h",
"engine/webrtcmediaengine.h", "engine/webrtcmediaengine.h",
"engine/webrtcvideodecoderfactory.h",
"engine/webrtcvideoencoderfactory.h",
"engine/webrtcvideoengine.h", "engine/webrtcvideoengine.h",
"engine/webrtcvoiceengine.h", "engine/webrtcvoiceengine.h",
] ]
@ -382,9 +361,6 @@ rtc_static_library("rtc_audio_video") {
} else { } else {
deps += [ "../modules/audio_processing/aec_dump:null_aec_dump_factory" ] deps += [ "../modules/audio_processing/aec_dump:null_aec_dump_factory" ]
} }
if (rtc_use_builtin_sw_codecs) {
deps += [ ":rtc_internal_video_codecs" ]
}
deps += [ deps += [
":rtc_constants", ":rtc_constants",
":rtc_media_base", ":rtc_media_base",
@ -467,10 +443,7 @@ rtc_static_library("rtc_data") {
rtc_source_set("rtc_media") { rtc_source_set("rtc_media") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
deps = [ deps = [
":rtc_audio_video", ":rtc_audio_video",
":rtc_data", ":rtc_data",
@ -634,7 +607,6 @@ if (rtc_include_tests) {
"engine/simulcast_encoder_adapter_unittest.cc", "engine/simulcast_encoder_adapter_unittest.cc",
"engine/simulcast_unittest.cc", "engine/simulcast_unittest.cc",
"engine/webrtc_media_engine_unittest.cc", "engine/webrtc_media_engine_unittest.cc",
"engine/webrtc_video_encoder_factory_unittest.cc",
"engine/webrtc_video_engine_unittest.cc", "engine/webrtc_video_engine_unittest.cc",
] ]

297
media/engine/convert_legacy_video_factory.cc
View File

@ -1,297 +0,0 @@
/*
* Copyright (c) 2017 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.
*/
#include "media/engine/convert_legacy_video_factory.h"
#include <string>
#include <utility>
#include <vector>
#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "api/video_codecs/sdp_video_format.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_decoder.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_decoder_software_fallback_wrapper.h"
#include "api/video_codecs/video_encoder.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "api/video_codecs/video_encoder_software_fallback_wrapper.h"
#include "media/base/codec.h"
#include "media/base/media_constants.h"
#include "media/engine/encoder_simulcast_proxy.h"
#include "media/engine/internal_decoder_factory.h"
#include "media/engine/internal_encoder_factory.h"
#include "media/engine/scoped_video_decoder.h"
#include "media/engine/scoped_video_encoder.h"
#include "media/engine/simulcast_encoder_adapter.h"
#include "media/engine/webrtc_video_decoder_factory.h"
#include "media/engine/webrtc_video_encoder_factory.h"
#include "rtc_base/checks.h"
namespace cricket {
namespace {
bool IsFormatSupported(
const std::vector<webrtc::SdpVideoFormat>& supported_formats,
const webrtc::SdpVideoFormat& format) {
for (const webrtc::SdpVideoFormat& supported_format : supported_formats) {
if (IsSameCodec(format.name, format.parameters, supported_format.name,
supported_format.parameters)) {
return true;
}
}
return false;
}
// Converts the cricket::WebRtcVideoEncoderFactory to a
// webrtc::VideoEncoderFactory (without adding any simulcast or SW fallback).
class CricketToWebRtcEncoderFactory : public webrtc::VideoEncoderFactory {
public:
explicit CricketToWebRtcEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory)
: external_encoder_factory_(std::move(external_encoder_factory)) {}
webrtc::VideoEncoderFactory::CodecInfo QueryVideoEncoder(
const webrtc::SdpVideoFormat& format) const override {
CodecInfo info;
info.has_internal_source = false;
info.is_hardware_accelerated = false;
if (!external_encoder_factory_)
return info;
info.has_internal_source =
external_encoder_factory_->EncoderTypeHasInternalSource(
webrtc::PayloadStringToCodecType(format.name));
info.is_hardware_accelerated = true;
return info;
}
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
if (!external_encoder_factory_)
return std::vector<webrtc::SdpVideoFormat>();
std::vector<webrtc::SdpVideoFormat> formats;
for (const VideoCodec& codec :
external_encoder_factory_->supported_codecs()) {
formats.push_back(webrtc::SdpVideoFormat(codec.name, codec.params));
}
return formats;
}
std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(
const webrtc::SdpVideoFormat& format) override {
return DEPRECATED_CreateScopedVideoEncoder(external_encoder_factory_.get(),
VideoCodec(format));
}
private:
const std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory_;
};
// This class combines an external factory with the internal factory and adds
// internal SW codecs, simulcast, and SW fallback wrappers.
class EncoderAdapter : public webrtc::VideoEncoderFactory {
public:
explicit EncoderAdapter(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory)
: internal_encoder_factory_(new webrtc::InternalEncoderFactory()),
external_encoder_factory_(
absl::make_unique<CricketToWebRtcEncoderFactory>(
std::move(external_encoder_factory))) {}
explicit EncoderAdapter(
std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory)
: internal_encoder_factory_(new webrtc::InternalEncoderFactory()),
external_encoder_factory_(std::move(external_encoder_factory)) {}
webrtc::VideoEncoderFactory::CodecInfo QueryVideoEncoder(
const webrtc::SdpVideoFormat& format) const override {
if (IsFormatSupported(external_encoder_factory_->GetSupportedFormats(),
format)) {
return external_encoder_factory_->QueryVideoEncoder(format);
}
// Format must be one of the internal formats.
RTC_DCHECK(IsFormatSupported(
internal_encoder_factory_->GetSupportedFormats(), format));
webrtc::VideoEncoderFactory::CodecInfo info;
info.has_internal_source = false;
info.is_hardware_accelerated = false;
return info;
}
std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(
const webrtc::SdpVideoFormat& format) override {
// Try creating internal encoder.
std::unique_ptr<webrtc::VideoEncoder> internal_encoder;
if (IsFormatSupported(internal_encoder_factory_->GetSupportedFormats(),
format)) {
internal_encoder =
absl::EqualsIgnoreCase(format.name, kVp8CodecName)
? absl::make_unique<webrtc::EncoderSimulcastProxy>(
internal_encoder_factory_.get(), format)
: internal_encoder_factory_->CreateVideoEncoder(format);
}
// Try creating external encoder.
std::unique_ptr<webrtc::VideoEncoder> external_encoder;
if (IsFormatSupported(external_encoder_factory_->GetSupportedFormats(),
format)) {
external_encoder =
absl::EqualsIgnoreCase(format.name, kVp8CodecName)
? absl::make_unique<webrtc::SimulcastEncoderAdapter>(
external_encoder_factory_.get(), format)
: external_encoder_factory_->CreateVideoEncoder(format);
}
if (internal_encoder && external_encoder) {
// Both internal SW encoder and external HW encoder available - create
// fallback encoder.
return webrtc::CreateVideoEncoderSoftwareFallbackWrapper(
std::move(internal_encoder), std::move(external_encoder));
}
return external_encoder ? std::move(external_encoder)
: std::move(internal_encoder);
}
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
std::vector<webrtc::SdpVideoFormat> formats =
internal_encoder_factory_->GetSupportedFormats();
// Add external codecs.
for (const webrtc::SdpVideoFormat& format :
external_encoder_factory_->GetSupportedFormats()) {
// Don't add same codec twice.
if (!IsFormatSupported(formats, format))
formats.push_back(format);
}
return formats;
}
private:
const std::unique_ptr<webrtc::VideoEncoderFactory> internal_encoder_factory_;
const std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory_;
};
// Converts the cricket::WebRtcVideoDecoderFactory to a
// webrtc::VideoDecoderFactory (without adding any SW fallback).
class CricketToWebRtcDecoderFactory : public webrtc::VideoDecoderFactory {
public:
explicit CricketToWebRtcDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory)
: external_decoder_factory_(std::move(external_decoder_factory)) {}
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const webrtc::SdpVideoFormat& format) override {
return LegacyCreateVideoDecoder(format, /* receive_stream_id= */ "");
}
std::unique_ptr<webrtc::VideoDecoder> LegacyCreateVideoDecoder(
const webrtc::SdpVideoFormat& format,
const std::string& receive_stream_id) override {
if (external_decoder_factory_ != nullptr) {
return DEPRECATED_CreateScopedVideoDecoder(
external_decoder_factory_.get(), VideoCodec(format),
{receive_stream_id});
}
return nullptr;
}
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
// This is not implemented for the legacy decoder factory.
RTC_NOTREACHED();
return std::vector<webrtc::SdpVideoFormat>();
}
private:
const std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory_;
};
// This class combines an external factory with the internal factory and adds
// internal SW codecs and SW fallback wrappers.
class DecoderAdapter : public webrtc::VideoDecoderFactory {
public:
explicit DecoderAdapter(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory)
: internal_decoder_factory_(new webrtc::InternalDecoderFactory()),
external_decoder_factory_(
absl::make_unique<CricketToWebRtcDecoderFactory>(
std::move(external_decoder_factory))) {}
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const webrtc::SdpVideoFormat& format) override {
return LegacyCreateVideoDecoder(format, /* receive_stream_id= */ "");
}
std::unique_ptr<webrtc::VideoDecoder> LegacyCreateVideoDecoder(
const webrtc::SdpVideoFormat& format,
const std::string& receive_stream_id) override {
std::unique_ptr<webrtc::VideoDecoder> internal_decoder;
if (IsFormatSupported(internal_decoder_factory_->GetSupportedFormats(),
format)) {
internal_decoder = internal_decoder_factory_->CreateVideoDecoder(format);
}
std::unique_ptr<webrtc::VideoDecoder> external_decoder = nullptr;
if (external_decoder_factory_ != nullptr) {
external_decoder = external_decoder_factory_->LegacyCreateVideoDecoder(
format, receive_stream_id);
}
if (internal_decoder && external_decoder) {
// Both internal SW decoder and external HW decoder available - create
// fallback decoder.
return webrtc::CreateVideoDecoderSoftwareFallbackWrapper(
std::move(internal_decoder), std::move(external_decoder));
}
return external_decoder ? std::move(external_decoder)
: std::move(internal_decoder);
}
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
std::vector<webrtc::SdpVideoFormat> formats =
internal_decoder_factory_->GetSupportedFormats();
// Add external codecs.
for (const webrtc::SdpVideoFormat& format :
external_decoder_factory_->GetSupportedFormats()) {
// Don't add same codec twice.
if (!IsFormatSupported(formats, format))
formats.push_back(format);
}
return formats;
}
private:
const std::unique_ptr<webrtc::VideoDecoderFactory> internal_decoder_factory_;
const std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory_;
};
} // namespace
std::unique_ptr<webrtc::VideoEncoderFactory>
DEPRECATED_ConvertVideoEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory) {
return std::unique_ptr<webrtc::VideoEncoderFactory>(
new EncoderAdapter(std::move(external_encoder_factory)));
}
std::unique_ptr<webrtc::VideoDecoderFactory>
DEPRECATED_ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory) {
return std::unique_ptr<webrtc::VideoDecoderFactory>(
new DecoderAdapter(std::move(external_decoder_factory)));
}
} // namespace cricket

57
media/engine/convert_legacy_video_factory.h
View File

@ -1,57 +0,0 @@
/*
* Copyright (c) 2017 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_CONVERT_LEGACY_VIDEO_FACTORY_H_
#define MEDIA_ENGINE_CONVERT_LEGACY_VIDEO_FACTORY_H_
#include <memory>
#include <utility>
#include "media/engine/webrtc_video_decoder_factory.h"
#include "media/engine/webrtc_video_encoder_factory.h"
#include "rtc_base/deprecation.h"
#include "rtc_base/system/rtc_export.h"
namespace webrtc {
class VideoEncoderFactory;
class VideoDecoderFactory;
} // namespace webrtc
namespace cricket {
RTC_EXPORT std::unique_ptr<webrtc::VideoEncoderFactory>
DEPRECATED_ConvertVideoEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory);
RTC_EXPORT std::unique_ptr<webrtc::VideoDecoderFactory>
DEPRECATED_ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory);
// Adds internal SW codecs, simulcast, SW fallback wrappers, and converts to the
// new type of codec factories. The purpose of these functions is to provide an
// easy way for clients to migrate to the API with new factory types.
// TODO(magjed): Remove once old factories are gone, webrtc:7925.
RTC_DEPRECATED RTC_EXPORT inline std::unique_ptr<webrtc::VideoEncoderFactory>
ConvertVideoEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory) {
return DEPRECATED_ConvertVideoEncoderFactory(
std::move(external_encoder_factory));
}
RTC_DEPRECATED RTC_EXPORT inline std::unique_ptr<webrtc::VideoDecoderFactory>
ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory) {
return DEPRECATED_ConvertVideoDecoderFactory(
std::move(external_decoder_factory));
}
} // namespace cricket
#endif // MEDIA_ENGINE_CONVERT_LEGACY_VIDEO_FACTORY_H_

1
media/engine/encoder_simulcast_proxy_unittest.cc
View File

@ -14,7 +14,6 @@
#include "api/test/mock_video_encoder_factory.h" #include "api/test/mock_video_encoder_factory.h"
#include "api/video_codecs/vp8_temporal_layers.h" #include "api/video_codecs/vp8_temporal_layers.h"
#include "media/engine/webrtc_video_encoder_factory.h"
#include "modules/video_coding/include/video_codec_interface.h" #include "modules/video_coding/include/video_codec_interface.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"

2
media/engine/null_webrtc_video_engine.h
View File

@ -25,8 +25,6 @@ class Call;
namespace cricket { namespace cricket {
class VideoMediaChannel; class VideoMediaChannel;
class WebRtcVideoDecoderFactory;
class WebRtcVideoEncoderFactory;
// Video engine implementation that does nothing and can be used in // Video engine implementation that does nothing and can be used in
// CompositeMediaEngine. // CompositeMediaEngine.

100
media/engine/scoped_video_decoder.cc
View File

@ -1,100 +0,0 @@
/*
* Copyright (c) 2017 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.
*/
#include "media/engine/scoped_video_decoder.h"
#include <stdint.h>
#include "api/video/encoded_image.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_decoder.h"
namespace cricket {
namespace {
class ScopedVideoDecoder : public webrtc::VideoDecoder {
public:
ScopedVideoDecoder(WebRtcVideoDecoderFactory* factory,
webrtc::VideoDecoder* decoder);
int32_t InitDecode(const webrtc::VideoCodec* codec_settings,
int32_t number_of_cores) override;
int32_t RegisterDecodeCompleteCallback(
webrtc::DecodedImageCallback* callback) override;
int32_t Release() override;
int32_t Decode(const webrtc::EncodedImage& input_image,
bool missing_frames,
const webrtc::CodecSpecificInfo* codec_specific_info,
int64_t render_time_ms) override;
bool PrefersLateDecoding() const override;
const char* ImplementationName() const override;
~ScopedVideoDecoder() override;
private:
WebRtcVideoDecoderFactory* factory_;
webrtc::VideoDecoder* decoder_;
};
ScopedVideoDecoder::ScopedVideoDecoder(WebRtcVideoDecoderFactory* factory,
webrtc::VideoDecoder* decoder)
: factory_(factory), decoder_(decoder) {}
int32_t ScopedVideoDecoder::InitDecode(const webrtc::VideoCodec* codec_settings,
int32_t number_of_cores) {
return decoder_->InitDecode(codec_settings, number_of_cores);
}
int32_t ScopedVideoDecoder::RegisterDecodeCompleteCallback(
webrtc::DecodedImageCallback* callback) {
return decoder_->RegisterDecodeCompleteCallback(callback);
}
int32_t ScopedVideoDecoder::Release() {
return decoder_->Release();
}
int32_t ScopedVideoDecoder::Decode(
const webrtc::EncodedImage& input_image,
bool missing_frames,
const webrtc::CodecSpecificInfo* codec_specific_info,
int64_t render_time_ms) {
return decoder_->Decode(input_image, missing_frames, codec_specific_info,
render_time_ms);
}
bool ScopedVideoDecoder::PrefersLateDecoding() const {
return decoder_->PrefersLateDecoding();
}
const char* ScopedVideoDecoder::ImplementationName() const {
return decoder_->ImplementationName();
}
ScopedVideoDecoder::~ScopedVideoDecoder() {
factory_->DestroyVideoDecoder(decoder_);
}
} // namespace
std::unique_ptr<webrtc::VideoDecoder> DEPRECATED_CreateScopedVideoDecoder(
WebRtcVideoDecoderFactory* factory,
const VideoCodec& codec,
VideoDecoderParams params) {
webrtc::VideoDecoder* decoder =
factory->CreateVideoDecoderWithParams(codec, params);
if (!decoder)
return nullptr;
return std::unique_ptr<webrtc::VideoDecoder>(
new ScopedVideoDecoder(factory, decoder));
}
} // namespace cricket

44
media/engine/scoped_video_decoder.h
View File

@ -1,44 +0,0 @@
/*
* Copyright (c) 2017 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_SCOPED_VIDEO_DECODER_H_
#define MEDIA_ENGINE_SCOPED_VIDEO_DECODER_H_
#include <memory>
#include "api/video_codecs/video_decoder.h"
#include "media/base/codec.h"
#include "media/engine/webrtc_video_decoder_factory.h"
#include "rtc_base/deprecation.h"
namespace cricket {
std::unique_ptr<webrtc::VideoDecoder> DEPRECATED_CreateScopedVideoDecoder(
cricket::WebRtcVideoDecoderFactory* factory,
const VideoCodec& codec,
VideoDecoderParams params);
// Helper function that creates a webrtc::VideoDecoder held by an
// std::unique_ptr instead of having to be deleted through
// WebRtcVideoDecoderFactory::DestroyVideoDecoder. The factory passed in must
// outlive the returned encoder.
// TODO(andersc): This helper function will be deleted once
// cricket::WebRtcVideoDecoderFactory is deprecated, see
// https://bugs.chromium.org/p/webrtc/issues/detail?id=7925 for more info.
RTC_DEPRECATED inline std::unique_ptr<webrtc::VideoDecoder>
CreateScopedVideoDecoder(cricket::WebRtcVideoDecoderFactory* factory,
const VideoCodec& codec,
VideoDecoderParams params) {
return DEPRECATED_CreateScopedVideoDecoder(factory, codec, params);
}
} // namespace cricket
#endif // MEDIA_ENGINE_SCOPED_VIDEO_DECODER_H_

109
media/engine/scoped_video_encoder.cc
View File

@ -1,109 +0,0 @@
/*
* Copyright (c) 2017 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.
*/
#include "media/engine/scoped_video_encoder.h"
#include <stddef.h>
#include <stdint.h>
#include <vector>
#include "api/video/video_bitrate_allocation.h"
#include "api/video/video_frame.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_encoder.h"
#include "common_types.h" // NOLINT(build/include)
namespace cricket {
namespace {
class ScopedVideoEncoder : public webrtc::VideoEncoder {
public:
ScopedVideoEncoder(WebRtcVideoEncoderFactory* factory,
webrtc::VideoEncoder* encoder);
int32_t InitEncode(const webrtc::VideoCodec* codec_settings,
int32_t number_of_cores,
size_t max_payload_size) override;
int32_t RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback) override;
int32_t Release() override;
int32_t Encode(const webrtc::VideoFrame& frame,
const webrtc::CodecSpecificInfo* codec_specific_info,
const std::vector<webrtc::FrameType>* frame_types) override;
int32_t SetRates(uint32_t bitrate, uint32_t framerate) override;
int32_t SetRateAllocation(const webrtc::VideoBitrateAllocation& allocation,
uint32_t framerate) override;
EncoderInfo GetEncoderInfo() const override;
~ScopedVideoEncoder() override;
private:
WebRtcVideoEncoderFactory* factory_;
webrtc::VideoEncoder* encoder_;
};
ScopedVideoEncoder::ScopedVideoEncoder(WebRtcVideoEncoderFactory* factory,
webrtc::VideoEncoder* encoder)
: factory_(factory), encoder_(encoder) {}
int32_t ScopedVideoEncoder::InitEncode(const webrtc::VideoCodec* codec_settings,
int32_t number_of_cores,
size_t max_payload_size) {
return encoder_->InitEncode(codec_settings, number_of_cores,
max_payload_size);
}
int32_t ScopedVideoEncoder::RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback) {
return encoder_->RegisterEncodeCompleteCallback(callback);
}
int32_t ScopedVideoEncoder::Release() {
return encoder_->Release();
}
int32_t ScopedVideoEncoder::Encode(
const webrtc::VideoFrame& frame,
const webrtc::CodecSpecificInfo* codec_specific_info,
const std::vector<webrtc::FrameType>* frame_types) {
return encoder_->Encode(frame, codec_specific_info, frame_types);
}
int32_t ScopedVideoEncoder::SetRates(uint32_t bitrate, uint32_t framerate) {
return encoder_->SetRates(bitrate, framerate);
}
int32_t ScopedVideoEncoder::SetRateAllocation(
const webrtc::VideoBitrateAllocation& allocation,
uint32_t framerate) {
return encoder_->SetRateAllocation(allocation, framerate);
}
webrtc::VideoEncoder::EncoderInfo ScopedVideoEncoder::GetEncoderInfo() const {
return encoder_->GetEncoderInfo();
}
ScopedVideoEncoder::~ScopedVideoEncoder() {
factory_->DestroyVideoEncoder(encoder_);
}
} // namespace
std::unique_ptr<webrtc::VideoEncoder> DEPRECATED_CreateScopedVideoEncoder(
WebRtcVideoEncoderFactory* factory,
const VideoCodec& codec) {
webrtc::VideoEncoder* encoder = factory->CreateVideoEncoder(codec);
if (!encoder)
return nullptr;
return std::unique_ptr<webrtc::VideoEncoder>(
new ScopedVideoEncoder(factory, encoder));
}
} // namespace cricket

42
media/engine/scoped_video_encoder.h
View File

@ -1,42 +0,0 @@
/*
* Copyright (c) 2017 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_SCOPED_VIDEO_ENCODER_H_
#define MEDIA_ENGINE_SCOPED_VIDEO_ENCODER_H_
#include <memory>
#include "api/video_codecs/video_encoder.h"
#include "media/base/codec.h"
#include "media/engine/webrtc_video_encoder_factory.h"
#include "rtc_base/deprecation.h"
namespace cricket {
std::unique_ptr<webrtc::VideoEncoder> DEPRECATED_CreateScopedVideoEncoder(
cricket::WebRtcVideoEncoderFactory* factory,
const VideoCodec& codec);
// Helper function that creates a webrtc::VideoEncoder held by an
// std::unique_ptr instead of having to be deleted through
// WebRtcVideoEncoderFactory::DestroyVideoEncoder. The factory passed in must
// outlive the returned encoder.
// TODO(magjed): This helper function will be deleted once
// cricket::WebRtcVideoEncoderFactory is deprecated, see
// https://bugs.chromium.org/p/webrtc/issues/detail?id=7925 for more info.
RTC_DEPRECATED inline std::unique_ptr<webrtc::VideoEncoder>
CreateScopedVideoEncoder(cricket::WebRtcVideoEncoderFactory* factory,
const VideoCodec& codec) {
return DEPRECATED_CreateScopedVideoEncoder(factory, codec);
}
} // namespace cricket
#endif // MEDIA_ENGINE_SCOPED_VIDEO_ENCODER_H_

19
media/engine/scopedvideodecoder.h
View File

@ -1,19 +0,0 @@
/*
* Copyright 2019 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_SCOPEDVIDEODECODER_H_
#define MEDIA_ENGINE_SCOPEDVIDEODECODER_H_
// TODO(bugs.webrtc.org/10159): Remove this files once downstream projects have
// been updated to include the new path.
#include "media/engine/scoped_video_decoder.h"
#endif // MEDIA_ENGINE_SCOPEDVIDEODECODER_H_

19
media/engine/scopedvideoencoder.h
View File

@ -1,19 +0,0 @@
/*
* Copyright 2019 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_SCOPEDVIDEOENCODER_H_
#define MEDIA_ENGINE_SCOPEDVIDEOENCODER_H_
// TODO(bugs.webrtc.org/10159): Remove this files once downstream projects have
// been updated to include the new path.
#include "media/engine/scoped_video_encoder.h"
#endif // MEDIA_ENGINE_SCOPEDVIDEOENCODER_H_

105
media/engine/webrtc_media_engine.cc
View File

@ -19,10 +19,6 @@
#include "api/video_codecs/video_encoder_factory.h" #include "api/video_codecs/video_encoder_factory.h"
#include "media/engine/webrtc_voice_engine.h" #include "media/engine/webrtc_voice_engine.h"
#if defined(USE_BUILTIN_SW_CODECS)
#include "media/engine/convert_legacy_video_factory.h"
#endif
#ifdef HAVE_WEBRTC_VIDEO #ifdef HAVE_WEBRTC_VIDEO
#include "media/engine/webrtc_video_engine.h" #include "media/engine/webrtc_video_engine.h"
#else #else
@ -31,107 +27,6 @@
namespace cricket { namespace cricket {
#if defined(USE_BUILTIN_SW_CODECS)
namespace {
MediaEngineInterface* CreateWebRtcMediaEngine(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
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) {
std::unique_ptr<VideoEngineInterface> video_engine;
#ifdef HAVE_WEBRTC_VIDEO
video_engine = absl::make_unique<WebRtcVideoEngine>(
DEPRECATED_ConvertVideoEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory>(video_encoder_factory)),
DEPRECATED_ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory>(video_decoder_factory)),
std::move(video_bitrate_allocator_factory));
#else
video_engine = absl::make_unique<NullWebRtcVideoEngine>();
#endif
return new CompositeMediaEngine(
absl::make_unique<WebRtcVoiceEngine>(adm, audio_encoder_factory,
audio_decoder_factory, audio_mixer,
audio_processing),
std::move(video_engine));
}
} // namespace
MediaEngineInterface* WebRtcMediaEngineFactory::Create(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory) {
return WebRtcMediaEngineFactory::Create(
adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
video_decoder_factory,
webrtc::CreateBuiltinVideoBitrateAllocatorFactory());
}
MediaEngineInterface* WebRtcMediaEngineFactory::Create(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
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(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing) {
return WebRtcMediaEngineFactory::Create(
adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
video_decoder_factory,
webrtc::CreateBuiltinVideoBitrateAllocatorFactory(), audio_mixer,
audio_processing);
}
MediaEngineInterface* WebRtcMediaEngineFactory::Create(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
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, std::move(video_bitrate_allocator_factory),
audio_mixer, audio_processing);
}
#endif
std::unique_ptr<MediaEngineInterface> WebRtcMediaEngineFactory::Create( std::unique_ptr<MediaEngineInterface> WebRtcMediaEngineFactory::Create(
rtc::scoped_refptr<webrtc::AudioDeviceModule> adm, rtc::scoped_refptr<webrtc::AudioDeviceModule> adm,
rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory, rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,

52
media/engine/webrtc_media_engine.h
View File

@ -27,10 +27,6 @@ class VideoDecoderFactory;
class VideoEncoderFactory; class VideoEncoderFactory;
class VideoBitrateAllocatorFactory; class VideoBitrateAllocatorFactory;
} // namespace webrtc } // namespace webrtc
namespace cricket {
class WebRtcVideoDecoderFactory;
class WebRtcVideoEncoderFactory;
} // namespace cricket
namespace cricket { namespace cricket {
@ -39,54 +35,6 @@ class WebRtcMediaEngineFactory {
// These Create methods may be called on any thread, though the engine is // These Create methods may be called on any thread, though the engine is
// only expected to be used on one thread, internally called the "worker // only expected to be used on one thread, internally called the "worker
// thread". This is the thread Init must be called on. // thread". This is the thread Init must be called on.
//
// TODO(deadbeef): Change these to return an std::unique_ptr<>, to indicate
// that the caller owns the returned object.
#if defined(USE_BUILTIN_SW_CODECS)
RTC_DEPRECATED static MediaEngineInterface* Create(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory);
RTC_DEPRECATED static MediaEngineInterface* Create(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
rtc::scoped_refptr<webrtc::AudioProcessing> apm);
RTC_DEPRECATED static MediaEngineInterface* Create(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
WebRtcVideoEncoderFactory* video_encoder_factory,
WebRtcVideoDecoderFactory* video_decoder_factory,
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory);
RTC_DEPRECATED static MediaEngineInterface* Create(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
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
// Create a MediaEngineInterface with optional video codec factories. These // Create a MediaEngineInterface with optional video codec factories. These
// video factories represents all video codecs, i.e. no extra internal video // video factories represents all video codecs, i.e. no extra internal video

39
media/engine/webrtc_video_decoder_factory.cc
View File

@ -1,39 +0,0 @@
/*
* Copyright (c) 2017 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.
*/
#include "media/engine/webrtc_video_decoder_factory.h"
#include "api/video_codecs/video_codec.h"
#include "rtc_base/checks.h"
namespace cricket {
webrtc::VideoDecoder* WebRtcVideoDecoderFactory::CreateVideoDecoderWithParams(
const VideoCodec& codec,
VideoDecoderParams params) {
// Default implementation that delegates to old version in order to preserve
// backwards-compatability.
webrtc::VideoCodecType type = webrtc::PayloadStringToCodecType(codec.name);
return CreateVideoDecoderWithParams(type, params);
}
webrtc::VideoDecoder* WebRtcVideoDecoderFactory::CreateVideoDecoder(
webrtc::VideoCodecType type) {
RTC_NOTREACHED();
return nullptr;
}
webrtc::VideoDecoder* WebRtcVideoDecoderFactory::CreateVideoDecoderWithParams(
webrtc::VideoCodecType type,
VideoDecoderParams params) {
return CreateVideoDecoder(type);
}
} // namespace cricket

57
media/engine/webrtc_video_decoder_factory.h
View File

@ -1,57 +0,0 @@
/*
* Copyright (c) 2013 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_WEBRTC_VIDEO_DECODER_FACTORY_H_
#define MEDIA_ENGINE_WEBRTC_VIDEO_DECODER_FACTORY_H_
#include <string>
#include "api/video/video_codec_type.h"
#include "media/base/codec.h"
#include "rtc_base/ref_count.h"
#include "rtc_base/system/rtc_export.h"
namespace webrtc {
class VideoDecoder;
}
namespace cricket {
struct VideoDecoderParams {
std::string receive_stream_id;
};
// Deprecated. Use webrtc::VideoDecoderFactory instead.
// https://bugs.chromium.org/p/webrtc/issues/detail?id=7925
class RTC_EXPORT WebRtcVideoDecoderFactory {
public:
// Caller takes the ownership of the returned object and it should be released
// by calling DestroyVideoDecoder().
virtual webrtc::VideoDecoder* CreateVideoDecoderWithParams(
const VideoCodec& codec,
VideoDecoderParams params);
// DEPRECATED.
// These methods should not be used by new code and will eventually be
// removed. See http://crbug.com/webrtc/8140.
virtual webrtc::VideoDecoder* CreateVideoDecoder(webrtc::VideoCodecType type);
virtual webrtc::VideoDecoder* CreateVideoDecoderWithParams(
webrtc::VideoCodecType type,
VideoDecoderParams params);
virtual ~WebRtcVideoDecoderFactory() {}
virtual void DestroyVideoDecoder(webrtc::VideoDecoder* decoder) = 0;
};
} // namespace cricket
#endif // MEDIA_ENGINE_WEBRTC_VIDEO_DECODER_FACTORY_H_

20
media/engine/webrtc_video_encoder_factory.cc
View File

@ -1,20 +0,0 @@
/*
* Copyright (c) 2017 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.
*/
#include "media/engine/webrtc_video_encoder_factory.h"
namespace cricket {
bool WebRtcVideoEncoderFactory::EncoderTypeHasInternalSource(
webrtc::VideoCodecType type) const {
return false;
}
} // namespace cricket

51
media/engine/webrtc_video_encoder_factory.h
View File

@ -1,51 +0,0 @@
/*
* Copyright (c) 2013 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_WEBRTC_VIDEO_ENCODER_FACTORY_H_
#define MEDIA_ENGINE_WEBRTC_VIDEO_ENCODER_FACTORY_H_
#include <string>
#include <vector>
#include "api/video/video_codec_type.h"
#include "media/base/codec.h"
#include "rtc_base/system/rtc_export.h"
namespace webrtc {
class VideoEncoder;
}
namespace cricket {
// Deprecated. Use webrtc::VideoEncoderFactory instead.
// https://bugs.chromium.org/p/webrtc/issues/detail?id=7925
class RTC_EXPORT WebRtcVideoEncoderFactory {
public:
virtual ~WebRtcVideoEncoderFactory() {}
// Caller takes the ownership of the returned object and it should be released
// by calling DestroyVideoEncoder().
virtual webrtc::VideoEncoder* CreateVideoEncoder(
const cricket::VideoCodec& codec) = 0;
// Returns a list of supported codecs in order of preference.
virtual const std::vector<cricket::VideoCodec>& supported_codecs() const = 0;
// Returns true if encoders created by this factory of the given codec type
// will use internal camera sources, meaning that they don't require/expect
// frames to be delivered via webrtc::VideoEncoder::Encode.
virtual bool EncoderTypeHasInternalSource(webrtc::VideoCodecType type) const;
virtual void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) = 0;
};
} // namespace cricket
#endif // MEDIA_ENGINE_WEBRTC_VIDEO_ENCODER_FACTORY_H_

45
media/engine/webrtc_video_encoder_factory_unittest.cc
View File

@ -1,45 +0,0 @@
/*
* Copyright (c) 2017 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.
*/
#include "media/engine/webrtc_video_encoder_factory.h"
#include "test/gtest.h"
class WebRtcVideoEncoderFactoryForTest
: public cricket::WebRtcVideoEncoderFactory {
public:
WebRtcVideoEncoderFactoryForTest() {
codecs_.push_back(cricket::VideoCodec("H264"));
codecs_.push_back(cricket::VideoCodec("VP8"));
}
webrtc::VideoEncoder* CreateVideoEncoder(
const cricket::VideoCodec& codec) override {
return nullptr;
}
const std::vector<cricket::VideoCodec>& supported_codecs() const override {
return codecs_;
}
void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override {}
std::vector<cricket::VideoCodec> codecs_;
};
TEST(WebRtcVideoEncoderFactoryTest, TestMultipleCallsToSupportedCodecs) {
WebRtcVideoEncoderFactoryForTest factory;
EXPECT_EQ(2u, factory.supported_codecs().size());
EXPECT_EQ("H264", factory.supported_codecs()[0].name);
EXPECT_EQ("VP8", factory.supported_codecs()[1].name);
// The codec list doesn't grow when called repeatedly.
EXPECT_EQ(2u, factory.supported_codecs().size());
}

18
media/engine/webrtc_video_engine.cc
View File

@ -23,9 +23,6 @@
#include "api/video_codecs/video_encoder_factory.h" #include "api/video_codecs/video_encoder_factory.h"
#include "call/call.h" #include "call/call.h"
#include "media/engine/constants.h" #include "media/engine/constants.h"
#if defined(USE_BUILTIN_SW_CODECS)
#include "media/engine/convert_legacy_video_factory.h" // nogncheck
#endif
#include "media/engine/simulcast.h" #include "media/engine/simulcast.h"
#include "media/engine/webrtc_media_engine.h" #include "media/engine/webrtc_media_engine.h"
#include "media/engine/webrtc_voice_engine.h" #include "media/engine/webrtc_voice_engine.h"
@ -436,21 +433,6 @@ 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<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory)
: decoder_factory_(ConvertVideoDecoderFactory(
std::move(external_video_decoder_factory))),
encoder_factory_(ConvertVideoEncoderFactory(
std::move(external_video_encoder_factory))),
bitrate_allocator_factory_(std::move(video_bitrate_allocator_factory)) {
RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
}
#endif
WebRtcVideoEngine::WebRtcVideoEngine( WebRtcVideoEngine::WebRtcVideoEngine(
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory, std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory, std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory,

11
media/engine/webrtc_video_engine.h
View File

@ -29,8 +29,6 @@
#include "call/video_receive_stream.h" #include "call/video_receive_stream.h"
#include "call/video_send_stream.h" #include "call/video_send_stream.h"
#include "media/base/media_engine.h" #include "media/base/media_engine.h"
#include "media/engine/webrtc_video_decoder_factory.h"
#include "media/engine/webrtc_video_encoder_factory.h"
#include "rtc_base/async_invoker.h" #include "rtc_base/async_invoker.h"
#include "rtc_base/critical_section.h" #include "rtc_base/critical_section.h"
#include "rtc_base/network_route.h" #include "rtc_base/network_route.h"
@ -81,15 +79,6 @@ class DefaultUnsignalledSsrcHandler : public UnsignalledSsrcHandler {
// WebRtcVideoEngine is used for the new native WebRTC Video API (webrtc:1667). // WebRtcVideoEngine is used for the new native WebRTC Video API (webrtc:1667).
class WebRtcVideoEngine : public VideoEngineInterface { class WebRtcVideoEngine : public VideoEngineInterface {
public: public:
#if defined(USE_BUILTIN_SW_CODECS)
// Internal SW video codecs will be added on top of the external codecs.
RTC_DEPRECATED WebRtcVideoEngine(
std::unique_ptr<WebRtcVideoEncoderFactory> external_video_encoder_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 // These video codec factories represents all video codecs, i.e. both software
// and external hardware codecs. // and external hardware codecs.
WebRtcVideoEngine( WebRtcVideoEngine(

19
media/engine/webrtcvideodecoderfactory.h
View File

@ -1,19 +0,0 @@
/*
* Copyright 2019 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_WEBRTCVIDEODECODERFACTORY_H_
#define MEDIA_ENGINE_WEBRTCVIDEODECODERFACTORY_H_
// TODO(bugs.webrtc.org/10159): Remove this files once downstream projects have
// been updated to include the new path.
#include "media/engine/webrtc_video_decoder_factory.h"
#endif // MEDIA_ENGINE_WEBRTCVIDEODECODERFACTORY_H_

19
media/engine/webrtcvideoencoderfactory.h
View File

@ -1,19 +0,0 @@
/*
* Copyright 2019 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_WEBRTCVIDEOENCODERFACTORY_H_
#define MEDIA_ENGINE_WEBRTCVIDEOENCODERFACTORY_H_
// TODO(bugs.webrtc.org/10159): Remove this files once downstream projects have
// been updated to include the new path.
#include "media/engine/webrtc_video_encoder_factory.h"
#endif // MEDIA_ENGINE_WEBRTCVIDEOENCODERFACTORY_H_

10
pc/BUILD.gn
View File

@ -134,10 +134,7 @@ rtc_static_library("rtc_pc_base") {
rtc_source_set("rtc_pc") { rtc_source_set("rtc_pc") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
deps = [ deps = [
":rtc_pc_base", ":rtc_pc_base",
"../media:rtc_audio_video", "../media:rtc_audio_video",
@ -278,10 +275,7 @@ rtc_static_library("peerconnection") {
rtc_source_set("libjingle_peerconnection") { rtc_source_set("libjingle_peerconnection") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
deps = [ deps = [
":peerconnection", ":peerconnection",
"../api:create_peerconnection_factory", "../api:create_peerconnection_factory",

2
pc/peer_connection_factory.cc
View File

@ -34,8 +34,6 @@
// TODO(zhihuang): This wouldn't be necessary if the interface and // TODO(zhihuang): This wouldn't be necessary if the interface and
// implementation of the media engine were in separate build targets. // implementation of the media engine were in separate build targets.
#include "media/engine/webrtc_media_engine.h" // nogncheck #include "media/engine/webrtc_media_engine.h" // nogncheck
#include "media/engine/webrtc_video_decoder_factory.h" // nogncheck
#include "media/engine/webrtc_video_encoder_factory.h" // nogncheck
#include "modules/audio_device/include/audio_device.h" // nogncheck #include "modules/audio_device/include/audio_device.h" // nogncheck
#include "p2p/base/basic_packet_socket_factory.h" #include "p2p/base/basic_packet_socket_factory.h"
#include "p2p/client/basic_port_allocator.h" #include "p2p/client/basic_port_allocator.h"

40
sdk/BUILD.gn
View File

@ -411,10 +411,7 @@ if (is_ios || is_mac) {
rtc_static_library("ui_objc") { rtc_static_library("ui_objc") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
if (is_ios) { if (is_ios) {
sources = [ sources = [
"objc/components/renderer/opengl/RTCDisplayLinkTimer.h", "objc/components/renderer/opengl/RTCDisplayLinkTimer.h",
@ -442,10 +439,7 @@ if (is_ios || is_mac) {
if (rtc_use_metal_rendering) { if (rtc_use_metal_rendering) {
rtc_static_library("metal_objc") { rtc_static_library("metal_objc") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
sources = [ sources = [
"objc/components/renderer/metal/RTCMTLI420Renderer.h", "objc/components/renderer/metal/RTCMTLI420Renderer.h",
"objc/components/renderer/metal/RTCMTLI420Renderer.mm", "objc/components/renderer/metal/RTCMTLI420Renderer.mm",
@ -507,10 +501,7 @@ if (is_ios || is_mac) {
rtc_static_library("videocapture_objc") { rtc_static_library("videocapture_objc") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
sources = [ sources = [
"objc/components/capturer/RTCCameraVideoCapturer.h", "objc/components/capturer/RTCCameraVideoCapturer.h",
"objc/components/capturer/RTCCameraVideoCapturer.m", "objc/components/capturer/RTCCameraVideoCapturer.m",
@ -647,10 +638,7 @@ if (is_ios || is_mac) {
# The applications which only use WebRTC DataChannel can depend on this. # The applications which only use WebRTC DataChannel can depend on this.
rtc_static_library("peerconnectionfactory_no_media_objc") { rtc_static_library("peerconnectionfactory_no_media_objc") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
defines = [ "HAVE_NO_MEDIA" ] defines = [ "HAVE_NO_MEDIA" ]
sources = [ sources = [
@ -701,10 +689,7 @@ if (is_ios || is_mac) {
rtc_static_library("videorendereradapter_objc") { rtc_static_library("videorendereradapter_objc") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
sources = [ sources = [
"objc/api/RTCVideoRendererAdapter+Private.h", "objc/api/RTCVideoRendererAdapter+Private.h",
"objc/api/RTCVideoRendererAdapter.h", "objc/api/RTCVideoRendererAdapter.h",
@ -777,10 +762,7 @@ if (is_ios || is_mac) {
rtc_static_library("peerconnectionfactory_base_objc") { rtc_static_library("peerconnectionfactory_base_objc") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
configs += [ configs += [
"..:no_exit_time_destructors", "..:no_exit_time_destructors",
"..:no_global_constructors", "..:no_global_constructors",
@ -1524,10 +1506,7 @@ if (is_ios || is_mac) {
# The native API is currently experimental and may change without notice. # The native API is currently experimental and may change without notice.
rtc_static_library("native_api") { rtc_static_library("native_api") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
sources = [ sources = [
"objc/native/api/video_capturer.h", "objc/native/api/video_capturer.h",
"objc/native/api/video_capturer.mm", "objc/native/api/video_capturer.mm",
@ -1630,10 +1609,7 @@ if (is_ios || is_mac) {
rtc_static_library("videotoolbox_objc") { rtc_static_library("videotoolbox_objc") {
visibility = [ "*" ] visibility = [ "*" ]
allow_poison = [ allow_poison = [ "audio_codecs" ] # TODO(bugs.webrtc.org/8396): Remove.
"audio_codecs", # TODO(bugs.webrtc.org/8396): Remove.
"software_video_codecs", # TODO(bugs.webrtc.org/7925): Remove.
]
sources = [ sources = [
"objc/components/video_codec/RTCVideoDecoderFactoryH264.h", "objc/components/video_codec/RTCVideoDecoderFactoryH264.h",
"objc/components/video_codec/RTCVideoDecoderFactoryH264.m", "objc/components/video_codec/RTCVideoDecoderFactoryH264.m",

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

@ -31,7 +31,6 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h" // nogncheck #include "api/audio_codecs/builtin_audio_decoder_factory.h" // nogncheck
#include "api/audio_codecs/builtin_audio_encoder_factory.h" // nogncheck #include "api/audio_codecs/builtin_audio_encoder_factory.h" // nogncheck
#include "logging/rtc_event_log/rtc_event_log_factory.h" #include "logging/rtc_event_log/rtc_event_log_factory.h"
#include "media/engine/convert_legacy_video_factory.h" // nogncheck
#include "modules/audio_device/include/audio_device.h" // nogncheck #include "modules/audio_device/include/audio_device.h" // nogncheck
#include "modules/audio_processing/include/audio_processing.h" // nogncheck #include "modules/audio_processing/include/audio_processing.h" // nogncheck

2
video/BUILD.gn
View File

@ -165,8 +165,6 @@ rtc_source_set("video_stream_encoder_impl") {
visibility = [ "*" ] visibility = [ "*" ]
# visibility = [ "../api/video:video_stream_encoder_create" ] # visibility = [ "../api/video:video_stream_encoder_create" ]
# In modules/video_coding, there's a dependency video_coding --> webrtc_vp8
allow_poison = [ "software_video_codecs" ] # TODO(bugs.webrtc.org/7925): Remove.
sources = [ sources = [
"overuse_frame_detector.cc", "overuse_frame_detector.cc",
"overuse_frame_detector.h", "overuse_frame_detector.h",

3
webrtc.gni
View File

@ -168,9 +168,6 @@ declare_args() {
# real audio samples. # real audio samples.
rtc_audio_device_plays_sinus_tone = false rtc_audio_device_plays_sinus_tone = false
# Disable this to build without support for built-in software codecs.
rtc_use_builtin_sw_codecs = true
if (is_ios) { if (is_ios) {
# Build broadcast extension in AppRTCMobile for iOS. This results in the # Build broadcast extension in AppRTCMobile for iOS. This results in the
# binary only running on iOS 11+, which is why it is disabled by default. # binary only running on iOS 11+, which is why it is disabled by default.