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/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
 644  protected:
 645   // downcasts a MediaChannel.
 646   virtual DataMediaChannel* media_channel() const {
 647     return static_cast<DataMediaChannel*>(BaseChannel::media_channel());
 648   }
 649
 650  private:
 651   struct SendDataMessageData : public talk_base::MessageData {
 652     SendDataMessageData(const SendDataParams& params,
 653                         const talk_base::Buffer* payload,
 654                         SendDataResult* result)
 655         : params(params),
 656           payload(payload),
 657           result(result),
 658           succeeded(false) {
 659     }
 660
 661     const SendDataParams& params;
 662     const talk_base::Buffer* payload;
 663     SendDataResult* result;
 664     bool succeeded;
 665   };
 666
 667   struct DataReceivedMessageData : public talk_base::MessageData {
 668     // We copy the data because the data will become invalid after we
 669     // handle DataMediaChannel::SignalDataReceived but before we fire
 670     // SignalDataReceived.
 671     DataReceivedMessageData(
 672         const ReceiveDataParams& params, const char* data, size_t len)
 673         : params(params),
 674           payload(data, len) {
 675     }
 676     const ReceiveDataParams params;
 677     const talk_base::Buffer payload;
 678   };
 679
 680   typedef talk_base::TypedMessageData<bool> DataChannelReadyToSendMessageData;
 681
 682   // overrides from BaseChannel
 683   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
 684   // If data_channel_type_ is DCT_NONE, set it.  Otherwise, check that
 685   // it's the same as what was set previously.  Returns false if it's
 686   // set to one type one type and changed to another type later.
 687   bool SetDataChannelType(DataChannelType new_data_channel_type,
 688                           std::string* error_desc);
 689   // Same as SetDataChannelType, but extracts the type from the
 690   // DataContentDescription.
 691   bool SetDataChannelTypeFromContent(const DataContentDescription* content,
 692                                      std::string* error_desc);
 693   virtual bool SetLocalContent_w(const MediaContentDescription* content,
 694                                  ContentAction action,
 695                                  std::string* error_desc);
 696   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
 697                                   ContentAction action,
 698                                   std::string* error_desc);
 699   virtual void ChangeState();
 700   virtual bool WantsPacket(bool rtcp, talk_base::Buffer* packet);
 701
 702   virtual void OnMessage(talk_base::Message* pmsg);
 703   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
 704   virtual void OnConnectionMonitorUpdate(
 705       SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos);
 706   virtual void OnMediaMonitorUpdate(
 707       DataMediaChannel* media_channel, const DataMediaInfo& info);
 708   virtual bool ShouldSetupDtlsSrtp() const;
 709   void OnDataReceived(
 710       const ReceiveDataParams& params, const char* data, size_t len);
 711   void OnDataChannelError(uint32 ssrc, DataMediaChannel::Error error);
 712   void OnDataChannelReadyToSend(bool writable);
 713   void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
 714
 715   talk_base::scoped_ptr<DataMediaMonitor> media_monitor_;
 716   // TODO(pthatcher): Make a separate SctpDataChannel and
 717   // RtpDataChannel instead of using this.
 718   DataChannelType data_channel_type_;
 719   bool ready_to_send_data_;
 720 };
 721
 722 }  // namespace cricket
 723
 724 #endif  // TALK_SESSION_MEDIA_CHANNEL_H_