src/media/cast/logging/logging_impl.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/debug/trace_event.h"
   6 #include "base/metrics/histogram.h"
   7 #include "media/cast/logging/logging_impl.h"
   8
   9 namespace media {
  10 namespace cast {
  11
  12 LoggingImpl::LoggingImpl(base::TickClock* clock,
  13                          bool enable_data_collection,
  14                          bool enable_uma_stats,
  15                          bool enable_tracing)
  16     : enable_data_collection_(enable_data_collection),
  17       enable_uma_stats_(enable_uma_stats),
  18       enable_tracing_(enable_tracing),
  19       raw_(clock),
  20       stats_(clock) {}
  21
  22 LoggingImpl::~LoggingImpl() {}
  23
  24 void LoggingImpl::InsertFrameEvent(CastLoggingEvent event,
  25                                    uint32 rtp_timestamp,
  26                                    uint8 frame_id) {
  27   if (enable_data_collection_) {
  28     raw_.InsertFrameEvent(event, rtp_timestamp, frame_id);
  29     stats_.InsertFrameEvent(event, rtp_timestamp, frame_id);
  30   }
  31   if (enable_tracing_) {
  32     std::string event_string = CastLoggingToString(event);
  33     TRACE_EVENT_INSTANT2(event_string.c_str(), "FE",
  34         TRACE_EVENT_SCOPE_THREAD, "rtp_timestamp", rtp_timestamp, "frame_id",
  35         frame_id);
  36   }
  37 }
  38
  39 void LoggingImpl::InsertFrameEventWithSize(CastLoggingEvent event,
  40                                            uint32 rtp_timestamp,
  41                                            uint8 frame_id,
  42                                            int frame_size) {
  43   if (enable_data_collection_) {
  44     raw_.InsertFrameEventWithSize(event, rtp_timestamp, frame_id, frame_size);
  45     stats_.InsertFrameEventWithSize(event, rtp_timestamp, frame_id, frame_size);
  46   }
  47   if (enable_uma_stats_) {
  48     UMA_HISTOGRAM_COUNTS(CastLoggingToString(event), frame_size);
  49   }
  50   if (enable_tracing_) {
  51     std::string event_string = CastLoggingToString(event);
  52     TRACE_EVENT_INSTANT2(event_string.c_str(), "FES",
  53         TRACE_EVENT_SCOPE_THREAD, "rtp_timestamp", rtp_timestamp, "frame_size",
  54         frame_size);
  55   }
  56
  57 }
  58
  59 void LoggingImpl::InsertFrameEventWithDelay(CastLoggingEvent event,
  60                                             uint32 rtp_timestamp,
  61                                             uint8 frame_id,
  62                                             base::TimeDelta delay) {
  63   if (enable_data_collection_) {
  64     raw_.InsertFrameEventWithDelay(event, rtp_timestamp, frame_id, delay);
  65     stats_.InsertFrameEventWithDelay(event, rtp_timestamp, frame_id, delay);
  66   }
  67   if (enable_uma_stats_) {
  68     UMA_HISTOGRAM_TIMES(CastLoggingToString(event), delay);
  69   }
  70    if (enable_tracing_) {
  71       std::string event_string = CastLoggingToString(event);
  72       TRACE_EVENT_INSTANT2(event_string.c_str(), "FED",
  73           TRACE_EVENT_SCOPE_THREAD, "rtp_timestamp", rtp_timestamp, "delay",
  74           delay.InMilliseconds());
  75   }
  76 }
  77
  78 void LoggingImpl::InsertPacketEvent(CastLoggingEvent event,
  79                                     uint32 rtp_timestamp,
  80                                     uint8 frame_id,
  81                                     uint16 packet_id,
  82                                     uint16 max_packet_id,
  83                                     int size) {
  84   if (enable_data_collection_) {
  85     raw_.InsertPacketEvent(event, rtp_timestamp, frame_id, packet_id,
  86                            max_packet_id, size);
  87     stats_.InsertPacketEvent(event, rtp_timestamp, frame_id, packet_id,
  88                              max_packet_id, size);
  89   }
  90     if (enable_tracing_) {
  91       std::string event_string = CastLoggingToString(event);
  92       TRACE_EVENT_INSTANT2(event_string.c_str(), "PE",
  93           TRACE_EVENT_SCOPE_THREAD, "rtp_timestamp", rtp_timestamp,
  94           "packet_id", packet_id);
  95     }
  96 }
  97
  98 void LoggingImpl::InsertGenericEvent(CastLoggingEvent event, int value) {
  99   if (enable_data_collection_) {
 100     raw_.InsertGenericEvent(event, value);
 101     stats_.InsertGenericEvent(event, value);
 102   }
 103   if (enable_uma_stats_) {
 104     UMA_HISTOGRAM_COUNTS(CastLoggingToString(event), value);
 105   }
 106   if (enable_tracing_) {
 107     std::string event_string = CastLoggingToString(event);
 108     TRACE_EVENT_INSTANT1(event_string.c_str(), "GE",
 109         TRACE_EVENT_SCOPE_THREAD, "value", value);
 110   }
 111 }
 112
 113
 114 // should just get the entire class, would be much easier.
 115 FrameRawMap LoggingImpl::GetFrameRawData() {
 116   return raw_.GetFrameData();
 117 }
 118
 119 PacketRawMap LoggingImpl::GetPacketRawData() {
 120  return raw_.GetPacketData();
 121 }
 122
 123 GenericRawMap LoggingImpl::GetGenericRawData() {
 124  return raw_.GetGenericData();
 125 }
 126
 127 const FrameStatsMap* LoggingImpl::GetFrameStatsData() {
 128   // Get stats data.
 129   const FrameStatsMap* stats = stats_.GetFrameStatsData();
 130   if (enable_uma_stats_) {
 131     FrameStatsMap::const_iterator it;
 132     for (it = stats->begin(); it != stats->end(); ++it) {
 133       // Check for an active event.
 134       if (it->second->framerate_fps > 0) {
 135         std::string event_string = CastLoggingToString(it->first);
 136         UMA_HISTOGRAM_COUNTS(event_string.append("_framerate_fps"),
 137                              it->second->framerate_fps);
 138       } else {
 139         // All active frame events trigger framerate computation.
 140         continue;
 141       }
 142       if (it->second->bitrate_kbps > 0) {
 143         std::string evnt_string = CastLoggingToString(it->first);
 144         UMA_HISTOGRAM_COUNTS(evnt_string.append("_bitrate_kbps"),
 145                              it->second->framerate_fps);
 146       }
 147       if (it->second->avg_delay_ms > 0) {
 148         std::string event_string = CastLoggingToString(it->first);
 149         UMA_HISTOGRAM_COUNTS(event_string.append("_avg_delay_ms"),
 150                              it->second->avg_delay_ms);
 151         UMA_HISTOGRAM_COUNTS(event_string.append("_min_delay_ms"),
 152                              it->second->min_delay_ms);
 153         UMA_HISTOGRAM_COUNTS(event_string.append("_max_delay_ms"),
 154                              it->second->max_delay_ms);
 155       }
 156     }
 157   }
 158   return stats;
 159 }
 160
 161 const PacketStatsMap* LoggingImpl::GetPacketStatsData() {
 162   // Get stats data.
 163   const PacketStatsMap* stats = stats_.GetPacketStatsData();
 164   if (enable_uma_stats_) {
 165     PacketStatsMap::const_iterator it;
 166     for (it = stats->begin(); it != stats->end(); ++it) {
 167       if (it->second > 0) {
 168         std::string event_string = CastLoggingToString(it->first);
 169         UMA_HISTOGRAM_COUNTS(event_string.append("_bitrate_kbps"), it->second);
 170       }
 171     }
 172   }
 173   return stats;
 174 }
 175
 176 const GenericStatsMap* LoggingImpl::GetGenericStatsData() {
 177   // Get stats data.
 178   const GenericStatsMap* stats = stats_.GetGenericStatsData();
 179    if (enable_uma_stats_) {
 180     GenericStatsMap::const_iterator it;
 181     for (it = stats->begin(); it != stats->end(); ++it) {
 182       if (it->second > 0) {
 183         UMA_HISTOGRAM_COUNTS(CastLoggingToString(it->first), it->second);
 184       }
 185     }
 186   }
 187   return stats;
 188 }
 189
 190 void LoggingImpl::Reset() {
 191   raw_.Reset();
 192   stats_.Reset();
 193 }
 194
 195 }  // namespace cast
 196 }  // namespace media