Cast: cast_simulator to print more info

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 127 matching lines @@
     int* counter,
     CastReceiver* cast_receiver,
     scoped_ptr<AudioBus> audio_bus,
     const base::TimeTicks& playout_time,
     bool is_continuous) {
   ++*counter;
   cast_receiver->RequestDecodedAudioFrame(
       base::Bind(&GotAudioFrame, counter, cast_receiver));
 }
 
-void AppendLog(EncodingEventSubscriber* subscriber,
-               const std::string& extra_data,
-               const base::FilePath& output_path) {
-  media::cast::proto::LogMetadata metadata;
-  metadata.set_extra_data(extra_data);
-
-  media::cast::FrameEventList frame_events;
-  media::cast::PacketEventList packet_events;
-  subscriber->GetEventsAndReset(
-      &metadata, &frame_events, &packet_events);
+// Serialize |frame_events| and |packet_events| and append to the file
+// located at |output_path|.
+void AppendLogToFile(media::cast::proto::LogMetadata* metadata,
+                     const media::cast::FrameEventList& frame_events,
+                     const media::cast::PacketEventList& packet_events,
+                     const base::FilePath& output_path) {
   media::cast::proto::GeneralDescription* gen_desc =
-      metadata.mutable_general_description();
+      metadata->mutable_general_description();
   gen_desc->set_product("Cast Simulator");
   gen_desc->set_product_version("0.1");
 
   scoped_ptr<char[]> serialized_log(new char[media::cast::kMaxSerializedBytes]);
   int output_bytes;
-  bool success = media::cast::SerializeEvents(metadata,
+  bool success = media::cast::SerializeEvents(*metadata,
                                               frame_events,
                                               packet_events,
                                               true,
                                               media::cast::kMaxSerializedBytes,
                                               serialized_log.get(),
                                               &output_bytes);
 
   if (!success) {
     LOG(ERROR) << "Failed to serialize log.";
     return;
@@ skipping 147 matching lines @@
 
   // Run for 3 minutes.
   base::TimeDelta elapsed_time;
   while (elapsed_time.InMinutes() < 3) {
     // Each step is 100us.
     base::TimeDelta step = base::TimeDelta::FromMicroseconds(100);
     task_runner->Sleep(step);
     elapsed_time += step;
   }
 
+  // Get event logs for audio and video.
+  media::cast::proto::LogMetadata audio_metadata, video_metadata;
+  media::cast::FrameEventList audio_frame_events, video_frame_events;
+  media::cast::PacketEventList audio_packet_events, video_packet_events;
+  audio_metadata.set_extra_data(extra_data);
+  video_metadata.set_extra_data(extra_data);
+  audio_event_subscriber.GetEventsAndReset(
+      &audio_metadata, &audio_frame_events, &audio_packet_events);
+  video_event_subscriber.GetEventsAndReset(
+      &video_metadata, &video_frame_events, &video_packet_events);
+
+  // Print simulation results.
+
+  // Compute and print statistics for video:
+  //
+  // * 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 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)
+      ++late_video_frames;
+  }
+
+  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) << "Audio frame count: " << audio_frame_count;
-  LOG(INFO) << "Video frame count: " << video_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) << "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;
     }
   }
-  AppendLog(&video_event_subscriber, extra_data, output_path);
-  AppendLog(&audio_event_subscriber, extra_data, output_path);
+  AppendLogToFile(&video_metadata, video_frame_events, video_packet_events,
+                  output_path);
+  AppendLogToFile(&audio_metadata, audio_frame_events, audio_packet_events,
+                  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);
@@ skipping 101 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;
 }