Home | History | Annotate | Download | only in media 
      1 /*
      2  * libjingle
      3  * Copyright 2004 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_SESSION_MEDIA_CHANNEL_H_
     29 #define TALK_SESSION_MEDIA_CHANNEL_H_
     30 
     31 #include <string>
     32 #include <vector>
     33 
     34 #include "talk/base/asyncudpsocket.h"
     35 #include "talk/base/criticalsection.h"
     36 #include "talk/base/network.h"
     37 #include "talk/base/sigslot.h"
     38 #include "talk/base/window.h"
     39 #include "talk/media/base/mediachannel.h"
     40 #include "talk/media/base/mediaengine.h"
     41 #include "talk/media/base/screencastid.h"
     42 #include "talk/media/base/streamparams.h"
     43 #include "talk/media/base/videocapturer.h"
     44 #include "talk/p2p/base/session.h"
     45 #include "talk/p2p/client/socketmonitor.h"
     46 #include "talk/session/media/audiomonitor.h"
     47 #include "talk/session/media/bundlefilter.h"
     48 #include "talk/session/media/mediamonitor.h"
     49 #include "talk/session/media/mediasession.h"
     50 #include "talk/session/media/rtcpmuxfilter.h"
     51 #include "talk/session/media/srtpfilter.h"
     52 
     53 namespace cricket {
     54 
     55 struct CryptoParams;
     56 class MediaContentDescription;
     57 struct TypingMonitorOptions;
     58 class TypingMonitor;
     59 struct ViewRequest;
     60 
     61 enum SinkType {
     62   SINK_PRE_CRYPTO,  // Sink packets before encryption or after decryption.
     63   SINK_POST_CRYPTO  // Sink packets after encryption or before decryption.
     64 };
     65 
     66 // BaseChannel contains logic common to voice and video, including
     67 // enable/mute, marshaling calls to a worker thread, and
     68 // connection and media monitors.
     69 //
     70 // WARNING! SUBCLASSES MUST CALL Deinit() IN THEIR DESTRUCTORS!
     71 // This is required to avoid a data race between the destructor modifying the
     72 // vtable, and the media channel's thread using BaseChannel as the
     73 // NetworkInterface.
     74 
     75 class BaseChannel
     76     : public talk_base::MessageHandler, public sigslot::has_slots<>,
     77       public MediaChannel::NetworkInterface {
     78  public:
     79   BaseChannel(talk_base::Thread* thread, MediaEngineInterface* media_engine,
     80               MediaChannel* channel, BaseSession* session,
     81               const std::string& content_name, bool rtcp);
     82   virtual ~BaseChannel();
     83   bool Init(TransportChannel* transport_channel,
     84             TransportChannel* rtcp_transport_channel);
     85   // Deinit may be called multiple times and is simply ignored if it's alreay
     86   // done.
     87   void Deinit();
     88 
     89   talk_base::Thread* worker_thread() const { return worker_thread_; }
     90   BaseSession* session() const { return session_; }
     91   const std::string& content_name() { return content_name_; }
     92   TransportChannel* transport_channel() const {
     93     return transport_channel_;
     94   }
     95   TransportChannel* rtcp_transport_channel() const {
     96     return rtcp_transport_channel_;
     97   }
     98   bool enabled() const { return enabled_; }
     99 
    100   // This function returns true if we are using SRTP.
    101   bool secure() const { return srtp_filter_.IsActive(); }
    102   // The following function returns true if we are using
    103   // DTLS-based keying. If you turned off SRTP later, however
    104   // you could have secure() == false and dtls_secure() == true.
    105   bool secure_dtls() const { return dtls_keyed_; }
    106   // This function returns true if we require secure channel for call setup.
    107   bool secure_required() const { return secure_required_; }
    108 
    109   bool writable() const { return writable_; }
    110   bool IsStreamMuted(uint32 ssrc);
    111 
    112   // Channel control
    113   bool SetLocalContent(const MediaContentDescription* content,
    114                        ContentAction action,
    115                        std::string* error_desc);
    116   bool SetRemoteContent(const MediaContentDescription* content,
    117                         ContentAction action,
    118                         std::string* error_desc);
    119 
    120   bool Enable(bool enable);
    121   // Mute sending media on the stream with SSRC |ssrc|
    122   // If there is only one sending stream SSRC 0 can be used.
    123   bool MuteStream(uint32 ssrc, bool mute);
    124 
    125   // Multiplexing
    126   bool AddRecvStream(const StreamParams& sp);
    127   bool RemoveRecvStream(uint32 ssrc);
    128   bool AddSendStream(const StreamParams& sp);
    129   bool RemoveSendStream(uint32 ssrc);
    130 
    131   // Monitoring
    132   void StartConnectionMonitor(int cms);
    133   void StopConnectionMonitor();
    134 
    135   void set_srtp_signal_silent_time(uint32 silent_time) {
    136     srtp_filter_.set_signal_silent_time(silent_time);
    137   }
    138 
    139   void set_content_name(const std::string& content_name) {
    140     ASSERT(signaling_thread()->IsCurrent());
    141     ASSERT(!writable_);
    142     if (session_->state() != BaseSession::STATE_INIT) {
    143       LOG(LS_ERROR) << "Content name for a channel can be changed only "
    144                     << "when BaseSession is in STATE_INIT state.";
    145       return;
    146     }
    147     content_name_ = content_name;
    148   }
    149 
    150   template <class T>
    151   void RegisterSendSink(T* sink,
    152                         void (T::*OnPacket)(const void*, size_t, bool),
    153                         SinkType type) {
    154     talk_base::CritScope cs(&signal_send_packet_cs_);
    155     if (SINK_POST_CRYPTO == type) {
    156       SignalSendPacketPostCrypto.disconnect(sink);
    157       SignalSendPacketPostCrypto.connect(sink, OnPacket);
    158     } else {
    159       SignalSendPacketPreCrypto.disconnect(sink);
    160       SignalSendPacketPreCrypto.connect(sink, OnPacket);
    161     }
    162   }
    163 
    164   void UnregisterSendSink(sigslot::has_slots<>* sink,
    165                           SinkType type) {
    166     talk_base::CritScope cs(&signal_send_packet_cs_);
    167     if (SINK_POST_CRYPTO == type) {
    168       SignalSendPacketPostCrypto.disconnect(sink);
    169     } else {
    170       SignalSendPacketPreCrypto.disconnect(sink);
    171     }
    172   }
    173 
    174   bool HasSendSinks(SinkType type) {
    175     talk_base::CritScope cs(&signal_send_packet_cs_);
    176     if (SINK_POST_CRYPTO == type) {
    177       return !SignalSendPacketPostCrypto.is_empty();
    178     } else {
    179       return !SignalSendPacketPreCrypto.is_empty();
    180     }
    181   }
    182 
    183   template <class T>
    184   void RegisterRecvSink(T* sink,
    185                         void (T::*OnPacket)(const void*, size_t, bool),
    186                         SinkType type) {
    187     talk_base::CritScope cs(&signal_recv_packet_cs_);
    188     if (SINK_POST_CRYPTO == type) {
    189       SignalRecvPacketPostCrypto.disconnect(sink);
    190       SignalRecvPacketPostCrypto.connect(sink, OnPacket);
    191     } else {
    192       SignalRecvPacketPreCrypto.disconnect(sink);
    193       SignalRecvPacketPreCrypto.connect(sink, OnPacket);
    194     }
    195   }
    196 
    197   void UnregisterRecvSink(sigslot::has_slots<>* sink,
    198                           SinkType type) {
    199     talk_base::CritScope cs(&signal_recv_packet_cs_);
    200     if (SINK_POST_CRYPTO == type) {
    201       SignalRecvPacketPostCrypto.disconnect(sink);
    202     } else {
    203       SignalRecvPacketPreCrypto.disconnect(sink);
    204     }
    205   }
    206 
    207   bool HasRecvSinks(SinkType type) {
    208     talk_base::CritScope cs(&signal_recv_packet_cs_);
    209     if (SINK_POST_CRYPTO == type) {
    210       return !SignalRecvPacketPostCrypto.is_empty();
    211     } else {
    212       return !SignalRecvPacketPreCrypto.is_empty();
    213     }
    214   }
    215 
    216   BundleFilter* bundle_filter() { return &bundle_filter_; }
    217 
    218   const std::vector<StreamParams>& local_streams() const {
    219     return local_streams_;
    220   }
    221   const std::vector<StreamParams>& remote_streams() const {
    222     return remote_streams_;
    223   }
    224 
    225   // Used for latency measurements.
    226   sigslot::signal1<BaseChannel*> SignalFirstPacketReceived;
    227 
    228   // Used to alert UI when the muted status changes, perhaps autonomously.
    229   sigslot::repeater2<BaseChannel*, bool> SignalAutoMuted;
    230 
    231   // Made public for easier testing.
    232   void SetReadyToSend(TransportChannel* channel, bool ready);
    233 
    234  protected:
    235   MediaEngineInterface* media_engine() const { return media_engine_; }
    236   virtual MediaChannel* media_channel() const { return media_channel_; }
    237   void set_rtcp_transport_channel(TransportChannel* transport);
    238   bool was_ever_writable() const { return was_ever_writable_; }
    239   void set_local_content_direction(MediaContentDirection direction) {
    240     local_content_direction_ = direction;
    241   }
    242   void set_remote_content_direction(MediaContentDirection direction) {
    243     remote_content_direction_ = direction;
    244   }
    245   bool IsReadyToReceive() const;
    246   bool IsReadyToSend() const;
    247   talk_base::Thread* signaling_thread() { return session_->signaling_thread(); }
    248   SrtpFilter* srtp_filter() { return &srtp_filter_; }
    249   bool rtcp() const { return rtcp_; }
    250 
    251   void FlushRtcpMessages();
    252 
    253   // NetworkInterface implementation, called by MediaEngine
    254   virtual bool SendPacket(talk_base::Buffer* packet,
    255                           talk_base::DiffServCodePoint dscp);
    256   virtual bool SendRtcp(talk_base::Buffer* packet,
    257                         talk_base::DiffServCodePoint dscp);
    258   virtual int SetOption(SocketType type, talk_base::Socket::Option o, int val);
    259 
    260   // From TransportChannel
    261   void OnWritableState(TransportChannel* channel);
    262   virtual void OnChannelRead(TransportChannel* channel,
    263                              const char* data,
    264                              size_t len,
    265                              const talk_base::PacketTime& packet_time,
    266                              int flags);
    267   void OnReadyToSend(TransportChannel* channel);
    268 
    269   bool PacketIsRtcp(const TransportChannel* channel, const char* data,
    270                     size_t len);
    271   bool SendPacket(bool rtcp, talk_base::Buffer* packet,
    272                   talk_base::DiffServCodePoint dscp);
    273   virtual bool WantsPacket(bool rtcp, talk_base::Buffer* packet);
    274   void HandlePacket(bool rtcp, talk_base::Buffer* packet,
    275                     const talk_base::PacketTime& packet_time);
    276 
    277   // Apply the new local/remote session description.
    278   void OnNewLocalDescription(BaseSession* session, ContentAction action);
    279   void OnNewRemoteDescription(BaseSession* session, ContentAction action);
    280 
    281   void EnableMedia_w();
    282   void DisableMedia_w();
    283   virtual bool MuteStream_w(uint32 ssrc, bool mute);
    284   bool IsStreamMuted_w(uint32 ssrc);
    285   void ChannelWritable_w();
    286   void ChannelNotWritable_w();
    287   bool AddRecvStream_w(const StreamParams& sp);
    288   bool RemoveRecvStream_w(uint32 ssrc);
    289   bool AddSendStream_w(const StreamParams& sp);
    290   bool RemoveSendStream_w(uint32 ssrc);
    291   virtual bool ShouldSetupDtlsSrtp() const;
    292   // Do the DTLS key expansion and impose it on the SRTP/SRTCP filters.
    293   // |rtcp_channel| indicates whether to set up the RTP or RTCP filter.
    294   bool SetupDtlsSrtp(bool rtcp_channel);
    295   // Set the DTLS-SRTP cipher policy on this channel as appropriate.
    296   bool SetDtlsSrtpCiphers(TransportChannel *tc, bool rtcp);
    297 
    298   virtual void ChangeState() = 0;
    299 
    300   // Gets the content info appropriate to the channel (audio or video).
    301   virtual const ContentInfo* GetFirstContent(
    302       const SessionDescription* sdesc) = 0;
    303   bool UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
    304                             ContentAction action,
    305                             std::string* error_desc);
    306   bool UpdateRemoteStreams_w(const std::vector<StreamParams>& streams,
    307                              ContentAction action,
    308                              std::string* error_desc);
    309   bool SetBaseLocalContent_w(const MediaContentDescription* content,
    310                              ContentAction action,
    311                              std::string* error_desc);
    312   virtual bool SetLocalContent_w(const MediaContentDescription* content,
    313                                  ContentAction action,
    314                                  std::string* error_desc) = 0;
    315   bool SetBaseRemoteContent_w(const MediaContentDescription* content,
    316                               ContentAction action,
    317                               std::string* error_desc);
    318   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
    319                                   ContentAction action,
    320                                   std::string* error_desc) = 0;
    321 
    322   // Helper method to get RTP Absoulute SendTime extension header id if
    323   // present in remote supported extensions list.
    324   void MaybeCacheRtpAbsSendTimeHeaderExtension(
    325     const std::vector<RtpHeaderExtension>& extensions);
    326 
    327   bool CheckSrtpConfig(const std::vector<CryptoParams>& cryptos,
    328                        bool* dtls,
    329                        std::string* error_desc);
    330   bool SetSrtp_w(const std::vector<CryptoParams>& params,
    331                  ContentAction action,
    332                  ContentSource src,
    333                  std::string* error_desc);
    334   bool SetRtcpMux_w(bool enable,
    335                     ContentAction action,
    336                     ContentSource src,
    337                     std::string* error_desc);
    338 
    339   // From MessageHandler
    340   virtual void OnMessage(talk_base::Message* pmsg);
    341 
    342   // Handled in derived classes
    343   // Get the SRTP ciphers to use for RTP media
    344   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const = 0;
    345   virtual void OnConnectionMonitorUpdate(SocketMonitor* monitor,
    346       const std::vector<ConnectionInfo>& infos) = 0;
    347 
    348   // Helper function for invoking bool-returning methods on the worker thread.
    349   template <class FunctorT>
    350   bool InvokeOnWorker(const FunctorT& functor) {
    351     return worker_thread_->Invoke<bool>(functor);
    352   }
    353 
    354  private:
    355   sigslot::signal3<const void*, size_t, bool> SignalSendPacketPreCrypto;
    356   sigslot::signal3<const void*, size_t, bool> SignalSendPacketPostCrypto;
    357   sigslot::signal3<const void*, size_t, bool> SignalRecvPacketPreCrypto;
    358   sigslot::signal3<const void*, size_t, bool> SignalRecvPacketPostCrypto;
    359   talk_base::CriticalSection signal_send_packet_cs_;
    360   talk_base::CriticalSection signal_recv_packet_cs_;
    361 
    362   talk_base::Thread* worker_thread_;
    363   MediaEngineInterface* media_engine_;
    364   BaseSession* session_;
    365   MediaChannel* media_channel_;
    366   std::vector<StreamParams> local_streams_;
    367   std::vector<StreamParams> remote_streams_;
    368 
    369   std::string content_name_;
    370   bool rtcp_;
    371   TransportChannel* transport_channel_;
    372   TransportChannel* rtcp_transport_channel_;
    373   SrtpFilter srtp_filter_;
    374   RtcpMuxFilter rtcp_mux_filter_;
    375   BundleFilter bundle_filter_;
    376   talk_base::scoped_ptr<SocketMonitor> socket_monitor_;
    377   bool enabled_;
    378   bool writable_;
    379   bool rtp_ready_to_send_;
    380   bool rtcp_ready_to_send_;
    381   bool was_ever_writable_;
    382   MediaContentDirection local_content_direction_;
    383   MediaContentDirection remote_content_direction_;
    384   std::set<uint32> muted_streams_;
    385   bool has_received_packet_;
    386   bool dtls_keyed_;
    387   bool secure_required_;
    388   int rtp_abs_sendtime_extn_id_;
    389 };
    390 
    391 // VoiceChannel is a specialization that adds support for early media, DTMF,
    392 // and input/output level monitoring.
    393 class VoiceChannel : public BaseChannel {
    394  public:
    395   VoiceChannel(talk_base::Thread* thread, MediaEngineInterface* media_engine,
    396                VoiceMediaChannel* channel, BaseSession* session,
    397                const std::string& content_name, bool rtcp);
    398   ~VoiceChannel();
    399   bool Init();
    400   bool SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer);
    401   bool SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer);
    402 
    403   // downcasts a MediaChannel
    404   virtual VoiceMediaChannel* media_channel() const {
    405     return static_cast<VoiceMediaChannel*>(BaseChannel::media_channel());
    406   }
    407 
    408   bool SetRingbackTone(const void* buf, int len);
    409   void SetEarlyMedia(bool enable);
    410   // This signal is emitted when we have gone a period of time without
    411   // receiving early media. When received, a UI should start playing its
    412   // own ringing sound
    413   sigslot::signal1<VoiceChannel*> SignalEarlyMediaTimeout;
    414 
    415   bool PlayRingbackTone(uint32 ssrc, bool play, bool loop);
    416   // TODO(ronghuawu): Replace PressDTMF with InsertDtmf.
    417   bool PressDTMF(int digit, bool playout);
    418   // Returns if the telephone-event has been negotiated.
    419   bool CanInsertDtmf();
    420   // Send and/or play a DTMF |event| according to the |flags|.
    421   // The DTMF out-of-band signal will be used on sending.
    422   // The |ssrc| should be either 0 or a valid send stream ssrc.
    423   // The valid value for the |event| are 0 which corresponding to DTMF
    424   // event 0-9, *, #, A-D.
    425   bool InsertDtmf(uint32 ssrc, int event_code, int duration, int flags);
    426   bool SetOutputScaling(uint32 ssrc, double left, double right);
    427   // Get statistics about the current media session.
    428   bool GetStats(VoiceMediaInfo* stats);
    429 
    430   // Monitoring functions
    431   sigslot::signal2<VoiceChannel*, const std::vector<ConnectionInfo>&>
    432       SignalConnectionMonitor;
    433 
    434   void StartMediaMonitor(int cms);
    435   void StopMediaMonitor();
    436   sigslot::signal2<VoiceChannel*, const VoiceMediaInfo&> SignalMediaMonitor;
    437 
    438   void StartAudioMonitor(int cms);
    439   void StopAudioMonitor();
    440   bool IsAudioMonitorRunning() const;
    441   sigslot::signal2<VoiceChannel*, const AudioInfo&> SignalAudioMonitor;
    442 
    443   void StartTypingMonitor(const TypingMonitorOptions& settings);
    444   void StopTypingMonitor();
    445   bool IsTypingMonitorRunning() const;
    446 
    447   // Overrides BaseChannel::MuteStream_w.
    448   virtual bool MuteStream_w(uint32 ssrc, bool mute);
    449 
    450   int GetInputLevel_w();
    451   int GetOutputLevel_w();
    452   void GetActiveStreams_w(AudioInfo::StreamList* actives);
    453 
    454   // Signal errors from VoiceMediaChannel.  Arguments are:
    455   //     ssrc(uint32), and error(VoiceMediaChannel::Error).
    456   sigslot::signal3<VoiceChannel*, uint32, VoiceMediaChannel::Error>
    457       SignalMediaError;
    458 
    459   // Configuration and setting.
    460   bool SetChannelOptions(const AudioOptions& options);
    461 
    462  private:
    463   // overrides from BaseChannel
    464   virtual void OnChannelRead(TransportChannel* channel,
    465                              const char* data, size_t len,
    466                              const talk_base::PacketTime& packet_time,
    467                              int flags);
    468   virtual void ChangeState();
    469   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
    470   virtual bool SetLocalContent_w(const MediaContentDescription* content,
    471                                  ContentAction action,
    472                                  std::string* error_desc);
    473   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
    474                                   ContentAction action,
    475                                   std::string* error_desc);
    476   bool SetRingbackTone_w(const void* buf, int len);
    477   bool PlayRingbackTone_w(uint32 ssrc, bool play, bool loop);
    478   void HandleEarlyMediaTimeout();
    479   bool InsertDtmf_w(uint32 ssrc, int event, int duration, int flags);
    480   bool SetOutputScaling_w(uint32 ssrc, double left, double right);
    481   bool GetStats_w(VoiceMediaInfo* stats);
    482 
    483   virtual void OnMessage(talk_base::Message* pmsg);
    484   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
    485   virtual void OnConnectionMonitorUpdate(
    486       SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos);
    487   virtual void OnMediaMonitorUpdate(
    488       VoiceMediaChannel* media_channel, const VoiceMediaInfo& info);
    489   void OnAudioMonitorUpdate(AudioMonitor* monitor, const AudioInfo& info);
    490   void OnVoiceChannelError(uint32 ssrc, VoiceMediaChannel::Error error);
    491   void SendLastMediaError();
    492   void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
    493 
    494   static const int kEarlyMediaTimeout = 1000;
    495   bool received_media_;
    496   talk_base::scoped_ptr<VoiceMediaMonitor> media_monitor_;
    497   talk_base::scoped_ptr<AudioMonitor> audio_monitor_;
    498   talk_base::scoped_ptr<TypingMonitor> typing_monitor_;
    499 };
    500 
    501 // VideoChannel is a specialization for video.
    502 class VideoChannel : public BaseChannel {
    503  public:
    504   // Make screen capturer virtual so that it can be overriden in testing.
    505   // E.g. used to test that window events are triggered correctly.
    506   class ScreenCapturerFactory {
    507    public:
    508     virtual VideoCapturer* CreateScreenCapturer(const ScreencastId& window) = 0;
    509     virtual ~ScreenCapturerFactory() {}
    510   };
    511 
    512   VideoChannel(talk_base::Thread* thread, MediaEngineInterface* media_engine,
    513                VideoMediaChannel* channel, BaseSession* session,
    514                const std::string& content_name, bool rtcp,
    515                VoiceChannel* voice_channel);
    516   ~VideoChannel();
    517   bool Init();
    518 
    519   bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
    520   bool ApplyViewRequest(const ViewRequest& request);
    521 
    522   // TODO(pthatcher): Refactor to use a "capture id" instead of an
    523   // ssrc here as the "key".
    524   VideoCapturer* AddScreencast(uint32 ssrc, const ScreencastId& id);
    525   bool SetCapturer(uint32 ssrc, VideoCapturer* capturer);
    526   bool RemoveScreencast(uint32 ssrc);
    527   // True if we've added a screencast.  Doesn't matter if the capturer
    528   // has been started or not.
    529   bool IsScreencasting();
    530   int GetScreencastFps(uint32 ssrc);
    531   int GetScreencastMaxPixels(uint32 ssrc);
    532   // Get statistics about the current media session.
    533   bool GetStats(const StatsOptions& options, VideoMediaInfo* stats);
    534 
    535   sigslot::signal2<VideoChannel*, const std::vector<ConnectionInfo>&>
    536       SignalConnectionMonitor;
    537 
    538   void StartMediaMonitor(int cms);
    539   void StopMediaMonitor();
    540   sigslot::signal2<VideoChannel*, const VideoMediaInfo&> SignalMediaMonitor;
    541   sigslot::signal2<uint32, talk_base::WindowEvent> SignalScreencastWindowEvent;
    542 
    543   bool SendIntraFrame();
    544   bool RequestIntraFrame();
    545   sigslot::signal3<VideoChannel*, uint32, VideoMediaChannel::Error>
    546       SignalMediaError;
    547 
    548   void SetScreenCaptureFactory(
    549       ScreenCapturerFactory* screencapture_factory);
    550 
    551   // Configuration and setting.
    552   bool SetChannelOptions(const VideoOptions& options);
    553 
    554  protected:
    555   // downcasts a MediaChannel
    556   virtual VideoMediaChannel* media_channel() const {
    557     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
    558   }
    559 
    560  private:
    561   typedef std::map<uint32, VideoCapturer*> ScreencastMap;
    562   struct ScreencastDetailsData;
    563 
    564   // overrides from BaseChannel
    565   virtual void ChangeState();
    566   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
    567   virtual bool SetLocalContent_w(const MediaContentDescription* content,
    568                                  ContentAction action,
    569                                  std::string* error_desc);
    570   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
    571                                   ContentAction action,
    572                                   std::string* error_desc);
    573   bool ApplyViewRequest_w(const ViewRequest& request);
    574 
    575   VideoCapturer* AddScreencast_w(uint32 ssrc, const ScreencastId& id);
    576   bool RemoveScreencast_w(uint32 ssrc);
    577   void OnScreencastWindowEvent_s(uint32 ssrc, talk_base::WindowEvent we);
    578   bool IsScreencasting_w() const;
    579   void GetScreencastDetails_w(ScreencastDetailsData* d) const;
    580   void SetScreenCaptureFactory_w(
    581       ScreenCapturerFactory* screencapture_factory);
    582   bool GetStats_w(VideoMediaInfo* stats);
    583 
    584   virtual void OnMessage(talk_base::Message* pmsg);
    585   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
    586   virtual void OnConnectionMonitorUpdate(
    587       SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos);
    588   virtual void OnMediaMonitorUpdate(
    589       VideoMediaChannel* media_channel, const VideoMediaInfo& info);
    590   virtual void OnScreencastWindowEvent(uint32 ssrc,
    591                                        talk_base::WindowEvent event);
    592   virtual void OnStateChange(VideoCapturer* capturer, CaptureState ev);
    593   bool GetLocalSsrc(const VideoCapturer* capturer, uint32* ssrc);
    594 
    595   void OnVideoChannelError(uint32 ssrc, VideoMediaChannel::Error error);
    596   void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
    597 
    598   VoiceChannel* voice_channel_;
    599   VideoRenderer* renderer_;
    600   talk_base::scoped_ptr<ScreenCapturerFactory> screencapture_factory_;
    601   ScreencastMap screencast_capturers_;
    602   talk_base::scoped_ptr<VideoMediaMonitor> media_monitor_;
    603 
    604   talk_base::WindowEvent previous_we_;
    605 };
    606 
    607 // DataChannel is a specialization for data.
    608 class DataChannel : public BaseChannel {
    609  public:
    610   DataChannel(talk_base::Thread* thread,
    611               DataMediaChannel* media_channel,
    612               BaseSession* session,
    613               const std::string& content_name,
    614               bool rtcp);
    615   ~DataChannel();
    616   bool Init();
    617 
    618   virtual bool SendData(const SendDataParams& params,
    619                         const talk_base::Buffer& payload,
    620                         SendDataResult* result);
    621 
    622   void StartMediaMonitor(int cms);
    623   void StopMediaMonitor();
    624 
    625   // Should be called on the signaling thread only.
    626   bool ready_to_send_data() const {
    627     return ready_to_send_data_;
    628   }
    629 
    630   sigslot::signal2<DataChannel*, const DataMediaInfo&> SignalMediaMonitor;
    631   sigslot::signal2<DataChannel*, const std::vector<ConnectionInfo>&>
    632       SignalConnectionMonitor;
    633   sigslot::signal3<DataChannel*, uint32, DataMediaChannel::Error>
    634       SignalMediaError;
    635   sigslot::signal3<DataChannel*,
    636                    const ReceiveDataParams&,
    637                    const talk_base::Buffer&>
    638       SignalDataReceived;
    639   // Signal for notifying when the channel becomes ready to send data.
    640   // That occurs when the channel is enabled, the transport is writable,
    641   // both local and remote descriptions are set, and the channel is unblocked.
    642   sigslot::signal1<bool> SignalReadyToSendData;
    643   // Signal for notifying that the remote side has closed the DataChannel.
    644   sigslot::signal1<uint32> SignalStreamClosedRemotely;
    645 
    646  protected:
    647   // downcasts a MediaChannel.
    648   virtual DataMediaChannel* media_channel() const {
    649     return static_cast<DataMediaChannel*>(BaseChannel::media_channel());
    650   }
    651 
    652  private:
    653   struct SendDataMessageData : public talk_base::MessageData {
    654     SendDataMessageData(const SendDataParams& params,
    655                         const talk_base::Buffer* payload,
    656                         SendDataResult* result)
    657         : params(params),
    658           payload(payload),
    659           result(result),
    660           succeeded(false) {
    661     }
    662 
    663     const SendDataParams& params;
    664     const talk_base::Buffer* payload;
    665     SendDataResult* result;
    666     bool succeeded;
    667   };
    668 
    669   struct DataReceivedMessageData : public talk_base::MessageData {
    670     // We copy the data because the data will become invalid after we
    671     // handle DataMediaChannel::SignalDataReceived but before we fire
    672     // SignalDataReceived.
    673     DataReceivedMessageData(
    674         const ReceiveDataParams& params, const char* data, size_t len)
    675         : params(params),
    676           payload(data, len) {
    677     }
    678     const ReceiveDataParams params;
    679     const talk_base::Buffer payload;
    680   };
    681 
    682   typedef talk_base::TypedMessageData<bool> DataChannelReadyToSendMessageData;
    683 
    684   // overrides from BaseChannel
    685   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
    686   // If data_channel_type_ is DCT_NONE, set it.  Otherwise, check that
    687   // it's the same as what was set previously.  Returns false if it's
    688   // set to one type one type and changed to another type later.
    689   bool SetDataChannelType(DataChannelType new_data_channel_type,
    690                           std::string* error_desc);
    691   // Same as SetDataChannelType, but extracts the type from the
    692   // DataContentDescription.
    693   bool SetDataChannelTypeFromContent(const DataContentDescription* content,
    694                                      std::string* error_desc);
    695   virtual bool SetLocalContent_w(const MediaContentDescription* content,
    696                                  ContentAction action,
    697                                  std::string* error_desc);
    698   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
    699                                   ContentAction action,
    700                                   std::string* error_desc);
    701   virtual void ChangeState();
    702   virtual bool WantsPacket(bool rtcp, talk_base::Buffer* packet);
    703 
    704   virtual void OnMessage(talk_base::Message* pmsg);
    705   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
    706   virtual void OnConnectionMonitorUpdate(
    707       SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos);
    708   virtual void OnMediaMonitorUpdate(
    709       DataMediaChannel* media_channel, const DataMediaInfo& info);
    710   virtual bool ShouldSetupDtlsSrtp() const;
    711   void OnDataReceived(
    712       const ReceiveDataParams& params, const char* data, size_t len);
    713   void OnDataChannelError(uint32 ssrc, DataMediaChannel::Error error);
    714   void OnDataChannelReadyToSend(bool writable);
    715   void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
    716   void OnStreamClosedRemotely(uint32 sid);
    717 
    718   talk_base::scoped_ptr<DataMediaMonitor> media_monitor_;
    719   // TODO(pthatcher): Make a separate SctpDataChannel and
    720   // RtpDataChannel instead of using this.
    721   DataChannelType data_channel_type_;
    722   bool ready_to_send_data_;
    723 };
    724 
    725 }  // namespace cricket
    726 
    727 #endif  // TALK_SESSION_MEDIA_CHANNEL_H_
    728