src/media/cast/logging/logging_stats.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/linked_ptr.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "media/cast/logging/logging_stats.h"
   8
   9 namespace media {
  10 namespace cast {
  11
  12 LoggingStats::LoggingStats(base::TickClock* clock)
  13     : frame_stats_(),
  14       packet_stats_(),
  15       generic_stats_(),
  16       start_time_(),
  17       clock_(clock) {
  18   memset(counts_, 0, sizeof(counts_));
  19 }
  20
  21 LoggingStats::~LoggingStats() {}
  22
  23 void LoggingStats::Reset() {
  24   frame_stats_.clear();
  25   packet_stats_.clear();
  26   generic_stats_.clear();
  27   memset(counts_, 0, sizeof(counts_));
  28 }
  29
  30 void LoggingStats::InsertFrameEvent(CastLoggingEvent event,
  31                                     uint32 rtp_timestamp,
  32                                     uint8 frame_id) {
  33   InsertBaseFrameEvent(event, frame_id, rtp_timestamp);
  34 }
  35
  36 void LoggingStats::InsertFrameEventWithSize(CastLoggingEvent event,
  37                                             uint32 rtp_timestamp,
  38                                             uint8 frame_id,
  39                                             int frame_size) {
  40   InsertBaseFrameEvent(event, frame_id, rtp_timestamp);
  41   // Update size.
  42   FrameStatsMap::iterator it = frame_stats_.find(event);
  43   DCHECK(it != frame_stats_.end());
  44   it->second->bitrate_kbps += frame_size;
  45 }
  46
  47 void LoggingStats::InsertFrameEventWithDelay(CastLoggingEvent event,
  48                                              uint32 rtp_timestamp,
  49                                              uint8 frame_id,
  50                                              base::TimeDelta delay) {
  51   InsertBaseFrameEvent(event, frame_id, rtp_timestamp);
  52   // Update size.
  53   FrameStatsMap::iterator it = frame_stats_.find(event);
  54   DCHECK(it != frame_stats_.end());
  55   // Using the average delay as a counter, will divide by the counter when
  56   // triggered.
  57   it->second->avg_delay_ms += delay.InMilliseconds();
  58   if (delay.InMilliseconds() > it->second->max_delay_ms)
  59     it->second->max_delay_ms = delay.InMilliseconds();
  60   if ((delay.InMilliseconds() < it->second->min_delay_ms) ||
  61       (counts_[event] == 1) )
  62     it->second->min_delay_ms = delay.InMilliseconds();
  63 }
  64
  65 void LoggingStats::InsertBaseFrameEvent(CastLoggingEvent event,
  66                                         uint8 frame_id,
  67                                         uint32 rtp_timestamp) {
  68   // Does this belong to an existing event?
  69   FrameStatsMap::iterator it = frame_stats_.find(event);
  70   if (it == frame_stats_.end()) {
  71     // New event.
  72     start_time_[event] = clock_->NowTicks();
  73     linked_ptr<FrameLogStats> stats(new FrameLogStats());
  74     frame_stats_.insert(std::make_pair(event, stats));
  75   }
  76
  77   ++counts_[event];
  78 }
  79
  80 void LoggingStats::InsertPacketEvent(CastLoggingEvent event,
  81                                      uint32 rtp_timestamp,
  82                                      uint8 frame_id,
  83                                      uint16 packet_id,
  84                                      uint16 max_packet_id,
  85                                      int size) {
  86   // Does this packet belong to an existing event?
  87   PacketStatsMap::iterator it = packet_stats_.find(event);
  88   if (it == packet_stats_.end()) {
  89     // New event.
  90     start_time_[event] = clock_->NowTicks();
  91     packet_stats_.insert(std::make_pair(event, size));
  92   } else {
  93     // Add to existing.
  94     it->second += size;
  95   }
  96   ++counts_[event];
  97 }
  98
  99 void LoggingStats::InsertGenericEvent(CastLoggingEvent event, int value) {
 100   // Does this event belong to an existing event?
 101   GenericStatsMap::iterator it = generic_stats_.find(event);
 102   if (it == generic_stats_.end()) {
 103     // New event.
 104     start_time_[event] = clock_->NowTicks();
 105     generic_stats_.insert(std::make_pair(event, value));
 106   } else {
 107     // Add to existing (will be used to compute average).
 108     it->second += value;
 109   }
 110    ++counts_[event];
 111 }
 112
 113 const FrameStatsMap* LoggingStats::GetFrameStatsData() {
 114   // Compute framerate and bitrate (when available).
 115   FrameStatsMap::iterator it;
 116   for (it = frame_stats_.begin(); it != frame_stats_.end(); ++it) {
 117     base::TimeDelta time_diff = clock_->NowTicks() - start_time_[it->first];
 118     it->second->framerate_fps = counts_[it->first] / time_diff.InSecondsF();
 119     if (it->second->bitrate_kbps > 0) {
 120       it->second->bitrate_kbps = (8 / 1000) *
 121           it->second->bitrate_kbps / time_diff.InSecondsF();
 122     }
 123     if (it->second->avg_delay_ms > 0)
 124       it->second->avg_delay_ms /= counts_[it->first];
 125   }
 126   return &frame_stats_;
 127 }
 128
 129 const PacketStatsMap* LoggingStats::GetPacketStatsData() {
 130   PacketStatsMap::iterator it;
 131   for (it = packet_stats_.begin(); it != packet_stats_.end(); ++it) {
 132     if (counts_[it->first] == 0) continue;
 133     base::TimeDelta time_diff = clock_->NowTicks() - start_time_[it->first];
 134     it->second = (8 / 1000) * it->second / time_diff.InSecondsF();
 135   }
 136   return &packet_stats_;
 137 }
 138
 139 const GenericStatsMap* LoggingStats::GetGenericStatsData() {
 140   // Compute averages.
 141   GenericStatsMap::iterator it;
 142   for (it = generic_stats_.begin(); it != generic_stats_.end(); ++it) {
 143     it->second /= counts_[ it->first];
 144   }
 145   return &generic_stats_;
 146 }
 147
 148 }  // namespace cast
 149 }  // namespace media