Media Capabilities encoding: wire the hardware encoding support

content/renderer/media_recorder/media_recorder_handler.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/media_recorder_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
+#include "base/sys_info.h"
 #include "content/child/scoped_web_callbacks.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/media_recorder/audio_track_recorder.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/mime_util.h"
 #include "media/base/video_frame.h"
 #include "media/muxers/webm_muxer.h"
 #include "third_party/WebKit/public/platform/WebMediaRecorderHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/modules/media_capabilities/WebMediaConfiguration.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using base::ToLowerASCII;
 
 namespace content {
 
 using blink::WebMediaCapabilitiesQueryCallbacks;
 
 namespace {
 
+// Encoding smoothness depends on a number of parameters, namely: frame rate,
+// resolution, hardware support availability, platform and IsLowEndDevice(); to
+// simplify calculations we compare the amount of pixels per second (i.e.
+// resolution times frame rate). Software based encoding on Desktop can run
+// fine up and until HD resolution at 30fps, whereas if IsLowEndDevice() we set
+// the cut at VGA at 30fps (~27Mpps and ~9Mpps respectively).
+// TODO(mcasas): The influence of the frame rate is not exactly linear, so this
+// threshold might be oversimplified, https://crbug.com/709181.
+const float kNumPixelsPerSecondSmoothnessThresholdLow = 640 * 480 * 30.0;
+const float kNumPixelsPerSecondSmoothnessThresholdHigh = 1280 * 720 * 30.0;
+
 media::VideoCodec CodecIdToMediaVideoCodec(VideoTrackRecorder::CodecId id) {
   switch (id) {
     case VideoTrackRecorder::CodecId::VP8:
       return media::kCodecVP8;
     case VideoTrackRecorder::CodecId::VP9:
       return media::kCodecVP9;
 #if BUILDFLAG(RTC_USE_H264)
     case VideoTrackRecorder::CodecId::H264:
       return media::kCodecH264;
 #endif
     case VideoTrackRecorder::CodecId::LAST:
       return media::kUnknownVideoCodec;
   }
   NOTREACHED() << "Unsupported codec";
   return media::kUnknownVideoCodec;
 }
 
+// Extracts the first recognised CodecId of |codecs| or CodecId::LAST if none
+// of them is known.
+VideoTrackRecorder::CodecId StringToCodecId(const blink::WebString& codecs) {
+  const std::string& codecs_str = ToLowerASCII(codecs.Utf8());
+
+  if (codecs_str.find("vp8") != std::string::npos)
+    return VideoTrackRecorder::CodecId::VP8;
+  else if (codecs_str.find("vp9") != std::string::npos)
+    return VideoTrackRecorder::CodecId::VP9;
+#if BUILDFLAG(RTC_USE_H264)
+  else if (codecs_str.find("h264") != std::string::npos ||
+           codecs_str.find("avc1") != std::string::npos)
+    return VideoTrackRecorder::CodecId::H264;
+#endif
+  return VideoTrackRecorder::CodecId::LAST;
+}
+
 void OnEncodingInfoError(
     std::unique_ptr<WebMediaCapabilitiesQueryCallbacks> callbacks) {
   callbacks->OnError();
 }
 
 }  // anonymous namespace
 
 MediaRecorderHandler::MediaRecorderHandler()
     : video_bits_per_second_(0),
       audio_bits_per_second_(0),
@@ skipping 62 matching lines @@
   // Save histogram data so we can see how much MediaStream Recorder is used.
   // The histogram counts the number of calls to the JS API.
   UpdateWebRTCMethodCount(WEBKIT_MEDIA_STREAM_RECORDER);
 
   if (!CanSupportMimeType(type, codecs)) {
     DLOG(ERROR) << "Unsupported " << type.Utf8() << ";codecs=" << codecs.Utf8();
     return false;
   }
 
   // Once established that we support the codec(s), hunt then individually.
-  const std::string& codecs_str = ToLowerASCII(codecs.Utf8());
-  if (codecs_str.find("vp8") != std::string::npos)
-    codec_id_ = VideoTrackRecorder::CodecId::VP8;
-  else if (codecs_str.find("vp9") != std::string::npos)
-    codec_id_ = VideoTrackRecorder::CodecId::VP9;
-#if BUILDFLAG(RTC_USE_H264)
-  else if (codecs_str.find("h264") != std::string::npos)
-    codec_id_ = VideoTrackRecorder::CodecId::H264;
-  else if (codecs_str.find("avc1") != std::string::npos)
-    codec_id_ = VideoTrackRecorder::CodecId::H264;
-#endif
-  else
-    codec_id_ = VideoTrackRecorder::GetPreferredCodecId();
+  const VideoTrackRecorder::CodecId codec_id = StringToCodecId(codecs);
+  codec_id_ = (codec_id != VideoTrackRecorder::CodecId::LAST)
+                  ? codec_id
+                  : VideoTrackRecorder::GetPreferredCodecId();
 
-  DVLOG_IF(1, codecs_str.empty()) << "Falling back to preferred codec id "
-                                  << static_cast<int>(codec_id_);
+  DVLOG_IF(1, codec_id == VideoTrackRecorder::CodecId::LAST)
+      << "Falling back to preferred codec id " << static_cast<int>(codec_id_);
 
   media_stream_ = media_stream;
   DCHECK(client);
   client_ = client;
 
   audio_bits_per_second_ = audio_bits_per_second;
   video_bits_per_second_ = video_bits_per_second;
   return true;
 }
 
@@ skipping 129 matching lines @@
   blink::WebString mime_type;
   blink::WebString codec;
   if (configuration.video_configuration) {
     mime_type = configuration.video_configuration->mime_type;
     codec = configuration.video_configuration->codec;
   } else {
     mime_type = configuration.audio_configuration->mime_type;
     codec = configuration.audio_configuration->codec;
   }
 
-  // See RFC 2231. https://tools.ietf.org/html/rfc2231
   info->supported = CanSupportMimeType(mime_type, codec);
-  DVLOG(1) << "type: " << mime_type.Ascii() << ", codec:" << codec.Ascii()
-           << " is" << (info->supported ? " supported" : " NOT supported");
+
+  if (configuration.video_configuration && info->supported) {
+    const bool is_likely_accelerated =
+        VideoTrackRecorder::CanUseAcceleratedEncoder(
+            StringToCodecId(codec), configuration.video_configuration->width,
+            configuration.video_configuration->height);
+
+    const float pixels_per_second =
+        configuration.video_configuration->width *
+        configuration.video_configuration->height *
+        configuration.video_configuration->framerate;
+    // Encoding is considered |smooth| up and until the pixels per second
+    // threshold or if it's likely to be accelerated.
+    const float threshold = base::SysInfo::IsLowEndDevice()
+                                ? kNumPixelsPerSecondSmoothnessThresholdLow
+                                : kNumPixelsPerSecondSmoothnessThresholdHigh;
+    info->smooth = is_likely_accelerated || pixels_per_second <= threshold;
+
+    // TODO(mcasas): revisit what |power_efficient| means
+    // https://crbug.com/709181.
+    info->power_efficient = info->smooth;
+  }
+  DVLOG(1) << "type: " << mime_type.Ascii() << ", params:" << codec.Ascii()
+           << " is" << (info->supported ? " supported" : " NOT supported")
+           << " and" << (info->smooth ? " smooth" : " NOT smooth");
 
   scoped_callbacks.PassCallbacks()->OnSuccess(std::move(info));
 }
 
 void MediaRecorderHandler::OnEncodedVideo(
     const media::WebmMuxer::VideoParameters& params,
     std::unique_ptr<std::string> encoded_data,
     std::unique_ptr<std::string> encoded_alpha,
     TimeTicks timestamp,
     bool is_key_frame) {
@@ skipping 99 matching lines @@
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (const auto& recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content