From 76c53d36bc455fe89ca1f860d5171633198fe907 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Bostr=C3=B6m?= Date: Thu, 9 Apr 2015 14:35:37 +0200 Subject: [PATCH] Remove ViE interface usage from VideoReceiveStream. References channels and underlying objects directly instead of using interfaces referenced with channel id. Channel creation is still done as before for now. BUG=1695 R=stefan@webrtc.org TBR=mflodman@webrtc.org Review URL: https://webrtc-codereview.appspot.com/46849004 Cr-Commit-Position: refs/heads/master@{#8958} --- talk/media/webrtc/fakewebrtcvideoengine.h | 7 + webrtc/call.h | 8 +- webrtc/video/call.cc | 7 +- webrtc/video/video_receive_stream.cc | 153 ++++++++++----------- webrtc/video/video_receive_stream.h | 19 ++- webrtc/video_engine/include/vie_base.h | 13 ++ webrtc/video_engine/vie_base_impl.cc | 23 ++++ webrtc/video_engine/vie_base_impl.h | 5 + webrtc/video_engine/vie_channel_group.cc | 5 +- webrtc/video_engine/vie_channel_group.h | 5 +- webrtc/video_engine/vie_channel_manager.cc | 10 +- webrtc/video_engine/vie_channel_manager.h | 2 + 12 files changed, 149 insertions(+), 108 deletions(-) diff --git a/talk/media/webrtc/fakewebrtcvideoengine.h b/talk/media/webrtc/fakewebrtcvideoengine.h index 24a1cbb3a..f7924567d 100644 --- a/talk/media/webrtc/fakewebrtcvideoengine.h +++ b/talk/media/webrtc/fakewebrtcvideoengine.h @@ -699,6 +699,13 @@ class FakeWebRtcVideoEngine return 0; } WEBRTC_STUB(CreateChannelWithoutDefaultEncoder, (int&, int original_channel)); + webrtc::ChannelGroup* GetChannelGroup(int channel_id) override { + return nullptr; + } + webrtc::ViEChannel* GetChannel(int channel_id) override { return nullptr; } + webrtc::ViEEncoder* GetEncoder(int channel_id) override { return nullptr; } + webrtc::ViERenderManager* GetRenderManager() override { return nullptr; } + WEBRTC_FUNC(CreateReceiveChannel, (int& channel, int original_channel)) { return CreateChannel(channel, original_channel); } diff --git a/webrtc/call.h b/webrtc/call.h index f5b7fed54..4319cc5e5 100644 --- a/webrtc/call.h +++ b/webrtc/call.h @@ -62,15 +62,12 @@ class Call { }; struct Config { explicit Config(newapi::Transport* send_transport) - : webrtc_config(NULL), - send_transport(send_transport), + : send_transport(send_transport), voice_engine(NULL), overuse_callback(NULL) {} static const int kDefaultStartBitrateBps; - webrtc::Config* webrtc_config; - newapi::Transport* send_transport; // VoiceEngine used for audio/video synchronization for this Call. @@ -108,9 +105,6 @@ class Call { static Call* Create(const Call::Config& config); - static Call* Create(const Call::Config& config, - const webrtc::Config& webrtc_config); - virtual VideoSendStream* CreateVideoSendStream( const VideoSendStream::Config& config, const VideoEncoderConfig& encoder_config) = 0; diff --git a/webrtc/video/call.cc b/webrtc/video/call.cc index d9dc334c0..7c8b05912 100644 --- a/webrtc/video/call.cc +++ b/webrtc/video/call.cc @@ -157,6 +157,7 @@ class Call : public webrtc::Call, public PacketReceiver { ViEBase* base_; ViENetwork* network_; int base_channel_id_; + ChannelGroup* channel_group_; rtc::scoped_ptr external_render_; @@ -165,9 +166,7 @@ class Call : public webrtc::Call, public PacketReceiver { } // namespace internal Call* Call::Create(const Call::Config& config) { - VideoEngine* video_engine = config.webrtc_config != nullptr - ? VideoEngine::Create(*config.webrtc_config) - : VideoEngine::Create(); + VideoEngine* video_engine = VideoEngine::Create(); DCHECK(video_engine != nullptr); return new internal::Call(video_engine, config); @@ -221,6 +220,7 @@ Call::Call(webrtc::VideoEngine* video_engine, const Call::Config& config) base_->CreateChannel(base_channel_id_); DCHECK(base_channel_id_ != -1); + channel_group_ = base_->GetChannelGroup(base_channel_id_); network_->SetBitrateConfig(base_channel_id_, config_.bitrate_config.min_bitrate_bps, @@ -309,6 +309,7 @@ VideoReceiveStream* Call::CreateVideoReceiveStream( LOG(LS_INFO) << "CreateVideoReceiveStream: " << config.ToString(); VideoReceiveStream* receive_stream = new VideoReceiveStream(video_engine_, + channel_group_, config, config_.send_transport, config_.voice_engine, diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc index 126d485e5..a8dea5eb7 100644 --- a/webrtc/video/video_receive_stream.cc +++ b/webrtc/video/video_receive_stream.cc @@ -132,6 +132,7 @@ VideoCodec CreateDecoderVideoCodec(const VideoReceiveStream::Decoder& decoder) { } // namespace VideoReceiveStream::VideoReceiveStream(webrtc::VideoEngine* video_engine, + ChannelGroup* channel_group, const VideoReceiveStream::Config& config, newapi::Transport* transport, webrtc::VoiceEngine* voice_engine, @@ -140,17 +141,19 @@ VideoReceiveStream::VideoReceiveStream(webrtc::VideoEngine* video_engine, encoded_frame_proxy_(config.pre_decode_callback), config_(config), clock_(Clock::GetRealTimeClock()), + channel_group_(channel_group), + voe_sync_interface_(nullptr), channel_(-1) { video_engine_base_ = ViEBase::GetInterface(video_engine); video_engine_base_->CreateReceiveChannel(channel_, base_channel); DCHECK(channel_ != -1); - rtp_rtcp_ = ViERTP_RTCP::GetInterface(video_engine); - DCHECK(rtp_rtcp_ != nullptr); + vie_channel_ = video_engine_base_->GetChannel(channel_); + vie_render_manager_ = video_engine_base_->GetRenderManager(); // TODO(pbos): This is not fine grained enough... - rtp_rtcp_->SetNACKStatus(channel_, config_.rtp.nack.rtp_history_ms > 0); - rtp_rtcp_->SetKeyFrameRequestMethod(channel_, kViEKeyFrameRequestPliRtcp); + vie_channel_->SetNACKStatus(config_.rtp.nack.rtp_history_ms > 0); + vie_channel_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp); SetRtcpMode(config_.rtp.rtcp_mode); DCHECK(config_.rtp.remote_ssrc != 0); @@ -158,18 +161,20 @@ VideoReceiveStream::VideoReceiveStream(webrtc::VideoEngine* video_engine, DCHECK(config_.rtp.local_ssrc != 0); DCHECK(config_.rtp.remote_ssrc != config_.rtp.local_ssrc); - rtp_rtcp_->SetLocalSSRC(channel_, config_.rtp.local_ssrc); + vie_channel_->SetSSRC(config_.rtp.local_ssrc, kViEStreamTypeNormal, 0); // TODO(pbos): Support multiple RTX, per video payload. Config::Rtp::RtxMap::const_iterator it = config_.rtp.rtx.begin(); if (it != config_.rtp.rtx.end()) { DCHECK(it->second.ssrc != 0); DCHECK(it->second.payload_type != 0); - rtp_rtcp_->SetRemoteSSRCType(channel_, kViEStreamTypeRtx, it->second.ssrc); - rtp_rtcp_->SetRtxReceivePayloadType(channel_, it->second.payload_type); + vie_channel_->SetRemoteSSRCType(kViEStreamTypeRtx, it->second.ssrc); + vie_channel_->SetRtxReceivePayloadType(it->second.payload_type); } - rtp_rtcp_->SetRembStatus(channel_, false, config_.rtp.remb); + // TODO(pbos): Remove channel_group_ usage from VideoReceiveStream. This + // should be configured in call.cc. + channel_group_->SetChannelRembStatus(false, config_.rtp.remb, vie_channel_); for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) { const std::string& extension = config_.rtp.extensions[i].name; @@ -178,24 +183,17 @@ VideoReceiveStream::VideoReceiveStream(webrtc::VideoEngine* video_engine, DCHECK_GE(id, 1); DCHECK_LE(id, 14); if (extension == RtpExtension::kTOffset) { - CHECK_EQ(0, - rtp_rtcp_->SetReceiveTimestampOffsetStatus(channel_, true, id)); + CHECK_EQ(0, vie_channel_->SetReceiveTimestampOffsetStatus(true, id)); } else if (extension == RtpExtension::kAbsSendTime) { - CHECK_EQ(0, - rtp_rtcp_->SetReceiveAbsoluteSendTimeStatus(channel_, true, id)); + CHECK_EQ(0, vie_channel_->SetReceiveAbsoluteSendTimeStatus(true, id)); } else if (extension == RtpExtension::kVideoRotation) { - CHECK_EQ(0, rtp_rtcp_->SetReceiveVideoRotationStatus(channel_, true, id)); + CHECK_EQ(0, vie_channel_->SetReceiveVideoRotationStatus(true, id)); } else { RTC_NOTREACHED() << "Unsupported RTP extension."; } } - network_ = ViENetwork::GetInterface(video_engine); - DCHECK(network_ != nullptr); - - network_->RegisterSendTransport(channel_, transport_adapter_); - - codec_ = ViECodec::GetInterface(video_engine); + vie_channel_->RegisterSendTransport(&transport_adapter_); if (config_.rtp.fec.ulpfec_payload_type != -1) { // ULPFEC without RED doesn't make sense. @@ -205,7 +203,7 @@ VideoReceiveStream::VideoReceiveStream(webrtc::VideoEngine* video_engine, codec.codecType = kVideoCodecULPFEC; strcpy(codec.plName, "ulpfec"); codec.plType = config_.rtp.fec.ulpfec_payload_type; - CHECK_EQ(0, codec_->SetReceiveCodec(channel_, codec)); + CHECK_EQ(0, vie_channel_->SetReceiveCodec(codec)); } if (config_.rtp.fec.red_payload_type != -1) { VideoCodec codec; @@ -213,97 +211,86 @@ VideoReceiveStream::VideoReceiveStream(webrtc::VideoEngine* video_engine, codec.codecType = kVideoCodecRED; strcpy(codec.plName, "red"); codec.plType = config_.rtp.fec.red_payload_type; - CHECK_EQ(0, codec_->SetReceiveCodec(channel_, codec)); + CHECK_EQ(0, vie_channel_->SetReceiveCodec(codec)); } + if (config.rtp.rtcp_xr.receiver_reference_time_report) + vie_channel_->SetRtcpXrRrtrStatus(true); + stats_proxy_.reset( new ReceiveStatisticsProxy(config_.rtp.remote_ssrc, clock_)); - CHECK_EQ(0, rtp_rtcp_->RegisterReceiveChannelRtcpStatisticsCallback( - channel_, stats_proxy_.get())); - CHECK_EQ(0, rtp_rtcp_->RegisterReceiveChannelRtpStatisticsCallback( - channel_, stats_proxy_.get())); - CHECK_EQ(0, rtp_rtcp_->RegisterRtcpPacketTypeCounterObserver( - channel_, stats_proxy_.get())); - CHECK_EQ(0, codec_->RegisterDecoderObserver(channel_, *stats_proxy_)); + vie_channel_->RegisterReceiveChannelRtcpStatisticsCallback( + stats_proxy_.get()); + vie_channel_->RegisterReceiveChannelRtpStatisticsCallback(stats_proxy_.get()); + vie_channel_->RegisterRtcpPacketTypeCounterObserver(stats_proxy_.get()); + vie_channel_->RegisterCodecObserver(stats_proxy_.get()); - video_engine_base_->RegisterReceiveStatisticsProxy(channel_, - stats_proxy_.get()); + vie_channel_->RegisterReceiveStatisticsProxy(stats_proxy_.get()); - external_codec_ = ViEExternalCodec::GetInterface(video_engine); DCHECK(!config_.decoders.empty()); for (size_t i = 0; i < config_.decoders.size(); ++i) { const Decoder& decoder = config_.decoders[i]; - CHECK_EQ(0, external_codec_->RegisterExternalReceiveCodec( - channel_, decoder.payload_type, decoder.decoder, - decoder.is_renderer, decoder.expected_delay_ms)); + CHECK_EQ(0, vie_channel_->RegisterExternalDecoder( + decoder.payload_type, decoder.decoder, decoder.is_renderer, + decoder.expected_delay_ms)); VideoCodec codec = CreateDecoderVideoCodec(decoder); - CHECK_EQ(0, codec_->SetReceiveCodec(channel_, codec)); + CHECK_EQ(0, vie_channel_->SetReceiveCodec(codec)); } - render_ = ViERender::GetInterface(video_engine); - DCHECK(render_ != nullptr); - - render_->AddRenderer(channel_, kVideoI420, this); + // Register a renderer without a window handle, at depth 0, that covers the + // entire rendered area (0->1 both axes). This registers a renderer that + // renders the entire video. + vie_renderer_ = vie_render_manager_->AddRenderStream(channel_, nullptr, 0, + 0.0f, 0.0f, 1.0f, 1.0f); + vie_renderer_->SetExternalRenderer(channel_, kVideoI420, this); + vie_channel_->RegisterFrameCallback(channel_, vie_renderer_); if (voice_engine && config_.audio_channel_id != -1) { - video_engine_base_->SetVoiceEngine(voice_engine); - video_engine_base_->ConnectAudioChannel(channel_, config_.audio_channel_id); + voe_sync_interface_ = VoEVideoSync::GetInterface(voice_engine); + vie_channel_->SetVoiceChannel(config.audio_channel_id, voe_sync_interface_); } - image_process_ = ViEImageProcess::GetInterface(video_engine); - if (config.pre_decode_callback) { - image_process_->RegisterPreDecodeImageCallback(channel_, - &encoded_frame_proxy_); - } - image_process_->RegisterPreRenderCallback(channel_, this); - - if (config.rtp.rtcp_xr.receiver_reference_time_report) { - rtp_rtcp_->SetRtcpXrRrtrStatus(channel_, true); - } + if (config.pre_decode_callback) + vie_channel_->RegisterPreDecodeImageCallback(&encoded_frame_proxy_); + vie_channel_->RegisterPreRenderCallback(this); } VideoReceiveStream::~VideoReceiveStream() { - image_process_->DeRegisterPreRenderCallback(channel_); - image_process_->DeRegisterPreDecodeCallback(channel_); + vie_channel_->RegisterPreRenderCallback(nullptr); + vie_channel_->RegisterPreDecodeImageCallback(nullptr); - render_->RemoveRenderer(channel_); + vie_channel_->DeregisterFrameCallback(vie_renderer_); + vie_render_manager_->RemoveRenderStream(channel_); - for (size_t i = 0; i < config_.decoders.size(); ++i) { - external_codec_->DeRegisterExternalReceiveCodec( - channel_, config_.decoders[i].payload_type); + for (size_t i = 0; i < config_.decoders.size(); ++i) + vie_channel_->DeRegisterExternalDecoder(config_.decoders[i].payload_type); + + vie_channel_->DeregisterSendTransport(); + + if (voe_sync_interface_ != nullptr) { + vie_channel_->SetVoiceChannel(-1, nullptr); + voe_sync_interface_->Release(); } - - network_->DeregisterSendTransport(channel_); - - video_engine_base_->SetVoiceEngine(nullptr); - image_process_->Release(); - external_codec_->Release(); - codec_->DeregisterDecoderObserver(channel_); - rtp_rtcp_->DeregisterReceiveChannelRtpStatisticsCallback(channel_, - stats_proxy_.get()); - rtp_rtcp_->DeregisterReceiveChannelRtcpStatisticsCallback(channel_, - stats_proxy_.get()); - rtp_rtcp_->RegisterRtcpPacketTypeCounterObserver(channel_, nullptr); - codec_->Release(); - network_->Release(); - render_->Release(); - rtp_rtcp_->Release(); + vie_channel_->RegisterCodecObserver(nullptr); + vie_channel_->RegisterReceiveChannelRtpStatisticsCallback(nullptr); + vie_channel_->RegisterReceiveChannelRtcpStatisticsCallback(nullptr); + vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr); video_engine_base_->DeleteChannel(channel_); video_engine_base_->Release(); } void VideoReceiveStream::Start() { transport_adapter_.Enable(); - CHECK_EQ(0, render_->StartRender(channel_)); - CHECK_EQ(0, video_engine_base_->StartReceive(channel_)); + vie_renderer_->StartRender(); + vie_channel_->StartReceive(); } void VideoReceiveStream::Stop() { - CHECK_EQ(0, render_->StopRender(channel_)); - CHECK_EQ(0, video_engine_base_->StopReceive(channel_)); + vie_renderer_->StopRender(); + vie_channel_->StopReceive(); transport_adapter_.Disable(); } @@ -312,12 +299,11 @@ VideoReceiveStream::Stats VideoReceiveStream::GetStats() const { } bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { - return network_->ReceivedRTCPPacket(channel_, packet, length) == 0; + return vie_channel_->ReceivedRTCPPacket(packet, length) == 0; } bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, size_t length) { - return network_->ReceivedRTPPacket(channel_, packet, length, PacketTime()) == - 0; + return vie_channel_->ReceivedRTPPacket(packet, length, PacketTime()) == 0; } void VideoReceiveStream::FrameCallback(I420VideoFrame* video_frame) { @@ -364,18 +350,17 @@ bool VideoReceiveStream::IsTextureSupported() { void VideoReceiveStream::SignalNetworkState(Call::NetworkState state) { if (state == Call::kNetworkUp) SetRtcpMode(config_.rtp.rtcp_mode); - network_->SetNetworkTransmissionState(channel_, state == Call::kNetworkUp); if (state == Call::kNetworkDown) - rtp_rtcp_->SetRTCPStatus(channel_, kRtcpNone); + vie_channel_->SetRTCPMode(kRtcpOff); } void VideoReceiveStream::SetRtcpMode(newapi::RtcpMode mode) { switch (mode) { case newapi::kRtcpCompound: - rtp_rtcp_->SetRTCPStatus(channel_, kRtcpCompound_RFC4585); + vie_channel_->SetRTCPMode(kRtcpCompound); break; case newapi::kRtcpReducedSize: - rtp_rtcp_->SetRTCPStatus(channel_, kRtcpNonCompound_RFC5506); + vie_channel_->SetRTCPMode(kRtcpNonCompound); break; } } diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index dcc8122ee..8e4a9e5f0 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -22,6 +22,11 @@ #include "webrtc/video/receive_statistics_proxy.h" #include "webrtc/video/transport_adapter.h" #include "webrtc/video_engine/include/vie_render.h" +#include "webrtc/video_engine/vie_channel.h" +#include "webrtc/video_engine/vie_channel_group.h" +#include "webrtc/video_engine/vie_encoder.h" +#include "webrtc/video_engine/vie_render_manager.h" +#include "webrtc/video_engine/vie_renderer.h" #include "webrtc/video_receive_stream.h" namespace webrtc { @@ -43,6 +48,7 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, public ExternalRenderer { public: VideoReceiveStream(webrtc::VideoEngine* video_engine, + ChannelGroup* channel_group, const VideoReceiveStream::Config& config, newapi::Transport* transport, webrtc::VoiceEngine* voice_engine, @@ -82,13 +88,14 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, const VideoReceiveStream::Config config_; Clock* const clock_; + ChannelGroup* const channel_group_; + ViEChannel* vie_channel_; + ViERenderManager* vie_render_manager_; + ViERenderer* vie_renderer_; + ViEBase* video_engine_base_; - ViECodec* codec_; - ViEExternalCodec* external_codec_; - ViENetwork* network_; - ViERender* render_; - ViERTP_RTCP* rtp_rtcp_; - ViEImageProcess* image_process_; + + VoEVideoSync* voe_sync_interface_; rtc::scoped_ptr stats_proxy_; diff --git a/webrtc/video_engine/include/vie_base.h b/webrtc/video_engine/include/vie_base.h index 7262ca286..55bc5f5eb 100644 --- a/webrtc/video_engine/include/vie_base.h +++ b/webrtc/video_engine/include/vie_base.h @@ -28,6 +28,14 @@ class VoiceEngine; class ReceiveStatisticsProxy; class SendStatisticsProxy; +// Internal-class forward declarations, used to break out implementations for +// the new video API to remove interface dependencies to the VideoEngine API +// See webrtc:1695. +class ChannelGroup; +class ViEChannel; +class ViEEncoder; +class ViERenderManager; + // CpuOveruseObserver is called when a system overuse is detected and // VideoEngine cannot keep up the encoding frequency. class CpuOveruseObserver { @@ -190,6 +198,11 @@ class WEBRTC_DLLEXPORT ViEBase { virtual int CreateChannelWithoutDefaultEncoder(int& video_channel, int original_channel) = 0; + virtual ChannelGroup* GetChannelGroup(int channel_id) = 0; + virtual ViEChannel* GetChannel(int channel_id) = 0; + virtual ViEEncoder* GetEncoder(int channel_id) = 0; + virtual ViERenderManager* GetRenderManager() = 0; + // Creates a new channel grouped together with |original_channel|. The channel // can only receive video and it is assumed the remote end-point is the same // as for |original_channel|. diff --git a/webrtc/video_engine/vie_base_impl.cc b/webrtc/video_engine/vie_base_impl.cc index ca7fd5097..7d25172ec 100644 --- a/webrtc/video_engine/vie_base_impl.cc +++ b/webrtc/video_engine/vie_base_impl.cc @@ -13,6 +13,7 @@ #include #include +#include "webrtc/base/checks.h" #include "webrtc/engine_configurations.h" #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" #include "webrtc/modules/video_coding/main/interface/video_coding.h" @@ -195,6 +196,28 @@ int ViEBaseImpl::CreateChannelWithoutDefaultEncoder( return CreateChannel(video_channel, original_channel, true, true); } +ChannelGroup* ViEBaseImpl::GetChannelGroup(int channel_id) { + return shared_data_.channel_manager()->GetChannelGroup(channel_id); +} + +ViEChannel* ViEBaseImpl::GetChannel(int channel_id) { + ViEChannelManagerScoped cs(*(shared_data_.channel_manager())); + ViEChannel* vie_channel = cs.Channel(channel_id); + DCHECK(vie_channel); + return vie_channel; +} + +ViEEncoder* ViEBaseImpl::GetEncoder(int channel_id) { + ViEChannelManagerScoped cs(*(shared_data_.channel_manager())); + ViEEncoder* vie_encoder = cs.Encoder(channel_id); + DCHECK(vie_encoder); + return vie_encoder; +} + +ViERenderManager* ViEBaseImpl::GetRenderManager() { + return shared_data_.render_manager(); +} + int ViEBaseImpl::CreateReceiveChannel(int& video_channel, // NOLINT int original_channel) { return CreateChannel(video_channel, original_channel, false, true); diff --git a/webrtc/video_engine/vie_base_impl.h b/webrtc/video_engine/vie_base_impl.h index 958e1c15c..5df94901c 100644 --- a/webrtc/video_engine/vie_base_impl.h +++ b/webrtc/video_engine/vie_base_impl.h @@ -50,6 +50,11 @@ class ViEBaseImpl virtual int CreateChannelWithoutDefaultEncoder(int& video_channel, // NOLINT int original_channel); + ChannelGroup* GetChannelGroup(int channel_id) override; + ViEChannel* GetChannel(int channel_id) override; + ViEEncoder* GetEncoder(int channel_id) override; + ViERenderManager* GetRenderManager() override; + virtual int CreateReceiveChannel(int& video_channel, // NOLINT int original_channel); virtual int DeleteChannel(const int video_channel); diff --git a/webrtc/video_engine/vie_channel_group.cc b/webrtc/video_engine/vie_channel_group.cc index 3508d6a7f..f573ff163 100644 --- a/webrtc/video_engine/vie_channel_group.cc +++ b/webrtc/video_engine/vie_channel_group.cc @@ -285,7 +285,7 @@ void ChannelGroup::DeleteChannel(int channel_id) { DCHECK(vie_encoder != NULL); call_stats_->DeregisterStatsObserver(vie_channel->GetStatsObserver()); - SetChannelRembStatus(channel_id, false, false, vie_channel); + SetChannelRembStatus(false, false, vie_channel); // If we're owning the encoder, remove the feedback and stop all encoding // threads and processing. This must be done before deleting the channel. @@ -446,8 +446,7 @@ int64_t ChannelGroup::GetPacerQueuingDelayMs() const { return pacer_->QueueInMs(); } -void ChannelGroup::SetChannelRembStatus(int channel_id, - bool sender, +void ChannelGroup::SetChannelRembStatus(bool sender, bool receiver, ViEChannel* channel) { // Update the channel state. diff --git a/webrtc/video_engine/vie_channel_group.h b/webrtc/video_engine/vie_channel_group.h index 546da690b..a20a541d6 100644 --- a/webrtc/video_engine/vie_channel_group.h +++ b/webrtc/video_engine/vie_channel_group.h @@ -64,10 +64,7 @@ class ChannelGroup : public BitrateObserver { void SetSyncInterface(VoEVideoSync* sync_interface); - void SetChannelRembStatus(int channel_id, - bool sender, - bool receiver, - ViEChannel* channel); + void SetChannelRembStatus(bool sender, bool receiver, ViEChannel* channel); BitrateController* GetBitrateController() const; CallStats* GetCallStats() const; diff --git a/webrtc/video_engine/vie_channel_manager.cc b/webrtc/video_engine/vie_channel_manager.cc index c06b7e3f4..3e091e1f2 100644 --- a/webrtc/video_engine/vie_channel_manager.cc +++ b/webrtc/video_engine/vie_channel_manager.cc @@ -12,6 +12,7 @@ #include +#include "webrtc/base/checks.h" #include "webrtc/common.h" #include "webrtc/engine_configurations.h" #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" @@ -134,6 +135,13 @@ int ViEChannelManager::CreateChannel(int* channel_id, return 0; } +ChannelGroup* ViEChannelManager::GetChannelGroup(int channel_id) { + CriticalSectionScoped cs(channel_id_critsect_); + ChannelGroup* group = FindGroup(channel_id); + DCHECK(group); + return group; +} + int ViEChannelManager::DeleteChannel(int channel_id) { ChannelGroup* group = NULL; { @@ -224,7 +232,7 @@ bool ViEChannelManager::SetRembStatus(int channel_id, bool sender, ViEChannel* channel = ViEChannelPtr(channel_id); assert(channel); - group->SetChannelRembStatus(channel_id, sender, receiver, channel); + group->SetChannelRembStatus(sender, receiver, channel); return true; } diff --git a/webrtc/video_engine/vie_channel_manager.h b/webrtc/video_engine/vie_channel_manager.h index 1732d7923..0fbbaf6e9 100644 --- a/webrtc/video_engine/vie_channel_manager.h +++ b/webrtc/video_engine/vie_channel_manager.h @@ -59,6 +59,8 @@ class ViEChannelManager: private ViEManagerBase { bool sender, bool disable_default_encoder); + ChannelGroup* GetChannelGroup(int channel_id); + // Deletes a channel. int DeleteChannel(int channel_id);