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()