Android: enable H264&VP8 HW accelerator for MediaRecorder

content/renderer/media_recorder/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_recorder/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 29 matching lines @@
 // backwards compatibility for legacy applications using the library.
 #define VPX_CODEC_DISABLE_COMPAT 1
 #include "third_party/libvpx/source/libvpx/vpx/vp8cx.h"
 #include "third_party/libvpx/source/libvpx/vpx/vpx_encoder.h"
 }
 
 using media::VideoFrame;
 using media::VideoFrameMetadata;
 using video_track_recorder::kVEAEncoderMinResolutionWidth;
 using video_track_recorder::kVEAEncoderMinResolutionHeight;
+using video_track_recorder::kVEAEncoderMinResolutionWidthAndroid;
+using video_track_recorder::kVEAEncoderMinResolutionHeightAndroid;
 
 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;
 
 using CodecId = VideoTrackRecorder::CodecId;
 
 static const struct {
   CodecId codec_id;
   media::VideoCodecProfile min_profile;
   media::VideoCodecProfile max_profile;
 } kPreferredCodecIdAndVEAProfiles[] = {
     {CodecId::VP8, media::VP8PROFILE_MIN, media::VP8PROFILE_MAX},
     {CodecId::VP9, media::VP9PROFILE_MIN, media::VP9PROFILE_MAX},
-#if BUILDFLAG(RTC_USE_H264)
+#if BUILDFLAG(RTC_USE_H264) || defined(OS_ANDROID)
     {CodecId::H264, media::H264PROFILE_MIN, media::H264PROFILE_MAX}
 #endif
 };
 
 static_assert(arraysize(kPreferredCodecIdAndVEAProfiles) ==
                   static_cast<int>(CodecId::LAST),
               "|kPreferredCodecIdAndVEAProfiles| should consider all CodecIds");
 
 // Class to encapsulate the enumeration of CodecIds/VideoCodecProfiles supported
 // by the VEA underlying platform. Provides methods to query the preferred
@@ skipping 22 matching lines @@
   static CodecEnumerator* enumerator = new CodecEnumerator();
   return enumerator;
 }
 
 CodecEnumerator::CodecEnumerator() {
 #if defined(OS_CHROMEOS)
   // See https://crbug.com/616659.
   return;
 #endif
 
-#if defined(OS_ANDROID)
-  // See https://crbug.com/653864.
-  return;
-#endif
-
   content::RenderThreadImpl* const render_thread_impl =
       content::RenderThreadImpl::current();
   if (!render_thread_impl) {
     DVLOG(2) << "Couldn't access the render thread";
     return;
   }
 
   media::GpuVideoAcceleratorFactories* const gpu_factories =
       render_thread_impl->GetGpuFactories();
   if (!gpu_factories || !gpu_factories->IsGpuVideoAcceleratorEnabled()) {
@@ skipping 22 matching lines @@
   return codec_id_to_profile_.begin()->first;
 }
 
 media::VideoCodecProfile CodecEnumerator::CodecIdToVEAProfile(CodecId codec) {
   const auto profile = codec_id_to_profile_.find(codec);
   return profile == codec_id_to_profile_.end()
              ? media::VIDEO_CODEC_PROFILE_UNKNOWN
              : profile->second;
 }
 
+bool IsFrameSizeBiggerThanVEAEncoderMinResolution(const gfx::Size& input_size) {
+#if !defined(OS_ANDROID)
+  if (input_size.width() >= input_size.height()) {
+    return input_size.width() >= kVEAEncoderMinResolutionWidth &&
+           input_size.height() >= kVEAEncoderMinResolutionHeight;
+  } else {
+    return input_size.height() >= kVEAEncoderMinResolutionWidth &&
+           input_size.width() >= kVEAEncoderMinResolutionHeight;
+  }
+#else
+  return input_size.width() >= kVEAEncoderMinResolutionWidthAndroid &&
+         input_size.height() >= kVEAEncoderMinResolutionHeightAndroid;
+#endif
+}
+
 }  // anonymous namespace
 
 // Base class to describe a generic Encoder, encapsulating all actual encoder
 // (re)configurations, encoding and delivery of received frames. This class is
 // ref-counted to allow the MediaStreamVideoTrack to hold a reference to it (via
 // the callback that MediaStreamVideoSink passes along) and to jump back and
 // forth to an internal encoder thread. Moreover, this class:
 // - is created on its parent's thread (usually the main Render thread),
 // that is, |main_task_runner_|.
 // - receives VideoFrames on |origin_task_runner_| and runs OnEncodedVideoCB on
@@ skipping 421 matching lines @@
     media::VideoCodecProfile codec,
     const gfx::Size& size)
     : Encoder(on_encoded_video_callback,
               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,
                             this, size));
 }
 
 VEAEncoder::~VEAEncoder() {
   base::WaitableEvent release_waiter(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
@@ skipping 110 matching lines @@
   }
 
   // Lower resolutions may fall back to SW encoder in some platforms, i.e. Mac.
   // In that case, the encoder expects more frames before returning result.
   // Therefore, a copy is necessary to release the current frame.
   // Only STORAGE_SHMEM backed frames can be shared with GPU process, therefore
   // a copy is required for other storage types.
   scoped_refptr<media::VideoFrame> video_frame = frame;
   if (video_frame->storage_type() != VideoFrame::STORAGE_SHMEM ||
       vea_requested_input_coded_size_ != frame->coded_size() ||
-      input_visible_size_.width() < kVEAEncoderMinResolutionWidth ||
-      input_visible_size_.height() < kVEAEncoderMinResolutionHeight) {
+      !IsFrameSizeBiggerThanVEAEncoderMinResolution(input_visible_size_)) {
     // Create SharedMemory backed input buffers as necessary. These SharedMemory
     // instances will be shared with GPU process.
     std::unique_ptr<base::SharedMemory> input_buffer;
     const size_t desired_mapped_size = media::VideoFrame::AllocationSize(
         media::PIXEL_FORMAT_I420, vea_requested_input_coded_size_);
     if (input_buffers_.empty()) {
       input_buffer = gpu_factories_->CreateSharedMemory(desired_mapped_size);
     } else {
       do {
         input_buffer = std::move(input_buffers_.front());
@@ skipping 552 matching lines @@
   // sink to initialize, https://crbug.com/698441.
   if (encoder_)
     return;
 
   MediaStreamVideoSink::DisconnectFromTrack();
 
   const gfx::Size& input_size = frame->visible_rect().size();
   const auto& vea_supported_profile =
       GetCodecEnumerator()->CodecIdToVEAProfile(codec);
   if (vea_supported_profile != media::VIDEO_CODEC_PROFILE_UNKNOWN &&
-      input_size.width() >= kVEAEncoderMinResolutionWidth &&
-      input_size.height() >= kVEAEncoderMinResolutionHeight) {
+      IsFrameSizeBiggerThanVEAEncoderMinResolution(input_size)) {
     encoder_ = new VEAEncoder(on_encoded_video_callback, bits_per_second,
                               vea_supported_profile, input_size);
   } else {
     switch (codec) {
 #if BUILDFLAG(RTC_USE_H264)
       case CodecId::H264:
         encoder_ =
             new H264Encoder(on_encoded_video_callback, bits_per_second);
         break;
 #endif
@@ skipping 16 matching lines @@
       base::Bind(&VideoTrackRecorder::Encoder::StartFrameEncode, encoder_),
       false);
 }
 
 bool VideoTrackRecorder::CanEncodeAlphaChannelForTesting() {
   DCHECK(encoder_);
   return encoder_->CanEncodeAlphaChannel();
 }
 
 }  // namespace content