Lint enabled for webrtc/modules/video_coding folder.

webrtc/modules/video_coding/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 35 matching lines @@
   key_fec_params.max_fec_frames = selected_method->MaxFramesFec();
 
   // Set the FEC packet mask type. |kFecMaskBursty| is more effective for
   // consecutive losses and little/no packet re-ordering. As we currently
   // do not have feedback data on the degree of correlated losses and packet
   // re-ordering, we keep default setting to |kFecMaskRandom| for now.
   delta_fec_params.fec_mask_type = kFecMaskRandom;
   key_fec_params.fec_mask_type = kFecMaskRandom;
 
   // TODO(Marco): Pass FEC protection values per layer.
-  video_protection_callback->ProtectionRequest(&delta_fec_params,
-                                               &key_fec_params,
-                                               video_rate_bps,
-                                               nack_overhead_rate_bps,
-                                               fec_overhead_rate_bps);
+  video_protection_callback->ProtectionRequest(
+      &delta_fec_params, &key_fec_params, video_rate_bps,
+      nack_overhead_rate_bps, fec_overhead_rate_bps);
 }
 }  // namespace
 
 struct MediaOptimization::EncodedFrameSample {
   EncodedFrameSample(size_t size_bytes,
                      uint32_t timestamp,
                      int64_t time_complete_ms)
       : size_bytes(size_bytes),
         timestamp(timestamp),
         time_complete_ms(time_complete_ms) {}
@@ skipping 37 matching lines @@
   memset(send_statistics_, 0, sizeof(send_statistics_));
   memset(incoming_frame_times_, -1, sizeof(incoming_frame_times_));
 }
 
 MediaOptimization::~MediaOptimization(void) {
   loss_prot_logic_->Release();
 }
 
 void MediaOptimization::Reset() {
   CriticalSectionScoped lock(crit_sect_.get());
-  SetEncodingDataInternal(
-      kVideoCodecUnknown, 0, 0, 0, 0, 0, 0, max_payload_size_);
+  SetEncodingDataInternal(kVideoCodecUnknown, 0, 0, 0, 0, 0, 0,
+                          max_payload_size_);
   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;
@@ skipping 12 matching lines @@
 
 void MediaOptimization::SetEncodingData(VideoCodecType send_codec_type,
                                         int32_t max_bit_rate,
                                         uint32_t target_bitrate,
                                         uint16_t width,
                                         uint16_t height,
                                         uint32_t frame_rate,
                                         int num_layers,
                                         int32_t mtu) {
   CriticalSectionScoped lock(crit_sect_.get());
-  SetEncodingDataInternal(send_codec_type,
-                          max_bit_rate,
-                          frame_rate,
-                          target_bitrate,
-                          width,
-                          height,
-                          num_layers,
-                          mtu);
+  SetEncodingDataInternal(send_codec_type, max_bit_rate, frame_rate,
+                          target_bitrate, width, height, num_layers, mtu);
 }
 
 void MediaOptimization::SetEncodingDataInternal(VideoCodecType send_codec_type,
                                                 int32_t max_bit_rate,
                                                 uint32_t frame_rate,
                                                 uint32_t target_bitrate,
                                                 uint16_t width,
                                                 uint16_t height,
                                                 int num_layers,
                                                 int32_t mtu) {
@@ skipping 13 matching lines @@
   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_);
+  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());
   VCMProtectionMethod* selected_method = loss_prot_logic_->SelectedMethod();
@@ skipping 41 matching lines @@
     loss_prot_logic_->UpdateMethod();
 
     // Update protection callback with protection settings.
     uint32_t sent_video_rate_bps = 0;
     uint32_t sent_nack_rate_bps = 0;
     uint32_t sent_fec_rate_bps = 0;
     // Get the bit cost of protection method, based on the amount of
     // overhead data actually transmitted (including headers) the last
     // second.
     if (protection_callback) {
-      UpdateProtectionCallback(selected_method,
-                               &sent_video_rate_bps,
-                               &sent_nack_rate_bps,
-                               &sent_fec_rate_bps,
+      UpdateProtectionCallback(selected_method, &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_rate =
           static_cast<float>(sent_nack_rate_bps + sent_fec_rate_bps) /
           sent_total_rate_bps;
@@ skipping 16 matching lines @@
     video_target_bitrate_ = max_bit_rate_;
   }
 
   // Update encoding rates following protection settings.
   float target_video_bitrate_kbps =
       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_);
+    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();
@@ skipping 194 matching lines @@
   }
 }
 
 void MediaOptimization::UpdateSentBitrate(int64_t now_ms) {
   if (encoded_frame_samples_.empty()) {
     avg_sent_bit_rate_bps_ = 0;
     return;
   }
   size_t framesize_sum = 0;
   for (FrameSampleList::iterator it = encoded_frame_samples_.begin();
-       it != encoded_frame_samples_.end();
-       ++it) {
+       it != encoded_frame_samples_.end(); ++it) {
     framesize_sum += it->size_bytes;
   }
   float denom = static_cast<float>(
       now_ms - encoded_frame_samples_.front().time_complete_ms);
   if (denom >= 1.0f) {
     avg_sent_bit_rate_bps_ =
         static_cast<uint32_t>(framesize_sum * 8.0f * 1000.0f / denom + 0.5f);
   } else {
     avg_sent_bit_rate_bps_ = framesize_sum * 8;
   }
@@ skipping 29 matching lines @@
     memset(incoming_frame_times_, -1, sizeof(incoming_frame_times_));
   }
 
   // Check for change in frame size.
   if (qm->change_resolution_spatial) {
     codec_width_ = qm->codec_width;
     codec_height_ = qm->codec_height;
   }
 
   LOG(LS_INFO) << "Media optimizer requests the video resolution to be changed "
-                  "to " << qm->codec_width << "x" << qm->codec_height << "@"
+                  "to "
+               << qm->codec_width << "x" << qm->codec_height << "@"
                << qm->frame_rate;
 
   // Update VPM with new target frame rate and frame size.
   // Note: use |qm->frame_rate| instead of |_incoming_frame_rate| for updating
   // target frame rate in VPM frame dropper. The quantity |_incoming_frame_rate|
   // will vary/fluctuate, and since we don't want to change the state of the
   // VPM frame dropper, unless a temporal action was selected, we use the
   // quantity |qm->frame_rate| for updating.
-  video_qmsettings_callback->SetVideoQMSettings(
-      qm->frame_rate, codec_width_, codec_height_);
+  video_qmsettings_callback->SetVideoQMSettings(qm->frame_rate, codec_width_,
+                                                codec_height_);
   content_->UpdateFrameRate(qm->frame_rate);
-  qm_resolution_->UpdateCodecParameters(
-      qm->frame_rate, codec_width_, codec_height_);
+  qm_resolution_->UpdateCodecParameters(qm->frame_rate, codec_width_,
+                                        codec_height_);
   return true;
 }
 
 // Check timing constraints and look for significant change in:
 // (1) scene content,
 // (2) target bit rate.
 bool MediaOptimization::CheckStatusForQMchange() {
   bool status = true;
 
   // Check that we do not call QMSelect too often, and that we waited some time
@@ skipping 47 matching lines @@
       if (video_target_bitrate_ >
           suspension_threshold_bps_ + suspension_window_bps_) {
         video_suspended_ = false;
       }
     }
   }
 }
 
 }  // namespace media_optimization
 }  // namespace webrtc