Wire up transport sequence number / send time callbacks to webrtc via libjingle.

talk/session/media/channel.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 34 matching lines @@
 #include "talk/session/media/mediamonitor.h"
 #include "talk/session/media/mediasession.h"
 #include "talk/session/media/rtcpmuxfilter.h"
 #include "talk/session/media/srtpfilter.h"
 #include "webrtc/base/asyncudpsocket.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/network.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/window.h"
 
+namespace webrtc {
+class MediaControllerInterface;
+}  // namespace webrtc
+
 namespace cricket {
 
 struct CryptoParams;
 class MediaContentDescription;
 struct ViewRequest;
 
 enum SinkType {
   SINK_PRE_CRYPTO,  // Sink packets before encryption or after decryption.
   SINK_POST_CRYPTO  // Sink packets after encryption or before decryption.
 };
 
 // BaseChannel contains logic common to voice and video, including
 // enable, marshaling calls to a worker thread, and
 // connection and media monitors.
 //
 // WARNING! SUBCLASSES MUST CALL Deinit() IN THEIR DESTRUCTORS!
 // This is required to avoid a data race between the destructor modifying the
 // vtable, and the media channel's thread using BaseChannel as the
 // NetworkInterface.
 
 class BaseChannel
     : public rtc::MessageHandler, public sigslot::has_slots<>,
       public MediaChannel::NetworkInterface,
       public ConnectionStatsGetter {
  public:
   BaseChannel(rtc::Thread* thread,
               MediaChannel* channel,
+              webrtc::MediaControllerInterface* media_controller,
               TransportController* transport_controller,
               const std::string& content_name,
               bool rtcp);
   virtual ~BaseChannel();
   bool Init();
   // Deinit may be called multiple times and is simply ignored if it's alreay
   // done.
   void Deinit();
 
   rtc::Thread* worker_thread() const { return worker_thread_; }
@@ skipping 100 matching lines @@
   }
   bool rtcp_transport_enabled() const { return rtcp_transport_enabled_; }
 
   void ConnectToTransportChannel(TransportChannel* tc);
   void DisconnectFromTransportChannel(TransportChannel* tc);
 
   void FlushRtcpMessages();
 
   // NetworkInterface implementation, called by MediaEngine
   virtual bool SendPacket(rtc::Buffer* packet,
-                          rtc::DiffServCodePoint dscp);
-  virtual bool SendRtcp(rtc::Buffer* packet,
-                        rtc::DiffServCodePoint dscp);
+                          const rtc::PacketOptions& options);
+  virtual bool SendRtcp(rtc::Buffer* packet, const rtc::PacketOptions& options);
 
   // From TransportChannel
   void OnWritableState(TransportChannel* channel);
   virtual void OnChannelRead(TransportChannel* channel,
                              const char* data,
                              size_t len,
                              const rtc::PacketTime& packet_time,
                              int flags);
   void OnReadyToSend(TransportChannel* channel);
 
   bool PacketIsRtcp(const TransportChannel* channel, const char* data,
                     size_t len);
-  bool SendPacket(bool rtcp, rtc::Buffer* packet,
-                  rtc::DiffServCodePoint dscp);
+  bool SendPacket(bool rtcp,
+                  rtc::Buffer* packet,
+                  const rtc::PacketOptions& options);
   virtual bool WantsPacket(bool rtcp, rtc::Buffer* packet);
   void HandlePacket(bool rtcp, rtc::Buffer* packet,
                     const rtc::PacketTime& packet_time);
 
   void EnableMedia_w();
   void DisableMedia_w();
   void UpdateWritableState_w();
   void ChannelWritable_w();
   void ChannelNotWritable_w();
   bool AddRecvStream_w(const StreamParams& sp);
@@ skipping 25 matching lines @@
                                   ContentAction action,
                                   std::string* error_desc) = 0;
   bool SetRtpTransportParameters_w(const MediaContentDescription* content,
                                    ContentAction action,
                                    ContentSource src,
                                    std::string* error_desc);
 
   // Helper method to get RTP Absoulute SendTime extension header id if
   // present in remote supported extensions list.
   void MaybeCacheRtpAbsSendTimeHeaderExtension(
-    const std::vector<RtpHeaderExtension>& extensions);
+      const std::vector<RtpHeaderExtension>& extensions);
 
   bool CheckSrtpConfig(const std::vector<CryptoParams>& cryptos,
                        bool* dtls,
                        std::string* error_desc);
   bool SetSrtp_w(const std::vector<CryptoParams>& params,
                  ContentAction action,
                  ContentSource src,
                  std::string* error_desc);
   void ActivateRtcpMux_w();
   bool SetRtcpMux_w(bool enable,
@@ skipping 14 matching lines @@
   // Helper function for invoking bool-returning methods on the worker thread.
   template <class FunctorT>
   bool InvokeOnWorker(const FunctorT& functor) {
     return worker_thread_->Invoke<bool>(functor);
   }
 
  private:
   rtc::Thread* worker_thread_;
   TransportController* transport_controller_;
   MediaChannel* media_channel_;
+  webrtc::MediaControllerInterface* const media_controller_;
   std::vector<StreamParams> local_streams_;
   std::vector<StreamParams> remote_streams_;
 
   const std::string content_name_;
   std::string transport_name_;
   bool rtcp_transport_enabled_;
   TransportChannel* transport_channel_;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
   TransportChannel* rtcp_transport_channel_;
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
@@ skipping 14 matching lines @@
   int rtp_abs_sendtime_extn_id_;
 };
 
 // VoiceChannel is a specialization that adds support for early media, DTMF,
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
   VoiceChannel(rtc::Thread* thread,
                MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel,
+               webrtc::MediaControllerInterface* media_controller,
                TransportController* transport_controller,
                const std::string& content_name,
                bool rtcp);
   ~VoiceChannel();
   bool Init();
   bool SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer);
 
   // Configure sending media on the stream with SSRC |ssrc|
   // If there is only one sending stream SSRC 0 can be used.
   bool SetAudioSend(uint32 ssrc,
@@ skipping 82 matching lines @@
   // Last AudioRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   AudioRecvParameters last_recv_params_;
 };
 
 // VideoChannel is a specialization for video.
 class VideoChannel : public BaseChannel {
  public:
   VideoChannel(rtc::Thread* thread,
                VideoMediaChannel* channel,
+               webrtc::MediaControllerInterface* media_controller,
                TransportController* transport_controller,
                const std::string& content_name,
                bool rtcp);
   ~VideoChannel();
   bool Init();
 
   // downcasts a MediaChannel
   virtual VideoMediaChannel* media_channel() const {
     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
   }
@@ skipping 19 matching lines @@
       SignalConnectionMonitor;
 
   void StartMediaMonitor(int cms);
   void StopMediaMonitor();
   sigslot::signal2<VideoChannel*, const VideoMediaInfo&> SignalMediaMonitor;
   sigslot::signal2<uint32, rtc::WindowEvent> SignalScreencastWindowEvent;
 
   bool SendIntraFrame();
   bool RequestIntraFrame();
 
-  // Configure sending media on the stream with SSRC |ssrc|
-  // If there is only one sending stream SSRC 0 can be used.
   bool SetVideoSend(uint32 ssrc, bool enable, const VideoOptions* options);
 
  private:
   typedef std::map<uint32, VideoCapturer*> ScreencastMap;
   struct ScreencastDetailsData;
 
   // overrides from BaseChannel
   virtual void ChangeState();
   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
   virtual bool SetLocalContent_w(const MediaContentDescription* content,
@@ skipping 154 matching lines @@
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_MEDIA_CHANNEL_H_