Cast: Synthetic benchmark tool.

media/cast/test/cast_benchmarks.cc

+// Copyright 2014 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.
+//
+// This program benchmarks the theoretical throughput of the cast library.
+// It runs using a fake clock, simulated network and fake codecs. This allows
+// tests to run much faster than real time.
+// To run the program, run:
+// $ ./out/Release/cast_benchmarks | tee benchmarkoutput.asc
+// This may take a while, when it is done, you can view the data with
+// meshlab by running:
+// $ meshlab benchmarkoutput.asc
+// After starting meshlab, turn on Render->Show Axis. The red axis will
+// represent bandwidth (in megabits) the blue axis will be packet drop
+// (in percent) and the green axis will be latency (in milliseconds).
+//
+// This program can also be used for profiling. On linux it has
+// built-in support for this. Simply set the environment variable
+// PROFILE_FILE before running it, like so:
+// $ export PROFILE_FILE=cast_benchmark.profile
+// Then after running the program, you can view the profile with:
+// $ pprof ./out/Release/cast_benchmarks $PROFILE_FILE --gv
+
+#include <math.h>
+#include <stdint.h>
+
+#include <map>
+#include <vector>
+
+#include "base/at_exit.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/command_line.h"
+#include "base/debug/profiler.h"
+#include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "base/threading/thread.h"
+#include "base/time/tick_clock.h"
+#include "media/base/audio_bus.h"
+#include "media/base/video_frame.h"
+#include "media/cast/cast_config.h"
+#include "media/cast/cast_environment.h"
+#include "media/cast/cast_receiver.h"
+#include "media/cast/cast_sender.h"
+#include "media/cast/logging/simple_event_subscriber.h"
+#include "media/cast/test/fake_single_thread_task_runner.h"
+#include "media/cast/test/skewed_single_thread_task_runner.h"
+#include "media/cast/test/skewed_tick_clock.h"
+#include "media/cast/test/utility/audio_utility.h"
+#include "media/cast/test/utility/default_config.h"
+#include "media/cast/test/utility/test_util.h"
+#include "media/cast/test/utility/udp_proxy.h"
+#include "media/cast/test/utility/video_utility.h"
+#include "media/cast/transport/cast_transport_config.h"
+#include "media/cast/transport/cast_transport_defines.h"
+#include "media/cast/transport/cast_transport_sender.h"
+#include "media/cast/transport/cast_transport_sender_impl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+namespace cast {
+
+namespace {
+
+static const int64 kStartMillisecond = INT64_C(1245);
+static const int kAudioChannels = 2;
+static const int kVideoHdWidth = 1280;
+static const int kVideoHdHeight = 720;
+static const int kTargetDelay = 300;
+
+// The tests are commonly implemented with |kFrameTimerMs| RunTask function;
+// a normal video is 30 fps hence the 33 ms between frames.
+static const int kFrameTimerMs = 33;
+
+void UpdateCastTransportStatus(transport::CastTransportStatus status) {
+  bool result = (status == transport::TRANSPORT_AUDIO_INITIALIZED ||
+                 status == transport::TRANSPORT_VIDEO_INITIALIZED);
+  EXPECT_TRUE(result);
+}
+
+void AudioInitializationStatus(CastInitializationStatus status) {
+  EXPECT_EQ(STATUS_AUDIO_INITIALIZED, status);
+}
+
+void VideoInitializationStatus(CastInitializationStatus status) {
+  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status);
+}
+
+void IgnoreRawEvents(const std::vector<PacketEvent>& packet_events) {
+}
+
+}  // namespace
+
+// Shim that turns forwards packets from a test::PacketPipe to a
+// PacketReceiverCallback.
+class LoopBackPacketPipe : public test::PacketPipe {
+ public:
+  LoopBackPacketPipe(const transport::PacketReceiverCallback& packet_receiver)
+      : packet_receiver_(packet_receiver) {}
+
+  virtual ~LoopBackPacketPipe() {}
+
+  // PacketPipe implementations.
+  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
+    packet_receiver_.Run(packet.Pass());
+  }
+
+ private:
+  transport::PacketReceiverCallback packet_receiver_;
+};
+
+// Class that sends the packet direct from sender into the receiver with the
+// ability to drop packets between the two.
+// TODO(hubbe): Break this out and share code with end2end_unittest.cc
+class LoopBackTransport : public transport::PacketSender {
+ public:
+  explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
+      : cast_environment_(cast_environment) {}
+
+  void SetPacketReceiver(
+      const transport::PacketReceiverCallback& packet_receiver,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      base::TickClock* clock) {
+    scoped_ptr<test::PacketPipe> loopback_pipe(
+        new LoopBackPacketPipe(packet_receiver));
+    if (packet_pipe_) {
+      packet_pipe_->AppendToPipe(loopback_pipe.Pass());
+    } else {
+      packet_pipe_ = loopback_pipe.Pass();
+    }
+    packet_pipe_->InitOnIOThread(task_runner, clock);
+  }
+
+  virtual bool SendPacket(transport::PacketRef packet,
+                          const base::Closure& cb) OVERRIDE {
+    DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+    scoped_ptr<Packet> packet_copy(new Packet(packet->data));
+    packet_pipe_->Send(packet_copy.Pass());
+    return true;
+  }
+
+  void SetPacketPipe(scoped_ptr<test::PacketPipe> pipe) {
+    // Append the loopback pipe to the end.
+    pipe->AppendToPipe(packet_pipe_.Pass());
+    packet_pipe_ = pipe.Pass();
+  }
+
+ private:
+  scoped_refptr<CastEnvironment> cast_environment_;
+  scoped_ptr<test::PacketPipe> packet_pipe_;
+};
+
+// Wraps a CastTransportSender and records some statistics about
+// the data that goes through it.
+class CastTransportSenderWrapper : public transport::CastTransportSender {
+ public:
+  // Takes ownership of |transport|.
+  void Init(CastTransportSender* transport,
+            uint64* encoded_video_bytes,
+            uint64* encoded_audio_bytes) {
+    transport_.reset(transport);
+    encoded_video_bytes_ = encoded_video_bytes;
+    encoded_audio_bytes_ = encoded_audio_bytes;
+  }
+
+  virtual void InitializeAudio(
+      const transport::CastTransportAudioConfig& config) OVERRIDE {
+    transport_->InitializeAudio(config);
+  }
+
+  virtual void InitializeVideo(
+      const transport::CastTransportVideoConfig& config) OVERRIDE {
+    transport_->InitializeVideo(config);
+  }
+
+  virtual void SetPacketReceiver(
+      const transport::PacketReceiverCallback& packet_receiver) OVERRIDE {
+    transport_->SetPacketReceiver(packet_receiver);
+  }
+
+  virtual void InsertCodedAudioFrame(
+      const transport::EncodedFrame& audio_frame) OVERRIDE {
+    *encoded_audio_bytes_ += audio_frame.data.size();
+    transport_->InsertCodedAudioFrame(audio_frame);
+  }
+
+  virtual void InsertCodedVideoFrame(
+      const transport::EncodedFrame& video_frame) OVERRIDE {
+    *encoded_video_bytes_ += video_frame.data.size();
+    transport_->InsertCodedVideoFrame(video_frame);
+  }
+
+  virtual void SendRtcpFromRtpSender(uint32 packet_type_flags,
+                                     uint32 ntp_seconds,
+                                     uint32 ntp_fraction,
+                                     uint32 rtp_timestamp,
+                                     const transport::RtcpDlrrReportBlock& dlrr,
+                                     uint32 sending_ssrc,
+                                     const std::string& c_name) OVERRIDE {
+    transport_->SendRtcpFromRtpSender(packet_type_flags,
+                                      ntp_seconds,
+                                      ntp_fraction,
+                                      rtp_timestamp,
+                                      dlrr,
+                                      sending_ssrc,
+                                      c_name);
+  }
+
+  // Retransmission request.
+  virtual void ResendPackets(
+      bool is_audio,
+      const MissingFramesAndPacketsMap& missing_packets,
+      bool cancel_rtx_if_not_in_list) OVERRIDE {
+    transport_->ResendPackets(
+        is_audio, missing_packets, cancel_rtx_if_not_in_list);
+  }
+
+ private:
+  scoped_ptr<transport::CastTransportSender> transport_;
+  uint64* encoded_video_bytes_;
+  uint64* encoded_audio_bytes_;
+};
+
+struct MeasuringPoint {
+  MeasuringPoint(double bitrate_, double latency_, double percent_packet_drop_)
+      : bitrate(bitrate_),
+        latency(latency_),
+        percent_packet_drop(percent_packet_drop_) {}
+  bool operator<=(const MeasuringPoint& other) const {
+    return bitrate >= other.bitrate && latency <= other.latency &&
+           percent_packet_drop <= other.percent_packet_drop;
+  }
+  bool operator>=(const MeasuringPoint& other) const {
+    return bitrate <= other.bitrate && latency >= other.latency &&
+           percent_packet_drop >= other.percent_packet_drop;
+  }
+
+  std::string AsString() const {
+    return base::StringPrintf(
+        "%f Mbit/s %f ms %f %% ", bitrate, latency, percent_packet_drop);
+  }
+
+  double bitrate;
+  double latency;
+  double percent_packet_drop;
+};
+
+class RunOneBenchmark {
+ public:
+  RunOneBenchmark()
+      : start_time_(),
+        task_runner_(new test::FakeSingleThreadTaskRunner(&testing_clock_)),
+        testing_clock_sender_(new test::SkewedTickClock(&testing_clock_)),
+        task_runner_sender_(
+            new test::SkewedSingleThreadTaskRunner(task_runner_)),
+        testing_clock_receiver_(new test::SkewedTickClock(&testing_clock_)),
+        task_runner_receiver_(
+            new test::SkewedSingleThreadTaskRunner(task_runner_)),
+        cast_environment_sender_(new CastEnvironment(
+            scoped_ptr<base::TickClock>(testing_clock_sender_).Pass(),
+            task_runner_sender_,
+            task_runner_sender_,
+            task_runner_sender_)),
+        cast_environment_receiver_(new CastEnvironment(
+            scoped_ptr<base::TickClock>(testing_clock_receiver_).Pass(),
+            task_runner_receiver_,
+            task_runner_receiver_,
+            task_runner_receiver_)),
+        receiver_to_sender_(cast_environment_receiver_),
+        sender_to_receiver_(cast_environment_sender_),
+        video_bytes_encoded_(0),
+        audio_bytes_encoded_(0),
+        frames_sent_(0) {
+    testing_clock_.Advance(
+        base::TimeDelta::FromMilliseconds(kStartMillisecond));
+  }
+
+  void Configure(transport::VideoCodec video_codec,
+                 transport::AudioCodec audio_codec,
+                 int audio_sampling_frequency,
+                 int max_number_of_video_buffers_used) {
+    audio_sender_config_.rtp_config.ssrc = 1;
+    audio_sender_config_.incoming_feedback_ssrc = 2;
+    audio_sender_config_.rtp_config.payload_type = 96;
+    audio_sender_config_.use_external_encoder = false;
+    audio_sender_config_.frequency = audio_sampling_frequency;
+    audio_sender_config_.channels = kAudioChannels;
+    audio_sender_config_.bitrate = kDefaultAudioEncoderBitrate;
+    audio_sender_config_.codec = audio_codec;
+    audio_sender_config_.rtp_config.max_delay_ms = kTargetDelay;
+
+    audio_receiver_config_.feedback_ssrc =
+        audio_sender_config_.incoming_feedback_ssrc;
+    audio_receiver_config_.incoming_ssrc = audio_sender_config_.rtp_config.ssrc;
+    audio_receiver_config_.rtp_payload_type =
+        audio_sender_config_.rtp_config.payload_type;
+    audio_receiver_config_.frequency = audio_sender_config_.frequency;
+    audio_receiver_config_.channels = kAudioChannels;
+    audio_receiver_config_.max_frame_rate = 100;
+    audio_receiver_config_.codec.audio = audio_sender_config_.codec;
+    audio_receiver_config_.rtp_max_delay_ms = kTargetDelay;
+
+    video_sender_config_.rtp_config.ssrc = 3;
+    video_sender_config_.incoming_feedback_ssrc = 4;
+    video_sender_config_.rtp_config.payload_type = 97;
+    video_sender_config_.use_external_encoder = false;
+    video_sender_config_.width = kVideoHdWidth;
+    video_sender_config_.height = kVideoHdHeight;
+#if 0
+    video_sender_config_.max_bitrate = 10000000;  // 10Mbit max
+    video_sender_config_.min_bitrate = 1000000;   // 1Mbit min
+    video_sender_config_.start_bitrate = 1000000; // 1Mbit start
+#else
+    video_sender_config_.max_bitrate = 4000000;  // 4Mbit all the time
+    video_sender_config_.min_bitrate = 4000000;
+    video_sender_config_.start_bitrate = 4000000;
+#endif
+    video_sender_config_.max_qp = 56;
+    video_sender_config_.min_qp = 4;
+    video_sender_config_.max_frame_rate = 30;
+    video_sender_config_.max_number_of_video_buffers_used =
+        max_number_of_video_buffers_used;
+    video_sender_config_.codec = video_codec;
+    video_sender_config_.rtp_config.max_delay_ms = kTargetDelay;
+
+    video_receiver_config_.feedback_ssrc =
+        video_sender_config_.incoming_feedback_ssrc;
+    video_receiver_config_.incoming_ssrc = video_sender_config_.rtp_config.ssrc;
+    video_receiver_config_.rtp_payload_type =
+        video_sender_config_.rtp_config.payload_type;
+    video_receiver_config_.codec.video = video_sender_config_.codec;
+    video_receiver_config_.frequency = kVideoFrequency;
+    video_receiver_config_.channels = 1;
+    video_receiver_config_.max_frame_rate = 100;
+    video_receiver_config_.rtp_max_delay_ms = kTargetDelay;
+  }
+
+  void SetSenderClockSkew(double skew, base::TimeDelta offset) {
+    testing_clock_sender_->SetSkew(skew, offset);
+    task_runner_sender_->SetSkew(1.0 / skew);
+  }
+
+  void SetReceiverClockSkew(double skew, base::TimeDelta offset) {
+    testing_clock_receiver_->SetSkew(skew, offset);
+    task_runner_receiver_->SetSkew(1.0 / skew);
+  }
+
+  void Create() {
+    cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
+                                          audio_receiver_config_,
+                                          video_receiver_config_,
+                                          &receiver_to_sender_);
+    net::IPEndPoint dummy_endpoint;
+    transport_sender_.Init(new transport::CastTransportSenderImpl(
+                               NULL,
+                               testing_clock_sender_,
+                               dummy_endpoint,
+                               base::Bind(&UpdateCastTransportStatus),
+                               base::Bind(&IgnoreRawEvents),
+                               base::TimeDelta::FromSeconds(1),
+                               task_runner_sender_,
+                               &sender_to_receiver_),
+                           &video_bytes_encoded_,
+                           &audio_bytes_encoded_);
+
+    cast_sender_ =
+        CastSender::Create(cast_environment_sender_, &transport_sender_);
+
+    // Initializing audio and video senders.
+    cast_sender_->InitializeAudio(audio_sender_config_,
+                                  base::Bind(&AudioInitializationStatus));
+    cast_sender_->InitializeVideo(video_sender_config_,
+                                  base::Bind(&VideoInitializationStatus),
+                                  CreateDefaultVideoEncodeAcceleratorCallback(),
+                                  CreateDefaultVideoEncodeMemoryCallback());
+
+    receiver_to_sender_.SetPacketReceiver(
+        cast_sender_->packet_receiver(), task_runner_, &testing_clock_);
+    sender_to_receiver_.SetPacketReceiver(
+        cast_receiver_->packet_receiver(), task_runner_, &testing_clock_);
+  }
+
+  virtual ~RunOneBenchmark() {
+    cast_sender_.reset();
+    cast_receiver_.reset();
+    task_runner_->RunTasks();
+  }
+
+  void SendFakeVideoFrame() {
+    frames_sent_++;
+    cast_sender_->video_frame_input()->InsertRawVideoFrame(
+        media::VideoFrame::CreateBlackFrame(gfx::Size(2, 2)),
+        testing_clock_sender_->NowTicks());
+  }
+
+  void RunTasks(int ms) {
+    task_runner_->Sleep(base::TimeDelta::FromMilliseconds(ms));
+  }
+
+  void BasicPlayerGotVideoFrame(
+      const scoped_refptr<media::VideoFrame>& video_frame,
+      const base::TimeTicks& render_time,
+      bool continuous) {
+    video_ticks_.push_back(
+        std::make_pair(testing_clock_receiver_->NowTicks(), render_time));
+    cast_receiver_->RequestDecodedVideoFrame(base::Bind(
+        &RunOneBenchmark::BasicPlayerGotVideoFrame, base::Unretained(this)));
+  }
+
+  void BasicPlayerGotAudioFrame(scoped_ptr<AudioBus> audio_bus,
+                                const base::TimeTicks& playout_time,
+                                bool is_continuous) {
+    audio_ticks_.push_back(
+        std::make_pair(testing_clock_receiver_->NowTicks(), playout_time));
+    cast_receiver_->RequestDecodedAudioFrame(base::Bind(
+        &RunOneBenchmark::BasicPlayerGotAudioFrame, base::Unretained(this)));
+  }
+
+  void StartBasicPlayer() {
+    cast_receiver_->RequestDecodedVideoFrame(base::Bind(
+        &RunOneBenchmark::BasicPlayerGotVideoFrame, base::Unretained(this)));
+    cast_receiver_->RequestDecodedAudioFrame(base::Bind(
+        &RunOneBenchmark::BasicPlayerGotAudioFrame, base::Unretained(this)));
+  }
+
+  scoped_ptr<test::PacketPipe> CreateSimplePipe(const MeasuringPoint& p) {
+    scoped_ptr<test::PacketPipe> pipe = test::NewBuffer(65536, p.bitrate);
+    pipe->AppendToPipe(
+        test::NewRandomDrop(p.percent_packet_drop / 100.0).Pass());
+    pipe->AppendToPipe(test::NewConstantDelay(p.latency / 1000.0));
+    return pipe.Pass();
+  }
+
+  void Run(const MeasuringPoint& p) {
+    available_bitrate_ = p.bitrate;
+    Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, 1);
+    receiver_to_sender_.SetPacketPipe(CreateSimplePipe(p).Pass());
+    sender_to_receiver_.SetPacketPipe(CreateSimplePipe(p).Pass());
+    Create();
+    StartBasicPlayer();
+
+    for (int frame = 0; frame < 1000; frame++) {
+      SendFakeVideoFrame();
+      RunTasks(kFrameTimerMs);
+    }
+    RunTasks(100 * kFrameTimerMs);  // Empty the pipeline.
+    VLOG(1) << "=============INPUTS============";
+    VLOG(1) << "Bitrate: " << p.bitrate << " mbit/s";
+    VLOG(1) << "Latency: " << p.latency << " ms";
+    VLOG(1) << "Packet drop drop: " << p.percent_packet_drop << "%";
+    VLOG(1) << "=============OUTPUTS============";
+    VLOG(1) << "Frames lost: " << frames_lost();
+    VLOG(1) << "Late frames: " << late_frames();
+    VLOG(1) << "Playout margin: " << frame_playout_buffer().AsString();
+    VLOG(1) << "Video bandwidth used: " << video_bandwidth() << " mbit/s ("
+            << (video_bandwidth() * 100 / desired_video_bitrate()) << "%)";
+    VLOG(1) << "Good run: " << SimpleGood();
+  }
+
+  // Metrics
+  int frames_lost() const { return frames_sent_ - video_ticks_.size(); }
+
+  int late_frames() const {
+    int frames = 0;
+    // Ignore the first two seconds of video or so.
+    for (size_t i = 60; i < video_ticks_.size(); i++) {
+      if (video_ticks_[i].first > video_ticks_[i].second) {
+        frames++;
+      }
+    }
+    return frames;
+  }
+
+  test::MeanAndError frame_playout_buffer() const {
+    std::vector<double> values;
+    for (size_t i = 0; i < video_ticks_.size(); i++) {
+      values.push_back(
+          (video_ticks_[i].second - video_ticks_[i].first).InMillisecondsF());
+    }
+    return test::MeanAndError(values);
+  }
+
+  // Mbits per second
+  double video_bandwidth() const {
+    double seconds = (kFrameTimerMs * frames_sent_ / 1000.0);
+    double megabits = video_bytes_encoded_ * 8 / 1000000.0;
+    return megabits / seconds;
+  }
+
+  // Mbits per second
+  double audio_bandwidth() const {
+    double seconds = (kFrameTimerMs * frames_sent_ / 1000.0);
+    double megabits = audio_bytes_encoded_ * 8 / 1000000.0;
+    return megabits / seconds;
+  }
+
+  double desired_video_bitrate() {
+    return std::min<double>(available_bitrate_,
+                            video_sender_config_.max_bitrate / 1000000.0);
+  }
+
+  bool SimpleGood() {
+    return frames_lost() <= 1 && late_frames() <= 1 &&
+           video_bandwidth() > desired_video_bitrate() * 0.8 &&
+           video_bandwidth() < desired_video_bitrate() * 1.2;
+  }
+
+ private:
+  FrameReceiverConfig audio_receiver_config_;
+  FrameReceiverConfig video_receiver_config_;
+  AudioSenderConfig audio_sender_config_;
+  VideoSenderConfig video_sender_config_;
+
+  base::TimeTicks start_time_;
+
+  // These run in "test time"
+  base::SimpleTestTickClock testing_clock_;
+  scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
+
+  // These run on the sender timeline.
+  test::SkewedTickClock* testing_clock_sender_;
+  scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_sender_;
+
+  // These run on the receiver timeline.
+  test::SkewedTickClock* testing_clock_receiver_;
+  scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_receiver_;
+
+  scoped_refptr<CastEnvironment> cast_environment_sender_;
+  scoped_refptr<CastEnvironment> cast_environment_receiver_;
+
+  LoopBackTransport receiver_to_sender_;
+  LoopBackTransport sender_to_receiver_;
+  CastTransportSenderWrapper transport_sender_;
+  uint64 video_bytes_encoded_;
+  uint64 audio_bytes_encoded_;
+
+  scoped_ptr<CastReceiver> cast_receiver_;
+  scoped_ptr<CastSender> cast_sender_;
+
+  int frames_sent_;
+  double available_bitrate_;
+  std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_;
+  std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_;
+};
+
+enum CacheResult { FOUND_TRUE, FOUND_FALSE, NOT_FOUND };
+
+template <class T>
+class BenchmarkCache {
+ public:
+  CacheResult Lookup(const T& x) {
+    base::AutoLock key(lock_);
+    for (size_t i = 0; i < results_.size(); i++) {
+      if (results_[i].second) {
+        if (x <= results_[i].first) {
+          VLOG(2) << "TRUE because: " << x.AsString()
+                  << " <= " << results_[i].first.AsString();
+          return FOUND_TRUE;
+        }
+      } else {
+        if (x >= results_[i].first) {
+          VLOG(2) << "FALSE because: " << x.AsString()
+                  << " >= " << results_[i].first.AsString();
+          return FOUND_FALSE;
+        }
+      }
+    }
+    return NOT_FOUND;
+  }
+
+  void Add(const T& x, bool result) {
+    base::AutoLock key(lock_);
+    VLOG(2) << "Cache Insert: " << x.AsString() << " = " << result;
+    results_.push_back(std::make_pair(x, result));
+  }
+
+ private:
+  base::Lock lock_;
+  std::vector<std::pair<T, bool> > results_;
+};
+
+struct SearchVariable {
+  SearchVariable() : base(0.0), grade(0.0) {}
+  SearchVariable(double b, double g) : base(b), grade(g) {}
+  SearchVariable blend(const SearchVariable& other, double factor) {
+    CHECK_GE(factor, 0);
+    CHECK_LE(factor, 1.0);
+    return SearchVariable(base * (1 - factor) + other.base * factor,
+                          grade * (1 - factor) + other.grade * factor);
+  }
+  double value(double x) const { return base + grade * x; }
+  double base;
+  double grade;
+};
+
+struct SearchVector {
+  SearchVector blend(const SearchVector& other, double factor) {
+    SearchVector ret;
+    ret.bitrate = bitrate.blend(other.bitrate, factor);
+    ret.latency = latency.blend(other.latency, factor);
+    ret.packet_drop = packet_drop.blend(other.packet_drop, factor);
+    return ret;
+  }
+
+  SearchVector average(const SearchVector& other) {
+    return blend(other, 0.5);
+  }
+
+  MeasuringPoint GetMeasuringPoint(double v) const {
+    return MeasuringPoint(
+        bitrate.value(-v), latency.value(v), packet_drop.value(v));
+  }
+  std::string AsString(double v) { return GetMeasuringPoint(v).AsString(); }
+
+  SearchVariable bitrate;
+  SearchVariable latency;
+  SearchVariable packet_drop;
+};
+
+class CastBenchmark {
+ public:
+  bool RunOnePoint(const SearchVector& v, double multiplier) {
+    MeasuringPoint p = v.GetMeasuringPoint(multiplier);
+    VLOG(1) << "RUN: v = " << multiplier << " p = " << p.AsString();
+    if (p.bitrate <= 0) {
+      return false;
+    }
+    switch (cache_.Lookup(p)) {
+      case FOUND_TRUE:
+        return true;
+      case FOUND_FALSE:
+        return false;
+      case NOT_FOUND:
+        // Keep going
+        break;
+    }
+    bool result = true;
+    for (int tries = 0; tries < 3 && result; tries++) {
+      RunOneBenchmark benchmark;
+      benchmark.Run(p);
+      result &= benchmark.SimpleGood();
+    }
+    cache_.Add(p, result);
+    return result;
+  }
+
+  void BinarySearch(SearchVector v, double accuracy) {
+    double min = 0.0;
+    double max = 1.0;
+    while (RunOnePoint(v, max)) {
+      min = max;
+      max *= 2;
+    }
+
+    while (max - min > accuracy) {
+      double avg = (min + max) / 2;
+      if (RunOnePoint(v, avg)) {
+        min = avg;
+      } else {
+        max = avg;
+      }
+    }
+
+    // Print a data point to stdout.
+    base::AutoLock key(lock_);
+    MeasuringPoint p = v.GetMeasuringPoint(min);
+    fprintf(stdout, "%f %f %f\n", p.bitrate, p.latency, p.percent_packet_drop);
+    fflush(stdout);
+  }
+
+  void SpanningSearch(int max,
+                      int x,
+                      int y,
+                      int skip,
+                      SearchVector a,
+                      SearchVector b,
+                      SearchVector c,
+                      double accuracy,
+                      std::vector<linked_ptr<base::Thread> >* threads) {
+    static int thread_num = 0;
+    if (x > max) return;
+    if (skip > max) {
+      if (y > x) return;
+      SearchVector ab = a.blend(b, static_cast<double>(x) / max);
+      SearchVector ac = a.blend(c, static_cast<double>(x) / max);
+      SearchVector v = ab.blend(ac, x == y ? 1.0 : static_cast<double>(y) / x);
+      thread_num++;
+      (*threads)[thread_num % threads->size()]->message_loop()->PostTask(
+          FROM_HERE,
+          base::Bind(&CastBenchmark::BinarySearch,
+                     base::Unretained(this),
+                     v,
+                     accuracy));
+    } else {
+      skip *= 2;
+      SpanningSearch(max, x, y, skip, a, b, c, accuracy, threads);
+      SpanningSearch(max, x + skip, y + skip, skip, a, b, c, accuracy, threads);
+      SpanningSearch(max, x + skip, y, skip, a, b, c, accuracy, threads);
+      SpanningSearch(max, x, y + skip, skip, a, b, c, accuracy, threads);
+    }
+  }
+
+  void Run() {
+    // Spanning search.
+
+    std::vector<linked_ptr<base::Thread> > threads;
+    for (int i = 0; i < 16; i++) {
+      threads.push_back(make_linked_ptr(new base::Thread(
+          base::StringPrintf("cast_bench_thread_%d", i))));
+      threads[i]->Start();
+    }
+
+    if (CommandLine::ForCurrentProcess()->HasSwitch("single-run")) {
+      SearchVector a;
+      a.bitrate.base = 100.0;
+      a.bitrate.grade = 1.0;
+      a.latency.grade = 1.0;
+      a.packet_drop.grade = 1.0;
+      threads[0]->message_loop()->PostTask(
+          FROM_HERE,
+          base::Bind(base::IgnoreResult(&CastBenchmark::RunOnePoint),
+                     base::Unretained(this),
+                     a,
+                     1.0));
+    } else {
+      SearchVector a, b, c;
+      a.bitrate.base = b.bitrate.base = c.bitrate.base = 100.0;
+      a.bitrate.grade = 1.0;
+      b.latency.grade = 1.0;
+      c.packet_drop.grade = 1.0;
+
+      SpanningSearch(512,
+                     0,
+                     0,
+                     1,
+                     a,
+                     b,
+                     c,
+                     0.01,
+                     &threads);
+    }
+
+    for (size_t i = 0; i < threads.size(); i++) {
+      threads[i]->Stop();
+    }
+  }
+
+ private:
+  BenchmarkCache<MeasuringPoint> cache_;
+  base::Lock lock_;
+};
+
+}  // namespace cast
+}  // namespace media
+
+int main(int argc, char** argv) {
+  base::AtExitManager at_exit;
+  CommandLine::Init(argc, argv);
+  media::cast::CastBenchmark benchmark;
+  if (getenv("PROFILE_FILE")) {
+    std::string profile_file(getenv("PROFILE_FILE"));
+    base::debug::StartProfiling(profile_file);
+    benchmark.Run();
+    base::debug::StopProfiling();
+  } else {
+    benchmark.Run();
+  }
+}