Remove unused members in MediaOptimization.

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 19 matching lines @@
         time_complete_ms(time_complete_ms) {}
 
   size_t size_bytes;
   uint32_t timestamp;
   int64_t time_complete_ms;
 };
 
 MediaOptimization::MediaOptimization(Clock* clock)
     : clock_(clock),
       max_bit_rate_(0),
-      codec_width_(0),
-      codec_height_(0),
       user_frame_rate_(0),
       frame_dropper_(new FrameDropper),
-      send_statistics_zero_encode_(0),
-      max_payload_size_(1460),
       video_target_bitrate_(0),
       incoming_frame_rate_(0),
       encoded_frame_samples_(),
-      avg_sent_framerate_(0),
-      num_layers_(0) {
-  memset(send_statistics_, 0, sizeof(send_statistics_));
+      avg_sent_framerate_(0) {
   memset(incoming_frame_times_, -1, sizeof(incoming_frame_times_));
 }
 
 MediaOptimization::~MediaOptimization(void) {
 }
 
 void MediaOptimization::Reset() {
   rtc::CritScope lock(&crit_sect_);
-  SetEncodingDataInternal(0, 0, 0, 0, 0, 0, max_payload_size_);
+  SetEncodingDataInternal(0, 0, 0);
   memset(incoming_frame_times_, -1, sizeof(incoming_frame_times_));
   incoming_frame_rate_ = 0.0;
   frame_dropper_->Reset();
   frame_dropper_->SetRates(0, 0);
-  send_statistics_zero_encode_ = 0;
   video_target_bitrate_ = 0;
-  codec_width_ = 0;
-  codec_height_ = 0;
   user_frame_rate_ = 0;
   encoded_frame_samples_.clear();
-  num_layers_ = 1;
 }
 
 void MediaOptimization::SetEncodingData(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) {
+                                        uint32_t frame_rate) {
   rtc::CritScope lock(&crit_sect_);
-  SetEncodingDataInternal(max_bit_rate, frame_rate, target_bitrate, width,
-                          height, num_layers, mtu);
+  SetEncodingDataInternal(max_bit_rate, frame_rate, target_bitrate);
 }
 
 void MediaOptimization::SetEncodingDataInternal(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) {
+                                                uint32_t target_bitrate) {
   // Everything codec specific should be reset here since this means the codec
   // has changed.
-
   max_bit_rate_ = max_bit_rate;
   video_target_bitrate_ = target_bitrate;
   float target_bitrate_kbps = static_cast<float>(target_bitrate) / 1000.0f;
   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;
 }
 
 uint32_t MediaOptimization::SetTargetRates(uint32_t target_bitrate) {
   rtc::CritScope lock(&crit_sect_);
 
   video_target_bitrate_ = target_bitrate;
 
   // Cap target video bitrate to codec maximum.
   if (max_bit_rate_ > 0 && video_target_bitrate_ > max_bit_rate_) {
     video_target_bitrate_ = max_bit_rate_;
@@ skipping 124 matching lines @@
     avg_sent_framerate_ = encoded_frame_samples_.size();
   }
 }
 
 // Allowing VCM to keep track of incoming frame rate.
 void MediaOptimization::ProcessIncomingFrameRate(int64_t now) {
   int32_t num = 0;
   int32_t nr_of_frames = 0;
   for (num = 1; num < (kFrameCountHistorySize - 1); ++num) {
     if (incoming_frame_times_[num] <= 0 ||
-        // don't use data older than 2 s
+        // Don't use data older than 2 s.
         now - incoming_frame_times_[num] > kFrameHistoryWinMs) {
       break;
     } else {
       nr_of_frames++;
     }
   }
   if (num > 1) {
     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);
     }
   }
 }
 }  // namespace media_optimization
 }  // namespace webrtc