Fix BitrateAdjuster issues in VTVideoEncodeAccelerator

media/gpu/vt_video_encode_accelerator_mac.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/gpu/vt_video_encode_accelerator_mac.h"
 
 #include <memory>
 
 #include "base/mac/mac_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 54 matching lines @@
 };
 
 // .5 is set as a minimum to prevent overcompensating for large temporary
 // overshoots. We don't want to degrade video quality too badly.
 // .95 is set to prevent oscillations. When a lower bitrate is set on the
 // encoder than previously set, its output seems to have a brief period of
 // drastically reduced bitrate, so we want to avoid that. In steady state
 // conditions, 0.95 seems to give us better overall bitrate over long periods
 // of time.
 VTVideoEncodeAccelerator::VTVideoEncodeAccelerator()
-    : bitrate_adjuster_(webrtc::Clock::GetRealTimeClock(), .5, .95),
+    : target_bitrate_(0),
+      bitrate_adjuster_(webrtc::Clock::GetRealTimeClock(), .5, .95),
       client_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       encoder_thread_("VTEncoderThread"),
       encoder_task_weak_factory_(this) {
   encoder_weak_ptr_ = encoder_task_weak_factory_.GetWeakPtr();
 }
 
 VTVideoEncodeAccelerator::~VTVideoEncodeAccelerator() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 70 matching lines @@
   if (!base::mac::IsOSMavericksOrLater()) {
     DLOG(ERROR) << "VideoToolbox hardware encoder is supported on Mac OS 10.9 "
                    "and later.";
     return false;
   }
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
   input_visible_size_ = input_visible_size;
   frame_rate_ = kMaxFrameRateNumerator / kMaxFrameRateDenominator;
-  target_bitrate_ = initial_bitrate;
+  initial_bitrate_ = initial_bitrate;
   bitstream_buffer_size_ = input_visible_size.GetArea();
 
   if (!encoder_thread_.Start()) {
     DLOG(ERROR) << "Failed spawning encoder thread.";
     return false;
   }
   encoder_thread_task_runner_ = encoder_thread_.task_runner();
 
   if (!ResetCompressionSession()) {
     DLOG(ERROR) << "Failed creating compression session.";
@@ skipping 99 matching lines @@
     ref_time = base::TimeTicks::Now();
   }
   auto timestamp_cm = CoreMediaGlue::CMTimeMake(
       frame->timestamp().InMicroseconds(), USEC_PER_SEC);
   // Wrap information we'll need after the frame is encoded in a heap object.
   // We'll get the pointer back from the VideoToolbox completion callback.
   std::unique_ptr<InProgressFrameEncode> request(
       new InProgressFrameEncode(frame->timestamp(), ref_time));
 
   // Update the bitrate if needed.
-  RequestEncodingParametersChangeTask(bitrate_adjuster_.GetAdjustedBitrateBps(),
-                                      frame_rate_);
+  SetAdjustedBitrate(bitrate_adjuster_.GetAdjustedBitrateBps());
 
   // We can pass the ownership of |request| to the encode callback if
   // successful. Otherwise let it fall out of scope.
   OSStatus status = videotoolbox_glue_->VTCompressionSessionEncodeFrame(
       compression_session_, pixel_buffer, timestamp_cm,
       CoreMediaGlue::CMTime{0, 0, 0, 0}, frame_props,
       reinterpret_cast<void*>(request.get()), nullptr);
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionEncodeFrame failed: " << status;
     NotifyError(kPlatformFailureError);
@@ skipping 21 matching lines @@
 void VTVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
     uint32_t bitrate,
     uint32_t framerate) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (!compression_session_) {
     NotifyError(kPlatformFailureError);
     return;
   }
 
-  bool rv;
   if (framerate != static_cast<uint32_t>(frame_rate_)) {
-    frame_rate_ = framerate > 1 ? framerate : 1;
     media::video_toolbox::SessionPropertySetter session_property_setter(
         compression_session_, videotoolbox_glue_);
-    rv = session_property_setter.Set(
+    session_property_setter.Set(
         videotoolbox_glue_->kVTCompressionPropertyKey_ExpectedFrameRate(),
         frame_rate_);
-    DLOG_IF(ERROR, !rv)
-        << "Couldn't change frame rate parameters of encode session.";
   }
 
-  if (bitrate != static_cast<uint32_t>(adjusted_bitrate_)) {
-    target_bitrate_ = bitrate > 1 ? bitrate : 1;
+  if (bitrate != static_cast<uint32_t>(target_bitrate_) && bitrate > 0) {
+    target_bitrate_ = bitrate;
     bitrate_adjuster_.SetTargetBitrateBps(target_bitrate_);
-    adjusted_bitrate_ = bitrate_adjuster_.GetAdjustedBitrateBps();
-    media::video_toolbox::SessionPropertySetter session_property_setter(
-        compression_session_, videotoolbox_glue_);
-    rv = session_property_setter.Set(
-        videotoolbox_glue_->kVTCompressionPropertyKey_AverageBitRate(),
-        adjusted_bitrate_);
-    rv &= session_property_setter.Set(
-        videotoolbox_glue_->kVTCompressionPropertyKey_DataRateLimits(),
-        media::video_toolbox::ArrayWithIntegerAndFloat(
-            adjusted_bitrate_ / kBitsPerByte, 1.0f));
-    DLOG_IF(ERROR, !rv)
-        << "Couldn't change bitrate parameters of encode session.";
+    SetAdjustedBitrate(bitrate_adjuster_.GetAdjustedBitrateBps());
   }
 }
 
+void VTVideoEncodeAccelerator::SetAdjustedBitrate(int32_t bitrate) {
+  DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+
+  if (bitrate == encoder_set_bitrate_)
+    return;
+
+  encoder_set_bitrate_ = bitrate;
+  media::video_toolbox::SessionPropertySetter session_property_setter(
+      compression_session_, videotoolbox_glue_);
+  bool rv = session_property_setter.Set(
+      videotoolbox_glue_->kVTCompressionPropertyKey_AverageBitRate(),
+      encoder_set_bitrate_);
+  rv &= session_property_setter.Set(
+      videotoolbox_glue_->kVTCompressionPropertyKey_DataRateLimits(),
+      media::video_toolbox::ArrayWithIntegerAndFloat(
+          encoder_set_bitrate_ / kBitsPerByte, 1.0f));
+  DLOG_IF(ERROR, !rv)
+      << "Couldn't change bitrate parameters of encode session.";
+}
+
 void VTVideoEncodeAccelerator::DestroyTask() {
   DCHECK(thread_checker_.CalledOnValidThread() ||
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   // Cancel all encoder thread callbacks.
   encoder_task_weak_factory_.InvalidateWeakPtrs();
 
   // This call blocks until all pending frames are flushed out.
   DestroyCompressionSession();
@@ skipping 121 matching lines @@
 
   bool session_rv =
       CreateCompressionSession(attributes, input_visible_size_, false);
   if (!session_rv) {
     DestroyCompressionSession();
     return false;
   }
 
   const bool configure_rv = ConfigureCompressionSession();
   if (configure_rv)
-    RequestEncodingParametersChange(target_bitrate_, frame_rate_);
+    RequestEncodingParametersChange(initial_bitrate_, frame_rate_);
   return configure_rv;
 }
 
 bool VTVideoEncodeAccelerator::CreateCompressionSession(
     base::ScopedCFTypeRef<CFDictionaryRef> attributes,
     const gfx::Size& input_size,
     bool require_hw_encoding) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<CFTypeRef> encoder_keys;
@@ skipping 61 matching lines @@
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   if (compression_session_) {
     videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 }  // namespace media