Remove simulcast bitrate modes.

talk/media/base/mediachannel.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 44 matching lines @@
 class AudioRenderer;
 struct RtpHeader;
 class ScreencastId;
 struct VideoFormat;
 class VideoCapturer;
 class VideoRenderer;
 
 const int kMinRtpHeaderExtensionId = 1;
 const int kMaxRtpHeaderExtensionId = 255;
 const int kScreencastDefaultFps = 5;
-const int kHighStartBitrate = 1500;
 
 // Used in AudioOptions and VideoOptions to signify "unset" values.
 template <class T>
 class Settable {
  public:
   Settable() : set_(false), val_() {}
   explicit Settable(T val) : set_(true), val_(val) {}
 
   bool IsSet() const {
     return set_;
@@ skipping 205 matching lines @@
   Settable<bool> dscp;
   // Enable combined audio+bandwidth BWE.
   Settable<bool> combined_audio_video_bwe;
 };
 
 // Options that can be applied to a VideoMediaChannel or a VideoMediaEngine.
 // Used to be flags, but that makes it hard to selectively apply options.
 // We are moving all of the setting of options to structs like this,
 // but some things currently still use flags.
 struct VideoOptions {
-  enum HighestBitrate {
-    NORMAL,
-    HIGH,
-    VERY_HIGH
-  };
-
   VideoOptions() {
     process_adaptation_threshhold.Set(kProcessCpuThreshold);
     system_low_adaptation_threshhold.Set(kLowSystemCpuThreshold);
     system_high_adaptation_threshhold.Set(kHighSystemCpuThreshold);
     unsignalled_recv_stream_limit.Set(kNumDefaultUnsignalledVideoRecvStreams);
   }
 
   void SetAll(const VideoOptions& change) {
     adapt_input_to_cpu_usage.SetFrom(change.adapt_input_to_cpu_usage);
     adapt_cpu_with_smoothing.SetFrom(change.adapt_cpu_with_smoothing);
     video_adapt_third.SetFrom(change.video_adapt_third);
     video_noise_reduction.SetFrom(change.video_noise_reduction);
     video_start_bitrate.SetFrom(change.video_start_bitrate);
-    video_highest_bitrate.SetFrom(change.video_highest_bitrate);
     cpu_overuse_detection.SetFrom(change.cpu_overuse_detection);
     cpu_underuse_threshold.SetFrom(change.cpu_underuse_threshold);
     cpu_overuse_threshold.SetFrom(change.cpu_overuse_threshold);
     cpu_underuse_encode_rsd_threshold.SetFrom(
         change.cpu_underuse_encode_rsd_threshold);
     cpu_overuse_encode_rsd_threshold.SetFrom(
         change.cpu_overuse_encode_rsd_threshold);
     cpu_overuse_encode_usage.SetFrom(change.cpu_overuse_encode_usage);
     conference_mode.SetFrom(change.conference_mode);
     process_adaptation_threshhold.SetFrom(change.process_adaptation_threshhold);
     system_low_adaptation_threshhold.SetFrom(
         change.system_low_adaptation_threshhold);
     system_high_adaptation_threshhold.SetFrom(
         change.system_high_adaptation_threshhold);
     dscp.SetFrom(change.dscp);
     suspend_below_min_bitrate.SetFrom(change.suspend_below_min_bitrate);
     unsignalled_recv_stream_limit.SetFrom(change.unsignalled_recv_stream_limit);
     use_simulcast_adapter.SetFrom(change.use_simulcast_adapter);
     screencast_min_bitrate.SetFrom(change.screencast_min_bitrate);
   }
 
   bool operator==(const VideoOptions& o) const {
     return adapt_input_to_cpu_usage == o.adapt_input_to_cpu_usage &&
            adapt_cpu_with_smoothing == o.adapt_cpu_with_smoothing &&
            video_adapt_third == o.video_adapt_third &&
            video_noise_reduction == o.video_noise_reduction &&
            video_start_bitrate == o.video_start_bitrate &&
-           video_highest_bitrate == o.video_highest_bitrate &&
            cpu_overuse_detection == o.cpu_overuse_detection &&
            cpu_underuse_threshold == o.cpu_underuse_threshold &&
            cpu_overuse_threshold == o.cpu_overuse_threshold &&
            cpu_underuse_encode_rsd_threshold ==
                o.cpu_underuse_encode_rsd_threshold &&
            cpu_overuse_encode_rsd_threshold ==
                o.cpu_overuse_encode_rsd_threshold &&
            cpu_overuse_encode_usage == o.cpu_overuse_encode_usage &&
            conference_mode == o.conference_mode &&
            process_adaptation_threshhold == o.process_adaptation_threshhold &&
            system_low_adaptation_threshhold ==
                o.system_low_adaptation_threshhold &&
            system_high_adaptation_threshhold ==
                o.system_high_adaptation_threshhold &&
            dscp == o.dscp &&
            suspend_below_min_bitrate == o.suspend_below_min_bitrate &&
            unsignalled_recv_stream_limit == o.unsignalled_recv_stream_limit &&
            use_simulcast_adapter == o.use_simulcast_adapter &&
            screencast_min_bitrate == o.screencast_min_bitrate;
   }
 
   std::string ToString() const {
     std::ostringstream ost;
     ost << "VideoOptions {";
     ost << ToStringIfSet("cpu adaption", adapt_input_to_cpu_usage);
     ost << ToStringIfSet("cpu adaptation smoothing", adapt_cpu_with_smoothing);
     ost << ToStringIfSet("video adapt third", video_adapt_third);
     ost << ToStringIfSet("noise reduction", video_noise_reduction);
     ost << ToStringIfSet("start bitrate", video_start_bitrate);
-    ost << ToStringIfSet("highest video bitrate", video_highest_bitrate);
     ost << ToStringIfSet("cpu overuse detection", cpu_overuse_detection);
     ost << ToStringIfSet("cpu underuse threshold", cpu_underuse_threshold);
     ost << ToStringIfSet("cpu overuse threshold", cpu_overuse_threshold);
     ost << ToStringIfSet("cpu underuse encode rsd threshold",
                          cpu_underuse_encode_rsd_threshold);
     ost << ToStringIfSet("cpu overuse encode rsd threshold",
                          cpu_overuse_encode_rsd_threshold);
     ost << ToStringIfSet("cpu overuse encode usage",
                          cpu_overuse_encode_usage);
     ost << ToStringIfSet("conference mode", conference_mode);
@@ skipping 14 matching lines @@
   // Enable CPU adaptation?
   Settable<bool> adapt_input_to_cpu_usage;
   // Enable CPU adaptation smoothing?
   Settable<bool> adapt_cpu_with_smoothing;
   // Enable video adapt third?
   Settable<bool> video_adapt_third;
   // Enable denoising?
   Settable<bool> video_noise_reduction;
   // Experimental: Enable WebRtc higher start bitrate?
   Settable<int> video_start_bitrate;
-  // Set highest bitrate mode for video.
-  Settable<HighestBitrate> video_highest_bitrate;
   // Enable WebRTC Cpu Overuse Detection, which is a new version of the CPU
   // adaptation algorithm. So this option will override the
   // |adapt_input_to_cpu_usage|.
   Settable<bool> cpu_overuse_detection;
   // Low threshold (t1) for cpu overuse adaptation.  (Adapt up)
   // Metric: encode usage (m1). m1 < t1 => underuse.
   Settable<int> cpu_underuse_threshold;
   // High threshold (t1) for cpu overuse adaptation.  (Adapt down)
   // Metric: encode usage (m1). m1 > t1 => overuse.
   Settable<int> cpu_overuse_threshold;
@@ skipping 845 matching lines @@
   // Signal when the media channel is ready to send the stream. Arguments are:
   //     writable(bool)
   sigslot::signal1<bool> SignalReadyToSend;
   // Signal for notifying that the remote side has closed the DataChannel.
   sigslot::signal1<uint32_t> SignalStreamClosedRemotely;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_MEDIACHANNEL_H_