Cast logging: Additional stats for getStats() API.

media/cast/logging/stats_event_subscriber.h

 // 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.
 
 #ifndef MEDIA_CAST_LOGGING_STATS_EVENT_SUBSCRIBER_H_
 #define MEDIA_CAST_LOGGING_STATS_EVENT_SUBSCRIBER_H_
 
 #include "base/gtest_prod_util.h"
+#include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/tick_clock.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/logging/raw_event_subscriber.h"
 #include "media/cast/logging/receiver_time_offset_estimator.h"
 
 namespace base {
 class DictionaryValue;
+class ListValue;
 }
 
 namespace media {
 namespace cast {
 
 class StatsEventSubscriberTest;
 
 // A RawEventSubscriber implementation that subscribes to events,
 // and aggregates them into stats.
 class StatsEventSubscriber : public RawEventSubscriber {
@@ skipping 41 matching lines @@
     base::TimeDelta sum_delay;
   };
 
   struct PacketLogStats {
     PacketLogStats();
     ~PacketLogStats();
     int event_counter;
     size_t sum_size;
   };
 
+  class SimpleHistogram {
+   public:
+    // This will create N+2 buckets where N = (max - min) / width:
+    // Underflow bucket: < min
+    // Bucket 0: [min, min + width - 1]
+    // Bucket 1: [min + width, min + 2 * width - 1]
+    // ...
+    // Bucket N-1: [max - width, max - 1]
+    // Overflow bucket: >= max
+    // |min| must be less than |max|.
+    // |width| must divide |max - min| evenly.
+    SimpleHistogram(int64 min, int64 max, int64 width);
+
+    ~SimpleHistogram();
+
+    void Add(int64 sample);
+
+    void Reset();
+
+    scoped_ptr<base::ListValue> GetHistogram() const;
+
+   private:
+    int64 min_;
+    int64 max_;
+    int64 width_;
+    std::vector<int> buckets_;
+  };
+
   enum CastStat {
     // Capture frame rate.
     CAPTURE_FPS,
     // Encode frame rate.
     ENCODE_FPS,
     // Decode frame rate.
     DECODE_FPS,
     // Average encode duration in milliseconds.
     // TODO(imcheng): This stat is not populated yet because we do not have
     // the time when encode started. Record it in FRAME_ENCODED event.
@@ skipping 20 matching lines @@
     // Number of frames dropped by encoder.
     NUM_FRAMES_DROPPED_BY_ENCODER,
     // Number of late frames.
     NUM_FRAMES_LATE,
     // Number of packets that were sent (not retransmitted).
     NUM_PACKETS_SENT,
     // Number of packets that were retransmitted.
     NUM_PACKETS_RETRANSMITTED,
     // Number of packets that had their retransmission cancelled.
     NUM_PACKETS_RTX_REJECTED,
+    // Unix time in milliseconds of first event since reset.
+    FIRST_EVENT_TIME_MS,
+    // Unix time in milliseconds of last event since reset.
+    LAST_EVENT_TIME_MS,
+
+    // Histograms
+    CAPTURE_LATENCY_MS_HISTO,
+    ENCODE_LATENCY_MS_HISTO,
+    PACKET_LATENCY_MS_HISTO,
+    FRAME_LATENCY_MS_HISTO,
+    PLAYOUT_DELAY_MS_HISTO
   };
 
   struct FrameInfo {
-    explicit FrameInfo(base::TimeTicks capture_time);
+    FrameInfo();
     ~FrameInfo();
 
     base::TimeTicks capture_time;
+    base::TimeTicks capture_end_time;
+    base::TimeTicks encode_time;
     bool encoded;
   };
 
   typedef std::map<CastStat, double> StatsMap;
+  typedef std::map<CastStat, linked_ptr<SimpleHistogram> > HistogramMap;
   typedef std::map<RtpTimestamp, FrameInfo> FrameInfoMap;
   typedef std::map<
       std::pair<RtpTimestamp, uint16>,
       std::pair<base::TimeTicks, CastLoggingEvent> >
       PacketEventTimeMap;
   typedef std::map<CastLoggingEvent, FrameLogStats> FrameStatsMap;
   typedef std::map<CastLoggingEvent, PacketLogStats> PacketStatsMap;
 
   static const char* CastStatToString(CastStat stat);
 
+  void InitHistograms();
+
   // Assigns |stats_map| with stats data. Used for testing.
   void GetStatsInternal(StatsMap* stats_map) const;
 
+  void UpdateFirstLastEventTime(base::TimeTicks timestamp,
+                                bool is_receiver_event);
   bool GetReceiverOffset(base::TimeDelta* offset);
+  void MaybeInsertFrameInfo(RtpTimestamp rtp_timestamp,
+                            const FrameInfo& frame_info);
   void RecordFrameCaptureTime(const FrameEvent& frame_event);
-  void MarkAsEncoded(RtpTimestamp rtp_timestamp);
+  void RecordCaptureLatency(const FrameEvent& frame_event);
+  void RecordEncodeLatency(const FrameEvent& frame_event);
+  void RecordFrameTxLatency(const FrameEvent& frame_event);
   void RecordE2ELatency(const FrameEvent& frame_event);
   void RecordPacketSentTime(const PacketEvent& packet_event);
   void ErasePacketSentTime(const PacketEvent& packet_event);
   void RecordNetworkLatency(const PacketEvent& packet_event);
   void UpdateLastResponseTime(base::TimeTicks receiver_time);
 
   void PopulateFpsStat(base::TimeTicks now,
                        CastLoggingEvent event,
                        CastStat stat,
                        StatsMap* stats_map) const;
@@ skipping 26 matching lines @@
   int network_latency_datapoints_;
   base::TimeDelta total_e2e_latency_;
   int e2e_latency_datapoints_;
 
   base::TimeTicks last_response_received_time_;
 
   int num_frames_dropped_by_encoder_;
   int num_frames_late_;
 
   // Fixed size map to record when recent frames were captured and other info.
-  FrameInfoMap recent_captured_frames_;
+  FrameInfoMap recent_frame_infos_;
 
   // Fixed size map to record when recent packets were sent.
   PacketEventTimeMap packet_sent_times_;
 
   // Sender time assigned on creation and |Reset()|.
   base::TimeTicks start_time_;
+  base::TimeTicks first_event_time_;
+  base::TimeTicks last_event_time_;
+
+  HistogramMap histograms_;
 
   base::ThreadChecker thread_checker_;
   DISALLOW_COPY_AND_ASSIGN(StatsEventSubscriber);
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_LOGGING_STATS_EVENT_SUBSCRIBER_H_