Utilize bitrate above codec max to protect video.

webrtc/modules/video_coding/main/source/media_optimization.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 70 matching lines @@
       send_codec_type_(kVideoCodecUnknown),
       codec_width_(0),
       codec_height_(0),
       user_frame_rate_(0),
       frame_dropper_(new FrameDropper),
       loss_prot_logic_(
           new VCMLossProtectionLogic(clock_->TimeInMilliseconds())),
       fraction_lost_(0),
       send_statistics_zero_encode_(0),
       max_payload_size_(1460),
-      target_bit_rate_(0),
+      video_target_bitrate_(0),
       incoming_frame_rate_(0),
       enable_qm_(false),
       encoded_frame_samples_(),
       avg_sent_bit_rate_bps_(0),
       avg_sent_framerate_(0),
       key_frame_cnt_(0),
       delta_frame_cnt_(0),
       content_(new VCMContentMetricsProcessing()),
       qm_resolution_(new VCMQmResolution()),
       last_qm_update_time_(0),
@@ skipping 18 matching lines @@
   memset(incoming_frame_times_, -1, sizeof(incoming_frame_times_));
   incoming_frame_rate_ = 0.0;
   frame_dropper_->Reset();
   loss_prot_logic_->Reset(clock_->TimeInMilliseconds());
   frame_dropper_->SetRates(0, 0);
   content_->Reset();
   qm_resolution_->Reset();
   loss_prot_logic_->UpdateFrameRate(incoming_frame_rate_);
   loss_prot_logic_->Reset(clock_->TimeInMilliseconds());
   send_statistics_zero_encode_ = 0;
-  target_bit_rate_ = 0;
+  video_target_bitrate_ = 0;
   codec_width_ = 0;
   codec_height_ = 0;
   user_frame_rate_ = 0;
   key_frame_cnt_ = 0;
   delta_frame_cnt_ = 0;
   last_qm_update_time_ = 0;
   last_change_time_ = 0;
   encoded_frame_samples_.clear();
   avg_sent_bit_rate_bps_ = 0;
   num_layers_ = 1;
@@ skipping 29 matching lines @@
   // Everything codec specific should be reset here since this means the codec
   // has changed. If native dimension values have changed, then either user
   // initiated change, or QM initiated change. Will be able to determine only
   // after the processing of the first frame.
   last_change_time_ = clock_->TimeInMilliseconds();
   content_->Reset();
   content_->UpdateFrameRate(frame_rate);
 
   max_bit_rate_ = max_bit_rate;
   send_codec_type_ = send_codec_type;
-  target_bit_rate_ = target_bitrate;
+  video_target_bitrate_ = target_bitrate;
   float target_bitrate_kbps = static_cast<float>(target_bitrate) / 1000.0f;
   loss_prot_logic_->UpdateBitRate(target_bitrate_kbps);
   loss_prot_logic_->UpdateFrameRate(static_cast<float>(frame_rate));
   loss_prot_logic_->UpdateFrameSize(width, height);
   loss_prot_logic_->UpdateNumLayers(num_layers);
   frame_dropper_->Reset();
   frame_dropper_->SetRates(target_bitrate_kbps, static_cast<float>(frame_rate));
   user_frame_rate_ = static_cast<float>(frame_rate);
   codec_width_ = width;
   codec_height_ = height;
   num_layers_ = (num_layers <= 1) ? 1 : num_layers;  // Can also be zero.
   max_payload_size_ = mtu;
   qm_resolution_->Initialize(target_bitrate_kbps,
                              user_frame_rate_,
                              codec_width_,
                              codec_height_,
                              num_layers_);
 }
 
 uint32_t MediaOptimization::SetTargetRates(
     uint32_t target_bitrate,
     uint8_t fraction_lost,
     int64_t round_trip_time_ms,
     VCMProtectionCallback* protection_callback,
     VCMQMSettingsCallback* qmsettings_callback) {
   CriticalSectionScoped lock(crit_sect_.get());
-  // TODO(holmer): Consider putting this threshold only on the video bitrate,
-  // and not on protection.
-  if (max_bit_rate_ > 0 &&
-      target_bitrate > static_cast<uint32_t>(max_bit_rate_)) {
-    target_bitrate = max_bit_rate_;
-  }
   VCMProtectionMethod* selected_method = loss_prot_logic_->SelectedMethod();
   float target_bitrate_kbps = static_cast<float>(target_bitrate) / 1000.0f;
   loss_prot_logic_->UpdateBitRate(target_bitrate_kbps);
   loss_prot_logic_->UpdateRtt(round_trip_time_ms);
 
   // Get frame rate for encoder: this is the actual/sent frame rate.
   float actual_frame_rate = SentFrameRateInternal();
 
   // Sanity check.
   if (actual_frame_rate < 1.0) {
@@ skipping 11 matching lines @@
   // filtered value (average or max window filter).
   // Use max window filter for now.
   FilterPacketLossMode filter_mode = kMaxFilter;
   uint8_t packet_loss_enc = loss_prot_logic_->FilteredLoss(
       clock_->TimeInMilliseconds(), filter_mode, fraction_lost);
 
   // For now use the filtered loss for computing the robustness settings.
   loss_prot_logic_->UpdateFilteredLossPr(packet_loss_enc);
 
   // Rate cost of the protection methods.
-  uint32_t protection_overhead_bps = 0;
+  float protection_overhead_rate = 0.0f;
 
   // Update protection settings, when applicable.
   float sent_video_rate_kbps = 0.0f;
   if (loss_prot_logic_->SelectedType() != kNone) {
     // Update protection method with content metrics.
     selected_method->UpdateContentMetrics(content_->ShortTermAvgData());
 
     // Update method will compute the robustness settings for the given
     // protection method and the overhead cost
     // the protection method is set by the user via SetVideoProtection.
@@ skipping 11 matching lines @@
                                &sent_video_rate_bps,
                                &sent_nack_rate_bps,
                                &sent_fec_rate_bps,
                                protection_callback);
     }
     uint32_t sent_total_rate_bps =
         sent_video_rate_bps + sent_nack_rate_bps + sent_fec_rate_bps;
     // Estimate the overhead costs of the next second as staying the same
     // wrt the source bitrate.
     if (sent_total_rate_bps > 0) {
-      protection_overhead_bps = static_cast<uint32_t>(
-          target_bitrate *
-              static_cast<double>(sent_nack_rate_bps + sent_fec_rate_bps) /
-              sent_total_rate_bps +
-          0.5);
+      protection_overhead_rate =
+          static_cast<float>(sent_nack_rate_bps + sent_fec_rate_bps) /
+          sent_total_rate_bps;
     }
     // Cap the overhead estimate to 50%.
-    if (protection_overhead_bps > target_bitrate / 2)
-      protection_overhead_bps = target_bitrate / 2;
+    if (protection_overhead_rate > 0.5)
+      protection_overhead_rate = 0.5;
 
     // Get the effective packet loss for encoder ER when applicable. Should be
     // passed to encoder via fraction_lost.
     packet_loss_enc = selected_method->RequiredPacketLossER();
     sent_video_rate_kbps = static_cast<float>(sent_video_rate_bps) / 1000.0f;
   }
 
   // Source coding rate: total rate - protection overhead.
-  target_bit_rate_ = target_bitrate - protection_overhead_bps;
+  video_target_bitrate_ = target_bitrate * (1.0 - protection_overhead_rate);
+
+  // Cap target video bitrate to codec maximum.
+  if (max_bit_rate_ > 0 && video_target_bitrate_ > max_bit_rate_) {
+    video_target_bitrate_ = max_bit_rate_;
+  }
 
   // Update encoding rates following protection settings.
   float target_video_bitrate_kbps =
-      static_cast<float>(target_bit_rate_) / 1000.0f;
+      static_cast<float>(video_target_bitrate_) / 1000.0f;
   frame_dropper_->SetRates(target_video_bitrate_kbps, incoming_frame_rate_);
 
   if (enable_qm_ && qmsettings_callback) {
     // Update QM with rates.
     qm_resolution_->UpdateRates(target_video_bitrate_kbps,
                                 sent_video_rate_kbps,
                                 incoming_frame_rate_,
                                 fraction_lost_);
     // Check for QM selection.
     bool select_qm = CheckStatusForQMchange();
     if (select_qm) {
       SelectQuality(qmsettings_callback);
     }
     // Reset the short-term averaged content data.
     content_->ResetShortTermAvgData();
   }
 
   CheckSuspendConditions();
 
-  return target_bit_rate_;
+  return video_target_bitrate_;
 }
 
 void MediaOptimization::SetProtectionMethod(VCMProtectionMethodEnum method) {
   CriticalSectionScoped lock(crit_sect_.get());
   loss_prot_logic_->SetMethod(method);
 }
 
 uint32_t MediaOptimization::InputFrameRate() {
   CriticalSectionScoped lock(crit_sect_.get());
   return InputFrameRateInternal();
@@ skipping 293 matching lines @@
     const int64_t diff =
         incoming_frame_times_[0] - incoming_frame_times_[num - 1];
     incoming_frame_rate_ = 0.0;  // No frame rate estimate available.
     if (diff > 0) {
       incoming_frame_rate_ = nr_of_frames * 1000.0f / static_cast<float>(diff);
     }
   }
 }
 
 void MediaOptimization::CheckSuspendConditions() {
-  // Check conditions for SuspendBelowMinBitrate. |target_bit_rate_| is in bps.
+  // Check conditions for SuspendBelowMinBitrate. |video_target_bitrate_| is in
+  // bps.
   if (suspension_enabled_) {
     if (!video_suspended_) {
       // Check if we just went below the threshold.
-      if (target_bit_rate_ < suspension_threshold_bps_) {
+      if (video_target_bitrate_ < suspension_threshold_bps_) {
         video_suspended_ = true;
       }
     } else {
       // Video is already suspended. Check if we just went over the threshold
       // with a margin.
-      if (target_bit_rate_ >
+      if (video_target_bitrate_ >
           suspension_threshold_bps_ + suspension_window_bps_) {
         video_suspended_ = false;
       }
     }
   }
 }
 
 }  // namespace media_optimization
 }  // namespace webrtc