Revert of Refactoring: Merge VideoSenderConfig and AudioSenderConfig.

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 <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
+#include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/common/chrome_switches.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_utils.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/base/audio_bus.h"
 #include "media/base/audio_converter.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "ui/gfx/geometry/size.h"
 
-using media::cast::FrameSenderConfig;
+using media::cast::AudioSenderConfig;
+using media::cast::VideoSenderConfig;
 
 namespace {
 
+const char kCodecNameOpus[] = "OPUS";
+const char kCodecNameVp8[] = "VP8";
+const char kCodecNameH264[] = "H264";
+
+// To convert from kilobits per second to bits to per second.
+const int kBitrateMultiplier = 1000;
+
 // The maximum number of milliseconds that should elapse since the last video
 // frame was received from the video source, before requesting refresh frames.
 const int kRefreshIntervalMilliseconds = 250;
 
 // The maximum number of refresh video frames to request/receive.  After this
 // limit (60 * 250ms = 15 seconds), refresh frame requests will stop being made.
 const int kMaxConsecutiveRefreshFrames = 60;
 
-FrameSenderConfig DefaultOpusConfig() {
-  FrameSenderConfig config;
-  config.rtp_payload_type = media::cast::RtpPayloadType::AUDIO_OPUS;
-  config.sender_ssrc = 1;
-  config.receiver_ssrc = 2;
-  config.rtp_timebase = media::cast::kDefaultAudioSamplingRate;
-  config.channels = 2;
+CastRtpPayloadParams DefaultOpusPayload() {
+  CastRtpPayloadParams payload;
+  payload.payload_type = media::cast::RtpPayloadType::AUDIO_OPUS;
+  payload.max_latency_ms = media::cast::kDefaultRtpMaxDelayMs;
+  payload.ssrc = 1;
+  payload.feedback_ssrc = 2;
+  payload.clock_rate = media::cast::kDefaultAudioSamplingRate;
   // The value is 0 which means VBR.
-  config.min_bitrate = config.max_bitrate = config.start_bitrate =
+  payload.min_bitrate = payload.max_bitrate =
       media::cast::kDefaultAudioEncoderBitrate;
-  config.max_frame_rate = 100;  // 10 ms audio frames
-  config.codec = media::cast::CODEC_AUDIO_OPUS;
-  return config;
-}
-
-FrameSenderConfig DefaultVp8Config() {
-  FrameSenderConfig config;
-  config.rtp_payload_type = media::cast::RtpPayloadType::VIDEO_VP8;
-  config.sender_ssrc = 11;
-  config.receiver_ssrc = 12;
-  config.rtp_timebase = media::cast::kVideoFrequency;
-  config.channels = 1;
-  config.max_bitrate = media::cast::kDefaultMaxVideoBitrate;
-  config.min_bitrate = media::cast::kDefaultMinVideoBitrate;
-  config.max_frame_rate = media::cast::kDefaultMaxFrameRate;
-  config.codec = media::cast::CODEC_VIDEO_VP8;
-  return config;
-}
-
-FrameSenderConfig DefaultH264Config() {
-  FrameSenderConfig config;
-  config.rtp_payload_type = media::cast::RtpPayloadType::VIDEO_H264;
-  config.sender_ssrc = 11;
-  config.receiver_ssrc = 12;
-  config.rtp_timebase = media::cast::kVideoFrequency;
-  config.channels = 1;
-  config.max_bitrate = media::cast::kDefaultMaxVideoBitrate;
-  config.min_bitrate = media::cast::kDefaultMinVideoBitrate;
-  config.max_frame_rate = media::cast::kDefaultMaxFrameRate;
-  config.codec = media::cast::CODEC_VIDEO_H264;
-  return config;
-}
-
-std::vector<FrameSenderConfig> SupportedAudioConfigs() {
+  payload.channels = 2;
+  payload.max_frame_rate = 100;  // 10 ms audio frames
+  payload.codec_name = kCodecNameOpus;
+  return payload;
+}
+
+CastRtpPayloadParams DefaultVp8Payload() {
+  CastRtpPayloadParams payload;
+  payload.payload_type = media::cast::RtpPayloadType::VIDEO_VP8;
+  payload.max_latency_ms = media::cast::kDefaultRtpMaxDelayMs;
+  payload.ssrc = 11;
+  payload.feedback_ssrc = 12;
+  payload.clock_rate = media::cast::kVideoFrequency;
+  payload.max_bitrate = media::cast::kDefaultMaxVideoKbps;
+  payload.min_bitrate = media::cast::kDefaultMinVideoKbps;
+  payload.channels = 1;
+  payload.max_frame_rate = media::cast::kDefaultMaxFrameRate;
+  payload.codec_name = kCodecNameVp8;
+  return payload;
+}
+
+CastRtpPayloadParams DefaultH264Payload() {
+  CastRtpPayloadParams payload;
+  payload.payload_type = media::cast::RtpPayloadType::VIDEO_H264;
+  payload.max_latency_ms = media::cast::kDefaultRtpMaxDelayMs;
+  payload.ssrc = 11;
+  payload.feedback_ssrc = 12;
+  payload.clock_rate = media::cast::kVideoFrequency;
+  payload.max_bitrate = media::cast::kDefaultMaxVideoKbps;
+  payload.min_bitrate = media::cast::kDefaultMinVideoKbps;
+  payload.channels = 1;
+  payload.max_frame_rate = media::cast::kDefaultMaxFrameRate;
+  payload.codec_name = kCodecNameH264;
+  return payload;
+}
+
+bool IsHardwareVP8EncodingSupported() {
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableCastStreamingHWEncoding)) {
+    DVLOG(1) << "Disabled hardware VP8 support for Cast Streaming.";
+    return false;
+  }
+
+  // Query for hardware VP8 encoder support.
+  const std::vector<media::VideoEncodeAccelerator::SupportedProfile>
+      vea_profiles = content::GetSupportedVideoEncodeAcceleratorProfiles();
+  for (const auto& vea_profile : vea_profiles) {
+    if (vea_profile.profile >= media::VP8PROFILE_MIN &&
+        vea_profile.profile <= media::VP8PROFILE_MAX) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool IsHardwareH264EncodingSupported() {
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableCastStreamingHWEncoding)) {
+    DVLOG(1) << "Disabled hardware h264 support for Cast Streaming.";
+    return false;
+  }
+
+  // Query for hardware H.264 encoder support.
+  //
+  // TODO(miu): Look into why H.264 hardware encoder on MacOS is broken.
+  // http://crbug.com/596674
+#if !defined(OS_MACOSX)
+  const std::vector<media::VideoEncodeAccelerator::SupportedProfile>
+      vea_profiles = content::GetSupportedVideoEncodeAcceleratorProfiles();
+  for (const auto& vea_profile : vea_profiles) {
+    if (vea_profile.profile >= media::H264PROFILE_MIN &&
+        vea_profile.profile <= media::H264PROFILE_MAX) {
+      return true;
+    }
+  }
+#endif  // !defined(OS_MACOSX)
+  return false;
+}
+
+int NumberOfEncodeThreads() {
+  // Do not saturate CPU utilization just for encoding. On a lower-end system
+  // with only 1 or 2 cores, use only one thread for encoding. On systems with
+  // more cores, allow half of the cores to be used for encoding.
+  return std::min(8, (base::SysInfo::NumberOfProcessors() + 1) / 2);
+}
+
+std::vector<CastRtpParams> SupportedAudioParams() {
   // TODO(hclam): Fill in more codecs here.
-  return std::vector<FrameSenderConfig>(1, DefaultOpusConfig());
-}
-
-std::vector<FrameSenderConfig> SupportedVideoConfigs() {
-  std::vector<FrameSenderConfig> supported_configs;
+  return std::vector<CastRtpParams>(1, CastRtpParams(DefaultOpusPayload()));
+}
+
+std::vector<CastRtpParams> SupportedVideoParams() {
+  std::vector<CastRtpParams> supported_params;
 
   // Prefer VP8 over H.264 for hardware encoder.
-  if (CastRtpStream::IsHardwareVP8EncodingSupported())
-    supported_configs.push_back(DefaultVp8Config());
-  if (CastRtpStream::IsHardwareH264EncodingSupported())
-    supported_configs.push_back(DefaultH264Config());
+  if (IsHardwareVP8EncodingSupported())
+    supported_params.push_back(CastRtpParams(DefaultVp8Payload()));
+  if (IsHardwareH264EncodingSupported())
+    supported_params.push_back(CastRtpParams(DefaultH264Payload()));
 
   // Propose the default software VP8 encoder, if no hardware encoders are
   // available.
-  if (supported_configs.empty())
-    supported_configs.push_back(DefaultVp8Config());
-
-  return supported_configs;
+  if (supported_params.empty())
+    supported_params.push_back(CastRtpParams(DefaultVp8Payload()));
+
+  return supported_params;
+}
+
+bool ToAudioSenderConfig(const CastRtpParams& params,
+                         AudioSenderConfig* config) {
+  config->ssrc = params.payload.ssrc;
+  config->receiver_ssrc = params.payload.feedback_ssrc;
+  if (config->ssrc == config->receiver_ssrc) {
+    DVLOG(1) << "ssrc " << config->ssrc << " cannot be equal to receiver_ssrc";
+    return false;
+  }
+  config->min_playout_delay = base::TimeDelta::FromMilliseconds(
+                                  params.payload.min_latency_ms ?
+                                  params.payload.min_latency_ms :
+                                  params.payload.max_latency_ms);
+  config->max_playout_delay =
+      base::TimeDelta::FromMilliseconds(params.payload.max_latency_ms);
+  config->animated_playout_delay = base::TimeDelta::FromMilliseconds(
+      params.payload.animated_latency_ms ? params.payload.animated_latency_ms
+                                         : params.payload.max_latency_ms);
+  if (config->min_playout_delay <= base::TimeDelta()) {
+    DVLOG(1) << "min_playout_delay " << config->min_playout_delay
+             << " is too small";
+    return false;
+  }
+  if (config->min_playout_delay > config->max_playout_delay) {
+    DVLOG(1) << "min_playout_delay " << config->min_playout_delay
+             << " is too big";
+    return false;
+  }
+  if (config->animated_playout_delay < config->min_playout_delay ||
+      config->animated_playout_delay > config->max_playout_delay) {
+    DVLOG(1) << "animated_playout_delay " << config->animated_playout_delay
+             << " is out of range";
+    return false;
+  }
+  config->rtp_payload_type = params.payload.payload_type;
+  config->use_external_encoder = false;
+  config->frequency = params.payload.clock_rate;
+  // Sampling rate must be one of the Opus-supported values.
+  switch (config->frequency) {
+    case 48000:
+    case 24000:
+    case 16000:
+    case 12000:
+    case 8000:
+      break;
+    default:
+      DVLOG(1) << "frequency " << config->frequency << " is invalid";
+      return false;
+  }
+  config->channels = params.payload.channels;
+  if (config->channels < 1) {
+    DVLOG(1) << "channels " << config->channels << " is invalid";
+    return false;
+  }
+  config->bitrate = params.payload.max_bitrate * kBitrateMultiplier;
+  if (params.payload.codec_name == kCodecNameOpus) {
+    config->codec = media::cast::CODEC_AUDIO_OPUS;
+  } else {
+    DVLOG(1) << "codec_name " << params.payload.codec_name << " is invalid";
+    return false;
+  }
+  config->aes_key = params.payload.aes_key;
+  config->aes_iv_mask = params.payload.aes_iv_mask;
+  return true;
+}
+
+bool ToVideoSenderConfig(const CastRtpParams& params,
+                         VideoSenderConfig* config) {
+  config->ssrc = params.payload.ssrc;
+  config->receiver_ssrc = params.payload.feedback_ssrc;
+  if (config->ssrc == config->receiver_ssrc) {
+    DVLOG(1) << "ssrc " << config->ssrc << " cannot be equal to receiver_ssrc";
+    return false;
+  }
+  config->min_playout_delay = base::TimeDelta::FromMilliseconds(
+                                  params.payload.min_latency_ms ?
+                                  params.payload.min_latency_ms :
+                                  params.payload.max_latency_ms);
+  config->max_playout_delay =
+      base::TimeDelta::FromMilliseconds(params.payload.max_latency_ms);
+  config->animated_playout_delay = base::TimeDelta::FromMilliseconds(
+      params.payload.animated_latency_ms ? params.payload.animated_latency_ms
+                                         : params.payload.max_latency_ms);
+  if (config->min_playout_delay <= base::TimeDelta()) {
+    DVLOG(1) << "min_playout_delay " << config->min_playout_delay
+             << " is too small";
+    return false;
+  }
+  if (config->min_playout_delay > config->max_playout_delay) {
+    DVLOG(1) << "min_playout_delay " << config->min_playout_delay
+             << " is too big";
+    return false;
+  }
+  if (config->animated_playout_delay < config->min_playout_delay ||
+      config->animated_playout_delay > config->max_playout_delay) {
+    DVLOG(1) << "animated_playout_delay " << config->animated_playout_delay
+             << " is out of range";
+    return false;
+  }
+  config->rtp_payload_type = params.payload.payload_type;
+  config->min_bitrate = config->start_bitrate =
+      params.payload.min_bitrate * kBitrateMultiplier;
+  config->max_bitrate = params.payload.max_bitrate * kBitrateMultiplier;
+  if (config->min_bitrate > config->max_bitrate) {
+    DVLOG(1) << "min_bitrate " << config->min_bitrate << " is larger than "
+             << "max_bitrate " << config->max_bitrate;
+    return false;
+  }
+  config->start_bitrate = config->min_bitrate;
+  config->max_frame_rate = static_cast<int>(
+      std::max(1.0, params.payload.max_frame_rate) + 0.5);
+  if (config->max_frame_rate > media::limits::kMaxFramesPerSecond) {
+    DVLOG(1) << "max_frame_rate " << config->max_frame_rate << " is invalid";
+    return false;
+  }
+  if (params.payload.codec_name == kCodecNameVp8) {
+    config->use_external_encoder = IsHardwareVP8EncodingSupported();
+    config->codec = media::cast::CODEC_VIDEO_VP8;
+  } else if (params.payload.codec_name == kCodecNameH264) {
+    config->use_external_encoder = IsHardwareH264EncodingSupported();
+    config->codec = media::cast::CODEC_VIDEO_H264;
+  } else {
+    DVLOG(1) << "codec_name " << params.payload.codec_name << " is invalid";
+    return false;
+  }
+  if (!config->use_external_encoder)
+    config->number_of_encode_threads = NumberOfEncodeThreads();
+  config->aes_key = params.payload.aes_key;
+  config->aes_iv_mask = params.payload.aes_iv_mask;
+  return true;
 }
 
 }  // namespace
 
 // This class receives MediaStreamTrack events and video frames from a
 // MediaStreamVideoTrack.  It also includes a timer to request refresh frames
 // when the capturer halts (e.g., a screen capturer stops delivering frames
 // because the screen is not being updated).  When a halt is detected, refresh
 // frames will be requested at regular intervals for a short period of time.
 // This provides the video encoder, downstream, several copies of the last frame
@@ skipping 264 matching lines @@
   // These members are accessed on the real-time audio time only.
   media::AudioParameters input_params_;
   std::unique_ptr<media::AudioConverter> converter_;
   const media::AudioBus* current_input_bus_;
   int64_t sample_frames_in_;
   int64_t sample_frames_out_;
 
   DISALLOW_COPY_AND_ASSIGN(CastAudioSink);
 };
 
-bool CastRtpStream::IsHardwareVP8EncodingSupported() {
-  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-  if (cmd_line->HasSwitch(switches::kDisableCastStreamingHWEncoding)) {
-    DVLOG(1) << "Disabled hardware VP8 support for Cast Streaming.";
-    return false;
-  }
+CastRtpParams::CastRtpParams(const CastRtpPayloadParams& payload_params)
+    : payload(payload_params) {}
 
-  // Query for hardware VP8 encoder support.
-  const std::vector<media::VideoEncodeAccelerator::SupportedProfile>
-      vea_profiles = content::GetSupportedVideoEncodeAcceleratorProfiles();
-  for (const auto& vea_profile : vea_profiles) {
-    if (vea_profile.profile >= media::VP8PROFILE_MIN &&
-        vea_profile.profile <= media::VP8PROFILE_MAX) {
-      return true;
-    }
-  }
-  return false;
-}
+CastCodecSpecificParams::CastCodecSpecificParams() {}
 
-bool CastRtpStream::IsHardwareH264EncodingSupported() {
-  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-  if (cmd_line->HasSwitch(switches::kDisableCastStreamingHWEncoding)) {
-    DVLOG(1) << "Disabled hardware h264 support for Cast Streaming.";
-    return false;
-  }
+CastCodecSpecificParams::~CastCodecSpecificParams() {}
 
-// Query for hardware H.264 encoder support.
-//
-// TODO(miu): Look into why H.264 hardware encoder on MacOS is broken.
-// http://crbug.com/596674
-#if !defined(OS_MACOSX)
-  const std::vector<media::VideoEncodeAccelerator::SupportedProfile>
-      vea_profiles = content::GetSupportedVideoEncodeAcceleratorProfiles();
-  for (const auto& vea_profile : vea_profiles) {
-    if (vea_profile.profile >= media::H264PROFILE_MIN &&
-        vea_profile.profile <= media::H264PROFILE_MAX) {
-      return true;
-    }
-  }
-#endif  // !defined(OS_MACOSX)
-  return false;
-}
+CastRtpPayloadParams::CastRtpPayloadParams()
+    : payload_type(media::cast::RtpPayloadType::UNKNOWN),
+      max_latency_ms(0),
+      min_latency_ms(0),
+      ssrc(0),
+      feedback_ssrc(0),
+      clock_rate(0),
+      max_bitrate(0),
+      min_bitrate(0),
+      channels(0),
+      max_frame_rate(0.0) {}
+
+CastRtpPayloadParams::CastRtpPayloadParams(const CastRtpPayloadParams& other) =
+    default;
+
+CastRtpPayloadParams::~CastRtpPayloadParams() {}
+
+CastRtpParams::CastRtpParams() {}
+
+CastRtpParams::CastRtpParams(const CastRtpParams& other) = default;
+
+CastRtpParams::~CastRtpParams() {}
 
 CastRtpStream::CastRtpStream(const blink::WebMediaStreamTrack& track,
                              const scoped_refptr<CastSession>& session)
     : track_(track), cast_session_(session), weak_factory_(this) {}
 
 CastRtpStream::~CastRtpStream() {
   Stop();
 }
 
-std::vector<FrameSenderConfig> CastRtpStream::GetSupportedConfigs() {
+std::vector<CastRtpParams> CastRtpStream::GetSupportedParams() {
   if (IsAudio())
-    return SupportedAudioConfigs();
+    return SupportedAudioParams();
   else
-    return SupportedVideoConfigs();
+    return SupportedVideoParams();
 }
 
-void CastRtpStream::Start(const FrameSenderConfig& config,
+CastRtpParams CastRtpStream::GetParams() { return params_; }
+
+void CastRtpStream::Start(const CastRtpParams& params,
                           const base::Closure& start_callback,
                           const base::Closure& stop_callback,
                           const ErrorCallback& error_callback) {
   DCHECK(!start_callback.is_null());
   DCHECK(!stop_callback.is_null());
   DCHECK(!error_callback.is_null());
 
   DVLOG(1) << "CastRtpStream::Start = " << (IsAudio() ? "audio" : "video");
   stop_callback_ = stop_callback;
   error_callback_ = error_callback;
 
   if (IsAudio()) {
+    AudioSenderConfig config;
+    if (!ToAudioSenderConfig(params, &config)) {
+      DidEncounterError("Invalid parameters for audio.");
+      return;
+    }
+
     // In case of error we have to go through DidEncounterError() to stop
     // the streaming after reporting the error.
-    audio_sink_.reset(
-        new CastAudioSink(track_, config.channels, config.rtp_timebase));
+    audio_sink_.reset(new CastAudioSink(
+        track_,
+        params.payload.channels,
+        params.payload.clock_rate));
     cast_session_->StartAudio(
         config,
         base::Bind(&CastAudioSink::AddToTrack, audio_sink_->AsWeakPtr()),
         base::Bind(&CastRtpStream::DidEncounterError,
                    weak_factory_.GetWeakPtr()));
     start_callback.Run();
   } else {
+    VideoSenderConfig config;
+    if (!ToVideoSenderConfig(params, &config)) {
+      DidEncounterError("Invalid parameters for video.");
+      return;
+    }
     // See the code for audio above for explanation of callbacks.
     video_sink_.reset(new CastVideoSink(
         track_,
         media::BindToCurrentLoop(base::Bind(&CastRtpStream::DidEncounterError,
                                             weak_factory_.GetWeakPtr()))));
     cast_session_->StartVideo(
         config, base::Bind(&CastVideoSink::AddToTrack, video_sink_->AsWeakPtr(),
-                           !config.aes_key.empty()),
+                           !params.payload.aes_key.empty()),
         base::Bind(&CastRtpStream::DidEncounterError,
                    weak_factory_.GetWeakPtr()));
     start_callback.Run();
   }
 }
 
 void CastRtpStream::Stop() {
   DVLOG(1) << "CastRtpStream::Stop = " << (IsAudio() ? "audio" : "video");
   if (stop_callback_.is_null())
     return;  // Already stopped.
@@ skipping 34 matching lines @@
   DCHECK(content::RenderThread::Get());
   DVLOG(1) << "CastRtpStream::DidEncounterError(" << message << ") = "
            << (IsAudio() ? "audio" : "video");
   // Save the WeakPtr first because the error callback might delete this object.
   base::WeakPtr<CastRtpStream> ptr = weak_factory_.GetWeakPtr();
   error_callback_.Run(message);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&CastRtpStream::Stop, ptr));
 }