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/command_line.h"
 #include "base/file_util.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/threading/thread.h"
 #include "base/time/default_tick_clock.h"
+#include "base/values.h"
 #include "media/base/video_frame.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 "ui/gfx/size.h"
 
 namespace media {
@@ skipping 343 matching lines @@
                      bool compress,
                      base::ScopedFILE log_file) {
   VLOG(0) << "Frame map size: " << frame_events.size();
   VLOG(0) << "Packet map size: " << packet_events.size();
 
   scoped_ptr<char[]> event_log(new char[media::cast::kMaxSerializedLogBytes]);
   int event_log_bytes;
   if (!media::cast::SerializeEvents(log_metadata,
                                     frame_events,
                                     packet_events,
-                                    compress,
+                                    true,
                                     media::cast::kMaxSerializedLogBytes,
                                     event_log.get(),
                                     &event_log_bytes)) {
     VLOG(0) << "Failed to serialize events.";
     return;
   }
 
   VLOG(0) << "Events serialized length: " << event_log_bytes;
 
   int ret = fwrite(event_log.get(), 1, event_log_bytes, log_file.get());
@@ skipping 30 matching lines @@
   audio_event_subscriber->GetEventsAndReset(
       &log_metadata, &frame_events, &packet_events);
 
   DumpLoggingData(log_metadata,
                   frame_events,
                   packet_events,
                   compress,
                   audio_log_file.Pass());
 }
 
+void WriteStats(
+    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());
   base::Thread test_thread("Cast sender test app thread");
   base::Thread audio_thread("Cast audio encoder thread");
   base::Thread video_thread("Cast video encoder thread");
   test_thread.Start();
@@ skipping 66 matching lines @@
       cast_sender->video_frame_input();
   scoped_ptr<media::cast::SendProcess> send_process(
       new media::cast::SendProcess(test_thread.message_loop_proxy(),
                                    cast_environment->Clock(),
                                    video_config,
                                    audio_frame_input,
                                    video_frame_input));
 
   // Set up event subscribers.
   int logging_duration = media::cast::GetLoggingDuration();
+  scoped_ptr<media::cast::ReceiverTimeOffsetEstimatorImpl> offset_estimator(
+      new media::cast::ReceiverTimeOffsetEstimatorImpl);
+  cast_environment->Logging()->AddRawEventSubscriber(offset_estimator.get());
+
   scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber;
   scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber;
+  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());
   if (logging_duration > 0) {
     bool compress = media::cast::CompressLogs();
     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));
@@ skipping 17 matching lines @@
     io_message_loop.message_loop_proxy()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&WriteLogsToFileAndStopSubscribing,
                    cast_environment,
                    base::Passed(&video_event_subscriber),
                    base::Passed(&audio_event_subscriber),
                    base::Passed(&video_log_file),
                    base::Passed(&audio_log_file),
                    compress),
         base::TimeDelta::FromSeconds(logging_duration));
+
+    io_message_loop.message_loop_proxy()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&WriteStats,
+                   cast_environment,
+                   base::Passed(&video_stats_subscriber),
+                   base::Passed(&audio_stats_subscriber),
+                   base::Passed(&offset_estimator)),
+        base::TimeDelta::FromSeconds(logging_duration));
   }
 
   test_thread.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&media::cast::SendProcess::SendFrame,
                  base::Unretained(send_process.get())));
 
   io_message_loop.Run();
 
   return 0;
 }