Merge 56: Specify a default bitrate for VEAEncoder

content/renderer/media/video_track_recorder.cc

 // Copyright 2015 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 "content/renderer/media/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 34 matching lines @@
 
 using media::VideoFrame;
 using media::VideoFrameMetadata;
 using video_track_recorder::kVEAEncoderMinResolutionWidth;
 using video_track_recorder::kVEAEncoderMinResolutionHeight;
 
 namespace content {
 
 namespace {
 
+// HW encoders expect a nonzero bitrate, so |kVEADefaultBitratePerPixel| is used
+// to estimate bits per second for ~30 fps with ~1/16 compression rate.
+const int kVEADefaultBitratePerPixel = 2;
+// Number of output buffers used to copy the encoded data coming from HW
+// encoders.
 const int kVEAEncoderOutputBufferCount = 4;
 
 static struct {
   VideoTrackRecorder::CodecId codec_id;
   media::VideoCodecProfile min_profile;
   media::VideoCodecProfile max_profile;
 } const kSupportedVideoCodecIdToProfile[] = {
     {VideoTrackRecorder::CodecId::VP8,
      media::VP8PROFILE_MIN,
      media::VP8PROFILE_MAX},
@@ skipping 430 matching lines @@
 };
 
 #endif  // #if BUILDFLAG(RTC_USE_H264)
 
 VEAEncoder::VEAEncoder(
     const VideoTrackRecorder::OnEncodedVideoCB& on_encoded_video_callback,
     int32_t bits_per_second,
     media::VideoCodecProfile codec,
     const gfx::Size& size)
     : Encoder(on_encoded_video_callback,
-              bits_per_second,
+              bits_per_second > 0 ? bits_per_second
+                                  : size.GetArea() * kVEADefaultBitratePerPixel,
               RenderThreadImpl::current()->GetGpuFactories()->GetTaskRunner()),
       gpu_factories_(RenderThreadImpl::current()->GetGpuFactories()),
       codec_(codec),
       error_notified_(false) {
   DCHECK(gpu_factories_);
   DCHECK_GE(size.width(), kVEAEncoderMinResolutionWidth);
   DCHECK_GE(size.height(), kVEAEncoderMinResolutionHeight);
 
   encoding_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VEAEncoder::ConfigureEncoderOnEncodingTaskRunner,
@@ skipping 162 matching lines @@
   encoding_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&media::VideoEncodeAccelerator::Encode,
                  base::Unretained(video_encoder_.get()), video_frame, false));
 }
 
 void VEAEncoder::ConfigureEncoderOnEncodingTaskRunner(const gfx::Size& size) {
   DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   DCHECK(gpu_factories_->GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK_GT(bits_per_second_, 0);
 
   input_size_ = size;
   video_encoder_ = gpu_factories_->CreateVideoEncodeAccelerator();
   if (!video_encoder_ ||
       !video_encoder_->Initialize(media::PIXEL_FORMAT_I420, input_size_, codec_,
                                   bits_per_second_, this)) {
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
   }
 }
 
@@ skipping 451 matching lines @@
     encoder_->SetPaused(paused_before_init_);
 
   // StartFrameEncode() will be called on Render IO thread.
   MediaStreamVideoSink::ConnectToTrack(
       track_,
       base::Bind(&VideoTrackRecorder::Encoder::StartFrameEncode, encoder_),
       false);
 }
 
 }  // namespace content