Add overhead per packet observer to the rtp_sender.

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 17 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/playout_delay_oracle.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_history.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/ssrc_database.h"
 #include "webrtc/transport.h"
 
 namespace webrtc {
 
+class OverheadSizeObserver;
 class RateLimiter;
 class RtcEventLog;
 class RtpPacketToSend;
 class RTPSenderAudio;
 class RTPSenderVideo;
 
 class RTPSender {
  public:
   RTPSender(bool audio,
             Clock* clock,
             Transport* transport,
             RtpPacketSender* paced_sender,
             // TODO(brandtr): Remove |flexfec_sender| when that is hooked up
             // to PacedSender instead.
             FlexfecSender* flexfec_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);
+            RateLimiter* nack_rate_limiter,
+            OverheadSizeObserver* overhead_size_observer);
 
   ~RTPSender();
 
   void ProcessBitrate();
 
   uint16_t ActualSendBitrateKbit() const;
 
   uint32_t VideoBitrateSent() const;
   uint32_t FecOverheadRate() const;
   uint32_t NackOverheadRate() const;
@@ skipping 132 matching lines @@
   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;
 
+  void SetTransportOverhead(int transport_overhead);
+
  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;
 
   size_t SendPadData(size_t bytes, int probe_cluster_id);
@@ skipping 25 matching lines @@
                           uint32_t ssrc);
 
   bool UpdateTransportSequenceNumber(RtpPacketToSend* packet,
                                      int* packet_id) const;
 
   void UpdateRtpStats(const RtpPacketToSend& packet,
                       bool is_rtx,
                       bool is_retransmit);
   bool IsFecPacket(const RtpPacketToSend& packet) const;
 
+  void AddPacketToTransportFeedback(uint16_t packet_id,
+                                    const RtpPacketToSend& packet,
+                                    int probe_cluster_id);
+
+  void RtpOverheadSizeChanged(const RtpPacketToSend& packet);

[stefan-webrtc, 2016/11/15 11:50:14]

OnRtpOverheadSizeChanged, or perhaps UpdateRtpOverheadSize()?

[stefan-webrtc, 2016/11/15 16:05:49]

I'd prefer if we rename this.

[michaelt, 2016/11/15 16:18:54]

Done.

+
   Clock* const clock_;
   const int64_t clock_delta_ms_;
   Random random_ GUARDED_BY(send_critsect_);
 
   const bool audio_configured_;
   const std::unique_ptr<RTPSenderAudio> audio_;
   const std::unique_ptr<RTPSenderVideo> video_;
 
   RtpPacketSender* const paced_sender_;
   TransportSequenceNumberAllocator* const transport_sequence_number_allocator_;
@@ skipping 45 matching lines @@
   uint32_t last_rtp_timestamp_ GUARDED_BY(send_critsect_);
   int64_t capture_time_ms_ GUARDED_BY(send_critsect_);
   int64_t last_timestamp_time_ms_ GUARDED_BY(send_critsect_);
   bool media_has_been_sent_ GUARDED_BY(send_critsect_);
   bool last_packet_marker_bit_ GUARDED_BY(send_critsect_);
   std::vector<uint32_t> csrcs_ GUARDED_BY(send_critsect_);
   int rtx_ GUARDED_BY(send_critsect_);
   uint32_t ssrc_rtx_ GUARDED_BY(send_critsect_);
   // Mapping rtx_payload_type_map_[associated] = rtx.
   std::map<int8_t, int8_t> rtx_payload_type_map_ GUARDED_BY(send_critsect_);
+  size_t transport_overhead_bytes_per_packet_ GUARDED_BY(send_critsect_);
+  size_t rtp_overhead_bytes_per_packet_ GUARDED_BY(send_critsect_);
 
   RateLimiter* const retransmission_rate_limiter_;
+  OverheadSizeObserver* overhead_size_observer_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTPSender);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_