Home | History | Annotate | Download | only in webrtc 
      1 /*
      2  * libjingle
      3  * Copyright 2012 Google Inc.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are met:
      7  *
      8  *  1. Redistributions of source code must retain the above copyright notice,
      9  *     this list of conditions and the following disclaimer.
     10  *  2. Redistributions in binary form must reproduce the above copyright notice,
     11  *     this list of conditions and the following disclaimer in the documentation
     12  *     and/or other materials provided with the distribution.
     13  *  3. The name of the author may not be used to endorse or promote products
     14  *     derived from this software without specific prior written permission.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
     17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
     19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26  */
     27 
     28 #ifndef TALK_APP_WEBRTC_PEERCONNECTION_H_
     29 #define TALK_APP_WEBRTC_PEERCONNECTION_H_
     30 
     31 #include <string>
     32 
     33 #include "talk/app/webrtc/dtlsidentitystore.h"
     34 #include "talk/app/webrtc/peerconnectionfactory.h"
     35 #include "talk/app/webrtc/peerconnectioninterface.h"
     36 #include "talk/app/webrtc/rtpreceiverinterface.h"
     37 #include "talk/app/webrtc/rtpsenderinterface.h"
     38 #include "talk/app/webrtc/statscollector.h"
     39 #include "talk/app/webrtc/streamcollection.h"
     40 #include "talk/app/webrtc/webrtcsession.h"
     41 #include "webrtc/base/scoped_ptr.h"
     42 
     43 namespace webrtc {
     44 
     45 class MediaStreamObserver;
     46 class RemoteMediaStreamFactory;
     47 
     48 // Populates |session_options| from |rtc_options|, and returns true if options
     49 // are valid.
     50 bool ConvertRtcOptionsForOffer(
     51     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
     52     cricket::MediaSessionOptions* session_options);
     53 
     54 // Populates |session_options| from |constraints|, and returns true if all
     55 // mandatory constraints are satisfied.
     56 bool ParseConstraintsForAnswer(const MediaConstraintsInterface* constraints,
     57                                cricket::MediaSessionOptions* session_options);
     58 
     59 // Parses the URLs for each server in |servers| to build |stun_servers| and
     60 // |turn_servers|.
     61 bool ParseIceServers(const PeerConnectionInterface::IceServers& servers,
     62                      cricket::ServerAddresses* stun_servers,
     63                      std::vector<cricket::RelayServerConfig>* turn_servers);
     64 
     65 // PeerConnection implements the PeerConnectionInterface interface.
     66 // It uses WebRtcSession to implement the PeerConnection functionality.
     67 class PeerConnection : public PeerConnectionInterface,
     68                        public IceObserver,
     69                        public rtc::MessageHandler,
     70                        public sigslot::has_slots<> {
     71  public:
     72   explicit PeerConnection(PeerConnectionFactory* factory);
     73 
     74   bool Initialize(
     75       const PeerConnectionInterface::RTCConfiguration& configuration,
     76       const MediaConstraintsInterface* constraints,
     77       rtc::scoped_ptr<cricket::PortAllocator> allocator,
     78       rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     79       PeerConnectionObserver* observer);
     80 
     81   rtc::scoped_refptr<StreamCollectionInterface> local_streams() override;
     82   rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override;
     83   bool AddStream(MediaStreamInterface* local_stream) override;
     84   void RemoveStream(MediaStreamInterface* local_stream) override;
     85 
     86   virtual WebRtcSession* session() { return session_.get(); }
     87 
     88   rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
     89       AudioTrackInterface* track) override;
     90 
     91   rtc::scoped_refptr<RtpSenderInterface> CreateSender(
     92       const std::string& kind,
     93       const std::string& stream_id) override;
     94 
     95   std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
     96       const override;
     97   std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
     98       const override;
     99 
    100   rtc::scoped_refptr<DataChannelInterface> CreateDataChannel(
    101       const std::string& label,
    102       const DataChannelInit* config) override;
    103   bool GetStats(StatsObserver* observer,
    104                 webrtc::MediaStreamTrackInterface* track,
    105                 StatsOutputLevel level) override;
    106 
    107   SignalingState signaling_state() override;
    108 
    109   // TODO(bemasc): Remove ice_state() when callers are removed.
    110   IceState ice_state() override;
    111   IceConnectionState ice_connection_state() override;
    112   IceGatheringState ice_gathering_state() override;
    113 
    114   const SessionDescriptionInterface* local_description() const override;
    115   const SessionDescriptionInterface* remote_description() const override;
    116 
    117   // JSEP01
    118   void CreateOffer(CreateSessionDescriptionObserver* observer,
    119                    const MediaConstraintsInterface* constraints) override;
    120   void CreateOffer(CreateSessionDescriptionObserver* observer,
    121                    const RTCOfferAnswerOptions& options) override;
    122   void CreateAnswer(CreateSessionDescriptionObserver* observer,
    123                     const MediaConstraintsInterface* constraints) override;
    124   void SetLocalDescription(SetSessionDescriptionObserver* observer,
    125                            SessionDescriptionInterface* desc) override;
    126   void SetRemoteDescription(SetSessionDescriptionObserver* observer,
    127                             SessionDescriptionInterface* desc) override;
    128   bool SetConfiguration(
    129       const PeerConnectionInterface::RTCConfiguration& config) override;
    130   bool AddIceCandidate(const IceCandidateInterface* candidate) override;
    131 
    132   void RegisterUMAObserver(UMAObserver* observer) override;
    133 
    134   void Close() override;
    135 
    136   // Virtual for unit tests.
    137   virtual const std::vector<rtc::scoped_refptr<DataChannel>>&
    138   sctp_data_channels() const {
    139     return sctp_data_channels_;
    140   };
    141 
    142  protected:
    143   ~PeerConnection() override;
    144 
    145  private:
    146   struct TrackInfo {
    147     TrackInfo() : ssrc(0) {}
    148     TrackInfo(const std::string& stream_label,
    149               const std::string track_id,
    150               uint32_t ssrc)
    151         : stream_label(stream_label), track_id(track_id), ssrc(ssrc) {}
    152     bool operator==(const TrackInfo& other) {
    153       return this->stream_label == other.stream_label &&
    154              this->track_id == other.track_id && this->ssrc == other.ssrc;
    155     }
    156     std::string stream_label;
    157     std::string track_id;
    158     uint32_t ssrc;
    159   };
    160   typedef std::vector<TrackInfo> TrackInfos;
    161 
    162   // Implements MessageHandler.
    163   void OnMessage(rtc::Message* msg) override;
    164 
    165   void CreateAudioReceiver(MediaStreamInterface* stream,
    166                            AudioTrackInterface* audio_track,
    167                            uint32_t ssrc);
    168   void CreateVideoReceiver(MediaStreamInterface* stream,
    169                            VideoTrackInterface* video_track,
    170                            uint32_t ssrc);
    171   void DestroyAudioReceiver(MediaStreamInterface* stream,
    172                             AudioTrackInterface* audio_track);
    173   void DestroyVideoReceiver(MediaStreamInterface* stream,
    174                             VideoTrackInterface* video_track);
    175   void DestroyAudioSender(MediaStreamInterface* stream,
    176                           AudioTrackInterface* audio_track,
    177                           uint32_t ssrc);
    178   void DestroyVideoSender(MediaStreamInterface* stream,
    179                           VideoTrackInterface* video_track);
    180 
    181   // Implements IceObserver
    182   void OnIceConnectionChange(IceConnectionState new_state) override;
    183   void OnIceGatheringChange(IceGatheringState new_state) override;
    184   void OnIceCandidate(const IceCandidateInterface* candidate) override;
    185   void OnIceComplete() override;
    186   void OnIceConnectionReceivingChange(bool receiving) override;
    187 
    188   // Signals from WebRtcSession.
    189   void OnSessionStateChange(WebRtcSession* session, WebRtcSession::State state);
    190   void ChangeSignalingState(SignalingState signaling_state);
    191 
    192   // Signals from MediaStreamObserver.
    193   void OnAudioTrackAdded(AudioTrackInterface* track,
    194                          MediaStreamInterface* stream);
    195   void OnAudioTrackRemoved(AudioTrackInterface* track,
    196                            MediaStreamInterface* stream);
    197   void OnVideoTrackAdded(VideoTrackInterface* track,
    198                          MediaStreamInterface* stream);
    199   void OnVideoTrackRemoved(VideoTrackInterface* track,
    200                            MediaStreamInterface* stream);
    201 
    202   rtc::Thread* signaling_thread() const {
    203     return factory_->signaling_thread();
    204   }
    205 
    206   void PostSetSessionDescriptionFailure(SetSessionDescriptionObserver* observer,
    207                                         const std::string& error);
    208   void PostCreateSessionDescriptionFailure(
    209       CreateSessionDescriptionObserver* observer,
    210       const std::string& error);
    211 
    212   bool IsClosed() const {
    213     return signaling_state_ == PeerConnectionInterface::kClosed;
    214   }
    215 
    216   // Returns a MediaSessionOptions struct with options decided by |options|,
    217   // the local MediaStreams and DataChannels.
    218   virtual bool GetOptionsForOffer(
    219       const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
    220       cricket::MediaSessionOptions* session_options);
    221 
    222   // Returns a MediaSessionOptions struct with options decided by
    223   // |constraints|, the local MediaStreams and DataChannels.
    224   virtual bool GetOptionsForAnswer(
    225       const MediaConstraintsInterface* constraints,
    226       cricket::MediaSessionOptions* session_options);
    227 
    228   // Remove all local and remote tracks of type |media_type|.
    229   // Called when a media type is rejected (m-line set to port 0).
    230   void RemoveTracks(cricket::MediaType media_type);
    231 
    232   // Makes sure a MediaStreamTrack is created for each StreamParam in |streams|,
    233   // and existing MediaStreamTracks are removed if there is no corresponding
    234   // StreamParam. If |default_track_needed| is true, a default MediaStreamTrack
    235   // is created if it doesn't exist; if false, it's removed if it exists.
    236   // |media_type| is the type of the |streams| and can be either audio or video.
    237   // If a new MediaStream is created it is added to |new_streams|.
    238   void UpdateRemoteStreamsList(
    239       const std::vector<cricket::StreamParams>& streams,
    240       bool default_track_needed,
    241       cricket::MediaType media_type,
    242       StreamCollection* new_streams);
    243 
    244   // Triggered when a remote track has been seen for the first time in a remote
    245   // session description. It creates a remote MediaStreamTrackInterface
    246   // implementation and triggers CreateAudioReceiver or CreateVideoReceiver.
    247   void OnRemoteTrackSeen(const std::string& stream_label,
    248                          const std::string& track_id,
    249                          uint32_t ssrc,
    250                          cricket::MediaType media_type);
    251 
    252   // Triggered when a remote track has been removed from a remote session
    253   // description. It removes the remote track with id |track_id| from a remote
    254   // MediaStream and triggers DestroyAudioReceiver or DestroyVideoReceiver.
    255   void OnRemoteTrackRemoved(const std::string& stream_label,
    256                             const std::string& track_id,
    257                             cricket::MediaType media_type);
    258 
    259   // Finds remote MediaStreams without any tracks and removes them from
    260   // |remote_streams_| and notifies the observer that the MediaStreams no longer
    261   // exist.
    262   void UpdateEndedRemoteMediaStreams();
    263 
    264   // Set the MediaStreamTrackInterface::TrackState to |kEnded| on all remote
    265   // tracks of type |media_type|.
    266   void EndRemoteTracks(cricket::MediaType media_type);
    267 
    268   // Loops through the vector of |streams| and finds added and removed
    269   // StreamParams since last time this method was called.
    270   // For each new or removed StreamParam, OnLocalTrackSeen or
    271   // OnLocalTrackRemoved is invoked.
    272   void UpdateLocalTracks(const std::vector<cricket::StreamParams>& streams,
    273                          cricket::MediaType media_type);
    274 
    275   // Triggered when a local track has been seen for the first time in a local
    276   // session description.
    277   // This method triggers CreateAudioSender or CreateVideoSender if the rtp
    278   // streams in the local SessionDescription can be mapped to a MediaStreamTrack
    279   // in a MediaStream in |local_streams_|
    280   void OnLocalTrackSeen(const std::string& stream_label,
    281                         const std::string& track_id,
    282                         uint32_t ssrc,
    283                         cricket::MediaType media_type);
    284 
    285   // Triggered when a local track has been removed from a local session
    286   // description.
    287   // This method triggers DestroyAudioSender or DestroyVideoSender if a stream
    288   // has been removed from the local SessionDescription and the stream can be
    289   // mapped to a MediaStreamTrack in a MediaStream in |local_streams_|.
    290   void OnLocalTrackRemoved(const std::string& stream_label,
    291                            const std::string& track_id,
    292                            uint32_t ssrc,
    293                            cricket::MediaType media_type);
    294 
    295   void UpdateLocalRtpDataChannels(const cricket::StreamParamsVec& streams);
    296   void UpdateRemoteRtpDataChannels(const cricket::StreamParamsVec& streams);
    297   void UpdateClosingRtpDataChannels(
    298       const std::vector<std::string>& active_channels,
    299       bool is_local_update);
    300   void CreateRemoteRtpDataChannel(const std::string& label,
    301                                   uint32_t remote_ssrc);
    302 
    303   // Creates channel and adds it to the collection of DataChannels that will
    304   // be offered in a SessionDescription.
    305   rtc::scoped_refptr<DataChannel> InternalCreateDataChannel(
    306       const std::string& label,
    307       const InternalDataChannelInit* config);
    308 
    309   // Checks if any data channel has been added.
    310   bool HasDataChannels() const;
    311 
    312   void AllocateSctpSids(rtc::SSLRole role);
    313   void OnSctpDataChannelClosed(DataChannel* channel);
    314 
    315   // Notifications from WebRtcSession relating to BaseChannels.
    316   void OnVoiceChannelDestroyed();
    317   void OnVideoChannelDestroyed();
    318   void OnDataChannelCreated();
    319   void OnDataChannelDestroyed();
    320   // Called when the cricket::DataChannel receives a message indicating that a
    321   // webrtc::DataChannel should be opened.
    322   void OnDataChannelOpenMessage(const std::string& label,
    323                                 const InternalDataChannelInit& config);
    324 
    325   RtpSenderInterface* FindSenderById(const std::string& id);
    326 
    327   std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator
    328   FindSenderForTrack(MediaStreamTrackInterface* track);
    329   std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator
    330   FindReceiverForTrack(MediaStreamTrackInterface* track);
    331 
    332   TrackInfos* GetRemoteTracks(cricket::MediaType media_type);
    333   TrackInfos* GetLocalTracks(cricket::MediaType media_type);
    334   const TrackInfo* FindTrackInfo(const TrackInfos& infos,
    335                                  const std::string& stream_label,
    336                                  const std::string track_id) const;
    337 
    338   // Returns the specified SCTP DataChannel in sctp_data_channels_,
    339   // or nullptr if not found.
    340   DataChannel* FindDataChannelBySid(int sid) const;
    341 
    342   // Storing the factory as a scoped reference pointer ensures that the memory
    343   // in the PeerConnectionFactoryImpl remains available as long as the
    344   // PeerConnection is running. It is passed to PeerConnection as a raw pointer.
    345   // However, since the reference counting is done in the
    346   // PeerConnectionFactoryInterface all instances created using the raw pointer
    347   // will refer to the same reference count.
    348   rtc::scoped_refptr<PeerConnectionFactory> factory_;
    349   PeerConnectionObserver* observer_;
    350   UMAObserver* uma_observer_;
    351   SignalingState signaling_state_;
    352   // TODO(bemasc): Remove ice_state_.
    353   IceState ice_state_;
    354   IceConnectionState ice_connection_state_;
    355   IceGatheringState ice_gathering_state_;
    356 
    357   rtc::scoped_ptr<cricket::PortAllocator> port_allocator_;
    358   rtc::scoped_ptr<MediaControllerInterface> media_controller_;
    359 
    360   // Streams added via AddStream.
    361   rtc::scoped_refptr<StreamCollection> local_streams_;
    362   // Streams created as a result of SetRemoteDescription.
    363   rtc::scoped_refptr<StreamCollection> remote_streams_;
    364 
    365   std::vector<rtc::scoped_ptr<MediaStreamObserver>> stream_observers_;
    366 
    367   // These lists store track info seen in local/remote descriptions.
    368   TrackInfos remote_audio_tracks_;
    369   TrackInfos remote_video_tracks_;
    370   TrackInfos local_audio_tracks_;
    371   TrackInfos local_video_tracks_;
    372 
    373   SctpSidAllocator sid_allocator_;
    374   // label -> DataChannel
    375   std::map<std::string, rtc::scoped_refptr<DataChannel>> rtp_data_channels_;
    376   std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_;
    377   std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_to_free_;
    378 
    379   bool remote_peer_supports_msid_ = false;
    380   rtc::scoped_ptr<RemoteMediaStreamFactory> remote_stream_factory_;
    381 
    382   std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_;
    383   std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers_;
    384 
    385   // The session_ scoped_ptr is declared at the bottom of PeerConnection
    386   // because its destruction fires signals (such as VoiceChannelDestroyed)
    387   // which will trigger some final actions in PeerConnection...
    388   rtc::scoped_ptr<WebRtcSession> session_;
    389   // ... But stats_ depends on session_ so it should be destroyed even earlier.
    390   rtc::scoped_ptr<StatsCollector> stats_;
    391 };
    392 
    393 }  // namespace webrtc
    394 
    395 #endif  // TALK_APP_WEBRTC_PEERCONNECTION_H_
    396