Set actual transport overhead in rtp_rtcp

webrtc/pc/channel.cc

 /*
  *  Copyright 2004 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 567 matching lines @@
     bool ready_to_send) {
   RTC_DCHECK(channel == transport_channel_ ||
              channel == rtcp_transport_channel_);
   RTC_DCHECK(network_thread_->IsCurrent());
   std::string transport_name = channel->transport_name();
   rtc::NetworkRoute network_route;
   if (selected_candidate_pair) {
     network_route = rtc::NetworkRoute(
         ready_to_send, selected_candidate_pair->local_candidate().network_id(),
         selected_candidate_pair->remote_candidate().network_id(),
-        last_sent_packet_id);
+        last_sent_packet_id,
+        GetTransportOverheadPerPacket(*selected_candidate_pair));
   }
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
       Bind(&MediaChannel::OnNetworkRouteChanged, media_channel_, transport_name,
            network_route));
 }
 
 void BaseChannel::SetTransportChannelReadyToSend(bool rtcp, bool ready) {
   RTC_DCHECK(network_thread_->IsCurrent());
   if (rtcp) {
@@ skipping 1055 matching lines @@
   }
 }
 
 void BaseChannel::UpdateMediaSendRecvState() {
   RTC_DCHECK(network_thread_->IsCurrent());
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
       Bind(&BaseChannel::UpdateMediaSendRecvState_w, this));
 }
 
+int BaseChannel::GetTransportOverheadPerPacket(
+    const CandidatePairInterface& selected_candidate_pair) {
+  constexpr int kIpv4Overhaed = 20;
+  constexpr int kIpv6Overhaed = 40;
+  constexpr int kUdpOverhaed = 8;
+  constexpr int kTcpOverhaed = 20;
+  constexpr int kSrtpAuthOverhaed = 4;

[stefan-webrtc, 2016/10/26 15:08:41]

kSrtpAuthOverhead

I'm not sure about this, but I think the srtp overhead can be larger? Can we get
it from somewhere perhaps?

[honghaiz3, 2016/10/26 17:44:56]

In this site, it shows the srtp overhead is 12 bytes if we include the overhead
after the payload. 
http://www.networksorcery.com/enp/protocol/srtp.htm

[michaelt, 2016/10/27 13:05:17]

According to https://tools.ietf.org/html/rfc3711,
SRTP could at max just add two params (auth_tag, mki (optional)).
I misinterpreted the rfc3711 auth_tag is not necessary just 4bit long. Its just
4 bit alignment with a variable size.
When I'm not wrong again :) , MKI is not used in webrtc. So just the size of the
auth_tag is relevant for the overhead.

Additional to this problem, i found that a dtls connection setup si done after
the route change. So I had to change the concept of getting the Overhead a
little.

Thanks for catching this.
 

+
+  int ransport_overhead_per_packet = 0;

[honghaiz3, 2016/10/26 17:44:56]

ransport... =>transport...

[michaelt, 2016/10/27 13:05:17]

Done.

+  ransport_overhead_per_packet +=
+      selected_candidate_pair.local_candidate().protocol() == TCP_PROTOCOL_NAME
+          ? kTcpOverhaed
+          : kUdpOverhaed;
+  ransport_overhead_per_packet +=
+      selected_candidate_pair.local_candidate().address().family() == AF_INET
+          ? kIpv4Overhaed
+          : kIpv6Overhaed;
+  if (secure()) {
+    ransport_overhead_per_packet += kSrtpAuthOverhaed;
+  }
+  return ransport_overhead_per_packet;
+}
+
 void VoiceChannel::UpdateMediaSendRecvState_w() {
   // Render incoming data if we're the active call, and we have the local
   // content. We receive data on the default channel and multiplexed streams.
   bool recv = IsReadyToReceiveMedia_w();
   media_channel()->SetPlayout(recv);
 
   // Send outgoing data if we're the active call, we have the remote content,
   // and we have had some form of connectivity.
   bool send = IsReadyToSendMedia_w();
   media_channel()->SetSend(send);
@@ skipping 736 matching lines @@
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
   rtc::TypedMessageData<uint32_t>* message =
       new rtc::TypedMessageData<uint32_t>(sid);
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_STREAMCLOSEDREMOTELY,
                            message);
 }
 
 }  // namespace cricket