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

Reland "Add helper functions for migrating to new video codec factories"

Browse Source 
This reverts commit a7678667fc726979ca27d2429689d5735cca425d.

Reason for reland: Fix initializer list constructor.

Original change's description:
> Revert "Add helper functions for migrating to new video codec factories"
> 
> This reverts commit 1c9623c70db42550d152c127e01434004087f743.
> 
> Reason for revert: Breaks brace initialization:
> 
> cricket::VideoDecoderParams params = { "deadbeef" };
> 
> I suggest adding an initializer list constructor.
> 
> Original change's description:
> > Add helper functions for migrating to new video codec factories
> > 
> > This CL adds helper functions in media/engine/convert_legacy_video_factory.h to
> > convert from the old WebRtcVideoEncoder and WebRtcVideoDecoder to the new
> > webrtc::VideoEncoder and webrtc::VideoDecoder.
> > 
> > The purpose is to make it as easy as possible for clients to migrate to the new
> > API and allow us to stop depending on the internal SW codecs as soon as possible.
> > 
> > There still exists an ugly decoder adapter class in the video engine. The reason
> > is that we need to continue to pass in the |receive_stream_id| decoder params to
> > some legacy clients.
> > 
> > Bug: webrtc:7925
> > Change-Id: I43ff03e036411a85d4940fe517a34489f171d698
> > Reviewed-on: https://webrtc-review.googlesource.com/15181
> > Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
> > Reviewed-by: Anders Carlsson <andersc@webrtc.org>
> > Cr-Commit-Position: refs/heads/master@{#20475}
> 
> TBR=magjed@webrtc.org,andersc@webrtc.org
> 
> Change-Id: I0d1084dc86979fbca748d9ba287d1db3dbe52b44
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: webrtc:7925
> Reviewed-on: https://webrtc-review.googlesource.com/17160
> Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
> Commit-Queue: Taylor Brandstetter <deadbeef@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#20486}

TBR=deadbeef@webrtc.org,magjed@webrtc.org,andersc@webrtc.org

Change-Id: Ic825d133b6e1c6e5aad811ba528751dd5ed85e67
Bug: webrtc:7925
Reviewed-on: https://webrtc-review.googlesource.com/17360
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Anders Carlsson <andersc@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20501}
This commit is contained in:
Magnus Jedvert
2017-10-31 11:24:54 +01:00
committed by Commit Bot
parent 0110d3e0ca
commit 07e0d015b7
5 changed files with 354 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
media/BUILD.gn
View File

@ -143,6 +143,8 @@ rtc_static_library("rtc_audio_video") {
"engine/apm_helpers.cc",
"engine/apm_helpers.h",
"engine/constants.h",
"engine/convert_legacy_video_factory.cc",
"engine/convert_legacy_video_factory.h",
"engine/internaldecoderfactory.cc",
"engine/internaldecoderfactory.h",
"engine/internalencoderfactory.cc",

191
media/engine/convert_legacy_video_factory.cc Normal file
View File

@ -0,0 +1,191 @@
/*
* 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 <utility>
#include <vector>
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "media/engine/internaldecoderfactory.h"
#include "media/engine/internalencoderfactory.h"
#include "media/engine/scopedvideodecoder.h"
#include "media/engine/scopedvideoencoder.h"
#include "media/engine/simulcast_encoder_adapter.h"
#include "media/engine/videodecodersoftwarefallbackwrapper.h"
#include "media/engine/videoencodersoftwarefallbackwrapper.h"
#include "media/engine/vp8_encoder_simulcast_proxy.h"
#include "media/engine/webrtcvideodecoderfactory.h"
#include "media/engine/webrtcvideoencoderfactory.h"
#include "rtc_base/checks.h"
namespace cricket {
namespace {
class EncoderAdapter : public webrtc::VideoEncoderFactory {
public:
explicit EncoderAdapter(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory)
: internal_encoder_factory_(new InternalEncoderFactory()),
external_encoder_factory_(std::move(external_encoder_factory)) {}
webrtc::VideoEncoderFactory::CodecInfo QueryVideoEncoder(
const webrtc::SdpVideoFormat& format) const {
const VideoCodec codec(format);
if (external_encoder_factory_ != nullptr &&
FindMatchingCodec(external_encoder_factory_->supported_codecs(),
codec)) {
// Format is supported by the external factory.
const webrtc::VideoCodecType codec_type =
webrtc::PayloadStringToCodecType(codec.name);
webrtc::VideoEncoderFactory::CodecInfo info;
info.has_internal_source =
external_encoder_factory_->EncoderTypeHasInternalSource(codec_type);
info.is_hardware_accelerated = true;
return info;
}
// Format must be one of the internal formats.
RTC_DCHECK(FindMatchingCodec(internal_encoder_factory_->supported_codecs(),
codec));
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) {
const VideoCodec codec(format);
// Try creating external encoder.
if (external_encoder_factory_ != nullptr &&
FindMatchingCodec(external_encoder_factory_->supported_codecs(),
codec)) {
std::unique_ptr<webrtc::VideoEncoder> external_encoder;
if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
// If it's a codec type we can simulcast, create a wrapped encoder.
external_encoder = std::unique_ptr<webrtc::VideoEncoder>(
new webrtc::SimulcastEncoderAdapter(
external_encoder_factory_.get()));
} else {
external_encoder =
CreateScopedVideoEncoder(external_encoder_factory_.get(), codec);
}
if (external_encoder) {
return std::unique_ptr<webrtc::VideoEncoder>(
new webrtc::VideoEncoderSoftwareFallbackWrapper(
codec, std::move(external_encoder)));
}
}
// Try creating internal encoder.
if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(),
codec)) {
if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
return std::unique_ptr<webrtc::VideoEncoder>(
new webrtc::VP8EncoderSimulcastProxy(
internal_encoder_factory_.get()));
} else {
return std::unique_ptr<webrtc::VideoEncoder>(
internal_encoder_factory_->CreateVideoEncoder(codec));
}
}
// This shouldn't happen, we should not be trying to create something we
// don't support.
RTC_NOTREACHED();
return nullptr;
}
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const {
std::vector<VideoCodec> codecs =
InternalEncoderFactory().supported_codecs();
// Add external codecs.
if (external_encoder_factory_ != nullptr) {
const std::vector<VideoCodec>& external_codecs =
external_encoder_factory_->supported_codecs();
for (const VideoCodec& codec : external_codecs) {
// Don't add same codec twice.
if (!FindMatchingCodec(codecs, codec))
codecs.push_back(codec);
}
}
std::vector<webrtc::SdpVideoFormat> formats;
for (const VideoCodec& codec : codecs) {
formats.push_back(webrtc::SdpVideoFormat(codec.name, codec.params));
}
return formats;
}
private:
const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_;
const std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory_;
};
class DecoderAdapter : public webrtc::VideoDecoderFactory {
public:
explicit DecoderAdapter(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory)
: internal_decoder_factory_(new InternalDecoderFactory()),
external_decoder_factory_(std::move(external_decoder_factory)) {}
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const webrtc::SdpVideoFormat& format) override {
const VideoCodec codec(format);
const VideoDecoderParams params = {};
if (external_decoder_factory_ != nullptr) {
std::unique_ptr<webrtc::VideoDecoder> external_decoder =
CreateScopedVideoDecoder(external_decoder_factory_.get(), codec,
params);
if (external_decoder) {
webrtc::VideoCodecType type =
webrtc::PayloadStringToCodecType(codec.name);
std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
new webrtc::VideoDecoderSoftwareFallbackWrapper(
type, std::move(external_decoder)));
return internal_decoder;
}
}
std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
internal_decoder_factory_->CreateVideoDecoderWithParams(codec, params));
return internal_decoder;
}
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> internal_decoder_factory_;
const std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory_;
};
} // namespace
std::unique_ptr<webrtc::VideoEncoderFactory> 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> ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory) {
return std::unique_ptr<webrtc::VideoDecoderFactory>(
new DecoderAdapter(std::move(external_decoder_factory)));
}
} // namespace cricket

38
media/engine/convert_legacy_video_factory.h Normal file
View File

@ -0,0 +1,38 @@
/*
* 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>
namespace webrtc {
class VideoEncoderFactory;
class VideoDecoderFactory;
} // namespace webrtc
namespace cricket {
class WebRtcVideoEncoderFactory;
class WebRtcVideoDecoderFactory;
// 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.
std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory);
std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory);
} // namespace cricket
#endif // MEDIA_ENGINE_CONVERT_LEGACY_VIDEO_FACTORY_H_

373
media/engine/webrtcvideoengine.cc
View File

@ -25,16 +25,9 @@
#include "call/call.h"
#include "common_video/h264/profile_level_id.h"
#include "media/engine/constants.h"
#include "media/engine/internaldecoderfactory.h"
#include "media/engine/internalencoderfactory.h"
#include "media/engine/scopedvideodecoder.h"
#include "media/engine/scopedvideoencoder.h"
#include "media/engine/convert_legacy_video_factory.h"
#include "media/engine/simulcast.h"
#include "media/engine/simulcast_encoder_adapter.h"
#include "media/engine/videodecodersoftwarefallbackwrapper.h"
#include "media/engine/videoencodersoftwarefallbackwrapper.h"
#include "media/engine/webrtcmediaengine.h"
#include "media/engine/webrtcvideoencoderfactory.h"
#include "media/engine/webrtcvoiceengine.h"
#include "rtc_base/copyonwritebuffer.h"
#include "rtc_base/logging.h"
@ -42,141 +35,103 @@
#include "rtc_base/timeutils.h"
#include "rtc_base/trace_event.h"
#include "system_wrappers/include/field_trial.h"
#include "vp8_encoder_simulcast_proxy.h"
using DegradationPreference = webrtc::VideoSendStream::DegradationPreference;
namespace cricket {
// This class represents all encoders, i.e. both internal and external. It
// serves as a temporary adapter between WebRtcVideoEncoderFactory* and the new
// factory interface that is being developed.
// TODO(magjed): Remove once WebRtcVideoEncoderFactory* is deprecated and
// Hack in order to pass in |receive_stream_id| to legacy clients.
// TODO(magjed): Remove once WebRtcVideoDecoderFactory is deprecated and
// webrtc:7925 is fixed.
class EncoderFactoryAdapter {
public:
struct AllocatedEncoder {
AllocatedEncoder() = default;
AllocatedEncoder(std::unique_ptr<webrtc::VideoEncoder> encoder,
bool is_hardware_accelerated,
bool has_internal_source);
std::unique_ptr<webrtc::VideoEncoder> encoder;
bool is_hardware_accelerated;
bool has_internal_source;
};
virtual ~EncoderFactoryAdapter() {}
virtual AllocatedEncoder CreateVideoEncoder(
const VideoCodec& codec) const = 0;
virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0;
};
class DecoderFactoryAdapter {
public:
virtual ~DecoderFactoryAdapter() {}
explicit DecoderFactoryAdapter(
std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory)
: cricket_decoder_with_params_(new CricketDecoderWithParams(
std::move(external_video_decoder_factory))),
decoder_factory_(ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory>(
cricket_decoder_with_params_))) {}
virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const VideoCodec& codec,
const VideoDecoderParams& decoder_params) const = 0;
explicit DecoderFactoryAdapter(
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory)
: cricket_decoder_with_params_(nullptr),
decoder_factory_(std::move(video_decoder_factory)) {}
void SetReceiveStreamId(const std::string& receive_stream_id) {
if (cricket_decoder_with_params_)
cricket_decoder_with_params_->SetReceiveStreamId(receive_stream_id);
}
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const {
return decoder_factory_->GetSupportedFormats();
}
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const webrtc::SdpVideoFormat& format) {
return decoder_factory_->CreateVideoDecoder(format);
}
private:
// WebRtcVideoDecoderFactory implementation that allows to override
// |receive_stream_id|.
class CricketDecoderWithParams : public WebRtcVideoDecoderFactory {
public:
explicit CricketDecoderWithParams(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory)
: external_decoder_factory_(std::move(external_decoder_factory)) {}
void SetReceiveStreamId(const std::string& receive_stream_id) {
receive_stream_id_ = receive_stream_id;
}
private:
webrtc::VideoDecoder* CreateVideoDecoderWithParams(
const VideoCodec& codec,
VideoDecoderParams params) override {
if (!external_decoder_factory_)
return nullptr;
params.receive_stream_id = receive_stream_id_;
return external_decoder_factory_->CreateVideoDecoderWithParams(codec,
params);
}
webrtc::VideoDecoder* CreateVideoDecoderWithParams(
webrtc::VideoCodecType type,
VideoDecoderParams params) override {
RTC_NOTREACHED();
return nullptr;
}
void DestroyVideoDecoder(webrtc::VideoDecoder* decoder) override {
if (external_decoder_factory_) {
external_decoder_factory_->DestroyVideoDecoder(decoder);
} else {
delete decoder;
}
}
const std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory_;
std::string receive_stream_id_;
};
// If |cricket_decoder_with_params_| is non-null, it's owned by
// |decoder_factory_|.
CricketDecoderWithParams* const cricket_decoder_with_params_;
std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_;
};
namespace {
std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
const std::vector<VideoCodec>& input_codecs);
const std::vector<webrtc::SdpVideoFormat>& input_formats);
// Wraps cricket::WebRtcVideoEncoderFactory into common EncoderFactoryAdapter
// interface.
// TODO(magjed): Remove once WebRtcVideoEncoderFactory is deprecated and
// webrtc:7925 is fixed.
class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter {
public:
explicit CricketEncoderFactoryAdapter(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory)
: internal_encoder_factory_(new InternalEncoderFactory()),
external_encoder_factory_(std::move(external_encoder_factory)) {}
private:
AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec) const override;
std::vector<VideoCodec> GetSupportedCodecs() const override;
const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_;
const std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory_;
};
class CricketDecoderFactoryAdapter : public DecoderFactoryAdapter {
public:
explicit CricketDecoderFactoryAdapter(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory)
: internal_decoder_factory_(new InternalDecoderFactory()),
external_decoder_factory_(std::move(external_decoder_factory)) {}
private:
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const VideoCodec& codec,
const VideoDecoderParams& decoder_params) const override;
const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_;
const std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory_;
};
// Wraps webrtc::VideoEncoderFactory into common EncoderFactoryAdapter
// interface.
class WebRtcEncoderFactoryAdapter : public EncoderFactoryAdapter {
public:
explicit WebRtcEncoderFactoryAdapter(
std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory)
: encoder_factory_(std::move(encoder_factory)) {}
private:
AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec) const override {
if (!encoder_factory_)
return AllocatedEncoder();
const webrtc::SdpVideoFormat format(codec.name, codec.params);
const webrtc::VideoEncoderFactory::CodecInfo info =
encoder_factory_->QueryVideoEncoder(format);
return AllocatedEncoder(encoder_factory_->CreateVideoEncoder(format),
info.is_hardware_accelerated,
info.has_internal_source);
}
std::vector<VideoCodec> GetSupportedCodecs() const override {
if (!encoder_factory_)
return std::vector<VideoCodec>();
std::vector<VideoCodec> codecs;
for (const webrtc::SdpVideoFormat& format :
encoder_factory_->GetSupportedFormats()) {
codecs.push_back(VideoCodec(format));
}
return AssignPayloadTypesAndAddAssociatedRtxCodecs(codecs);
}
std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory_;
};
// Wraps webrtc::VideoDecoderFactory into common DecoderFactoryAdapter
// interface.
class WebRtcDecoderFactoryAdapter : public DecoderFactoryAdapter {
public:
explicit WebRtcDecoderFactoryAdapter(
std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory)
: decoder_factory_(std::move(decoder_factory)) {}
private:
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const VideoCodec& codec,
const VideoDecoderParams& decoder_params) const override {
return decoder_factory_
? decoder_factory_->CreateVideoDecoder(
webrtc::SdpVideoFormat(codec.name, codec.params))
: nullptr;
}
std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_;
};
std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
const webrtc::VideoEncoderFactory* encoder_factory) {
return encoder_factory ? AssignPayloadTypesAndAddAssociatedRtxCodecs(
encoder_factory->GetSupportedFormats())
: std::vector<VideoCodec>();
}
// If this field trial is enabled, we will enable sending FlexFEC and disable
// sending ULPFEC whenever the former has been negotiated in the SDPs.
@ -448,9 +403,9 @@ void DefaultUnsignalledSsrcHandler::SetDefaultSink(
WebRtcVideoEngine::WebRtcVideoEngine(
std::unique_ptr<WebRtcVideoEncoderFactory> external_video_encoder_factory,
std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory)
: decoder_factory_(new CricketDecoderFactoryAdapter(
std::move(external_video_decoder_factory))),
encoder_factory_(new CricketEncoderFactoryAdapter(
: decoder_factory_(
new DecoderFactoryAdapter(std::move(external_video_decoder_factory))),
encoder_factory_(ConvertVideoEncoderFactory(
std::move(external_video_encoder_factory))) {
LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
}
@ -459,9 +414,8 @@ WebRtcVideoEngine::WebRtcVideoEngine(
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory)
: decoder_factory_(
new WebRtcDecoderFactoryAdapter(std::move(video_decoder_factory))),
encoder_factory_(
new WebRtcEncoderFactoryAdapter(std::move(video_encoder_factory))) {
new DecoderFactoryAdapter(std::move(video_decoder_factory))),
encoder_factory_(std::move(video_encoder_factory)) {
LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
}
@ -479,7 +433,7 @@ WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel(
}
std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
return encoder_factory_->GetSupportedCodecs();
return AssignPayloadTypesAndAddAssociatedRtxCodecs(encoder_factory_.get());
}
RtpCapabilities WebRtcVideoEngine::GetCapabilities() const {
@ -514,12 +468,13 @@ namespace {
// (VP8, VP9, H264, and RED). It will also add default feedback params to the
// codecs.
std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
const std::vector<VideoCodec>& input_codecs) {
const std::vector<webrtc::SdpVideoFormat>& input_formats) {
static const int kFirstDynamicPayloadType = 96;
static const int kLastDynamicPayloadType = 127;
int payload_type = kFirstDynamicPayloadType;
std::vector<VideoCodec> output_codecs;
for (VideoCodec codec : input_codecs) {
for (const webrtc::SdpVideoFormat& format : input_formats) {
VideoCodec codec(format);
codec.id = payload_type;
AddDefaultFeedbackParams(&codec);
output_codecs.push_back(codec);
@ -549,34 +504,12 @@ std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
}
} // namespace
std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs()
const {
std::vector<VideoCodec> codecs = InternalEncoderFactory().supported_codecs();
LOG(LS_INFO) << "Internally supported codecs: "
<< CodecVectorToString(codecs);
// Add external codecs.
if (external_encoder_factory_ != nullptr) {
const std::vector<VideoCodec>& external_codecs =
external_encoder_factory_->supported_codecs();
for (const VideoCodec& codec : external_codecs) {
// Don't add same codec twice.
if (!FindMatchingCodec(codecs, codec))
codecs.push_back(codec);
}
LOG(LS_INFO) << "Codecs supported by the external encoder factory: "
<< CodecVectorToString(external_codecs);
}
return AssignPayloadTypesAndAddAssociatedRtxCodecs(codecs);
}
WebRtcVideoChannel::WebRtcVideoChannel(
webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options,
const EncoderFactoryAdapter* encoder_factory,
const DecoderFactoryAdapter* decoder_factory)
webrtc::VideoEncoderFactory* encoder_factory,
DecoderFactoryAdapter* decoder_factory)
: VideoMediaChannel(config),
call_(call),
unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
@ -589,7 +522,8 @@ WebRtcVideoChannel::WebRtcVideoChannel(
rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
sending_ = false;
recv_codecs_ = MapCodecs(encoder_factory_->GetSupportedCodecs());
recv_codecs_ =
MapCodecs(AssignPayloadTypesAndAddAssociatedRtxCodecs(encoder_factory_));
recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type;
}
@ -604,7 +538,7 @@ rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>
WebRtcVideoChannel::SelectSendVideoCodec(
const std::vector<VideoCodecSettings>& remote_mapped_codecs) const {
const std::vector<VideoCodec> local_supported_codecs =
encoder_factory_->GetSupportedCodecs();
AssignPayloadTypesAndAddAssociatedRtxCodecs(encoder_factory_);
// Select the first remote codec that is supported locally.
for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) {
// For H264, we will limit the encode level to the remote offered level
@ -916,7 +850,7 @@ bool WebRtcVideoChannel::GetChangedRecvParameters(
// Verify that every mapped codec is supported locally.
const std::vector<VideoCodec> local_supported_codecs =
encoder_factory_->GetSupportedCodecs();
AssignPayloadTypesAndAddAssociatedRtxCodecs(encoder_factory_);
for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
LOG(LS_ERROR) << "SetRecvParameters called with unsupported video codec: "
@ -1524,20 +1458,12 @@ WebRtcVideoChannel::WebRtcVideoSendStream::VideoSendStreamParameters::
conference_mode(false),
codec_settings(codec_settings) {}
EncoderFactoryAdapter::AllocatedEncoder::AllocatedEncoder(
std::unique_ptr<webrtc::VideoEncoder> encoder,
bool is_hardware_accelerated,
bool has_internal_source)
: encoder(std::move(encoder)),
is_hardware_accelerated(is_hardware_accelerated),
has_internal_source(has_internal_source) {}
WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoSendStream::Config config,
const VideoOptions& options,
const EncoderFactoryAdapter* encoder_factory,
webrtc::VideoEncoderFactory* encoder_factory,
bool enable_cpu_overuse_detection,
int max_bitrate_bps,
const rtc::Optional<VideoCodecSettings>& codec_settings,
@ -1685,57 +1611,6 @@ WebRtcVideoChannel::WebRtcVideoSendStream::GetSsrcs() const {
return ssrcs_;
}
EncoderFactoryAdapter::AllocatedEncoder
CricketEncoderFactoryAdapter::CreateVideoEncoder(
const VideoCodec& codec) const {
// Try creating external encoder.
if (external_encoder_factory_ != nullptr &&
FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) {
std::unique_ptr<webrtc::VideoEncoder> external_encoder;
if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
// If it's a codec type we can simulcast, create a wrapped encoder.
external_encoder = std::unique_ptr<webrtc::VideoEncoder>(
new webrtc::SimulcastEncoderAdapter(external_encoder_factory_.get()));
} else {
external_encoder =
CreateScopedVideoEncoder(external_encoder_factory_.get(), codec);
}
if (external_encoder) {
std::unique_ptr<webrtc::VideoEncoder> internal_encoder(
new webrtc::VideoEncoderSoftwareFallbackWrapper(
codec, std::move(external_encoder)));
const webrtc::VideoCodecType codec_type =
webrtc::PayloadStringToCodecType(codec.name);
const bool has_internal_source =
external_encoder_factory_->EncoderTypeHasInternalSource(codec_type);
return AllocatedEncoder(std::move(internal_encoder),
true /* is_hardware_accelerated */,
has_internal_source);
}
}
// Try creating internal encoder.
std::unique_ptr<webrtc::VideoEncoder> internal_encoder;
if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(), codec)) {
if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
internal_encoder = std::unique_ptr<webrtc::VideoEncoder>(
new webrtc::VP8EncoderSimulcastProxy(
internal_encoder_factory_.get()));
} else {
internal_encoder = std::unique_ptr<webrtc::VideoEncoder>(
internal_encoder_factory_->CreateVideoEncoder(codec));
}
return AllocatedEncoder(std::move(internal_encoder),
false /* is_hardware_accelerated */,
false /* has_internal_source */);
}
// This shouldn't happen, we should not be trying to create something we don't
// support.
RTC_NOTREACHED();
return AllocatedEncoder();
}
void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec(
const VideoCodecSettings& codec_settings,
bool force_encoder_allocation) {
@ -1749,15 +1624,18 @@ void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec(
std::unique_ptr<webrtc::VideoEncoder> new_encoder;
if (force_encoder_allocation || !allocated_encoder_ ||
allocated_codec_ != codec_settings.codec) {
EncoderFactoryAdapter::AllocatedEncoder new_allocated_encoder =
encoder_factory_->CreateVideoEncoder(codec_settings.codec);
new_encoder = std::unique_ptr<webrtc::VideoEncoder>(
std::move(new_allocated_encoder.encoder));
const webrtc::SdpVideoFormat format(codec_settings.codec.name,
codec_settings.codec.params);
new_encoder = encoder_factory_->CreateVideoEncoder(format);
parameters_.config.encoder_settings.encoder = new_encoder.get();
const webrtc::VideoEncoderFactory::CodecInfo info =
encoder_factory_->QueryVideoEncoder(format);
parameters_.config.encoder_settings.full_overuse_time =
new_allocated_encoder.is_hardware_accelerated;
info.is_hardware_accelerated;
parameters_.config.encoder_settings.internal_source =
new_allocated_encoder.has_internal_source;
info.has_internal_source;
} else {
new_encoder = std::move(allocated_encoder_);
}
@ -2131,7 +2009,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoReceiveStream::Config config,
const DecoderFactoryAdapter* decoder_factory,
DecoderFactoryAdapter* decoder_factory,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
const webrtc::FlexfecReceiveStream::Config& flexfec_config)
@ -2182,30 +2060,6 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const {
}
}
std::unique_ptr<webrtc::VideoDecoder>
CricketDecoderFactoryAdapter::CreateVideoDecoder(
const VideoCodec& codec,
const VideoDecoderParams& decoder_params) const {
if (external_decoder_factory_ != nullptr) {
std::unique_ptr<webrtc::VideoDecoder> external_decoder =
CreateScopedVideoDecoder(external_decoder_factory_.get(), codec,
decoder_params);
if (external_decoder) {
webrtc::VideoCodecType type =
webrtc::PayloadStringToCodecType(codec.name);
std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
new webrtc::VideoDecoderSoftwareFallbackWrapper(
type, std::move(external_decoder)));
return internal_decoder;
}
}
std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
internal_decoder_factory_->CreateVideoDecoderWithParams(codec,
decoder_params));
return internal_decoder;
}
void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
const std::vector<VideoCodecSettings>& recv_codecs,
DecoderMap* old_decoders) {
@ -2224,9 +2078,10 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
old_decoders->erase(it);
}
if (!new_decoder) {
new_decoder = decoder_factory_->CreateVideoDecoder(recv_codec.codec,
{stream_params_.id});
if (!new_decoder && decoder_factory_) {
decoder_factory_->SetReceiveStreamId(stream_params_.id);
new_decoder = decoder_factory_->CreateVideoDecoder(webrtc::SdpVideoFormat(
recv_codec.codec.name, recv_codec.codec.params));
}
webrtc::VideoReceiveStream::Decoder decoder;

19
media/engine/webrtcvideoengine.h
View File

@ -51,7 +51,6 @@ class Thread;
namespace cricket {
class DecoderFactoryAdapter;
class EncoderFactoryAdapter;
class VideoCapturer;
class VideoProcessor;
class VideoRenderer;
@ -122,7 +121,7 @@ class WebRtcVideoEngine {
private:
const std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
const std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
const std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory_;
};
class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
@ -130,8 +129,8 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
WebRtcVideoChannel(webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options,
const EncoderFactoryAdapter* encoder_factory,
const DecoderFactoryAdapter* decoder_factory);
webrtc::VideoEncoderFactory* encoder_factory,
DecoderFactoryAdapter* decoder_factory);
~WebRtcVideoChannel() override;
// VideoMediaChannel implementation
@ -259,7 +258,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
const StreamParams& sp,
webrtc::VideoSendStream::Config config,
const VideoOptions& options,
const EncoderFactoryAdapter* encoder_factory,
webrtc::VideoEncoderFactory* encoder_factory,
bool enable_cpu_overuse_detection,
int max_bitrate_bps,
const rtc::Optional<VideoCodecSettings>& codec_settings,
@ -337,7 +336,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
const bool enable_cpu_overuse_detection_;
rtc::VideoSourceInterface<webrtc::VideoFrame>* source_
RTC_ACCESS_ON(&thread_checker_);
const EncoderFactoryAdapter* const encoder_factory_
webrtc::VideoEncoderFactory* const encoder_factory_
RTC_ACCESS_ON(&thread_checker_);
webrtc::VideoSendStream* stream_ RTC_ACCESS_ON(&thread_checker_);
@ -369,7 +368,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoReceiveStream::Config config,
const DecoderFactoryAdapter* decoder_factory,
DecoderFactoryAdapter* decoder_factory,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
const webrtc::FlexfecReceiveStream::Config& flexfec_config);
@ -430,7 +429,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
webrtc::FlexfecReceiveStream::Config flexfec_config_;
webrtc::FlexfecReceiveStream* flexfec_stream_;
const DecoderFactoryAdapter* decoder_factory_;
DecoderFactoryAdapter* decoder_factory_;
DecoderMap allocated_decoders_;
rtc::CriticalSection sink_lock_;
@ -494,8 +493,8 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
rtc::Optional<VideoCodecSettings> send_codec_;
rtc::Optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
const EncoderFactoryAdapter* const encoder_factory_;
const DecoderFactoryAdapter* const decoder_factory_;
webrtc::VideoEncoderFactory* const encoder_factory_;
DecoderFactoryAdapter* const decoder_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