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"
@@ skipping 23 matching lines @@
     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);
+
+    // 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 |framerate|). Software based
+    // encoding on Desktop can run fine up and until HD resolution at 30fps,
+    // whereas if IsLowEndDevice() we set the cut at VGA (note that either pixel
+    // volumes would make use of hardware acceleration if available).
+    const float kNumPixelsPerSecondSmoothnessThreshold =
+        base::SysInfo::IsLowEndDevice() ? 640 * 480 * 30.0 : 1280 * 720 * 30.0;

[emircan, 2017/05/01 17:12:29]

Can we define this as constant at the top of this file? It would be easier with
naming.

[mcasas, 2017/05/01 20:18:44]

Done.

+    const float pixels_per_second =
+        configuration.video_configuration->width *
+        configuration.video_configuration->height *
+        configuration.video_configuration->framerate;
+    info->smooth = is_likely_accelerated ||
+                   pixels_per_second <= kNumPixelsPerSecondSmoothnessThreshold;
+
+    // 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