Make OverheadObserver::OnOverheadChanged count RTP headers only

webrtc/modules/rtp_rtcp/source/rtp_sender.cc

 /*
  *  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 75 matching lines @@
       random_(clock_->TimeInMicroseconds()),
       audio_configured_(audio),
       audio_(audio ? new RTPSenderAudio(clock, this) : nullptr),
       video_(audio ? nullptr : new RTPSenderVideo(clock, this, flexfec_sender)),
       paced_sender_(paced_sender),
       transport_sequence_number_allocator_(sequence_number_allocator),
       transport_feedback_observer_(transport_feedback_observer),
       last_capture_time_ms_sent_(0),
       transport_(transport),
       sending_media_(true),                      // Default to sending media.
-      max_payload_length_(IP_PACKET_SIZE - 28),  // Default is IP-v4/UDP.
+      max_packet_size_(IP_PACKET_SIZE - 28),  // Default is IP-v4/UDP.
       payload_type_(-1),
       payload_type_map_(),
       rtp_header_extension_map_(),
       packet_history_(clock),
       flexfec_packet_history_(clock),
       // Statistics
       rtp_stats_callback_(nullptr),
       total_bitrate_sent_(kBitrateStatisticsWindowMs,
                           RateStatistics::kBpsScale),
       nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
       frame_count_observer_(frame_count_observer),
       send_side_delay_observer_(send_side_delay_observer),
       event_log_(event_log),
       send_packet_observer_(send_packet_observer),
       bitrate_callback_(bitrate_callback),
       // RTP variables
       ssrc_db_(SSRCDatabase::GetSSRCDatabase()),
       remote_ssrc_(0),
       sequence_number_forced_(false),
       ssrc_forced_(false),
       last_rtp_timestamp_(0),
       capture_time_ms_(0),
       last_timestamp_time_ms_(0),
       media_has_been_sent_(false),
       last_packet_marker_bit_(false),
       csrcs_(),
       rtx_(kRtxOff),
-      transport_overhead_bytes_per_packet_(0),
       rtp_overhead_bytes_per_packet_(0),
       retransmission_rate_limiter_(retransmission_rate_limiter),
       overhead_observer_(overhead_observer) {
   ssrc_ = ssrc_db_->CreateSSRC();
   RTC_DCHECK(ssrc_ != 0);
   ssrc_rtx_ = ssrc_db_->CreateSSRC();
   RTC_DCHECK(ssrc_rtx_ != 0);
 
   // This random initialization is not intended to be cryptographic strong.
   timestamp_offset_ = random_.Rand<uint32_t>();
@@ skipping 155 matching lines @@
 void RTPSender::SetSendPayloadType(int8_t payload_type) {
   rtc::CritScope lock(&send_critsect_);
   payload_type_ = payload_type;
 }
 
 int8_t RTPSender::SendPayloadType() const {
   rtc::CritScope lock(&send_critsect_);
   return payload_type_;
 }
 
-void RTPSender::SetMaxPayloadLength(size_t max_payload_length) {
+void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
   // Sanity check.
-  RTC_DCHECK(max_payload_length >= 100 && max_payload_length <= IP_PACKET_SIZE)
-      << "Invalid max payload length: " << max_payload_length;
+  RTC_DCHECK(max_packet_size >= 100 && max_packet_size <= IP_PACKET_SIZE)
+      << "Invalid max payload length: " << max_packet_size;
   rtc::CritScope lock(&send_critsect_);
-  max_payload_length_ = max_payload_length;
+  max_packet_size_ = max_packet_size;
 }
 
-size_t RTPSender::MaxDataPayloadLength() const {
+size_t RTPSender::MaxPayloadSize() const {
   if (audio_configured_) {
-    return max_payload_length_ - RtpHeaderLength();
+    return max_packet_size_ - RtpHeaderLength();
   } else {
-    return max_payload_length_ - RtpHeaderLength()  // RTP overhead.
+    return max_packet_size_ - RtpHeaderLength()  // RTP overhead.
            - video_->FecPacketOverhead()            // FEC/ULP/RED overhead.
            - (RtxStatus() ? kRtxHeaderSize : 0);    // RTX overhead.
   }
 }
 
-size_t RTPSender::MaxPayloadLength() const {
-  return max_payload_length_;
+size_t RTPSender::MaxRtpPacketSize() const {
+  return max_packet_size_;
 }
 
 void RTPSender::SetRtxStatus(int mode) {
   rtc::CritScope lock(&send_critsect_);
   rtx_ = mode;
 }
 
 int RTPSender::RtxStatus() const {
   rtc::CritScope lock(&send_critsect_);
   return rtx_;
@@ skipping 146 matching lines @@
     bytes_left -= payload_size;
   }
   return bytes_to_send - bytes_left;
 }
 
 size_t RTPSender::SendPadData(size_t bytes, int probe_cluster_id) {
   // Always send full padding packets. This is accounted for by the
   // RtpPacketSender, which will make sure we don't send too much padding even
   // if a single packet is larger than requested.
   size_t padding_bytes_in_packet =
-      std::min(MaxDataPayloadLength(), kMaxPaddingLength);
+      std::min(MaxPayloadSize(), kMaxPaddingLength);
   size_t bytes_sent = 0;
   while (bytes_sent < bytes) {
     int64_t now_ms = clock_->TimeInMilliseconds();
     uint32_t ssrc;
     uint32_t timestamp;
     int64_t capture_time_ms;
     uint16_t sequence_number;
     int payload_type;
     bool over_rtx;
     {
@@ skipping 467 matching lines @@
 void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
                                 StreamDataCounters* rtx_stats) const {
   rtc::CritScope lock(&statistics_crit_);
   *rtp_stats = rtp_stats_;
   *rtx_stats = rtx_rtp_stats_;
 }
 
 std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
   rtc::CritScope lock(&send_critsect_);
   std::unique_ptr<RtpPacketToSend> packet(
-      new RtpPacketToSend(&rtp_header_extension_map_, max_payload_length_));
+      new RtpPacketToSend(&rtp_header_extension_map_, max_packet_size_));
   packet->SetSsrc(ssrc_);
   packet->SetCsrcs(csrcs_);
   // Reserve extensions, if registered, RtpSender set in SendToNetwork.
   packet->ReserveExtension<AbsoluteSendTime>();
   packet->ReserveExtension<TransmissionOffset>();
   packet->ReserveExtension<TransportSequenceNumber>();
   if (playout_delay_oracle_.send_playout_delay()) {
     packet->SetExtension<PlayoutDelayLimits>(
         playout_delay_oracle_.playout_delay());
   }
@@ skipping 258 matching lines @@
 RtpState RTPSender::GetRtxRtpState() const {
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = timestamp_offset_;
 
   return state;
 }
 
-void RTPSender::SetTransportOverhead(int transport_overhead) {
-  if (!overhead_observer_)
-    return;
-  size_t overhead_bytes_per_packet = 0;
-  {
-    rtc::CritScope lock(&send_critsect_);
-    if (transport_overhead_bytes_per_packet_ ==
-        static_cast<size_t>(transport_overhead)) {
-      return;
-    }
-    transport_overhead_bytes_per_packet_ = transport_overhead;
-    overhead_bytes_per_packet =
-        rtp_overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_;
-  }
-  overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
-}
-
 void RTPSender::AddPacketToTransportFeedback(uint16_t packet_id,
                                              const RtpPacketToSend& packet,
                                              int probe_cluster_id) {
   size_t packet_size = packet.payload_size() + packet.padding_size();
   if (webrtc::field_trial::FindFullName("WebRTC-SendSideBwe-WithOverhead") ==
       "Enabled") {
-    rtc::CritScope lock(&send_critsect_);
-    packet_size = packet.size() + transport_overhead_bytes_per_packet_;
+    packet_size = packet.size();
   }
 
   if (transport_feedback_observer_) {
     transport_feedback_observer_->AddPacket(packet_id, packet_size,
                                             probe_cluster_id);
   }
 }
 
 void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
   if (!overhead_observer_)
     return;
-  size_t overhead_bytes_per_packet = 0;
+  size_t overhead_bytes_per_packet;
   {
     rtc::CritScope lock(&send_critsect_);
     if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
       return;
     }
     rtp_overhead_bytes_per_packet_ = packet.headers_size();
-    overhead_bytes_per_packet =
-        rtp_overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_;
+    overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
   }
   overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);

[stefan-webrtc, 2016/12/20 13:05:01]

This should now be renamed OnRtpOverheadChanged()

[nisse-webrtc, 2016/12/20 13:38:13]

And the abstract-looking OverheadObserver interface should also be renamed to
the more specific RtpOverheadObserver. And perhaps be moved from common_types.h
to rtp_rtcp.h. Do you want me to do that? I'm not sure that's the right way to
go. 

If this stays the only use, it doesn't matter much, but if we ever want to keep
track of overhead with non-RTP-transport, I think it would be nice to not have
to introduce another interface with a different name but identical purpose.

[stefan-webrtc, 2016/12/20 14:18:23]

True. Maybe it's clear enough since it's only possible to register it to the rtp
module.

 }
 
 }  // namespace webrtc