Cast: Provide more meaningful stats.

media/cast/test/sender.cc

 // Copyright 2013 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.
 
 // Test application that simulates a cast sender - Data can be either generated
 // or read from a file.
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.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/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/time/default_tick_clock.h"
+#include "base/values.h"
 #include "media/base/media.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #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/receiver_time_offset_estimator_impl.h"
+#include "media/cast/logging/stats_event_subscriber.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/input_builder.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "media/cast/transport/cast_transport_sender.h"
 #include "media/cast/transport/transport/udp_transport.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_glue.h"
@@ skipping 424 matching lines @@
     return;
   }
 
   VLOG(0) << "Events serialized length: " << event_log_bytes;
 
   int ret = fwrite(event_log.get(), 1, event_log_bytes, log_file.get());
   if (ret != event_log_bytes)
     VLOG(0) << "Failed to write logs to file.";
 }
 
-void WriteLogsToFileAndStopSubscribing(
+void WriteLogsToFileAndDestroySubscribers(
     const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
     scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber,
     scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber,
     base::ScopedFILE video_log_file,
     base::ScopedFILE audio_log_file) {
   cast_environment->Logging()->RemoveRawEventSubscriber(
       video_event_subscriber.get());
   cast_environment->Logging()->RemoveRawEventSubscriber(
       audio_event_subscriber.get());
 
@@ skipping 12 matching lines @@
   VLOG(0) << "Dumping logging data for audio stream.";
   audio_event_subscriber->GetEventsAndReset(
       &log_metadata, &frame_events, &packet_events);
 
   DumpLoggingData(log_metadata,
                   frame_events,
                   packet_events,
                   audio_log_file.Pass());
 }
 
+void WriteStatsAndDestroySubscribers(
+    const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
+    scoped_ptr<media::cast::StatsEventSubscriber> video_event_subscriber,
+    scoped_ptr<media::cast::StatsEventSubscriber> audio_event_subscriber,
+    scoped_ptr<media::cast::ReceiverTimeOffsetEstimatorImpl> estimator) {
+  cast_environment->Logging()->RemoveRawEventSubscriber(
+      video_event_subscriber.get());
+  cast_environment->Logging()->RemoveRawEventSubscriber(
+      audio_event_subscriber.get());
+  cast_environment->Logging()->RemoveRawEventSubscriber(estimator.get());
+
+  scoped_ptr<base::DictionaryValue> stats = video_event_subscriber->GetStats();
+  std::string json;
+  base::JSONWriter::WriteWithOptions(
+      stats.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+  VLOG(0) << "Video stats: " << json;
+
+  stats = audio_event_subscriber->GetStats();
+  json.clear();
+  base::JSONWriter::WriteWithOptions(
+      stats.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+  VLOG(0) << "Audio stats: " << json;
+}
+
 }  // namespace
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
   CommandLine::Init(argc, argv);
   InitLogging(logging::LoggingSettings());
 
   // Load the media module for FFmpeg decoding.
   base::FilePath path;
   PathService::Get(base::DIR_MODULE, &path);
@@ skipping 85 matching lines @@
                                    audio_frame_input,
                                    video_frame_input));
 
   // Set up event subscribers.
   scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber;
   scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber;
   std::string video_log_file_name("/tmp/video_events.log.gz");
   std::string audio_log_file_name("/tmp/audio_events.log.gz");
   LOG(INFO) << "Logging audio events to: " << audio_log_file_name;
   LOG(INFO) << "Logging video events to: " << video_log_file_name;
+
+  // Subscribers for raw events.
   video_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
       media::cast::VIDEO_EVENT, 10000));
   audio_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
+      media::cast::AUDIO_EVENT, 10000));
+  cast_environment->Logging()->AddRawEventSubscriber(
+      video_event_subscriber.get());
+  cast_environment->Logging()->AddRawEventSubscriber(
+      audio_event_subscriber.get());
+
+  // Subscribers for stats.
+  scoped_ptr<media::cast::ReceiverTimeOffsetEstimatorImpl> offset_estimator(
+      new media::cast::ReceiverTimeOffsetEstimatorImpl);
+  cast_environment->Logging()->AddRawEventSubscriber(offset_estimator.get());
+  scoped_ptr<media::cast::StatsEventSubscriber> video_stats_subscriber(
+      new media::cast::StatsEventSubscriber(media::cast::VIDEO_EVENT,
+                                            cast_environment->Clock(),
+                                            offset_estimator.get()));
+  scoped_ptr<media::cast::StatsEventSubscriber> audio_stats_subscriber(
+      new media::cast::StatsEventSubscriber(media::cast::AUDIO_EVENT,
+                                            cast_environment->Clock(),
+                                            offset_estimator.get()));
+  cast_environment->Logging()->AddRawEventSubscriber(
+      video_stats_subscriber.get());
+  cast_environment->Logging()->AddRawEventSubscriber(
+      audio_stats_subscriber.get());
+
+  std::string video_log_file_name(
+      media::cast::GetVideoLogFileDestination(compress));
+  std::string audio_log_file_name(
+      media::cast::GetAudioLogFileDestination(compress));
+  video_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
+      media::cast::VIDEO_EVENT, 10000));
+  audio_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
       media::cast::AUDIO_EVENT, 10000));
   cast_environment->Logging()->AddRawEventSubscriber(
       video_event_subscriber.get());
   cast_environment->Logging()->AddRawEventSubscriber(
       audio_event_subscriber.get());
 
   base::ScopedFILE video_log_file(fopen(video_log_file_name.c_str(), "w"));
   if (!video_log_file) {
     VLOG(1) << "Failed to open video log file for writing.";
     exit(-1);
   }
 
-  base::ScopedFILE audio_log_file(fopen(audio_log_file_name.c_str(), "w"));
-  if (!audio_log_file) {
-    VLOG(1) << "Failed to open audio log file for writing.";
+  base::ScopedFILE video_log_file(fopen(video_log_file_name.c_str(), "w"));
+  if (!video_log_file) {
+    VLOG(1) << "Failed to open video log file for writing.";
     exit(-1);
   }
 
   const int logging_duration_seconds = 300;
   io_message_loop.message_loop_proxy()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&WriteLogsToFileAndStopSubscribing,
+      base::Bind(&WriteLogsToFileAndDestroySubscribers,
                  cast_environment,
                  base::Passed(&video_event_subscriber),
                  base::Passed(&audio_event_subscriber),
                  base::Passed(&video_log_file),
                  base::Passed(&audio_log_file)),
       base::TimeDelta::FromSeconds(logging_duration_seconds));
 
+  io_message_loop.message_loop_proxy()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&WriteStatsAndDestroySubscribers,
+                 cast_environment,
+                 base::Passed(&video_stats_subscriber),
+                 base::Passed(&audio_stats_subscriber),
+                 base::Passed(&offset_estimator)),
+      base::TimeDelta::FromSeconds(logging_duration_seconds));
+  }
+
   test_thread.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&media::cast::SendProcess::SendNextFrame,
                  base::Unretained(send_process.get())));
 
   io_message_loop.Run();
 
   return 0;
 }