Media Capabilities encoding: wire the hardware encoding support

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 314 matching lines @@
 
 bool VideoTrackRecorder::Encoder::CanEncodeAlphaChannel() {
   return false;
 }
 
 // static
 VideoTrackRecorder::CodecId VideoTrackRecorder::GetPreferredCodecId() {
   return GetCodecEnumerator()->GetPreferredCodecId();
 }
 
+// static
+bool VideoTrackRecorder::CanUseAcceleratedEncoder(CodecId codec,
+                                                  size_t width,
+                                                  size_t height) {
+  return GetCodecEnumerator()->CodecIdToVEAProfile(codec) !=
+             media::VIDEO_CODEC_PROFILE_UNKNOWN &&
+         width >= kVEAEncoderMinResolutionWidth &&
+         height >= kVEAEncoderMinResolutionHeight;
+}
+
 VideoTrackRecorder::VideoTrackRecorder(
     CodecId codec,
     const blink::WebMediaStreamTrack& track,
     const OnEncodedVideoCB& on_encoded_video_callback,
     int32_t bits_per_second)
     : track_(track),
       paused_before_init_(false),
       weak_ptr_factory_(this) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!track_.IsNull());
@@ skipping 58 matching lines @@
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 
   // Avoid reinitializing |encoder_| when there are multiple frames sent to the
   // 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 (allow_vea_encoder &&
-      vea_supported_profile != media::VIDEO_CODEC_PROFILE_UNKNOWN &&
-      input_size.width() >= kVEAEncoderMinResolutionWidth &&
-      input_size.height() >= kVEAEncoderMinResolutionHeight) {
+  if (allow_vea_encoder && CanUseAcceleratedEncoder(codec, input_size.width(),
+                                                    input_size.height())) {
+    const auto vea_profile = GetCodecEnumerator()->CodecIdToVEAProfile(codec);
     encoder_ = new VEAEncoder(
         on_encoded_video_callback,
         media::BindToCurrentLoop(base::Bind(&VideoTrackRecorder::OnError,
                                             weak_ptr_factory_.GetWeakPtr())),
-        bits_per_second, vea_supported_profile, input_size);
+        bits_per_second, vea_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
       case CodecId::VP8:
       case CodecId::VP9:
@@ skipping 24 matching lines @@
   MediaStreamVideoSink::DisconnectFromTrack();
   encoder_ = nullptr;
   MediaStreamVideoSink::ConnectToTrack(
       track_,
       media::BindToCurrentLoop(base::Bind(initialize_encoder_callback_,
                                           false /*allow_vea_encoder*/)),
       false);
 }
 
 }  // namespace content