src/third_party/libjingle/source/talk/session/media/channel.h

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