From a601f5c86310c078c21161947f526f2d1e65c9cc Mon Sep 17 00:00:00 2001 From: deadbeef Date: Mon, 6 Jun 2016 14:27:39 -0700 Subject: [PATCH] Separating internal and external methods of RtpSender/RtpReceiver. This moves the implementation specific methods to separate classes (RtpSenderInternal/RtpReceiverInternal) so that the interface classes represent the interface that external applications can rely on. The reason this wasn't done earlier was that PeerConnection needed to store proxy pointers, but also needed to access implementation- specific methods on the underlying objects. This is now possible by using "RtpSenderProxyWithInternal", which is a proxy that implements RtpSenderInterface but also provides direct access to an RtpSenderInternal. Review-Url: https://codereview.webrtc.org/2023373002 Cr-Commit-Position: refs/heads/master@{#13056} --- webrtc/api/peerconnection.cc | 137 ++++++++++-------- webrtc/api/peerconnection.h | 19 ++- .../api/peerconnectioninterface_unittest.cc | 10 +- webrtc/api/proxy.h | 123 +++++++++------- webrtc/api/proxy_unittest.cc | 1 + webrtc/api/rtpreceiver.cc | 36 ++--- webrtc/api/rtpreceiver.h | 20 ++- webrtc/api/rtpreceiverinterface.h | 3 - webrtc/api/rtpsender.cc | 36 ++--- webrtc/api/rtpsender.h | 56 +++++-- webrtc/api/rtpsenderinterface.h | 21 +-- 11 files changed, 268 insertions(+), 194 deletions(-) diff --git a/webrtc/api/peerconnection.cc b/webrtc/api/peerconnection.cc index 5f8acca566..6b5cc69b95 100644 --- a/webrtc/api/peerconnection.cc +++ b/webrtc/api/peerconnection.cc @@ -45,7 +45,10 @@ using webrtc::DataChannel; using webrtc::MediaConstraintsInterface; using webrtc::MediaStreamInterface; using webrtc::PeerConnectionInterface; +using webrtc::RtpSenderInternal; using webrtc::RtpSenderInterface; +using webrtc::RtpSenderProxy; +using webrtc::RtpSenderProxyWithInternal; using webrtc::StreamCollection; static const char kDefaultStreamLabel[] = "default"; @@ -349,13 +352,14 @@ bool IsValidOfferToReceiveMedia(int value) { // Add the stream and RTP data channel info to |session_options|. void AddSendStreams( cricket::MediaSessionOptions* session_options, - const std::vector>& senders, + const std::vector>>& senders, const std::map>& rtp_data_channels) { session_options->streams.clear(); for (const auto& sender : senders) { session_options->AddSendStream(sender->media_type(), sender->id(), - sender->stream_id()); + sender->internal()->stream_id()); } // Check for data channels. @@ -547,10 +551,10 @@ PeerConnection::~PeerConnection() { // Need to detach RTP senders/receivers from WebRtcSession, // since it's about to be destroyed. for (const auto& sender : senders_) { - sender->Stop(); + sender->internal()->Stop(); } for (const auto& receiver : receivers_) { - receiver->Stop(); + receiver->internal()->Stop(); } // Destroy stats_ because it depends on session_. stats_.reset(nullptr); @@ -702,32 +706,32 @@ rtc::scoped_refptr PeerConnection::AddTrack( } // TODO(deadbeef): Support adding a track to multiple streams. - rtc::scoped_refptr new_sender; + rtc::scoped_refptr> new_sender; if (track->kind() == MediaStreamTrackInterface::kAudioKind) { - new_sender = RtpSenderProxy::Create( + new_sender = RtpSenderProxyWithInternal::Create( signaling_thread(), new AudioRtpSender(static_cast(track), session_.get(), stats_.get())); if (!streams.empty()) { - new_sender->set_stream_id(streams[0]->label()); + new_sender->internal()->set_stream_id(streams[0]->label()); } const TrackInfo* track_info = FindTrackInfo( - local_audio_tracks_, new_sender->stream_id(), track->id()); + local_audio_tracks_, new_sender->internal()->stream_id(), track->id()); if (track_info) { - new_sender->SetSsrc(track_info->ssrc); + new_sender->internal()->SetSsrc(track_info->ssrc); } } else if (track->kind() == MediaStreamTrackInterface::kVideoKind) { - new_sender = RtpSenderProxy::Create( + new_sender = RtpSenderProxyWithInternal::Create( signaling_thread(), new VideoRtpSender(static_cast(track), session_.get())); if (!streams.empty()) { - new_sender->set_stream_id(streams[0]->label()); + new_sender->internal()->set_stream_id(streams[0]->label()); } const TrackInfo* track_info = FindTrackInfo( - local_video_tracks_, new_sender->stream_id(), track->id()); + local_video_tracks_, new_sender->internal()->stream_id(), track->id()); if (track_info) { - new_sender->SetSsrc(track_info->ssrc); + new_sender->internal()->SetSsrc(track_info->ssrc); } } else { LOG(LS_ERROR) << "CreateSender called with invalid kind: " << track->kind(); @@ -750,7 +754,7 @@ bool PeerConnection::RemoveTrack(RtpSenderInterface* sender) { LOG(LS_ERROR) << "Couldn't find sender " << sender->id() << " to remove."; return false; } - (*it)->Stop(); + (*it)->internal()->Stop(); senders_.erase(it); observer_->OnRenegotiationNeeded(); @@ -782,19 +786,19 @@ rtc::scoped_refptr PeerConnection::CreateSender( const std::string& kind, const std::string& stream_id) { TRACE_EVENT0("webrtc", "PeerConnection::CreateSender"); - rtc::scoped_refptr new_sender; + rtc::scoped_refptr> new_sender; if (kind == MediaStreamTrackInterface::kAudioKind) { - new_sender = RtpSenderProxy::Create( + new_sender = RtpSenderProxyWithInternal::Create( signaling_thread(), new AudioRtpSender(session_.get(), stats_.get())); } else if (kind == MediaStreamTrackInterface::kVideoKind) { - new_sender = RtpSenderProxy::Create(signaling_thread(), - new VideoRtpSender(session_.get())); + new_sender = RtpSenderProxyWithInternal::Create( + signaling_thread(), new VideoRtpSender(session_.get())); } else { LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind; return new_sender; } if (!stream_id.empty()) { - new_sender->set_stream_id(stream_id); + new_sender->internal()->set_stream_id(stream_id); } senders_.push_back(new_sender); return new_sender; @@ -802,12 +806,20 @@ rtc::scoped_refptr PeerConnection::CreateSender( std::vector> PeerConnection::GetSenders() const { - return senders_; + std::vector> ret; + for (const auto& sender : senders_) { + ret.push_back(sender.get()); + } + return ret; } std::vector> PeerConnection::GetReceivers() const { - return receivers_; + std::vector> ret; + for (const auto& receiver : receivers_) { + ret.push_back(receiver.get()); + } + return ret; } bool PeerConnection::GetStats(StatsObserver* observer, @@ -1303,18 +1315,20 @@ void PeerConnection::OnMessage(rtc::Message* msg) { void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream, const std::string& track_id, uint32_t ssrc) { - receivers_.push_back(RtpReceiverProxy::Create( - signaling_thread(), - new AudioRtpReceiver(stream, track_id, ssrc, session_.get()))); + receivers_.push_back( + RtpReceiverProxyWithInternal::Create( + signaling_thread(), + new AudioRtpReceiver(stream, track_id, ssrc, session_.get()))); } void PeerConnection::CreateVideoReceiver(MediaStreamInterface* stream, const std::string& track_id, uint32_t ssrc) { - receivers_.push_back(RtpReceiverProxy::Create( - signaling_thread(), - new VideoRtpReceiver(stream, track_id, factory_->worker_thread(), ssrc, - session_.get()))); + receivers_.push_back( + RtpReceiverProxyWithInternal::Create( + signaling_thread(), + new VideoRtpReceiver(stream, track_id, factory_->worker_thread(), + ssrc, session_.get()))); } // TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote @@ -1325,7 +1339,7 @@ void PeerConnection::DestroyReceiver(const std::string& track_id) { LOG(LS_WARNING) << "RtpReceiver for track with id " << track_id << " doesn't exist."; } else { - (*it)->Stop(); + (*it)->internal()->Stop(); receivers_.erase(it); } } @@ -1338,7 +1352,7 @@ void PeerConnection::StopReceivers(cricket::MediaType media_type) { LOG(LS_WARNING) << "RtpReceiver for track with id " << track_info.track_id << " doesn't exist."; } else { - (*it)->Stop(); + (*it)->internal()->Stop(); } } } @@ -1401,14 +1415,15 @@ void PeerConnection::OnAudioTrackAdded(AudioTrackInterface* track, if (sender != senders_.end()) { // We already have a sender for this track, so just change the stream_id // so that it's correct in the next call to CreateOffer. - (*sender)->set_stream_id(stream->label()); + (*sender)->internal()->set_stream_id(stream->label()); return; } // Normal case; we've never seen this track before. - rtc::scoped_refptr new_sender = RtpSenderProxy::Create( - signaling_thread(), - new AudioRtpSender(track, stream->label(), session_.get(), stats_.get())); + rtc::scoped_refptr> new_sender = + RtpSenderProxyWithInternal::Create( + signaling_thread(), new AudioRtpSender(track, stream->label(), + session_.get(), stats_.get())); senders_.push_back(new_sender); // If the sender has already been configured in SDP, we call SetSsrc, // which will connect the sender to the underlying transport. This can @@ -1419,7 +1434,7 @@ void PeerConnection::OnAudioTrackAdded(AudioTrackInterface* track, const TrackInfo* track_info = FindTrackInfo(local_audio_tracks_, stream->label(), track->id()); if (track_info) { - new_sender->SetSsrc(track_info->ssrc); + new_sender->internal()->SetSsrc(track_info->ssrc); } } @@ -1433,7 +1448,7 @@ void PeerConnection::OnAudioTrackRemoved(AudioTrackInterface* track, << " doesn't exist."; return; } - (*sender)->Stop(); + (*sender)->internal()->Stop(); senders_.erase(sender); } @@ -1443,19 +1458,20 @@ void PeerConnection::OnVideoTrackAdded(VideoTrackInterface* track, if (sender != senders_.end()) { // We already have a sender for this track, so just change the stream_id // so that it's correct in the next call to CreateOffer. - (*sender)->set_stream_id(stream->label()); + (*sender)->internal()->set_stream_id(stream->label()); return; } // Normal case; we've never seen this track before. - rtc::scoped_refptr new_sender = RtpSenderProxy::Create( - signaling_thread(), - new VideoRtpSender(track, stream->label(), session_.get())); + rtc::scoped_refptr> new_sender = + RtpSenderProxyWithInternal::Create( + signaling_thread(), + new VideoRtpSender(track, stream->label(), session_.get())); senders_.push_back(new_sender); const TrackInfo* track_info = FindTrackInfo(local_video_tracks_, stream->label(), track->id()); if (track_info) { - new_sender->SetSsrc(track_info->ssrc); + new_sender->internal()->SetSsrc(track_info->ssrc); } } @@ -1467,7 +1483,7 @@ void PeerConnection::OnVideoTrackRemoved(VideoTrackInterface* track, << " doesn't exist."; return; } - (*sender)->Stop(); + (*sender)->internal()->Stop(); senders_.erase(sender); } @@ -1769,7 +1785,7 @@ void PeerConnection::OnLocalTrackSeen(const std::string& stream_label, const std::string& track_id, uint32_t ssrc, cricket::MediaType media_type) { - RtpSenderInterface* sender = FindSenderById(track_id); + RtpSenderInternal* sender = FindSenderById(track_id); if (!sender) { LOG(LS_WARNING) << "An unknown RtpSender with id " << track_id << " has been configured in the local description."; @@ -1790,7 +1806,7 @@ void PeerConnection::OnLocalTrackRemoved(const std::string& stream_label, const std::string& track_id, uint32_t ssrc, cricket::MediaType media_type) { - RtpSenderInterface* sender = FindSenderById(track_id); + RtpSenderInternal* sender = FindSenderById(track_id); if (!sender) { // This is the normal case. I.e., RemoveStream has been called and the // SessionDescriptions has been renegotiated. @@ -1894,7 +1910,8 @@ void PeerConnection::CreateRemoteRtpDataChannel(const std::string& label, return; } channel->SetReceiveSsrc(remote_ssrc); - auto proxy_channel = DataChannelProxy::Create(signaling_thread(), channel); + rtc::scoped_refptr proxy_channel = + DataChannelProxy::Create(signaling_thread(), channel); // Call both the raw pointer and scoped_refptr versions of the method // for compatibility. observer_->OnDataChannel(proxy_channel.get()); @@ -2028,36 +2045,42 @@ void PeerConnection::OnDataChannelOpenMessage( return; } - auto proxy_channel = DataChannelProxy::Create(signaling_thread(), channel); + rtc::scoped_refptr proxy_channel = + DataChannelProxy::Create(signaling_thread(), channel); // Call both the raw pointer and scoped_refptr versions of the method // for compatibility. observer_->OnDataChannel(proxy_channel.get()); observer_->OnDataChannel(std::move(proxy_channel)); } -RtpSenderInterface* PeerConnection::FindSenderById(const std::string& id) { - auto it = - std::find_if(senders_.begin(), senders_.end(), - [id](const rtc::scoped_refptr& sender) { - return sender->id() == id; - }); - return it != senders_.end() ? it->get() : nullptr; +RtpSenderInternal* PeerConnection::FindSenderById(const std::string& id) { + auto it = std::find_if( + senders_.begin(), senders_.end(), + [id](const rtc::scoped_refptr< + RtpSenderProxyWithInternal>& sender) { + return sender->id() == id; + }); + return it != senders_.end() ? (*it)->internal() : nullptr; } -std::vector>::iterator +std::vector< + rtc::scoped_refptr>>::iterator PeerConnection::FindSenderForTrack(MediaStreamTrackInterface* track) { return std::find_if( senders_.begin(), senders_.end(), - [track](const rtc::scoped_refptr& sender) { + [track](const rtc::scoped_refptr< + RtpSenderProxyWithInternal>& sender) { return sender->track() == track; }); } -std::vector>::iterator +std::vector>>::iterator PeerConnection::FindReceiverForTrack(const std::string& track_id) { return std::find_if( receivers_.begin(), receivers_.end(), - [track_id](const rtc::scoped_refptr& receiver) { + [track_id](const rtc::scoped_refptr< + RtpReceiverProxyWithInternal>& receiver) { return receiver->id() == track_id; }); } diff --git a/webrtc/api/peerconnection.h b/webrtc/api/peerconnection.h index a683e8d685..aba595c4bb 100644 --- a/webrtc/api/peerconnection.h +++ b/webrtc/api/peerconnection.h @@ -18,8 +18,8 @@ #include "webrtc/api/peerconnectionfactory.h" #include "webrtc/api/peerconnectioninterface.h" -#include "webrtc/api/rtpreceiverinterface.h" -#include "webrtc/api/rtpsenderinterface.h" +#include "webrtc/api/rtpreceiver.h" +#include "webrtc/api/rtpsender.h" #include "webrtc/api/statscollector.h" #include "webrtc/api/streamcollection.h" #include "webrtc/api/webrtcsession.h" @@ -334,11 +334,13 @@ class PeerConnection : public PeerConnectionInterface, void OnDataChannelOpenMessage(const std::string& label, const InternalDataChannelInit& config); - RtpSenderInterface* FindSenderById(const std::string& id); + RtpSenderInternal* FindSenderById(const std::string& id); - std::vector>::iterator + std::vector>>::iterator FindSenderForTrack(MediaStreamTrackInterface* track); - std::vector>::iterator + std::vector>>::iterator FindReceiverForTrack(const std::string& track_id); TrackInfos* GetRemoteTracks(cricket::MediaType media_type); @@ -400,8 +402,11 @@ class PeerConnection : public PeerConnectionInterface, bool remote_peer_supports_msid_ = false; - std::vector> senders_; - std::vector> receivers_; + std::vector>> + senders_; + std::vector< + rtc::scoped_refptr>> + receivers_; std::unique_ptr session_; std::unique_ptr stats_; diff --git a/webrtc/api/peerconnectioninterface_unittest.cc b/webrtc/api/peerconnectioninterface_unittest.cc index 7addbec477..71233e0608 100644 --- a/webrtc/api/peerconnectioninterface_unittest.cc +++ b/webrtc/api/peerconnectioninterface_unittest.cc @@ -333,7 +333,7 @@ bool ContainsSender( const std::string& id, const std::string& stream_id) { for (const auto& sender : senders) { - if (sender->id() == id && sender->stream_id() == stream_id) { + if (sender->id() == id && sender->stream_ids()[0] == stream_id) { return true; } } @@ -1166,10 +1166,12 @@ TEST_F(PeerConnectionInterfaceTest, AddTrackRemoveTrack) { pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer()))); auto audio_sender = pc_->AddTrack(audio_track, stream_list); auto video_sender = pc_->AddTrack(video_track, stream_list); - EXPECT_EQ(kStreamLabel1, audio_sender->stream_id()); + EXPECT_EQ(1UL, audio_sender->stream_ids().size()); + EXPECT_EQ(kStreamLabel1, audio_sender->stream_ids()[0]); EXPECT_EQ("audio_track", audio_sender->id()); EXPECT_EQ(audio_track, audio_sender->track()); - EXPECT_EQ(kStreamLabel1, video_sender->stream_id()); + EXPECT_EQ(1UL, video_sender->stream_ids().size()); + EXPECT_EQ(kStreamLabel1, video_sender->stream_ids()[0]); EXPECT_EQ("video_track", video_sender->id()); EXPECT_EQ(video_track, video_sender->track()); @@ -1242,7 +1244,7 @@ TEST_F(PeerConnectionInterfaceTest, AddTrackWithoutStream) { EXPECT_EQ(video_track, video_sender->track()); // If the ID is truly a random GUID, it should be infinitely unlikely they // will be the same. - EXPECT_NE(video_sender->stream_id(), audio_sender->stream_id()); + EXPECT_NE(video_sender->stream_ids(), audio_sender->stream_ids()); } TEST_F(PeerConnectionInterfaceTest, CreateOfferReceiveAnswer) { diff --git a/webrtc/api/proxy.h b/webrtc/api/proxy.h index 2df85c4bf4..20a5b494a5 100644 --- a/webrtc/api/proxy.h +++ b/webrtc/api/proxy.h @@ -306,43 +306,62 @@ class MethodCall5 : public rtc::Message, T5 a5_; }; -#define BEGIN_SIGNALING_PROXY_MAP(c) \ - class c##Proxy : public c##Interface { \ - protected: \ - typedef c##Interface C; \ - c##Proxy(rtc::Thread* signaling_thread, C* c) \ - : signaling_thread_(signaling_thread), c_(c) {} \ - ~c##Proxy() { \ - MethodCall0 call( \ - this, &c##Proxy::Release_s); \ - call.Marshal(signaling_thread_); \ - } \ - \ - public: \ - static rtc::scoped_refptr Create(rtc::Thread* signaling_thread, C* c) { \ - return new rtc::RefCountedObject( \ - signaling_thread, c); \ - } +#define BEGIN_SIGNALING_PROXY_MAP(c) \ + template \ + class c##ProxyWithInternal; \ + typedef c##ProxyWithInternal c##Proxy; \ + template \ + class c##ProxyWithInternal : public c##Interface { \ + protected: \ + typedef c##Interface C; \ + c##ProxyWithInternal(rtc::Thread* signaling_thread, INTERNAL_CLASS* c) \ + : signaling_thread_(signaling_thread), c_(c) {} \ + ~c##ProxyWithInternal() { \ + MethodCall0 call( \ + this, &c##ProxyWithInternal::Release_s); \ + call.Marshal(signaling_thread_); \ + } \ + \ + public: \ + static rtc::scoped_refptr Create( \ + rtc::Thread* signaling_thread, \ + INTERNAL_CLASS* c) { \ + return new rtc::RefCountedObject(signaling_thread, \ + c); \ + } \ + const INTERNAL_CLASS* internal() const { return c_.get(); } \ + INTERNAL_CLASS* internal() { return c_.get(); } -#define BEGIN_PROXY_MAP(c) \ - class c##Proxy : public c##Interface { \ - protected: \ - typedef c##Interface C; \ - c##Proxy(rtc::Thread* signaling_thread, rtc::Thread* worker_thread, C* c) \ - : signaling_thread_(signaling_thread), \ - worker_thread_(worker_thread), \ - c_(c) {} \ - ~c##Proxy() { \ - MethodCall0 call(this, &c##Proxy::Release_s); \ - call.Marshal(signaling_thread_); \ - } \ - \ - public: \ - static rtc::scoped_refptr Create( \ - rtc::Thread* signaling_thread, rtc::Thread* worker_thread, C* c) { \ - return new rtc::RefCountedObject( \ - signaling_thread, worker_thread, c); \ - } +#define BEGIN_PROXY_MAP(c) \ + template \ + class c##ProxyWithInternal; \ + typedef c##ProxyWithInternal c##Proxy; \ + template \ + class c##ProxyWithInternal : public c##Interface { \ + protected: \ + typedef c##Interface C; \ + c##ProxyWithInternal(rtc::Thread* signaling_thread, \ + rtc::Thread* worker_thread, \ + INTERNAL_CLASS* c) \ + : signaling_thread_(signaling_thread), \ + worker_thread_(worker_thread), \ + c_(c) {} \ + ~c##ProxyWithInternal() { \ + MethodCall0 call( \ + this, &c##ProxyWithInternal::Release_s); \ + call.Marshal(signaling_thread_); \ + } \ + \ + public: \ + static rtc::scoped_refptr Create( \ + rtc::Thread* signaling_thread, \ + rtc::Thread* worker_thread, \ + INTERNAL_CLASS* c) { \ + return new rtc::RefCountedObject( \ + signaling_thread, worker_thread, c); \ + } \ + const INTERNAL_CLASS* internal() const { return c_.get(); } \ + INTERNAL_CLASS* internal() { return c_.get(); } #define PROXY_METHOD0(r, method) \ r method() override { \ @@ -407,24 +426,22 @@ class MethodCall5 : public rtc::Message, return call.Marshal(worker_thread_); \ } -#define END_SIGNALING_PROXY() \ - private:\ - void Release_s() {\ - c_ = NULL;\ - }\ - mutable rtc::Thread* signaling_thread_;\ - rtc::scoped_refptr c_;\ - }; +#define END_SIGNALING_PROXY() \ + private: \ + void Release_s() { c_ = NULL; } \ + mutable rtc::Thread* signaling_thread_; \ + rtc::scoped_refptr c_; \ + } \ + ; -#define END_PROXY() \ - private: \ - void Release_s() { \ - c_ = NULL; \ - } \ - mutable rtc::Thread* signaling_thread_; \ - mutable rtc::Thread* worker_thread_; \ - rtc::scoped_refptr c_; \ - }; \ +#define END_PROXY() \ + private: \ + void Release_s() { c_ = NULL; } \ + mutable rtc::Thread* signaling_thread_; \ + mutable rtc::Thread* worker_thread_; \ + rtc::scoped_refptr c_; \ + } \ + ; } // namespace webrtc diff --git a/webrtc/api/proxy_unittest.cc b/webrtc/api/proxy_unittest.cc index 931ba28eba..005d0622ce 100644 --- a/webrtc/api/proxy_unittest.cc +++ b/webrtc/api/proxy_unittest.cc @@ -73,6 +73,7 @@ END_PROXY() // Preprocessor hack to get a proxy class a name different than FakeProxy. #define FakeProxy FakeSignalingProxy +#define FakeProxyWithInternal FakeSignalingProxyWithInternal BEGIN_SIGNALING_PROXY_MAP(Fake) PROXY_METHOD0(void, VoidMethod0) PROXY_METHOD0(std::string, Method0) diff --git a/webrtc/api/rtpreceiver.cc b/webrtc/api/rtpreceiver.cc index 1b52ce27de..9df336e1f0 100644 --- a/webrtc/api/rtpreceiver.cc +++ b/webrtc/api/rtpreceiver.cc @@ -58,15 +58,6 @@ void AudioRtpReceiver::OnSetVolume(double volume) { provider_->SetAudioPlayoutVolume(ssrc_, volume); } -void AudioRtpReceiver::Stop() { - // TODO(deadbeef): Need to do more here to fully stop receiving packets. - if (!provider_) { - return; - } - provider_->SetAudioPlayout(ssrc_, false); - provider_ = nullptr; -} - RtpParameters AudioRtpReceiver::GetParameters() const { return provider_->GetAudioRtpReceiveParameters(ssrc_); } @@ -76,6 +67,15 @@ bool AudioRtpReceiver::SetParameters(const RtpParameters& parameters) { return provider_->SetAudioRtpReceiveParameters(ssrc_, parameters); } +void AudioRtpReceiver::Stop() { + // TODO(deadbeef): Need to do more here to fully stop receiving packets. + if (!provider_) { + return; + } + provider_->SetAudioPlayout(ssrc_, false); + provider_ = nullptr; +} + void AudioRtpReceiver::Reconfigure() { if (!provider_) { return; @@ -112,6 +112,15 @@ VideoRtpReceiver::~VideoRtpReceiver() { Stop(); } +RtpParameters VideoRtpReceiver::GetParameters() const { + return provider_->GetVideoRtpReceiveParameters(ssrc_); +} + +bool VideoRtpReceiver::SetParameters(const RtpParameters& parameters) { + TRACE_EVENT0("webrtc", "VideoRtpReceiver::SetParameters"); + return provider_->SetVideoRtpReceiveParameters(ssrc_, parameters); +} + void VideoRtpReceiver::Stop() { // TODO(deadbeef): Need to do more here to fully stop receiving packets. if (!provider_) { @@ -123,13 +132,4 @@ void VideoRtpReceiver::Stop() { provider_ = nullptr; } -RtpParameters VideoRtpReceiver::GetParameters() const { - return provider_->GetVideoRtpReceiveParameters(ssrc_); -} - -bool VideoRtpReceiver::SetParameters(const RtpParameters& parameters) { - TRACE_EVENT0("webrtc", "VideoRtpReceiver::SetParameters"); - return provider_->SetVideoRtpReceiveParameters(ssrc_, parameters); -} - } // namespace webrtc diff --git a/webrtc/api/rtpreceiver.h b/webrtc/api/rtpreceiver.h index 2e7339d4da..001264d7a7 100644 --- a/webrtc/api/rtpreceiver.h +++ b/webrtc/api/rtpreceiver.h @@ -26,9 +26,15 @@ namespace webrtc { +// Internal class used by PeerConnection. +class RtpReceiverInternal : public RtpReceiverInterface { + public: + virtual void Stop() = 0; +}; + class AudioRtpReceiver : public ObserverInterface, public AudioSourceInterface::AudioObserver, - public rtc::RefCountedObject { + public rtc::RefCountedObject { public: AudioRtpReceiver(MediaStreamInterface* stream, const std::string& track_id, @@ -54,11 +60,12 @@ class AudioRtpReceiver : public ObserverInterface, std::string id() const override { return id_; } - void Stop() override; - RtpParameters GetParameters() const override; bool SetParameters(const RtpParameters& parameters) override; + // RtpReceiverInternal implementation. + void Stop() override; + private: void Reconfigure(); @@ -69,7 +76,7 @@ class AudioRtpReceiver : public ObserverInterface, bool cached_track_enabled_; }; -class VideoRtpReceiver : public rtc::RefCountedObject { +class VideoRtpReceiver : public rtc::RefCountedObject { public: VideoRtpReceiver(MediaStreamInterface* stream, const std::string& track_id, @@ -90,11 +97,12 @@ class VideoRtpReceiver : public rtc::RefCountedObject { std::string id() const override { return id_; } - void Stop() override; - RtpParameters GetParameters() const override; bool SetParameters(const RtpParameters& parameters) override; + // RtpReceiverInternal implementation. + void Stop() override; + private: std::string id_; uint32_t ssrc_; diff --git a/webrtc/api/rtpreceiverinterface.h b/webrtc/api/rtpreceiverinterface.h index ef4f0e113f..49888381e1 100644 --- a/webrtc/api/rtpreceiverinterface.h +++ b/webrtc/api/rtpreceiverinterface.h @@ -31,8 +31,6 @@ class RtpReceiverInterface : public rtc::RefCountInterface { // to uniquely identify a receiver until we implement Unified Plan SDP. virtual std::string id() const = 0; - virtual void Stop() = 0; - // The WebRTC specification only defines RTCRtpParameters in terms of senders, // but this API also applies them to receivers, similar to ORTC: // http://ortc.org/wp-content/uploads/2016/03/ortc.html#rtcrtpparameters*. @@ -47,7 +45,6 @@ class RtpReceiverInterface : public rtc::RefCountInterface { BEGIN_SIGNALING_PROXY_MAP(RtpReceiver) PROXY_CONSTMETHOD0(rtc::scoped_refptr, track) PROXY_CONSTMETHOD0(std::string, id) -PROXY_METHOD0(void, Stop) PROXY_CONSTMETHOD0(RtpParameters, GetParameters); PROXY_METHOD1(bool, SetParameters, const RtpParameters&) END_SIGNALING_PROXY() diff --git a/webrtc/api/rtpsender.cc b/webrtc/api/rtpsender.cc index 33d7ee37a9..f66e66b435 100644 --- a/webrtc/api/rtpsender.cc +++ b/webrtc/api/rtpsender.cc @@ -145,6 +145,15 @@ bool AudioRtpSender::SetTrack(MediaStreamTrackInterface* track) { return true; } +RtpParameters AudioRtpSender::GetParameters() const { + return provider_->GetAudioRtpSendParameters(ssrc_); +} + +bool AudioRtpSender::SetParameters(const RtpParameters& parameters) { + TRACE_EVENT0("webrtc", "AudioRtpSender::SetParameters"); + return provider_->SetAudioRtpSendParameters(ssrc_, parameters); +} + void AudioRtpSender::SetSsrc(uint32_t ssrc) { TRACE_EVENT0("webrtc", "AudioRtpSender::SetSsrc"); if (stopped_ || ssrc == ssrc_) { @@ -207,15 +216,6 @@ void AudioRtpSender::SetAudioSend() { provider_->SetAudioSend(ssrc_, track_->enabled(), options, source); } -RtpParameters AudioRtpSender::GetParameters() const { - return provider_->GetAudioRtpSendParameters(ssrc_); -} - -bool AudioRtpSender::SetParameters(const RtpParameters& parameters) { - TRACE_EVENT0("webrtc", "AudioRtpSender::SetParameters"); - return provider_->SetAudioRtpSendParameters(ssrc_, parameters); -} - VideoRtpSender::VideoRtpSender(VideoTrackInterface* track, const std::string& stream_id, VideoProviderInterface* provider) @@ -297,6 +297,15 @@ bool VideoRtpSender::SetTrack(MediaStreamTrackInterface* track) { return true; } +RtpParameters VideoRtpSender::GetParameters() const { + return provider_->GetVideoRtpSendParameters(ssrc_); +} + +bool VideoRtpSender::SetParameters(const RtpParameters& parameters) { + TRACE_EVENT0("webrtc", "VideoRtpSender::SetParameters"); + return provider_->SetVideoRtpSendParameters(ssrc_, parameters); +} + void VideoRtpSender::SetSsrc(uint32_t ssrc) { TRACE_EVENT0("webrtc", "VideoRtpSender::SetSsrc"); if (stopped_ || ssrc == ssrc_) { @@ -344,13 +353,4 @@ void VideoRtpSender::ClearVideoSend() { provider_->SetVideoSend(ssrc_, false, nullptr, nullptr); } -RtpParameters VideoRtpSender::GetParameters() const { - return provider_->GetVideoRtpSendParameters(ssrc_); -} - -bool VideoRtpSender::SetParameters(const RtpParameters& parameters) { - TRACE_EVENT0("webrtc", "VideoRtpSender::SetParameters"); - return provider_->SetVideoRtpSendParameters(ssrc_, parameters); -} - } // namespace webrtc diff --git a/webrtc/api/rtpsender.h b/webrtc/api/rtpsender.h index c8a46a80e4..a0bcc9407a 100644 --- a/webrtc/api/rtpsender.h +++ b/webrtc/api/rtpsender.h @@ -27,6 +27,22 @@ namespace webrtc { +// Internal interface used by PeerConnection. +class RtpSenderInternal : public RtpSenderInterface { + public: + // Used to set the SSRC of the sender, once a local description has been set. + // If |ssrc| is 0, this indiates that the sender should disconnect from the + // underlying transport (this occurs if the sender isn't seen in a local + // description). + virtual void SetSsrc(uint32_t ssrc) = 0; + + // TODO(deadbeef): Support one sender having multiple stream ids. + virtual void set_stream_id(const std::string& stream_id) = 0; + virtual std::string stream_id() const = 0; + + virtual void Stop() = 0; +}; + // LocalAudioSinkAdapter receives data callback as a sink to the local // AudioTrack, and passes the data to the sink of AudioSource. class LocalAudioSinkAdapter : public AudioTrackSinkInterface, @@ -52,7 +68,7 @@ class LocalAudioSinkAdapter : public AudioTrackSinkInterface, }; class AudioRtpSender : public ObserverInterface, - public rtc::RefCountedObject { + public rtc::RefCountedObject { public: // StatsCollector provided so that Add/RemoveLocalAudioTrack can be called // at the appropriate times. @@ -77,11 +93,9 @@ class AudioRtpSender : public ObserverInterface, // RtpSenderInterface implementation bool SetTrack(MediaStreamTrackInterface* track) override; rtc::scoped_refptr track() const override { - return track_.get(); + return track_; } - void SetSsrc(uint32_t ssrc) override; - uint32_t ssrc() const override { return ssrc_; } cricket::MediaType media_type() const override { @@ -90,6 +104,17 @@ class AudioRtpSender : public ObserverInterface, std::string id() const override { return id_; } + std::vector stream_ids() const override { + std::vector ret = {stream_id_}; + return ret; + } + + RtpParameters GetParameters() const override; + bool SetParameters(const RtpParameters& parameters) override; + + // RtpSenderInternal implementation. + void SetSsrc(uint32_t ssrc) override; + void set_stream_id(const std::string& stream_id) override { stream_id_ = stream_id; } @@ -97,9 +122,6 @@ class AudioRtpSender : public ObserverInterface, void Stop() override; - RtpParameters GetParameters() const override; - bool SetParameters(const RtpParameters& parameters) override; - private: // TODO(nisse): Since SSRC == 0 is technically valid, figure out // some other way to test if we have a valid SSRC. @@ -123,7 +145,7 @@ class AudioRtpSender : public ObserverInterface, }; class VideoRtpSender : public ObserverInterface, - public rtc::RefCountedObject { + public rtc::RefCountedObject { public: VideoRtpSender(VideoTrackInterface* track, const std::string& stream_id, @@ -143,11 +165,9 @@ class VideoRtpSender : public ObserverInterface, // RtpSenderInterface implementation bool SetTrack(MediaStreamTrackInterface* track) override; rtc::scoped_refptr track() const override { - return track_.get(); + return track_; } - void SetSsrc(uint32_t ssrc) override; - uint32_t ssrc() const override { return ssrc_; } cricket::MediaType media_type() const override { @@ -156,6 +176,17 @@ class VideoRtpSender : public ObserverInterface, std::string id() const override { return id_; } + std::vector stream_ids() const override { + std::vector ret = {stream_id_}; + return ret; + } + + RtpParameters GetParameters() const override; + bool SetParameters(const RtpParameters& parameters) override; + + // RtpSenderInternal implementation. + void SetSsrc(uint32_t ssrc) override; + void set_stream_id(const std::string& stream_id) override { stream_id_ = stream_id; } @@ -163,9 +194,6 @@ class VideoRtpSender : public ObserverInterface, void Stop() override; - RtpParameters GetParameters() const override; - bool SetParameters(const RtpParameters& parameters) override; - private: bool can_send_track() const { return track_ && ssrc_; } // Helper function to construct options for diff --git a/webrtc/api/rtpsenderinterface.h b/webrtc/api/rtpsenderinterface.h index 2291bb4e21..c940dc7c09 100644 --- a/webrtc/api/rtpsenderinterface.h +++ b/webrtc/api/rtpsenderinterface.h @@ -15,6 +15,7 @@ #define WEBRTC_API_RTPSENDERINTERFACE_H_ #include +#include #include "webrtc/api/mediastreaminterface.h" #include "webrtc/api/proxy.h" @@ -32,11 +33,10 @@ class RtpSenderInterface : public rtc::RefCountInterface { virtual bool SetTrack(MediaStreamTrackInterface* track) = 0; virtual rtc::scoped_refptr track() const = 0; - // Used to set the SSRC of the sender, once a local description has been set. - // If |ssrc| is 0, this indiates that the sender should disconnect from the - // underlying transport (this occurs if the sender isn't seen in a local - // description). - virtual void SetSsrc(uint32_t ssrc) = 0; + // Returns primary SSRC used by this sender for sending media. + // Returns 0 if not yet determined. + // TODO(deadbeef): Change to rtc::Optional. + // TODO(deadbeef): Remove? With GetParameters this should be redundant. virtual uint32_t ssrc() const = 0; // Audio or video sender? @@ -46,11 +46,7 @@ class RtpSenderInterface : public rtc::RefCountInterface { // to uniquely identify a receiver until we implement Unified Plan SDP. virtual std::string id() const = 0; - // TODO(deadbeef): Support one sender having multiple stream ids. - virtual void set_stream_id(const std::string& stream_id) = 0; - virtual std::string stream_id() const = 0; - - virtual void Stop() = 0; + virtual std::vector stream_ids() const = 0; virtual RtpParameters GetParameters() const = 0; virtual bool SetParameters(const RtpParameters& parameters) = 0; @@ -63,13 +59,10 @@ class RtpSenderInterface : public rtc::RefCountInterface { BEGIN_SIGNALING_PROXY_MAP(RtpSender) PROXY_METHOD1(bool, SetTrack, MediaStreamTrackInterface*) PROXY_CONSTMETHOD0(rtc::scoped_refptr, track) -PROXY_METHOD1(void, SetSsrc, uint32_t) PROXY_CONSTMETHOD0(uint32_t, ssrc) PROXY_CONSTMETHOD0(cricket::MediaType, media_type) PROXY_CONSTMETHOD0(std::string, id) -PROXY_METHOD1(void, set_stream_id, const std::string&) -PROXY_CONSTMETHOD0(std::string, stream_id) -PROXY_METHOD0(void, Stop) +PROXY_CONSTMETHOD0(std::vector, stream_ids) PROXY_CONSTMETHOD0(RtpParameters, GetParameters); PROXY_METHOD1(bool, SetParameters, const RtpParameters&) END_SIGNALING_PROXY()