Cast: Update simulator tool with more inputs.

media/cast/test/simulator.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.
 
 // Simulate end to end streaming.
 //
 // Input:
 // --source=
 //   WebM used as the source of video and audio frames.
 // --output=
@@ skipping 28 matching lines @@
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/encoding_event_subscriber.h"
 #include "media/cast/logging/log_serializer.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/logging/proto/raw_events.pb.h"
 #include "media/cast/logging/raw_event_subscriber_bundle.h"
 #include "media/cast/logging/simple_event_subscriber.h"
 #include "media/cast/test/fake_media_source.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/loopback_transport.h"
+#include "media/cast/test/proto/network_simulation_model.pb.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"
 
+using media::cast::proto::IPPModel;
+using media::cast::proto::NetworkSimulationModel;
+using media::cast::proto::NetworkSimulationModelType;
+
 namespace media {
 namespace cast {
 namespace {
-
 const int kTargetDelay = 300;
 const char kSourcePath[] = "source";
+const char kModelPath[] = "model";
 const char kOutputPath[] = "output";
 const char kSimulationId[] = "sim-id";
+const char kLibDir[] = "lib-dir";
 
 void UpdateCastTransportStatus(transport::CastTransportStatus status) {
   LOG(INFO) << "Cast transport status: " << status;
 }
 
 void AudioInitializationStatus(CastInitializationStatus status) {
   LOG(INFO) << "Audio status: " << status;
 }
 
 void VideoInitializationStatus(CastInitializationStatus status) {
@@ skipping 73 matching lines @@
     LOG(ERROR) << "Failed to append to log.";
   }
 }
 
 // Run simulation once.
 //
 // |output_path| is the path to write serialized log.
 // |extra_data| is extra tagging information to write to log.
 void RunSimulation(const base::FilePath& source_path,
                    const base::FilePath& output_path,
-                   const std::string& extra_data) {
+                   const std::string& extra_data,
+                   const NetworkSimulationModel& model) {
   // Fake clock. Make sure start time is non zero.
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromSeconds(1));
 
   // Task runner.
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner =
       new test::FakeSingleThreadTaskRunner(&testing_clock);
   base::ThreadTaskRunnerHandle task_runner_handle(task_runner);
 
   // CastEnvironments.
@@ skipping 64 matching lines @@
           net::IPEndPoint(),
           base::Bind(&UpdateCastTransportStatus),
           base::Bind(&LogTransportEvents, sender_env),
           base::TimeDelta::FromSeconds(1),
           task_runner,
           &sender_to_receiver));
   scoped_ptr<CastSender> cast_sender(
       CastSender::Create(sender_env, transport_sender.get()));
 
   // Build packet pipe.
-  // TODO(hclam): Allow user to input these parameters. Following
-  // parameters are taken from a session from real-world data. It is
-  // chosen here because it gives a difficult environment.
-  std::vector<double> average_rates;
-  average_rates.push_back(0.609);
-  average_rates.push_back(0.495);
-  average_rates.push_back(0.561);
-  average_rates.push_back(0.458);
-  average_rates.push_back(0.538);
-  average_rates.push_back(0.513);
-  average_rates.push_back(0.585);
-  average_rates.push_back(0.592);
-  average_rates.push_back(0.658);
-  average_rates.push_back(0.556);
-  average_rates.push_back(0.371);
-  average_rates.push_back(0.595);
-  average_rates.push_back(0.490);
-  average_rates.push_back(0.980);
-  average_rates.push_back(0.781);
-  average_rates.push_back(0.463);
-  test::InterruptedPoissonProcess ipp(average_rates, 0.3, 4.1, 0);
+  if (model.type() != media::cast::proto::INTERRUPTED_POISSON_PROCESS) {
+    LOG(ERROR) << "Unknown model type " << model.type() << ".";
+    return;
+  }
+
+  const IPPModel& ipp_model = model.ipp();
+
+  std::vector<double> average_rates(ipp_model.average_rate_size());
+  std::copy(ipp_model.average_rate().begin(), ipp_model.average_rate().end(),
+      average_rates.begin());
+  test::InterruptedPoissonProcess ipp(average_rates,
+      ipp_model.coef_burstiness(), ipp_model.coef_variance(), 0);
 
   // Connect sender to receiver. This initializes the pipe.
   receiver_to_sender.Initialize(
       ipp.NewBuffer(128 * 1024), cast_sender->packet_receiver(), task_runner,
       &testing_clock);
   sender_to_receiver.Initialize(
       ipp.NewBuffer(128 * 1024), cast_receiver->packet_receiver(), task_runner,
       &testing_clock);
 
   // Start receiver.
@@ skipping 17 matching lines @@
                                CreateDefaultVideoEncodeMemoryCallback());
 
   // Start sending.
   if (!source_path.empty()) {
     // 0 means using the FPS from the file.
     media_source.SetSourceFile(source_path, 0);
   }
   media_source.Start(cast_sender->audio_frame_input(),
                      cast_sender->video_frame_input());
 
-  // Run for 5 minutes.
+  // Run for 3 minutes.
   base::TimeDelta elapsed_time;
-  while (elapsed_time.InMinutes() < 5) {
+  while (elapsed_time.InMinutes() < 3) {
     // Each step is 100us.
     base::TimeDelta step = base::TimeDelta::FromMicroseconds(100);
     task_runner->Sleep(step);
     elapsed_time += step;
   }
 
   LOG(INFO) << "Audio frame count: " << audio_frame_count;
   LOG(INFO) << "Video frame count: " << video_frame_count;
   LOG(INFO) << "Writing log: " << output_path.value();
 
   // Truncate file and then write serialized log.
   {
     base::ScopedFILE file(base::OpenFile(output_path, "wb"));
     if (!file.get()) {
       LOG(INFO) << "Cannot write to log.";
       return;
     }
   }
   AppendLog(&video_event_subscriber, extra_data, output_path);
   AppendLog(&audio_event_subscriber, extra_data, output_path);
 }
 
+NetworkSimulationModel DefaultModel() {
+  NetworkSimulationModel model;
+  model.set_type(cast::proto::INTERRUPTED_POISSON_PROCESS);
+  IPPModel* ipp = model.mutable_ipp();
+  ipp->set_coef_burstiness(0.609);
+  ipp->set_coef_variance(4.1);
+
+  ipp->add_average_rate(0.609);
+  ipp->add_average_rate(0.495);
+  ipp->add_average_rate(0.561);
+  ipp->add_average_rate(0.458);
+  ipp->add_average_rate(0.538);
+  ipp->add_average_rate(0.513);
+  ipp->add_average_rate(0.585);
+  ipp->add_average_rate(0.592);
+  ipp->add_average_rate(0.658);
+  ipp->add_average_rate(0.556);
+  ipp->add_average_rate(0.371);
+  ipp->add_average_rate(0.595);
+  ipp->add_average_rate(0.490);
+  ipp->add_average_rate(0.980);
+  ipp->add_average_rate(0.781);
+  ipp->add_average_rate(0.463);
+
+  return model;
+}
+
+bool IsModelValid(const NetworkSimulationModel& model) {
+  if (!model.has_type())
+    return false;
+  NetworkSimulationModelType type = model.type();
+  if (type == media::cast::proto::INTERRUPTED_POISSON_PROCESS) {
+    if (!model.has_ipp())
+      return false;
+    const IPPModel& ipp = model.ipp();
+    if (ipp.coef_burstiness() <= 0.0 || ipp.coef_variance() <= 0.0)
+      return false;
+    if (ipp.average_rate_size() == 0)
+      return false;
+    for (int i = 0; i < ipp.average_rate_size(); i++) {
+      if (ipp.average_rate(i) <= 0.0)
+        return false;
+    }
+  }
+
+  return true;
+}
+
+NetworkSimulationModel LoadModel(const base::FilePath& model_path) {
+  if (model_path.empty()) {
+    LOG(ERROR) << "Model path not set.";
+    return DefaultModel();
+  }
+  std::string model_str;
+  if (!base::ReadFileToString(model_path, &model_str)) {
+    LOG(ERROR) << "Failed to read model file.";
+    return DefaultModel();
+  }
+
+  NetworkSimulationModel model;
+  if (!model.ParseFromString(model_str)) {
+    LOG(ERROR) << "Failed to parse model.";
+    return DefaultModel();
+  }
+  if (!IsModelValid(model)) {
+    LOG(ERROR) << "Invalid model.";
+    return DefaultModel();
+  }
+
+  return model;
+}
+
 }  // namespace
 }  // namespace cast
 }  // namespace media
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
   CommandLine::Init(argc, argv);
   InitLogging(logging::LoggingSettings());
 
-  base::FilePath media_path;
-  if (!PathService::Get(base::DIR_MODULE, &media_path)) {
-    LOG(ERROR) << "Failed to load FFmpeg.";
+  const CommandLine* cmd = CommandLine::ForCurrentProcess();
+  base::FilePath media_path = cmd->GetSwitchValuePath(media::cast::kLibDir);
+  if (media_path.empty()) {
+    if (!PathService::Get(base::DIR_MODULE, &media_path)) {
+      LOG(ERROR) << "Failed to load FFmpeg.";
+      return 1;
+    }
+  }
+
+  if (!media::InitializeMediaLibrary(media_path)) {
+    LOG(ERROR) << "Failed to initialize FFmpeg.";
     return 1;
   }
-  media::InitializeMediaLibrary(media_path);
 
-  const CommandLine* cmd = CommandLine::ForCurrentProcess();
   base::FilePath source_path = cmd->GetSwitchValuePath(
       media::cast::kSourcePath);
   base::FilePath output_path = cmd->GetSwitchValuePath(
       media::cast::kOutputPath);
   if (output_path.empty()) {
     base::GetTempDir(&output_path);
     output_path = output_path.AppendASCII("sim-events.gz");
   }
   std::string sim_id = cmd->GetSwitchValueASCII(media::cast::kSimulationId);
 
+  NetworkSimulationModel model = media::cast::LoadModel(
+      cmd->GetSwitchValuePath(media::cast::kModelPath));
+
   base::DictionaryValue values;
   values.SetBoolean("sim", true);
   values.SetString("sim-id", sim_id);
 
   std::string extra_data;
   base::JSONWriter::Write(&values, &extra_data);
 
   // Run.
-  media::cast::RunSimulation(source_path, output_path, extra_data);
+  media::cast::RunSimulation(source_path, output_path, extra_data, model);
   return 0;
 }