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 186 matching lines @@
                              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;
     }
+    // TODO(pbos): Does this make sense? NACK retransmissions + FEC overhead can
+    // go above 50% with FEC maxed out.

[stefan-webrtc, 2015/10/29 07:11:15]

I don't think it does. Please remove.

[pbos-webrtc, 2015/10/29 16:40:42]

Done.

     // 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;
+  printf("protection_overhead_bps: %f\n", protection_overhead_rate);

[stefan-webrtc, 2015/10/29 07:11:15]

Please remove!

[pbos-webrtc, 2015/10/29 16:40:42]

Done.

+  target_bit_rate_ = target_bitrate * (1.0 - protection_overhead_rate);

[stefan-webrtc, 2015/10/29 07:11:15]

Name this video_target_bitrate_

[pbos-webrtc, 2015/10/29 16:40:42]

Done.

+
+  // Cap target video bitrate to codec maximum.
+  if (max_bit_rate_ > 0 && target_bit_rate_ > max_bit_rate_) {
+    target_bit_rate_ = max_bit_rate_;
+  }
 
   // Update encoding rates following protection settings.
   float target_video_bitrate_kbps =
       static_cast<float>(target_bit_rate_) / 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,
@@ skipping 337 matching lines @@
       if (target_bit_rate_ >
           suspension_threshold_bps_ + suspension_window_bps_) {
         video_suspended_ = false;
       }
     }
   }
 }
 
 }  // namespace media_optimization
 }  // namespace webrtc