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

Remove transitional shim classes

Browse Source 
Bug: webrtc:13931
Change-Id: Iaeb0b892aca4b4d64d13a025adc7564e572e0f26
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/307940
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40232}
This commit is contained in:
Harald Alvestrand 2023-06-06 09:45:45 +00:00 committed by WebRTC LUCI CQ
parent ade07ca45e
commit 847208e9d6
8 changed files with 172 additions and 624 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

449
media/base/media_channel_impl.h
View File

@ -388,455 +388,6 @@ class VoiceMediaChannel : public MediaChannel,
}
};
// The externally exposed objects that support the Send and Receive interfaces.
// These dispatch their functions to the underlying MediaChannel objects.
class VoiceMediaSendChannel : public VoiceMediaSendChannelInterface {
public:
explicit VoiceMediaSendChannel(VoiceMediaChannel* impl) : impl_(impl) {}
virtual ~VoiceMediaSendChannel() {}
VoiceMediaSendChannelInterface* AsVoiceSendChannel() override { return this; }
VideoMediaSendChannelInterface* AsVideoSendChannel() override {
RTC_CHECK_NOTREACHED();
return nullptr;
}
// Implementation of MediaBaseChannelInterface
cricket::MediaType media_type() const override { return MEDIA_TYPE_AUDIO; }
void OnPacketSent(const rtc::SentPacket& sent_packet) override {
impl()->OnPacketSent(sent_packet);
}
void OnReadyToSend(bool ready) override { impl()->OnReadyToSend(ready); }
void OnNetworkRouteChanged(absl::string_view transport_name,
const rtc::NetworkRoute& network_route) override {
impl()->OnNetworkRouteChanged(transport_name, network_route);
}
void SetExtmapAllowMixed(bool extmap_allow_mixed) override {
impl()->SetExtmapAllowMixed(extmap_allow_mixed);
}
bool ExtmapAllowMixed() const override { return impl()->ExtmapAllowMixed(); }
void SetInterface(MediaChannelNetworkInterface* iface) override {
return impl()->SetInterface(iface);
}
bool HasNetworkInterface() const override {
return impl()->HasNetworkInterface();
}
// Implementation of MediaSendChannelInterface
bool AddSendStream(const StreamParams& sp) override {
return impl()->AddSendStream(sp);
}
bool RemoveSendStream(uint32_t ssrc) override {
return impl()->RemoveSendStream(ssrc);
}
void SetFrameEncryptor(uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameEncryptorInterface>
frame_encryptor) override {
impl()->SetFrameEncryptor(ssrc, frame_encryptor);
}
webrtc::RTCError SetRtpSendParameters(
uint32_t ssrc,
const webrtc::RtpParameters& parameters,
webrtc::SetParametersCallback callback = nullptr) override {
return impl()->SetRtpSendParameters(ssrc, parameters, std::move(callback));
}
void SetEncoderToPacketizerFrameTransformer(
uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override {
return impl()->SetEncoderToPacketizerFrameTransformer(ssrc,
frame_transformer);
}
void SetEncoderSelector(uint32_t ssrc,
webrtc::VideoEncoderFactory::EncoderSelectorInterface*
encoder_selector) override {
impl()->SetEncoderSelector(ssrc, encoder_selector);
}
webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override {
return impl()->GetRtpSendParameters(ssrc);
}
void SetSsrcListChangedCallback(
absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override {
impl()->SetSsrcListChangedCallback(std::move(callback));
}
// Implementation of VoiceMediaSendChannel
bool SetSendParameters(const AudioSendParameters& params) override {
return impl()->SetSendParameters(params);
}
void SetSend(bool send) override { return impl()->SetSend(send); }
bool SetAudioSend(uint32_t ssrc,
bool enable,
const AudioOptions* options,
AudioSource* source) override {
return impl()->SetAudioSend(ssrc, enable, options, source);
}
bool CanInsertDtmf() override { return impl()->CanInsertDtmf(); }
bool InsertDtmf(uint32_t ssrc, int event, int duration) override {
return impl()->InsertDtmf(ssrc, event, duration);
}
bool GetStats(VoiceMediaSendInfo* info) override {
return impl_->GetSendStats(info);
}
bool SenderNackEnabled() const override { return impl_->SenderNackEnabled(); }
bool SenderNonSenderRttEnabled() const override {
return impl_->SenderNonSenderRttEnabled();
}
bool SendCodecHasNack() const override { return impl()->SendCodecHasNack(); }
void SetSendCodecChangedCallback(
absl::AnyInvocable<void()> callback) override {
impl()->SetSendCodecChangedCallback(std::move(callback));
}
MediaChannel* ImplForTesting() override { return impl_; }
private:
VoiceMediaSendChannelInterface* impl() { return impl_; }
const VoiceMediaSendChannelInterface* impl() const { return impl_; }
VoiceMediaChannel* impl_;
};
class VoiceMediaReceiveChannel : public VoiceMediaReceiveChannelInterface {
public:
explicit VoiceMediaReceiveChannel(VoiceMediaChannel* impl) : impl_(impl) {}
virtual ~VoiceMediaReceiveChannel() {}
VoiceMediaReceiveChannelInterface* AsVoiceReceiveChannel() override {
return this;
}
VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override {
RTC_DCHECK_NOTREACHED();
return nullptr;
}
// Implementation of MediaBaseChannelInterface
cricket::MediaType media_type() const override { return MEDIA_TYPE_AUDIO; }
void OnPacketReceived(const webrtc::RtpPacketReceived& packet) override {
impl()->OnPacketReceived(packet);
}
void SetInterface(MediaChannelNetworkInterface* iface) override {
return impl()->SetInterface(iface);
}
// Implementation of Delayable
bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override {
return impl()->SetBaseMinimumPlayoutDelayMs(ssrc, delay_ms);
}
absl::optional<int> GetBaseMinimumPlayoutDelayMs(
uint32_t ssrc) const override {
return impl()->GetBaseMinimumPlayoutDelayMs(ssrc);
}
// Implementation of MediaReceiveChannelInterface
bool AddRecvStream(const StreamParams& sp) override {
return impl()->AddRecvStream(sp);
}
bool RemoveRecvStream(uint32_t ssrc) override {
return impl()->RemoveRecvStream(ssrc);
}
void ResetUnsignaledRecvStream() override {
return impl()->ResetUnsignaledRecvStream();
}
void ChooseReceiverReportSsrc(const std::set<uint32_t>& choices) override {
return impl()->ChooseReceiverReportSsrc(choices);
}
absl::optional<uint32_t> GetUnsignaledSsrc() const override {
return impl()->GetUnsignaledSsrc();
}
void OnDemuxerCriteriaUpdatePending() override {
impl()->OnDemuxerCriteriaUpdatePending();
}
void OnDemuxerCriteriaUpdateComplete() override {
impl()->OnDemuxerCriteriaUpdateComplete();
}
void SetFrameDecryptor(uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
frame_decryptor) override {
impl()->SetFrameDecryptor(ssrc, frame_decryptor);
}
void SetDepacketizerToDecoderFrameTransformer(
uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override {
impl()->SetDepacketizerToDecoderFrameTransformer(ssrc, frame_transformer);
}
// Implementation of VoiceMediaReceiveChannelInterface
bool SetRecvParameters(const AudioRecvParameters& params) override {
return impl()->SetRecvParameters(params);
}
webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override {
return impl()->GetRtpReceiveParameters(ssrc);
}
std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override {
return impl()->GetSources(ssrc);
}
webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override {
return impl()->GetDefaultRtpReceiveParameters();
}
void SetPlayout(bool playout) override { return impl()->SetPlayout(playout); }
bool SetOutputVolume(uint32_t ssrc, double volume) override {
return impl()->SetOutputVolume(ssrc, volume);
}
bool SetDefaultOutputVolume(double volume) override {
return impl()->SetDefaultOutputVolume(volume);
}
void SetRawAudioSink(
uint32_t ssrc,
std::unique_ptr<webrtc::AudioSinkInterface> sink) override {
return impl()->SetRawAudioSink(ssrc, std::move(sink));
}
void SetDefaultRawAudioSink(
std::unique_ptr<webrtc::AudioSinkInterface> sink) override {
return impl()->SetDefaultRawAudioSink(std::move(sink));
}
bool GetStats(VoiceMediaReceiveInfo* info, bool reset_legacy) override {
return impl_->GetReceiveStats(info, reset_legacy);
}
void SetReceiveNackEnabled(bool enabled) override {
impl_->SetReceiveNackEnabled(enabled);
}
void SetReceiveNonSenderRttEnabled(bool enabled) override {
impl_->SetReceiveNonSenderRttEnabled(enabled);
}
MediaChannel* ImplForTesting() override { return impl_; }
private:
VoiceMediaReceiveChannelInterface* impl() { return impl_; }
const VoiceMediaReceiveChannelInterface* impl() const { return impl_; }
VoiceMediaChannel* impl_;
};
class VideoMediaSendChannel : public VideoMediaSendChannelInterface {
public:
explicit VideoMediaSendChannel(VideoMediaChannel* impl) : impl_(impl) {}
VideoMediaSendChannelInterface* AsVideoSendChannel() override { return this; }
VoiceMediaSendChannelInterface* AsVoiceSendChannel() override {
RTC_CHECK_NOTREACHED();
return nullptr;
}
// Implementation of MediaBaseChannelInterface
cricket::MediaType media_type() const override { return MEDIA_TYPE_VIDEO; }
void OnPacketSent(const rtc::SentPacket& sent_packet) override {
impl()->OnPacketSent(sent_packet);
}
void OnReadyToSend(bool ready) override { impl()->OnReadyToSend(ready); }
void OnNetworkRouteChanged(absl::string_view transport_name,
const rtc::NetworkRoute& network_route) override {
impl()->OnNetworkRouteChanged(transport_name, network_route);
}
void SetExtmapAllowMixed(bool extmap_allow_mixed) override {
impl()->SetExtmapAllowMixed(extmap_allow_mixed);
}
bool HasNetworkInterface() const override {
return impl()->HasNetworkInterface();
}
bool ExtmapAllowMixed() const override { return impl()->ExtmapAllowMixed(); }
void SetInterface(MediaChannelNetworkInterface* iface) override {
return impl()->SetInterface(iface);
}
// Implementation of MediaSendChannelInterface
bool AddSendStream(const StreamParams& sp) override {
return impl()->AddSendStream(sp);
}
bool RemoveSendStream(uint32_t ssrc) override {
return impl()->RemoveSendStream(ssrc);
}
void SetFrameEncryptor(uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameEncryptorInterface>
frame_encryptor) override {
impl()->SetFrameEncryptor(ssrc, frame_encryptor);
}
webrtc::RTCError SetRtpSendParameters(
uint32_t ssrc,
const webrtc::RtpParameters& parameters,
webrtc::SetParametersCallback callback = nullptr) override {
return impl()->SetRtpSendParameters(ssrc, parameters, std::move(callback));
}
void SetEncoderToPacketizerFrameTransformer(
uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override {
return impl()->SetEncoderToPacketizerFrameTransformer(ssrc,
frame_transformer);
}
void SetEncoderSelector(uint32_t ssrc,
webrtc::VideoEncoderFactory::EncoderSelectorInterface*
encoder_selector) override {
impl()->SetEncoderSelector(ssrc, encoder_selector);
}
webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override {
return impl()->GetRtpSendParameters(ssrc);
}
// Implementation of VideoMediaSendChannelInterface
bool SetSendParameters(const VideoSendParameters& params) override {
return impl()->SetSendParameters(params);
}
absl::optional<VideoCodec> GetSendCodec() override {
return impl()->GetSendCodec();
}
bool SetSend(bool send) override { return impl()->SetSend(send); }
bool SetVideoSend(
uint32_t ssrc,
const VideoOptions* options,
rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override {
return impl()->SetVideoSend(ssrc, options, source);
}
void GenerateSendKeyFrame(uint32_t ssrc,
const std::vector<std::string>& rids) override {
return impl()->GenerateSendKeyFrame(ssrc, rids);
}
void SetVideoCodecSwitchingEnabled(bool enabled) override {
return impl()->SetVideoCodecSwitchingEnabled(enabled);
}
bool GetStats(VideoMediaSendInfo* info) override {
return impl_->GetSendStats(info);
}
void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override {
return impl_->FillBitrateInfo(bwe_info);
}
// Information queries to support SetReceiverFeedbackParameters
webrtc::RtcpMode SendCodecRtcpMode() const override {
return impl()->SendCodecRtcpMode();
}
bool SendCodecHasLntf() const override { return impl()->SendCodecHasLntf(); }
bool SendCodecHasNack() const override { return impl()->SendCodecHasNack(); }
absl::optional<int> SendCodecRtxTime() const override {
return impl()->SendCodecRtxTime();
}
void SetSsrcListChangedCallback(
absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override {
impl()->SetSsrcListChangedCallback(std::move(callback));
}
void SetSendCodecChangedCallback(
absl::AnyInvocable<void()> callback) override {
impl()->SetSendCodecChangedCallback(std::move(callback));
}
MediaChannel* ImplForTesting() override { return impl_; }
private:
VideoMediaSendChannelInterface* impl() { return impl_; }
const VideoMediaSendChannelInterface* impl() const { return impl_; }
VideoMediaChannel* const impl_;
};
class VideoMediaReceiveChannel : public VideoMediaReceiveChannelInterface {
public:
explicit VideoMediaReceiveChannel(VideoMediaChannel* impl) : impl_(impl) {}
VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override {
return this;
}
VoiceMediaReceiveChannelInterface* AsVoiceReceiveChannel() override {
RTC_DCHECK_NOTREACHED();
return nullptr;
}
// Implementation of MediaBaseChannelInterface
cricket::MediaType media_type() const override { return MEDIA_TYPE_VIDEO; }
void OnPacketReceived(const webrtc::RtpPacketReceived& packet) override {
impl()->OnPacketReceived(packet);
}
// Implementation of Delayable
bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override {
return impl()->SetBaseMinimumPlayoutDelayMs(ssrc, delay_ms);
}
absl::optional<int> GetBaseMinimumPlayoutDelayMs(
uint32_t ssrc) const override {
return impl()->GetBaseMinimumPlayoutDelayMs(ssrc);
}
// Implementation of MediaReceiveChannelInterface
void SetInterface(MediaChannelNetworkInterface* iface) override {
return impl()->SetInterface(iface);
}
bool AddRecvStream(const StreamParams& sp) override {
return impl()->AddRecvStream(sp);
}
bool RemoveRecvStream(uint32_t ssrc) override {
return impl()->RemoveRecvStream(ssrc);
}
void ResetUnsignaledRecvStream() override {
return impl()->ResetUnsignaledRecvStream();
}
absl::optional<uint32_t> GetUnsignaledSsrc() const override {
return impl()->GetUnsignaledSsrc();
}
void ChooseReceiverReportSsrc(const std::set<uint32_t>& choices) override {
return impl()->ChooseReceiverReportSsrc(choices);
}
void OnDemuxerCriteriaUpdatePending() override {
impl()->OnDemuxerCriteriaUpdatePending();
}
void OnDemuxerCriteriaUpdateComplete() override {
impl()->OnDemuxerCriteriaUpdateComplete();
}
void SetFrameDecryptor(uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
frame_decryptor) override {
impl()->SetFrameDecryptor(ssrc, frame_decryptor);
}
void SetDepacketizerToDecoderFrameTransformer(
uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override {
impl()->SetDepacketizerToDecoderFrameTransformer(ssrc, frame_transformer);
}
// Implementation of VideoMediaReceiveChannelInterface
bool SetRecvParameters(const VideoRecvParameters& params) override {
return impl()->SetRecvParameters(params);
}
webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override {
return impl()->GetRtpReceiveParameters(ssrc);
}
webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override {
return impl()->GetDefaultRtpReceiveParameters();
}
bool SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
return impl()->SetSink(ssrc, sink);
}
void SetDefaultSink(
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
return impl()->SetDefaultSink(sink);
}
void RequestRecvKeyFrame(uint32_t ssrc) override {
return impl()->RequestRecvKeyFrame(ssrc);
}
std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override {
return impl()->GetSources(ssrc);
}
// Set recordable encoded frame callback for `ssrc`
void SetRecordableEncodedFrameCallback(
uint32_t ssrc,
std::function<void(const webrtc::RecordableEncodedFrame&)> callback)
override {
return impl()->SetRecordableEncodedFrameCallback(ssrc, std::move(callback));
}
// Clear recordable encoded frame callback for `ssrc`
void ClearRecordableEncodedFrameCallback(uint32_t ssrc) override {
impl()->ClearRecordableEncodedFrameCallback(ssrc);
}
bool GetStats(VideoMediaReceiveInfo* info) override {
return impl_->GetReceiveStats(info);
}
void SetReceiverFeedbackParameters(bool lntf_enabled,
bool nack_enabled,
webrtc::RtcpMode rtcp_mode,
absl::optional<int> rtx_time) override {
impl()->SetReceiverFeedbackParameters(lntf_enabled, nack_enabled, rtcp_mode,
rtx_time);
}
void SetReceive(bool receive) override { impl()->SetReceive(receive); }
MediaChannel* ImplForTesting() override { return impl_; }
bool AddDefaultRecvStreamForTesting(const StreamParams& sp) override {
return impl()->AddDefaultRecvStreamForTesting(sp);
}
private:
VideoMediaReceiveChannelInterface* impl() { return impl_; }
const VideoMediaReceiveChannelInterface* impl() const { return impl_; }
VideoMediaChannel* const impl_;
};
} // namespace cricket
#endif // MEDIA_BASE_MEDIA_CHANNEL_IMPL_H_

2
media/base/media_channel_shim.h
View File

@ -90,7 +90,7 @@ class VoiceMediaShimChannel : public VoiceMediaChannel {
}
// Implementation of MediaBaseChannelInterface
cricket::MediaType media_type() const override { return MEDIA_TYPE_VIDEO; }
cricket::MediaType media_type() const override { return MEDIA_TYPE_AUDIO; }
// Implementation of MediaSendChannelInterface
void OnPacketSent(const rtc::SentPacket& sent_packet) override {

112
media/engine/webrtc_video_engine_unittest.cc
View File

@ -520,7 +520,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeCapturer) {
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
EXPECT_TRUE(send_channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
// Add CVO extension.
@ -558,7 +558,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) {
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
// Add CVO extension.
const int id = 1;
cricket::VideoSendParameters parameters;
@ -583,7 +583,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) {
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
EXPECT_TRUE(send_channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
@ -628,7 +628,7 @@ TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
cricket::MediaChannel::Role::kBoth, call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
EXPECT_TRUE(send_channel->AddSendStream(StreamParams::CreateLegacy(123)));
@ -645,7 +645,7 @@ TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
cricket::MediaChannel::Role::kBoth, call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
EXPECT_TRUE(send_channel->AddSendStream(StreamParams::CreateLegacy(123)));
VideoMediaSendInfo send_info;
@ -659,7 +659,7 @@ TEST_F(WebRtcVideoEngineTest, UseFactoryForVp8WhenSupported) {
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
send_channel->OnReadyToSend(true);
@ -740,8 +740,7 @@ TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
auto receive_channel =
std::make_unique<VideoMediaReceiveChannel>(channel.get());
auto receive_channel = channel->AsVideoReceiveChannel();
EXPECT_TRUE(receive_channel->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
@ -754,7 +753,7 @@ TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
call_.reset(fake_call);
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
EXPECT_TRUE(
send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@ -1008,7 +1007,7 @@ TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
@ -1055,7 +1054,7 @@ TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) {
cricket::MediaChannel::Role::kBoth, call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(GetEngineCodec("H264"));
EXPECT_TRUE(channel->SetSendParameters(parameters));
@ -1089,7 +1088,7 @@ TEST_F(WebRtcVideoEngineTest,
cricket::MediaChannel::Role::kBoth, call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel->SetSendParameters(parameters));
@ -1129,7 +1128,7 @@ TEST_F(WebRtcVideoEngineTest,
cricket::MediaChannel::Role::kBoth, call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(GetEngineCodec("H264"));
EXPECT_TRUE(channel->SetSendParameters(parameters));
@ -1162,7 +1161,7 @@ TEST_F(WebRtcVideoEngineTest, SimulcastEnabledForH264) {
cricket::MediaChannel::Role::kBoth, call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(GetEngineCodec("H264"));
@ -1287,8 +1286,7 @@ TEST_F(WebRtcVideoEngineTest, RegisterDecodersIfSupported) {
std::unique_ptr<VideoMediaChannel> channel(
SetRecvParamsWithSupportedCodecs(parameters.codecs));
auto receive_channel =
std::make_unique<VideoMediaReceiveChannel>(channel.get());
auto receive_channel = channel->AsVideoReceiveChannel();
EXPECT_TRUE(receive_channel->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
@ -1317,8 +1315,7 @@ TEST_F(WebRtcVideoEngineTest, RegisterH264DecoderIfSupported) {
std::unique_ptr<VideoMediaChannel> channel(
SetRecvParamsWithSupportedCodecs(codecs));
auto receive_channel =
std::make_unique<VideoMediaReceiveChannel>(channel.get());
auto receive_channel = channel->AsVideoReceiveChannel();
EXPECT_TRUE(receive_channel->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
@ -1336,8 +1333,7 @@ TEST_F(WebRtcVideoEngineTest, GetSourcesWithNonExistingSsrc) {
parameters.codecs.push_back(GetEngineCodec("VP8"));
std::unique_ptr<VideoMediaChannel> channel(
SetRecvParamsWithSupportedCodecs(parameters.codecs));
auto receive_channel =
std::make_unique<VideoMediaReceiveChannel>(channel.get());
auto receive_channel = channel->AsVideoReceiveChannel();
EXPECT_TRUE(receive_channel->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
@ -1463,8 +1459,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
std::unique_ptr<VideoMediaChannel> send_channel(engine.CreateMediaChannel(
cricket::MediaChannel::Role::kBoth, call.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(), rate_allocator_factory.get()));
auto send_send_channel =
std::make_unique<VideoMediaSendChannel>(send_channel.get());
auto send_send_channel = send_channel->AsVideoSendChannel();
cricket::VideoSendParameters send_parameters;
send_parameters.codecs.push_back(engine_codecs.at(0));
@ -1488,8 +1483,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
std::unique_ptr<VideoMediaChannel> recv_channel(engine.CreateMediaChannel(
cricket::MediaChannel::Role::kBoth, call.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(), rate_allocator_factory.get()));
auto receive_channel =
std::make_unique<VideoMediaReceiveChannel>(recv_channel.get());
auto receive_channel = recv_channel->AsVideoReceiveChannel();
cricket::VideoRecvParameters recv_parameters;
recv_parameters.codecs.push_back(engine_codecs.at(0));
@ -1510,7 +1504,7 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
std::unique_ptr<FakeCall> fake_call(new FakeCall());
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
auto send_channel = std::make_unique<VideoMediaSendChannel>(channel.get());
auto send_channel = channel->AsVideoSendChannel();
ASSERT_TRUE(
send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@ -1621,9 +1615,8 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test {
cricket::VideoOptions(),
webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()))) {
send_channel_ = std::make_unique<VideoMediaSendChannel>(channel_.get());
receive_channel_ =
std::make_unique<VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
network_interface_.SetDestination(channel_.get());
channel_->SetInterface(&network_interface_);
@ -1658,8 +1651,8 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test {
video_bitrate_allocator_factory_;
WebRtcVideoEngine engine_;
std::unique_ptr<VideoMediaChannel> channel_;
std::unique_ptr<VideoMediaSendChannel> send_channel_;
std::unique_ptr<VideoMediaReceiveChannel> receive_channel_;
VideoMediaSendChannelInterface* send_channel_;
VideoMediaReceiveChannelInterface* receive_channel_;
cricket::FakeNetworkInterface network_interface_;
cricket::FakeVideoRenderer renderer_;
};
@ -1802,9 +1795,8 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
cricket::MediaChannel::Role::kBoth, call_.get(), media_config,
cricket::VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
send_channel_ = std::make_unique<VideoMediaSendChannel>(channel_.get());
receive_channel_ =
std::make_unique<VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
send_channel_->OnReadyToSend(true);
receive_channel_->SetReceive(true);
EXPECT_TRUE(channel_.get() != NULL);
@ -2002,8 +1994,8 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
std::unique_ptr<webrtc::test::FrameForwarder> frame_forwarder_2_;
std::unique_ptr<VideoMediaChannel> channel_;
std::unique_ptr<VideoMediaSendChannel> send_channel_;
std::unique_ptr<VideoMediaReceiveChannel> receive_channel_;
VideoMediaSendChannelInterface* send_channel_;
VideoMediaReceiveChannelInterface* receive_channel_;
cricket::FakeNetworkInterface network_interface_;
cricket::FakeVideoRenderer renderer_;
@ -2667,10 +2659,8 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
cricket::MediaChannel::Role::kBoth, fake_call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
send_channel_ =
std::make_unique<cricket::VideoMediaSendChannel>(channel_.get());
receive_channel_ =
std::make_unique<cricket::VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
send_channel_->OnReadyToSend(true);
receive_channel_->SetReceive(true);
last_ssrc_ = 123;
@ -3009,8 +2999,8 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
cricket::FakeFrameSource frame_source_;
std::unique_ptr<FakeCall> fake_call_;
std::unique_ptr<VideoMediaChannel> channel_;
std::unique_ptr<VideoMediaSendChannel> send_channel_;
std::unique_ptr<VideoMediaReceiveChannel> receive_channel_;
VideoMediaSendChannelInterface* send_channel_;
VideoMediaReceiveChannelInterface* receive_channel_;
cricket::VideoSendParameters send_parameters_;
cricket::VideoRecvParameters recv_parameters_;
uint32_t last_ssrc_;
@ -3564,9 +3554,8 @@ TEST_F(WebRtcVideoChannelTest, SetMediaConfigSuspendBelowMinBitrate) {
cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config,
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
send_channel_.reset(new VideoMediaSendChannel(channel_.get()));
receive_channel_ =
std::make_unique<cricket::VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
send_channel_->OnReadyToSend(true);
channel_->SetSendParameters(send_parameters_);
@ -3579,9 +3568,8 @@ TEST_F(WebRtcVideoChannelTest, SetMediaConfigSuspendBelowMinBitrate) {
cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config,
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
send_channel_.reset(new VideoMediaSendChannel(channel_.get()));
receive_channel_ =
std::make_unique<cricket::VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
send_channel_->OnReadyToSend(true);
channel_->SetSendParameters(send_parameters_);
@ -4124,9 +4112,8 @@ TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) {
cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config,
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
send_channel_.reset(new VideoMediaSendChannel(channel_.get()));
receive_channel_ =
std::make_unique<cricket::VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
send_channel_->OnReadyToSend(true);
ASSERT_TRUE(channel_->SetSendParameters(parameters));
@ -4179,9 +4166,8 @@ void WebRtcVideoChannelTest::TestDegradationPreference(
cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config,
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
send_channel_.reset(new VideoMediaSendChannel(channel_.get()));
receive_channel_ =
std::make_unique<cricket::VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
send_channel_->OnReadyToSend(true);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
@ -4216,9 +4202,8 @@ void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse,
cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config,
VideoOptions(), webrtc::CryptoOptions(),
video_bitrate_allocator_factory_.get()));
send_channel_.reset(new VideoMediaSendChannel(channel_.get()));
receive_channel_ =
std::make_unique<cricket::VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
send_channel_->OnReadyToSend(true);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
@ -5549,13 +5534,13 @@ TEST_F(WebRtcVideoChannelTest, TestSetDscpOptions) {
new cricket::FakeNetworkInterface);
MediaConfig config;
std::unique_ptr<cricket::VideoMediaChannel> channel;
std::unique_ptr<cricket::VideoMediaSendChannel> send_channel;
cricket::VideoMediaSendChannelInterface* send_channel;
webrtc::RtpParameters parameters;
channel.reset(engine_.CreateMediaChannel(
cricket::MediaChannel::Role::kBoth, call_.get(), config, VideoOptions(),
webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()));
send_channel.reset(new VideoMediaSendChannel(channel_.get()));
send_channel = channel->AsVideoSendChannel();
channel->SetInterface(network_interface.get());
// Default value when DSCP is disabled should be DSCP_DEFAULT.
@ -5568,7 +5553,7 @@ TEST_F(WebRtcVideoChannelTest, TestSetDscpOptions) {
channel.reset(engine_.CreateMediaChannel(
cricket::MediaChannel::Role::kBoth, call_.get(), config, VideoOptions(),
webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()));
send_channel.reset(new VideoMediaSendChannel(channel.get()));
send_channel = channel->AsVideoSendChannel();
channel->SetInterface(network_interface.get());
EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
@ -9511,9 +9496,8 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test {
cricket::MediaChannel::Role::kBoth, &fake_call_, GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions(),
mock_rate_allocator_factory_.get()));
send_channel_ = std::make_unique<VideoMediaSendChannel>(channel_.get());
receive_channel_ =
std::make_unique<VideoMediaReceiveChannel>(channel_.get());
send_channel_ = channel_->AsVideoSendChannel();
receive_channel_ = channel_->AsVideoReceiveChannel();
send_channel_->OnReadyToSend(true);
receive_channel_->SetReceive(true);
last_ssrc_ = 123;
@ -9663,8 +9647,8 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test {
mock_rate_allocator_factory_;
WebRtcVideoEngine engine_;
std::unique_ptr<VideoMediaChannel> channel_;
std::unique_ptr<VideoMediaSendChannel> send_channel_;
std::unique_ptr<VideoMediaReceiveChannel> receive_channel_;
VideoMediaSendChannelInterface* send_channel_;
VideoMediaReceiveChannelInterface* receive_channel_;
uint32_t last_ssrc_;
};

9
media/engine/webrtc_voice_engine_unittest.cc
View File

@ -237,9 +237,8 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
cricket::MediaChannel::Role::kBoth, &call_, cricket::MediaConfig(),
cricket::AudioOptions(), webrtc::CryptoOptions(),
webrtc::AudioCodecPairId::Create());
send_channel_ = std::make_unique<cricket::VoiceMediaSendChannel>(channel_);
receive_channel_ =
std::make_unique<cricket::VoiceMediaReceiveChannel>(channel_);
send_channel_ = channel_->AsVoiceSendChannel();
receive_channel_ = channel_->AsVoiceReceiveChannel();
return (channel_ != nullptr);
}
@ -832,8 +831,8 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
cricket::FakeCall call_;
std::unique_ptr<cricket::WebRtcVoiceEngine> engine_;
cricket::VoiceMediaChannel* channel_ = nullptr;
std::unique_ptr<cricket::VoiceMediaSendChannel> send_channel_;
std::unique_ptr<cricket::VoiceMediaReceiveChannel> receive_channel_;
cricket::VoiceMediaSendChannelInterface* send_channel_;
cricket::VoiceMediaReceiveChannelInterface* receive_channel_;
cricket::AudioSendParameters send_parameters_;
cricket::AudioRecvParameters recv_parameters_;
FakeAudioSource fake_source_;

81
pc/channel.cc
View File

@ -114,14 +114,14 @@ BaseChannel::BaseChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<MediaChannel> send_media_channel_impl,
std::unique_ptr<MediaChannel> receive_media_channel_impl,
std::unique_ptr<MediaSendChannelInterface> send_media_channel_impl,
std::unique_ptr<MediaReceiveChannelInterface> receive_media_channel_impl,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
UniqueRandomIdGenerator* ssrc_generator)
: media_send_channel_impl_(std::move(send_media_channel_impl)),
media_receive_channel_impl_(std::move(receive_media_channel_impl)),
: media_send_channel_(std::move(send_media_channel_impl)),
media_receive_channel_(std::move(receive_media_channel_impl)),
worker_thread_(worker_thread),
network_thread_(network_thread),
signaling_thread_(signaling_thread),
@ -134,8 +134,8 @@ BaseChannel::BaseChannel(
demuxer_criteria_(mid),
ssrc_generator_(ssrc_generator) {
RTC_DCHECK_RUN_ON(worker_thread_);
RTC_DCHECK(media_send_channel_impl_);
RTC_DCHECK(media_receive_channel_impl_);
RTC_DCHECK(media_send_channel_);
RTC_DCHECK(media_receive_channel_);
RTC_DCHECK(ssrc_generator_);
RTC_DLOG(LS_INFO) << "Created channel: " << ToString();
}
@ -143,12 +143,12 @@ BaseChannel::BaseChannel(
BaseChannel::BaseChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<MediaChannel> media_channel_impl,
std::unique_ptr<MediaChannel> media_channel,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
UniqueRandomIdGenerator* ssrc_generator)
: media_channel_impl_(std::move(media_channel_impl)),
: media_channel_(std::move(media_channel)),
worker_thread_(worker_thread),
network_thread_(network_thread),
signaling_thread_(signaling_thread),
@ -161,7 +161,7 @@ BaseChannel::BaseChannel(rtc::Thread* worker_thread,
demuxer_criteria_(mid),
ssrc_generator_(ssrc_generator) {
RTC_DCHECK_RUN_ON(worker_thread_);
RTC_DCHECK(media_channel_impl_);
RTC_DCHECK(media_channel_);
RTC_DCHECK(ssrc_generator_);
RTC_DLOG(LS_INFO) << "Created channel: " << ToString();
}
@ -178,14 +178,14 @@ BaseChannel::~BaseChannel() {
}
std::string BaseChannel::ToString() const {
if (media_send_channel_impl_) {
if (media_send_channel_) {
return StringFormat(
"{mid: %s, media_type: %s}", mid().c_str(),
MediaTypeToString(media_send_channel_impl_->media_type()).c_str());
MediaTypeToString(media_send_channel_->media_type()).c_str());
} else {
return StringFormat(
"{mid: %s, media_type: %s}", mid().c_str(),
MediaTypeToString(media_channel_impl_->media_type()).c_str());
MediaTypeToString(media_channel_->media_type()).c_str());
}
}
@ -850,8 +850,8 @@ VoiceChannel::VoiceChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<VoiceMediaChannel> media_send_channel_impl,
std::unique_ptr<VoiceMediaChannel> media_receive_channel_impl,
std::unique_ptr<VoiceMediaSendChannelInterface> media_send_channel,
std::unique_ptr<VoiceMediaReceiveChannelInterface> media_receive_channel,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
@ -859,14 +859,12 @@ VoiceChannel::VoiceChannel(
: BaseChannel(worker_thread,
network_thread,
signaling_thread,
std::move(media_send_channel_impl),
std::move(media_receive_channel_impl),
std::move(media_send_channel),
std::move(media_receive_channel),
mid,
srtp_required,
crypto_options,
ssrc_generator),
send_channel_(media_send_channel_impl_->AsVoiceChannel()),
receive_channel_(media_receive_channel_impl_->AsVoiceChannel()) {}
ssrc_generator) {}
VoiceChannel::VoiceChannel(
rtc::Thread* worker_thread,
@ -884,9 +882,7 @@ VoiceChannel::VoiceChannel(
mid,
srtp_required,
crypto_options,
ssrc_generator),
send_channel_(media_channel_impl_->AsVoiceChannel()),
receive_channel_(media_channel_impl_->AsVoiceChannel()) {
ssrc_generator) {
InitCallback();
}
@ -900,12 +896,13 @@ void VoiceChannel::InitCallback() {
RTC_DCHECK_RUN_ON(worker_thread());
// TODO(bugs.webrtc.org/13931): Remove when values are set
// in a more sensible fashion
send_channel_.SetSendCodecChangedCallback([this]() {
send_channel()->SetSendCodecChangedCallback([this]() {
RTC_DCHECK_RUN_ON(worker_thread());
// Adjust receive streams based on send codec.
receive_channel_.SetReceiveNackEnabled(send_channel_.SendCodecHasNack());
receive_channel_.SetReceiveNonSenderRttEnabled(
send_channel_.SenderNonSenderRttEnabled());
receive_channel()->SetReceiveNackEnabled(
send_channel()->SendCodecHasNack());
receive_channel()->SetReceiveNonSenderRttEnabled(
send_channel()->SenderNonSenderRttEnabled());
});
}
void VoiceChannel::UpdateMediaSendRecvState_w() {
@ -1019,8 +1016,8 @@ VideoChannel::VideoChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<VideoMediaChannel> media_send_channel_impl,
std::unique_ptr<VideoMediaChannel> media_receive_channel_impl,
std::unique_ptr<VideoMediaSendChannelInterface> media_send_channel,
std::unique_ptr<VideoMediaReceiveChannelInterface> media_receive_channel,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
@ -1028,25 +1025,21 @@ VideoChannel::VideoChannel(
: BaseChannel(worker_thread,
network_thread,
signaling_thread,
std::move(media_send_channel_impl),
std::move(media_receive_channel_impl),
std::move(media_send_channel),
std::move(media_receive_channel),
mid,
srtp_required,
crypto_options,
ssrc_generator),
send_channel_(media_send_channel_impl_->AsVideoChannel()),
receive_channel_(media_receive_channel_impl_->AsVideoChannel()) {
ssrc_generator) {
// TODO(bugs.webrtc.org/13931): Remove when values are set
// in a more sensible fashion
media_send_channel_impl_->AsVideoChannel()->SetSendCodecChangedCallback(
[this]() {
// Adjust receive streams based on send codec.
media_receive_channel()->SetReceiverFeedbackParameters(
media_send_channel()->SendCodecHasLntf(),
media_send_channel()->SendCodecHasNack(),
media_send_channel()->SendCodecRtcpMode(),
media_send_channel()->SendCodecRtxTime());
});
send_channel()->SetSendCodecChangedCallback([this]() {
// Adjust receive streams based on send codec.
receive_channel()->SetReceiverFeedbackParameters(
send_channel()->SendCodecHasLntf(), send_channel()->SendCodecHasNack(),
send_channel()->SendCodecRtcpMode(),
send_channel()->SendCodecRtxTime());
});
}
VideoChannel::VideoChannel(
rtc::Thread* worker_thread,
@ -1064,9 +1057,7 @@ VideoChannel::VideoChannel(
mid,
srtp_required,
crypto_options,
ssrc_generator),
send_channel_(media_channel_impl_->AsVideoChannel()),
receive_channel_(media_channel_impl_->AsVideoChannel()) {}
ssrc_generator) {}
VideoChannel::~VideoChannel() {
TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");

122
pc/channel.h
View File

@ -84,15 +84,16 @@ class BaseChannel : public ChannelInterface,
// which will make it easier to change the constructor.
// Constructor for use when the MediaChannels are split
BaseChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<MediaChannel> media_send_channel_impl,
std::unique_ptr<MediaChannel> media_receive_channel_impl,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
rtc::UniqueRandomIdGenerator* ssrc_generator);
BaseChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<MediaSendChannelInterface> media_send_channel,
std::unique_ptr<MediaReceiveChannelInterface> media_receive_channel,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
rtc::UniqueRandomIdGenerator* ssrc_generator);
// Constructor for use when the MediaChannel is not split
// TODO(bugs.webrtc.org/13931): Delete when split channel project is complete.
BaseChannel(rtc::Thread* worker_thread,
@ -315,16 +316,15 @@ class BaseChannel : public ChannelInterface,
// Return description of media channel to facilitate logging
std::string ToString() const;
// MediaChannel related members that should be accessed from the worker
// thread. These are used in initializing the subclasses and deleting
// the channels when exiting; they have no accessors.
// Either the media_channel_impl_ is set, or the media_send_channel_impl_
// and the media_receive_channel_impl_ is set.
// TODO(bugs.webrtc.org/13931): Delete when split channel project is complete.
const std::unique_ptr<MediaChannel> media_channel_impl_;
// MediaChannel implementation pointers.
// Either the `media_channel_` is set, or the `media_send_channel_`
// and the `media_receive_channel_` is set.
// TODO(bugs.webrtc.org/13931): Delete `media_channel_` when split channel
// project is complete.
const std::unique_ptr<MediaChannel> media_channel_;
const std::unique_ptr<MediaChannel> media_send_channel_impl_;
const std::unique_ptr<MediaChannel> media_receive_channel_impl_;
const std::unique_ptr<MediaSendChannelInterface> media_send_channel_;
const std::unique_ptr<MediaReceiveChannelInterface> media_receive_channel_;
private:
bool ConnectToRtpTransport_n() RTC_RUN_ON(network_thread());
@ -386,15 +386,16 @@ class BaseChannel : public ChannelInterface,
// and input/output level monitoring.
class VoiceChannel : public BaseChannel {
public:
VoiceChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<VoiceMediaChannel> send_channel_impl,
std::unique_ptr<VoiceMediaChannel> receive_channel_impl,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
rtc::UniqueRandomIdGenerator* ssrc_generator);
VoiceChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<VoiceMediaSendChannelInterface> send_channel_impl,
std::unique_ptr<VoiceMediaReceiveChannelInterface> receive_channel_impl,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
rtc::UniqueRandomIdGenerator* ssrc_generator);
// Constructor for use when the MediaChannel is not split
// TODO(bugs.webrtc.org/13931): Delete when split channel project is complete.
VoiceChannel(rtc::Thread* worker_thread,
@ -414,20 +415,34 @@ class VoiceChannel : public BaseChannel {
}
VoiceChannel* AsVoiceChannel() override { return this; }
VoiceMediaSendChannelInterface* send_channel() {
if (media_send_channel_) {
return media_send_channel_->AsVoiceSendChannel();
}
return media_channel_->AsVoiceSendChannel();
}
VoiceMediaReceiveChannelInterface* receive_channel() {
if (media_receive_channel_) {
return media_receive_channel_->AsVoiceReceiveChannel();
}
return media_channel_->AsVoiceReceiveChannel();
}
VoiceMediaSendChannelInterface* media_send_channel() override {
return &send_channel_;
return send_channel();
}
VoiceMediaSendChannelInterface* voice_media_send_channel() override {
return &send_channel_;
return send_channel();
}
VoiceMediaReceiveChannelInterface* media_receive_channel() override {
return &receive_channel_;
return receive_channel();
}
VoiceMediaReceiveChannelInterface* voice_media_receive_channel() override {
return &receive_channel_;
return receive_channel();
}
cricket::MediaType media_type() const override {
@ -447,8 +462,6 @@ class VoiceChannel : public BaseChannel {
std::string& error_desc)
RTC_RUN_ON(worker_thread()) override;
VoiceMediaSendChannel send_channel_ RTC_GUARDED_BY(worker_thread());
VoiceMediaReceiveChannel receive_channel_ RTC_GUARDED_BY(worker_thread());
// Last AudioSendParameters sent down to the media_channel() via
// SetSendParameters.
AudioSendParameters last_send_params_ RTC_GUARDED_BY(worker_thread());
@ -460,15 +473,16 @@ class VoiceChannel : public BaseChannel {
// VideoChannel is a specialization for video.
class VideoChannel : public BaseChannel {
public:
VideoChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<VideoMediaChannel> media_send_channel_impl,
std::unique_ptr<VideoMediaChannel> media_receive_channel_impl,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
rtc::UniqueRandomIdGenerator* ssrc_generator);
VideoChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
std::unique_ptr<VideoMediaSendChannelInterface> media_send_channel,
std::unique_ptr<VideoMediaReceiveChannelInterface> media_receive_channel,
absl::string_view mid,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
rtc::UniqueRandomIdGenerator* ssrc_generator);
// Constructor for use when the MediaChannel is not split
// TODO(bugs.webrtc.org/13931): Delete when split channel project is complete.
VideoChannel(rtc::Thread* worker_thread,
@ -487,20 +501,34 @@ class VideoChannel : public BaseChannel {
return nullptr;
}
VideoMediaSendChannelInterface* send_channel() {
if (media_send_channel_) {
return media_send_channel_->AsVideoSendChannel();
}
return media_channel_->AsVideoSendChannel();
}
VideoMediaReceiveChannelInterface* receive_channel() {
if (media_receive_channel_) {
return media_receive_channel_->AsVideoReceiveChannel();
}
return media_channel_->AsVideoReceiveChannel();
}
VideoMediaSendChannelInterface* media_send_channel() override {
return &send_channel_;
return send_channel();
}
VideoMediaSendChannelInterface* video_media_send_channel() override {
return &send_channel_;
return send_channel();
}
VideoMediaReceiveChannelInterface* media_receive_channel() override {
return &receive_channel_;
return receive_channel();
}
VideoMediaReceiveChannelInterface* video_media_receive_channel() override {
return &receive_channel_;
return receive_channel();
}
cricket::MediaType media_type() const override {
@ -519,8 +547,6 @@ class VideoChannel : public BaseChannel {
std::string& error_desc)
RTC_RUN_ON(worker_thread()) override;
VideoMediaSendChannel send_channel_ RTC_GUARDED_BY(worker_thread());
VideoMediaReceiveChannel receive_channel_ RTC_GUARDED_BY(worker_thread());
// Last VideoSendParameters sent down to the media_channel() via
// SetSendParameters.
VideoSendParameters last_send_params_ RTC_GUARDED_BY(worker_thread());

9
pc/channel_unittest.cc
View File

@ -1476,29 +1476,28 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
// T::MediaChannel is either FakeVoiceMediaChannel or FakeVideoMediaChannel.
typename T::MediaChannel* media_send_channel1_impl() {
RTC_DCHECK(channel1_);
RTC_DCHECK(channel1_->media_send_channel());
return static_cast<typename T::MediaChannel*>(
channel1_->media_send_channel()->ImplForTesting());
channel1_->media_send_channel());
}
typename T::MediaChannel* media_send_channel2_impl() {
RTC_DCHECK(channel2_);
RTC_DCHECK(channel2_->media_send_channel());
return static_cast<typename T::MediaChannel*>(
channel2_->media_send_channel()->ImplForTesting());
channel2_->media_send_channel());
}
typename T::MediaChannel* media_receive_channel1_impl() {
RTC_DCHECK(channel1_);
RTC_DCHECK(channel1_->media_receive_channel());
return static_cast<typename T::MediaChannel*>(
channel1_->media_receive_channel()->ImplForTesting());
channel1_->media_receive_channel());
}
typename T::MediaChannel* media_receive_channel2_impl() {
RTC_DCHECK(channel2_);
RTC_DCHECK(channel2_->media_receive_channel());
return static_cast<typename T::MediaChannel*>(
channel2_->media_receive_channel()->ImplForTesting());
channel2_->media_receive_channel());
}
rtc::AutoThread main_thread_;

12
pc/rtp_sender_receiver_unittest.cc
View File

@ -149,10 +149,8 @@ class RtpSenderReceiverTest
RTC_CHECK(voice_media_receive_channel());
RTC_CHECK(video_media_receive_channel());
// Create sender channel objects
voice_send_channel_ = std::make_unique<cricket::VoiceMediaSendChannel>(
voice_media_send_channel());
video_send_channel_ = std::make_unique<cricket::VideoMediaSendChannel>(
video_media_send_channel());
voice_send_channel_ = voice_media_send_channel()->AsVoiceSendChannel();
video_send_channel_ = video_media_send_channel()->AsVideoSendChannel();
// Create streams for predefined SSRCs. Streams need to exist in order
// for the senders and receievers to apply parameters to them.
@ -227,7 +225,7 @@ class RtpSenderReceiverTest
ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams());
audio_rtp_sender_->SetStreams({local_stream_->id()});
audio_rtp_sender_->SetMediaChannel(voice_send_channel_.get());
audio_rtp_sender_->SetMediaChannel(voice_send_channel_);
audio_rtp_sender_->SetSsrc(kAudioSsrc);
VerifyVoiceChannelInput();
}
@ -554,8 +552,8 @@ class RtpSenderReceiverTest
std::unique_ptr<cricket::FakeVideoMediaChannel> video_media_send_channel_;
std::unique_ptr<cricket::FakeVoiceMediaChannel> voice_media_receive_channel_;
std::unique_ptr<cricket::FakeVideoMediaChannel> video_media_receive_channel_;
std::unique_ptr<cricket::VoiceMediaSendChannel> voice_send_channel_;
std::unique_ptr<cricket::VideoMediaSendChannel> video_send_channel_;
cricket::VoiceMediaSendChannelInterface* voice_send_channel_;
cricket::VideoMediaSendChannelInterface* video_send_channel_;
rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_;
rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;