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

Add receive stream id argument to CreateDecoder() method

Browse Source 
This is necessary to migrate some clients so that we can move forward
with removal of cricket::WebRtcVideoDecoderFactory.

TBR=stefan@webrtc.org

Bug: webrtc:7925
Change-Id: Icc2949e3f7f3137d1b68eb30874f14a33168e41f
Reviewed-on: https://webrtc-review.googlesource.com/97500
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Anders Carlsson <andersc@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24671}
This commit is contained in:
Magnus Jedvert
2018-09-03 18:07:56 +02:00
committed by Commit Bot
parent b0fc70303d
commit 59ab3536a4
7 changed files with 61 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
api/video_codecs/BUILD.gn
View File

@ -21,6 +21,7 @@ rtc_source_set("video_codecs_api") {
"video_codec.h",
"video_decoder.cc",
"video_decoder.h",
"video_decoder_factory.cc",
"video_decoder_factory.h",
"video_encoder.cc",
"video_encoder.h",

23
api/video_codecs/video_decoder_factory.cc Normal file
View File

@ -0,0 +1,23 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_decoder.h"
namespace webrtc {
std::unique_ptr<VideoDecoder> VideoDecoderFactory::LegacyCreateVideoDecoder(
const SdpVideoFormat& format,
const std::string& receive_stream_id) {
return CreateVideoDecoder(format);
}
} // namespace webrtc

7
api/video_codecs/video_decoder_factory.h
View File

@ -12,6 +12,7 @@
#define API_VIDEO_CODECS_VIDEO_DECODER_FACTORY_H_
#include <memory>
#include <string>
#include <vector>
namespace webrtc {
@ -31,6 +32,12 @@ class VideoDecoderFactory {
virtual std::unique_ptr<VideoDecoder> CreateVideoDecoder(
const SdpVideoFormat& format) = 0;
// Note: Do not call or override this method! This method is a legacy
// workaround and is scheduled for removal without notice.
virtual std::unique_ptr<VideoDecoder> LegacyCreateVideoDecoder(
const SdpVideoFormat& format,
const std::string& receive_stream_id);
virtual ~VideoDecoderFactory() {}
};

35
media/engine/convert_legacy_video_factory.cc
View File

@ -10,6 +10,7 @@
#include "media/engine/convert_legacy_video_factory.h"
#include <string>
#include <utility>
#include <vector>
@ -186,9 +187,15 @@ class CricketToWebRtcDecoderFactory : public webrtc::VideoDecoderFactory {
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 CreateScopedVideoDecoder(external_decoder_factory_.get(),
VideoCodec(format), {});
VideoCodec(format), {receive_stream_id});
}
return nullptr;
}
@ -214,13 +221,14 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory {
absl::make_unique<CricketToWebRtcDecoderFactory>(
std::move(external_decoder_factory))) {}
explicit DecoderAdapter(
std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory)
: internal_decoder_factory_(new webrtc::InternalDecoderFactory()),
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 {
std::unique_ptr<webrtc::VideoDecoder> internal_decoder;
if (IsFormatSupported(internal_decoder_factory_->GetSupportedFormats(),
format)) {
@ -229,7 +237,8 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory {
std::unique_ptr<webrtc::VideoDecoder> external_decoder = nullptr;
if (external_decoder_factory_ != nullptr) {
external_decoder = external_decoder_factory_->CreateVideoDecoder(format);
external_decoder = external_decoder_factory_->LegacyCreateVideoDecoder(
format, receive_stream_id);
}
if (internal_decoder && external_decoder) {
@ -270,22 +279,10 @@ std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
new EncoderAdapter(std::move(external_encoder_factory)));
}
std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
std::unique_ptr<webrtc::VideoEncoderFactory> 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)));
}
std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory) {
return std::unique_ptr<webrtc::VideoDecoderFactory>(
new DecoderAdapter(std::move(external_decoder_factory)));
}
} // namespace cricket

6
media/engine/convert_legacy_video_factory.h
View File

@ -30,15 +30,9 @@ class WebRtcVideoDecoderFactory;
std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory);
std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory);
std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory);
std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory);
} // namespace cricket
#endif // MEDIA_ENGINE_CONVERT_LEGACY_VIDEO_FACTORY_H_

101
media/engine/webrtcvideoengine.cc
View File

@ -41,89 +41,6 @@
namespace cricket {
// 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 DecoderFactoryAdapter {
public:
#if defined(USE_BUILTIN_SW_CODECS)
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_))) {}
#endif
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 {
// Video decoder class to be used for unknown codecs. Doesn't support decoding
@ -536,8 +453,8 @@ void DefaultUnsignalledSsrcHandler::SetDefaultSink(
WebRtcVideoEngine::WebRtcVideoEngine(
std::unique_ptr<WebRtcVideoEncoderFactory> external_video_encoder_factory,
std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory)
: decoder_factory_(
new DecoderFactoryAdapter(std::move(external_video_decoder_factory))),
: decoder_factory_(ConvertVideoDecoderFactory(
std::move(external_video_decoder_factory))),
encoder_factory_(ConvertVideoEncoderFactory(
std::move(external_video_encoder_factory))) {
RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
@ -547,8 +464,7 @@ WebRtcVideoEngine::WebRtcVideoEngine(
WebRtcVideoEngine::WebRtcVideoEngine(
std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory)
: decoder_factory_(
new DecoderFactoryAdapter(std::move(video_decoder_factory))),
: decoder_factory_(std::move(video_decoder_factory)),
encoder_factory_(std::move(video_encoder_factory)) {
RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
}
@ -605,7 +521,7 @@ WebRtcVideoChannel::WebRtcVideoChannel(
const MediaConfig& config,
const VideoOptions& options,
webrtc::VideoEncoderFactory* encoder_factory,
DecoderFactoryAdapter* decoder_factory)
webrtc::VideoDecoderFactory* decoder_factory)
: VideoMediaChannel(config),
call_(call),
unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
@ -2226,7 +2142,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoReceiveStream::Config config,
DecoderFactoryAdapter* decoder_factory,
webrtc::VideoDecoderFactory* decoder_factory,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
const webrtc::FlexfecReceiveStream::Config& flexfec_config)
@ -2314,9 +2230,10 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
}
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));
new_decoder = decoder_factory_->LegacyCreateVideoDecoder(
webrtc::SdpVideoFormat(recv_codec.codec.name,
recv_codec.codec.params),
stream_params_.id);
}
// If we still have no valid decoder, we have to create a "Null" decoder

11
media/engine/webrtcvideoengine.h
View File

@ -50,7 +50,6 @@ class Thread;
namespace cricket {
class DecoderFactoryAdapter;
class WebRtcVideoChannel;
class UnsignalledSsrcHandler {
@ -107,7 +106,7 @@ class WebRtcVideoEngine {
RtpCapabilities GetCapabilities() const;
private:
const std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
const std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_;
const std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory_;
};
@ -117,7 +116,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
const MediaConfig& config,
const VideoOptions& options,
webrtc::VideoEncoderFactory* encoder_factory,
DecoderFactoryAdapter* decoder_factory);
webrtc::VideoDecoderFactory* decoder_factory);
~WebRtcVideoChannel() override;
// VideoMediaChannel implementation
@ -350,7 +349,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoReceiveStream::Config config,
DecoderFactoryAdapter* decoder_factory,
webrtc::VideoDecoderFactory* decoder_factory,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
const webrtc::FlexfecReceiveStream::Config& flexfec_config);
@ -415,7 +414,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
webrtc::FlexfecReceiveStream::Config flexfec_config_;
webrtc::FlexfecReceiveStream* flexfec_stream_;
DecoderFactoryAdapter* decoder_factory_;
webrtc::VideoDecoderFactory* decoder_factory_;
DecoderMap allocated_decoders_;
rtc::CriticalSection sink_lock_;
@ -480,7 +479,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
absl::optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
webrtc::VideoEncoderFactory* const encoder_factory_;
DecoderFactoryAdapter* const decoder_factory_;
webrtc::VideoDecoderFactory* 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