Move simple RtpRtcp calls to VideoSendStream.

webrtc/video/vie_channel.h

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 67 matching lines @@
              size_t max_rtp_streams,
              bool sender);
   ~ViEChannel();
 
   int32_t Init();
 
   // Sets the encoder to use for the channel. |new_stream| indicates the encoder
   // type has changed and we should start a new RTP stream.
   int32_t SetSendCodec(const VideoCodec& video_codec, bool new_stream = true);
 
-  void SetRTCPMode(const RtcpMode rtcp_mode);
   void SetProtectionMode(bool enable_nack,
                          bool enable_fec,
                          int payload_type_red,
                          int payload_type_fec);
-  bool IsSendingFecEnabled();
   int SetSenderBufferingMode(int target_delay_ms);
   int SetSendTimestampOffsetStatus(bool enable, int id);
   int SetSendAbsoluteSendTimeStatus(bool enable, int id);
   int SetSendVideoRotationStatus(bool enable, int id);
   int SetSendTransportSequenceNumber(bool enable, int id);
 
-  // Sets SSRC for outgoing stream.
-  int32_t SetSSRC(const uint32_t SSRC,
-                  const StreamType usage,
-                  const unsigned char simulcast_idx);
-
-  // Gets SSRC for outgoing stream number |idx|.
-  int32_t GetLocalSSRC(uint8_t idx, unsigned int* ssrc);
-
-  int SetRtxSendPayloadType(int payload_type, int associated_payload_type);
-
-  void SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state);
   RtpState GetRtpStateForSsrc(uint32_t ssrc) const;
 
-  // Sets the CName for the outgoing stream on the channel.
-  int32_t SetRTCPCName(const char* rtcp_cname);
-
-  // Gets the CName of the incoming stream.
-  int32_t GetRemoteRTCPCName(char rtcp_cname[]);
-
   // Returns statistics reported by the remote client in an RTCP packet.
   // TODO(pbos): Remove this along with VideoSendStream::GetRtt().
   int32_t GetSendRtcpStatistics(uint16_t* fraction_lost,
                                 uint32_t* cumulative_lost,
                                 uint32_t* extended_max,
                                 uint32_t* jitter_samples,
                                 int64_t* rtt_ms) const;
 
-  // Called on receipt of RTCP report block from remote side.
-  void RegisterSendChannelRtcpStatisticsCallback(
-      RtcpStatisticsCallback* callback);
-
   // Gets send statistics for the rtp and rtx stream.
   void GetSendStreamDataCounters(StreamDataCounters* rtp_counters,
                                  StreamDataCounters* rtx_counters) const;
 
   // Gets received stream data counters.
   void GetReceiveStreamDataCounters(StreamDataCounters* rtp_counters,
                                     StreamDataCounters* rtx_counters) const;
 
-  // Called on update of RTP statistics.
-  void RegisterSendChannelRtpStatisticsCallback(
-      StreamDataCountersCallback* callback);
-
   void GetSendRtcpPacketTypeCounter(
       RtcpPacketTypeCounter* packet_counter) const;
 
   void GetReceiveRtcpPacketTypeCounter(
       RtcpPacketTypeCounter* packet_counter) const;
 
   void RegisterSendSideDelayObserver(SendSideDelayObserver* observer);
 
   // Called on any new send bitrate estimate.
   void RegisterSendBitrateObserver(BitrateStatisticsObserver* observer);
 
   // Implements RtpFeedback.
   int32_t OnInitializeDecoder(const int8_t payload_type,
                               const char payload_name[RTP_PAYLOAD_NAME_SIZE],
                               const int frequency,
                               const size_t channels,
                               const uint32_t rate) override;
   void OnIncomingSSRCChanged(const uint32_t ssrc) override;
   void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) override;
 
   int32_t StartSend();
   int32_t StopSend();
 
-  // Sets the maximum transfer unit size for the network link, i.e. including
-  // IP, UDP and RTP headers.
-  int32_t SetMTU(uint16_t mtu);
-
   // Gets the modules used by the channel.
-  RtpRtcp* rtp_rtcp();
+  const std::vector<RtpRtcp*>& rtp_rtcp() const;
   ViEReceiver* vie_receiver();
   VCMProtectionCallback* vcm_protection_callback();
 
 
   CallStatsObserver* GetStatsObserver();
 
   // Implements VCMReceiveCallback.
   virtual int32_t FrameToRender(VideoFrame& video_frame);  // NOLINT
 
   // Implements VCMReceiveCallback.
@@ skipping 69 matching lines @@
       SendSideDelayObserver* send_side_delay_observer,
       size_t num_modules);
 
   // Assumed to be protected.
   void StartDecodeThread();
   void StopDecodeThread();
 
   void ProcessNACKRequest(const bool enable);
   // Compute NACK list parameters for the buffering mode.
   int GetRequiredNackListSize(int target_delay_ms);
-  void SetRtxSendStatus(bool enable);
 
   void UpdateHistograms();
 
   // ViEChannel exposes methods that allow to modify observers and callbacks
   // to be modified. Such an API-style is cumbersome to implement and maintain
   // at all the levels when comparing to only setting them at construction. As
   // so this class instantiates its children with a wrapper that can be modified
   // at a later time.
   template <class T>
   class RegisterableCallback : public T {
@@ skipping 116 matching lines @@
   size_t num_rtts_ GUARDED_BY(crit_);
 
   // RtpRtcp modules, declared last as they use other members on construction.
   const std::vector<RtpRtcp*> rtp_rtcp_modules_;
   size_t num_active_rtp_rtcp_modules_ GUARDED_BY(crit_);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_VIDEO_VIE_CHANNEL_H_