Refactoring: Merge VideoSenderConfig and AudioSenderConfig.

In the CL: 1) VideoSenderConfig and AudioSenderConfig are merged to
FrameSenderConfig. 2) CastRtpParams is removed . RtpParams is directly
converted to/from FrameSenderConfig.

BUG=530839

Review-Url: https://codereview.chromium.org/2113783002
Cr-Commit-Position: refs/heads/master@{#404520}

chrome/renderer/media/cast_rtp_stream.h

@@ -26,86 +26,6 @@ class CastAudioSink;
 class CastSession;
 class CastVideoSink;
 
-// A key value pair structure for codec specific parameters.
-struct CastCodecSpecificParams {
-  std::string key;
-  std::string value;
-
-  CastCodecSpecificParams();
-  ~CastCodecSpecificParams();
-};
-
-// Defines the basic properties of a payload supported by cast transport.
-struct CastRtpPayloadParams {
-  // RTP specific field that identifies the content type.
-  media::cast::RtpPayloadType payload_type =
-      media::cast::RtpPayloadType::VIDEO_VP8;
-
-  // Maximum latency in milliseconds. Implemetation tries to keep latency
-  // under this threshold.
-  int max_latency_ms = media::cast::kDefaultRtpMaxDelayMs;
-
-  // Minimum latency.
-  // Default value (0) means use max_latency_ms.
-  int min_latency_ms = 0;
-
-  // Starting latency on animated content.
-  // Default value (0) means use max_latency_ms.
-  int animated_latency_ms = 0;
-
-  // RTP specific field to identify a stream.
-  int ssrc = 1;
-
-  // RTP specific field to idenfity the feedback stream.
-  int feedback_ssrc = 2;
-
-  // Update frequency of payload sample.
-  int clock_rate = media::cast::kVideoFrequency;
-
-  // Maximum bitrate in kilobits per second.
-  int max_bitrate = media::cast::kDefaultMaxVideoKbps;
-
-  // Minimum bitrate in kilobits per second.
-  int min_bitrate = media::cast::kDefaultMinVideoKbps;
-
-  // Number of audio channels.
-  int channels = 1;
-
-  // The maximum frame rate.
-  double max_frame_rate = media::cast::kDefaultMaxFrameRate;
-
-  // Name of the codec used.
-  std::string codec_name;
-
-  // AES encryption key.
-  std::string aes_key;
-
-  // AES encryption IV mask.
-  std::string aes_iv_mask;
-
-  // List of codec specific parameters.
-  std::vector<CastCodecSpecificParams> codec_specific_params;
-
-  CastRtpPayloadParams();
-  CastRtpPayloadParams(const CastRtpPayloadParams& other);
-  ~CastRtpPayloadParams();
-};
-
-// Defines the parameters of a RTP stream.
-struct CastRtpParams {
-  explicit CastRtpParams(const CastRtpPayloadParams& payload_params);
-
-  // Payload parameters.
-  CastRtpPayloadParams payload;
-
-  // Names of supported RTCP features.
-  std::vector<std::string> rtcp_features;
-
-  CastRtpParams();
-  CastRtpParams(const CastRtpParams& other);
-  ~CastRtpParams();
-};
-
 // This object represents a RTP stream that encodes and optionally
 // encrypt audio or video data from a WebMediaStreamTrack.
 // Note that this object does not actually output packets. It allows
@@ -115,22 +35,23 @@ class CastRtpStream {
  public:
   typedef base::Callback<void(const std::string&)> ErrorCallback;
 
+  static bool IsHardwareVP8EncodingSupported();
+
+  static bool IsHardwareH264EncodingSupported();
+
   CastRtpStream(const blink::WebMediaStreamTrack& track,
                 const scoped_refptr<CastSession>& session);
   ~CastRtpStream();
 
   // Return parameters currently supported by this stream.
-  std::vector<CastRtpParams> GetSupportedParams();
-
-  // Return parameters set to this stream.
-  CastRtpParams GetParams();
+  std::vector<media::cast::FrameSenderConfig> GetSupportedConfigs();
 
   // Begin encoding of media stream and then submit the encoded streams
   // to underlying transport.
   // When the stream is started |start_callback| is called.
   // When the stream is stopped |stop_callback| is called.
   // When there is an error |error_callback| is called with a message.
-  void Start(const CastRtpParams& params,
+  void Start(const media::cast::FrameSenderConfig& config,
              const base::Closure& start_callback,
              const base::Closure& stop_callback,
              const ErrorCallback& error_callback);
@@ -163,7 +84,6 @@ class CastRtpStream {
   const scoped_refptr<CastSession> cast_session_;
   std::unique_ptr<CastAudioSink> audio_sink_;
   std::unique_ptr<CastVideoSink> video_sink_;
-  CastRtpParams params_;
   base::Closure stop_callback_;
   ErrorCallback error_callback_;
 

chrome/renderer/media/cast_session.cc

@@ -53,7 +53,7 @@ CastSession::~CastSession() {
   CHECK(io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release()));
 }
 
-void CastSession::StartAudio(const media::cast::AudioSenderConfig& config,
+void CastSession::StartAudio(const media::cast::FrameSenderConfig& config,
                              const AudioFrameInputAvailableCallback& callback,
                              const ErrorCallback& error_callback) {
   DCHECK(content::RenderThread::Get());
@@ -67,7 +67,7 @@ void CastSession::StartAudio(const media::cast::AudioSenderConfig& config,
                  media::BindToCurrentLoop(error_callback)));
 }
 
-void CastSession::StartVideo(const media::cast::VideoSenderConfig& config,
+void CastSession::StartVideo(const media::cast::FrameSenderConfig& config,
                              const VideoFrameInputAvailableCallback& callback,
                              const ErrorCallback& error_callback) {
   DCHECK(content::RenderThread::Get());

chrome/renderer/media/cast_session.h

@@ -60,10 +60,10 @@ class CastSession : public base::RefCounted<CastSession> {
   // error message. Both |callback| and |error_callback| will be made on
   // the main thread.
   // |StartUDP()| must be called before these methods.
-  void StartAudio(const media::cast::AudioSenderConfig& config,
+  void StartAudio(const media::cast::FrameSenderConfig& config,
                   const AudioFrameInputAvailableCallback& callback,
                   const ErrorCallback& error_callback);
-  void StartVideo(const media::cast::VideoSenderConfig& config,
+  void StartVideo(const media::cast::FrameSenderConfig& config,
                   const VideoFrameInputAvailableCallback& callback,
                   const ErrorCallback& error_callback);
 

chrome/renderer/media/cast_session_delegate.cc

@@ -29,10 +29,9 @@
 #include "media/cast/net/cast_transport.h"
 #include "media/cast/net/cast_transport_config.h"
 
-using media::cast::AudioSenderConfig;
 using media::cast::CastEnvironment;
 using media::cast::CastSender;
-using media::cast::VideoSenderConfig;
+using media::cast::FrameSenderConfig;
 
 static base::LazyInstance<CastThreads> g_cast_threads =
     LAZY_INSTANCE_INITIALIZER;
@@ -116,7 +115,7 @@ CastSessionDelegate::~CastSessionDelegate() {
 }
 
 void CastSessionDelegate::StartAudio(
-    const AudioSenderConfig& config,
+    const FrameSenderConfig& config,
     const AudioFrameInputAvailableCallback& callback,
     const ErrorCallback& error_callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
@@ -134,7 +133,7 @@ void CastSessionDelegate::StartAudio(
 }
 
 void CastSessionDelegate::StartVideo(
-    const VideoSenderConfig& config,
+    const FrameSenderConfig& config,
     const VideoFrameInputAvailableCallback& callback,
     const ErrorCallback& error_callback,
     const media::cast::CreateVideoEncodeAcceleratorCallback& create_vea_cb,

chrome/renderer/media/cast_session_delegate.h

@@ -104,17 +104,17 @@ class CastSessionDelegate : public CastSessionDelegateBase {
   // deliver any data between calling the two methods.
   // It's OK to call only one of the two methods.
   // StartUDP must be called before these methods.
-  void StartAudio(const media::cast::AudioSenderConfig& config,
+  void StartAudio(const media::cast::FrameSenderConfig& config,
                   const AudioFrameInputAvailableCallback& callback,
                   const ErrorCallback& error_callback);
 
-  void StartVideo(const media::cast::VideoSenderConfig& config,
-                  const VideoFrameInputAvailableCallback& callback,
-                  const ErrorCallback& error_callback,
-                  const media::cast::CreateVideoEncodeAcceleratorCallback&
-                      create_vea_cb,
-                  const media::cast::CreateVideoEncodeMemoryCallback&
-                      create_video_encode_mem_cb);
+  void StartVideo(
+      const media::cast::FrameSenderConfig& config,
+      const VideoFrameInputAvailableCallback& callback,
+      const ErrorCallback& error_callback,
+      const media::cast::CreateVideoEncodeAcceleratorCallback& create_vea_cb,
+      const media::cast::CreateVideoEncodeMemoryCallback&
+          create_video_encode_mem_cb);
 
   void ToggleLogging(bool is_audio, bool enable);
   void GetEventLogsAndReset(bool is_audio,

chrome/test/data/extensions/api_test/cast_streaming/rtp_stream_error.js

@@ -31,19 +31,21 @@ chrome.test.runTests([
                     pass(function(stream, audioId, videoId, udpId) {
         var audioParams = rtpStream.getSupportedParams(audioId)[0];
         var videoParams = rtpStream.getSupportedParams(videoId)[0];
-        rtpStream.onError.addListener(
-            pass(function(audioId, videoId, id, msg) {
-          chrome.test.assertEq(videoId, id);
-          rtpStream.destroy(audioId);
-          rtpStream.destroy(videoId);
-          udpTransport.destroy(udpId);
-          console.log(msg);
-        }.bind(null, audioId, videoId)));
         // Specify invalid value to trigger error.
         videoParams.payload.codecName = "Animated WebP";
         udpTransport.setDestination(udpId,
                                     {address: "127.0.0.1", port: 2344});
-        rtpStream.start(videoId, videoParams);
+        try {
+          rtpStream.start(videoId, videoParams);
+          chrome.test.fail();
+        } catch (e) {
+          rtpStream.stop(audioId);
+          rtpStream.stop(videoId);
+          rtpStream.destroy(audioId);
+          rtpStream.destroy(videoId);
+          udpTransport.destroy(udpId);
+          chrome.test.succeed();
+        }
       }.bind(null, stream)));
     }));
   },

media/cast/cast_config.cc

@@ -4,79 +4,43 @@
 
 #include "media/cast/cast_config.h"
 
-namespace {
-
-const float kDefaultCongestionControlBackOff = 0.875f;
-
-enum {
-  // Minimum and Maximum VP8 quantizer in default configuration.
-  kDefaultMaxQp = 63,
-  kDefaultMinQp = 4,
-
-  kDefaultMaxCpuSaverQp = 25,
-
-  // Number of video buffers in default configuration (applies only to certain
-  // external codecs).
-  kDefaultNumberOfVideoBuffers = 1,
-};
-
-}  // namespace
-
 namespace media {
 namespace cast {
 
-// TODO(miu): Revisit code factoring of these structs.  There are a number of
-// common elements between them all, so it might be reasonable to only have one
-// or two structs; or, at least a common base class.
-
-// TODO(miu): Make sure all POD members are initialized by ctors.  Policy
-// decision: Reasonable defaults or use invalid placeholder values to expose
-// unset members?
-
-// TODO(miu): Provide IsValidConfig() functions?
-
-// TODO(miu): Throughout the code, there is a lot of copy-and-paste of the same
-// calculations based on these config values.  So, why don't we add methods to
-// these classes to centralize the logic?
-
-VideoSenderConfig::VideoSenderConfig()
-    : ssrc(0),
-      receiver_ssrc(0),
-      max_playout_delay(
-          base::TimeDelta::FromMilliseconds(kDefaultRtpMaxDelayMs)),
-      rtp_payload_type(RtpPayloadType::UNKNOWN),
-      use_external_encoder(false),
-      congestion_control_back_off(kDefaultCongestionControlBackOff),
-      max_bitrate(kDefaultMaxVideoKbps * 1000),
-      min_bitrate(kDefaultMinVideoKbps * 1000),
-      start_bitrate(kDefaultMaxVideoKbps * 1000),
-      max_qp(kDefaultMaxQp),
+VideoCodecParams::VideoCodecParams()
+    : max_qp(kDefaultMaxQp),
       min_qp(kDefaultMinQp),
       max_cpu_saver_qp(kDefaultMaxCpuSaverQp),
-      max_frame_rate(kDefaultMaxFrameRate),
       max_number_of_video_buffers_used(kDefaultNumberOfVideoBuffers),
-      codec(CODEC_VIDEO_VP8),
       number_of_encode_threads(1) {}
 
-VideoSenderConfig::VideoSenderConfig(const VideoSenderConfig& other) = default;
+VideoCodecParams::VideoCodecParams(const VideoCodecParams& other) = default;
 
-VideoSenderConfig::~VideoSenderConfig() {}
+VideoCodecParams::~VideoCodecParams() {}
 
-AudioSenderConfig::AudioSenderConfig()
-    : ssrc(0),
+// TODO(miu): Provide IsValidConfig() functions?
+
+FrameSenderConfig::FrameSenderConfig()
+    : sender_ssrc(0),
       receiver_ssrc(0),
+      min_playout_delay(
+          base::TimeDelta::FromMilliseconds(kDefaultRtpMaxDelayMs)),
       max_playout_delay(
           base::TimeDelta::FromMilliseconds(kDefaultRtpMaxDelayMs)),
+      animated_playout_delay(min_playout_delay),
       rtp_payload_type(RtpPayloadType::UNKNOWN),
       use_external_encoder(false),
-      frequency(0),
+      rtp_timebase(0),
       channels(0),
-      bitrate(kDefaultAudioEncoderBitrate),
-      codec(CODEC_AUDIO_OPUS) {}
+      max_bitrate(0),
+      min_bitrate(0),
+      start_bitrate(0),
+      max_frame_rate(kDefaultMaxFrameRate),
+      codec(CODEC_UNKNOWN) {}
 
-AudioSenderConfig::AudioSenderConfig(const AudioSenderConfig& other) = default;
+FrameSenderConfig::FrameSenderConfig(const FrameSenderConfig& other) = default;
 
-AudioSenderConfig::~AudioSenderConfig() {}
+FrameSenderConfig::~FrameSenderConfig() {}
 
 FrameReceiverConfig::FrameReceiverConfig()
     : receiver_ssrc(0),

media/cast/cast_config.h

@@ -46,59 +46,60 @@ enum SuggestedDefaults {
 
   // Suggested minimum and maximum video bitrates for general-purpose use (up to
   // 1080p, 30 FPS).
-  kDefaultMinVideoKbps = 300,
-  kDefaultMaxVideoKbps = 5000,
-};
+  kDefaultMinVideoBitrate = 300000,
+  kDefaultMaxVideoBitrate = 5000000,
 
-// TODO(miu): Merge AudioSenderConfig and VideoSenderConfig and make their
-// naming/documentation consistent with FrameReceiverConfig.
-// http://crbug.com/530839
-struct AudioSenderConfig {
-  AudioSenderConfig();
-  AudioSenderConfig(const AudioSenderConfig& other);
-  ~AudioSenderConfig();
+  // Minimum and Maximum VP8 quantizer in default configuration.
+  kDefaultMaxQp = 63,
+  kDefaultMinQp = 4,
 
-  // Identifier referring to the sender, used by the receiver.
-  uint32_t ssrc;
+  kDefaultMaxCpuSaverQp = 25,
 
-  // The receiver's SSRC identifier.
-  uint32_t receiver_ssrc;
+  // Number of video buffers in default configuration (applies only to certain
+  // external codecs).
+  kDefaultNumberOfVideoBuffers = 1,
+};
 
-  // The total amount of time between a frame's capture/recording on the sender
-  // and its playback on the receiver (i.e., shown to a user).  This should be
-  // set to a value large enough to give the system sufficient time to encode,
-  // transmit/retransmit, receive, decode, and render; given its run-time
-  // environment (sender/receiver hardware performance, network conditions,
-  // etc.).
-  base::TimeDelta min_playout_delay;
-  base::TimeDelta max_playout_delay;
+// These parameters are only for video encoders.
+struct VideoCodecParams {
+  VideoCodecParams();
+  VideoCodecParams(const VideoCodecParams& other);
+  ~VideoCodecParams();
 
-  // Starting playout delay when streaming animated content.
-  base::TimeDelta animated_playout_delay;
+  int max_qp;
+  int min_qp;
 
-  // RTP payload type enum: Specifies the type/encoding of frame data.
-  RtpPayloadType rtp_payload_type;
+  // The maximum |min_quantizer| set to the encoder when CPU is constrained.
+  // This is a trade-off between higher resolution with lower encoding quality
+  // and lower resolution with higher encoding quality. The set value indicates
+  // the maximum quantizer that the encoder might produce better quality video
+  // at this resolution than lowering resolution with similar CPU usage and
+  // smaller quantizer. The set value has to be between |min_qp| and |max_qp|.
+  // Suggested value range: [4, 30]. It is only used by software VP8 codec.
+  int max_cpu_saver_qp;
 
-  bool use_external_encoder;
-  int frequency;
-  int channels;
-  int bitrate;  // Set to <= 0 for "auto variable bitrate" (libopus knows best).
-  Codec codec;
+  // This field is used differently by various encoders.
+  //
+  // It defaults to 1.
+  //
+  // For VP8, this field is ignored.
+  //
+  // For H.264 on Mac or iOS, it controls the max number of frames the encoder
+  // may hold before emitting a frame. A larger window may allow higher encoding
+  // efficiency at the cost of latency and memory. Set to 0 to let the encoder
+  // choose a suitable value for the platform and other encoding settings.
+  int max_number_of_video_buffers_used;
 
-  // The AES crypto key and initialization vector.  Each of these strings
-  // contains the data in binary form, of size kAesKeySize.  If they are empty
-  // strings, crypto is not being used.
-  std::string aes_key;
-  std::string aes_iv_mask;
+  int number_of_encode_threads;
 };
 
-struct VideoSenderConfig {
-  VideoSenderConfig();
-  VideoSenderConfig(const VideoSenderConfig& other);
-  ~VideoSenderConfig();
+struct FrameSenderConfig {
+  FrameSenderConfig();
+  FrameSenderConfig(const FrameSenderConfig& other);
+  ~FrameSenderConfig();
 
-  // Identifier referring to the sender, used by the receiver.
-  uint32_t ssrc;
+  // The sender's SSRC identifier.
+  uint32_t sender_ssrc;
 
   // The receiver's SSRC identifier.
   uint32_t receiver_ssrc;
@@ -118,44 +119,38 @@ struct VideoSenderConfig {
   // RTP payload type enum: Specifies the type/encoding of frame data.
   RtpPayloadType rtp_payload_type;
 
+  // If true, use an external HW encoder rather than the built-in
+  // software-based one.
   bool use_external_encoder;
 
-  float congestion_control_back_off;
+  // RTP timebase: The number of RTP units advanced per one second.  For audio,
+  // this is the sampling rate.  For video, by convention, this is 90 kHz.
+  int rtp_timebase;
+
+  // Number of channels.  For audio, this is normally 2.  For video, this must
+  // be 1 as Cast does not have support for stereoscopic video.
+  int channels;
+
+  // For now, only fixed bitrate is used for audio encoding. So for audio,
+  // |max_bitrate| is used, and the other two will be overriden if they are not
+  // equal to |max_bitrate|.
   int max_bitrate;
   int min_bitrate;
   int start_bitrate;
-  int max_qp;
-  int min_qp;
 
-  // The maximum |min_quantizer| set to the encoder when CPU is constrained.
-  // This is a trade-off between higher resolution with lower encoding quality
-  // and lower resolution with higher encoding quality. The set value indicates
-  // the maximum quantizer that the encoder might produce better quality video
-  // at this resolution than lowering resolution with similar CPU usage and
-  // smaller quantizer. The set value has to be between |min_qp| and |max_qp|.
-  // Suggested value range: [4, 30].
-  int max_cpu_saver_qp;
-
-  int max_frame_rate;  // TODO(miu): Should be double, not int.
-
-  // This field is used differently by various encoders. It defaults to 1.
-  //
-  // For VP8, this field is ignored.
-  //
-  // For H.264 on Mac or iOS, it controls the max number of frames the encoder
-  // may hold before emitting a frame. A larger window may allow higher encoding
-  // efficiency at the cost of latency and memory. Set to 0 to let the encoder
-  // choose a suitable value for the platform and other encoding settings.
-  int max_number_of_video_buffers_used;
+  double max_frame_rate;
 
+  // Codec used for the compression of signal data.
   Codec codec;
-  int number_of_encode_threads;
 
   // The AES crypto key and initialization vector.  Each of these strings
   // contains the data in binary form, of size kAesKeySize.  If they are empty
   // strings, crypto is not being used.
   std::string aes_key;
   std::string aes_iv_mask;
+
+  // These are codec specific parameters for video streams only.
+  VideoCodecParams video_codec_params;
 };
 
 // TODO(miu): Naming and minor type changes are badly needed in a later CL.
@@ -192,7 +187,7 @@ struct FrameReceiverConfig {
   // The target frame rate.  For audio, this is normally 100 (i.e., frames have
   // a duration of 10ms each).  For video, this is normally 30, but any frame
   // rate is supported.
-  int target_frame_rate;
+  double target_frame_rate;
 
   // Codec used for the compression of signal data.
   // TODO(miu): Merge the AudioCodec and VideoCodec enums into one so this union

media/cast/cast_sender.h

@@ -104,7 +104,7 @@ class CastSender {
   // Initialize the audio stack. Must be called in order to send audio frames.
   // |status_change_cb| will be run as operational status changes.
   virtual void InitializeAudio(
-      const AudioSenderConfig& audio_config,
+      const FrameSenderConfig& audio_config,
       const StatusChangeCallback& status_change_cb) = 0;
 
   // Initialize the video stack. Must be called in order to send video frames.
@@ -112,7 +112,7 @@ class CastSender {
   //
   // TODO(miu): Remove the VEA-specific callbacks.  http://crbug.com/454029
   virtual void InitializeVideo(
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb) = 0;

media/cast/cast_sender_impl.cc

@@ -108,7 +108,7 @@ CastSenderImpl::CastSenderImpl(scoped_refptr<CastEnvironment> cast_environment,
 }
 
 void CastSenderImpl::InitializeAudio(
-    const AudioSenderConfig& audio_config,
+    const FrameSenderConfig& audio_config,
     const StatusChangeCallback& status_change_cb) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   CHECK(audio_config.use_external_encoder ||
@@ -130,7 +130,7 @@ void CastSenderImpl::InitializeAudio(
 }
 
 void CastSenderImpl::InitializeVideo(
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb) {

media/cast/cast_sender_impl.h

@@ -27,14 +27,13 @@ class CastSenderImpl : public CastSender {
   CastSenderImpl(scoped_refptr<CastEnvironment> cast_environment,
                  CastTransport* const transport_sender);
 
-  void InitializeAudio(const AudioSenderConfig& audio_config,
+  void InitializeAudio(const FrameSenderConfig& audio_config,
                        const StatusChangeCallback& status_change_cb) final;
   void InitializeVideo(
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
-      const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb)
-      final;
+      const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb) final;
 
   void SetTargetPlayoutDelay(base::TimeDelta new_target_playout_delay) final;
 

media/cast/receiver/frame_receiver.cc

@@ -48,14 +48,15 @@ FrameReceiver::FrameReceiver(
       rtp_timebase_(config.rtp_timebase),
       target_playout_delay_(
           base::TimeDelta::FromMilliseconds(config.rtp_max_delay_ms)),
-      expected_frame_duration_(base::TimeDelta::FromSeconds(1) /
-                               config.target_frame_rate),
+      expected_frame_duration_(
+          base::TimeDelta::FromSecondsD(1.0 / config.target_frame_rate)),
       reports_are_scheduled_(false),
       framer_(cast_environment->Clock(),
               this,
               config.sender_ssrc,
               true,
-              config.rtp_max_delay_ms * config.target_frame_rate / 1000),
+              static_cast<int>(
+                  config.rtp_max_delay_ms * config.target_frame_rate / 1000)),
       rtcp_(cast_environment_->Clock(),
             config.receiver_ssrc,
             config.sender_ssrc),

media/cast/receiver/video_decoder_unittest.cc

@@ -31,8 +31,8 @@ const int kStartingWidth = 360;
 const int kStartingHeight = 240;
 const int kFrameRate = 10;
 
-VideoSenderConfig GetVideoSenderConfigForTest() {
-  VideoSenderConfig config = GetDefaultVideoSenderConfig();
+FrameSenderConfig GetVideoSenderConfigForTest() {
+  FrameSenderConfig config = GetDefaultVideoSenderConfig();
   config.max_frame_rate = kFrameRate;
   return config;
 }

media/cast/sender/audio_sender.cc

@@ -18,31 +18,27 @@ namespace media {
 namespace cast {
 
 AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
-                         const AudioSenderConfig& audio_config,
+                         const FrameSenderConfig& audio_config,
                          const StatusChangeCallback& status_change_cb,
                          CastTransport* const transport_sender)
     : FrameSender(cast_environment,
                   true,
                   transport_sender,
-                  audio_config.frequency,
-                  audio_config.ssrc,
+                  audio_config.rtp_timebase,
+                  audio_config.sender_ssrc,
                   0,  // |max_frame_rate_| is set after encoder initialization.
                   audio_config.min_playout_delay,
                   audio_config.max_playout_delay,
                   audio_config.animated_playout_delay,
-                  NewFixedCongestionControl(audio_config.bitrate)),
+                  NewFixedCongestionControl(audio_config.max_bitrate)),
       samples_in_encoder_(0),
       weak_factory_(this) {
   if (!audio_config.use_external_encoder) {
-    audio_encoder_.reset(
-        new AudioEncoder(cast_environment,
-                         audio_config.channels,
-                         audio_config.frequency,
-                         audio_config.bitrate,
-                         audio_config.codec,
-                         base::Bind(&AudioSender::OnEncodedAudioFrame,
-                                    weak_factory_.GetWeakPtr(),
-                                    audio_config.bitrate)));
+    audio_encoder_.reset(new AudioEncoder(
+        cast_environment, audio_config.channels, audio_config.rtp_timebase,
+        audio_config.max_bitrate, audio_config.codec,
+        base::Bind(&AudioSender::OnEncodedAudioFrame,
+                   weak_factory_.GetWeakPtr(), audio_config.max_bitrate)));
   }
 
   // AudioEncoder provides no operational status changes during normal use.
@@ -59,10 +55,10 @@ AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
   // initialization parameters. Now that we have an encoder, we can calculate
   // the maximum frame rate.
   max_frame_rate_ =
-      audio_config.frequency / audio_encoder_->GetSamplesPerFrame();
+      audio_config.rtp_timebase / audio_encoder_->GetSamplesPerFrame();
 
   media::cast::CastTransportRtpConfig transport_config;
-  transport_config.ssrc = audio_config.ssrc;
+  transport_config.ssrc = audio_config.sender_ssrc;
   transport_config.feedback_ssrc = audio_config.receiver_ssrc;
   transport_config.rtp_payload_type = audio_config.rtp_payload_type;
   transport_config.aes_key = audio_config.aes_key;

media/cast/sender/audio_sender.h

@@ -35,7 +35,7 @@ class AudioSender : public FrameSender,
                     public base::SupportsWeakPtr<AudioSender> {
  public:
   AudioSender(scoped_refptr<CastEnvironment> cast_environment,
-              const AudioSenderConfig& audio_config,
+              const FrameSenderConfig& audio_config,
               const StatusChangeCallback& status_change_cb,
               CastTransport* const transport_sender);
 

media/cast/sender/audio_sender_unittest.cc

@@ -103,9 +103,9 @@ class AudioSenderTest : public ::testing::Test {
                             task_runner_, task_runner_, task_runner_);
     audio_config_.codec = CODEC_AUDIO_OPUS;
     audio_config_.use_external_encoder = false;
-    audio_config_.frequency = kDefaultAudioSamplingRate;
+    audio_config_.rtp_timebase = kDefaultAudioSamplingRate;
     audio_config_.channels = 2;
-    audio_config_.bitrate = kDefaultAudioEncoderBitrate;
+    audio_config_.max_bitrate = kDefaultAudioEncoderBitrate;
     audio_config_.rtp_payload_type = RtpPayloadType::AUDIO_OPUS;
 
     transport_ = new TestPacketSender();
@@ -131,13 +131,13 @@ class AudioSenderTest : public ::testing::Test {
   scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
   std::unique_ptr<AudioSender> audio_sender_;
   scoped_refptr<CastEnvironment> cast_environment_;
-  AudioSenderConfig audio_config_;
+  FrameSenderConfig audio_config_;
 };
 
 TEST_F(AudioSenderTest, Encode20ms) {
   const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20);
   std::unique_ptr<AudioBus> bus(
-      TestAudioBusFactory(audio_config_.channels, audio_config_.frequency,
+      TestAudioBusFactory(audio_config_.channels, audio_config_.rtp_timebase,
                           TestAudioBusFactory::kMiddleANoteFreq, 0.5f)
           .NextAudioBus(kDuration));
 
@@ -150,7 +150,7 @@ TEST_F(AudioSenderTest, Encode20ms) {
 TEST_F(AudioSenderTest, RtcpTimer) {
   const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20);
   std::unique_ptr<AudioBus> bus(
-      TestAudioBusFactory(audio_config_.channels, audio_config_.frequency,
+      TestAudioBusFactory(audio_config_.channels, audio_config_.rtp_timebase,
                           TestAudioBusFactory::kMiddleANoteFreq, 0.5f)
           .NextAudioBus(kDuration));
 

media/cast/sender/external_video_encoder.cc

@@ -124,7 +124,7 @@ class ExternalVideoEncoder::VEAClientImpl
       const scoped_refptr<CastEnvironment>& cast_environment,
       const scoped_refptr<base::SingleThreadTaskRunner>& encoder_task_runner,
       std::unique_ptr<media::VideoEncodeAccelerator> vea,
-      int max_frame_rate,
+      double max_frame_rate,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
       : cast_environment_(cast_environment),
@@ -176,8 +176,8 @@ class ExternalVideoEncoder::VEAClientImpl
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
     requested_bit_rate_ = bit_rate;
-    video_encode_accelerator_->RequestEncodingParametersChange(bit_rate,
-                                                               max_frame_rate_);
+    video_encode_accelerator_->RequestEncodingParametersChange(
+        bit_rate, static_cast<uint32_t>(max_frame_rate_ + 0.5));
   }
 
   // The destruction call back of the copied video frame to free its use of
@@ -592,7 +592,7 @@ class ExternalVideoEncoder::VEAClientImpl
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  const int max_frame_rate_;
+  const double max_frame_rate_;
   const StatusChangeCallback status_change_cb_;  // Must be run on MAIN thread.
   const CreateVideoEncodeMemoryCallback create_video_encode_memory_cb_;
   std::unique_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
@@ -647,7 +647,7 @@ class ExternalVideoEncoder::VEAClientImpl
 };
 
 // static
-bool ExternalVideoEncoder::IsSupported(const VideoSenderConfig& video_config) {
+bool ExternalVideoEncoder::IsSupported(const FrameSenderConfig& video_config) {
   if (video_config.codec != CODEC_VIDEO_VP8 &&
       video_config.codec != CODEC_VIDEO_H264)
     return false;
@@ -661,7 +661,7 @@ bool ExternalVideoEncoder::IsSupported(const VideoSenderConfig& video_config) {
 
 ExternalVideoEncoder::ExternalVideoEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const gfx::Size& frame_size,
     FrameId first_frame_id,
     const StatusChangeCallback& status_change_cb,
@@ -730,7 +730,7 @@ void ExternalVideoEncoder::GenerateKeyFrame() {
 }
 
 void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     FrameId first_frame_id,
     const StatusChangeCallback& status_change_cb,
     scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner,
@@ -782,7 +782,7 @@ void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
 
 SizeAdaptableExternalVideoEncoder::SizeAdaptableExternalVideoEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)

media/cast/sender/external_video_encoder.h

@@ -28,11 +28,11 @@ class ExternalVideoEncoder : public VideoEncoder {
  public:
   // Returns true if the current platform and system configuration supports
   // using ExternalVideoEncoder with the given |video_config|.
-  static bool IsSupported(const VideoSenderConfig& video_config);
+  static bool IsSupported(const FrameSenderConfig& video_config);
 
   ExternalVideoEncoder(
       const scoped_refptr<CastEnvironment>& cast_environment,
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const gfx::Size& frame_size,
       FrameId first_frame_id,
       const StatusChangeCallback& status_change_cb,
@@ -56,7 +56,7 @@ class ExternalVideoEncoder : public VideoEncoder {
   // VEAClientImpl to own and interface with a new |vea|.  Upon return,
   // |client_| holds a reference to the new VEAClientImpl.
   void OnCreateVideoEncodeAccelerator(
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       FrameId first_frame_id,
       const StatusChangeCallback& status_change_cb,
       scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner,
@@ -86,7 +86,7 @@ class SizeAdaptableExternalVideoEncoder : public SizeAdaptableVideoEncoderBase {
  public:
   SizeAdaptableExternalVideoEncoder(
       const scoped_refptr<CastEnvironment>& cast_environment,
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb);

media/cast/sender/fake_software_video_encoder.cc

@@ -18,11 +18,13 @@ namespace media {
 namespace cast {
 
 FakeSoftwareVideoEncoder::FakeSoftwareVideoEncoder(
-    const VideoSenderConfig& video_config)
+    const FrameSenderConfig& video_config)
     : video_config_(video_config),
       next_frame_is_key_(true),
       frame_id_(FrameId::first()),
-      frame_size_(0) {}
+      frame_size_(0) {
+  DCHECK_GT(video_config_.max_frame_rate, 0);
+}
 
 FakeSoftwareVideoEncoder::~FakeSoftwareVideoEncoder() {}
 

media/cast/sender/fake_software_video_encoder.h

@@ -16,7 +16,7 @@ namespace cast {
 
 class FakeSoftwareVideoEncoder : public SoftwareVideoEncoder {
  public:
-  FakeSoftwareVideoEncoder(const VideoSenderConfig& video_config);
+  FakeSoftwareVideoEncoder(const FrameSenderConfig& video_config);
   ~FakeSoftwareVideoEncoder() final;
 
   // SoftwareVideoEncoder implementations.
@@ -28,7 +28,7 @@ class FakeSoftwareVideoEncoder : public SoftwareVideoEncoder {
   void GenerateKeyFrame() final;
 
  private:
-  VideoSenderConfig video_config_;
+  const FrameSenderConfig video_config_;
   gfx::Size last_frame_size_;
   bool next_frame_is_key_;
   FrameId frame_id_;

media/cast/sender/h264_vt_encoder.cc

@@ -147,13 +147,13 @@ class H264VideoToolboxEncoder::VideoFrameFactoryImpl::Proxy
 
 // static
 bool H264VideoToolboxEncoder::IsSupported(
-    const VideoSenderConfig& video_config) {
+    const FrameSenderConfig& video_config) {
   return video_config.codec == CODEC_VIDEO_H264 && VideoToolboxGlue::Get();
 }
 
 H264VideoToolboxEncoder::H264VideoToolboxEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb)
     : cast_environment_(cast_environment),
       videotoolbox_glue_(VideoToolboxGlue::Get()),
@@ -322,7 +322,7 @@ void H264VideoToolboxEncoder::ConfigureCompressionSession() {
       (video_config_.min_bitrate + video_config_.max_bitrate) / 2);
   session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_ExpectedFrameRate(),
-      video_config_.max_frame_rate);
+      static_cast<int>(video_config_.max_frame_rate + 0.5));
   // Keep these attachment settings in-sync with those in Initialize().
   session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_ColorPrimaries(),
@@ -333,10 +333,10 @@ void H264VideoToolboxEncoder::ConfigureCompressionSession() {
   session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_YCbCrMatrix(),
       kCVImageBufferYCbCrMatrix_ITU_R_709_2);
-  if (video_config_.max_number_of_video_buffers_used > 0) {
+  if (video_config_.video_codec_params.max_number_of_video_buffers_used > 0) {
     session_property_setter.Set(
         videotoolbox_glue_->kVTCompressionPropertyKey_MaxFrameDelayCount(),
-        video_config_.max_number_of_video_buffers_used);
+        video_config_.video_codec_params.max_number_of_video_buffers_used);
   }
 }
 

media/cast/sender/h264_vt_encoder.h

@@ -33,11 +33,11 @@ class H264VideoToolboxEncoder : public VideoEncoder,
  public:
   // Returns true if the current platform and system configuration supports
   // using H264VideoToolboxEncoder with the given |video_config|.
-  static bool IsSupported(const VideoSenderConfig& video_config);
+  static bool IsSupported(const FrameSenderConfig& video_config);
 
   H264VideoToolboxEncoder(
       const scoped_refptr<CastEnvironment>& cast_environment,
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb);
   ~H264VideoToolboxEncoder() final;
 
@@ -92,7 +92,7 @@ class H264VideoToolboxEncoder : public VideoEncoder,
   // VideoSenderConfig copy so we can create compression sessions on demand.
   // This is needed to recover from backgrounding and other events that can
   // invalidate compression sessions.
-  const VideoSenderConfig video_config_;
+  const FrameSenderConfig video_config_;
 
   // Frame size of the current compression session. Can be changed by submitting
   // a frame of a different size, which will cause a compression session reset.

media/cast/sender/size_adaptable_video_encoder_base.cc

@@ -15,7 +15,7 @@ namespace cast {
 
 SizeAdaptableVideoEncoderBase::SizeAdaptableVideoEncoderBase(
     const scoped_refptr<CastEnvironment>& cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb)
     : cast_environment_(cast_environment),
       video_config_(video_config),

media/cast/sender/size_adaptable_video_encoder_base.h

@@ -30,7 +30,7 @@ class SizeAdaptableVideoEncoderBase : public VideoEncoder {
  public:
   SizeAdaptableVideoEncoderBase(
       const scoped_refptr<CastEnvironment>& cast_environment,
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb);
 
   ~SizeAdaptableVideoEncoderBase() override;
@@ -50,9 +50,7 @@ class SizeAdaptableVideoEncoderBase : public VideoEncoder {
   CastEnvironment* cast_environment() const {
     return cast_environment_.get();
   }
-  const VideoSenderConfig& video_config() const {
-    return video_config_;
-  }
+  const FrameSenderConfig& video_config() const { return video_config_; }
   const gfx::Size& frame_size() const {
     return frame_size_;
   }
@@ -93,7 +91,7 @@ class SizeAdaptableVideoEncoderBase : public VideoEncoder {
 
   // This is not const since |video_config_.starting_bitrate| is modified by
   // SetBitRate(), for when a replacement encoder is spawned.
-  VideoSenderConfig video_config_;
+  FrameSenderConfig video_config_;
 
   // Run whenever the underlying encoder reports a status change.
   const StatusChangeCallback status_change_cb_;

media/cast/sender/video_encoder.cc

@@ -18,7 +18,7 @@ namespace cast {
 // static
 std::unique_ptr<VideoEncoder> VideoEncoder::Create(
     const scoped_refptr<CastEnvironment>& cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb) {

media/cast/sender/video_encoder.h

@@ -38,7 +38,7 @@ class VideoEncoder {
   // TODO(miu): Remove the CreateVEA callbacks.  http://crbug.com/454029
   static std::unique_ptr<VideoEncoder> Create(
       const scoped_refptr<CastEnvironment>& cast_environment,
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb);

media/cast/sender/video_encoder_impl.cc

@@ -51,7 +51,7 @@ void EncodeVideoFrameOnEncoderThread(
 }  // namespace
 
 // static
-bool VideoEncoderImpl::IsSupported(const VideoSenderConfig& video_config) {
+bool VideoEncoderImpl::IsSupported(const FrameSenderConfig& video_config) {
 #ifndef OFFICIAL_BUILD
   if (video_config.codec == CODEC_VIDEO_FAKE)
     return true;
@@ -61,7 +61,7 @@ bool VideoEncoderImpl::IsSupported(const VideoSenderConfig& video_config) {
 
 VideoEncoderImpl::VideoEncoderImpl(
     scoped_refptr<CastEnvironment> cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb)
     : cast_environment_(cast_environment) {
   CHECK(cast_environment_->HasVideoThread());

media/cast/sender/video_encoder_impl.h

@@ -28,10 +28,10 @@ class VideoEncoderImpl : public VideoEncoder {
   };
 
   // Returns true if VideoEncoderImpl can be used with the given |video_config|.
-  static bool IsSupported(const VideoSenderConfig& video_config);
+  static bool IsSupported(const FrameSenderConfig& video_config);
 
   VideoEncoderImpl(scoped_refptr<CastEnvironment> cast_environment,
-                   const VideoSenderConfig& video_config,
+                   const FrameSenderConfig& video_config,
                    const StatusChangeCallback& status_change_cb);
 
   ~VideoEncoderImpl() final;

media/cast/sender/video_encoder_unittest.cc

@@ -66,7 +66,7 @@ class VideoEncoderTest
 
   void CreateEncoder() {
     ASSERT_EQ(STATUS_UNINITIALIZED, operational_status_);
-    video_config_.max_number_of_video_buffers_used = 1;
+    video_config_.video_codec_params.max_number_of_video_buffers_used = 1;
     video_encoder_ = VideoEncoder::Create(
         cast_environment_, video_config_,
         base::Bind(&VideoEncoderTest::OnOperationalStatusChange,
@@ -121,6 +121,7 @@ class VideoEncoderTest
   }
 
   void RunTasksAndAdvanceClock() const {
+    DCHECK_GT(video_config_.max_frame_rate, 0);
     const base::TimeDelta frame_duration = base::TimeDelta::FromMicroseconds(
         1000000.0 / video_config_.max_frame_rate);
 #if defined(OS_MACOSX)
@@ -247,7 +248,8 @@ class VideoEncoderTest
     } else {
       if (expected_frame_id != expected_last_referenced_frame_id) {
         EXPECT_EQ(EncodedFrame::DEPENDENT, encoded_frame->dependency);
-      } else if (video_config_.max_number_of_video_buffers_used == 1) {
+      } else if (video_config_.video_codec_params
+                     .max_number_of_video_buffers_used == 1) {
         EXPECT_EQ(EncodedFrame::KEY, encoded_frame->dependency);
       }
       EXPECT_EQ(expected_last_referenced_frame_id,
@@ -265,7 +267,7 @@ class VideoEncoderTest
   base::SimpleTestTickClock* const testing_clock_;  // Owned by CastEnvironment.
   const scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
   const scoped_refptr<CastEnvironment> cast_environment_;
-  VideoSenderConfig video_config_;
+  FrameSenderConfig video_config_;
   std::unique_ptr<FakeVideoEncodeAcceleratorFactory> vea_factory_;
   base::TimeTicks first_frame_time_;
   OperationalStatus operational_status_;
@@ -414,7 +416,7 @@ std::vector<std::pair<Codec, bool>> DetermineEncodersToTest() {
   values.push_back(std::make_pair(CODEC_VIDEO_VP8, true));
 #if defined(OS_MACOSX)
   // VideoToolbox encoder (when VideoToolbox is present).
-  VideoSenderConfig video_config = GetDefaultVideoSenderConfig();
+  FrameSenderConfig video_config = GetDefaultVideoSenderConfig();
   video_config.use_external_encoder = false;
   video_config.codec = CODEC_VIDEO_H264;
   if (H264VideoToolboxEncoder::IsSupported(video_config))

media/cast/sender/video_sender.cc

@@ -89,7 +89,7 @@ void LogVideoCaptureTimestamps(CastEnvironment* cast_environment,
 // See details: crbug.com/392086.
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
@@ -100,7 +100,7 @@ VideoSender::VideoSender(
           false,
           transport_sender,
           kVideoFrequency,
-          video_config.ssrc,
+          video_config.sender_ssrc,
           video_config.max_frame_rate,
           video_config.min_playout_delay,
           video_config.max_playout_delay,
@@ -133,7 +133,7 @@ VideoSender::VideoSender(
   }
 
   media::cast::CastTransportRtpConfig transport_config;
-  transport_config.ssrc = video_config.ssrc;
+  transport_config.ssrc = video_config.sender_ssrc;
   transport_config.feedback_ssrc = video_config.receiver_ssrc;
   transport_config.rtp_payload_type = video_config.rtp_payload_type;
   transport_config.aes_key = video_config.aes_key;

media/cast/sender/video_sender.h

@@ -43,7 +43,7 @@ class VideoSender : public FrameSender,
                     public base::SupportsWeakPtr<VideoSender> {
  public:
   VideoSender(scoped_refptr<CastEnvironment> cast_environment,
-              const VideoSenderConfig& video_config,
+              const FrameSenderConfig& video_config,
               const StatusChangeCallback& status_change_cb,
               const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
               const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,

media/cast/sender/video_sender_unittest.cc

@@ -113,7 +113,7 @@ class PeerVideoSender : public VideoSender {
  public:
   PeerVideoSender(
       scoped_refptr<CastEnvironment> cast_environment,
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
@@ -178,7 +178,7 @@ class VideoSenderTest : public ::testing::Test {
   // If |external| is true then external video encoder (VEA) is used.
   // |expect_init_success| is true if initialization is expected to succeed.
   void InitEncoder(bool external, bool expect_init_success) {
-    VideoSenderConfig video_config = GetDefaultVideoSenderConfig();
+    FrameSenderConfig video_config = GetDefaultVideoSenderConfig();
     video_config.use_external_encoder = external;
 
     ASSERT_EQ(operational_status_, STATUS_UNINITIALIZED);

media/cast/sender/vp8_encoder.cc

@@ -63,12 +63,12 @@ bool HasSufficientFeedback(
 
 }  // namespace
 
-Vp8Encoder::Vp8Encoder(const VideoSenderConfig& video_config)
+Vp8Encoder::Vp8Encoder(const FrameSenderConfig& video_config)
     : cast_config_(video_config),
       target_encoder_utilization_(
-          video_config.number_of_encode_threads > 2
+          video_config.video_codec_params.number_of_encode_threads > 2
               ? kHiTargetEncoderUtilization
-              : (video_config.number_of_encode_threads > 1
+              : (video_config.video_codec_params.number_of_encode_threads > 1
                      ? kMidTargetEncoderUtilization
                      : kLoTargetEncoderUtilization)),
       key_frame_requested_(true),
@@ -79,8 +79,10 @@ Vp8Encoder::Vp8Encoder(const VideoSenderConfig& video_config)
           base::TimeDelta::FromMicroseconds(kEncodingSpeedAccHalfLife)),
       encoding_speed_(kHighestEncodingSpeed) {
   config_.g_timebase.den = 0;  // Not initialized.
-  DCHECK_LE(cast_config_.min_qp, cast_config_.max_cpu_saver_qp);
-  DCHECK_LE(cast_config_.max_cpu_saver_qp, cast_config_.max_qp);
+  DCHECK_LE(cast_config_.video_codec_params.min_qp,
+            cast_config_.video_codec_params.max_cpu_saver_qp);
+  DCHECK_LE(cast_config_.video_codec_params.max_cpu_saver_qp,
+            cast_config_.video_codec_params.max_qp);
 
   thread_checker_.DetachFromThread();
 }
@@ -110,7 +112,7 @@ void Vp8Encoder::ConfigureForNewFrameSize(const gfx::Size& frame_size) {
                << frame_size.ToString();
       config_.g_w = frame_size.width();
       config_.g_h = frame_size.height();
-      config_.rc_min_quantizer = cast_config_.min_qp;
+      config_.rc_min_quantizer = cast_config_.video_codec_params.min_qp;
       if (vpx_codec_enc_config_set(&encoder_, &config_) == VPX_CODEC_OK)
         return;
       DVLOG(1) << "libvpx rejected the attempt to use a smaller frame size in "
@@ -130,7 +132,7 @@ void Vp8Encoder::ConfigureForNewFrameSize(const gfx::Size& frame_size) {
   CHECK_EQ(vpx_codec_enc_config_default(vpx_codec_vp8_cx(), &config_, 0),
            VPX_CODEC_OK);
 
-  config_.g_threads = cast_config_.number_of_encode_threads;
+  config_.g_threads = cast_config_.video_codec_params.number_of_encode_threads;
   config_.g_w = frame_size.width();
   config_.g_h = frame_size.height();
   // Set the timebase to match that of base::TimeDelta.
@@ -147,8 +149,8 @@ void Vp8Encoder::ConfigureForNewFrameSize(const gfx::Size& frame_size) {
   config_.rc_resize_allowed = 0;  // TODO(miu): Why not?  Investigate this.
   config_.rc_end_usage = VPX_CBR;
   config_.rc_target_bitrate = bitrate_kbit_;
-  config_.rc_min_quantizer = cast_config_.min_qp;
-  config_.rc_max_quantizer = cast_config_.max_qp;
+  config_.rc_min_quantizer = cast_config_.video_codec_params.min_qp;
+  config_.rc_max_quantizer = cast_config_.video_codec_params.max_qp;
   // TODO(miu): Revisit these now that the encoder is being successfully
   // micro-managed.
   config_.rc_undershoot_pct = 100;
@@ -351,7 +353,7 @@ void Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
     double actual_encoding_speed =
         encoding_speed_ +
         kEquivalentEncodingSpeedStepPerQpStep *
-            std::max(0, quantizer - cast_config_.min_qp);
+            std::max(0, quantizer - cast_config_.video_codec_params.min_qp);
     double adjusted_encoding_speed = actual_encoding_speed *
                                      encoded_frame->encoder_utilization /
                                      target_encoder_utilization_;
@@ -370,12 +372,13 @@ void Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
       next_encoding_speed = kHighestEncodingSpeed;
       next_min_qp =
           static_cast<int>(remainder / kEquivalentEncodingSpeedStepPerQpStep +
-                           cast_config_.min_qp + 0.5);
-      next_min_qp = std::min(next_min_qp, cast_config_.max_cpu_saver_qp);
+                           cast_config_.video_codec_params.min_qp + 0.5);
+      next_min_qp = std::min(next_min_qp,
+                             cast_config_.video_codec_params.max_cpu_saver_qp);
     } else {
       next_encoding_speed =
           std::max<double>(kLowestEncodingSpeed, next_encoding_speed) + 0.5;
-      next_min_qp = cast_config_.min_qp;
+      next_min_qp = cast_config_.video_codec_params.min_qp;
     }
     if (encoding_speed_ != static_cast<int>(next_encoding_speed)) {
       encoding_speed_ = static_cast<int>(next_encoding_speed);

media/cast/sender/vp8_encoder.h

@@ -26,7 +26,7 @@ namespace cast {
 
 class Vp8Encoder : public SoftwareVideoEncoder {
  public:
-  explicit Vp8Encoder(const VideoSenderConfig& video_config);
+  explicit Vp8Encoder(const FrameSenderConfig& video_config);
 
   ~Vp8Encoder() final;
 
@@ -51,7 +51,7 @@ class Vp8Encoder : public SoftwareVideoEncoder {
   // |encoder_| instance.
   void ConfigureForNewFrameSize(const gfx::Size& frame_size);
 
-  const VideoSenderConfig cast_config_;
+  const FrameSenderConfig cast_config_;
 
   const double target_encoder_utilization_;
 

media/cast/sender/vp8_quantizer_parser_unittest.cc

@@ -26,14 +26,14 @@ const int kHeight = 32;
 const int kFrameRate = 10;
 const int kQp = 20;
 
-VideoSenderConfig GetVideoConfigForTest() {
-  VideoSenderConfig config = GetDefaultVideoSenderConfig();
+FrameSenderConfig GetVideoConfigForTest() {
+  FrameSenderConfig config = GetDefaultVideoSenderConfig();
   config.codec = CODEC_VIDEO_VP8;
   config.use_external_encoder = false;
   config.max_frame_rate = kFrameRate;
-  config.min_qp = kQp;
-  config.max_qp = kQp;
-  config.max_cpu_saver_qp = kQp;
+  config.video_codec_params.min_qp = kQp;
+  config.video_codec_params.max_qp = kQp;
+  config.video_codec_params.max_cpu_saver_qp = kQp;
   return config;
 }
 }  // unnamed namespace
@@ -58,9 +58,9 @@ class Vp8QuantizerParserTest : public ::testing::Test {
   // Update the vp8 encoder with the new quantizer.
   void UpdateQuantizer(int qp) {
     DCHECK((qp > 3) && (qp < 64));
-    video_config_.min_qp = qp;
-    video_config_.max_qp = qp;
-    video_config_.max_cpu_saver_qp = qp;
+    video_config_.video_codec_params.min_qp = qp;
+    video_config_.video_codec_params.max_qp = qp;
+    video_config_.video_codec_params.max_cpu_saver_qp = qp;
     RecreateVp8Encoder();
   }
 
@@ -79,7 +79,7 @@ class Vp8QuantizerParserTest : public ::testing::Test {
   }
 
   base::TimeDelta next_frame_timestamp_;
-  VideoSenderConfig video_config_;
+  FrameSenderConfig video_config_;
   std::unique_ptr<Vp8Encoder> vp8_encoder_;
 
   DISALLOW_COPY_AND_ASSIGN(Vp8QuantizerParserTest);

media/cast/test/cast_benchmarks.cc

@@ -258,8 +258,9 @@ class RunOneBenchmark {
     video_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs;
     video_receiver_config_.codec = video_codec;
 
-    frame_duration_ = base::TimeDelta::FromSeconds(1) /
-        video_sender_config_.max_frame_rate;
+    DCHECK_GT(video_sender_config_.max_frame_rate, 0);
+    frame_duration_ = base::TimeDelta::FromSecondsD(
+        1.0 / video_sender_config_.max_frame_rate);
   }
 
   void SetSenderClockSkew(double skew, base::TimeDelta offset) {
@@ -285,8 +286,8 @@ class RunOneBenchmark {
   }
 
   base::TimeDelta VideoTimestamp(int frame_number) {
-    return (frame_number * base::TimeDelta::FromSeconds(1)) /
-        video_sender_config_.max_frame_rate;
+    return frame_number * base::TimeDelta::FromSecondsD(
+                              1.0 / video_sender_config_.max_frame_rate);
   }
 
   void SendFakeVideoFrame() {
@@ -410,8 +411,8 @@ class RunOneBenchmark {
  private:
   FrameReceiverConfig audio_receiver_config_;
   FrameReceiverConfig video_receiver_config_;
-  AudioSenderConfig audio_sender_config_;
-  VideoSenderConfig video_sender_config_;
+  FrameSenderConfig audio_sender_config_;
+  FrameSenderConfig video_sender_config_;
 
   base::TimeTicks start_time_;
 

media/cast/test/end2end_unittest.cc

@@ -432,15 +432,15 @@ class End2EndTest : public ::testing::Test {
   }
 
   void Configure(Codec video_codec, Codec audio_codec) {
-    audio_sender_config_.ssrc = 1;
+    audio_sender_config_.sender_ssrc = 1;
     audio_sender_config_.receiver_ssrc = 2;
     audio_sender_config_.max_playout_delay =
         base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs);
     audio_sender_config_.rtp_payload_type = RtpPayloadType::AUDIO_OPUS;
     audio_sender_config_.use_external_encoder = false;
-    audio_sender_config_.frequency = kDefaultAudioSamplingRate;
+    audio_sender_config_.rtp_timebase = kDefaultAudioSamplingRate;
     audio_sender_config_.channels = kAudioChannels;
-    audio_sender_config_.bitrate = kDefaultAudioEncoderBitrate;
+    audio_sender_config_.max_bitrate = kDefaultAudioEncoderBitrate;
     audio_sender_config_.codec = audio_codec;
     audio_sender_config_.aes_iv_mask =
         ConvertFromBase16String("abcdeffedcba12345678900987654321");
@@ -449,11 +449,11 @@ class End2EndTest : public ::testing::Test {
 
     audio_receiver_config_.receiver_ssrc =
         audio_sender_config_.receiver_ssrc;
-    audio_receiver_config_.sender_ssrc = audio_sender_config_.ssrc;
+    audio_receiver_config_.sender_ssrc = audio_sender_config_.sender_ssrc;
     audio_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs;
     audio_receiver_config_.rtp_payload_type =
         audio_sender_config_.rtp_payload_type;
-    audio_receiver_config_.rtp_timebase = audio_sender_config_.frequency;
+    audio_receiver_config_.rtp_timebase = audio_sender_config_.rtp_timebase;
     audio_receiver_config_.channels = kAudioChannels;
     audio_receiver_config_.target_frame_rate = 100;
     audio_receiver_config_.codec = audio_sender_config_.codec;
@@ -463,7 +463,7 @@ class End2EndTest : public ::testing::Test {
     test_receiver_audio_callback_->SetExpectedSamplingFrequency(
         audio_receiver_config_.rtp_timebase);
 
-    video_sender_config_.ssrc = 3;
+    video_sender_config_.sender_ssrc = 3;
     video_sender_config_.receiver_ssrc = 4;
     video_sender_config_.max_playout_delay =
         base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs);
@@ -472,8 +472,8 @@ class End2EndTest : public ::testing::Test {
     video_sender_config_.max_bitrate = 50000;
     video_sender_config_.min_bitrate = 10000;
     video_sender_config_.start_bitrate = 10000;
-    video_sender_config_.max_qp = 30;
-    video_sender_config_.min_qp = 4;
+    video_sender_config_.video_codec_params.max_qp = 30;
+    video_sender_config_.video_codec_params.min_qp = 4;
     video_sender_config_.max_frame_rate = 30;
     video_sender_config_.codec = video_codec;
     video_sender_config_.aes_iv_mask =
@@ -483,7 +483,7 @@ class End2EndTest : public ::testing::Test {
 
     video_receiver_config_.receiver_ssrc =
         video_sender_config_.receiver_ssrc;
-    video_receiver_config_.sender_ssrc = video_sender_config_.ssrc;
+    video_receiver_config_.sender_ssrc = video_sender_config_.sender_ssrc;
     video_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs;
     video_receiver_config_.rtp_payload_type =
         video_sender_config_.rtp_payload_type;
@@ -834,8 +834,8 @@ class End2EndTest : public ::testing::Test {
 
   FrameReceiverConfig audio_receiver_config_;
   FrameReceiverConfig video_receiver_config_;
-  AudioSenderConfig audio_sender_config_;
-  VideoSenderConfig video_sender_config_;
+  FrameSenderConfig audio_sender_config_;
+  FrameSenderConfig video_sender_config_;
 
   base::TimeTicks start_time_;
 
@@ -958,7 +958,7 @@ void End2EndTest::Create() {
   video_frame_input_ = cast_sender_->video_frame_input();
 
   audio_bus_factory_.reset(new TestAudioBusFactory(
-      audio_sender_config_.channels, audio_sender_config_.frequency,
+      audio_sender_config_.channels, audio_sender_config_.rtp_timebase,
       kSoundFrequency, kSoundVolume));
 }
 

media/cast/test/fake_media_source.cc

@@ -76,15 +76,15 @@ namespace cast {
 FakeMediaSource::FakeMediaSource(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     base::TickClock* clock,
-    const AudioSenderConfig& audio_config,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& audio_config,
+    const FrameSenderConfig& video_config,
     bool keep_frames)
     : task_runner_(task_runner),
       output_audio_params_(AudioParameters::AUDIO_PCM_LINEAR,
                            media::GuessChannelLayout(audio_config.channels),
-                           audio_config.frequency,
+                           audio_config.rtp_timebase,
                            32,
-                           audio_config.frequency / kAudioPacketsPerSecond),
+                           audio_config.rtp_timebase / kAudioPacketsPerSecond),
       video_config_(video_config),
       keep_frames_(keep_frames),
       variable_frame_size_mode_(false),
@@ -102,10 +102,9 @@ FakeMediaSource::FakeMediaSource(
       video_first_pts_set_(false),
       weak_factory_(this) {
   CHECK(output_audio_params_.IsValid());
-  audio_bus_factory_.reset(new TestAudioBusFactory(audio_config.channels,
-                                                   audio_config.frequency,
-                                                   kSoundFrequency,
-                                                   kSoundVolume));
+  audio_bus_factory_.reset(
+      new TestAudioBusFactory(audio_config.channels, audio_config.rtp_timebase,
+                              kSoundFrequency, kSoundVolume));
 }
 
 FakeMediaSource::~FakeMediaSource() {

media/cast/test/fake_media_source.h

@@ -55,8 +55,8 @@ class FakeMediaSource : public media::AudioConverter::InputCallback {
   // |keep_frames| is true if all VideoFrames are saved in a queue.
   FakeMediaSource(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                   base::TickClock* clock,
-                  const AudioSenderConfig& audio_config,
-                  const VideoSenderConfig& video_config,
+                  const FrameSenderConfig& audio_config,
+                  const FrameSenderConfig& video_config,
                   bool keep_frames);
   ~FakeMediaSource() final;
 
@@ -71,7 +71,7 @@ class FakeMediaSource : public media::AudioConverter::InputCallback {
   void Start(scoped_refptr<AudioFrameInput> audio_frame_input,
              scoped_refptr<VideoFrameInput> video_frame_input);
 
-  const VideoSenderConfig& get_video_config() const { return video_config_; }
+  const FrameSenderConfig& get_video_config() const { return video_config_; }
 
   scoped_refptr<media::VideoFrame> PopOldestInsertedVideoFrame();
 
@@ -118,7 +118,7 @@ class FakeMediaSource : public media::AudioConverter::InputCallback {
 
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   const media::AudioParameters output_audio_params_;
-  const VideoSenderConfig video_config_;
+  const FrameSenderConfig video_config_;
   const bool keep_frames_;
   bool variable_frame_size_mode_;
   gfx::Size current_frame_size_;

media/cast/test/sender.cc

@@ -224,9 +224,9 @@ int main(int argc, char** argv) {
   LOG(INFO) << "Sending to " << remote_ip_address << ":" << remote_port
             << ".";
 
-  media::cast::AudioSenderConfig audio_config =
+  media::cast::FrameSenderConfig audio_config =
       media::cast::GetDefaultAudioSenderConfig();
-  media::cast::VideoSenderConfig video_config =
+  media::cast::FrameSenderConfig video_config =
       media::cast::GetDefaultVideoSenderConfig();
 
   // Running transport on the main thread.

media/cast/test/simulator.cc

@@ -356,7 +356,7 @@ void RunSimulation(const base::FilePath& source_path,
   sender_env->logger()->Subscribe(&video_event_subscriber);
 
   // Audio sender config.
-  AudioSenderConfig audio_sender_config = GetDefaultAudioSenderConfig();
+  FrameSenderConfig audio_sender_config = GetDefaultAudioSenderConfig();
   audio_sender_config.min_playout_delay =
       audio_sender_config.max_playout_delay = base::TimeDelta::FromMilliseconds(
           GetIntegerSwitchValue(kTargetDelay, 400));
@@ -368,7 +368,7 @@ void RunSimulation(const base::FilePath& source_path,
       audio_sender_config.max_playout_delay.InMilliseconds();
 
   // Video sender config.
-  VideoSenderConfig video_sender_config = GetDefaultVideoSenderConfig();
+  FrameSenderConfig video_sender_config = GetDefaultVideoSenderConfig();
   video_sender_config.max_bitrate = 2500000;
   video_sender_config.min_bitrate = 2000000;
   video_sender_config.start_bitrate = 2000000;

media/cast/test/utility/default_config.cc

@@ -55,38 +55,41 @@ FrameReceiverConfig GetDefaultVideoReceiverConfig() {
   return config;
 }
 
-AudioSenderConfig GetDefaultAudioSenderConfig() {
+FrameSenderConfig GetDefaultAudioSenderConfig() {
   FrameReceiverConfig recv_config = GetDefaultAudioReceiverConfig();
-  AudioSenderConfig config;
-  config.ssrc = recv_config.sender_ssrc;
+  FrameSenderConfig config;
+  config.sender_ssrc = recv_config.sender_ssrc;
   config.receiver_ssrc = recv_config.receiver_ssrc;
   config.rtp_payload_type = recv_config.rtp_payload_type;
   config.use_external_encoder = false;
-  config.frequency = recv_config.rtp_timebase;
+  config.rtp_timebase = recv_config.rtp_timebase;
   config.channels = recv_config.channels;
-  config.bitrate = kDefaultAudioEncoderBitrate;
+  config.max_bitrate = config.min_bitrate = config.start_bitrate =
+      kDefaultAudioEncoderBitrate;
+  config.max_frame_rate = recv_config.target_frame_rate;
   config.codec = recv_config.codec;
-  config.max_playout_delay =
-      base::TimeDelta::FromMilliseconds(kDefaultRtpMaxDelayMs);
   return config;
 }
 
-VideoSenderConfig GetDefaultVideoSenderConfig() {
+FrameSenderConfig GetDefaultVideoSenderConfig() {
   FrameReceiverConfig recv_config = GetDefaultVideoReceiverConfig();
-  VideoSenderConfig config;
-  config.ssrc = recv_config.sender_ssrc;
+  FrameSenderConfig config;
+  config.sender_ssrc = recv_config.sender_ssrc;
   config.receiver_ssrc = recv_config.receiver_ssrc;
   config.rtp_payload_type = recv_config.rtp_payload_type;
   config.use_external_encoder = false;
-  config.max_bitrate = 4000000;
-  config.min_bitrate = 2000000;
-  config.start_bitrate = 4000000;
+  config.rtp_timebase = recv_config.rtp_timebase;
+  config.max_bitrate = kDefaultMaxVideoBitrate;
+  config.min_bitrate = kDefaultMinVideoBitrate;
+  config.start_bitrate = config.max_bitrate;
   config.max_frame_rate = recv_config.target_frame_rate;
-  config.max_number_of_video_buffers_used = 1;
   config.codec = recv_config.codec;
-  config.number_of_encode_threads = 2;
-  config.max_playout_delay =
-      base::TimeDelta::FromMilliseconds(kDefaultRtpMaxDelayMs);
+  config.video_codec_params.max_qp = kDefaultMaxQp;
+  config.video_codec_params.min_qp = kDefaultMinQp;
+  config.video_codec_params.max_cpu_saver_qp = kDefaultMaxCpuSaverQp;
+  config.video_codec_params.max_number_of_video_buffers_used =
+      kDefaultNumberOfVideoBuffers;
+  config.video_codec_params.number_of_encode_threads = 2;
   return config;
 }
 

media/cast/test/utility/default_config.h

@@ -20,14 +20,14 @@ FrameReceiverConfig GetDefaultAudioReceiverConfig();
 // name.
 FrameReceiverConfig GetDefaultVideoReceiverConfig();
 
-// Returns a AudioSenderConfig initialized to default values. This means
+// Returns a FrameSenderConfig initialized to default values. This means
 // 48 kHz, 2-channel Opus-coded audio. Default values for SSRCs and payload
 // type.
-AudioSenderConfig GetDefaultAudioSenderConfig();
+FrameSenderConfig GetDefaultAudioSenderConfig();
 
-// Returns a VideoSenderConfig initialized to default values. This means
+// Returns a FrameSenderConfig initialized to default values. This means
 // 30 Hz VP8 coded code. Default values for SSRCs and payload type.
-VideoSenderConfig GetDefaultVideoSenderConfig();
+FrameSenderConfig GetDefaultVideoSenderConfig();
 
 // Returns a callback that does nothing.
 CreateVideoEncodeAcceleratorCallback