Make OverheadObserver::OnOverheadChanged count RTP headers only

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.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 103 matching lines @@
       rtt_ms_(0) {
   // Make sure that RTCP objects are aware of our SSRC.
   uint32_t SSRC = rtp_sender_.SSRC();
   rtcp_sender_.SetSSRC(SSRC);
   SetRtcpReceiverSsrcs(SSRC);
 
   // Make sure rtcp sender use same timestamp offset as rtp sender.
   rtcp_sender_.SetTimestampOffset(rtp_sender_.TimestampOffset());
 
   // Set default packet size limit.
-  SetMaxTransferUnit(IP_PACKET_SIZE);
+  // TODO(nisse): Symbolic constant.
+  SetMaxRtpPacketSize(IP_PACKET_SIZE - 40);

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

I think it would make sense to make 40 a named constant.

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

There's just too many named constants for the same numerical values...

Would it make sense to use
webrtc::VideoSendStream::Config::Rtp::kDefaultMaxPacketSize here, or do I have
to duplicate it?

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

Probably, since then you won't be able to build this without depending on
webrtc::VideoSendStream.

Maybe just add a comment, or make it a local named constant?

[nisse-webrtc, 2017/01/09 16:02:24]

Done.

 }
 
 // Returns the number of milliseconds until the module want a worker thread
 // to call Process.
 int64_t ModuleRtpRtcpImpl::TimeUntilNextProcess() {
   const int64_t now = clock_->TimeInMilliseconds();
   const int64_t kRtpRtcpMaxIdleTimeProcessMs = 5;
   return kRtpRtcpMaxIdleTimeProcessMs - (now - last_process_time_);
 }
 
@@ skipping 273 matching lines @@
                                          int probe_cluster_id) {
   return rtp_sender_.TimeToSendPacket(ssrc, sequence_number, capture_time_ms,
                                       retransmission, probe_cluster_id);
 }
 
 size_t ModuleRtpRtcpImpl::TimeToSendPadding(size_t bytes,
                                             int probe_cluster_id) {
   return rtp_sender_.TimeToSendPadding(bytes, probe_cluster_id);
 }
 
-uint16_t ModuleRtpRtcpImpl::MaxPayloadLength() const {
-  return rtp_sender_.MaxPayloadLength();
+size_t ModuleRtpRtcpImpl::MaxPayloadSize() const {
+  return rtp_sender_.MaxPayloadSize();
 }
 
-uint16_t ModuleRtpRtcpImpl::MaxDataPayloadLength() const {
-  return rtp_sender_.MaxDataPayloadLength();
+size_t ModuleRtpRtcpImpl::MaxRtpPacketSize() const {
+  return rtp_sender_.MaxRtpPacketSize();
 }
 
-int32_t ModuleRtpRtcpImpl::SetTransportOverhead(
-    const bool tcp,
-    const bool ipv6,
-    const uint8_t authentication_overhead) {
-  uint16_t packet_overhead = 0;
-  if (ipv6) {
-    packet_overhead = 40;
-  } else {
-    packet_overhead = 20;
-  }
-  if (tcp) {
-    // TCP.
-    packet_overhead += 20;
-  } else {
-    // UDP.
-    packet_overhead += 8;
-  }
-  packet_overhead += authentication_overhead;
+void ModuleRtpRtcpImpl::SetMaxRtpPacketSize(size_t rtp_packet_size) {
+  RTC_DCHECK_LE(rtp_packet_size, IP_PACKET_SIZE)
+      << "rtp packet size too large: " << rtp_packet_size;
+  RTC_DCHECK_GT(rtp_packet_size, packet_overhead_)
+      << "rtp packet size too small: " << rtp_packet_size;
 
-  if (packet_overhead == packet_overhead_) {
-    // Ok same as before.
-    return 0;
-  }
-
-  size_t mtu = rtp_sender_.MaxPayloadLength() + packet_overhead_;
-  size_t max_payload_length = mtu - packet_overhead;
-  packet_overhead_ = packet_overhead;
-  rtcp_sender_.SetMaxPayloadLength(max_payload_length);
-  rtp_sender_.SetMaxPayloadLength(max_payload_length);
-  return 0;
-}
-
-void ModuleRtpRtcpImpl::SetTransportOverhead(
-    int transport_overhead_per_packet) {
-  RTC_DCHECK_GT(transport_overhead_per_packet, 0);
-  int mtu = rtp_sender_.MaxPayloadLength() + packet_overhead_;
-  RTC_DCHECK_LT(transport_overhead_per_packet, mtu);
-  size_t max_payload_length = mtu - transport_overhead_per_packet;
-  packet_overhead_ = transport_overhead_per_packet;
-  rtp_sender_.SetTransportOverhead(packet_overhead_);
-  rtcp_sender_.SetMaxPayloadLength(max_payload_length);
-  rtp_sender_.SetMaxPayloadLength(max_payload_length);
-}
-
-int32_t ModuleRtpRtcpImpl::SetMaxTransferUnit(uint16_t mtu) {
-  RTC_DCHECK_LE(mtu, IP_PACKET_SIZE) << "MTU too large: " << mtu;
-  RTC_DCHECK_GT(mtu, packet_overhead_) << "MTU too small: " << mtu;
-  size_t max_payload_length = mtu - packet_overhead_;
-  rtcp_sender_.SetMaxPayloadLength(max_payload_length);
-  rtp_sender_.SetMaxPayloadLength(max_payload_length);
-  return 0;
+  rtcp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
+  rtp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
 }
 
 RtcpMode ModuleRtpRtcpImpl::RTCP() const {
   return rtcp_sender_.Status();
 }
 
 // Configure RTCP status i.e on/off.
 void ModuleRtpRtcpImpl::SetRTCPStatus(const RtcpMode method) {
   rtcp_sender_.SetRTCPStatus(method);
 }
@@ skipping 464 matching lines @@
 StreamDataCountersCallback*
     ModuleRtpRtcpImpl::GetSendChannelRtpStatisticsCallback() const {
   return rtp_sender_.GetRtpStatisticsCallback();
 }
 
 void ModuleRtpRtcpImpl::SetVideoBitrateAllocation(
     const BitrateAllocation& bitrate) {
   rtcp_sender_.SetVideoBitrateAllocation(bitrate);
 }
 }  // namespace webrtc