Set actual transport overhead in rtp_rtcp

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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 84 matching lines @@
                                const PacketTime& packet_time) override;
 
   // Implements RecoveredPacketReceiver.
   bool OnRecoveredPacket(const uint8_t* packet, size_t length) override;
 
   void SetBitrateConfig(
       const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
 
   void SignalChannelNetworkState(MediaType media, NetworkState state) override;
 
+  void SignalTransportOverheadChange(
+      MediaType media,
+      int transport_overhead_per_packet) override;
+
   void OnNetworkRouteChanged(const std::string& transport_name,
                              const rtc::NetworkRoute& network_route) override;
 
   void OnSentPacket(const rtc::SentPacket& sent_packet) override;
 
   // Implements BitrateObserver.
   void OnNetworkChanged(uint32_t bitrate_bps, uint8_t fraction_loss,
                         int64_t rtt_ms) override;
 
   // Implements BitrateAllocator::LimitObserver.
@@ skipping 544 matching lines @@
     ReadLockScoped read_lock(*receive_crit_);
     for (auto& kv : audio_receive_ssrcs_) {
       kv.second->SignalNetworkState(audio_network_state_);
     }
     for (auto& kv : video_receive_ssrcs_) {
       kv.second->SignalNetworkState(video_network_state_);
     }
   }
 }
 
+void Call::SignalTransportOverheadChange(MediaType media,
+                                         int transport_overhead_per_packet) {
+  switch (media) {
+    case MediaType::AUDIO: {
+      ReadLockScoped read_lock(*send_crit_);
+      for (auto& kv : audio_send_ssrcs_) {
+        kv.second->SetTransportOverhead(transport_overhead_per_packet);
+      }
+      break;
+    }
+    case MediaType::VIDEO: {
+      ReadLockScoped read_lock(*send_crit_);
+      for (auto& kv : video_send_ssrcs_) {
+        kv.second->SetTransportOverhead(transport_overhead_per_packet);
+      }
+      break;
+    }
+    case MediaType::ANY:
+    case MediaType::DATA:
+      RTC_NOTREACHED();
+      break;
+  }
+}
+
 // TODO(honghaiz): Add tests for this method.
 void Call::OnNetworkRouteChanged(const std::string& transport_name,
                                  const rtc::NetworkRoute& network_route) {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   // Check if the network route is connected.
   if (!network_route.connected) {
     LOG(LS_INFO) << "Transport " << transport_name << " is disconnected";
     // TODO(honghaiz): Perhaps handle this in SignalChannelNetworkState and
     // consider merging these two methods.
     return;
@@ skipping 273 matching lines @@
   uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
   ReadLockScoped read_lock(*receive_crit_);
   auto it = video_receive_ssrcs_.find(ssrc);
   if (it == video_receive_ssrcs_.end())
     return false;
   return it->second->OnRecoveredPacket(packet, length);
 }
 
 }  // namespace internal
 }  // namespace webrtc