RELAND: MediaRecorder: use VideoTrackRecorder::GetPreferredCodecId() when available

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 42 matching lines @@
 
 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;
+using CodecId = VideoTrackRecorder::CodecId;
+
+static const struct {
+  CodecId codec_id;
   media::VideoCodecProfile min_profile;
   media::VideoCodecProfile max_profile;
-} const kSupportedVideoCodecIdToProfile[] = {
-    {VideoTrackRecorder::CodecId::VP8,
-     media::VP8PROFILE_MIN,
-     media::VP8PROFILE_MAX},
-    {VideoTrackRecorder::CodecId::VP9,
-     media::VP9PROFILE_MIN,
-     media::VP9PROFILE_MAX},
-    {VideoTrackRecorder::CodecId::H264,
-     media::H264PROFILE_MIN,
-     media::H264PROFILE_MAX}};
+} kPreferredCodecIdAndVEAProfiles[] = {
+    {CodecId::VP8, media::VP8PROFILE_MIN, media::VP8PROFILE_MAX},
+    {CodecId::VP9, media::VP9PROFILE_MIN, media::VP9PROFILE_MAX},
+#if BUILDFLAG(RTC_USE_H264)
+    {CodecId::H264, media::H264PROFILE_MIN, media::H264PROFILE_MAX}
+#endif
+};
 
-// Returns the corresponding codec profile from VEA supported codecs. If no
-// profile is found, returns VIDEO_CODEC_PROFILE_UNKNOWN.
-media::VideoCodecProfile CodecIdToVEAProfile(
-    content::VideoTrackRecorder::CodecId codec) {
+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
+// CodecId and to check if a given CodecId is supported.
+class CodecEnumerator {
+ public:
+  CodecEnumerator();
+  ~CodecEnumerator() = default;
+
+  // Returns the first CodecId that has an associated VEA VideoCodecProfile, or
+  // VP8 if none available.
+  CodecId GetPreferredCodecId();
+
+  // Returns the VEA VideoCodedProfile for a given CodecId, if supported, or
+  // VIDEO_CODEC_PROFILE_UNKNOWN otherwise.
+  media::VideoCodecProfile CodecIdToVEAProfile(CodecId codec);
+
+ private:
+  // A map of VEA-supported CodecId-and-VEA-profile pairs.
+  std::map<CodecId, media::VideoCodecProfile> codec_id_to_profile_;
+
+  DISALLOW_COPY_AND_ASSIGN(CodecEnumerator);
+};
+
+static base::LazyInstance<CodecEnumerator>::Leaky g_codec_enumerator =
+    LAZY_INSTANCE_INITIALIZER;
+
+CodecEnumerator::CodecEnumerator() {
+#if defined(OS_CHROMEOS)
   // See https://crbug.com/616659.
-#if defined(OS_CHROMEOS)
-  return media::VIDEO_CODEC_PROFILE_UNKNOWN;
-#endif  // defined(OS_CHROMEOS)
+  return;
+#endif
 
-// See https://crbug.com/653864.
 #if defined(OS_ANDROID)
-  return media::VIDEO_CODEC_PROFILE_UNKNOWN;
-#endif  // defined(OS_ANDROID)
+  // See https://crbug.com/653864.
+  return;
+#endif
 
   content::RenderThreadImpl* const render_thread_impl =
       content::RenderThreadImpl::current();
   if (!render_thread_impl) {
-    DVLOG(3) << "Couldn't access the render thread";
-    return media::VIDEO_CODEC_PROFILE_UNKNOWN;
+    DVLOG(2) << "Couldn't access the render thread";
+    return;
   }
 
   media::GpuVideoAcceleratorFactories* const gpu_factories =
       render_thread_impl->GetGpuFactories();
   if (!gpu_factories || !gpu_factories->IsGpuVideoAcceleratorEnabled()) {
-    DVLOG(3) << "Couldn't initialize GpuVideoAcceleratorFactories";
-    return media::VIDEO_CODEC_PROFILE_UNKNOWN;
+    DVLOG(2) << "Couldn't initialize GpuVideoAcceleratorFactories";
+    return;
   }
 
-  const media::VideoEncodeAccelerator::SupportedProfiles& vea_profiles =
+  const auto vea_supported_profiles =
       gpu_factories->GetVideoEncodeAcceleratorSupportedProfiles();
-  for (const auto& vea_profile : vea_profiles) {
-    for (const auto& supported_profile : kSupportedVideoCodecIdToProfile) {
-      if (codec == supported_profile.codec_id &&
-          vea_profile.profile >= supported_profile.min_profile &&
-          vea_profile.profile <= supported_profile.max_profile)
-        return vea_profile.profile;
+  for (const auto& supported_profile : vea_supported_profiles) {
+    for (auto& codec_id_and_profile : kPreferredCodecIdAndVEAProfiles) {
+      if (supported_profile.profile >= codec_id_and_profile.min_profile &&
+          supported_profile.profile <= codec_id_and_profile.max_profile) {
+        DVLOG(2) << "Accelerated codec found: "
+                 << media::GetProfileName(supported_profile.profile);
+        codec_id_to_profile_.insert(std::make_pair(
+            codec_id_and_profile.codec_id, supported_profile.profile));
+      }
     }
   }
-  return media::VIDEO_CODEC_PROFILE_UNKNOWN;
+}
+
+CodecId CodecEnumerator::GetPreferredCodecId() {
+  if (codec_id_to_profile_.empty())
+    return CodecId::VP8;
+  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;
 }
 
 }  // 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),
@@ skipping 941 matching lines @@
     return;
   }
 
   int pixel_format = EVideoFormatType::videoFormatI420;
   openh264_encoder_->SetOption(ENCODER_OPTION_DATAFORMAT, &pixel_format);
 }
 #endif //#if BUILDFLAG(RTC_USE_H264)
 
 }  // anonymous namespace
 
+// static
+VideoTrackRecorder::CodecId VideoTrackRecorder::GetPreferredCodecId() {
+  return g_codec_enumerator.Get().GetPreferredCodecId();
+}
+
 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 48 matching lines @@
     const OnEncodedVideoCB& on_encoded_video_callback,
     int32_t bits_per_second,
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks capture_time) {
   DVLOG(3) << __func__ << frame->visible_rect().size().ToString();
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 
   MediaStreamVideoSink::DisconnectFromTrack();
 
   const gfx::Size& input_size = frame->visible_rect().size();
-  const auto& vea_supported_profile = CodecIdToVEAProfile(codec);
+  const auto& vea_supported_profile =
+      g_codec_enumerator.Get().CodecIdToVEAProfile(codec);
   if (vea_supported_profile != media::VIDEO_CODEC_PROFILE_UNKNOWN &&
       input_size.width() >= kVEAEncoderMinResolutionWidth &&
       input_size.height() >= kVEAEncoderMinResolutionHeight) {
     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
       case CodecId::VP8:
       case CodecId::VP9:
         encoder_ = new VpxEncoder(codec == CodecId::VP9,
                                   on_encoded_video_callback, bits_per_second);
         break;
       default:
-        NOTREACHED() << "Unsupported codec";
+        NOTREACHED() << "Unsupported codec " << static_cast<int>(codec);
     }
   }
 
   if (paused_before_init_)
     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