Reland of actor NACK bitrate allocation

webrtc/modules/rtp_rtcp/source/rtp_sender_video.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 13 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/producer_fec.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
 
 namespace webrtc {
 enum { REDForFECHeaderLength = 1 };
 
 RTPSenderVideo::RTPSenderVideo(Clock* clock, RTPSenderInterface* rtpSender)
     : _rtpSender(*rtpSender),
+      clock_(clock),
       _videoType(kRtpVideoGeneric),
       _retransmissionSettings(kRetransmitBaseLayer),
       // Generic FEC
       fec_(),
       fec_enabled_(false),
       red_payload_type_(0),
       fec_payload_type_(0),
       delta_fec_params_(),
       key_fec_params_(),
       producer_fec_(&fec_),
-      _fecOverheadRate(clock, NULL),
-      _videoBitrate(clock, NULL) {
+      fec_bitrate_(1000, RateStatistics::kBpsScale),
+      video_bitrate_(1000, RateStatistics::kBpsScale) {
   memset(&delta_fec_params_, 0, sizeof(delta_fec_params_));
   memset(&key_fec_params_, 0, sizeof(key_fec_params_));
   delta_fec_params_.max_fec_frames = key_fec_params_.max_fec_frames = 1;
   delta_fec_params_.fec_mask_type = key_fec_params_.fec_mask_type =
       kFecMaskRandom;
 }
 
 RTPSenderVideo::~RTPSenderVideo() {
 }
 
@@ skipping 32 matching lines @@
 void RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
                                      const size_t payload_length,
                                      const size_t rtp_header_length,
                                      uint16_t seq_num,
                                      const uint32_t capture_timestamp,
                                      int64_t capture_time_ms,
                                      StorageType storage) {
   if (_rtpSender.SendToNetwork(data_buffer, payload_length, rtp_header_length,
                                capture_time_ms, storage,
                                RtpPacketSender::kLowPriority) == 0) {
-    _videoBitrate.Update(payload_length + rtp_header_length);
+    rtc::CritScope cs(&stats_crit_);
+    video_bitrate_.Update(payload_length + rtp_header_length,
+                          clock_->TimeInMilliseconds());
     TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                          "Video::PacketNormal", "timestamp", capture_timestamp,
                          "seqnum", seq_num);
   } else {
     LOG(LS_WARNING) << "Failed to send video packet " << seq_num;
   }
 }
 
 void RTPSenderVideo::SendVideoPacketAsRed(uint8_t* data_buffer,
                                           const size_t payload_length,
@@ skipping 25 matching lines @@
           rtp_header_length);
       RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
       if (_retransmissionSettings & kRetransmitFECPackets)
         fec_storage = kAllowRetransmission;
     }
   }
   if (_rtpSender.SendToNetwork(
           red_packet->data(), red_packet->length() - rtp_header_length,
           rtp_header_length, capture_time_ms, media_packet_storage,
           RtpPacketSender::kLowPriority) == 0) {
-    _videoBitrate.Update(red_packet->length());
+    rtc::CritScope cs(&stats_crit_);
+    video_bitrate_.Update(red_packet->length(), clock_->TimeInMilliseconds());
     TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                          "Video::PacketRed", "timestamp", capture_timestamp,
                          "seqnum", media_seq_num);
   } else {
     LOG(LS_WARNING) << "Failed to send RED packet " << media_seq_num;
   }
   for (RedPacket* fec_packet : fec_packets) {
     if (_rtpSender.SendToNetwork(
             fec_packet->data(), fec_packet->length() - rtp_header_length,
             rtp_header_length, capture_time_ms, fec_storage,
             RtpPacketSender::kLowPriority) == 0) {
-      _fecOverheadRate.Update(fec_packet->length());
+      rtc::CritScope cs(&stats_crit_);
+      fec_bitrate_.Update(fec_packet->length(), clock_->TimeInMilliseconds());
       TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                            "Video::PacketFec", "timestamp", capture_timestamp,
                            "seqnum", next_fec_sequence_number);
     } else {
       LOG(LS_WARNING) << "Failed to send FEC packet "
                       << next_fec_sequence_number;
     }
     delete fec_packet;
     ++next_fec_sequence_number;
   }
@@ skipping 163 matching lines @@
       }
     }
     first = false;
   }
 
   TRACE_EVENT_ASYNC_END1(
       "webrtc", "Video", capture_time_ms, "timestamp", _rtpSender.Timestamp());
   return 0;
 }
 
-void RTPSenderVideo::ProcessBitrate() {
-  _videoBitrate.Process();
-  _fecOverheadRate.Process();
-}
-
 uint32_t RTPSenderVideo::VideoBitrateSent() const {
-  return _videoBitrate.BitrateLast();
+  rtc::CritScope cs(&stats_crit_);
+  return video_bitrate_.Rate(clock_->TimeInMilliseconds()).value_or(0);
 }
 
 uint32_t RTPSenderVideo::FecOverheadRate() const {
-  return _fecOverheadRate.BitrateLast();
+  rtc::CritScope cs(&stats_crit_);
+  return fec_bitrate_.Rate(clock_->TimeInMilliseconds()).value_or(0);
 }
 
 int RTPSenderVideo::SelectiveRetransmissions() const {
   rtc::CritScope cs(&crit_);
   return _retransmissionSettings;
 }
 
 void RTPSenderVideo::SetSelectiveRetransmissions(uint8_t settings) {
   rtc::CritScope cs(&crit_);
   _retransmissionSettings = settings;
 }
 
 }  // namespace webrtc