Cast: Use 2 threads for encoding on capable systems

chrome/renderer/media/cast_rtp_stream.cc

 // Copyright 2013 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 "chrome/renderer/media/cast_rtp_stream.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sys_info.h"
 #include "chrome/renderer/media/cast_session.h"
 #include "chrome/renderer/media/cast_udp_transport.h"
 #include "content/public/renderer/media_stream_audio_sink.h"
 #include "content/public/renderer/media_stream_video_sink.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/video_encode_accelerator.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_fifo.h"
 #include "media/base/bind_to_current_loop.h"
@@ skipping 88 matching lines @@
       content::GetSupportedVideoEncodeAcceleratorProfiles();
   for (size_t i = 0; i < vea_profiles.size(); ++i) {
     if (vea_profiles[i].profile >= media::H264PROFILE_MIN &&
         vea_profiles[i].profile <= media::H264PROFILE_MAX) {
       return true;
     }
   }
   return false;
 }
 
+int NumberOfEncodeThreads() {
+  // We want to give CPU cycles for capturing and not to saturate the system
+  // just for encoding. So on a lower end system with only 1 or 2 cores we
+  // use only one thread for encoding.
+  if (base::SysInfo::NumberOfProcessors() <= 2)
+    return 1;
+
+  // On higher end we want to use 2 threads for encoding to reduce latency.
+  // In theory a physical CPU core has maximum 2 hyperthreads. Having 3 or
+  // more logical processors means the system has at least 2 physical cores.
+  return 2;

[miu, 2014/04/09 00:53:42]

Unless I'm missing something, the change description should say "2" and not "3."

Also, something to consider: Should we attempt to use a number of encode threads
proportional to the number of pixels?  Meaning,

480p: 2 threads
720p: 3 threads
1080p: 4 threads

+}
+
 std::vector<CastRtpParams> SupportedAudioParams() {
   // TODO(hclam): Fill in more codecs here.
   std::vector<CastRtpParams> supported_params;
   supported_params.push_back(CastRtpParams(DefaultOpusPayload()));
   return supported_params;
 }
 
 std::vector<CastRtpParams> SupportedVideoParams() {
   std::vector<CastRtpParams> supported_params;
   if (IsHardwareH264EncodingSupported())
@@ skipping 32 matching lines @@
   config->max_bitrate = params.payload.max_bitrate * kBitrateMultiplier;
   if (params.payload.codec_name == kCodecNameVp8) {
     config->use_external_encoder = IsHardwareVP8EncodingSupported();
     config->codec = media::cast::transport::kVp8;
   } else if (params.payload.codec_name == kCodecNameH264) {
     config->use_external_encoder = IsHardwareH264EncodingSupported();
     config->codec = media::cast::transport::kH264;
   } else {
     return false;
   }
+  if (!config->use_external_encoder) {
+    config->number_of_encode_threads = NumberOfEncodeThreads();
+  }
   return true;
 }
 
 }  // namespace
 
 // This class receives MediaStreamTrack events and video frames from a
 // MediaStreamTrack. Video frames are submitted to media::cast::FrameInput.
 //
 // Threading: Video frames are received on the render thread.
 class CastVideoSink : public base::SupportsWeakPtr<CastVideoSink>,
@@ skipping 318 matching lines @@
 }
 
 void CastRtpStream::DidEncounterError(const std::string& message) {
   // Save the WeakPtr first because the error callback might delete this object.
   base::WeakPtr<CastRtpStream> ptr = weak_factory_.GetWeakPtr();
   error_callback_.Run(message);
   content::RenderThread::Get()->GetMessageLoop()->PostTask(
       FROM_HERE,
       base::Bind(&CastRtpStream::Stop, ptr));
 }