Bitrate controller for VideoToolbox Video Encode Accelerator

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"
 #include "media/base/mac/coremedia_glue.h"
 #include "media/base/mac/corevideo_glue.h"
 #include "media/base/mac/video_frame_mac.h"
+#include "third_party/webrtc/system_wrappers/include/clock.h"
 
 namespace media {
 
 namespace {
 
 // TODO(emircan): Check if we can find the actual system capabilities via
 // creating VTCompressionSessions with varying requirements.
 // See crbug.com/584784.
 const size_t kBitsPerByte = 8;
 const size_t kDefaultResolutionWidth = 640;
@@ skipping 32 matching lines @@
                      size_t size)
       : id(id), shm(std::move(shm)), size(size) {}
   const int32_t id;
   const std::unique_ptr<base::SharedMemory> shm;
   const size_t size;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(BitstreamBufferRef);
 };
 
+// .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()
-    : client_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+    : 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());
 
   Destroy();
@@ skipping 188 matching lines @@
           media::VideoFrameMetadata::REFERENCE_TIME, &ref_time)) {
     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_);
+
   // 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);
   } else {
@@ skipping 15 matching lines @@
   }
 
   bitstream_buffer_queue_.push_back(std::move(buffer_ref));
 }
 
 void VTVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
     uint32_t bitrate,
     uint32_t framerate) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
-  frame_rate_ = framerate > 1 ? framerate : 1;
-  target_bitrate_ = bitrate > 1 ? bitrate : 1;
-
   if (!compression_session_) {
     NotifyError(kPlatformFailureError);
     return;
   }
 
-  media::video_toolbox::SessionPropertySetter session_property_setter(
-      compression_session_, videotoolbox_glue_);
-  // TODO(emircan): See crbug.com/425352.
-  bool rv = session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_AverageBitRate(),
-      target_bitrate_);
-  rv &= session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_ExpectedFrameRate(),
-      frame_rate_);
-  rv &= session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_DataRateLimits(),
-      media::video_toolbox::ArrayWithIntegerAndFloat(
-          target_bitrate_ / kBitsPerByte, 1.0f));
-  DLOG_IF(ERROR, !rv) << "Couldn't change session encoding parameters.";
+  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(
+        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;
+    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.";
+  }
 }
 
 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();
 
@@ skipping 85 matching lines @@
       sample_attachments, CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
 
   size_t used_buffer_size = 0;
   const bool copy_rv = media::video_toolbox::CopySampleBufferToAnnexBBuffer(
       encode_output->sample_buffer.get(), keyframe, buffer_ref->size,
       reinterpret_cast<char*>(buffer_ref->shm->memory()), &used_buffer_size);
   if (!copy_rv) {
     DLOG(ERROR) << "Cannot copy output from SampleBuffer to AnnexBBuffer.";
     used_buffer_size = 0;
   }
+  bitrate_adjuster_.Update(used_buffer_size);
 
   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_,
                             buffer_ref->id, used_buffer_size, keyframe));
 }
 
 bool VTVideoEncodeAccelerator::ResetCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyCompressionSession();
@@ skipping 99 matching lines @@
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   if (compression_session_) {
     videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 }  // namespace media