[Cast] Add target playout delay CL arg for cast_simulator.

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=
 //   File path to writing out the raw event log of the simulation session.
 // --sim-id=
 //   Unique simulation ID.
+// --target-delay-ms=
+//   Target playout delay to configure (integer number of milliseconds).
+//   Optional; default is 400.
 //
 // Output:
 // - Raw event log of the simulation session tagged with the unique test ID,
 //   written out to the specified file path.
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/path_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/tick_clock.h"
 #include "base/values.h"
 #include "media/base/audio_bus.h"
 #include "media/base/media.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"
@@ skipping 19 matching lines @@
 #include "media/cast/test/utility/udp_proxy.h"
 #include "media/cast/test/utility/video_utility.h"
 
 using media::cast::proto::IPPModel;
 using media::cast::proto::NetworkSimulationModel;
 using media::cast::proto::NetworkSimulationModelType;
 
 namespace media {
 namespace cast {
 namespace {
-const int kTargetDelay = 400;
 const char kSourcePath[] = "source";
 const char kModelPath[] = "model";
 const char kOutputPath[] = "output";
 const char kSimulationId[] = "sim-id";
 const char kLibDir[] = "lib-dir";
+const char kTargetDelay[] = "target-delay-ms";
+
+base::TimeDelta GetTargetPlayoutDelay() {
+  const std::string delay_str =
+      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(kTargetDelay);
+  if (delay_str.empty())
+    return base::TimeDelta::FromMilliseconds(400);
+  int delay_ms;
+  CHECK(base::StringToInt(delay_str, &delay_ms));
+  CHECK_GT(delay_ms, 0);
+  return base::TimeDelta::FromMilliseconds(delay_ms);
+}
 
 void UpdateCastTransportStatus(CastTransportStatus status) {
   LOG(INFO) << "Cast transport status: " << status;
 }
 
 void AudioInitializationStatus(CastInitializationStatus status) {
   LOG(INFO) << "Audio status: " << status;
 }
 
 void VideoInitializationStatus(CastInitializationStatus status) {
@@ skipping 128 matching lines @@
   // Event subscriber. Store at most 1 hour of events.
   EncodingEventSubscriber audio_event_subscriber(AUDIO_EVENT,
                                                  100 * 60 * 60);
   EncodingEventSubscriber video_event_subscriber(VIDEO_EVENT,
                                                  30 * 60 * 60);
   sender_env->Logging()->AddRawEventSubscriber(&audio_event_subscriber);
   sender_env->Logging()->AddRawEventSubscriber(&video_event_subscriber);
 
   // Audio sender config.
   AudioSenderConfig audio_sender_config = GetDefaultAudioSenderConfig();
-  audio_sender_config.max_playout_delay =
-      base::TimeDelta::FromMilliseconds(kTargetDelay);
+  audio_sender_config.max_playout_delay = GetTargetPlayoutDelay();
 
   // Audio receiver config.
   FrameReceiverConfig audio_receiver_config =
       GetDefaultAudioReceiverConfig();
   audio_receiver_config.rtp_max_delay_ms =
       audio_sender_config.max_playout_delay.InMilliseconds();
 
   // Video sender config.
   VideoSenderConfig video_sender_config = GetDefaultVideoSenderConfig();
   video_sender_config.max_bitrate = 2500000;
   video_sender_config.min_bitrate = 2000000;
   video_sender_config.start_bitrate = 2000000;
-  video_sender_config.max_playout_delay =
-      base::TimeDelta::FromMilliseconds(kTargetDelay);
+  video_sender_config.max_playout_delay = GetTargetPlayoutDelay();
 
   // Video receiver config.
   FrameReceiverConfig video_receiver_config =
       GetDefaultVideoReceiverConfig();
   video_receiver_config.rtp_max_delay_ms =
       video_sender_config.max_playout_delay.InMilliseconds();
 
   // Loopback transport.
   LoopBackTransport receiver_to_sender(receiver_env);
   LoopBackTransport sender_to_receiver(sender_env);
@@ skipping 100 matching lines @@
   // * Total video frames captured.
   // * Total video frames encoded.
   // * Total video frames dropped.
   // * Total video frames received late.
   // * Average target bitrate.
   // * Average encoded bitrate.
   int total_video_frames = 0;
   int encoded_video_frames = 0;
   int dropped_video_frames = 0;
   int late_video_frames = 0;
+  int64 total_delay_of_late_frames_ms = 0;
   int64 encoded_size = 0;
   int64 target_bitrate = 0;
   for (size_t i = 0; i < video_frame_events.size(); ++i) {
     const media::cast::proto::AggregatedFrameEvent& event =
         *video_frame_events[i];
     ++total_video_frames;
     if (event.has_encoded_frame_size()) {
       ++encoded_video_frames;
       encoded_size += event.encoded_frame_size();
       target_bitrate += event.target_bitrate();
     } else {
       ++dropped_video_frames;
     }
-    if (event.has_delay_millis() && event.delay_millis() < 0)
+    if (event.has_delay_millis() && event.delay_millis() < 0) {
       ++late_video_frames;
+      total_delay_of_late_frames_ms += -event.delay_millis();
+    }
   }
 
   double avg_encoded_bitrate =
       !encoded_video_frames ? 0 :
       8.0 * encoded_size * video_sender_config.max_frame_rate /
       encoded_video_frames / 1000;
   double avg_target_bitrate =
       !encoded_video_frames ? 0 : target_bitrate / encoded_video_frames / 1000;
 
+  LOG(INFO) << "Configured target playout delay (ms): "
+            << video_receiver_config.rtp_max_delay_ms;
   LOG(INFO) << "Audio frame count: " << audio_frame_count;
   LOG(INFO) << "Total video frames: " << total_video_frames;
   LOG(INFO) << "Dropped video frames " << dropped_video_frames;
-  LOG(INFO) << "Late video frames: " << late_video_frames;
+  LOG(INFO) << "Late video frames: " << late_video_frames
+            << " (average lateness: "
+            << (late_video_frames > 0 ?
+                    static_cast<double>(total_delay_of_late_frames_ms) /
+                        late_video_frames :
+                    0)
+            << " ms)";
   LOG(INFO) << "Average encoded bitrate (kbps): " << avg_encoded_bitrate;
   LOG(INFO) << "Average target bitrate (kbps): " << avg_target_bitrate;
   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;
@@ skipping 117 matching lines @@
   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, model);
   return 0;
 }