From 4eeeefebb20554aeef31aa9fcf5ee5280a7cb535 Mon Sep 17 00:00:00 2001 From: "henrike@webrtc.org" Date: Wed, 13 Aug 2014 14:57:30 +0000 Subject: [PATCH] (Auto)update libjingle 73072800 -> 73215194 git-svn-id: http://webrtc.googlecode.com/svn/trunk@6887 4adac7df-926f-26a2-2b94-8c16560cd09d --- talk/media/base/videoengine_unittest.h | 9 +- talk/media/webrtc/fakewebrtcvideoengine.h | 14 +- talk/media/webrtc/webrtcvideoengine.cc | 418 ++++++++++++---------- talk/media/webrtc/webrtcvideoengine.h | 62 ++-- 4 files changed, 277 insertions(+), 226 deletions(-) diff --git a/talk/media/base/videoengine_unittest.h b/talk/media/base/videoengine_unittest.h index 502cf47ce..40881ebd2 100644 --- a/talk/media/base/videoengine_unittest.h +++ b/talk/media/base/videoengine_unittest.h @@ -1720,7 +1720,6 @@ class VideoMediaChannelTest : public testing::Test, EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[kSsrcsSize - 1])); } - // Two streams one channel tests. // Tests that we can send and receive frames. @@ -1742,18 +1741,18 @@ class VideoMediaChannelTest : public testing::Test, void TwoStreamsReUseFirstStream(const cricket::VideoCodec& codec) { SetUpSecondStream(); // Default channel used by the first stream. - EXPECT_EQ(kSsrc, channel_->GetDefaultChannelSsrc()); + EXPECT_EQ(kSsrc, channel_->GetDefaultSendChannelSsrc()); EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc)); EXPECT_FALSE(channel_->RemoveRecvStream(kSsrc)); EXPECT_TRUE(channel_->RemoveSendStream(kSsrc)); EXPECT_FALSE(channel_->RemoveSendStream(kSsrc)); // Default channel is no longer used by a stream. - EXPECT_EQ(0u, channel_->GetDefaultChannelSsrc()); + EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc()); uint32 new_ssrc = kSsrc + 100; EXPECT_TRUE(channel_->AddSendStream( cricket::StreamParams::CreateLegacy(new_ssrc))); // Re-use default channel. - EXPECT_EQ(new_ssrc, channel_->GetDefaultChannelSsrc()); + EXPECT_EQ(new_ssrc, channel_->GetDefaultSendChannelSsrc()); EXPECT_FALSE(channel_->AddSendStream( cricket::StreamParams::CreateLegacy(new_ssrc))); EXPECT_TRUE(channel_->AddRecvStream( @@ -1766,7 +1765,7 @@ class VideoMediaChannelTest : public testing::Test, SendAndReceive(codec); EXPECT_TRUE(channel_->RemoveSendStream(new_ssrc)); - EXPECT_EQ(0u, channel_->GetDefaultChannelSsrc()); + EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc()); } // Tests that we can send and receive frames with early receive. diff --git a/talk/media/webrtc/fakewebrtcvideoengine.h b/talk/media/webrtc/fakewebrtcvideoengine.h index 3a619bd8a..da5cd893b 100644 --- a/talk/media/webrtc/fakewebrtcvideoengine.h +++ b/talk/media/webrtc/fakewebrtcvideoengine.h @@ -548,13 +548,21 @@ class FakeWebRtcVideoEngine WEBRTC_ASSERT_CHANNEL(channel); return channels_.find(channel)->second->overuse_options_; } - int GetRtxSsrc(int channel, int simulcast_idx) const { + int GetSsrc(int channel, int idx) const { WEBRTC_ASSERT_CHANNEL(channel); - if (channels_.find(channel)->second->rtx_ssrcs_.find(simulcast_idx) == + if (channels_.find(channel)->second->ssrcs_.find(idx) == + channels_.find(channel)->second->ssrcs_.end()) { + return -1; + } + return channels_.find(channel)->second->ssrcs_[idx]; + } + int GetRtxSsrc(int channel, int idx) const { + WEBRTC_ASSERT_CHANNEL(channel); + if (channels_.find(channel)->second->rtx_ssrcs_.find(idx) == channels_.find(channel)->second->rtx_ssrcs_.end()) { return -1; } - return channels_.find(channel)->second->rtx_ssrcs_[simulcast_idx]; + return channels_.find(channel)->second->rtx_ssrcs_[idx]; } bool ReceiveCodecRegistered(int channel, const webrtc::VideoCodec& codec) const { diff --git a/talk/media/webrtc/webrtcvideoengine.cc b/talk/media/webrtc/webrtcvideoengine.cc index 7afe5de6b..3e42b7c48 100644 --- a/talk/media/webrtc/webrtcvideoengine.cc +++ b/talk/media/webrtc/webrtcvideoengine.cc @@ -88,6 +88,10 @@ static const int kDefaultNumberOfTemporalLayers = 1; // 1:1 static const int kExternalVideoPayloadTypeBase = 120; +static const int kChannelIdUnset = -1; +static const uint32 kDefaultChannelSsrcKey = 0; +static const uint32 kSsrcUnset = 0; + static bool BitrateIsSet(int value) { return value > kAutoBandwidth; } @@ -177,7 +181,7 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer { // TODO(ronghuawu): Add unit test for this case. Didn't do it now // because the WebRtcRenderAdapter is currently hiding in cc file. No // good way to get access to it from the unit test. - if (width_ > 0 && height_ > 0 && renderer_ != NULL) { + if (width_ > 0 && height_ > 0 && renderer_) { if (!renderer_->SetSize(width_, height_, 0)) { LOG(LS_ERROR) << "WebRtcRenderAdapter (channel " << channel_id_ @@ -196,7 +200,7 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer { LOG(LS_INFO) << "WebRtcRenderAdapter (channel " << channel_id_ << ") frame size changed to: " << width << "x" << height; - if (renderer_ == NULL) { + if (!renderer_) { LOG(LS_VERBOSE) << "WebRtcRenderAdapter (channel " << channel_id_ << ") the renderer has not been set. " << "SetSize will be called later in SetRenderer."; @@ -225,7 +229,7 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer { capture_start_ntp_time_ms_ = ntp_time_ms - elapsed_time_ms; } frame_rate_tracker_.Update(1); - if (renderer_ == NULL) { + if (!renderer_) { return 0; } // Convert elapsed_time_ms to ns timestamp. @@ -237,7 +241,7 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer { // Note that here we send the |elapsed_time_ns| to renderer as the // cricket::VideoFrame's elapsed_time_ and the |render_time_ns| as the // cricket::VideoFrame's time_stamp_. - if (handle == NULL) { + if (!handle) { return DeliverBufferFrame(buffer, buffer_size, render_time_ns, elapsed_time_ns); } else { @@ -311,8 +315,8 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer { class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver { public: - explicit WebRtcDecoderObserver(int video_channel) - : video_channel_(video_channel), + explicit WebRtcDecoderObserver(int video_channel_id) + : video_channel_id_(video_channel_id), framerate_(0), bitrate_(0), decode_ms_(0), @@ -325,13 +329,13 @@ class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver { } // virtual functions from VieDecoderObserver. - virtual void IncomingCodecChanged(const int videoChannel, + virtual void IncomingCodecChanged(const int video_channel_id, const webrtc::VideoCodec& videoCodec) {} - virtual void IncomingRate(const int videoChannel, + virtual void IncomingRate(const int video_channel_id, const unsigned int framerate, const unsigned int bitrate) { rtc::CritScope cs(&crit_); - ASSERT(video_channel_ == videoChannel); + ASSERT(video_channel_id_ == video_channel_id); framerate_ = framerate; bitrate_ = bitrate; } @@ -353,7 +357,7 @@ class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver { render_delay_ms_ = render_delay_ms; } - virtual void RequestNewKeyFrame(const int videoChannel) {} + virtual void RequestNewKeyFrame(const int video_channel_id) {} // Populate |rinfo| based on previously-set data in |*this|. void ExportTo(VideoReceiverInfo* rinfo) { @@ -370,7 +374,7 @@ class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver { private: mutable rtc::CriticalSection crit_; - int video_channel_; + int video_channel_id_; int framerate_; int bitrate_; int decode_ms_; @@ -384,26 +388,26 @@ class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver { class WebRtcEncoderObserver : public webrtc::ViEEncoderObserver { public: - explicit WebRtcEncoderObserver(int video_channel) - : video_channel_(video_channel), + explicit WebRtcEncoderObserver(int video_channel_id) + : video_channel_id_(video_channel_id), framerate_(0), bitrate_(0), suspended_(false) { } // virtual functions from VieEncoderObserver. - virtual void OutgoingRate(const int videoChannel, + virtual void OutgoingRate(const int video_channel_id, const unsigned int framerate, const unsigned int bitrate) { rtc::CritScope cs(&crit_); - ASSERT(video_channel_ == videoChannel); + ASSERT(video_channel_id_ == video_channel_id); framerate_ = framerate; bitrate_ = bitrate; } - virtual void SuspendChange(int video_channel, bool is_suspended) { + virtual void SuspendChange(int video_channel_id, bool is_suspended) { rtc::CritScope cs(&crit_); - ASSERT(video_channel_ == video_channel); + ASSERT(video_channel_id_ == video_channel_id); suspended_ = is_suspended; } @@ -422,7 +426,7 @@ class WebRtcEncoderObserver : public webrtc::ViEEncoderObserver { private: mutable rtc::CriticalSection crit_; - int video_channel_; + int video_channel_id_; int framerate_; int bitrate_; bool suspended_; @@ -840,7 +844,7 @@ const VideoFormatPod WebRtcVideoEngine::kDefaultMaxVideoFormat = static void UpdateVideoCodec(const cricket::VideoFormat& video_format, webrtc::VideoCodec* target_codec) { - if ((target_codec == NULL) || (video_format == cricket::VideoFormat())) { + if ((!target_codec) || (video_format == cricket::VideoFormat())) { return; } target_codec->width = video_format.width; @@ -1473,7 +1477,7 @@ void WebRtcVideoEngine::Print(webrtc::TraceLevel level, const char* trace, webrtc::VideoDecoder* WebRtcVideoEngine::CreateExternalDecoder( webrtc::VideoCodecType type) { - if (decoder_factory_ == NULL) { + if (!decoder_factory_) { return NULL; } return decoder_factory_->CreateVideoDecoder(type); @@ -1481,14 +1485,14 @@ webrtc::VideoDecoder* WebRtcVideoEngine::CreateExternalDecoder( void WebRtcVideoEngine::DestroyExternalDecoder(webrtc::VideoDecoder* decoder) { ASSERT(decoder_factory_ != NULL); - if (decoder_factory_ == NULL) + if (!decoder_factory_) return; decoder_factory_->DestroyVideoDecoder(decoder); } webrtc::VideoEncoder* WebRtcVideoEngine::CreateExternalEncoder( webrtc::VideoCodecType type) { - if (encoder_factory_ == NULL) { + if (!encoder_factory_) { return NULL; } return encoder_factory_->CreateVideoEncoder(type); @@ -1496,7 +1500,7 @@ webrtc::VideoEncoder* WebRtcVideoEngine::CreateExternalEncoder( void WebRtcVideoEngine::DestroyExternalEncoder(webrtc::VideoEncoder* encoder) { ASSERT(encoder_factory_ != NULL); - if (encoder_factory_ == NULL) + if (!encoder_factory_) return; encoder_factory_->DestroyVideoEncoder(encoder); } @@ -1559,11 +1563,11 @@ WebRtcVideoMediaChannel::WebRtcVideoMediaChannel( VoiceMediaChannel* channel) : engine_(engine), voice_channel_(channel), - vie_channel_(-1), + default_channel_id_(kChannelIdUnset), nack_enabled_(true), remb_enabled_(false), render_started_(false), - first_receive_ssrc_(0), + first_receive_ssrc_(kSsrcUnset), num_unsignalled_recv_channels_(0), send_rtx_type_(-1), send_red_type_(-1), @@ -1576,7 +1580,7 @@ WebRtcVideoMediaChannel::WebRtcVideoMediaChannel( bool WebRtcVideoMediaChannel::Init() { const uint32 ssrc_key = 0; - return CreateChannel(ssrc_key, MD_SENDRECV, &vie_channel_); + return CreateChannel(ssrc_key, MD_SENDRECV, &default_channel_id_); } WebRtcVideoMediaChannel::~WebRtcVideoMediaChannel() { @@ -1758,7 +1762,7 @@ bool WebRtcVideoMediaChannel::GetSendCodec(VideoCodec* send_codec) { bool WebRtcVideoMediaChannel::SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) { - WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc); + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc); if (!send_channel) { LOG(LS_ERROR) << "The specified ssrc " << ssrc << " is not in use."; return false; @@ -1840,22 +1844,23 @@ bool WebRtcVideoMediaChannel::AddSendStream(const StreamParams& sp) { } uint32 ssrc_key; - if (!CreateSendChannelKey(sp.first_ssrc(), &ssrc_key)) { + if (!CreateSendChannelSsrcKey(sp.first_ssrc(), &ssrc_key)) { LOG(LS_ERROR) << "Trying to register duplicate ssrc: " << sp.first_ssrc(); return false; } // If the default channel is already used for sending create a new channel // otherwise use the default channel for sending. - int channel_id = -1; - if (send_channels_[0]->stream_params() == NULL) { - channel_id = vie_channel_; + int channel_id = kChannelIdUnset; + if (!DefaultSendChannelInUse()) { + channel_id = default_channel_id_; } else { if (!CreateChannel(ssrc_key, MD_SEND, &channel_id)) { LOG(LS_ERROR) << "AddSendStream: unable to create channel"; return false; } } - WebRtcVideoChannelSendInfo* send_channel = send_channels_[ssrc_key]; + + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrcKey(ssrc_key); // Set the send (local) SSRC. // If there are multiple send SSRCs, we can only set the first one here, and // the rest of the SSRC(s) need to be set after SetSendCodec has been called @@ -1882,7 +1887,7 @@ bool WebRtcVideoMediaChannel::AddSendStream(const StreamParams& sp) { // the default channel make sure that all the receive channels are updated as // well. Receive channels have to have the same SSRC as the default channel in // order to send receiver reports with this SSRC. - if (IsDefaultChannel(channel_id)) { + if (IsDefaultChannelId(channel_id)) { for (RecvChannelMap::const_iterator it = recv_channels_.begin(); it != recv_channels_.end(); ++it) { WebRtcVideoChannelRecvInfo* info = it->second; @@ -1918,14 +1923,14 @@ bool WebRtcVideoMediaChannel::RemoveSendStream(uint32 ssrc) { } uint32 ssrc_key; - if (!GetSendChannelKey(ssrc, &ssrc_key)) { + if (!GetSendChannelSsrcKey(ssrc, &ssrc_key)) { LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc << " which doesn't exist."; return false; } - WebRtcVideoChannelSendInfo* send_channel = send_channels_[ssrc_key]; + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrcKey(ssrc_key); int channel_id = send_channel->channel_id(); - if (IsDefaultChannel(channel_id) && (send_channel->stream_params() == NULL)) { + if (IsDefaultChannelId(channel_id) && !send_channel->stream_params()) { // Default channel will still exist. However, if stream_params() is NULL // there is no stream to remove. return false; @@ -1947,8 +1952,8 @@ bool WebRtcVideoMediaChannel::RemoveSendStream(uint32 ssrc) { send_channel->ClearRegisteredEncoders(); // The receive channels depend on the default channel, recycle it instead. - if (IsDefaultChannel(channel_id)) { - SetCapturer(GetDefaultChannelSsrc(), NULL); + if (IsDefaultChannelId(channel_id)) { + SetCapturer(GetDefaultSendChannelSsrc(), NULL); send_channel->ClearStreamParams(); } else { return DeleteSendChannel(ssrc_key); @@ -1965,27 +1970,26 @@ bool WebRtcVideoMediaChannel::AddRecvStream(const StreamParams& sp) { // TODO(zhurunz) Remove this once BWE works properly across different send // and receive channels. // Reuse default channel for recv stream in 1:1 call. - if (!InConferenceMode() && first_receive_ssrc_ == 0) { + if (!InConferenceMode() && first_receive_ssrc_ == kSsrcUnset) { LOG(LS_INFO) << "Recv stream " << sp.first_ssrc() << " reuse default channel #" - << vie_channel_; + << default_channel_id_; first_receive_ssrc_ = sp.first_ssrc(); - if (!MaybeSetRtxSsrc(sp, vie_channel_)) { + if (!MaybeSetRtxSsrc(sp, default_channel_id_)) { return false; } if (render_started_) { - if (engine()->vie()->render()->StartRender(vie_channel_) !=0) { - LOG_RTCERR1(StartRender, vie_channel_); + if (engine()->vie()->render()->StartRender(default_channel_id_) !=0) { + LOG_RTCERR1(StartRender, default_channel_id_); } } return true; } - int channel_id = -1; - RecvChannelMap::iterator channel_iterator = - recv_channels_.find(sp.first_ssrc()); - if (channel_iterator == recv_channels_.end() && - first_receive_ssrc_ != sp.first_ssrc()) { + int channel_id = kChannelIdUnset; + uint32 ssrc = sp.first_ssrc(); + WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc); + if (!recv_channel && first_receive_ssrc_ != ssrc) { // TODO(perkj): Implement recv media from multiple media SSRCs per stream. // NOTE: We have two SSRCs per stream when RTX is enabled. if (!IsOneSsrcStream(sp)) { @@ -2003,13 +2007,12 @@ bool WebRtcVideoMediaChannel::AddRecvStream(const StreamParams& sp) { } } else { // Already exists. - if (first_receive_ssrc_ == sp.first_ssrc()) { + if (first_receive_ssrc_ == ssrc) { return false; } // Early receive added channel. - channel_id = (*channel_iterator).second->channel_id(); + channel_id = recv_channel->channel_id(); } - channel_iterator = recv_channels_.find(sp.first_ssrc()); if (!MaybeSetRtxSsrc(sp, channel_id)) { return false; @@ -2018,13 +2021,13 @@ bool WebRtcVideoMediaChannel::AddRecvStream(const StreamParams& sp) { // Get the default renderer. VideoRenderer* default_renderer = NULL; if (InConferenceMode()) { - // The recv_channels_ size start out being 1, so if it is two here this - // is the first receive channel created (vie_channel_ is not used for - // receiving in a conference call). This means that the renderer stored - // inside vie_channel_ should be used for the just created channel. - if (recv_channels_.size() == 2 && - recv_channels_.find(0) != recv_channels_.end()) { - GetRenderer(0, &default_renderer); + // The recv_channels_ size start out being 1, so if it is two here + // this is the first receive channel created (default_channel_id_ + // is not used for receiving in a conference call). This means + // that the renderer stored inside default_channel_id_ should be + // used for the just created channel. + if (recv_channels_.size() == 2 && GetDefaultRecvChannel()) { + GetDefaultRenderer(&default_renderer); } } @@ -2036,8 +2039,8 @@ bool WebRtcVideoMediaChannel::AddRecvStream(const StreamParams& sp) { LOG(LS_INFO) << "New video stream " << sp.first_ssrc() << " registered to VideoEngine channel #" - << channel_id << " and connected to channel #" << vie_channel_; - + << channel_id << " and connected to channel #" + << default_channel_id_; return true; } @@ -2068,26 +2071,25 @@ bool WebRtcVideoMediaChannel::RemoveRecvStream(uint32 ssrc) { } bool WebRtcVideoMediaChannel::RemoveRecvStreamInternal(uint32 ssrc) { - RecvChannelMap::iterator it = recv_channels_.find(ssrc); - if (it == recv_channels_.end()) { + WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc); + if (!recv_channel) { // TODO(perkj): Remove this once BWE works properly across different send // and receive channels. // The default channel is reused for recv stream in 1:1 call. if (first_receive_ssrc_ == ssrc) { - first_receive_ssrc_ = 0; + first_receive_ssrc_ = kSsrcUnset; // Need to stop the renderer and remove it since the render window can be // deleted after this. if (render_started_) { - if (engine()->vie()->render()->StopRender(vie_channel_) !=0) { - LOG_RTCERR1(StopRender, it->second->channel_id()); + if (engine()->vie()->render()->StopRender(default_channel_id_) !=0) { + LOG_RTCERR1(StopRender, recv_channel->channel_id()); } } - recv_channels_[0]->SetRenderer(NULL); + GetDefaultRecvChannel()->SetRenderer(NULL); return true; } return false; } - WebRtcVideoChannelRecvInfo* info = it->second; // Remove any RTX SSRC mappings to this stream. SsrcMap::iterator rtx_it = rtx_to_primary_ssrc_.begin(); @@ -2099,7 +2101,7 @@ bool WebRtcVideoMediaChannel::RemoveRecvStreamInternal(uint32 ssrc) { } } - int channel_id = info->channel_id(); + int channel_id = recv_channel->channel_id(); if (engine()->vie()->render()->RemoveRenderer(channel_id) != 0) { LOG_RTCERR1(RemoveRenderer, channel_id); } @@ -2114,7 +2116,7 @@ bool WebRtcVideoMediaChannel::RemoveRecvStreamInternal(uint32 ssrc) { } const WebRtcVideoChannelRecvInfo::DecoderMap& decoder_map = - info->registered_decoders(); + recv_channel->registered_decoders(); for (WebRtcVideoChannelRecvInfo::DecoderMap::const_iterator it = decoder_map.begin(); it != decoder_map.end(); ++it) { if (engine()->vie()->ext_codec()->DeRegisterExternalReceiveCodec( @@ -2123,7 +2125,7 @@ bool WebRtcVideoMediaChannel::RemoveRecvStreamInternal(uint32 ssrc) { } engine()->DestroyExternalDecoder(it->second); } - info->ClearRegisteredDecoders(); + recv_channel->ClearRegisteredDecoders(); LOG(LS_INFO) << "Removing video stream " << ssrc << " with VideoEngine channel #" @@ -2134,8 +2136,8 @@ bool WebRtcVideoMediaChannel::RemoveRecvStreamInternal(uint32 ssrc) { ret = false; } // Delete the WebRtcVideoChannelRecvInfo pointed to by it->second. - delete info; - recv_channels_.erase(it); + delete recv_channel; + recv_channels_.erase(ssrc); return ret; } @@ -2203,67 +2205,86 @@ bool WebRtcVideoMediaChannel::SendIntraFrame() { bool WebRtcVideoMediaChannel::HasReadySendChannels() { return !send_channels_.empty() && - ((send_channels_.size() > 1) || - (send_channels_[0]->stream_params() != NULL)); + ((send_channels_.size() > 1) || DefaultSendChannelInUse()); } -bool WebRtcVideoMediaChannel::GetSendChannelKey(uint32 local_ssrc, - uint32* key) { - *key = 0; +bool WebRtcVideoMediaChannel::DefaultSendChannelInUse() { + return GetDefaultSendChannel() && GetDefaultSendChannel()->stream_params(); +} + +bool WebRtcVideoMediaChannel::GetSendChannelSsrcKey(uint32 local_ssrc, + uint32* ssrc_key) { + *ssrc_key = kDefaultChannelSsrcKey; // If a send channel is not ready to send it will not have local_ssrc // registered to it. if (!HasReadySendChannels()) { return false; } - // The default channel is stored with key 0. The key therefore does not match - // the SSRC associated with the default channel. Check if the SSRC provided - // corresponds to the default channel's SSRC. - if (local_ssrc == GetDefaultChannelSsrc()) { + // The default channel is stored with ssrc key + // kDefaultChannelSsrcKey. The ssrc key therefore does not match the + // SSRC associated with the default channel. Check if the SSRC + // provided corresponds to the default channel's SSRC. + if (local_ssrc == GetDefaultSendChannelSsrc()) { return true; } - if (send_channels_.find(local_ssrc) == send_channels_.end()) { + if (!GetSendChannelBySsrcKey(local_ssrc)) { for (SendChannelMap::iterator iter = send_channels_.begin(); iter != send_channels_.end(); ++iter) { WebRtcVideoChannelSendInfo* send_channel = iter->second; if (send_channel->has_ssrc(local_ssrc)) { - *key = iter->first; + *ssrc_key = iter->first; return true; } } return false; } - // The key was found in the above std::map::find call. This means that the - // ssrc is the key. - *key = local_ssrc; + // The ssrc key was found in the above std::map::find call. This + // means that the ssrc is the ssrc key. + *ssrc_key = local_ssrc; return true; } -WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetSendChannel( - uint32 local_ssrc) { - uint32 key; - if (!GetSendChannelKey(local_ssrc, &key)) { - return NULL; - } - return send_channels_[key]; +WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetDefaultSendChannel() { + return GetSendChannelBySsrcKey(kDefaultChannelSsrcKey); } -bool WebRtcVideoMediaChannel::CreateSendChannelKey(uint32 local_ssrc, - uint32* key) { - if (GetSendChannelKey(local_ssrc, key)) { - // If there is a key corresponding to |local_ssrc|, the SSRC is already in - // use. SSRCs need to be unique in a session and at this point a duplicate - // SSRC has been detected. +WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetSendChannelBySsrcKey( + uint32 ssrc_key) { + std::map::iterator iter = + send_channels_.find(ssrc_key); + if (iter == send_channels_.end()) { + return NULL; + } + return iter->second; +} + +WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetSendChannelBySsrc( + uint32 local_ssrc) { + uint32 ssrc_key; + if (!GetSendChannelSsrcKey(local_ssrc, &ssrc_key)) { + return NULL; + } + return send_channels_[ssrc_key]; +} + +bool WebRtcVideoMediaChannel::CreateSendChannelSsrcKey(uint32 local_ssrc, + uint32* ssrc_key) { + if (GetSendChannelSsrcKey(local_ssrc, ssrc_key)) { + // If there is an ssrc key corresponding to |local_ssrc|, the SSRC + // is already in use. SSRCs need to be unique in a session and at + // this point a duplicate SSRC has been detected. return false; } - if (send_channels_[0]->stream_params() == NULL) { - // key should be 0 here as the default channel should be re-used whenever it - // is not used. - *key = 0; + if (!DefaultSendChannelInUse()) { + // |ssrc_key| should be kDefaultChannelSsrcKey here as the default + // channel should be re-used whenever it is not used. + *ssrc_key = kDefaultChannelSsrcKey; return true; } - // SSRC is currently not in use and the default channel is already in use. Use - // the SSRC as key since it is supposed to be unique in a session. - *key = local_ssrc; + // SSRC is currently not in use and the default channel is already + // in use. Use the SSRC as ssrc_key since it is supposed to be + // unique in a session. + *ssrc_key = local_ssrc; return true; } @@ -2279,21 +2300,18 @@ int WebRtcVideoMediaChannel::GetSendChannelNum(VideoCapturer* capturer) { return num; } -uint32 WebRtcVideoMediaChannel::GetDefaultChannelSsrc() { - WebRtcVideoChannelSendInfo* send_channel = send_channels_[0]; - const StreamParams* sp = send_channel->stream_params(); - if (sp == NULL) { - // This happens if no send stream is currently registered. +uint32 WebRtcVideoMediaChannel::GetDefaultSendChannelSsrc() { + if (!DefaultSendChannelInUse()) { return 0; } - return sp->first_ssrc(); + return GetDefaultSendChannel()->stream_params()->first_ssrc(); } bool WebRtcVideoMediaChannel::DeleteSendChannel(uint32 ssrc_key) { - if (send_channels_.find(ssrc_key) == send_channels_.end()) { + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrcKey(ssrc_key); + if (!send_channel) { return false; } - WebRtcVideoChannelSendInfo* send_channel = send_channels_[ssrc_key]; MaybeDisconnectCapturer(send_channel->video_capturer()); send_channel->set_video_capturer(NULL, engine()->vie()); @@ -2317,7 +2335,7 @@ bool WebRtcVideoMediaChannel::DeleteSendChannel(uint32 ssrc_key) { // The default channel is stored in both |send_channels_| and // |recv_channels_|. To make sure it is only deleted once from vie let the // delete call happen when tearing down |recv_channels_| and not here. - if (!IsDefaultChannel(channel_id)) { + if (!IsDefaultChannelId(channel_id)) { engine_->vie()->base()->DeleteChannel(channel_id); } delete send_channel; @@ -2325,13 +2343,25 @@ bool WebRtcVideoMediaChannel::DeleteSendChannel(uint32 ssrc_key) { return true; } +WebRtcVideoChannelRecvInfo* WebRtcVideoMediaChannel::GetDefaultRecvChannel() { + return GetRecvChannelBySsrc(kDefaultChannelSsrcKey); +} + +WebRtcVideoChannelRecvInfo* WebRtcVideoMediaChannel::GetRecvChannelBySsrc( + uint32 ssrc) { + if (recv_channels_.find(ssrc) == recv_channels_.end()) { + return NULL; + } + return recv_channels_[ssrc]; +} + bool WebRtcVideoMediaChannel::RemoveCapturer(uint32 ssrc) { - WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc); + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc); if (!send_channel) { return false; } VideoCapturer* capturer = send_channel->video_capturer(); - if (capturer == NULL) { + if (!capturer) { return false; } MaybeDisconnectCapturer(capturer); @@ -2345,22 +2375,22 @@ bool WebRtcVideoMediaChannel::RemoveCapturer(uint32 ssrc) { bool WebRtcVideoMediaChannel::SetRenderer(uint32 ssrc, VideoRenderer* renderer) { - if (recv_channels_.find(ssrc) == recv_channels_.end()) { + WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc); + if (!recv_channel) { // TODO(perkj): Remove this once BWE works properly across different send // and receive channels. // The default channel is reused for recv stream in 1:1 call. - if (first_receive_ssrc_ == ssrc && - recv_channels_.find(0) != recv_channels_.end()) { + if (first_receive_ssrc_ == ssrc && GetDefaultRecvChannel()) { LOG(LS_INFO) << "SetRenderer " << ssrc << " reuse default channel #" - << vie_channel_; - recv_channels_[0]->SetRenderer(renderer); + << default_channel_id_; + GetDefaultRecvChannel()->SetRenderer(renderer); return true; } return false; } - recv_channels_[ssrc]->SetRenderer(renderer); + recv_channel->SetRenderer(renderer); return true; } @@ -2380,21 +2410,21 @@ bool WebRtcVideoMediaChannel::GetStats(const StatsOptions& options, const int channel_id = send_channel->channel_id(); VideoSenderInfo sinfo; const StreamParams* send_params = send_channel->stream_params(); - if (send_params == NULL) { + if (!send_params) { // This should only happen if the default vie channel is not in use. // This can happen if no streams have ever been added or the stream // corresponding to the default channel has been removed. Note that // there may be non-default vie channels in use when this happen so // asserting send_channels_.size() == 1 is not correct and neither is // breaking out of the loop. - ASSERT(channel_id == vie_channel_); + ASSERT(channel_id == default_channel_id_); continue; } unsigned int bytes_sent, packets_sent, bytes_recv, packets_recv; if (engine_->vie()->rtp()->GetRTPStatistics(channel_id, bytes_sent, packets_sent, bytes_recv, packets_recv) != 0) { - LOG_RTCERR1(GetRTPStatistics, vie_channel_); + LOG_RTCERR1(GetRTPStatistics, default_channel_id_); continue; } WebRtcLocalStreamInfo* channel_stream_info = @@ -2638,7 +2668,7 @@ bool WebRtcVideoMediaChannel::GetStats(const StatsOptions& options, // Only call for the default channel because the returned stats are // collected for all the channels using the same estimator. if (engine_->vie()->rtp()->GetReceiveBandwidthEstimatorStats( - recv_channels_[0]->channel_id(), &additional_stats) == 0) { + GetDefaultRecvChannel()->channel_id(), &additional_stats) == 0) { bwe.total_received_propagation_delta_ms = additional_stats.total_propagation_time_delta_ms; bwe.recent_received_propagation_delta_ms.swap( @@ -2649,7 +2679,7 @@ bool WebRtcVideoMediaChannel::GetStats(const StatsOptions& options, } engine_->vie()->rtp()->GetPacerQueuingDelayMs( - recv_channels_[0]->channel_id(), &bwe.bucket_delay); + GetDefaultRecvChannel()->channel_id(), &bwe.bucket_delay); // Calculations done above per send/receive stream. bwe.actual_enc_bitrate = video_bitrate_sent; @@ -2670,7 +2700,7 @@ bool WebRtcVideoMediaChannel::SetCapturer(uint32 ssrc, if (!capturer) { return RemoveCapturer(ssrc); } - WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc); + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc); if (!send_channel) { return false; } @@ -2703,13 +2733,13 @@ void WebRtcVideoMediaChannel::OnPacketReceived( uint32 ssrc = 0; if (!GetRtpSsrc(packet->data(), packet->length(), &ssrc)) return; - int processing_channel = GetRecvChannelNum(ssrc); - if (processing_channel == -1) { + int processing_channel_id = GetRecvChannelId(ssrc); + if (processing_channel_id == kChannelIdUnset) { // Allocate an unsignalled recv channel for processing in conference mode. if (!InConferenceMode()) { // If we can't find or allocate one, use the default. - processing_channel = video_channel(); - } else if (!CreateUnsignalledRecvChannel(ssrc, &processing_channel)) { + processing_channel_id = default_channel_id_; + } else if (!CreateUnsignalledRecvChannel(ssrc, &processing_channel_id)) { // If we can't create an unsignalled recv channel, drop the packet in // conference mode. return; @@ -2717,7 +2747,7 @@ void WebRtcVideoMediaChannel::OnPacketReceived( } engine()->vie()->network()->ReceivedRTPPacket( - processing_channel, + processing_channel_id, packet->data(), static_cast(packet->length()), webrtc::PacketTime(packet_time.timestamp, packet_time.not_before)); @@ -2743,10 +2773,10 @@ void WebRtcVideoMediaChannel::OnRtcpReceived( // If it is a sender report, find the channel that is listening. if (type == kRtcpTypeSR) { - int which_channel = GetRecvChannelNum(ssrc); - if (which_channel != -1 && !IsDefaultChannel(which_channel)) { + int recv_channel_id = GetRecvChannelId(ssrc); + if (recv_channel_id != kChannelIdUnset && !IsDefaultChannelId(recv_channel_id)) { engine_->vie()->network()->ReceivedRTCPPacket( - which_channel, + recv_channel_id, packet->data(), static_cast(packet->length())); } @@ -2770,7 +2800,7 @@ void WebRtcVideoMediaChannel::OnReadyToSend(bool ready) { } bool WebRtcVideoMediaChannel::MuteStream(uint32 ssrc, bool muted) { - WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc); + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc); if (!send_channel) { LOG(LS_ERROR) << "The specified ssrc " << ssrc << " is not in use."; return false; @@ -3110,30 +3140,33 @@ void WebRtcVideoMediaChannel::UpdateAspectRatio(int ratio_w, int ratio_h) { bool WebRtcVideoMediaChannel::GetRenderer(uint32 ssrc, VideoRenderer** renderer) { - RecvChannelMap::const_iterator it = recv_channels_.find(ssrc); - if (it == recv_channels_.end()) { - if (first_receive_ssrc_ == ssrc && - recv_channels_.find(0) != recv_channels_.end()) { + WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc); + if (!recv_channel) { + if (first_receive_ssrc_ == ssrc && GetDefaultRecvChannel()) { LOG(LS_INFO) << " GetRenderer " << ssrc << " reuse default renderer #" - << vie_channel_; - *renderer = recv_channels_[0]->render_adapter()->renderer(); + << default_channel_id_; + *renderer = GetDefaultRecvChannel()->render_adapter()->renderer(); return true; } return false; } - *renderer = it->second->render_adapter()->renderer(); + *renderer = recv_channel->render_adapter()->renderer(); return true; } +bool WebRtcVideoMediaChannel::GetDefaultRenderer(VideoRenderer** renderer) { + return GetRenderer(kDefaultChannelSsrcKey, renderer); +} + bool WebRtcVideoMediaChannel::GetVideoAdapter( uint32 ssrc, CoordinatedVideoAdapter** video_adapter) { - SendChannelMap::iterator it = send_channels_.find(ssrc); - if (it == send_channels_.end()) { + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc); + if (!send_channel) { return false; } - *video_adapter = it->second->video_adapter(); + *video_adapter = send_channel->video_adapter(); return true; } @@ -3159,7 +3192,7 @@ void WebRtcVideoMediaChannel::SendFrame(VideoCapturer* capturer, for (SendChannelMap::iterator iter = send_channels_.begin(); iter != send_channels_.end(); ++iter) { WebRtcVideoChannelSendInfo* send_channel = iter->second; - if (send_channel->video_capturer() == NULL) { + if (!send_channel->video_capturer()) { SendFrame(send_channel, frame, capturer->IsScreencast()); } } @@ -3244,32 +3277,33 @@ bool WebRtcVideoMediaChannel::CreateChannel(uint32 ssrc_key, int* channel_id) { // There are 3 types of channels. Sending only, receiving only and // sending and receiving. The sending and receiving channel is the - // default channel and there is only one. All other channels that are created - // are associated with the default channel which must exist. The default - // channel id is stored in |vie_channel_|. All channels need to know about - // the default channel to properly handle remb which is why there are - // different ViE create channel calls. - // For this channel the local and remote ssrc key is 0. However, it may - // have a non-zero local and/or remote ssrc depending on if it is currently - // sending and/or receiving. - if ((vie_channel_ == -1 || direction == MD_SENDRECV) && + // default channel and there is only one. All other channels that + // are created are associated with the default channel which must + // exist. The default channel id is stored in + // |default_channel_id_|. All channels need to know about the + // default channel to properly handle remb which is why there are + // different ViE create channel calls. For this channel the local + // and remote ssrc_key is kDefaultChannelSsrcKey. However, it may + // have a non-zero local and/or remote ssrc depending on if it is + // currently sending and/or receiving. + if ((default_channel_id_ == kChannelIdUnset || direction == MD_SENDRECV) && (!send_channels_.empty() || !recv_channels_.empty())) { ASSERT(false); return false; } - *channel_id = -1; + *channel_id = kChannelIdUnset; if (direction == MD_RECV) { - // All rec channels are associated with the default channel |vie_channel_| + // All rec channels are associated with default_channel_id_. if (engine_->vie()->base()->CreateReceiveChannel(*channel_id, - vie_channel_) != 0) { - LOG_RTCERR2(CreateReceiveChannel, *channel_id, vie_channel_); + default_channel_id_) != 0) { + LOG_RTCERR2(CreateReceiveChannel, *channel_id, default_channel_id_); return false; } } else if (direction == MD_SEND) { if (engine_->vie()->base()->CreateChannel(*channel_id, - vie_channel_) != 0) { - LOG_RTCERR2(CreateChannel, *channel_id, vie_channel_); + default_channel_id_) != 0) { + LOG_RTCERR2(CreateChannel, *channel_id, default_channel_id_); return false; } } else { @@ -3281,7 +3315,7 @@ bool WebRtcVideoMediaChannel::CreateChannel(uint32 ssrc_key, } if (!ConfigureChannel(*channel_id, direction, ssrc_key)) { engine_->vie()->base()->DeleteChannel(*channel_id); - *channel_id = -1; + *channel_id = kChannelIdUnset; return false; } @@ -3363,9 +3397,9 @@ bool WebRtcVideoMediaChannel::ConfigureChannel(int channel_id, } bool WebRtcVideoMediaChannel::ConfigureReceiving(int channel_id, - uint32 remote_ssrc_key) { - // Make sure that an SSRC/key isn't registered more than once. - if (recv_channels_.find(remote_ssrc_key) != recv_channels_.end()) { + uint32 remote_ssrc) { + // Make sure that an SSRC isn't registered more than once. + if (GetRecvChannelBySsrc(remote_ssrc)) { return false; } // Connect the voice channel, if there is one. @@ -3373,11 +3407,11 @@ bool WebRtcVideoMediaChannel::ConfigureReceiving(int channel_id, // know the SSRC of the remote audio channel in order to fetch the correct // webrtc VoiceEngine channel. For now- only sync the default channel used // in 1-1 calls. - if (remote_ssrc_key == 0 && voice_channel_) { + if (remote_ssrc == kDefaultChannelSsrcKey && voice_channel_) { WebRtcVoiceMediaChannel* voice_channel = static_cast(voice_channel_); if (engine_->vie()->base()->ConnectAudioChannel( - vie_channel_, voice_channel->voe_channel()) != 0) { + default_channel_id_, voice_channel->voe_channel()) != 0) { LOG_RTCERR2(ConnectAudioChannel, channel_id, voice_channel->voe_channel()); LOG(LS_WARNING) << "A/V not synchronized"; @@ -3414,13 +3448,13 @@ bool WebRtcVideoMediaChannel::ConfigureReceiving(int channel_id, return false; } - if (remote_ssrc_key != 0) { + if (remote_ssrc != kDefaultChannelSsrcKey) { // Use the same SSRC as our default channel // (so the RTCP reports are correct). unsigned int send_ssrc = 0; webrtc::ViERTP_RTCP* rtp = engine()->vie()->rtp(); - if (rtp->GetLocalSSRC(vie_channel_, send_ssrc) == -1) { - LOG_RTCERR2(GetLocalSSRC, vie_channel_, send_ssrc); + if (rtp->GetLocalSSRC(default_channel_id_, send_ssrc) == -1) { + LOG_RTCERR2(GetLocalSSRC, default_channel_id_, send_ssrc); return false; } if (rtp->SetLocalSSRC(channel_id, send_ssrc) == -1) { @@ -3464,7 +3498,7 @@ bool WebRtcVideoMediaChannel::ConfigureReceiving(int channel_id, return false; } - recv_channels_[remote_ssrc_key] = channel_info.release(); + recv_channels_[remote_ssrc] = channel_info.release(); return true; } @@ -3472,12 +3506,12 @@ bool WebRtcVideoMediaChannel::ConfigureSending(int channel_id, uint32 local_ssrc_key) { // The ssrc key can be zero or correspond to an SSRC. // Make sure the default channel isn't configured more than once. - if (local_ssrc_key == 0 && send_channels_.find(0) != send_channels_.end()) { + if (local_ssrc_key == kDefaultChannelSsrcKey && GetDefaultSendChannel()) { return false; } // Make sure that the SSRC is not already in use. uint32 dummy_key; - if (GetSendChannelKey(local_ssrc_key, &dummy_key)) { + if (GetSendChannelSsrcKey(local_ssrc_key, &dummy_key)) { return false; } int vie_capture = 0; @@ -3731,8 +3765,8 @@ static std::string ToString(webrtc::VP8ResilienceMode resilience) { void WebRtcVideoMediaChannel::LogSendCodecChange(const std::string& reason) { webrtc::VideoCodec vie_codec; - if (engine()->vie()->codec()->GetSendCodec(vie_channel_, vie_codec) != 0) { - LOG_RTCERR1(GetSendCodec, vie_channel_); + if (engine()->vie()->codec()->GetSendCodec(default_channel_id_, vie_codec) != 0) { + LOG_RTCERR1(GetSendCodec, default_channel_id_); return; } @@ -3846,28 +3880,28 @@ bool WebRtcVideoMediaChannel::SetReceiveCodecs( return true; } -int WebRtcVideoMediaChannel::GetRecvChannelNum(uint32 ssrc) { +int WebRtcVideoMediaChannel::GetRecvChannelId(uint32 ssrc) { if (ssrc == first_receive_ssrc_) { - return vie_channel_; + return default_channel_id_; } - int recv_channel = -1; - RecvChannelMap::iterator it = recv_channels_.find(ssrc); - if (it == recv_channels_.end()) { + int recv_channel_id = kChannelIdUnset; + WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc); + if (!recv_channel) { // Check if we have an RTX stream registered on this SSRC. SsrcMap::iterator rtx_it = rtx_to_primary_ssrc_.find(ssrc); if (rtx_it != rtx_to_primary_ssrc_.end()) { if (rtx_it->second == first_receive_ssrc_) { - recv_channel = vie_channel_; + recv_channel_id = default_channel_id_; } else { - it = recv_channels_.find(rtx_it->second); - assert(it != recv_channels_.end()); - recv_channel = it->second->channel_id(); + recv_channel = GetRecvChannelBySsrc(rtx_it->second); + ASSERT(recv_channel != NULL); + recv_channel_id = recv_channel->channel_id(); } } } else { - recv_channel = it->second->channel_id(); + recv_channel_id = recv_channel->channel_id(); } - return recv_channel; + return recv_channel_id; } // If the new frame size is different from the send codec size we set on vie, @@ -4057,7 +4091,7 @@ void WebRtcVideoMediaChannel::QueueBlackFrame(uint32 ssrc, int64 timestamp, } void WebRtcVideoMediaChannel::FlushBlackFrame(uint32 ssrc, int64 timestamp) { - WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc); + WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc); if (!send_channel) { return; } @@ -4145,14 +4179,14 @@ bool WebRtcVideoMediaChannel::SetLocalRtxSsrc(int channel_id, } void WebRtcVideoMediaChannel::MaybeConnectCapturer(VideoCapturer* capturer) { - if (capturer != NULL && GetSendChannelNum(capturer) == 1) { + if (capturer && GetSendChannelNum(capturer) == 1) { capturer->SignalVideoFrame.connect(this, &WebRtcVideoMediaChannel::SendFrame); } } void WebRtcVideoMediaChannel::MaybeDisconnectCapturer(VideoCapturer* capturer) { - if (capturer != NULL && GetSendChannelNum(capturer) == 1) { + if (capturer && GetSendChannelNum(capturer) == 1) { capturer->SignalVideoFrame.disconnect(this); } } diff --git a/talk/media/webrtc/webrtcvideoengine.h b/talk/media/webrtc/webrtcvideoengine.h index f467b9757..90f8d0cc8 100644 --- a/talk/media/webrtc/webrtcvideoengine.h +++ b/talk/media/webrtc/webrtcvideoengine.h @@ -243,11 +243,11 @@ class WebRtcVideoMediaChannel : public rtc::MessageHandler, WebRtcVideoEngine* engine() { return engine_; } VoiceMediaChannel* voice_channel() { return voice_channel_; } - int video_channel() const { return vie_channel_; } bool sending() const { return sending_; } // Public for testing purpose. - uint32 GetDefaultChannelSsrc(); + uint32 GetDefaultSendChannelSsrc(); + int GetDefaultChannelId() const { return default_channel_id_; } // VideoMediaChannel implementation virtual bool SetRecvCodecs(const std::vector &codecs); @@ -318,14 +318,15 @@ class WebRtcVideoMediaChannel : public rtc::MessageHandler, enum MediaDirection { MD_RECV, MD_SEND, MD_SENDRECV }; - // Creates and initializes a ViE channel. When successful |channel_id| will - // contain the new channel's ID. If |receiving| is true |ssrc| is the - // remote ssrc. If |sending| is true the ssrc is local ssrc. If both - // |receiving| and |sending| is true the ssrc must be 0 and the channel will - // be created as a default channel. The ssrc must be different for receive - // channels and it must be different for send channels. If the same SSRC is - // being used for creating channel more than once, this function will fail - // returning false. + // Creates and initializes a ViE channel. When successful + // |channel_id| will contain the new channel's ID. If |receiving| is + // true |ssrc| is the remote ssrc. If |sending| is true the ssrc is + // local ssrc. If both |receiving| and |sending| is true the ssrc + // must be kDefaultChannelSsrcKey and the channel will be created as + // a default channel. The ssrc must be different for receive + // channels and it must be different for send channels. If the same + // SSRC is being used for creating channel more than once, this + // function will fail returning false. bool CreateChannel(uint32 ssrc_key, MediaDirection direction, int* channel_id); bool CreateUnsignalledRecvChannel(uint32 ssrc_key, int* channel_id); @@ -342,8 +343,8 @@ class WebRtcVideoMediaChannel : public rtc::MessageHandler, // Prepares the channel with channel id |info->channel_id()| to receive all // codecs in |receive_codecs_| and start receive packets. bool SetReceiveCodecs(WebRtcVideoChannelRecvInfo* info); - // Returns the channel number that receives the stream with SSRC |ssrc|. - int GetRecvChannelNum(uint32 ssrc); + // Returns the channel ID that receives the stream with SSRC |ssrc|. + int GetRecvChannelId(uint32 ssrc); bool MaybeSetRtxSsrc(const StreamParams& sp, int channel_id); // Given captured video frame size, checks if we need to reset vie send codec. // |reset| is set to whether resetting has happened on vie or not. @@ -365,25 +366,34 @@ class WebRtcVideoMediaChannel : public rtc::MessageHandler, bool SendIntraFrame(int channel_id); bool HasReadySendChannels(); + bool DefaultSendChannelInUse(); - // Send channel key returns the key corresponding to the provided local SSRC - // in |key|. The return value is true upon success. - // If the local ssrc correspond to that of the default channel the key is 0. - // For all other channels the returned key will be the same as the local ssrc. - bool GetSendChannelKey(uint32 local_ssrc, uint32* key); - WebRtcVideoChannelSendInfo* GetSendChannel(uint32 local_ssrc); - // Creates a new unique key that can be used for inserting a new send channel - // into |send_channels_| - bool CreateSendChannelKey(uint32 local_ssrc, uint32* key); + // Returns the ssrc key corresponding to the provided local SSRC in + // |ssrc_key|. The return value is true upon success. If the local + // ssrc correspond to that of the default channel the key is + // kDefaultChannelSsrcKey. + // For all other channels the returned ssrc key will be the same as + // the local ssrc. + bool GetSendChannelSsrcKey(uint32 local_ssrc, uint32* ssrc_key); + WebRtcVideoChannelSendInfo* GetDefaultSendChannel(); + WebRtcVideoChannelSendInfo* GetSendChannelBySsrcKey(uint32 ssrc_key); + WebRtcVideoChannelSendInfo* GetSendChannelBySsrc(uint32 local_ssrc); + // Creates a new unique ssrc key that can be used for inserting a + // new send channel into |send_channels_| + bool CreateSendChannelSsrcKey(uint32 local_ssrc, uint32* ssrc_key); // Get the number of the send channels |capturer| registered with. int GetSendChannelNum(VideoCapturer* capturer); - bool IsDefaultChannel(int channel_id) const { - return channel_id == vie_channel_; + bool IsDefaultChannelId(int channel_id) const { + return channel_id == default_channel_id_; } + bool GetDefaultRenderer(VideoRenderer** renderer); bool DeleteSendChannel(uint32 ssrc_key); + WebRtcVideoChannelRecvInfo* GetDefaultRecvChannel(); + WebRtcVideoChannelRecvInfo* GetRecvChannelBySsrc(uint32 ssrc); + bool InConferenceMode() const { return options_.conference_mode.GetWithDefaultIfUnset(false); } @@ -420,17 +430,17 @@ class WebRtcVideoMediaChannel : public rtc::MessageHandler, // Global state. WebRtcVideoEngine* engine_; VoiceMediaChannel* voice_channel_; - int vie_channel_; + int default_channel_id_; bool nack_enabled_; // Receiver Estimated Max Bitrate bool remb_enabled_; VideoOptions options_; // Global recv side state. - // Note the default channel (vie_channel_), i.e. the send channel + // Note the default channel (default_channel_id_), i.e. the send channel // corresponding to all the receive channels (this must be done for REMB to // work properly), resides in both recv_channels_ and send_channels_ with the - // ssrc key 0. + // ssrc key kDefaultChannelSsrcKey. RecvChannelMap recv_channels_; // Contains all receive channels. // A map from the SSRCs on which RTX packets are received to the media SSRCs // the RTX packets are associated with. RTX packets will be delivered to the