Remove RTPSenderInterface

webrtc/modules/rtp_rtcp/source/rtp_sender.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 22 matching lines @@
 #include "webrtc/transport.h"
 
 namespace webrtc {
 
 class RateLimiter;
 class RtcEventLog;
 class RtpPacketToSend;
 class RTPSenderAudio;
 class RTPSenderVideo;
 
-class RTPSenderInterface {
- public:
-  RTPSenderInterface() {}
-  virtual ~RTPSenderInterface() {}
-
-  virtual uint32_t SSRC() const = 0;
-  virtual uint32_t Timestamp() const = 0;
-
-  // Deprecated version of BuildRtpHeader(). |timestamp_provided| and
-  // |inc_sequence_number| are ignored.
-  // TODO(sergeyu): Remove this method.
-  virtual int32_t BuildRTPheader(uint8_t* data_buffer,
-                                 int8_t payload_type,
-                                 bool marker_bit,
-                                 uint32_t capture_timestamp,
-                                 int64_t capture_time_ms,
-                                 bool timestamp_provided = true,
-                                 bool inc_sequence_number = true) = 0;
-
-  virtual int32_t BuildRtpHeader(uint8_t* data_buffer,
-                                 int8_t payload_type,
-                                 bool marker_bit,
-                                 uint32_t capture_timestamp,
-                                 int64_t capture_time_ms) = 0;
-
-  // This returns the expected header length taking into consideration
-  // the optional RTP header extensions that may not be currently active.
-  virtual size_t RtpHeaderLength() const = 0;
-  // Returns the next sequence number to use for a packet and allocates
-  // 'packets_to_send' number of sequence numbers. It's important all allocated
-  // sequence numbers are used in sequence to avoid perceived packet loss.
-  virtual uint16_t AllocateSequenceNumber(uint16_t packets_to_send) = 0;
-  virtual uint16_t SequenceNumber() const = 0;
-  virtual size_t MaxPayloadLength() const = 0;
-  virtual size_t MaxDataPayloadLength() const = 0;
-  virtual uint16_t ActualSendBitrateKbit() const = 0;
-
-  virtual bool SendToNetwork(uint8_t* data_buffer,
-                             size_t payload_length,
-                             size_t rtp_header_length,
-                             int64_t capture_time_ms,
-                             StorageType storage,
-                             RtpPacketSender::Priority priority) = 0;
-
-  virtual bool UpdateVideoRotation(uint8_t* rtp_packet,
-                                   size_t rtp_packet_length,
-                                   const RTPHeader& rtp_header,
-                                   VideoRotation rotation) const = 0;
-  virtual bool IsRtpHeaderExtensionRegistered(RTPExtensionType type) = 0;
-  virtual bool ActivateCVORtpHeaderExtension() = 0;
-};
-
-class RTPSender : public RTPSenderInterface {
+class RTPSender {
  public:
   RTPSender(bool audio,
             Clock* clock,
             Transport* transport,
             RtpPacketSender* paced_sender,
             TransportSequenceNumberAllocator* sequence_number_allocator,
             TransportFeedbackObserver* transport_feedback_callback,
             BitrateStatisticsObserver* bitrate_callback,
             FrameCountObserver* frame_count_observer,
             SendSideDelayObserver* send_side_delay_observer,
             RtcEventLog* event_log,
             SendPacketObserver* send_packet_observer,
             RateLimiter* nack_rate_limiter);
 
-  virtual ~RTPSender();
+  ~RTPSender();
 
   void ProcessBitrate();
 
-  uint16_t ActualSendBitrateKbit() const override;
+  uint16_t ActualSendBitrateKbit() const;
 
   uint32_t VideoBitrateSent() const;
   uint32_t FecOverheadRate() const;
   uint32_t NackOverheadRate() const;
 
   // Includes size of RTP and FEC headers.
-  size_t MaxDataPayloadLength() const override;
+  size_t MaxDataPayloadLength() const;
 
   int32_t RegisterPayload(const char* payload_name,
                           const int8_t payload_type,
                           const uint32_t frequency,
                           const size_t channels,
                           const uint32_t rate);
 
   int32_t DeRegisterSendPayload(const int8_t payload_type);
 
   void SetSendPayloadType(int8_t payload_type);
 
   int8_t SendPayloadType() const;
 
   int SendPayloadFrequency() const;
 
   void SetSendingStatus(bool enabled);
 
   void SetSendingMediaStatus(bool enabled);
   bool SendingMedia() const;
 
   void GetDataCounters(StreamDataCounters* rtp_stats,
                        StreamDataCounters* rtx_stats) const;
 
   uint32_t StartTimestamp() const;
   void SetStartTimestamp(uint32_t timestamp, bool force);
 
   uint32_t GenerateNewSSRC();
   void SetSSRC(uint32_t ssrc);
 
-  uint16_t SequenceNumber() const override;
+  uint16_t SequenceNumber() const;
   void SetSequenceNumber(uint16_t seq);
 
   void SetCsrcs(const std::vector<uint32_t>& csrcs);
 
   void SetMaxPayloadLength(size_t max_payload_length);
 
   bool SendOutgoingData(FrameType frame_type,
                         int8_t payload_type,
                         uint32_t timestamp,
                         int64_t capture_time_ms,
                         const uint8_t* payload_data,
                         size_t payload_size,
                         const RTPFragmentationHeader* fragmentation,
                         const RTPVideoHeader* rtp_header,
                         uint32_t* transport_frame_id_out);
 
   // RTP header extension
   int32_t SetTransmissionTimeOffset(int32_t transmission_time_offset);
   int32_t SetAbsoluteSendTime(uint32_t absolute_send_time);
   void SetVideoRotation(VideoRotation rotation);
   int32_t SetTransportSequenceNumber(uint16_t sequence_number);
 
   int32_t RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id);
-  bool IsRtpHeaderExtensionRegistered(RTPExtensionType type) override;
+  bool IsRtpHeaderExtensionRegistered(RTPExtensionType type);
   int32_t DeregisterRtpHeaderExtension(RTPExtensionType type);
 
   size_t RtpHeaderExtensionLength() const;
 
   uint16_t BuildRtpHeaderExtension(uint8_t* data_buffer, bool marker_bit) const
       EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
 
   uint8_t BuildTransmissionTimeOffsetExtension(uint8_t* data_buffer) const
       EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
   uint8_t BuildAudioLevelExtension(uint8_t* data_buffer) const
@@ skipping 31 matching lines @@
 
   bool UpdateAudioLevel(uint8_t* rtp_packet,
                         size_t rtp_packet_length,
                         const RTPHeader& rtp_header,
                         bool is_voiced,
                         uint8_t dBov) const;
 
   bool UpdateVideoRotation(uint8_t* rtp_packet,
                            size_t rtp_packet_length,
                            const RTPHeader& rtp_header,
-                           VideoRotation rotation) const override;
+                           VideoRotation rotation) const;
 
   bool TimeToSendPacket(uint16_t sequence_number,
                         int64_t capture_time_ms,
                         bool retransmission,
                         int probe_cluster_id);
   size_t TimeToSendPadding(size_t bytes, int probe_cluster_id);
 
   // NACK.
   int SelectiveRetransmissions() const;
   int SetSelectiveRetransmissions(uint8_t settings);
@@ skipping 18 matching lines @@
 
   void SetRtxPayloadType(int payload_type, int associated_payload_type);
 
   // Functions wrapping RTPSenderInterface.
   int32_t BuildRTPheader(uint8_t* data_buffer,
                          int8_t payload_type,
                          bool marker_bit,
                          uint32_t capture_timestamp,
                          int64_t capture_time_ms,
                          bool timestamp_provided = true,
-                         bool inc_sequence_number = true) override;
+                         bool inc_sequence_number = true);
   int32_t BuildRtpHeader(uint8_t* data_buffer,
                          int8_t payload_type,
                          bool marker_bit,
                          uint32_t capture_timestamp,
-                         int64_t capture_time_ms) override;
+                         int64_t capture_time_ms);
 
-  size_t RtpHeaderLength() const override;
-  uint16_t AllocateSequenceNumber(uint16_t packets_to_send) override;
-  size_t MaxPayloadLength() const override;
+  size_t RtpHeaderLength() const;
+  uint16_t AllocateSequenceNumber(uint16_t packets_to_send);
+  size_t MaxPayloadLength() const;
 
   // Current timestamp.
-  uint32_t Timestamp() const override;
-  uint32_t SSRC() const override;
+  uint32_t Timestamp() const;
+  uint32_t SSRC() const;
 
   // Deprecated. Create RtpPacketToSend instead and use next function.
   bool SendToNetwork(uint8_t* data_buffer,
                      size_t payload_length,
                      size_t rtp_header_length,
                      int64_t capture_time_ms,
                      StorageType storage,
-                     RtpPacketSender::Priority priority) override;
+                     RtpPacketSender::Priority priority);
   bool SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
                      StorageType storage,
                      RtpPacketSender::Priority priority);
 
   // Audio.
 
   // Send a DTMF tone using RFC 2833 (4733).
   int32_t SendTelephoneEvent(uint8_t key, uint16_t time_ms, uint8_t level);
 
   // Set audio packet size, used to determine when it's time to send a DTMF
@@ skipping 39 matching lines @@
   // Called on update of RTP statistics.
   void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback);
   StreamDataCountersCallback* GetRtpStatisticsCallback() const;
 
   uint32_t BitrateSent() const;
 
   void SetRtpState(const RtpState& rtp_state);
   RtpState GetRtpState() const;
   void SetRtxRtpState(const RtpState& rtp_state);
   RtpState GetRtxRtpState() const;
-  bool ActivateCVORtpHeaderExtension() override;
+  bool ActivateCVORtpHeaderExtension();
 
  protected:
   int32_t CheckPayloadType(int8_t payload_type, RtpVideoCodecTypes* video_type);
 
  private:
   // Maps capture time in milliseconds to send-side delay in milliseconds.
   // Send-side delay is the difference between transmission time and capture
   // time.
   typedef std::map<int64_t, int> SendDelayMap;
 
@@ skipping 123 matching lines @@
   std::map<int8_t, int8_t> rtx_payload_type_map_ GUARDED_BY(send_critsect_);
 
   RateLimiter* const retransmission_rate_limiter_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTPSender);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_