Simplify BitrateAllocator::AddBitrateObserver.

webrtc/video_engine/vie_encoder.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.
  */
 
 #include "webrtc/video_engine/vie_encoder.h"
 
 #include <assert.h>
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/common_video/interface/video_image.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/frame_callback.h"
+#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/pacing/include/paced_sender.h"
 #include "webrtc/modules/utility/interface/process_thread.h"
 #include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding_defines.h"
 #include "webrtc/modules/video_coding/main/source/encoded_frame.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/metrics.h"
@@ skipping 67 matching lines @@
     owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt);
   }
  private:
   ViEEncoder* owner_;
 };
 
 ViEEncoder::ViEEncoder(int32_t channel_id,
                        uint32_t number_of_cores,
                        ProcessThread& module_process_thread,
                        PacedSender* pacer,
-                       BitrateAllocator* bitrate_allocator,
-                       BitrateController* bitrate_controller)
+                       BitrateAllocator* bitrate_allocator)
     : channel_id_(channel_id),
       number_of_cores_(number_of_cores),
       vpm_(VideoProcessingModule::Create(ViEModuleId(-1, channel_id))),
       qm_callback_(new QMVideoSettingsCallback(vpm_.get())),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      this,
                                      qm_callback_.get())),
       send_payload_router_(NULL),
       callback_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       data_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       pacer_(pacer),
       bitrate_allocator_(bitrate_allocator),
-      bitrate_controller_(bitrate_controller),
       time_of_last_frame_activity_ms_(0),
       simulcast_enabled_(false),
       min_transmit_bitrate_kbps_(0),
       last_observed_bitrate_bps_(0),
       target_delay_ms_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
       fec_enabled_(false),
       nack_enabled_(false),
@@ skipping 129 matching lines @@
     return -1;
   }
 
   {
     CriticalSectionScoped cs(data_cs_.get());
     simulcast_enabled_ = video_codec.numberOfSimulcastStreams > 1;
   }
 
   // Add a bitrate observer to the allocator and update the start, max and
   // min bitrates of the bitrate controller as needed.
-  int allocated_bitrate_bps;
-  int new_bwe_candidate_bps = bitrate_allocator_->AddBitrateObserver(
-      bitrate_observer_.get(), video_codec.startBitrate * 1000,
-      video_codec.minBitrate * 1000, video_codec.maxBitrate * 1000,
-      &allocated_bitrate_bps);
-
-  // Only set the start/min/max bitrate of the bitrate controller if the start
-  // bitrate is greater than zero. The new API sets these via the channel group
-  // and passes a zero start bitrate to SetSendCodec.
-  // TODO(holmer): Remove this when the new API has been launched.
-  if (video_codec.startBitrate > 0) {
-    if (new_bwe_candidate_bps > 0) {
-      uint32_t current_bwe_bps = 0;
-      bitrate_controller_->AvailableBandwidth(&current_bwe_bps);
-      bitrate_controller_->SetStartBitrate(std::max(
-          static_cast<uint32_t>(new_bwe_candidate_bps), current_bwe_bps));
-    }
-
-    int new_bwe_min_bps = 0;
-    int new_bwe_max_bps = 0;
-    bitrate_allocator_->GetMinMaxBitrateSumBps(&new_bwe_min_bps,
-                                               &new_bwe_max_bps);
-    bitrate_controller_->SetMinMaxBitrate(new_bwe_min_bps, new_bwe_max_bps);
-  }
+  int allocated_bitrate_bps = bitrate_allocator_->AddBitrateObserver(
+      bitrate_observer_.get(), video_codec.minBitrate * 1000,
+      video_codec.maxBitrate * 1000);
 
   webrtc::VideoCodec modified_video_codec = video_codec;
   modified_video_codec.startBitrate = allocated_bitrate_bps / 1000;
 
   size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
   if (vcm_->RegisterSendCodec(&modified_video_codec, number_of_cores_,
                               static_cast<uint32_t>(max_data_payload_length)) !=
       VCM_OK) {
     return -1;
   }
@@ skipping 503 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vpm_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vpm_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc